diff --git a/cmd/gotelemetry/internal/csv/csv.go b/cmd/gotelemetry/internal/csv/csv.go
index b20357c..bba140b 100644
--- a/cmd/gotelemetry/internal/csv/csv.go
+++ b/cmd/gotelemetry/internal/csv/csv.go
@@ -32,7 +32,7 @@
 }
 
 func Csv() {
-	files, err := readdir(telemetry.LocalDir, nil)
+	files, err := readdir(telemetry.Default.LocalDir(), nil)
 	if err != nil {
 		log.Fatal(err)
 	}
diff --git a/cmd/gotelemetry/internal/view/view.go b/cmd/gotelemetry/internal/view/view.go
index 25232d7..b781b3e 100644
--- a/cmd/gotelemetry/internal/view/view.go
+++ b/cmd/gotelemetry/internal/view/view.go
@@ -114,16 +114,17 @@
 		if err != nil {
 			return err
 		}
-		if _, err := os.Stat(telemetry.LocalDir); err != nil {
+		localDir := telemetry.Default.LocalDir()
+		if _, err := os.Stat(localDir); err != nil {
 			return fmt.Errorf(
 				`The telemetry dir %s does not exist.
-There is nothing to report.`, telemetry.LocalDir)
+There is nothing to report.`, telemetry.Default.LocalDir())
 		}
-		reports, err := reports(telemetry.LocalDir, cfg)
+		reports, err := reports(localDir, cfg)
 		if err != nil {
 			return err
 		}
-		files, err := files(telemetry.LocalDir, cfg)
+		files, err := files(localDir, cfg)
 		if err != nil {
 			return err
 		}
diff --git a/cmd/gotelemetry/main.go b/cmd/gotelemetry/main.go
index 6538d97..c86213f 100644
--- a/cmd/gotelemetry/main.go
+++ b/cmd/gotelemetry/main.go
@@ -213,10 +213,10 @@
 }
 
 func runOn(_ []string) {
-	if old, _ := telemetry.Mode(); old == "on" {
+	if old, _ := telemetry.Default.Mode(); old == "on" {
 		return
 	}
-	if err := telemetry.SetMode("on"); err != nil {
+	if err := telemetry.Default.SetMode("on"); err != nil {
 		failf("Failed to enable telemetry: %v", err)
 	}
 	// We could perhaps only show the telemetry on message when the mode goes
@@ -236,19 +236,19 @@
 }
 
 func runLocal(_ []string) {
-	if old, _ := telemetry.Mode(); old == "local" {
+	if old, _ := telemetry.Default.Mode(); old == "local" {
 		return
 	}
-	if err := telemetry.SetMode("local"); err != nil {
+	if err := telemetry.Default.SetMode("local"); err != nil {
 		failf("Failed to set the telemetry mode to local: %v", err)
 	}
 }
 
 func runOff(_ []string) {
-	if old, _ := telemetry.Mode(); old == "off" {
+	if old, _ := telemetry.Default.Mode(); old == "off" {
 		return
 	}
-	if err := telemetry.SetMode("off"); err != nil {
+	if err := telemetry.Default.SetMode("off"); err != nil {
 		failf("Failed to disable telemetry: %v", err)
 	}
 }
@@ -258,12 +258,12 @@
 }
 
 func runEnv(_ []string) {
-	m, t := telemetry.Mode()
+	m, t := telemetry.Default.Mode()
 	fmt.Printf("mode: %s %s\n", m, t)
 	fmt.Println()
-	fmt.Println("modefile:", telemetry.ModeFile)
-	fmt.Println("localdir:", telemetry.LocalDir)
-	fmt.Println("uploaddir:", telemetry.UploadDir)
+	fmt.Println("modefile:", telemetry.Default.ModeFile())
+	fmt.Println("localdir:", telemetry.Default.LocalDir())
+	fmt.Println("uploaddir:", telemetry.Default.UploadDir())
 }
 
 func runClean(_ []string) {
@@ -271,8 +271,8 @@
 	// It would probably be OK to just remove everything, but it may
 	// be useful to preserve the weekends file.
 	for dir, suffixes := range map[string][]string{
-		telemetry.LocalDir:  {"." + counter.FileVersion + ".count", ".json"},
-		telemetry.UploadDir: {".json"},
+		telemetry.Default.LocalDir():  {"." + counter.FileVersion + ".count", ".json"},
+		telemetry.Default.UploadDir(): {".json"},
 	} {
 		entries, err := os.ReadDir(dir)
 		if err != nil {
@@ -307,7 +307,7 @@
 
 func runDump(args []string) {
 	if len(args) == 0 {
-		localdir := telemetry.LocalDir
+		localdir := telemetry.Default.LocalDir()
 		fi, err := os.ReadDir(localdir)
 		if err != nil && len(args) == 0 {
 			log.Fatal(err)
diff --git a/counter/countertest/countertest.go b/counter/countertest/countertest.go
index c2f41f6..dc8bb11 100644
--- a/counter/countertest/countertest.go
+++ b/counter/countertest/countertest.go
@@ -7,7 +7,6 @@
 package countertest
 
 import (
-	"path/filepath"
 	"sync"
 
 	"golang.org/x/telemetry/counter"
@@ -39,9 +38,7 @@
 	if opened {
 		panic("Open was called more than once")
 	}
-	telemetry.ModeFile = telemetry.ModeFilePath(filepath.Join(telemetryDir, "mode"))
-	telemetry.LocalDir = filepath.Join(telemetryDir, "local")
-	telemetry.UploadDir = filepath.Join(telemetryDir, "upload")
+	telemetry.Default = telemetry.NewDir(telemetryDir)
 
 	counter.Open()
 	opened = true
diff --git a/internal/counter/counter_test.go b/internal/counter/counter_test.go
index ba5dfab..e3d6ff5 100644
--- a/internal/counter/counter_test.go
+++ b/internal/counter/counter_test.go
@@ -70,7 +70,7 @@
 
 func TestMissingLocalDir(t *testing.T) {
 	testenv.SkipIfUnsupportedPlatform(t)
-	err := os.RemoveAll(telemetry.LocalDir)
+	err := os.RemoveAll(telemetry.Default.LocalDir())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -236,7 +236,7 @@
 		var f file
 		c := f.New("gophers")
 		// shouldn't see a file yet
-		fi, err := os.ReadDir(telemetry.LocalDir)
+		fi, err := os.ReadDir(telemetry.Default.LocalDir())
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -245,7 +245,7 @@
 		}
 		c.Add(9)
 		// still shouldn't see a file
-		fi, err = os.ReadDir(telemetry.LocalDir)
+		fi, err = os.ReadDir(telemetry.Default.LocalDir())
 		if err != nil {
 			close(&f)
 			t.Fatal(err)
@@ -256,7 +256,7 @@
 		}
 		f.rotate()
 		// now we should see a count file and a weekends file
-		fi, _ = os.ReadDir(telemetry.LocalDir)
+		fi, _ = os.ReadDir(telemetry.Default.LocalDir())
 		if len(fi) != 2 {
 			close(&f)
 			t.Fatalf("len(fi) = %d, want 2", len(fi))
@@ -267,7 +267,7 @@
 			case "weekends":
 				weekendsFile = f.Name()
 				// while we're here, check that is ok
-				buf, err := os.ReadFile(filepath.Join(telemetry.LocalDir, weekendsFile))
+				buf, err := os.ReadFile(filepath.Join(telemetry.Default.LocalDir(), weekendsFile))
 				if err != nil {
 					t.Fatal(err)
 				}
@@ -280,7 +280,7 @@
 			}
 		}
 
-		buf, err := os.ReadFile(filepath.Join(telemetry.LocalDir, countFile))
+		buf, err := os.ReadFile(filepath.Join(telemetry.Default.LocalDir(), countFile))
 		if err != nil {
 			close(&f)
 			t.Fatal(err)
@@ -303,8 +303,8 @@
 		}
 		close(&f)
 		// remove the file for the next iteration of the loop
-		os.Remove(filepath.Join(telemetry.LocalDir, countFile))
-		os.Remove(filepath.Join(telemetry.LocalDir, weekendsFile))
+		os.Remove(filepath.Join(telemetry.Default.LocalDir(), countFile))
+		os.Remove(filepath.Join(telemetry.Default.LocalDir(), weekendsFile))
 	}
 }
 
@@ -316,12 +316,12 @@
 	for i := 0; i < 7; i++ {
 		counterTime = future(i)
 		for index := range "0123456" {
-			os.WriteFile(filepath.Join(telemetry.LocalDir, "weekends"), []byte{byte(index + '0')}, 0666)
+			os.WriteFile(filepath.Join(telemetry.Default.LocalDir(), "weekends"), []byte{byte(index + '0')}, 0666)
 			var f file
 			c := f.New("gophers")
 			c.Add(7)
 			f.rotate()
-			fis, err := os.ReadDir(telemetry.LocalDir)
+			fis, err := os.ReadDir(telemetry.Default.LocalDir())
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -330,11 +330,11 @@
 			for _, fi := range fis {
 				// ignore errors for brevity: something else will fail
 				if fi.Name() == "weekends" {
-					buf, _ := os.ReadFile(filepath.Join(telemetry.LocalDir, fi.Name()))
+					buf, _ := os.ReadFile(filepath.Join(telemetry.Default.LocalDir(), fi.Name()))
 					buf = bytes.TrimSpace(buf)
 					weekends = time.Weekday(buf[0] - '0')
 				} else if strings.HasSuffix(fi.Name(), ".count") {
-					buf, _ := os.ReadFile(filepath.Join(telemetry.LocalDir, fi.Name()))
+					buf, _ := os.ReadFile(filepath.Join(telemetry.Default.LocalDir(), fi.Name()))
 					parsed, _ := Parse(fi.Name(), buf)
 					begins, _ = time.Parse(time.RFC3339, parsed.Meta["TimeBegin"])
 					ends, _ = time.Parse(time.RFC3339, parsed.Meta["TimeEnd"])
@@ -361,7 +361,7 @@
 			close(&f)
 			// remove files for the next iteration of the loop
 			for _, f := range fis {
-				os.Remove(filepath.Join(telemetry.LocalDir, f.Name()))
+				os.Remove(filepath.Join(telemetry.Default.LocalDir(), f.Name()))
 			}
 		}
 	}
@@ -505,13 +505,9 @@
 
 func setup(t *testing.T) {
 	log.SetFlags(log.Lshortfile)
-	tmpDir := t.TempDir() // new dir for each test
-	telemetry.LocalDir = tmpDir + "/local"
-	telemetry.UploadDir = tmpDir + "/upload"
-	os.MkdirAll(telemetry.LocalDir, 0777)
-	os.MkdirAll(telemetry.UploadDir, 0777)
-	telemetry.ModeFile = telemetry.ModeFilePath(filepath.Join(tmpDir, "mode"))
-	// os.UserConfigDir() is "" in tests so no point in looking at it
+	telemetry.Default = telemetry.NewDir(t.TempDir()) // new dir for each test
+	os.MkdirAll(telemetry.Default.LocalDir(), 0777)
+	os.MkdirAll(telemetry.Default.UploadDir(), 0777)
 }
 
 func restore() {
diff --git a/internal/counter/file.go b/internal/counter/file.go
index 742b1fc..12181b2 100644
--- a/internal/counter/file.go
+++ b/internal/counter/file.go
@@ -124,11 +124,11 @@
 		f.err = errNoBuildInfo
 		return
 	}
-	if mode, _ := telemetry.Mode(); mode == "off" {
+	if mode, _ := telemetry.Default.Mode(); mode == "off" {
 		f.err = ErrDisabled
 		return
 	}
-	dir := telemetry.LocalDir
+	dir := telemetry.Default.LocalDir()
 
 	if err := os.MkdirAll(dir, 0777); err != nil {
 		f.err = err
@@ -203,11 +203,11 @@
 	// If there is no 'weekends' file create it and initialize it
 	// to a random day of the week. There is a short interval for
 	// a race.
-	weekends := filepath.Join(telemetry.LocalDir, "weekends")
+	weekends := filepath.Join(telemetry.Default.LocalDir(), "weekends")
 	day := fmt.Sprintf("%d\n", rand.Intn(7))
 	if _, err := os.ReadFile(weekends); err != nil {
-		if err := os.MkdirAll(telemetry.LocalDir, 0777); err != nil {
-			debugPrintf("%v: could not create telemetry.LocalDir %s", err, telemetry.LocalDir)
+		if err := os.MkdirAll(telemetry.Default.LocalDir(), 0777); err != nil {
+			debugPrintf("%v: could not create telemetry.LocalDir %s", err, telemetry.Default.LocalDir())
 			return 7, err
 		}
 		if err = os.WriteFile(weekends, []byte(day), 0666); err != nil {
@@ -357,7 +357,7 @@
 	if telemetry.DisabledOnPlatform {
 		return func() {}
 	}
-	if mode, _ := telemetry.Mode(); mode == "off" {
+	if mode, _ := telemetry.Default.Mode(); mode == "off" {
 		// Don't open the file when telemetry is off.
 		defaultFile.err = ErrDisabled
 		return func() {} // No need to clean up.
diff --git a/internal/counter/rotate_test.go b/internal/counter/rotate_test.go
index 8b2c390..9e8ae49 100644
--- a/internal/counter/rotate_test.go
+++ b/internal/counter/rotate_test.go
@@ -147,7 +147,7 @@
 	setup(t)
 	defer restore()
 	// pretend something was uploaded
-	os.WriteFile(filepath.Join(telemetry.UploadDir, "anything"), []byte{}, 0666)
+	os.WriteFile(filepath.Join(telemetry.Default.UploadDir(), "anything"), []byte{}, 0666)
 	var f file
 	defer close(&f)
 	c := f.New("gophers")
@@ -156,7 +156,7 @@
 	for i := 0; i < 2; i++ {
 		// nothing should change on the second rotate
 		f.rotate()
-		fi, err := os.ReadDir(telemetry.LocalDir)
+		fi, err := os.ReadDir(telemetry.Default.LocalDir())
 		if err != nil || len(fi) != 2 {
 			t.Fatalf("err=%v, len(fi) = %d, want 2", err, len(fi))
 		}
@@ -170,7 +170,7 @@
 		if us != now {
 			t.Errorf("us = %v, want %v, i=%d y=%s", us, now, i, y)
 		}
-		fd, err := os.Open(filepath.Join(telemetry.LocalDir, fi[0].Name()))
+		fd, err := os.Open(filepath.Join(telemetry.Default.LocalDir(), fi[0].Name()))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -189,7 +189,7 @@
 	}
 	counterTime = func() time.Time { return now.Add(7 * 24 * time.Hour) }
 	f.rotate()
-	fi, err := os.ReadDir(telemetry.LocalDir)
+	fi, err := os.ReadDir(telemetry.Default.LocalDir())
 	if err != nil || len(fi) != 3 {
 		t.Fatalf("err=%v, len(fi) = %d, want 3", err, len(fi))
 	}
diff --git a/internal/regtest/e2e_test.go b/internal/regtest/e2e_test.go
index 9346c3d..d2ff7d3 100644
--- a/internal/regtest/e2e_test.go
+++ b/internal/regtest/e2e_test.go
@@ -73,20 +73,19 @@
 
 	for _, test := range tests {
 		t.Run(fmt.Sprintf("mode=%s", test.mode), func(t *testing.T) {
-			telemetryDir := t.TempDir()
+			dir := telemetry.NewDir(t.TempDir())
 			if test.mode != "" {
-				if err := telemetry.ModeFilePath(filepath.Join(telemetryDir, "mode")).SetMode(test.mode); err != nil {
+				if err := dir.SetMode(test.mode); err != nil {
 					t.Fatalf("SetMode failed: %v", err)
 				}
 			}
-			out, err := RunProg(t, telemetryDir, prog)
+			out, err := RunProg(t, dir.Dir(), prog)
 			if err != nil {
 				t.Fatalf("program failed unexpectedly (%v)\n%s", err, out)
 			}
-			localDir := filepath.Join(telemetryDir, "local")
-			_, err = os.Stat(localDir)
+			_, err = os.Stat(dir.LocalDir())
 			if err != nil && !os.IsNotExist(err) {
-				t.Fatalf("os.Stat(%q): unexpected error: %v", localDir, err)
+				t.Fatalf("os.Stat(%q): unexpected error: %v", dir.LocalDir(), err)
 			}
 			if gotLocalDir := err == nil; gotLocalDir != test.wantLocalDir {
 				t.Errorf("got /local dir: %v, want %v; out:\n%s", gotLocalDir, test.wantLocalDir, string(out))
diff --git a/internal/telemetry/dir.go b/internal/telemetry/dir.go
new file mode 100644
index 0000000..62f9a75
--- /dev/null
+++ b/internal/telemetry/dir.go
@@ -0,0 +1,155 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package telemetry manages the telemetry mode file.
+package telemetry
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+)
+
+// Default is the default directory containing Go telemetry configuration and
+// data.
+//
+// If Default is uninitialized, Default.Mode will be "off". As a consequence,
+// no data should be written to the directory, and so the path values of
+// LocalDir, UploadDir, etc. must not matter.
+//
+// Default is a global for convenience and testing, but should not be mutated
+// outside of tests.
+//
+// TODO(rfindley): it would be nice to completely eliminate this global state,
+// or at least push it in the golang.org/x/telemetry package
+var Default Dir
+
+// A Dir holds paths to telemetry data inside a directory.
+type Dir struct {
+	dir, local, upload, modefile string
+}
+
+// NewDir creates a new Dir encapsulating paths in the given dir.
+//
+// NewDir does not create any new directories or files--it merely encapsulates
+// the telemetry directory layout.
+func NewDir(dir string) Dir {
+	return Dir{
+		dir:      dir,
+		local:    filepath.Join(dir, "local"),
+		upload:   filepath.Join(dir, "upload"),
+		modefile: filepath.Join(dir, "mode"),
+	}
+}
+
+func init() {
+	cfgDir, err := os.UserConfigDir()
+	if err != nil {
+		return
+	}
+	Default = NewDir(filepath.Join(cfgDir, "go", "telemetry"))
+}
+
+func (d Dir) Dir() string {
+	return d.dir
+}
+
+func (d Dir) LocalDir() string {
+	return d.local
+}
+
+func (d Dir) UploadDir() string {
+	return d.upload
+}
+
+func (d Dir) ModeFile() string {
+	return d.modefile
+}
+
+// SetMode updates the telemetry mode with the given mode.
+// Acceptable values for mode are "on", "off", or "local".
+//
+// SetMode always writes the mode file, and explicitly records the date at
+// which the modefile was updated. This means that calling SetMode with "on"
+// effectively resets the timeout before the next telemetry report is uploaded.
+func (d Dir) SetMode(mode string) error {
+	return d.SetModeAsOf(mode, time.Now())
+}
+
+// SetModeAsOf is like SetMode, but accepts an explicit time to use to
+// back-date the mode state. This exists only for testing purposes.
+func (d Dir) SetModeAsOf(mode string, asofTime time.Time) error {
+	mode = strings.TrimSpace(mode)
+	switch mode {
+	case "on", "off", "local":
+	default:
+		return fmt.Errorf("invalid telemetry mode: %q", mode)
+	}
+	if d.modefile == "" {
+		return fmt.Errorf("cannot determine telemetry mode file name")
+	}
+	// TODO(rfindley): why is this not 777, consistent with the use of 666 below?
+	if err := os.MkdirAll(filepath.Dir(d.modefile), 0755); err != nil {
+		return fmt.Errorf("cannot create a telemetry mode file: %w", err)
+	}
+
+	asof := asofTime.UTC().Format("2006-01-02")
+	// Defensively guarantee that we can parse the asof time.
+	if _, err := time.Parse("2006-01-02", asof); err != nil {
+		return fmt.Errorf("internal error: invalid mode date %q: %v", asof, err)
+	}
+
+	data := []byte(mode + " " + asof)
+	return os.WriteFile(d.modefile, data, 0666)
+}
+
+// Mode returns the current telemetry mode, as well as the time that the mode
+// was effective.
+//
+// If there is no effective time, the second result is the zero time.
+//
+// If Mode is "off", no data should be written to the telemetry directory, and
+// the other paths values referenced by Dir should be considered undefined.
+// This accounts for the case where initializing [Default] fails, and therefore
+// local telemetry paths are unknown.
+func (d Dir) Mode() (string, time.Time) {
+	if d.modefile == "" {
+		return "off", time.Time{} // it's likely LocalDir/UploadDir are empty too. Turn off telemetry.
+	}
+	data, err := os.ReadFile(d.modefile)
+	if err != nil {
+		return "local", time.Time{} // default
+	}
+	mode := string(data)
+	mode = strings.TrimSpace(mode)
+
+	// Forward compatibility for https://go.dev/issue/63142#issuecomment-1734025130
+	//
+	// If the modefile contains a date, return it.
+	if idx := strings.Index(mode, " "); idx >= 0 {
+		d, err := time.Parse("2006-01-02", mode[idx+1:])
+		if err != nil {
+			d = time.Time{}
+		}
+		return mode[:idx], d
+	}
+
+	return mode, time.Time{}
+}
+
+// DisabledOnPlatform indicates whether telemetry is disabled
+// due to bugs in the current platform.
+const DisabledOnPlatform = false ||
+	// The following platforms could potentially be supported in the future:
+	runtime.GOOS == "openbsd" || // #60614
+	runtime.GOOS == "solaris" || // #60968 #60970
+	runtime.GOOS == "android" || // #60967
+	runtime.GOOS == "illumos" || // #65544
+	// These platforms fundamentally can't be supported:
+	runtime.GOOS == "js" || // #60971
+	runtime.GOOS == "wasip1" || // #60971
+	runtime.GOOS == "plan9" // https://github.com/golang/go/issues/57540#issuecomment-1470766639
diff --git a/internal/telemetry/mode_test.go b/internal/telemetry/dir_test.go
similarity index 63%
rename from internal/telemetry/mode_test.go
rename to internal/telemetry/dir_test.go
index ebde64b..aafe06b 100644
--- a/internal/telemetry/mode_test.go
+++ b/internal/telemetry/dir_test.go
@@ -6,42 +6,38 @@
 package telemetry
 
 import (
-	"fmt"
 	"os"
-	"path/filepath"
 	"testing"
 	"time"
 )
 
-func TestTelemetryDefault(t *testing.T) {
+func TestDefaults(t *testing.T) {
 	defaultDirMissing := false
 	if _, err := os.UserConfigDir(); err != nil {
 		defaultDirMissing = true
 	}
 	if defaultDirMissing {
-		if LocalDir != "" || UploadDir != "" || ModeFile != "" {
-			t.Errorf("DefaultSetting: (%q, %q, %q), want empty LocalDir/UploadDir/ModeFile", LocalDir, UploadDir, ModeFile)
+		if Default.LocalDir() != "" || Default.UploadDir() != "" || Default.ModeFile() != "" {
+			t.Errorf("DefaultSetting: (%q, %q, %q), want empty LocalDir/UploadDir/ModeFile", Default.LocalDir(), Default.UploadDir(), Default.ModeFile())
 		}
 	} else {
-		if LocalDir == "" || UploadDir == "" || ModeFile == "" {
-			t.Errorf("DefaultSetting: (%q, %q, %q), want non-empty LocalDir/UploadDir/ModeFile", LocalDir, UploadDir, ModeFile)
+		if Default.LocalDir() == "" || Default.UploadDir() == "" || Default.ModeFile() == "" {
+			t.Errorf("DefaultSetting: (%q, %q, %q), want non-empty LocalDir/UploadDir/ModeFile", Default.LocalDir(), Default.UploadDir(), Default.ModeFile())
 		}
 	}
 }
 
 func TestTelemetryModeWithNoModeConfig(t *testing.T) {
-	tmp := t.TempDir()
 	tests := []struct {
-		modefile ModeFilePath
-		want     string
+		dir  Dir
+		want string
 	}{
-		{ModeFilePath(filepath.Join(tmp, "mode")), "local"},
-		{"", "off"},
+		{NewDir(t.TempDir()), "local"},
+		{Dir{}, "off"},
 	}
 	for _, tt := range tests {
-		if got, _ := tt.modefile.Mode(); got != tt.want {
-			t.Logf("Mode file: %q", tt.modefile)
-			t.Errorf("Mode() = %v, want %v", got, tt.want)
+		if got, _ := tt.dir.Mode(); got != tt.want {
+			t.Errorf("Dir{modefile=%q}.Mode() = %v, want %v", tt.dir.ModeFile(), got, tt.want)
 		}
 	}
 }
@@ -59,18 +55,17 @@
 		{"bogus", true},
 		{"", true},
 	}
-	tmp := t.TempDir()
-	for i, tt := range tests {
+	for _, tt := range tests {
 		t.Run("mode="+tt.in, func(t *testing.T) {
-			modefile := ModeFilePath(filepath.Join(tmp, fmt.Sprintf("modefile%d", i)))
-			setErr := modefile.SetMode(tt.in)
+			dir := NewDir(t.TempDir())
+			setErr := dir.SetMode(tt.in)
 			if (setErr != nil) != tt.wantErr {
 				t.Fatalf("Set() error = %v, wantErr %v", setErr, tt.wantErr)
 			}
 			if setErr != nil {
 				return
 			}
-			if got, _ := modefile.Mode(); got != tt.in {
+			if got, _ := dir.Mode(); got != tt.in {
 				t.Errorf("LookupMode() = %q, want %q", got, tt.in)
 			}
 		})
@@ -88,16 +83,15 @@
 		{"off", "off", time.Time{}},
 		{"local", "local", time.Time{}},
 	}
-	tmp := t.TempDir()
-	for i, tt := range tests {
+	for _, tt := range tests {
 		t.Run("mode="+tt.in, func(t *testing.T) {
-			fname := filepath.Join(tmp, fmt.Sprintf("modefile%d", i))
-			if err := os.WriteFile(fname, []byte(tt.in), 0666); err != nil {
+			dir := NewDir(t.TempDir())
+			if err := os.WriteFile(dir.ModeFile(), []byte(tt.in), 0666); err != nil {
 				t.Fatal(err)
 			}
 			// Note: the checks below intentionally do not use time.Equal:
 			// we want this exact representation of time.
-			if gotMode, gotTime := ModeFilePath(fname).Mode(); gotMode != tt.wantMode || gotTime != tt.wantTime {
+			if gotMode, gotTime := dir.Mode(); gotMode != tt.wantMode || gotTime != tt.wantTime {
 				t.Errorf("ModeFilePath(contents=%s).Mode() = %q, %v, want %q, %v", tt.in, gotMode, gotTime, tt.wantMode, tt.wantTime)
 			}
 		})
diff --git a/internal/telemetry/mode.go b/internal/telemetry/mode.go
deleted file mode 100644
index d7d3f24..0000000
--- a/internal/telemetry/mode.go
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright 2023 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package telemetry manages the telemetry mode file.
-package telemetry
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-)
-
-// The followings are the process' default Settings.
-// The values are subdirectories and a file under
-// os.UserConfigDir()/go/telemetry.
-// For convenience, each field is made to global
-// and they are not supposed to be changed.
-var (
-	// Default directory containing count files, local reports (not yet uploaded), and logs
-	LocalDir string
-	// Default directory containing uploaded reports.
-	UploadDir string
-	// Default file path that holds the telemetry mode info.
-	ModeFile ModeFilePath
-)
-
-// ModeFilePath is the telemetry mode file path with methods to manipulate the file contents.
-type ModeFilePath string
-
-func init() {
-	cfgDir, err := os.UserConfigDir()
-	if err != nil {
-		return
-	}
-	gotelemetrydir := filepath.Join(cfgDir, "go", "telemetry")
-	LocalDir = filepath.Join(gotelemetrydir, "local")
-	UploadDir = filepath.Join(gotelemetrydir, "upload")
-	ModeFile = ModeFilePath(filepath.Join(gotelemetrydir, "mode"))
-}
-
-// SetMode updates the telemetry mode with the given mode.
-// Acceptable values for mode are "on", "off", or "local".
-//
-// SetMode always writes the mode file, and explicitly records the date at
-// which the modefile was updated. This means that calling SetMode with "on"
-// effectively resets the timeout before the next telemetry report is uploaded.
-func SetMode(mode string) error {
-	return ModeFile.SetMode(mode)
-}
-
-func (m ModeFilePath) SetMode(mode string) error {
-	return m.SetModeAsOf(mode, time.Now())
-}
-
-// SetModeAsOf is like SetMode, but accepts an explicit time to use to
-// back-date the mode state. This exists only for testing purposes.
-func (m ModeFilePath) SetModeAsOf(mode string, asofTime time.Time) error {
-	mode = strings.TrimSpace(mode)
-	switch mode {
-	case "on", "off", "local":
-	default:
-		return fmt.Errorf("invalid telemetry mode: %q", mode)
-	}
-	fname := string(m)
-	if fname == "" {
-		return fmt.Errorf("cannot determine telemetry mode file name")
-	}
-	if err := os.MkdirAll(filepath.Dir(fname), 0755); err != nil {
-		return fmt.Errorf("cannot create a telemetry mode file: %w", err)
-	}
-
-	asof := asofTime.UTC().Format("2006-01-02")
-	// Defensively guarantee that we can parse the asof time.
-	if _, err := time.Parse("2006-01-02", asof); err != nil {
-		return fmt.Errorf("internal error: invalid mode date %q: %v", asof, err)
-	}
-
-	data := []byte(mode + " " + asof)
-	return os.WriteFile(fname, data, 0666)
-}
-
-// Mode returns the current telemetry mode, as well as the time that the mode
-// was effective.
-//
-// If there is no effective time, the second result is the zero time.
-func Mode() (string, time.Time) {
-	return ModeFile.Mode()
-}
-
-func (m ModeFilePath) Mode() (string, time.Time) {
-	fname := string(m)
-	if fname == "" {
-		return "off", time.Time{} // it's likely LocalDir/UploadDir are empty too. Turn off telemetry.
-	}
-	data, err := os.ReadFile(fname)
-	if err != nil {
-		return "local", time.Time{} // default
-	}
-	mode := string(data)
-	mode = strings.TrimSpace(mode)
-
-	// Forward compatibility for https://go.dev/issue/63142#issuecomment-1734025130
-	//
-	// If the modefile contains a date, return it.
-	if idx := strings.Index(mode, " "); idx >= 0 {
-		d, err := time.Parse("2006-01-02", mode[idx+1:])
-		if err != nil {
-			d = time.Time{}
-		}
-		return mode[:idx], d
-	}
-
-	return mode, time.Time{}
-}
-
-// DisabledOnPlatform indicates whether telemetry is disabled
-// due to bugs in the current platform.
-const DisabledOnPlatform = false ||
-	// The following platforms could potentially be supported in the future:
-	runtime.GOOS == "openbsd" || // #60614
-	runtime.GOOS == "solaris" || // #60968 #60970
-	runtime.GOOS == "android" || // #60967
-	runtime.GOOS == "illumos" || // #65544
-	// These platforms fundamentally can't be supported:
-	runtime.GOOS == "js" || // #60971
-	runtime.GOOS == "wasip1" || // #60971
-	runtime.GOOS == "plan9" // https://github.com/golang/go/issues/57540#issuecomment-1470766639
diff --git a/internal/upload/dates_test.go b/internal/upload/dates_test.go
index 495ac2e..bf41e37 100644
--- a/internal/upload/dates_test.go
+++ b/internal/upload/dates_test.go
@@ -66,24 +66,21 @@
 	// and scheduled to get expired in the future.
 	// Let's pretend telemetry was enabled a year ago by mutating the mode file,
 	// we are in the future, and test if the count files are successfully uploaded.
-	uploader.ModeFilePath.SetModeAsOf("on", uploader.StartTime.Add(-365*24*time.Hour).UTC())
-	uploadedContent, fname := subtest(t, uc, uploader) // TODO(hyangah) : inline
+	uploader.Dir.SetModeAsOf("on", uploader.StartTime.Add(-365*24*time.Hour).UTC())
+	uploadedContent, fname := subtest(t, uploader) // TODO(hyangah) : inline
 
 	if want, got := [][]byte{uploadedContent}, uploaded(); !reflect.DeepEqual(want, got) {
 		t.Errorf("server got %s\nwant %s", got, want)
 	}
 	// and check that the uploaded report is in the upload dir
-	uname := filepath.Join(uploader.UploadDir, fname)
+	uname := filepath.Join(uploader.Dir.UploadDir(), fname)
 	if _, err := os.Stat(uname); err != nil {
 		t.Errorf("%v for uploade report %s", err, uname)
 	}
 }
 
 func newTestUploader(uc *telemetry.UploadConfig, telemetryDir string, srv *httptest.Server) *Uploader {
-	uploader := NewUploader(uc)
-	uploader.LocalDir = filepath.Join(telemetryDir, "local")
-	uploader.UploadDir = filepath.Join(telemetryDir, "upload")
-	uploader.ModeFilePath = telemetry.ModeFilePath(filepath.Join(telemetryDir, "mode"))
+	uploader := NewUploader(telemetryDir, uc)
 	uploader.UploadServerURL = srv.URL
 	return uploader
 }
@@ -103,7 +100,7 @@
 }
 
 // createFailingUploadServer creates a test server that returns errors
-func createFailingUploadServer(t *testing.T) *httptest.Server {
+func createFailingUploadServer() *httptest.Server {
 	f := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		io.ReadAll(r.Body)
 		http.Error(w, "failed", http.StatusBadRequest)
@@ -130,7 +127,7 @@
 	uc := createTestUploadConfig(t, []string{"knownCounter"}, []string{"aStack"})
 
 	// Start upload server
-	srv := createFailingUploadServer(t)
+	srv := createFailingUploadServer()
 	defer srv.Close()
 
 	uploader := newTestUploader(uc, telemetryDir, srv)
@@ -151,11 +148,11 @@
 	// and scheduled to get expired in the future.
 	// Let's pretend telemetry was enabled a year ago by mutating the mode file,
 	// we are in the future, and test if the count files are successfully uploaded.
-	uploader.ModeFilePath.SetModeAsOf("on", uploader.StartTime.Add(-365*24*time.Hour).UTC())
-	_, fname := subtest(t, uc, uploader)
+	uploader.Dir.SetModeAsOf("on", uploader.StartTime.Add(-365*24*time.Hour).UTC())
+	_, fname := subtest(t, uploader)
 	// check that fname does not exist
-	lname := filepath.Join(uploader.LocalDir, fname)
-	uname := filepath.Join(uploader.UploadDir, fname)
+	lname := filepath.Join(uploader.Dir.LocalDir(), fname)
+	uname := filepath.Join(uploader.Dir.UploadDir(), fname)
 	if _, err := os.Stat(lname); err == nil {
 		t.Errorf("local file %s should not exist", lname)
 	}
@@ -322,7 +319,7 @@
 			defer srv.Close()
 
 			uploader := newTestUploader(uc, telemetryDir, srv)
-			uploader.ModeFilePath.SetModeAsOf("on", telemetryEnableTime)
+			uploader.Dir.SetModeAsOf("on", telemetryEnableTime)
 			uploader.UploadServerURL = srv.URL
 			uploader.StartTime = mustParseDate(tx.today)
 
@@ -441,13 +438,13 @@
 }
 
 func doTest(t *testing.T, u *Uploader, doing *Test, known *countFileInfo) int {
-	dbg := filepath.Join(u.LocalDir, "debug")
+	dbg := filepath.Join(u.Dir.LocalDir(), "debug")
 	os.MkdirAll(dbg, 0777)
 	if err := LogIfDebug(dbg); err != nil {
 		t.Errorf("debug logging: %v", err)
 	}
 	if len(doing.uploads) > 0 {
-		os.MkdirAll(u.UploadDir, 0777)
+		os.MkdirAll(u.Dir.UploadDir(), 0777)
 	}
 	contents := bytes.Join([][]byte{
 		known.buf[:known.beginOffset],
@@ -457,25 +454,25 @@
 		known.buf[known.endOffset+len("YYYY-MM-DD"):],
 	}, nil)
 	filename := known.namePrefix + doing.date + ".v1.count"
-	if err := os.WriteFile(filepath.Join(u.LocalDir, filename), contents, 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(u.Dir.LocalDir(), filename), contents, 0666); err != nil {
 		t.Errorf("%v writing count file for %s (%s)", err, doing.name, filename)
 		return 0
 	}
 	for _, x := range doing.locals {
 		nm := fmt.Sprintf("local.%s.json", x)
-		if err := os.WriteFile(filepath.Join(u.LocalDir, nm), []byte{}, 0666); err != nil {
+		if err := os.WriteFile(filepath.Join(u.Dir.LocalDir(), nm), []byte{}, 0666); err != nil {
 			t.Errorf("%v writing local file %s", err, nm)
 		}
 	}
 	for _, x := range doing.readys {
 		nm := fmt.Sprintf("%s.json", x)
-		if err := os.WriteFile(filepath.Join(u.LocalDir, nm), []byte{}, 0666); err != nil {
+		if err := os.WriteFile(filepath.Join(u.Dir.LocalDir(), nm), []byte{}, 0666); err != nil {
 			t.Errorf("%v writing ready file %s", err, nm)
 		}
 	}
 	for _, x := range doing.uploads {
 		nm := fmt.Sprintf("%s.json", x)
-		if err := os.WriteFile(filepath.Join(u.UploadDir, nm), []byte{}, 0666); err != nil {
+		if err := os.WriteFile(filepath.Join(u.Dir.UploadDir(), nm), []byte{}, 0666); err != nil {
 			t.Errorf("%v writing upload %s", err, nm)
 		}
 	}
@@ -485,9 +482,9 @@
 
 	// check results
 	var cfiles, rfiles, lfiles, ufiles, logcnt int
-	fis, err := os.ReadDir(u.LocalDir)
+	fis, err := os.ReadDir(u.Dir.LocalDir())
 	if err != nil {
-		t.Errorf("%v reading localdir %s", err, u.LocalDir)
+		t.Errorf("%v reading localdir %s", err, u.Dir.LocalDir())
 		return 0
 	}
 	for _, f := range fis {
@@ -500,7 +497,7 @@
 		case strings.HasSuffix(f.Name(), ".json"):
 			rfiles++
 		case f.Name() == "debug":
-			dbgname := filepath.Join(u.LocalDir, "debug")
+			dbgname := filepath.Join(u.Dir.LocalDir(), "debug")
 			logs, err := os.ReadDir(dbgname)
 			if err != nil {
 				break
@@ -513,9 +510,9 @@
 	if logcnt != 1 {
 		t.Errorf("expected 1 log file, got %d", logcnt)
 	}
-	fis, err = os.ReadDir(u.UploadDir)
+	fis, err = os.ReadDir(u.Dir.UploadDir())
 	if err != nil {
-		t.Errorf("%v reading uploaddir %s", err, u.UploadDir)
+		t.Errorf("%v reading uploaddir %s", err, u.Dir.UploadDir())
 		return 0
 	}
 	ufiles = len(fis) // assume there's nothing but .json reports
@@ -543,7 +540,7 @@
 }
 
 // check that generated report is as expected, and return its contents and its name
-func subtest(t *testing.T, c *telemetry.UploadConfig, u *Uploader) ([]byte, string) {
+func subtest(t *testing.T, u *Uploader) ([]byte, string) {
 	// check state before generating report
 	work := u.findWork()
 	// expect one count file and nothing else
@@ -569,7 +566,7 @@
 		// the uploadable report
 		t.Errorf("expected one readyfile, got %d", len(got.readyfiles))
 	}
-	fi, err := os.ReadDir(u.LocalDir)
+	fi, err := os.ReadDir(u.Dir.LocalDir())
 	if len(fi) != 3 || err != nil {
 		// one local report, one uploadable report, one weekends file
 		t.Errorf("expected three files in LocalDir, got %d, %v", len(fi), err)
@@ -581,7 +578,7 @@
 	var localFile, uploadFile []byte
 	var uploadName string
 	for _, f := range fi {
-		fname := filepath.Join(u.LocalDir, f.Name())
+		fname := filepath.Join(u.Dir.LocalDir(), f.Name())
 		buf, err := os.ReadFile(fname)
 		if err != nil {
 			t.Fatal(err)
diff --git a/internal/upload/findwork.go b/internal/upload/findwork.go
index 286d6be..da3a16a 100644
--- a/internal/upload/findwork.go
+++ b/internal/upload/findwork.go
@@ -23,7 +23,7 @@
 // that need to be uploaded. (There may be unexpected leftover files
 // and uploading is supposed to be idempotent.)
 func (u *Uploader) findWork() work {
-	localdir, uploaddir := u.LocalDir, u.UploadDir
+	localdir, uploaddir := u.Dir.LocalDir(), u.Dir.UploadDir()
 	var ans work
 	fis, err := os.ReadDir(localdir)
 	if err != nil {
@@ -31,7 +31,7 @@
 		return ans
 	}
 
-	mode, asof := u.ModeFilePath.Mode()
+	mode, asof := u.Dir.Mode()
 	logger.Printf("mode %s, asof %s", mode, asof)
 
 	// count files end in .v1.count
diff --git a/internal/upload/reports.go b/internal/upload/reports.go
index e8a65bc..c679612 100644
--- a/internal/upload/reports.go
+++ b/internal/upload/reports.go
@@ -23,7 +23,7 @@
 
 // reports generates reports from inactive count files
 func (u *Uploader) reports(todo *work) ([]string, error) {
-	if mode, _ := u.ModeFilePath.Mode(); mode == "off" {
+	if mode, _ := u.Dir.Mode(); mode == "off" {
 		return nil, nil // no reports
 	}
 	thisInstant := u.StartTime
@@ -120,7 +120,7 @@
 		u.ConfigVersion = v
 	}
 	uploadOK := true
-	mode, asof := u.ModeFilePath.Mode()
+	mode, asof := u.Dir.Mode()
 	if u.Config == nil || mode != "on" {
 		logger.Printf("no upload config or mode %q is not 'on'", mode)
 		uploadOK = false // no config, nothing to upload
@@ -227,8 +227,8 @@
 			return "", fmt.Errorf("failed to marshal upload report (%v)", err)
 		}
 	}
-	localFileName := filepath.Join(u.LocalDir, "local."+expiryDate+".json")
-	uploadFileName := filepath.Join(u.LocalDir, expiryDate+".json")
+	localFileName := filepath.Join(u.Dir.LocalDir(), "local."+expiryDate+".json")
+	uploadFileName := filepath.Join(u.Dir.LocalDir(), expiryDate+".json")
 
 	/* Prepare to write files */
 	// if either file exists, someone has been here ahead of us
diff --git a/internal/upload/run.go b/internal/upload/run.go
index f21d973..beab886 100644
--- a/internal/upload/run.go
+++ b/internal/upload/run.go
@@ -44,7 +44,7 @@
 // dirname, if it exists. If dirname is the empty string,
 // the function tries the directory it.Localdir/debug.
 func LogIfDebug(dirname string) error {
-	dname := filepath.Join(telemetry.LocalDir, "debug")
+	dname := filepath.Join(telemetry.Default.LocalDir(), "debug")
 	if dirname != "" {
 		dname = dirname
 	}
@@ -93,12 +93,8 @@
 	// ConfigVersion is the version of the config.
 	ConfigVersion string
 
-	// LocalDir is where the local counter files are.
-	LocalDir string
-	// UploadDir is where uploader leaves the copy of uploaded data.
-	UploadDir string
-	// ModeFilePath is the file.
-	ModeFilePath telemetry.ModeFilePath
+	// Dir is the telemetry directory to process.
+	Dir telemetry.Dir
 
 	UploadServerURL string
 	StartTime       time.Time
@@ -107,13 +103,24 @@
 }
 
 // NewUploader creates a default uploader.
-func NewUploader(config *telemetry.UploadConfig) *Uploader {
+//
+// If telemetryDir is set, it is used as the telemetry data directory to
+// process, instead of the default directory.
+//
+// If config is set, it is used as the upload config, rather than the
+// downloaded upload configuration.
+func NewUploader(telemetryDir string, config *telemetry.UploadConfig) *Uploader {
+	var dir telemetry.Dir
+	if telemetryDir != "" {
+		dir = telemetry.NewDir(telemetryDir)
+	} else {
+		dir = telemetry.Default
+	}
+	// TODO(rfindley): get the config here, rather than during the upload process.
 	return &Uploader{
 		Config:          config,
 		ConfigVersion:   "custom",
-		LocalDir:        telemetry.LocalDir,
-		UploadDir:       telemetry.UploadDir,
-		ModeFilePath:    telemetry.ModeFile,
+		Dir:             dir,
 		UploadServerURL: "https://telemetry.go.dev/upload",
 		StartTime:       time.Now().UTC(),
 	}
diff --git a/internal/upload/upload.go b/internal/upload/upload.go
index 9be10a7..c01f9c4 100644
--- a/internal/upload/upload.go
+++ b/internal/upload/upload.go
@@ -85,7 +85,7 @@
 		return false
 	}
 	// put a copy in the uploaded directory
-	newname := filepath.Join(u.UploadDir, fdate+".json")
+	newname := filepath.Join(u.Dir.UploadDir(), fdate+".json")
 	if err := os.WriteFile(newname, buf, 0644); err == nil {
 		os.Remove(fname) // if it exists
 	}
diff --git a/mode.go b/mode.go
index fb9672c..1361d64 100644
--- a/mode.go
+++ b/mode.go
@@ -24,7 +24,7 @@
 //
 // [gotelemetry]: https://pkg.go.dev/golang.org/x/telemetry/cmd/gotelemetry
 func Mode() string {
-	mode, _ := telemetry.Mode()
+	mode, _ := telemetry.Default.Mode()
 	return mode
 }
 
@@ -36,5 +36,5 @@
 // An error is returned if the provided mode value is invalid, or if an error
 // occurs while persisting the mode value to the file system.
 func SetMode(mode string) error {
-	return telemetry.SetMode(mode)
+	return telemetry.Default.SetMode(mode)
 }
diff --git a/start.go b/start.go
index 6c88992..3cc5c1f 100644
--- a/start.go
+++ b/start.go
@@ -70,11 +70,9 @@
 // be executed twice (parent and child).
 func Start(config Config) {
 	if config.TelemetryDir != "" {
-		telemetry.ModeFile = telemetry.ModeFilePath(filepath.Join(config.TelemetryDir, "mode"))
-		telemetry.LocalDir = filepath.Join(config.TelemetryDir, "local")
-		telemetry.UploadDir = filepath.Join(config.TelemetryDir, "upload")
+		telemetry.Default = telemetry.NewDir(config.TelemetryDir)
 	}
-	mode, _ := telemetry.Mode()
+	mode, _ := telemetry.Default.Mode()
 	if mode == "off" {
 		// Telemetry is turned off. Crash reporting doesn't work without telemetry
 		// at least set to "local", and the uploader isn't started in uploaderChild if
@@ -84,7 +82,7 @@
 
 	counter.Open()
 
-	if _, err := os.Stat(telemetry.LocalDir); err != nil {
+	if _, err := os.Stat(telemetry.Default.LocalDir()); err != nil {
 		// There was a problem statting LocalDir, which is needed for both
 		// crash monitoring and counter uploading. Most likely, there was an
 		// error creating telemetry.LocalDir in the counter.Open call above.
@@ -121,7 +119,7 @@
 	cmd := exec.Command(exe, "** telemetry **") // this unused arg is just for ps(1)
 	daemonize(cmd)
 	cmd.Env = append(os.Environ(), telemetryChildVar+"=1")
-	cmd.Dir = telemetry.LocalDir
+	cmd.Dir = telemetry.Default.LocalDir()
 
 	// The child process must write to a log file, not
 	// the stderr file it inherited from the parent, as
@@ -132,7 +130,7 @@
 	// By default, we discard the child process's stderr,
 	// but in line with the uploader, log to a file in local/debug
 	// only if that directory was created by the user.
-	localDebug := filepath.Join(telemetry.LocalDir, "debug")
+	localDebug := filepath.Join(telemetry.Default.LocalDir(), "debug")
 	fd, err := os.Stat(localDebug)
 	if err != nil {
 		if !os.IsNotExist(err) {
@@ -190,17 +188,17 @@
 }
 
 func uploaderChild() {
-	if mode, _ := telemetry.Mode(); mode == "off" {
+	if mode, _ := telemetry.Default.Mode(); mode == "off" {
 		// There's no work to be done if telemetry is turned off.
 		return
 	}
-	if telemetry.LocalDir == "" {
+	if telemetry.Default.LocalDir() == "" {
 		// The telemetry dir wasn't initialized properly, probably because
 		// os.UserConfigDir did not complete successfully. In that case
 		// there are no counters to upload, so we should just do nothing.
 		return
 	}
-	tokenfilepath := filepath.Join(telemetry.LocalDir, "upload.token")
+	tokenfilepath := filepath.Join(telemetry.Default.LocalDir(), "upload.token")
 	ok, err := acquireUploadToken(tokenfilepath)
 	if err != nil {
 		log.Printf("error acquiring upload token: %v", err)
diff --git a/upload/upload.go b/upload/upload.go
index 122b725..bb2eecc 100644
--- a/upload/upload.go
+++ b/upload/upload.go
@@ -25,7 +25,7 @@
 			log.Printf("upload recover: %v", err)
 		}
 	}()
-	upload.NewUploader(nil).Run()
+	upload.NewUploader("", nil).Run()
 }
 
 // A Control allows the user to override various default