feat: permission prompt overhaul and queue hardening

- Rich tool detail formatting with structured labels, scrollable command preview, and bash descriptions
- Double-submit prevention with loading states and request ID tracking
- Permission queue extracted to pure functions with comprehensive tests
- Graceful handling of stale permission requests via completed ID tracking
- Analytics instrumentation across all engines and IPC handlers

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: OpenSource03

electron/src/ipc/acp-sessions.ts

@@ -8,6 +8,7 @@ import { safeSend } from "../lib/safe-send";
 import { getAgent } from "../lib/agent-registry";
 import { getMcpAuthHeaders } from "../lib/mcp-oauth-flow";
 import { extractErrorMessage } from "../lib/error-utils";
+import { captureEvent } from "../lib/posthog";
 
 // ACP SDK is ESM-only, must be async-imported
 import type { ClientSideConnection } from "@agentclientprotocol/sdk";
@@ -462,6 +463,8 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
       // Startup succeeded — clear the pending tracker before returning
       pendingStartProcess = null;
 
+      void captureEvent("session_created", { engine: "acp" });
+
       return {
         sessionId: internalId,
         agentSessionId: sessionResult.sessionId,
@@ -540,6 +543,7 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
       }
 
       const mcpStatuses = (options.mcpServers ?? []).map(s => ({ name: s.name, status: "connected" as const }));
+      void captureEvent("session_revived", { engine: "acp", success: true });
       return { sessionId: internalId, agentSessionId: acpSessionId, usedLoad, configOptions, mcpStatuses };
     } catch (err) {
       // Kill process and clean up any partial session entry

electron/src/ipc/claude-sessions.ts

@@ -10,6 +10,7 @@ import { getMcpAuthHeaders } from "../lib/mcp-oauth-flow";
 import { getClaudeModelsCache, setClaudeModelsCache } from "../lib/claude-model-cache";
 import { extractErrorMessage } from "../lib/error-utils";
 import { getClaudeBinaryPath, getClaudeBinaryStatus, getClaudeVersion } from "../lib/claude-binary";
+import { captureEvent } from "../lib/posthog";
 
 /** SDK options for file checkpointing — enables Write/Edit/NotebookEdit revert support */
 function fileCheckpointOptions(): Record<string, unknown> {
@@ -186,6 +187,33 @@ function startEventLoop(
           log("EVENT_FULL", message);
         }
         safeSend(getMainWindow, "claude:event", { ...(message as object), _sessionId: sessionId });
+
+        // Track session completion on result events
+        if (msgObj.type === "result") {
+          void captureEvent("session_completed", {
+            engine: "claude",
+            total_cost: msgObj.total_cost_usd,
+            num_turns: msgObj.num_turns,
+            duration_ms: msgObj.duration_ms,
+            is_error: !!msgObj.is_error,
+          });
+        }
+
+        // Track tool execution on tool_result user events
+        if (msgObj.type === "user") {
+          const userMsg = msgObj.message as { content?: unknown } | undefined;
+          const content = userMsg?.content;
+          if (Array.isArray(content) && content[0]?.type === "tool_result") {
+            const isError = !!content[0].is_error;
+            const toolMeta = msgObj.tool_use_result as Record<string, unknown> | undefined;
+            void captureEvent("tool_executed", {
+              engine: "claude",
+              is_error: isError,
+              is_mcp: false,
+              is_async: !!toolMeta?.isAsync,
+            });
+          }
+        }
       }
     } catch (err) {
       queryError = extractErrorMessage(err);
@@ -553,6 +581,12 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
 
       startEventLoop(sessionId, q, session, getMainWindow);
 
+      void captureEvent("session_created", {
+        engine: "claude",
+        model: options.model,
+        is_resume: !!options.resume,
+      });
+
       return { sessionId, pid: 0 };
     } catch (err) {
       // getSDK() or query() threw — clean up and return error
@@ -562,6 +596,7 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
       safeSend(getMainWindow,"claude:exit", {
         code: 1, _sessionId: sessionId, error: errMsg,
       });
+      void captureEvent("session_error", { engine: "claude", phase: "start" });
       return { sessionId, pid: 0, error: errMsg };
     }
   });
@@ -662,6 +697,7 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
         session.startOptions.model = model;
       }
       log("SET_MODEL", "session=" + sessionId.slice(0, 8) + " model=" + model);
+      void captureEvent("model_changed", { engine: "claude", model });
       return { ok: true };
     } catch (err) {
       log("SET_MODEL_ERR", "session=" + sessionId.slice(0, 8) + " model=" + model + " " + extractErrorMessage(err));

electron/src/ipc/codex-sessions.ts

@@ -15,6 +15,7 @@ import { CodexRpcClient } from "../lib/codex-rpc";
 import { getCodexBinaryPath, getCodexBinaryStatus, getCodexVersion } from "../lib/codex-binary";
 import { getAppSetting } from "../lib/app-settings";
 import { extractErrorMessage } from "../lib/error-utils";
+import { captureEvent } from "../lib/posthog";
 
 import type {
   CodexServerNotification,
@@ -346,6 +347,8 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
         session.threadId = threadResult.thread.id;
         log("codex",` Thread started: ${session.threadId}`);
 
+        void captureEvent("session_created", { engine: "codex", model: selectedModel });
+
         return {
           sessionId: internalId,
           threadId: session.threadId,
@@ -355,6 +358,7 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
           needsAuth: false,
         };
       } catch (err) {
+        void captureEvent("session_error", { engine: "codex", phase: "start" });
         log("codex",` Start failed: ${extractErrorMessage(err)}`);
         // Clean up on failure
         const session = codexSessions.get(internalId);
@@ -716,8 +720,10 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
         session.threadId = threadResult.thread.id;
         log("codex",` Thread resumed: ${session.threadId}`);
 
+        void captureEvent("session_revived", { engine: "codex", success: true });
         return { sessionId: internalId, threadId: session.threadId };
       } catch (err) {
+        void captureEvent("session_revived", { engine: "codex", success: false });
         log("codex",` Resume failed: ${extractErrorMessage(err)}`);
         const session = codexSessions.get(internalId);
         if (session) {

electron/src/ipc/files.ts

@@ -5,6 +5,7 @@ import fs from "fs";
 import { log } from "../lib/logger";
 import { ALWAYS_SKIP } from "../lib/git-exec";
 import { getAppSetting } from "../lib/app-settings";
+import { captureEvent } from "../lib/posthog";
 
 function listFilesGit(cwd: string): Promise<string[]> {
   return new Promise((resolve, reject) => {
@@ -301,7 +302,9 @@ export function register(): void {
 
     for (const editor of ordered) {
       try {
-        return await tryEditor(editor);
+        const result = await tryEditor(editor);
+        void captureEvent("file_opened_in_editor", { editor });
+        return result;
       } catch {
         // Editor not found, try next
       }
@@ -310,6 +313,7 @@ export function register(): void {
     // Fallback: OS default
     try {
       await shell.openPath(filePath);
+      void captureEvent("file_opened_in_editor", { editor: "default" });
       return { ok: true, editor: "default" };
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);

electron/src/ipc/git.ts

@@ -2,6 +2,7 @@ import { ipcMain } from "electron";
 import path from "path";
 import fs from "fs";
 import { gitExec, ALWAYS_SKIP } from "../lib/git-exec";
+import { captureEvent } from "../lib/posthog";
 
 interface DiscoveredRepo {
   path: string;
@@ -281,6 +282,7 @@ export function register(): void {
   ipcMain.handle("git:commit", async (_event, { cwd, message }: { cwd: string; message: string }) => {
     try {
       const output = await gitExec(["commit", "-m", message], cwd);
+      void captureEvent("git_commit_created", { message_length: message.length });
       return { ok: true, output };
     } catch (err) {
       return { error: err instanceof Error ? err.message : String(err) };
@@ -333,6 +335,7 @@ export function register(): void {
     try {
       validateRef(branch);
       await gitExec(["checkout", branch], cwd);
+      void captureEvent("git_branch_switched");
       return { ok: true };
     } catch (err) {
       return { error: err instanceof Error ? err.message : String(err) };

electron/src/ipc/mcp.ts

@@ -4,6 +4,7 @@ import { loadMcpServers, addMcpServer, removeMcpServer } from "../lib/mcp-store"
 import { authenticateMcpServer } from "../lib/mcp-oauth-flow";
 import { loadOAuthData, deleteOAuthData } from "../lib/mcp-oauth-store";
 import { log } from "../lib/logger";
+import { captureEvent } from "../lib/posthog";
 import type { McpServerConfig } from "../lib/mcp-store";
 
 interface ProbeResult {
@@ -124,6 +125,7 @@ export function register(): void {
   ipcMain.handle("mcp:add", (_event, { projectId, server }: { projectId: string; server: McpServerConfig }) => {
     try {
       addMcpServer(projectId, server);
+      void captureEvent("mcp_server_added", { transport: server.transport });
       return { ok: true };
     } catch (err) {
       return { error: String(err) };

electron/src/ipc/projects.ts

@@ -4,6 +4,7 @@ import fs from "fs";
 import crypto from "crypto";
 import { getDataDir } from "../lib/data-dir";
 import { log } from "../lib/logger";
+import { captureEvent } from "../lib/posthog";
 
 interface Project {
   id: string;
@@ -66,6 +67,7 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
       };
       projects.push(project);
       writeProjects(projects);
+      void captureEvent("project_created");
       return project;
     } catch (err) {
       log("PROJECTS:CREATE_ERR", (err as Error).message);

electron/src/ipc/terminal.ts

@@ -2,6 +2,7 @@ import { BrowserWindow, ipcMain } from "electron";
 import crypto from "crypto";
 import { log } from "../lib/logger";
 import { safeSend } from "../lib/safe-send";
+import { captureEvent } from "../lib/posthog";
 import {
   appendTerminalHistory,
   EMPTY_TERMINAL_HISTORY,
@@ -71,6 +72,7 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
         destroyed: false,
       };
       terminals.set(terminalId, entry);
+      void captureEvent("terminal_created");
 
       ptyProcess.onData((data: string) => {
         if (entry.destroyed) return;

electron/src/main.ts

@@ -23,7 +23,7 @@ import { log } from "./lib/logger";
 import { migrateFromOpenAcpUi } from "./lib/migration";
 import { glassEnabled, liquidGlass } from "./lib/glass";
 import { initAutoUpdater, getIsInstallingUpdate } from "./lib/updater";
-import { initPostHog, shutdownPostHog, reinitPostHog } from "./lib/posthog";
+import { initPostHog, shutdownPostHog, reinitPostHog, captureEvent } from "./lib/posthog";
 import { sessions } from "./ipc/claude-sessions";
 import { acpSessions } from "./ipc/acp-sessions";
 import { terminals } from "./ipc/terminal";
@@ -196,6 +196,11 @@ onSettingsChanged((settings) => {
   }
 });
 
+// --- Renderer→main analytics bridge ---
+ipcMain.on("analytics:capture", (_event, eventName: string, properties?: Record<string, unknown>) => {
+  captureEvent(eventName, properties).catch(() => { /* non-fatal */ });
+});
+
 // --- DevTools in separate window via remote debugging ---
 let devToolsWindow: BrowserWindow | null = null;
 

electron/src/preload.ts

@@ -271,6 +271,10 @@ contextBridge.exposeInMainWorld("claude", {
     transitionIssue: (params: { instanceUrl: string; issueKey: string; transitionId: string }) =>
       ipcRenderer.invoke("jira:transition-issue", params),
   },
+  analytics: {
+    capture: (event: string, properties?: Record<string, unknown>) =>
+      ipcRenderer.send("analytics:capture", event, properties),
+  },
   speech: {
     startNativeDictation: () => ipcRenderer.invoke("speech:start-native-dictation"),
     getPlatform: () => ipcRenderer.invoke("speech:get-platform"),