🤖 feat: enhance telemetry with runtime, platform, and usage tracking

Add comprehensive telemetry enhancements for better product insights:

Runtime & Platform Data:
- Add runtimeType (local/worktree/ssh) to workspace_created and message_sent
- Add frontend platform info (userAgent, platform) for mux server mode
- Enhance backend platform data with nodeVersion and bunVersion

New Events:
- stream_completed: Track completion vs interruption, duration, output tokens
- provider_configured: Track which providers users set up (not keys!)
- command_used: Track slash command usage patterns
- voice_transcription: Track voice input adoption and success rate

Enhanced Events:
- app_started: Add vimModeEnabled for vim mode adoption
- message_sent: Add thinkingLevel for extended thinking usage

All metrics use base-2 rounding for privacy-preserving numerical data.

_Generated with `mux`_

Author: ammar-agent

docs/system-prompt.md

@@ -62,5 +62,4 @@ You are in a git worktree at ${workspacePath}
 }
 ```
 
-
 {/* END SYSTEM_PROMPT_DOCS */}

src/browser/App.tsx

@@ -33,6 +33,7 @@ import { isWorkspaceForkSwitchEvent } from "./utils/workspaceEvents";
 import { getThinkingLevelKey } from "@/common/constants/storage";
 import type { BranchListResult } from "@/common/orpc/types";
 import { useTelemetry } from "./hooks/useTelemetry";
+import { getRuntimeTypeForTelemetry } from "@/common/telemetry";
 import { useStartWorkspaceCreation, getFirstProjectPath } from "./hooks/useStartWorkspaceCreation";
 import { useAPI } from "@/browser/contexts/API";
 import { AuthTokenModal } from "@/browser/components/AuthTokenModal";
@@ -640,7 +641,10 @@ function AppInner() {
                             });
 
                             // Track telemetry
-                            telemetry.workspaceCreated(metadata.id);
+                            telemetry.workspaceCreated(
+                              metadata.id,
+                              getRuntimeTypeForTelemetry(metadata.runtimeConfig)
+                            );
 
                             // Clear pending state
                             clearPendingWorkspaceCreation();

src/browser/components/AIView.tsx

@@ -33,6 +33,7 @@ import { WorkspaceHeader } from "./WorkspaceHeader";
 import { getModelName } from "@/common/utils/ai/models";
 import type { DisplayedMessage } from "@/common/types/message";
 import type { RuntimeConfig } from "@/common/types/runtime";
+import { getRuntimeTypeForTelemetry } from "@/common/telemetry";
 import { useAIViewKeybinds } from "@/browser/hooks/useAIViewKeybinds";
 import { evictModelFromLRU } from "@/browser/hooks/useModelLRU";
 import { QueuedMessage } from "./Messages/QueuedMessage";
@@ -620,6 +621,7 @@ const AIViewInner: React.FC<AIViewProps> = ({
         <ChatInput
           variant="workspace"
           workspaceId={workspaceId}
+          runtimeType={getRuntimeTypeForTelemetry(runtimeConfig)}
           onMessageSent={handleMessageSent}
           onTruncateHistory={handleClearHistory}
           onProviderConfig={handleProviderConfig}

src/browser/components/ChatInput/index.tsx

@@ -119,6 +119,8 @@ export const ChatInput: React.FC<ChatInputProps> = (props) => {
   const editingMessage = variant === "workspace" ? props.editingMessage : undefined;
   const isCompacting = variant === "workspace" ? (props.isCompacting ?? false) : false;
   const canInterrupt = variant === "workspace" ? (props.canInterrupt ?? false) : false;
+  // runtimeType for telemetry - defaults to "worktree" if not provided
+  const runtimeType = variant === "workspace" ? (props.runtimeType ?? "worktree") : "worktree";
 
   // Storage keys differ by variant
   const storageKeys = (() => {
@@ -1015,7 +1017,13 @@ export const ChatInput: React.FC<ChatInputProps> = (props) => {
           setImageAttachments(previousImageAttachments);
         } else {
           // Track telemetry for successful message send
-          telemetry.messageSent(sendMessageOptions.model, mode, actualMessageText.length);
+          telemetry.messageSent(
+            sendMessageOptions.model,
+            mode,
+            actualMessageText.length,
+            runtimeType,
+            sendMessageOptions.thinkingLevel ?? "off"
+          );
 
           // Exit editing mode if we were editing
           if (editingMessage && props.onCancelEdit) {

src/browser/components/ChatInput/types.ts

@@ -1,5 +1,6 @@
 import type { ImagePart } from "@/common/orpc/types";
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
+import type { TelemetryRuntimeType } from "@/common/telemetry/payload";
 import type { AutoCompactionCheckResult } from "@/browser/utils/compaction/autoCompactionCheck";
 
 export interface ChatInputAPI {
@@ -14,6 +15,8 @@ export interface ChatInputAPI {
 export interface ChatInputWorkspaceVariant {
   variant: "workspace";
   workspaceId: string;
+  /** Runtime type for the workspace (for telemetry) - no sensitive details like SSH host */
+  runtimeType?: TelemetryRuntimeType;
   onMessageSent?: () => void;
   onTruncateHistory: (percentage?: number) => Promise<void>;
   onProviderConfig?: (provider: string, keyPath: string[], value: string) => Promise<void>;

src/browser/hooks/useTelemetry.ts

@@ -1,6 +1,11 @@
 import { useCallback } from "react";
-import { trackEvent, roundToBase2 } from "@/common/telemetry";
-import type { ErrorContext } from "@/common/telemetry/payload";
+import { trackEvent, roundToBase2, getFrontendPlatformInfo } from "@/common/telemetry";
+import type {
+  ErrorContext,
+  TelemetryRuntimeType,
+  TelemetryThinkingLevel,
+  TelemetryCommandType,
+} from "@/common/telemetry/payload";
 
 /**
  * Hook for clean telemetry integration in React components
@@ -16,11 +21,23 @@ import type { ErrorContext } from "@/common/telemetry/payload";
  * // Track workspace switch
  * telemetry.workspaceSwitched(fromId, toId);
  *
- * // Track workspace creation
- * telemetry.workspaceCreated(workspaceId);
+ * // Track workspace creation (runtimeType: 'local' | 'worktree' | 'ssh')
+ * telemetry.workspaceCreated(workspaceId, runtimeType);
  *
  * // Track message sent
- * telemetry.messageSent(model, mode, messageLength);
+ * telemetry.messageSent(model, mode, messageLength, runtimeType, thinkingLevel);
+ *
+ * // Track stream completion
+ * telemetry.streamCompleted(model, wasInterrupted, durationSecs, outputTokens);
+ *
+ * // Track provider configuration
+ * telemetry.providerConfigured(provider, keyType);
+ *
+ * // Track command usage
+ * telemetry.commandUsed(commandType);
+ *
+ * // Track voice transcription
+ * telemetry.voiceTranscription(audioDurationSecs, success);
  *
  * // Track error
  * telemetry.errorOccurred(errorType, context);
@@ -38,24 +55,104 @@ export function useTelemetry() {
     });
   }, []);
 
-  const workspaceCreated = useCallback((workspaceId: string) => {
-    console.debug("[useTelemetry] workspaceCreated called", { workspaceId });
+  const workspaceCreated = useCallback((workspaceId: string, runtimeType: TelemetryRuntimeType) => {
+    const frontendPlatform = getFrontendPlatformInfo();
+    console.debug("[useTelemetry] workspaceCreated called", {
+      workspaceId,
+      runtimeType,
+      frontendPlatform,
+    });
     trackEvent({
       event: "workspace_created",
       properties: {
         workspaceId,
+        runtimeType,
+        frontendPlatform,
       },
     });
   }, []);
 
-  const messageSent = useCallback((model: string, mode: string, messageLength: number) => {
-    console.debug("[useTelemetry] messageSent called", { model, mode, messageLength });
-    trackEvent({
-      event: "message_sent",
-      properties: {
+  const messageSent = useCallback(
+    (
+      model: string,
+      mode: string,
+      messageLength: number,
+      runtimeType: TelemetryRuntimeType,
+      thinkingLevel: TelemetryThinkingLevel
+    ) => {
+      const frontendPlatform = getFrontendPlatformInfo();
+      console.debug("[useTelemetry] messageSent called", {
         model,
         mode,
-        message_length_b2: roundToBase2(messageLength),
+        messageLength,
+        runtimeType,
+        thinkingLevel,
+        frontendPlatform,
+      });
+      trackEvent({
+        event: "message_sent",
+        properties: {
+          model,
+          mode,
+          message_length_b2: roundToBase2(messageLength),
+          runtimeType,
+          frontendPlatform,
+          thinkingLevel,
+        },
+      });
+    },
+    []
+  );
+
+  const streamCompleted = useCallback(
+    (model: string, wasInterrupted: boolean, durationSecs: number, outputTokens: number) => {
+      console.debug("[useTelemetry] streamCompleted called", {
+        model,
+        wasInterrupted,
+        durationSecs,
+        outputTokens,
+      });
+      trackEvent({
+        event: "stream_completed",
+        properties: {
+          model,
+          wasInterrupted,
+          duration_b2: roundToBase2(durationSecs),
+          output_tokens_b2: roundToBase2(outputTokens),
+        },
+      });
+    },
+    []
+  );
+
+  const providerConfigured = useCallback((provider: string, keyType: string) => {
+    console.debug("[useTelemetry] providerConfigured called", { provider, keyType });
+    trackEvent({
+      event: "provider_configured",
+      properties: {
+        provider,
+        keyType,
+      },
+    });
+  }, []);
+
+  const commandUsed = useCallback((command: TelemetryCommandType) => {
+    console.debug("[useTelemetry] commandUsed called", { command });
+    trackEvent({
+      event: "command_used",
+      properties: {
+        command,
+      },
+    });
+  }, []);
+
+  const voiceTranscription = useCallback((audioDurationSecs: number, success: boolean) => {
+    console.debug("[useTelemetry] voiceTranscription called", { audioDurationSecs, success });
+    trackEvent({
+      event: "voice_transcription",
+      properties: {
+        audio_duration_b2: roundToBase2(audioDurationSecs),
+        success,
       },
     });
   }, []);
@@ -75,6 +172,10 @@ export function useTelemetry() {
     workspaceSwitched,
     workspaceCreated,
     messageSent,
+    streamCompleted,
+    providerConfigured,
+    commandUsed,
+    voiceTranscription,
     errorOccurred,
   };
 }

src/browser/hooks/useVoiceInput.ts

@@ -9,6 +9,7 @@
 import { useState, useCallback, useRef, useEffect } from "react";
 import { matchesKeybind, KEYBINDS } from "@/browser/utils/ui/keybinds";
 import type { APIClient } from "@/browser/contexts/API";
+import { trackEvent, roundToBase2 } from "@/common/telemetry";
 
 export type VoiceInputState = "idle" | "recording" | "transcribing";
 
@@ -117,6 +118,9 @@ export function useVoiceInput(options: UseVoiceInputOptions): UseVoiceInputResul
   const shouldSendRef = useRef(false);
   const wasCancelledRef = useRef(false);
 
+  // Track recording start time for duration telemetry
+  const recordingStartTimeRef = useRef<number>(0);
+
   // Keep callbacks fresh without recreating functions
   const callbacksRef = useRef(options);
   useEffect(() => {
@@ -134,6 +138,9 @@ export function useVoiceInput(options: UseVoiceInputOptions): UseVoiceInputResul
     const shouldSend = shouldSendRef.current;
     shouldSendRef.current = false;
 
+    // Calculate recording duration for telemetry
+    const audioDurationSecs = (Date.now() - recordingStartTimeRef.current) / 1000;
+
     try {
       // Encode audio as base64 for IPC transport
       const buffer = await audioBlob.arrayBuffer();
@@ -144,18 +151,41 @@ export function useVoiceInput(options: UseVoiceInputOptions): UseVoiceInputResul
       const api = callbacksRef.current.api;
       if (!api) {
         callbacksRef.current.onError?.("Voice API not available");
+        // Track failed transcription
+        trackEvent({
+          event: "voice_transcription",
+          properties: { audio_duration_b2: roundToBase2(audioDurationSecs), success: false },
+        });
         return;
       }
 
       const result = await api.voice.transcribe({ audioBase64: base64 });
 
       if (!result.success) {
         callbacksRef.current.onError?.(result.error);
+        // Track failed transcription
+        trackEvent({
+          event: "voice_transcription",
+          properties: { audio_duration_b2: roundToBase2(audioDurationSecs), success: false },
+        });
         return;
       }
 
       const text = result.data.trim();
-      if (!text) return; // Empty transcription, nothing to do
+      if (!text) {
+        // Track empty transcription as success (API worked, just no speech)
+        trackEvent({
+          event: "voice_transcription",
+          properties: { audio_duration_b2: roundToBase2(audioDurationSecs), success: true },
+        });
+        return;
+      }
+
+      // Track successful transcription
+      trackEvent({
+        event: "voice_transcription",
+        properties: { audio_duration_b2: roundToBase2(audioDurationSecs), success: true },
+      });
 
       callbacksRef.current.onTranscript(text);
 
@@ -166,6 +196,11 @@ export function useVoiceInput(options: UseVoiceInputOptions): UseVoiceInputResul
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       callbacksRef.current.onError?.(`Transcription failed: ${msg}`);
+      // Track failed transcription
+      trackEvent({
+        event: "voice_transcription",
+        properties: { audio_duration_b2: roundToBase2(audioDurationSecs), success: false },
+      });
     } finally {
       setState("idle");
     }
@@ -235,6 +270,7 @@ export function useVoiceInput(options: UseVoiceInputOptions): UseVoiceInputResul
       recorderRef.current = recorder;
       setMediaRecorder(recorder);
       recorder.start();
+      recordingStartTimeRef.current = Date.now();
       setState("recording");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);