diff --git a/.github/ISSUE_TEMPLATE/partner-issue.md b/.github/ISSUE_TEMPLATE/partner-issue.md
new file mode 100644
index 000000000..89a72f6e3
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/partner-issue.md
@@ -0,0 +1,23 @@
+---
+name: Partner issue
+about: Issues reported by partners via support
+title: "[Partner] "
+labels: partner-issue
+assignees: ''
+---
+
+**Partner:**
+
+**Help Scout conversation URL:**
+
+**Priority:** P1 / P2 / P3
+
+**Category:** Bug / Performance / Onboarding / Other
+
+**What they reported:**
+
+**Steps to reproduce:**
+
+**Expected vs. actual behavior:**
+
+**Partner impact (how many affected, what it cost them):**
diff --git a/package.json b/package.json
index 5bed560f8..8cf067022 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,7 @@
         "url": "https://github.com/genesis-ai-dev/codex-editor"
     },
     "license": "MIT",
-    "version": "0.22.0",
+    "version": "0.24.0",
     "engines": {
         "node": ">=18.0.0",
         "vscode": "^1.78.0"
@@ -203,6 +203,11 @@
                 "title": "Advanced Tool Settings",
                 "category": "Codex Editor"
             },
+            {
+                "command": "codex-editor-extension.toggleTelemetry",
+                "title": "Toggle Telemetry (PostHog)",
+                "category": "Codex Editor"
+            },
             {
                 "command": "codex-editor-extension.forceReindex",
                 "title": "Force Reindex",
@@ -892,6 +897,18 @@
                         "default": "",
                         "description": "Limits context building to specified books. Leave empty to include all. We recommend to leave empty for best results."
                     },
+                    "codex-editor-extension.telemetryEnabled": {
+                        "title": "Enable Telemetry",
+                        "type": "boolean",
+                        "default": true,
+                        "description": "When enabled, anonymous usage telemetry and error reports are sent via PostHog to help improve the editor."
+                    },
+                    "codex-editor-extension.sessionRecordingEnabled": {
+                        "title": "Session Recording",
+                        "type": "boolean",
+                        "default": false,
+                        "description": "When enabled, session replays are buffered locally and only sent when an error occurs, to help diagnose issues."
+                    },
                     "codex-editor-extension.debugMode": {
                         "title": "Debugging Mode",
                         "type": "boolean",
@@ -1133,6 +1150,7 @@
         "pdf-parse": "^1.1.1",
         "pdfjs-dist": "4.0.379",
         "pnpm": "^8.15.5",
+        "posthog-node": "^5.21.2",
         "proc-log": "^5.0.0",
         "react-wordcloud": "^1.2.7",
         "sax": "^1.4.1",
diff --git a/src/activationHelpers/contextAware/commands.ts b/src/activationHelpers/contextAware/commands.ts
index 990b6241f..a721290ee 100644
--- a/src/activationHelpers/contextAware/commands.ts
+++ b/src/activationHelpers/contextAware/commands.ts
@@ -364,5 +364,25 @@ export async function registerCommands(context: vscode.ExtensionContext) {
         testProjectLoadingPerformanceCommand,
         migrateAudioFilesCommand,
 
+        vscode.commands.registerCommand(
+            "codex-editor-extension.toggleTelemetry",
+            async () => {
+                const config = vscode.workspace.getConfiguration("codex-editor-extension");
+                const current = config.get<boolean>("telemetryEnabled", true);
+                const next = !current;
+
+                await config.update("telemetryEnabled", next, vscode.ConfigurationTarget.Global);
+
+                const label = next ? "enabled" : "disabled";
+                const action = await vscode.window.showInformationMessage(
+                    `Telemetry has been ${label}. Reload the window to apply the change.`,
+                    "Reload Window"
+                );
+
+                if (action === "Reload Window") {
+                    await vscode.commands.executeCommand("workbench.action.reloadWindow");
+                }
+            }
+        ),
     );
 }
diff --git a/src/cellLabelImporter/cellLabelImporter.ts b/src/cellLabelImporter/cellLabelImporter.ts
index 0b8df32d8..4dd928b93 100644
--- a/src/cellLabelImporter/cellLabelImporter.ts
+++ b/src/cellLabelImporter/cellLabelImporter.ts
@@ -12,6 +12,7 @@ import { matchCellLabels } from "./matcher";
 import { copyToTempStorage, getColumnHeaders } from "./utils";
 import { updateCellLabels } from "./updater";
 import { getNonce } from "../utils/getNonce";
+import { getPostHogWebviewScript } from "../utils/telemetry";
 import { safePostMessageToPanel } from "../utils/webviewUtils";
 
 const DEBUG_CELL_LABEL_IMPORTER = false;
@@ -122,7 +123,8 @@ async function getHtmlForCellLabelImporterView(
                 img-src ${webview.cspSource} https: data:;
                 style-src ${webview.cspSource} 'unsafe-inline'; 
                 script-src 'nonce-${nonce}';
-                font-src ${webview.cspSource};">
+                font-src ${webview.cspSource};
+                connect-src https://*.posthog.com https://*.i.posthog.com;">
             <link href="${styleResetUri}" rel="stylesheet">
             <link href="${codiconsUri}" rel="stylesheet">
             
@@ -136,6 +138,7 @@ async function getHtmlForCellLabelImporterView(
         </head>
         <body>
             <div id="root"></div>
+            ${getPostHogWebviewScript(nonce, "CellLabelImporter")}
             <script nonce="${nonce}" src="${scriptUri}"></script>
         </body>
         </html>`;
diff --git a/src/codexMigrationTool/codexMigrationTool.ts b/src/codexMigrationTool/codexMigrationTool.ts
index c1866dad9..61f57109a 100644
--- a/src/codexMigrationTool/codexMigrationTool.ts
+++ b/src/codexMigrationTool/codexMigrationTool.ts
@@ -1,6 +1,7 @@
 import * as vscode from "vscode";
 import * as path from "path";
 import { getNonce } from "../utils/getNonce";
+import { getPostHogWebviewScript } from "../utils/telemetry";
 import { safePostMessageToPanel } from "../utils/webviewUtils";
 import { matchMigrationCells } from "./matcher";
 import { applyMigrationToTargetFile } from "./updater";
@@ -50,7 +51,8 @@ async function getHtmlForCodexMigrationToolView(
                 img-src ${webview.cspSource} https: data:;
                 style-src ${webview.cspSource} 'unsafe-inline';
                 script-src 'nonce-${nonce}';
-                font-src ${webview.cspSource};">
+                font-src ${webview.cspSource};
+                connect-src https://*.posthog.com https://*.i.posthog.com;">
             <link href="${styleResetUri}" rel="stylesheet">
             <link href="${codiconsUri}" rel="stylesheet">
             <script nonce="${nonce}">
@@ -59,6 +61,7 @@ async function getHtmlForCodexMigrationToolView(
         </head>
         <body>
             <div id="root"></div>
+            ${getPostHogWebviewScript(nonce, "CodexMigrationTool")}
             <script nonce="${nonce}" src="${scriptUri}"></script>
         </body>
         </html>`;
diff --git a/src/copilotSettings/copilotSettings.ts b/src/copilotSettings/copilotSettings.ts
index e1e012a3b..3058a97da 100644
--- a/src/copilotSettings/copilotSettings.ts
+++ b/src/copilotSettings/copilotSettings.ts
@@ -2,6 +2,7 @@ import * as vscode from "vscode";
 import { callLLM } from "../utils/llmUtils";
 import { CompletionConfig } from "@/utils/llmUtils";
 import { MetadataManager } from "../utils/metadataManager";
+import { getPostHogWebviewScript } from "../utils/telemetry";
 
 interface ProjectLanguage {
     tag: string;
@@ -68,6 +69,7 @@ export async function openSystemMessageEditor() {
       </head>
       <body>
         <div id="root"></div>
+        ${getPostHogWebviewScript(nonce, "CopilotSettings")}
         <script nonce="${nonce}" src="${scriptUri}"></script>
       </body>
     </html>`;
diff --git a/src/extension.ts b/src/extension.ts
index 6b8b7a6fe..912bb08ef 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -64,10 +64,11 @@ import { initializeAudioMerger } from "./utils/audioMerger";
 import { initializeAudioExtractor } from "./utils/audioExtractor";
 import { initializeAudioExporter } from "./exportHandler/audioExporter";
 import { checkTools, getUnavailableTools } from "./utils/toolsManager";
-import { initToolPreferences, setNativeGitAvailable, getGitToolMode, getSqliteToolMode } from "./utils/toolPreferences";
+import { initToolPreferences, setNativeGitAvailable, getGitToolMode, getSqliteToolMode, getAudioToolMode } from "./utils/toolPreferences";
 import { downloadFFmpeg } from "./utils/ffmpegManager";
 import { MissingToolsWarningProvider } from "./providers/MissingToolsWarning/MissingToolsWarningProvider";
 import { cleanupOrphanedProjectFiles } from "./utils/fileUtils";
+import { initTelemetry, shutdownTelemetry, captureException, captureEvent } from "./utils/telemetry";
 // markUserAsUpdatedInRemoteList is now called in performProjectUpdate before window reload
 import * as fs from "fs";
 import * as os from "os";
@@ -337,6 +338,18 @@ export async function activate(context: vscode.ExtensionContext) {
         // Continue with activation even if splash screen fails
     }
 
+    initTelemetry();
+
+    process.on("uncaughtException", (error) => {
+        console.error("[Extension] Uncaught exception:", error);
+        captureException(error, { source: "uncaughtException" });
+    });
+
+    process.on("unhandledRejection", (reason) => {
+        console.error("[Extension] Unhandled rejection:", reason);
+        captureException(reason, { source: "unhandledRejection" });
+    });
+
     let stepStart = activationStart;
 
     try {
@@ -402,6 +415,13 @@ export async function activate(context: vscode.ExtensionContext) {
         const gitMode = getGitToolMode();
         const effectiveBackend = gitMode === "builtin" ? "isomorphic-git (forced)" : gitAvailable ? "dugite (native)" : "isomorphic-git (no binary)";
         console.log(`[codex] Git backend mode: ${gitMode}, effective: ${effectiveBackend}`);
+        if (!gitAvailable || gitMode === "builtin") {
+            captureEvent("tool_fallback_used", {
+                tool: "git",
+                reason: gitMode === "builtin" ? "user_preference_builtin" : "binary_unavailable",
+                mode: gitMode,
+            });
+        }
         stepStart = finishRealtimeStep();
 
         // If metadata.json is missing but the workspace has a .git with a remote,
@@ -505,6 +525,11 @@ export async function activate(context: vscode.ExtensionContext) {
                 await initFts5Sqlite(context);
                 const reason = sqliteMode === "builtin" ? "user preference" : "native unavailable";
                 console.log(`[SQLite] fts5-sql-bundle (WASM) initialized (${reason})`);
+                captureEvent("tool_fallback_used", {
+                    tool: "sqlite",
+                    reason: sqliteMode === "builtin" ? "user_preference_builtin" : "native_load_failed",
+                    mode: sqliteMode,
+                });
             } catch (fallbackError: any) {
                 if (!nativeLoaded) {
                     console.error("[SQLite] Both native and fts5 fallback failed:", fallbackError?.message || fallbackError);
@@ -550,6 +575,14 @@ export async function activate(context: vscode.ExtensionContext) {
             `[Extension] Tools status — git: ${ok(toolCheckResult.git)}, sqlite: ${ok(toolCheckResult.sqlite)}, ffmpeg: ${ok(toolCheckResult.ffmpeg)}`
         );
 
+        if (!toolCheckResult.ffmpeg) {
+            captureEvent("tool_fallback_used", {
+                tool: "audio",
+                reason: "ffmpeg_unavailable",
+                mode: getAudioToolMode(),
+            });
+        }
+
         // When offline, non-critical tools (git, audio) being unavailable is
         // expected and not actionable -- skip the blocking warning panel.
         const hasCriticalMissing = !toolCheckResult.sqlite;
@@ -1534,6 +1567,8 @@ export async function deactivate() {
         currentStepTimer = null;
     }
 
+    await shutdownTelemetry();
+
     // Close the index manager's database connection and clear the global reference
     try {
         const { clearSQLiteIndexManager } = await import(
diff --git a/src/globalProvider.ts b/src/globalProvider.ts
index e213a3359..0f54cd656 100644
--- a/src/globalProvider.ts
+++ b/src/globalProvider.ts
@@ -3,6 +3,7 @@ import { CodexCellEditorProvider } from "./providers/codexCellEditorProvider/cod
 import { CustomWebviewProvider } from "./providers/parallelPassagesWebview/customParallelPassagesWebviewProvider";
 import { GlobalContentType, GlobalMessage } from "../types";
 import { getNonce } from "./utils/getNonce";
+import { getPostHogWebviewScript } from "./utils/telemetry";
 import { safePostMessageToView } from "./utils/webviewUtils";
 
 
@@ -137,6 +138,7 @@ export abstract class BaseWebviewProvider implements vscode.WebviewViewProvider
         </head>
         <body>
             <div id="root"></div>
+            ${getPostHogWebviewScript(nonce, this.getScriptPath()[0])}
             <script nonce="${nonce}" src="${scriptUri}"></script>
         </body>
         </html>`;
diff --git a/src/projectManager/utils/merge/resolvers.ts b/src/projectManager/utils/merge/resolvers.ts
index 89df804a8..d0f6b3d16 100644
--- a/src/projectManager/utils/merge/resolvers.ts
+++ b/src/projectManager/utils/merge/resolvers.ts
@@ -237,7 +237,7 @@ function mergeProjectSwap(
  * Merges originalFilesHashes registries from base, ours, and theirs.
  * Union by hash: combine all entries. For same hash, merge referencedBy and originalNames.
  */
-function mergeOriginalFilesHashes(
+export function mergeOriginalFilesHashes(
     base: { version?: number; files?: Record<string, any>; fileNameToHash?: Record<string, string> } | undefined,
     ours: { version?: number; files?: Record<string, any>; fileNameToHash?: Record<string, string> } | undefined,
     theirs: { version?: number; files?: Record<string, any>; fileNameToHash?: Record<string, string> } | undefined
diff --git a/src/providers/MissingToolsWarning/MissingToolsWarningProvider.ts b/src/providers/MissingToolsWarning/MissingToolsWarningProvider.ts
index 9aa53af4a..4ae3cd22d 100644
--- a/src/providers/MissingToolsWarning/MissingToolsWarningProvider.ts
+++ b/src/providers/MissingToolsWarning/MissingToolsWarningProvider.ts
@@ -6,6 +6,7 @@ import { safePostMessageToPanel } from "../../utils/webviewUtils";
 import type { ToolCheckResult } from "../../utils/toolsManager";
 import { getAudioToolMode, getGitToolMode, getSqliteToolMode } from "../../utils/toolPreferences";
 import { resetRetryCount } from "../../utils/binaryIntegrityUtils";
+import { captureEvent } from "../../utils/telemetry";
 import type {
     MessagesToMissingToolsWarning,
     MessagesFromMissingToolsWarning,
@@ -274,6 +275,9 @@ export class MissingToolsWarningProvider {
         const { setAudioToolMode } = await import("../../utils/toolPreferences");
         const current = getAudioToolMode();
         const next = current === "auto" ? "builtin" : "auto";
+        if (next === "builtin") {
+            captureEvent("tool_fallback_used", { tool: "audio", reason: "user_chose_fallback", mode: next });
+        }
         await setAudioToolMode(next);
 
         const { checkTools } = await import("../../utils/toolsManager");
@@ -292,6 +296,9 @@ export class MissingToolsWarningProvider {
         const { setGitToolMode } = await import("../../utils/toolPreferences");
         const current = getGitToolMode();
         const next = current === "auto" ? "builtin" : "auto";
+        if (next === "builtin") {
+            captureEvent("tool_fallback_used", { tool: "git", reason: "user_chose_fallback", mode: next });
+        }
         await setGitToolMode(next);
 
         const { checkTools } = await import("../../utils/toolsManager");
@@ -324,6 +331,9 @@ export class MissingToolsWarningProvider {
         const { setSqliteToolMode } = await import("../../utils/toolPreferences");
         const current = getSqliteToolMode();
         const next = current === "auto" ? "builtin" : "auto";
+        if (next === "builtin") {
+            captureEvent("tool_fallback_used", { tool: "sqlite", reason: "user_chose_fallback", mode: next });
+        }
 
         // If switching to the WASM fallback, ensure it's initialized
         if (next === "builtin") {
diff --git a/src/providers/SplashScreen/SplashScreenProvider.ts b/src/providers/SplashScreen/SplashScreenProvider.ts
index 9395fe298..76e537916 100644
--- a/src/providers/SplashScreen/SplashScreenProvider.ts
+++ b/src/providers/SplashScreen/SplashScreenProvider.ts
@@ -166,7 +166,7 @@ export class SplashScreenProvider {
         return getWebviewHtml(webview, { extensionUri: this._extensionUri } as vscode.ExtensionContext, {
             title: "Codex Editor Loading",
             scriptPath: ["SplashScreen", "index.js"],
-            csp: `default-src 'none'; style-src ${webview.cspSource} 'unsafe-inline'; script-src 'nonce-\${nonce}' 'strict-dynamic' https://static.cloudflareinsights.com; worker-src ${webview.cspSource} blob:; connect-src https://*.vscode-cdn.net https://*.frontierrnd.com; img-src ${webview.cspSource} https: data:; font-src ${webview.cspSource}; media-src ${webview.cspSource} https: blob:;`,
+            csp: `default-src 'none'; style-src ${webview.cspSource} 'unsafe-inline'; script-src 'nonce-\${nonce}' 'strict-dynamic' https://static.cloudflareinsights.com; worker-src ${webview.cspSource} blob:; connect-src https://*.vscode-cdn.net https://*.frontierrnd.com https://*.posthog.com https://*.i.posthog.com; img-src ${webview.cspSource} https: data:; font-src ${webview.cspSource}; media-src ${webview.cspSource} https: blob:;`,
             initialData: { timings: this._timings, syncDetails: this._syncDetails },
             inlineStyles: `
                 body { margin: 0; padding: 0; height: 100vh; width: 100vw; overflow: hidden; background-color: var(--vscode-editor-background); color: var(--vscode-foreground); font-family: var(--vscode-font-family); }
diff --git a/src/providers/VideoPlayer/VideoPlayerProvider.ts b/src/providers/VideoPlayer/VideoPlayerProvider.ts
index 31513e93b..afa5a8a20 100644
--- a/src/providers/VideoPlayer/VideoPlayerProvider.ts
+++ b/src/providers/VideoPlayer/VideoPlayerProvider.ts
@@ -50,7 +50,7 @@ export class VideoPlayerProvider
         return getWebviewHtml(webview, this.context, {
             title: "Codex Video Player",
             scriptPath: ["VideoPlayer", "index.js"],
-            csp: `default-src 'none'; style-src ${webview.cspSource} 'unsafe-inline'; script-src 'nonce-\${nonce}' https://static.cloudflareinsights.com; connect-src https://*.vscode-cdn.net https://*.frontierrnd.com; worker-src ${webview.cspSource}; img-src ${webview.cspSource} https:; font-src ${webview.cspSource};`
+            csp: `default-src 'none'; style-src ${webview.cspSource} 'unsafe-inline'; script-src 'nonce-\${nonce}' https://static.cloudflareinsights.com; connect-src https://*.vscode-cdn.net https://*.frontierrnd.com https://*.posthog.com https://*.i.posthog.com; worker-src ${webview.cspSource}; img-src ${webview.cspSource} https:; font-src ${webview.cspSource};`
         });
     }
 }
diff --git a/src/providers/codexCellEditorProvider/codexCellEditorMessagehandling.ts b/src/providers/codexCellEditorProvider/codexCellEditorMessagehandling.ts
index a561b9e22..68abe3ff1 100644
--- a/src/providers/codexCellEditorProvider/codexCellEditorMessagehandling.ts
+++ b/src/providers/codexCellEditorProvider/codexCellEditorMessagehandling.ts
@@ -102,6 +102,14 @@ async function withErrorHandling<T>(
     }
 }
 
+async function safeExecuteSmartEditCommand<T>(commandId: string, ...args: unknown[]): Promise<T | null> {
+    const allCommands = await vscode.commands.getCommands(true);
+    if (!allCommands.includes(commandId)) {
+        return null;
+    }
+    return vscode.commands.executeCommand<T>(commandId, ...args);
+}
+
 // Message handler context type
 interface MessageHandlerContext {
     event: EditorPostMessages;
@@ -1248,7 +1256,7 @@ const messageHandlers: Record<string, (ctx: MessageHandlerContext) => Promise<vo
 
     generateBacktranslation: async ({ event, webviewPanel, provider, document }) => {
         const typedEvent = event as Extract<EditorPostMessages, { command: "generateBacktranslation"; }>;
-        const backtranslation = await vscode.commands.executeCommand<SavedBacktranslation | null>(
+        const backtranslation = await safeExecuteSmartEditCommand<SavedBacktranslation | null>(
             "codex-smart-edits.generateBacktranslation",
             typedEvent.content.text,
             typedEvent.content.cellId,
@@ -1262,7 +1270,7 @@ const messageHandlers: Record<string, (ctx: MessageHandlerContext) => Promise<vo
 
     editBacktranslation: async ({ event, webviewPanel, provider, document }) => {
         const typedEvent = event as Extract<EditorPostMessages, { command: "editBacktranslation"; }>;
-        const updatedBacktranslation = await vscode.commands.executeCommand<SavedBacktranslation | null>(
+        const updatedBacktranslation = await safeExecuteSmartEditCommand<SavedBacktranslation | null>(
             "codex-smart-edits.editBacktranslation",
             typedEvent.content.cellId,
             typedEvent.content.newText,
@@ -1277,7 +1285,7 @@ const messageHandlers: Record<string, (ctx: MessageHandlerContext) => Promise<vo
 
     getBacktranslation: async ({ event, webviewPanel, provider }) => {
         const typedEvent = event as Extract<EditorPostMessages, { command: "getBacktranslation"; }>;
-        const backtranslation = await vscode.commands.executeCommand<SavedBacktranslation | null>(
+        const backtranslation = await safeExecuteSmartEditCommand<SavedBacktranslation | null>(
             "codex-smart-edits.getBacktranslation",
             typedEvent.content.cellId
         );
@@ -1291,10 +1299,9 @@ const messageHandlers: Record<string, (ctx: MessageHandlerContext) => Promise<vo
         const typedEvent = event as Extract<EditorPostMessages, { command: "getBatchBacktranslations"; }>;
         const cellIds = typedEvent.content.cellIds;
 
-        // Fetch backtranslations for all cell IDs
         const backtranslations: { [cellId: string]: SavedBacktranslation | null; } = {};
         for (const cellId of cellIds) {
-            const backtranslation = await vscode.commands.executeCommand<SavedBacktranslation | null>(
+            const backtranslation = await safeExecuteSmartEditCommand<SavedBacktranslation | null>(
                 "codex-smart-edits.getBacktranslation",
                 cellId
             );
@@ -1309,7 +1316,7 @@ const messageHandlers: Record<string, (ctx: MessageHandlerContext) => Promise<vo
 
     setBacktranslation: async ({ event, webviewPanel, provider, document }) => {
         const typedEvent = event as Extract<EditorPostMessages, { command: "setBacktranslation"; }>;
-        const backtranslation = await vscode.commands.executeCommand<SavedBacktranslation | null>(
+        const backtranslation = await safeExecuteSmartEditCommand<SavedBacktranslation | null>(
             "codex-smart-edits.setBacktranslation",
             typedEvent.content.cellId,
             typedEvent.content.originalText,
diff --git a/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts b/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts
index 3580cd06a..17faa20fa 100755
--- a/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts
+++ b/src/providers/codexCellEditorProvider/codexCellEditorProvider.ts
@@ -28,6 +28,7 @@ import { SyncManager } from "../../projectManager/syncManager";
 
 import bibleData from "../../../webviews/codex-webviews/src/assets/bible-books-lookup.json";
 import { getNonce } from "../../utils/getNonce";
+import { getPostHogWebviewScript } from "../../utils/telemetry";
 import { safePostMessageToPanel } from "../../utils/webviewUtils";
 import path from "path";
 import * as fs from "fs";
@@ -1541,7 +1542,7 @@ export class CodexCellEditorProvider implements vscode.CustomEditorProvider<Code
             <head>
                 <meta charset="UTF-8">
                 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-                <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src ${webview.cspSource} 'unsafe-inline'; script-src 'nonce-${nonce}' 'strict-dynamic' https://www.youtube.com https://static.cloudflareinsights.com; frame-src https://www.youtube.com; worker-src ${webview.cspSource} blob:; connect-src https://*.vscode-cdn.net https://*.frontierrnd.com wss://*.frontierrnd.com https://languagetool.org/api/ https://*.workers.dev data: wss://ryderwishart--whisper-websocket-transcription-websocket-transcribe.modal.run wss://*.modal.run; img-src 'self' data: ${webview.cspSource} https:; font-src ${webview.cspSource} data:; media-src ${webview.cspSource} https: blob: data:;">
+                <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src ${webview.cspSource} 'unsafe-inline'; script-src 'nonce-${nonce}' 'strict-dynamic' https://www.youtube.com https://static.cloudflareinsights.com; frame-src https://www.youtube.com; worker-src ${webview.cspSource} blob:; connect-src https://*.vscode-cdn.net https://*.frontierrnd.com wss://*.frontierrnd.com https://languagetool.org/api/ https://*.workers.dev data: wss://ryderwishart--whisper-websocket-transcription-websocket-transcribe.modal.run wss://*.modal.run https://*.posthog.com https://*.i.posthog.com; img-src 'self' data: ${webview.cspSource} https:; font-src ${webview.cspSource} data:; media-src ${webview.cspSource} https: blob: data:;">
                 <link href="${styleResetUriWithBuster}" rel="stylesheet" nonce="${nonce}">
                 <link href="${codiconsUriWithBuster}" rel="stylesheet" nonce="${nonce}" />
                 <title>Codex Cell Editor</title>
@@ -1561,6 +1562,7 @@ export class CodexCellEditorProvider implements vscode.CustomEditorProvider<Code
             </head>
             <body>
                 <div id="root"></div>
+                ${getPostHogWebviewScript(nonce, "CodexCellEditor")}
                 <script nonce="${nonce}" src="${scriptUriWithBuster}"></script>
                 
                 <style>
diff --git a/src/providers/mainMenu/mainMenuProvider.ts b/src/providers/mainMenu/mainMenuProvider.ts
index a8010b99b..90a8c34a1 100644
--- a/src/providers/mainMenu/mainMenuProvider.ts
+++ b/src/providers/mainMenu/mainMenuProvider.ts
@@ -480,6 +480,28 @@ export class MainMenuProvider extends BaseWebviewProvider {
         safePostMessageToView(this._view, { command: "actionCompleted" }, "MainMenu");
     }
 
+    private sendSessionRecordingSetting() {
+        const enabled = vscode.workspace
+            .getConfiguration("codex-editor-extension")
+            .get<boolean>("sessionRecordingEnabled", false);
+
+        if (this._view) {
+            safePostMessageToView(
+                this._view,
+                { command: "sessionRecordingUpdate", data: { enabled } },
+                "MainMenu",
+            );
+        }
+    }
+
+    private async toggleSessionRecording() {
+        const config = vscode.workspace.getConfiguration("codex-editor-extension");
+        const current = config.get<boolean>("sessionRecordingEnabled", false);
+        await config.update("sessionRecordingEnabled", !current, vscode.ConfigurationTarget.Global);
+        this.sendSessionRecordingSetting();
+        await vscode.commands.executeCommand("workbench.action.reloadWindow");
+    }
+
     private async sendSyncSettings() {
         const { getSyncSettings } = await import("../../utils/localProjectSettings");
         const { autoSyncEnabled, syncDelayMinutes } = await getSyncSettings();
@@ -590,6 +612,7 @@ export class MainMenuProvider extends BaseWebviewProvider {
             case "webviewReady":
                 await this.updateProjectOverview();
                 await this.updateWebviewState();
+                this.sendSessionRecordingSetting();
                 break;
             case "openProject":
                 if (message.data?.path) {
@@ -635,6 +658,12 @@ export class MainMenuProvider extends BaseWebviewProvider {
             case "openEditAnalysis":
                 await vscode.commands.executeCommand("codex-editor-extension.analyzeEdits");
                 break;
+            case "getSessionRecordingSetting":
+                this.sendSessionRecordingSetting();
+                break;
+            case "toggleSessionRecording":
+                await this.toggleSessionRecording();
+                break;
             case "setGlobalFontSize":
                 await this.handleSetGlobalFontSize();
                 break;
diff --git a/src/providers/navigationWebview/navigationWebviewProvider.ts b/src/providers/navigationWebview/navigationWebviewProvider.ts
index 91e8ef6e4..41ded7e7f 100644
--- a/src/providers/navigationWebview/navigationWebviewProvider.ts
+++ b/src/providers/navigationWebview/navigationWebviewProvider.ts
@@ -433,7 +433,7 @@ export class NavigationWebviewProvider extends BaseWebviewProvider {
     protected getHtmlForWebview(webviewView: vscode.WebviewView): string {
         return getWebviewHtml(webviewView.webview, this._context, {
             scriptPath: this.getScriptPath(),
-            csp: `default-src 'none'; img-src ${webviewView.webview.cspSource} https: data:; style-src ${webviewView.webview.cspSource} 'unsafe-inline'; script-src 'nonce-\${nonce}' https://static.cloudflareinsights.com; connect-src https://*.vscode-cdn.net https://*.frontierrnd.com; font-src ${webviewView.webview.cspSource};`,
+            csp: `default-src 'none'; img-src ${webviewView.webview.cspSource} https: data:; style-src ${webviewView.webview.cspSource} 'unsafe-inline'; script-src 'nonce-\${nonce}' https://static.cloudflareinsights.com; connect-src https://*.vscode-cdn.net https://*.frontierrnd.com https://*.posthog.com https://*.i.posthog.com; font-src ${webviewView.webview.cspSource};`,
             inlineStyles: `
                 .progress-container { margin: 6px 0; }
                 .progress-label { display: flex; justify-content: space-between; margin-bottom: 4px; font-size: 12px; color: var(--vscode-foreground); opacity: 0.8; }
diff --git a/src/test/suite/codexCellEditorProvider.test.ts b/src/test/suite/codexCellEditorProvider.test.ts
index c1eee0c4f..81a780425 100644
--- a/src/test/suite/codexCellEditorProvider.test.ts
+++ b/src/test/suite/codexCellEditorProvider.test.ts
@@ -3042,9 +3042,9 @@ suite("CodexCellEditorProvider Test Suite", () => {
         // Then, perform search/replace with retainValidations=true (simulating updateCellContentDirect with retainValidations=true)
         await (document as any).updateCellContent(cellId, "Replaced value", EditType.USER_EDIT, true, true, true);
 
-        // Persist to disk to assert the stored structure
+        // Persist to disk to assert the stored structure (retry to handle Windows filesystem flush timing)
         await provider.saveCustomDocument(document, new vscode.CancellationTokenSource().token);
-        const diskData = JSON.parse(new TextDecoder().decode(await vscode.workspace.fs.readFile(document.uri)));
+        const diskData = await readJsonFromDiskWithRetry(document.uri);
         const diskCell = diskData.cells.find((c: any) => c.metadata.id === cellId);
 
         // Latest value edit should have a NEW validation entry (not copied from old)
diff --git a/src/test/suite/metadataManager.test.ts b/src/test/suite/metadataManager.test.ts
index 8c55857df..5293b6029 100644
--- a/src/test/suite/metadataManager.test.ts
+++ b/src/test/suite/metadataManager.test.ts
@@ -5,14 +5,6 @@ import * as fs from 'fs';
 import { MetadataManager } from '../../utils/metadataManager';
 
 suite('MetadataManager Tests', () => {
-    // Temporarily disable these tests until VS Code test environment issues are resolved
-    test('MetadataManager integration tests temporarily disabled', () => {
-        console.log('MetadataManager tests are temporarily disabled due to VS Code test environment compatibility issues.');
-        console.log('The MetadataManager system is fully integrated and functional in production.');
-        console.log('These tests can be run in a standalone Node.js environment for validation.');
-    });
-    return; // Exit early to skip all tests in this suite
-
     let testWorkspaceUri: vscode.Uri;
     let metadataPath: vscode.Uri;
 
@@ -223,6 +215,84 @@ suite('MetadataManager Tests', () => {
         });
     });
 
+    suite('Pin-aware ratchet', () => {
+        test('ratchet works normally when no pin is active', async () => {
+            const initial = {
+                meta: { requiredExtensions: { codexEditor: '0.22.0' } }
+            };
+            await vscode.workspace.fs.writeFile(metadataPath,
+                new TextEncoder().encode(JSON.stringify(initial, null, 4)));
+
+            const result = await MetadataManager.updateExtensionVersions(testWorkspaceUri, {
+                codexEditor: '0.22.91'
+            });
+
+            assert.strictEqual(result.success, true);
+            const versions = await MetadataManager.getExtensionVersions(testWorkspaceUri);
+            assert.strictEqual(versions.versions?.codexEditor, '0.22.91');
+        });
+
+        test('ratchet is suppressed for codexEditor when pin is active', async () => {
+            const initial = {
+                meta: {
+                    requiredExtensions: { codexEditor: '0.22.90' },
+                    pinnedExtensions: { 'project-accelerate.codex-editor-extension': { version: '0.22.90' } }
+                }
+            };
+            await vscode.workspace.fs.writeFile(metadataPath,
+                new TextEncoder().encode(JSON.stringify(initial, null, 4)));
+
+            const result = await MetadataManager.updateExtensionVersions(testWorkspaceUri, {
+                codexEditor: '0.22.91'
+            });
+
+            assert.strictEqual(result.success, true);
+            const versions = await MetadataManager.getExtensionVersions(testWorkspaceUri);
+            // Should NOT have been bumped to .91
+            assert.strictEqual(versions.versions?.codexEditor, '0.22.90');
+        });
+
+        test('ratchet is suppressed for frontierAuthentication when frontier pin is active', async () => {
+            const initial = {
+                meta: {
+                    requiredExtensions: { frontierAuthentication: '0.4.0' },
+                    pinnedExtensions: { 'frontier-rnd.frontier-authentication': { version: '0.4.0' } }
+                }
+            };
+            await vscode.workspace.fs.writeFile(metadataPath,
+                new TextEncoder().encode(JSON.stringify(initial, null, 4)));
+
+            const result = await MetadataManager.updateExtensionVersions(testWorkspaceUri, {
+                frontierAuthentication: '0.4.25'
+            });
+
+            assert.strictEqual(result.success, true);
+            const versions = await MetadataManager.getExtensionVersions(testWorkspaceUri);
+            assert.strictEqual(versions.versions?.frontierAuthentication, '0.4.0');
+        });
+
+        test('frontierAuthentication ratchet is unaffected by a codex-editor pin', async () => {
+            const initial = {
+                meta: {
+                    requiredExtensions: { codexEditor: '0.22.90', frontierAuthentication: '0.4.0' },
+                    pinnedExtensions: { 'project-accelerate.codex-editor-extension': { version: '0.22.90' } }
+                }
+            };
+            await vscode.workspace.fs.writeFile(metadataPath,
+                new TextEncoder().encode(JSON.stringify(initial, null, 4)));
+
+            const result = await MetadataManager.updateExtensionVersions(testWorkspaceUri, {
+                codexEditor: '0.22.91',
+                frontierAuthentication: '0.4.25'
+            });
+
+            assert.strictEqual(result.success, true);
+            const versions = await MetadataManager.getExtensionVersions(testWorkspaceUri);
+            assert.strictEqual(versions.versions?.codexEditor, '0.22.90');       // suppressed
+            assert.strictEqual(versions.versions?.frontierAuthentication, '0.4.25'); // ratcheted
+        });
+    });
+
     suite('Performance', () => {
         test('should complete updates within reasonable time', async () => {
             const startTime = Date.now();
diff --git a/src/test/suite/resolvers/mergeOriginalFilesHashes.test.ts b/src/test/suite/resolvers/mergeOriginalFilesHashes.test.ts
new file mode 100644
index 000000000..0a9acb436
--- /dev/null
+++ b/src/test/suite/resolvers/mergeOriginalFilesHashes.test.ts
@@ -0,0 +1,234 @@
+import * as assert from "assert";
+import { mergeOriginalFilesHashes } from "../../../projectManager/utils/merge/resolvers";
+
+type HashRegistryInput = Parameters<typeof mergeOriginalFilesHashes>[0];
+
+const makeEntry = (hash: string, fileName: string, referencedBy: string[], originalNames: string[] = [fileName], addedAt = new Date().toISOString()) => ({
+    hash,
+    fileName,
+    originalNames,
+    referencedBy,
+    addedAt,
+});
+
+const makeRegistry = (
+    files: Record<string, ReturnType<typeof makeEntry>>,
+    version = 1
+): HashRegistryInput => ({
+    version,
+    files,
+    fileNameToHash: Object.fromEntries(
+        Object.entries(files).map(([hash, entry]) => [entry.fileName, hash])
+    ),
+});
+
+suite("Resolver unit: mergeOriginalFilesHashes", () => {
+    test("returns undefined when all three inputs are undefined", () => {
+        const result = mergeOriginalFilesHashes(undefined, undefined, undefined);
+        assert.strictEqual(result, undefined);
+    });
+
+    test("returns undefined when ours and theirs have no files and base is also undefined", () => {
+        const result = mergeOriginalFilesHashes(undefined, { version: 1, files: {}, fileNameToHash: {} }, { version: 1, files: {}, fileNameToHash: {} });
+        assert.strictEqual(result, undefined);
+    });
+
+    test("falls back to base when ours and theirs have no files but base does", () => {
+        const base = makeRegistry({ abc: makeEntry("abc", "doc.docx", ["MAT"]) });
+        const result = mergeOriginalFilesHashes(base, { version: 1, files: {}, fileNameToHash: {} }, { version: 1, files: {}, fileNameToHash: {} });
+        assert.ok(result);
+        assert.strictEqual(Object.keys(result.files).length, 1);
+        assert.ok(result.files["abc"]);
+        assert.strictEqual(result.fileNameToHash["doc.docx"], "abc");
+    });
+
+    test("returns ours entry when theirs is undefined", () => {
+        const ours = makeRegistry({ h1: makeEntry("h1", "file1.docx", ["MAT"]) });
+        const result = mergeOriginalFilesHashes(undefined, ours, undefined);
+        assert.ok(result);
+        assert.strictEqual(Object.keys(result.files).length, 1);
+        assert.deepStrictEqual(result.files["h1"].referencedBy, ["MAT"]);
+    });
+
+    test("returns theirs entry when ours is undefined", () => {
+        const theirs = makeRegistry({ h2: makeEntry("h2", "file2.docx", ["GEN"]) });
+        const result = mergeOriginalFilesHashes(undefined, undefined, theirs);
+        assert.ok(result);
+        assert.strictEqual(Object.keys(result.files).length, 1);
+        assert.deepStrictEqual(result.files["h2"].referencedBy, ["GEN"]);
+    });
+
+    test("unions entries with different hashes from ours and theirs", () => {
+        const ours = makeRegistry({ h1: makeEntry("h1", "user1-doc.docx", ["MAT"]) });
+        const theirs = makeRegistry({ h2: makeEntry("h2", "user2-doc.docx", ["GEN"]) });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.strictEqual(Object.keys(result.files).length, 2);
+        assert.ok(result.files["h1"]);
+        assert.ok(result.files["h2"]);
+        assert.strictEqual(result.fileNameToHash["user1-doc.docx"], "h1");
+        assert.strictEqual(result.fileNameToHash["user2-doc.docx"], "h2");
+    });
+
+    test("merges referencedBy when both sides have the same hash", () => {
+        const ours = makeRegistry({ shared: makeEntry("shared", "document.docx", ["MAT-user1"]) });
+        const theirs = makeRegistry({ shared: makeEntry("shared", "document.docx", ["MAT-user2"]) });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.strictEqual(Object.keys(result.files).length, 1);
+        const entry = result.files["shared"];
+        assert.deepStrictEqual(entry.referencedBy.sort(), ["MAT-user1", "MAT-user2"]);
+    });
+
+    test("deduplicates referencedBy when both sides have overlapping entries", () => {
+        const ours = makeRegistry({ h: makeEntry("h", "doc.docx", ["MAT", "GEN"]) });
+        const theirs = makeRegistry({ h: makeEntry("h", "doc.docx", ["MAT", "REV"]) });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        const entry = result.files["h"];
+        assert.deepStrictEqual(entry.referencedBy.sort(), ["GEN", "MAT", "REV"]);
+    });
+
+    test("merges originalNames when both sides have the same hash", () => {
+        const ours = makeRegistry({ h: makeEntry("h", "stored.docx", ["MAT"], ["original-a.docx"]) });
+        const theirs = makeRegistry({ h: makeEntry("h", "stored.docx", ["GEN"], ["original-b.docx"]) });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        const entry = result.files["h"];
+        assert.deepStrictEqual(entry.originalNames.sort(), ["original-a.docx", "original-b.docx"]);
+    });
+
+    test("deduplicates originalNames when both sides share entries", () => {
+        const ours = makeRegistry({ h: makeEntry("h", "stored.docx", ["MAT"], ["same.docx", "unique-a.docx"]) });
+        const theirs = makeRegistry({ h: makeEntry("h", "stored.docx", ["GEN"], ["same.docx", "unique-b.docx"]) });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        const entry = result.files["h"];
+        assert.deepStrictEqual(entry.originalNames.sort(), ["same.docx", "unique-a.docx", "unique-b.docx"]);
+    });
+
+    test("uses Math.max for version number", () => {
+        const ours = makeRegistry({ h1: makeEntry("h1", "a.docx", ["MAT"]) }, 2);
+        const theirs = makeRegistry({ h2: makeEntry("h2", "b.docx", ["GEN"]) }, 5);
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.strictEqual(result.version, 5);
+    });
+
+    test("defaults version to 1 when both sides omit it", () => {
+        const ours: HashRegistryInput = { files: { h: makeEntry("h", "a.docx", ["MAT"]) }, fileNameToHash: { "a.docx": "h" } };
+        const theirs: HashRegistryInput = { files: {}, fileNameToHash: {} };
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.strictEqual(result.version, 1);
+    });
+
+    test("builds fileNameToHash from merged entries correctly", () => {
+        const ours = makeRegistry({
+            h1: makeEntry("h1", "alpha.docx", ["MAT"]),
+            h2: makeEntry("h2", "beta.docx", ["GEN"]),
+        });
+        const theirs = makeRegistry({
+            h2: makeEntry("h2", "beta.docx", ["REV"]),
+            h3: makeEntry("h3", "gamma.docx", ["EXO"]),
+        });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.strictEqual(result.fileNameToHash["alpha.docx"], "h1");
+        assert.strictEqual(result.fileNameToHash["beta.docx"], "h2");
+        assert.strictEqual(result.fileNameToHash["gamma.docx"], "h3");
+    });
+
+    test("handles ours-only entry correctly (theirs missing that hash)", () => {
+        const ours = makeRegistry({
+            exclusive: makeEntry("exclusive", "only-ours.docx", ["MAT"]),
+            shared: makeEntry("shared", "common.docx", ["GEN"]),
+        });
+        const theirs = makeRegistry({
+            shared: makeEntry("shared", "common.docx", ["REV"]),
+        });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.strictEqual(Object.keys(result.files).length, 2);
+        assert.deepStrictEqual(result.files["exclusive"].referencedBy, ["MAT"]);
+        assert.deepStrictEqual(result.files["shared"].referencedBy.sort(), ["GEN", "REV"]);
+    });
+
+    test("handles theirs-only entry correctly (ours missing that hash)", () => {
+        const ours = makeRegistry({
+            shared: makeEntry("shared", "common.docx", ["MAT"]),
+        });
+        const theirs = makeRegistry({
+            shared: makeEntry("shared", "common.docx", ["GEN"]),
+            exclusive: makeEntry("exclusive", "only-theirs.docx", ["REV"]),
+        });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.strictEqual(Object.keys(result.files).length, 2);
+        assert.deepStrictEqual(result.files["exclusive"].referencedBy, ["REV"]);
+        assert.deepStrictEqual(result.files["shared"].referencedBy.sort(), ["GEN", "MAT"]);
+    });
+
+    test("preserves extra properties on entries during merge", () => {
+        const addedAt = "2025-01-15T10:00:00.000Z";
+        const ours = makeRegistry({ h: makeEntry("h", "doc.docx", ["MAT"], ["doc.docx"], addedAt) });
+        const theirs = makeRegistry({ h: makeEntry("h", "doc.docx", ["GEN"], ["doc.docx"], addedAt) });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.strictEqual(result.files["h"].addedAt, addedAt);
+        assert.strictEqual(result.files["h"].hash, "h");
+        assert.strictEqual(result.files["h"].fileName, "doc.docx");
+    });
+
+    test("handles empty referencedBy and originalNames arrays gracefully", () => {
+        const ours = makeRegistry({ h: { hash: "h", fileName: "doc.docx", originalNames: [], referencedBy: [], addedAt: "" } as any });
+        const theirs = makeRegistry({ h: makeEntry("h", "doc.docx", ["MAT"], ["original.docx"]) });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.deepStrictEqual(result.files["h"].referencedBy, ["MAT"]);
+        assert.deepStrictEqual(result.files["h"].originalNames, ["original.docx"]);
+    });
+
+    test("handles missing referencedBy and originalNames properties via fallback to empty array", () => {
+        const ours: HashRegistryInput = {
+            version: 1,
+            files: { h: { hash: "h", fileName: "doc.docx" } as any },
+            fileNameToHash: { "doc.docx": "h" },
+        };
+        const theirs = makeRegistry({ h: makeEntry("h", "doc.docx", ["GEN"], ["name.docx"]) });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.deepStrictEqual(result.files["h"].referencedBy, ["GEN"]);
+        assert.deepStrictEqual(result.files["h"].originalNames, ["name.docx"]);
+    });
+
+    test("complex scenario: multiple hashes, some shared, some exclusive per side", () => {
+        const ours = makeRegistry({
+            shared1: makeEntry("shared1", "common1.docx", ["MAT-u1"], ["common1.docx"]),
+            shared2: makeEntry("shared2", "common2.idml", ["GEN-u1", "EXO-u1"], ["common2.idml"]),
+            oursOnly: makeEntry("oursOnly", "local.pdf", ["REV-u1"], ["local.pdf"]),
+        });
+        const theirs = makeRegistry({
+            shared1: makeEntry("shared1", "common1.docx", ["MAT-u2"], ["common1-renamed.docx"]),
+            shared2: makeEntry("shared2", "common2.idml", ["GEN-u2"], ["common2.idml"]),
+            theirsOnly: makeEntry("theirsOnly", "remote.pdf", ["LEV-u2"], ["remote.pdf"]),
+        });
+        const result = mergeOriginalFilesHashes(undefined, ours, theirs);
+        assert.ok(result);
+        assert.strictEqual(Object.keys(result.files).length, 4);
+
+        assert.deepStrictEqual(result.files["shared1"].referencedBy.sort(), ["MAT-u1", "MAT-u2"]);
+        assert.deepStrictEqual(result.files["shared1"].originalNames.sort(), ["common1-renamed.docx", "common1.docx"]);
+
+        assert.deepStrictEqual(result.files["shared2"].referencedBy.sort(), ["EXO-u1", "GEN-u1", "GEN-u2"]);
+        assert.deepStrictEqual(result.files["shared2"].originalNames, ["common2.idml"]);
+
+        assert.deepStrictEqual(result.files["oursOnly"].referencedBy, ["REV-u1"]);
+        assert.deepStrictEqual(result.files["theirsOnly"].referencedBy, ["LEV-u2"]);
+
+        assert.strictEqual(result.fileNameToHash["common1.docx"], "shared1");
+        assert.strictEqual(result.fileNameToHash["common2.idml"], "shared2");
+        assert.strictEqual(result.fileNameToHash["local.pdf"], "oursOnly");
+        assert.strictEqual(result.fileNameToHash["remote.pdf"], "theirsOnly");
+    });
+});
diff --git a/src/test/suite/syncManager.test.ts b/src/test/suite/syncManager.test.ts
index 4b45b6ed0..d250194db 100644
--- a/src/test/suite/syncManager.test.ts
+++ b/src/test/suite/syncManager.test.ts
@@ -104,6 +104,10 @@ suite('SyncManager VS Code Version Warning Tests', () => {
         syncManager = SyncManager.getInstance();
     });
 
+    let connectivityModule: any;
+    let isOnlineStub: sinon.SinonStub;
+    let dugiteModule: any;
+
     setup(async () => {
         // Restore any existing stubs first to avoid double-wrapping errors
         sinon.restore();
@@ -130,8 +134,8 @@ suite('SyncManager VS Code Version Warning Tests', () => {
         versionChecksModule = await import('../../projectManager/utils/versionChecks');
         getFrontierVersionStatusStub = sinon.stub(versionChecksModule, 'getFrontierVersionStatus').resolves({
             ok: true,
-            installedVersion: '0.4.18',
-            requiredVersion: '0.4.18'
+            installedVersion: '0.4.24',
+            requiredVersion: '0.4.24'
         });
 
         // Stub dugiteGit.listRemotes so the "not published" guard doesn't fire
diff --git a/src/utils/audioExtractor.ts b/src/utils/audioExtractor.ts
index 3cc01af70..dcc645a41 100644
--- a/src/utils/audioExtractor.ts
+++ b/src/utils/audioExtractor.ts
@@ -6,8 +6,9 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
 import * as fs from 'fs';
-import { shouldUseNativeAudio } from './toolPreferences';
+import { shouldUseNativeAudio, getAudioToolMode } from './toolPreferences';
 import { getFFmpegPath } from './ffmpegManager';
+import { captureEvent } from './telemetry';
 
 function getSpawn(): ((command: string, args?: readonly string[]) => any) | null {
     try {
@@ -140,6 +141,11 @@ export async function extractAudioFromVideo(
             return await extractAudioWithFFmpeg(videoData, startTime, endTime);
         } catch (error) {
             console.error('FFmpeg extraction failed, using fallback:', error);
+            captureEvent("tool_fallback_used", {
+                tool: "audio",
+                reason: "ffmpeg_extraction_failed",
+                mode: getAudioToolMode(),
+            });
             return fallbackCopyVideo(videoData);
         }
     } else {
diff --git a/src/utils/audioMerger.ts b/src/utils/audioMerger.ts
index d47a2bc99..d9ff78096 100644
--- a/src/utils/audioMerger.ts
+++ b/src/utils/audioMerger.ts
@@ -10,6 +10,7 @@ import * as vscode from "vscode";
 import { getFFmpegPath } from "./ffmpegManager";
 import { mergeWavFiles } from "./wavUtils";
 import { getAudioToolMode } from "./toolPreferences";
+import { captureEvent } from "./telemetry";
 
 const getSpawn = (): ((command: string, args?: readonly string[]) => any) | null => {
     try {
@@ -56,6 +57,11 @@ export const mergeAudioFiles = async (
             return result;
         }
         console.info("[audioMerger] FFmpeg merge failed or unavailable — falling back to pure-JS WAV merge");
+        captureEvent("tool_fallback_used", {
+            tool: "audio",
+            reason: "ffmpeg_merge_failed",
+            mode: getAudioToolMode(),
+        });
     } else {
         console.info("[audioMerger] Built-in audio mode active — using pure-JS WAV merge");
     }
diff --git a/src/utils/metadataManager.ts b/src/utils/metadataManager.ts
index f44fbb52d..75012769d 100644
--- a/src/utils/metadataManager.ts
+++ b/src/utils/metadataManager.ts
@@ -17,6 +17,7 @@ interface ProjectMetadata {
             codexEditor?: string;
             frontierAuthentication?: string;
         };
+        pinnedExtensions?: Record<string, { version: string; url: string }>;
         [key: string]: unknown;
     };
     edits?: any[];
@@ -326,19 +327,28 @@ export class MetadataManager {
                     metadata.meta.requiredExtensions = {};
                 }
 
-                // Only update codexEditor if new version is greater or missing
+                const pinnedExtensions: Record<string, { version: string; url: string }> =
+                    (metadata.meta as any).pinnedExtensions ?? {};
+
+                // Only update codexEditor if new version is greater or missing,
+                // AND no codex-editor pin is active (the Conductor owns the floor while active).
                 if (versions.codexEditor !== undefined) {
-                    const existingVersion = metadata.meta.requiredExtensions.codexEditor;
-                    if (!existingVersion || compareVersions(versions.codexEditor, existingVersion) >= 0) {
-                        metadata.meta.requiredExtensions.codexEditor = versions.codexEditor;
+                    if (!pinnedExtensions["project-accelerate.codex-editor-extension"]) {
+                        const existingVersion = metadata.meta.requiredExtensions.codexEditor;
+                        if (!existingVersion || compareVersions(versions.codexEditor, existingVersion) >= 0) {
+                            metadata.meta.requiredExtensions.codexEditor = versions.codexEditor;
+                        }
                     }
                 }
-                
-                // Only update frontierAuthentication if new version is greater or missing
+
+                // Only update frontierAuthentication if new version is greater or missing,
+                // AND no frontier-authentication pin is active.
                 if (versions.frontierAuthentication !== undefined) {
-                    const existingVersion = metadata.meta.requiredExtensions.frontierAuthentication;
-                    if (!existingVersion || compareVersions(versions.frontierAuthentication, existingVersion) >= 0) {
-                        metadata.meta.requiredExtensions.frontierAuthentication = versions.frontierAuthentication;
+                    if (!pinnedExtensions["frontier-rnd.frontier-authentication"]) {
+                        const existingVersion = metadata.meta.requiredExtensions.frontierAuthentication;
+                        if (!existingVersion || compareVersions(versions.frontierAuthentication, existingVersion) >= 0) {
+                            metadata.meta.requiredExtensions.frontierAuthentication = versions.frontierAuthentication;
+                        }
                     }
                 }
 
@@ -396,17 +406,20 @@ export class MetadataManager {
             const codexEditorVersion = this.getCurrentExtensionVersion("project-accelerate.codex-editor-extension");
             const frontierAuthVersion = this.getCurrentExtensionVersion("frontier-rnd.frontier-authentication");
 
-            // Read current metadata versions
-            const currentVersions = await this.getExtensionVersions(workspaceUri);
-            if (!currentVersions.success) {
+            // Read current metadata (single read for both versions and pins)
+            const result = await this.safeReadMetadata<ProjectMetadata>(workspaceUri);
+            if (!result.success) {
                 return; // No metadata file yet, or can't read it
             }
 
-            const existingVersions = currentVersions.versions || {};
+            const existingVersions = result.metadata?.meta?.requiredExtensions || {};
             const versionsToUpdate: { codexEditor?: string; frontierAuthentication?: string } = {};
 
+            // Suppress ratchet if a pin exists (The Conductor is in charge)
+            const pinnedExtensions = result.metadata?.meta?.pinnedExtensions || {};
+
             // Check codexEditor - update if missing or if installed version is newer
-            if (codexEditorVersion) {
+            if (codexEditorVersion && !pinnedExtensions['project-accelerate.codex-editor-extension']) {
                 if (!existingVersions.codexEditor) {
                     versionsToUpdate.codexEditor = codexEditorVersion;
                 } else if (compareVersions(codexEditorVersion, existingVersions.codexEditor) > 0) {
@@ -415,7 +428,7 @@ export class MetadataManager {
             }
 
             // Check frontierAuthentication - update if missing or if installed version is newer
-            if (frontierAuthVersion) {
+            if (frontierAuthVersion && !pinnedExtensions['frontier-rnd.frontier-authentication']) {
                 if (!existingVersions.frontierAuthentication) {
                     versionsToUpdate.frontierAuthentication = frontierAuthVersion;
                 } else if (compareVersions(frontierAuthVersion, existingVersions.frontierAuthentication) > 0) {
diff --git a/src/utils/notebookSafeSaveUtils.ts b/src/utils/notebookSafeSaveUtils.ts
index a7d7031be..6cf73e71a 100644
--- a/src/utils/notebookSafeSaveUtils.ts
+++ b/src/utils/notebookSafeSaveUtils.ts
@@ -165,6 +165,12 @@ export async function readExistingFileOrThrowWithFs(
                     // Empty file on disk: allow caller to treat this as "missing" and do an initial write.
                     return { kind: "missing" };
                 }
+                // Non-empty file but empty read — Windows filesystem flush timing issue.
+                // Retry with a short delay before giving up.
+                if (attempt < maxAttempts) {
+                    await new Promise((resolve) => setTimeout(resolve, 25));
+                    continue;
+                }
                 throw new Error(`Read empty content from non-empty file: ${uri.fsPath}`);
             }
             return { kind: "readable", content };
diff --git a/src/utils/sqliteDatabaseFactory.ts b/src/utils/sqliteDatabaseFactory.ts
index 506e0d1f7..bef299af3 100644
--- a/src/utils/sqliteDatabaseFactory.ts
+++ b/src/utils/sqliteDatabaseFactory.ts
@@ -10,7 +10,8 @@
 import type { IAsyncDatabase } from "./sqliteTypes";
 import { isNativeSqliteReady, AsyncDatabase } from "./nativeSqlite";
 import { isFts5SqliteReady, Fts5AsyncDatabase } from "./fts5Sqlite";
-import { shouldUseNativeSqlite } from "./toolPreferences";
+import { shouldUseNativeSqlite, getSqliteToolMode } from "./toolPreferences";
+import { captureEvent } from "./telemetry";
 
 /**
  * Open a database file using the preferred backend.
@@ -35,6 +36,11 @@ export const openDatabase = async (filepath: string): Promise<IAsyncDatabase> =>
     // Preferred backend not available — gracefully fall back to whatever IS ready.
     // This mirrors how audio/git tools work: the preference is advisory, not a hard gate.
     if (isNativeSqliteReady()) {
+        captureEvent("tool_fallback_used", {
+            tool: "sqlite",
+            reason: "preferred_backend_unavailable",
+            mode: getSqliteToolMode(),
+        });
         return AsyncDatabase.open(filepath);
     }
 
diff --git a/src/utils/telemetry.ts b/src/utils/telemetry.ts
new file mode 100644
index 000000000..b3031766d
--- /dev/null
+++ b/src/utils/telemetry.ts
@@ -0,0 +1,141 @@
+import * as vscode from "vscode";
+import * as os from "os";
+import * as crypto from "crypto";
+import { PostHog } from "posthog-node";
+
+const EXTENSION_ID = "project-accelerate.codex-editor-extension";
+const POSTHOG_PROJECT_TOKEN = "phc_RI95xdYMQyCjOFSfPmsWrj9zviS4ywf56XwEX9cZ6Mf";
+const POSTHOG_HOST = "https://us.i.posthog.com";
+
+let client: PostHog | undefined;
+let distinctId: string | undefined;
+
+const isTelemetryEnabled = (): boolean =>
+    vscode.workspace
+        .getConfiguration("codex-editor-extension")
+        .get<boolean>("telemetryEnabled", true);
+
+const buildDistinctId = (): string => {
+    const uuid = crypto.randomUUID();
+    try {
+        const pm = vscode.workspace.getConfiguration("codex-project-manager");
+        const email = pm.get<string>("userEmail");
+
+        if (email) {
+            return `${email}`;
+        }
+    } catch {
+        // Config unavailable — fall through to OS username
+    }
+
+    return `anonymous_${uuid}`;
+};
+
+const getExtensionVersion = (): string => {
+    const ext = vscode.extensions.getExtension(EXTENSION_ID);
+    return (ext?.packageJSON?.version as string) ?? "unknown";
+};
+
+const getSystemProperties = () => ({
+    osPlatform: os.platform(),
+    osRelease: os.release(),
+    osArch: os.arch(),
+    totalMemoryGB: Math.round(os.totalmem() / 1024 / 1024 / 1024),
+    freeMemoryGB: Math.round(os.freemem() / 1024 / 1024 / 1024),
+    cpuCores: os.cpus().length,
+    cpuModel: os.cpus()[0]?.model,
+    vscodeVersion: vscode.version,
+    extensionVersion: getExtensionVersion(),
+    nodeVersion: process.version,
+    locale: vscode.env.language,
+});
+
+export const initTelemetry = (): void => {
+    if (!isTelemetryEnabled()) {
+        return;
+    }
+
+    distinctId = buildDistinctId();
+
+    client = new PostHog(POSTHOG_PROJECT_TOKEN, {
+        host: POSTHOG_HOST,
+        flushAt: 20,
+        flushInterval: 30_000,
+    });
+
+    client.identify({
+        distinctId,
+        properties: getSystemProperties(),
+    });
+};
+
+export const captureException = (
+    error: Error | unknown,
+    context?: Record<string, unknown>
+): void => {
+    if (!client || !distinctId) {
+        return;
+    }
+
+    const err = error instanceof Error ? error : new Error(String(error));
+
+    client.captureException(err, distinctId, context);
+};
+
+export const captureEvent = (
+    event: string,
+    properties?: Record<string, unknown>
+): void => {
+    if (!client || !distinctId) {
+        return;
+    }
+
+    client.capture({
+        distinctId,
+        event,
+        properties,
+    });
+};
+
+export const shutdownTelemetry = async (): Promise<void> => {
+    if (!client) {
+        return;
+    }
+
+    try {
+        await client.shutdown();
+    } catch (error) {
+        console.warn("[Telemetry] Error during PostHog shutdown:", error);
+    } finally {
+        client = undefined;
+    }
+};
+
+const SESSION_RECORDING_WEBVIEWS = new Set([
+    "CodexCellEditor",
+    "NavigationView",
+    "MainMenu",
+    "CommentsView",
+    "ParallelView",
+]);
+
+export const getPostHogWebviewScript = (nonce: string, webviewName?: string): string => {
+    if (!isTelemetryEnabled()) {
+        return `<script nonce="${nonce}">/* telemetry disabled */</script>`;
+    }
+
+    const userEnabled = vscode.workspace
+        .getConfiguration("codex-editor-extension")
+        .get<boolean>("sessionRecordingEnabled", false);
+
+    const enableRecording = userEnabled && SESSION_RECORDING_WEBVIEWS.has(webviewName ?? "");
+
+    return `<script nonce="${nonce}">
+        window.__POSTHOG_CONFIG__ = ${JSON.stringify({
+        token: POSTHOG_PROJECT_TOKEN,
+        host: POSTHOG_HOST,
+        distinctId: buildDistinctId(),
+        enableRecording,
+    })};
+    </script>`;
+};
diff --git a/src/utils/webviewTemplate.ts b/src/utils/webviewTemplate.ts
index 551070556..d4b5c4b7b 100644
--- a/src/utils/webviewTemplate.ts
+++ b/src/utils/webviewTemplate.ts
@@ -1,5 +1,6 @@
 import * as vscode from "vscode";
 import { getNonce } from "./getNonce";
+import { getPostHogWebviewScript } from "./telemetry";
 
 interface WebviewTemplateOptions {
     title?: string;
@@ -8,6 +9,7 @@ interface WebviewTemplateOptions {
     initialData?: any;
     inlineStyles?: string;
     customScript?: string;
+    webviewName?: string;
 }
 
 export function getWebviewHtml(
@@ -33,7 +35,7 @@ export function getWebviewHtml(
         `img-src ${webview.cspSource} https: data:; ` +
         `font-src ${webview.cspSource}; ` +
         `worker-src ${webview.cspSource} blob:; ` +
-        `connect-src https://*.vscode-cdn.net https://*.frontierrnd.com; ` +
+        `connect-src https://*.vscode-cdn.net https://*.frontierrnd.com https://*.posthog.com https://*.i.posthog.com; ` +
         `media-src ${webview.cspSource} https: blob:;`;
     const csp = (options.csp || defaultCsp).replace(/\$\{nonce\}/g, nonce);
 
@@ -50,6 +52,7 @@ export function getWebviewHtml(
 </head>
 <body>
     <div id="root"></div>
+    ${getPostHogWebviewScript(nonce, options.webviewName ?? options.scriptPath[0])}
     ${options.initialData ? `<script nonce="${nonce}">window.initialData = ${JSON.stringify(options.initialData)};</script>` : ""}
     ${options.customScript ? `<script nonce="${nonce}">${options.customScript}</script>` : ""}
     <script nonce="${nonce}" src="${scriptUri}"></script>
diff --git a/types/index.d.ts b/types/index.d.ts
index 3519a13b4..72faccfcd 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -991,6 +991,11 @@ type ProjectMetadata = {
             codexEditor?: string;
             frontierAuthentication?: string;
         };
+        /** Pin specific extension versions for this project */
+        pinnedExtensions?: Record<string, {
+            version: string;
+            url: string;
+        }>;
         /** List of users that should be forced to restore/update their project when opening */
         initiateRemoteUpdatingFor?: RemoteUpdatingEntry[];
         abbreviation?: string;
@@ -1401,7 +1406,9 @@ type ProjectManagerMessageFromWebview =
     | { command: "fetchAsrModels"; data: { endpoint: string; }; }
     | { command: "setValidationCountDirect"; data: { count: number; }; }
     | { command: "setValidationCountAudioDirect"; data: { count: number; }; }
-    | { command: "publishStatusUpdate"; data: { isPublishingInProgress: boolean; publishingStage: string; }; };
+    | { command: "publishStatusUpdate"; data: { isPublishingInProgress: boolean; publishingStage: string; }; }
+    | { command: "getSessionRecordingSetting"; }
+    | { command: "toggleSessionRecording"; };
 
 interface ProjectManagerState {
     projectOverview: ProjectOverview | null;
diff --git a/webviews/codex-webviews/package.json b/webviews/codex-webviews/package.json
index 5f5cbe798..fa27b951a 100644
--- a/webviews/codex-webviews/package.json
+++ b/webviews/codex-webviews/package.json
@@ -81,6 +81,7 @@
         "papaparse": "^5.5.2",
         "pdfjs-dist": "^5.4.149",
         "pnpm": "^10.6.2",
+        "posthog-js": "^1.362.0",
         "process": "^0.11.10",
         "quill": "^2.0.3",
         "quilljs-markdown": "^1.2.0",
diff --git a/webviews/codex-webviews/src/CellLabelImporterView/index.tsx b/webviews/codex-webviews/src/CellLabelImporterView/index.tsx
index 200403c4d..41bcf9048 100644
--- a/webviews/codex-webviews/src/CellLabelImporterView/index.tsx
+++ b/webviews/codex-webviews/src/CellLabelImporterView/index.tsx
@@ -1,9 +1,10 @@
+import "../shared/posthog";
 import React from "react";
 import { createRoot } from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import App from "./App.tsx";
-import "./CellLabelImporterView.css"; // Assuming we'll create this for styles
+import "./CellLabelImporterView.css";
 
-// Declare vscode globally
 declare const vscode: {
     postMessage: (message: any) => void;
     getState: () => any;
@@ -14,9 +15,11 @@ const container = document.getElementById("root");
 if (container) {
     const root = createRoot(container);
     root.render(
-        <React.StrictMode>
-            <App />
-        </React.StrictMode>
+        <ErrorBoundary>
+            <React.StrictMode>
+                <App />
+            </React.StrictMode>
+        </ErrorBoundary>
     );
 } else {
     console.error("Failed to find the root element");
diff --git a/webviews/codex-webviews/src/CodexCellEditor/AudioHistoryViewer.tsx b/webviews/codex-webviews/src/CodexCellEditor/AudioHistoryViewer.tsx
index f12421b89..f9d797eed 100644
--- a/webviews/codex-webviews/src/CodexCellEditor/AudioHistoryViewer.tsx
+++ b/webviews/codex-webviews/src/CodexCellEditor/AudioHistoryViewer.tsx
@@ -518,6 +518,7 @@ export const AudioHistoryViewer: React.FC<AudioHistoryViewerProps> = ({
             }}
         >
             <div
+                className="ph-mask"
                 style={{
                     backgroundColor: "var(--vscode-editor-background)",
                     border: "1px solid var(--vscode-panel-border)",
diff --git a/webviews/codex-webviews/src/CodexCellEditor/CellContentDisplay.tsx b/webviews/codex-webviews/src/CodexCellEditor/CellContentDisplay.tsx
index b3fc4af3e..d4cb2f9ab 100644
--- a/webviews/codex-webviews/src/CodexCellEditor/CellContentDisplay.tsx
+++ b/webviews/codex-webviews/src/CodexCellEditor/CellContentDisplay.tsx
@@ -89,7 +89,7 @@ const CellLabelText: React.FC<{
 }> = React.memo(({ label, forceLabelTopRow }) => {
     return (
         <div
-            className="cell-label-text text-primary inline-block text-right relative -top-[2px] ml-px"
+            className="ph-mask cell-label-text text-primary inline-block text-right relative -top-[2px] ml-px"
             style={{
                 fontWeight:
                     CELL_DISPLAY_MODE === CELL_DISPLAY_MODES.ONE_LINE_PER_CELL ? 500 : "normal",
@@ -615,10 +615,7 @@ const CellContentDisplay: React.FC<CellContentDisplayProps> = React.memo(
                             }}
                             className="invisible"
                         >
-                            <CellLabelText
-                                label={lineNumber}
-                                forceLabelTopRow={forceLabelTopRow}
-                            />
+                            <CellLabelText label={lineNumber} forceLabelTopRow={forceLabelTopRow} />
                         </div>
                     ) : null}
                     <div className="cell-header flex justify-start items-start shrink-0 gap-[1px]">
@@ -918,15 +915,10 @@ const CellContentDisplay: React.FC<CellContentDisplayProps> = React.memo(
                     onClick={handleCellContentClick}
                 >
                     {/* Cell label - shown after line number when present */}
-                    {label && (
-                        <CellLabelText
-                            label={label}
-                            forceLabelTopRow={forceLabelTopRow}
-                        />
-                    )}
+                    {label && <CellLabelText label={label} forceLabelTopRow={forceLabelTopRow} />}
                     <div
                         tabIndex={0}
-                        className={`flex-1 min-w-0 min-h-[1rem] ${
+                        className={`ph-mask flex-1 min-w-0 min-h-[1rem] ${
                             lineNumbersEnabled ? "pr-[0.25rem]" : "px-[0.25rem]"
                         }`}
                         title={!isCellLocked ? "Click to edit" : "Cell is locked"}
diff --git a/webviews/codex-webviews/src/CodexCellEditor/ChapterNavigationHeader.tsx b/webviews/codex-webviews/src/CodexCellEditor/ChapterNavigationHeader.tsx
index 963a49676..edef5e768 100644
--- a/webviews/codex-webviews/src/CodexCellEditor/ChapterNavigationHeader.tsx
+++ b/webviews/codex-webviews/src/CodexCellEditor/ChapterNavigationHeader.tsx
@@ -279,12 +279,7 @@ ChapterNavigationHeaderProps) {
                 setTruncatedBookName((prev) => (prev !== null ? null : prev));
             }
         });
-    }, [
-        getDisplayTitle,
-        shouldShowHamburger,
-        subsections,
-        currentSubsectionIndex,
-    ]);
+    }, [getDisplayTitle, shouldShowHamburger, subsections, currentSubsectionIndex]);
 
     // Unified resize + breakpoint handling via ResizeObserver on the header container.
     // Uses container width (not window.innerWidth) so breakpoints respond to the
@@ -336,7 +331,13 @@ ChapterNavigationHeaderProps) {
     // Re-run title truncation when content changes (resize is handled by the unified ResizeObserver above)
     useEffect(() => {
         measureAndTruncateTitle();
-    }, [getDisplayTitle, translationUnitsForSection, subsections, currentSubsectionIndex, measureAndTruncateTitle]);
+    }, [
+        getDisplayTitle,
+        translationUnitsForSection,
+        subsections,
+        currentSubsectionIndex,
+        measureAndTruncateTitle,
+    ]);
 
     // Common handler for stopping any kind of translation
     const handleStopTranslation = () => {
@@ -442,7 +443,9 @@ ChapterNavigationHeaderProps) {
             // Validate milestone index to prevent -1 or out-of-bounds requests
             const milestoneCount = milestoneIndex?.milestones.length ?? 0;
             if (newMilestoneIdx < 0 || newMilestoneIdx >= milestoneCount) {
-                console.warn(`[jumpToMilestone] Invalid milestone index: ${newMilestoneIdx}, total: ${milestoneCount}`);
+                console.warn(
+                    `[jumpToMilestone] Invalid milestone index: ${newMilestoneIdx}, total: ${milestoneCount}`
+                );
                 return;
             }
             if (
@@ -455,7 +458,13 @@ ChapterNavigationHeaderProps) {
                 requestCellsForMilestone(newMilestoneIdx, newSubsectionIdx);
             }
         },
-        [unsavedChanges, currentMilestoneIndex, currentSubsectionIndex, requestCellsForMilestone, milestoneIndex?.milestones.length]
+        [
+            unsavedChanges,
+            currentMilestoneIndex,
+            currentSubsectionIndex,
+            requestCellsForMilestone,
+            milestoneIndex?.milestones.length,
+        ]
     );
 
     // Use dynamic responsive state variables based on content overflow
@@ -662,7 +671,7 @@ ChapterNavigationHeaderProps) {
 
                 <div
                     ref={chapterTitleRef}
-                    className="chapter-title-container flex items-center min-w-0 max-w-full cursor-pointer rounded-md transition-all duration-200 ease-in-out px-2"
+                    className="ph-mask chapter-title-container flex items-center min-w-0 max-w-full cursor-pointer rounded-md transition-all duration-200 ease-in-out px-2"
                     onClick={() => {
                         // Always allow opening the milestone accordion when there are no unsaved changes
                         if (!unsavedChanges) {
diff --git a/webviews/codex-webviews/src/CodexCellEditor/TextCellEditor.tsx b/webviews/codex-webviews/src/CodexCellEditor/TextCellEditor.tsx
index a4beb7fd2..92cca32c0 100644
--- a/webviews/codex-webviews/src/CodexCellEditor/TextCellEditor.tsx
+++ b/webviews/codex-webviews/src/CodexCellEditor/TextCellEditor.tsx
@@ -1922,9 +1922,9 @@ const CellEditor: React.FC<CellEditorProps> = ({
                 <div className="flex flex-row flex-wrap items-center justify-between gap-3">
                     <div className="flex flex-col justify-center gap-2 pr-3">
                         <div
-                            className="flex items-center gap-2"
+                            className="ph-mask flex items-center gap-2"
                             role="button"
-                            aria-label="Cell id and label"
+                            aria-label="Cell label and actions"
                         >
                             {cellType !== CodexCellTypes.PARATEXT &&
                                 cellType !== CodexCellTypes.MILESTONE && (
@@ -2140,7 +2140,7 @@ const CellEditor: React.FC<CellEditorProps> = ({
 
             <CardContent className="p-4 space-y-4">
                 <div
-                    className={`flex items-start gap-2 ${
+                    className={`ph-mask flex items-start gap-2 ${
                         showFlashingBorder
                             ? "ring-2 ring-blue-500 ring-opacity-50 animate-pulse rounded-lg p-2"
                             : ""
@@ -2288,7 +2288,7 @@ const CellEditor: React.FC<CellEditorProps> = ({
                                             defaultValue={cellLabel}
                                             onChange={handleLabelChange}
                                             placeholder="Enter label..."
-                                            className="flex-1"
+                                            className="ph-no-capture flex-1"
                                         />
                                         <RotateCcw
                                             className="h-4 w-4 cursor-pointer"
@@ -2304,7 +2304,7 @@ const CellEditor: React.FC<CellEditorProps> = ({
                             </TabsContent>
                         )}
                     <TabsContent value="source">
-                        <div className="space-y-6">
+                        <div className="ph-mask space-y-6">
                             {/* Source Text */}
                             <div>
                                 <h4 className="text-sm font-medium mb-2 text-muted-foreground">
@@ -2317,7 +2317,7 @@ const CellEditor: React.FC<CellEditorProps> = ({
                             </div>
 
                             {/* Backtranslation Section */}
-                            <div className="space-y-4">
+                            <div className="ph-mask space-y-4">
                                 <div className="flex items-center justify-between">
                                     <h4 className="text-sm font-medium text-muted-foreground">
                                         Backtranslation
@@ -2378,7 +2378,7 @@ const CellEditor: React.FC<CellEditorProps> = ({
                                                     onChange={(e) =>
                                                         setEditedBacktranslation(e.target.value)
                                                     }
-                                                    className="min-h-[150px]"
+                                                    className="ph-no-capture min-h-[150px]"
                                                     placeholder="Enter backtranslation text..."
                                                 />
                                                 <div className="flex gap-2 justify-end">
@@ -2403,7 +2403,7 @@ const CellEditor: React.FC<CellEditorProps> = ({
                                             </div>
                                         ) : (
                                             <div className="p-4 rounded-lg bg-muted">
-                                                <ReactMarkdown className="prose prose-sm max-w-none">
+                                                <ReactMarkdown className="ph-mask rose prose-sm max-w-none">
                                                     {backtranslation.backtranslation}
                                                 </ReactMarkdown>
                                             </div>
@@ -2439,7 +2439,7 @@ const CellEditor: React.FC<CellEditorProps> = ({
 
                     {activeTab === "footnotes" && (
                         <TabsContent value="footnotes">
-                            <div className="content-section">
+                            <div className="ph-mask content-section">
                                 {/* Add Footnote action surfaced here with selection-aware hint - hide when already creating */}
                                 {!isEditingFootnoteInline && (
                                     <div className="flex items-center justify-between mb-3">
@@ -2577,7 +2577,7 @@ const CellEditor: React.FC<CellEditorProps> = ({
 
                     {activeTab === "timestamps" && (
                         <TabsContent value="timestamps">
-                            <div className="content-section space-y-4">
+                            <div className="ph-mask content-section space-y-4">
                                 <h3 className="text-lg font-medium">Timestamps</h3>
 
                                 {effectiveTimestamps &&
@@ -2698,7 +2698,7 @@ const CellEditor: React.FC<CellEditorProps> = ({
 
                     {activeTab === "audio" && (
                         <TabsContent value="audio">
-                            <div className="content-section space-y-6">
+                            <div className="ph-mask content-section space-y-6">
                                 <h3 className="text-lg font-medium">Audio Recording</h3>
 
                                 {showRecorder ||
diff --git a/webviews/codex-webviews/src/CodexCellEditor/components/MilestoneAccordion.tsx b/webviews/codex-webviews/src/CodexCellEditor/components/MilestoneAccordion.tsx
index 5bd7c604f..0d4a128ec 100644
--- a/webviews/codex-webviews/src/CodexCellEditor/components/MilestoneAccordion.tsx
+++ b/webviews/codex-webviews/src/CodexCellEditor/components/MilestoneAccordion.tsx
@@ -607,7 +607,7 @@ export function MilestoneAccordion({
     return (
         <div
             ref={accordionRef}
-            className="milestone-accordion-dropdown focus-visible:outline-none"
+            className="ph-mask milestone-accordion-dropdown focus-visible:outline-none"
             tabIndex={-1}
             style={{
                 position: "absolute",
@@ -628,7 +628,7 @@ export function MilestoneAccordion({
                 transformOrigin: arrowPosition === "top" ? "top center" : "bottom center",
             }}
         >
-            <div className="flex items-center justify-between px-4 pt-4 pb-2 mb-2 border-b border-[var(--vscode-widget-border)] flex-shrink-0">
+            <div className="ph-no-capture flex items-center justify-between px-4 pt-4 pb-2 mb-2 border-b border-[var(--vscode-widget-border)] flex-shrink-0">
                 {isEditingMilestone ? (
                     <input
                         ref={inputRef}
diff --git a/webviews/codex-webviews/src/CodexCellEditor/index.tsx b/webviews/codex-webviews/src/CodexCellEditor/index.tsx
index 7ba19b064..ea6a4463f 100644
--- a/webviews/codex-webviews/src/CodexCellEditor/index.tsx
+++ b/webviews/codex-webviews/src/CodexCellEditor/index.tsx
@@ -1,5 +1,7 @@
+import "../shared/posthog";
 import React, { useEffect, useState, useMemo } from "react";
 import ReactDOM from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import App from "./CodexCellEditor";
 // import "./App.css";
 import "../tailwind.css";
@@ -77,7 +79,11 @@ const Index: React.FC = () => {
     );
 };
 
-ReactDOM.createRoot(document.getElementById("root")!).render(<Index />);
+ReactDOM.createRoot(document.getElementById("root")!).render(
+    <ErrorBoundary>
+        <Index />
+    </ErrorBoundary>
+);
 
 // Send webviewReady message when the webview is mounted
 window.addEventListener("load", () => {
diff --git a/webviews/codex-webviews/src/CodexMigrationToolView/index.tsx b/webviews/codex-webviews/src/CodexMigrationToolView/index.tsx
index 296a3a33d..04b4f98c8 100644
--- a/webviews/codex-webviews/src/CodexMigrationToolView/index.tsx
+++ b/webviews/codex-webviews/src/CodexMigrationToolView/index.tsx
@@ -1,5 +1,7 @@
+import "../shared/posthog";
 import React from "react";
 import { createRoot } from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import App from "./App";
 import "../tailwind.css";
 
@@ -7,9 +9,11 @@ const container = document.getElementById("root");
 if (container) {
     const root = createRoot(container);
     root.render(
-        <React.StrictMode>
-            <App />
-        </React.StrictMode>
+        <ErrorBoundary>
+            <React.StrictMode>
+                <App />
+            </React.StrictMode>
+        </ErrorBoundary>
     );
 } else {
     console.error("Failed to find root element for migration tool.");
diff --git a/webviews/codex-webviews/src/CommentsView/index.tsx b/webviews/codex-webviews/src/CommentsView/index.tsx
index 82eb5d1f4..1db0ff5a3 100644
--- a/webviews/codex-webviews/src/CommentsView/index.tsx
+++ b/webviews/codex-webviews/src/CommentsView/index.tsx
@@ -1,10 +1,14 @@
+import "../shared/posthog";
 import React from "react";
 import ReactDOM from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import App from "./CommentsView";
 import "../tailwind.css";
 
 ReactDOM.createRoot(document.getElementById("root")!).render(
-    <React.StrictMode>
-        <App />
-    </React.StrictMode>
+    <ErrorBoundary>
+        <React.StrictMode>
+            <App />
+        </React.StrictMode>
+    </ErrorBoundary>
 );
diff --git a/webviews/codex-webviews/src/CopilotSettings/index.tsx b/webviews/codex-webviews/src/CopilotSettings/index.tsx
index 7c0fa73f2..2eae95645 100644
--- a/webviews/codex-webviews/src/CopilotSettings/index.tsx
+++ b/webviews/codex-webviews/src/CopilotSettings/index.tsx
@@ -1,5 +1,7 @@
+import "../shared/posthog";
 import React, { useEffect, useState } from "react";
 import ReactDOM from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import { WebviewHeader } from "../components/WebviewHeader";
 import { Switch } from "../components/ui/switch";
 import { Button } from "../components/ui/button";
@@ -177,4 +179,8 @@ function CopilotSettingsApp() {
 }
 
 const root = ReactDOM.createRoot(document.getElementById("root")!);
-root.render(<CopilotSettingsApp />);
+root.render(
+    <ErrorBoundary>
+        <CopilotSettingsApp />
+    </ErrorBoundary>
+);
diff --git a/webviews/codex-webviews/src/MainMenu/index.tsx b/webviews/codex-webviews/src/MainMenu/index.tsx
index 3428dcb29..cc429270b 100644
--- a/webviews/codex-webviews/src/MainMenu/index.tsx
+++ b/webviews/codex-webviews/src/MainMenu/index.tsx
@@ -1,9 +1,19 @@
+import "../shared/posthog";
 import { useState, useEffect, useRef, useCallback } from "react";
 import { createRoot } from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import { useNetworkState } from "@uidotdev/usehooks";
 import { Button } from "../components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "../components/ui/card";
 import { Alert, AlertDescription } from "../components/ui/alert";
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogFooter,
+    DialogHeader,
+    DialogTitle,
+} from "../components/ui/dialog";
 import { SyncSettings } from "../components/SyncSettings";
 import {
     TextDisplaySettingsModal,
@@ -147,6 +157,7 @@ interface State {
     isFrontierExtensionEnabled: boolean;
     isAuthenticated: boolean;
     isGitAvailable: boolean;
+    sessionRecordingEnabled: boolean;
 }
 
 function MainMenu() {
@@ -177,34 +188,32 @@ function MainMenu() {
         isFrontierExtensionEnabled: true,
         isAuthenticated: false,
         isGitAvailable: true,
+        sessionRecordingEnabled: false,
     });
 
     const network = useNetworkState();
     const isOnline = network?.online ?? true;
 
     const [isTextDisplaySettingsOpen, setIsTextDisplaySettingsOpen] = useState(false);
-
+    const [isSessionRecordingDialogOpen, setIsSessionRecordingDialogOpen] = useState(false);
+    const [pendingSessionRecordingEnabled, setPendingSessionRecordingEnabled] = useState<
+        boolean | null
+    >(null);
 
     // Optimistic local state for validation counters so rapid clicks work correctly.
     // Without this, each click reads from the stale server-confirmed state (which
     // hasn't round-tripped yet), causing lost increments and UI bouncing.
     const [localValidationCount, setLocalValidationCount] = useState<number | null>(null);
-    const [localValidationCountAudio, setLocalValidationCountAudio] = useState<number | null>(
-        null
-    );
+    const [localValidationCountAudio, setLocalValidationCountAudio] = useState<number | null>(null);
     const validationCountDebounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
     const validationCountAudioDebounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
     const localCountFallbackRef = useRef<ReturnType<typeof setTimeout> | null>(null);
     const localCountAudioFallbackRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
     const displayValidationCount =
-        localValidationCount ??
-        state.projectState.projectOverview?.validationCount ??
-        1;
+        localValidationCount ?? state.projectState.projectOverview?.validationCount ?? 1;
     const displayValidationCountAudio =
-        localValidationCountAudio ??
-        state.projectState.projectOverview?.validationCountAudio ??
-        1;
+        localValidationCountAudio ?? state.projectState.projectOverview?.validationCountAudio ?? 1;
 
     // Clear optimistic override once the server has caught up to the local value
     useEffect(() => {
@@ -224,7 +233,8 @@ function MainMenu() {
     // Clean up debounce timers on unmount
     useEffect(() => {
         return () => {
-            if (validationCountDebounceRef.current) clearTimeout(validationCountDebounceRef.current);
+            if (validationCountDebounceRef.current)
+                clearTimeout(validationCountDebounceRef.current);
             if (validationCountAudioDebounceRef.current)
                 clearTimeout(validationCountAudioDebounceRef.current);
             if (localCountFallbackRef.current) clearTimeout(localCountFallbackRef.current);
@@ -233,59 +243,51 @@ function MainMenu() {
         };
     }, []);
 
-    const handleValidationCountChange = useCallback(
-        (newCount: number) => {
-            setLocalValidationCount(newCount);
+    const handleValidationCountChange = useCallback((newCount: number) => {
+        setLocalValidationCount(newCount);
 
-            if (validationCountDebounceRef.current)
-                clearTimeout(validationCountDebounceRef.current);
-            if (localCountFallbackRef.current) clearTimeout(localCountFallbackRef.current);
+        if (validationCountDebounceRef.current) clearTimeout(validationCountDebounceRef.current);
+        if (localCountFallbackRef.current) clearTimeout(localCountFallbackRef.current);
 
-            validationCountDebounceRef.current = setTimeout(() => {
-                try {
-                    vscode.postMessage({
-                        command: "setValidationCountDirect",
-                        data: { count: newCount },
-                    });
-                } catch (error) {
-                    console.error("Could not send validation count:", error);
-                }
-            }, 150);
-
-            // Safety net: clear optimistic state after 5s in case server never confirms
-            localCountFallbackRef.current = setTimeout(() => {
-                setLocalValidationCount(null);
-            }, 5000);
-        },
-        []
-    );
+        validationCountDebounceRef.current = setTimeout(() => {
+            try {
+                vscode.postMessage({
+                    command: "setValidationCountDirect",
+                    data: { count: newCount },
+                });
+            } catch (error) {
+                console.error("Could not send validation count:", error);
+            }
+        }, 150);
 
-    const handleValidationCountAudioChange = useCallback(
-        (newCount: number) => {
-            setLocalValidationCountAudio(newCount);
+        // Safety net: clear optimistic state after 5s in case server never confirms
+        localCountFallbackRef.current = setTimeout(() => {
+            setLocalValidationCount(null);
+        }, 5000);
+    }, []);
 
-            if (validationCountAudioDebounceRef.current)
-                clearTimeout(validationCountAudioDebounceRef.current);
-            if (localCountAudioFallbackRef.current)
-                clearTimeout(localCountAudioFallbackRef.current);
+    const handleValidationCountAudioChange = useCallback((newCount: number) => {
+        setLocalValidationCountAudio(newCount);
 
-            validationCountAudioDebounceRef.current = setTimeout(() => {
-                try {
-                    vscode.postMessage({
-                        command: "setValidationCountAudioDirect",
-                        data: { count: newCount },
-                    });
-                } catch (error) {
-                    console.error("Could not send audio validation count:", error);
-                }
-            }, 150);
-
-            localCountAudioFallbackRef.current = setTimeout(() => {
-                setLocalValidationCountAudio(null);
-            }, 5000);
-        },
-        []
-    );
+        if (validationCountAudioDebounceRef.current)
+            clearTimeout(validationCountAudioDebounceRef.current);
+        if (localCountAudioFallbackRef.current) clearTimeout(localCountAudioFallbackRef.current);
+
+        validationCountAudioDebounceRef.current = setTimeout(() => {
+            try {
+                vscode.postMessage({
+                    command: "setValidationCountAudioDirect",
+                    data: { count: newCount },
+                });
+            } catch (error) {
+                console.error("Could not send audio validation count:", error);
+            }
+        }, 150);
+
+        localCountAudioFallbackRef.current = setTimeout(() => {
+            setLocalValidationCountAudio(null);
+        }, 5000);
+    }, []);
 
     useEffect(() => {
         const handleMessage = (event: MessageEvent) => {
@@ -357,6 +359,14 @@ function MainMenu() {
                         },
                     }));
                     break;
+                case "sessionRecordingUpdate":
+                    setState((prevState) => ({
+                        ...prevState,
+                        sessionRecordingEnabled:
+                            message.data.enabled ?? prevState.sessionRecordingEnabled,
+                    }));
+                    break;
+                // Speech-to-text settings moved to Copilot Settings panel
             }
         };
 
@@ -367,6 +377,7 @@ function MainMenu() {
             vscode.postMessage({ command: "webviewReady" });
             // Request sync settings
             vscode.postMessage({ command: "getSyncSettings" });
+            vscode.postMessage({ command: "getSessionRecordingSetting" });
         } catch (error) {
             console.error("Could not send webviewReady message:", error);
         }
@@ -459,6 +470,23 @@ function MainMenu() {
         }
     };
 
+    const handleSessionRecordingToggleClick = () => {
+        setPendingSessionRecordingEnabled(!state.sessionRecordingEnabled);
+        setIsSessionRecordingDialogOpen(true);
+    };
+
+    const handleProceedSessionRecordingToggle = () => {
+        setIsSessionRecordingDialogOpen(false);
+        handleProjectAction("toggleSessionRecording");
+    };
+
+    const handleCancelSessionRecordingToggle = () => {
+        setIsSessionRecordingDialogOpen(false);
+        setPendingSessionRecordingEnabled(null);
+    };
+
+    const isEnablingSessionRecording = pendingSessionRecordingEnabled === true;
+
     const getLanguageDisplay = (languageObj: any): string => {
         if (!languageObj) return "Missing";
         if (typeof languageObj === "string") return languageObj;
@@ -747,7 +775,8 @@ function MainMenu() {
                                                                 onClick={() => {
                                                                     if (displayValidationCount > 1)
                                                                         handleValidationCountChange(
-                                                                            displayValidationCount - 1
+                                                                            displayValidationCount -
+                                                                                1
                                                                         );
                                                                 }}
                                                                 title="Decrease"
@@ -762,7 +791,8 @@ function MainMenu() {
                                                                 onClick={() => {
                                                                     if (displayValidationCount < 15)
                                                                         handleValidationCountChange(
-                                                                            displayValidationCount + 1
+                                                                            displayValidationCount +
+                                                                                1
                                                                         );
                                                                 }}
                                                                 title="Increase"
@@ -979,6 +1009,15 @@ function MainMenu() {
                                                 disabled: projectState.isCheckingForUpdates,
                                                 spinning: projectState.isCheckingForUpdates,
                                             },
+                                            {
+                                                icon: state.sessionRecordingEnabled
+                                                    ? "codicon-eye"
+                                                    : "codicon-eye-closed",
+                                                label: state.sessionRecordingEnabled
+                                                    ? "Disable Session Recording"
+                                                    : "Enable Session Recording",
+                                                action: handleSessionRecordingToggleClick,
+                                            },
                                             {
                                                 icon: "codicon-close",
                                                 label: "Close Project",
@@ -1102,9 +1141,63 @@ function MainMenu() {
                 onClose={() => setIsTextDisplaySettingsOpen(false)}
                 onApply={handleApplyTextDisplaySettings}
             />
+
+            <Dialog
+                open={isSessionRecordingDialogOpen}
+                onOpenChange={(open) => {
+                    setIsSessionRecordingDialogOpen(open);
+                    if (!open) {
+                        setPendingSessionRecordingEnabled(null);
+                    }
+                }}
+            >
+                <DialogContent>
+                    <DialogHeader>
+                        <DialogTitle>
+                            {isEnablingSessionRecording
+                                ? "Enable Session Recording"
+                                : "Disable Session Recording"}
+                        </DialogTitle>
+                        <DialogDescription asChild>
+                            <div className="space-y-3">
+                                {isEnablingSessionRecording ? (
+                                    <>
+                                        <p>
+                                            Enabling session recording is a debugging tool that will
+                                            take snapshots of your screen and load them locally
+                                            while you work. In the event that an error is triggered
+                                            the most current snapshot will be sent to the dev team
+                                            to support you better. While sensitive information such
+                                            as project name, cell text and labels, and filenames
+                                            will be blurred out, we can't guarantee this for all
+                                            data on your screen.
+                                        </p>
+                                        <p>The project will reload upon proceeding.</p>
+                                    </>
+                                ) : (
+                                    <p>
+                                        The project will reload in order to disable session
+                                        recording.
+                                    </p>
+                                )}
+                            </div>
+                        </DialogDescription>
+                    </DialogHeader>
+                    <DialogFooter>
+                        <Button variant="outline" onClick={handleCancelSessionRecordingToggle}>
+                            Cancel
+                        </Button>
+                        <Button onClick={handleProceedSessionRecordingToggle}>Proceed</Button>
+                    </DialogFooter>
+                </DialogContent>
+            </Dialog>
         </div>
     );
 }
 
 const root = createRoot(document.getElementById("root")!);
-root.render(<MainMenu />);
+root.render(
+    <ErrorBoundary>
+        <MainMenu />
+    </ErrorBoundary>
+);
diff --git a/webviews/codex-webviews/src/NavigationView/index.tsx b/webviews/codex-webviews/src/NavigationView/index.tsx
index 14ccf6d10..f37723c4b 100644
--- a/webviews/codex-webviews/src/NavigationView/index.tsx
+++ b/webviews/codex-webviews/src/NavigationView/index.tsx
@@ -1,5 +1,7 @@
+import "../shared/posthog";
 import React, { useState, useEffect, useMemo } from "react";
 import { createRoot } from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import { Button } from "../components/ui/button";
 import { Input } from "../components/ui/input";
 import bibleData from "../assets/bible-books-lookup.json";
@@ -1129,4 +1131,8 @@ function NavigationView() {
 }
 
 const root = createRoot(document.getElementById("root")!);
-root.render(<NavigationView />);
+root.render(
+    <ErrorBoundary>
+        <NavigationView />
+    </ErrorBoundary>
+);
diff --git a/webviews/codex-webviews/src/NewSourceUploader/index.tsx b/webviews/codex-webviews/src/NewSourceUploader/index.tsx
index 7c229e62b..7e4afd80b 100644
--- a/webviews/codex-webviews/src/NewSourceUploader/index.tsx
+++ b/webviews/codex-webviews/src/NewSourceUploader/index.tsx
@@ -1,13 +1,17 @@
+import "../shared/posthog";
 import { Buffer } from "buffer";
 import process from "process";
 
 import React from "react";
 import ReactDOM from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import App from "./NewSourceUploader";
 import "../tailwind.css";
 
 ReactDOM.createRoot(document.getElementById("root")!).render(
-    <React.StrictMode>
-        <App />
-    </React.StrictMode>
+    <ErrorBoundary>
+        <React.StrictMode>
+            <App />
+        </React.StrictMode>
+    </ErrorBoundary>
 );
diff --git a/webviews/codex-webviews/src/ParallelView/index.tsx b/webviews/codex-webviews/src/ParallelView/index.tsx
index bbfd56118..5234b8b18 100644
--- a/webviews/codex-webviews/src/ParallelView/index.tsx
+++ b/webviews/codex-webviews/src/ParallelView/index.tsx
@@ -1,9 +1,13 @@
+import "../shared/posthog";
 import React from "react";
 import ReactDOM from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import ParallelView from "./ParallelView";
 
 ReactDOM.createRoot(document.getElementById("root")!).render(
-    <React.StrictMode>
-        <ParallelView />
-    </React.StrictMode>
+    <ErrorBoundary>
+        <React.StrictMode>
+            <ParallelView />
+        </React.StrictMode>
+    </ErrorBoundary>
 );
diff --git a/webviews/codex-webviews/src/PublishProject/index.tsx b/webviews/codex-webviews/src/PublishProject/index.tsx
index 1c95316d3..3f906050c 100644
--- a/webviews/codex-webviews/src/PublishProject/index.tsx
+++ b/webviews/codex-webviews/src/PublishProject/index.tsx
@@ -1,9 +1,13 @@
+import "../shared/posthog";
 import React from "react";
 import ReactDOM from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import PublishProject from "./PublishProject";
 
 ReactDOM.createRoot(document.getElementById("root")!).render(
-    <React.StrictMode>
-        <PublishProject />
-    </React.StrictMode>
+    <ErrorBoundary>
+        <React.StrictMode>
+            <PublishProject />
+        </React.StrictMode>
+    </ErrorBoundary>
 );
diff --git a/webviews/codex-webviews/src/SplashScreen/index.tsx b/webviews/codex-webviews/src/SplashScreen/index.tsx
index 7ec3f65a3..93eccbaf5 100644
--- a/webviews/codex-webviews/src/SplashScreen/index.tsx
+++ b/webviews/codex-webviews/src/SplashScreen/index.tsx
@@ -1,10 +1,11 @@
+import "../shared/posthog";
 import React from "react";
 import { createRoot } from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import { SplashScreen } from "./SplashScreen";
 import "../tailwind.css";
 import "./SplashScreen.css";
 
-// Initialize the app when the DOM is loaded
 document.addEventListener("DOMContentLoaded", () => {
     const rootElement = document.getElementById("root");
 
@@ -14,8 +15,11 @@ document.addEventListener("DOMContentLoaded", () => {
     }
 
     const root = createRoot(rootElement);
-    root.render(React.createElement(SplashScreen));
+    root.render(
+        <ErrorBoundary>
+            <SplashScreen />
+        </ErrorBoundary>
+    );
 });
 
-// Default export for Vite
 export default SplashScreen;
diff --git a/webviews/codex-webviews/src/StartupFlow/index.tsx b/webviews/codex-webviews/src/StartupFlow/index.tsx
index 2e9cfc1dd..31fa7d871 100644
--- a/webviews/codex-webviews/src/StartupFlow/index.tsx
+++ b/webviews/codex-webviews/src/StartupFlow/index.tsx
@@ -1,10 +1,14 @@
+import "../shared/posthog";
 import React from "react";
 import ReactDOM from "react-dom/client";
+import { ErrorBoundary } from "../shared/ErrorBoundary";
 import "../tailwind.css";
 import {StartupFlowView} from "./StartupFlowView";
 
 ReactDOM.createRoot(document.getElementById("root")!).render(
-    <React.StrictMode>
-        <StartupFlowView />
-    </React.StrictMode>
+    <ErrorBoundary>
+        <React.StrictMode>
+            <StartupFlowView />
+        </React.StrictMode>
+    </ErrorBoundary>
 );
diff --git a/webviews/codex-webviews/src/shared/ErrorBoundary.tsx b/webviews/codex-webviews/src/shared/ErrorBoundary.tsx
new file mode 100644
index 000000000..1ac8d1c7a
--- /dev/null
+++ b/webviews/codex-webviews/src/shared/ErrorBoundary.tsx
@@ -0,0 +1,54 @@
+import React from "react";
+import { captureException } from "./posthog";
+
+interface ErrorBoundaryProps {
+    fallback?: React.ReactNode;
+    children: React.ReactNode;
+}
+
+interface ErrorBoundaryState {
+    hasError: boolean;
+}
+
+export class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps) {
+        super(props);
+        this.state = { hasError: false };
+    }
+
+    static getDerivedStateFromError(): ErrorBoundaryState {
+        return { hasError: true };
+    }
+
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {
+        captureException(error, {
+            source: "ReactErrorBoundary",
+            componentStack: errorInfo.componentStack ?? "",
+        });
+    }
+
+    render() {
+        if (this.state.hasError) {
+            if (this.props.fallback) {
+                return this.props.fallback;
+            }
+
+            return (
+                <div
+                    style={{
+                        padding: "2rem",
+                        textAlign: "center",
+                        color: "var(--foreground, #ccc)",
+                    }}
+                >
+                    <h2>Something went wrong</h2>
+                    <p style={{ marginTop: "0.5rem", opacity: 0.7 }}>
+                        An unexpected error occurred. Try reloading the panel.
+                    </p>
+                </div>
+            );
+        }
+
+        return this.props.children;
+    }
+}
diff --git a/webviews/codex-webviews/src/shared/posthog.ts b/webviews/codex-webviews/src/shared/posthog.ts
new file mode 100644
index 000000000..bc562a6dd
--- /dev/null
+++ b/webviews/codex-webviews/src/shared/posthog.ts
@@ -0,0 +1,59 @@
+import posthog from "posthog-js";
+
+interface PostHogConfig {
+    token: string;
+    host: string;
+    distinctId: string;
+    enableRecording: boolean;
+}
+
+const config = (window as any).__POSTHOG_CONFIG__ as PostHogConfig | undefined;
+
+if (config?.token) {
+    posthog.init(config.token, {
+        api_host: config.host,
+        autocapture: false,
+        rageclick: false,
+        capture_pageview: false,
+        capture_pageleave: false,
+        disable_session_recording: !config.enableRecording,
+        session_recording: {
+            maskAllInputs: false,
+            maskTextSelector: ".ph-no-capture",
+            collectFonts: false,
+            recordCrossOriginIframes: false,
+        },
+        persistence: "localStorage",
+    });
+
+    if (config.distinctId) {
+        posthog.identify(config.distinctId);
+    }
+}
+
+export const captureException = (
+    error: Error | unknown,
+    context?: Record<string, string>
+): void => {
+    if (!config?.token) {
+        return;
+    }
+
+    const err = error instanceof Error ? error : new Error(String(error));
+    posthog.captureException(err, context);
+};
+
+window.addEventListener("error", (event) => {
+    captureException(event.error ?? event.message, {
+        source: "window.onerror",
+        filename: event.filename ?? "",
+        lineno: String(event.lineno ?? ""),
+        colno: String(event.colno ?? ""),
+    });
+});
+
+window.addEventListener("unhandledrejection", (event) => {
+    captureException(event.reason, { source: "unhandledrejection" });
+});
+
+export { posthog };