fix(telemetry): make telemetry opt-out by disclosed default

Author: edelauna

PRIVACY.md

@@ -56,8 +56,8 @@ go—and, importantly, where they don't.
 ## **Your Choices & Control**
 
 - You can run models locally to prevent data being sent to third-parties.
-- Telemetry collection is off by default and requires your explicit opt-in.
-  You can change your choice at any time through the settings.
+- Telemetry collection is enabled by default to help us improve Zoo Code, but
+  you can opt out at any time through the settings.
 - You can delete Zoo Code to stop all data collection.
 
 ## **Security & Updates**

packages/types/src/__tests__/telemetry.isTelemetryOptedIn.test.ts

@@ -3,19 +3,19 @@
 import { isTelemetryOptedIn } from "../telemetry.js"
 
 describe("isTelemetryOptedIn", () => {
-	it("returns true only for an explicit 'enabled' setting", () => {
+	it("returns true for an explicit 'enabled' setting", () => {
 		expect(isTelemetryOptedIn("enabled")).toBe(true)
 	})
 
 	it("returns false for an explicit 'disabled' setting", () => {
 		expect(isTelemetryOptedIn("disabled")).toBe(false)
 	})
 
-	it("returns false for 'unset' (no explicit consent yet)", () => {
-		expect(isTelemetryOptedIn("unset")).toBe(false)
+	it("returns true for 'unset' (disclosed opt-out default applies)", () => {
+		expect(isTelemetryOptedIn("unset")).toBe(true)
 	})
 
-	it("returns false for undefined (treated the same as unset)", () => {
-		expect(isTelemetryOptedIn(undefined)).toBe(false)
+	it("returns true for undefined (treated the same as unset)", () => {
+		expect(isTelemetryOptedIn(undefined)).toBe(true)
 	})
 })

packages/types/src/telemetry.ts

@@ -14,15 +14,15 @@ export const telemetrySettingsSchema = z.enum(telemetrySettings)
 export type TelemetrySetting = z.infer<typeof telemetrySettingsSchema>
 
 /**
- * Whether the user has explicitly opted into telemetry.
+ * Whether telemetry should be captured for this install.
  *
- * Only an explicit "enabled" counts as consent. "unset" (no choice made yet) and
- * "disabled" both mean telemetry must not be captured -- this is what makes a
- * neutral dismiss of the consent banner (which leaves the setting "unset")
- * actually neutral, rather than silently opting the user in.
+ * Telemetry is on by default (disclosed opt-out): "unset" (no choice made yet) and
+ * "enabled" both mean telemetry may be captured. Only an explicit "disabled" opts out.
+ * The consent banner's dismiss/close action never writes a setting, so it stays neutral --
+ * it just leaves the default in effect rather than recording an affirmative choice either way.
  */
 export function isTelemetryOptedIn(telemetrySetting: TelemetrySetting | undefined): boolean {
-	return telemetrySetting === "enabled"
+	return telemetrySetting !== "disabled"
 }
 
 /**

src/core/webview/__tests__/telemetrySettingsTracking.spec.ts

@@ -50,7 +50,7 @@ describe("Telemetry Settings Tracking", () => {
 			expect(mockTelemetryService.updateTelemetryState).toHaveBeenCalledWith(false)
 		})
 
-		it("should not fire an opt-out event when going from unset to disabled (was never opted in)", () => {
+		it("should fire an opt-out event when going from unset to disabled (explicit Decline)", () => {
 			const previousSetting = "unset" as TelemetrySetting
 			const newSetting = "disabled" as TelemetrySetting
 
@@ -63,8 +63,9 @@ describe("Telemetry Settings Tracking", () => {
 
 			TelemetryService.instance.updateTelemetryState(isOptedIn)
 
-			// "unset" was never opted in, so there is no opt-out transition to report.
-			expect(mockTelemetryService.captureTelemetrySettingsChanged).not.toHaveBeenCalled()
+			// "unset" is opted in under the disclosed opt-out default, so unset -> disabled
+			// is a genuine opt-out transition.
+			expect(mockTelemetryService.captureTelemetrySettingsChanged).toHaveBeenCalledWith("unset", "disabled")
 			expect(mockTelemetryService.updateTelemetryState).toHaveBeenCalledWith(false)
 		})
 	})
@@ -116,7 +117,7 @@ describe("Telemetry Settings Tracking", () => {
 			expect(mockTelemetryService.updateTelemetryState).toHaveBeenCalledWith(true)
 		})
 
-		it("should fire an opt-in event when going from unset to enabled (explicit Accept)", () => {
+		it("should not fire an event when going from unset to enabled (already opted in by default)", () => {
 			const previousSetting = "unset" as TelemetrySetting
 			const newSetting = "enabled" as TelemetrySetting
 
@@ -133,18 +134,21 @@ describe("Telemetry Settings Tracking", () => {
 				TelemetryService.instance.captureTelemetrySettingsChanged(previousSetting, newSetting)
 			}
 
-			// "unset" is not opted in, so unset -> enabled is a genuine opt-in transition.
-			expect(mockTelemetryService.captureTelemetrySettingsChanged).toHaveBeenCalledWith("unset", "enabled")
+			// "unset" is already opted in under the disclosed opt-out default, so explicit
+			// Accept (unset -> enabled) is a no-op transition, not a new opt-in.
+			expect(mockTelemetryService.captureTelemetrySettingsChanged).not.toHaveBeenCalled()
 			expect(mockTelemetryService.updateTelemetryState).toHaveBeenCalledWith(true)
 		})
 	})
 
 	describe("neutral banner dismiss ('unset' left as-is)", () => {
-		it("does not report telemetry as opted in while the setting remains unset", () => {
+		it("leaves the disclosed opt-out default in effect while the setting remains unset", () => {
 			// A neutral dismiss of the consent banner sends no telemetrySetting message at
 			// all, so the stored setting stays "unset". Confirm "unset" alone -- with no
-			// transition -- is not treated as consent.
-			expect(isTelemetryOptedIn("unset" as TelemetrySetting)).toBe(false)
+			// transition, and no affirmative choice recorded either way -- resolves to the
+			// disclosed default (telemetry on) rather than silently opting the user in via
+			// dismissal itself.
+			expect(isTelemetryOptedIn("unset" as TelemetrySetting)).toBe(true)
 		})
 	})
 

src/core/webview/webviewMessageHandler.ts

@@ -629,8 +629,8 @@ export const webviewMessageHandler = async (
 					),
 				)
 
-			// Only capture telemetry once the user has explicitly opted in; "unset" (no
-			// choice made yet) and "disabled" are both treated as not opted in.
+			// Telemetry is on by disclosed default: "unset" (no choice made yet) leaves that
+			// default in effect, same as "enabled". Only an explicit "disabled" opts out.
 			provider.getStateToPostToWebview().then((state) => {
 				const { telemetrySetting } = state
 				TelemetryService.instance.updateTelemetryState(isTelemetryOptedIn(telemetrySetting))

webview-ui/src/__tests__/TelemetryClient.spec.ts

@@ -77,7 +77,26 @@ describe("TelemetryClient", () => {
 			expect(posthog.init).not.toHaveBeenCalled()
 		})
 
-		it("doesn't initialize PostHog when telemetry is unset", () => {
+		it("initializes PostHog when telemetry is unset and credentials are present (disclosed opt-out default)", () => {
+			// Arrange
+			const API_KEY = "test-api-key"
+			const DISTINCT_ID = "test-user-id"
+
+			// Act
+			telemetryClient.updateTelemetryState("unset", API_KEY, DISTINCT_ID)
+
+			// Assert
+			expect(posthog.init).toHaveBeenCalledWith(
+				API_KEY,
+				expect.objectContaining({
+					api_host: "https://us.i.posthog.com",
+					persistence: "localStorage",
+					loaded: expect.any(Function),
+				}),
+			)
+		})
+
+		it("doesn't initialize PostHog when telemetry is unset but credentials are missing", () => {
 			// Act
 			telemetryClient.updateTelemetryState("unset")
 

webview-ui/src/components/common/TelemetryBanner.tsx

@@ -11,9 +11,10 @@ const TelemetryBanner = () => {
 	const { t } = useAppTranslation()
 	const [isDismissed, setIsDismissed] = useState(false)
 
-	// A neutral dismiss ("x") intentionally sends no message, leaving the
-	// setting as "unset" (routed to disabled for actual capture). Only the
-	// explicit Accept/Decline actions record the user's choice.
+	// A neutral dismiss ("x") intentionally sends no message, leaving the setting
+	// "unset" so the disclosed opt-out default (telemetry on) stays in effect.
+	// Only an explicit Decline (-> "disabled") opts out. Only the explicit
+	// Accept/Decline actions record the user's choice.
 	const handleClose = () => {
 		setIsDismissed(true)
 	}
@@ -42,7 +43,7 @@ const TelemetryBanner = () => {
 
 	return (
 		<div className="relative px-4 py-2.5 pr-10 bg-vscode-banner-background border-b border-vscode-panel-border text-sm leading-normal text-vscode-foreground">
-			{/* Close button (X) - neutral dismiss, does not opt in */}
+			{/* Close button (X) - neutral dismiss, does not record a choice */}
 			<button
 				onClick={handleClose}
 				className="absolute top-1.5 right-2 bg-transparent border-none text-vscode-foreground cursor-pointer text-2xl p-1 opacity-70 hover:opacity-100 transition-opacity duration-200 leading-none"

webview-ui/src/components/settings/__tests__/About.spec.tsx

@@ -161,14 +161,14 @@ describe("About", () => {
 		expect(screen.getByRole("checkbox", { name: /telemetry/i })).toBeChecked()
 	})
 
-	it("does not show the telemetry checkbox as checked when the setting is unset (no consent given yet)", () => {
+	it("shows the telemetry checkbox as checked when the setting is unset (disclosed opt-out default)", () => {
 		render(
 			<TranslationProvider>
 				<About {...defaultProps} telemetrySetting="unset" />
 			</TranslationProvider>,
 		)
 
-		expect(screen.getByRole("checkbox", { name: /telemetry/i })).not.toBeChecked()
+		expect(screen.getByRole("checkbox", { name: /telemetry/i })).toBeChecked()
 	})
 
 	it("does not show the telemetry checkbox as checked when the setting is disabled", () => {