diff --git a/.ade/db.sqlite b/.ade/db.sqlite
new file mode 100644
index 000000000..e69de29bb
diff --git a/apps/desktop/src/main/main.ts b/apps/desktop/src/main/main.ts
index f465ed47c..d7f544316 100644
--- a/apps/desktop/src/main/main.ts
+++ b/apps/desktop/src/main/main.ts
@@ -1,4 +1,4 @@
-import { app, BrowserWindow, nativeImage, shell } from "electron";
+import { app, BrowserWindow, nativeImage, protocol, shell } from "electron";
 import path from "node:path";
 type NodePtyType = typeof import("node-pty");
 import { registerIpc } from "./services/ipc/registerIpc";
@@ -38,6 +38,7 @@ import { detectDefaultBaseRef, resolveRepoRoot, toProjectInfo, upsertProjectRow
 import { createAdeProjectService } from "./services/projects/adeProjectService";
 import { createConfigReloadService } from "./services/projects/configReloadService";
 import { IPC } from "../shared/ipc";
+import { resolveAdeLayout } from "../shared/adeLayout";
 import type { PortLease, ProjectInfo } from "../shared/types";
 import type { AppContext } from "./services/ipc/registerIpc";
 import fs from "node:fs";
@@ -228,7 +229,8 @@ async function createWindow(logger?: Logger): Promise<BrowserWindow> {
     `frame-src 'none'`,
     `script-src ${cspSources} 'unsafe-inline'`,
     `style-src ${cspSources} 'unsafe-inline'`,
-    `img-src ${cspImageSources} data: blob:`,
+    `img-src ${cspImageSources} ade-artifact: data: blob:`,
+    `media-src ade-artifact:`,
     `font-src ${cspSources} data:`,
     `connect-src ${cspSources}${cspWsSources} https:`,
     `worker-src 'self' blob:`,
@@ -394,7 +396,125 @@ async function createWindow(logger?: Logger): Promise<BrowserWindow> {
   return win;
 }
 
+// Register custom protocol for serving local artifact files (images, videos) to the renderer.
+// Must be called before app.whenReady().
+protocol.registerSchemesAsPrivileged([
+  { scheme: "ade-artifact", privileges: { standard: false, supportFetchAPI: true, stream: true } },
+]);
+
 app.whenReady().then(async () => {
+  /** Canonical artifacts dir for the active project; ade-artifact:// only serves under this path. */
+  let adeArtifactAllowedDir: string | null = null;
+
+  const isPathInsideArtifactAllowRoot = (resolvedFile: string, allowedDir: string): boolean => {
+    let allowed: string;
+    try {
+      allowed = fs.realpathSync(allowedDir);
+    } catch {
+      return false;
+    }
+    const normFile = path.normalize(resolvedFile);
+    const normAllowed = path.normalize(allowed);
+    if (process.platform === "win32") {
+      return normFile.toLowerCase().startsWith(normAllowed.toLowerCase() + path.sep)
+        || normFile.toLowerCase() === normAllowed.toLowerCase();
+    }
+    return normFile === normAllowed || normFile.startsWith(normAllowed + path.sep);
+  };
+
+  // Handle ade-artifact:// requests — serves local files for proof drawer previews.
+  // Path is encoded in the URL: ade-artifact:///absolute/path/to/file.png
+  protocol.handle("ade-artifact", (request) => {
+    const url = new URL(request.url);
+    let filePath = decodeURIComponent(url.pathname);
+    // On Windows, pathname starts with /C:/... — strip leading slash
+    if (process.platform === "win32" && /^\/[a-zA-Z]:/.test(filePath)) {
+      filePath = filePath.slice(1);
+    }
+    filePath = path.resolve(filePath);
+    let resolvedFile: string;
+    try {
+      resolvedFile = fs.realpathSync(filePath);
+    } catch {
+      console.warn("[ade-artifact] realpath failed", { filePath });
+      return new Response("Not found", { status: 404 });
+    }
+    const allowedDir = adeArtifactAllowedDir;
+    if (!allowedDir || !isPathInsideArtifactAllowRoot(resolvedFile, allowedDir)) {
+      console.warn("[ade-artifact] rejected path outside artifacts dir", { resolvedFile, allowedDir });
+      return new Response("Not found", { status: 404 });
+    }
+    try {
+      const stat = fs.statSync(resolvedFile);
+      if (!stat.isFile()) return new Response("Not found", { status: 404 });
+      const fileSize = stat.size;
+      const ext = path.extname(resolvedFile).replace(/^\./, "").toLowerCase();
+      const mimeMap: Record<string, string> = {
+        png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", webp: "image/webp",
+        gif: "image/gif", bmp: "image/bmp", svg: "image/svg+xml",
+        mp4: "video/mp4", webm: "video/webm", mov: "video/quicktime", avi: "video/x-msvideo", mkv: "video/x-matroska",
+      };
+      const mime = mimeMap[ext] ?? "application/octet-stream";
+
+      // Support Range requests — required for <video> playback and seeking
+      const rangeHeader = request.headers.get("Range");
+      if (rangeHeader) {
+        const match = /bytes=(\d+)-(\d*)/.exec(rangeHeader);
+        let start = match ? parseInt(match[1], 10) : 0;
+        let end = match && match[2] !== undefined && match[2] !== "" ? parseInt(match[2], 10) : fileSize - 1;
+        if (!Number.isFinite(start) || start < 0) start = 0;
+        if (!Number.isFinite(end)) end = fileSize - 1;
+        if (end > fileSize - 1) end = fileSize - 1;
+        if (start >= fileSize || start > end) {
+          return new Response(null, {
+            status: 416,
+            headers: {
+              "Content-Range": `bytes */${fileSize}`,
+            },
+          });
+        }
+        const chunkSize = end - start + 1;
+        const fileStream = fs.createReadStream(resolvedFile, { start, end });
+        const webStream = new ReadableStream({
+          start(controller) {
+            fileStream.on("data", (chunk) => controller.enqueue(typeof chunk === "string" ? Buffer.from(chunk) : chunk));
+            fileStream.on("end", () => controller.close());
+            fileStream.on("error", (err) => controller.error(err));
+          },
+          cancel() { fileStream.destroy(); },
+        });
+        return new Response(webStream, {
+          status: 206,
+          headers: {
+            "Content-Type": mime,
+            "Content-Range": `bytes ${start}-${end}/${fileSize}`,
+            "Content-Length": String(chunkSize),
+            "Accept-Ranges": "bytes",
+          },
+        });
+      }
+
+      // Full file response (images, small files)
+      const fileStream = fs.createReadStream(resolvedFile);
+      const webStream = new ReadableStream({
+        start(controller) {
+          fileStream.on("data", (chunk) => controller.enqueue(typeof chunk === "string" ? Buffer.from(chunk) : chunk));
+          fileStream.on("end", () => controller.close());
+          fileStream.on("error", (err) => controller.error(err));
+        },
+        cancel() { fileStream.destroy(); },
+      });
+      return new Response(webStream, {
+        headers: {
+          "Content-Type": mime,
+          "Content-Length": String(fileSize),
+          "Accept-Ranges": "bytes",
+        },
+      });
+    } catch {
+      return new Response("Not found", { status: 404 });
+    }
+  });
   console.log("[info] app.hardware_acceleration", {
     enabled: !disableHardwareAcceleration,
     reason: disableHardwareAcceleration
@@ -485,6 +605,15 @@ app.whenReady().then(async () => {
 
   const setActiveProject = (projectRoot: string | null): void => {
     activeProjectRoot = projectRoot ? normalizeProjectRoot(projectRoot) : null;
+    if (activeProjectRoot) {
+      try {
+        adeArtifactAllowedDir = resolveAdeLayout(activeProjectRoot).artifactsDir;
+      } catch {
+        adeArtifactAllowedDir = null;
+      }
+    } else {
+      adeArtifactAllowedDir = null;
+    }
   };
 
   const getActiveContext = (): AppContext => {
@@ -903,6 +1032,7 @@ app.whenReady().then(async () => {
     const ptyService = createPtyService({
       projectRoot,
       transcriptsDir: adePaths.transcriptsDir,
+      chatSessionsDir: adePaths.chatSessionsDir,
       laneService,
       sessionService,
       aiIntegrationService,
diff --git a/apps/desktop/src/main/services/chat/agentChatService.test.ts b/apps/desktop/src/main/services/chat/agentChatService.test.ts
index 6e8c314e4..92efaef49 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.test.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.test.ts
@@ -2807,6 +2807,306 @@ describe("createAgentChatService", () => {
         service.interrupt({ sessionId: "unknown-session-id" }),
       ).rejects.toThrow(/not found/i);
     });
+
+    it("emits subagent_result stopped for active subagents on claude interrupt", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+
+      // The stream function is called multiple times: once for warmup, once for the actual turn.
+      let streamCall = 0;
+      let warmupComplete = false;
+      let hangResolve: (() => void) | null = null;
+      const hangPromise = new Promise<void>((resolve) => { hangResolve = resolve; });
+      const send = vi.fn().mockResolvedValue(undefined);
+      const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          // Warmup stream — init + result to complete prewarm
+          yield {
+            type: "system",
+            subtype: "init",
+            session_id: "sdk-interrupt-sub-1",
+            slash_commands: [],
+          };
+          // Set before final yield: prewarm breaks the stream on `result` without draining further.
+          warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        // Actual turn stream — emit two task_started events, then hang
+        yield {
+          type: "system",
+          subtype: "task_started",
+          task_id: "sub-task-1",
+          description: "Subagent A",
+        };
+        yield {
+          type: "system",
+          subtype: "task_started",
+          task_id: "sub-task-2",
+          description: "Subagent B",
+        };
+        // Hang until test resolves the promise (simulating a long-running turn)
+        await hangPromise;
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      vi.mocked(unstable_v2_createSession).mockReturnValue({
+        send,
+        stream,
+        close: vi.fn(),
+        sessionId: "sdk-interrupt-sub-1",
+        setPermissionMode,
+      } as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+
+      await vi.waitFor(() => {
+        expect(warmupComplete).toBe(true);
+      });
+
+      // Start the turn (don't await — it will hang)
+      const sendPromise = service.sendMessage({
+        sessionId: session.id,
+        text: "Do something with subagents",
+      });
+
+      // Wait for the subagent_started events to appear
+      await waitForEvent(
+        events,
+        (e): e is AgentChatEventEnvelope =>
+          e.event.type === "subagent_started" && (e.event as any).taskId === "sub-task-2",
+      );
+
+      // Now interrupt — should emit subagent_result "stopped" for both
+      await service.interrupt({ sessionId: session.id });
+
+      const stoppedEvents = events.filter(
+        (e) => e.event.type === "subagent_result" && (e.event as any).status === "stopped",
+      );
+      expect(stoppedEvents).toHaveLength(2);
+
+      const stoppedTaskIds = stoppedEvents.map((e) => (e.event as any).taskId).sort();
+      expect(stoppedTaskIds).toEqual(["sub-task-1", "sub-task-2"]);
+
+      // After interrupt, listSubagents should reflect the stopped status
+      const subagents = service.listSubagents({ sessionId: session.id });
+      const stoppedSubagents = subagents.filter((s: any) => s.status === "stopped");
+      expect(stoppedSubagents).toHaveLength(2);
+
+      // Clean up: unblock the hanging stream so sendPromise resolves
+      hangResolve!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+
+    it("claude interrupt idempotency — second call is a no-op", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      let streamCall = 0;
+      let warmupComplete = false;
+      let hangResolve: (() => void) | null = null;
+      const hangPromise = new Promise<void>((resolve) => { hangResolve = resolve; });
+      const send = vi.fn().mockResolvedValue(undefined);
+      const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "system", subtype: "init", session_id: "sdk-idem-1", slash_commands: [] };
+          warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        yield {
+          type: "stream_event",
+          event: {
+            type: "content_block_delta",
+            index: 0,
+            delta: { type: "text_delta", text: "working" },
+          },
+        };
+        await hangPromise;
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      vi.mocked(unstable_v2_createSession).mockReturnValue({
+        send,
+        stream,
+        close: vi.fn(),
+        sessionId: "sdk-idem-1",
+        setPermissionMode,
+      } as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+
+      await vi.waitFor(() => {
+        expect(warmupComplete).toBe(true);
+      });
+
+      const sendPromise = service.sendMessage({
+        sessionId: session.id,
+        text: "Hello",
+      });
+
+      await waitForEvent(
+        events,
+        (e): e is AgentChatEventEnvelope => e.event.type === "text",
+      );
+
+      await service.interrupt({ sessionId: session.id });
+      const eventsAfterFirst = events.length;
+
+      await service.interrupt({ sessionId: session.id });
+      const newEvents = events.slice(eventsAfterFirst);
+      expect(newEvents).toHaveLength(0);
+
+      hangResolve!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+
+    it("claude interrupt with no active subagents emits no subagent events", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      let streamCall = 0;
+      let warmupComplete = false;
+      let hangResolve: (() => void) | null = null;
+      const hangPromise = new Promise<void>((resolve) => { hangResolve = resolve; });
+      const send = vi.fn().mockResolvedValue(undefined);
+      const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "system", subtype: "init", session_id: "sdk-no-sub-1", slash_commands: [] };
+          warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        yield {
+          type: "stream_event",
+          event: {
+            type: "content_block_delta",
+            index: 0,
+            delta: { type: "text_delta", text: "tick" },
+          },
+        };
+        await hangPromise;
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      vi.mocked(unstable_v2_createSession).mockReturnValue({
+        send,
+        stream,
+        close: vi.fn(),
+        sessionId: "sdk-no-sub-1",
+        setPermissionMode,
+      } as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+
+      await vi.waitFor(() => {
+        expect(warmupComplete).toBe(true);
+      });
+
+      const sendPromise = service.sendMessage({
+        sessionId: session.id,
+        text: "Hello",
+      });
+
+      await waitForEvent(
+        events,
+        (e): e is AgentChatEventEnvelope => e.event.type === "text",
+      );
+
+      await service.interrupt({ sessionId: session.id });
+
+      const subagentResultEvents = events.filter(
+        (e) => e.event.type === "subagent_result",
+      );
+      expect(subagentResultEvents).toHaveLength(0);
+
+      const eventsAfterFirst = events.length;
+      await service.interrupt({ sessionId: session.id });
+      const newEvents = events.slice(eventsAfterFirst);
+      expect(newEvents).toHaveLength(0);
+
+      hangResolve!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+
+    it("unified interrupt idempotency — second call is a no-op", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+
+      // Mock streamText to create a stream that hangs, giving us a unified
+      // runtime in a busy state so we can interrupt it.
+      let hangResolve: (() => void) | null = null;
+      const hangPromise = new Promise<void>((resolve) => { hangResolve = resolve; });
+      vi.mocked(streamText).mockImplementation(() => ({
+        fullStream: (async function* () {
+          yield { type: "start-step", stepNumber: 0 };
+          yield { type: "text-delta", textDelta: "Thinking..." };
+          // Hang until resolved
+          await hangPromise;
+          yield { type: "finish", usage: {} };
+        })(),
+      }) as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "unified",
+        model: "anthropic/claude-sonnet-4-6-api",
+        modelId: "anthropic/claude-sonnet-4-6-api",
+        permissionMode: "edit",
+      });
+
+      // Start a turn so the unified runtime gets created
+      const sendPromise = service.sendMessage({
+        sessionId: session.id,
+        text: "Do something",
+      });
+
+      // Wait for the text event to confirm the stream is running
+      await waitForEvent(
+        events,
+        (e): e is AgentChatEventEnvelope => e.event.type === "text",
+      );
+
+      // First interrupt — sets runtime.interrupted = true
+      await service.interrupt({ sessionId: session.id });
+      const eventsAfterFirst = events.length;
+
+      // Second interrupt — should be a no-op due to idempotency guard
+      await service.interrupt({ sessionId: session.id });
+      const newEvents = events.slice(eventsAfterFirst);
+
+      // The second interrupt should have produced no new events at all
+      expect(newEvents).toHaveLength(0);
+
+      // Clean up
+      hangResolve!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
   });
 
   // --------------------------------------------------------------------------
diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index 0f590284d..ab781a773 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -131,6 +131,7 @@ import type { LinearCredentialService } from "../cto/linearCredentialService";
 import type { createPrService } from "../prs/prService";
 import type { ComputerUseArtifactBrokerService } from "../computerUse/computerUseArtifactBrokerService";
 import { createProofObserver } from "../computerUse/proofObserver";
+import { maybeSyntheticToolResult } from "../computerUse/syntheticToolResult";
 import { resolveAdeMcpServerLaunch, resolveUnifiedRuntimeRoot } from "../orchestrator/unifiedOrchestratorAdapter";
 import type { createMissionService } from "../missions/missionService";
 import type { createAiOrchestratorService } from "../orchestrator/aiOrchestratorService";
@@ -193,6 +194,8 @@ type PersistedChatState = {
   preferredExecutionLaneId?: string | null;
   selectedExecutionLaneId?: string | null;
   lastLaneDirectiveKey?: string | null;
+  manuallyNamed?: boolean;
+  requestedCwd?: string | null;
   updatedAt: string;
 };
 
@@ -565,6 +568,7 @@ type ManagedChatSession = {
   autoTitleSeed: string | null;
   autoTitleStage: "none" | "initial" | "final";
   autoTitleInFlight: boolean;
+  manuallyNamed: boolean;
   summaryInFlight: boolean;
   activeAssistantMessageId: string | null;
   lastActivitySignature: string | null;
@@ -964,6 +968,8 @@ function defaultChatSessionTitle(provider: AgentChatProvider): string {
   return "AI Chat";
 }
 
+const DEFAULT_SESSION_TITLES = new Set(["Codex Chat", "Claude Chat", "AI Chat"]);
+
 function hasCustomChatSessionTitle(title: string | null | undefined, provider: AgentChatProvider): boolean {
   const normalized = String(title ?? "").trim();
   return normalized.length > 0 && normalized !== defaultChatSessionTitle(provider);
@@ -2843,6 +2849,7 @@ export function createAgentChatService(args: {
   ): Promise<void> => {
     const config = resolveChatConfig();
     if (!config.autoTitleEnabled) return;
+    if (managed.manuallyNamed) return;
     if (managed.autoTitleInFlight) return;
     if (args.stage === "initial" && managed.autoTitleStage !== "none") return;
     if (args.stage === "final") {
@@ -2908,6 +2915,8 @@ export function createAgentChatService(args: {
           titleContext.join("\n"),
         ].join("\n\n"),
       });
+      // Re-check after async — user may have manually renamed while the request was in flight.
+      if (managed.manuallyNamed) return;
       const nextTitle = setManagedSessionTitle(managed, result.text);
       if (!nextTitle) return;
       managed.autoTitleStage = args.stage;
@@ -3110,7 +3119,7 @@ export function createAgentChatService(args: {
   ): LaneLaunchContext & { laneId: string; laneDirectiveKey: string | null } => {
     const launchContext = resolveManagedExecutionContext(managed, {
       purpose: args.purpose ?? "continue this chat",
-      requestedCwd: args.requestedCwd,
+      requestedCwd: args.requestedCwd !== undefined ? args.requestedCwd : managed.session.requestedCwd,
     });
     const laneWorktreeChanged = managed.laneWorktreePath !== launchContext.laneWorktreePath;
     managed.laneWorktreePath = launchContext.laneWorktreePath;
@@ -3177,6 +3186,14 @@ export function createAgentChatService(args: {
       ...(managed.preferredExecutionLaneId ? { preferredExecutionLaneId: managed.preferredExecutionLaneId } : {}),
       ...(managed.selectedExecutionLaneId ? { selectedExecutionLaneId: managed.selectedExecutionLaneId } : {}),
       ...(managed.lastLaneDirectiveKey ? { lastLaneDirectiveKey: managed.lastLaneDirectiveKey } : {}),
+      manuallyNamed: Boolean(managed.manuallyNamed)
+        || (() => {
+          const trimmedTitle = String(sessionService.get(managed.session.id)?.title || "").trim();
+          return trimmedTitle.length > 0 && !DEFAULT_SESSION_TITLES.has(trimmedTitle);
+        })(),
+      ...(managed.session.requestedCwd != null && String(managed.session.requestedCwd).trim().length
+        ? { requestedCwd: String(managed.session.requestedCwd).trim() }
+        : {}),
       updatedAt: nowIso()
     };
 
@@ -3292,6 +3309,10 @@ export function createAgentChatService(args: {
         ...(typeof record.lastLaneDirectiveKey === "string" && record.lastLaneDirectiveKey.trim().length
           ? { lastLaneDirectiveKey: record.lastLaneDirectiveKey.trim() }
           : {}),
+        ...(record.manuallyNamed === true ? { manuallyNamed: true } : {}),
+        ...(typeof record.requestedCwd === "string" && record.requestedCwd.trim().length
+          ? { requestedCwd: record.requestedCwd.trim() }
+          : {}),
         updatedAt: typeof record.updatedAt === "string" && record.updatedAt.trim().length ? record.updatedAt : nowIso()
       };
       hydrateNativePermissionControls(hydrated as Parameters<typeof hydrateNativePermissionControls>[0]);
@@ -4103,6 +4124,9 @@ export function createAgentChatService(args: {
         completion: persisted?.completion ?? null,
         status: mapTerminalStatusToChatStatus(row.status),
         ...(persisted?.threadId ? { threadId: persisted.threadId } : {}),
+        ...(persisted?.requestedCwd != null && String(persisted.requestedCwd).trim().length
+          ? { requestedCwd: String(persisted.requestedCwd).trim() }
+          : {}),
         createdAt: row.startedAt,
         lastActivityAt: persisted?.updatedAt ?? row.endedAt ?? row.startedAt
       },
@@ -4120,6 +4144,11 @@ export function createAgentChatService(args: {
       autoTitleSeed: null,
       autoTitleStage: hasCustomChatSessionTitle(row.title, provider) ? "initial" : "none",
       autoTitleInFlight: false,
+      manuallyNamed: persisted?.manuallyNamed === true
+        || (() => {
+          const trimmedTitle = String(row.title || "").trim();
+          return trimmedTitle.length > 0 && !DEFAULT_SESSION_TITLES.has(trimmedTitle);
+        })(),
       summaryInFlight: false,
       continuitySummary: persisted?.continuitySummary ?? null,
       continuitySummaryUpdatedAt: persisted?.continuitySummaryUpdatedAt ?? null,
@@ -4441,6 +4470,9 @@ export function createAgentChatService(args: {
     const turnStartedAt = Date.now();
     let firstStreamEventLogged = false;
     const emittedClaudeToolIds = new Set<string>();
+    const emittedSyntheticItemIds = new Set<string>();
+    const toolInputJsonByContentIndex = new Map<number, string>();
+    const toolUseMetaByContentIndex = new Map<number, { toolName: string; itemId: string }>();
     const markFirstStreamEvent = (kind: string): void => {
       if (firstStreamEventLogged) return;
       firstStreamEventLogged = true;
@@ -4795,6 +4827,13 @@ export function createAgentChatService(args: {
                     itemId,
                     turnId,
                   });
+                  // Synthesize a tool_result for the proof observer since the
+                  // Claude V2 SDK never surfaces tool results in the stream.
+                  const syntheticResult = maybeSyntheticToolResult(toolName, block.input ?? {}, itemId, turnId);
+                  if (syntheticResult && !emittedSyntheticItemIds.has(itemId)) {
+                    emittedSyntheticItemIds.add(itemId);
+                    emitChatEvent(managed, syntheticResult);
+                  }
                 }
               }
             }
@@ -4842,7 +4881,17 @@ export function createAgentChatService(args: {
                 });
               }
             } else if (delta?.type === "input_json_delta") {
-              // Tool input streaming — just emit activity
+              const idx =
+                typeof event.index === "number"
+                  ? event.index
+                  : typeof contentIndex === "number"
+                    ? contentIndex
+                    : null;
+              const partial = typeof delta.partial_json === "string" ? delta.partial_json : "";
+              if (idx != null && partial.length) {
+                const prev = toolInputJsonByContentIndex.get(idx) ?? "";
+                toolInputJsonByContentIndex.set(idx, prev + partial);
+              }
               emitChatEvent(managed, {
                 type: "activity",
                 activity: "tool_calling",
@@ -4893,6 +4942,37 @@ export function createAgentChatService(args: {
                   itemId,
                   turnId,
                 });
+                if (typeof contentIndex === "number") {
+                  const initial =
+                    block.input != null && typeof block.input === "object" && Object.keys(block.input as object).length
+                      ? JSON.stringify(block.input)
+                      : "";
+                  toolInputJsonByContentIndex.set(contentIndex, initial);
+                  toolUseMetaByContentIndex.set(contentIndex, { toolName, itemId });
+                }
+              }
+            }
+          } else if (event.type === "content_block_stop") {
+            const stopIndex = typeof event.index === "number" ? event.index : contentIndex;
+            if (typeof stopIndex === "number") {
+              const meta = toolUseMetaByContentIndex.get(stopIndex);
+              if (meta) {
+                toolUseMetaByContentIndex.delete(stopIndex);
+                const raw = toolInputJsonByContentIndex.get(stopIndex) ?? "";
+                toolInputJsonByContentIndex.delete(stopIndex);
+                let parsed: unknown = {};
+                if (raw.trim().length) {
+                  try {
+                    parsed = JSON.parse(raw);
+                  } catch {
+                    parsed = {};
+                  }
+                }
+                const syntheticResult = maybeSyntheticToolResult(meta.toolName, parsed, meta.itemId, turnId);
+                if (syntheticResult && !emittedSyntheticItemIds.has(meta.itemId)) {
+                  emittedSyntheticItemIds.add(meta.itemId);
+                  emitChatEvent(managed, syntheticResult);
+                }
               }
             }
           } else if (event.type === "message_start") {
@@ -5540,6 +5620,7 @@ export function createAgentChatService(args: {
       // ── Stream processing loop ──
       const streamSupportsReasoning = runtime.modelDescriptor.capabilities.reasoning;
       for await (const part of stream.fullStream as AsyncIterable<any>) {
+        if (runtime.interrupted) break;
         if (!part || typeof part !== "object") continue;
         markFirstStreamEvent(String(part.type ?? "unknown"));
 
@@ -5704,51 +5785,67 @@ export function createAgentChatService(args: {
       // ── Shared turn completion ──
       persistDeliveredLaneDirectiveKey(managed, args.laneDirectiveKey);
       clearTimeout(turnTimeout);
-      if (assistantText.trim().length) {
-        runtime.messages.push({ role: "assistant", content: assistantText });
-      }
-
-      runtime.busy = false;
-      runtime.activeTurnId = null;
-      runtime.abortController = null;
-      managed.session.status = "idle";
+      if (runtime.interrupted) {
+        runtime.busy = false;
+        runtime.activeTurnId = null;
+        runtime.abortController = null;
+        managed.session.status = "idle";
+        emitChatEvent(managed, { type: "status", turnStatus: "interrupted", turnId });
+        emitChatEvent(managed, {
+          type: "done",
+          turnId,
+          status: "interrupted",
+          model: managed.session.model,
+          ...(managed.session.modelId ? { modelId: managed.session.modelId } : {}),
+        });
+        persistChatState(managed);
+      } else {
+        if (assistantText.trim().length) {
+          runtime.messages.push({ role: "assistant", content: assistantText });
+        }
 
-      emitChatEvent(managed, { type: "status", turnStatus: "completed", turnId });
-      emitChatEvent(managed, {
-        type: "done",
-        turnId,
-        status: "completed",
-        model: managed.session.model,
-        ...(managed.session.modelId ? { modelId: managed.session.modelId } : {}),
-        ...(usage ? { usage } : {})
-      });
+        runtime.busy = false;
+        runtime.activeTurnId = null;
+        runtime.abortController = null;
+        managed.session.status = "idle";
 
-      if (assistantText.trim().length > 0) {
-        appendWorkerActivityToCto(managed, {
-          activityType: "chat_turn",
-          summary: assistantText,
+        emitChatEvent(managed, { type: "status", turnStatus: "completed", turnId });
+        emitChatEvent(managed, {
+          type: "done",
+          turnId,
+          status: "completed",
+          model: managed.session.model,
+          ...(managed.session.modelId ? { modelId: managed.session.modelId } : {}),
+          ...(usage ? { usage } : {})
         });
-      }
 
-      const endSha = await computeHeadShaBestEffort(resolveManagedExecutionLaneId(managed)).catch(() => null);
-      if (endSha) {
-        sessionService.setHeadShaEnd(managed.session.id, endSha);
-      }
+        if (assistantText.trim().length > 0) {
+          appendWorkerActivityToCto(managed, {
+            activityType: "chat_turn",
+            summary: assistantText,
+          });
+        }
 
-      persistChatState(managed);
+        const endSha = await computeHeadShaBestEffort(resolveManagedExecutionLaneId(managed)).catch(() => null);
+        if (endSha) {
+          sessionService.setHeadShaEnd(managed.session.id, endSha);
+        }
 
-      // Process queued steers (skip if session was disposed during execution)
-      if (!managed.closed && runtime.pendingSteers.length) {
-        const steerText = runtime.pendingSteers.shift() ?? "";
-        if (steerText.trim().length) {
-          const preparedSteer = prepareSendMessage({
-            sessionId: managed.session.id,
-            text: steerText,
-            displayText: steerText,
-            attachments: [],
-          });
-          if (preparedSteer) {
-            await executePreparedSendMessage(preparedSteer);
+        persistChatState(managed);
+
+        // Process queued steers (skip if session was disposed during execution)
+        if (!managed.closed && runtime.pendingSteers.length) {
+          const steerText = runtime.pendingSteers.shift() ?? "";
+          if (steerText.trim().length) {
+            const preparedSteer = prepareSendMessage({
+              sessionId: managed.session.id,
+              text: steerText,
+              displayText: steerText,
+              attachments: [],
+            });
+            if (preparedSteer) {
+              await executePreparedSendMessage(preparedSteer);
+            }
           }
         }
       }
@@ -7290,6 +7387,13 @@ export function createAgentChatService(args: {
           return;
         }
 
+        // Apply permission mode before the first interaction so the session
+        // starts with the correct approval behaviour selected in the rebase tab.
+        const initialPermissionMode = resolveClaudeTurnPermissionMode(managed);
+        if (typeof runtime.v2Session.setPermissionMode === "function") {
+          await runtime.v2Session.setPermissionMode(initialPermissionMode);
+        }
+
         await runtime.v2Session.send("System initialization check. Respond with only the word READY.");
         for await (const msg of runtime.v2Session.stream()) {
           if (runtime.v2WarmupCancelled) break;
@@ -7443,6 +7547,7 @@ export function createAgentChatService(args: {
       autoTitleSeed: null,
       autoTitleStage: "none",
       autoTitleInFlight: false,
+      manuallyNamed: false,
       summaryInFlight: false,
       continuitySummary: null,
       continuitySummaryUpdatedAt: null,
@@ -7600,11 +7705,13 @@ export function createAgentChatService(args: {
     automationId,
     automationRunId,
     computerUse,
+    requestedCwd,
   }: AgentChatCreateArgs): Promise<AgentChatSession> => {
     const launchContext = resolveLaneLaunchContext({
       laneService,
       laneId,
       purpose: "start this chat",
+      requestedCwd,
     });
     const sessionId = randomUUID();
     const startedAt = nowIso();
@@ -7734,7 +7841,10 @@ export function createAgentChatService(args: {
         completion: null,
         status: "idle",
         createdAt: startedAt,
-        lastActivityAt: startedAt
+        lastActivityAt: startedAt,
+        ...(typeof requestedCwd === "string" && requestedCwd.trim().length
+          ? { requestedCwd: requestedCwd.trim() }
+          : {}),
       },
       transcriptPath,
       transcriptBytesWritten: fileSizeOrZero(transcriptPath),
@@ -7750,6 +7860,7 @@ export function createAgentChatService(args: {
       autoTitleSeed: null,
       autoTitleStage: "none",
       autoTitleInFlight: false,
+      manuallyNamed: false,
       summaryInFlight: false,
       continuitySummary: null,
       continuitySummaryUpdatedAt: null,
@@ -8100,6 +8211,20 @@ export function createAgentChatService(args: {
       if (reasoningEffort) {
         managed.session.reasoningEffort = normalizeReasoningEffort(reasoningEffort);
       }
+      // Re-sync permission mode so mid-session changes take effect on this turn.
+      if (managed.runtime?.kind === "unified") {
+        const chatConfig = resolveChatConfig();
+        const previousPermissionMode = managed.runtime.permissionMode;
+        managed.runtime.permissionMode = resolveSessionUnifiedPermissionMode(
+          managed.session,
+          chatConfig.unifiedPermissionMode,
+        );
+        // When permission mode becomes stricter, clear accept_for_session approvals
+        // so old overrides cannot auto-approve actions under the new policy.
+        if (managed.runtime.permissionMode !== previousPermissionMode) {
+          managed.runtime.approvalOverrides = new Set();
+        }
+      }
       await runTurn(managed, {
         promptText,
         displayText: visibleText,
@@ -8120,6 +8245,20 @@ export function createAgentChatService(args: {
         managed.session.reasoningEffort = DEFAULT_REASONING_EFFORT;
       }
 
+      // Re-sync codex approval policy so mid-session changes take effect on this turn.
+      if (runtime.threadResumed) {
+        const prevApproval = managed.session.codexApprovalPolicy;
+        const prevSandbox = managed.session.codexSandbox;
+        resolveCodexThreadParams(managed);
+        if (
+          managed.session.codexApprovalPolicy !== prevApproval
+          || managed.session.codexSandbox !== prevSandbox
+        ) {
+          // Policy drifted — force a re-resume so the codex server picks up the new settings.
+          runtime.threadResumed = false;
+        }
+      }
+
       if (!runtime.threadResumed) {
         const threadIdToResume = managed.session.threadId || readPersistedState(sessionId)?.threadId;
         const { codexPolicy, mcpServers } = resolveCodexThreadParams(managed);
@@ -8370,6 +8509,7 @@ export function createAgentChatService(args: {
 
     // Unified runtime interrupt — auto-decline pending approvals to prevent orphans
     if (managed.runtime?.kind === "unified") {
+      if (managed.runtime.interrupted) return;
       managed.runtime.interrupted = true;
       managed.runtime.abortController?.abort();
       for (const [itemId, approval] of managed.runtime.pendingApprovals) {
@@ -8390,6 +8530,8 @@ export function createAgentChatService(args: {
     }
 
     const runtime = ensureClaudeSessionRuntime(managed);
+    // Idempotency guard: skip if already interrupted (e.g. rapid cancel clicks)
+    if (runtime.interrupted) return;
     logger.info("agent_chat.turn_interrupt_requested", {
       sessionId,
       provider: "claude",
@@ -8397,13 +8539,28 @@ export function createAgentChatService(args: {
       busy: runtime.busy,
       warmupInFlight: Boolean(runtime.v2WarmupDone),
     });
+    // Set interrupted before closing the session so the streaming loop sees it
+    // and breaks cleanly rather than throwing from a closed session.
     runtime.interrupted = true;
     cancelClaudeWarmup(managed, runtime, "interrupt");
     runtime.activeQuery?.interrupt().catch(() => {});
-    // Close the V2 session on interrupt — it will be recreated on the next turn
+    // Close the V2 session — it will be recreated on the next turn.
     try { runtime.v2Session?.close(); } catch { /* ignore */ }
     runtime.v2Session = null;
     runtime.v2StreamGen = null;
+
+    // Emit subagent_result "stopped" for every active subagent so the UI
+    // properly transitions them from "running" → "stopped" (matching Claude Code CLI behaviour).
+    const turnId = runtime.activeTurnId ?? undefined;
+    for (const { taskId } of runtime.activeSubagents.values()) {
+      emitChatEvent(managed, {
+        type: "subagent_result",
+        taskId,
+        status: "stopped",
+        summary: "Interrupted by user",
+        turnId,
+      });
+    }
     runtime.activeSubagents.clear();
     logger.info("agent_chat.turn_interrupt_completed", {
       sessionId,
@@ -8474,6 +8631,11 @@ export function createAgentChatService(args: {
           await startFreshCodexThread(managed, runtime, codexPolicy, mcpServers);
         }
       }
+      // Re-sync codex approval policy from persisted/config settings
+      managed.session.codexApprovalPolicy = persisted?.codexApprovalPolicy ?? managed.session.codexApprovalPolicy;
+      managed.session.codexSandbox = persisted?.codexSandbox ?? managed.session.codexSandbox;
+      managed.session.codexConfigSource = persisted?.codexConfigSource ?? managed.session.codexConfigSource;
+      managed.session.permissionMode = syncLegacyPermissionMode(managed.session) ?? managed.session.permissionMode;
     } else if (managed.runtime?.kind === "unified" || (managed.session.modelId && !providerResolver.isModelCliWrapped(managed.session.modelId))) {
       // Unified runtime resume — re-resolve the model
       const result = await startUnifiedSession(managed);
@@ -8496,11 +8658,21 @@ export function createAgentChatService(args: {
         }
         // Fallthrough to Claude — SDK manages history via sdkSessionId
         ensureClaudeSessionRuntime(managed);
+        // Re-sync permission mode from persisted/config settings
+        const fallbackPermMode = resolveClaudeTurnPermissionMode(managed);
+        if (managed.runtime?.kind === "claude" && managed.runtime.v2Session && typeof managed.runtime.v2Session.setPermissionMode === "function") {
+          await managed.runtime.v2Session.setPermissionMode(fallbackPermMode);
+        }
         sessionService.setResumeCommand(sessionId, `chat:claude:${sessionId}`);
       }
     } else {
       // Claude — SDK manages history via sdkSessionId
       ensureClaudeSessionRuntime(managed);
+      // Re-sync permission mode from persisted/config settings
+      const claudePermMode = resolveClaudeTurnPermissionMode(managed);
+      if (managed.runtime?.kind === "claude" && managed.runtime.v2Session && typeof managed.runtime.v2Session.setPermissionMode === "function") {
+        await managed.runtime.v2Session.setPermissionMode(claudePermMode);
+      }
       sessionService.setResumeCommand(sessionId, `chat:claude:${sessionId}`);
     }
 
@@ -8935,6 +9107,7 @@ export function createAgentChatService(args: {
   const updateSession = async ({
     sessionId,
     title,
+    manuallyNamed,
     modelId,
     reasoningEffort,
     interactionMode,
@@ -9144,10 +9317,22 @@ export function createAgentChatService(args: {
 
     if (title !== undefined) {
       const normalizedTitle = String(title ?? "").trim();
+      const hasExplicitTitle = normalizedTitle.length > 0;
       sessionService.updateMeta({
         sessionId,
-        title: normalizedTitle.length ? normalizedTitle : defaultChatSessionTitle(managed.session.provider),
+        title: hasExplicitTitle ? normalizedTitle : defaultChatSessionTitle(managed.session.provider),
       });
+      if (manuallyNamed !== undefined) {
+        managed.manuallyNamed = manuallyNamed && hasExplicitTitle;
+      } else if (hasExplicitTitle) {
+        managed.manuallyNamed = true;
+      } else {
+        managed.manuallyNamed = false;
+      }
+    }
+    // Allow resetting manuallyNamed independently when no title change is provided
+    if (manuallyNamed !== undefined && title === undefined) {
+      managed.manuallyNamed = manuallyNamed;
     }
 
     persistChatState(managed);
diff --git a/apps/desktop/src/main/services/computerUse/syntheticToolResult.test.ts b/apps/desktop/src/main/services/computerUse/syntheticToolResult.test.ts
new file mode 100644
index 000000000..baa6ccce1
--- /dev/null
+++ b/apps/desktop/src/main/services/computerUse/syntheticToolResult.test.ts
@@ -0,0 +1,343 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ComputerUseArtifactIngestionRequest } from "../../../shared/types";
+import { extractArtifactPathsFromArgs, maybeSyntheticToolResult } from "./syntheticToolResult";
+import { createProofObserver } from "./proofObserver";
+
+// ---------------------------------------------------------------------------
+// Unit tests for extractArtifactPathsFromArgs
+// ---------------------------------------------------------------------------
+
+describe("extractArtifactPathsFromArgs", () => {
+  it("extracts a png path from a Bash command string", () => {
+    const paths = extractArtifactPathsFromArgs({
+      command: "screenshot /tmp/proof.png",
+    });
+    expect(paths).toEqual(["/tmp/proof.png"]);
+  });
+
+  it("extracts multiple artifact paths from a single command", () => {
+    const paths = extractArtifactPathsFromArgs({
+      command: "cp /home/user/screenshot.png /tmp/trace.zip && cat /var/log/app.log",
+    });
+    expect(paths).toContain("/home/user/screenshot.png");
+    expect(paths).toContain("/tmp/trace.zip");
+    expect(paths).toContain("/var/log/app.log");
+    expect(paths).toHaveLength(3);
+  });
+
+  it("extracts image path from Read tool args", () => {
+    const paths = extractArtifactPathsFromArgs({
+      file_path: "/Users/dev/captures/test-result.jpg",
+    });
+    expect(paths).toEqual(["/Users/dev/captures/test-result.jpg"]);
+  });
+
+  it("extracts paths from nested object structures", () => {
+    const paths = extractArtifactPathsFromArgs({
+      options: {
+        output: {
+          screenshot: "/tmp/nested/shot.webp",
+        },
+      },
+    });
+    expect(paths).toEqual(["/tmp/nested/shot.webp"]);
+  });
+
+  it("extracts paths from arrays", () => {
+    const paths = extractArtifactPathsFromArgs({
+      files: ["/a/b.png", "/c/d.mp4"],
+    });
+    expect(paths).toContain("/a/b.png");
+    expect(paths).toContain("/c/d.mp4");
+    expect(paths).toHaveLength(2);
+  });
+
+  it("ignores relative paths (no leading slash)", () => {
+    const paths = extractArtifactPathsFromArgs({
+      command: "cat relative/path.png",
+    });
+    expect(paths).toEqual([]);
+  });
+
+  it("returns empty for args with no artifact paths", () => {
+    const paths = extractArtifactPathsFromArgs({
+      command: "echo hello world",
+    });
+    expect(paths).toEqual([]);
+  });
+
+  it("returns empty for non-artifact extensions", () => {
+    const paths = extractArtifactPathsFromArgs({
+      file_path: "/tmp/data.json",
+    });
+    expect(paths).toEqual([]);
+  });
+
+  it("deduplicates repeated paths", () => {
+    const paths = extractArtifactPathsFromArgs({
+      a: "/tmp/shot.png",
+      b: "/tmp/shot.png",
+    });
+    expect(paths).toEqual(["/tmp/shot.png"]);
+  });
+
+  it("handles null/undefined/number args gracefully", () => {
+    expect(extractArtifactPathsFromArgs(null)).toEqual([]);
+    expect(extractArtifactPathsFromArgs(undefined)).toEqual([]);
+    expect(extractArtifactPathsFromArgs(42)).toEqual([]);
+    expect(extractArtifactPathsFromArgs("")).toEqual([]);
+  });
+
+  it("respects recursion depth limit", () => {
+    // Build deeply nested structure (depth > 8)
+    let obj: any = { path: "/tmp/deep.png" };
+    for (let i = 0; i < 12; i++) {
+      obj = { nested: obj };
+    }
+    // The path is at depth 13 — beyond the limit of 8
+    const paths = extractArtifactPathsFromArgs(obj);
+    expect(paths).toEqual([]);
+  });
+
+  it("handles video extensions", () => {
+    const paths = extractArtifactPathsFromArgs({
+      command: "ffmpeg -o /tmp/recording.mp4",
+    });
+    expect(paths).toEqual(["/tmp/recording.mp4"]);
+  });
+
+  it("handles trace extensions", () => {
+    const paths = extractArtifactPathsFromArgs({
+      command: "playwright trace /tmp/session.trace",
+    });
+    expect(paths).toEqual(["/tmp/session.trace"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Unit tests for maybeSyntheticToolResult
+// ---------------------------------------------------------------------------
+
+describe("maybeSyntheticToolResult", () => {
+  it("returns null when no artifact paths found", () => {
+    const result = maybeSyntheticToolResult("Bash", { command: "echo hi" }, "item-1", "turn-1");
+    expect(result).toBeNull();
+  });
+
+  it("returns a tool_result event with artifact paths", () => {
+    const result = maybeSyntheticToolResult(
+      "Bash",
+      { command: "screenshot /tmp/proof.png" },
+      "item-1",
+      "turn-1",
+    );
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("tool_result");
+    expect(result).toMatchObject({
+      type: "tool_result",
+      tool: "Bash",
+      itemId: "item-1:synthetic",
+      turnId: "turn-1",
+      status: "completed",
+    });
+    // The result object contains the artifact path
+    expect((result as any).result).toMatchObject({
+      artifactPath0: "/tmp/proof.png",
+    });
+  });
+
+  it("includes multiple artifact paths in the result", () => {
+    const result = maybeSyntheticToolResult(
+      "Bash",
+      { command: "cp /tmp/a.png /tmp/b.mp4" },
+      "item-2",
+      "turn-2",
+    );
+    expect(result).not.toBeNull();
+    const resultObj = (result as any).result;
+    expect(resultObj.artifactPath0).toBe("/tmp/a.png");
+    expect(resultObj.artifactPath1).toBe("/tmp/b.mp4");
+  });
+
+  it("appends :synthetic to the itemId to avoid collisions", () => {
+    const result = maybeSyntheticToolResult(
+      "Read",
+      { file_path: "/tmp/shot.png" },
+      "orig-id",
+      undefined,
+    );
+    expect((result as any).itemId).toBe("orig-id:synthetic");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Integration: synthetic tool_result flows through proof observer
+// ---------------------------------------------------------------------------
+
+describe("proof observer integration with synthetic tool_result", () => {
+  function createHarness() {
+    const requests: ComputerUseArtifactIngestionRequest[] = [];
+    const broker = {
+      ingest: vi.fn((request: ComputerUseArtifactIngestionRequest) => {
+        requests.push(request);
+        return { artifacts: [], links: [] };
+      }),
+    } as any;
+    return {
+      requests,
+      broker,
+      observer: createProofObserver({ broker }),
+    };
+  }
+
+  it("proof observer ingests screenshot from synthetic Bash tool_result", () => {
+    const { observer, requests } = createHarness();
+
+    // Simulate what agentChatService does: build a synthetic tool_result from Bash args
+    const synthetic = maybeSyntheticToolResult(
+      "Bash",
+      { command: "take-screenshot /tmp/proof.png" },
+      "claude-tool:turn1:0",
+      "turn1",
+    );
+    expect(synthetic).not.toBeNull();
+
+    // Feed it to the observer
+    observer.observe(synthetic!, "session-1");
+
+    expect(requests).toHaveLength(1);
+    expect(requests[0]?.inputs).toEqual([
+      expect.objectContaining({
+        kind: "screenshot",
+        path: "/tmp/proof.png",
+      }),
+    ]);
+  });
+
+  it("proof observer ingests video from synthetic tool_result", () => {
+    const { observer, requests } = createHarness();
+
+    const synthetic = maybeSyntheticToolResult(
+      "Bash",
+      { command: "record /tmp/test.mp4" },
+      "claude-tool:turn1:1",
+      "turn1",
+    );
+    expect(synthetic).not.toBeNull();
+
+    observer.observe(synthetic!, "session-1");
+
+    expect(requests).toHaveLength(1);
+    expect(requests[0]?.inputs).toEqual([
+      expect.objectContaining({
+        kind: "video_recording",
+        path: "/tmp/test.mp4",
+      }),
+    ]);
+  });
+
+  it("proof observer ingests trace from synthetic tool_result", () => {
+    const { observer, requests } = createHarness();
+
+    const synthetic = maybeSyntheticToolResult(
+      "Bash",
+      { command: "playwright trace save /tmp/session-trace.zip" },
+      "claude-tool:turn1:2",
+      "turn1",
+    );
+    expect(synthetic).not.toBeNull();
+
+    observer.observe(synthetic!, "session-1");
+
+    expect(requests).toHaveLength(1);
+    expect(requests[0]?.inputs).toEqual([
+      expect.objectContaining({
+        kind: "browser_trace",
+        path: "/tmp/session-trace.zip",
+      }),
+    ]);
+  });
+
+  it("proof observer ignores synthetic tool_result with no artifacts", () => {
+    const { observer, requests } = createHarness();
+
+    const synthetic = maybeSyntheticToolResult(
+      "Bash",
+      { command: "echo hello" },
+      "claude-tool:turn1:3",
+      "turn1",
+    );
+    expect(synthetic).toBeNull();
+
+    // No event to observe
+    expect(requests).toHaveLength(0);
+  });
+
+  it("proof observer deduplicates synthetic results by itemId", () => {
+    const { observer, requests } = createHarness();
+
+    const synthetic = maybeSyntheticToolResult(
+      "Bash",
+      { command: "screenshot /tmp/proof.png" },
+      "claude-tool:turn1:0",
+      "turn1",
+    )!;
+
+    observer.observe(synthetic, "session-1");
+    observer.observe(synthetic, "session-1");
+
+    // Only ingested once
+    expect(requests).toHaveLength(1);
+  });
+
+  it("proof observer handles Read tool with image file_path", () => {
+    const { observer, requests } = createHarness();
+
+    const synthetic = maybeSyntheticToolResult(
+      "Read",
+      { file_path: "/Users/dev/screenshots/test.webp" },
+      "claude-tool:turn2:0",
+      "turn2",
+    )!;
+
+    observer.observe(synthetic, "session-1");
+
+    expect(requests).toHaveLength(1);
+    expect(requests[0]?.inputs).toEqual([
+      expect.objectContaining({
+        kind: "screenshot",
+        path: "/Users/dev/screenshots/test.webp",
+      }),
+    ]);
+    expect(requests[0]?.backend).toMatchObject({
+      style: "external_cli",
+      name: "chat-tool",
+      toolName: "Read",
+    });
+  });
+
+  it("proof observer handles MCP tool with artifact in args", () => {
+    const { observer, requests } = createHarness();
+
+    const synthetic = maybeSyntheticToolResult(
+      "mcp__playwright__browser_take_screenshot",
+      { outputPath: "/tmp/playwright-shot.png" },
+      "claude-tool:turn3:0",
+      "turn3",
+    )!;
+
+    observer.observe(synthetic, "session-1");
+
+    expect(requests).toHaveLength(1);
+    expect(requests[0]?.backend).toMatchObject({
+      style: "external_mcp",
+      name: "playwright",
+    });
+    expect(requests[0]?.inputs).toEqual([
+      expect.objectContaining({
+        kind: "screenshot",
+        path: "/tmp/playwright-shot.png",
+      }),
+    ]);
+  });
+});
diff --git a/apps/desktop/src/main/services/computerUse/syntheticToolResult.ts b/apps/desktop/src/main/services/computerUse/syntheticToolResult.ts
new file mode 100644
index 000000000..751974923
--- /dev/null
+++ b/apps/desktop/src/main/services/computerUse/syntheticToolResult.ts
@@ -0,0 +1,112 @@
+/**
+ * Synthetic tool_result generation for the Claude V2 SDK streaming path.
+ *
+ * The Claude V2 SDK executes tools internally and only surfaces `assistant`
+ * messages in the stream — tool results are opaque. The proof observer relies
+ * on `tool_result` events to auto-ingest screenshots and other artifacts into
+ * the proof drawer.
+ *
+ * This module scans tool call *args* for artifact-indicating file paths and
+ * builds a synthetic `tool_result` event that the proof observer can process.
+ */
+
+import path from "node:path";
+import type { AgentChatEvent } from "../../../shared/types/chat";
+
+const ARTIFACT_EXT =
+  "png|jpe?g|webp|gif|bmp|tiff|svg|mp4|webm|mov|avi|mkv|zip|trace|log|txt|ndjson|jsonl";
+
+/** Broad match for POSIX, Windows, and quoted paths ending with known artifact extensions. */
+const ARTIFACT_PATH_RE = new RegExp(
+  [
+    "(?:^|[\\s\"'=:,])(",
+    "(?:\"(?:[^\"\\\\]|\\\\.)+\"|'(?:[^'\\\\]|\\\\.)+'|",
+    "(?:[a-zA-Z]:[\\\\/]|\\\\\\\\|/)[^\\n\\r\\s\"'<>|*?]+|",
+    "(?:/[\\w.~\\-\\[\\] ]+/)+[\\w.~-]+)",
+    `\\.(?:${ARTIFACT_EXT})`,
+    ")(?:\\b|$)",
+  ].join(""),
+  "gi",
+);
+
+function stripQuotes(raw: string): string {
+  const t = raw.trim();
+  if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+    return t.slice(1, -1).replace(/\\(.)/g, "$1");
+  }
+  return t;
+}
+
+function isAbsoluteArtifactPath(candidate: string): boolean {
+  const p = stripQuotes(candidate).trim();
+  if (!p.length) return false;
+  if (path.posix.isAbsolute(p)) return true;
+  if (path.win32.isAbsolute(p)) return true;
+  return /^\\\\/.test(p);
+}
+
+/**
+ * Extract file paths that look like artifacts from an arbitrary args value.
+ * Returns an array of unique absolute paths found.
+ */
+export function extractArtifactPathsFromArgs(args: unknown): string[] {
+  const paths = new Set<string>();
+
+  function scan(value: unknown, depth: number): void {
+    if (depth > 8) return;
+    if (typeof value === "string") {
+      ARTIFACT_PATH_RE.lastIndex = 0;
+      let match: RegExpExecArray | null;
+      while ((match = ARTIFACT_PATH_RE.exec(value)) !== null) {
+        const raw = match[1]?.trim();
+        if (!raw) continue;
+        const p = stripQuotes(raw);
+        if (isAbsoluteArtifactPath(p)) paths.add(p);
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) scan(item, depth + 1);
+      return;
+    }
+    if (value != null && typeof value === "object") {
+      for (const v of Object.values(value as Record<string, unknown>)) {
+        scan(v, depth + 1);
+      }
+    }
+  }
+
+  scan(args, 0);
+  return Array.from(paths);
+}
+
+/**
+ * Build a synthetic `tool_result` AgentChatEvent from tool call args.
+ * Returns null if no artifact paths are found in the args.
+ */
+export function maybeSyntheticToolResult(
+  toolName: string,
+  args: unknown,
+  itemId: string,
+  turnId: string | undefined,
+): AgentChatEvent | null {
+  const artifactPaths = extractArtifactPathsFromArgs(args);
+  if (artifactPaths.length === 0) return null;
+
+  // Build a result object that the proof observer's scanners will pick up.
+  // Use a structure with named fields so the observer can infer kind from
+  // both the field name and the file extension.
+  const result: Record<string, string> = {};
+  for (let i = 0; i < artifactPaths.length; i++) {
+    result[`artifactPath${i}`] = artifactPaths[i];
+  }
+
+  return {
+    type: "tool_result",
+    tool: toolName,
+    result,
+    itemId: `${itemId}:synthetic`,
+    turnId,
+    status: "completed",
+  };
+}
diff --git a/apps/desktop/src/main/services/conflicts/conflictService.ts b/apps/desktop/src/main/services/conflicts/conflictService.ts
index 889035853..0b990e9ec 100644
--- a/apps/desktop/src/main/services/conflicts/conflictService.ts
+++ b/apps/desktop/src/main/services/conflicts/conflictService.ts
@@ -4350,12 +4350,16 @@ export function createConflictService({
       }
     }
 
-    // Emit rebase-needs-updated so renderer gets notified
+    // Deduplicate: when a lane has both a lane-base need and a PR-target need,
+    // keep only the PR-target need (PR target is the source of truth).
+    const laneIdsWithPrNeeds = new Set(needs.filter(n => n.prId != null).map(n => n.laneId));
+    const deduplicated = needs.filter(n => !(n.prId == null && laneIdsWithPrNeeds.has(n.laneId)));
+
     if (onEvent) {
-      onEvent({ type: "rebase-needs-updated", needs, timestamp: new Date().toISOString() });
+      onEvent({ type: "rebase-needs-updated", needs: deduplicated, timestamp: new Date().toISOString() });
     }
 
-    return needs;
+    return deduplicated;
   };
 
   const getRebaseNeed = async (laneId: string): Promise<RebaseNeed | null> => {
diff --git a/apps/desktop/src/main/services/git/gitOperationsService.ts b/apps/desktop/src/main/services/git/gitOperationsService.ts
index dcc7e82b2..f9bd2dda5 100644
--- a/apps/desktop/src/main/services/git/gitOperationsService.ts
+++ b/apps/desktop/src/main/services/git/gitOperationsService.ts
@@ -608,6 +608,10 @@ export function createGitOperationsService({
       } else if (normalizedBehind > 0 && normalizedAhead === 0) {
         recommendedAction = "pull";
       } else if (diverged) {
+        // True divergence (ahead>0 and behind>0) means the remote has commits not
+        // in HEAD, so upstream cannot be a strict ancestor of HEAD; merge-base
+        // --is-ancestor upstream HEAD is therefore never satisfied here. Default
+        // to a non-destructive merge/rebase via pull.
         recommendedAction = "pull";
       }
 
diff --git a/apps/desktop/src/main/services/ipc/registerIpc.ts b/apps/desktop/src/main/services/ipc/registerIpc.ts
index 1aace2a6f..1b213a3f9 100644
--- a/apps/desktop/src/main/services/ipc/registerIpc.ts
+++ b/apps/desktop/src/main/services/ipc/registerIpc.ts
@@ -551,6 +551,7 @@ import type { createSyncService } from "../sync/syncService";
 import type { AdeProjectService } from "../projects/adeProjectService";
 import type { ConfigReloadService } from "../projects/configReloadService";
 import { getErrorMessage, isRecord, nowIso, resolvePathWithinRoot, toMemoryEntryDto } from "../shared/utils";
+import { resolveAdeLayout } from "../../../shared/adeLayout";
 
 export type AppContext = {
   db: AdeDb;
@@ -1665,6 +1666,28 @@ export function registerIpc({
     shell.showItemInFolder(normalized);
   });
 
+  ipcMain.handle(IPC.appOpenPath, async (_event, arg: { path: string }): Promise<void> => {
+    const raw = typeof arg?.path === "string" ? arg.path.trim() : "";
+    if (!raw) return;
+    const normalized = path.resolve(raw);
+    const allowedDirs = getAllowedDirs(getCtx);
+    const allowed = allowedDirs.some((dir) => {
+      try {
+        resolvePathWithinRoot(dir, normalized);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (!allowed) {
+      throw new Error("Path is outside allowed directories.");
+    }
+    const errorMessage = await shell.openPath(normalized);
+    if (errorMessage) {
+      throw new Error(`Failed to open path: ${errorMessage}`);
+    }
+  });
+
   ipcMain.handle(IPC.appWriteClipboardText, async (_event, arg: { text: string }): Promise<void> => {
     const text = typeof arg?.text === "string" ? arg.text : "";
     clipboard.writeText(text);
@@ -3902,6 +3925,51 @@ export function registerIpc({
     return ctx.computerUseArtifactBrokerService.updateArtifactReview(arg);
   });
 
+  ipcMain.handle(IPC.computerUseReadArtifactPreview, async (_event, arg: { uri: string }): Promise<string | null> => {
+    const ctx = getCtx();
+    const projectRoot = ctx.project.rootPath;
+    const layout = resolveAdeLayout(projectRoot);
+    // Only allow files under artifactsDir — consistent with the ade-artifact:// protocol
+    // handler in main.ts which validates exclusively against currentArtifactsDir.
+    const allowedRoots = [layout.artifactsDir];
+
+    let filePath = arg.uri;
+    if (filePath.startsWith("file://")) {
+      const { fileURLToPath } = await import("node:url");
+      try { filePath = fileURLToPath(filePath); } catch { filePath = decodeURIComponent(filePath.replace(/^file:\/\//i, "")); }
+    }
+    if (!path.isAbsolute(filePath)) {
+      filePath = path.resolve(projectRoot, filePath);
+    }
+    // Canonicalize and verify the resolved path is inside an allowed artifact root.
+    const canonical = path.normalize(path.resolve(filePath));
+    const inside = allowedRoots.some((root) => {
+      try {
+        resolvePathWithinRoot(root, canonical);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (!inside) return null;
+
+    // Cap preview size to 10 MB to avoid loading arbitrarily large files into memory.
+    const PREVIEW_SIZE_CAP = 10 * 1024 * 1024;
+    try {
+      const stat = await fs.promises.stat(canonical);
+      if (!stat.isFile()) return null;
+      if (stat.size > PREVIEW_SIZE_CAP) return null;
+      const buf = await fs.promises.readFile(canonical);
+      const ext = path.extname(canonical).replace(/^\./, "").toLowerCase();
+      const mimeMap: Record<string, string> = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", webp: "image/webp", gif: "image/gif", bmp: "image/bmp", svg: "image/svg+xml" };
+      const mime = mimeMap[ext];
+      if (!mime) return null;
+      return `data:${mime};base64,${buf.toString("base64")}`;
+    } catch {
+      return null;
+    }
+  });
+
   ipcMain.handle(IPC.ptyCreate, async (_event, arg: PtyCreateArgs): Promise<PtyCreateResult> => {
     const ctx = getCtx();
     return await ctx.ptyService.create(arg);
diff --git a/apps/desktop/src/main/services/lanes/laneLaunchContext.test.ts b/apps/desktop/src/main/services/lanes/laneLaunchContext.test.ts
new file mode 100644
index 000000000..9f631de0b
--- /dev/null
+++ b/apps/desktop/src/main/services/lanes/laneLaunchContext.test.ts
@@ -0,0 +1,322 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Hoisted mocks
+// ---------------------------------------------------------------------------
+
+const mocks = vi.hoisted(() => ({
+  statSync: vi.fn(),
+  realpathSync: vi.fn(),
+  resolvePathWithinRoot: vi.fn(),
+}));
+
+vi.mock("node:fs", () => ({
+  default: {
+    statSync: mocks.statSync,
+    realpathSync: mocks.realpathSync,
+  },
+  statSync: mocks.statSync,
+  realpathSync: mocks.realpathSync,
+}));
+
+vi.mock("../shared/utils", () => ({
+  resolvePathWithinRoot: mocks.resolvePathWithinRoot,
+}));
+
+// ---------------------------------------------------------------------------
+// Import the module under test AFTER mocks are set up
+// ---------------------------------------------------------------------------
+
+import { resolveLaneLaunchContext } from "./laneLaunchContext";
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+function makeLaneService(worktreePath: string) {
+  return {
+    getLaneBaseAndBranch: vi.fn(() => ({
+      baseRef: "main",
+      branchRef: "feature/test",
+      worktreePath,
+      laneType: "standard" as const,
+    })),
+  } as unknown as Parameters<typeof resolveLaneLaunchContext>[0]["laneService"];
+}
+
+function setupDirectoryExists(realPath: string) {
+  mocks.statSync.mockReturnValue({ isDirectory: () => true });
+  mocks.realpathSync.mockReturnValue(realPath);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("resolveLaneLaunchContext", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("happy path: no custom cwd", () => {
+    it("returns lane root as both laneWorktreePath and cwd", () => {
+      setupDirectoryExists("/real/lane/root");
+
+      const result = resolveLaneLaunchContext({
+        laneService: makeLaneService("/projects/my-lane"),
+        laneId: "lane-1",
+        purpose: "start agent",
+      });
+
+      expect(result).toEqual({
+        laneWorktreePath: "/real/lane/root",
+        cwd: "/real/lane/root",
+      });
+    });
+
+    it("treats null requestedCwd the same as no cwd", () => {
+      setupDirectoryExists("/real/lane/root");
+
+      const result = resolveLaneLaunchContext({
+        laneService: makeLaneService("/projects/my-lane"),
+        laneId: "lane-1",
+        requestedCwd: null,
+        purpose: "start agent",
+      });
+
+      expect(result).toEqual({
+        laneWorktreePath: "/real/lane/root",
+        cwd: "/real/lane/root",
+      });
+    });
+
+    it("treats empty-string requestedCwd the same as no cwd", () => {
+      setupDirectoryExists("/real/lane/root");
+
+      const result = resolveLaneLaunchContext({
+        laneService: makeLaneService("/projects/my-lane"),
+        laneId: "lane-1",
+        requestedCwd: "  ",
+        purpose: "start agent",
+      });
+
+      expect(result).toEqual({
+        laneWorktreePath: "/real/lane/root",
+        cwd: "/real/lane/root",
+      });
+    });
+  });
+
+  describe("happy path: valid relative cwd inside worktree", () => {
+    it("resolves relative cwd within lane root", () => {
+      mocks.statSync.mockReturnValue({ isDirectory: () => true });
+      mocks.realpathSync
+        .mockReturnValueOnce("/real/lane/root")       // first ensureDirectoryExists (lane root)
+        .mockReturnValueOnce("/real/lane/root/src");   // second ensureDirectoryExists (cwd)
+      mocks.resolvePathWithinRoot.mockReturnValue("/real/lane/root/src");
+
+      const result = resolveLaneLaunchContext({
+        laneService: makeLaneService("/projects/my-lane"),
+        laneId: "lane-1",
+        requestedCwd: "src",
+        purpose: "start agent",
+      });
+
+      expect(result).toEqual({
+        laneWorktreePath: "/real/lane/root",
+        cwd: "/real/lane/root/src",
+      });
+      expect(mocks.resolvePathWithinRoot).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe("happy path: valid absolute cwd inside worktree", () => {
+    it("resolves absolute cwd within lane root", () => {
+      mocks.statSync.mockReturnValue({ isDirectory: () => true });
+      mocks.realpathSync
+        .mockReturnValueOnce("/real/lane/root")                // first ensureDirectoryExists (lane root)
+        .mockReturnValueOnce("/real/lane/root/packages/core"); // second ensureDirectoryExists (cwd)
+      mocks.resolvePathWithinRoot.mockReturnValue("/real/lane/root/packages/core");
+
+      const result = resolveLaneLaunchContext({
+        laneService: makeLaneService("/projects/my-lane"),
+        laneId: "lane-1",
+        requestedCwd: "/real/lane/root/packages/core",
+        purpose: "start agent",
+      });
+
+      expect(result).toEqual({
+        laneWorktreePath: "/real/lane/root",
+        cwd: "/real/lane/root/packages/core",
+      });
+      expect(mocks.resolvePathWithinRoot).toHaveBeenCalledWith(
+        "/real/lane/root",
+        "/real/lane/root/packages/core",
+      );
+    });
+  });
+
+  describe("error: lane has no worktree configured", () => {
+    it("throws when worktreePath is empty string", () => {
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService(""),
+          laneId: "lane-orphan",
+          purpose: "launch terminal",
+        }),
+      ).toThrow("Lane 'lane-orphan' has no worktree configured");
+    });
+
+    it("throws when worktreePath is whitespace-only", () => {
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService("   "),
+          laneId: "lane-ws",
+          purpose: "launch terminal",
+        }),
+      ).toThrow("Lane 'lane-ws' has no worktree configured");
+    });
+
+    it("includes the purpose in the error message", () => {
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService(""),
+          laneId: "lane-1",
+          purpose: "run tests",
+        }),
+      ).toThrow("ADE cannot run tests outside the selected lane");
+    });
+  });
+
+  describe("error: lane worktree directory doesn't exist", () => {
+    it("throws when statSync fails (directory missing)", () => {
+      mocks.statSync.mockImplementation(() => {
+        throw new Error("ENOENT");
+      });
+
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService("/gone/lane"),
+          laneId: "lane-gone",
+          purpose: "deploy",
+        }),
+      ).toThrow("worktree is unavailable");
+    });
+
+    it("throws when path is not a directory", () => {
+      mocks.statSync.mockReturnValue({ isDirectory: () => false });
+
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService("/some/file.txt"),
+          laneId: "lane-file",
+          purpose: "build",
+        }),
+      ).toThrow("worktree is unavailable");
+    });
+
+    it("throws when realpathSync fails after stat succeeds", () => {
+      mocks.statSync.mockReturnValue({ isDirectory: () => true });
+      mocks.realpathSync.mockImplementation(() => {
+        throw new Error("EACCES");
+      });
+
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService("/broken/symlink"),
+          laneId: "lane-broken",
+          purpose: "launch agent",
+        }),
+      ).toThrow("worktree is unavailable");
+    });
+  });
+
+  describe("error: requested cwd escapes lane root (path traversal)", () => {
+    it("throws with descriptive message when resolvePathWithinRoot detects traversal", () => {
+      setupDirectoryExists("/real/lane/root");
+      mocks.resolvePathWithinRoot.mockImplementation(() => {
+        throw new Error("Path escapes root");
+      });
+
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService("/projects/my-lane"),
+          laneId: "lane-1",
+          requestedCwd: "../../etc/passwd",
+          purpose: "start agent",
+        }),
+      ).toThrow("escapes lane 'lane-1'");
+    });
+
+    it("re-throws non-traversal errors from resolvePathWithinRoot", () => {
+      setupDirectoryExists("/real/lane/root");
+      mocks.resolvePathWithinRoot.mockImplementation(() => {
+        throw new Error("Permission denied");
+      });
+
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService("/projects/my-lane"),
+          laneId: "lane-1",
+          requestedCwd: "src",
+          purpose: "start agent",
+        }),
+      ).toThrow("Permission denied");
+    });
+  });
+
+  describe("error: requested cwd doesn't exist inside worktree", () => {
+    it("throws when cwd directory does not exist after path validation", () => {
+      // First ensureDirectoryExists (for lane root) succeeds
+      setupDirectoryExists("/real/lane/root");
+      mocks.resolvePathWithinRoot.mockReturnValue("/real/lane/root/nonexistent");
+
+      // Second ensureDirectoryExists (for resolved cwd) fails
+      let callCount = 0;
+      mocks.statSync.mockImplementation(() => {
+        callCount++;
+        if (callCount <= 1) {
+          // First call: lane root check succeeds
+          return { isDirectory: () => true };
+        }
+        // Second call: cwd check fails
+        throw new Error("ENOENT");
+      });
+
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService("/projects/my-lane"),
+          laneId: "lane-1",
+          requestedCwd: "nonexistent",
+          purpose: "start agent",
+        }),
+      ).toThrow("is not an existing directory inside lane");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("trims laneId whitespace", () => {
+      setupDirectoryExists("/real/lane/root");
+
+      const laneService = makeLaneService("/projects/my-lane");
+      resolveLaneLaunchContext({
+        laneService,
+        laneId: "  lane-1  ",
+        purpose: "test",
+      });
+
+      // Verify getLaneBaseAndBranch was called with the trimmed laneId
+      expect(laneService.getLaneBaseAndBranch).toHaveBeenCalledWith("lane-1");
+    });
+
+    it("uses 'launch work' as default purpose when purpose is empty", () => {
+      expect(() =>
+        resolveLaneLaunchContext({
+          laneService: makeLaneService(""),
+          laneId: "lane-1",
+          purpose: "",
+        }),
+      ).toThrow("ADE cannot launch work outside the selected lane");
+    });
+  });
+});
diff --git a/apps/desktop/src/main/services/lanes/laneService.test.ts b/apps/desktop/src/main/services/lanes/laneService.test.ts
index 49db42281..d6fe465b1 100644
--- a/apps/desktop/src/main/services/lanes/laneService.test.ts
+++ b/apps/desktop/src/main/services/lanes/laneService.test.ts
@@ -515,6 +515,235 @@ describe("laneService create", () => {
   });
 });
 
+describe("laneService importBranch", () => {
+  beforeEach(() => {
+    vi.mocked(getHeadSha).mockReset();
+    vi.mocked(runGit).mockReset();
+    vi.mocked(runGitOrThrow).mockReset();
+  });
+
+  it("imports a branch from an explicit non-origin remote", async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-lane-service-import-upstream-"));
+    const db = await openKvDb(path.join(repoRoot, "kv.sqlite"), createLogger());
+    await seedProjectAndStack(db, { projectId: "proj-import-upstream", repoRoot });
+
+    vi.mocked(runGitOrThrow).mockImplementation(async (args: string[]) => {
+      if (args[0] === "branch" && args[1] === "--track") {
+        expect(args).toEqual(["branch", "--track", "feature/import", "upstream/feature/import"]);
+        return { exitCode: 0, stdout: "", stderr: "" } as any;
+      }
+      if (args[0] === "worktree" && args[1] === "add") {
+        expect(args[2]).toContain(path.join("worktrees", "imported-lane-"));
+        expect(args[3]).toBe("feature/import");
+        return { exitCode: 0, stdout: "", stderr: "" } as any;
+      }
+      throw new Error(`Unexpected git call: ${args.join(" ")}`);
+    });
+
+    vi.mocked(runGit).mockImplementation(async (args: string[]) => {
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/heads/upstream/feature/import") {
+        return { exitCode: 1, stdout: "", stderr: "" };
+      }
+      if (args[0] === "fetch" && args[1] === "--prune" && args[2] === "--all") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/remotes/upstream/feature/import") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/heads/feature/import") {
+        return { exitCode: 1, stdout: "", stderr: "" };
+      }
+      if (args[0] === "status" && args[1] === "--porcelain=v1") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "rev-list" && args[1] === "--left-right" && args[2] === "--count") {
+        return { exitCode: 0, stdout: "0\t0\n", stderr: "" };
+      }
+      if (args[0] === "rev-parse" && args[1] === "--abbrev-ref" && args[2] === "--symbolic-full-name" && args[3] === "@{upstream}") {
+        return { exitCode: 0, stdout: "upstream/feature/import\n", stderr: "" };
+      }
+      if (args[0] === "rev-list" && args[1] === "HEAD..@{upstream}" && args[2] === "--count") {
+        return { exitCode: 0, stdout: "0\n", stderr: "" };
+      }
+      if (args[0] === "rev-parse" && args[1] === "--path-format=absolute" && args[2] === "--git-dir") {
+        return { exitCode: 1, stdout: "", stderr: "fatal: no git dir" };
+      }
+      throw new Error(`Unexpected git call: ${args.join(" ")}`);
+    });
+
+    const service = createLaneService({
+      db,
+      projectRoot: repoRoot,
+      projectId: "proj-import-upstream",
+      defaultBaseRef: "main",
+      worktreesDir: path.join(repoRoot, "worktrees"),
+    });
+
+    const result = await service.importBranch({ branchRef: "upstream/feature/import", name: "Imported lane" });
+
+    expect(result.branchRef).toBe("feature/import");
+    expect(result.baseRef).toBe("main");
+    expect(result.parentLaneId).toBe("lane-main");
+    expect(runGitOrThrow).toHaveBeenCalledWith(
+      ["branch", "--track", "feature/import", "upstream/feature/import"],
+      expect.objectContaining({ cwd: repoRoot }),
+    );
+  });
+
+  it("rejects duplicate imported branches before creating a local tracking branch", async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-lane-service-import-duplicate-"));
+    const db = await openKvDb(path.join(repoRoot, "kv.sqlite"), createLogger());
+    await seedProjectAndStack(db, { projectId: "proj-import-duplicate", repoRoot });
+    const now = "2026-03-11T12:05:00.000Z";
+    db.run(
+      `
+        insert into lanes(
+          id, project_id, name, description, lane_type, base_ref, branch_ref, worktree_path,
+          attached_root_path, is_edit_protected, parent_lane_id, color, icon, tags_json, status, created_at, archived_at
+        ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      ["lane-existing-import", "proj-import-duplicate", "Existing import", null, "worktree", "main", "feature/existing", path.join(repoRoot, "existing"), null, 0, "lane-main", null, null, null, "active", now, null],
+    );
+
+    vi.mocked(runGit).mockImplementation(async (args: string[]) => {
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/heads/origin/feature/existing") {
+        return { exitCode: 1, stdout: "", stderr: "" };
+      }
+      if (args[0] === "fetch" && args[1] === "--prune" && args[2] === "--all") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/remotes/origin/feature/existing") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/heads/feature/existing") {
+        return { exitCode: 1, stdout: "", stderr: "" };
+      }
+      throw new Error(`Unexpected git call: ${args.join(" ")}`);
+    });
+
+    const service = createLaneService({
+      db,
+      projectRoot: repoRoot,
+      projectId: "proj-import-duplicate",
+      defaultBaseRef: "main",
+      worktreesDir: path.join(repoRoot, "worktrees"),
+    });
+
+    await expect(service.importBranch({ branchRef: "origin/feature/existing" })).rejects.toThrow(
+      "Lane already exists for branch 'feature/existing'",
+    );
+    expect(vi.mocked(runGitOrThrow).mock.calls.some(([args]) => args[0] === "branch" && args[1] === "--track")).toBe(false);
+  });
+
+  it("reuses an existing local branch when importing a remote-qualified ref", async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-lane-service-import-local-existing-"));
+    const db = await openKvDb(path.join(repoRoot, "kv.sqlite"), createLogger());
+    await seedProjectAndStack(db, { projectId: "proj-import-local-existing", repoRoot });
+
+    vi.mocked(runGit).mockImplementation(async (args: string[]) => {
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/heads/origin/feature/existing-local") {
+        return { exitCode: 1, stdout: "", stderr: "" };
+      }
+      if (args[0] === "fetch" && args[1] === "--prune" && args[2] === "--all") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/remotes/origin/feature/existing-local") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/heads/feature/existing-local") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "status" && args[1] === "--porcelain=v1") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "rev-list" && args[1] === "--left-right" && args[2] === "--count") {
+        return { exitCode: 0, stdout: "0\t0\n", stderr: "" };
+      }
+      if (args[0] === "rev-parse" && args[1] === "--abbrev-ref" && args[2] === "--symbolic-full-name" && args[3] === "@{upstream}") {
+        return { exitCode: 0, stdout: "origin/feature/existing-local\n", stderr: "" };
+      }
+      if (args[0] === "rev-list" && args[1] === "HEAD..@{upstream}" && args[2] === "--count") {
+        return { exitCode: 0, stdout: "0\n", stderr: "" };
+      }
+      if (args[0] === "rev-parse" && args[1] === "--path-format=absolute" && args[2] === "--git-dir") {
+        return { exitCode: 1, stdout: "", stderr: "fatal: no git dir" };
+      }
+      throw new Error(`Unexpected git call: ${args.join(" ")}`);
+    });
+
+    vi.mocked(runGitOrThrow).mockImplementation(async (args: string[]) => {
+      if (args[0] === "worktree" && args[1] === "add") {
+        expect(args[3]).toBe("feature/existing-local");
+        return { exitCode: 0, stdout: "", stderr: "" } as any;
+      }
+      throw new Error(`Unexpected git call: ${args.join(" ")}`);
+    });
+
+    const service = createLaneService({
+      db,
+      projectRoot: repoRoot,
+      projectId: "proj-import-local-existing",
+      defaultBaseRef: "main",
+      worktreesDir: path.join(repoRoot, "worktrees"),
+    });
+
+    const result = await service.importBranch({ branchRef: "origin/feature/existing-local" });
+
+    expect(result.branchRef).toBe("feature/existing-local");
+    expect(vi.mocked(runGitOrThrow).mock.calls.some(([args]) => args[0] === "branch" && args[1] === "--track")).toBe(false);
+  });
+
+  it("removes a created tracking branch when worktree setup fails during import", async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-lane-service-import-cleanup-"));
+    const db = await openKvDb(path.join(repoRoot, "kv.sqlite"), createLogger());
+    await seedProjectAndStack(db, { projectId: "proj-import-cleanup", repoRoot });
+
+    vi.mocked(runGit).mockImplementation(async (args: string[]) => {
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/heads/origin/feature/broken") {
+        return { exitCode: 1, stdout: "", stderr: "" };
+      }
+      if (args[0] === "fetch" && args[1] === "--prune" && args[2] === "--all") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/remotes/origin/feature/broken") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+      }
+      if (args[0] === "show-ref" && args[1] === "--verify" && args[3] === "refs/heads/feature/broken") {
+        return { exitCode: 1, stdout: "", stderr: "" };
+      }
+      throw new Error(`Unexpected git call: ${args.join(" ")}`);
+    });
+
+    vi.mocked(runGitOrThrow).mockImplementation(async (args: string[]) => {
+      if (args[0] === "branch" && args[1] === "--track") {
+        return { exitCode: 0, stdout: "", stderr: "" } as any;
+      }
+      if (args[0] === "worktree" && args[1] === "add") {
+        throw new Error("worktree add failed");
+      }
+      if (args[0] === "branch" && args[1] === "-D") {
+        expect(args[2]).toBe("feature/broken");
+        return { exitCode: 0, stdout: "", stderr: "" } as any;
+      }
+      throw new Error(`Unexpected git call: ${args.join(" ")}`);
+    });
+
+    const service = createLaneService({
+      db,
+      projectRoot: repoRoot,
+      projectId: "proj-import-cleanup",
+      defaultBaseRef: "main",
+      worktreesDir: path.join(repoRoot, "worktrees"),
+    });
+
+    await expect(service.importBranch({ branchRef: "origin/feature/broken" })).rejects.toThrow("worktree add failed");
+    expect(runGitOrThrow).toHaveBeenCalledWith(
+      ["branch", "-D", "feature/broken"],
+      expect.objectContaining({ cwd: repoRoot }),
+    );
+  });
+});
+
 describe("laneService rebaseStart", () => {
   beforeEach(() => {
     vi.mocked(getHeadSha).mockReset();
diff --git a/apps/desktop/src/main/services/lanes/laneService.ts b/apps/desktop/src/main/services/lanes/laneService.ts
index 99bfd8d33..f242be835 100644
--- a/apps/desktop/src/main/services/lanes/laneService.ts
+++ b/apps/desktop/src/main/services/lanes/laneService.ts
@@ -315,6 +315,69 @@ function describeBranchRebaseTarget(branchName: string, label: string): string {
   return label === branchName ? branchName : `${branchName} (${label})`;
 }
 
+function localBranchNameFromRemoteRef(ref: string): string {
+  const normalized = ref.trim();
+  const slashIndex = normalized.indexOf("/");
+  return slashIndex >= 0 ? normalized.slice(slashIndex + 1) : normalized;
+}
+
+async function resolveImportBranchTarget(args: {
+  projectRoot: string;
+  rawRef: string;
+}): Promise<{ localBranchName: string; remoteRef: string }> {
+  const rawRef = args.rawRef.trim();
+
+  // Refresh cached remote refs, but still allow import when the fetch fails and refs are already present locally.
+  await runGit(["fetch", "--prune", "--all"], {
+    cwd: args.projectRoot,
+    timeoutMs: 60_000,
+  }).catch(() => {});
+
+  const directCandidates = new Set<string>();
+  if (rawRef.includes("/")) directCandidates.add(rawRef);
+  directCandidates.add(`origin/${rawRef}`);
+
+  for (const remoteRef of directCandidates) {
+    const remoteExists = await runGit(["show-ref", "--verify", "--quiet", `refs/remotes/${remoteRef}`], {
+      cwd: args.projectRoot,
+      timeoutMs: 8_000,
+    }).then((result) => result.exitCode === 0);
+    if (remoteExists) {
+      return {
+        localBranchName: localBranchNameFromRemoteRef(remoteRef),
+        remoteRef,
+      };
+    }
+  }
+
+  const remoteRefsRes = await runGit(["for-each-ref", "--format=%(refname:short)", "refs/remotes"], {
+    cwd: args.projectRoot,
+    timeoutMs: 15_000,
+  });
+  if (remoteRefsRes.exitCode === 0) {
+    const suffix = `/${rawRef}`;
+    const matches = remoteRefsRes.stdout
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .filter((ref) => !ref.endsWith("/HEAD"))
+      .filter((ref) => ref.endsWith(suffix));
+    if (matches.length === 1) {
+      return {
+        localBranchName: localBranchNameFromRemoteRef(matches[0]!),
+        remoteRef: matches[0]!,
+      };
+    }
+    if (matches.length > 1) {
+      throw new Error(
+        `Branch '${rawRef}' exists on multiple remotes. Import it using an explicit remote ref like '${matches[0]}'.`,
+      );
+    }
+  }
+
+  throw new Error(`Branch '${rawRef}' not found locally or on any remote`);
+}
+
 function computeStackDepth(args: {
   laneId: string;
   rowsById: Map<string, LaneRow>;
@@ -1218,13 +1281,29 @@ export function createLaneService({
       }
     },
 
-    async importBranch(args: { branchRef: string; name?: string; description?: string; parentLaneId?: string | null }): Promise<LaneSummary> {
-      const branchRef = (args.branchRef ?? "").trim();
-      if (!branchRef) throw new Error("branchRef is required");
-      if (branchRef.includes("\0")) throw new Error("Invalid branchRef");
-
-      // Ensure branch exists locally.
-      await runGitOrThrow(["rev-parse", "--verify", branchRef], { cwd: projectRoot, timeoutMs: 12_000 });
+    async importBranch(args: { branchRef: string; name?: string; description?: string; parentLaneId?: string | null; baseBranch?: string }): Promise<LaneSummary> {
+      const rawRef = (args.branchRef ?? "").trim();
+      if (!rawRef) throw new Error("branchRef is required");
+      if (rawRef.includes("\0")) throw new Error("Invalid branchRef");
+
+      let branchRef = rawRef;
+      let remoteRefToTrack: string | null = null;
+      let branchCreated = false;
+      let worktreeAdded = false;
+      let laneInserted = false;
+      let localExists = await runGit(["show-ref", "--verify", "--quiet", `refs/heads/${rawRef}`], {
+        cwd: projectRoot, timeoutMs: 8_000
+      }).then((r) => r.exitCode === 0);
+
+      if (!localExists) {
+        const resolved = await resolveImportBranchTarget({ projectRoot, rawRef });
+        branchRef = resolved.localBranchName;
+        localExists = await runGit(["show-ref", "--verify", "--quiet", `refs/heads/${resolved.localBranchName}`], {
+          cwd: projectRoot,
+          timeoutMs: 8_000,
+        }).then((r) => r.exitCode === 0);
+        remoteRefToTrack = localExists ? null : resolved.remoteRef;
+      }
 
       // Prevent duplicates.
       const existing = db.get<{ id: string }>(
@@ -1242,74 +1321,244 @@ export function createLaneService({
       const suffix = laneId.slice(0, 8);
       const worktreePath = path.join(worktreesDir, `${slug}-${suffix}`);
 
-      // Attaching an existing branch: do NOT create a new branch, just add a worktree checkout.
-      await runGitOrThrow(["worktree", "add", worktreePath, branchRef], {
-        cwd: projectRoot,
-        timeoutMs: 60_000
-      });
+      try {
+        if (remoteRefToTrack) {
+          await runGitOrThrow(["branch", "--track", branchRef, remoteRefToTrack], { cwd: projectRoot, timeoutMs: 15_000 });
+          branchCreated = true;
+        }
 
-      const parentLaneIdRaw = typeof args.parentLaneId === "string" ? args.parentLaneId.trim() : "";
-      let parentLaneId = parentLaneIdRaw.length ? parentLaneIdRaw : null;
-      // Default to primary lane when no parent is specified.
-      if (!parentLaneId) {
-        const primaryRow = getActivePrimaryLane();
-        if (primaryRow?.id) parentLaneId = primaryRow.id;
-      }
-      const parent = parentLaneId ? getLaneRow(parentLaneId) : null;
-      if (parentLaneId && !parent) throw new Error(`Parent lane not found: ${parentLaneId}`);
-      if (parent && parent.status === "archived") throw new Error("Parent lane is archived");
+        // Attaching an existing branch: do NOT create a new branch, just add a worktree checkout.
+        await runGitOrThrow(["worktree", "add", worktreePath, branchRef], {
+          cwd: projectRoot,
+          timeoutMs: 60_000
+        });
+        worktreeAdded = true;
 
-      const baseRef = parent?.branch_ref ?? defaultBaseRef;
+        // --- Detect real parent lane via git merge-base ---
+        const parentLaneIdRaw = typeof args.parentLaneId === "string" ? args.parentLaneId.trim() : "";
+        const explicitParentLaneId = parentLaneIdRaw.length ? parentLaneIdRaw : null;
+        let parentLaneId: string | null = null;
 
-      db.run(
-        `
-          insert into lanes(
-            id, project_id, name, description, lane_type, base_ref, branch_ref, worktree_path,
-            attached_root_path, is_edit_protected, parent_lane_id, color, icon, tags_json, status, created_at, archived_at
-          )
-          values(?, ?, ?, ?, 'worktree', ?, ?, ?, null, 0, ?, null, null, null, 'active', ?, null)
-        `,
-        [laneId, projectId, displayName, args.description ?? null, baseRef, branchRef, worktreePath, parentLaneId, now]
-      );
-      invalidateLaneListCache();
+        // Try to detect the true parent by finding which lane's HEAD shares the
+        // most recent common ancestor with the imported branch.
+        try {
+          const importedHeadSha = await getHeadSha(worktreePath);
+          if (importedHeadSha) {
+            const activeRows = getAllLaneRows(false);
+            let bestLaneId: string | null = null;
+            let bestScore = Infinity;
+            let bestTieBreak: string | null = null;
+
+            for (const row of activeRows) {
+              // Skip the lane we are currently importing (same id won't exist yet,
+              // but skip by branch_ref match just in case).
+              if (row.branch_ref === branchRef) continue;
+
+              const laneWorktree = row.worktree_path;
+              if (!laneWorktree) continue;
+
+              const laneHeadSha = await getHeadSha(laneWorktree);
+              if (!laneHeadSha) continue;
+
+              const mbResult = await runGit(
+                ["merge-base", laneHeadSha, importedHeadSha],
+                { cwd: projectRoot, timeoutMs: 10_000 },
+              );
+              if (mbResult.exitCode !== 0) continue;
+              const mergeBaseSha = mbResult.stdout.trim();
+              if (!mergeBaseSha) continue;
 
-      // Best-effort push to establish upstream if not already tracking a remote
-      try {
-        const upstreamCheck = await runGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], { cwd: worktreePath, timeoutMs: 5_000 });
-        if (upstreamCheck.exitCode !== 0) {
-          await runGit(["push", "-u", "origin", branchRef], { cwd: worktreePath, timeoutMs: 60_000 });
+              const importedCountResult = await runGit(
+                ["rev-list", "--count", `${mergeBaseSha}..${importedHeadSha}`],
+                { cwd: projectRoot, timeoutMs: 10_000 },
+              );
+              if (importedCountResult.exitCode !== 0) continue;
+              const importedDistance = parseInt(importedCountResult.stdout.trim(), 10);
+              if (isNaN(importedDistance)) continue;
+
+              const candidateCountResult = await runGit(
+                ["rev-list", "--count", `${mergeBaseSha}..${laneHeadSha}`],
+                { cwd: projectRoot, timeoutMs: 10_000 },
+              );
+              if (candidateCountResult.exitCode !== 0) continue;
+              const candidateDistance = parseInt(candidateCountResult.stdout.trim(), 10);
+              if (isNaN(candidateDistance)) continue;
+
+              const score = importedDistance + candidateDistance;
+              const tieBreak = `${row.id}\0${row.branch_ref}`;
+              if (
+                score < bestScore
+                || (score === bestScore && tieBreak.localeCompare(bestTieBreak ?? "") < 0)
+              ) {
+                bestScore = score;
+                bestLaneId = row.id;
+                bestTieBreak = tieBreak;
+              }
+            }
+
+            if (bestLaneId) {
+              if (explicitParentLaneId && explicitParentLaneId !== bestLaneId) {
+                console.warn(
+                  `[laneService] importBranch: explicit parentLaneId '${explicitParentLaneId}' differs from ` +
+                  `git-detected parent '${bestLaneId}' — using detected parent`,
+                );
+              }
+              parentLaneId = bestLaneId;
+            }
+          }
+        } catch (err) {
+          console.warn("[laneService] importBranch: merge-base parent detection failed, falling back", err);
         }
-      } catch {
-        // Non-fatal: lane works locally even without remote tracking
-      }
 
-      const row = getLaneRow(laneId);
-      if (!row) throw new Error(`Failed to import lane: ${laneId}`);
-      const rowsById = getRowsById(true);
-      const status = await computeLaneStatus(worktreePath, baseRef, branchRef);
-      const parentStatus = parent ? await computeLaneStatus(parent.worktree_path, parent.base_ref, parent.branch_ref) : null;
+        // Fallback: use explicit parent or primary lane if detection yielded nothing.
+        if (!parentLaneId) {
+          parentLaneId = explicitParentLaneId;
+        }
+        if (!parentLaneId) {
+          // Only auto-assign Primary as parent when the imported branch's base
+          // matches Primary's branch — otherwise the lane is independent and
+          // should rebase directly against its baseRef (e.g. main).
+          const primaryRow = getActivePrimaryLane();
+          if (primaryRow?.id) {
+            const primary = getLaneRow(primaryRow.id);
+            const resolvedBase = args.baseBranch?.trim() || defaultBaseRef;
+            if (primary && normalizeBranchName(primary.branch_ref) === normalizeBranchName(resolvedBase)) {
+              parentLaneId = primaryRow.id;
+            }
+          }
+        }
+
+        const parent = parentLaneId ? getLaneRow(parentLaneId) : null;
+        if (parentLaneId && !parent) throw new Error(`Parent lane not found: ${parentLaneId}`);
+        if (parent && parent.status === "archived") throw new Error("Parent lane is archived");
 
-      if (onHeadChanged) {
+        const baseRef = args.baseBranch?.trim() || defaultBaseRef;
+
+        db.run(
+          `
+            insert into lanes(
+              id, project_id, name, description, lane_type, base_ref, branch_ref, worktree_path,
+              attached_root_path, is_edit_protected, parent_lane_id, color, icon, tags_json, status, created_at, archived_at
+            )
+            values(?, ?, ?, ?, 'worktree', ?, ?, ?, null, 0, ?, null, null, null, 'active', ?, null)
+          `,
+          [laneId, projectId, displayName, args.description ?? null, baseRef, branchRef, worktreePath, parentLaneId, now]
+        );
+        laneInserted = true;
+        invalidateLaneListCache();
+
+        // Best-effort push to establish upstream if not already tracking a remote
         try {
-          const postHeadSha = await getHeadSha(worktreePath);
-          onHeadChanged({
-            laneId,
-            reason: "import_branch",
-            preHeadSha: null,
-            postHeadSha
-          });
+          const upstreamCheck = await runGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], { cwd: worktreePath, timeoutMs: 5_000 });
+          if (upstreamCheck.exitCode !== 0) {
+            await runGit(["push", "-u", "origin", branchRef], { cwd: worktreePath, timeoutMs: 60_000 });
+          }
         } catch {
-          // ignore
+          // Non-fatal: lane works locally even without remote tracking
         }
-      }
 
-      return toLaneSummary({
-        row,
-        status,
-        parentStatus,
-        childCount: 0,
-        stackDepth: computeStackDepth({ laneId, rowsById, memo: new Map() })
-      });
+        const row = getLaneRow(laneId);
+        if (!row) throw new Error(`Failed to import lane: ${laneId}`);
+        const rowsById = getRowsById(true);
+        const status = await computeLaneStatus(worktreePath, baseRef, branchRef);
+        const parentStatus = parent ? await computeLaneStatus(parent.worktree_path, parent.base_ref, parent.branch_ref) : null;
+
+        if (onHeadChanged) {
+          try {
+            const postHeadSha = await getHeadSha(worktreePath);
+            onHeadChanged({
+              laneId,
+              reason: "import_branch",
+              preHeadSha: null,
+              postHeadSha
+            });
+          } catch {
+            // ignore
+          }
+        }
+
+        return toLaneSummary({
+          row,
+          status,
+          parentStatus,
+          childCount: 0,
+          stackDepth: computeStackDepth({ laneId, rowsById, memo: new Map() })
+        });
+      } catch (error) {
+        if (laneInserted) {
+          const persistedRow = getLaneRow(laneId);
+          if (!persistedRow) throw error;
+          const rowsById = getRowsById(true);
+          let status: Awaited<ReturnType<typeof computeLaneStatus>> | null = null;
+          let parentStatus: Awaited<ReturnType<typeof computeLaneStatus>> | null = null;
+          let stackDepth = 0;
+          try {
+            status = await computeLaneStatus(worktreePath, persistedRow.base_ref, branchRef);
+          } catch {
+            status = null;
+          }
+          try {
+            const parent = persistedRow.parent_lane_id ? getLaneRow(persistedRow.parent_lane_id) : null;
+            if (parent) {
+              parentStatus = await computeLaneStatus(parent.worktree_path, parent.base_ref, parent.branch_ref);
+            }
+          } catch {
+            parentStatus = null;
+          }
+          try {
+            stackDepth = computeStackDepth({ laneId, rowsById, memo: new Map() });
+          } catch {
+            stackDepth = 0;
+          }
+          return toLaneSummary({
+            row: persistedRow,
+            status: status ?? { dirty: false, ahead: 0, behind: 0, remoteBehind: -1, rebaseInProgress: false },
+            parentStatus,
+            childCount: 0,
+            stackDepth,
+          });
+        }
+
+        const cleanupErrors: string[] = [];
+        if (worktreeAdded) {
+          try {
+            await runGitOrThrow(["worktree", "remove", "--force", worktreePath], {
+              cwd: projectRoot,
+              timeoutMs: 60_000,
+            });
+          } catch (cleanupError) {
+            try {
+              fs.rmSync(worktreePath, { recursive: true, force: true });
+              // Directory removed but git metadata may be orphaned; prune to clean up
+              try {
+                await runGitOrThrow(["worktree", "prune"], {
+                  cwd: projectRoot,
+                  timeoutMs: 60_000,
+                });
+              } catch (pruneError) {
+                cleanupErrors.push(`worktree prune failed: ${pruneError instanceof Error ? pruneError.message : String(pruneError)}`);
+              }
+            } catch {
+              cleanupErrors.push(`remove worktree failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+          }
+        }
+        if (branchCreated) {
+          try {
+            await runGitOrThrow(["branch", "-D", branchRef], {
+              cwd: projectRoot,
+              timeoutMs: 15_000,
+            });
+          } catch (cleanupError) {
+            cleanupErrors.push(`delete branch failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+          }
+        }
+
+        if (cleanupErrors.length > 0) {
+          throw new Error(`${error instanceof Error ? error.message : String(error)} Cleanup failed: ${cleanupErrors.join(" ")}`);
+        }
+        throw error;
+      }
     },
 
     async getChildren(laneId: string): Promise<LaneSummary[]> {
diff --git a/apps/desktop/src/main/services/lanes/rebaseSuggestionService.ts b/apps/desktop/src/main/services/lanes/rebaseSuggestionService.ts
index 1c872f1d4..06d8257e8 100644
--- a/apps/desktop/src/main/services/lanes/rebaseSuggestionService.ts
+++ b/apps/desktop/src/main/services/lanes/rebaseSuggestionService.ts
@@ -131,34 +131,54 @@ export function createRebaseSuggestionService(args: {
       };
     }
 
-    if (!lane.parentLaneId) return null;
-    const parent = laneById.get(lane.parentLaneId);
-    if (!parent) return null;
-    let parentHeadSha: string | null;
-    if (parent.laneType === "primary") {
-      const parentBranch = parent.branchRef.trim();
-      if (!parentBranch) return null;
-      if (primaryParentHeadByBranch.has(parentBranch)) {
-        parentHeadSha = primaryParentHeadByBranch.get(parentBranch) ?? null;
-      } else {
-        await fetchRemoteTrackingBranch({
-          projectRoot,
-          targetBranch: parentBranch,
-        }).catch(() => {});
-        parentHeadSha = await readRefHeadSha(`origin/${parentBranch}`);
-        if (!parentHeadSha) {
+    if (lane.parentLaneId) {
+      const parent = laneById.get(lane.parentLaneId);
+      if (parent) {
+        let parentHeadSha: string | null;
+        if (parent.laneType === "primary") {
+          const parentBranch = parent.branchRef.trim();
+          if (!parentBranch) return null;
+          if (primaryParentHeadByBranch.has(parentBranch)) {
+            parentHeadSha = primaryParentHeadByBranch.get(parentBranch) ?? null;
+          } else {
+            await fetchRemoteTrackingBranch({
+              projectRoot,
+              targetBranch: parentBranch,
+            }).catch(() => {});
+            parentHeadSha = await readRefHeadSha(`origin/${parentBranch}`);
+            if (!parentHeadSha) {
+              parentHeadSha = await getHeadSha(parent.worktreePath);
+            }
+            primaryParentHeadByBranch.set(parentBranch, parentHeadSha);
+          }
+        } else {
           parentHeadSha = await getHeadSha(parent.worktreePath);
         }
-        primaryParentHeadByBranch.set(parentBranch, parentHeadSha);
+        if (!parentHeadSha) return null;
+        return {
+          parentLaneId: lane.parentLaneId,
+          parentHeadSha,
+          baseLabel: parent.name ?? null,
+          groupContext: null,
+        };
       }
-    } else {
-      parentHeadSha = await getHeadSha(parent.worktreePath);
     }
-    if (!parentHeadSha) return null;
+
+    // No parent lane — fall back to baseRef (e.g. "main" or "origin/main") for parentless imported lanes.
+    const baseRef = lane.baseRef?.trim();
+    if (!baseRef) return null;
+    if (lane.laneType === "primary") return null;
+    const fetchTargetName = baseRef.replace(/^origin\//, "");
+    await fetchRemoteTrackingBranch({ projectRoot, targetBranch: fetchTargetName }).catch(() => {});
+    const comparisonRef = baseRef.startsWith("origin/") ? baseRef : `origin/${fetchTargetName}`;
+    const baseHeadSha =
+      (await readRefHeadSha(comparisonRef))
+      ?? (await readRefHeadSha(fetchTargetName));
+    if (!baseHeadSha) return null;
     return {
-      parentLaneId: lane.parentLaneId,
-      parentHeadSha,
-      baseLabel: parent.name ?? null,
+      parentLaneId: `base:${baseRef}`,
+      parentHeadSha: baseHeadSha,
+      baseLabel: baseRef,
       groupContext: null,
     };
   };
diff --git a/apps/desktop/src/main/services/prs/prRebaseResolver.ts b/apps/desktop/src/main/services/prs/prRebaseResolver.ts
index b248300da..d7006f766 100644
--- a/apps/desktop/src/main/services/prs/prRebaseResolver.ts
+++ b/apps/desktop/src/main/services/prs/prRebaseResolver.ts
@@ -144,6 +144,7 @@ export async function launchRebaseResolutionChat(
     unifiedPermissionMode: mapPermissionMode(args.permissionMode) as import("../../../shared/types").AgentChatUnifiedPermissionMode,
     surface: "work",
     sessionProfile: "workflow",
+    requestedCwd: lane.worktreePath,
   });
 
   deps.sessionService.updateMeta({ sessionId: session.id, title });
diff --git a/apps/desktop/src/main/services/pty/ptyService.test.ts b/apps/desktop/src/main/services/pty/ptyService.test.ts
index 63d327b8b..5df9ecf2e 100644
--- a/apps/desktop/src/main/services/pty/ptyService.test.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.test.ts
@@ -124,7 +124,7 @@ vi.mock("../../utils/terminalSessionSignals", () => ({
   runtimeStateFromOsc133Chunk: mocks.runtimeStateFromOsc133Chunk,
 }));
 
-import { createPtyService } from "./ptyService";
+import { createPtyService, PTY_AI_TITLE_DEBOUNCE_MS } from "./ptyService";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -207,6 +207,7 @@ function createHarness(overrides: {
   const service = createPtyService({
     projectRoot: "/tmp/test-project",
     transcriptsDir: "/tmp/transcripts",
+    chatSessionsDir: "/tmp/chat-sessions",
     laneService: laneService as any,
     sessionService: sessionService as any,
     ...(overrides.aiIntegrationService ? { aiIntegrationService: overrides.aiIntegrationService as any } : {}),
@@ -448,7 +449,7 @@ describe("ptyService", () => {
           getMode: vi.fn(() => "subscription"),
           summarizeTerminal: vi.fn(async () => ({ text: "Bound title" })),
         };
-        const { service, mockPty, laneService } = createHarness({ aiIntegrationService });
+        const { service, mockPty, laneService, sessionService } = createHarness({ aiIntegrationService });
         await service.create({
           laneId: "lane-1",
           cwd: "/tmp/test-worktree/subdir",
@@ -457,6 +458,11 @@ describe("ptyService", () => {
           rows: 24,
           toolType: "claude",
         });
+        // Mark the metadata file as non-existent so readPersistedChatManuallyNamed returns false
+        const createdSessionId = (sessionService.create as ReturnType<typeof vi.fn>).mock.calls[0]?.[0]?.sessionId;
+        if (createdSessionId) {
+          mocks.existsSyncResults.set(`/tmp/chat-sessions/${createdSessionId}.json`, false);
+        }
 
         laneService.getLaneBaseAndBranch.mockReturnValue({
           worktreePath: "/tmp/other-worktree",
@@ -465,7 +471,7 @@ describe("ptyService", () => {
         });
 
         mockPty._emitter.emit("data", "generated enough output for a better title");
-        await vi.advanceTimersByTimeAsync(4000);
+        await vi.advanceTimersByTimeAsync(PTY_AI_TITLE_DEBOUNCE_MS);
 
         expect(aiIntegrationService.summarizeTerminal).toHaveBeenCalledWith(
           expect.objectContaining({ cwd: "/tmp/test-worktree/subdir" }),
@@ -684,7 +690,7 @@ describe("ptyService", () => {
         const { service, mockPty } = createHarness();
         await service.create({ laneId: "lane-1", title: "Claude", cols: 80, rows: 24, toolType: "claude" });
 
-        await vi.advanceTimersByTimeAsync(6000);
+        await vi.advanceTimersByTimeAsync(PTY_AI_TITLE_DEBOUNCE_MS);
         mockPty._emitter.emit("data", "\u001b]133;A\u0007");
         await vi.advanceTimersByTimeAsync(2000);
 
@@ -707,7 +713,7 @@ describe("ptyService", () => {
           toolType: "claude-orchestrated",
         });
 
-        await vi.advanceTimersByTimeAsync(6000);
+        await vi.advanceTimersByTimeAsync(PTY_AI_TITLE_DEBOUNCE_MS);
         mockPty._emitter.emit("data", "\u001b]133;A\u0007");
         await vi.advanceTimersByTimeAsync(1499);
         expect(mockPty.kill).not.toHaveBeenCalled();
diff --git a/apps/desktop/src/main/services/pty/ptyService.ts b/apps/desktop/src/main/services/pty/ptyService.ts
index bddb3ca92..9336cce86 100644
--- a/apps/desktop/src/main/services/pty/ptyService.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.ts
@@ -32,6 +32,25 @@ import {
   runtimeStateFromOsc133Chunk
 } from "../../utils/terminalSessionSignals";
 
+/** Delay before auto-generating a title from CLI output; keep in sync with tests. */
+export const PTY_AI_TITLE_DEBOUNCE_MS = 6000;
+
+function readPersistedChatManuallyNamed(chatSessionsDir: string, sessionId: string): boolean {
+  try {
+    const metadataPath = path.join(chatSessionsDir, `${sessionId}.json`);
+    if (!fs.existsSync(metadataPath)) return false;
+    const raw = fs.readFileSync(metadataPath, "utf8");
+    const parsed = JSON.parse(raw) as { manuallyNamed?: boolean };
+    return parsed.manuallyNamed === true;
+  } catch (err: unknown) {
+    if (err && typeof err === "object" && "code" in err && (err as { code: string }).code === "ENOENT") {
+      return false;
+    }
+    // Non-ENOENT errors (e.g. corrupt JSON, permission issues) — block auto-titling to be safe
+    return true;
+  }
+}
+
 type PtyEntry = {
   pty: IPty;
   laneId: string;
@@ -199,6 +218,7 @@ function enrichStartupCommandForAdeMcp(args: {
 export function createPtyService({
   projectRoot,
   transcriptsDir,
+  chatSessionsDir,
   laneService,
   sessionService,
   aiIntegrationService,
@@ -212,6 +232,7 @@ export function createPtyService({
 }: {
   projectRoot: string;
   transcriptsDir: string;
+  chatSessionsDir: string;
   laneService: ReturnType<typeof createLaneService>;
   sessionService: ReturnType<typeof createSessionService>;
   aiIntegrationService?: ReturnType<typeof createAiIntegrationService>;
@@ -239,6 +260,18 @@ export function createPtyService({
     return ai?.sessionIntelligence;
   };
 
+  const isTitleGenerationEnabled = (): boolean => {
+    const si = getSessionIntelligence();
+    const ai = projectConfigService?.get().effective.ai;
+    return si?.titles?.enabled ?? (ai?.chat as any)?.autoTitleEnabled ?? true;
+  };
+
+  const resolveTitleModelId = (): string | undefined => {
+    const si = getSessionIntelligence();
+    const raw = si?.titles?.modelId;
+    return typeof raw === "string" && raw.trim().length ? raw.trim() : undefined;
+  };
+
   /** Only orchestrated worker sessions auto-close after the wrapped CLI exits back to shell. */
   const TOOL_TYPES_WITH_AUTO_CLOSE = new Set<TerminalToolType>([
     "claude-orchestrated",
@@ -337,33 +370,91 @@ export function createPtyService({
         sessionService.setSummary(sessionId, summary);
 
         const si = getSessionIntelligence();
-        if (si?.summaries?.enabled === false) return;
-        if (!aiIntegrationService || aiIntegrationService.getMode() === "guest") return;
-
-        const prompt = [
-          "You are ADE's terminal summary assistant.",
-          "Rewrite this terminal session into a concise 1-3 sentence summary with outcome and next action.",
-          "Do not invent commands or outcomes.",
-          "",
-          "Deterministic summary:",
-          summary,
-          "",
-          "Terminal transcript tail:",
-          transcript.slice(-18_000)
-        ].join("\n");
-
-        const summaryModelId = typeof si?.summaries?.modelId === "string" && si.summaries.modelId.trim().length
-          ? si.summaries.modelId.trim()
-          : undefined;
-
-        const aiSummary = await aiIntegrationService.summarizeTerminal({
-          cwd: summaryCwd || laneService.getLaneBaseAndBranch(session.laneId).worktreePath,
-          prompt,
-          ...(summaryModelId ? { model: summaryModelId } : {}),
-        });
-        const text = aiSummary.text.trim();
-        if (text.length) {
-          sessionService.setSummary(sessionId, text);
+        const hasAi = Boolean(aiIntegrationService && aiIntegrationService.getMode() !== "guest");
+
+        // AI-enhanced summary (only when summaries are enabled and AI is available)
+        if (si?.summaries?.enabled !== false && hasAi) {
+          try {
+            const prompt = [
+              "You are ADE's terminal summary assistant.",
+              "Rewrite this terminal session into a concise 1-3 sentence summary with outcome and next action.",
+              "Do not invent commands or outcomes.",
+              "",
+              "Deterministic summary:",
+              summary,
+              "",
+              "Terminal transcript tail:",
+              transcript.slice(-18_000)
+            ].join("\n");
+
+            const summaryModelId = typeof si?.summaries?.modelId === "string" && si.summaries.modelId.trim().length
+              ? si.summaries.modelId.trim()
+              : undefined;
+
+            const aiSummary = await aiIntegrationService!.summarizeTerminal({
+              cwd: summaryCwd || laneService.getLaneBaseAndBranch(session.laneId).worktreePath,
+              prompt,
+              ...(summaryModelId ? { model: summaryModelId } : {}),
+            });
+            const text = aiSummary.text.trim();
+            if (text.length) {
+              sessionService.setSummary(sessionId, text);
+            }
+          } catch (err) {
+            logger.warn("pty.ai_summary_failed", {
+              sessionId,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        }
+
+        // Refresh title on complete — runs independently of AI summaries toggle
+        if (hasAi) {
+          const refreshOnComplete = getSessionIntelligence()?.titles?.refreshOnComplete
+            ?? (projectConfigService?.get().effective.ai?.chat as any)?.autoTitleRefreshOnComplete
+            ?? true;
+          if (refreshOnComplete && isTitleGenerationEnabled()) {
+            try {
+              if (readPersistedChatManuallyNamed(chatSessionsDir, sessionId)) {
+                logger.info("pty.session_title_refresh_skipped_user_renamed", { sessionId });
+              } else {
+              const titlePrompt = [
+                "Generate a concise final title for this completed terminal session.",
+                "Return only plain text, max 80 characters, no punctuation at the end.",
+                "",
+                `Session type: ${session.toolType ?? "terminal"}`,
+                `Initial title: ${session.title}`,
+                session.goal ? `Current goal: ${session.goal}` : null,
+                `Exit code: ${session.exitCode ?? "unknown"}`,
+                "",
+                "Terminal transcript tail:",
+                transcript.slice(-2000),
+              ].filter(Boolean).join("\n");
+
+              const titleModelId = resolveTitleModelId();
+              const titleResult = await aiIntegrationService!.summarizeTerminal({
+                cwd: summaryCwd || laneService.getLaneBaseAndBranch(session.laneId).worktreePath,
+                prompt: titlePrompt,
+                timeoutMs: 8_000,
+                ...(titleModelId ? { model: titleModelId } : {}),
+              });
+              const finalTitle = titleResult.text.trim().replace(/\s+/g, " ").slice(0, 80);
+              if (finalTitle) {
+                // Re-check in case user renamed during AI call
+                if (readPersistedChatManuallyNamed(chatSessionsDir, sessionId)) {
+                  logger.info("pty.session_title_refresh_skipped_user_renamed", { sessionId });
+                } else {
+                  sessionService.updateMeta({ sessionId, title: finalTitle });
+                }
+              }
+              }
+            } catch (err) {
+              logger.warn("pty.session_title_refresh_failed", {
+                sessionId,
+                error: err instanceof Error ? err.message : String(err),
+              });
+            }
+          }
         }
       })
       .catch(() => {
@@ -741,7 +832,7 @@ export function createPtyService({
         // Accumulate initial output for session title generation
         if (!titleBufferFull) {
           titleOutputBuffer += data;
-          if (titleOutputBuffer.length >= 500) {
+          if (titleOutputBuffer.length >= 800) {
             titleBufferFull = true;
           }
         }
@@ -770,14 +861,18 @@ export function createPtyService({
         }
       }
 
-      // Fire-and-forget: after 4s, attempt AI title generation for non-shell sessions
-      if (aiIntegrationService && aiIntegrationService.getMode() === "subscription") {
+      // Fire-and-forget: after 6s, attempt AI title generation for non-shell sessions
+      if (aiIntegrationService && aiIntegrationService.getMode() !== "guest") {
         const capturedAi = aiIntegrationService;
         setTimeout(() => {
           if (entry.disposed) return;
 
-          const si = getSessionIntelligence();
-          if (si?.titles?.enabled === false) return;
+          if (!isTitleGenerationEnabled()) return;
+
+          if (readPersistedChatManuallyNamed(chatSessionsDir, sessionId)) {
+            logger.info("pty.session_title_skipped_user_renamed", { sessionId });
+            return;
+          }
 
           const strippedOutput = stripAnsi(titleOutputBuffer).trim();
           if (strippedOutput.length < 10) return;
@@ -793,13 +888,10 @@ export function createPtyService({
             "Return only plain text, max 80 characters, no punctuation at the end.",
             "",
             "Initial output:",
-            strippedOutput.slice(0, 500)
+            strippedOutput.slice(0, 800)
           ].join("\n");
 
-          const titleModelId = typeof si?.titles?.modelId === "string" && si.titles.modelId.trim().length
-            ? si.titles.modelId.trim()
-            : undefined;
-
+          const titleModelId = resolveTitleModelId();
           capturedAi
             .summarizeTerminal({
               cwd: entry.boundCwd || entry.laneWorktreePath,
@@ -810,7 +902,12 @@ export function createPtyService({
             .then((result) => {
               const title = result.text.trim().replace(/\s+/g, " ").slice(0, 80);
               if (title) {
-                sessionService.updateMeta({ sessionId, goal: title });
+                // Re-check in case user renamed during AI call
+                if (readPersistedChatManuallyNamed(chatSessionsDir, sessionId)) {
+                  logger.info("pty.session_title_skipped_user_renamed", { sessionId });
+                } else {
+                  sessionService.updateMeta({ sessionId, title });
+                }
               }
             })
             .catch((err) => {
@@ -819,7 +916,7 @@ export function createPtyService({
                 error: err instanceof Error ? err.message : String(err)
               });
             });
-        }, 4000);
+        }, PTY_AI_TITLE_DEBOUNCE_MS);
       }
 
       logger.info("pty.create", { ptyId, sessionId, laneId, cwd, shell: selectedShell?.file ?? "unknown" });
diff --git a/apps/desktop/src/main/services/sync/syncRemoteCommandService.ts b/apps/desktop/src/main/services/sync/syncRemoteCommandService.ts
index bbe87f620..fca0f150c 100644
--- a/apps/desktop/src/main/services/sync/syncRemoteCommandService.ts
+++ b/apps/desktop/src/main/services/sync/syncRemoteCommandService.ts
@@ -384,6 +384,7 @@ function parseAgentChatUpdateSessionArgs(value: Record<string, unknown>): AgentC
   if ("codexConfigSource" in value) parsed.codexConfigSource = value.codexConfigSource == null ? undefined : asTrimmedString(value.codexConfigSource) as AgentChatUpdateSessionArgs["codexConfigSource"];
   if ("unifiedPermissionMode" in value) parsed.unifiedPermissionMode = value.unifiedPermissionMode == null ? undefined : asTrimmedString(value.unifiedPermissionMode) as AgentChatUpdateSessionArgs["unifiedPermissionMode"];
   if ("computerUse" in value) parsed.computerUse = value.computerUse == null ? null : value.computerUse as AgentChatUpdateSessionArgs["computerUse"];
+  if ("manuallyNamed" in value) parsed.manuallyNamed = value.manuallyNamed === true;
   return parsed;
 }
 
diff --git a/apps/desktop/src/preload/global.d.ts b/apps/desktop/src/preload/global.d.ts
index 29edf6687..8af9182c2 100644
--- a/apps/desktop/src/preload/global.d.ts
+++ b/apps/desktop/src/preload/global.d.ts
@@ -560,6 +560,7 @@ declare global {
         getProject: () => Promise<ProjectInfo | null>;
         openExternal: (url: string) => Promise<void>;
         revealPath: (path: string) => Promise<void>;
+        openPath: (path: string) => Promise<void>;
         writeClipboardText: (text: string) => Promise<void>;
         openPathInEditor: (args: {
           rootPath: string;
@@ -850,6 +851,7 @@ declare global {
         getOwnerSnapshot: (args: ComputerUseOwnerSnapshotArgs) => Promise<ComputerUseOwnerSnapshot>;
         routeArtifact: (args: ComputerUseArtifactRouteArgs) => Promise<ComputerUseArtifactView>;
         updateArtifactReview: (args: ComputerUseArtifactReviewArgs) => Promise<ComputerUseArtifactView>;
+        readArtifactPreview: (args: { uri: string }) => Promise<string | null>;
         onEvent: (cb: (ev: ComputerUseEventPayload) => void) => () => void;
       };
       pty: {
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index f9c5f6168..2009b5930 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -556,6 +556,7 @@ contextBridge.exposeInMainWorld("ade", {
     getProject: async (): Promise<ProjectInfo | null> => ipcRenderer.invoke(IPC.appGetProject),
     openExternal: async (url: string): Promise<void> => ipcRenderer.invoke(IPC.appOpenExternal, { url }),
     revealPath: async (path: string): Promise<void> => ipcRenderer.invoke(IPC.appRevealPath, { path }),
+    openPath: async (path: string): Promise<void> => ipcRenderer.invoke(IPC.appOpenPath, { path }),
     writeClipboardText: async (text: string): Promise<void> => ipcRenderer.invoke(IPC.appWriteClipboardText, { text }),
     openPathInEditor: async (args: {
       rootPath: string;
@@ -1169,6 +1170,8 @@ contextBridge.exposeInMainWorld("ade", {
       ipcRenderer.invoke(IPC.computerUseRouteArtifact, args),
     updateArtifactReview: async (args: ComputerUseArtifactReviewArgs): Promise<ComputerUseArtifactView> =>
       ipcRenderer.invoke(IPC.computerUseUpdateArtifactReview, args),
+    readArtifactPreview: async (args: { uri: string }): Promise<string | null> =>
+      ipcRenderer.invoke(IPC.computerUseReadArtifactPreview, args),
     onEvent: (cb: (ev: ComputerUseEventPayload) => void) => {
       const listener = (_event: Electron.IpcRendererEvent, payload: ComputerUseEventPayload) => cb(payload);
       ipcRenderer.on(IPC.computerUseEvent, listener);
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
index 3a47bf0c8..f7ab285a5 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
@@ -187,32 +187,41 @@ describe("AgentChatComposer", () => {
     expect((screen.getByTitle("Upload file from disk") as HTMLButtonElement).disabled).toBe(true);
   });
 
-  it("opens the advanced popover and wires the advanced controls", () => {
-    const onExecutionModeChange = vi.fn();
-    const onComputerUsePolicyChange = vi.fn();
+  it("shows inline proof toggle and wires callback", () => {
     const onToggleProof = vi.fn();
-    const onIncludeProjectDocsChange = vi.fn();
     renderComposer({
-      executionMode: "focused",
-      executionModeOptions,
-      onExecutionModeChange,
-      onComputerUsePolicyChange,
       onToggleProof,
-      includeProjectDocs: false,
-      onIncludeProjectDocsChange,
+      proofOpen: false,
+      proofArtifactCount: 3,
     });
 
-    fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
+    const proofButton = screen.getByTitle("Open proof drawer");
+    fireEvent.click(proofButton);
+    expect(onToggleProof).toHaveBeenCalledTimes(1);
+    expect(screen.getByText("3")).toBeTruthy();
+  });
 
-    fireEvent.click(screen.getByRole("button", { name: /^Parallel/ }));
-    fireEvent.click(screen.getByRole("button", { name: /^Proof\b/i }));
-    fireEvent.click(screen.getByRole("button", { name: /^Project Context\b/i }));
+  it("shows inline context toggle only before first message", () => {
+    const onIncludeProjectDocsChange = vi.fn();
+    renderComposer({
+      chatHasMessages: false,
+      includeProjectDocs: false,
+      onIncludeProjectDocsChange,
+    });
 
-    expect(onExecutionModeChange).toHaveBeenCalledWith("parallel");
-    expect(onToggleProof).toHaveBeenCalledTimes(1);
+    const contextButton = screen.getByTitle("Include project context (PRD + architecture) with first message");
+    fireEvent.click(contextButton);
     expect(onIncludeProjectDocsChange).toHaveBeenCalledWith(true);
+  });
+
+  it("hides context toggle after first message is sent", () => {
+    const onIncludeProjectDocsChange = vi.fn();
+    renderComposer({
+      chatHasMessages: true,
+      includeProjectDocs: false,
+      onIncludeProjectDocsChange,
+    });
 
-    fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
-    expect(screen.queryByText("Advanced settings")).toBeNull();
+    expect(screen.queryByTitle("Include project context (PRD + architecture) with first message")).toBeNull();
   });
 });
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
index d2f1de951..2c58d9cc2 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { At, CaretDown, Image, Paperclip, Square, X, PaperPlaneTilt } from "@phosphor-icons/react";
+import { At, Image, Paperclip, Square, X, PaperPlaneTilt, Cube, BookOpen } from "@phosphor-icons/react";
 import {
   inferAttachmentType,
   type AgentChatApprovalDecision,
@@ -130,258 +130,7 @@ const UNIFIED_PERMISSION_OPTIONS: Array<{ value: AgentChatUnifiedPermissionMode;
   { value: "full-auto", label: "Full auto" },
 ];
 
-type AdvancedSettingsPopoverProps = {
-  executionModeOptions: ExecutionModeOption[];
-  executionMode: AgentChatExecutionMode | null;
-  onExecutionModeChange?: (mode: AgentChatExecutionMode) => void;
-  computerUsePolicy: ComputerUsePolicy;
-  computerUseSnapshot: ComputerUseOwnerSnapshot | null;
-  onOpenComputerUseDetails: () => void;
-  proofOpen: boolean;
-  proofArtifactCount: number;
-  onToggleProof?: () => void;
-  includeProjectDocs?: boolean;
-  onIncludeProjectDocsChange?: (checked: boolean) => void;
-};
-
-function AdvancedSettingsPopover({
-  executionModeOptions,
-  executionMode,
-  onExecutionModeChange,
-  computerUsePolicy,
-  computerUseSnapshot,
-  onOpenComputerUseDetails,
-  proofOpen,
-  proofArtifactCount,
-  onToggleProof,
-  includeProjectDocs,
-  onIncludeProjectDocsChange,
-}: AdvancedSettingsPopoverProps) {
-  const [hoveredExecutionMode, setHoveredExecutionMode] = useState<AgentChatExecutionMode | null>(null);
-  const activeBackend = computerUseSnapshot?.activeBackend?.name ?? (computerUsePolicy.allowLocalFallback ? "Fallback allowed" : "No fallback");
-  const activeExecutionMode = executionModeOptions.find((option) => option.value === executionMode) ?? executionModeOptions[0] ?? null;
-  const helpMode = hoveredExecutionMode
-    ? executionModeOptions.find((option) => option.value === hoveredExecutionMode) ?? activeExecutionMode
-    : activeExecutionMode;
 
-  return (
-    <div className="absolute bottom-full right-0 z-30 mb-3 w-[min(44rem,calc(100vw-2rem))] overflow-hidden rounded-[22px] border border-white/[0.08] bg-[linear-gradient(180deg,rgba(18,20,28,0.98),rgba(10,12,18,0.98))] shadow-[0_24px_90px_-40px_rgba(0,0,0,0.88)] backdrop-blur-xl">
-      <div className="border-b border-white/[0.05] px-4 py-3">
-        <div className="flex items-start justify-between gap-4">
-          <div className="space-y-1">
-            <div className="font-sans text-[12px] font-semibold tracking-tight text-fg/86">Advanced settings</div>
-            <div className="max-w-[34rem] text-[11px] leading-5 text-fg/54">
-              Tune execution behavior, computer use, proof retention, and project context without widening the main composer.
-            </div>
-          </div>
-          <button
-            type="button"
-            className="rounded-[var(--chat-radius-pill)] border border-white/[0.08] bg-white/[0.03] px-3 py-1 font-sans text-[11px] font-medium text-fg/58 transition-colors hover:text-fg/82"
-            onClick={onOpenComputerUseDetails}
-            title="Open the detailed computer-use settings"
-          >
-            Computer use details
-          </button>
-        </div>
-      </div>
-
-      <div className="space-y-4 px-4 py-4">
-        {executionModeOptions.length > 0 && onExecutionModeChange ? (
-          <div className="space-y-2">
-            <div className="flex items-center justify-between gap-3">
-              <div>
-                <div className="font-sans text-[11px] font-semibold uppercase tracking-[0.16em] text-fg/64">Execution mode</div>
-                <div className="mt-1 text-[11px] leading-5 text-fg/48">Choose whether the model stays in one thread or spreads work across delegates.</div>
-              </div>
-              {helpMode ? (
-                <div className="rounded-md border border-white/[0.08] bg-white/[0.03] px-2 py-1 font-sans text-[10px] font-medium text-fg/72">
-                  {helpMode.summary}
-                </div>
-              ) : null}
-            </div>
-            <div className="grid gap-2 sm:grid-cols-2">
-              {executionModeOptions.map((option) => {
-                const isActive = executionMode === option.value;
-                return (
-                  <button
-                    key={option.value}
-                    type="button"
-                    className={cn(
-                      "rounded-[18px] border px-3 py-2 text-left transition-colors",
-                      isActive
-                        ? "border-[color:color-mix(in_srgb,var(--chat-accent)_28%,transparent)] bg-[color:color-mix(in_srgb,var(--chat-accent)_12%,transparent)] text-fg/84"
-                        : "border-white/[0.06] bg-white/[0.03] text-fg/62 hover:border-white/[0.12] hover:bg-white/[0.05]",
-                    )}
-                    style={isActive ? {
-                      borderColor: `${option.accent}44`,
-                      background: `${option.accent}16`,
-                    } : undefined}
-                    onClick={() => onExecutionModeChange(option.value)}
-                    onMouseEnter={() => setHoveredExecutionMode(option.value)}
-                    onMouseLeave={() => setHoveredExecutionMode(null)}
-                    title={option.helper}
-                    aria-pressed={isActive}
-                  >
-                    <div className="flex items-center justify-between gap-2">
-                      <span className="font-sans text-[12px] font-medium text-fg/82">{option.label}</span>
-                      <span className="font-sans text-[10px] uppercase tracking-[0.16em] text-fg/34">{option.summary}</span>
-                    </div>
-                    <div className="mt-1 text-[11px] leading-5 text-fg/54">{option.helper}</div>
-                  </button>
-                );
-              })}
-            </div>
-          </div>
-        ) : null}
-
-        <div className="grid gap-3 md:grid-cols-2">
-          <button
-            type="button"
-            className={cn(
-              "rounded-[18px] border px-3 py-3 text-left transition-colors",
-              proofOpen || proofArtifactCount > 0
-                ? "border-emerald-400/22 bg-emerald-500/10"
-                : "border-white/[0.06] bg-white/[0.03] hover:border-white/[0.12] hover:bg-white/[0.05]",
-            )}
-            onClick={onToggleProof}
-            aria-pressed={proofOpen}
-            disabled={!onToggleProof}
-            title="Open or hide the proof drawer for retained screenshots, traces, logs, and verification output"
-          >
-            <div className="flex items-center justify-between gap-2">
-              <span className="font-sans text-[12px] font-medium text-fg/84">Proof</span>
-              <span className={cn(
-                "rounded-md border px-2 py-0.5 font-sans text-[9px] font-semibold uppercase tracking-[0.14em]",
-                proofOpen
-                  ? "border-emerald-400/25 bg-emerald-500/10 text-emerald-200"
-                  : "border-white/[0.08] bg-white/[0.03] text-fg/45",
-              )}>
-                {proofArtifactCount > 0 ? `${proofArtifactCount} artifacts` : proofOpen ? "Open" : "Closed"}
-              </span>
-            </div>
-            <div className="mt-1 text-[11px] leading-5 text-fg/58">
-              Inspect retained screenshots, traces, logs, and validation output from this chat.
-            </div>
-          </button>
-
-          <button
-            type="button"
-            className={cn(
-              "rounded-[18px] border px-3 py-3 text-left transition-colors md:col-span-2",
-              includeProjectDocs
-                ? "border-accent/22 bg-accent/10"
-                : "border-white/[0.06] bg-white/[0.03] hover:border-white/[0.12] hover:bg-white/[0.05]",
-            )}
-            onClick={() => onIncludeProjectDocsChange?.(!includeProjectDocs)}
-            aria-pressed={!!includeProjectDocs}
-            disabled={!onIncludeProjectDocsChange}
-            title="Include project-level context docs (PRD and architecture) with the first message"
-          >
-            <div className="flex items-center justify-between gap-2">
-              <span className="font-sans text-[12px] font-medium text-fg/84">Project Context</span>
-              <span className={cn(
-                "rounded-md border px-2 py-0.5 font-sans text-[9px] font-semibold uppercase tracking-[0.14em]",
-                includeProjectDocs
-                  ? "border-accent/25 bg-accent/10 text-accent"
-                  : "border-white/[0.08] bg-white/[0.03] text-fg/45",
-              )}>
-                {includeProjectDocs ? "Included" : "Off"}
-              </span>
-            </div>
-            <div className="mt-1 text-[11px] leading-5 text-fg/58">
-              Attach the project-level PRD and architecture context to the next turn so the agent starts with more background.
-            </div>
-          </button>
-        </div>
-
-        {helpMode ? (
-          <div className="rounded-[18px] border border-white/[0.06] bg-black/20 px-3 py-2">
-            <div className="flex items-center justify-between gap-2">
-              <span className="font-sans text-[10px] font-semibold uppercase tracking-[0.16em] text-fg/48">Mode help</span>
-              <span className="font-sans text-[10px] text-fg/38">{helpMode.label}</span>
-            </div>
-            <div className="mt-1 text-[11px] leading-5 text-fg/58">{hoveredExecutionMode ? helpMode.helper : helpMode.summary}</div>
-          </div>
-        ) : null}
-      </div>
-    </div>
-  );
-}
-
-function ComputerUseSettingsModal({
-  open,
-  policy,
-  snapshot,
-  onClose,
-  onChange,
-  onOpenProof,
-}: {
-  open: boolean;
-  policy: ComputerUsePolicy;
-  snapshot: ComputerUseOwnerSnapshot | null;
-  onClose: () => void;
-  onChange: (policy: ComputerUsePolicy) => void;
-  onOpenProof: () => void;
-}) {
-  if (!open) return null;
-
-  const activeBackend = snapshot?.activeBackend?.name ?? "None";
-  const artifactCount = snapshot?.artifacts.length ?? 0;
-
-  return (
-    <div
-      className="fixed inset-0 z-[9999] flex items-center justify-center bg-[radial-gradient(circle_at_top,rgba(56,189,248,0.1),rgba(7,10,18,0.88))] px-4 backdrop-blur-md"
-      onClick={(event) => {
-        if (event.target === event.currentTarget) onClose();
-      }}
-    >
-      <div className="w-full max-w-sm overflow-hidden rounded-[28px] border border-white/[0.08] bg-[linear-gradient(180deg,rgba(15,21,34,0.96),rgba(10,13,22,0.94))] shadow-[0_28px_110px_-36px_rgba(0,0,0,0.82)]">
-        <div className="border-b border-white/[0.05] bg-[linear-gradient(90deg,rgba(56,189,248,0.12),transparent)] px-5 py-4">
-          <div className="flex items-start justify-between gap-4">
-            <div className="space-y-1">
-              <div className="font-sans text-[15px] font-semibold tracking-tight text-fg/88">Computer use</div>
-              <div className="text-[12px] leading-5 text-fg/58">
-                ADE captures proof from your agent's tool calls automatically.
-              </div>
-            </div>
-            <button
-              type="button"
-              className="rounded-[var(--chat-radius-pill)] border border-white/[0.08] bg-white/[0.03] px-3 py-1 font-sans text-[11px] font-medium text-fg/60 transition-colors hover:text-fg/85"
-              onClick={onClose}
-              title="Close"
-            >
-              Close
-            </button>
-          </div>
-        </div>
-
-        <div className="space-y-4 px-5 py-5">
-          <div className="space-y-2">
-            <div className="flex items-center justify-between">
-              <span className="font-sans text-[11px] uppercase tracking-[0.14em] text-muted-fg/40">Backend</span>
-              <span className="text-[12px] text-fg/78">{activeBackend}</span>
-            </div>
-            <div className="flex items-center justify-between">
-              <span className="font-sans text-[11px] uppercase tracking-[0.14em] text-muted-fg/40">Artifacts</span>
-              <span className="text-[12px] text-fg/78">{artifactCount} captured</span>
-            </div>
-          </div>
-
-          <div className="grid gap-3">
-            <button
-              type="button"
-              className="rounded-[18px] border border-white/[0.06] bg-white/[0.03] px-4 py-2.5 font-sans text-[12px] font-medium text-fg/78 transition-colors hover:border-white/[0.12] hover:text-fg/90"
-              onClick={onOpenProof}
-              title="Open the proof drawer"
-            >
-              Open proof drawer
-            </button>
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-}
 
 export function AgentChatComposer({
   surfaceMode = "standard",
@@ -437,6 +186,7 @@ export function AgentChatComposer({
   onClearEvents,
   promptSuggestion,
   subagentSnapshots = [],
+  chatHasMessages = false,
 }: {
   surfaceMode?: ChatSurfaceMode;
   sdkSlashCommands?: AgentChatSlashCommand[];
@@ -495,6 +245,7 @@ export function AgentChatComposer({
   onClearEvents?: () => void;
   promptSuggestion?: string | null;
   subagentSnapshots?: ChatSubagentSnapshot[];
+  chatHasMessages?: boolean;
 }) {
   const [attachmentPickerOpen, setAttachmentPickerOpen] = useState(false);
   const [attachmentQuery, setAttachmentQuery] = useState("");
@@ -510,14 +261,10 @@ export function AgentChatComposer({
   const [hoveredCodexPreset, setHoveredCodexPreset] = useState<"plan" | "edit" | "full-auto" | null>(null);
 
   const [dragActive, setDragActive] = useState(false);
-  const [advancedMenuOpen, setAdvancedMenuOpen] = useState(false);
-  const [computerUseModalOpen, setComputerUseModalOpen] = useState(false);
 
   const attachmentInputRef = useRef<HTMLInputElement | null>(null);
   const uploadInputRef = useRef<HTMLInputElement | null>(null);
   const textareaRef = useRef<HTMLTextAreaElement | null>(null);
-  const advancedMenuRef = useRef<HTMLDivElement | null>(null);
-  const advancedButtonRef = useRef<HTMLButtonElement | null>(null);
   const fileAddInProgressRef = useRef(false);
   const canAttach = !turnActive;
 
@@ -553,41 +300,6 @@ export function AgentChatComposer({
     return () => window.clearTimeout(timeout);
   }, [attachmentPickerOpen]);
 
-  useEffect(() => {
-    if (!computerUseModalOpen) return;
-    const onKeyDown = (event: KeyboardEvent) => {
-      if (event.key === "Escape") {
-        event.stopPropagation();
-        setComputerUseModalOpen(false);
-      }
-    };
-    window.addEventListener("keydown", onKeyDown, true);
-    return () => window.removeEventListener("keydown", onKeyDown, true);
-  }, [computerUseModalOpen]);
-
-  useEffect(() => {
-    if (!advancedMenuOpen) return;
-    const onPointerDown = (event: PointerEvent) => {
-      const target = event.target;
-      if (!(target instanceof Node)) return;
-      if (advancedMenuRef.current?.contains(target)) return;
-      if (advancedButtonRef.current?.contains(target)) return;
-      setAdvancedMenuOpen(false);
-    };
-    const onKeyDown = (event: KeyboardEvent) => {
-      if (event.key === "Escape") {
-        setAdvancedMenuOpen(false);
-        advancedButtonRef.current?.focus();
-      }
-    };
-    window.addEventListener("pointerdown", onPointerDown, true);
-    window.addEventListener("keydown", onKeyDown, true);
-    return () => {
-      window.removeEventListener("pointerdown", onPointerDown, true);
-      window.removeEventListener("keydown", onKeyDown, true);
-    };
-  }, [advancedMenuOpen]);
-
   useEffect(() => {
     if (!attachmentPickerOpen) return;
     const query = attachmentQuery.trim();
@@ -1210,44 +922,47 @@ export function AgentChatComposer({
             </div>
 
             <div className="ml-auto flex shrink-0 items-center gap-1.5">
-              <div className="relative">
+              {/* Proof drawer toggle */}
+              {onToggleProof ? (
                 <button
-                  ref={advancedButtonRef}
                   type="button"
                   className={cn(
-                    "inline-flex h-7 items-center gap-1 rounded-md border px-2.5 font-sans text-[10px] font-medium transition-colors",
-                    advancedMenuOpen
-                      ? "border-[color:color-mix(in_srgb,var(--chat-accent)_28%,transparent)] bg-[color:color-mix(in_srgb,var(--chat-accent)_12%,transparent)] text-[var(--chat-accent)]"
+                    "relative inline-flex h-7 items-center gap-1 rounded-md border px-2 font-sans text-[10px] font-medium transition-colors",
+                    proofOpen
+                      ? "border-emerald-400/22 bg-emerald-500/10 text-emerald-200/80"
                       : "border-white/[0.06] bg-white/[0.02] text-muted-fg/40 hover:border-white/[0.12] hover:text-fg/68",
                   )}
-                  onClick={() => setAdvancedMenuOpen((open) => !open)}
-                  title="Open advanced composer settings"
-                  aria-expanded={advancedMenuOpen}
+                  onClick={onToggleProof}
+                  title={proofOpen ? "Close proof drawer" : "Open proof drawer"}
+                  aria-pressed={proofOpen}
                 >
-                  <span>Advanced</span>
-                  <CaretDown size={10} weight="bold" />
+                  <Cube size={12} weight={proofOpen ? "fill" : "regular"} />
+                  {proofArtifactCount > 0 ? (
+                    <span className="inline-flex h-[14px] min-w-[14px] items-center justify-center rounded-full bg-emerald-500/20 px-1 font-mono text-[8px] font-bold text-emerald-200/90">
+                      {proofArtifactCount}
+                    </span>
+                  ) : null}
                 </button>
-                {advancedMenuOpen ? (
-                  <div ref={advancedMenuRef}>
-                    <AdvancedSettingsPopover
-                      executionModeOptions={executionModeOptions}
-                      executionMode={executionMode ?? null}
-                      onExecutionModeChange={onExecutionModeChange}
-                      computerUsePolicy={computerUsePolicy}
-                      computerUseSnapshot={computerUseSnapshot ?? null}
-                      onOpenComputerUseDetails={() => {
-                        setAdvancedMenuOpen(false);
-                        setComputerUseModalOpen(true);
-                      }}
-                      proofOpen={proofOpen}
-                      proofArtifactCount={proofArtifactCount}
-                      onToggleProof={onToggleProof}
-                      includeProjectDocs={includeProjectDocs}
-                      onIncludeProjectDocsChange={onIncludeProjectDocsChange}
-                    />
-                  </div>
-                ) : null}
-              </div>
+              ) : null}
+
+              {/* Include context toggle -- only before first message */}
+              {!chatHasMessages && onIncludeProjectDocsChange ? (
+                <button
+                  type="button"
+                  className={cn(
+                    "inline-flex h-7 items-center gap-1 rounded-md border px-2 font-sans text-[10px] font-medium transition-colors",
+                    includeProjectDocs
+                      ? "border-accent/22 bg-accent/10 text-accent"
+                      : "border-white/[0.06] bg-white/[0.02] text-muted-fg/40 hover:border-white/[0.12] hover:text-fg/68",
+                  )}
+                  onClick={() => onIncludeProjectDocsChange(!includeProjectDocs)}
+                  title="Include project context (PRD + architecture) with first message"
+                  aria-pressed={!!includeProjectDocs}
+                >
+                  <BookOpen size={12} weight={includeProjectDocs ? "fill" : "regular"} />
+                  <span>Context</span>
+                </button>
+              ) : null}
 
               {turnActive ? (
                 <>
@@ -1342,7 +1057,7 @@ export function AgentChatComposer({
               if (val.startsWith("/")) { setSlashQuery(val.slice(1)); setSlashCursor(0); }
             }}
             className={cn(
-              "min-h-[40px] max-h-[40vh] w-full resize-none bg-transparent px-4 py-3 text-[13px] leading-[1.6] text-fg/88 outline-none transition-colors placeholder:text-muted-fg/25",
+              "min-h-[52px] max-h-[40vh] w-full resize-none bg-transparent px-4 py-3 text-[13px] leading-[1.6] text-fg/88 outline-none transition-colors placeholder:text-muted-fg/25",
               dragActive ? "opacity-30" : "",
             )}
             placeholder={turnActive ? "Steer the active turn..." : (promptSuggestion ? "" : (messagePlaceholder ?? "Message the assistant..."))}
@@ -1352,17 +1067,6 @@ export function AgentChatComposer({
         </div>
       </div>
       </ChatComposerShell>
-      <ComputerUseSettingsModal
-        open={computerUseModalOpen}
-        policy={computerUsePolicy}
-        snapshot={computerUseSnapshot ?? null}
-        onClose={() => setComputerUseModalOpen(false)}
-        onChange={onComputerUsePolicyChange}
-        onOpenProof={() => {
-          if (!proofOpen) onToggleProof?.();
-          setComputerUseModalOpen(false);
-        }}
-      />
     </>
   );
 }
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.submit.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.submit.test.tsx
index 5a4590065..879fcd4ac 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.submit.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.submit.test.tsx
@@ -584,4 +584,72 @@ describe("AgentChatPane submit recovery", () => {
       expect(onSessionCreated).toHaveBeenCalledWith("session-2");
     });
   });
+
+  it("shows 'New chat' in the header when no session is selected", async () => {
+    installAdeMocks({ sessions: [] });
+
+    render(
+      <MemoryRouter>
+        <AgentChatPane
+          laneId="lane-1"
+          forceNewSession
+        />
+      </MemoryRouter>,
+    );
+
+    expect(await screen.findByText("New chat")).toBeTruthy();
+  });
+
+  it("shows the session title in the header when the session has one", async () => {
+    const session = buildSession("session-1", {
+      title: "Fix login bug",
+    });
+    installAdeMocks({ sessions: [session] });
+    renderPane(session);
+
+    expect(await screen.findByText("Fix login bug")).toBeTruthy();
+  });
+
+  it("renders the lane navigation button when laneLabel is provided", async () => {
+    const session = buildSession("session-1");
+    installAdeMocks({ sessions: [session] });
+
+    render(
+      <MemoryRouter>
+        <AgentChatPane
+          laneId={session.laneId}
+          laneLabel="feature/auth"
+          lockSessionId={session.sessionId}
+          hideSessionTabs
+          initialSessionSummary={session}
+        />
+      </MemoryRouter>,
+    );
+
+    const laneButton = await screen.findByTitle("Go to lane: feature/auth");
+    expect(laneButton).toBeTruthy();
+    expect(laneButton.textContent).toContain("feature/auth");
+  });
+
+  it("does not render the lane navigation button when laneId is null", async () => {
+    const session = buildSession("session-1");
+    installAdeMocks({ sessions: [session] });
+
+    render(
+      <MemoryRouter>
+        <AgentChatPane
+          laneId={null}
+          laneLabel="feature/auth"
+          lockSessionId={session.sessionId}
+          hideSessionTabs
+          initialSessionSummary={session}
+        />
+      </MemoryRouter>,
+    );
+
+    // Wait for the pane to fully render (renders "Select a lane" placeholder when laneId is null)
+    await waitFor(() => {
+      expect(screen.queryByTitle(/Go to lane:/)).toBeNull();
+    });
+  });
 });
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
index fec2a9e5c..4e1dcfc58 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Plus } from "@phosphor-icons/react";
+import { useNavigate } from "react-router-dom";
+import { GitBranch, Plus } from "@phosphor-icons/react";
 import {
   createDefaultComputerUsePolicy,
   inferAttachmentType,
@@ -45,6 +46,7 @@ import { deriveChatSubagentSnapshots } from "./chatExecutionSummary";
 import { derivePendingInputRequests, type DerivedPendingInput } from "./pendingInput";
 import { UnifiedModelSelector } from "../shared/UnifiedModelSelector";
 import { useClickOutside } from "../../hooks/useClickOutside";
+import { useAppStore } from "../../state/appStore";
 
 const LAST_MODEL_ID_KEY = "ade.chat.lastModelId";
 const LAST_REASONING_KEY_PREFIX = "ade.chat.lastReasoningEffort";
@@ -472,6 +474,8 @@ export function AgentChatPane({
   presentation?: ChatSurfacePresentation;
   onSessionCreated?: (sessionId: string) => void | Promise<void>;
 }) {
+  const navigate = useNavigate();
+  const selectLane = useAppStore((s) => s.selectLane);
   const lockedSingleSessionMode = Boolean(lockSessionId && hideSessionTabs && initialSessionSummary);
   const forceDraft = forceDraftMode || forceNewSession;
   const preferDraftStart = !lockSessionId && !initialSessionId && !forceNewSession;
@@ -611,7 +615,7 @@ export function AgentChatPane({
   }, [computerUsePolicy, selectedSession?.computerUse]);
   const launchModeEditable = !selectedSessionId || selectedEvents.length === 0;
   const resolvedTitle = presentation?.title?.trim()
-    || (surfaceMode === "resolver" ? "AI Resolver" : laneDisplayLabel?.trim() || "Chat");
+    || (surfaceMode === "resolver" ? "AI Resolver" : selectedSession ? chatSessionTitle(selectedSession) : "New chat");
   const assistantLabel = presentation?.assistantLabel?.trim()
     || resolveAssistantLabel(selectedModelDesc, selectedSession?.provider);
   const messagePlaceholder = presentation?.messagePlaceholder?.trim()
@@ -1741,6 +1745,20 @@ export function AgentChatPane({
           </div>
         </div>
         <div className="flex flex-wrap items-center justify-end gap-1.5">
+          {laneId && laneDisplayLabel && laneDisplayLabel !== laneId ? (
+            <button
+              type="button"
+              className="inline-flex items-center gap-1.5 rounded-md border border-white/[0.06] px-2 py-1 font-sans text-[11px] font-medium text-muted-fg/50 transition-colors hover:border-white/[0.1] hover:text-fg/70"
+              title={`Go to lane: ${laneDisplayLabel}`}
+              onClick={() => {
+                selectLane(laneId);
+                navigate(`/lanes?laneId=${encodeURIComponent(laneId)}`);
+              }}
+            >
+              <GitBranch size={11} weight="regular" />
+              <span className="max-w-[140px] truncate">{laneDisplayLabel}</span>
+            </button>
+          ) : null}
           {canShowHandoff ? (
             <div ref={handoffRef} className="relative">
               <button
@@ -2026,6 +2044,7 @@ export function AgentChatPane({
             }}
             promptSuggestion={promptSuggestion}
             subagentSnapshots={selectedSubagentSnapshots}
+            chatHasMessages={selectedEvents.some(env => env.event.type === "user_message" || env.event.type === "text")}
           />
         }
         bodyClassName="flex min-h-0 flex-col overflow-hidden"
@@ -2080,9 +2099,7 @@ export function AgentChatPane({
                   </div>
                   <div className="max-h-[48vh] overflow-auto px-4 pb-4">
                     <ChatComputerUsePanel
-                      laneId={laneId}
                       sessionId={selectedSessionId}
-                      policy={computerUsePolicy}
                       snapshot={computerUseSnapshot}
                       onRefresh={() => refreshComputerUseSnapshot(selectedSessionId, { force: true })}
                     />
diff --git a/apps/desktop/src/renderer/components/chat/ChatComputerUsePanel.tsx b/apps/desktop/src/renderer/components/chat/ChatComputerUsePanel.tsx
index 5f7a05b2c..92f716da7 100644
--- a/apps/desktop/src/renderer/components/chat/ChatComputerUsePanel.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatComputerUsePanel.tsx
@@ -1,323 +1,396 @@
-import React, { useEffect, useMemo, useState } from "react";
-import type { ComputerUseArtifactOwnerKind, ComputerUseOwnerSnapshot, ComputerUsePolicy } from "../../../shared/types";
-import {
-  buildComputerUseRoutePresets,
-  describeComputerUseLinks,
-  formatComputerUseKind,
-  formatComputerUseMode,
-  summarizeComputerUseProof,
-} from "../../lib/computerUse";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { ComputerUseArtifactView, ComputerUseOwnerSnapshot } from "../../../shared/types";
 import { cn } from "../ui/cn";
 
-function isExternalUri(value: string): boolean {
-  return /^https?:\/\//i.test(value);
+function isImageArtifact(artifact: ComputerUseArtifactView): boolean {
+  return artifact.kind === "screenshot" || (artifact.mimeType?.startsWith("image/") ?? false);
 }
 
-function openArtifactUri(uri: string | null) {
-  if (!uri) return;
-  if (isExternalUri(uri)) {
+function isVideoArtifact(artifact: ComputerUseArtifactView): boolean {
+  return artifact.kind === "video_recording" || (artifact.mimeType?.startsWith("video/") ?? false);
+}
+
+function kindLabel(kind: string): string {
+  return kind.replace(/_/g, " ");
+}
+
+/** Convert an artifact URI to an ade-artifact:// URL that Electron's custom protocol can serve. Remote http(s) URLs return null (no automatic preview / no renderer fetch). */
+function toPreviewSrc(uri: string): string | null {
+  if (/^https?:\/\//i.test(uri)) return null;
+  // Strip file:// prefix if present
+  let filePath = uri;
+  if (filePath.startsWith("file://")) {
+    try { filePath = decodeURIComponent(new URL(filePath).pathname); } catch { filePath = filePath.replace(/^file:\/\//i, ""); }
+  }
+  // For relative paths, we can't resolve here — the protocol handler in main will need the project root.
+  // But artifacts stored by the broker are typically absolute or relative to project root.
+  const encoded = new URL(filePath, "file://").pathname;
+  return `ade-artifact://${encoded.startsWith("/") ? "" : "/"}${encoded}`;
+}
+
+function fileUriToFsPath(uri: string): string {
+  if (!uri.startsWith("file://")) return uri;
+  try {
+    const u = new URL(uri);
+    let p = decodeURIComponent(u.pathname);
+    if (/^\/[a-zA-Z]:/.test(p)) {
+      p = p.slice(1);
+    }
+    return p;
+  } catch {
+    return uri.replace(/^file:\/\//i, "");
+  }
+}
+
+function openInSystemPlayer(uri: string) {
+  if (/^https?:\/\//i.test(uri)) {
     void window.ade.app.openExternal(uri);
-    return;
+  } else {
+    const fsPath = fileUriToFsPath(uri);
+    window.ade.app.openPath(fsPath).catch((err: unknown) => {
+      console.error("[ChatComputerUsePanel] Failed to open local path:", fsPath, err);
+    });
+  }
+}
+
+function PreviewFallback({
+  message,
+  actionLabel,
+  onOpen,
+}: {
+  message: string;
+  actionLabel: string;
+  onOpen: () => void;
+}) {
+  return (
+    <div className="flex min-h-28 w-full flex-col items-center justify-center gap-2 rounded-md border border-white/[0.06] bg-black/20 px-3 py-4 text-center">
+      <div className="text-[11px] text-fg/40">{message}</div>
+      <button
+        type="button"
+        onClick={onOpen}
+        className="rounded-md border border-white/[0.08] px-2.5 py-1 text-[11px] text-fg/50 transition-colors hover:bg-white/[0.04] hover:text-fg/70"
+      >
+        {actionLabel}
+      </button>
+    </div>
+  );
+}
+
+function VideoPreview({ artifact, src }: { artifact: ComputerUseArtifactView; src: string | null }) {
+  const [canPlay, setCanPlay] = useState(true);
+  const stalledTimeoutRef = useRef<number | null>(null);
+
+  const clearStalledTimeout = useCallback(() => {
+    if (stalledTimeoutRef.current == null) return;
+    window.clearTimeout(stalledTimeoutRef.current);
+    stalledTimeoutRef.current = null;
+  }, []);
+
+  useEffect(() => {
+    setCanPlay(true);
+    clearStalledTimeout();
+    return clearStalledTimeout;
+  }, [clearStalledTimeout, src]);
+
+  const handlePlaybackRecovered = useCallback(() => {
+    clearStalledTimeout();
+    setCanPlay(true);
+  }, [clearStalledTimeout]);
+
+  const handlePlaybackError = useCallback(() => {
+    clearStalledTimeout();
+    setCanPlay(false);
+  }, [clearStalledTimeout]);
+
+  const handleStalled = useCallback(() => {
+    clearStalledTimeout();
+    stalledTimeoutRef.current = window.setTimeout(() => {
+      stalledTimeoutRef.current = null;
+      setCanPlay(false);
+    }, 3000);
+  }, [clearStalledTimeout]);
+
+  if (!src) {
+    return (
+      <PreviewFallback
+        message="Video preview unavailable for this URI."
+        actionLabel="Open in system player"
+        onOpen={() => artifact.uri && openInSystemPlayer(artifact.uri)}
+      />
+    );
+  }
+
+  if (!canPlay) {
+    return (
+      <PreviewFallback
+        message="Video preview unavailable."
+        actionLabel="Open in system player"
+        onOpen={() => artifact.uri && openInSystemPlayer(artifact.uri)}
+      />
+    );
   }
-  void window.ade.app.revealPath(uri);
+
+  return (
+    <video
+      src={src}
+      controls
+      className="block max-h-[360px] w-full rounded-md border border-white/[0.06] bg-black"
+      onCanPlay={handlePlaybackRecovered}
+      onPlaying={handlePlaybackRecovered}
+      onError={handlePlaybackError}
+      onStalled={handleStalled}
+    />
+  );
 }
 
-function resolveArtifactPreviewUri(uri: string | null, projectRoot: string | null): string | null {
-  if (!uri) return null;
-  if (isExternalUri(uri)) return uri;
-  const absolutePath = uri.startsWith("/")
-    ? uri
-    : projectRoot
-      ? `${projectRoot.replace(/\/$/, "")}/${uri.replace(/^\.\//, "")}`
-      : null;
-  return absolutePath ? encodeURI(`file://${absolutePath}`) : null;
+function ImagePreview({ artifact, src }: { artifact: ComputerUseArtifactView; src: string | null }) {
+  const [imageError, setImageError] = useState(false);
+
+  useEffect(() => {
+    setImageError(false);
+  }, [src]);
+
+  if (!src) {
+    return (
+      <PreviewFallback
+        message="Image preview unavailable for this URI."
+        actionLabel="Open in system viewer"
+        onOpen={() => artifact.uri && openInSystemPlayer(artifact.uri)}
+      />
+    );
+  }
+
+  if (imageError) {
+    return (
+      <PreviewFallback
+        message="Image preview unavailable."
+        actionLabel="Open in system viewer"
+        onOpen={() => artifact.uri && openInSystemPlayer(artifact.uri)}
+      />
+    );
+  }
+
+  return (
+    <img
+      src={src}
+      alt={artifact.title}
+      className="block max-h-[360px] w-full rounded-md border border-white/[0.06] object-contain"
+      onError={() => setImageError(true)}
+    />
+  );
+}
+
+function ArtifactPreview({ artifact }: { artifact: ComputerUseArtifactView }) {
+  if (!artifact.uri) return null;
+
+  if (/^https?:\/\//i.test(artifact.uri)) {
+    return (
+      <PreviewFallback
+        message="Remote artifact — preview disabled. Open to view in your browser."
+        actionLabel="Open"
+        onOpen={() => openInSystemPlayer(artifact.uri!)}
+      />
+    );
+  }
+
+  const src = toPreviewSrc(artifact.uri);
+
+  if (isImageArtifact(artifact)) {
+    return <ImagePreview artifact={artifact} src={src} />;
+  }
+
+  if (isVideoArtifact(artifact)) {
+    return <VideoPreview artifact={artifact} src={src} />;
+  }
+
+  return null;
 }
 
 export function ChatComputerUsePanel({
-  laneId,
   sessionId,
-  policy,
   snapshot,
   onRefresh,
 }: {
-  laneId: string | null;
   sessionId: string;
-  policy: ComputerUsePolicy;
   snapshot: ComputerUseOwnerSnapshot | null;
   onRefresh: () => void | Promise<void>;
 }) {
-  const [selectedArtifactId, setSelectedArtifactId] = useState<string | null>(snapshot?.artifacts[0]?.id ?? null);
+  const [selectedId, setSelectedId] = useState<string | null>(null);
   const [busy, setBusy] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [routeKind, setRouteKind] = useState<ComputerUseArtifactOwnerKind>("mission");
-  const [routeTargetId, setRouteTargetId] = useState("");
-  const [projectRoot, setProjectRoot] = useState<string | null>(null);
-
-  const selectedArtifact = useMemo(
-    () => snapshot?.artifacts.find((artifact) => artifact.id === selectedArtifactId) ?? snapshot?.artifacts[0] ?? null,
-    [selectedArtifactId, snapshot],
-  );
-  const routePresets = useMemo(
-    () => buildComputerUseRoutePresets({ laneId, chatSessionId: sessionId }),
-    [laneId, sessionId],
-  );
 
-  useEffect(() => {
-    setSelectedArtifactId((current) => current && snapshot?.artifacts.some((artifact) => artifact.id === current)
-      ? current
-      : snapshot?.artifacts[0]?.id ?? null);
-  }, [snapshot]);
+  const artifacts = useMemo(() => snapshot?.artifacts ?? [], [snapshot]);
+  const selected = useMemo(
+    () => artifacts.find((a) => a.id === selectedId) ?? artifacts[0] ?? null,
+    [selectedId, artifacts],
+  );
 
   useEffect(() => {
-    let cancelled = false;
-    window.ade.project.getSnapshot()
-      .then((project) => {
-        if (!cancelled) setProjectRoot(project.rootPath);
-      })
-      .catch(() => {
-        if (!cancelled) setProjectRoot(null);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, []);
-
-  if (!snapshot) {
-    return (
-      <div className="rounded-[var(--chat-radius-card)] border border-white/[0.06] bg-black/10 px-3 py-2 font-sans text-[11px] text-muted-fg/35">
-        Computer use is {formatComputerUseMode(policy).toLowerCase()} for this chat. Start a session or capture proof to see backend activity and artifacts here.
-      </div>
+    setSelectedId((current) =>
+      current && artifacts.some((a) => a.id === current)
+        ? current
+        : artifacts[0]?.id ?? null,
     );
-  }
+  }, [artifacts]);
 
-  const previewUri = resolveArtifactPreviewUri(selectedArtifact?.uri ?? null, projectRoot);
-  const showImagePreview = Boolean(
-    selectedArtifact
-      && previewUri
-      && (selectedArtifact.kind === "screenshot" || selectedArtifact.mimeType?.startsWith("image/")),
-  );
-  const showVideoPreview = Boolean(
-    selectedArtifact
-      && previewUri
-      && (selectedArtifact.kind === "video_recording" || selectedArtifact.mimeType?.startsWith("video/")),
-  );
+  const handleReveal = useCallback(() => {
+    if (!selected?.uri) return;
+    if (/^https?:\/\//i.test(selected.uri)) {
+      window.ade.app.openExternal(selected.uri).catch((err: unknown) => {
+        console.error("[ChatComputerUsePanel] Failed to open external URL:", selected.uri, err);
+      });
+    } else if (selected.uri.startsWith("file://")) {
+      window.ade.app.revealPath(fileUriToFsPath(selected.uri)).catch((err: unknown) => {
+        console.error("[ChatComputerUsePanel] Failed to reveal path:", selected.uri, err);
+      });
+    } else {
+      window.ade.app.revealPath(selected.uri).catch((err: unknown) => {
+        console.error("[ChatComputerUsePanel] Failed to reveal path:", selected.uri, err);
+      });
+    }
+  }, [selected]);
 
-  const updateReview = async (artifactId: string, reviewState: "accepted" | "needs_more" | "dismissed", workflowState?: "promoted" | "published" | "dismissed") => {
+  const handleAccept = useCallback(async () => {
+    if (!selected) return;
     setBusy(true);
-    setError(null);
     try {
       await window.ade.computerUse.updateArtifactReview({
-        artifactId,
-        reviewState,
-        ...(workflowState ? { workflowState } : {}),
+        artifactId: selected.id,
+        reviewState: "accepted",
+        workflowState: "promoted",
       });
       await onRefresh();
     } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
+      console.error("[ChatComputerUsePanel] Failed to accept artifact review:", selected.id, err);
     } finally {
       setBusy(false);
     }
-  };
+  }, [selected, onRefresh]);
 
-  const routeArtifact = async (artifactId: string, ownerKind: ComputerUseArtifactOwnerKind, ownerId: string) => {
-    if (!ownerId.trim()) return;
+  const handleDismiss = useCallback(async () => {
+    if (!selected) return;
     setBusy(true);
-    setError(null);
     try {
-      await window.ade.computerUse.routeArtifact({
-        artifactId,
-        owner: { kind: ownerKind, id: ownerId.trim() },
+      await window.ade.computerUse.updateArtifactReview({
+        artifactId: selected.id,
+        reviewState: "dismissed",
+        workflowState: "dismissed",
       });
-      setRouteTargetId("");
       await onRefresh();
     } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
+      console.error("[ChatComputerUsePanel] Failed to dismiss artifact review:", selected.id, err);
     } finally {
       setBusy(false);
     }
-  };
+  }, [selected, onRefresh]);
+
+  if (!snapshot || artifacts.length === 0) {
+    return (
+      <div className="px-4 py-6 text-center text-[12px] text-fg/30">
+        No artifacts captured yet.
+      </div>
+    );
+  }
 
   return (
-    <div className="space-y-3">
-      <div className="flex flex-wrap items-start justify-between gap-3">
-        <div>
-          <div className="font-sans text-[11px] font-medium text-sky-300/60">
-            Computer Use
-          </div>
-          <div className="mt-1 font-sans text-[12px] text-fg/50">{snapshot.summary}</div>
-        </div>
-        <div className="flex flex-wrap gap-2">
-          <span className="inline-flex items-center rounded-[var(--chat-radius-pill)] border border-sky-400/18 bg-sky-500/8 px-2.5 py-1 font-sans text-[10px] font-medium text-sky-200/80">
-            {formatComputerUseMode(policy)}
+    <div className="flex flex-col gap-3 p-3">
+      {/* Header */}
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <span className="text-[12px] font-medium text-fg/70">Proof</span>
+          <span className="inline-flex h-[18px] min-w-[18px] items-center justify-center rounded-full bg-white/[0.08] px-1.5 text-[10px] font-medium tabular-nums text-fg/50">
+            {artifacts.length}
           </span>
-          <span className={cn(
-            "inline-flex items-center rounded-[var(--chat-radius-pill)] border px-2.5 py-1 font-sans text-[10px] font-medium",
-            snapshot.usingLocalFallback
-              ? "border-amber-400/18 bg-amber-500/8 text-amber-200/80"
-              : "border-emerald-400/18 bg-emerald-500/8 text-emerald-200/80",
-          )}>
-            {snapshot.usingLocalFallback ? "Fallback" : "External"}
-          </span>
-          <button
-            type="button"
-            className="rounded-[var(--chat-radius-pill)] border border-white/[0.06] bg-black/10 px-2.5 py-1 font-sans text-[10px] font-medium text-fg/50 hover:text-fg/78"
-            onClick={() => void onRefresh()}
-            disabled={busy}
-          >
-            Refresh
-          </button>
         </div>
+        <button
+          type="button"
+          onClick={() => void onRefresh()}
+          disabled={busy}
+          className="rounded px-1.5 py-0.5 text-[10px] text-fg/40 transition-colors hover:bg-white/[0.06] hover:text-fg/60"
+        >
+          Refresh
+        </button>
       </div>
 
-      <div className="flex flex-wrap gap-3 font-sans text-[11px] text-muted-fg/35">
-        <span>{summarizeComputerUseProof(snapshot)}</span>
-        <span>Backend: {snapshot.activeBackend?.name ?? "not selected"}</span>
-        <span>Artifacts: {snapshot.artifacts.length}</span>
-      </div>
-
-      {snapshot.activity.length > 0 ? (
-        <div className="grid gap-2 lg:grid-cols-2">
-          {snapshot.activity.slice(0, 4).map((item) => (
-            <div key={item.id} className="rounded-[var(--chat-radius-card)] border border-white/[0.05] bg-black/10 px-3 py-2">
-              <div className="font-sans text-[10px] font-medium text-muted-fg/30">{item.kind.replace(/_/g, " ")}</div>
-              <div className="mt-1 text-[11px] text-fg/72">{item.title}</div>
-              <div className="mt-1 font-sans text-[10px] text-muted-fg/30">{item.detail}</div>
-            </div>
-          ))}
-        </div>
-      ) : null}
-
-      <div className="grid gap-3 lg:grid-cols-[220px_minmax(0,1fr)]">
-        <div className="space-y-2">
-          {snapshot.artifacts.length === 0 ? (
-            <div className="rounded-[var(--chat-radius-card)] border border-white/[0.05] bg-black/10 px-3 py-2 font-sans text-[11px] text-muted-fg/30">
-              No screenshots, traces, logs, or verification output retained yet.
-            </div>
-          ) : snapshot.artifacts.map((artifact) => (
+      {/* Thumbnail strip */}
+      {artifacts.length > 1 && (
+        <div className="flex gap-1.5 overflow-x-auto pb-1">
+          {artifacts.map((artifact) => (
             <button
               key={artifact.id}
               type="button"
-              onClick={() => setSelectedArtifactId(artifact.id)}
+              onClick={() => setSelectedId(artifact.id)}
               className={cn(
-                "w-full rounded-[var(--chat-radius-card)] border px-3 py-2 text-left transition-colors",
-                selectedArtifact?.id === artifact.id
-                  ? "border-sky-400/24 bg-sky-500/10"
-                  : "border-white/[0.05] bg-black/10 hover:border-white/[0.1]",
+                "shrink-0 rounded-md border px-2.5 py-1.5 text-left transition-colors",
+                selected?.id === artifact.id
+                  ? "border-sky-400/30 bg-sky-500/10"
+                  : "border-white/[0.06] bg-white/[0.03] hover:border-white/[0.12]",
               )}
             >
-              <div className="font-sans text-[10px] font-medium text-muted-fg/30">{artifact.backendName}</div>
-              <div className="mt-1 text-[11px] text-fg/78">{artifact.title}</div>
-              <div className="mt-1 font-sans text-[10px] text-muted-fg/30">
-                {formatComputerUseKind(artifact.kind)} • {artifact.reviewState}
+              <div className="text-[10px] font-medium text-fg/60 whitespace-nowrap">
+                {kindLabel(artifact.kind)}
+              </div>
+              <div className="mt-0.5 text-[10px] text-fg/30 whitespace-nowrap">
+                {artifact.backendName}
               </div>
             </button>
           ))}
         </div>
+      )}
 
-        {selectedArtifact ? (
-          <div className="space-y-3">
-            <div className="rounded-[var(--chat-radius-card)] border border-white/[0.05] bg-black/10 px-3 py-3">
-              <div className="flex flex-wrap items-start justify-between gap-3">
-                <div>
-                  <div className="font-sans text-[10px] font-medium text-muted-fg/30">{selectedArtifact.backendName}</div>
-                  <div className="mt-1 text-[13px] text-fg/82">{selectedArtifact.title}</div>
-                  {selectedArtifact.description ? (
-                    <div className="mt-2 text-[11px] leading-relaxed text-fg/58">{selectedArtifact.description}</div>
-                  ) : null}
-                </div>
-                {selectedArtifact.uri ? (
+      {/* Selected artifact */}
+      {selected && (
+        <>
+          <ArtifactPreview artifact={selected} />
+
+          <div className="flex items-center justify-between gap-2">
+            <div className="min-w-0">
+              <div className="truncate text-[11px] text-fg/60">{selected.title}</div>
+              <div className="mt-0.5 flex items-center gap-2 text-[10px] text-fg/30">
+                <span>{kindLabel(selected.kind)}</span>
+                <span className={cn(
+                  "rounded px-1 py-px text-[9px] font-medium",
+                  selected.reviewState === "accepted" ? "bg-emerald-500/15 text-emerald-300/70" :
+                  selected.reviewState === "dismissed" ? "bg-red-500/15 text-red-300/70" :
+                  "bg-white/[0.06] text-fg/40",
+                )}>
+                  {selected.reviewState}
+                </span>
+              </div>
+            </div>
+            <div className="flex shrink-0 gap-1.5">
+              {selected.reviewState === "pending" && (
+                <>
                   <button
                     type="button"
-                    className="rounded-[var(--chat-radius-pill)] border border-white/[0.06] bg-black/10 px-2.5 py-1 font-sans text-[10px] font-medium text-fg/50 hover:text-fg/78"
-                    onClick={() => openArtifactUri(selectedArtifact.uri)}
+                    onClick={() => void handleAccept()}
+                    disabled={busy}
+                    className="rounded-md border border-emerald-400/20 bg-emerald-500/10 px-2 py-1 text-[10px] font-medium text-emerald-300/80 transition-colors hover:bg-emerald-500/20"
                   >
-                    {isExternalUri(selectedArtifact.uri) ? "Open" : "Reveal"}
+                    Accept
                   </button>
-                ) : null}
-              </div>
-              <div className="mt-3 flex flex-wrap gap-2 font-sans text-[10px] font-medium text-muted-fg/30">
-                <span>{formatComputerUseKind(selectedArtifact.kind)}</span>
-                <span>{selectedArtifact.workflowState}</span>
-                <span>{describeComputerUseLinks(selectedArtifact.links)}</span>
-              </div>
-            </div>
-
-            {showImagePreview ? (
-              <div className="overflow-hidden rounded-[var(--chat-radius-card)] border border-white/[0.05] bg-black/20">
-                <img
-                  src={previewUri!}
-                  alt={selectedArtifact.title}
-                  className="block max-h-[420px] w-full object-contain"
-                />
-              </div>
-            ) : null}
-
-            {showVideoPreview ? (
-              <div className="overflow-hidden rounded-[var(--chat-radius-card)] border border-white/[0.05] bg-black/20 p-2">
-                <video src={previewUri!} controls className="block max-h-[420px] w-full rounded-[calc(var(--chat-radius-card)-8px)] bg-black" />
-              </div>
-            ) : null}
-
-            {!showImagePreview && !showVideoPreview && selectedArtifact.uri ? (
-              <div className="rounded-[var(--chat-radius-card)] border border-white/[0.05] bg-black/10 px-3 py-2 font-sans text-[11px] text-muted-fg/34">
-                Inline preview is available for screenshots and recordings. Use open or reveal for this artifact type.
-              </div>
-            ) : null}
-
-            <div className="flex flex-wrap gap-2">
-              <button type="button" className="rounded-[var(--chat-radius-pill)] border border-emerald-400/18 bg-emerald-500/8 px-2.5 py-1 font-sans text-[10px] font-medium text-emerald-200/80" onClick={() => void updateReview(selectedArtifact.id, "accepted", "promoted")} disabled={busy}>Accept</button>
-              <button type="button" className="rounded-[var(--chat-radius-pill)] border border-amber-400/18 bg-amber-500/8 px-2.5 py-1 font-sans text-[10px] font-medium text-amber-200/80" onClick={() => void updateReview(selectedArtifact.id, "needs_more")} disabled={busy}>Need more</button>
-              <button type="button" className="rounded-[var(--chat-radius-pill)] border border-red-400/18 bg-red-500/8 px-2.5 py-1 font-sans text-[10px] font-medium text-red-200/80" onClick={() => void updateReview(selectedArtifact.id, "dismissed", "dismissed")} disabled={busy}>Dismiss</button>
-              <button type="button" className="rounded-[var(--chat-radius-pill)] border border-sky-400/18 bg-sky-500/8 px-2.5 py-1 font-sans text-[10px] font-medium text-sky-200/80" onClick={() => void updateReview(selectedArtifact.id, "accepted", "published")} disabled={busy}>Publish</button>
-            </div>
-
-            <div className="rounded-[var(--chat-radius-card)] border border-white/[0.05] bg-black/10 px-3 py-3">
-              <div className="font-sans text-[10px] font-medium text-muted-fg/30">Route Artifact</div>
-              <div className="mt-2 flex flex-wrap gap-2">
-                {routePresets.map((preset) => (
                   <button
-                    key={`${preset.owner.kind}:${preset.owner.id}`}
                     type="button"
-                    className="rounded-[var(--chat-radius-pill)] border border-white/[0.06] bg-black/10 px-2.5 py-1 font-sans text-[10px] font-medium text-fg/50 hover:text-fg/78"
-                    onClick={() => void routeArtifact(selectedArtifact.id, preset.owner.kind, preset.owner.id)}
+                    onClick={() => void handleDismiss()}
                     disabled={busy}
+                    className="rounded-md border border-white/[0.06] px-2 py-1 text-[10px] font-medium text-fg/40 transition-colors hover:bg-white/[0.06] hover:text-fg/60"
                   >
-                    {preset.label}
+                    Dismiss
                   </button>
-                ))}
-              </div>
-              <div className="mt-3 grid gap-2 md:grid-cols-[140px_minmax(0,1fr)_auto]">
-                <select
-                  value={routeKind}
-                  onChange={(event) => setRouteKind(event.target.value as ComputerUseArtifactOwnerKind)}
-                  className="h-8 rounded-[var(--chat-radius-pill)] border border-white/[0.06] bg-black/10 px-2 font-sans text-[11px] text-fg/78 outline-none"
-                >
-                  <option value="mission">mission</option>
-                  <option value="lane">lane</option>
-                  <option value="github_pr">GitHub PR</option>
-                  <option value="linear_issue">linear issue</option>
-                </select>
-                <input
-                  value={routeTargetId}
-                  onChange={(event) => setRouteTargetId(event.target.value)}
-                  placeholder="Target ID"
-                  className="h-8 rounded-[var(--chat-radius-pill)] border border-white/[0.06] bg-black/10 px-2 font-sans text-[11px] text-fg/78 outline-none placeholder:text-muted-fg/24"
-                />
+                </>
+              )}
+              {selected.uri && (
                 <button
                   type="button"
-                  className="rounded-[var(--chat-radius-pill)] border border-white/[0.06] bg-black/10 px-3 font-sans text-[10px] font-medium text-fg/50 hover:text-fg/78"
-                  onClick={() => void routeArtifact(selectedArtifact.id, routeKind, routeTargetId)}
-                  disabled={busy || !routeTargetId.trim()}
+                  onClick={handleReveal}
+                  className="rounded-md border border-white/[0.06] px-2 py-1 text-[10px] font-medium text-fg/40 transition-colors hover:bg-white/[0.06] hover:text-fg/60"
                 >
-                  Attach
+                  Reveal
                 </button>
-              </div>
+              )}
             </div>
           </div>
-        ) : null}
-      </div>
-
-      {error ? <div className="font-sans text-[11px] text-amber-200/80">{error}</div> : null}
+        </>
+      )}
     </div>
   );
 }
diff --git a/apps/desktop/src/renderer/components/lanes/CreateLaneDialog.tsx b/apps/desktop/src/renderer/components/lanes/CreateLaneDialog.tsx
index b5052ec67..c8583e11c 100644
--- a/apps/desktop/src/renderer/components/lanes/CreateLaneDialog.tsx
+++ b/apps/desktop/src/renderer/components/lanes/CreateLaneDialog.tsx
@@ -1,4 +1,4 @@
-import { GitBranch, Plus, StackSimple } from "@phosphor-icons/react";
+import { GitBranch, GitFork, Plus, StackSimple } from "@phosphor-icons/react";
 import { Button } from "../ui/Button";
 import type { LaneSummary, LaneEnvInitProgress, LaneTemplate } from "../../../shared/types";
 import type { LaneBranchOption } from "./laneUtils";
@@ -6,9 +6,19 @@ import { LaneEnvInitProgressPanel } from "./LaneEnvInitProgress";
 import { LaneDialogShell } from "./LaneDialogShell";
 import { SECTION_CLASS_NAME, LABEL_CLASS_NAME, INPUT_CLASS_NAME, SELECT_CLASS_NAME } from "./laneDialogTokens";
 
-function buttonLabel(busy: boolean | undefined, createAsChild: boolean, parentLaneId: string, baseBranch: string): string {
-  if (busy) return "Setting up lane...";
-  if (createAsChild && parentLaneId) return "Create child lane";
+export type CreateLaneMode = "primary" | "existing" | "child";
+
+const MODE_META: Record<CreateLaneMode, { icon: typeof GitBranch; label: string }> = {
+  primary:  { icon: GitBranch,    label: "From primary" },
+  existing: { icon: GitFork,      label: "Existing branch" },
+  child:    { icon: StackSimple,  label: "Child lane" },
+};
+
+function submitLabel(busy: boolean | undefined, mode: CreateLaneMode, baseBranch: string, laneCreated: boolean | undefined): string {
+  if (busy) return "Setting up lane\u2026";
+  if (laneCreated) return "Retry environment setup";
+  if (mode === "child") return "Create child lane";
+  if (mode === "existing") return "Import as lane";
   return `Create from ${baseBranch || "primary"}`;
 }
 
@@ -17,18 +27,21 @@ export function CreateLaneDialog({
   onOpenChange,
   createLaneName,
   setCreateLaneName,
-  createAsChild,
-  setCreateAsChild,
+  createMode,
+  setCreateMode,
   createParentLaneId,
   setCreateParentLaneId,
   createBaseBranch,
   setCreateBaseBranch,
+  createImportBranch,
+  setCreateImportBranch,
   createBranches,
   lanes,
   onSubmit,
   busy,
   error,
   envInitProgress,
+  laneCreated,
   templates,
   selectedTemplateId,
   setSelectedTemplateId,
@@ -38,70 +51,198 @@ export function CreateLaneDialog({
   onOpenChange: (open: boolean) => void;
   createLaneName: string;
   setCreateLaneName: (v: string) => void;
-  createAsChild: boolean;
-  setCreateAsChild: (v: boolean) => void;
+  createMode: CreateLaneMode;
+  setCreateMode: (v: CreateLaneMode) => void;
   createParentLaneId: string;
   setCreateParentLaneId: (v: string) => void;
   createBaseBranch: string;
   setCreateBaseBranch: (v: string) => void;
+  createImportBranch: string;
+  setCreateImportBranch: (v: string) => void;
   createBranches: LaneBranchOption[];
   lanes: LaneSummary[];
   onSubmit: () => void;
   busy?: boolean;
   error?: string | null;
   envInitProgress?: LaneEnvInitProgress | null;
+  /** When true, the lane has already been created and the CTA only retries env setup. */
+  laneCreated?: boolean;
   templates: LaneTemplate[];
   selectedTemplateId: string;
   setSelectedTemplateId: (id: string) => void;
   onNavigateToTemplates?: () => void;
 }) {
-  const localBranches = createBranches.filter((branch) => !branch.isRemote);
-  const selectedTemplate = templates.find((template) => template.id === selectedTemplateId) ?? null;
+  const localBranches = createBranches.filter((b) => !b.isRemote);
+  const allBranches = createBranches;
+  const selectedTemplate = templates.find((t) => t.id === selectedTemplateId) ?? null;
+
+  // When the lane already exists, the CTA only retries env setup — no form
+  // validation needed beyond not being busy.
+  const isSubmitDisabled = laneCreated
+    ? !!busy
+    : (busy
+      || !createLaneName.trim()
+      || (createMode === "child" && !createParentLaneId)
+      || (createMode === "primary" && !createBaseBranch)
+      || (createMode === "existing" && !createImportBranch));
 
   return (
     <LaneDialogShell
       open={open}
       onOpenChange={onOpenChange}
       title="Create lane"
-      description="Start a fresh lane from primary or branch from an existing lane. Templates can install deps, copy files, and preconfigure the lane."
       icon={Plus}
-      widthClassName="w-[min(720px,calc(100vw-24px))]"
+      widthClassName="w-[min(560px,calc(100vw-24px))]"
       busy={busy}
     >
-      <div className="space-y-4">
+      <div className="space-y-3">
+        {/* Lane name */}
         <section className={SECTION_CLASS_NAME}>
           <label className="block">
             <span className={LABEL_CLASS_NAME}>Lane name</span>
             <input
               value={createLaneName}
-              onChange={(event) => setCreateLaneName(event.target.value)}
+              onChange={(e) => setCreateLaneName(e.target.value)}
               placeholder="e.g. feature/auth-refresh"
               className={INPUT_CLASS_NAME}
               autoFocus
-              disabled={busy}
+              disabled={busy || laneCreated}
             />
           </label>
         </section>
 
+        {/* Starting point — mode picker + contextual field */}
         <section className={SECTION_CLASS_NAME}>
-          <div className="flex items-start justify-between gap-3">
-            <div>
-              <div className={LABEL_CLASS_NAME}>Template</div>
-              <div className="mt-1 text-sm text-muted-fg">
-                Optional automation for dependency install, file copy, and lane setup.
-              </div>
-            </div>
+          <span className={LABEL_CLASS_NAME}>Starting point</span>
+
+          {/* Compact pill tabs */}
+          <div className="mt-2 inline-flex rounded-lg border border-white/[0.06] bg-white/[0.02] p-0.5">
+            {(["primary", "existing", "child"] as const).map((mode) => {
+              const meta = MODE_META[mode];
+              const Icon = meta.icon;
+              const active = createMode === mode;
+              return (
+                <button
+                  key={mode}
+                  type="button"
+                  aria-pressed={active}
+                  disabled={busy || laneCreated}
+                  onClick={() => {
+                    setCreateMode(mode);
+                    if (mode !== "child") setCreateParentLaneId("");
+                  }}
+                  className={`inline-flex items-center gap-1.5 rounded-md px-3 py-1.5 text-xs font-medium transition-colors ${
+                    active
+                      ? "bg-accent/15 text-accent shadow-sm"
+                      : "text-muted-fg hover:text-fg"
+                  }`}
+                >
+                  <Icon size={12} />
+                  {meta.label}
+                </button>
+              );
+            })}
+          </div>
+
+          {/* Contextual field for selected mode */}
+          <div className="mt-3">
+            {createMode === "primary" ? (
+              localBranches.length > 0 ? (
+                <>
+                  <select
+                    value={createBaseBranch}
+                    onChange={(e) => setCreateBaseBranch(e.target.value)}
+                    className={SELECT_CLASS_NAME + " !mt-0"}
+                    disabled={busy || laneCreated}
+                    aria-label="Base branch"
+                  >
+                    {localBranches.map((b) => (
+                      <option key={b.name} value={b.name}>
+                        {b.name}{b.isCurrent ? " (current)" : ""}
+                      </option>
+                    ))}
+                  </select>
+                  {createBaseBranch ? (
+                    <div className="mt-1.5 text-[11px] text-muted-fg/60">
+                      Base: {createBaseBranch} — rebase suggestions will track this branch
+                    </div>
+                  ) : null}
+                </>
+              ) : (
+                <div className="rounded-lg border border-dashed border-white/[0.08] bg-black/10 px-3 py-2 text-xs text-muted-fg">
+                  No local branches found.
+                </div>
+              )
+            ) : null}
+
+            {createMode === "existing" ? (
+              allBranches.length > 0 ? (
+                <>
+                  <select
+                    value={createImportBranch}
+                    onChange={(e) => setCreateImportBranch(e.target.value)}
+                    className={SELECT_CLASS_NAME + " !mt-0"}
+                    disabled={busy || laneCreated}
+                    aria-label="Import branch"
+                  >
+                    <option value="">Select a branch\u2026</option>
+                    {allBranches.map((b) => (
+                      <option key={b.name} value={b.name}>
+                        {b.name}{b.isRemote ? " (remote)" : ""}
+                      </option>
+                    ))}
+                  </select>
+                  {createImportBranch ? (
+                    <div className="mt-1.5 text-[11px] text-muted-fg/60">
+                      Base will be auto-detected from git history
+                    </div>
+                  ) : null}
+                </>
+              ) : (
+                <div className="rounded-lg border border-dashed border-white/[0.08] bg-black/10 px-3 py-2 text-xs text-muted-fg">
+                  No branches found.
+                </div>
+              )
+            ) : null}
+
+            {createMode === "child" ? (
+              <>
+                <select
+                  value={createParentLaneId}
+                  onChange={(e) => setCreateParentLaneId(e.target.value)}
+                  className={SELECT_CLASS_NAME + " !mt-0"}
+                  disabled={busy || laneCreated}
+                  aria-label="Parent lane"
+                >
+                  <option value="">Select parent lane\u2026</option>
+                  {lanes.map((lane) => (
+                    <option key={lane.id} value={lane.id}>
+                      {lane.name} ({lane.branchRef})
+                    </option>
+                  ))}
+                </select>
+                {createParentLaneId ? (
+                  <div className="mt-1.5 text-[11px] text-muted-fg/60">
+                    Base: {lanes.find((l) => l.id === createParentLaneId)?.branchRef ?? "unknown"} — rebase suggestions will track parent lane
+                  </div>
+                ) : null}
+              </>
+            ) : null}
+          </div>
+        </section>
+
+        {/* Template — compact row, not a big section */}
+        <section className={SECTION_CLASS_NAME}>
+          <div className="flex items-center justify-between gap-3">
+            <span className={LABEL_CLASS_NAME}>Template</span>
             {onNavigateToTemplates ? (
               <button
                 type="button"
-                className="inline-flex h-8 items-center rounded-lg border border-white/[0.06] bg-white/[0.03] px-3 text-[11px] font-medium text-fg transition-colors hover:border-accent/30 hover:text-accent"
-                disabled={busy}
-                onClick={() => {
-                  onOpenChange(false);
-                  onNavigateToTemplates();
-                }}
+                className="text-[10px] font-medium text-muted-fg/60 transition-colors hover:text-accent"
+                disabled={busy || laneCreated}
+                onClick={() => { onOpenChange(false); onNavigateToTemplates(); }}
               >
-                {templates.length > 0 ? "Manage templates" : "Create template"}
+                {templates.length > 0 ? "Manage" : "Create template"}
               </button>
             ) : null}
           </div>
@@ -109,129 +250,36 @@ export function CreateLaneDialog({
             <>
               <select
                 value={selectedTemplateId}
-                onChange={(event) => setSelectedTemplateId(event.target.value)}
+                onChange={(e) => setSelectedTemplateId(e.target.value)}
                 className={SELECT_CLASS_NAME}
-                disabled={busy}
+                disabled={busy || laneCreated}
+                aria-label="Template"
               >
-                <option value="">No template</option>
-                {templates.map((template) => (
-                  <option key={template.id} value={template.id}>
-                    {template.name}
-                    {template.description ? ` — ${template.description}` : ""}
+                <option value="">None</option>
+                {templates.map((t) => (
+                  <option key={t.id} value={t.id}>
+                    {t.name}{t.description ? ` — ${t.description}` : ""}
                   </option>
                 ))}
               </select>
-              <div className="mt-2 text-xs text-muted-fg/80">
-                {selectedTemplate?.description ?? "Create a lane with the default environment setup."}
-              </div>
+              {selectedTemplate?.description ? (
+                <div className="mt-1.5 text-[11px] text-muted-fg/60">{selectedTemplate.description}</div>
+              ) : null}
             </>
           ) : (
-            <div className="mt-3 rounded-lg border border-dashed border-white/[0.08] bg-black/10 px-3 py-3 text-sm text-muted-fg">
-              No templates yet. Create one to copy folders, install dependencies, and configure lanes automatically.
+            <div className="mt-2 text-xs text-muted-fg/50">
+              No templates yet.
             </div>
           )}
         </section>
 
-        <section className={SECTION_CLASS_NAME}>
-          <div className="flex items-start gap-3">
-            <span className="inline-flex h-9 w-9 shrink-0 items-center justify-center rounded-lg border border-white/[0.06] bg-white/[0.03] text-accent">
-              {createAsChild ? <StackSimple size={16} /> : <GitBranch size={16} />}
-            </span>
-            <div className="min-w-0 flex-1">
-              <div className={LABEL_CLASS_NAME}>Starting point</div>
-              <div className="mt-1 text-sm text-muted-fg">
-                Choose whether the new lane starts as its own branch from primary or stacks under another lane.
-              </div>
-              <div className="mt-3 grid grid-cols-2 gap-2">
-                <button
-                  type="button"
-                  className={`rounded-lg border px-3 py-2 text-left text-sm transition-colors ${
-                    !createAsChild
-                      ? "border-accent/35 bg-accent/10 text-fg"
-                      : "border-white/[0.06] bg-white/[0.02] text-muted-fg hover:text-fg"
-                  }`}
-                  disabled={busy}
-                  onClick={() => {
-                    setCreateAsChild(false);
-                    setCreateParentLaneId("");
-                  }}
-                >
-                  <div className="font-medium">From primary</div>
-                  <div className="mt-1 text-xs text-muted-fg">Create an independent lane from the selected branch on primary.</div>
-                </button>
-                <button
-                  type="button"
-                  className={`rounded-lg border px-3 py-2 text-left text-sm transition-colors ${
-                    createAsChild
-                      ? "border-accent/35 bg-accent/10 text-fg"
-                      : "border-white/[0.06] bg-white/[0.02] text-muted-fg hover:text-fg"
-                  }`}
-                  disabled={busy}
-                  onClick={() => setCreateAsChild(true)}
-                >
-                  <div className="font-medium">Child lane</div>
-                  <div className="mt-1 text-xs text-muted-fg">Stack the lane under an existing lane and follow that parent for rebases.</div>
-                </button>
-              </div>
-
-              {createAsChild ? (
-                <label className="mt-4 block">
-                  <span className={LABEL_CLASS_NAME}>Parent lane</span>
-                  <select
-                    value={createParentLaneId}
-                    onChange={(event) => setCreateParentLaneId(event.target.value)}
-                    className={SELECT_CLASS_NAME}
-                    disabled={busy}
-                  >
-                    <option value="">Select a parent lane...</option>
-                    {lanes.map((lane) => (
-                      <option key={lane.id} value={lane.id}>
-                        {lane.name} ({lane.branchRef})
-                      </option>
-                    ))}
-                  </select>
-                  <div className="mt-2 text-xs text-muted-fg/80">
-                    The new lane will be created as a child of the selected lane.
-                  </div>
-                </label>
-              ) : (
-                <label className="mt-4 block">
-                  <span className={LABEL_CLASS_NAME}>Base branch on primary</span>
-                  {localBranches.length > 0 ? (
-                    <select
-                      value={createBaseBranch}
-                      onChange={(event) => setCreateBaseBranch(event.target.value)}
-                      className={SELECT_CLASS_NAME}
-                      disabled={busy}
-                    >
-                      {localBranches.map((branch) => (
-                        <option key={branch.name} value={branch.name}>
-                          {branch.name}
-                          {branch.isCurrent ? " (current)" : ""}
-                        </option>
-                      ))}
-                    </select>
-                  ) : (
-                    <div className="mt-1 rounded-lg border border-dashed border-white/[0.08] bg-black/10 px-3 py-2 text-sm text-muted-fg">
-                      No local branches found.
-                    </div>
-                  )}
-                  <div className="mt-2 text-xs text-muted-fg/80">
-                    Lane will be created from primary/{createBaseBranch || "..."} as its own lane, not stacked under Primary.
-                  </div>
-                </label>
-              )}
-            </div>
-          </div>
-        </section>
-
         {error ? (
           <div className="rounded-xl border border-red-500/25 bg-red-500/10 px-3 py-2 text-sm text-red-200">
             {error}
           </div>
         ) : null}
 
-        <div className="flex items-center justify-end gap-2">
+        <div className="flex items-center justify-end gap-2 pt-1">
           <Button
             variant="outline"
             disabled={busy}
@@ -239,18 +287,15 @@ export function CreateLaneDialog({
               onOpenChange(false);
               setCreateLaneName("");
               setCreateParentLaneId("");
-              setCreateAsChild(false);
+              setCreateMode("primary");
               setCreateBaseBranch("");
+              setCreateImportBranch("");
             }}
           >
             Cancel
           </Button>
-          <Button
-            variant="primary"
-            disabled={busy || !createLaneName.trim() || (createAsChild ? !createParentLaneId : !createBaseBranch)}
-            onClick={onSubmit}
-          >
-            {buttonLabel(busy, createAsChild, createParentLaneId, createBaseBranch)}
+          <Button variant="primary" disabled={isSubmitDisabled} onClick={onSubmit}>
+            {submitLabel(busy, createMode, createBaseBranch, laneCreated)}
           </Button>
         </div>
 
diff --git a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
index 8a9f27d6a..6aec74ba0 100644
--- a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
@@ -1,5 +1,5 @@
 import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { ArrowDown, ArrowsClockwise, Check, Stack, Upload, Warning } from "@phosphor-icons/react";
+import { ArrowDown, ArrowsClockwise, Check, Stack, Trash, Upload, Warning } from "@phosphor-icons/react";
 import { useNavigate } from "react-router-dom";
 import { useAppStore } from "../../state/appStore";
 import { cn } from "../ui/cn";
@@ -706,6 +706,28 @@ export function LaneGitActionsPane({
     await refreshChanges();
   };
 
+  const discardFile = (path: string) => {
+    if (!laneId) return;
+    if (busyAction) return;
+    const ok = window.confirm(`Discard all changes to ${path}? This cannot be undone.`);
+    if (!ok) return;
+    void runAction("discard file", async () => {
+      await window.ade.git.discardFile({ laneId, path });
+    });
+  };
+
+  const discardAll = () => {
+    if (!laneId) return;
+    if (busyAction) return;
+    const ok = window.confirm(`Discard ALL unstaged changes (${changes.unstaged.length} file${changes.unstaged.length === 1 ? "" : "s"})? This cannot be undone.`);
+    if (!ok) return;
+    void runAction("discard all", async () => {
+      for (const file of changes.unstaged) {
+        await window.ade.git.discardFile({ laneId, path: file.path });
+      }
+    });
+  };
+
   const stageAll = () => {
     if (!laneId) return;
     void runAction("stage all", async () => {
@@ -959,6 +981,33 @@ export function LaneGitActionsPane({
             PARTIAL
           </span>
         ) : null}
+        {mode === "unstaged" ? (
+          <button
+            type="button"
+            className="shrink-0 opacity-0 group-hover:opacity-100 focus:opacity-100 transition-opacity flex items-center justify-center"
+            style={{
+              width: 20,
+              height: 20,
+              background: "transparent",
+              border: "none",
+              cursor: "pointer",
+              color: COLORS.textDim,
+            }}
+            aria-label={`Discard changes to ${file.path}`}
+            onMouseEnter={(e) => { e.currentTarget.style.color = COLORS.danger; }}
+            onMouseLeave={(e) => { e.currentTarget.style.color = COLORS.textDim; }}
+            onFocus={(e) => { e.currentTarget.style.color = COLORS.danger; }}
+            onBlur={(e) => { e.currentTarget.style.color = COLORS.textDim; }}
+            disabled={!!busyAction}
+            onClick={(event) => {
+              event.stopPropagation();
+              void discardFile(file.path);
+            }}
+            title="Discard changes to this file. This cannot be undone."
+          >
+            <Trash size={12} />
+          </button>
+        ) : null}
       </div>
     );
   };
@@ -1312,14 +1361,24 @@ export function LaneGitActionsPane({
               type="button"
               style={{
                 ...outlineButton({ height: 30, padding: "0 10px", fontSize: 10, borderRadius: 6 }),
-                ...(nextActionHint?.action === "push" ? { color: COLORS.accent, border: `1px solid ${COLORS.accent}40`, background: `${COLORS.accent}08` } : {}),
+                ...(nextActionHint?.action === "push" || nextActionHint?.action === "force_push_lease" ? { color: COLORS.accent, border: `1px solid ${COLORS.accent}40`, background: `${COLORS.accent}08` } : {}),
               }}
               disabled={!laneId || busyAction != null}
-              onClick={() => runPush(false)}
-              title={getPushSummary(syncStatus)}
+              onClick={() => {
+                if (nextActionHint?.action === "force_push_lease") {
+                  const ok = window.confirm(
+                    "Force push with lease? This overwrites the remote branch with your local history. Only use this if you intend to publish rewritten commits.",
+                  );
+                  if (!ok) return;
+                  runPush(true);
+                } else {
+                  runPush(false);
+                }
+              }}
+              title={nextActionHint?.action === "force_push_lease" ? "Force push (lease) — history was rewritten" : getPushSummary(syncStatus)}
             >
               <Upload size={12} weight="bold" style={{ marginRight: 4 }} />
-              {syncStatus?.hasUpstream === false ? "PUBLISH" : "PUSH"}
+              {syncStatus?.hasUpstream === false ? "PUBLISH" : nextActionHint?.action === "force_push_lease" ? "FORCE PUSH" : "PUSH"}
             </button>
             {lane?.parentLaneId ? (
               <button
@@ -1552,13 +1611,26 @@ export function LaneGitActionsPane({
                   {changedFileCount}
                 </span>
                 {changes.unstaged.length > 0 ? (
-                  <button
-                    type="button"
-                    style={outlineButton({ height: 24, padding: "0 8px", fontSize: 10 })}
-                    onClick={stageAll}
-                  >
-                    STAGE ALL
-                  </button>
+                  <>
+                    <button
+                      type="button"
+                      style={outlineButton({ height: 24, padding: "0 8px", fontSize: 10 })}
+                      onClick={stageAll}
+                      disabled={busyAction != null}
+                      title={busyAction != null ? "Action in progress" : "Stage all unstaged changes"}
+                    >
+                      STAGE ALL
+                    </button>
+                    <button
+                      type="button"
+                      style={dangerButton({ height: 24, padding: "0 8px", fontSize: 10 })}
+                      onClick={discardAll}
+                      disabled={busyAction != null}
+                      title="Discard all unstaged changes. This cannot be undone."
+                    >
+                      DISCARD ALL
+                    </button>
+                  </>
                 ) : null}
                 {changes.staged.length > 0 ? (
                   <button
diff --git a/apps/desktop/src/renderer/components/lanes/LanesPage.test.ts b/apps/desktop/src/renderer/components/lanes/LanesPage.test.ts
index fd93b4256..1d23e66a6 100644
--- a/apps/desktop/src/renderer/components/lanes/LanesPage.test.ts
+++ b/apps/desktop/src/renderer/components/lanes/LanesPage.test.ts
@@ -6,9 +6,10 @@ describe("resolveCreateLaneRequest", () => {
     expect(
       resolveCreateLaneRequest({
         name: "git actions fixes",
-        createAsChild: false,
+        createMode: "primary",
         createParentLaneId: "lane-primary",
         createBaseBranch: "main",
+        createImportBranch: "",
       }),
     ).toEqual({
       kind: "root",
@@ -19,13 +20,14 @@ describe("resolveCreateLaneRequest", () => {
     });
   });
 
-  it("creates a stacked child lane only when child mode is selected", () => {
+  it("creates a stacked child lane when child mode is selected", () => {
     expect(
       resolveCreateLaneRequest({
         name: "git actions fixes",
-        createAsChild: true,
+        createMode: "child",
         createParentLaneId: "lane-primary",
         createBaseBranch: "main",
+        createImportBranch: "",
       }),
     ).toEqual({
       kind: "child",
@@ -35,4 +37,22 @@ describe("resolveCreateLaneRequest", () => {
       },
     });
   });
+
+  it("imports an existing branch as a lane when existing mode is selected", () => {
+    expect(
+      resolveCreateLaneRequest({
+        name: "git actions fixes",
+        createMode: "existing",
+        createParentLaneId: "",
+        createBaseBranch: "release-10",
+        createImportBranch: "origin/ade/git-actions-fixes-5144fe89",
+      }),
+    ).toEqual({
+      kind: "import",
+      args: {
+        branchRef: "origin/ade/git-actions-fixes-5144fe89",
+        name: "git actions fixes",
+      },
+    });
+  });
 });
diff --git a/apps/desktop/src/renderer/components/lanes/LanesPage.tsx b/apps/desktop/src/renderer/components/lanes/LanesPage.tsx
index 9d587c499..76190e076 100644
--- a/apps/desktop/src/renderer/components/lanes/LanesPage.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LanesPage.tsx
@@ -16,7 +16,7 @@ import { LaneStackPane } from "./LaneStackPane";
 import { LaneGitActionsPane } from "./LaneGitActionsPane";
 import { LaneDiffPane } from "./LaneDiffPane";
 import { LaneWorkPane } from "./LaneWorkPane";
-import { CreateLaneDialog } from "./CreateLaneDialog";
+import { CreateLaneDialog, type CreateLaneMode } from "./CreateLaneDialog";
 import { AttachLaneDialog } from "./AttachLaneDialog";
 import { ManageLaneDialog } from "./ManageLaneDialog";
 import { LaneContextMenu } from "./LaneContextMenu";
@@ -82,15 +82,17 @@ const ADOPT_HINT_DISMISSED_KEY = "ade.lanes.adoptHintDismissed.v1";
 
 type CreateLaneRequest =
   | { kind: "child"; args: { name: string; parentLaneId: string } }
-  | { kind: "root"; args: { name: string; baseBranch: string } };
+  | { kind: "root"; args: { name: string; baseBranch: string } }
+  | { kind: "import"; args: { branchRef: string; name: string; baseBranch?: string } };
 
 export function resolveCreateLaneRequest(args: {
   name: string;
-  createAsChild: boolean;
+  createMode: CreateLaneMode;
   createParentLaneId: string;
   createBaseBranch: string;
+  createImportBranch: string;
 }): CreateLaneRequest {
-  if (args.createAsChild) {
+  if (args.createMode === "child") {
     return {
       kind: "child",
       args: {
@@ -100,6 +102,16 @@ export function resolveCreateLaneRequest(args: {
     };
   }
 
+  if (args.createMode === "existing") {
+    return {
+      kind: "import",
+      args: {
+        branchRef: args.createImportBranch,
+        name: args.name,
+      },
+    };
+  }
+
   return {
     kind: "root",
     args: {
@@ -132,13 +144,16 @@ export function LanesPage() {
   const [createOpen, setCreateOpen] = useState(false);
   const [createLaneName, setCreateLaneName] = useState("");
   const [createParentLaneId, setCreateParentLaneId] = useState<string>("");
-  const [createAsChild, setCreateAsChild] = useState(false);
+  const [createMode, setCreateMode] = useState<CreateLaneMode>("primary");
   const [createBaseBranch, setCreateBaseBranch] = useState("");
+  const [createImportBranch, setCreateImportBranch] = useState("");
   const [createBranches, setCreateBranches] = useState<LaneBranchOption[]>([]);
   const [createBusy, setCreateBusy] = useState(false);
   const [createError, setCreateError] = useState<string | null>(null);
   const [createEnvInitProgress, setCreateEnvInitProgress] = useState<LaneEnvInitProgress | null>(null);
+  const [laneCreated, setLaneCreated] = useState(false);
   const createEnvInitLaneIdRef = useRef<string | null>(null);
+  const createBaseBranchUserPickedRef = useRef(false);
   const [templates, setTemplates] = useState<LaneTemplate[]>([]);
   const [selectedTemplateId, setSelectedTemplateId] = useState("");
   const [attachOpen, setAttachOpen] = useState(false);
@@ -1057,10 +1072,13 @@ export function LanesPage() {
 
   const resetCreateDialogState = useCallback(() => {
     createEnvInitLaneIdRef.current = null;
+    createBaseBranchUserPickedRef.current = false;
+    setLaneCreated(false);
     setCreateLaneName("");
     setCreateParentLaneId("");
-    setCreateAsChild(false);
+    setCreateMode("primary");
     setCreateBaseBranch("");
+    setCreateImportBranch("");
     setCreateBusy(false);
     setCreateError(null);
     setCreateEnvInitProgress(null);
@@ -1070,15 +1088,26 @@ export function LanesPage() {
   const prepareCreateDialog = useCallback(() => {
     setCreateLaneName("");
     setCreateParentLaneId("");
-    setCreateAsChild(false);
+    setCreateMode("primary");
     setCreateBaseBranch("");
+    setCreateImportBranch("");
+    setCreateBranches([]);
+    setLaneCreated(false);
+    createBaseBranchUserPickedRef.current = false;
     const primary = lanes.find((l) => l.laneType === "primary");
     if (primary) {
-      window.ade.git.listBranches({ laneId: primary.id })
+      // Fetch remotes first so remote-only branches (pushed from other machines) appear.
+      window.ade.git.fetch({ laneId: primary.id })
+        .catch(() => {})
+        .then(() => window.ade.git.listBranches({ laneId: primary.id }))
         .then((branches) => {
+          if (!branches) return;
           setCreateBranches(branches);
-          const current = branches.find((b) => b.isCurrent && !b.isRemote);
-          if (current) setCreateBaseBranch(current.name);
+          // Only auto-select the current branch if the user hasn't already picked one.
+          if (!createBaseBranchUserPickedRef.current) {
+            const current = branches.find((b) => b.isCurrent && !b.isRemote);
+            if (current) setCreateBaseBranch(current.name);
+          }
         })
         .catch(() => {});
     }
@@ -1102,9 +1131,53 @@ export function LanesPage() {
     setCreateOpen(open);
   }, [createBusy, resetCreateDialogState]);
 
+  /** Wraps setCreateBaseBranch so we can track user-driven selections and avoid
+   *  the async branch-list fetch from overwriting a value the user already picked. */
+  const handleSetCreateBaseBranch = useCallback((v: string) => {
+    createBaseBranchUserPickedRef.current = true;
+    setCreateBaseBranch(v);
+  }, []);
+
+  /** Run only the environment-setup phase (applyTemplate / initEnv) for a lane
+   *  that has already been created.  Used as the retry path when env setup fails. */
+  const runEnvSetupForCreatedLane = useCallback(async (laneId: string) => {
+    setCreateBusy(true);
+    setCreateError(null);
+    setCreateEnvInitProgress(null);
+
+    try {
+      const envProgress = selectedTemplateId
+        ? await window.ade.lanes.applyTemplate({ laneId, templateId: selectedTemplateId })
+        : await window.ade.lanes.initEnv({ laneId });
+      setCreateEnvInitProgress(envProgress);
+
+      if (envProgress.overallStatus === "failed") {
+        setCreateError("Environment setup failed. Review the progress log and retry.");
+        return;
+      }
+
+      resetCreateDialogState();
+      setCreateOpen(false);
+    } catch (err) {
+      setCreateError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setCreateBusy(false);
+    }
+  }, [selectedTemplateId, resetCreateDialogState]);
+
   const handleCreateSubmit = useCallback(async () => {
+    // If the lane was already created (e.g. env-setup failed on a previous
+    // attempt), retry only the environment setup — never re-run creation.
+    if (createEnvInitLaneIdRef.current) {
+      await runEnvSetupForCreatedLane(createEnvInitLaneIdRef.current);
+      return;
+    }
+
     const name = createLaneName.trim();
-    if (!name || createBusy || (createAsChild && !createParentLaneId) || (!createAsChild && !createBaseBranch)) return;
+    if (!name || createBusy) return;
+    if (createMode === "child" && !createParentLaneId) return;
+    if (createMode === "primary" && !createBaseBranch) return;
+    if (createMode === "existing" && !createImportBranch) return;
     if (selectedTemplateId && !templates.some((template) => template.id === selectedTemplateId)) {
       setCreateError("The selected lane template no longer exists. Refresh templates or choose a different option.");
       return;
@@ -1113,41 +1186,38 @@ export function LanesPage() {
     setCreateBusy(true);
     setCreateError(null);
     setCreateEnvInitProgress(null);
-    createEnvInitLaneIdRef.current = null;
 
     try {
       const request = resolveCreateLaneRequest({
         name,
-        createAsChild,
+        createMode,
         createParentLaneId,
         createBaseBranch,
+        createImportBranch,
       });
-      const lane = request.kind === "child"
-        ? await window.ade.lanes.createChild(request.args)
-        : await window.ade.lanes.create(request.args);
-
-      await refreshLanes();
-      navigate(`/lanes?laneId=${encodeURIComponent(lane.id)}&focus=single`);
+      let lane: LaneSummary;
+      if (request.kind === "import") {
+        lane = await window.ade.lanes.importBranch(request.args);
+      } else if (request.kind === "child") {
+        lane = await window.ade.lanes.createChild(request.args);
+      } else {
+        lane = await window.ade.lanes.create(request.args);
+      }
 
+      // Lane created successfully — record its id so retries skip creation.
       createEnvInitLaneIdRef.current = lane.id;
-      const envProgress = selectedTemplateId
-        ? await window.ade.lanes.applyTemplate({ laneId: lane.id, templateId: selectedTemplateId })
-        : await window.ade.lanes.initEnv({ laneId: lane.id });
-      setCreateEnvInitProgress(envProgress);
+      setLaneCreated(true);
 
-      if (envProgress.overallStatus === "failed") {
-        setCreateError("Lane was created, but environment setup failed. Review the progress log and retry manually if needed.");
-        return;
-      }
+      await refreshLanes();
+      navigate(`/lanes?laneId=${encodeURIComponent(lane.id)}&focus=single`);
 
-      resetCreateDialogState();
-      setCreateOpen(false);
+      // Now run environment setup as a separate phase.
+      await runEnvSetupForCreatedLane(lane.id);
     } catch (err) {
       setCreateError(err instanceof Error ? err.message : String(err));
-    } finally {
       setCreateBusy(false);
     }
-  }, [createLaneName, createAsChild, createParentLaneId, createBusy, lanes, navigate, refreshLanes, resetCreateDialogState, selectedTemplateId, templates]);
+  }, [createLaneName, createMode, createParentLaneId, createBaseBranch, createImportBranch, createBusy, navigate, refreshLanes, runEnvSetupForCreatedLane, selectedTemplateId, templates]);
 
   const handleAttachSubmit = useCallback(async () => {
     const name = attachName.trim();
@@ -1927,18 +1997,21 @@ export function LanesPage() {
         onOpenChange={handleCreateDialogOpenChange}
         createLaneName={createLaneName}
         setCreateLaneName={setCreateLaneName}
-        createAsChild={createAsChild}
-        setCreateAsChild={setCreateAsChild}
+        createMode={createMode}
+        setCreateMode={setCreateMode}
         createParentLaneId={createParentLaneId}
         setCreateParentLaneId={setCreateParentLaneId}
         createBaseBranch={createBaseBranch}
-        setCreateBaseBranch={setCreateBaseBranch}
+        setCreateBaseBranch={handleSetCreateBaseBranch}
+        createImportBranch={createImportBranch}
+        setCreateImportBranch={setCreateImportBranch}
         createBranches={createBranches}
         lanes={lanes}
         onSubmit={handleCreateSubmit}
         busy={createBusy}
         error={createError}
         envInitProgress={createEnvInitProgress}
+        laneCreated={laneCreated}
         templates={templates}
         selectedTemplateId={selectedTemplateId}
         setSelectedTemplateId={setSelectedTemplateId}
diff --git a/apps/desktop/src/renderer/components/lanes/TilingLayout.tsx b/apps/desktop/src/renderer/components/lanes/TilingLayout.tsx
index bc70fa4ff..42ba0a3f3 100644
--- a/apps/desktop/src/renderer/components/lanes/TilingLayout.tsx
+++ b/apps/desktop/src/renderer/components/lanes/TilingLayout.tsx
@@ -137,7 +137,7 @@ function TileRenderer({
 
         <div className="min-h-0 flex-1 bg-bg">
           {isChat ? (
-            <AgentChatPane laneId={laneId} lockSessionId={session.id} />
+            <AgentChatPane laneId={laneId} laneLabel={session.laneName} lockSessionId={session.id} />
           ) : isRunning ? (
             <TerminalView ptyId={session.ptyId!} sessionId={session.id} className="h-full" />
           ) : (
diff --git a/apps/desktop/src/renderer/components/prs/CreatePrModal.test.tsx b/apps/desktop/src/renderer/components/prs/CreatePrModal.test.tsx
index 35f964c26..7c3fa158e 100644
--- a/apps/desktop/src/renderer/components/prs/CreatePrModal.test.tsx
+++ b/apps/desktop/src/renderer/components/prs/CreatePrModal.test.tsx
@@ -101,6 +101,11 @@ describe("CreatePrModal queue workflow", () => {
       },
       git: {
         getSyncStatus: vi.fn().mockResolvedValue(null),
+        listBranches: vi.fn().mockResolvedValue([
+          { name: "main", isCurrent: true, isRemote: false, upstream: "origin/main" },
+          { name: "develop", isCurrent: false, isRemote: false, upstream: "origin/develop" },
+          { name: "release-9", isCurrent: false, isRemote: false, upstream: null },
+        ]),
       },
     } as any;
   });
@@ -162,10 +167,15 @@ describe("CreatePrModal queue workflow", () => {
     const user = userEvent.setup();
     render(<CreatePrModal open onOpenChange={vi.fn()} />);
 
-    await user.selectOptions(screen.getByRole("combobox"), "lane-1");
-    const targetBranchInput = screen.getByDisplayValue("main");
-    await user.clear(targetBranchInput);
-    await user.type(targetBranchInput, "release-9");
+    // Select source lane
+    const comboboxes = screen.getAllByRole("combobox");
+    await user.selectOptions(comboboxes[0]!, "lane-1");
+
+    // Wait for branches to load, then type a different target branch
+    await waitFor(() => expect(screen.getByDisplayValue("main")).toBeTruthy());
+    const targetInput = screen.getByDisplayValue("main");
+    await user.clear(targetInput);
+    await user.type(targetInput, "release-9");
 
     await user.click(screen.getByRole("button", { name: /next step/i }));
     await user.click(screen.getByRole("button", { name: /create pr/i }));
@@ -183,10 +193,15 @@ describe("CreatePrModal queue workflow", () => {
     const user = userEvent.setup();
     render(<CreatePrModal open onOpenChange={vi.fn()} />);
 
-    await user.selectOptions(screen.getByRole("combobox"), "lane-1");
-    const targetBranchInput = screen.getByDisplayValue("main");
-    await user.clear(targetBranchInput);
-    await user.type(targetBranchInput, "release-9");
+    // Select source lane
+    const comboboxes = screen.getAllByRole("combobox");
+    await user.selectOptions(comboboxes[0]!, "lane-1");
+
+    // Wait for branches to load, then type a different target branch
+    await waitFor(() => expect(screen.getByDisplayValue("main")).toBeTruthy());
+    const targetInput = screen.getByDisplayValue("main");
+    await user.clear(targetInput);
+    await user.type(targetInput, "release-9");
 
     expect(screen.getByText("Lane Needs Attention")).toBeTruthy();
     expect(screen.getByText(/targets release-9, but this lane currently tracks main/i)).toBeTruthy();
@@ -200,9 +215,11 @@ describe("CreatePrModal queue workflow", () => {
     await user.click(screen.getAllByRole("button", { name: /queue workflow/i })[0]!);
     await user.click(screen.getByRole("checkbox", { name: /01 queue lane/i }));
 
-    const targetBranchInput = screen.getByDisplayValue("main");
-    await user.clear(targetBranchInput);
-    await user.type(targetBranchInput, "release-9");
+    // Wait for branches to load, then type a different target branch
+    await waitFor(() => expect(screen.getByDisplayValue("main")).toBeTruthy());
+    const targetInput = screen.getByDisplayValue("main");
+    await user.clear(targetInput);
+    await user.type(targetInput, "release-9");
 
     await user.click(screen.getByRole("button", { name: /next step/i }));
     await user.click(screen.getByRole("button", { name: /create pr/i }));
diff --git a/apps/desktop/src/renderer/components/prs/CreatePrModal.tsx b/apps/desktop/src/renderer/components/prs/CreatePrModal.tsx
index ad6b5083b..63ca3dfe4 100644
--- a/apps/desktop/src/renderer/components/prs/CreatePrModal.tsx
+++ b/apps/desktop/src/renderer/components/prs/CreatePrModal.tsx
@@ -9,6 +9,7 @@ import type {
   IntegrationProposalStep,
   CreateIntegrationPrResult,
   GitUpstreamSyncStatus,
+  GitBranchSummary,
   LaneSummary,
 } from "../../../shared/types";
 import { COLORS, MONO_FONT, LABEL_STYLE } from "../lanes/laneDesignTokens";
@@ -72,6 +73,17 @@ const inputStyle: React.CSSProperties = {
   transition: "border-color 0.15s",
 };
 
+const selectStyle: React.CSSProperties = {
+  ...inputStyle,
+  paddingLeft: 32,
+  appearance: "none",
+  WebkitAppearance: "none",
+  cursor: "pointer",
+  backgroundImage: `url("data:image/svg+xml,%3Csvg width='10' height='6' viewBox='0 0 10 6' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M1 1l4 4 4-4' stroke='%2371717A' stroke-width='1.5' fill='none' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E")`,
+  backgroundRepeat: "no-repeat",
+  backgroundPosition: "right 12px center",
+};
+
 const textareaStyle: React.CSSProperties = {
   ...inputStyle,
   resize: "none" as const,
@@ -500,6 +512,62 @@ export function CreatePrModal({
 
   const [draftError, setDraftError] = React.useState<string | null>(null);
 
+  // Available branches for target-branch dropdowns
+  const [availableBranches, setAvailableBranches] = React.useState<GitBranchSummary[]>([]);
+  const [branchLoadError, setBranchLoadError] = React.useState<string | null>(null);
+
+  React.useEffect(() => {
+    if (!open || !primaryLane) return;
+    let cancelled = false;
+    setBranchLoadError(null);
+    window.ade.git.listBranches({ laneId: primaryLane.id })
+      .then((branches) => {
+        if (!cancelled) setAvailableBranches(branches);
+      })
+      .catch((err: unknown) => {
+        console.error("[CreatePrModal] listBranches failed", { laneId: primaryLane.id, err });
+        if (!cancelled) {
+          setBranchLoadError(err instanceof Error ? err.message : String(err));
+        }
+      });
+    return () => { cancelled = true; };
+  }, [open, primaryLane?.id]);
+
+  /** Deduplicated list of branch names suitable for a target-branch dropdown. */
+  const targetBranchOptions = React.useMemo(() => {
+    const seen = new Set<string>();
+    const options: string[] = [];
+    for (const b of availableBranches) {
+      // For remote branches like "origin/main", strip the remote prefix
+      const name = b.isRemote
+        ? b.name.replace(/^[^/]+\//, "")
+        : b.name;
+      if (!seen.has(name)) {
+        seen.add(name);
+        options.push(name);
+      }
+    }
+    return options.sort((a, b) => a.localeCompare(b));
+  }, [availableBranches]);
+
+  const normalBranchSelectOptions = React.useMemo(() => {
+    const v = normalBaseBranch.trim();
+    if (!v.length) return targetBranchOptions;
+    return [v, ...targetBranchOptions.filter((b) => b !== v)];
+  }, [targetBranchOptions, normalBaseBranch]);
+
+  const queueBranchSelectOptions = React.useMemo(() => {
+    const v = queueTargetBranch.trim();
+    if (!v.length) return targetBranchOptions;
+    return [v, ...targetBranchOptions.filter((b) => b !== v)];
+  }, [targetBranchOptions, queueTargetBranch]);
+
+  const integrationBranchSelectOptions = React.useMemo(() => {
+    const v = integrationBaseBranch.trim();
+    if (!v.length) return targetBranchOptions;
+    return [v, ...targetBranchOptions.filter((b) => b !== v)];
+  }, [targetBranchOptions, integrationBaseBranch]);
+
   const handleDraftAI = async (laneId: string) => {
     setDrafting(true);
     setDraftError(null);
@@ -564,6 +632,8 @@ export function CreatePrModal({
       setIntegrationProgress(null);
       setIntegrationBranchError(null);
       setQueueErrors([]);
+      setAvailableBranches([]);
+      setBranchLoadError(null);
     }, 200);
     return () => clearTimeout(id);
   }, [open]);
@@ -941,6 +1011,12 @@ export function CreatePrModal({
           {/* ── Stepper ─────────────────────────────────────────── */}
           <Stepper currentStep={numericStep} />
 
+          {branchLoadError ? (
+            <div role="alert" style={{ padding: "8px 24px", fontSize: 11, color: C.error, background: `${C.error}10` }}>
+              Could not load branch list: {branchLoadError}
+            </div>
+          ) : null}
+
           {/* ── Scrollable Body ─────────────────────────────────── */}
           <div style={{
             flex: 1,
@@ -1069,14 +1145,24 @@ export function CreatePrModal({
                             transform: "translateY(-50%)",
                             color: C.textMuted,
                             pointerEvents: "none",
+                            zIndex: 1,
                           }}
                         />
                         <input
+                          list="normalBranchOptions"
                           value={normalBaseBranch}
                           onChange={(e) => setNormalBaseBranch(e.target.value)}
-                          style={{ ...inputStyle, paddingLeft: 32 }}
-                          placeholder={branchNameFromRef(primaryLane?.branchRef ?? "main")}
+                          aria-label="Target branch"
+                          placeholder="Type or select a branch"
+                          style={selectStyle}
+                          onFocus={(e) => { e.currentTarget.style.borderColor = C.accent; }}
+                          onBlur={(e) => { e.currentTarget.style.borderColor = C.borderSubtle; }}
                         />
+                        <datalist id="normalBranchOptions">
+                          {normalBranchSelectOptions.map((name) => (
+                            <option key={name} value={name} />
+                          ))}
+                        </datalist>
                       </div>
                     </div>
 
@@ -1333,14 +1419,24 @@ export function CreatePrModal({
                             transform: "translateY(-50%)",
                             color: C.textMuted,
                             pointerEvents: "none",
+                            zIndex: 1,
                           }}
                         />
                         <input
+                          list="queueBranchOptions"
                           value={queueTargetBranch}
                           onChange={(e) => setQueueTargetBranch(e.target.value)}
-                          style={{ ...inputStyle, paddingLeft: 32 }}
-                          placeholder={branchNameFromRef(primaryLane?.branchRef ?? "main")}
+                          aria-label="Target branch"
+                          placeholder="Type or select a branch"
+                          style={selectStyle}
+                          onFocus={(e) => { e.currentTarget.style.borderColor = C.accent; }}
+                          onBlur={(e) => { e.currentTarget.style.borderColor = C.borderSubtle; }}
                         />
+                        <datalist id="queueBranchOptions">
+                          {queueBranchSelectOptions.map((name) => (
+                            <option key={name} value={name} />
+                          ))}
+                        </datalist>
                       </div>
                     </div>
                   </div>
@@ -1362,14 +1458,27 @@ export function CreatePrModal({
                             transform: "translateY(-50%)",
                             color: C.textMuted,
                             pointerEvents: "none",
+                            zIndex: 1,
                           }}
                         />
                         <input
+                          list="integrationBranchOptions"
                           value={integrationBaseBranch}
-                          onChange={(e) => setIntegrationBaseBranch(e.target.value)}
-                          style={{ ...inputStyle, paddingLeft: 32 }}
-                          placeholder={branchNameFromRef(primaryLane?.branchRef ?? "main")}
+                          onChange={(e) => {
+                            setIntegrationBaseBranch(e.target.value);
+                            setProposal(null);
+                          }}
+                          aria-label="Target branch"
+                          placeholder="Type or select a branch"
+                          style={selectStyle}
+                          onFocus={(e) => { e.currentTarget.style.borderColor = C.accent; }}
+                          onBlur={(e) => { e.currentTarget.style.borderColor = C.borderSubtle; }}
                         />
+                        <datalist id="integrationBranchOptions">
+                          {integrationBranchSelectOptions.map((name) => (
+                            <option key={name} value={name} />
+                          ))}
+                        </datalist>
                       </div>
                     </div>
 
diff --git a/apps/desktop/src/renderer/components/run/processUtils.test.ts b/apps/desktop/src/renderer/components/run/processUtils.test.ts
new file mode 100644
index 000000000..791433125
--- /dev/null
+++ b/apps/desktop/src/renderer/components/run/processUtils.test.ts
@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+import type { ProcessRuntime, ProcessRuntimeStatus } from "../../../shared/types";
+import { formatProcessStatus, hasInspectableProcessOutput, isActiveProcessStatus } from "./processUtils";
+
+const ALL_STATUSES: ProcessRuntimeStatus[] = [
+  "stopped",
+  "starting",
+  "running",
+  "degraded",
+  "stopping",
+  "exited",
+  "crashed",
+];
+
+describe("isActiveProcessStatus", () => {
+  it.each(["running", "starting", "degraded", "stopping"] as const)(
+    "returns true for '%s'",
+    (status) => {
+      expect(isActiveProcessStatus(status)).toBe(true);
+    },
+  );
+
+  it.each(["stopped", "exited", "crashed"] as const)(
+    "returns false for '%s'",
+    (status) => {
+      expect(isActiveProcessStatus(status)).toBe(false);
+    },
+  );
+
+  it("covers every status in ProcessRuntimeStatus", () => {
+    for (const status of ALL_STATUSES) {
+      expect(typeof isActiveProcessStatus(status)).toBe("boolean");
+    }
+  });
+});
+
+function makeRuntime(overrides: Partial<ProcessRuntime> = {}): ProcessRuntime {
+  return {
+    laneId: "lane-1",
+    processId: "proc-1",
+    status: "stopped",
+    readiness: "unknown",
+    pid: null,
+    startedAt: null,
+    endedAt: null,
+    exitCode: null,
+    lastExitCode: null,
+    lastEndedAt: null,
+    uptimeMs: null,
+    ports: [],
+    logPath: null,
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe("hasInspectableProcessOutput", () => {
+  it("returns false for a pristine stopped process with no timing info", () => {
+    expect(hasInspectableProcessOutput(makeRuntime({ status: "stopped" }))).toBe(false);
+  });
+
+  it("returns true for any non-stopped status", () => {
+    for (const status of ALL_STATUSES.filter((s) => s !== "stopped")) {
+      expect(hasInspectableProcessOutput(makeRuntime({ status }))).toBe(true);
+    }
+  });
+
+  it("returns true for stopped process with startedAt", () => {
+    expect(
+      hasInspectableProcessOutput(makeRuntime({ status: "stopped", startedAt: "2026-01-01T00:00:00Z" })),
+    ).toBe(true);
+  });
+
+  it("returns true for stopped process with lastEndedAt", () => {
+    expect(
+      hasInspectableProcessOutput(makeRuntime({ status: "stopped", lastEndedAt: "2026-01-01T00:00:00Z" })),
+    ).toBe(true);
+  });
+
+  it("returns true for stopped process with lastExitCode", () => {
+    expect(
+      hasInspectableProcessOutput(makeRuntime({ status: "stopped", lastExitCode: 0 })),
+    ).toBe(true);
+  });
+
+  it("returns true for stopped process with non-zero lastExitCode", () => {
+    expect(
+      hasInspectableProcessOutput(makeRuntime({ status: "stopped", lastExitCode: 1 })),
+    ).toBe(true);
+  });
+});
+
+describe("formatProcessStatus", () => {
+  it("returns plain status for non-crash/exit statuses", () => {
+    for (const status of ["stopped", "starting", "running", "degraded", "stopping"] as const) {
+      expect(formatProcessStatus({ status, lastExitCode: null })).toBe(status);
+    }
+  });
+
+  it("appends exit code to crashed status", () => {
+    expect(formatProcessStatus({ status: "crashed", lastExitCode: 137 })).toBe("crashed:137");
+  });
+
+  it("appends exit code to exited status", () => {
+    expect(formatProcessStatus({ status: "exited", lastExitCode: 0 })).toBe("exited:0");
+  });
+
+  it("returns plain status for crashed/exited without exit code", () => {
+    expect(formatProcessStatus({ status: "crashed", lastExitCode: null })).toBe("crashed");
+    expect(formatProcessStatus({ status: "exited", lastExitCode: null })).toBe("exited");
+  });
+
+  it("does not append exit code to non-crash/exit statuses even if present", () => {
+    expect(formatProcessStatus({ status: "running", lastExitCode: 1 })).toBe("running");
+    expect(formatProcessStatus({ status: "stopped", lastExitCode: 0 })).toBe("stopped");
+  });
+
+  it("handles exit code 0 for crashed status", () => {
+    expect(formatProcessStatus({ status: "crashed", lastExitCode: 0 })).toBe("crashed:0");
+  });
+});
diff --git a/apps/desktop/src/renderer/components/run/processUtils.ts b/apps/desktop/src/renderer/components/run/processUtils.ts
index c5fe767d0..ac20d0ce0 100644
--- a/apps/desktop/src/renderer/components/run/processUtils.ts
+++ b/apps/desktop/src/renderer/components/run/processUtils.ts
@@ -1,15 +1,24 @@
 import type { ProcessRuntime, ProcessRuntimeStatus } from "../../../shared/types";
 
+const ACTIVE_STATUSES: ReadonlySet<ProcessRuntimeStatus> = new Set([
+  "running",
+  "starting",
+  "degraded",
+  "stopping",
+]);
+
 export function isActiveProcessStatus(status: ProcessRuntimeStatus): boolean {
-  return status === "running" || status === "starting" || status === "degraded" || status === "stopping";
+  return ACTIVE_STATUSES.has(status);
 }
 
 export function hasInspectableProcessOutput(runtime: ProcessRuntime): boolean {
   return runtime.status !== "stopped" || runtime.startedAt != null || runtime.lastEndedAt != null || runtime.lastExitCode != null;
 }
 
+const TERMINAL_STATUSES: ReadonlySet<ProcessRuntimeStatus> = new Set(["crashed", "exited"]);
+
 export function formatProcessStatus(runtime: Pick<ProcessRuntime, "status" | "lastExitCode">): string {
-  if ((runtime.status === "crashed" || runtime.status === "exited") && runtime.lastExitCode != null) {
+  if (TERMINAL_STATUSES.has(runtime.status) && runtime.lastExitCode != null) {
     return `${runtime.status}:${runtime.lastExitCode}`;
   }
   return runtime.status;
diff --git a/apps/desktop/src/renderer/components/settings/AiFeaturesSection.tsx b/apps/desktop/src/renderer/components/settings/AiFeaturesSection.tsx
index 4737f5edc..63c911564 100644
--- a/apps/desktop/src/renderer/components/settings/AiFeaturesSection.tsx
+++ b/apps/desktop/src/renderer/components/settings/AiFeaturesSection.tsx
@@ -146,7 +146,7 @@ export function AiFeaturesSection() {
         || normalizeModelSetting(effectiveAi?.featureModelOverrides?.terminal_summaries)
         || "",
       );
-      setChatAutoTitleEnabled(effectiveAi?.chat?.autoTitleEnabled === true);
+      setChatAutoTitleEnabled(effectiveAi?.chat?.autoTitleEnabled !== false);
       setChatAutoTitleRefresh(effectiveAi?.chat?.autoTitleRefreshOnComplete !== false);
       setChatAutoTitleReasoning(effectiveAi?.chat?.autoTitleReasoningEffort ?? null);
 
diff --git a/apps/desktop/src/renderer/components/shared/MentionInput.tsx b/apps/desktop/src/renderer/components/shared/MentionInput.tsx
index 06ebea54e..62f37e3fd 100644
--- a/apps/desktop/src/renderer/components/shared/MentionInput.tsx
+++ b/apps/desktop/src/renderer/components/shared/MentionInput.tsx
@@ -320,7 +320,7 @@ export function MentionInput({
               fontFamily: MONO_FONT,
               color: "#FAFAFA",
               lineHeight: "1.55",
-              minHeight: 60,
+              minHeight: 72,
               maxHeight: 160,
             }}
           />
diff --git a/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx
index 03a44b982..18c687321 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx
@@ -1,3 +1,4 @@
+import { useState, useRef, useEffect } from "react";
 import type { TerminalSessionSummary } from "../../../shared/types";
 import { isChatToolType } from "../../lib/sessions";
 
@@ -7,6 +8,18 @@ export type SessionContextMenuState = {
   y: number;
 } | null;
 
+type SessionContextMenuProps = {
+  menu: SessionContextMenuState;
+  onClose: () => void;
+  onCloseSession: (args: { ptyId: string; sessionId: string }) => void;
+  onEndChat: (sessionId: string) => void;
+  onResume: (session: TerminalSessionSummary) => void;
+  onCopyResumeCommand: (command: string) => void;
+  onGoToLane: (session: TerminalSessionSummary) => void;
+  onCopySessionId: (id: string) => void;
+  onRename: (sessionId: string, newTitle: string) => void;
+};
+
 export function SessionContextMenu({
   menu,
   onClose,
@@ -16,16 +29,28 @@ export function SessionContextMenu({
   onCopyResumeCommand,
   onGoToLane,
   onCopySessionId,
-}: {
-  menu: SessionContextMenuState;
-  onClose: () => void;
-  onCloseSession: (args: { ptyId: string; sessionId: string }) => void;
-  onEndChat: (sessionId: string) => void;
-  onResume: (session: TerminalSessionSummary) => void;
-  onCopyResumeCommand: (command: string) => void;
-  onGoToLane: (session: TerminalSessionSummary) => void;
-  onCopySessionId: (id: string) => void;
-}) {
+  onRename,
+}: SessionContextMenuProps) {
+  const [renaming, setRenaming] = useState(false);
+  const [draft, setDraft] = useState("");
+  const inputRef = useRef<HTMLInputElement>(null);
+  const finalizedRef = useRef(false);
+
+  // Reset rename state when menu changes
+  useEffect(() => {
+    setRenaming(false);
+    setDraft("");
+    finalizedRef.current = false;
+  }, [menu]);
+
+  // Focus input when entering rename mode
+  useEffect(() => {
+    if (renaming && inputRef.current) {
+      inputRef.current.focus();
+      inputRef.current.select();
+    }
+  }, [renaming]);
+
   if (!menu) return null;
 
   const { session, x, y } = menu;
@@ -33,6 +58,16 @@ export function SessionContextMenu({
   const isChat = isChatToolType(session.toolType);
   const canResume = !isRunning && Boolean(session.resumeCommand);
 
+  const commitRename = () => {
+    if (finalizedRef.current) return;
+    finalizedRef.current = true;
+    const trimmed = draft.trim();
+    if (trimmed.length > 0) {
+      onRename(session.id, trimmed);
+    }
+    onClose();
+  };
+
   return (
     <>
       {/* Backdrop */}
@@ -44,6 +79,35 @@ export function SessionContextMenu({
         style={{ left: x, top: y }}
         onPointerDown={(e) => e.stopPropagation()}
       >
+        {/* Rename (chat sessions only) */}
+        {isChat && renaming && (
+          <div className="px-3 py-1.5">
+            <input
+              ref={inputRef}
+              type="text"
+              aria-label="Rename session"
+              value={draft}
+              onChange={(e) => setDraft(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") { e.preventDefault(); commitRename(); }
+                if (e.key === "Escape") { e.preventDefault(); finalizedRef.current = true; onClose(); }
+              }}
+              onBlur={commitRename}
+              className="w-full rounded border border-border/30 bg-transparent px-2 py-1 text-xs text-[--color-fg] outline-none focus:border-[--color-accent]"
+              placeholder="Enter title..."
+              maxLength={48}
+            />
+          </div>
+        )}
+        {isChat && !renaming && (
+          <button
+            className="flex w-full items-center gap-2 rounded px-3 py-1.5 text-left text-xs hover:bg-muted/40 transition-colors"
+            onClick={() => { setDraft(session.title); setRenaming(true); }}
+          >
+            Rename
+          </button>
+        )}
+
         {isRunning && session.ptyId && !isChat ? (
           <button
             className="flex w-full items-center gap-2 rounded px-3 py-1.5 text-left text-xs hover:bg-muted/40 transition-colors"
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx b/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
index 90f00040c..76f55370d 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
@@ -30,6 +30,7 @@ export function TerminalsPage() {
   /* Floating overlays */
   const [contextMenu, setContextMenu] = useState<SessionContextMenuState>(null);
   const [infoPopover, setInfoPopover] = useState<InfoPopoverState>(null);
+  const [renameError, setRenameError] = useState<string | null>(null);
 
   const handleSelectSession = useCallback(
     (id: string) => {
@@ -123,6 +124,7 @@ export function TerminalsPage() {
             onOpenChatSession={handleOpenChatSession}
             onLaunchPtySession={work.launchPtySession}
             closingPtyIds={work.closingPtyIds}
+            onContextMenu={handleContextMenu}
           />
         ),
       },
@@ -132,6 +134,15 @@ export function TerminalsPage() {
 
   return (
     <div className="flex h-full min-w-0 flex-col" style={{ background: "var(--color-bg)", fontFamily: SANS_FONT }}>
+      {renameError ? (
+        <div
+          className="shrink-0 border-b border-red-500/25 px-4 py-2 text-[12px] text-red-300/95"
+          style={{ background: "rgba(239, 68, 68, 0.08)" }}
+          role="status"
+        >
+          {renameError}
+        </div>
+      ) : null}
       {/* Header */}
       <div
         style={{
@@ -203,6 +214,21 @@ export function TerminalsPage() {
         onCopyResumeCommand={(cmd) => navigator.clipboard.writeText(cmd).catch(() => {})}
         onGoToLane={handleGoToLane}
         onCopySessionId={(id) => navigator.clipboard.writeText(id).catch(() => {})}
+        onRename={(sessionId, newTitle) => {
+          setRenameError(null);
+          window.ade.agentChat.updateSession({ sessionId, title: newTitle, manuallyNamed: true })
+            .then(() => {
+              work.refresh({ showLoading: false }).catch((refreshErr: unknown) => {
+                console.error("[TerminalsPage] refresh after rename failed", { sessionId, refreshErr });
+              });
+            })
+            .catch((err: unknown) => {
+              const message = err instanceof Error ? err.message : String(err);
+              console.error("[TerminalsPage] rename session failed", { sessionId, err });
+              setRenameError(`Rename failed: ${message}`);
+              window.setTimeout(() => setRenameError(null), 6000);
+            });
+        }}
       />
 
       <SessionInfoPopover
diff --git a/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx b/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
index 5001d86fb..739e25a4e 100644
--- a/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
+++ b/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
@@ -37,7 +37,7 @@ function SessionSurface({
 }) {
   const isChat = isChatToolType(session.toolType);
   if (isChat) {
-    return <AgentChatPane laneId={session.laneId} lockSessionId={session.id} onSessionCreated={onOpenChatSession} />;
+    return <AgentChatPane laneId={session.laneId} laneLabel={session.laneName} lockSessionId={session.id} onSessionCreated={onOpenChatSession} />;
   }
   if (isRunningPtySession(session)) {
     return (
@@ -87,6 +87,7 @@ export function WorkViewArea({
   onOpenChatSession,
   onLaunchPtySession,
   closingPtyIds,
+  onContextMenu,
 }: {
   lanes: LaneSummary[];
   sessions: TerminalSessionSummary[];
@@ -106,6 +107,7 @@ export function WorkViewArea({
     tracked?: boolean;
   }) => Promise<unknown>;
   closingPtyIds: Set<string>;
+  onContextMenu?: (session: TerminalSessionSummary, e: React.MouseEvent) => void;
 }) {
   const sessionsById = useMemo(() => {
     const map = new Map<string, TerminalSessionSummary>();
@@ -189,6 +191,7 @@ export function WorkViewArea({
                   <div
                     key={session.id}
                     className="flex min-h-[260px] flex-col overflow-hidden"
+                    onContextMenu={(e) => { if (onContextMenu) { e.preventDefault(); onContextMenu(session, e); } }}
                     style={{
                       border: isActive
                         ? "1px solid rgba(255,255,255, 0.08)"
@@ -317,6 +320,7 @@ export function WorkViewArea({
                   opacity: isActive ? 1 : 0.5,
                 }}
                 onClick={() => onSelectItem(session.id)}
+                onContextMenu={(e) => { if (onContextMenu) { e.preventDefault(); onContextMenu(session, e); } }}
               >
                 <ToolLogo toolType={session.toolType} size={10} />
                 <span className="max-w-[120px] truncate">
diff --git a/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts b/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts
new file mode 100644
index 000000000..19b5ae5b6
--- /dev/null
+++ b/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts
@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import { buildTrackedCliStartupCommand, defaultTrackedCliStartupCommand, withCodexNoAltScreen } from "./cliLaunch";
+import type { AgentChatPermissionMode } from "../../../shared/types";
+
+describe("withCodexNoAltScreen", () => {
+  it("returns non-codex commands unchanged", () => {
+    expect(withCodexNoAltScreen("claude")).toBe("claude");
+    expect(withCodexNoAltScreen("  claude --help  ")).toBe("claude --help");
+  });
+
+  it("adds --no-alt-screen to bare 'codex'", () => {
+    expect(withCodexNoAltScreen("codex")).toBe("codex --no-alt-screen");
+  });
+
+  it("adds --no-alt-screen to 'codex' with arguments", () => {
+    expect(withCodexNoAltScreen("codex --full-auto")).toBe("codex --no-alt-screen --full-auto");
+  });
+
+  it("does not add flag if already present", () => {
+    expect(withCodexNoAltScreen("codex --no-alt-screen")).toBe("codex --no-alt-screen");
+    expect(withCodexNoAltScreen("codex --no-alt-screen --full-auto")).toBe("codex --no-alt-screen --full-auto");
+  });
+
+  it("trims whitespace from input", () => {
+    expect(withCodexNoAltScreen("  codex  ")).toBe("codex --no-alt-screen");
+  });
+
+  it("does not match codex as a substring", () => {
+    expect(withCodexNoAltScreen("mycodex")).toBe("mycodex");
+    expect(withCodexNoAltScreen("codex-fork --arg")).toBe("codex-fork --arg");
+  });
+});
+
+describe("defaultTrackedCliStartupCommand", () => {
+  it("returns 'claude' for claude provider", () => {
+    expect(defaultTrackedCliStartupCommand("claude")).toBe("claude");
+  });
+
+  it("returns 'codex --no-alt-screen' for codex provider", () => {
+    expect(defaultTrackedCliStartupCommand("codex")).toBe("codex --no-alt-screen");
+  });
+});
+
+describe("buildTrackedCliStartupCommand", () => {
+  describe("claude provider", () => {
+    it("adds --dangerously-skip-permissions for full-auto", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "full-auto" }),
+      ).toBe("claude --dangerously-skip-permissions");
+    });
+
+    it("adds --permission-mode acceptEdits for edit", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "edit" }),
+      ).toBe("claude --permission-mode acceptEdits");
+    });
+
+    it("adds --permission-mode default for default", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "default" }),
+      ).toBe("claude --permission-mode default");
+    });
+
+    it("adds --permission-mode plan for plan (else branch)", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "plan" }),
+      ).toBe("claude --permission-mode plan");
+    });
+
+    it("adds --permission-mode plan for config-toml (falls through to else)", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "config-toml" }),
+      ).toBe("claude --permission-mode plan");
+    });
+  });
+
+  describe("codex provider", () => {
+    it("adds --full-auto for full-auto", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "full-auto" }),
+      ).toBe("codex --no-alt-screen --full-auto");
+    });
+
+    it("passes no extra flags for config-toml", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "config-toml" }),
+      ).toBe("codex --no-alt-screen");
+    });
+
+    it("adds on-failure approval and workspace-write sandbox for edit", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "edit" }),
+      ).toBe("codex --no-alt-screen -c approval_policy=on-failure -c sandbox_mode=workspace-write");
+    });
+
+    it("adds untrusted approval and read-only sandbox for default", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "default" }),
+      ).toBe("codex --no-alt-screen -c approval_policy=untrusted -c sandbox_mode=read-only");
+    });
+
+    it("adds untrusted approval and read-only sandbox for plan (else branch)", () => {
+      expect(
+        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "plan" }),
+      ).toBe("codex --no-alt-screen -c approval_policy=untrusted -c sandbox_mode=read-only");
+    });
+  });
+
+  it("covers all AgentChatPermissionMode values for both providers", () => {
+    const modes = ["default", "plan", "edit", "full-auto", "config-toml"] as const satisfies readonly AgentChatPermissionMode[];
+    for (const mode of modes) {
+      const claude = buildTrackedCliStartupCommand({ provider: "claude", permissionMode: mode });
+      const codex = buildTrackedCliStartupCommand({ provider: "codex", permissionMode: mode });
+      expect(claude.length).toBeGreaterThan(0);
+      expect(codex.length).toBeGreaterThan(0);
+    }
+  });
+});
diff --git a/apps/desktop/src/renderer/state/chatDraftStore.test.ts b/apps/desktop/src/renderer/state/chatDraftStore.test.ts
new file mode 100644
index 000000000..7f89dcd93
--- /dev/null
+++ b/apps/desktop/src/renderer/state/chatDraftStore.test.ts
@@ -0,0 +1,176 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { useChatDraftStore, type ComposerDraftSnapshot } from "./chatDraftStore";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function resetStore() {
+  useChatDraftStore.setState({ snapshots: {}, draftsPerSession: {} });
+}
+
+function makeSnapshot(overrides: Partial<ComposerDraftSnapshot> = {}): ComposerDraftSnapshot {
+  return {
+    draft: "hello world",
+    modelId: "openai/gpt-5.4-codex",
+    reasoningEffort: "high",
+    executionMode: "focused",
+    interactionMode: "default",
+    claudePermissionMode: "default",
+    codexApprovalPolicy: "untrusted",
+    codexSandbox: "read-only",
+    codexConfigSource: "flags",
+    unifiedPermissionMode: "plan",
+    computerUsePolicy: { mode: "auto", allowLocalFallback: false, retainArtifacts: false, preferredBackend: null },
+    attachments: [],
+    includeProjectDocs: false,
+    sendOnEnter: true,
+    ...overrides,
+  };
+}
+
+describe("chatDraftStore", () => {
+  beforeEach(() => {
+    resetStore();
+  });
+
+  // ─────────────────────────────────────────────────────────────
+  // saveSnapshot + getSnapshot
+  // ─────────────────────────────────────────────────────────────
+
+  describe("saveSnapshot / getSnapshot", () => {
+    it("round-trips a snapshot with a string sessionId", () => {
+      const snap = makeSnapshot({ draft: "draft-a" });
+      useChatDraftStore.getState().saveSnapshot("lane-1", "session-1", snap);
+      const result = useChatDraftStore.getState().getSnapshot("lane-1", "session-1");
+      expect(result).toEqual(snap);
+    });
+
+    it("round-trips a snapshot with a null sessionId (new chat)", () => {
+      const snap = makeSnapshot({ draft: "new chat draft" });
+      useChatDraftStore.getState().saveSnapshot("lane-1", null, snap);
+      const result = useChatDraftStore.getState().getSnapshot("lane-1", null);
+      expect(result).toEqual(snap);
+    });
+
+    it("returns undefined for a missing key", () => {
+      const result = useChatDraftStore.getState().getSnapshot("lane-404", "session-404");
+      expect(result).toBeUndefined();
+    });
+
+    it("distinguishes null sessionId from string sessionId", () => {
+      const snapNew = makeSnapshot({ draft: "new" });
+      const snapExisting = makeSnapshot({ draft: "existing" });
+      useChatDraftStore.getState().saveSnapshot("lane-1", null, snapNew);
+      useChatDraftStore.getState().saveSnapshot("lane-1", "session-1", snapExisting);
+
+      expect(useChatDraftStore.getState().getSnapshot("lane-1", null)?.draft).toBe("new");
+      expect(useChatDraftStore.getState().getSnapshot("lane-1", "session-1")?.draft).toBe("existing");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────
+  // clearSnapshot
+  // ─────────────────────────────────────────────────────────────
+
+  describe("clearSnapshot", () => {
+    it("removes an existing snapshot", () => {
+      const snap = makeSnapshot();
+      useChatDraftStore.getState().saveSnapshot("lane-1", "session-1", snap);
+      expect(useChatDraftStore.getState().getSnapshot("lane-1", "session-1")).toBeDefined();
+
+      useChatDraftStore.getState().clearSnapshot("lane-1", "session-1");
+      expect(useChatDraftStore.getState().getSnapshot("lane-1", "session-1")).toBeUndefined();
+    });
+
+    it("does not throw when clearing a non-existent key", () => {
+      expect(() => {
+        useChatDraftStore.getState().clearSnapshot("lane-404", "session-404");
+      }).not.toThrow();
+    });
+
+    it("does not affect other snapshots when clearing one", () => {
+      const snap1 = makeSnapshot({ draft: "one" });
+      const snap2 = makeSnapshot({ draft: "two" });
+      useChatDraftStore.getState().saveSnapshot("lane-1", "session-1", snap1);
+      useChatDraftStore.getState().saveSnapshot("lane-1", "session-2", snap2);
+
+      useChatDraftStore.getState().clearSnapshot("lane-1", "session-1");
+      expect(useChatDraftStore.getState().getSnapshot("lane-1", "session-1")).toBeUndefined();
+      expect(useChatDraftStore.getState().getSnapshot("lane-1", "session-2")).toEqual(snap2);
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────
+  // saveDraftsMap / getDraftsMap
+  // ─────────────────────────────────────────────────────────────
+
+  describe("saveDraftsMap / getDraftsMap", () => {
+    it("round-trips a map with null key and string keys", () => {
+      const map = new Map<string | null, string>([
+        [null, "new chat draft"],
+        ["session-1", "draft for session 1"],
+        ["session-2", "draft for session 2"],
+      ]);
+      useChatDraftStore.getState().saveDraftsMap("lane-1", map);
+      const result = useChatDraftStore.getState().getDraftsMap("lane-1");
+
+      expect(result).toBeInstanceOf(Map);
+      expect(result.size).toBe(3);
+      expect(result.get(null)).toBe("new chat draft");
+      expect(result.get("session-1")).toBe("draft for session 1");
+      expect(result.get("session-2")).toBe("draft for session 2");
+    });
+
+    it("returns an empty Map for an unknown laneId", () => {
+      const result = useChatDraftStore.getState().getDraftsMap("lane-unknown");
+      expect(result).toBeInstanceOf(Map);
+      expect(result.size).toBe(0);
+    });
+
+    it("overwrites a previous drafts map for the same lane", () => {
+      const map1 = new Map<string | null, string>([[null, "old"]]);
+      const map2 = new Map<string | null, string>([[null, "new"]]);
+      useChatDraftStore.getState().saveDraftsMap("lane-1", map1);
+      useChatDraftStore.getState().saveDraftsMap("lane-1", map2);
+
+      const result = useChatDraftStore.getState().getDraftsMap("lane-1");
+      expect(result.get(null)).toBe("new");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────
+  // Cross-lane isolation
+  // ─────────────────────────────────────────────────────────────
+
+  describe("cross-lane isolation", () => {
+    it("snapshots from different lanes do not interfere", () => {
+      const snapA = makeSnapshot({ draft: "lane-A draft" });
+      const snapB = makeSnapshot({ draft: "lane-B draft" });
+      useChatDraftStore.getState().saveSnapshot("lane-A", "session-1", snapA);
+      useChatDraftStore.getState().saveSnapshot("lane-B", "session-1", snapB);
+
+      expect(useChatDraftStore.getState().getSnapshot("lane-A", "session-1")?.draft).toBe("lane-A draft");
+      expect(useChatDraftStore.getState().getSnapshot("lane-B", "session-1")?.draft).toBe("lane-B draft");
+    });
+
+    it("drafts maps from different lanes do not interfere", () => {
+      const mapA = new Map<string | null, string>([[null, "A new"]]);
+      const mapB = new Map<string | null, string>([[null, "B new"]]);
+      useChatDraftStore.getState().saveDraftsMap("lane-A", mapA);
+      useChatDraftStore.getState().saveDraftsMap("lane-B", mapB);
+
+      expect(useChatDraftStore.getState().getDraftsMap("lane-A").get(null)).toBe("A new");
+      expect(useChatDraftStore.getState().getDraftsMap("lane-B").get(null)).toBe("B new");
+    });
+
+    it("clearing a snapshot in one lane does not affect another lane", () => {
+      const snap = makeSnapshot({ draft: "keep me" });
+      useChatDraftStore.getState().saveSnapshot("lane-A", "session-1", snap);
+      useChatDraftStore.getState().saveSnapshot("lane-B", "session-1", makeSnapshot());
+
+      useChatDraftStore.getState().clearSnapshot("lane-B", "session-1");
+      expect(useChatDraftStore.getState().getSnapshot("lane-A", "session-1")?.draft).toBe("keep me");
+    });
+  });
+});
diff --git a/apps/desktop/src/renderer/state/chatDraftStore.ts b/apps/desktop/src/renderer/state/chatDraftStore.ts
new file mode 100644
index 000000000..cccc68507
--- /dev/null
+++ b/apps/desktop/src/renderer/state/chatDraftStore.ts
@@ -0,0 +1,88 @@
+import { create } from "zustand";
+import type {
+  AgentChatClaudePermissionMode,
+  AgentChatCodexApprovalPolicy,
+  AgentChatCodexConfigSource,
+  AgentChatCodexSandbox,
+  AgentChatExecutionMode,
+  AgentChatFileRef,
+  AgentChatInteractionMode,
+  AgentChatUnifiedPermissionMode,
+  ComputerUsePolicy,
+} from "../../shared/types";
+
+const NEW_SESSION_KEY = "\0new";
+const SEP = "\0";
+
+export interface ComposerDraftSnapshot {
+  draft: string;
+  modelId: string;
+  reasoningEffort: string | null;
+  executionMode: AgentChatExecutionMode;
+  interactionMode: AgentChatInteractionMode;
+  claudePermissionMode: AgentChatClaudePermissionMode;
+  codexApprovalPolicy: AgentChatCodexApprovalPolicy;
+  codexSandbox: AgentChatCodexSandbox;
+  codexConfigSource: AgentChatCodexConfigSource;
+  unifiedPermissionMode: AgentChatUnifiedPermissionMode;
+  computerUsePolicy: ComputerUsePolicy;
+  attachments: AgentChatFileRef[];
+  includeProjectDocs: boolean;
+  sendOnEnter: boolean;
+}
+
+function snapshotKey(laneId: string, sessionId: string | null): string {
+  return `${laneId}${SEP}${sessionId ?? NEW_SESSION_KEY}`;
+}
+
+interface ChatDraftState {
+  snapshots: Record<string, ComposerDraftSnapshot>;
+  draftsPerSession: Record<string, Record<string, string>>;
+
+  saveSnapshot: (laneId: string, sessionId: string | null, snapshot: ComposerDraftSnapshot) => void;
+  getSnapshot: (laneId: string, sessionId: string | null) => ComposerDraftSnapshot | undefined;
+  clearSnapshot: (laneId: string, sessionId: string | null) => void;
+
+  saveDraftsMap: (laneId: string, map: Map<string | null, string>) => void;
+  getDraftsMap: (laneId: string) => Map<string | null, string>;
+}
+
+export const useChatDraftStore = create<ChatDraftState>((set, get) => ({
+  snapshots: {},
+  draftsPerSession: {},
+
+  saveSnapshot: (laneId, sessionId, snapshot) => {
+    const key = snapshotKey(laneId, sessionId);
+    set((state) => ({ snapshots: { ...state.snapshots, [key]: snapshot } }));
+  },
+
+  getSnapshot: (laneId, sessionId) => {
+    return get().snapshots[snapshotKey(laneId, sessionId)];
+  },
+
+  clearSnapshot: (laneId, sessionId) => {
+    const key = snapshotKey(laneId, sessionId);
+    set((state) => {
+      const { [key]: _, ...rest } = state.snapshots;
+      return { snapshots: rest };
+    });
+  },
+
+  saveDraftsMap: (laneId, map) => {
+    const serialized: Record<string, string> = {};
+    for (const [k, v] of map.entries()) {
+      serialized[k ?? NEW_SESSION_KEY] = v;
+    }
+    set((state) => ({ draftsPerSession: { ...state.draftsPerSession, [laneId]: serialized } }));
+  },
+
+  getDraftsMap: (laneId) => {
+    const serialized = get().draftsPerSession[laneId];
+    if (!serialized) return new Map();
+    const map = new Map<string | null, string>();
+    for (const [k, v] of Object.entries(serialized)) {
+      map.set(k === NEW_SESSION_KEY ? null : k, v);
+    }
+    return map;
+  },
+}));
diff --git a/apps/desktop/src/shared/ipc.ts b/apps/desktop/src/shared/ipc.ts
index 3e841345f..410e88067 100644
--- a/apps/desktop/src/shared/ipc.ts
+++ b/apps/desktop/src/shared/ipc.ts
@@ -4,6 +4,7 @@ export const IPC = {
   appGetProject: "ade.app.getProject",
   appOpenExternal: "ade.app.openExternal",
   appRevealPath: "ade.app.revealPath",
+  appOpenPath: "ade.app.openPath",
   appWriteClipboardText: "ade.app.writeClipboardText",
   appOpenPathInEditor: "ade.app.openPathInEditor",
   projectOpenRepo: "ade.project.openRepo",
@@ -122,6 +123,7 @@ export const IPC = {
   computerUseGetOwnerSnapshot: "ade.computerUse.getOwnerSnapshot",
   computerUseRouteArtifact: "ade.computerUse.routeArtifact",
   computerUseUpdateArtifactReview: "ade.computerUse.updateArtifactReview",
+  computerUseReadArtifactPreview: "ade.computerUse.readArtifactPreview",
   computerUseEvent: "ade.computerUse.event",
   ptyCreate: "ade.pty.create",
   ptyWrite: "ade.pty.write",
diff --git a/apps/desktop/src/shared/types/chat.ts b/apps/desktop/src/shared/types/chat.ts
index aa8aad761..61684f631 100644
--- a/apps/desktop/src/shared/types/chat.ts
+++ b/apps/desktop/src/shared/types/chat.ts
@@ -435,6 +435,8 @@ export type AgentChatSession = {
   completion?: AgentChatCompletionReport | null;
   status: AgentChatSessionStatus;
   threadId?: string;
+  /** Subdirectory or absolute path under the lane worktree used as cwd; persisted for relaunch/resume. */
+  requestedCwd?: string | null;
   createdAt: string;
   lastActivityAt: string;
 };
@@ -544,6 +546,7 @@ export type AgentChatCreateArgs = {
   automationId?: string | null;
   automationRunId?: string | null;
   computerUse?: ComputerUsePolicy | null;
+  requestedCwd?: string;
 };
 
 export type AgentChatHandoffArgs = {
@@ -623,6 +626,7 @@ export type AgentChatDisposeArgs = {
 export type AgentChatUpdateSessionArgs = {
   sessionId: string;
   title?: string | null;
+  manuallyNamed?: boolean;
   modelId?: ModelId;
   reasoningEffort?: string | null;
   permissionMode?: AgentChatPermissionMode;
diff --git a/apps/desktop/src/shared/types/lanes.ts b/apps/desktop/src/shared/types/lanes.ts
index cb02f352d..fa9d2682d 100644
--- a/apps/desktop/src/shared/types/lanes.ts
+++ b/apps/desktop/src/shared/types/lanes.ts
@@ -127,6 +127,7 @@ export type ImportBranchLaneArgs = {
   name?: string;
   description?: string;
   parentLaneId?: string | null;
+  baseBranch?: string;
 };
 
 export type AttachLaneArgs = {
diff --git a/apps/mcp-server/src/bootstrap.ts b/apps/mcp-server/src/bootstrap.ts
index b490b4cec..551d434de 100644
--- a/apps/mcp-server/src/bootstrap.ts
+++ b/apps/mcp-server/src/bootstrap.ts
@@ -254,6 +254,7 @@ export async function createAdeMcpRuntime(args: { projectRoot: string; workspace
   const ptyService = createPtyService({
     projectRoot,
     transcriptsDir: paths.transcriptsDir,
+    chatSessionsDir: paths.chatSessionsDir,
     laneService,
     sessionService,
     logger,
diff --git a/docs/architecture/AI_INTEGRATION.md b/docs/architecture/AI_INTEGRATION.md
index cf864f350..e408b9605 100644
--- a/docs/architecture/AI_INTEGRATION.md
+++ b/docs/architecture/AI_INTEGRATION.md
@@ -2,7 +2,7 @@
 
 > Roadmap reference: `docs/final-plan/README.md` is the canonical future plan and sequencing source.
 
-> Last updated: 2026-03-24
+> Last updated: 2026-03-30
 
 The AI integration layer replaces the previous hosted agent with a local-first, provider-flexible approach. Instead of a cloud backend with remote job queues, ADE routes work to configured runtimes (CLI subscriptions, API-key/OpenRouter providers, and local endpoints such as LM Studio/Ollama/vLLM), coordinates tooling through MCP, and manages multi-step workflows via an AI orchestrator.
 
@@ -1521,6 +1521,8 @@ type ChatEvent =
   | { type: "approval_request"; itemId: string; kind: "command" | "file_change"; description: string; detail: unknown }
   | { type: "system_notice"; noticeKind: "auth" | "rate_limit" | "hook" | "file_persist" | "info" | "memory" | "provider_health" | "thread_error"; message: string; detail?: string | AgentChatNoticeDetail }
   | { type: "status"; turnStatus: "started" | "completed" | "interrupted" | "failed"; error?: string }
+  | { type: "subagent_started"; taskId: string; description: string; turnId?: string }
+  | { type: "subagent_result"; taskId: string; status: "completed" | "stopped" | "failed"; summary: string; turnId?: string }
   | { type: "error"; message: string; errorInfo?: string }
   | { type: "done"; turnId: string };
 
@@ -1580,7 +1582,7 @@ send({ method: "initialized", params: {} });
 | `steer()` | `turn/steer` | Appends to in-flight turn; cannot change model/sandbox |
 | `cancelSteer()` | N/A | Cancel a pending steer before it is delivered |
 | `editSteer()` | N/A | Replace pending steer text before it is delivered |
-| `interrupt()` | `turn/interrupt` | Turn completes with `status: "interrupted"` |
+| `interrupt()` | `turn/interrupt` | Turn completes with `status: "interrupted"`. Idempotent — second call is a no-op. Claude/unified runtimes emit `subagent_result` "stopped" for active subagents. |
 | `resumeSession()` | `thread/resume` | Params: `threadId`, optional `personality` |
 | `listSessions()` | `thread/list` | Filter by `cwd` to scope to lane |
 | `approveToolUse()` | Response to `requestApproval` | Payload: `accept`/`acceptForSession`/`decline`/`cancel` |
diff --git a/docs/features/CHAT.md b/docs/features/CHAT.md
index 5339b5dbe..e8515efe7 100644
--- a/docs/features/CHAT.md
+++ b/docs/features/CHAT.md
@@ -44,6 +44,60 @@ the abort infrastructure. When a turn exceeds this limit, an error event
 is emitted and the turn is terminated, preventing a single stalled
 provider call from blocking the session indefinitely.
 
+### Auto-Title Generation
+
+Chat sessions support automatic AI-generated titles. The feature
+progresses through two stages:
+
+- **initial** -- Generated early in the conversation from the first
+  user message. Provides an immediate label while the session is still
+  brief.
+- **final** -- Generated after sufficient conversation context has
+  accumulated, producing a more accurate title.
+
+Auto-title generation is enabled by default (`ai.chat.autoTitleEnabled`
+defaults to `true`) and runs for any AI mode that is not `guest`.
+Reasoning effort for title generation is configurable via
+`ai.chat.autoTitleReasoningEffort`.
+
+When a session is refreshed on completion, a final title can also be
+generated if `ai.chat.autoTitleRefreshOnComplete` is enabled (default:
+`true`).
+
+### Manual Rename
+
+Users can rename a chat session through the right-click context menu on
+any chat session card. The context menu provides an inline text input
+for entering a new title (max 48 characters). Renaming a session sets a
+`manuallyNamed` flag on the session, which permanently suppresses
+further auto-title generation for that session. This ensures a
+user-chosen name is never overwritten by the AI.
+
+## Turn Interruption
+
+Users can interrupt an in-flight turn via `interrupt()`. The behavior
+is provider-specific:
+
+- **Claude**: The runtime's `interrupted` flag is set, the warmup is
+  cancelled, the active query is interrupted, and the V2 session is
+  closed (it will be recreated on the next turn). The streaming loop
+  checks the `interrupted` flag on each iteration and breaks cleanly
+  rather than throwing from a closed session. All active subagents are
+  transitioned from "running" to "stopped" by emitting a
+  `subagent_result` event with `status: "stopped"` for each one,
+  matching Claude Code CLI behaviour. The `activeSubagents` map is
+  then cleared.
+- **Codex**: The interrupt is forwarded to the app-server via the
+  `turn/interrupt` JSON-RPC method. The turn completes with
+  `status: "interrupted"`.
+- **Unified**: The abort controller is signalled and all pending
+  approval promises are auto-declined to prevent orphaned
+  human-in-the-loop requests.
+
+All providers implement an **idempotency guard**: if the runtime is
+already interrupted, a second `interrupt()` call is a no-op. This
+prevents duplicate side-effects from rapid cancel clicks.
+
 ### Text Batching
 
 Streaming assistant text events from Codex and unified providers are
@@ -170,7 +224,9 @@ Codex sessions have two independent controls:
 
 The unified orchestrator adapter translates abstract permission modes (`plan`, `edit`, `full-auto`) into the correct provider-native fields via `mapPermissionModeToNativeFields()`. For Claude this maps to `claudePermissionMode`, for Codex to `codexApprovalPolicy`/`codexSandbox`, and for unified to `unifiedPermissionMode`. Chat sessions still persist an abstract `permissionMode` field alongside the provider-native controls so the UI can summarize session state and legacy flows can be normalized consistently.
 
-All controls can be changed mid-session via `updateSession`.
+All controls can be changed mid-session via `updateSession`. The
+`updateSession` API also accepts a `manuallyNamed` flag to mark a
+session as user-renamed, suppressing future auto-title generation.
 
 ## Pending Input System (Human-in-the-Loop)
 
diff --git a/docs/features/TERMINALS_AND_SESSIONS.md b/docs/features/TERMINALS_AND_SESSIONS.md
index c926faa6a..32f7b793c 100644
--- a/docs/features/TERMINALS_AND_SESSIONS.md
+++ b/docs/features/TERMINALS_AND_SESSIONS.md
@@ -1,8 +1,6 @@
 # Terminals and sessions
 
 > Roadmap reference: `docs/final-plan/README.md` is the canonical future plan and sequencing source.
->
-> Last updated: 2026-03-13
 
 ADE treats PTY sessions and agent chat sessions as tracked execution surfaces with shared session metadata, delta computation, transcript persistence, and lane associations.
 
@@ -72,6 +70,38 @@ This keeps session visibility current without leaving zero-row polling loops run
 
 ---
 
+## AI-Generated Session Titles
+
+PTY sessions support automatic AI-generated titles when an AI provider
+is available (any mode other than `guest`). Title generation happens at
+two points:
+
+1. **Shortly after launch** -- After a 6-second delay, the service
+   collects up to 800 characters of initial terminal output, strips ANSI
+   escape sequences, and sends the cleaned text to the AI integration
+   service with a prompt requesting a concise title (max 80 characters).
+   This gives non-shell sessions (build commands, test runs, dev
+   servers) a descriptive name based on their early output.
+
+2. **On session completion** -- When a PTY session exits and
+   `refreshOnComplete` is enabled (default: `true`), the service
+   generates a final title from the transcript tail (last 2000
+   characters). The prompt includes the session type, initial title,
+   current goal, and exit code, producing a title that reflects the
+   outcome of the completed session.
+
+Title generation is gated by the `sessionIntelligence.titles.enabled`
+config (falling back to `ai.chat.autoTitleEnabled`, default `true`).
+The model used for title generation can be overridden via
+`sessionIntelligence.titles.modelId`. The refresh-on-complete behavior
+is controlled by `sessionIntelligence.titles.refreshOnComplete` (falling
+back to `ai.chat.autoTitleRefreshOnComplete`, default `true`).
+
+Title generation failures are logged as warnings and do not affect
+session lifecycle.
+
+---
+
 ## Session lifecycle
 
 The lifecycle model remains the same:
@@ -96,6 +126,23 @@ This pattern applies across all session-creation and session-opening paths:
 
 ---
 
+## Session context menu
+
+Right-clicking a session card in the Work view opens a context menu with
+actions appropriate to the session type and state:
+
+- **Chat sessions**: Rename (inline text input), stop, resume, go to
+  lane, copy session ID.
+- **PTY sessions**: Stop (sends SIGHUP), go to lane, copy session ID,
+  copy resume command (when available).
+
+The context menu is available on both the expanded session cards and the
+compact tab bar at the bottom of the Work view. Renaming a chat session
+through the context menu marks it as manually named, preventing
+auto-title from overwriting the user's choice.
+
+---
+
 ## Current product contract
 
 The current terminals and sessions feature follows these rules: