From b2176435bd6d3218a82ef98621df2cfa18a11afd Mon Sep 17 00:00:00 2001
From: Arjun <6592213+arkml@users.noreply.github.com>
Date: Wed, 10 Jun 2026 23:11:37 +0530
Subject: [PATCH] code mode initial commit

---
 apps/x/ANALYTICS.md                           |   3 +-
 apps/x/apps/main/src/ipc.ts                   | 132 +++-
 apps/x/apps/main/src/main.ts                  |   4 +
 apps/x/apps/renderer/package.json             |   7 +
 apps/x/apps/renderer/src/App.tsx              |  82 ++-
 .../x/apps/renderer/src/components/code/cm.ts |  72 ++
 .../src/components/code/code-chat.tsx         | 271 ++++++++
 .../src/components/code/code-view.tsx         | 173 +++++
 .../src/components/code/diff-viewer.tsx       | 100 +++
 .../src/components/code/file-tree.tsx         | 101 +++
 .../src/components/code/file-viewer.tsx       |  70 ++
 .../components/code/new-session-dialog.tsx    | 206 ++++++
 .../src/components/code/session-rail.tsx      | 168 +++++
 .../src/components/code/use-code-chat.ts      | 378 +++++++++++
 .../src/components/code/use-code-sessions.ts  |  72 ++
 .../src/components/code/workspace-pane.tsx    | 254 ++++++++
 .../renderer/src/components/coding-run.tsx    |  29 +-
 .../src/components/sidebar-content.tsx        |  11 +-
 apps/x/packages/core/src/agents/runtime.ts    |   8 +-
 .../x/packages/core/src/analytics/use_case.ts |   2 +-
 .../core/src/application/lib/builtin-tools.ts |  22 +-
 .../core/src/application/lib/exec-tool.ts     |   5 +
 .../core/src/application/lib/message-queue.ts |  12 +-
 .../core/src/code-mode/acp/manager.ts         |  23 +-
 .../core/src/code-mode/git/service.ts         | 240 +++++++
 .../core/src/code-mode/projects/fs.ts         |  83 +++
 .../core/src/code-mode/projects/repo.ts       |  69 ++
 .../core/src/code-mode/sessions/repo.ts       |  63 ++
 .../core/src/code-mode/sessions/service.ts    | 335 ++++++++++
 .../src/code-mode/sessions/status-tracker.ts  | 136 ++++
 apps/x/packages/core/src/di/container.ts      |  11 +
 apps/x/packages/core/src/runs/repo.ts         |   1 +
 apps/x/packages/core/src/runs/runs.ts         |   4 +-
 apps/x/packages/core/src/workspace/watcher.ts |   8 +
 apps/x/packages/shared/src/code-sessions.ts   |  71 ++
 apps/x/packages/shared/src/index.ts           |   1 +
 apps/x/packages/shared/src/ipc.ts             | 170 ++++-
 apps/x/packages/shared/src/runs.ts            |   3 +
 apps/x/pnpm-lock.yaml                         | 613 ++++++++++++++++--
 39 files changed, 3919 insertions(+), 94 deletions(-)
 create mode 100644 apps/x/apps/renderer/src/components/code/cm.ts
 create mode 100644 apps/x/apps/renderer/src/components/code/code-chat.tsx
 create mode 100644 apps/x/apps/renderer/src/components/code/code-view.tsx
 create mode 100644 apps/x/apps/renderer/src/components/code/diff-viewer.tsx
 create mode 100644 apps/x/apps/renderer/src/components/code/file-tree.tsx
 create mode 100644 apps/x/apps/renderer/src/components/code/file-viewer.tsx
 create mode 100644 apps/x/apps/renderer/src/components/code/new-session-dialog.tsx
 create mode 100644 apps/x/apps/renderer/src/components/code/session-rail.tsx
 create mode 100644 apps/x/apps/renderer/src/components/code/use-code-chat.ts
 create mode 100644 apps/x/apps/renderer/src/components/code/use-code-sessions.ts
 create mode 100644 apps/x/apps/renderer/src/components/code/workspace-pane.tsx
 create mode 100644 apps/x/packages/core/src/code-mode/git/service.ts
 create mode 100644 apps/x/packages/core/src/code-mode/projects/fs.ts
 create mode 100644 apps/x/packages/core/src/code-mode/projects/repo.ts
 create mode 100644 apps/x/packages/core/src/code-mode/sessions/repo.ts
 create mode 100644 apps/x/packages/core/src/code-mode/sessions/service.ts
 create mode 100644 apps/x/packages/core/src/code-mode/sessions/status-tracker.ts
 create mode 100644 apps/x/packages/shared/src/code-sessions.ts

diff --git a/apps/x/ANALYTICS.md b/apps/x/ANALYTICS.md
index 2d9816d0..5ddfcf6e 100644
--- a/apps/x/ANALYTICS.md
+++ b/apps/x/ANALYTICS.md
@@ -24,7 +24,7 @@ Emitted whenever ai-sdk returns token usage (one event per LLM call, not per run
 
 | Property | Type | Notes |
 |---|---|---|
-| `use_case` | enum | `copilot_chat` / `live_note_agent` / `meeting_note` / `knowledge_sync` |
+| `use_case` | enum | `copilot_chat` / `live_note_agent` / `meeting_note` / `knowledge_sync` / `code_session` |
 | `sub_use_case` | string? | Refines `use_case` — see taxonomy table below |
 | `agent_name` | string? | Present when the call goes through an agent run (`createRun`); omitted for direct `generateText`/`generateObject` |
 | `model` | string | e.g. `claude-sonnet-4-6` |
@@ -57,6 +57,7 @@ Every `llm_usage` emit point in the codebase:
 | `knowledge_sync` | `inline_task_run` | yes | Inline `@rowboat` task execution (two call sites) | `packages/core/src/knowledge/inline_tasks.ts:471, 552` (createRun) |
 | `knowledge_sync` | `inline_task_classify` | no | Inline task scheduling classifier (`generateText`) | `packages/core/src/knowledge/inline_tasks.ts:673` |
 | `knowledge_sync` | `pre_built` | yes | Pre-built scheduled agents | `packages/core/src/pre_built/runner.ts:43` (createRun) |
+| `code_session` | (none) | yes | Code-section coding session in Rowboat mode (direct mode talks to the on-device coding agent and emits no `llm_usage`) | `packages/core/src/code-mode/sessions/service.ts` (createRun) |
 
 ##### `live_note_agent` sub-use-case shape
 
diff --git a/apps/x/apps/main/src/ipc.ts b/apps/x/apps/main/src/ipc.ts
index e5d407f8..a7fa35af 100644
--- a/apps/x/apps/main/src/ipc.ts
+++ b/apps/x/apps/main/src/ipc.ts
@@ -34,6 +34,13 @@ import { IGranolaConfigRepo } from '@x/core/dist/knowledge/granola/repo.js';
 import { ICodeModeConfigRepo } from '@x/core/dist/code-mode/repo.js';
 import { CodePermissionRegistry } from '@x/core/dist/code-mode/acp/permission-registry.js';
 import { checkCodeModeAgentStatus } from '@x/core/dist/code-mode/status.js';
+import type { ICodeProjectsRepo } from '@x/core/dist/code-mode/projects/repo.js';
+import type { ICodeSessionsRepo } from '@x/core/dist/code-mode/sessions/repo.js';
+import { CodeSessionService } from '@x/core/dist/code-mode/sessions/service.js';
+import { CodeSessionStatusTracker } from '@x/core/dist/code-mode/sessions/status-tracker.js';
+import * as codeGit from '@x/core/dist/code-mode/git/service.js';
+import { readProjectDir, readProjectFile } from '@x/core/dist/code-mode/projects/fs.js';
+import type { CodeSession } from '@x/shared/dist/code-sessions.js';
 import { invalidateCopilotInstructionsCache } from '@x/core/dist/application/assistant/instructions.js';
 import { triggerSync as triggerGranolaSync } from '@x/core/dist/knowledge/granola/sync.js';
 import { ISlackConfigRepo } from '@x/core/dist/slack/repo.js';
@@ -372,6 +379,32 @@ export function emitOAuthEvent(event: { provider: string; success: boolean; erro
   }
 }
 
+async function requireCodeSession(sessionId: string): Promise<CodeSession> {
+  const repo = container.resolve<ICodeSessionsRepo>('codeSessionsRepo');
+  const session = await repo.get(sessionId);
+  if (!session) {
+    throw new Error(`Unknown code session: ${sessionId}`);
+  }
+  return session;
+}
+
+let codeSessionStatusWatcher: (() => void) | null = null;
+export async function startCodeSessionStatusWatcher(): Promise<void> {
+  if (codeSessionStatusWatcher) {
+    return;
+  }
+  const tracker = container.resolve<CodeSessionStatusTracker>('codeSessionStatusTracker');
+  await tracker.start();
+  codeSessionStatusWatcher = tracker.onTransition((sessionId, status) => {
+    const windows = BrowserWindow.getAllWindows();
+    for (const win of windows) {
+      if (!win.isDestroyed() && win.webContents) {
+        win.webContents.send('codeSession:status', { sessionId, status });
+      }
+    }
+  });
+}
+
 let runsWatcher: (() => void) | null = null;
 export async function startRunsWatcher(): Promise<void> {
   if (runsWatcher) {
@@ -531,7 +564,7 @@ export function setupIpcHandlers() {
       return runsCore.createRun(args);
     },
     'runs:createMessage': async (_event, args) => {
-      return { messageId: await runsCore.createMessage(args.runId, args.message, args.voiceInput, args.voiceOutput, args.searchEnabled, args.middlePaneContext, args.codeMode) };
+      return { messageId: await runsCore.createMessage(args.runId, args.message, args.voiceInput, args.voiceOutput, args.searchEnabled, args.middlePaneContext, args.codeMode, args.codeCwd, args.codePolicy) };
     },
     'runs:authorizePermission': async (_event, args) => {
       await runsCore.authorizePermission(args.runId, args.authorization);
@@ -654,6 +687,103 @@ export function setupIpcHandlers() {
     'codeMode:checkAgentStatus': async () => {
       return await checkCodeModeAgentStatus();
     },
+    'codeProject:add': async (_event, args) => {
+      const repo = container.resolve<ICodeProjectsRepo>('codeProjectsRepo');
+      const project = await repo.add(args.path);
+      const git = await codeGit.repoInfo(project.path);
+      return { project, git };
+    },
+    'codeProject:remove': async (_event, args) => {
+      const repo = container.resolve<ICodeProjectsRepo>('codeProjectsRepo');
+      await repo.remove(args.projectId);
+      return { success: true };
+    },
+    'codeProject:list': async () => {
+      const repo = container.resolve<ICodeProjectsRepo>('codeProjectsRepo');
+      const projects = await repo.list();
+      return {
+        projects: await Promise.all(projects.map(async (project) => ({
+          project,
+          git: await codeGit.repoInfo(project.path),
+        }))),
+      };
+    },
+    'codeSession:create': async (_event, args) => {
+      const service = container.resolve<CodeSessionService>('codeSessionService');
+      const session = await service.create(args);
+      return { session };
+    },
+    'codeSession:list': async () => {
+      const repo = container.resolve<ICodeSessionsRepo>('codeSessionsRepo');
+      const tracker = container.resolve<CodeSessionStatusTracker>('codeSessionStatusTracker');
+      return { sessions: await repo.list(), statuses: tracker.getStatuses() };
+    },
+    'codeSession:update': async (_event, args) => {
+      const service = container.resolve<CodeSessionService>('codeSessionService');
+      return { session: await service.update(args.sessionId, args.patch) };
+    },
+    'codeSession:delete': async (_event, args) => {
+      const service = container.resolve<CodeSessionService>('codeSessionService');
+      await service.delete(args.sessionId, {
+        removeWorktree: args.removeWorktree,
+        deleteBranch: args.deleteBranch,
+      });
+      return { success: true };
+    },
+    'codeSession:sendMessage': async (_event, args) => {
+      const service = container.resolve<CodeSessionService>('codeSessionService');
+      // Intentionally not awaited: the turn can run for minutes and streams over
+      // runs:events. sendMessage validates synchronously enough that busy/unknown
+      // errors are reported via the run's error events instead.
+      const resultPromise = service.sendMessage(args.sessionId, args.text);
+      // Surface immediate rejections (busy session, unknown id) to the caller.
+      const result = await Promise.race([
+        resultPromise,
+        new Promise<{ accepted: true }>((resolve) => setTimeout(() => resolve({ accepted: true }), 300)),
+      ]);
+      resultPromise.catch((err) => console.error('codeSession:sendMessage failed', err));
+      return result;
+    },
+    'codeSession:stop': async (_event, args) => {
+      const service = container.resolve<CodeSessionService>('codeSessionService');
+      await service.stop(args.sessionId);
+      return { success: true };
+    },
+    'codeSession:gitStatus': async (_event, args) => {
+      const session = await requireCodeSession(args.sessionId);
+      const info = await codeGit.repoInfo(session.cwd);
+      if (!info.isGitRepo) {
+        return { isRepo: false, branch: null, hasCommits: false, files: [] };
+      }
+      const files = await codeGit.status(session.cwd);
+      return { isRepo: true, branch: info.branch, hasCommits: info.hasCommits, files };
+    },
+    'codeSession:fileDiff': async (_event, args) => {
+      const session = await requireCodeSession(args.sessionId);
+      return codeGit.fileDiff(session.cwd, args.path);
+    },
+    'codeSession:readdir': async (_event, args) => {
+      const session = await requireCodeSession(args.sessionId);
+      return { entries: await readProjectDir(session.cwd, args.relPath) };
+    },
+    'codeSession:readFile': async (_event, args) => {
+      const session = await requireCodeSession(args.sessionId);
+      return readProjectFile(session.cwd, args.relPath);
+    },
+    'codeSession:mergeBack': async (_event, args) => {
+      const service = container.resolve<CodeSessionService>('codeSessionService');
+      return service.mergeBack(args.sessionId);
+    },
+    'codeSession:cleanupWorktree': async (_event, args) => {
+      const service = container.resolve<CodeSessionService>('codeSessionService');
+      try {
+        await service.cleanupWorktree(args.sessionId, args.deleteBranch);
+        return { success: true };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to clean up worktree';
+        return { success: false, error: message };
+      }
+    },
     'granola:setConfig': async (_event, args) => {
       const repo = container.resolve<IGranolaConfigRepo>('granolaConfigRepo');
       await repo.setConfig({ enabled: args.enabled });
diff --git a/apps/x/apps/main/src/main.ts b/apps/x/apps/main/src/main.ts
index f4415b5d..53cf9e63 100644
--- a/apps/x/apps/main/src/main.ts
+++ b/apps/x/apps/main/src/main.ts
@@ -3,6 +3,7 @@ import path from "node:path";
 import {
   setupIpcHandlers,
   startRunsWatcher,
+  startCodeSessionStatusWatcher,
   startServicesWatcher,
   startLiveNoteAgentWatcher,
   startBackgroundTaskAgentWatcher,
@@ -332,6 +333,9 @@ app.whenReady().then(async () => {
   // start runs watcher
   startRunsWatcher();
 
+  // start code-session status tracker (derives working/needs-you/idle + notifications)
+  startCodeSessionStatusWatcher();
+
   // start services watcher
   startServicesWatcher();
 
diff --git a/apps/x/apps/renderer/package.json b/apps/x/apps/renderer/package.json
index 67876189..3482b58e 100644
--- a/apps/x/apps/renderer/package.json
+++ b/apps/x/apps/renderer/package.json
@@ -9,7 +9,13 @@
     "preview": "vite preview"
   },
   "dependencies": {
+    "@codemirror/language": "^6.12.3",
+    "@codemirror/language-data": "^6.5.2",
+    "@codemirror/merge": "^6.12.2",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/view": "^6.43.1",
     "@eigenpal/docx-editor-react": "^1.0.3",
+    "@lezer/highlight": "^1.2.3",
     "@radix-ui/react-avatar": "^1.1.11",
     "@radix-ui/react-collapsible": "^1.1.12",
     "@radix-ui/react-context-menu": "^2.2.16",
@@ -42,6 +48,7 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
+    "codemirror": "^6.0.2",
     "lucide-react": "^0.562.0",
     "mermaid": "^11.14.0",
     "motion": "^12.23.26",
diff --git a/apps/x/apps/renderer/src/App.tsx b/apps/x/apps/renderer/src/App.tsx
index b850b57f..417d2284 100644
--- a/apps/x/apps/renderer/src/App.tsx
+++ b/apps/x/apps/renderer/src/App.tsx
@@ -34,6 +34,7 @@ import { KnowledgeView } from '@/components/knowledge-view';
 import { ChatHistoryView } from '@/components/chat-history-view';
 import { HomeView } from '@/components/home-view';
 import { MeetingsView } from '@/components/meetings-view';
+import { CodeView } from '@/components/code/code-view';
 import { SidebarSectionProvider } from '@/contexts/sidebar-context';
 import {
   Conversation,
@@ -199,6 +200,7 @@ const KNOWLEDGE_VIEW_TAB_PATH = '__rowboat_knowledge_view__'
 const CHAT_HISTORY_TAB_PATH = '__rowboat_chat_history__'
 const HOME_TAB_PATH = '__rowboat_home__'
 const BASES_DEFAULT_TAB_PATH = '__rowboat_bases_default__'
+const CODE_TAB_PATH = '__rowboat_code__'
 
 const clampNumber = (value: number, min: number, max: number) =>
   Math.min(max, Math.max(min, value))
@@ -336,6 +338,7 @@ const isKnowledgeViewTabPath = (path: string) => path === KNOWLEDGE_VIEW_TAB_PAT
 const isChatHistoryTabPath = (path: string) => path === CHAT_HISTORY_TAB_PATH
 const isHomeTabPath = (path: string) => path === HOME_TAB_PATH
 const isBaseFilePath = (path: string) => path.endsWith('.base') || path === BASES_DEFAULT_TAB_PATH
+const isCodeTabPath = (path: string) => path === CODE_TAB_PATH
 
 const getSuggestedTopicTargetFolder = (category?: string) => {
   const normalized = category?.trim().toLowerCase()
@@ -589,6 +592,7 @@ type ViewState =
   | { type: 'knowledge-view'; folderPath?: string }
   | { type: 'chat-history' }
   | { type: 'home' }
+  | { type: 'code' }
 
 function viewStatesEqual(a: ViewState, b: ViewState): boolean {
   if (a.type !== b.type) return false
@@ -652,6 +656,8 @@ function parseDeepLink(input: string): ViewState | null {
       return { type: 'chat-history' }
     case 'home':
       return { type: 'home' }
+    case 'code':
+      return { type: 'code' }
     default:
       return null
   }
@@ -1034,7 +1040,7 @@ function App() {
   }, [])
 
   // Runs history state
-  type RunListItem = { id: string; title?: string; createdAt: string; agentId: string }
+  type RunListItem = { id: string; title?: string; createdAt: string; agentId: string; useCase?: string }
   const [runs, setRuns] = useState<RunListItem[]>([])
 
   // Chat tab state
@@ -1159,6 +1165,12 @@ function App() {
   const [activeFileTabId, setActiveFileTabId] = useState<string | null>('home-tab')
   const activeFileTabIdRef = useRef(activeFileTabId)
   activeFileTabIdRef.current = activeFileTabId
+  // The Code section is tab-derived (no boolean to keep in sync with the other
+  // section flags): it is open exactly while its sentinel tab is active.
+  const isCodeOpen = React.useMemo(() => {
+    const activeTab = fileTabs.find((tab) => tab.id === activeFileTabId)
+    return activeTab ? isCodeTabPath(activeTab.path) : false
+  }, [fileTabs, activeFileTabId])
   const [editorSessionByTabId, setEditorSessionByTabId] = useState<Record<string, number>>({})
   const fileHistoryHandlersRef = useRef<Map<string, MarkdownHistoryHandlers>>(new Map())
   const fileTabIdCounterRef = useRef(0)
@@ -1175,6 +1187,7 @@ function App() {
     if (isKnowledgeViewTabPath(tab.path)) return 'Notes'
     if (isChatHistoryTabPath(tab.path)) return 'Chat history'
     if (isHomeTabPath(tab.path)) return 'Home'
+    if (isCodeTabPath(tab.path)) return 'Code'
     if (tab.path === BASES_DEFAULT_TAB_PATH) return 'Bases'
     if (tab.path.endsWith('.base')) return tab.path.split('/').pop()?.replace(/\.base$/i, '') || 'Base'
     return tab.path.split('/').pop()?.replace(/\.md$/i, '') || tab.path
@@ -1807,8 +1820,8 @@ function App() {
         cursor = result.nextCursor
       } while (cursor)
 
-      // Filter for copilot runs only
-      const copilotRuns = allRuns.filter((run: RunListItem) => run.agentId === 'copilot')
+      // Filter for copilot chats only (Code-section sessions live in the Code view)
+      const copilotRuns = allRuns.filter((run: RunListItem) => run.agentId === 'copilot' && run.useCase !== 'code_session')
       setRuns(copilotRuns)
     } catch (err) {
       console.error('Failed to load runs:', err)
@@ -3147,6 +3160,14 @@ function App() {
       setIsHomeOpen(true)
       return
     }
+    if (isCodeTabPath(tab.path)) {
+      // isCodeOpen itself is derived from the active tab — just clear the rest.
+      setSelectedPath(null)
+      setIsGraphOpen(false)
+      setIsSuggestedTopicsOpen(false)
+      setIsMeetingsOpen(false); setIsLiveNotesOpen(false); setIsBgTasksOpen(false); setIsEmailOpen(false); setIsWorkspaceOpen(false); setIsKnowledgeViewOpen(false); setIsChatHistoryOpen(false); setIsHomeOpen(false)
+      return
+    }
     setIsGraphOpen(false)
     setIsSuggestedTopicsOpen(false)
     setIsMeetingsOpen(false); setIsLiveNotesOpen(false); setIsBgTasksOpen(false); setIsEmailOpen(false); setIsWorkspaceOpen(false); setIsKnowledgeViewOpen(false); setIsChatHistoryOpen(false); setIsHomeOpen(false)
@@ -3155,7 +3176,7 @@ function App() {
 
   const closeFileTab = useCallback((tabId: string) => {
     const closingTab = fileTabs.find(t => t.id === tabId)
-    if (closingTab && !isGraphTabPath(closingTab.path) && !isSuggestedTopicsTabPath(closingTab.path) && !isLiveNotesTabPath(closingTab.path) && !isBgTasksTabPath(closingTab.path) && !isEmailTabPath(closingTab.path) && !isWorkspaceTabPath(closingTab.path) && !isKnowledgeViewTabPath(closingTab.path) && !isChatHistoryTabPath(closingTab.path) && !isHomeTabPath(closingTab.path) && !isBaseFilePath(closingTab.path)) {
+    if (closingTab && !isGraphTabPath(closingTab.path) && !isSuggestedTopicsTabPath(closingTab.path) && !isLiveNotesTabPath(closingTab.path) && !isBgTasksTabPath(closingTab.path) && !isEmailTabPath(closingTab.path) && !isWorkspaceTabPath(closingTab.path) && !isKnowledgeViewTabPath(closingTab.path) && !isChatHistoryTabPath(closingTab.path) && !isHomeTabPath(closingTab.path) && !isCodeTabPath(closingTab.path) && !isBaseFilePath(closingTab.path)) {
       removeEditorCacheForPath(closingTab.path)
       initialContentByPathRef.current.delete(closingTab.path)
       untitledRenameReadyPathsRef.current.delete(closingTab.path)
@@ -3548,10 +3569,11 @@ function App() {
     if (isKnowledgeViewOpen) return { type: 'knowledge-view', folderPath: knowledgeViewFolderPath ?? undefined }
     if (isChatHistoryOpen) return { type: 'chat-history' }
     if (isHomeOpen) return { type: 'home' }
+    if (isCodeOpen) return { type: 'code' }
     if (selectedPath) return { type: 'file', path: selectedPath }
     if (isGraphOpen) return { type: 'graph' }
     return { type: 'chat', runId }
-  }, [selectedBackgroundTask, isEmailOpen, isMeetingsOpen, isLiveNotesOpen, isBgTasksOpen, isSuggestedTopicsOpen, selectedPath, isGraphOpen, isWorkspaceOpen, isKnowledgeViewOpen, knowledgeViewFolderPath, isChatHistoryOpen, isHomeOpen, workspaceInitialPath, runId])
+  }, [selectedBackgroundTask, isEmailOpen, isMeetingsOpen, isLiveNotesOpen, isBgTasksOpen, isSuggestedTopicsOpen, selectedPath, isGraphOpen, isWorkspaceOpen, isKnowledgeViewOpen, knowledgeViewFolderPath, isChatHistoryOpen, isHomeOpen, isCodeOpen, workspaceInitialPath, runId])
 
   const appendUnique = useCallback((stack: ViewState[], entry: ViewState) => {
     const last = stack[stack.length - 1]
@@ -3696,6 +3718,17 @@ function App() {
     setActiveFileTabId(id)
   }, [fileTabs])
 
+  const ensureCodeFileTab = useCallback(() => {
+    const existing = fileTabs.find((tab) => isCodeTabPath(tab.path))
+    if (existing) {
+      setActiveFileTabId(existing.id)
+      return
+    }
+    const id = newFileTabId()
+    setFileTabs((prev) => [...prev, { id, path: CODE_TAB_PATH }])
+    setActiveFileTabId(id)
+  }, [fileTabs])
+
   const openEmailView = useCallback((threadId?: string) => {
     setSelectedPath(null)
     setIsGraphOpen(false)
@@ -3751,6 +3784,18 @@ function App() {
     ensureMeetingsFileTab()
   }, [ensureMeetingsFileTab])
 
+  const openCodeView = useCallback(() => {
+    setSelectedPath(null)
+    setIsGraphOpen(false)
+    setIsBrowserOpen(false)
+    setIsSuggestedTopicsOpen(false)
+    setIsMeetingsOpen(false); setIsLiveNotesOpen(false); setIsBgTasksOpen(false); setIsEmailOpen(false); setIsWorkspaceOpen(false); setIsKnowledgeViewOpen(false); setIsChatHistoryOpen(false); setIsHomeOpen(false)
+    setSelectedBackgroundTask(null)
+    setExpandedFrom(null)
+    setIsRightPaneMaximized(false)
+    ensureCodeFileTab()
+  }, [ensureCodeFileTab])
+
   const applyViewState = useCallback(async (view: ViewState) => {
     switch (view.type) {
       case 'file':
@@ -3931,6 +3976,17 @@ function App() {
         setIsHomeOpen(true)
         ensureHomeFileTab()
         return
+      case 'code':
+        setSelectedPath(null)
+        setIsGraphOpen(false)
+        setIsBrowserOpen(false)
+        setExpandedFrom(null)
+        setIsRightPaneMaximized(false)
+        setSelectedBackgroundTask(null)
+        setIsSuggestedTopicsOpen(false)
+        setIsMeetingsOpen(false); setIsLiveNotesOpen(false); setIsBgTasksOpen(false); setIsEmailOpen(false); setIsWorkspaceOpen(false); setIsKnowledgeViewOpen(false); setIsChatHistoryOpen(false); setIsHomeOpen(false)
+        ensureCodeFileTab()
+        return
       case 'chat':
         setSelectedPath(null)
         setIsGraphOpen(false)
@@ -3959,7 +4015,7 @@ function App() {
         }
         return
     }
-  }, [ensureEmailFileTab, ensureMeetingsFileTab, ensureLiveNotesFileTab, ensureFileTabForPath, ensureGraphFileTab, ensureSuggestedTopicsFileTab, ensureWorkspaceFileTab, ensureKnowledgeViewFileTab, ensureChatHistoryFileTab, ensureHomeFileTab, handleNewChat, isRightPaneMaximized, loadRun])
+  }, [ensureEmailFileTab, ensureMeetingsFileTab, ensureLiveNotesFileTab, ensureFileTabForPath, ensureGraphFileTab, ensureSuggestedTopicsFileTab, ensureWorkspaceFileTab, ensureKnowledgeViewFileTab, ensureChatHistoryFileTab, ensureHomeFileTab, ensureCodeFileTab, handleNewChat, isRightPaneMaximized, loadRun])
 
   const navigateToView = useCallback(async (nextView: ViewState) => {
     const current = currentViewState
@@ -4294,7 +4350,7 @@ function App() {
   }, [])
 
   // Keyboard shortcut: Ctrl+L to toggle main chat view
-  const isFullScreenChat = !selectedPath && !isGraphOpen && !isSuggestedTopicsOpen && !isMeetingsOpen && !isLiveNotesOpen && !isBgTasksOpen && !isEmailOpen && !isWorkspaceOpen && !isKnowledgeViewOpen && !isChatHistoryOpen && !isHomeOpen && !selectedBackgroundTask && !isBrowserOpen
+  const isFullScreenChat = !selectedPath && !isGraphOpen && !isSuggestedTopicsOpen && !isMeetingsOpen && !isLiveNotesOpen && !isBgTasksOpen && !isEmailOpen && !isWorkspaceOpen && !isKnowledgeViewOpen && !isChatHistoryOpen && !isHomeOpen && !isCodeOpen && !selectedBackgroundTask && !isBrowserOpen
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
       if ((e.ctrlKey || e.metaKey) && e.key === 'l') {
@@ -5369,12 +5425,14 @@ function App() {
                 isHomeOpen ? 'home'
                 : isEmailOpen ? 'email'
                 : isMeetingsOpen ? 'meetings'
+                : isCodeOpen ? 'code'
                 : (isKnowledgeViewOpen || isGraphOpen || (selectedPath != null && selectedPath.startsWith('knowledge/'))) ? 'knowledge'
                 : isBgTasksOpen ? 'agents'
                 : isWorkspaceOpen ? 'workspaces'
                 : null
               }
               onOpenMeetings={openMeetingsView}
+              onOpenCode={openCodeView}
               onOpenBgTasks={() => { setBgTaskInitialSlug(null); setBgTaskSlugVersion((v) => v + 1); openBgTasksView() }}
               onOpenAgent={(slug) => { setBgTaskInitialSlug(slug); setBgTaskSlugVersion((v) => v + 1); openBgTasksView() }}
               recentRuns={runs}
@@ -5408,7 +5466,7 @@ function App() {
                 canNavigateForward={canNavigateForward}
                 collapsedLeftPaddingPx={collapsedLeftPaddingPx}
               >
-                {(selectedPath || isGraphOpen || isSuggestedTopicsOpen || isMeetingsOpen || isLiveNotesOpen || isBgTasksOpen || isEmailOpen || isWorkspaceOpen || isKnowledgeViewOpen || isChatHistoryOpen || isHomeOpen) && fileTabs.length >= 1 ? (
+                {(selectedPath || isGraphOpen || isSuggestedTopicsOpen || isMeetingsOpen || isLiveNotesOpen || isBgTasksOpen || isEmailOpen || isWorkspaceOpen || isKnowledgeViewOpen || isChatHistoryOpen || isHomeOpen || isCodeOpen) && fileTabs.length >= 1 ? (
                   <TabBar
                     tabs={fileTabs}
                     activeTabId={activeFileTabId ?? ''}
@@ -5416,7 +5474,7 @@ function App() {
                     getTabId={(t) => t.id}
                     onSwitchTab={switchFileTab}
                     onCloseTab={closeFileTab}
-                    allowSingleTabClose={fileTabs.length === 1 && (isGraphOpen || isSuggestedTopicsOpen || isMeetingsOpen || isLiveNotesOpen || isBgTasksOpen || isEmailOpen || isWorkspaceOpen || isKnowledgeViewOpen || isChatHistoryOpen || isHomeOpen || (selectedPath != null && isBaseFilePath(selectedPath)))}
+                    allowSingleTabClose={fileTabs.length === 1 && (isGraphOpen || isSuggestedTopicsOpen || isMeetingsOpen || isLiveNotesOpen || isBgTasksOpen || isEmailOpen || isWorkspaceOpen || isKnowledgeViewOpen || isChatHistoryOpen || isHomeOpen || isCodeOpen || (selectedPath != null && isBaseFilePath(selectedPath)))}
                   />
                 ) : isFullScreenChat ? (
                   <ChatHeader
@@ -5481,7 +5539,7 @@ function App() {
                     <TooltipContent side="bottom">Version history</TooltipContent>
                   </Tooltip>
                 )}
-                {!isFullScreenChat && !selectedPath && !isGraphOpen && !isSuggestedTopicsOpen && !isMeetingsOpen && !isLiveNotesOpen && !isBgTasksOpen && !isEmailOpen && !isWorkspaceOpen && !isKnowledgeViewOpen && !isChatHistoryOpen && !selectedTask && !isBrowserOpen && (
+                {!isFullScreenChat && !selectedPath && !isGraphOpen && !isSuggestedTopicsOpen && !isMeetingsOpen && !isLiveNotesOpen && !isBgTasksOpen && !isEmailOpen && !isWorkspaceOpen && !isKnowledgeViewOpen && !isChatHistoryOpen && !isCodeOpen && !selectedTask && !isBrowserOpen && (
                   <Tooltip>
                     <TooltipTrigger asChild>
                       <button
@@ -5575,6 +5633,10 @@ function App() {
                     meetingSummarizing={meetingSummarizing}
                   />
                 </div>
+              ) : isCodeOpen ? (
+                <div className="flex-1 min-h-0 flex flex-col overflow-hidden">
+                  <CodeView />
+                </div>
               ) : isLiveNotesOpen ? (
                 <div className="flex-1 min-h-0 flex flex-col overflow-hidden">
                   <LiveNotesView
diff --git a/apps/x/apps/renderer/src/components/code/cm.ts b/apps/x/apps/renderer/src/components/code/cm.ts
new file mode 100644
index 00000000..7fe9d922
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/cm.ts
@@ -0,0 +1,72 @@
+import { EditorView, lineNumbers } from '@codemirror/view'
+import { EditorState, type Extension } from '@codemirror/state'
+import {
+  HighlightStyle,
+  LanguageDescription,
+  bracketMatching,
+  syntaxHighlighting,
+  defaultHighlightStyle,
+} from '@codemirror/language'
+import { languages } from '@codemirror/language-data'
+import { tags } from '@lezer/highlight'
+
+// Shared CodeMirror setup for the Code section's read-only viewers
+// (file viewer + diff viewer). Theming keys off the app's resolved theme
+// instead of pulling in a theme package.
+
+const darkHighlight = HighlightStyle.define([
+  { tag: tags.keyword, color: '#c678dd' },
+  { tag: [tags.name, tags.deleted, tags.character, tags.macroName], color: '#e06c75' },
+  { tag: [tags.function(tags.variableName), tags.labelName], color: '#61afef' },
+  { tag: [tags.color, tags.constant(tags.name), tags.standard(tags.name)], color: '#d19a66' },
+  { tag: [tags.definition(tags.name), tags.separator], color: '#abb2bf' },
+  { tag: [tags.typeName, tags.className, tags.number, tags.changed, tags.annotation, tags.modifier, tags.self, tags.namespace], color: '#e5c07b' },
+  { tag: [tags.operator, tags.operatorKeyword, tags.url, tags.escape, tags.regexp, tags.link, tags.special(tags.string)], color: '#56b6c2' },
+  { tag: [tags.meta, tags.comment], color: '#7d8799', fontStyle: 'italic' },
+  { tag: [tags.atom, tags.bool, tags.special(tags.variableName)], color: '#d19a66' },
+  { tag: [tags.processingInstruction, tags.string, tags.inserted], color: '#98c379' },
+  { tag: tags.invalid, color: '#ffffff' },
+])
+
+export function cmBaseExtensions(isDark: boolean): Extension[] {
+  return [
+    lineNumbers(),
+    bracketMatching(),
+    syntaxHighlighting(isDark ? darkHighlight : defaultHighlightStyle, { fallback: true }),
+    EditorView.lineWrapping,
+    EditorState.readOnly.of(true),
+    EditorView.editable.of(false),
+    EditorView.theme(
+      {
+        '&': {
+          backgroundColor: 'transparent',
+          fontSize: '12px',
+          height: '100%',
+        },
+        '.cm-scroller': {
+          fontFamily: 'ui-monospace, SFMono-Regular, Menlo, monospace',
+          overflow: 'auto',
+        },
+        '.cm-gutters': {
+          backgroundColor: 'transparent',
+          border: 'none',
+          color: isDark ? '#6b7280' : '#9ca3af',
+        },
+        '&.cm-focused': { outline: 'none' },
+      },
+      { dark: isDark },
+    ),
+  ]
+}
+
+// Resolve a language extension from the filename (lazy-loaded; Vite splits
+// each language into its own chunk).
+export async function cmLanguageFor(filename: string): Promise<Extension | null> {
+  const desc = LanguageDescription.matchFilename(languages, filename)
+  if (!desc) return null
+  try {
+    return await desc.load()
+  } catch {
+    return null
+  }
+}
diff --git a/apps/x/apps/renderer/src/components/code/code-chat.tsx b/apps/x/apps/renderer/src/components/code/code-chat.tsx
new file mode 100644
index 00000000..47c557e1
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/code-chat.tsx
@@ -0,0 +1,271 @@
+import { useEffect, useRef, useState } from 'react'
+import { ArrowUp, Bot, GitBranch, Loader2, Square, User } from 'lucide-react'
+import type { CodeSession, CodeSessionStatus } from '@x/shared/src/code-sessions.js'
+import type { ApprovalPolicy } from '@x/shared/src/code-mode.js'
+import { cn } from '@/lib/utils'
+import { toast } from 'sonner'
+import { Button } from '@/components/ui/button'
+import { Switch } from '@/components/ui/switch'
+import { Textarea } from '@/components/ui/textarea'
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu'
+import { Conversation, ConversationContent, ConversationScrollButton } from '@/components/ai-elements/conversation'
+import { MessageResponse } from '@/components/ai-elements/message'
+import { Shimmer } from '@/components/ai-elements/shimmer'
+import { Tool, ToolContent, ToolHeader } from '@/components/ai-elements/tool'
+import { toToolState, getToolDisplayName, type ToolCall } from '@/lib/chat-conversation'
+import { CodeRunPermissionRequest, CodingRunTimeline } from '@/components/coding-run'
+import { useCodeChat, isDirectTurn, isChatToolCall, isChatErrorMessage, type CodeChatItem } from './use-code-chat'
+
+const AGENT_LABEL: Record<string, string> = { claude: 'Claude Code', codex: 'Codex' }
+const POLICY_LABEL: Record<ApprovalPolicy, string> = {
+  ask: 'Ask every time',
+  'auto-approve-reads': 'Auto-approve reads',
+  yolo: 'Auto-approve everything',
+}
+
+function RowboatToolCall({ item, onOpenDiff }: { item: ToolCall; onOpenDiff: (path: string) => void }) {
+  const [open, setOpen] = useState(false)
+  if (item.name === 'code_agent_run') {
+    const agent = (item.result as { agent?: string } | undefined)?.agent
+      ?? (item.input as { agent?: string } | undefined)?.agent
+    return (
+      <Tool open={open || item.status === 'running'} onOpenChange={setOpen}>
+        <ToolHeader title={AGENT_LABEL[agent ?? ''] ?? 'Coding agent'} type="tool-code_agent_run" state={toToolState(item.status)} />
+        <ToolContent>
+          <CodingRunTimeline events={item.codeRunEvents ?? []} onOpenDiff={onOpenDiff} />
+        </ToolContent>
+      </Tool>
+    )
+  }
+  return (
+    <div className="flex items-center gap-2 text-xs text-muted-foreground">
+      {item.status === 'running' || item.status === 'pending'
+        ? <Loader2 className="size-3 animate-spin" />
+        : <span className="text-green-600">✓</span>}
+      <span className="truncate">{getToolDisplayName(item)}</span>
+    </div>
+  )
+}
+
+function ChatItem({ item, onOpenDiff }: { item: CodeChatItem; onOpenDiff: (path: string) => void }) {
+  if (isDirectTurn(item)) {
+    if (item.events.length === 0) return null
+    return (
+      <div className="rounded-[16px] border bg-muted/20">
+        <CodingRunTimeline events={item.events} onOpenDiff={onOpenDiff} />
+      </div>
+    )
+  }
+  if (isChatErrorMessage(item)) {
+    return (
+      <div className="rounded-lg border border-destructive/30 bg-destructive/5 px-3 py-2 text-sm text-destructive">
+        {item.message.split('\n')[0]}
+      </div>
+    )
+  }
+  if (isChatToolCall(item)) {
+    return <RowboatToolCall item={item} onOpenDiff={onOpenDiff} />
+  }
+  if (item.role === 'user') {
+    return (
+      <div className="flex justify-end">
+        <div className="max-w-[85%] whitespace-pre-wrap rounded-2xl bg-primary/10 px-4 py-2.5 text-sm">
+          {item.content}
+        </div>
+      </div>
+    )
+  }
+  return (
+    <div className="max-w-none text-sm">
+      <MessageResponse>{item.content}</MessageResponse>
+    </div>
+  )
+}
+
+// The chat surface for one coding session: direct messages go straight to the
+// ACP agent; with "Rowboat drives" on they route through the copilot LLM.
+export function CodeChat({
+  session,
+  status,
+  onOpenDiff,
+  onUpdateSession,
+}: {
+  session: CodeSession
+  status: CodeSessionStatus
+  onOpenDiff: (path: string) => void
+  onUpdateSession: (patch: { mode?: 'direct' | 'rowboat'; policy?: ApprovalPolicy; agent?: 'claude' | 'codex' }) => void
+}) {
+  const { items, liveText, isProcessing, pendingPermission, loading, send, stop, resolvePermission } = useCodeChat(session)
+  const [draft, setDraft] = useState('')
+  const [stopping, setStopping] = useState(false)
+  const textareaRef = useRef<HTMLTextAreaElement>(null)
+
+  const busy = isProcessing || status === 'working' || status === 'needs-you'
+
+  useEffect(() => {
+    setDraft('')
+    setStopping(false)
+    textareaRef.current?.focus()
+  }, [session.id])
+
+  useEffect(() => {
+    if (!busy) setStopping(false)
+  }, [busy])
+
+  const handleSend = async () => {
+    const text = draft.trim()
+    if (!text || busy) return
+    setDraft('')
+    const result = await send(text)
+    if (!result.ok && result.error) {
+      toast.error(result.error)
+      setDraft(text)
+    }
+  }
+
+  const handleStop = async () => {
+    setStopping(true)
+    await stop()
+  }
+
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      {/* Session header */}
+      <div className="flex items-center gap-3 border-b px-4 py-2">
+        <div className="min-w-0 flex-1">
+          <div className="truncate text-sm font-medium">{session.title}</div>
+          <div className="flex items-center gap-2 text-[11px] text-muted-foreground">
+            <span>{AGENT_LABEL[session.agent]}</span>
+            <span>·</span>
+            <span className="truncate font-mono" title={session.cwd}>{session.cwd}</span>
+            {session.worktree && !session.worktree.removedAt && (
+              <span className="flex shrink-0 items-center gap-1 rounded-full bg-muted px-1.5 py-0.5">
+                <GitBranch className="size-3" />
+                {session.worktree.branch}
+              </span>
+            )}
+          </div>
+        </div>
+        <DropdownMenu>
+          <DropdownMenuTrigger asChild>
+            <Button variant="ghost" size="sm" className="h-7 px-2 text-xs text-muted-foreground">
+              {POLICY_LABEL[session.policy]}
+            </Button>
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="end">
+            {(Object.keys(POLICY_LABEL) as ApprovalPolicy[]).map((policy) => (
+              <DropdownMenuItem key={policy} onClick={() => onUpdateSession({ policy })}>
+                {POLICY_LABEL[policy]}
+                {session.policy === policy && <span className="ml-auto">✓</span>}
+              </DropdownMenuItem>
+            ))}
+          </DropdownMenuContent>
+        </DropdownMenu>
+        <label className="flex shrink-0 cursor-pointer items-center gap-1.5 text-xs text-muted-foreground">
+          <Bot className="size-3.5" />
+          Rowboat drives
+          <Switch
+            checked={session.mode === 'rowboat'}
+            disabled={busy}
+            onCheckedChange={(checked) => onUpdateSession({ mode: checked ? 'rowboat' : 'direct' })}
+          />
+        </label>
+      </div>
+
+      {/* Conversation */}
+      <Conversation className="min-h-0 flex-1">
+        <ConversationContent className="mx-auto flex w-full max-w-3xl flex-col gap-4 px-4 py-4">
+          {loading && <div className="text-sm text-muted-foreground">Loading conversation…</div>}
+          {!loading && items.length === 0 && !busy && (
+            <div className="flex flex-col items-center gap-2 py-16 text-center">
+              <div className="text-sm font-medium">
+                {session.mode === 'direct'
+                  ? `Talk directly to ${AGENT_LABEL[session.agent]}`
+                  : `Rowboat will drive ${AGENT_LABEL[session.agent]} for you`}
+              </div>
+              <p className="max-w-sm text-xs text-muted-foreground">
+                {session.mode === 'direct'
+                  ? 'Your messages go straight to the coding agent in this project. Tool calls, plans, and diffs stream in here.'
+                  : 'Describe the outcome you want — Rowboat plans the work, runs the coding agent, checks results, and reports back.'}
+              </p>
+            </div>
+          )}
+          {items.map((item) => (
+            <ChatItem key={item.id} item={item} onOpenDiff={onOpenDiff} />
+          ))}
+          {liveText && (
+            <div className="max-w-none text-sm">
+              <MessageResponse>{liveText.replace(/<\/?voice>/g, '')}</MessageResponse>
+            </div>
+          )}
+          {pendingPermission && (
+            <CodeRunPermissionRequest ask={pendingPermission.ask} onDecide={(d) => void resolvePermission(d)} />
+          )}
+          {busy && !pendingPermission && (
+            <Shimmer className="text-sm">
+              {stopping ? 'Stopping…' : session.mode === 'direct' ? `${AGENT_LABEL[session.agent]} is working…` : 'Working…'}
+            </Shimmer>
+          )}
+        </ConversationContent>
+        <ConversationScrollButton />
+      </Conversation>
+
+      {/* Composer */}
+      <div className="border-t p-3">
+        <div className="mx-auto flex w-full max-w-3xl items-end gap-2">
+          <Textarea
+            ref={textareaRef}
+            value={draft}
+            onChange={(e) => setDraft(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault()
+                void handleSend()
+              }
+            }}
+            placeholder={
+              session.mode === 'direct'
+                ? `Message ${AGENT_LABEL[session.agent]}…`
+                : 'Tell Rowboat what to build or fix…'
+            }
+            className="max-h-40 min-h-[44px] flex-1 resize-none"
+            rows={1}
+          />
+          {busy ? (
+            <Button
+              variant="outline"
+              size="icon"
+              className="shrink-0"
+              onClick={() => void handleStop()}
+              disabled={stopping}
+              title="Stop the agent"
+            >
+              <Square className={cn('size-4', stopping && 'animate-pulse')} />
+            </Button>
+          ) : (
+            <Button
+              size="icon"
+              className="shrink-0"
+              onClick={() => void handleSend()}
+              disabled={!draft.trim()}
+              title="Send"
+            >
+              <ArrowUp className="size-4" />
+            </Button>
+          )}
+        </div>
+        <div className="mx-auto mt-1.5 flex w-full max-w-3xl items-center gap-1 text-[10px] text-muted-foreground">
+          <User className="size-3" />
+          {session.mode === 'direct'
+            ? `Direct — messages go straight to ${AGENT_LABEL[session.agent]}`
+            : 'Rowboat orchestrates the coding agent for you'}
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/code/code-view.tsx b/apps/x/apps/renderer/src/components/code/code-view.tsx
new file mode 100644
index 00000000..f9b3d4b3
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/code-view.tsx
@@ -0,0 +1,173 @@
+import { useCallback, useState } from 'react'
+import { Code2 } from 'lucide-react'
+import type { CodeSession } from '@x/shared/src/code-sessions.js'
+import type { ApprovalPolicy } from '@x/shared/src/code-mode.js'
+import { toast } from 'sonner'
+import { Button } from '@/components/ui/button'
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from '@/components/ui/alert-dialog'
+import { useCodeSessions } from './use-code-sessions'
+import { SessionRail } from './session-rail'
+import { NewSessionDialog } from './new-session-dialog'
+import { CodeChat } from './code-chat'
+import { WorkspacePane } from './workspace-pane'
+
+// The Code section: projects → sessions → chat + workspace. Sessions run
+// Claude Code / Codex directly (or via Rowboat), with diffs and files on the
+// right.
+export function CodeView() {
+  const { projects, sessions, statusOf, refresh } = useCodeSessions()
+  const [selectedSessionId, setSelectedSessionId] = useState<string | null>(null)
+  const [newSessionProjectId, setNewSessionProjectId] = useState<string | null>(null)
+  const [deleteTarget, setDeleteTarget] = useState<CodeSession | null>(null)
+  const [openDiffPath, setOpenDiffPath] = useState<string | null>(null)
+
+  const selectedSession = sessions.find((s) => s.id === selectedSessionId) ?? null
+  const newSessionProject = projects.find((p) => p.project.id === newSessionProjectId) ?? null
+
+  const handleAddProject = useCallback(async () => {
+    const res = await window.ipc.invoke('dialog:openDirectory', { title: 'Choose a project folder' })
+    const dir = res.path
+    if (!dir) return
+    try {
+      const added = await window.ipc.invoke('codeProject:add', { path: dir })
+      await refresh()
+      setNewSessionProjectId(added.project.id)
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : 'Failed to add project')
+    }
+  }, [refresh])
+
+  const handleRemoveProject = useCallback(async (projectId: string) => {
+    await window.ipc.invoke('codeProject:remove', { projectId })
+    await refresh()
+  }, [refresh])
+
+  const handleSessionCreated = useCallback(async (session: CodeSession) => {
+    await refresh()
+    setSelectedSessionId(session.id)
+  }, [refresh])
+
+  const handleDeleteSession = useCallback(async (session: CodeSession, removeWorktree: boolean) => {
+    try {
+      await window.ipc.invoke('codeSession:delete', {
+        sessionId: session.id,
+        removeWorktree,
+        deleteBranch: removeWorktree,
+      })
+      if (selectedSessionId === session.id) setSelectedSessionId(null)
+      await refresh()
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : 'Failed to delete session')
+    }
+  }, [refresh, selectedSessionId])
+
+  const handleUpdateSession = useCallback(async (patch: { mode?: 'direct' | 'rowboat'; policy?: ApprovalPolicy; agent?: 'claude' | 'codex' }) => {
+    if (!selectedSessionId) return
+    try {
+      await window.ipc.invoke('codeSession:update', { sessionId: selectedSessionId, patch })
+      await refresh()
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : 'Failed to update session')
+    }
+  }, [refresh, selectedSessionId])
+
+  return (
+    <div className="flex h-full min-h-0">
+      {/* Session rail */}
+      <div className="w-64 shrink-0 border-r">
+        <SessionRail
+          projects={projects}
+          sessions={sessions}
+          statusOf={statusOf}
+          selectedSessionId={selectedSessionId}
+          onSelectSession={setSelectedSessionId}
+          onAddProject={() => void handleAddProject()}
+          onRemoveProject={(id) => void handleRemoveProject(id)}
+          onNewSession={setNewSessionProjectId}
+          onDeleteSession={setDeleteTarget}
+        />
+      </div>
+
+      {/* Chat */}
+      <div className="min-w-0 flex-1 border-r">
+        {selectedSession ? (
+          <CodeChat
+            key={selectedSession.id}
+            session={selectedSession}
+            status={statusOf(selectedSession.id)}
+            onOpenDiff={setOpenDiffPath}
+            onUpdateSession={(patch) => void handleUpdateSession(patch)}
+          />
+        ) : (
+          <div className="flex h-full flex-col items-center justify-center gap-3 text-center">
+            <Code2 className="size-10 text-muted-foreground/40" />
+            <div className="text-sm font-medium">Code with agents</div>
+            <p className="max-w-sm px-6 text-xs text-muted-foreground">
+              Run Claude Code or Codex on your projects — directly, or let Rowboat drive them.
+              Sessions stream the agent's plan, tool calls, and diffs, and you review changes on the right.
+            </p>
+            {projects.length === 0 ? (
+              <Button size="sm" onClick={() => void handleAddProject()}>Add a project to get started</Button>
+            ) : (
+              <p className="text-xs text-muted-foreground">Pick a session on the left, or create a new one.</p>
+            )}
+          </div>
+        )}
+      </div>
+
+      {/* Workspace pane */}
+      {selectedSession && (
+        <div className="hidden w-[42%] min-w-[320px] shrink-0 lg:block">
+          <WorkspacePane
+            session={selectedSession}
+            status={statusOf(selectedSession.id)}
+            openDiffPath={openDiffPath}
+            onDiffOpened={() => setOpenDiffPath(null)}
+            onSessionChanged={() => void refresh()}
+          />
+        </div>
+      )}
+
+      <NewSessionDialog
+        projectRow={newSessionProject}
+        open={newSessionProjectId !== null}
+        onOpenChange={(open) => { if (!open) setNewSessionProjectId(null) }}
+        onCreated={(session) => void handleSessionCreated(session)}
+      />
+
+      <AlertDialog open={deleteTarget !== null} onOpenChange={(open) => { if (!open) setDeleteTarget(null) }}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Delete this session?</AlertDialogTitle>
+            <AlertDialogDescription>
+              The conversation history will be deleted.
+              {deleteTarget?.worktree && !deleteTarget.worktree.removedAt
+                ? ' Its worktree and branch will be removed too — merge back first if you want to keep the changes.'
+                : ''}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>Cancel</AlertDialogCancel>
+            <AlertDialogAction
+              onClick={() => {
+                if (deleteTarget) void handleDeleteSession(deleteTarget, true)
+                setDeleteTarget(null)
+              }}
+            >
+              Delete
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </div>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/code/diff-viewer.tsx b/apps/x/apps/renderer/src/components/code/diff-viewer.tsx
new file mode 100644
index 00000000..6d34e498
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/diff-viewer.tsx
@@ -0,0 +1,100 @@
+import { useEffect, useRef, useState } from 'react'
+import { MergeView, unifiedMergeView } from '@codemirror/merge'
+import { EditorView } from '@codemirror/view'
+import { Columns2, Rows2, X } from 'lucide-react'
+import { useTheme } from '@/contexts/theme-context'
+import { Button } from '@/components/ui/button'
+import { cmBaseExtensions, cmLanguageFor } from './cm'
+
+// Read-only diff of one file's working-tree changes vs HEAD, side-by-side or
+// unified. Content comes from codeSession:fileDiff (old = git show HEAD:path,
+// new = disk).
+export function DiffViewer({
+  sessionId,
+  path,
+  onClose,
+}: {
+  sessionId: string
+  path: string
+  onClose: () => void
+}) {
+  const { resolvedTheme } = useTheme()
+  const isDark = resolvedTheme === 'dark'
+  const containerRef = useRef<HTMLDivElement>(null)
+  const [mode, setMode] = useState<'split' | 'unified'>('split')
+  const [diff, setDiff] = useState<{ oldText: string; newText: string; isBinary: boolean; tooLarge: boolean } | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    setDiff(null)
+    setError(null)
+    window.ipc.invoke('codeSession:fileDiff', { sessionId, path })
+      .then((res) => { if (!cancelled) setDiff(res) })
+      .catch((err) => { if (!cancelled) setError(err instanceof Error ? err.message : 'Failed to load diff') })
+    return () => { cancelled = true }
+  }, [sessionId, path])
+
+  useEffect(() => {
+    const parent = containerRef.current
+    if (!parent || !diff || diff.isBinary || diff.tooLarge) return
+    let view: MergeView | EditorView | null = null
+    let cancelled = false
+
+    void cmLanguageFor(path).then((language) => {
+      if (cancelled || !containerRef.current) return
+      const extensions = [...cmBaseExtensions(isDark), ...(language ? [language] : [])]
+      if (mode === 'split') {
+        view = new MergeView({
+          a: { doc: diff.oldText, extensions },
+          b: { doc: diff.newText, extensions },
+          parent,
+          gutter: true,
+        })
+      } else {
+        view = new EditorView({
+          doc: diff.newText,
+          extensions: [
+            ...extensions,
+            unifiedMergeView({ original: diff.oldText, mergeControls: false }),
+          ],
+          parent,
+        })
+      }
+    })
+
+    return () => {
+      cancelled = true
+      view?.destroy()
+    }
+  }, [diff, mode, isDark, path])
+
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="flex items-center gap-2 border-b px-3 py-1.5">
+        <span className="min-w-0 flex-1 truncate font-mono text-xs text-foreground/90" title={path}>{path}</span>
+        <Button
+          variant="ghost"
+          size="sm"
+          className="h-7 px-2 text-xs"
+          onClick={() => setMode((m) => (m === 'split' ? 'unified' : 'split'))}
+          title={mode === 'split' ? 'Switch to unified view' : 'Switch to side-by-side view'}
+        >
+          {mode === 'split' ? <Rows2 className="size-3.5" /> : <Columns2 className="size-3.5" />}
+        </Button>
+        <Button variant="ghost" size="sm" className="h-7 px-2" onClick={onClose} title="Close diff">
+          <X className="size-3.5" />
+        </Button>
+      </div>
+      <div className="min-h-0 flex-1 overflow-auto">
+        {error && <div className="p-4 text-sm text-destructive">{error}</div>}
+        {!error && !diff && <div className="p-4 text-sm text-muted-foreground">Loading diff…</div>}
+        {diff?.isBinary && <div className="p-4 text-sm text-muted-foreground">Binary file — no text diff.</div>}
+        {diff?.tooLarge && <div className="p-4 text-sm text-muted-foreground">File too large to diff here.</div>}
+        {diff && !diff.isBinary && !diff.tooLarge && (
+          <div ref={containerRef} className="h-full [&_.cm-mergeView]:h-full [&_.cm-editor]:h-full" />
+        )}
+      </div>
+    </div>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/code/file-tree.tsx b/apps/x/apps/renderer/src/components/code/file-tree.tsx
new file mode 100644
index 00000000..096cb199
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/file-tree.tsx
@@ -0,0 +1,101 @@
+import { useCallback, useEffect, useState } from 'react'
+import { ChevronDown, ChevronRight, FileText, Folder } from 'lucide-react'
+import { cn } from '@/lib/utils'
+
+interface TreeEntry {
+  name: string
+  kind: 'file' | 'dir'
+}
+
+// Lazy file tree over codeSession:readdir — one directory level per request,
+// so big folders (node_modules) cost nothing until expanded.
+export function CodeFileTree({
+  sessionId,
+  selectedPath,
+  onSelectFile,
+}: {
+  sessionId: string
+  selectedPath: string | null
+  onSelectFile: (relPath: string) => void
+}) {
+  const [childrenByDir, setChildrenByDir] = useState<Record<string, TreeEntry[]>>({})
+  const [expanded, setExpanded] = useState<Set<string>>(new Set())
+  const [error, setError] = useState<string | null>(null)
+
+  const loadDir = useCallback(async (relPath: string) => {
+    try {
+      const res = await window.ipc.invoke('codeSession:readdir', { sessionId, relPath })
+      setChildrenByDir((prev) => ({ ...prev, [relPath]: res.entries }))
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to read directory')
+    }
+  }, [sessionId])
+
+  useEffect(() => {
+    setChildrenByDir({})
+    setExpanded(new Set())
+    setError(null)
+    void loadDir('.')
+  }, [loadDir])
+
+  const toggleDir = (relPath: string) => {
+    setExpanded((prev) => {
+      const next = new Set(prev)
+      if (next.has(relPath)) {
+        next.delete(relPath)
+      } else {
+        next.add(relPath)
+        if (!childrenByDir[relPath]) void loadDir(relPath)
+      }
+      return next
+    })
+  }
+
+  const renderDir = (relPath: string, depth: number) => {
+    const entries = childrenByDir[relPath]
+    if (!entries) {
+      return <div className="px-2 py-1 text-xs text-muted-foreground" style={{ paddingLeft: depth * 12 + 8 }}>Loading…</div>
+    }
+    return entries.map((entry) => {
+      const childPath = relPath === '.' ? entry.name : `${relPath}/${entry.name}`
+      if (entry.kind === 'dir') {
+        const isOpen = expanded.has(childPath)
+        return (
+          <div key={childPath}>
+            <button
+              type="button"
+              onClick={() => toggleDir(childPath)}
+              className="flex w-full items-center gap-1.5 rounded px-2 py-1 text-left text-xs hover:bg-muted"
+              style={{ paddingLeft: depth * 12 + 8 }}
+            >
+              {isOpen ? <ChevronDown className="size-3 shrink-0" /> : <ChevronRight className="size-3 shrink-0" />}
+              <Folder className="size-3.5 shrink-0 text-muted-foreground" />
+              <span className="truncate">{entry.name}</span>
+            </button>
+            {isOpen && renderDir(childPath, depth + 1)}
+          </div>
+        )
+      }
+      return (
+        <button
+          key={childPath}
+          type="button"
+          onClick={() => onSelectFile(childPath)}
+          className={cn(
+            'flex w-full items-center gap-1.5 rounded px-2 py-1 text-left text-xs hover:bg-muted',
+            selectedPath === childPath && 'bg-muted font-medium',
+          )}
+          style={{ paddingLeft: depth * 12 + 22 }}
+        >
+          <FileText className="size-3.5 shrink-0 text-muted-foreground" />
+          <span className="truncate">{entry.name}</span>
+        </button>
+      )
+    })
+  }
+
+  if (error) {
+    return <div className="p-3 text-xs text-destructive">{error}</div>
+  }
+  return <div className="overflow-auto py-1">{renderDir('.', 0)}</div>
+}
diff --git a/apps/x/apps/renderer/src/components/code/file-viewer.tsx b/apps/x/apps/renderer/src/components/code/file-viewer.tsx
new file mode 100644
index 00000000..8e6cbcb9
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/file-viewer.tsx
@@ -0,0 +1,70 @@
+import { useEffect, useRef, useState } from 'react'
+import { EditorView } from '@codemirror/view'
+import { X } from 'lucide-react'
+import { useTheme } from '@/contexts/theme-context'
+import { Button } from '@/components/ui/button'
+import { cmBaseExtensions, cmLanguageFor } from './cm'
+
+// Read-only, syntax-highlighted view of one file in the session directory.
+export function CodeFileViewer({
+  sessionId,
+  path,
+  onClose,
+}: {
+  sessionId: string
+  path: string
+  onClose: () => void
+}) {
+  const { resolvedTheme } = useTheme()
+  const isDark = resolvedTheme === 'dark'
+  const containerRef = useRef<HTMLDivElement>(null)
+  const [file, setFile] = useState<{ content: string; isBinary: boolean; tooLarge: boolean } | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    setFile(null)
+    setError(null)
+    window.ipc.invoke('codeSession:readFile', { sessionId, relPath: path })
+      .then((res) => { if (!cancelled) setFile(res) })
+      .catch((err) => { if (!cancelled) setError(err instanceof Error ? err.message : 'Failed to read file') })
+    return () => { cancelled = true }
+  }, [sessionId, path])
+
+  useEffect(() => {
+    const parent = containerRef.current
+    if (!parent || !file || file.isBinary || file.tooLarge) return
+    let view: EditorView | null = null
+    let cancelled = false
+    void cmLanguageFor(path).then((language) => {
+      if (cancelled || !containerRef.current) return
+      view = new EditorView({
+        doc: file.content,
+        extensions: [...cmBaseExtensions(isDark), ...(language ? [language] : [])],
+        parent,
+      })
+    })
+    return () => {
+      cancelled = true
+      view?.destroy()
+    }
+  }, [file, isDark, path])
+
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="flex items-center gap-2 border-b px-3 py-1.5">
+        <span className="min-w-0 flex-1 truncate font-mono text-xs text-foreground/90" title={path}>{path}</span>
+        <Button variant="ghost" size="sm" className="h-7 px-2" onClick={onClose} title="Close file">
+          <X className="size-3.5" />
+        </Button>
+      </div>
+      <div className="min-h-0 flex-1 overflow-auto">
+        {error && <div className="p-4 text-sm text-destructive">{error}</div>}
+        {!error && !file && <div className="p-4 text-sm text-muted-foreground">Loading…</div>}
+        {file?.isBinary && <div className="p-4 text-sm text-muted-foreground">Binary file.</div>}
+        {file?.tooLarge && <div className="p-4 text-sm text-muted-foreground">File too large to preview.</div>}
+        {file && !file.isBinary && !file.tooLarge && <div ref={containerRef} className="h-full [&_.cm-editor]:h-full" />}
+      </div>
+    </div>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/code/new-session-dialog.tsx b/apps/x/apps/renderer/src/components/code/new-session-dialog.tsx
new file mode 100644
index 00000000..df28d988
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/new-session-dialog.tsx
@@ -0,0 +1,206 @@
+import { useEffect, useState } from 'react'
+import { GitBranch, Loader2 } from 'lucide-react'
+import type { CodeSession } from '@x/shared/src/code-sessions.js'
+import type { ApprovalPolicy, CodingAgent } from '@x/shared/src/code-mode.js'
+import { cn } from '@/lib/utils'
+import { toast } from 'sonner'
+import { Button } from '@/components/ui/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import { Input } from '@/components/ui/input'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select'
+import type { ProjectRow } from './use-code-sessions'
+
+type AgentStatus = { installed: boolean; signedIn: boolean }
+
+const POLICY_LABEL: Record<ApprovalPolicy, string> = {
+  ask: 'Ask every time',
+  'auto-approve-reads': 'Auto-approve reads',
+  yolo: 'Auto-approve everything (YOLO)',
+}
+
+export function NewSessionDialog({
+  projectRow,
+  open,
+  onOpenChange,
+  onCreated,
+}: {
+  projectRow: ProjectRow | null
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  onCreated: (session: CodeSession) => void
+}) {
+  const [agentStatus, setAgentStatus] = useState<{ claude: AgentStatus; codex: AgentStatus } | null>(null)
+  const [agent, setAgent] = useState<CodingAgent>('claude')
+  const [policy, setPolicy] = useState<ApprovalPolicy>('auto-approve-reads')
+  const [isolation, setIsolation] = useState<'in-repo' | 'worktree'>('in-repo')
+  const [title, setTitle] = useState('')
+  const [creating, setCreating] = useState(false)
+
+  const git = projectRow?.git
+  const worktreeAvailable = !!git?.isGitRepo && !!git?.hasCommits
+
+  useEffect(() => {
+    if (!open) return
+    setTitle('')
+    setCreating(false)
+    setIsolation('in-repo')
+    void window.ipc.invoke('codeMode:checkAgentStatus', null).then((status) => {
+      setAgentStatus(status)
+      // Default to whichever agent is actually ready.
+      const claudeReady = status.claude.installed && status.claude.signedIn
+      const codexReady = status.codex.installed && status.codex.signedIn
+      if (!claudeReady && codexReady) setAgent('codex')
+      else setAgent('claude')
+    })
+  }, [open])
+
+  const agentReady = (a: CodingAgent): boolean => {
+    if (!agentStatus) return true
+    const s = agentStatus[a]
+    return s.installed && s.signedIn
+  }
+
+  const handleCreate = async () => {
+    if (!projectRow) return
+    setCreating(true)
+    try {
+      const res = await window.ipc.invoke('codeSession:create', {
+        projectId: projectRow.project.id,
+        title: title.trim() || undefined,
+        agent,
+        mode: 'direct',
+        policy,
+        isolation,
+      })
+      onOpenChange(false)
+      onCreated(res.session)
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : 'Failed to create session')
+    } finally {
+      setCreating(false)
+    }
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>New coding session</DialogTitle>
+          <DialogDescription>
+            {projectRow ? <span className="font-mono text-xs">{projectRow.project.path}</span> : null}
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="flex flex-col gap-4">
+          <div className="flex flex-col gap-1.5">
+            <label className="text-xs font-medium">Name (optional)</label>
+            <Input
+              value={title}
+              onChange={(e) => setTitle(e.target.value)}
+              placeholder="e.g. Fix flaky auth tests"
+            />
+          </div>
+
+          <div className="flex flex-col gap-1.5">
+            <label className="text-xs font-medium">Coding agent</label>
+            <div className="grid grid-cols-2 gap-2">
+              {(['claude', 'codex'] as const).map((a) => {
+                const ready = agentReady(a)
+                return (
+                  <button
+                    key={a}
+                    type="button"
+                    disabled={!ready}
+                    onClick={() => setAgent(a)}
+                    className={cn(
+                      'rounded-lg border px-3 py-2 text-left text-sm transition-colors',
+                      agent === a ? 'border-foreground bg-muted' : 'hover:bg-muted/60',
+                      !ready && 'cursor-not-allowed opacity-50',
+                    )}
+                  >
+                    <div className="font-medium">{a === 'claude' ? 'Claude Code' : 'Codex'}</div>
+                    <div className="text-[11px] text-muted-foreground">
+                      {ready ? 'Ready' : agentStatus?.[a]?.installed ? 'Not signed in' : 'Not installed'}
+                    </div>
+                  </button>
+                )
+              })}
+            </div>
+          </div>
+
+          <div className="flex flex-col gap-1.5">
+            <label className="text-xs font-medium">Where it works</label>
+            <div className="flex flex-col gap-2">
+              <button
+                type="button"
+                onClick={() => setIsolation('in-repo')}
+                className={cn(
+                  'rounded-lg border px-3 py-2 text-left text-sm transition-colors',
+                  isolation === 'in-repo' ? 'border-foreground bg-muted' : 'hover:bg-muted/60',
+                )}
+              >
+                <div className="font-medium">Directly in the project</div>
+                <div className="text-[11px] text-muted-foreground">Changes land in your working tree.</div>
+              </button>
+              <button
+                type="button"
+                disabled={!worktreeAvailable}
+                onClick={() => setIsolation('worktree')}
+                className={cn(
+                  'rounded-lg border px-3 py-2 text-left text-sm transition-colors',
+                  isolation === 'worktree' ? 'border-foreground bg-muted' : 'hover:bg-muted/60',
+                  !worktreeAvailable && 'cursor-not-allowed opacity-50',
+                )}
+              >
+                <div className="flex items-center gap-1.5 font-medium">
+                  <GitBranch className="size-3.5" />
+                  Isolated worktree
+                </div>
+                <div className="text-[11px] text-muted-foreground">
+                  {worktreeAvailable
+                    ? 'Works on its own branch — safe to run sessions in parallel; merge back when done.'
+                    : 'Needs a git repository with at least one commit.'}
+                </div>
+              </button>
+            </div>
+          </div>
+
+          <div className="flex flex-col gap-1.5">
+            <label className="text-xs font-medium">Approvals</label>
+            <Select value={policy} onValueChange={(v) => setPolicy(v as ApprovalPolicy)}>
+              <SelectTrigger className="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {(Object.keys(POLICY_LABEL) as ApprovalPolicy[]).map((p) => (
+                  <SelectItem key={p} value={p}>{POLICY_LABEL[p]}</SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)}>Cancel</Button>
+          <Button onClick={() => void handleCreate()} disabled={creating || !projectRow || !agentReady(agent)}>
+            {creating && <Loader2 className="size-4 animate-spin" />}
+            Create session
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/code/session-rail.tsx b/apps/x/apps/renderer/src/components/code/session-rail.tsx
new file mode 100644
index 00000000..dbf59567
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/session-rail.tsx
@@ -0,0 +1,168 @@
+import { FolderGit2, FolderPlus, MoreHorizontal, Plus, Trash2 } from 'lucide-react'
+import type { CodeSession, CodeSessionStatus } from '@x/shared/src/code-sessions.js'
+import { cn } from '@/lib/utils'
+import { Button } from '@/components/ui/button'
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+import type { ProjectRow } from './use-code-sessions'
+
+function StatusDot({ status }: { status: CodeSessionStatus }) {
+  if (status === 'needs-you') {
+    return <span className="size-2 shrink-0 animate-pulse rounded-full bg-amber-500" title="Needs your attention" />
+  }
+  if (status === 'working') {
+    return <span className="size-2 shrink-0 animate-pulse rounded-full bg-blue-500" title="Working" />
+  }
+  return <span className="size-2 shrink-0 rounded-full bg-muted-foreground/30" title="Idle" />
+}
+
+const AGENT_SHORT: Record<string, string> = { claude: 'Claude', codex: 'Codex' }
+
+// Left rail: registered projects with their sessions, attention-first.
+export function SessionRail({
+  projects,
+  sessions,
+  statusOf,
+  selectedSessionId,
+  onSelectSession,
+  onAddProject,
+  onRemoveProject,
+  onNewSession,
+  onDeleteSession,
+}: {
+  projects: ProjectRow[]
+  sessions: CodeSession[]
+  statusOf: (sessionId: string) => CodeSessionStatus
+  selectedSessionId: string | null
+  onSelectSession: (sessionId: string) => void
+  onAddProject: () => void
+  onRemoveProject: (projectId: string) => void
+  onNewSession: (projectId: string) => void
+  onDeleteSession: (session: CodeSession) => void
+}) {
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="flex items-center justify-between px-3 py-2">
+        <span className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">Projects</span>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button variant="ghost" size="sm" className="h-7 w-7 p-0" onClick={onAddProject}>
+              <FolderPlus className="size-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>Add a project folder</TooltipContent>
+        </Tooltip>
+      </div>
+      <div className="min-h-0 flex-1 overflow-auto px-2 pb-2">
+        {projects.length === 0 && (
+          <div className="flex flex-col items-center gap-3 px-3 py-10 text-center">
+            <FolderGit2 className="size-8 text-muted-foreground/50" />
+            <p className="text-xs text-muted-foreground">
+              Add a project folder to start running coding agents on it.
+            </p>
+            <Button size="sm" variant="outline" onClick={onAddProject}>
+              <FolderPlus className="size-3.5" />
+              Add project
+            </Button>
+          </div>
+        )}
+        {projects.map(({ project }) => {
+          const projectSessions = sessions.filter((s) => s.projectId === project.id)
+          return (
+            <div key={project.id} className="mb-3">
+              <div className="group flex items-center gap-1.5 px-1 py-1">
+                <FolderGit2 className="size-3.5 shrink-0 text-muted-foreground" />
+                <span className="min-w-0 flex-1 truncate text-xs font-medium" title={project.path}>
+                  {project.name}
+                </span>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  className="h-6 w-6 p-0 opacity-0 transition-opacity group-hover:opacity-100"
+                  onClick={() => onNewSession(project.id)}
+                  title="New session"
+                >
+                  <Plus className="size-3.5" />
+                </Button>
+                <DropdownMenu>
+                  <DropdownMenuTrigger asChild>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      className="h-6 w-6 p-0 opacity-0 transition-opacity group-hover:opacity-100"
+                    >
+                      <MoreHorizontal className="size-3.5" />
+                    </Button>
+                  </DropdownMenuTrigger>
+                  <DropdownMenuContent align="start">
+                    <DropdownMenuItem onClick={() => onRemoveProject(project.id)}>
+                      <Trash2 className="size-4" />
+                      Remove project
+                    </DropdownMenuItem>
+                  </DropdownMenuContent>
+                </DropdownMenu>
+              </div>
+              {projectSessions.length === 0 ? (
+                <button
+                  type="button"
+                  onClick={() => onNewSession(project.id)}
+                  className="ml-5 flex items-center gap-1.5 rounded px-2 py-1 text-xs text-muted-foreground hover:bg-muted"
+                >
+                  <Plus className="size-3" />
+                  New session
+                </button>
+              ) : (
+                projectSessions.map((session) => {
+                  const status = statusOf(session.id)
+                  return (
+                    <div
+                      key={session.id}
+                      className={cn(
+                        'group ml-3 flex cursor-pointer items-center gap-2 rounded-lg px-2 py-1.5',
+                        selectedSessionId === session.id ? 'bg-muted' : 'hover:bg-muted/60',
+                      )}
+                      onClick={() => onSelectSession(session.id)}
+                    >
+                      <StatusDot status={status} />
+                      <div className="min-w-0 flex-1">
+                        <div className="truncate text-xs">{session.title}</div>
+                        <div className="truncate text-[10px] text-muted-foreground">
+                          {AGENT_SHORT[session.agent]}
+                          {session.mode === 'rowboat' ? ' · Rowboat drives' : ''}
+                          {session.worktree && !session.worktree.removedAt ? ' · worktree' : ''}
+                        </div>
+                      </div>
+                      <DropdownMenu>
+                        <DropdownMenuTrigger asChild>
+                          <Button
+                            variant="ghost"
+                            size="sm"
+                            className="h-6 w-6 shrink-0 p-0 opacity-0 transition-opacity group-hover:opacity-100"
+                            onClick={(e) => e.stopPropagation()}
+                          >
+                            <MoreHorizontal className="size-3.5" />
+                          </Button>
+                        </DropdownMenuTrigger>
+                        <DropdownMenuContent align="start" onClick={(e) => e.stopPropagation()}>
+                          <DropdownMenuItem onClick={() => onDeleteSession(session)}>
+                            <Trash2 className="size-4" />
+                            Delete session
+                          </DropdownMenuItem>
+                        </DropdownMenuContent>
+                      </DropdownMenu>
+                    </div>
+                  )
+                })
+              )}
+            </div>
+          )
+        })}
+      </div>
+    </div>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/code/use-code-chat.ts b/apps/x/apps/renderer/src/components/code/use-code-chat.ts
new file mode 100644
index 00000000..e8e08262
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/use-code-chat.ts
@@ -0,0 +1,378 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type z from 'zod'
+import type { RunEvent } from '@x/shared/src/runs.js'
+import type { CodeRunEvent, PermissionAsk, PermissionDecision } from '@x/shared/src/code-mode.js'
+import type { CodeSession } from '@x/shared/src/code-sessions.js'
+import {
+  type ChatMessage,
+  type ErrorMessage,
+  type ToolCall,
+  normalizeToolInput,
+} from '@/lib/chat-conversation'
+
+// A direct-drive coding turn: the structural ACP events (tool calls, plan,
+// resolved permissions) grouped under one turn id. The agent's prose is NOT
+// part of the turn — it streams via liveText and lands as an assistant
+// ChatMessage, so live rendering and JSONL replay converge on the same shape.
+export interface DirectTurn {
+  kind: 'direct-turn'
+  id: string
+  events: CodeRunEvent[]
+  timestamp: number
+}
+
+export type CodeChatItem = ChatMessage | ToolCall | ErrorMessage | DirectTurn
+
+export const isDirectTurn = (item: CodeChatItem): item is DirectTurn =>
+  'kind' in item && (item as DirectTurn).kind === 'direct-turn'
+
+// Narrowing guards over the widened item union (the chat-conversation guards
+// only accept ConversationItem).
+export const isChatToolCall = (item: CodeChatItem): item is ToolCall => 'name' in item
+export const isChatErrorMessage = (item: CodeChatItem): item is ErrorMessage =>
+  'kind' in item && (item as ErrorMessage).kind === 'error'
+export const isChatMessageItem = (item: CodeChatItem): item is ChatMessage => 'role' in item
+
+export interface PendingCodePermission {
+  requestId: string
+  ask: PermissionAsk
+  toolCallId: string
+}
+
+const DIRECT_PREFIX = 'direct-'
+const STRUCTURAL_EVENTS = new Set(['tool_call', 'tool_call_update', 'plan', 'permission'])
+
+function messageText(content: unknown): string {
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return (content as Array<{ type: string; text?: string }>)
+      .filter((p) => p.type === 'text')
+      .map((p) => p.text ?? '')
+      .join('')
+  }
+  return ''
+}
+
+// Conversation state for one coding session, fed by the run JSONL (history)
+// and the live runs:events stream. Handles both modes: direct turns arrive as
+// code-run-events with a `direct-` toolCallId; Rowboat turns arrive as the
+// usual LLM message/tool events (incl. code_agent_run blocks).
+export function useCodeChat(session: CodeSession | null) {
+  const sessionId = session?.id ?? null
+  const [items, setItems] = useState<CodeChatItem[]>([])
+  const [liveText, setLiveText] = useState('')
+  const [isProcessing, setIsProcessing] = useState(false)
+  const [pendingPermission, setPendingPermission] = useState<PendingCodePermission | null>(null)
+  const [loading, setLoading] = useState(false)
+  const seenMessageIdsRef = useRef<Set<string>>(new Set())
+
+  const applyCodeRunEvent = useCallback((toolCallId: string, event: CodeRunEvent) => {
+    if (toolCallId.startsWith(DIRECT_PREFIX)) {
+      if (!STRUCTURAL_EVENTS.has(event.type)) return
+      setItems((prev) => {
+        const at = prev.findIndex((item) => isDirectTurn(item) && item.id === toolCallId)
+        if (at >= 0) {
+          const turn = prev[at] as DirectTurn
+          const next = [...prev]
+          next[at] = { ...turn, events: [...turn.events, event] }
+          return next
+        }
+        return [...prev, { kind: 'direct-turn', id: toolCallId, events: [event], timestamp: Date.now() }]
+      })
+      return
+    }
+    // Rowboat mode: attach to the code_agent_run tool call block.
+    setItems((prev) => prev.map((item) => {
+      if (isChatToolCall(item) && item.id === toolCallId) {
+        return { ...item, codeRunEvents: [...(item.codeRunEvents ?? []), event] }
+      }
+      return item
+    }))
+  }, [])
+
+  // Load history from the run log whenever the session changes.
+  useEffect(() => {
+    if (!sessionId) {
+      setItems([])
+      setLiveText('')
+      setPendingPermission(null)
+      return
+    }
+    let cancelled = false
+    setLoading(true)
+    setItems([])
+    setLiveText('')
+    setPendingPermission(null)
+    seenMessageIdsRef.current = new Set()
+
+    void window.ipc.invoke('runs:fetch', { runId: sessionId }).then((run) => {
+      if (cancelled) return
+      const loaded: CodeChatItem[] = []
+      const toolCallMap = new Map<string, ToolCall>()
+      const turnMap = new Map<string, DirectTurn>()
+
+      for (const event of run.log as z.infer<typeof RunEvent>[]) {
+        const ts = event.ts ? new Date(event.ts).getTime() : Date.now()
+        switch (event.type) {
+          case 'message': {
+            const msg = event.message
+            if (msg.role === 'user' || msg.role === 'assistant') {
+              const text = messageText(msg.content)
+              if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+                for (const part of msg.content as Array<{ type: string; toolCallId?: string; toolName?: string; arguments?: unknown }>) {
+                  if (part.type === 'tool-call' && part.toolCallId && part.toolName) {
+                    const toolCall: ToolCall = {
+                      id: part.toolCallId,
+                      name: part.toolName,
+                      input: normalizeToolInput(part.arguments as ToolCall['input']),
+                      status: 'pending',
+                      timestamp: ts,
+                    }
+                    toolCallMap.set(toolCall.id, toolCall)
+                    loaded.push(toolCall)
+                  }
+                }
+              }
+              if (text.trim()) {
+                seenMessageIdsRef.current.add(event.messageId)
+                loaded.push({ id: event.messageId, role: msg.role, content: text, timestamp: ts })
+              }
+            }
+            break
+          }
+          case 'tool-invocation': {
+            const existing = event.toolCallId ? toolCallMap.get(event.toolCallId) : null
+            if (existing) {
+              existing.input = normalizeToolInput(event.input)
+              existing.status = 'running'
+            }
+            break
+          }
+          case 'tool-result': {
+            const existing = event.toolCallId ? toolCallMap.get(event.toolCallId) : null
+            if (existing) {
+              existing.result = event.result as ToolCall['result']
+              existing.status = 'completed'
+            }
+            break
+          }
+          case 'code-run-event': {
+            if (event.toolCallId.startsWith(DIRECT_PREFIX)) {
+              if (!STRUCTURAL_EVENTS.has(event.event.type)) break
+              let turn = turnMap.get(event.toolCallId)
+              if (!turn) {
+                turn = { kind: 'direct-turn', id: event.toolCallId, events: [], timestamp: ts }
+                turnMap.set(event.toolCallId, turn)
+                loaded.push(turn)
+              }
+              turn.events.push(event.event)
+            } else {
+              const existing = toolCallMap.get(event.toolCallId)
+              if (existing) existing.codeRunEvents = [...(existing.codeRunEvents ?? []), event.event]
+            }
+            break
+          }
+          case 'error':
+            loaded.push({ id: `error-${loaded.length}`, kind: 'error', message: event.error, timestamp: ts })
+            break
+          default:
+            break
+        }
+      }
+      setItems(loaded)
+    }).catch(() => {
+      // Run log unreadable — show an empty conversation rather than crashing.
+    }).finally(() => {
+      if (!cancelled) setLoading(false)
+    })
+
+    return () => { cancelled = true }
+  }, [sessionId])
+
+  // Live event stream.
+  useEffect(() => {
+    if (!sessionId) return
+    // runs:events is schema-less on the wire (req: z.null()) — cast like App.tsx does.
+    return window.ipc.on('runs:events', ((raw: unknown) => {
+      const event = raw as z.infer<typeof RunEvent>
+      if (event.runId !== sessionId) return
+      switch (event.type) {
+        case 'run-processing-start':
+          setIsProcessing(true)
+          break
+        case 'run-processing-end':
+          setIsProcessing(false)
+          setPendingPermission(null)
+          // Anything still streaming that never landed as a message (e.g. the
+          // turn errored) is flushed so the text isn't lost.
+          setLiveText((text) => {
+            if (text.trim()) {
+              setItems((prev) => [...prev, {
+                id: `assistant-flush-${Date.now()}`,
+                role: 'assistant',
+                content: text,
+                timestamp: Date.now(),
+              }])
+            }
+            return ''
+          })
+          break
+        case 'run-stopped':
+          setIsProcessing(false)
+          setPendingPermission(null)
+          break
+        case 'message': {
+          const msg = event.message
+          if (msg.role !== 'user' && msg.role !== 'assistant') break
+          if (seenMessageIdsRef.current.has(event.messageId)) break
+          const text = messageText(msg.content)
+          if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+            for (const part of msg.content as Array<{ type: string; toolCallId?: string; toolName?: string; arguments?: unknown }>) {
+              if (part.type === 'tool-call' && part.toolCallId && part.toolName) {
+                const toolCall: ToolCall = {
+                  id: part.toolCallId,
+                  name: part.toolName,
+                  input: normalizeToolInput(part.arguments as ToolCall['input']),
+                  status: 'running',
+                  timestamp: Date.now(),
+                }
+                setItems((prev) => (prev.some((i) => isChatToolCall(i) && i.id === toolCall.id) ? prev : [...prev, toolCall]))
+              }
+            }
+          }
+          if (!text.trim()) break
+          seenMessageIdsRef.current.add(event.messageId)
+          const chatMessage: ChatMessage = {
+            id: event.messageId,
+            role: msg.role,
+            content: text.replace(/<\/?voice>/g, ''),
+            timestamp: Date.now(),
+          }
+          if (msg.role === 'assistant') setLiveText('')
+          setItems((prev) => {
+            // Replace the optimistic local echo of this user message if present.
+            if (msg.role === 'user') {
+              const at = prev.findIndex((item) =>
+                'role' in item && item.role === 'user' && item.id.startsWith('local-') && item.content === text)
+              if (at >= 0) {
+                const next = [...prev]
+                next[at] = chatMessage
+                return next
+              }
+            }
+            return [...prev, chatMessage]
+          })
+          break
+        }
+        case 'llm-stream-event': {
+          // Rowboat mode streaming text.
+          const llmEvent = event.event as { type: string; delta?: string; toolCallId?: string; toolName?: string; input?: unknown }
+          setIsProcessing(true)
+          if (llmEvent.type === 'text-delta' && llmEvent.delta) {
+            setLiveText((prev) => prev + llmEvent.delta)
+          } else if (llmEvent.type === 'tool-call' && llmEvent.toolCallId) {
+            const toolCall: ToolCall = {
+              id: llmEvent.toolCallId,
+              name: llmEvent.toolName || 'tool',
+              input: normalizeToolInput(llmEvent.input as ToolCall['input']),
+              status: 'running',
+              timestamp: Date.now(),
+            }
+            setItems((prev) => (prev.some((i) => isChatToolCall(i) && i.id === toolCall.id) ? prev : [...prev, toolCall]))
+          }
+          break
+        }
+        case 'tool-invocation':
+          setItems((prev) => prev.map((item) => (
+            isChatToolCall(item) && item.id === event.toolCallId
+              ? { ...item, input: normalizeToolInput(event.input), status: 'running' as const }
+              : item
+          )))
+          break
+        case 'tool-result':
+          setItems((prev) => prev.map((item) => (
+            isChatToolCall(item) && item.id === event.toolCallId
+              ? { ...item, result: event.result as ToolCall['result'], status: 'completed' as const, pendingCodePermission: null }
+              : item
+          )))
+          break
+        case 'code-run-event': {
+          setIsProcessing(true)
+          if (event.event.type === 'message' && event.event.role === 'agent' && event.toolCallId.startsWith(DIRECT_PREFIX)) {
+            const text = event.event.text
+            setLiveText((prev) => prev + text)
+          }
+          if (event.event.type === 'permission') {
+            setPendingPermission(null)
+          }
+          applyCodeRunEvent(event.toolCallId, event.event)
+          break
+        }
+        case 'code-run-permission-request':
+          setPendingPermission({ requestId: event.requestId, ask: event.ask, toolCallId: event.toolCallId })
+          break
+        case 'error':
+          setItems((prev) => [...prev, {
+            id: `error-${Date.now()}`,
+            kind: 'error',
+            message: event.error,
+            timestamp: Date.now(),
+          }])
+          break
+        default:
+          break
+      }
+    }) as unknown as (event: null) => void)
+  }, [sessionId, applyCodeRunEvent])
+
+  const send = useCallback(async (text: string): Promise<{ ok: boolean; error?: string }> => {
+    if (!session) return { ok: false, error: 'No session selected' }
+    const trimmed = text.trim()
+    if (!trimmed) return { ok: false }
+    // Optimistic echo, replaced by the persisted event when it arrives.
+    setItems((prev) => [...prev, {
+      id: `local-${Date.now()}`,
+      role: 'user',
+      content: trimmed,
+      timestamp: Date.now(),
+    }])
+    setIsProcessing(true)
+    try {
+      if (session.mode === 'direct') {
+        const res = await window.ipc.invoke('codeSession:sendMessage', { sessionId: session.id, text: trimmed })
+        if (!res.accepted) {
+          setIsProcessing(false)
+          return { ok: false, error: res.error ?? 'The session is busy.' }
+        }
+      } else {
+        await window.ipc.invoke('runs:createMessage', {
+          runId: session.id,
+          message: trimmed,
+          codeMode: session.agent,
+          codeCwd: session.cwd,
+          codePolicy: session.policy,
+        })
+      }
+      return { ok: true }
+    } catch (err) {
+      setIsProcessing(false)
+      return { ok: false, error: err instanceof Error ? err.message : 'Failed to send message' }
+    }
+  }, [session])
+
+  const stop = useCallback(async () => {
+    if (!sessionId) return
+    await window.ipc.invoke('codeSession:stop', { sessionId })
+  }, [sessionId])
+
+  const resolvePermission = useCallback(async (decision: PermissionDecision) => {
+    if (!pendingPermission) return
+    setPendingPermission(null)
+    await window.ipc.invoke('codeRun:resolvePermission', {
+      requestId: pendingPermission.requestId,
+      decision,
+    })
+  }, [pendingPermission])
+
+  return { items, liveText, isProcessing, pendingPermission, loading, send, stop, resolvePermission }
+}
diff --git a/apps/x/apps/renderer/src/components/code/use-code-sessions.ts b/apps/x/apps/renderer/src/components/code/use-code-sessions.ts
new file mode 100644
index 00000000..9728c813
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/use-code-sessions.ts
@@ -0,0 +1,72 @@
+import { useCallback, useEffect, useState } from 'react'
+import type { CodeProject, CodeSession, CodeSessionStatus, GitRepoInfo } from '@x/shared/src/code-sessions.js'
+
+export interface ProjectRow {
+  project: CodeProject
+  git: GitRepoInfo
+}
+
+const STATUS_RANK: Record<CodeSessionStatus, number> = {
+  'needs-you': 0,
+  working: 1,
+  idle: 2,
+}
+
+// Projects + sessions + live statuses for the Code section. Statuses stream
+// over `codeSession:status` (pushed by the main-process tracker); the lists
+// load on demand and on session lifecycle changes.
+export function useCodeSessions() {
+  const [projects, setProjects] = useState<ProjectRow[]>([])
+  const [sessions, setSessions] = useState<CodeSession[]>([])
+  const [statuses, setStatuses] = useState<Record<string, CodeSessionStatus>>({})
+  const [loaded, setLoaded] = useState(false)
+
+  const refresh = useCallback(async () => {
+    try {
+      const [projectsRes, sessionsRes] = await Promise.all([
+        window.ipc.invoke('codeProject:list', null),
+        window.ipc.invoke('codeSession:list', null),
+      ])
+      setProjects(projectsRes.projects)
+      setSessions(sessionsRes.sessions)
+      setStatuses((prev) => ({ ...sessionsRes.statuses, ...prev }))
+    } finally {
+      setLoaded(true)
+    }
+  }, [])
+
+  useEffect(() => {
+    void refresh()
+  }, [refresh])
+
+  useEffect(() => {
+    return window.ipc.on('codeSession:status', ({ sessionId, status }) => {
+      setStatuses((prev) => (prev[sessionId] === status ? prev : { ...prev, [sessionId]: status }))
+      // Turn boundaries bump lastActivityAt — refresh ordering when one ends.
+      if (status === 'idle') {
+        void window.ipc.invoke('codeSession:list', null).then((res) => setSessions(res.sessions))
+      }
+    })
+  }, [])
+
+  const statusOf = useCallback(
+    (sessionId: string): CodeSessionStatus => statuses[sessionId] ?? 'idle',
+    [statuses],
+  )
+
+  const sortedSessions = [...sessions].sort((a, b) => {
+    const rank = STATUS_RANK[statusOf(a.id)] - STATUS_RANK[statusOf(b.id)]
+    if (rank !== 0) return rank
+    return (b.lastActivityAt ?? b.createdAt).localeCompare(a.lastActivityAt ?? a.createdAt)
+  })
+
+  return {
+    projects,
+    sessions: sortedSessions,
+    statuses,
+    statusOf,
+    loaded,
+    refresh,
+    setSessions,
+  }
+}
diff --git a/apps/x/apps/renderer/src/components/code/workspace-pane.tsx b/apps/x/apps/renderer/src/components/code/workspace-pane.tsx
new file mode 100644
index 00000000..57172015
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/code/workspace-pane.tsx
@@ -0,0 +1,254 @@
+import { useCallback, useEffect, useState } from 'react'
+import {
+  FileDiff,
+  FilePlus2,
+  FileX2,
+  FileEdit,
+  GitBranch,
+  GitMerge,
+  MoreHorizontal,
+  RefreshCw,
+  Trash2,
+} from 'lucide-react'
+import type { CodeSession, CodeSessionStatus, GitStatusFile } from '@x/shared/src/code-sessions.js'
+import { cn } from '@/lib/utils'
+import { toast } from 'sonner'
+import { Button } from '@/components/ui/button'
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu'
+import { CodeFileTree } from './file-tree'
+import { CodeFileViewer } from './file-viewer'
+import { DiffViewer } from './diff-viewer'
+
+type GitStatus = {
+  isRepo: boolean
+  branch: string | null
+  hasCommits: boolean
+  files: GitStatusFile[]
+}
+
+const STATE_ICON: Record<GitStatusFile['state'], typeof FileEdit> = {
+  modified: FileEdit,
+  added: FilePlus2,
+  untracked: FilePlus2,
+  deleted: FileX2,
+  renamed: FileEdit,
+}
+
+// Right pane of a coding session: a diff reviewer first (Changes), a code
+// browser second (Files). Read-only in v1 by design.
+export function WorkspacePane({
+  session,
+  status,
+  openDiffPath,
+  onDiffOpened,
+  onSessionChanged,
+}: {
+  session: CodeSession
+  status: CodeSessionStatus
+  // A file path requested from the chat (clicking a changed file in a tool call).
+  openDiffPath: string | null
+  onDiffOpened: () => void
+  onSessionChanged: () => void
+}) {
+  const [tab, setTab] = useState<'changes' | 'files'>('changes')
+  const [gitStatus, setGitStatus] = useState<GitStatus | null>(null)
+  const [diffPath, setDiffPath] = useState<string | null>(null)
+  const [filePath, setFilePath] = useState<string | null>(null)
+  const [merging, setMerging] = useState(false)
+
+  const refreshStatus = useCallback(async () => {
+    try {
+      const res = await window.ipc.invoke('codeSession:gitStatus', { sessionId: session.id })
+      setGitStatus(res)
+    } catch {
+      setGitStatus(null)
+    }
+  }, [session.id])
+
+  useEffect(() => {
+    setTab('changes')
+    setDiffPath(null)
+    setFilePath(null)
+    void refreshStatus()
+  }, [refreshStatus])
+
+  // Refresh on turn end, and poll lightly while the agent is working — the
+  // session cwd lives outside the workspace watcher, so there are no change
+  // events to react to.
+  useEffect(() => {
+    if (status === 'idle') {
+      void refreshStatus()
+      return
+    }
+    const interval = setInterval(() => void refreshStatus(), 5000)
+    return () => clearInterval(interval)
+  }, [status, refreshStatus])
+
+  // Chat asked to show a specific file's diff.
+  useEffect(() => {
+    if (!openDiffPath) return
+    // Tool events may carry absolute paths — make them cwd-relative.
+    const rel = openDiffPath.startsWith(session.cwd + '/')
+      ? openDiffPath.slice(session.cwd.length + 1)
+      : openDiffPath
+    setTab('changes')
+    setDiffPath(rel)
+    onDiffOpened()
+  }, [openDiffPath, session.cwd, onDiffOpened])
+
+  const handleMergeBack = async () => {
+    setMerging(true)
+    try {
+      const res = await window.ipc.invoke('codeSession:mergeBack', { sessionId: session.id })
+      if (res.ok) {
+        toast.success(res.message)
+        onSessionChanged()
+      } else {
+        toast.error(res.message, { duration: 10000 })
+      }
+    } finally {
+      setMerging(false)
+    }
+  }
+
+  const handleCleanup = async (deleteBranch: boolean) => {
+    const res = await window.ipc.invoke('codeSession:cleanupWorktree', { sessionId: session.id, deleteBranch })
+    if (res.success) {
+      toast.success('Worktree removed. The session now works directly in the repo.')
+      onSessionChanged()
+    } else {
+      toast.error(res.error ?? 'Failed to remove worktree')
+    }
+  }
+
+  const dirtyCount = gitStatus?.files.length ?? 0
+  const worktreeActive = session.worktree && !session.worktree.removedAt
+
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      {/* Header: branch + worktree controls */}
+      <div className="flex items-center gap-2 border-b px-3 py-2">
+        <div className="flex min-w-0 flex-1 items-center gap-1.5 text-xs text-muted-foreground">
+          {gitStatus?.isRepo ? (
+            <>
+              <GitBranch className="size-3.5 shrink-0" />
+              <span className="truncate font-mono">{gitStatus.branch ?? '(no branch)'}</span>
+              {dirtyCount > 0 && (
+                <span className="shrink-0 rounded-full bg-amber-500/15 px-1.5 py-0.5 text-[10px] font-medium text-amber-600">
+                  {dirtyCount} changed
+                </span>
+              )}
+            </>
+          ) : (
+            <span>Not a git repository</span>
+          )}
+        </div>
+        <Button variant="ghost" size="sm" className="h-7 px-2" onClick={() => void refreshStatus()} title="Refresh">
+          <RefreshCw className="size-3.5" />
+        </Button>
+        {worktreeActive && (
+          <DropdownMenu>
+            <DropdownMenuTrigger asChild>
+              <Button variant="outline" size="sm" className="h-7 gap-1.5 px-2 text-xs">
+                <GitMerge className="size-3.5" />
+                Worktree
+                <MoreHorizontal className="size-3" />
+              </Button>
+            </DropdownMenuTrigger>
+            <DropdownMenuContent align="end">
+              <DropdownMenuItem disabled={merging} onClick={() => void handleMergeBack()}>
+                <GitMerge className="size-4" />
+                Merge back into repo
+              </DropdownMenuItem>
+              <DropdownMenuItem onClick={() => void handleCleanup(false)}>
+                <Trash2 className="size-4" />
+                Remove worktree (keep branch)
+              </DropdownMenuItem>
+              <DropdownMenuItem variant="destructive" onClick={() => void handleCleanup(true)}>
+                <Trash2 className="size-4" />
+                Remove worktree and branch
+              </DropdownMenuItem>
+            </DropdownMenuContent>
+          </DropdownMenu>
+        )}
+      </div>
+
+      {/* Tabs */}
+      <div className="flex items-center gap-1 border-b px-3 py-1.5">
+        {(['changes', 'files'] as const).map((t) => (
+          <button
+            key={t}
+            type="button"
+            onClick={() => setTab(t)}
+            className={cn(
+              'rounded-full px-3 py-1 text-xs font-medium capitalize transition-colors',
+              tab === t ? 'bg-foreground text-background' : 'text-muted-foreground hover:bg-muted',
+            )}
+          >
+            {t === 'changes' ? `Changes${dirtyCount > 0 ? ` (${dirtyCount})` : ''}` : 'Files'}
+          </button>
+        ))}
+      </div>
+
+      {/* Body */}
+      <div className="min-h-0 flex-1">
+        {tab === 'changes' && (
+          diffPath ? (
+            <DiffViewer sessionId={session.id} path={diffPath} onClose={() => setDiffPath(null)} />
+          ) : (
+            <div className="h-full overflow-auto p-2">
+              {!gitStatus?.isRepo && (
+                <p className="p-3 text-sm text-muted-foreground">
+                  This folder isn't a git repository, so there's nothing to diff. The Files tab still works.
+                </p>
+              )}
+              {gitStatus?.isRepo && gitStatus.files.length === 0 && (
+                <p className="p-3 text-sm text-muted-foreground">No uncommitted changes.</p>
+              )}
+              {gitStatus?.files.map((file) => {
+                const Icon = STATE_ICON[file.state]
+                return (
+                  <button
+                    key={file.path}
+                    type="button"
+                    onClick={() => setDiffPath(file.path)}
+                    className="flex w-full items-center gap-2 rounded-lg px-2 py-1.5 text-left text-xs hover:bg-muted"
+                    title={file.path}
+                  >
+                    <Icon className={cn(
+                      'size-3.5 shrink-0',
+                      file.state === 'deleted' ? 'text-red-500' : file.state === 'modified' || file.state === 'renamed' ? 'text-amber-500' : 'text-green-600',
+                    )} />
+                    <span className="min-w-0 flex-1 truncate font-mono">{file.path}</span>
+                    {file.insertions !== null && <span className="shrink-0 text-green-600">+{file.insertions}</span>}
+                    {file.deletions !== null && <span className="shrink-0 text-red-500">−{file.deletions}</span>}
+                  </button>
+                )
+              })}
+            </div>
+          )
+        )}
+        {tab === 'files' && (
+          filePath ? (
+            <CodeFileViewer sessionId={session.id} path={filePath} onClose={() => setFilePath(null)} />
+          ) : (
+            <div className="h-full overflow-auto">
+              <CodeFileTree sessionId={session.id} selectedPath={filePath} onSelectFile={setFilePath} />
+            </div>
+          )
+        )}
+      </div>
+      {tab === 'changes' && !diffPath && dirtyCount > 0 && (
+        <div className="border-t px-3 py-1.5 text-[11px] text-muted-foreground">
+          <FileDiff className="mr-1 inline size-3" />
+          Click a file to review its diff.
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/coding-run.tsx b/apps/x/apps/renderer/src/components/coding-run.tsx
index 4d5dd33b..4d896e6a 100644
--- a/apps/x/apps/renderer/src/components/coding-run.tsx
+++ b/apps/x/apps/renderer/src/components/coding-run.tsx
@@ -28,7 +28,7 @@ type PlanRow = { kind: 'plan'; id: string; entries: { content: string; status?:
 type PermRow = { kind: 'perm'; id: string; title: string; decision: string }
 type Row = TextRow | ToolRow | PlanRow | PermRow
 
-function reduceEvents(events: CodeRunEvent[]): Row[] {
+export function reduceEvents(events: CodeRunEvent[]): Row[] {
   const rows: Row[] = []
   const toolIdx = new Map<string, number>()
   let planIdx = -1
@@ -107,7 +107,14 @@ function planMarker(status?: string) {
 
 const basename = (p: string) => p.split(/[\\/]/).pop() || p
 
-function CodingRunTimeline({ events }: { events: CodeRunEvent[] }) {
+export function CodingRunTimeline({
+  events,
+  onOpenDiff,
+}: {
+  events: CodeRunEvent[]
+  // When set, changed-file names become clickable (the Code section opens the diff).
+  onOpenDiff?: (path: string) => void
+}) {
   const rows = useMemo(() => reduceEvents(events), [events])
   if (rows.length === 0) {
     return <div className="px-4 py-3 text-xs text-muted-foreground">Starting the agent…</div>
@@ -136,9 +143,21 @@ function CodingRunTimeline({ events }: { events: CodeRunEvent[] }) {
               {row.diffs.length > 0 && (
                 <div className="ml-7 flex flex-col gap-0.5">
                   {row.diffs.map((d) => (
-                    <span key={d} className="truncate font-mono text-xs text-muted-foreground" title={d}>
-                      {basename(d)}
-                    </span>
+                    onOpenDiff ? (
+                      <button
+                        key={d}
+                        type="button"
+                        onClick={() => onOpenDiff(d)}
+                        className="truncate text-left font-mono text-xs text-muted-foreground hover:text-foreground hover:underline"
+                        title={d}
+                      >
+                        {basename(d)}
+                      </button>
+                    ) : (
+                      <span key={d} className="truncate font-mono text-xs text-muted-foreground" title={d}>
+                        {basename(d)}
+                      </span>
+                    )
                   ))}
                 </div>
               )}
diff --git a/apps/x/apps/renderer/src/components/sidebar-content.tsx b/apps/x/apps/renderer/src/components/sidebar-content.tsx
index f5870ec4..54a4c61c 100644
--- a/apps/x/apps/renderer/src/components/sidebar-content.tsx
+++ b/apps/x/apps/renderer/src/components/sidebar-content.tsx
@@ -5,6 +5,7 @@ import { useCallback, useEffect, useRef, useState } from "react"
 import {
   Bot,
   ChevronRight,
+  Code2,
   FileText,
   FilePlus,
   Folder,
@@ -168,6 +169,7 @@ type SidebarContentPanelProps = {
   knowledgeActions: KnowledgeActions
   bgTaskSummaries?: TaskSummary[]
   onOpenMeetings?: () => void
+  onOpenCode?: () => void
   onOpenBgTasks?: () => void
   onOpenAgent?: (slug: string) => void
   recentRuns?: { id: string; title?: string; createdAt: string }[]
@@ -178,7 +180,7 @@ type SidebarContentPanelProps = {
   onToggleBrowser?: () => void
   onVoiceNoteCreated?: (path: string) => void
   /** Which primary destination is currently active, for nav highlighting. */
-  activeNav?: 'home' | 'email' | 'meetings' | 'knowledge' | 'agents' | 'workspaces' | null
+  activeNav?: 'home' | 'email' | 'meetings' | 'code' | 'knowledge' | 'agents' | 'workspaces' | null
   /** Live meeting recording state, so the recording row can show its indicator/stop. */
   meetingRecordingState?: 'idle' | 'connecting' | 'recording' | 'stopping'
   recordingMeetingSource?: string | null
@@ -416,6 +418,7 @@ export function SidebarContentPanel({
   knowledgeActions,
   bgTaskSummaries = [],
   onOpenMeetings,
+  onOpenCode,
   onOpenBgTasks,
   onOpenAgent,
   recentRuns = [],
@@ -834,6 +837,12 @@ export function SidebarContentPanel({
                   </div>
                 ) : null}
               </SidebarMenuItem>
+              <SidebarMenuItem>
+                <SidebarMenuButton isActive={activeNav === 'code'} onClick={onOpenCode}>
+                  <Code2 className="size-4 shrink-0" />
+                  <span className="flex-1 truncate">Code</span>
+                </SidebarMenuButton>
+              </SidebarMenuItem>
               <SidebarMenuItem>
                 <SidebarMenuButton
                   isActive={activeNav === 'knowledge'}
diff --git a/apps/x/packages/core/src/agents/runtime.ts b/apps/x/packages/core/src/agents/runtime.ts
index 6f563a07..a51987fc 100644
--- a/apps/x/packages/core/src/agents/runtime.ts
+++ b/apps/x/packages/core/src/agents/runtime.ts
@@ -1181,6 +1181,8 @@ export async function* streamAgent({
     let voiceOutput: 'summary' | 'full' | null = null;
     let searchEnabled = false;
     let codeMode: 'claude' | 'codex' | null = null;
+    let codeCwd: string | null = null;
+    let codePolicy: 'ask' | 'auto-approve-reads' | 'yolo' | null = null;
     let middlePaneContext:
         | { kind: 'note'; path: string; content: string }
         | { kind: 'browser'; url: string; title: string }
@@ -1280,6 +1282,8 @@ export async function* streamAgent({
                     abortRegistry,
                     publish: (event) => bus.publish(event),
                     codeMode,
+                    codeCwd,
+                    codePolicy,
                 });
             }
             } catch (error) {
@@ -1339,6 +1343,8 @@ export async function* streamAgent({
             // Code mode is per-message: latest message decides whether the assistant
             // should route coding work through the code-with-agents skill / chosen agent.
             codeMode = msg.codeMode ?? null;
+            codeCwd = msg.codeCwd ?? null;
+            codePolicy = msg.codePolicy ?? null;
             if (msg.voiceOutput) {
                 voiceOutput = msg.voiceOutput;
             }
@@ -1436,7 +1442,7 @@ The chip is the single source of truth for which agent runs:
 
 **How to run coding work — call the \`code_agent_run\` tool** with:
 - \`agent\`: \`${codeMode}\` (always — match the chip).
-- \`cwd\`: the absolute project/working directory (resolve it per the code-with-agents skill — a path the user named, the "# User Work Directory" block, or ask once).
+- \`cwd\`: ${codeCwd ? `\`${codeCwd}\` (always — this coding session is pinned to that directory; never use another path)` : `the absolute project/working directory (resolve it per the code-with-agents skill — a path the user named, the "# User Work Directory" block, or ask once)`}.
 - \`prompt\`: a clear, self-contained coding instruction.
 
 The tool runs the agent on-device and streams its tool calls, file diffs, and plan into the chat; any action needing approval surfaces as an inline permission card, so you do NOT pre-confirm with an in-chat "reply yes". This chat keeps ONE persistent agent session, so follow-up coding requests automatically resume with full context — just call \`code_agent_run\` again. Do NOT shell out to \`acpx\` or \`executeCommand\` for coding, and do NOT fall back to your own file tools.
diff --git a/apps/x/packages/core/src/analytics/use_case.ts b/apps/x/packages/core/src/analytics/use_case.ts
index a110dc19..a865a7cf 100644
--- a/apps/x/packages/core/src/analytics/use_case.ts
+++ b/apps/x/packages/core/src/analytics/use_case.ts
@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 
-export type UseCase = 'copilot_chat' | 'live_note_agent' | 'background_task_agent' | 'meeting_note' | 'knowledge_sync';
+export type UseCase = 'copilot_chat' | 'live_note_agent' | 'background_task_agent' | 'meeting_note' | 'knowledge_sync' | 'code_session';
 
 export interface UseCaseContext {
   useCase: UseCase;
diff --git a/apps/x/packages/core/src/application/lib/builtin-tools.ts b/apps/x/packages/core/src/application/lib/builtin-tools.ts
index 08e8334f..fe474463 100644
--- a/apps/x/packages/core/src/application/lib/builtin-tools.ts
+++ b/apps/x/packages/core/src/application/lib/builtin-tools.ts
@@ -824,16 +824,24 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
             // chip set) — otherwise it can anchor on the thread's earlier agent and ignore a
             // chip change. Honor the chip so switching it deterministically switches agents.
             const effectiveAgent = ctx.codeMode ?? agent;
+            // Code-section sessions pin the working directory — never trust the model's
+            // cwd argument over the session's.
+            const effectiveCwd = ctx.codeCwd ?? cwd;
             const manager = container.resolve<CodeModeManager>('codeModeManager');
             const registry = container.resolve<CodePermissionRegistry>('codePermissionRegistry');
 
-            // Approval policy from settings; default to asking the user.
+            // Approval policy: the session's (Code section) wins, else global settings,
+            // else default to asking the user.
             let policy: ApprovalPolicy = 'ask';
-            try {
-                const cfg = await container.resolve<ICodeModeConfigRepo>('codeModeConfigRepo').getConfig();
-                if (cfg.approvalPolicy) policy = cfg.approvalPolicy;
-            } catch {
-                // fall back to 'ask'
+            if (ctx.codePolicy) {
+                policy = ctx.codePolicy;
+            } else {
+                try {
+                    const cfg = await container.resolve<ICodeModeConfigRepo>('codeModeConfigRepo').getConfig();
+                    if (cfg.approvalPolicy) policy = cfg.approvalPolicy;
+                } catch {
+                    // fall back to 'ask'
+                }
             }
 
             // On stop, unblock any pending approval card so the broker stops waiting for
@@ -850,7 +858,7 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
                 const result = await manager.runPrompt({
                     runId: ctx.runId,
                     agent: effectiveAgent,
-                    cwd,
+                    cwd: effectiveCwd,
                     prompt,
                     policy,
                     signal: ctx.signal,
diff --git a/apps/x/packages/core/src/application/lib/exec-tool.ts b/apps/x/packages/core/src/application/lib/exec-tool.ts
index b34f6ed4..5fd2816c 100644
--- a/apps/x/packages/core/src/application/lib/exec-tool.ts
+++ b/apps/x/packages/core/src/application/lib/exec-tool.ts
@@ -18,6 +18,11 @@ export interface ToolContext {
     // it is the authoritative coding agent — code_agent_run uses it rather than the
     // agent the model guessed, so switching the chip deterministically switches agents.
     codeMode?: 'claude' | 'codex' | null;
+    // Set for Code-section sessions in Rowboat mode: the session's working directory
+    // and approval policy. code_agent_run honors these over the model's cwd argument
+    // and the global approval policy.
+    codeCwd?: string | null;
+    codePolicy?: 'ask' | 'auto-approve-reads' | 'yolo' | null;
 }
 
 async function execMcpTool(agentTool: z.infer<typeof ToolAttachment> & { type: "mcp" }, input: Record<string, unknown>): Promise<unknown> {
diff --git a/apps/x/packages/core/src/application/lib/message-queue.ts b/apps/x/packages/core/src/application/lib/message-queue.ts
index a513b3ac..3e8c27f3 100644
--- a/apps/x/packages/core/src/application/lib/message-queue.ts
+++ b/apps/x/packages/core/src/application/lib/message-queue.ts
@@ -9,6 +9,7 @@ export type MiddlePaneContext =
     | { kind: 'browser'; url: string; title: string };
 
 export type CodeMode = 'claude' | 'codex';
+export type CodePolicy = 'ask' | 'auto-approve-reads' | 'yolo';
 
 type EnqueuedMessage = {
     messageId: string;
@@ -17,11 +18,16 @@ type EnqueuedMessage = {
     voiceOutput?: VoiceOutputMode;
     searchEnabled?: boolean;
     codeMode?: CodeMode;
+    // Code-section sessions pin the coding agent's working directory and
+    // approval policy for the turn (code_agent_run honors these over its
+    // model-provided arguments / the global policy).
+    codeCwd?: string;
+    codePolicy?: CodePolicy;
     middlePaneContext?: MiddlePaneContext;
 };
 
 export interface IMessageQueue {
-    enqueue(runId: string, message: UserMessageContentType, voiceInput?: boolean, voiceOutput?: VoiceOutputMode, searchEnabled?: boolean, middlePaneContext?: MiddlePaneContext, codeMode?: CodeMode): Promise<string>;
+    enqueue(runId: string, message: UserMessageContentType, voiceInput?: boolean, voiceOutput?: VoiceOutputMode, searchEnabled?: boolean, middlePaneContext?: MiddlePaneContext, codeMode?: CodeMode, codeCwd?: string, codePolicy?: CodePolicy): Promise<string>;
     dequeue(runId: string): Promise<EnqueuedMessage | null>;
 }
 
@@ -37,7 +43,7 @@ export class InMemoryMessageQueue implements IMessageQueue {
         this.idGenerator = idGenerator;
     }
 
-    async enqueue(runId: string, message: UserMessageContentType, voiceInput?: boolean, voiceOutput?: VoiceOutputMode, searchEnabled?: boolean, middlePaneContext?: MiddlePaneContext, codeMode?: CodeMode): Promise<string> {
+    async enqueue(runId: string, message: UserMessageContentType, voiceInput?: boolean, voiceOutput?: VoiceOutputMode, searchEnabled?: boolean, middlePaneContext?: MiddlePaneContext, codeMode?: CodeMode, codeCwd?: string, codePolicy?: CodePolicy): Promise<string> {
         if (!this.store[runId]) {
             this.store[runId] = [];
         }
@@ -49,6 +55,8 @@ export class InMemoryMessageQueue implements IMessageQueue {
             voiceOutput,
             searchEnabled,
             codeMode,
+            codeCwd,
+            codePolicy,
             middlePaneContext,
         });
         return id;
diff --git a/apps/x/packages/core/src/code-mode/acp/manager.ts b/apps/x/packages/core/src/code-mode/acp/manager.ts
index 04ccdebd..033bf994 100644
--- a/apps/x/packages/core/src/code-mode/acp/manager.ts
+++ b/apps/x/packages/core/src/code-mode/acp/manager.ts
@@ -15,6 +15,13 @@ export interface RunPromptArgs {
     onEvent: (event: CodeRunEvent) => void;
     /** Aborts the turn on stop; the manager cancels then force-kills the adapter. */
     signal?: AbortSignal;
+    /**
+     * Drop the conversation replay that session/load streams on a cold resume.
+     * Direct sessions persist their own history (run JSONL) and render from it,
+     * so replaying through onEvent would duplicate every prior turn. When set,
+     * events only flow to onEvent once the session is open, right before prompt.
+     */
+    suppressReplay?: boolean;
 }
 
 interface ActiveRun {
@@ -51,7 +58,7 @@ export class CodeModeManager {
     private readonly runs = new Map<string, ActiveRun>();
 
     async runPrompt(args: RunPromptArgs): Promise<RunPromptResult> {
-        const { runId, agent, cwd, prompt, policy, ask, onEvent, signal } = args;
+        const { runId, agent, cwd, prompt, policy, ask, onEvent, signal, suppressReplay } = args;
 
         const broker = new PermissionBroker({
             policy,
@@ -59,7 +66,7 @@ export class CodeModeManager {
             onResolved: (a, decision, auto) => onEvent({ type: 'permission', ask: a, decision, auto }),
         });
 
-        const run = await this.ensureRun(runId, agent, cwd, broker, onEvent);
+        const run = await this.ensureRun(runId, agent, cwd, broker, onEvent, suppressReplay ?? false);
         run.inflight++;
 
         let graceTimer: ReturnType<typeof setTimeout> | undefined;
@@ -148,6 +155,7 @@ export class CodeModeManager {
         cwd: string,
         broker: PermissionBroker,
         onEvent: (event: CodeRunEvent) => void,
+        suppressReplay: boolean,
     ): Promise<ActiveRun> {
         const existing = this.runs.get(runId);
         if (existing && existing.agent === agent && existing.cwd === cwd) {
@@ -157,10 +165,19 @@ export class CodeModeManager {
         }
         if (existing) this.dispose(runId); // agent/cwd changed — start over
 
-        const client = new AcpClient({ agent, cwd, broker, onEvent });
+        // With suppressReplay, the client starts with a muted event sink so a
+        // session/load replay of the prior conversation goes nowhere; the real
+        // sink is installed once the session is open (below).
+        const client = new AcpClient({
+            agent,
+            cwd,
+            broker,
+            onEvent: suppressReplay ? () => {} : onEvent,
+        });
         await client.start();
 
         const sessionId = await this.openSession(runId, agent, cwd, client);
+        if (suppressReplay) client.setHandlers(broker, onEvent);
         const run: ActiveRun = { client, sessionId, agent, cwd, inflight: 0 };
         this.runs.set(runId, run);
         return run;
diff --git a/apps/x/packages/core/src/code-mode/git/service.ts b/apps/x/packages/core/src/code-mode/git/service.ts
new file mode 100644
index 00000000..17b4bfb1
--- /dev/null
+++ b/apps/x/packages/core/src/code-mode/git/service.ts
@@ -0,0 +1,240 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import type { GitRepoInfo, GitStatusFile, GitFileState } from '@x/shared/dist/code-sessions.js';
+
+const execFileAsync = promisify(execFile);
+
+// Plain shell-outs to the system git. isomorphic-git (already in core) doesn't
+// support worktrees, and these calls are simple enough that wrapping the CLI is
+// both lighter and more faithful to what the user's own git would do.
+
+const MAX_BUFFER = 32 * 1024 * 1024;
+// Diff/file payloads above this are not worth shipping to the renderer.
+const MAX_TEXT_BYTES = 1024 * 1024;
+
+async function git(cwd: string, args: string[]): Promise<string> {
+    const { stdout } = await execFileAsync('git', args, { cwd, maxBuffer: MAX_BUFFER });
+    return stdout;
+}
+
+let gitAvailable: Promise<boolean> | null = null;
+export function isGitAvailable(): Promise<boolean> {
+    if (!gitAvailable) {
+        gitAvailable = execFileAsync('git', ['--version'], { timeout: 5000 })
+            .then(() => true)
+            .catch(() => false);
+    }
+    return gitAvailable;
+}
+
+export async function repoInfo(cwd: string): Promise<GitRepoInfo> {
+    const none: GitRepoInfo = { isGitRepo: false, branch: null, hasCommits: false, dirtyCount: 0 };
+    if (!await isGitAvailable()) return none;
+    try {
+        const inside = (await git(cwd, ['rev-parse', '--is-inside-work-tree'])).trim();
+        if (inside !== 'true') return none;
+    } catch {
+        return none;
+    }
+    let branch: string | null = null;
+    try {
+        branch = (await git(cwd, ['rev-parse', '--abbrev-ref', 'HEAD'])).trim() || null;
+    } catch {
+        // unborn branch (no commits) — symbolic-ref still knows the name
+        try {
+            const ref = (await git(cwd, ['symbolic-ref', 'HEAD'])).trim();
+            branch = ref.replace(/^refs\/heads\//, '') || null;
+        } catch {
+            branch = null;
+        }
+    }
+    let hasCommits = false;
+    try {
+        await git(cwd, ['rev-parse', '--verify', 'HEAD']);
+        hasCommits = true;
+    } catch {
+        hasCommits = false;
+    }
+    let dirtyCount = 0;
+    try {
+        const out = await git(cwd, ['status', '--porcelain=v1', '-z']);
+        dirtyCount = out.split('\0').filter((l) => l.trim() !== '').length;
+    } catch {
+        dirtyCount = 0;
+    }
+    return { isGitRepo: true, branch, hasCommits, dirtyCount };
+}
+
+function stateFromPorcelain(xy: string): GitFileState {
+    if (xy === '??') return 'untracked';
+    if (xy.includes('R')) return 'renamed';
+    if (xy.includes('A')) return 'added';
+    if (xy.includes('D')) return 'deleted';
+    return 'modified';
+}
+
+// Working-tree changes vs HEAD with insertion/deletion counts. Untracked files
+// get their line count from disk (capped) since numstat doesn't cover them.
+export async function status(cwd: string): Promise<GitStatusFile[]> {
+    const out = await git(cwd, ['status', '--porcelain=v1', '-z']);
+    const entries: Array<{ path: string; state: GitFileState }> = [];
+    // -z format: "XY path\0" and for renames "XY newPath\0oldPath\0"
+    const parts = out.split('\0');
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (!part || part.length < 4) continue;
+        const xy = part.slice(0, 2);
+        const filePath = part.slice(3);
+        const state = stateFromPorcelain(xy);
+        if (state === 'renamed') i++; // skip the old path that follows
+        entries.push({ path: filePath, state });
+    }
+
+    const counts = new Map<string, { insertions: number | null; deletions: number | null }>();
+    try {
+        const numstat = await git(cwd, ['diff', 'HEAD', '--numstat', '-z']);
+        // -z numstat rows: "ins\tdel\tpath\0" (renames: "ins\tdel\0old\0new\0")
+        const rows = numstat.split('\0');
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            if (!row) continue;
+            const m = row.match(/^(\d+|-)\t(\d+|-)\t?(.*)$/);
+            if (!m) continue;
+            const insertions = m[1] === '-' ? null : Number(m[1]);
+            const deletions = m[2] === '-' ? null : Number(m[2]);
+            let filePath = m[3];
+            if (!filePath) {
+                // rename form: old and new paths follow as separate tokens
+                i += 2;
+                filePath = rows[i] ?? '';
+            }
+            if (filePath) counts.set(filePath, { insertions, deletions });
+        }
+    } catch {
+        // no HEAD yet (no commits) — leave counts empty
+    }
+
+    const result: GitStatusFile[] = [];
+    for (const entry of entries) {
+        let insertions: number | null = null;
+        let deletions: number | null = null;
+        const counted = counts.get(entry.path);
+        if (counted) {
+            insertions = counted.insertions;
+            deletions = counted.deletions;
+        } else if (entry.state === 'untracked') {
+            try {
+                const full = path.join(cwd, entry.path);
+                const stat = await fs.stat(full);
+                if (stat.isFile() && stat.size <= MAX_TEXT_BYTES) {
+                    const content = await fs.readFile(full, 'utf8');
+                    if (!content.includes('\0')) {
+                        insertions = content.length === 0
+                            ? 0
+                            : content.split('\n').length - (content.endsWith('\n') ? 1 : 0);
+                        deletions = 0;
+                    }
+                }
+            } catch {
+                // unreadable — leave counts null
+            }
+        }
+        result.push({ path: entry.path, state: entry.state, insertions, deletions });
+    }
+    return result;
+}
+
+export interface FileDiff {
+    oldText: string;
+    newText: string;
+    isBinary: boolean;
+    tooLarge: boolean;
+}
+
+export async function fileDiff(cwd: string, relPath: string): Promise<FileDiff> {
+    let oldText = '';
+    try {
+        oldText = await git(cwd, ['show', `HEAD:${relPath}`]);
+    } catch {
+        // untracked / newly added / no commits — diff against empty
+        oldText = '';
+    }
+    let newText = '';
+    try {
+        const full = path.join(cwd, relPath);
+        const stat = await fs.stat(full);
+        if (stat.size > MAX_TEXT_BYTES) {
+            return { oldText: '', newText: '', isBinary: false, tooLarge: true };
+        }
+        newText = await fs.readFile(full, 'utf8');
+    } catch {
+        // deleted from working tree
+        newText = '';
+    }
+    if (oldText.length > MAX_TEXT_BYTES) {
+        return { oldText: '', newText: '', isBinary: false, tooLarge: true };
+    }
+    if (oldText.includes('\0') || newText.includes('\0')) {
+        return { oldText: '', newText: '', isBinary: true, tooLarge: false };
+    }
+    return { oldText, newText, isBinary: false, tooLarge: false };
+}
+
+export async function worktreeAdd(repoPath: string, worktreePath: string, branch: string): Promise<void> {
+    await fs.mkdir(path.dirname(worktreePath), { recursive: true });
+    await git(repoPath, ['worktree', 'add', '-b', branch, worktreePath, 'HEAD']);
+}
+
+export async function worktreeRemove(
+    repoPath: string,
+    worktreePath: string,
+    opts: { force?: boolean; deleteBranch?: string } = {},
+): Promise<void> {
+    try {
+        const args = ['worktree', 'remove'];
+        if (opts.force) args.push('--force');
+        args.push(worktreePath);
+        await git(repoPath, args);
+    } catch {
+        // The worktree dir may have been deleted by hand — prune the registration.
+        await git(repoPath, ['worktree', 'prune']).catch(() => {});
+    }
+    if (opts.deleteBranch) {
+        await git(repoPath, ['branch', '-D', opts.deleteBranch]).catch(() => {});
+    }
+}
+
+export interface MergeBackResult {
+    ok: boolean;
+    conflict?: boolean;
+    message: string;
+}
+
+// Merge the session branch into whatever the original checkout currently has
+// checked out. Refuses on a dirty checkout; aborts cleanly on conflicts.
+export async function mergeBack(repoPath: string, branch: string): Promise<MergeBackResult> {
+    const info = await repoInfo(repoPath);
+    if (!info.isGitRepo) {
+        return { ok: false, message: 'The project folder is not a git repository.' };
+    }
+    if (info.dirtyCount > 0) {
+        return {
+            ok: false,
+            message: `The repository at ${repoPath} has ${info.dirtyCount} uncommitted change(s). Commit or stash them, then merge again — or merge manually with: git merge ${branch}`,
+        };
+    }
+    try {
+        await git(repoPath, ['merge', '--no-edit', branch]);
+        return { ok: true, message: `Merged ${branch} into ${info.branch ?? 'the current branch'}.` };
+    } catch (e) {
+        await git(repoPath, ['merge', '--abort']).catch(() => {});
+        const detail = e instanceof Error ? e.message : String(e);
+        return {
+            ok: false,
+            conflict: true,
+            message: `Merge of ${branch} hit conflicts and was aborted. Resolve manually with: git merge ${branch}\n\n${detail.slice(0, 600)}`,
+        };
+    }
+}
diff --git a/apps/x/packages/core/src/code-mode/projects/fs.ts b/apps/x/packages/core/src/code-mode/projects/fs.ts
new file mode 100644
index 00000000..07fc2ebb
--- /dev/null
+++ b/apps/x/packages/core/src/code-mode/projects/fs.ts
@@ -0,0 +1,83 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+// Contained file browsing for the Code section. Session cwds are arbitrary
+// user directories (outside the Rowboat workspace), so every access resolves
+// against the session root and is validated to stay inside it — realpath on
+// the containing directory defeats both `..` traversal and symlink escapes.
+
+const MAX_FILE_BYTES = 1024 * 1024;
+
+async function resolveContained(root: string, relPath: string): Promise<string> {
+    if (path.isAbsolute(relPath)) {
+        throw new Error('Absolute paths are not allowed');
+    }
+    const realRoot = await fs.realpath(root);
+    const resolved = path.resolve(realRoot, relPath);
+    // Realpath the parent so symlinked ancestors can't escape...
+    const realParent = await fs.realpath(path.dirname(resolved)).catch(() => null);
+    if (realParent === null) {
+        throw new Error(`No such directory: ${relPath}`);
+    }
+    // ...and the target itself, so the final component being a symlink
+    // (e.g. a link to /etc) can't either. A missing target keeps its own path.
+    const joined = path.join(realParent, path.basename(resolved));
+    const realTarget = await fs.realpath(joined).catch(() => joined);
+    if (realTarget !== realRoot && !realTarget.startsWith(realRoot + path.sep)) {
+        throw new Error('Path escapes the session directory');
+    }
+    return realTarget;
+}
+
+export interface ProjectDirEntry {
+    name: string;
+    kind: 'file' | 'dir';
+    size?: number;
+}
+
+// One level at a time — the tree lazily expands, so node_modules costs nothing
+// until the user opens it. `.git` is always hidden.
+export async function readProjectDir(root: string, relPath: string): Promise<ProjectDirEntry[]> {
+    const target = await resolveContained(root, relPath || '.');
+    const dirents = await fs.readdir(target, { withFileTypes: true });
+    const entries: ProjectDirEntry[] = [];
+    for (const d of dirents) {
+        if (d.name === '.git') continue;
+        if (d.isDirectory()) {
+            entries.push({ name: d.name, kind: 'dir' });
+        } else if (d.isFile()) {
+            let size: number | undefined;
+            try {
+                size = (await fs.stat(path.join(target, d.name))).size;
+            } catch {
+                size = undefined;
+            }
+            entries.push({ name: d.name, kind: 'file', size });
+        }
+        // symlinks and other entry kinds are skipped
+    }
+    entries.sort((a, b) => (a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === 'dir' ? -1 : 1));
+    return entries;
+}
+
+export interface ProjectFileContent {
+    content: string;
+    isBinary: boolean;
+    tooLarge: boolean;
+}
+
+export async function readProjectFile(root: string, relPath: string): Promise<ProjectFileContent> {
+    const target = await resolveContained(root, relPath);
+    const stat = await fs.stat(target);
+    if (!stat.isFile()) {
+        throw new Error(`Not a file: ${relPath}`);
+    }
+    if (stat.size > MAX_FILE_BYTES) {
+        return { content: '', isBinary: false, tooLarge: true };
+    }
+    const buf = await fs.readFile(target);
+    if (buf.includes(0)) {
+        return { content: '', isBinary: true, tooLarge: false };
+    }
+    return { content: buf.toString('utf8'), isBinary: false, tooLarge: false };
+}
diff --git a/apps/x/packages/core/src/code-mode/projects/repo.ts b/apps/x/packages/core/src/code-mode/projects/repo.ts
new file mode 100644
index 00000000..73a8ef1b
--- /dev/null
+++ b/apps/x/packages/core/src/code-mode/projects/repo.ts
@@ -0,0 +1,69 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { WorkDir } from '../../config/config.js';
+import z from 'zod';
+import { CodeProject } from '@x/shared/dist/code-sessions.js';
+
+const ProjectsFile = z.object({
+    projects: z.array(CodeProject),
+});
+
+export interface ICodeProjectsRepo {
+    list(): Promise<CodeProject[]>;
+    get(projectId: string): Promise<CodeProject | null>;
+    add(dirPath: string): Promise<CodeProject>;
+    remove(projectId: string): Promise<void>;
+}
+
+// Registered project directories for the Code section. One small JSON file —
+// same pattern as the other config repos.
+export class FSCodeProjectsRepo implements ICodeProjectsRepo {
+    private readonly configPath = path.join(WorkDir, 'config', 'code-projects.json');
+
+    private async read(): Promise<CodeProject[]> {
+        try {
+            const raw = await fs.readFile(this.configPath, 'utf8');
+            return ProjectsFile.parse(JSON.parse(raw)).projects;
+        } catch {
+            return [];
+        }
+    }
+
+    private async write(projects: CodeProject[]): Promise<void> {
+        await fs.mkdir(path.dirname(this.configPath), { recursive: true });
+        await fs.writeFile(this.configPath, JSON.stringify({ projects }, null, 2));
+    }
+
+    async list(): Promise<CodeProject[]> {
+        return this.read();
+    }
+
+    async get(projectId: string): Promise<CodeProject | null> {
+        const projects = await this.read();
+        return projects.find((p) => p.id === projectId) ?? null;
+    }
+
+    async add(dirPath: string): Promise<CodeProject> {
+        const resolved = path.resolve(dirPath);
+        const stat = await fs.stat(resolved);
+        if (!stat.isDirectory()) {
+            throw new Error(`Not a directory: ${resolved}`);
+        }
+        const projects = await this.read();
+        const existing = projects.find((p) => p.path === resolved);
+        if (existing) return existing;
+        const project: CodeProject = {
+            id: `proj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+            path: resolved,
+            name: path.basename(resolved),
+            addedAt: new Date().toISOString(),
+        };
+        await this.write([...projects, project]);
+        return project;
+    }
+
+    async remove(projectId: string): Promise<void> {
+        const projects = await this.read();
+        await this.write(projects.filter((p) => p.id !== projectId));
+    }
+}
diff --git a/apps/x/packages/core/src/code-mode/sessions/repo.ts b/apps/x/packages/core/src/code-mode/sessions/repo.ts
new file mode 100644
index 00000000..49eaede7
--- /dev/null
+++ b/apps/x/packages/core/src/code-mode/sessions/repo.ts
@@ -0,0 +1,63 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { WorkDir } from '../../config/config.js';
+import { CodeSession } from '@x/shared/dist/code-sessions.js';
+
+// Mutable metadata for Code-section sessions, one JSON file per session
+// (keyed by the session/run id). The immutable conversation itself lives in
+// the run JSONL; the ACP resume state lives in code-mode/sessions/.
+const META_DIR = path.join(WorkDir, 'code-mode', 'sessions-meta');
+
+function metaFile(sessionId: string): string {
+    return path.join(META_DIR, `${sessionId}.json`);
+}
+
+export interface ICodeSessionsRepo {
+    list(): Promise<CodeSession[]>;
+    get(sessionId: string): Promise<CodeSession | null>;
+    save(session: CodeSession): Promise<void>;
+    remove(sessionId: string): Promise<void>;
+}
+
+export class FSCodeSessionsRepo implements ICodeSessionsRepo {
+    async list(): Promise<CodeSession[]> {
+        let names: string[] = [];
+        try {
+            names = (await fs.readdir(META_DIR)).filter((n) => n.endsWith('.json'));
+        } catch {
+            return [];
+        }
+        const sessions: CodeSession[] = [];
+        for (const name of names) {
+            try {
+                const raw = await fs.readFile(path.join(META_DIR, name), 'utf8');
+                sessions.push(CodeSession.parse(JSON.parse(raw)));
+            } catch {
+                // skip malformed files
+            }
+        }
+        // Newest activity first; session ids are time-sortable as a tiebreaker.
+        sessions.sort((a, b) =>
+            (b.lastActivityAt ?? b.createdAt).localeCompare(a.lastActivityAt ?? a.createdAt));
+        return sessions;
+    }
+
+    async get(sessionId: string): Promise<CodeSession | null> {
+        try {
+            const raw = await fs.readFile(metaFile(sessionId), 'utf8');
+            return CodeSession.parse(JSON.parse(raw));
+        } catch {
+            return null;
+        }
+    }
+
+    async save(session: CodeSession): Promise<void> {
+        const validated = CodeSession.parse(session);
+        await fs.mkdir(META_DIR, { recursive: true });
+        await fs.writeFile(metaFile(validated.id), JSON.stringify(validated, null, 2));
+    }
+
+    async remove(sessionId: string): Promise<void> {
+        await fs.rm(metaFile(sessionId), { force: true }).catch(() => {});
+    }
+}
diff --git a/apps/x/packages/core/src/code-mode/sessions/service.ts b/apps/x/packages/core/src/code-mode/sessions/service.ts
new file mode 100644
index 00000000..f087c169
--- /dev/null
+++ b/apps/x/packages/core/src/code-mode/sessions/service.ts
@@ -0,0 +1,335 @@
+import path from 'path';
+import z from 'zod';
+import { WorkDir } from '../../config/config.js';
+import type { CodeSession, CodeSessionMode } from '@x/shared/dist/code-sessions.js';
+import type { CodingAgent, ApprovalPolicy } from '@x/shared/dist/code-mode.js';
+import { RunEvent, MessageEvent } from '@x/shared/dist/runs.js';
+import type { IRunsRepo } from '../../runs/repo.js';
+import type { IRunsLock } from '../../runs/lock.js';
+import type { IBus } from '../../application/lib/bus.js';
+import type { IMonotonicallyIncreasingIdGenerator } from '../../application/lib/id-gen.js';
+import type { IAbortRegistry } from '../../runs/abort-registry.js';
+import type { CodeModeManager } from '../acp/manager.js';
+import type { CodePermissionRegistry } from '../acp/permission-registry.js';
+import type { ICodeSessionsRepo } from './repo.js';
+import type { ICodeProjectsRepo } from '../projects/repo.js';
+import { clearStoredSession } from '../acp/session-store.js';
+import * as gitService from '../git/service.js';
+
+export interface CreateSessionArgs {
+    projectId: string;
+    title?: string;
+    agent: CodingAgent;
+    mode: CodeSessionMode;
+    policy: ApprovalPolicy;
+    isolation: 'in-repo' | 'worktree';
+}
+
+export interface SendMessageResult {
+    accepted: boolean;
+    error?: string;
+}
+
+function worktreeRoot(projectId: string, sessionId: string): string {
+    return path.join(WorkDir, 'code-mode', 'worktrees', projectId, sessionId);
+}
+
+// Drives Code-section sessions. A session is a run (same id) whose JSONL holds
+// both modes' history: Rowboat turns are written by the agent runtime; direct
+// turns are written here. The direct path talks straight to the ACP engine —
+// no copilot LLM in between — but mirrors the runtime's lifecycle contract
+// (runs lock, abort registry, processing-start/end, run-stopped) so the rest
+// of the app (stop IPC, status tracking, event forwarding) needs no special
+// casing.
+export class CodeSessionService {
+    private readonly runsRepo: IRunsRepo;
+    private readonly runsLock: IRunsLock;
+    private readonly bus: IBus;
+    private readonly idGenerator: IMonotonicallyIncreasingIdGenerator;
+    private readonly abortRegistry: IAbortRegistry;
+    private readonly codeModeManager: CodeModeManager;
+    private readonly codePermissionRegistry: CodePermissionRegistry;
+    private readonly codeSessionsRepo: ICodeSessionsRepo;
+    private readonly codeProjectsRepo: ICodeProjectsRepo;
+    // Session ids with a direct prompt currently streaming (the runs lock also
+    // guards this, but we keep our own set to give a precise "busy" error).
+    private readonly inflight = new Set<string>();
+
+    constructor({
+        runsRepo,
+        runsLock,
+        bus,
+        idGenerator,
+        abortRegistry,
+        codeModeManager,
+        codePermissionRegistry,
+        codeSessionsRepo,
+        codeProjectsRepo,
+    }: {
+        runsRepo: IRunsRepo;
+        runsLock: IRunsLock;
+        bus: IBus;
+        idGenerator: IMonotonicallyIncreasingIdGenerator;
+        abortRegistry: IAbortRegistry;
+        codeModeManager: CodeModeManager;
+        codePermissionRegistry: CodePermissionRegistry;
+        codeSessionsRepo: ICodeSessionsRepo;
+        codeProjectsRepo: ICodeProjectsRepo;
+    }) {
+        this.runsRepo = runsRepo;
+        this.runsLock = runsLock;
+        this.bus = bus;
+        this.idGenerator = idGenerator;
+        this.abortRegistry = abortRegistry;
+        this.codeModeManager = codeModeManager;
+        this.codePermissionRegistry = codePermissionRegistry;
+        this.codeSessionsRepo = codeSessionsRepo;
+        this.codeProjectsRepo = codeProjectsRepo;
+    }
+
+    async create(args: CreateSessionArgs): Promise<CodeSession> {
+        const project = await this.codeProjectsRepo.get(args.projectId);
+        if (!project) throw new Error(`Unknown project: ${args.projectId}`);
+
+        // The session is a real run so Rowboat mode (agent runtime) works on it
+        // directly and the existing runs plumbing (fetch/events/stop) applies.
+        const { createRun } = await import('../../runs/runs.js');
+        const run = await createRun({ agentId: 'copilot', useCase: 'code_session' });
+        const sessionId = run.id;
+
+        let cwd = project.path;
+        let worktree: CodeSession['worktree'];
+        if (args.isolation === 'worktree') {
+            const info = await gitService.repoInfo(project.path);
+            if (!info.isGitRepo || !info.hasCommits) {
+                throw new Error('Worktree isolation needs a git repository with at least one commit.');
+            }
+            const branch = `rowboat/${sessionId}`;
+            const wtPath = worktreeRoot(project.id, sessionId);
+            await gitService.worktreeAdd(project.path, wtPath, branch);
+            worktree = { path: wtPath, branch, baseBranch: info.branch };
+            cwd = wtPath;
+        }
+
+        const session: CodeSession = {
+            id: sessionId,
+            projectId: project.id,
+            title: args.title?.trim() || `${project.name} session`,
+            agent: args.agent,
+            mode: args.mode,
+            policy: args.policy,
+            cwd,
+            ...(worktree ? { worktree } : {}),
+            createdAt: new Date().toISOString(),
+        };
+        await this.codeSessionsRepo.save(session);
+        return session;
+    }
+
+    async update(sessionId: string, patch: Partial<Pick<CodeSession, 'title' | 'mode' | 'policy' | 'agent'>>): Promise<CodeSession> {
+        const session = await this.codeSessionsRepo.get(sessionId);
+        if (!session) throw new Error(`Unknown session: ${sessionId}`);
+        const updated: CodeSession = { ...session, ...patch };
+        await this.codeSessionsRepo.save(updated);
+        return updated;
+    }
+
+    isBusy(sessionId: string): boolean {
+        return this.inflight.has(sessionId);
+    }
+
+    // Direct drive: send the user's text straight to the session's ACP agent.
+    // Returns once the turn fully settles (the renderer streams via runs:events).
+    async sendMessage(sessionId: string, text: string): Promise<SendMessageResult> {
+        const session = await this.codeSessionsRepo.get(sessionId);
+        if (!session) return { accepted: false, error: `Unknown session: ${sessionId}` };
+        if (this.inflight.has(sessionId)) {
+            return { accepted: false, error: 'The agent is still working on the previous message.' };
+        }
+        // The runs lock is shared with the agent runtime, so a Rowboat-mode turn
+        // in flight blocks direct sends (and vice versa) — the run JSONL never
+        // interleaves two writers.
+        if (!await this.runsLock.lock(sessionId)) {
+            return { accepted: false, error: 'The session is busy with a Rowboat-driven turn.' };
+        }
+        this.inflight.add(sessionId);
+        const signal = this.abortRegistry.createForRun(sessionId);
+        const turnId = await this.idGenerator.next();
+        const toolCallId = `direct-${turnId}`;
+
+        const appendAndPublish = async (event: z.infer<typeof RunEvent>) => {
+            await this.runsRepo.appendEvents(sessionId, [event]);
+            await this.bus.publish(event);
+        };
+
+        try {
+            await this.bus.publish({ runId: sessionId, type: 'run-processing-start', subflow: [] });
+
+            const userEvent: z.infer<typeof MessageEvent> = {
+                runId: sessionId,
+                type: 'message',
+                messageId: await this.idGenerator.next(),
+                message: { role: 'user', content: text },
+                subflow: [],
+                ts: new Date().toISOString(),
+            };
+            await appendAndPublish(userEvent);
+            await this.touch(session);
+
+            // Stream events live; persist the structural ones (tool calls, plan,
+            // resolved permissions). Streaming `message` chunks are NOT persisted —
+            // the agent's full text lands as one assistant MessageEvent below, which
+            // is also what lets a later Rowboat-mode turn see this conversation.
+            let finalText = '';
+            const persistQueue: Array<z.infer<typeof RunEvent>> = [];
+            const onAbort = () => this.codePermissionRegistry.cancelRun(sessionId);
+            if (signal.aborted) onAbort();
+            else signal.addEventListener('abort', onAbort, { once: true });
+
+            let stopReason = 'cancelled';
+            try {
+                const result = await this.codeModeManager.runPrompt({
+                    runId: sessionId,
+                    agent: session.agent,
+                    cwd: session.cwd,
+                    prompt: text,
+                    policy: session.policy,
+                    signal,
+                    suppressReplay: true,
+                    onEvent: (event) => {
+                        if (event.type === 'message' && event.role === 'agent') finalText += event.text;
+                        const streamEvent: z.infer<typeof RunEvent> = {
+                            runId: sessionId,
+                            type: 'code-run-event',
+                            toolCallId,
+                            event,
+                            subflow: [],
+                        };
+                        void this.bus.publish(streamEvent);
+                        if (event.type === 'tool_call' || event.type === 'tool_call_update'
+                            || event.type === 'plan' || event.type === 'permission') {
+                            persistQueue.push({ ...streamEvent, ts: new Date().toISOString() });
+                        }
+                    },
+                    ask: (permAsk) => this.codePermissionRegistry.request(sessionId, (requestId) => {
+                        void this.bus.publish({
+                            runId: sessionId,
+                            type: 'code-run-permission-request',
+                            toolCallId,
+                            requestId,
+                            ask: permAsk,
+                            subflow: [],
+                        });
+                    }),
+                });
+                stopReason = result.stopReason;
+            } catch (error) {
+                if (!signal.aborted) {
+                    const message = error instanceof Error ? (error.message || error.name) : String(error);
+                    await appendAndPublish({ runId: sessionId, type: 'error', error: message, subflow: [] });
+                }
+            } finally {
+                signal.removeEventListener('abort', onAbort);
+            }
+
+            if (persistQueue.length > 0) {
+                await this.runsRepo.appendEvents(sessionId, persistQueue);
+            }
+            if (finalText.trim()) {
+                await appendAndPublish({
+                    runId: sessionId,
+                    type: 'message',
+                    messageId: await this.idGenerator.next(),
+                    message: { role: 'assistant', content: finalText },
+                    subflow: [],
+                    ts: new Date().toISOString(),
+                });
+            }
+            if (signal.aborted || stopReason === 'cancelled') {
+                await appendAndPublish({
+                    runId: sessionId,
+                    type: 'run-stopped',
+                    reason: 'user-requested',
+                    subflow: [],
+                });
+            }
+            await this.touch(session);
+            return { accepted: true };
+        } finally {
+            this.inflight.delete(sessionId);
+            this.abortRegistry.cleanup(sessionId);
+            await this.runsLock.release(sessionId);
+            await this.bus.publish({ runId: sessionId, type: 'run-processing-end', subflow: [] });
+        }
+    }
+
+    // Unblocks a stuck permission card immediately; the manager's signal handling
+    // (ACP cancel -> grace -> force-kill) actually unwinds the prompt.
+    async stop(sessionId: string): Promise<void> {
+        this.abortRegistry.abort(sessionId);
+        this.codePermissionRegistry.cancelRun(sessionId);
+    }
+
+    async mergeBack(sessionId: string): Promise<gitService.MergeBackResult> {
+        const session = await this.codeSessionsRepo.get(sessionId);
+        if (!session?.worktree) {
+            return { ok: false, message: 'This session has no isolated worktree to merge.' };
+        }
+        const project = await this.codeProjectsRepo.get(session.projectId);
+        if (!project) {
+            return { ok: false, message: 'The session\'s project is no longer registered.' };
+        }
+        const result = await gitService.mergeBack(project.path, session.worktree.branch);
+        if (result.ok) {
+            await this.codeSessionsRepo.save({
+                ...session,
+                worktree: { ...session.worktree, mergedAt: new Date().toISOString() },
+            });
+        }
+        return result;
+    }
+
+    async cleanupWorktree(sessionId: string, deleteBranch: boolean): Promise<void> {
+        const session = await this.codeSessionsRepo.get(sessionId);
+        if (!session?.worktree || session.worktree.removedAt) return;
+        const project = await this.codeProjectsRepo.get(session.projectId);
+        // Drop any live agent connection on the worktree before deleting it.
+        this.codeModeManager.dispose(sessionId);
+        if (project) {
+            await gitService.worktreeRemove(project.path, session.worktree.path, {
+                force: true,
+                ...(deleteBranch ? { deleteBranch: session.worktree.branch } : {}),
+            });
+        }
+        await this.codeSessionsRepo.save({
+            ...session,
+            // The worktree is gone — fall back to working directly in the repo.
+            cwd: project?.path ?? session.cwd,
+            worktree: { ...session.worktree, removedAt: new Date().toISOString() },
+        });
+    }
+
+    async delete(sessionId: string, opts: { removeWorktree?: boolean; deleteBranch?: boolean } = {}): Promise<void> {
+        await this.stop(sessionId);
+        this.codeModeManager.dispose(sessionId);
+        const session = await this.codeSessionsRepo.get(sessionId);
+        if (opts.removeWorktree && session?.worktree && !session.worktree.removedAt) {
+            const project = await this.codeProjectsRepo.get(session.projectId);
+            if (project) {
+                await gitService.worktreeRemove(project.path, session.worktree.path, {
+                    force: true,
+                    ...(opts.deleteBranch ? { deleteBranch: session.worktree.branch } : {}),
+                });
+            }
+        }
+        await clearStoredSession(sessionId);
+        await this.codeSessionsRepo.remove(sessionId);
+        await this.runsRepo.delete(sessionId).catch(() => {});
+    }
+
+    private async touch(session: CodeSession): Promise<void> {
+        const current = await this.codeSessionsRepo.get(session.id);
+        if (!current) return;
+        await this.codeSessionsRepo.save({ ...current, lastActivityAt: new Date().toISOString() });
+    }
+}
diff --git a/apps/x/packages/core/src/code-mode/sessions/status-tracker.ts b/apps/x/packages/core/src/code-mode/sessions/status-tracker.ts
new file mode 100644
index 00000000..92abdf80
--- /dev/null
+++ b/apps/x/packages/core/src/code-mode/sessions/status-tracker.ts
@@ -0,0 +1,136 @@
+import z from 'zod';
+import { RunEvent } from '@x/shared/dist/runs.js';
+import type { IBus } from '../../application/lib/bus.js';
+import type { ICodeSessionsRepo } from './repo.js';
+import type { INotificationService } from '../../application/notification/service.js';
+import type { CodeSessionStatus, CodeSession } from '@x/shared/dist/code-sessions.js';
+import container from '../../di/container.js';
+
+export type StatusListener = (sessionId: string, status: CodeSessionStatus) => void;
+
+// Authoritative live status for Code-section sessions, derived in the main
+// process from the run event stream. Works for both modes uniformly because
+// direct turns and Rowboat-mode code_agent_run turns publish the same event
+// types on the bus. The renderer just renders what this pushes.
+export class CodeSessionStatusTracker {
+    private readonly bus: IBus;
+    private readonly codeSessionsRepo: ICodeSessionsRepo;
+    private readonly statuses = new Map<string, CodeSessionStatus>();
+    private readonly busySince = new Map<string, number>();
+    private readonly listeners = new Set<StatusListener>();
+    private unsubscribe: (() => void) | null = null;
+    // Session ids known to be code sessions; refreshed lazily on unknown ids so
+    // sessions created after start() are picked up without explicit wiring.
+    private knownSessions = new Set<string>();
+    // Ids confirmed NOT to be sessions (regular chat runs). Safe to cache
+    // permanently: a session's meta file is written before its first turn, so
+    // an id that misses the refresh can never become a session later.
+    private readonly knownNonSessions = new Set<string>();
+
+    constructor({ bus, codeSessionsRepo }: { bus: IBus; codeSessionsRepo: ICodeSessionsRepo }) {
+        this.bus = bus;
+        this.codeSessionsRepo = codeSessionsRepo;
+    }
+
+    async start(): Promise<void> {
+        if (this.unsubscribe) return;
+        await this.refreshKnownSessions();
+        this.unsubscribe = await this.bus.subscribe('*', async (event) => {
+            await this.handle(event);
+        });
+    }
+
+    stop(): void {
+        this.unsubscribe?.();
+        this.unsubscribe = null;
+    }
+
+    onTransition(listener: StatusListener): () => void {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+
+    getStatuses(): Record<string, CodeSessionStatus> {
+        return Object.fromEntries(this.statuses);
+    }
+
+    private async refreshKnownSessions(): Promise<void> {
+        const sessions = await this.codeSessionsRepo.list().catch(() => [] as CodeSession[]);
+        this.knownSessions = new Set(sessions.map((s) => s.id));
+    }
+
+    private async isCodeSession(runId: string): Promise<boolean> {
+        if (this.knownSessions.has(runId)) return true;
+        if (this.knownNonSessions.has(runId)) return false;
+        // Unknown id — maybe a session created since the last refresh.
+        await this.refreshKnownSessions();
+        if (this.knownSessions.has(runId)) return true;
+        this.knownNonSessions.add(runId);
+        return false;
+    }
+
+    private async handle(event: z.infer<typeof RunEvent>): Promise<void> {
+        const relevant = event.type === 'run-processing-start'
+            || event.type === 'run-processing-end'
+            || event.type === 'run-stopped'
+            || event.type === 'error'
+            || event.type === 'code-run-permission-request'
+            || (event.type === 'code-run-event' && event.event.type === 'permission');
+        if (!relevant) return;
+        if (!await this.isCodeSession(event.runId)) return;
+
+        const previous = this.statuses.get(event.runId) ?? 'idle';
+        let next: CodeSessionStatus = previous;
+        switch (event.type) {
+            case 'run-processing-start':
+                next = 'working';
+                break;
+            case 'code-run-permission-request':
+                next = 'needs-you';
+                break;
+            case 'code-run-event':
+                // A permission resolution while the turn is still running.
+                if (previous === 'needs-you') next = 'working';
+                break;
+            case 'run-processing-end':
+            case 'run-stopped':
+            case 'error':
+                next = 'idle';
+                break;
+        }
+        if (next === previous) return;
+        if (previous === 'idle' && next !== 'idle') this.busySince.set(event.runId, Date.now());
+        this.statuses.set(event.runId, next);
+        for (const listener of this.listeners) listener(event.runId, next);
+        await this.notify(event.runId, previous, next);
+        if (next === 'idle') this.busySince.delete(event.runId);
+    }
+
+    private async notify(sessionId: string, previous: CodeSessionStatus, next: CodeSessionStatus): Promise<void> {
+        let notificationService: INotificationService;
+        try {
+            notificationService = container.resolve<INotificationService>('notificationService');
+        } catch {
+            return; // not registered (e.g. tests)
+        }
+        if (!notificationService.isSupported()) return;
+        const session = await this.codeSessionsRepo.get(sessionId);
+        const title = session?.title ?? 'Coding session';
+        if (next === 'needs-you') {
+            notificationService.notify({
+                title,
+                message: 'The coding agent needs your approval.',
+            });
+        } else if (next === 'idle' && previous === 'working') {
+            // Only worth interrupting for if the agent worked long enough that
+            // the user has plausibly moved on to something else.
+            const since = this.busySince.get(sessionId);
+            if (since !== undefined && Date.now() - since > 30_000) {
+                notificationService.notify({
+                    title,
+                    message: 'The coding agent finished its turn.',
+                });
+            }
+        }
+    }
+}
diff --git a/apps/x/packages/core/src/di/container.ts b/apps/x/packages/core/src/di/container.ts
index d7b17ce7..4bfc92ed 100644
--- a/apps/x/packages/core/src/di/container.ts
+++ b/apps/x/packages/core/src/di/container.ts
@@ -18,6 +18,10 @@ import { FSAgentScheduleStateRepo, IAgentScheduleStateRepo } from "../agent-sche
 import { FSSlackConfigRepo, ISlackConfigRepo } from "../slack/repo.js";
 import { CodeModeManager } from "../code-mode/acp/manager.js";
 import { CodePermissionRegistry } from "../code-mode/acp/permission-registry.js";
+import { FSCodeProjectsRepo, ICodeProjectsRepo } from "../code-mode/projects/repo.js";
+import { FSCodeSessionsRepo, ICodeSessionsRepo } from "../code-mode/sessions/repo.js";
+import { CodeSessionService } from "../code-mode/sessions/service.js";
+import { CodeSessionStatusTracker } from "../code-mode/sessions/status-tracker.js";
 import type { IBrowserControlService } from "../application/browser-control/service.js";
 import type { INotificationService } from "../application/notification/service.js";
 
@@ -51,6 +55,13 @@ container.register({
     // session/load); the registry brokers mid-run approvals.
     codeModeManager: asClass(CodeModeManager).singleton(),
     codePermissionRegistry: asClass(CodePermissionRegistry).singleton(),
+
+    // Code section: project registry, session metadata, the direct-drive
+    // session service, and the live status tracker.
+    codeProjectsRepo: asClass<ICodeProjectsRepo>(FSCodeProjectsRepo).singleton(),
+    codeSessionsRepo: asClass<ICodeSessionsRepo>(FSCodeSessionsRepo).singleton(),
+    codeSessionService: asClass(CodeSessionService).singleton(),
+    codeSessionStatusTracker: asClass(CodeSessionStatusTracker).singleton(),
 });
 
 export default container;
diff --git a/apps/x/packages/core/src/runs/repo.ts b/apps/x/packages/core/src/runs/repo.ts
index 8a1d3e85..19dccfda 100644
--- a/apps/x/packages/core/src/runs/repo.ts
+++ b/apps/x/packages/core/src/runs/repo.ts
@@ -307,6 +307,7 @@ export class FSRunsRepo implements IRunsRepo {
                 title: metadata.title,
                 createdAt: metadata.start.ts!,
                 agentId: metadata.start.agentName,
+                ...(metadata.start.useCase ? { useCase: metadata.start.useCase } : {}),
             });
         }
 
diff --git a/apps/x/packages/core/src/runs/runs.ts b/apps/x/packages/core/src/runs/runs.ts
index f832c00d..eeae02a4 100644
--- a/apps/x/packages/core/src/runs/runs.ts
+++ b/apps/x/packages/core/src/runs/runs.ts
@@ -40,9 +40,9 @@ export async function createRun(opts: z.infer<typeof CreateRunOptions>): Promise
     return run;
 }
 
-export async function createMessage(runId: string, message: UserMessageContentType, voiceInput?: boolean, voiceOutput?: VoiceOutputMode, searchEnabled?: boolean, middlePaneContext?: MiddlePaneContext, codeMode?: 'claude' | 'codex'): Promise<string> {
+export async function createMessage(runId: string, message: UserMessageContentType, voiceInput?: boolean, voiceOutput?: VoiceOutputMode, searchEnabled?: boolean, middlePaneContext?: MiddlePaneContext, codeMode?: 'claude' | 'codex', codeCwd?: string, codePolicy?: 'ask' | 'auto-approve-reads' | 'yolo'): Promise<string> {
     const queue = container.resolve<IMessageQueue>('messageQueue');
-    const id = await queue.enqueue(runId, message, voiceInput, voiceOutput, searchEnabled, middlePaneContext, codeMode);
+    const id = await queue.enqueue(runId, message, voiceInput, voiceOutput, searchEnabled, middlePaneContext, codeMode, codeCwd, codePolicy);
     const runtime = container.resolve<IAgentRuntime>('agentRuntime');
     runtime.trigger(runId);
     return id;
diff --git a/apps/x/packages/core/src/workspace/watcher.ts b/apps/x/packages/core/src/workspace/watcher.ts
index 3460f014..0b3e983b 100644
--- a/apps/x/packages/core/src/workspace/watcher.ts
+++ b/apps/x/packages/core/src/workspace/watcher.ts
@@ -1,5 +1,6 @@
 import chokidar, { type FSWatcher } from 'chokidar';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import { ensureWorkspaceRoot, absToRelPosix } from './workspace.js';
 import { WorkDir } from '../config/config.js';
 import { WorkspaceChangeEvent } from 'packages/shared/dist/workspace.js';
@@ -21,8 +22,15 @@ export async function createWorkspaceWatcher(
 ): Promise<FSWatcher> {
   await ensureWorkspaceRoot();
 
+  // Code-section session worktrees are full repo checkouts (thousands of files,
+  // possibly node_modules) living under WorkDir — watching them would flood the
+  // event stream and burn file handles, and nothing in the app renders them
+  // from workspace events.
+  const codeModeDir = path.join(WorkDir, 'code-mode');
   const watcher = chokidar.watch(WorkDir, {
     ignoreInitial: true,
+    ignored: (watchedPath: string) =>
+      watchedPath === codeModeDir || watchedPath.startsWith(codeModeDir + path.sep),
     awaitWriteFinish: {
       stabilityThreshold: 150,
       pollInterval: 50,
diff --git a/apps/x/packages/shared/src/code-sessions.ts b/apps/x/packages/shared/src/code-sessions.ts
new file mode 100644
index 00000000..2ec8a027
--- /dev/null
+++ b/apps/x/packages/shared/src/code-sessions.ts
@@ -0,0 +1,71 @@
+import z from "zod";
+import { CodingAgent, ApprovalPolicy } from "./code-mode.js";
+
+// Shared zod schemas for the Code section: registered projects and coding
+// sessions. A coding session is backed by a run (session id == run id); the
+// mutable metadata below lives in its own per-session file.
+
+export const CodeProject = z.object({
+    id: z.string(),
+    path: z.string(),
+    name: z.string(),
+    addedAt: z.iso.datetime(),
+});
+export type CodeProject = z.infer<typeof CodeProject>;
+
+// Git facts about a project path, used to gate worktree creation in the UI.
+export const GitRepoInfo = z.object({
+    isGitRepo: z.boolean(),
+    branch: z.string().nullable(),
+    hasCommits: z.boolean(),
+    dirtyCount: z.number(),
+});
+export type GitRepoInfo = z.infer<typeof GitRepoInfo>;
+
+// 'direct': the user's messages go straight to the ACP coding agent.
+// 'rowboat': Rowboat's copilot LLM orchestrates the agent via code_agent_run.
+export const CodeSessionMode = z.enum(["direct", "rowboat"]);
+export type CodeSessionMode = z.infer<typeof CodeSessionMode>;
+
+// Derived live in the main process from the run event stream; not persisted.
+export const CodeSessionStatus = z.enum(["working", "needs-you", "idle"]);
+export type CodeSessionStatus = z.infer<typeof CodeSessionStatus>;
+
+export const CodeWorktree = z.object({
+    path: z.string(),
+    branch: z.string(),
+    // Branch the original checkout was on when the worktree was created;
+    // merge-back targets whatever the checkout is on at merge time, this is
+    // informational.
+    baseBranch: z.string().nullable(),
+    mergedAt: z.iso.datetime().optional(),
+    removedAt: z.iso.datetime().optional(),
+});
+export type CodeWorktree = z.infer<typeof CodeWorktree>;
+
+export const CodeSession = z.object({
+    id: z.string(), // == runId
+    projectId: z.string(),
+    title: z.string(),
+    agent: CodingAgent,
+    mode: CodeSessionMode,
+    policy: ApprovalPolicy,
+    // Where the agent works: the project path, or the worktree path.
+    cwd: z.string(),
+    worktree: CodeWorktree.optional(),
+    createdAt: z.iso.datetime(),
+    lastActivityAt: z.iso.datetime().optional(),
+});
+export type CodeSession = z.infer<typeof CodeSession>;
+
+export const GitFileState = z.enum(["modified", "added", "deleted", "untracked", "renamed"]);
+export type GitFileState = z.infer<typeof GitFileState>;
+
+export const GitStatusFile = z.object({
+    path: z.string(),
+    state: GitFileState,
+    // Null when git can't compute line counts (binary files).
+    insertions: z.number().nullable(),
+    deletions: z.number().nullable(),
+});
+export type GitStatusFile = z.infer<typeof GitStatusFile>;
diff --git a/apps/x/packages/shared/src/index.ts b/apps/x/packages/shared/src/index.ts
index 02f980a2..3b47a563 100644
--- a/apps/x/packages/shared/src/index.ts
+++ b/apps/x/packages/shared/src/index.ts
@@ -17,4 +17,5 @@ export * as frontmatter from './frontmatter.js';
 export * as bases from './bases.js';
 export * as browserControl from './browser-control.js';
 export * as billing from './billing.js';
+export * as codeSessions from './code-sessions.js';
 export { PrefixLogger };
diff --git a/apps/x/packages/shared/src/ipc.ts b/apps/x/packages/shared/src/ipc.ts
index f3acffa1..1b0bf39f 100644
--- a/apps/x/packages/shared/src/ipc.ts
+++ b/apps/x/packages/shared/src/ipc.ts
@@ -19,7 +19,8 @@ import { ZListToolkitsResponse } from './composio.js';
 import { BrowserStateSchema } from './browser-control.js';
 import { BillingInfoSchema } from './billing.js';
 import { EmailBlockSchema, GmailThreadSchema } from './blocks.js';
-import { PermissionDecision, ApprovalPolicy } from './code-mode.js';
+import { PermissionDecision, ApprovalPolicy, CodingAgent } from './code-mode.js';
+import { CodeProject, CodeSession, CodeSessionMode, CodeSessionStatus, GitRepoInfo, GitStatusFile } from './code-sessions.js';
 
 // ============================================================================
 // Runtime Validation Schemas (Single Source of Truth)
@@ -231,6 +232,10 @@ const ipcSchemas = {
       voiceOutput: z.enum(['summary', 'full']).optional(),
       searchEnabled: z.boolean().optional(),
       codeMode: z.enum(['claude', 'codex']).optional(),
+      // Code-section sessions pin the coding agent's working directory and
+      // approval policy for the whole turn (see code_agent_run overrides).
+      codeCwd: z.string().optional(),
+      codePolicy: ApprovalPolicy.optional(),
       middlePaneContext: z.discriminatedUnion('kind', [
         z.object({
           kind: z.literal('note'),
@@ -460,6 +465,169 @@ const ipcSchemas = {
       codex: z.object({ installed: z.boolean(), signedIn: z.boolean() }),
     }),
   },
+  // ==========================================================================
+  // Code section: project registry + coding sessions
+  // ==========================================================================
+  'codeProject:add': {
+    req: z.object({
+      path: z.string(),
+    }),
+    res: z.object({
+      project: CodeProject,
+      git: GitRepoInfo,
+    }),
+  },
+  'codeProject:remove': {
+    req: z.object({
+      projectId: z.string(),
+    }),
+    res: z.object({
+      success: z.literal(true),
+    }),
+  },
+  'codeProject:list': {
+    req: z.null(),
+    res: z.object({
+      projects: z.array(z.object({
+        project: CodeProject,
+        git: GitRepoInfo,
+      })),
+    }),
+  },
+  'codeSession:create': {
+    req: z.object({
+      projectId: z.string(),
+      title: z.string().optional(),
+      agent: CodingAgent,
+      mode: CodeSessionMode,
+      policy: ApprovalPolicy,
+      isolation: z.enum(['in-repo', 'worktree']),
+    }),
+    res: z.object({
+      session: CodeSession,
+    }),
+  },
+  'codeSession:list': {
+    req: z.null(),
+    res: z.object({
+      sessions: z.array(CodeSession),
+      statuses: z.record(z.string(), CodeSessionStatus),
+    }),
+  },
+  'codeSession:update': {
+    req: z.object({
+      sessionId: z.string(),
+      patch: CodeSession.pick({ title: true, mode: true, policy: true, agent: true }).partial(),
+    }),
+    res: z.object({
+      session: CodeSession,
+    }),
+  },
+  'codeSession:delete': {
+    req: z.object({
+      sessionId: z.string(),
+      removeWorktree: z.boolean().optional(),
+      deleteBranch: z.boolean().optional(),
+    }),
+    res: z.object({
+      success: z.literal(true),
+    }),
+  },
+  // Direct-drive: send the user's message straight to the session's ACP agent
+  // (no copilot LLM in between). Streams back over `runs:events`.
+  'codeSession:sendMessage': {
+    req: z.object({
+      sessionId: z.string(),
+      text: z.string().min(1),
+    }),
+    res: z.object({
+      accepted: z.boolean(),
+      error: z.string().optional(),
+    }),
+  },
+  'codeSession:stop': {
+    req: z.object({
+      sessionId: z.string(),
+    }),
+    res: z.object({
+      success: z.literal(true),
+    }),
+  },
+  'codeSession:gitStatus': {
+    req: z.object({
+      sessionId: z.string(),
+    }),
+    res: z.object({
+      isRepo: z.boolean(),
+      branch: z.string().nullable(),
+      hasCommits: z.boolean(),
+      files: z.array(GitStatusFile),
+    }),
+  },
+  'codeSession:fileDiff': {
+    req: z.object({
+      sessionId: z.string(),
+      path: z.string(),
+    }),
+    res: z.object({
+      oldText: z.string(),
+      newText: z.string(),
+      isBinary: z.boolean(),
+      tooLarge: z.boolean(),
+    }),
+  },
+  'codeSession:readdir': {
+    req: z.object({
+      sessionId: z.string(),
+      relPath: z.string(),
+    }),
+    res: z.object({
+      entries: z.array(z.object({
+        name: z.string(),
+        kind: z.enum(['file', 'dir']),
+        size: z.number().optional(),
+      })),
+    }),
+  },
+  'codeSession:readFile': {
+    req: z.object({
+      sessionId: z.string(),
+      relPath: z.string(),
+    }),
+    res: z.object({
+      content: z.string(),
+      isBinary: z.boolean(),
+      tooLarge: z.boolean(),
+    }),
+  },
+  'codeSession:mergeBack': {
+    req: z.object({
+      sessionId: z.string(),
+    }),
+    res: z.object({
+      ok: z.boolean(),
+      conflict: z.boolean().optional(),
+      message: z.string(),
+    }),
+  },
+  'codeSession:cleanupWorktree': {
+    req: z.object({
+      sessionId: z.string(),
+      deleteBranch: z.boolean(),
+    }),
+    res: z.object({
+      success: z.boolean(),
+      error: z.string().optional(),
+    }),
+  },
+  // main → renderer: live session status transitions from the status tracker.
+  'codeSession:status': {
+    req: z.object({
+      sessionId: z.string(),
+      status: CodeSessionStatus,
+    }),
+    res: z.null(),
+  },
   'granola:setConfig': {
     req: z.object({
       enabled: z.boolean(),
diff --git a/apps/x/packages/shared/src/runs.ts b/apps/x/packages/shared/src/runs.ts
index a5043cde..496db9ba 100644
--- a/apps/x/packages/shared/src/runs.ts
+++ b/apps/x/packages/shared/src/runs.ts
@@ -31,6 +31,7 @@ export const StartEvent = BaseRunEvent.extend({
         "background_task_agent",
         "meeting_note",
         "knowledge_sync",
+        "code_session",
     ]).optional(),
     subUseCase: z.string().optional(),
 });
@@ -188,6 +189,7 @@ export const UseCase = z.enum([
     "background_task_agent",
     "meeting_note",
     "knowledge_sync",
+    "code_session",
 ]);
 
 export const Run = z.object({
@@ -209,6 +211,7 @@ export const ListRunsResponse = z.object({
         title: true,
         createdAt: true,
         agentId: true,
+        useCase: true,
     })),
     nextCursor: z.string().optional(),
 });
diff --git a/apps/x/pnpm-lock.yaml b/apps/x/pnpm-lock.yaml
index c4e5a8d5..17b0cc36 100644
--- a/apps/x/pnpm-lock.yaml
+++ b/apps/x/pnpm-lock.yaml
@@ -144,9 +144,27 @@ importers:
 
   apps/renderer:
     dependencies:
+      '@codemirror/language':
+        specifier: ^6.12.3
+        version: 6.12.3
+      '@codemirror/language-data':
+        specifier: ^6.5.2
+        version: 6.5.2
+      '@codemirror/merge':
+        specifier: ^6.12.2
+        version: 6.12.2
+      '@codemirror/state':
+        specifier: ^6.6.0
+        version: 6.6.0
+      '@codemirror/view':
+        specifier: ^6.43.1
+        version: 6.43.1
       '@eigenpal/docx-editor-react':
         specifier: ^1.0.3
         version: 1.0.3(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(ai@5.0.117(zod@4.2.1))(prosemirror-commands@1.7.1)(prosemirror-dropcursor@1.8.2)(prosemirror-history@1.5.0)(prosemirror-keymap@1.2.3)(prosemirror-model@1.25.7)(prosemirror-state@1.4.4)(prosemirror-tables@1.8.5)(prosemirror-transform@1.12.0)(prosemirror-view@1.41.8)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      '@lezer/highlight':
+        specifier: ^1.2.3
+        version: 1.2.3
       '@radix-ui/react-avatar':
         specifier: ^1.1.11
         version: 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
@@ -206,16 +224,16 @@ importers:
         version: 3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
       '@tiptap/extension-placeholder':
         specifier: 3.22.4
-        version: 3.22.4(@tiptap/extensions@3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))
+        version: 3.22.4(@tiptap/extensions@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))
       '@tiptap/extension-table':
         specifier: 3.22.4
         version: 3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
       '@tiptap/extension-task-item':
         specifier: 3.22.4
-        version: 3.22.4(@tiptap/extension-list@3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))
+        version: 3.22.4(@tiptap/extension-list@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))
       '@tiptap/extension-task-list':
         specifier: 3.22.4
-        version: 3.22.4(@tiptap/extension-list@3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))
+        version: 3.22.4(@tiptap/extension-list@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))
       '@tiptap/pm':
         specifier: 3.22.4
         version: 3.22.4
@@ -243,6 +261,9 @@ importers:
       cmdk:
         specifier: ^1.1.1
         version: 1.1.1(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      codemirror:
+        specifier: ^6.0.2
+        version: 6.0.2
       lucide-react:
         specifier: ^0.562.0
         version: 0.562.0(react@19.2.3)
@@ -596,25 +617,21 @@ packages:
     resolution: {integrity: sha512-R7KEVjxkR4rYgIQoHGBzwPdUJYxRTO8I4vHjRbMLH1eW4FS7BJvVs7ogfKR/NnHFBvMVqtC+l6jHLQv8bobUiw==}
     cpu: [arm64]
     os: [linux]
-    libc: [musl]
 
   '@anthropic-ai/claude-agent-sdk-linux-arm64@0.3.156':
     resolution: {integrity: sha512-H0Nfd41iw5isto9uQI1FlVSZ0eaDttr8rBpJMR25oK/mj3egMO5EmZ6aAxeeUYSLn2mSU50HA5VNxlGUE118TQ==}
     cpu: [arm64]
     os: [linux]
-    libc: [glibc]
 
   '@anthropic-ai/claude-agent-sdk-linux-x64-musl@0.3.156':
     resolution: {integrity: sha512-/Q6WUizI6a+hqZZ6ElwRU0PEuFhOoN4v6CuU35HHbiZ/7uaocGht4A8ZIgK1Fw6wOGtZzGLbc00CA1OU1Zg8EA==}
     cpu: [x64]
     os: [linux]
-    libc: [musl]
 
   '@anthropic-ai/claude-agent-sdk-linux-x64@0.3.156':
     resolution: {integrity: sha512-ymhrdlbWoYvTACUdaGdhrEv+ZMfwXLsf0BRLkr/IvY5aqybP7URzWmmZGOtDQpqkT/8xu/UCGqUYH3woJwUxfg==}
     cpu: [x64]
     os: [linux]
-    libc: [glibc]
 
   '@anthropic-ai/claude-agent-sdk-win32-arm64@0.3.156':
     resolution: {integrity: sha512-5sAeNObQQrMy4NF9HwxewrMnU7mVxZDHh+/MfJVQSz0GSTvXQ6gOuRH8helMlfspoU6VOdekPxVLRooX/3foEw==}
@@ -917,6 +934,99 @@ packages:
   '@chevrotain/utils@12.0.0':
     resolution: {integrity: sha512-lB59uJoaGIfOOL9knQqQRfhl9g7x8/wqFkp13zTdkRu1huG9kg6IJs1O8hqj9rs6h7orGxHJUKb+mX3rPbWGhA==}
 
+  '@codemirror/autocomplete@6.20.3':
+    resolution: {integrity: sha512-tlosUqb+3BbxCxZdu4tKeRghPFC+QM7q4X5YhKV2eCmPG+1r2F3f4AaSz5sCrFqUtX4Jh20VFTKecl16MgiV9g==}
+
+  '@codemirror/commands@6.10.3':
+    resolution: {integrity: sha512-JFRiqhKu+bvSkDLI+rUhJwSxQxYb759W5GBezE8Uc8mHLqC9aV/9aTC7yJSqCtB3F00pylrLCwnyS91Ap5ej4Q==}
+
+  '@codemirror/lang-angular@0.1.4':
+    resolution: {integrity: sha512-oap+gsltb/fzdlTQWD6BFF4bSLKcDnlxDsLdePiJpCVNKWXSTAbiiQeYI3UmES+BLAdkmIC1WjyztC1pi/bX4g==}
+
+  '@codemirror/lang-cpp@6.0.3':
+    resolution: {integrity: sha512-URM26M3vunFFn9/sm6rzqrBzDgfWuDixp85uTY49wKudToc2jTHUrKIGGKs+QWND+YLofNNZpxcNGRynFJfvgA==}
+
+  '@codemirror/lang-css@6.3.1':
+    resolution: {integrity: sha512-kr5fwBGiGtmz6l0LSJIbno9QrifNMUusivHbnA1H6Dmqy4HZFte3UAICix1VuKo0lMPKQr2rqB+0BkKi/S3Ejg==}
+
+  '@codemirror/lang-go@6.0.1':
+    resolution: {integrity: sha512-7fNvbyNylvqCphW9HD6WFnRpcDjr+KXX/FgqXy5H5ZS0eC5edDljukm/yNgYkwTsgp2busdod50AOTIy6Jikfg==}
+
+  '@codemirror/lang-html@6.4.11':
+    resolution: {integrity: sha512-9NsXp7Nwp891pQchI7gPdTwBuSuT3K65NGTHWHNJ55HjYcHLllr0rbIZNdOzas9ztc1EUVBlHou85FFZS4BNnw==}
+
+  '@codemirror/lang-java@6.0.2':
+    resolution: {integrity: sha512-m5Nt1mQ/cznJY7tMfQTJchmrjdjQ71IDs+55d1GAa8DGaB8JXWsVCkVT284C3RTASaY43YknrK2X3hPO/J3MOQ==}
+
+  '@codemirror/lang-javascript@6.2.5':
+    resolution: {integrity: sha512-zD4e5mS+50htS7F+TYjBPsiIFGanfVqg4HyUz6WNFikgOPf2BgKlx+TQedI1w6n/IqRBVBbBWmGFdLB/7uxO4A==}
+
+  '@codemirror/lang-jinja@6.0.1':
+    resolution: {integrity: sha512-P5kyHLObzjtbGj16h+hyvZTxJhSjBEeSx4wMjbnAf3b0uwTy2+F0zGjMZL4PQOm/mh2eGZ5xUDVZXgwP783Nsw==}
+
+  '@codemirror/lang-json@6.0.2':
+    resolution: {integrity: sha512-x2OtO+AvwEHrEwR0FyyPtfDUiloG3rnVTSZV1W8UteaLL8/MajQd8DpvUb2YVzC+/T18aSDv0H9mu+xw0EStoQ==}
+
+  '@codemirror/lang-less@6.0.2':
+    resolution: {integrity: sha512-EYdQTG22V+KUUk8Qq582g7FMnCZeEHsyuOJisHRft/mQ+ZSZ2w51NupvDUHiqtsOy7It5cHLPGfHQLpMh9bqpQ==}
+
+  '@codemirror/lang-liquid@6.3.2':
+    resolution: {integrity: sha512-6PDVU3ZnfeYyz1at1E/ttorErZvZFXXt1OPhtfe1EZJ2V2iDFa0CwPqPgG5F7NXN0yONGoBogKmFAafKTqlwIw==}
+
+  '@codemirror/lang-markdown@6.5.0':
+    resolution: {integrity: sha512-0K40bZ35jpHya6FriukbgaleaqzBLZfOh7HuzqbMxBXkbYMJDxfF39c23xOgxFezR+3G+tR2/Mup+Xk865OMvw==}
+
+  '@codemirror/lang-php@6.0.2':
+    resolution: {integrity: sha512-ZKy2v1n8Fc8oEXj0Th0PUMXzQJ0AIR6TaZU+PbDHExFwdu+guzOA4jmCHS1Nz4vbFezwD7LyBdDnddSJeScMCA==}
+
+  '@codemirror/lang-python@6.2.1':
+    resolution: {integrity: sha512-IRjC8RUBhn9mGR9ywecNhB51yePWCGgvHfY1lWN/Mrp3cKuHr0isDKia+9HnvhiWNnMpbGhWrkhuWOc09exRyw==}
+
+  '@codemirror/lang-rust@6.0.2':
+    resolution: {integrity: sha512-EZaGjCUegtiU7kSMvOfEZpaCReowEf3yNidYu7+vfuGTm9ow4mthAparY5hisJqOHmJowVH3Upu+eJlUji6qqA==}
+
+  '@codemirror/lang-sass@6.0.2':
+    resolution: {integrity: sha512-l/bdzIABvnTo1nzdY6U+kPAC51czYQcOErfzQ9zSm9D8GmNPD0WTW8st/CJwBTPLO8jlrbyvlSEcN20dc4iL0Q==}
+
+  '@codemirror/lang-sql@6.10.0':
+    resolution: {integrity: sha512-6ayPkEd/yRw0XKBx5uAiToSgGECo/GY2NoJIHXIIQh1EVwLuKoU8BP/qK0qH5NLXAbtJRLuT73hx7P9X34iO4w==}
+
+  '@codemirror/lang-vue@0.1.3':
+    resolution: {integrity: sha512-QSKdtYTDRhEHCfo5zOShzxCmqKJvgGrZwDQSdbvCRJ5pRLWBS7pD/8e/tH44aVQT6FKm0t6RVNoSUWHOI5vNug==}
+
+  '@codemirror/lang-wast@6.0.2':
+    resolution: {integrity: sha512-Imi2KTpVGm7TKuUkqyJ5NRmeFWF7aMpNiwHnLQe0x9kmrxElndyH0K6H/gXtWwY6UshMRAhpENsgfpSwsgmC6Q==}
+
+  '@codemirror/lang-xml@6.1.0':
+    resolution: {integrity: sha512-3z0blhicHLfwi2UgkZYRPioSgVTo9PV5GP5ducFH6FaHy0IAJRg+ixj5gTR1gnT/glAIC8xv4w2VL1LoZfs+Jg==}
+
+  '@codemirror/lang-yaml@6.1.3':
+    resolution: {integrity: sha512-AZ8DJBuXGVHybpBQhmZtgew5//4hv3tdkXnr3vDmOUMJRuB6vn/uuwtmTOTlqEaQFg3hQSVeA90NmvIQyUV6FQ==}
+
+  '@codemirror/language-data@6.5.2':
+    resolution: {integrity: sha512-CPkWBKrNS8stYbEU5kwBwTf3JB1kghlbh4FSAwzGW2TEscdeHHH4FGysREW86Mqnj3Qn09s0/6Ea/TutmoTobg==}
+
+  '@codemirror/language@6.12.3':
+    resolution: {integrity: sha512-QwCZW6Tt1siP37Jet9Tb02Zs81TQt6qQrZR2H+eGMcFsL1zMrk2/b9CLC7/9ieP1fjIUMgviLWMmgiHoJrj+ZA==}
+
+  '@codemirror/legacy-modes@6.5.3':
+    resolution: {integrity: sha512-xCsmIzH78MyWkib9jlPaaun57XNkfbMIhagfaZVd0iLTqlpw3jXaIcbZm72MTmmn64eTZpBVNjbyYh+QXnxRsg==}
+
+  '@codemirror/lint@6.9.7':
+    resolution: {integrity: sha512-28/+iWLYxKxsvGYhSYL7zaCZqLz5+FFFDq9tVsvGv9kv8RY4fFAchJ5WX9M3YrrRlTIsECjsXPqeNgnSmNP2dg==}
+
+  '@codemirror/merge@6.12.2':
+    resolution: {integrity: sha512-V8JvyAPjHbPupqP7BeMcsdsYCbyPij74jxIbaIJDORI+VZzW44zFmon8bF+oxGWvOKhcRmkiUMXd8MxHr3YA2w==}
+
+  '@codemirror/search@6.7.0':
+    resolution: {integrity: sha512-ZvGm99wc/s2cITtMT15LFdn8aH/aS+V+DqyGq/N5ZlV5vWtH+nILvC2nw0zX7ByNoHHDZ2IxxdW38O0tc5nVHg==}
+
+  '@codemirror/state@6.6.0':
+    resolution: {integrity: sha512-4nbvra5R5EtiCzr9BTHiTLc+MLXK2QGiAVYMyi8PkQd3SR+6ixar/Q/01Fa21TBIDOZXgeWV4WppsQolSreAPQ==}
+
+  '@codemirror/view@6.43.1':
+    resolution: {integrity: sha512-+BIjw/AG3tDQ4pJgTLPYdAW25eDE66YsvM4LKyVPgGzVgZ4a9Wj1SRX8kPVKgBDdPt8oHtZ15F0qx7p0oOHdHw==}
+
   '@composio/client@0.1.0-alpha.56':
     resolution: {integrity: sha512-hNgChB5uhdvT4QXNzzfUuvtG6vrfanQQFY2hPyKwbeR4x6mEmIGFiZ4y2qynErdUWldAZiB/7pY/MBMg6Q9E0g==}
 
@@ -1621,6 +1731,57 @@ packages:
   '@jridgewell/trace-mapping@0.3.31':
     resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
 
+  '@lezer/common@1.5.2':
+    resolution: {integrity: sha512-sxQE460fPZyU3sdc8lafxiPwJHBzZRy/udNFynGQky1SePYBdhkBl1kOagA9uT3pxR8K09bOrmTUqA9wb/PjSQ==}
+
+  '@lezer/cpp@1.1.6':
+    resolution: {integrity: sha512-vh9gWWJOXFVY8HBHK3Twzq8MgwG2iN4GSyzBP9sCGTe37P15x2R14VaBQk0VA0ezTRN1KHYBBsHhvpGZ2Xy/pA==}
+
+  '@lezer/css@1.3.3':
+    resolution: {integrity: sha512-RzBo8r+/6QJeow7aPHIpGVIH59xTcJXp399820gZoMo9noQDRVpJLheIBUicYwKcsbOYoBRoLZlf2720dG/4Tg==}
+
+  '@lezer/go@1.0.1':
+    resolution: {integrity: sha512-xToRsYxwsgJNHTgNdStpcvmbVuKxTapV0dM0wey1geMMRc9aggoVyKgzYp41D2/vVOx+Ii4hmE206kvxIXBVXQ==}
+
+  '@lezer/highlight@1.2.3':
+    resolution: {integrity: sha512-qXdH7UqTvGfdVBINrgKhDsVTJTxactNNxLk7+UMwZhU13lMHaOBlJe9Vqp907ya56Y3+ed2tlqzys7jDkTmW0g==}
+
+  '@lezer/html@1.3.13':
+    resolution: {integrity: sha512-oI7n6NJml729m7pjm9lvLvmXbdoMoi2f+1pwSDJkl9d68zGr7a9Btz8NdHTGQZtW2DA25ybeuv/SyDb9D5tseg==}
+
+  '@lezer/java@1.1.3':
+    resolution: {integrity: sha512-yHquUfujwg6Yu4Fd1GNHCvidIvJwi/1Xu2DaKl/pfWIA2c1oXkVvawH3NyXhCaFx4OdlYBVX5wvz2f7Aoa/4Xw==}
+
+  '@lezer/javascript@1.5.4':
+    resolution: {integrity: sha512-vvYx3MhWqeZtGPwDStM2dwgljd5smolYD2lR2UyFcHfxbBQebqx8yjmFmxtJ/E6nN6u1D9srOiVWm3Rb4tmcUA==}
+
+  '@lezer/json@1.0.3':
+    resolution: {integrity: sha512-BP9KzdF9Y35PDpv04r0VeSTKDeox5vVr3efE7eBbx3r4s3oNLfunchejZhjArmeieBH+nVOpgIiBJpEAv8ilqQ==}
+
+  '@lezer/lr@1.4.10':
+    resolution: {integrity: sha512-rnCpTIBafOx4mRp43xOxDJbFipJm/c0cia/V5TiGlhmMa+wsSdoGmUN3w5Bqrks/09Q/D4tNAmWaT8p6NRi77A==}
+
+  '@lezer/markdown@1.6.4':
+    resolution: {integrity: sha512-N0SxazMj4k65DBfaf1azqtMZd6u7MqluP84/NZnB/io8Td9aleFmAhz9hcbvSfsxT5tdYlJ5qgv5aMJGY4zEtA==}
+
+  '@lezer/php@1.0.5':
+    resolution: {integrity: sha512-W7asp9DhM6q0W6DYNwIkLSKOvxlXRrif+UXBMxzsJUuqmhE7oVU+gS3THO4S/Puh7Xzgm858UNaFi6dxTP8dJA==}
+
+  '@lezer/python@1.1.19':
+    resolution: {integrity: sha512-MhQIURHRytsNzP/YXnqpYKW6la6voAH3kyplTOOiCdjyFY6cWWGFVmYVdHIPrElqSDf4iCDktQCockB9FxuhzQ==}
+
+  '@lezer/rust@1.0.2':
+    resolution: {integrity: sha512-Lz5sIPBdF2FUXcWeCu1//ojFAZqzTQNRga0aYv6dYXqJqPfMdCAI0NzajWUd4Xijj1IKJLtjoXRPMvTKWBcqKg==}
+
+  '@lezer/sass@1.1.0':
+    resolution: {integrity: sha512-3mMGdCTUZ/84ArHOuXWQr37pnf7f+Nw9ycPUeKX+wu19b7pSMcZGLbaXwvD2APMBDOGxPmpK/O6S1v1EvLoqgQ==}
+
+  '@lezer/xml@1.0.6':
+    resolution: {integrity: sha512-CdDwirL0OEaStFue/66ZmFSeppuL6Dwjlk8qk153mSQwiSH/Dlri4GNymrNWnUmPl2Um7QfV1FO9KFUyX3Twww==}
+
+  '@lezer/yaml@1.0.4':
+    resolution: {integrity: sha512-2lrrHqxalACEbxIbsjhqGpSW8kWpUKuY6RHgnSAFZa6qK62wvnPxA8hGOwOoDbwHcOFs5M4o27mjGu+P7TvBmw==}
+
   '@listr2/prompt-adapter-inquirer@2.0.22':
     resolution: {integrity: sha512-hV36ZoY+xKL6pYOt1nPNnkciFkn89KZwqLhAFzJvYysAvL5uBQdiADZx/8bIDXIukzzwG0QlPYolgMzQUtKgpQ==}
     engines: {node: '>=18.0.0'}
@@ -1635,6 +1796,9 @@ packages:
     resolution: {integrity: sha512-1DpKU0Z5ThltBwjNySMC14g0CkbyhCaz9FkhxqNsZI6uAPJXFS8cMXlBKo26FJ8ZuW6S9GCMcR9IO5k2X5/9Fg==}
     engines: {node: '>= 12.13.0'}
 
+  '@marijn/find-cluster-break@1.0.2':
+    resolution: {integrity: sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g==}
+
   '@mermaid-js/parser@1.1.0':
     resolution: {integrity: sha512-gxK9ZX2+Fex5zu8LhRQoMeMPEHbc73UKZ0FQ54YrQtUxE1VVhMwzeNtKRPAu5aXks4FasbMe4xB4bWrmq6Jlxw==}
 
@@ -1677,35 +1841,30 @@ packages:
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
-    libc: [glibc]
 
   '@napi-rs/canvas-linux-arm64-musl@0.1.80':
     resolution: {integrity: sha512-1XbCOz/ymhj24lFaIXtWnwv/6eFHXDrjP0jYkc6iHQ9q8oXKzUX1Lc6bu+wuGiLhGh2GS/2JlfORC5ZcXimRcg==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
-    libc: [musl]
 
   '@napi-rs/canvas-linux-riscv64-gnu@0.1.80':
     resolution: {integrity: sha512-XTzR125w5ZMs0lJcxRlS1K3P5RaZ9RmUsPtd1uGt+EfDyYMu4c6SEROYsxyatbbu/2+lPe7MPHOO/0a0x7L/gw==}
     engines: {node: '>= 10'}
     cpu: [riscv64]
     os: [linux]
-    libc: [glibc]
 
   '@napi-rs/canvas-linux-x64-gnu@0.1.80':
     resolution: {integrity: sha512-BeXAmhKg1kX3UCrJsYbdQd3hIMDH/K6HnP/pG2LuITaXhXBiNdh//TVVVVCBbJzVQaV5gK/4ZOCMrQW9mvuTqA==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
-    libc: [glibc]
 
   '@napi-rs/canvas-linux-x64-musl@0.1.80':
     resolution: {integrity: sha512-x0XvZWdHbkgdgucJsRxprX/4o4sEed7qo9rCQA9ugiS9qE2QvP0RIiEugtZhfLH3cyI+jIRFJHV4Fuz+1BHHMg==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
-    libc: [musl]
 
   '@napi-rs/canvas-win32-x64-msvc@0.1.80':
     resolution: {integrity: sha512-Z8jPsM6df5V8B1HrCHB05+bDiCxjE9QA//3YrkKIdVDEwn5RKaqOxCJDRJkl48cJbylcrJbW4HxZbTte8juuPg==}
@@ -2869,67 +3028,56 @@ packages:
     resolution: {integrity: sha512-EHMUcDwhtdRGlXZsGSIuXSYwD5kOT9NVnx9sqzYiwAc91wfYOE1g1djOEDseZJKKqtHAHGwnGPQu3kytmfaXLQ==}
     cpu: [arm]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-arm-musleabihf@4.54.0':
     resolution: {integrity: sha512-+pBrqEjaakN2ySv5RVrj/qLytYhPKEUwk+e3SFU5jTLHIcAtqh2rLrd/OkbNuHJpsBgxsD8ccJt5ga/SeG0JmA==}
     cpu: [arm]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-linux-arm64-gnu@4.54.0':
     resolution: {integrity: sha512-NSqc7rE9wuUaRBsBp5ckQ5CVz5aIRKCwsoa6WMF7G01sX3/qHUw/z4pv+D+ahL1EIKy6Enpcnz1RY8pf7bjwng==}
     cpu: [arm64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-arm64-musl@4.54.0':
     resolution: {integrity: sha512-gr5vDbg3Bakga5kbdpqx81m2n9IX8M6gIMlQQIXiLTNeQW6CucvuInJ91EuCJ/JYvc+rcLLsDFcfAD1K7fMofg==}
     cpu: [arm64]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-linux-loong64-gnu@4.54.0':
     resolution: {integrity: sha512-gsrtB1NA3ZYj2vq0Rzkylo9ylCtW/PhpLEivlgWe0bpgtX5+9j9EZa0wtZiCjgu6zmSeZWyI/e2YRX1URozpIw==}
     cpu: [loong64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-ppc64-gnu@4.54.0':
     resolution: {integrity: sha512-y3qNOfTBStmFNq+t4s7Tmc9hW2ENtPg8FeUD/VShI7rKxNW7O4fFeaYbMsd3tpFlIg1Q8IapFgy7Q9i2BqeBvA==}
     cpu: [ppc64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-gnu@4.54.0':
     resolution: {integrity: sha512-89sepv7h2lIVPsFma8iwmccN7Yjjtgz0Rj/Ou6fEqg3HDhpCa+Et+YSufy27i6b0Wav69Qv4WBNl3Rs6pwhebQ==}
     cpu: [riscv64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-musl@4.54.0':
     resolution: {integrity: sha512-ZcU77ieh0M2Q8Ur7D5X7KvK+UxbXeDHwiOt/CPSBTI1fBmeDMivW0dPkdqkT4rOgDjrDDBUed9x4EgraIKoR2A==}
     cpu: [riscv64]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-linux-s390x-gnu@4.54.0':
     resolution: {integrity: sha512-2AdWy5RdDF5+4YfG/YesGDDtbyJlC9LHmL6rZw6FurBJ5n4vFGupsOBGfwMRjBYH7qRQowT8D/U4LoSvVwOhSQ==}
     cpu: [s390x]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-x64-gnu@4.54.0':
     resolution: {integrity: sha512-WGt5J8Ij/rvyqpFexxk3ffKqqbLf9AqrTBbWDk7ApGUzaIs6V+s2s84kAxklFwmMF/vBNGrVdYgbblCOFFezMQ==}
     cpu: [x64]
     os: [linux]
-    libc: [glibc]
 
   '@rollup/rollup-linux-x64-musl@4.54.0':
     resolution: {integrity: sha512-JzQmb38ATzHjxlPHuTH6tE7ojnMKM2kYNzt44LO/jJi8BpceEC8QuXYA908n8r3CNuG/B3BV8VR3Hi1rYtmPiw==}
     cpu: [x64]
     os: [linux]
-    libc: [musl]
 
   '@rollup/rollup-openharmony-arm64@4.54.0':
     resolution: {integrity: sha512-huT3fd0iC7jigGh7n3q/+lfPcXxBi+om/Rs3yiFxjvSxbSB6aohDFXbWvlspaqjeOh+hx7DDHS+5Es5qRkWkZg==}
@@ -3251,28 +3399,24 @@ packages:
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
-    libc: [glibc]
 
   '@tailwindcss/oxide-linux-arm64-musl@4.1.18':
     resolution: {integrity: sha512-1px92582HkPQlaaCkdRcio71p8bc8i/ap5807tPRDK/uw953cauQBT8c5tVGkOwrHMfc2Yh6UuxaH4vtTjGvHg==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
-    libc: [musl]
 
   '@tailwindcss/oxide-linux-x64-gnu@4.1.18':
     resolution: {integrity: sha512-v3gyT0ivkfBLoZGF9LyHmts0Isc8jHZyVcbzio6Wpzifg/+5ZJpDiRiUhDLkcr7f/r38SWNe7ucxmGW3j3Kb/g==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
-    libc: [glibc]
 
   '@tailwindcss/oxide-linux-x64-musl@4.1.18':
     resolution: {integrity: sha512-bhJ2y2OQNlcRwwgOAGMY0xTFStt4/wyU6pvI6LSuZpRgKQwxTec0/3Scu91O8ir7qCR3AuepQKLU/kX99FouqQ==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
-    libc: [musl]
 
   '@tailwindcss/oxide-wasm32-wasi@4.1.18':
     resolution: {integrity: sha512-LffYTvPjODiP6PT16oNeUQJzNVyJl1cjIebq/rWWBF+3eDst5JGEFSc5cWxyRCJ0Mxl+KyIkqRxk1XPEs9x8TA==}
@@ -3408,12 +3552,6 @@ packages:
     peerDependencies:
       '@tiptap/extension-list': 3.22.5
 
-  '@tiptap/extension-list@3.22.4':
-    resolution: {integrity: sha512-Xe8UFvvHmyp/c/TJsFwlwU9CWACYbBirNsluJ3U1+H8BTu1wqdrT/AXR5uIXeyCl5kiWKgX5q71eHWbYFOrqrg==}
-    peerDependencies:
-      '@tiptap/core': 3.22.4
-      '@tiptap/pm': 3.22.4
-
   '@tiptap/extension-list@3.22.5':
     resolution: {integrity: sha512-cVO3ZHCgxAWZ4zrFSs81FO2nyCk1wb2EHkpLpW98FzbJLkN9rDkazhW99P3HRWy/CvUldOT+8ecI1YrQtBojMg==}
     peerDependencies:
@@ -3466,12 +3604,6 @@ packages:
     peerDependencies:
       '@tiptap/core': 3.22.5
 
-  '@tiptap/extensions@3.22.4':
-    resolution: {integrity: sha512-fOe8VptJvLPs32bNdUYo8SRyljwqKNQVXWW056VoXIc5en/59OdJlJQVeHI0jRRciH3MtrqODi/gfJR0VHNZ8A==}
-    peerDependencies:
-      '@tiptap/core': 3.22.4
-      '@tiptap/pm': 3.22.4
-
   '@tiptap/extensions@3.22.5':
     resolution: {integrity: sha512-Ifg4MzKCj3uRqe3ieTwYnomu2y4p7EXr2avVSKZYfh12i2dyWe2Gkn1KuZDREANVE+gHqFlQjJRYzhJFwzSCrg==}
     peerDependencies:
@@ -4357,6 +4489,9 @@ packages:
       react: ^18 || ^19 || ^19.0.0-rc
       react-dom: ^18 || ^19 || ^19.0.0-rc
 
+  codemirror@6.0.2:
+    resolution: {integrity: sha512-VhydHotNW5w1UGK0Qj96BwSk/Zqbp9WbnyK2W/eVMv4QyF41INRGpjUhFJY7/uDNuudSc33a/PKr4iDqRduvHw==}
+
   codepage@1.15.0:
     resolution: {integrity: sha512-3g6NUTPd/YtuuGrhMnOMRjFc+LJw/bnMp3+0r/Wcz3IXUuCosKRJvMphm5+Q+bvTVGcJJuRvVLuYba+WojaFaA==}
     engines: {node: '>=0.8'}
@@ -4462,6 +4597,9 @@ packages:
     engines: {node: '>=0.8'}
     hasBin: true
 
+  crelt@1.0.6:
+    resolution: {integrity: sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==}
+
   cron-parser@5.5.0:
     resolution: {integrity: sha512-oML4lKUXxizYswqmxuOCpgFS8BNUJpIu6k/2HVHyaL8Ynnf3wdf9tkns0yRdJLSIjkJ+b0DXHMZEHGpMwjnPww==}
     engines: {node: '>=18'}
@@ -5973,28 +6111,24 @@ packages:
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [linux]
-    libc: [glibc]
 
   lightningcss-linux-arm64-musl@1.30.2:
     resolution: {integrity: sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA==}
     engines: {node: '>= 12.0.0'}
     cpu: [arm64]
     os: [linux]
-    libc: [musl]
 
   lightningcss-linux-x64-gnu@1.30.2:
     resolution: {integrity: sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [linux]
-    libc: [glibc]
 
   lightningcss-linux-x64-musl@1.30.2:
     resolution: {integrity: sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA==}
     engines: {node: '>= 12.0.0'}
     cpu: [x64]
     os: [linux]
-    libc: [musl]
 
   lightningcss-win32-arm64-msvc@1.30.2:
     resolution: {integrity: sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ==}
@@ -7574,6 +7708,9 @@ packages:
   strnum@2.1.2:
     resolution: {integrity: sha512-l63NF9y/cLROq/yqKXSLtcMeeyOfnSQlfMSlzFt/K73oIaD8DGaQWd7Z34X9GPiKqP5rbSh84Hl4bOlLcjiSrQ==}
 
+  style-mod@4.1.3:
+    resolution: {integrity: sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ==}
+
   style-to-js@1.1.21:
     resolution: {integrity: sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==}
 
@@ -9003,6 +9140,265 @@ snapshots:
 
   '@chevrotain/utils@12.0.0': {}
 
+  '@codemirror/autocomplete@6.20.3':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/common': 1.5.2
+
+  '@codemirror/commands@6.10.3':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/common': 1.5.2
+
+  '@codemirror/lang-angular@0.1.4':
+    dependencies:
+      '@codemirror/lang-html': 6.4.11
+      '@codemirror/lang-javascript': 6.2.5
+      '@codemirror/language': 6.12.3
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@codemirror/lang-cpp@6.0.3':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@lezer/cpp': 1.1.6
+
+  '@codemirror/lang-css@6.3.1':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/css': 1.3.3
+
+  '@codemirror/lang-go@6.0.1':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/go': 1.0.1
+
+  '@codemirror/lang-html@6.4.11':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/lang-css': 6.3.1
+      '@codemirror/lang-javascript': 6.2.5
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/common': 1.5.2
+      '@lezer/css': 1.3.3
+      '@lezer/html': 1.3.13
+
+  '@codemirror/lang-java@6.0.2':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@lezer/java': 1.1.3
+
+  '@codemirror/lang-javascript@6.2.5':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/lint': 6.9.7
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/common': 1.5.2
+      '@lezer/javascript': 1.5.4
+
+  '@codemirror/lang-jinja@6.0.1':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/lang-html': 6.4.11
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@codemirror/lang-json@6.0.2':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@lezer/json': 1.0.3
+
+  '@codemirror/lang-less@6.0.2':
+    dependencies:
+      '@codemirror/lang-css': 6.3.1
+      '@codemirror/language': 6.12.3
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@codemirror/lang-liquid@6.3.2':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/lang-html': 6.4.11
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@codemirror/lang-markdown@6.5.0':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/lang-html': 6.4.11
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/common': 1.5.2
+      '@lezer/markdown': 1.6.4
+
+  '@codemirror/lang-php@6.0.2':
+    dependencies:
+      '@codemirror/lang-html': 6.4.11
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/php': 1.0.5
+
+  '@codemirror/lang-python@6.2.1':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/python': 1.1.19
+
+  '@codemirror/lang-rust@6.0.2':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@lezer/rust': 1.0.2
+
+  '@codemirror/lang-sass@6.0.2':
+    dependencies:
+      '@codemirror/lang-css': 6.3.1
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/sass': 1.1.0
+
+  '@codemirror/lang-sql@6.10.0':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@codemirror/lang-vue@0.1.3':
+    dependencies:
+      '@codemirror/lang-html': 6.4.11
+      '@codemirror/lang-javascript': 6.2.5
+      '@codemirror/language': 6.12.3
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@codemirror/lang-wast@6.0.2':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@codemirror/lang-xml@6.1.0':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/common': 1.5.2
+      '@lezer/xml': 1.0.6
+
+  '@codemirror/lang-yaml@6.1.3':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+      '@lezer/yaml': 1.0.4
+
+  '@codemirror/language-data@6.5.2':
+    dependencies:
+      '@codemirror/lang-angular': 0.1.4
+      '@codemirror/lang-cpp': 6.0.3
+      '@codemirror/lang-css': 6.3.1
+      '@codemirror/lang-go': 6.0.1
+      '@codemirror/lang-html': 6.4.11
+      '@codemirror/lang-java': 6.0.2
+      '@codemirror/lang-javascript': 6.2.5
+      '@codemirror/lang-jinja': 6.0.1
+      '@codemirror/lang-json': 6.0.2
+      '@codemirror/lang-less': 6.0.2
+      '@codemirror/lang-liquid': 6.3.2
+      '@codemirror/lang-markdown': 6.5.0
+      '@codemirror/lang-php': 6.0.2
+      '@codemirror/lang-python': 6.2.1
+      '@codemirror/lang-rust': 6.0.2
+      '@codemirror/lang-sass': 6.0.2
+      '@codemirror/lang-sql': 6.10.0
+      '@codemirror/lang-vue': 0.1.3
+      '@codemirror/lang-wast': 6.0.2
+      '@codemirror/lang-xml': 6.1.0
+      '@codemirror/lang-yaml': 6.1.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/legacy-modes': 6.5.3
+
+  '@codemirror/language@6.12.3':
+    dependencies:
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+      style-mod: 4.1.3
+
+  '@codemirror/legacy-modes@6.5.3':
+    dependencies:
+      '@codemirror/language': 6.12.3
+
+  '@codemirror/lint@6.9.7':
+    dependencies:
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      crelt: 1.0.6
+
+  '@codemirror/merge@6.12.2':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      '@lezer/highlight': 1.2.3
+      style-mod: 4.1.3
+
+  '@codemirror/search@6.7.0':
+    dependencies:
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+      crelt: 1.0.6
+
+  '@codemirror/state@6.6.0':
+    dependencies:
+      '@marijn/find-cluster-break': 1.0.2
+
+  '@codemirror/view@6.43.1':
+    dependencies:
+      '@codemirror/state': 6.6.0
+      crelt: 1.0.6
+      style-mod: 4.1.3
+      w3c-keyname: 2.2.8
+
   '@composio/client@0.1.0-alpha.56': {}
 
   '@composio/core@0.6.2(zod@4.2.1)':
@@ -9890,6 +10286,99 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  '@lezer/common@1.5.2': {}
+
+  '@lezer/cpp@1.1.6':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/css@1.3.3':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/go@1.0.1':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/highlight@1.2.3':
+    dependencies:
+      '@lezer/common': 1.5.2
+
+  '@lezer/html@1.3.13':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/java@1.1.3':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/javascript@1.5.4':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/json@1.0.3':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/lr@1.4.10':
+    dependencies:
+      '@lezer/common': 1.5.2
+
+  '@lezer/markdown@1.6.4':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+
+  '@lezer/php@1.0.5':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/python@1.1.19':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/rust@1.0.2':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/sass@1.1.0':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/xml@1.0.6':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/yaml@1.0.4':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
   '@listr2/prompt-adapter-inquirer@2.0.22(@inquirer/prompts@6.0.1)':
     dependencies:
       '@inquirer/prompts': 6.0.1
@@ -9904,6 +10393,8 @@ snapshots:
     dependencies:
       cross-spawn: 7.0.6
 
+  '@marijn/find-cluster-break@1.0.2': {}
+
   '@mermaid-js/parser@1.1.0':
     dependencies:
       langium: 4.2.2
@@ -11783,11 +12274,6 @@ snapshots:
     dependencies:
       '@tiptap/extension-list': 3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
 
-  '@tiptap/extension-list@3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)':
-    dependencies:
-      '@tiptap/core': 3.22.4(@tiptap/pm@3.22.4)
-      '@tiptap/pm': 3.22.4
-
   '@tiptap/extension-list@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)':
     dependencies:
       '@tiptap/core': 3.22.4(@tiptap/pm@3.22.4)
@@ -11801,9 +12287,9 @@ snapshots:
     dependencies:
       '@tiptap/core': 3.22.4(@tiptap/pm@3.22.4)
 
-  '@tiptap/extension-placeholder@3.22.4(@tiptap/extensions@3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))':
+  '@tiptap/extension-placeholder@3.22.4(@tiptap/extensions@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))':
     dependencies:
-      '@tiptap/extensions': 3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
+      '@tiptap/extensions': 3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
 
   '@tiptap/extension-strike@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))':
     dependencies:
@@ -11814,13 +12300,13 @@ snapshots:
       '@tiptap/core': 3.22.4(@tiptap/pm@3.22.4)
       '@tiptap/pm': 3.22.4
 
-  '@tiptap/extension-task-item@3.22.4(@tiptap/extension-list@3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))':
+  '@tiptap/extension-task-item@3.22.4(@tiptap/extension-list@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))':
     dependencies:
-      '@tiptap/extension-list': 3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
+      '@tiptap/extension-list': 3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
 
-  '@tiptap/extension-task-list@3.22.4(@tiptap/extension-list@3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))':
+  '@tiptap/extension-task-list@3.22.4(@tiptap/extension-list@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4))':
     dependencies:
-      '@tiptap/extension-list': 3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
+      '@tiptap/extension-list': 3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
 
   '@tiptap/extension-text@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))':
     dependencies:
@@ -11830,11 +12316,6 @@ snapshots:
     dependencies:
       '@tiptap/core': 3.22.4(@tiptap/pm@3.22.4)
 
-  '@tiptap/extensions@3.22.4(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)':
-    dependencies:
-      '@tiptap/core': 3.22.4(@tiptap/pm@3.22.4)
-      '@tiptap/pm': 3.22.4
-
   '@tiptap/extensions@3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)':
     dependencies:
       '@tiptap/core': 3.22.4(@tiptap/pm@3.22.4)
@@ -12921,6 +13402,16 @@ snapshots:
       - '@types/react'
       - '@types/react-dom'
 
+  codemirror@6.0.2:
+    dependencies:
+      '@codemirror/autocomplete': 6.20.3
+      '@codemirror/commands': 6.10.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/lint': 6.9.7
+      '@codemirror/search': 6.7.0
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.1
+
   codepage@1.15.0: {}
 
   color-convert@0.5.3:
@@ -13001,6 +13492,8 @@ snapshots:
 
   crc-32@1.2.2: {}
 
+  crelt@1.0.6: {}
+
   cron-parser@5.5.0:
     dependencies:
       luxon: 3.7.2
@@ -16882,6 +17375,8 @@ snapshots:
 
   strnum@2.1.2: {}
 
+  style-mod@4.1.3: {}
+
   style-to-js@1.1.21:
     dependencies:
       style-to-object: 1.0.14