diff --git a/.claude/scheduled_tasks.lock b/.claude/scheduled_tasks.lock
deleted file mode 100644
index 11cff863c..000000000
--- a/.claude/scheduled_tasks.lock
+++ /dev/null
@@ -1 +0,0 @@
-{"sessionId":"1676c542-49ae-4b07-80db-808ac138cb4b","pid":24538,"procStart":"Fri Apr 24 04:52:14 2026","acquiredAt":1777006545124}
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 705f05441..4e7d78caa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,7 @@ node_modules
 *.png
 !docs/**/*.png
 !apps/web/public/**/*.png
+!apps/ios/**/*.png
 
 # Python cache
 __pycache__/
@@ -45,6 +46,7 @@ release-stable/
 # Xcode user data & derived data
 xcuserdata/
 *.xcuserstate
+/.derived-data/
 apps/ios/.dry-run-derived-data/
 apps/ios/build/
 ios-signing/
diff --git a/apps/ade-cli/package-lock.json b/apps/ade-cli/package-lock.json
index 882c5a8d5..c8e509f5b 100644
--- a/apps/ade-cli/package-lock.json
+++ b/apps/ade-cli/package-lock.json
@@ -2902,8 +2902,7 @@
       "version": "1.3.6",
       "resolved": "https://registry.npmjs.org/@types/chai-subset/-/chai-subset-1.3.6.tgz",
       "integrity": "sha512-m8lERkkQj+uek18hXOZuec3W/fCRTrU4hrnXjH3qhHy96ytuPaPiWGgu7sJb7tZxZonO75vYAjCvpe/e4VUwRw==",
-      "dev": true,
-      "requires": {}
+      "dev": true
     },
     "@types/estree": {
       "version": "1.0.8",
@@ -3150,8 +3149,7 @@
       "version": "6.5.0",
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
       "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
-      "dev": true,
-      "requires": {}
+      "dev": true
     },
     "fix-dts-default-cjs-exports": {
       "version": "1.0.1",
diff --git a/apps/desktop/src/main/main.ts b/apps/desktop/src/main/main.ts
index 8a53a1ab4..7bb97d72a 100644
--- a/apps/desktop/src/main/main.ts
+++ b/apps/desktop/src/main/main.ts
@@ -50,6 +50,7 @@ import {
   upsertProjectRow,
 } from "./services/projects/projectService";
 import { inspectRecentProject, type RecentProjectInspection } from "./services/projects/recentProjectSummary";
+import { resolveProjectIcon } from "./services/projects/projectIconResolver";
 import { createAdeProjectService } from "./services/projects/adeProjectService";
 import { createConfigReloadService } from "./services/projects/configReloadService";
 import { IPC } from "../shared/ipc";
@@ -955,6 +956,10 @@ app.whenReady().then(async () => {
     });
     if (activeProjectRoot) {
       projectLastActivatedAt.set(activeProjectRoot, Date.now());
+      const activeCtx = projectContexts.get(activeProjectRoot);
+      if (activeCtx) {
+        persistRecentProject(activeCtx.project, { recordLastProject: false });
+      }
       try {
         adeArtifactAllowedDir =
           resolveAdeLayout(activeProjectRoot).artifactsDir;
@@ -3938,6 +3943,7 @@ app.whenReady().then(async () => {
       rootPath: ctx.project.rootPath,
       defaultBaseRef: ctx.project.baseRef,
       lastOpenedAt: recent?.summary.lastOpenedAt ?? null,
+      iconDataUrl: mobileProjectIconDataUrl(ctx.project.rootPath),
       laneCount,
       isAvailable: fs.existsSync(ctx.project.rootPath),
       isCached: false,
@@ -3953,6 +3959,7 @@ app.whenReady().then(async () => {
       rootPath: recent.summary.rootPath,
       defaultBaseRef: recent.defaultBaseRef,
       lastOpenedAt: recent.summary.lastOpenedAt,
+      iconDataUrl: mobileProjectIconDataUrl(recent.summary.rootPath),
       laneCount: recent.summary.laneCount ?? 0,
       isAvailable: recent.summary.exists,
       isCached: false,
@@ -3960,6 +3967,22 @@ app.whenReady().then(async () => {
     };
   }
 
+  function mobileProjectIconDataUrl(projectRoot: string): string | null {
+    try {
+      const icon = resolveProjectIcon(projectRoot);
+      if (!icon.sourcePath) return null;
+
+      const image = nativeImage.createFromPath(icon.sourcePath);
+      if (!image.isEmpty()) {
+        return image.resize({ width: 64, height: 64, quality: "best" }).toDataURL();
+      }
+
+      return icon.mimeType === "image/png" ? icon.dataUrl : null;
+    } catch {
+      return null;
+    }
+  }
+
   async function listMobileSyncProjects(): Promise<{ projects: SyncMobileProjectSummary[] }> {
     const recentProjects = (readGlobalState(globalStatePath).recentProjects ?? [])
       .map(inspectRecentProject);
@@ -3971,9 +3994,11 @@ app.whenReady().then(async () => {
       byRoot.set(normalizeProjectRoot(recent.summary.rootPath), mobileProjectSummaryForRecent(recent));
     }
     const contextSummaries = await Promise.all(
-      [...projectContexts.entries()].map(async ([root, ctx]) =>
-        [root, await mobileProjectSummaryForContext(ctx, recentByRoot.get(root) ?? null)] as const
-      ),
+      [...projectContexts.entries()]
+        .filter(([root]) => recentByRoot.has(root))
+        .map(async ([root, ctx]) =>
+          [root, await mobileProjectSummaryForContext(ctx, recentByRoot.get(root) ?? null)] as const
+        ),
     );
     for (const [root, summary] of contextSummaries) {
       byRoot.set(root, summary);
diff --git a/apps/desktop/src/main/services/ipc/registerIpc.ts b/apps/desktop/src/main/services/ipc/registerIpc.ts
index 5c138d938..9cac407c9 100644
--- a/apps/desktop/src/main/services/ipc/registerIpc.ts
+++ b/apps/desktop/src/main/services/ipc/registerIpc.ts
@@ -1,4 +1,4 @@
-import { app, BrowserWindow, clipboard, dialog, ipcMain, shell } from "electron";
+import { app, BrowserWindow, clipboard, dialog, ipcMain, nativeImage, shell } from "electron";
 import { createEmptyAutoUpdateSnapshot, type createAutoUpdateService } from "../updates/autoUpdateService";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
@@ -13,6 +13,7 @@ import { launchPrIssueResolutionChat, previewPrIssueResolutionPrompt } from "../
 import { launchRebaseResolutionChat } from "../prs/prRebaseResolver";
 import { browseProjectDirectories } from "../projects/projectBrowserService";
 import { getProjectDetail } from "../projects/projectDetailService";
+import { resolveProjectIcon } from "../projects/projectIconResolver";
 import { runGit } from "../git/git";
 import type { AdeCleanupResult, AdeProjectSnapshot } from "../../../shared/types";
 import { toRecentProjectSummary } from "../projects/recentProjectSummary";
@@ -258,6 +259,7 @@ import type {
   ProjectBrowseInput,
   ProjectBrowseResult,
   ProjectDetail,
+  ProjectIcon,
   ProjectInfo,
   RecentProjectSummary,
   PtyCreateArgs,
@@ -1890,6 +1892,107 @@ export function registerIpc({
     return path.resolve(path.isAbsolute(inputPath) ? inputPath : path.join(projectRoot, inputPath));
   };
 
+  const resolveAllowedRendererPath = (rawPath: string): string => {
+    const raw = typeof rawPath === "string" ? rawPath.trim() : "";
+    if (!raw) throw new Error("Missing path.");
+    const ctx = getCtx();
+    const normalized = resolveRendererSuppliedPath(raw, ctx.project.rootPath);
+    const allowedDirs = getAllowedDirs(getCtx);
+    // resolvePathWithinRoot follows symlinks via fs.realpath while validating
+    // containment, so we both reject symlinks pointing outside the allowlist
+    // *and* return the canonical real path for callers to read from. Returning
+    // the lexical path would still be safe because the check resolved real
+    // paths, but handing back the realpath avoids any TOCTOU-adjacent surprises
+    // and keeps file I/O pinned to the validated target.
+    let resolved: string | null = null;
+    for (const dir of allowedDirs) {
+      try {
+        resolved = resolvePathWithinRoot(dir, normalized);
+        break;
+      } catch {
+        // try next allowed dir
+      }
+    }
+    if (!resolved) {
+      throw new Error("Path is outside allowed directories.");
+    }
+    return resolved;
+  };
+
+  /**
+   * Sniff the first bytes of a buffer for known image magic numbers and
+   * return the corresponding MIME type. Returns null if the buffer doesn't
+   * match any supported image format.
+   *
+   * We deliberately do NOT trust the file extension here — extension-only
+   * inference would let a renderer hand us any allow-listed file (text,
+   * binary, etc.) and get it back as a base64 `image/png` data URL.
+   */
+  const sniffImageMimeType = (buffer: Buffer): string | null => {
+    if (buffer.length >= 8
+      && buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4E && buffer[3] === 0x47
+      && buffer[4] === 0x0D && buffer[5] === 0x0A && buffer[6] === 0x1A && buffer[7] === 0x0A) {
+      return "image/png";
+    }
+    if (buffer.length >= 3
+      && buffer[0] === 0xFF && buffer[1] === 0xD8 && buffer[2] === 0xFF) {
+      return "image/jpeg";
+    }
+    if (buffer.length >= 6
+      && buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x38
+      && (buffer[4] === 0x37 || buffer[4] === 0x39) && buffer[5] === 0x61) {
+      return "image/gif";
+    }
+    if (buffer.length >= 12
+      && buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46
+      && buffer[8] === 0x57 && buffer[9] === 0x45 && buffer[10] === 0x42 && buffer[11] === 0x50) {
+      return "image/webp";
+    }
+    if (buffer.length >= 2 && buffer[0] === 0x42 && buffer[1] === 0x4D) {
+      return "image/bmp";
+    }
+    if (buffer.length >= 4
+      && buffer[0] === 0x00 && buffer[1] === 0x00
+      && buffer[2] === 0x01 && buffer[3] === 0x00) {
+      return "image/x-icon";
+    }
+    // SVG/XML: scan a small prefix as text so leading whitespace, BOM, or an
+    // <?xml ... ?> declaration before <svg ...> are tolerated.
+    const head = buffer.slice(0, Math.min(buffer.length, 1024)).toString("utf8");
+    const stripped = head.replace(/^/, "").trimStart();
+    if (/^<\?xml\b/i.test(stripped) && /<svg\b/i.test(head)) {
+      return "image/svg+xml";
+    }
+    if (/^<svg\b/i.test(stripped)) {
+      return "image/svg+xml";
+    }
+    return null;
+  };
+
+  const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+  /**
+   * Read an allow-listed image file from disk after a stat-based size check,
+   * sniff its bytes for a known image magic, and return both the bytes and
+   * the sniffed MIME type. Throws if the file is too large, isn't a regular
+   * file, or doesn't look like a supported image.
+   */
+  const readImageFileAndSniffMime = async (filePath: string): Promise<{ data: Buffer; mimeType: string }> => {
+    const stat = await fs.promises.stat(filePath);
+    if (!stat.isFile()) {
+      throw new Error("Path is not a file.");
+    }
+    if (stat.size > MAX_IMAGE_BYTES) {
+      throw new Error("Image must be 10 MB or smaller.");
+    }
+    const data = await fs.promises.readFile(filePath);
+    const mimeType = sniffImageMimeType(data);
+    if (!mimeType) {
+      throw new Error("Path is not an image.");
+    }
+    return { data, mimeType };
+  };
+
   ipcMain.handle(IPC.appRevealPath, async (_event, arg: { path: string }): Promise<void> => {
     const raw = typeof arg?.path === "string" ? arg.path.trim() : "";
     if (!raw) return;
@@ -1940,6 +2043,35 @@ export function registerIpc({
     clipboard.writeText(text);
   });
 
+  ipcMain.handle(IPC.appGetImageDataUrl, async (_event, arg: { path: string }): Promise<{ dataUrl: string }> => {
+    const filePath = resolveAllowedRendererPath(arg?.path);
+    // Use async fs APIs and a size pre-check so a 10 MB image read never
+    // blocks the main process event loop (input dispatch, IPC, window
+    // animations all share that loop). The MIME type is derived from the
+    // file's *bytes*, not its extension, so a renderer can't smuggle
+    // arbitrary text/binary back as a base64 `image/png` data URL.
+    const { data, mimeType } = await readImageFileAndSniffMime(filePath);
+    return {
+      dataUrl: `data:${mimeType};base64,${data.toString("base64")}`,
+    };
+  });
+
+  ipcMain.handle(IPC.appWriteClipboardImage, async (_event, arg: { path: string }): Promise<void> => {
+    const filePath = resolveAllowedRendererPath(arg?.path);
+    // Apply the same size + magic-byte preflight as `appGetImageDataUrl` so
+    // we can't hand `nativeImage.createFromPath` a giant or non-image file
+    // (which would otherwise silently produce an empty image, or worse,
+    // attempt a sync read of a 100 MB binary on the main process). We then
+    // hand the already-read buffer to `nativeImage.createFromBuffer` so the
+    // file isn't read a second time off the main thread.
+    const { data } = await readImageFileAndSniffMime(filePath);
+    const image = nativeImage.createFromBuffer(data);
+    if (image.isEmpty()) {
+      throw new Error("Unable to read image.");
+    }
+    clipboard.writeImage(image);
+  });
+
   ipcMain.handle(
     IPC.appOpenPathInEditor,
     async (
@@ -2146,6 +2278,54 @@ export function registerIpc({
     }
   );
 
+  // Project-root allowlist for icon resolution. Tab/catalog icons are
+  // resolved for the *current* project root and any *recently opened*
+  // project root — including ones that live outside Downloads/Documents/Temp
+  // (the generic `getAllowedDirs` set). Using `resolveAllowedRendererPath`
+  // here would silently strip icons for any project in `~/code/*` etc.
+  const getAllowedProjectRoots = (): string[] => {
+    const state = readGlobalState(globalStatePath);
+    return Array.from(new Set([
+      getCtx().project.rootPath,
+      ...(state.recentProjects ?? [])
+        .map((entry) => entry.rootPath)
+        .filter((root): root is string => typeof root === "string" && root.trim().length > 0),
+    ]));
+  };
+
+  const resolveAllowedProjectRoot = (rawPath: string): string => {
+    const raw = typeof rawPath === "string" ? rawPath.trim() : "";
+    if (!raw) throw new Error("Missing root path.");
+    const normalized = resolveRendererSuppliedPath(raw, getCtx().project.rootPath);
+    for (const dir of getAllowedProjectRoots()) {
+      try {
+        return resolvePathWithinRoot(dir, normalized);
+      } catch {
+        // try next known project root
+      }
+    }
+    throw new Error("rootPath is outside known project roots.");
+  };
+
+  ipcMain.handle(
+    IPC.projectResolveIcon,
+    async (_event, args: { rootPath: string }): Promise<ProjectIcon> => {
+      const rootPath = typeof args?.rootPath === "string" ? args.rootPath.trim() : "";
+      if (!rootPath) return { dataUrl: null, sourcePath: null, mimeType: null };
+      // Validate the renderer-supplied root against the project-root
+      // allowlist (current + recent projects) so a compromised renderer
+      // can't probe arbitrary directories for icons, while still serving
+      // icons for projects that live outside the generic file allowlist.
+      let validatedRoot: string;
+      try {
+        validatedRoot = resolveAllowedProjectRoot(rootPath);
+      } catch {
+        return { dataUrl: null, sourcePath: null, mimeType: null };
+      }
+      return resolveProjectIcon(validatedRoot);
+    },
+  );
+
   ipcMain.handle(IPC.projectOpenAdeFolder, async (): Promise<void> => {
     const ctx = getCtx();
     await shell.openPath(ctx.adeDir);
diff --git a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts
index def36e16f..c550559dd 100644
--- a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts
+++ b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts
@@ -3278,9 +3278,11 @@ describe("aiOrchestratorService", () => {
       }) as typeof fixture.orchestratorService.onTrackedSessionEnded;
 
       const firstSweep = fixture.aiOrchestratorService.runHealthSweep("overlap-owner");
-      // CI runners can be heavily loaded; give the first sweep up to ~5s to reach
-      // the gated `onTrackedSessionEnded` call before we assert it was invoked.
-      for (let tries = 0; tries < 200 && reconcileCalls === 0; tries += 1) {
+      // CI runners can be heavily loaded; give the first sweep up to ~15s to
+      // reach the gated `onTrackedSessionEnded` call before we assert it was
+      // invoked. The test passes immediately when the callback fires, so the
+      // generous ceiling only kicks in for slow/contended runners.
+      for (let tries = 0; tries < 600 && reconcileCalls === 0; tries += 1) {
         await new Promise((resolve) => setTimeout(resolve, 25));
       }
       expect(reconcileCalls).toBe(1);
@@ -3295,7 +3297,7 @@ describe("aiOrchestratorService", () => {
       releaseFirstSweep();
       fixture.dispose();
     }
-  }, 15_000);
+  }, 30_000);
 
   it("skips background health sweeps for runs blocked on open interventions", async () => {
     const fixture = await createFixture();
diff --git a/apps/desktop/src/main/services/projects/projectIconResolver.test.ts b/apps/desktop/src/main/services/projects/projectIconResolver.test.ts
new file mode 100644
index 000000000..c5d6633a4
--- /dev/null
+++ b/apps/desktop/src/main/services/projects/projectIconResolver.test.ts
@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { resolveProjectIcon, resolveProjectIconPath } from "./projectIconResolver";
+
+function makeProjectRoot(): string {
+  // Resolve through realpath so the assertions still hold on platforms
+  // (macOS) where the system tmpdir is itself a symlink (e.g. `/var` ->
+  // `/private/var`). The resolver returns canonical realpaths for callers.
+  return fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "ade-project-icon-")));
+}
+
+function writeFile(root: string, relativePath: string, contents: string | Buffer): string {
+  const filePath = path.join(root, relativePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+  return filePath;
+}
+
+describe("projectIconResolver", () => {
+  it("prefers well-known favicon files", () => {
+    const root = makeProjectRoot();
+    const iconPath = writeFile(root, "favicon.svg", "<svg>favicon</svg>");
+
+    expect(resolveProjectIconPath(root)).toBe(iconPath);
+  });
+
+  it("resolves icon hrefs from project source files", () => {
+    const root = makeProjectRoot();
+    writeFile(root, "index.html", '<link rel="icon" href="/brand/logo.svg">');
+    const iconPath = writeFile(root, "public/brand/logo.svg", "<svg>brand</svg>");
+
+    expect(resolveProjectIconPath(root)).toBe(iconPath);
+  });
+
+  it("does not resolve linked icons outside the project root", () => {
+    const root = makeProjectRoot();
+    writeFile(path.dirname(root), "outside.svg", "<svg>outside</svg>");
+    writeFile(root, "index.html", '<link rel="icon" href="../outside.svg">');
+
+    expect(resolveProjectIconPath(root)).toBeNull();
+  });
+
+  it("does not follow a symlinked icon directory outside the project root", () => {
+    const root = makeProjectRoot();
+    const outside = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "ade-outside-")));
+    fs.writeFileSync(path.join(outside, "favicon.svg"), "<svg>outside</svg>");
+    // Symlink `<root>/public` -> `<outside>` so any `public/<icon>` candidate
+    // would escape the project root if resolved lexically.
+    fs.symlinkSync(outside, path.join(root, "public"));
+
+    expect(resolveProjectIconPath(root)).toBeNull();
+  });
+
+  it("returns a data URL for resolved icons", () => {
+    const root = makeProjectRoot();
+    writeFile(root, "favicon.svg", "<svg>favicon</svg>");
+
+    const icon = resolveProjectIcon(root);
+
+    expect(icon.mimeType).toBe("image/svg+xml");
+    expect(icon.sourcePath).toContain("favicon.svg");
+    expect(icon.dataUrl).toMatch(/^data:image\/svg\+xml;base64,/);
+  });
+});
diff --git a/apps/desktop/src/main/services/projects/projectIconResolver.ts b/apps/desktop/src/main/services/projects/projectIconResolver.ts
new file mode 100644
index 000000000..67b99b972
--- /dev/null
+++ b/apps/desktop/src/main/services/projects/projectIconResolver.ts
@@ -0,0 +1,157 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import type { ProjectIcon } from "../../../shared/types";
+import { resolvePathWithinRoot } from "../shared/utils";
+
+const ICON_MAX_BYTES = 1024 * 1024;
+
+const ICON_CANDIDATES = [
+  "favicon.svg",
+  "favicon.ico",
+  "favicon.png",
+  "public/favicon.svg",
+  "public/favicon.ico",
+  "public/favicon.png",
+  "app/favicon.ico",
+  "app/favicon.png",
+  "app/icon.svg",
+  "app/icon.png",
+  "app/icon.ico",
+  "src/favicon.ico",
+  "src/favicon.svg",
+  "src/app/favicon.ico",
+  "src/app/icon.svg",
+  "src/app/icon.png",
+  "assets/icon.svg",
+  "assets/icon.png",
+  "assets/logo.svg",
+  "assets/logo.png",
+  ".idea/icon.svg",
+] as const;
+
+const ICON_SOURCE_FILES = [
+  "index.html",
+  "public/index.html",
+  "app/routes/__root.tsx",
+  "src/routes/__root.tsx",
+  "app/root.tsx",
+  "src/root.tsx",
+  "src/index.html",
+] as const;
+
+const LINK_ICON_HTML_RE =
+  /<link\b(?=[^>]*\brel=["'](?:icon|shortcut icon)["'])(?=[^>]*\bhref=["']([^"'?]+))[^>]*>/i;
+const LINK_ICON_OBJ_RE =
+  /(?=[^}]*\brel\s*:\s*["'](?:icon|shortcut icon)["'])(?=[^}]*\bhref\s*:\s*["']([^"'?]+))[^}]*/i;
+
+function extractIconHref(source: string): string | null {
+  const htmlMatch = source.match(LINK_ICON_HTML_RE);
+  if (htmlMatch?.[1]) return htmlMatch[1];
+  const objMatch = source.match(LINK_ICON_OBJ_RE);
+  if (objMatch?.[1]) return objMatch[1];
+  return null;
+}
+
+function isLocalIconHref(href: string): boolean {
+  return !/^(?:[a-z][a-z\d+.-]*:)?\/\//i.test(href)
+    && !href.startsWith("data:")
+    && !href.startsWith("#");
+}
+
+function findExistingFile(projectRoot: string, candidates: readonly string[]): string | null {
+  for (const candidate of candidates) {
+    // resolvePathWithinRoot follows symlinks via fs.realpath, so a `public ->
+    // /etc` symlink in the checked-out repo can't trick us into stat'ing or
+    // reading outside the project root. Treat any failure (escape, missing
+    // file, ENOENT, etc.) as "no icon" and keep probing.
+    let resolved: string;
+    try {
+      resolved = resolvePathWithinRoot(projectRoot, candidate, { allowMissing: false });
+    } catch {
+      continue;
+    }
+    try {
+      const stat = fs.statSync(resolved);
+      if (stat.isFile()) return resolved;
+    } catch {
+      // Keep probing other candidates.
+    }
+  }
+  return null;
+}
+
+function resolveIconHref(projectRoot: string, href: string): string[] {
+  const clean = href.replace(/^\//, "");
+  return [path.join(projectRoot, "public", clean), path.join(projectRoot, clean)];
+}
+
+export function resolveProjectIconPath(projectRoot: string): string | null {
+  const root = path.resolve(projectRoot);
+  const directMatch = findExistingFile(root, ICON_CANDIDATES.map((candidate) => path.join(root, candidate)));
+  if (directMatch) return directMatch;
+
+  for (const sourceFile of ICON_SOURCE_FILES) {
+    // Resolve through the real filesystem so a symlinked source file (e.g.
+    // `index.html -> ../outside.html`) can't trick us into reading outside
+    // the project root.
+    let sourcePath: string;
+    try {
+      sourcePath = resolvePathWithinRoot(root, sourceFile, { allowMissing: false });
+    } catch {
+      continue;
+    }
+    let source: string;
+    try {
+      source = fs.readFileSync(sourcePath, "utf8");
+    } catch {
+      continue;
+    }
+    const href = extractIconHref(source);
+    if (!href || !isLocalIconHref(href)) continue;
+    const existing = findExistingFile(root, resolveIconHref(root, href));
+    if (existing) return existing;
+  }
+
+  return null;
+}
+
+function mimeTypeForIconPath(filePath: string): string | null {
+  switch (path.extname(filePath).toLowerCase()) {
+    case ".svg":
+      return "image/svg+xml";
+    case ".ico":
+      return "image/x-icon";
+    case ".png":
+      return "image/png";
+    default:
+      return null;
+  }
+}
+
+export function resolveProjectIcon(projectRoot: string): ProjectIcon {
+  const iconPath = resolveProjectIconPath(projectRoot);
+  if (!iconPath) return { dataUrl: null, sourcePath: null, mimeType: null };
+
+  const mimeType = mimeTypeForIconPath(iconPath);
+  if (!mimeType) return { dataUrl: null, sourcePath: null, mimeType: null };
+
+  // resolveProjectIconPath already returned a realpath inside the project
+  // root, but defensively swallow any read/stat failure (e.g. a race that
+  // unlinks the icon between resolve and read) and return "no icon" rather
+  // than crashing.
+  try {
+    const stat = fs.statSync(iconPath);
+    if (stat.size > ICON_MAX_BYTES) {
+      return { dataUrl: null, sourcePath: iconPath, mimeType };
+    }
+    const data = fs.readFileSync(iconPath);
+    return {
+      dataUrl: `data:${mimeType};base64,${data.toString("base64")}`,
+      sourcePath: iconPath,
+      mimeType,
+    };
+  } catch {
+    return { dataUrl: null, sourcePath: null, mimeType: null };
+  }
+}
diff --git a/apps/desktop/src/main/services/pty/ptyService.test.ts b/apps/desktop/src/main/services/pty/ptyService.test.ts
index 2ebe85047..c968c5a16 100644
--- a/apps/desktop/src/main/services/pty/ptyService.test.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.test.ts
@@ -447,6 +447,38 @@ describe("ptyService", () => {
       expect(mockPty.write).not.toHaveBeenCalled();
     });
 
+    it("falls back to typing startupCommand in a shell when direct command spawn fails", async () => {
+      const { service, mockPty, loadPty } = createHarness();
+      const spawn = vi.fn((command: string) => {
+        if (command === "codex") throw new Error("ENOENT");
+        return mockPty;
+      });
+      loadPty.mockImplementationOnce(() => ({ spawn: spawn as any }));
+
+      await service.create({
+        laneId: "lane-1",
+        title: "Codex CLI",
+        cols: 80,
+        rows: 24,
+        toolType: "codex",
+        command: "codex",
+        args: ["--no-alt-screen", "ADE session guidance"],
+        startupCommand: "codex --no-alt-screen \"ADE session guidance\"",
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        "codex",
+        ["--no-alt-screen", "ADE session guidance"],
+        expect.any(Object),
+      );
+      expect(spawn).toHaveBeenCalledWith(
+        expect.stringMatching(/(?:zsh|bash|sh|powershell|cmd)(?:\.exe)?$/),
+        expect.any(Array),
+        expect.any(Object),
+      );
+      expect(mockPty.write).toHaveBeenCalledWith("codex --no-alt-screen \"ADE session guidance\"\r");
+    });
+
     it("wraps direct Windows command shims through cmd.exe", async () => {
       setPlatform("win32");
       const harness = createHarness();
@@ -1157,8 +1189,8 @@ describe("ptyService", () => {
         const homedir = os.homedir();
         const sessionsBase = path.join(homedir, ".codex", "sessions");
         const dirPath = path.join(sessionsBase, "2026", "04", "15");
-        const filePath = path.join(dirPath, "rollout-2026-04-15T21-30-00-thread-storage.jsonl");
-        const startedAt = "2026-04-15T21:30:00.000Z";
+        const filePath = path.join(dirPath, "rollout-2026-04-15T22-00-01-thread-storage.jsonl");
+        const startedAt = "2026-04-15T22:00:01.000Z";
         const oversizedFirstLine = JSON.stringify({
           timestamp: startedAt,
           type: "session_meta",
@@ -1496,7 +1528,13 @@ describe("ptyService", () => {
   });
 
   describe("ensureResumeTargets", () => {
-    it("calls sessionService.setResumeCommand for each session whose Codex JSONL matches", async () => {
+    it("backfills Codex storage resume targets during session-list hydration", async () => {
+      // The session-list path is how older sessions (whose transcripts no
+      // longer contain an explicit resume command) get their resume target
+      // backfilled. Excluding `session-list` from the Codex storage fallback
+      // breaks resumption of those sessions, so the fallback must run here.
+      // Only `resume-launch` is excluded — that flow uses the live capture
+      // poll for fresh sessions and the storage scan would slow launch.
       vi.useFakeTimers();
       try {
         const fakeNow = new Date("2026-04-15T22:00:00.000Z");
@@ -1545,6 +1583,63 @@ describe("ptyService", () => {
       }
     });
 
+    it("captures a fresh Codex storage target for a new launch without choosing older same-cwd sessions", async () => {
+      vi.useFakeTimers();
+      try {
+        const fakeNow = new Date("2026-04-15T22:00:00.000Z");
+        vi.setSystemTime(fakeNow);
+
+        const homedir = os.homedir();
+        const sessionsBase = path.join(homedir, ".codex", "sessions");
+        const dirPath = path.join(sessionsBase, "2026", "04", "15");
+        const stalePath = path.join(dirPath, "rollout-2026-04-15T21-30-00-thread-stale.jsonl");
+        const freshPath = path.join(dirPath, "rollout-2026-04-15T22-00-01-thread-fresh.jsonl");
+        const staleFirstLine = JSON.stringify({
+          timestamp: "2026-04-15T21:30:00.000Z",
+          type: "session_meta",
+          payload: {
+            id: "thread-stale",
+            timestamp: "2026-04-15T21:30:00.000Z",
+            cwd: "/tmp/test-worktree",
+          },
+        });
+        const freshFirstLine = JSON.stringify({
+          timestamp: "2026-04-15T22:00:01.000Z",
+          type: "session_meta",
+          payload: {
+            id: "thread-fresh",
+            timestamp: "2026-04-15T22:00:01.000Z",
+            cwd: "/tmp/test-worktree",
+          },
+        });
+
+        mocks.existsSyncResults.set(sessionsBase, true);
+        mocks.existsSyncResults.set(dirPath, true);
+        mocks.dirEntries.set(dirPath, [path.basename(stalePath), path.basename(freshPath)]);
+        mocks.fileContents.set(stalePath, `${staleFirstLine}\n`);
+        mocks.fileContents.set(freshPath, `${freshFirstLine}\n{"timestamp":"2026-04-15T22:00:01.500Z","type":"event_msg","payload":{"type":"user_message","message":"ADE session guidance"}}\n`);
+        mocks.fileStats.set(stalePath, { size: staleFirstLine.length, mtimeMs: fakeNow.getTime() - 30 * 60_000, isDirectory: false });
+        mocks.fileStats.set(freshPath, { size: freshFirstLine.length, mtimeMs: fakeNow.getTime() + 1_000, isDirectory: false });
+
+        const { service, sessionService } = createHarness();
+        const created = await service.create({
+          laneId: "lane-1",
+          title: "Codex CLI",
+          cols: 80,
+          rows: 24,
+          toolType: "codex",
+          startupCommand: "codex --no-alt-screen --dangerously-bypass-approvals-and-sandbox",
+        });
+
+        await vi.advanceTimersByTimeAsync(1_500);
+
+        expect(sessionService.setResumeCommand).toHaveBeenCalledWith(created.sessionId, "codex resume thread-fresh");
+        expect(sessionService.setResumeCommand).not.toHaveBeenCalledWith(created.sessionId, "codex resume thread-stale");
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
     it("dedupes duplicate/empty/whitespace sessionIds", async () => {
       const { service, sessionService } = createHarness();
       // No session is seeded, so tryBackfillResumeTarget returns early after calling get();
diff --git a/apps/desktop/src/main/services/pty/ptyService.ts b/apps/desktop/src/main/services/pty/ptyService.ts
index 041f51c2d..a7a9bf3f2 100644
--- a/apps/desktop/src/main/services/pty/ptyService.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.ts
@@ -697,13 +697,40 @@ export function createPtyService({
     }
   }
 
+  function readFilePrefix(filePath: string, maxBytes = 512 * 1024): string | null {
+    let fd: number | null = null;
+    try {
+      fd = fs.openSync(filePath, "r");
+      const buf = Buffer.alloc(maxBytes);
+      const bytesRead = fs.readSync(fd, buf, 0, maxBytes, 0);
+      if (bytesRead <= 0) return null;
+      return buf.subarray(0, bytesRead).toString("utf8");
+    } catch {
+      return null;
+    } finally {
+      if (fd !== null) {
+        try {
+          fs.closeSync(fd);
+        } catch {
+          // Ignore close errors while scanning best-effort session metadata.
+        }
+      }
+    }
+  }
+
   /**
    * Try to find the Codex session ID from Codex's local storage.
    * Codex stores sessions at ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl.
    * Each JSONL starts with a session_meta event containing `payload.id` and `payload.cwd`.
    * We score recent candidates by cwd match and closeness to ADE's session startedAt.
    */
-  const resolveCodexSessionIdFromStorage = (args: { cwd: string; startedAt?: string | null }): string | null => {
+  const resolveCodexSessionIdFromStorage = (args: {
+    cwd: string;
+    startedAt?: string | null;
+    maxStartDeltaMs?: number;
+    notBeforeMs?: number;
+    requiredText?: string;
+  }): string | null => {
     try {
       const sessionsBase = path.join(os.homedir(), ".codex", "sessions");
       if (!fs.existsSync(sessionsBase)) return null;
@@ -746,13 +773,22 @@ export function createPtyService({
         const id = typeof payload?.id === "string" ? payload.id.trim() : "";
         const cwd = typeof payload?.cwd === "string" ? payload.cwd.trim() : "";
         if (type !== "session_meta" || !id || cwd !== args.cwd) continue;
+        if (args.requiredText) {
+          // The Codex session_meta record sits at the very top of the JSONL,
+          // so 16 KB is more than enough to scan for the marker without
+          // pulling half a megabyte off disk per candidate inside the poll.
+          const prefix = readFilePrefix(candidate.filePath, 16 * 1024);
+          if (!prefix?.includes(args.requiredText)) continue;
+        }
 
         if (!hasStartedAt) return id;
 
         const payloadTimestamp = typeof payload?.timestamp === "string" ? payload.timestamp : "";
         const payloadTimestampMs = Date.parse(payloadTimestamp);
         const referenceMs = Number.isFinite(payloadTimestampMs) ? payloadTimestampMs : candidate.mtimeMs;
+        if (typeof args.notBeforeMs === "number" && referenceMs < args.notBeforeMs) continue;
         const score = Math.abs(referenceMs - requestedStartedAtMs);
+        if (typeof args.maxStartDeltaMs === "number" && score > args.maxStartDeltaMs) continue;
         if (!bestMatch || score < bestMatch.score || (score === bestMatch.score && candidate.mtimeMs > bestMatch.mtimeMs)) {
           bestMatch = { id, score, mtimeMs: candidate.mtimeMs };
         }
@@ -797,8 +833,17 @@ export function createPtyService({
       }
     }
 
-    if ((effectiveToolType === "codex" || effectiveToolType === "codex-orchestrated") && cwd) {
-      const codexSessionId = resolveCodexSessionIdFromStorage({ cwd, startedAt: session.startedAt });
+    // The session-list path NEEDS this Codex storage fallback: it's how we
+    // backfill resume targets for older sessions whose transcripts no longer
+    // contain an explicit resume command. Only resume-launch is excluded —
+    // that flow already has the live capture poll for fresh sessions, and
+    // running the storage scan inline would slow launch.
+    if ((effectiveToolType === "codex" || effectiveToolType === "codex-orchestrated") && cwd && reason !== "resume-launch") {
+      const codexSessionId = resolveCodexSessionIdFromStorage({
+        cwd,
+        startedAt: session.startedAt,
+        maxStartDeltaMs: 10 * 60_000,
+      });
       if (codexSessionId) {
         const resumeCmd = `codex resume ${codexSessionId}`;
         sessionService.setResumeCommand(sessionId, resumeCmd);
@@ -844,7 +889,14 @@ export function createPtyService({
           const session = sessionService.get(sessionId);
           if (!session) return;
           if (session.resumeMetadata?.targetId?.trim()) return;
-          const codexSessionId = resolveCodexSessionIdFromStorage({ cwd, startedAt });
+          const startedAtMs = Date.parse(startedAt);
+          const codexSessionId = resolveCodexSessionIdFromStorage({
+            cwd,
+            startedAt,
+            maxStartDeltaMs: 2 * 60_000,
+            ...(Number.isFinite(startedAtMs) ? { notBeforeMs: startedAtMs - 1_000 } : {}),
+            requiredText: "ADE session guidance",
+          });
           if (codexSessionId) {
             sessionService.setResumeCommand(sessionId, `codex resume ${codexSessionId}`);
             logger.info("pty.codex_session_id_captured_live", { sessionId, codexSessionId, attempt });
@@ -1176,6 +1228,7 @@ export function createPtyService({
       let selectedShell: ShellSpec | null = null;
       const directCommand = typeof args.command === "string" ? args.command.trim() : "";
       const directArgs = Array.isArray(args.args) ? args.args.filter((value): value is string => typeof value === "string") : [];
+      let launchedDirectCommand = false;
       try {
         const ptyLib = loadPty();
         const opts: IWindowsPtyForkOptions = {
@@ -1194,14 +1247,17 @@ export function createPtyService({
               ? invocation.args.join(" ")
               : invocation.args;
             created = ptyLib.spawn(invocation.command, ptyArgs, opts);
+            launchedDirectCommand = true;
           } catch (err) {
             lastErr = err;
           }
-        } else {
+        }
+        if (!created && (!directCommand || startupCommand)) {
           for (const shell of shellCandidates) {
             try {
               created = ptyLib.spawn(shell.file, shell.args, opts);
               selectedShell = shell;
+              launchedDirectCommand = false;
               break;
             } catch (err) {
               lastErr = err;
@@ -1380,10 +1436,10 @@ export function createPtyService({
       });
 
       // Only type the startup command into the terminal when we launched an
-      // interactive shell (no directCommand). If directCommand is set we either
-      // already threw on spawn failure or the command is running directly — in
-      // neither case do we want to feed an extra startupCommand string.
-      if (startupCommand && !directCommand && selectedShell) {
+      // interactive shell. Direct command launches already received argv; if a
+      // direct launch fell back to shell, startupCommand keeps compatibility
+      // with CLIs that are only available through shell startup files.
+      if (startupCommand && !launchedDirectCommand && selectedShell) {
         try {
           pty.write(`${startupCommand}\r`);
           setRuntimeState(sessionId, "running");
diff --git a/apps/desktop/src/main/services/sync/syncRemoteCommandService.test.ts b/apps/desktop/src/main/services/sync/syncRemoteCommandService.test.ts
index 3a29e2f95..ecdf6b3c8 100644
--- a/apps/desktop/src/main/services/sync/syncRemoteCommandService.test.ts
+++ b/apps/desktop/src/main/services/sync/syncRemoteCommandService.test.ts
@@ -433,6 +433,8 @@ function createMockConflictService() {
     getLaneStatus: vi.fn().mockResolvedValue(null),
     listOverlaps: vi.fn().mockResolvedValue([]),
     getBatchAssessment: vi.fn().mockResolvedValue({ lanes: [] }),
+    dismissRebase: vi.fn(),
+    deferRebase: vi.fn(),
   } as any;
 }
 
@@ -2206,6 +2208,38 @@ describe("createSyncRemoteCommandService", () => {
         laneIds: [],
       }))).rejects.toThrow("lanes.rebasePush requires laneIds.");
     });
+
+    it("lanes.dismissRebaseSuggestion routes to conflictService even without a rebaseSuggestionService", async () => {
+      const result = await service.execute(makePayload("lanes.dismissRebaseSuggestion", {
+        laneId: "lane-1",
+      }));
+      expect(conflictService.dismissRebase).toHaveBeenCalledWith("lane-1");
+      expect(result).toEqual({ ok: true });
+    });
+
+    it("lanes.deferRebaseSuggestion clamps minutes and forwards an ISO timestamp to conflictService", async () => {
+      vi.useFakeTimers();
+      try {
+        vi.setSystemTime(new Date("2026-04-15T22:00:00.000Z"));
+        await service.execute(makePayload("lanes.deferRebaseSuggestion", {
+          laneId: "lane-1",
+          minutes: 1,
+        }));
+        expect(conflictService.deferRebase).toHaveBeenCalledWith(
+          "lane-1",
+          "2026-04-15T22:05:00.000Z",
+        );
+        conflictService.deferRebase.mockClear();
+        await service.execute(makePayload("lanes.deferRebaseSuggestion", {
+          laneId: "lane-1",
+          minutes: 60 * 24 * 30,
+        }));
+        const [, until] = conflictService.deferRebase.mock.calls.at(-1) ?? [];
+        expect(until).toBe(new Date(Date.parse("2026-04-15T22:00:00.000Z") + 7 * 24 * 60 * 60_000).toISOString());
+      } finally {
+        vi.useRealTimers();
+      }
+    });
   });
 
   // ---------------------------------------------------------------
diff --git a/apps/desktop/src/main/services/sync/syncRemoteCommandService.ts b/apps/desktop/src/main/services/sync/syncRemoteCommandService.ts
index fdd07e5b9..2e2803bf7 100644
--- a/apps/desktop/src/main/services/sync/syncRemoteCommandService.ts
+++ b/apps/desktop/src/main/services/sync/syncRemoteCommandService.ts
@@ -1524,16 +1524,24 @@ export function createSyncRemoteCommandService(args: SyncRemoteCommandServiceArg
   register("lanes.rebaseAbort", { viewerAllowed: true, queueable: true }, async (payload) => args.laneService.rebaseAbort(parseRunIdArgs(payload, "lanes.rebaseAbort")));
   register("lanes.listRebaseSuggestions", { viewerAllowed: true }, async () => args.rebaseSuggestionService?.listSuggestions() ?? []);
   register("lanes.dismissRebaseSuggestion", { viewerAllowed: true, queueable: true }, async (payload) => {
-    if (!args.rebaseSuggestionService) return { ok: true };
-    await args.rebaseSuggestionService.dismiss({ laneId: requireString(payload.laneId, "lanes.dismissRebaseSuggestion requires laneId.") });
+    const laneId = requireString(payload.laneId, "lanes.dismissRebaseSuggestion requires laneId.");
+    args.conflictService?.dismissRebase(laneId);
+    if (args.rebaseSuggestionService) {
+      await args.rebaseSuggestionService.dismiss({ laneId });
+    }
     return { ok: true };
   });
   register("lanes.deferRebaseSuggestion", { viewerAllowed: true, queueable: true }, async (payload) => {
-    if (!args.rebaseSuggestionService) return { ok: true };
-    await args.rebaseSuggestionService.defer({
-      laneId: requireString(payload.laneId, "lanes.deferRebaseSuggestion requires laneId."),
-      minutes: asOptionalNumber(payload.minutes) ?? 60,
-    });
+    const laneId = requireString(payload.laneId, "lanes.deferRebaseSuggestion requires laneId.");
+    const minutes = Math.max(5, Math.min(7 * 24 * 60, Math.floor(asOptionalNumber(payload.minutes) ?? 60)));
+    const until = new Date(Date.now() + minutes * 60_000).toISOString();
+    args.conflictService?.deferRebase(laneId, until);
+    if (args.rebaseSuggestionService) {
+      await args.rebaseSuggestionService.defer({
+        laneId,
+        minutes,
+      });
+    }
     return { ok: true };
   });
   register("lanes.listAutoRebaseStatuses", { viewerAllowed: true }, async () => args.autoRebaseService?.listStatuses() ?? []);
diff --git a/apps/desktop/src/preload/global.d.ts b/apps/desktop/src/preload/global.d.ts
index c60f30f7e..843451823 100644
--- a/apps/desktop/src/preload/global.d.ts
+++ b/apps/desktop/src/preload/global.d.ts
@@ -5,6 +5,7 @@ import type {
   ProjectBrowseInput,
   ProjectBrowseResult,
   ProjectDetail,
+  ProjectIcon,
   BatchAssessmentResult,
   ApplyConflictProposalArgs,
   AttachLaneArgs,
@@ -608,6 +609,8 @@ declare global {
         revealPath: (path: string) => Promise<void>;
         openPath: (path: string) => Promise<void>;
         writeClipboardText: (text: string) => Promise<void>;
+        getImageDataUrl: (path: string) => Promise<{ dataUrl: string }>;
+        writeClipboardImage: (path: string) => Promise<void>;
         openPathInEditor: (args: {
           rootPath: string;
           relativePath?: string;
@@ -628,6 +631,7 @@ declare global {
           args?: ProjectBrowseInput,
         ) => Promise<ProjectBrowseResult>;
         getDetail: (rootPath: string) => Promise<ProjectDetail>;
+        resolveIcon: (rootPath: string) => Promise<ProjectIcon>;
         getDroppedPath: (file: File) => string;
         openAdeFolder: () => Promise<void>;
         clearLocalData: (
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index 10ba40d0c..5faebc117 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -7,6 +7,7 @@ import type {
   ProjectBrowseInput,
   ProjectBrowseResult,
   ProjectDetail,
+  ProjectIcon,
 } from "../shared/types";
 import type {
   BatchAssessmentResult,
@@ -619,6 +620,10 @@ contextBridge.exposeInMainWorld("ade", {
       ipcRenderer.invoke(IPC.appOpenPath, { path }),
     writeClipboardText: async (text: string): Promise<void> =>
       ipcRenderer.invoke(IPC.appWriteClipboardText, { text }),
+    getImageDataUrl: async (path: string): Promise<{ dataUrl: string }> =>
+      ipcRenderer.invoke(IPC.appGetImageDataUrl, { path }),
+    writeClipboardImage: async (path: string): Promise<void> =>
+      ipcRenderer.invoke(IPC.appWriteClipboardImage, { path }),
     openPathInEditor: async (args: {
       rootPath: string;
       relativePath?: string;
@@ -640,6 +645,8 @@ contextBridge.exposeInMainWorld("ade", {
       ipcRenderer.invoke(IPC.projectBrowseDirectories, args),
     getDetail: async (rootPath: string): Promise<ProjectDetail> =>
       ipcRenderer.invoke(IPC.projectGetDetail, { rootPath }),
+    resolveIcon: async (rootPath: string): Promise<ProjectIcon> =>
+      ipcRenderer.invoke(IPC.projectResolveIcon, { rootPath }),
     getDroppedPath: (file: File): string => {
       try {
         return webUtils.getPathForFile(file);
diff --git a/apps/desktop/src/renderer/browserMock.ts b/apps/desktop/src/renderer/browserMock.ts
index af8269058..62e929909 100644
--- a/apps/desktop/src/renderer/browserMock.ts
+++ b/apps/desktop/src/renderer/browserMock.ts
@@ -1657,6 +1657,8 @@ if (typeof window !== "undefined" && !(window as any).ade) {
       openExternal: resolvedArg(undefined),
       revealPath: resolvedArg(undefined),
       writeClipboardText: resolvedArg(undefined),
+      getImageDataUrl: resolvedArg({ dataUrl: "" }),
+      writeClipboardImage: resolvedArg(undefined),
       openPathInEditor: resolvedArg(undefined),
     },
     project: {
@@ -1698,6 +1700,7 @@ if (typeof window !== "undefined" && !(window as any).ade) {
       }),
       listRecent: resolved([]),
       closeCurrent: resolved(undefined),
+      resolveIcon: resolvedArg({ dataUrl: null, sourcePath: null, mimeType: null }),
       switchToPath: resolvedArg(MOCK_PROJECT),
       forgetRecent: resolvedArg([]),
       reorderRecent: resolvedArg([]),
diff --git a/apps/desktop/src/renderer/components/app/App.tsx b/apps/desktop/src/renderer/components/app/App.tsx
index a67f0e4d2..cf3faf090 100644
--- a/apps/desktop/src/renderer/components/app/App.tsx
+++ b/apps/desktop/src/renderer/components/app/App.tsx
@@ -59,6 +59,7 @@ const CtoPage = React.lazy(() =>
 
 import { useAppStore } from "../../state/appStore";
 import { getDirtyFileTextForWindow } from "../../lib/dirtyWorkspaceBuffers";
+import { dispatchWorkSurfaceRevealed } from "../terminals/workSurfaceVisibility";
 
 const StartupSplashScreen = (
   <div className="flex h-full w-full flex-col items-center justify-center relative overflow-hidden" style={{ background: "var(--color-bg)" }}>
@@ -190,20 +191,64 @@ function PersistentWorkSurface({ active }: { active: boolean }) {
   const projectHydrated = useAppStore((s) => s.projectHydrated);
   const showWelcome = useAppStore((s) => s.showWelcome);
   const project = useAppStore((s) => s.project);
+  const workSurfaceRef = React.useRef<HTMLDivElement | null>(null);
+
+  // Only fire the reveal once the surface is *actually* mounted with a
+  // project. On a cold `/work` boot the route renders before `projectHydrated`
+  // / `project.rootPath` settle; firing the reveal here would notify
+  // listeners about a surface that's still showing the loading fallback.
+  const hasActiveProject = Boolean(project?.rootPath);
+  const shouldReveal = active && projectHydrated && hasActiveProject && !showWelcome;
+  React.useEffect(() => {
+    if (!shouldReveal) return;
+    const raf = window.requestAnimationFrame(() => {
+      dispatchWorkSurfaceRevealed();
+    });
+    const settleTimer = window.setTimeout(() => {
+      dispatchWorkSurfaceRevealed();
+    }, 120);
+    return () => {
+      window.cancelAnimationFrame(raf);
+      window.clearTimeout(settleTimer);
+    };
+  }, [shouldReveal]);
+
+  React.useEffect(() => {
+    const node = workSurfaceRef.current;
+    // The `<div ref={workSurfaceRef}>` below is gated by the `projectHydrated`
+    // / `hasActiveProject` / `showWelcome` early returns, so on a cold `/work`
+    // boot the ref is null on the first run when `active` flips true. Re-run
+    // once those guards settle so the inert state lands on the real node.
+    if (!node) return;
+    if (active) {
+      node.removeAttribute("inert");
+    } else {
+      node.setAttribute("inert", "");
+    }
+  }, [active, projectHydrated, hasActiveProject, showWelcome]);
 
   if (!projectHydrated) {
     return active ? GuardLoadingFallback : null;
   }
 
-  const hasActiveProject = Boolean(project?.rootPath);
   if (!hasActiveProject || showWelcome) {
     return active ? <Navigate to="/project" replace /> : null;
   }
 
   return (
     <div
+      ref={workSurfaceRef}
       className="h-full min-h-0 w-full"
-      hidden={!active}
+      aria-hidden={!active}
+      style={!active
+        ? {
+          position: "absolute",
+          inset: 0,
+          zIndex: -1,
+          opacity: 0,
+          pointerEvents: "none",
+        }
+        : undefined}
     >
       <PageErrorBoundary>
         <React.Suspense fallback={LazyFallback}>
diff --git a/apps/desktop/src/renderer/components/app/App.workKeepAlive.test.tsx b/apps/desktop/src/renderer/components/app/App.workKeepAlive.test.tsx
index b66d868d0..7a81c5171 100644
--- a/apps/desktop/src/renderer/components/app/App.workKeepAlive.test.tsx
+++ b/apps/desktop/src/renderer/components/app/App.workKeepAlive.test.tsx
@@ -121,18 +121,20 @@ describe("App Work route keep-alive", () => {
       expect(workLifecycle.mounts).toBe(1);
     });
     expect(workLifecycle.unmounts).toBe(0);
-    expect(workPage.closest("[hidden]")).toBeNull();
+    expect(workPage.closest("[aria-hidden='true']")).toBeNull();
 
     fireEvent.click(screen.getByRole("button", { name: "Open files" }));
     await screen.findByTestId("files-page");
 
-    expect(screen.getByTestId("work-page").closest("[hidden]")).not.toBeNull();
+    const parkedWorkSurface = screen.getByTestId("work-page").closest("[aria-hidden='true']");
+    expect(parkedWorkSurface).not.toBeNull();
+    expect(parkedWorkSurface?.hasAttribute("hidden")).toBe(false);
     expect(workLifecycle.mounts).toBe(1);
     expect(workLifecycle.unmounts).toBe(0);
 
     fireEvent.click(screen.getByRole("button", { name: "Open work" }));
     await waitFor(() => {
-      expect(screen.getByTestId("work-page").closest("[hidden]")).toBeNull();
+      expect(screen.getByTestId("work-page").closest("[aria-hidden='true']")).toBeNull();
     });
     expect(workLifecycle.mounts).toBe(1);
     expect(workLifecycle.unmounts).toBe(0);
diff --git a/apps/desktop/src/renderer/components/app/TopBar.test.tsx b/apps/desktop/src/renderer/components/app/TopBar.test.tsx
index 80935ad3e..1a6a2f266 100644
--- a/apps/desktop/src/renderer/components/app/TopBar.test.tsx
+++ b/apps/desktop/src/renderer/components/app/TopBar.test.tsx
@@ -120,6 +120,7 @@ describe("TopBar", () => {
         onMissing: vi.fn(() => () => {}),
         forgetRecent: vi.fn(async () => []),
         reorderRecent: vi.fn(async () => undefined),
+        resolveIcon: vi.fn(async () => ({ dataUrl: null, sourcePath: null, mimeType: null })),
       },
       sync: {
         getStatus: vi.fn(async () => makeSyncSnapshot()),
diff --git a/apps/desktop/src/renderer/components/app/TopBar.tsx b/apps/desktop/src/renderer/components/app/TopBar.tsx
index fbf0920a7..36bc8d5b5 100644
--- a/apps/desktop/src/renderer/components/app/TopBar.tsx
+++ b/apps/desktop/src/renderer/components/app/TopBar.tsx
@@ -11,13 +11,39 @@ import {
   getStoredZoomLevel,
 } from "../../lib/zoom";
 import { cn } from "../ui/cn";
-import type { ProcessRuntime, RecentProjectSummary, SyncRoleSnapshot } from "../../../shared/types";
+import type { ProcessRuntime, ProjectIcon, RecentProjectSummary, SyncRoleSnapshot } from "../../../shared/types";
 import { AutoUpdateControl } from "./AutoUpdateControl";
 import { FeedbackReporterModal } from "./FeedbackReporterModal";
 import { HelpMenu } from "../onboarding/HelpMenu";
 import { SyncDevicesSection } from "../settings/SyncDevicesSection";
 
 const RUNNING_LANE_PROCESS_STATES: ProcessRuntime["status"][] = ["starting", "running", "degraded"];
+
+// Bounded LRU so we don't accumulate icons for every project ever opened in
+// long-lived sessions. 24 entries keeps the working set hot for typical usage
+// (current project + a few recents in the tab list) without unbounded growth.
+const PROJECT_ICON_CACHE_MAX = 24;
+const projectIconCache = new Map<string, ProjectIcon>();
+function getProjectIconFromCache(rootPath: string): ProjectIcon | undefined {
+  const cached = projectIconCache.get(rootPath);
+  if (cached === undefined) return undefined;
+  // Touch on read to mark as most-recently-used.
+  projectIconCache.delete(rootPath);
+  projectIconCache.set(rootPath, cached);
+  return cached;
+}
+function setProjectIconCache(rootPath: string, icon: ProjectIcon): void {
+  if (projectIconCache.has(rootPath)) {
+    projectIconCache.delete(rootPath);
+  } else if (projectIconCache.size >= PROJECT_ICON_CACHE_MAX) {
+    // Map iteration order is insertion order, so the first key is the LRU.
+    const oldestKey = projectIconCache.keys().next().value;
+    if (oldestKey !== undefined) {
+      projectIconCache.delete(oldestKey);
+    }
+  }
+  projectIconCache.set(rootPath, icon);
+}
 const PHONE_SYNC_FOCUSABLE_SELECTOR = [
   "a[href]",
   "button:not([disabled])",
@@ -63,6 +89,79 @@ function deriveSyncLabel(snapshot: SyncRoleSnapshot | null): string | null {
   }
 }
 
+function ProjectTabIcon({
+  rootPath,
+  isCurrent,
+  animate,
+  disabled,
+}: {
+  rootPath: string;
+  isCurrent: boolean;
+  animate: boolean;
+  disabled: boolean;
+}) {
+  const [icon, setIcon] = useState<ProjectIcon | null>(() =>
+    disabled ? null : getProjectIconFromCache(rootPath) ?? null
+  );
+  const [failed, setFailed] = useState(false);
+
+  useEffect(() => {
+    setFailed(false);
+    // Honor `disabled` (e.g. project marked missing) BEFORE consulting the
+    // cache. Otherwise a project that was successfully resolved earlier in
+    // the session keeps showing its stale icon after it goes missing.
+    if (disabled) {
+      setIcon(null);
+      return;
+    }
+    const cached = getProjectIconFromCache(rootPath);
+    if (cached) {
+      setIcon(cached);
+      return;
+    }
+
+    let cancelled = false;
+    window.ade.project.resolveIcon(rootPath).then((nextIcon) => {
+      if (cancelled) return;
+      setProjectIconCache(rootPath, nextIcon);
+      setIcon(nextIcon);
+    }).catch(() => {
+      if (!cancelled) setIcon(null);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [disabled, rootPath]);
+
+  const fallback = (
+    <Folder
+      size={12}
+      weight="regular"
+      className={cn(
+        "shrink-0 transition-opacity duration-150",
+        isCurrent ? "opacity-90" : "opacity-70",
+        animate && "animate-pulse",
+      )}
+    />
+  );
+
+  if (!icon?.dataUrl || failed) return fallback;
+
+  return (
+    <img
+      src={icon.dataUrl}
+      alt=""
+      className={cn(
+        "h-3 w-3 shrink-0 rounded-[2px] object-contain transition-opacity duration-150",
+        isCurrent ? "opacity-95" : "opacity-75",
+        animate && "animate-pulse",
+      )}
+      draggable={false}
+      onError={() => setFailed(true)}
+    />
+  );
+}
+
 export function TopBar() {
   const project = useAppStore((s) => s.project);
   const projectHydrated = useAppStore((s) => s.projectHydrated);
@@ -437,14 +536,11 @@ export function TopBar() {
                   }}
                   title={isMissing ? `Missing: ${rp.rootPath}` : rp.rootPath}
                 >
-                  <Folder
-                    size={12}
-                    weight="regular"
-                    className={cn(
-                      "shrink-0 transition-opacity duration-150",
-                      isCurrent ? "opacity-90" : "opacity-70",
-                      (isSwitchTarget || isClosingTarget) && "animate-pulse"
-                    )}
+                  <ProjectTabIcon
+                    rootPath={rp.rootPath}
+                    isCurrent={isCurrent}
+                    animate={isSwitchTarget || isClosingTarget}
+                    disabled={isMissing}
                   />
                   {isSwitchTarget || isClosingTarget ? (
                     <CircleNotch size={11} weight="bold" className="shrink-0 animate-spin opacity-80" />
diff --git a/apps/desktop/src/renderer/components/chat/ChatAttachmentTray.test.tsx b/apps/desktop/src/renderer/components/chat/ChatAttachmentTray.test.tsx
new file mode 100644
index 000000000..d29a5b371
--- /dev/null
+++ b/apps/desktop/src/renderer/components/chat/ChatAttachmentTray.test.tsx
@@ -0,0 +1,77 @@
+/* @vitest-environment jsdom */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { ChatAttachmentTray } from "./ChatAttachmentTray";
+
+describe("ChatAttachmentTray", () => {
+  const getImageDataUrl = vi.fn();
+  const writeClipboardImage = vi.fn();
+
+  beforeEach(() => {
+    getImageDataUrl.mockResolvedValue({ dataUrl: "data:image/png;base64,abc123" });
+    writeClipboardImage.mockResolvedValue(undefined);
+    Object.defineProperty(window, "ade", {
+      configurable: true,
+      value: {
+        app: {
+          getImageDataUrl,
+          writeClipboardImage,
+        },
+      },
+    });
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.clearAllMocks();
+  });
+
+  it("renders image attachments as previews that can expand", async () => {
+    render(
+      <ChatAttachmentTray
+        attachments={[{ path: "/tmp/screenshot.png", type: "image" }]}
+        mode="standard"
+      />,
+    );
+
+    await waitFor(() => expect(getImageDataUrl).toHaveBeenCalledWith("/tmp/screenshot.png"));
+
+    const openButton = screen.getByRole("button", { name: "Open screenshot.png" });
+    expect(screen.getByAltText("screenshot.png").getAttribute("src")).toBe("data:image/png;base64,abc123");
+
+    fireEvent.click(openButton);
+
+    expect(screen.getByRole("dialog", { name: "screenshot.png" })).toBeTruthy();
+  });
+
+  it("copies and removes image attachments from the preview controls", async () => {
+    const onRemove = vi.fn();
+
+    render(
+      <ChatAttachmentTray
+        attachments={[{ path: "/tmp/pasted-image.png", type: "image" }]}
+        mode="standard"
+        onRemove={onRemove}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Copy pasted-image.png" }));
+    await waitFor(() => expect(writeClipboardImage).toHaveBeenCalledWith("/tmp/pasted-image.png"));
+
+    fireEvent.click(screen.getByRole("button", { name: "Remove pasted-image.png" }));
+    expect(onRemove).toHaveBeenCalledWith("/tmp/pasted-image.png");
+  });
+
+  it("keeps non-image attachments as filename chips", () => {
+    render(
+      <ChatAttachmentTray
+        attachments={[{ path: "/tmp/context.txt", type: "file" }]}
+        mode="standard"
+      />,
+    );
+
+    expect(screen.getByText("context.txt")).toBeTruthy();
+    expect(screen.queryByRole("button", { name: "Open context.txt" })).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/renderer/components/chat/ChatAttachmentTray.tsx b/apps/desktop/src/renderer/components/chat/ChatAttachmentTray.tsx
index b7e7fee8a..e31cb32d5 100644
--- a/apps/desktop/src/renderer/components/chat/ChatAttachmentTray.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatAttachmentTray.tsx
@@ -1,7 +1,245 @@
-import { File, Image, X } from "@phosphor-icons/react";
+import { useEffect, useRef, useState, type KeyboardEvent, type MouseEvent } from "react";
+import { Copy, File, Image, X } from "@phosphor-icons/react";
 import type { AgentChatFileRef, ChatSurfaceMode } from "../../../shared/types";
 import { cn } from "../ui/cn";
 
+function attachmentName(path: string): string {
+  // Split on both POSIX and Windows separators so a Windows path
+  // like "C:\\Users\\foo\\bar.png" yields "bar.png" instead of the
+  // full path.
+  const segments = path.split(/[/\\]/);
+  return segments.pop() || path;
+}
+
+function ImageAttachmentPreview({
+  attachment,
+  toneClassName,
+  onRemove,
+}: {
+  attachment: AgentChatFileRef;
+  toneClassName: string;
+  onRemove?: (path: string) => void;
+}) {
+  const [dataUrl, setDataUrl] = useState<string | null>(null);
+  const [previewFailed, setPreviewFailed] = useState(false);
+  const [expanded, setExpanded] = useState(false);
+  const [copyState, setCopyState] = useState<"idle" | "copied" | "failed">("idle");
+  const name = attachmentName(attachment.path);
+
+  useEffect(() => {
+    let cancelled = false;
+    setDataUrl(null);
+    setPreviewFailed(false);
+    if (!window.ade?.app?.getImageDataUrl) {
+      setPreviewFailed(true);
+      return;
+    }
+    window.ade.app.getImageDataUrl(attachment.path)
+      .then((result) => {
+        if (!cancelled) setDataUrl(result.dataUrl);
+      })
+      .catch(() => {
+        if (!cancelled) setPreviewFailed(true);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [attachment.path]);
+
+  useEffect(() => {
+    if (copyState === "idle") return;
+    const timeout = window.setTimeout(() => setCopyState("idle"), 1200);
+    return () => window.clearTimeout(timeout);
+  }, [copyState]);
+
+  const copyImage = async (event: MouseEvent<HTMLButtonElement>) => {
+    event.stopPropagation();
+    try {
+      await window.ade.app.writeClipboardImage(attachment.path);
+      setCopyState("copied");
+    } catch {
+      setCopyState("failed");
+    }
+  };
+
+  let copyTitle: string;
+  switch (copyState) {
+    case "copied":
+      copyTitle = "Copied";
+      break;
+    case "failed":
+      copyTitle = "Copy failed";
+      break;
+    default:
+      copyTitle = `Copy ${name}`;
+      break;
+  }
+
+  return (
+    <>
+      <div
+        className={cn(
+          "group/image relative h-14 w-14 shrink-0 overflow-hidden rounded-md border p-0 text-left transition-colors focus:outline-none focus:ring-1 focus:ring-white/25",
+          toneClassName,
+        )}
+      >
+        <button
+          type="button"
+          className="block h-full w-full p-0"
+          title={`Open ${name}`}
+          aria-label={`Open ${name}`}
+          onClick={() => {
+            if (dataUrl) setExpanded(true);
+          }}
+        >
+          {dataUrl ? (
+            <img src={dataUrl} alt={name} className="h-full w-full object-cover" draggable={false} />
+          ) : (
+            <span className="flex h-full w-full items-center justify-center bg-black/18 text-current/60">
+              <Image size={18} weight="bold" />
+            </span>
+          )}
+        </button>
+        {previewFailed ? (
+          <span className="absolute inset-x-1 bottom-1 truncate rounded bg-black/65 px-1 py-0.5 text-center text-[8px] text-white/75">
+            No preview
+          </span>
+        ) : null}
+        <span className="pointer-events-none absolute inset-0 flex items-start justify-end gap-1 bg-black/0 p-1 opacity-0 transition-opacity group-hover/image:bg-black/35 group-hover/image:opacity-100 group-focus-within/image:bg-black/35 group-focus-within/image:opacity-100">
+          <button
+            type="button"
+            className="pointer-events-auto inline-flex h-5 w-5 items-center justify-center rounded border border-white/10 bg-black/70 text-white/80 transition-colors hover:bg-black hover:text-white"
+            title={copyTitle}
+            aria-label={`Copy ${name}`}
+            onClick={copyImage}
+          >
+            <Copy size={11} weight="bold" />
+          </button>
+          {onRemove ? (
+            <button
+              type="button"
+              className="pointer-events-auto inline-flex h-5 w-5 items-center justify-center rounded border border-white/10 bg-black/70 text-white/80 transition-colors hover:bg-black hover:text-white"
+              title={`Remove ${name}`}
+              aria-label={`Remove ${name}`}
+              onClick={(event) => {
+                event.stopPropagation();
+                onRemove(attachment.path);
+              }}
+            >
+              <X size={11} weight="bold" />
+            </button>
+          ) : null}
+        </span>
+      </div>
+      {expanded && dataUrl ? (
+        <ImageLightbox
+          name={name}
+          dataUrl={dataUrl}
+          onClose={() => setExpanded(false)}
+        />
+      ) : null}
+    </>
+  );
+}
+
+function ImageLightbox({
+  name,
+  dataUrl,
+  onClose,
+}: {
+  name: string;
+  dataUrl: string;
+  onClose: () => void;
+}) {
+  const closeButtonRef = useRef<HTMLButtonElement | null>(null);
+  const containerRef = useRef<HTMLDivElement | null>(null);
+
+  // Save the element that opened us so focus can return there on close,
+  // pull focus into the dialog on mount, and lock body scroll while open so
+  // the wheel doesn't move the page behind the overlay.
+  useEffect(() => {
+    const previouslyFocused = document.activeElement as HTMLElement | null;
+    closeButtonRef.current?.focus();
+    const previousBodyOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = previousBodyOverflow;
+      if (previouslyFocused && typeof previouslyFocused.focus === "function") {
+        previouslyFocused.focus();
+      }
+    };
+  }, []);
+
+  // Close on Escape and trap Tab / Shift-Tab inside the dialog. The dialog
+  // contains exactly the close button as a focusable element, so the trap
+  // pins focus there in either direction.
+  const handleKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {
+    if (event.key === "Escape") {
+      event.stopPropagation();
+      onClose();
+      return;
+    }
+    if (event.key !== "Tab") return;
+    const root = containerRef.current;
+    if (!root) return;
+    const focusables = Array.from(
+      root.querySelectorAll<HTMLElement>(
+        'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])',
+      ),
+    ).filter((element) => element.tabIndex >= 0);
+    if (focusables.length === 0) {
+      event.preventDefault();
+      closeButtonRef.current?.focus();
+      return;
+    }
+    const first = focusables[0]!;
+    const last = focusables[focusables.length - 1]!;
+    const active = document.activeElement as HTMLElement | null;
+    if (event.shiftKey) {
+      if (active === first || !active || !root.contains(active)) {
+        event.preventDefault();
+        last.focus();
+      }
+    } else {
+      if (active === last || !active || !root.contains(active)) {
+        event.preventDefault();
+        first.focus();
+      }
+    }
+  };
+
+  return (
+    <div
+      ref={containerRef}
+      className="fixed inset-0 z-[120] flex items-center justify-center bg-black/75 p-8"
+      role="dialog"
+      aria-modal="true"
+      aria-label={name}
+      onClick={onClose}
+      onKeyDown={handleKeyDown}
+    >
+      <div className="relative max-h-full max-w-full">
+        <button
+          ref={closeButtonRef}
+          type="button"
+          className="absolute right-2 top-2 inline-flex h-7 w-7 items-center justify-center rounded border border-white/10 bg-black/70 text-white/80 transition-colors hover:bg-black hover:text-white"
+          title="Close"
+          aria-label="Close"
+          onClick={onClose}
+        >
+          <X size={14} weight="bold" />
+        </button>
+        <img
+          src={dataUrl}
+          alt={name}
+          className="max-h-[calc(100vh-4rem)] max-w-[calc(100vw-4rem)] rounded-md object-contain"
+          onClick={(event) => event.stopPropagation()}
+        />
+      </div>
+    </div>
+  );
+}
+
 export function ChatAttachmentTray({
   attachments,
   mode,
@@ -33,28 +271,41 @@ export function ChatAttachmentTray({
 
   return (
     <div className={cn("flex flex-wrap items-center gap-2 px-4 py-3", className)}>
-      {attachments.map((attachment) => (
-        <span
-          key={attachment.path}
-          className={cn(
-            "ade-liquid-glass-pill group inline-flex max-w-full items-center gap-2 rounded-[var(--chat-radius-pill)] px-2.5 py-1.5 font-mono text-[10px] transition-colors",
-            chipTone,
-          )}
-        >
-          {attachment.type === "image" ? <Image size={12} weight="bold" /> : <File size={12} weight="bold" />}
-          <span className="max-w-[260px] truncate">{attachment.path.split("/").pop() ?? attachment.path}</span>
-          {onRemove ? (
-            <button
-              type="button"
-              className="rounded-full text-current/45 transition-colors hover:bg-white/[0.06] hover:text-current"
-              title={`Remove ${attachment.path}`}
-              onClick={() => onRemove(attachment.path)}
-            >
-              <X size={10} weight="bold" />
-            </button>
-          ) : null}
-        </span>
-      ))}
+      {attachments.map((attachment) => {
+        if (attachment.type === "image") {
+          return (
+            <ImageAttachmentPreview
+              key={attachment.path}
+              attachment={attachment}
+              toneClassName={chipTone}
+              onRemove={onRemove}
+            />
+          );
+        }
+        return (
+          <span
+            key={attachment.path}
+            className={cn(
+              "ade-liquid-glass-pill group inline-flex max-w-full items-center gap-2 rounded-[var(--chat-radius-pill)] px-2.5 py-1.5 font-mono text-[10px] transition-colors",
+              chipTone,
+            )}
+          >
+            <File size={12} weight="bold" />
+            <span className="max-w-[260px] truncate">{attachmentName(attachment.path)}</span>
+            {onRemove ? (
+              <button
+                type="button"
+                className="rounded-full text-current/45 transition-colors hover:bg-white/[0.06] hover:text-current"
+                title={`Remove ${attachmentName(attachment.path)}`}
+                aria-label={`Remove ${attachmentName(attachment.path)}`}
+                onClick={() => onRemove(attachment.path)}
+              >
+                <X size={10} weight="bold" />
+              </button>
+            ) : null}
+          </span>
+        );
+      })}
     </div>
   );
 }
diff --git a/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts b/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts
index 07fdfe2d0..ddd5225e1 100644
--- a/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts
+++ b/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts
@@ -5,7 +5,7 @@ import { listSessionsCached, invalidateSessionListCache } from "../../lib/sessio
 import { sessionStatusBucket } from "../../lib/terminalAttention";
 import { shouldRefreshSessionListForChatEvent } from "../../lib/chatSessionEvents";
 import { buildOptimisticChatSessionSummary, isRunOwnedSession } from "../../lib/sessions";
-import { defaultTrackedCliStartupCommand } from "../terminals/cliLaunch";
+import { resolveLaunchFields } from "../terminals/cliLaunch";
 
 const EMPTY_WORK_STATE: WorkProjectViewState = {
   openItemIds: [],
@@ -442,13 +442,21 @@ export function useLaneWorkSessions(laneId: string | null) {
       tracked?: boolean;
       title?: string;
       startupCommand?: string;
+      command?: string;
+      args?: string[];
     }) => {
       const titleMap = { claude: "Claude Code", codex: "Codex", shell: "Shell" } as const;
-      const commandMap = {
-        claude: defaultTrackedCliStartupCommand("claude"),
-        codex: defaultTrackedCliStartupCommand("codex"),
-        shell: "",
-      } as const;
+      // resolveLaunchFields treats the caller's launch overrides as atomic:
+      // if any of startupCommand/command/args is supplied we don't mix in
+      // defaults from the other fields (which used to override the caller's
+      // intent — e.g. a custom startupCommand silently displaced by default
+      // command/args).
+      const launchFields = resolveLaunchFields({
+        profile: args.profile,
+        ...(args.startupCommand !== undefined ? { startupCommand: args.startupCommand } : {}),
+        ...(args.command !== undefined ? { command: args.command } : {}),
+        ...(args.args !== undefined ? { args: args.args } : {}),
+      });
       const result = await window.ade.pty.create({
         laneId: args.laneId,
         cols: 100,
@@ -456,7 +464,7 @@ export function useLaneWorkSessions(laneId: string | null) {
         title: args.title ?? titleMap[args.profile],
         tracked: args.tracked ?? true,
         toolType: args.profile,
-        startupCommand: args.startupCommand ?? commandMap[args.profile] ?? undefined,
+        ...launchFields,
       });
       selectLane(args.laneId);
       // Invalidate all cache entries so other views (e.g. Work tab) pick up
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx b/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
index c29843e66..d47cf567f 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
@@ -147,6 +147,7 @@ import {
   disposeTerminalRuntimesForProjectChange,
   getTerminalRuntimeSnapshot,
 } from "./TerminalView";
+import { WORK_SURFACE_REVEALED_EVENT } from "./workSurfaceVisibility";
 
 function installWindowAde() {
   (window as any).ade = {
@@ -694,4 +695,40 @@ describe("TerminalView", () => {
 
     expect(terminal?.write).toHaveBeenCalledWith("buffered while hidden\n");
   });
+
+  it("redraws and force-fits a visible terminal when the Work surface is revealed", async () => {
+    render(<TerminalView ptyId="pty-revealed" sessionId="session-revealed" isActive />);
+    await flushAllTimers();
+
+    const terminal = mockState.terminalInstances.at(-1) as {
+      clearTextureAtlas: ReturnType<typeof vi.fn>;
+      refresh: ReturnType<typeof vi.fn>;
+      focus: ReturnType<typeof vi.fn>;
+      scrollToBottom: ReturnType<typeof vi.fn>;
+    } | undefined;
+    const resizeSpy = (window as any).ade.pty.resize as ReturnType<typeof vi.fn>;
+    expect(terminal).toBeTruthy();
+
+    terminal?.clearTextureAtlas.mockClear();
+    terminal?.refresh.mockClear();
+    terminal?.focus.mockClear();
+    terminal?.scrollToBottom.mockClear();
+    resizeSpy.mockClear();
+    mockState.nextFitDims = { cols: 132, rows: 42 };
+
+    window.dispatchEvent(new Event(WORK_SURFACE_REVEALED_EVENT));
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(2);
+    });
+
+    expect(terminal?.clearTextureAtlas).toHaveBeenCalled();
+    expect(terminal?.refresh).toHaveBeenCalled();
+    expect(terminal?.focus).toHaveBeenCalled();
+    expect(terminal?.scrollToBottom).toHaveBeenCalled();
+    expect(resizeSpy).toHaveBeenLastCalledWith({
+      ptyId: "pty-revealed",
+      cols: 132,
+      rows: 42,
+    });
+  });
 });
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalView.tsx b/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
index fa1a5d654..fef08c79e 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
@@ -10,6 +10,7 @@ import {
   type TerminalPreferences,
   type ThemeId,
 } from "../../state/appStore";
+import { WORK_SURFACE_REVEALED_EVENT } from "./workSurfaceVisibility";
 
 type XtermTheme = NonNullable<ConstructorParameters<typeof Terminal>[0]>["theme"];
 type TerminalRendererMode = "webgl" | "dom";
@@ -1116,9 +1117,27 @@ export function TerminalView({
     const onWindowResize = () => {
       requestAnimationFrame(() => schedule(true));
     };
+    const onWorkSurfaceRevealed = () => {
+      if (!mountConfigRef.current.isVisible) return;
+      clearTextureAtlas(runtime);
+      flushPendingFrameWrites(runtime);
+      requestAnimationFrame(() => {
+        schedule(true);
+        try {
+          runtime.term.refresh(0, Math.max(0, runtime.term.rows - 1));
+          if (mountConfigRef.current.isActive) {
+            runtime.term.focus();
+            runtime.term.scrollToBottom();
+          }
+        } catch {
+          // ignore redraw failures after disposal
+        }
+      });
+    };
     document.addEventListener("visibilitychange", onVisibilityChange);
     window.addEventListener("focus", onWindowFocus);
     window.addEventListener("resize", onWindowResize);
+    window.addEventListener(WORK_SURFACE_REVEALED_EVENT, onWorkSurfaceRevealed);
     window.visualViewport?.addEventListener("resize", onWindowResize);
 
     const setupDprListener = () => {
@@ -1177,6 +1196,7 @@ export function TerminalView({
       document.removeEventListener("visibilitychange", onVisibilityChange);
       window.removeEventListener("focus", onWindowFocus);
       window.removeEventListener("resize", onWindowResize);
+      window.removeEventListener(WORK_SURFACE_REVEALED_EVENT, onWorkSurfaceRevealed);
       window.visualViewport?.removeEventListener("resize", onWindowResize);
       el.removeEventListener("wheel", onWheel);
 
diff --git a/apps/desktop/src/renderer/components/terminals/WorkStartSurface.tsx b/apps/desktop/src/renderer/components/terminals/WorkStartSurface.tsx
index 8ec834242..3982b59ae 100644
--- a/apps/desktop/src/renderer/components/terminals/WorkStartSurface.tsx
+++ b/apps/desktop/src/renderer/components/terminals/WorkStartSurface.tsx
@@ -10,7 +10,7 @@ import { AgentChatPane } from "../chat/AgentChatPane";
 import { getPermissionOptions, safetyColors } from "../shared/permissionOptions";
 import { LaneCombobox } from "./LaneCombobox";
 import { COLORS } from "../lanes/laneDesignTokens";
-import { buildTrackedCliStartupCommand, type CliProvider } from "./cliLaunch";
+import { buildTrackedCliLaunchCommand, type CliProvider } from "./cliLaunch";
 import { ClaudeLogo, CodexLogo } from "./ToolLogos";
 import { SmartTooltip } from "../ui/SmartTooltip";
 
@@ -23,6 +23,8 @@ type WorkStartSurfaceProps = {
     profile: "claude" | "codex" | "shell";
     title?: string;
     startupCommand?: string;
+    command?: string;
+    args?: string[];
     tracked?: boolean;
   }) => Promise<unknown>;
 };
@@ -103,15 +105,18 @@ export function WorkStartSurface({
     try {
       // Generate a session ID upfront for Claude so resume always works
       const sessionId = cliProvider === "claude" ? crypto.randomUUID() : undefined;
+      const launch = buildTrackedCliLaunchCommand({
+        provider: cliProvider,
+        permissionMode: cliPermissionMode,
+        sessionId,
+      });
       await onLaunchPtySession({
         laneId: selectedLaneId,
         profile: cliProvider,
         title: cliProvider === "claude" ? "Claude CLI" : "Codex CLI",
-        startupCommand: buildTrackedCliStartupCommand({
-          provider: cliProvider,
-          permissionMode: cliPermissionMode,
-          sessionId,
-        }),
+        startupCommand: launch.startupCommand,
+        command: launch.command,
+        args: launch.args,
       });
     } finally {
       setLaunchBusy(false);
diff --git a/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx b/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
index 85ea31af3..160684834 100644
--- a/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
+++ b/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
@@ -279,6 +279,8 @@ export function WorkViewArea({
     profile: "claude" | "codex" | "shell";
     title?: string;
     startupCommand?: string;
+    command?: string;
+    args?: string[];
     tracked?: boolean;
   }) => Promise<unknown>;
   onShowDraftKind: (kind: WorkDraftKind) => void;
diff --git a/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts b/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts
index 136a3f6b8..5de546082 100644
--- a/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts
+++ b/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts
@@ -1,11 +1,13 @@
 import { describe, expect, it } from "vitest";
 import {
+  buildTrackedCliLaunchCommand,
   buildTrackedCliResumeCommand,
   buildTrackedCliStartupCommand,
   defaultTrackedCliStartupCommand,
   resolveTrackedCliResumeCommand,
   withCodexNoAltScreen,
 } from "./cliLaunch";
+import { ADE_CLI_AGENT_GUIDANCE, ADE_CLI_INLINE_GUIDANCE } from "../../../shared/adeCliGuidance";
 import type { AgentChatPermissionMode, TerminalSessionSummary } from "../../../shared/types";
 
 describe("withCodexNoAltScreen", () => {
@@ -50,65 +52,98 @@ describe("defaultTrackedCliStartupCommand", () => {
 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");
+      const command = buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "full-auto" });
+      expect(command).toContain("claude --append-system-prompt");
+      expect(command).toContain("only normal reason to skip ADE CLI");
+      expect(command).toContain("--dangerously-skip-permissions");
     });
 
     it("adds --permission-mode acceptEdits for edit", () => {
-      expect(
-        buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "edit" }),
-      ).toBe("claude --permission-mode acceptEdits");
+      const command = buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "edit" });
+      expect(command).toContain("--append-system-prompt");
+      expect(command).toContain("--permission-mode acceptEdits");
     });
 
     it("adds --permission-mode default for default", () => {
-      expect(
-        buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "default" }),
-      ).toBe("claude --permission-mode default");
+      const command = buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "default" });
+      expect(command).toContain("--append-system-prompt");
+      expect(command).toContain("--permission-mode default");
     });
 
     it("adds --permission-mode plan for plan (else branch)", () => {
-      expect(
-        buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "plan" }),
-      ).toBe("claude --permission-mode plan");
+      const command = buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "plan" });
+      expect(command).toContain("--append-system-prompt");
+      expect(command).toContain("--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");
+      const command = buildTrackedCliStartupCommand({ provider: "claude", permissionMode: "config-toml" });
+      expect(command).toContain("--append-system-prompt");
+      expect(command).toContain("--permission-mode plan");
+    });
+
+    it("uses Claude's system-prompt hook for ADE guidance", () => {
+      const launch = buildTrackedCliLaunchCommand({
+        provider: "claude",
+        permissionMode: "default",
+        sessionId: "00000000-0000-0000-0000-000000000001",
+      });
+      expect(launch.command).toBe("claude");
+      expect(launch.args).toEqual(expect.arrayContaining([
+        "--session-id",
+        "00000000-0000-0000-0000-000000000001",
+        "--append-system-prompt",
+        ADE_CLI_AGENT_GUIDANCE,
+        "--permission-mode",
+        "default",
+      ]));
+      expect(launch.startupCommand).toContain("--append-system-prompt");
+      expect(launch.startupCommand).toContain(ADE_CLI_AGENT_GUIDANCE.split("\n")[0]!);
+      expect(launch.startupCommand).toContain("clean up old, stale, or finished processes");
     });
   });
 
   describe("codex provider", () => {
     it("adds the dangerous bypass flag for full-auto", () => {
-      expect(
-        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "full-auto" }),
-      ).toBe("codex --no-alt-screen --dangerously-bypass-approvals-and-sandbox");
+      const command = buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "full-auto" });
+      expect(command).toContain("codex --no-alt-screen --dangerously-bypass-approvals-and-sandbox");
+      expect(command).toContain("only normal reason to skip ADE CLI");
     });
 
     it("adds Codex's auto preset for default", () => {
-      expect(
-        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "default" }),
-      ).toBe("codex --no-alt-screen --full-auto");
+      const command = buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "default" });
+      expect(command).toContain("codex --no-alt-screen --full-auto");
+      expect(command).toContain("only normal reason to skip ADE CLI");
     });
 
     it("passes no extra flags for config-toml", () => {
-      expect(
-        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "config-toml" }),
-      ).toBe("codex --no-alt-screen");
+      const command = buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "config-toml" });
+      expect(command).toContain("codex --no-alt-screen");
+      expect(command).not.toContain("--full-auto");
+      expect(command).toContain("only normal reason to skip ADE CLI");
     });
 
     it("adds untrusted approval and workspace-write sandbox for edit", () => {
-      expect(
-        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "edit" }),
-      ).toBe("codex --no-alt-screen --sandbox workspace-write --ask-for-approval untrusted");
+      const command = buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "edit" });
+      expect(command).toContain("codex --no-alt-screen --sandbox workspace-write --ask-for-approval untrusted");
+      expect(command).toContain("only normal reason to skip ADE CLI");
     });
 
     it("adds on-request approval and read-only sandbox for plan", () => {
-      expect(
-        buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "plan" }),
-      ).toBe("codex --no-alt-screen --sandbox read-only --ask-for-approval on-request");
+      const command = buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "plan" });
+      expect(command).toContain("codex --no-alt-screen --sandbox read-only --ask-for-approval on-request");
+      expect(command).toContain("only normal reason to skip ADE CLI");
+    });
+
+    it("seeds Codex with ADE guidance as the initial prompt", () => {
+      const launch = buildTrackedCliLaunchCommand({ provider: "codex", permissionMode: "default" });
+      expect(launch.command).toBe("codex");
+      expect(launch.args[0]).toBe("--no-alt-screen");
+      expect(launch.args.at(-1)).toContain("ADE session guidance");
+      expect(ADE_CLI_INLINE_GUIDANCE).toContain("default control plane");
+      expect(launch.args.at(-1)).toContain("default control plane");
+      expect(launch.args.at(-1)).toContain("clean up old, stale, or finished processes");
+      expect(launch.startupCommand).toContain("ADE session guidance");
     });
   });
 
diff --git a/apps/desktop/src/renderer/components/terminals/cliLaunch.ts b/apps/desktop/src/renderer/components/terminals/cliLaunch.ts
index b62c4db18..5ad6ad609 100644
--- a/apps/desktop/src/renderer/components/terminals/cliLaunch.ts
+++ b/apps/desktop/src/renderer/components/terminals/cliLaunch.ts
@@ -3,8 +3,15 @@ import type {
   TerminalResumeMetadata,
   TerminalSessionSummary,
 } from "../../../shared/types";
+import { ADE_CLI_AGENT_GUIDANCE, ADE_CLI_INLINE_GUIDANCE } from "../../../shared/adeCliGuidance";
+import { commandArrayToLine } from "../../lib/shell";
 
 export type CliProvider = "claude" | "codex";
+export type TrackedCliLaunchCommand = {
+  command: CliProvider;
+  args: string[];
+  startupCommand: string;
+};
 
 export function withCodexNoAltScreen(command: string): string {
   const trimmed = command.trim();
@@ -19,41 +26,54 @@ export function defaultTrackedCliStartupCommand(provider: CliProvider): string {
   return provider === "codex" ? withCodexNoAltScreen("codex") : "claude";
 }
 
+function workTabCodexPreamblePrompt(): string {
+  return [
+    "ADE session guidance. Treat this as operating guidance for the CLI session, keep it in mind for future user messages, and wait for the user's next instruction before taking action.",
+    "",
+    ADE_CLI_INLINE_GUIDANCE,
+  ].join("\n");
+}
+
 export function buildTrackedCliStartupCommand(args: {
   provider: CliProvider;
   permissionMode: AgentChatPermissionMode;
   /** Pre-assigned session ID for Claude CLI (enables reliable resume). */
   sessionId?: string;
 }): string {
+  return buildTrackedCliLaunchCommand(args).startupCommand;
+}
+
+export function buildTrackedCliLaunchCommand(args: {
+  provider: CliProvider;
+  permissionMode: AgentChatPermissionMode;
+  /** Pre-assigned session ID for Claude CLI (enables reliable resume). */
+  sessionId?: string;
+}): TrackedCliLaunchCommand {
   if (args.provider === "claude") {
-    const parts = ["claude"];
+    const commandArgs: string[] = [];
     // Inject --session-id so we know the Claude session ID upfront for resume
     if (args.sessionId) {
-      parts.push("--session-id", args.sessionId);
-    }
-    if (args.permissionMode === "full-auto") {
-      parts.push("--dangerously-skip-permissions");
-    } else if (args.permissionMode === "edit") {
-      parts.push("--permission-mode", "acceptEdits");
-    } else if (args.permissionMode === "default") {
-      parts.push("--permission-mode", "default");
-    } else {
-      parts.push("--permission-mode", "plan");
+      commandArgs.push("--session-id", args.sessionId);
     }
-    return parts.join(" ");
+    commandArgs.push("--append-system-prompt", ADE_CLI_AGENT_GUIDANCE);
+    commandArgs.push(...permissionModeToClaudeFlag(args.permissionMode));
+    return {
+      command: "claude",
+      args: commandArgs,
+      startupCommand: commandArrayToLine(["claude", ...commandArgs]),
+    };
   }
 
-  const parts = [withCodexNoAltScreen("codex")];
-  if (args.permissionMode === "full-auto") {
-    parts.push("--dangerously-bypass-approvals-and-sandbox");
-  } else if (args.permissionMode === "default") {
-    parts.push("--full-auto");
-  } else if (args.permissionMode !== "config-toml") {
-    const approvalPolicy = args.permissionMode === "edit" ? "untrusted" : "on-request";
-    const sandboxMode = args.permissionMode === "edit" ? "workspace-write" : "read-only";
-    parts.push("--sandbox", sandboxMode, "--ask-for-approval", approvalPolicy);
-  }
-  return parts.join(" ");
+  const commandArgs: string[] = [
+    "--no-alt-screen",
+    ...permissionModeToCodexFlags(args.permissionMode),
+    workTabCodexPreamblePrompt(),
+  ];
+  return {
+    command: "codex",
+    args: commandArgs,
+    startupCommand: commandArrayToLine(["codex", ...commandArgs]),
+  };
 }
 
 function permissionModeToClaudeFlag(permissionMode: AgentChatPermissionMode | null | undefined): string[] {
@@ -93,3 +113,44 @@ export function resolveTrackedCliResumeCommand(session: Pick<TerminalSessionSumm
   const command = session.resumeCommand?.trim() ?? "";
   return command.length > 0 ? command : null;
 }
+
+/**
+ * Resolve `pty.create` launch fields, treating caller-supplied overrides as
+ * atomic so we never mix the caller's `startupCommand` with default
+ * `command`/`args` (or vice versa). If the caller passed *any* override field,
+ * we use exactly what they supplied — defaults are skipped entirely. Only
+ * when the caller passed nothing do we fall back to the profile's default
+ * launch command.
+ */
+export function resolveLaunchFields<P extends "claude" | "codex" | "shell">(args: {
+  profile: P;
+  permissionMode?: AgentChatPermissionMode;
+  startupCommand?: string;
+  command?: string;
+  args?: string[];
+}): { startupCommand?: string; command?: string; args?: string[] } {
+  const callerHasOverride =
+    args.startupCommand !== undefined
+    || args.command !== undefined
+    || args.args !== undefined;
+
+  if (callerHasOverride) {
+    return {
+      ...(args.startupCommand !== undefined ? { startupCommand: args.startupCommand } : {}),
+      ...(args.command !== undefined ? { command: args.command } : {}),
+      ...(args.args !== undefined ? { args: args.args } : {}),
+    };
+  }
+
+  if (args.profile === "shell") return {};
+
+  const defaultLaunch = buildTrackedCliLaunchCommand({
+    provider: args.profile,
+    permissionMode: args.permissionMode ?? "default",
+  });
+  return {
+    startupCommand: defaultLaunch.startupCommand,
+    command: defaultLaunch.command,
+    args: defaultLaunch.args,
+  };
+}
diff --git a/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts b/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
index 5b50a7836..002ac96ce 100644
--- a/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
+++ b/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
@@ -14,7 +14,7 @@ import { sessionStatusBucket } from "../../lib/terminalAttention";
 import { buildOptimisticChatSessionSummary, isChatToolType, isRunOwnedSession } from "../../lib/sessions";
 import { shouldRefreshSessionListForChatEvent } from "../../lib/chatSessionEvents";
 import {
-  defaultTrackedCliStartupCommand,
+  resolveLaunchFields,
   resolveTrackedCliResumeCommand,
   withCodexNoAltScreen,
 } from "./cliLaunch";
@@ -1016,6 +1016,8 @@ export function useWorkSessions() {
       tracked?: boolean;
       title?: string;
       startupCommand?: string;
+      command?: string;
+      args?: string[];
     }) => {
       const toolTypeMap = {
         claude: "claude" as const,
@@ -1023,11 +1025,16 @@ export function useWorkSessions() {
         shell: "shell" as const,
       };
       const titleMap = { claude: "Claude Code", codex: "Codex", shell: "Shell" };
-      const commandMap = {
-        claude: defaultTrackedCliStartupCommand("claude"),
-        codex: defaultTrackedCliStartupCommand("codex"),
-        shell: "",
-      };
+      // resolveLaunchFields preserves caller intent: any caller-supplied
+      // startupCommand/command/args is used as-is, never mixed with defaults
+      // from the other fields. Only when the caller passes none of them do
+      // we substitute the profile's default launch.
+      const launchFields = resolveLaunchFields({
+        profile: args.profile,
+        ...(args.startupCommand !== undefined ? { startupCommand: args.startupCommand } : {}),
+        ...(args.command !== undefined ? { command: args.command } : {}),
+        ...(args.args !== undefined ? { args: args.args } : {}),
+      });
       const result = await window.ade.pty.create({
         laneId: args.laneId,
         cols: 100,
@@ -1035,7 +1042,7 @@ export function useWorkSessions() {
         title: args.title ?? titleMap[args.profile],
         tracked: args.tracked ?? true,
         toolType: toolTypeMap[args.profile],
-        startupCommand: args.startupCommand ?? commandMap[args.profile] ?? undefined,
+        ...launchFields,
       });
       selectLane(args.laneId);
       // Invalidate all cache entries so other views (e.g. Lanes tab) pick up
diff --git a/apps/desktop/src/renderer/components/terminals/workSurfaceVisibility.ts b/apps/desktop/src/renderer/components/terminals/workSurfaceVisibility.ts
new file mode 100644
index 000000000..03591a338
--- /dev/null
+++ b/apps/desktop/src/renderer/components/terminals/workSurfaceVisibility.ts
@@ -0,0 +1,5 @@
+export const WORK_SURFACE_REVEALED_EVENT = "ade:work-surface-revealed";
+
+export function dispatchWorkSurfaceRevealed(): void {
+  window.dispatchEvent(new Event(WORK_SURFACE_REVEALED_EVENT));
+}
diff --git a/apps/desktop/src/renderer/lib/shell.test.ts b/apps/desktop/src/renderer/lib/shell.test.ts
index 3ec579d38..01b67e397 100644
--- a/apps/desktop/src/renderer/lib/shell.test.ts
+++ b/apps/desktop/src/renderer/lib/shell.test.ts
@@ -62,4 +62,18 @@ describe("shell helpers", () => {
       "d",
     ]);
   });
+
+  it("uses ANSI-C $'...' quoting for posix args with embedded newlines", () => {
+    // Plain double-quotes would preserve the \n literally, but when the
+    // resulting startupCommand is written into an interactive PTY shell the
+    // terminal's line discipline fires on every \n, dropping PS2 continuation
+    // prompts into the command stream. $'...' keeps the line single-line on
+    // the wire and lets the shell decode the escapes.
+    expect(quoteShellArg("hello\nworld", { platform: "linux" })).toBe("$'hello\\nworld'");
+    expect(quoteShellArg("ADE guidance.\n\nUse `ade`.", { platform: "linux" })).toBe(
+      "$'ADE guidance.\\n\\nUse `ade`.'",
+    );
+    // Single quotes inside the arg must be backslash-escaped for ANSI-C form.
+    expect(quoteShellArg("it's\nfine", { platform: "linux" })).toBe("$'it\\'s\\nfine'");
+  });
 });
diff --git a/apps/desktop/src/renderer/lib/shell.ts b/apps/desktop/src/renderer/lib/shell.ts
index 507441319..f06243195 100644
--- a/apps/desktop/src/renderer/lib/shell.ts
+++ b/apps/desktop/src/renderer/lib/shell.ts
@@ -43,6 +43,24 @@ export function quoteShellArg(arg: string, options: { platform?: ShellPlatform }
     return quoteWindowsArg(arg);
   }
   if (/^[a-zA-Z0-9_.:@%+=,-]+$/.test(arg)) return arg;
+  // If the argument contains line terminators or other ANSI control bytes,
+  // use ANSI-C quoting (`$'...'`). Plain double-quoting preserves them
+  // literally to the receiving program, but when the resulting line is
+  // injected into an interactive PTY shell via `pty.write` the terminal's
+  // line discipline fires on every embedded \n, producing PS2 continuation
+  // noise mid-command. ANSI-C quoting keeps the line single-line on the wire
+  // and lets the shell expand the escapes back into the original bytes.
+  if (/[\n\r\t\v\f]/.test(arg)) {
+    const escaped = arg
+      .replace(/\\/g, "\\\\")
+      .replace(/'/g, "\\'")
+      .replace(/\n/g, "\\n")
+      .replace(/\r/g, "\\r")
+      .replace(/\t/g, "\\t")
+      .replace(/\v/g, "\\v")
+      .replace(/\f/g, "\\f");
+    return `$'${escaped}'`;
+  }
   return `"${arg.replace(/(["\\$`])/g, "\\$1")}"`;
 }
 
diff --git a/apps/desktop/src/shared/ipc.ts b/apps/desktop/src/shared/ipc.ts
index 53000a550..5be7705a5 100644
--- a/apps/desktop/src/shared/ipc.ts
+++ b/apps/desktop/src/shared/ipc.ts
@@ -7,12 +7,15 @@ export const IPC = {
   appRevealPath: "ade.app.revealPath",
   appOpenPath: "ade.app.openPath",
   appWriteClipboardText: "ade.app.writeClipboardText",
+  appGetImageDataUrl: "ade.app.getImageDataUrl",
+  appWriteClipboardImage: "ade.app.writeClipboardImage",
   appOpenPathInEditor: "ade.app.openPathInEditor",
   appLogDebugEvent: "ade.app.logDebugEvent",
   projectOpenRepo: "ade.project.openRepo",
   projectChooseDirectory: "ade.project.chooseDirectory",
   projectBrowseDirectories: "ade.project.browseDirectories",
   projectGetDetail: "ade.project.getDetail",
+  projectResolveIcon: "ade.project.resolveIcon",
   projectOpenAdeFolder: "ade.project.openAdeFolder",
   projectClearLocalData: "ade.project.clearLocalData",
   projectListRecent: "ade.project.listRecent",
diff --git a/apps/desktop/src/shared/types/core.ts b/apps/desktop/src/shared/types/core.ts
index 543674d4e..26d1d29c7 100644
--- a/apps/desktop/src/shared/types/core.ts
+++ b/apps/desktop/src/shared/types/core.ts
@@ -111,6 +111,12 @@ export type RecentProjectSummary = {
   laneCount?: number;
 };
 
+export type ProjectIcon = {
+  dataUrl: string | null;
+  sourcePath: string | null;
+  mimeType: string | null;
+};
+
 export type ProviderMode = "guest" | "subscription";
 
 /** Universal model identifier, e.g. "anthropic/claude-sonnet-4-6" or "openai/gpt-5.3-codex" */
diff --git a/apps/desktop/src/shared/types/sync.ts b/apps/desktop/src/shared/types/sync.ts
index 89c61296c..d17d42b47 100644
--- a/apps/desktop/src/shared/types/sync.ts
+++ b/apps/desktop/src/shared/types/sync.ts
@@ -224,6 +224,7 @@ export type SyncMobileProjectSummary = {
   rootPath: string | null;
   defaultBaseRef: string | null;
   lastOpenedAt: string | null;
+  iconDataUrl?: string | null;
   laneCount: number;
   isAvailable: boolean;
   isCached: boolean;
diff --git a/apps/ios/ADE.xcodeproj/project.pbxproj b/apps/ios/ADE.xcodeproj/project.pbxproj
index c1a71a6d7..6cc868bc7 100644
--- a/apps/ios/ADE.xcodeproj/project.pbxproj
+++ b/apps/ios/ADE.xcodeproj/project.pbxproj
@@ -134,6 +134,7 @@
 		B10000000000000000000101 /* LaneDetailRebaseBanner.swift in Sources */ = {isa = PBXBuildFile; fileRef = A10000000000000000000101 /* LaneDetailRebaseBanner.swift */; };
 		B10000000000000000000102 /* LaneCommitSheet.swift in Sources */ = {isa = PBXBuildFile; fileRef = A10000000000000000000102 /* LaneCommitSheet.swift */; };
 		B10000000000000000000103 /* LaneActionsCard.swift in Sources */ = {isa = PBXBuildFile; fileRef = A10000000000000000000103 /* LaneActionsCard.swift */; };
+		B10000000000000000000150 /* LaneAdvancedScreen.swift in Sources */ = {isa = PBXBuildFile; fileRef = A10000000000000000000150 /* LaneAdvancedScreen.swift */; };
 		B10000000000000000000104 /* LaneSyncDetailScreen.swift in Sources */ = {isa = PBXBuildFile; fileRef = A10000000000000000000104 /* LaneSyncDetailScreen.swift */; };
 		B10000000000000000000105 /* LaneStashesScreen.swift in Sources */ = {isa = PBXBuildFile; fileRef = A10000000000000000000105 /* LaneStashesScreen.swift */; };
 		B10000000000000000000106 /* LaneCommitHistoryScreen.swift in Sources */ = {isa = PBXBuildFile; fileRef = A10000000000000000000106 /* LaneCommitHistoryScreen.swift */; };
@@ -346,6 +347,7 @@
 		A10000000000000000000101 /* LaneDetailRebaseBanner.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = LaneDetailRebaseBanner.swift; path = ADE/Views/Lanes/LaneDetailRebaseBanner.swift; sourceTree = "<group>"; };
 		A10000000000000000000102 /* LaneCommitSheet.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = LaneCommitSheet.swift; path = ADE/Views/Lanes/LaneCommitSheet.swift; sourceTree = "<group>"; };
 		A10000000000000000000103 /* LaneActionsCard.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = LaneActionsCard.swift; path = ADE/Views/Lanes/LaneActionsCard.swift; sourceTree = "<group>"; };
+		A10000000000000000000150 /* LaneAdvancedScreen.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = LaneAdvancedScreen.swift; path = ADE/Views/Lanes/LaneAdvancedScreen.swift; sourceTree = "<group>"; };
 		A10000000000000000000104 /* LaneSyncDetailScreen.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = LaneSyncDetailScreen.swift; path = ADE/Views/Lanes/LaneSyncDetailScreen.swift; sourceTree = "<group>"; };
 		A10000000000000000000105 /* LaneStashesScreen.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = LaneStashesScreen.swift; path = ADE/Views/Lanes/LaneStashesScreen.swift; sourceTree = "<group>"; };
 		A10000000000000000000106 /* LaneCommitHistoryScreen.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = LaneCommitHistoryScreen.swift; path = ADE/Views/Lanes/LaneCommitHistoryScreen.swift; sourceTree = "<group>"; };
@@ -472,6 +474,7 @@
 				A10000000000000000000101 /* LaneDetailRebaseBanner.swift */,
 				A10000000000000000000102 /* LaneCommitSheet.swift */,
 				A10000000000000000000103 /* LaneActionsCard.swift */,
+				A10000000000000000000150 /* LaneAdvancedScreen.swift */,
 				A10000000000000000000104 /* LaneSyncDetailScreen.swift */,
 				A10000000000000000000105 /* LaneStashesScreen.swift */,
 				A10000000000000000000106 /* LaneCommitHistoryScreen.swift */,
@@ -1030,6 +1033,7 @@
 				B10000000000000000000101 /* LaneDetailRebaseBanner.swift in Sources */,
 				B10000000000000000000102 /* LaneCommitSheet.swift in Sources */,
 				B10000000000000000000103 /* LaneActionsCard.swift in Sources */,
+				B10000000000000000000150 /* LaneAdvancedScreen.swift in Sources */,
 				B10000000000000000000104 /* LaneSyncDetailScreen.swift in Sources */,
 				B10000000000000000000105 /* LaneStashesScreen.swift in Sources */,
 				B10000000000000000000106 /* LaneCommitHistoryScreen.swift in Sources */,
diff --git a/apps/ios/ADE/App/ContentView.swift b/apps/ios/ADE/App/ContentView.swift
index 5e597bd3d..84a73b2ab 100644
--- a/apps/ios/ADE/App/ContentView.swift
+++ b/apps/ios/ADE/App/ContentView.swift
@@ -126,21 +126,29 @@ private struct ProjectHomeView: View {
     syncService.activeProject ?? syncService.projects.first
   }
 
-  private var connectionLabel: String {
+  private var attachedComputerLabel: String {
+    let trimmedHost = syncService.hostName?.trimmingCharacters(in: .whitespacesAndNewlines)
+    let host = (trimmedHost?.isEmpty == false) ? trimmedHost! : nil
     switch syncService.connectionState {
-    case .connected: return "Connected"
-    case .syncing: return "Syncing"
-    case .connecting: return "Connecting"
-    case .error: return "Connection error"
-    case .disconnected: return "Connect to computer"
+    case .connected, .syncing:
+      if let host { return "Attached to \(host)" }
+      return "Attached to computer"
+    case .connecting:
+      if let host { return "Connecting to \(host)…" }
+      return "Connecting…"
+    case .error:
+      if let host { return "Cannot reach \(host)" }
+      return "Connection error"
+    case .disconnected:
+      return "No computer attached"
     }
   }
 
-  private var connectionTint: Color {
+  private var attachedComputerTint: Color {
     switch syncService.connectionState {
     case .connected: return ADEColor.success
     case .syncing, .connecting: return ADEColor.warning
-    case .error, .disconnected: return ADEColor.danger
+    case .error, .disconnected: return ADEColor.textMuted
     }
   }
 
@@ -151,6 +159,7 @@ private struct ProjectHomeView: View {
         ScrollView {
           VStack(spacing: 30) {
             welcomeHero
+            attachedComputerBanner
             openProjectButton
             projectSection
           }
@@ -162,13 +171,9 @@ private struct ProjectHomeView: View {
         }
         .scrollIndicators(.hidden)
       }
-      .navigationTitle("ADE")
+      .navigationTitle("")
       .navigationBarTitleDisplayMode(.inline)
-      .toolbar {
-        ToolbarItem(placement: .topBarTrailing) {
-          connectionButton
-        }
-      }
+      .toolbar(.hidden, for: .navigationBar)
     }
   }
 
@@ -193,20 +198,47 @@ private struct ProjectHomeView: View {
   }
 
   private var welcomeHero: some View {
-    ZStack {
-      Text("ADE")
-        .font(.system(size: 78, weight: .heavy, design: .rounded))
-        .foregroundStyle(ADEColor.purpleAccent.opacity(0.58))
-        .offset(x: 9, y: 10)
-      Text("ADE")
-        .font(.system(size: 78, weight: .heavy, design: .rounded))
-        .foregroundStyle(ADEColor.textPrimary)
-        .shadow(color: ADEColor.purpleAccent.opacity(0.80), radius: 28, x: 0, y: 0)
-        .shadow(color: ADEColor.purpleAccent.opacity(0.55), radius: 2, x: 7, y: 8)
+    Image("BrandMark")
+      .resizable()
+      .renderingMode(.original)
+      .interpolation(.high)
+      .aspectRatio(contentMode: .fit)
+      .frame(maxWidth: 280)
+      .frame(height: 142)
+      .frame(maxWidth: .infinity)
+      .shadow(color: ADEColor.purpleAccent.opacity(0.45), radius: 24, x: 0, y: 0)
+      .accessibilityLabel("ADE")
+  }
+
+  private var attachedComputerBanner: some View {
+    Button {
+      syncService.settingsPresented = true
+    } label: {
+      HStack(spacing: 10) {
+        Circle()
+          .fill(attachedComputerTint)
+          .frame(width: 8, height: 8)
+        Image(systemName: "desktopcomputer")
+          .font(.system(size: 13, weight: .semibold))
+          .foregroundStyle(ADEColor.textSecondary)
+        Text(attachedComputerLabel)
+          .font(.system(.footnote, design: .rounded).weight(.semibold))
+          .foregroundStyle(ADEColor.textPrimary)
+          .lineLimit(1)
+        Image(systemName: "chevron.right")
+          .font(.system(size: 11, weight: .semibold))
+          .foregroundStyle(ADEColor.textMuted)
+      }
+      .padding(.horizontal, 14)
+      .padding(.vertical, 10)
+      .background(ADEColor.cardBackground.opacity(0.62), in: Capsule())
+      .overlay(
+        Capsule().stroke(ADEColor.border.opacity(0.80), lineWidth: 1)
+      )
     }
-    .frame(height: 142)
-    .frame(maxWidth: .infinity)
-    .accessibilityLabel("ADE")
+    .buttonStyle(.plain)
+    .accessibilityLabel(attachedComputerLabel)
+    .accessibilityHint("Opens computer connection settings.")
   }
 
   private var openProjectButton: some View {
@@ -232,38 +264,9 @@ private struct ProjectHomeView: View {
     .accessibilityHint(primaryProject == nil ? "Opens computer connection settings." : "Opens the most recent project.")
   }
 
-  private var connectionButton: some View {
-    Button {
-      syncService.settingsPresented = true
-    } label: {
-      ZStack(alignment: .topTrailing) {
-        Image(systemName: "desktopcomputer")
-          .font(.system(size: 15, weight: .semibold))
-          .foregroundStyle(connectionTint)
-          .frame(width: 36, height: 36)
-          .background(ADEColor.raisedBackground, in: RoundedRectangle(cornerRadius: 8, style: .continuous))
-          .overlay(
-            RoundedRectangle(cornerRadius: 8, style: .continuous)
-              .stroke(ADEColor.border, lineWidth: 1)
-          )
-        Circle()
-          .fill(connectionTint)
-          .frame(width: 8, height: 8)
-          .overlay(
-            Circle()
-              .stroke(ADEColor.pageBackground, lineWidth: 2)
-          )
-          .offset(x: 1, y: -1)
-      }
-      .contentShape(RoundedRectangle(cornerRadius: 8, style: .continuous))
-    }
-    .accessibilityLabel("Computer connection: \(connectionLabel)")
-    .accessibilityHint("Opens computer connection settings.")
-  }
-
   private var projectSection: some View {
     VStack(spacing: 14) {
-      Text("RECENT PROJECTS")
+      Text("DESKTOP TABS")
         .font(.system(.caption, design: .rounded).weight(.semibold))
         .foregroundStyle(ADEColor.textMuted)
         .tracking(0.8)
@@ -292,12 +295,12 @@ private struct ProjectHomeView: View {
       syncService.settingsPresented = true
     } label: {
       HStack(spacing: 12) {
-        ProjectHomeIcon(isActive: false)
+        ProjectHomeIcon(iconDataUrl: nil, isActive: false)
         VStack(alignment: .leading, spacing: 4) {
-          Text("Connect ADE desktop")
+          Text(emptyProjectsTitle)
             .font(.system(.subheadline, design: .rounded).weight(.semibold))
             .foregroundStyle(ADEColor.textPrimary)
-          Text(syncService.hostName ?? "No recent projects yet")
+          Text(emptyProjectsSubtitle)
             .font(.system(.caption, design: .monospaced))
             .foregroundStyle(ADEColor.textMuted)
             .lineLimit(1)
@@ -317,9 +320,27 @@ private struct ProjectHomeView: View {
     }
     .buttonStyle(.plain)
   }
+
+  private var emptyProjectsTitle: String {
+    switch syncService.connectionState {
+    case .connected, .syncing: return "No projects on desktop"
+    case .connecting: return "Connecting to desktop"
+    case .error, .disconnected: return "Connect ADE desktop"
+    }
+  }
+
+  private var emptyProjectsSubtitle: String {
+    switch syncService.connectionState {
+    case .connected, .syncing:
+      return "Open a project on \(syncService.hostName ?? "your computer")"
+    case .connecting, .error, .disconnected:
+      return syncService.hostName ?? "Pair a computer to see your tabs"
+    }
+  }
 }
 
 private struct ProjectHomeIcon: View {
+  let iconDataUrl: String?
   let isActive: Bool
 
   var body: some View {
@@ -327,13 +348,39 @@ private struct ProjectHomeIcon: View {
       RoundedRectangle(cornerRadius: 7, style: .continuous)
         .fill(isActive ? ADEColor.accent.opacity(0.16) : ADEColor.recessedBackground)
         .frame(width: 38, height: 38)
-      Image(systemName: "folder")
-        .font(.system(size: 16, weight: .semibold))
-        .foregroundStyle(isActive ? ADEColor.accent : ADEColor.textSecondary)
+      if let image = projectHomeIconImage(from: iconDataUrl) {
+        Image(uiImage: image)
+          .resizable()
+          .interpolation(.high)
+          .aspectRatio(contentMode: .fit)
+          .frame(width: 24, height: 24)
+          .clipShape(RoundedRectangle(cornerRadius: 4, style: .continuous))
+      } else {
+        Image(systemName: "folder")
+          .font(.system(size: 16, weight: .semibold))
+          .foregroundStyle(isActive ? ADEColor.accent : ADEColor.textSecondary)
+      }
     }
   }
 }
 
+private let projectHomeIconImageCache = NSCache<NSString, UIImage>()
+
+private func projectHomeIconImage(from dataUrl: String?) -> UIImage? {
+  guard let dataUrl, !dataUrl.isEmpty else { return nil }
+  let cacheKey = dataUrl as NSString
+  if let cached = projectHomeIconImageCache.object(forKey: cacheKey) {
+    return cached
+  }
+  guard let commaIndex = dataUrl.firstIndex(of: ",") else { return nil }
+  let base64 = String(dataUrl[dataUrl.index(after: commaIndex)...])
+  guard let data = Data(base64Encoded: base64),
+        let image = UIImage(data: data)
+  else { return nil }
+  projectHomeIconImageCache.setObject(image, forKey: cacheKey)
+  return image
+}
+
 private struct ProjectHomeRow: View {
   let project: MobileProjectSummary
   let isActive: Bool
@@ -344,7 +391,7 @@ private struct ProjectHomeRow: View {
   var body: some View {
     Button(action: action) {
       HStack(alignment: .center, spacing: 12) {
-        ProjectHomeIcon(isActive: isActive)
+        ProjectHomeIcon(iconDataUrl: project.iconDataUrl, isActive: isActive)
 
         VStack(alignment: .leading, spacing: 4) {
           Text(project.displayName)
@@ -367,23 +414,14 @@ private struct ProjectHomeRow: View {
             .controlSize(.small)
         } else {
           VStack(alignment: .trailing, spacing: 6) {
-            if project.isOpen == false {
-              Text("Closed")
-                .font(.system(.caption2, design: .rounded).weight(.semibold))
-                .foregroundStyle(ADEColor.textMuted)
-                .padding(.horizontal, 8)
-                .padding(.vertical, 4)
-                .background(ADEColor.textMuted.opacity(0.14), in: Capsule())
-            } else {
-              Text("\(project.laneCount) lane\(project.laneCount == 1 ? "" : "s")")
-                .font(.system(.caption2, design: .rounded).weight(.semibold))
-                .foregroundStyle(ADEColor.accent)
-                .padding(.horizontal, 8)
-                .padding(.vertical, 4)
-                .background(ADEColor.accent.opacity(0.16), in: Capsule())
-            }
+            Text("\(project.laneCount) lane\(project.laneCount == 1 ? "" : "s")")
+              .font(.system(.caption2, design: .rounded).weight(.semibold))
+              .foregroundStyle(ADEColor.accent)
+              .padding(.horizontal, 8)
+              .padding(.vertical, 4)
+              .background(ADEColor.accent.opacity(0.16), in: Capsule())
             if let lastOpened = projectHomeRelativeTimestamp(project.lastOpenedAt) {
-              Text(lastOpened)
+              Text("Last opened \(lastOpened)")
                 .font(.system(.caption2, design: .monospaced))
                 .foregroundStyle(ADEColor.textMuted)
             }
diff --git a/apps/ios/ADE/Assets.xcassets/BrandMark.imageset/Contents.json b/apps/ios/ADE/Assets.xcassets/BrandMark.imageset/Contents.json
index 4abcbbe0e..5f670ca87 100644
--- a/apps/ios/ADE/Assets.xcassets/BrandMark.imageset/Contents.json
+++ b/apps/ios/ADE/Assets.xcassets/BrandMark.imageset/Contents.json
@@ -1,25 +1,21 @@
 {
   "images" : [
     {
-      "filename" : "logo-light.svg",
-      "idiom" : "universal"
+      "filename" : "logo.png",
+      "idiom" : "universal",
+      "scale" : "1x"
     },
     {
-      "appearances" : [
-        {
-          "appearance" : "luminosity",
-          "value" : "dark"
-        }
-      ],
-      "filename" : "logo-dark.svg",
-      "idiom" : "universal"
+      "idiom" : "universal",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "universal",
+      "scale" : "3x"
     }
   ],
   "info" : {
     "author" : "xcode",
     "version" : 1
-  },
-  "properties" : {
-    "preserves-vector-representation" : true
   }
 }
diff --git a/apps/ios/ADE/Assets.xcassets/BrandMark.imageset/logo.png b/apps/ios/ADE/Assets.xcassets/BrandMark.imageset/logo.png
new file mode 100644
index 000000000..5cb03d0da
Binary files /dev/null and b/apps/ios/ADE/Assets.xcassets/BrandMark.imageset/logo.png differ
diff --git a/apps/ios/ADE/Models/RemoteModels.swift b/apps/ios/ADE/Models/RemoteModels.swift
index 9279d1f8a..1b4b5a65e 100644
--- a/apps/ios/ADE/Models/RemoteModels.swift
+++ b/apps/ios/ADE/Models/RemoteModels.swift
@@ -73,6 +73,7 @@ struct MobileProjectSummary: Codable, Equatable, Identifiable {
   var rootPath: String?
   var defaultBaseRef: String?
   var lastOpenedAt: String?
+  var iconDataUrl: String?
   var laneCount: Int
   var isAvailable: Bool
   var isCached: Bool
@@ -84,6 +85,7 @@ struct MobileProjectSummary: Codable, Equatable, Identifiable {
     rootPath: String? = nil,
     defaultBaseRef: String? = nil,
     lastOpenedAt: String? = nil,
+    iconDataUrl: String? = nil,
     laneCount: Int,
     isAvailable: Bool,
     isCached: Bool,
@@ -94,6 +96,7 @@ struct MobileProjectSummary: Codable, Equatable, Identifiable {
     self.rootPath = rootPath
     self.defaultBaseRef = defaultBaseRef
     self.lastOpenedAt = lastOpenedAt
+    self.iconDataUrl = iconDataUrl
     self.laneCount = laneCount
     self.isAvailable = isAvailable
     self.isCached = isCached
diff --git a/apps/ios/ADE/Services/LiveActivityCoordinator.swift b/apps/ios/ADE/Services/LiveActivityCoordinator.swift
index 197962d9f..bf38e9c05 100644
--- a/apps/ios/ADE/Services/LiveActivityCoordinator.swift
+++ b/apps/ios/ADE/Services/LiveActivityCoordinator.swift
@@ -77,7 +77,11 @@ public final class LiveActivityCoordinator: ObservableObject {
 
     private weak var host: LiveActivityHost?
     private let configuration: Configuration
-    private let workspaceName: String
+    /// Latest header label for the activity (e.g. "Primary"). Mutable so a
+    /// new focused lane forces an end+restart on the next reconcile —
+    /// `ActivityAttributes` are immutable across an activity's lifetime, so
+    /// renaming is the only way to keep the system header in sync.
+    private var workspaceName: String
 
     /// One listener task for push-token updates on the current activity.
     private var pushTokenTask: Task<Void, Never>?
@@ -102,7 +106,7 @@ public final class LiveActivityCoordinator: ObservableObject {
 
     public init(
         host: LiveActivityHost,
-        workspaceName: String = "Workspace",
+        workspaceName: String = "",
         configuration: Configuration = Configuration()
     ) {
         self.host = host
@@ -132,18 +136,19 @@ public final class LiveActivityCoordinator: ObservableObject {
 
     /// Called by the host whenever the set of active sessions changes.
     /// - Parameters:
-    ///   - sessions: live sessions actively producing output (filtered to
-    ///     `runtimeState == "running"` by `SyncService`).
-    ///   - prs: optional PR snapshot for the pending-PR counts. Pass nil
-    ///     to leave the PR counts unchanged from the previous tick.
-    ///   - awaitingInputCount: chats waiting on user input — rendered as a
-    ///     count chip rather than a roster row.
-    ///   - idleCount: chats connected but not currently producing output.
+    ///   - sessions: chats currently streaming output. SyncService filters to
+    ///     `runtimeState == "running"` AND a recent `lastActivityAt` so this
+    ///     list is the LA roster verbatim — idle / awaiting / stale chats are
+    ///     handled by the in-app Attention Drawer instead.
+    ///   - prs: PR snapshot for the attention selector.
+    ///   - focusedLaneName: lane name of the most-recently-active running
+    ///     chat. Used as the LA system-header suffix ("ADE · Primary"); a
+    ///     change forces an end+restart since `ActivityAttributes` are
+    ///     immutable across an activity's lifetime.
     public func reconcile(
         with sessions: [AgentSnapshot],
         prs: [PrSnapshot] = [],
-        awaitingInputCount: Int = 0,
-        idleCount: Int = 0
+        focusedLaneName: String? = nil
     ) {
         let previousTask = reconcileTask
         reconcileTask = Task { @MainActor [weak self] in
@@ -152,8 +157,7 @@ public final class LiveActivityCoordinator: ObservableObject {
             await self.reconcileNow(
                 with: sessions,
                 prs: prs,
-                awaitingInputCount: awaitingInputCount,
-                idleCount: idleCount
+                focusedLaneName: focusedLaneName
             )
         }
     }
@@ -161,33 +165,38 @@ public final class LiveActivityCoordinator: ObservableObject {
     private func reconcileNow(
         with sessions: [AgentSnapshot],
         prs: [PrSnapshot],
-        awaitingInputCount: Int,
-        idleCount: Int
+        focusedLaneName: String?
     ) async {
         guard ActivityAuthorizationInfo().areActivitiesEnabled else {
             await endAllActivities(dismissalPolicy: .immediate)
             return
         }
 
-        let desiredState = makeContentState(
-            sessions: sessions,
-            prs: prs,
-            awaitingInputCount: awaitingInputCount,
-            idleCount: idleCount
-        )
+        // Per-tick header label. Falls back to "" so iOS just shows "ADE"
+        // when nothing better is available (no focused session).
+        let desiredHeader = (focusedLaneName?.trimmingCharacters(in: .whitespaces).isEmpty == false)
+            ? focusedLaneName!
+            : ""
+
+        let desiredState = makeContentState(sessions: sessions, prs: prs)
 
-        // If there's literally nothing to show, make sure no activity is
-        // visible and return. Counts alone (awaiting / idle) don't justify
-        // surfacing a Live Activity — only an actively-running roster, an
-        // attention signal, or pending PRs do.
+        // The LA only ever surfaces actively-streaming chats now. No roster +
+        // no attention + no PR signals → tear it down.
         if sessions.isEmpty && desiredState.attention == nil && desiredState.pendingPrCount == 0 {
             await endAllActivities(dismissalPolicy: .after(Date().addingTimeInterval(configuration.terminalDismissalDelay)))
             return
         }
 
+        // ActivityAttributes are immutable; the only way to change the system
+        // header is to end and re-request. Do it here so a focus-lane swap
+        // ("Primary" → "feature/x") is reflected immediately.
+        if desiredHeader != workspaceName {
+            workspaceName = desiredHeader
+            await endAllActivities(dismissalPolicy: .immediate)
+        }
+
         let existing = Activity<ADESessionAttributes>.activities
         if let canonical = canonicalActivity(from: existing) {
-            // End everything except the canonical; update it.
             for stray in existing where stray.id != canonical.id {
                 await stray.end(nil, dismissalPolicy: .immediate)
             }
@@ -196,8 +205,6 @@ public final class LiveActivityCoordinator: ObservableObject {
         } else if shouldStartFreshActivity(for: desiredState) {
             await startActivity(with: desiredState)
         }
-        // else: user dismissed recently and there's no urgent reason to re-summon.
-        // Home widget still reflects state; the LA stays out of the way.
     }
 
     /// Guard against re-summoning a freshly-dismissed Live Activity. Within
@@ -227,12 +234,10 @@ public final class LiveActivityCoordinator: ObservableObject {
 
     private func makeContentState(
         sessions: [AgentSnapshot],
-        prs: [PrSnapshot],
-        awaitingInputCount: Int = 0,
-        idleCount: Int = 0
+        prs: [PrSnapshot]
     ) -> ADESessionAttributes.ContentState {
-        // Prioritise: failed first (rare, urgent), then most-recently-active.
-        // Awaiting-input is no longer in this list (rolled into the count chip).
+        // Roster is now strictly currently-streaming chats; SyncService
+        // filters at source. Failed sessions still bubble to the top.
         let sorted = sessions.sorted { a, b in
             if isFailed(a) != isFailed(b) { return isFailed(a) }
             return a.lastActivityAt > b.lastActivityAt
@@ -242,6 +247,7 @@ public final class LiveActivityCoordinator: ObservableObject {
             .init(
                 id: snap.sessionId,
                 providerSlug: snap.provider,
+                modelId: snap.modelId,
                 title: snap.title ?? snap.sessionId,
                 isAwaitingInput: snap.awaitingInput,
                 isFailed: isFailed(snap),
@@ -261,12 +267,10 @@ public final class LiveActivityCoordinator: ObservableObject {
             if pr.mergeReady { mergeReady += 1 }
         }
 
-        // The single most important attention signal. Priority order:
-        // awaiting-input > failed > CI-failing > review-requested > merge-ready.
         let attention: ADESessionAttributes.ContentState.Attention? = selectAttention(
             sessions: sorted,
             prs: prs,
-            awaitingInputCount: awaitingInputCount,
+            awaitingInputCount: 0,
             failingChecks: failingChecks,
             awaitingReviews: awaitingReviews,
             mergeReady: mergeReady
@@ -278,8 +282,8 @@ public final class LiveActivityCoordinator: ObservableObject {
             failingCheckCount: failingChecks,
             awaitingReviewCount: awaitingReviews,
             mergeReadyCount: mergeReady,
-            awaitingInputCount: awaitingInputCount,
-            idleCount: idleCount,
+            awaitingInputCount: 0,
+            idleCount: 0,
             generatedAt: Date()
         )
     }
diff --git a/apps/ios/ADE/Services/SyncService.swift b/apps/ios/ADE/Services/SyncService.swift
index 2928a622a..6146154ec 100644
--- a/apps/ios/ADE/Services/SyncService.swift
+++ b/apps/ios/ADE/Services/SyncService.swift
@@ -385,6 +385,8 @@ private func syncLogPathSummary(_ snapshot: SyncNetworkPathSnapshot?) -> String
   return "satisfied=\(snapshot.isSatisfied) interfaces=\(interfaces.isEmpty ? "none" : interfaces.joined(separator: "+")) expensive=\(snapshot.isExpensive)"
 }
 
+private let syncAmbiguousRouteAuthFailureKey = "ADEAmbiguousRouteAuthFailure"
+
 private func syncLogProfileSummary(_ profile: HostConnectionProfile) -> String {
   [
     "host=\(profile.hostName ?? "unknown")",
@@ -417,6 +419,9 @@ func syncShouldRoamToTailnet(
 enum SyncUserFacingError {
   static func message(for error: Error) -> String {
     let nsError = error as NSError
+    if nsError.userInfo[syncAmbiguousRouteAuthFailureKey] as? Bool == true {
+      return "Reached an ADE host over Tailnet, but it did not match this saved computer. ADE kept the pairing and will keep trying other routes."
+    }
     if let code = nsError.userInfo["ADEErrorCode"] as? String, code == "auth_failed" {
       return "This phone is no longer paired with the host. Pair again from Settings."
     }
@@ -616,6 +621,10 @@ final class SyncService: ObservableObject {
   private(set) var terminalBuffers: [String: String] = [:]
   private(set) var chatEventEnvelopesBySession: [String: [AgentChatEventEnvelope]] = [:]
   private(set) var chatEventRevisionsBySession: [String: Int] = [:]
+  /// Latest known chat summary keyed by session id. Populated by the Work
+  /// list and chat detail screens so the LA reconcile can read `modelId`
+  /// + a real `lastActivityAt` without round-tripping for each running chat.
+  private(set) var chatSummaryCache: [String: AgentChatSessionSummary] = [:]
 
   private let legacyDraftKey = "ade.sync.connectionDraft"
   private let profileKey = "ade.sync.hostProfile"
@@ -834,13 +843,16 @@ final class SyncService: ObservableObject {
 
   func refreshProjectCatalog(preferRemoteSelection: Bool = false) {
     let cachedProjects = database.listMobileProjects()
-    var mergedById = Dictionary(uniqueKeysWithValues: deduplicatedRemoteProjectCatalog().map { ($0.id, $0) })
+    let remoteCatalog = deduplicatedRemoteProjectCatalog()
+    let hasRemoteCatalog = !remoteCatalog.isEmpty
+    var mergedById = Dictionary(uniqueKeysWithValues: remoteCatalog.map { ($0.id, $0) })
     for cachedProject in cachedProjects {
       if var existing = mergedById[cachedProject.id] {
         existing.displayName = cachedProject.displayName
         existing.rootPath = cachedProject.rootPath ?? existing.rootPath
         existing.defaultBaseRef = cachedProject.defaultBaseRef ?? existing.defaultBaseRef
         existing.lastOpenedAt = cachedProject.lastOpenedAt ?? existing.lastOpenedAt
+        existing.iconDataUrl = cachedProject.iconDataUrl ?? existing.iconDataUrl
         existing.laneCount = cachedProject.laneCount
         existing.isCached = true
         existing.isAvailable = existing.isAvailable || cachedProject.isAvailable
@@ -856,11 +868,12 @@ final class SyncService: ObservableObject {
         existing.displayName = cachedProject.displayName
         existing.defaultBaseRef = cachedProject.defaultBaseRef ?? existing.defaultBaseRef
         existing.lastOpenedAt = cachedProject.lastOpenedAt ?? existing.lastOpenedAt
+        existing.iconDataUrl = cachedProject.iconDataUrl ?? existing.iconDataUrl
         existing.laneCount = cachedProject.laneCount
         existing.isCached = true
         existing.isAvailable = existing.isAvailable || cachedProject.isAvailable
         mergedById[cachedProject.id] = existing
-      } else {
+      } else if !hasRemoteCatalog {
         mergedById[cachedProject.id] = cachedProject
       }
     }
@@ -3995,12 +4008,6 @@ final class SyncService: ObservableObject {
       return true
     }
 
-    if let tailnetService = discovered.tailscaleAddress,
-       syncIsTailnetDiscoveryHost(tailnetService),
-       profileHasTailnetRoute(profile) {
-      return true
-    }
-
     if let hostIdentity = profile.hostIdentity?.trimmingCharacters(in: .whitespacesAndNewlines),
        !hostIdentity.isEmpty {
       let discoveredIdentity = discovered.hostIdentity?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
@@ -4025,12 +4032,6 @@ final class SyncService: ObservableObject {
     return false
   }
 
-  private func profileHasTailnetRoute(_ profile: HostConnectionProfile) -> Bool {
-    if profile.tailscaleAddress.map(syncIsTailscaleRoute) == true { return true }
-    if profile.lastSuccessfulAddress.map(syncIsTailscaleRoute) == true { return true }
-    return profile.savedAddressCandidates.contains(where: syncIsTailscaleRoute)
-  }
-
   private func preferTailnetForUpcomingReconnect() {
     preferTailnetReconnectUntil = Date().addingTimeInterval(20)
   }
@@ -4179,11 +4180,12 @@ final class SyncService: ObservableObject {
           syncConnectLog.info("ADE_SYNC_TRACE reconnect success host=\(address, privacy: .public) port=\(candidatePort)")
           return (host: address, port: candidatePort)
         } catch {
-          syncConnectLog.info("ADE_SYNC_TRACE reconnect failure host=\(address, privacy: .public) port=\(candidatePort) error=\(syncLogErrorSummary(error), privacy: .public)")
-          lastFailure = error
-          if shouldInvalidateSavedPairing(for: error) {
+          let reconnectError = errorByMarkingAmbiguousRouteAuthFailure(error, attemptedAddress: address)
+          syncConnectLog.info("ADE_SYNC_TRACE reconnect failure host=\(address, privacy: .public) port=\(candidatePort) error=\(syncLogErrorSummary(reconnectError), privacy: .public)")
+          lastFailure = reconnectError
+          if shouldInvalidateSavedPairing(for: reconnectError) {
             forgetHost()
-            throw error
+            throw reconnectError
           }
           // Tear down this attempt's socket and keep iterating through the
           // remaining ports and addresses. Only surface an error if every
@@ -4245,9 +4247,23 @@ final class SyncService: ObservableObject {
 
   private func shouldInvalidateSavedPairing(for error: Error) -> Bool {
     let nsError = error as NSError
+    if nsError.userInfo[syncAmbiguousRouteAuthFailureKey] as? Bool == true {
+      return false
+    }
     return nsError.userInfo["ADEErrorCode"] as? String == "auth_failed"
   }
 
+  private func errorByMarkingAmbiguousRouteAuthFailure(_ error: Error, attemptedAddress: String) -> Error {
+    let nsError = error as NSError
+    guard nsError.userInfo["ADEErrorCode"] as? String == "auth_failed",
+          syncIsTailnetDiscoveryHost(syncNormalizedRouteHost(attemptedAddress)) else {
+      return error
+    }
+    var userInfo = nsError.userInfo
+    userInfo[syncAmbiguousRouteAuthFailureKey] = true
+    return NSError(domain: nsError.domain, code: nsError.code, userInfo: userInfo)
+  }
+
   private func applyDiscoveredHosts(_ hosts: [DiscoveredSyncHost]) {
     var mergedByIdentity: [String: DiscoveredSyncHost] = [:]
     var noIdentity: [DiscoveredSyncHost] = []
@@ -5615,6 +5631,24 @@ extension SyncService {
 
   // MARK: - Workspace snapshot debounce
 
+  /// Push the latest chat-summary set into the LA-reconcile cache. Callers
+  /// (Work list refresh, chat detail load) hand off the summaries they
+  /// already have so the LA can read `modelId` and a real `lastActivityAt`
+  /// without re-fetching per running session.
+  func cacheChatSummaries(_ summaries: [String: AgentChatSessionSummary]) {
+    chatSummaryCache = summaries
+    // Chat summaries feed `lastActivityAt` / `modelId` into the LA roster, so
+    // a refreshed cache must trigger a snapshot recompute. Otherwise widgets
+    // and live activities keep showing the stale model id / elapsed timer
+    // until the next session-list refresh.
+    refreshActiveSessionsAndSnapshot()
+  }
+
+  func cacheChatSummary(_ summary: AgentChatSessionSummary) {
+    chatSummaryCache[summary.sessionId] = summary
+    refreshActiveSessionsAndSnapshot()
+  }
+
   /// Recompute `activeSessions` from the local `TerminalSessionSummary` roster
   /// and schedule a debounced snapshot write so widgets + live activities pick
   /// up the delta.
@@ -5633,6 +5667,12 @@ extension SyncService {
     var awaitingInputCount = 0
     var idleCount = 0
 
+    // The Live Activity should only ever surface a chat that is actively
+    // streaming output right now. Anything older than this gate is dropped
+    // from the LA roster (it can still appear in the in-app Attention Drawer
+    // via `allAgents`).
+    let runningRecencyCutoff = now.addingTimeInterval(-120)
+
     for session in sessions {
       let isChat = (session.toolType?.contains("chat") == true)
       guard isChat else { continue }
@@ -5643,23 +5683,39 @@ extension SyncService {
       }
 
       let runtime = session.runtimeState.lowercased()
-      // Trust runtimeState (per-tick) over status (high-level) for the
-      // running-vs-idle distinction the user cares about.
       let isAwaiting = runtime == "waiting-input" || status == "awaiting_input"
       let isRunningRuntime = runtime == "running"
       let isIdleRuntime = runtime == "idle"
       let isEndedRuntime = runtime == "exited"
 
-      // Anything that's terminated mid-stream goes in the bin too.
       if isEndedRuntime { continue }
 
       let started = Self.parseIso8601(session.startedAt) ?? now
-      let lastActivity = Self.parseIso8601(session.endedAt ?? "") ?? now
+      // For active sessions there is no `endedAt`. Use the chat summary's
+      // `lastActivityAt` when available; fall back to `chatIdleSinceAt`. If
+      // neither is set yet, treat a running session as fresh by falling back
+      // to `now` — otherwise the recency gate below (`>= runningRecencyCutoff`)
+      // would drop long-lived chats whose `startedAt` was hours/days ago even
+      // while they're still streaming output. Idle / awaiting sessions still
+      // get filtered out by their runtime state, so this fallback only
+      // affects the running roster when activity timestamps are missing.
+      let summary = chatSummaryCache[session.id]
+      let lastActivity =
+        Self.parseIso8601(summary?.lastActivityAt ?? "")
+        ?? Self.parseIso8601(session.chatIdleSinceAt ?? "")
+        ?? (isRunningRuntime ? now : started)
       let elapsed = Int(max(0, lastActivity.timeIntervalSince(started)))
 
+      let resolvedModelId: String? = {
+        if let id = summary?.modelId, !id.isEmpty { return id }
+        if let m = summary?.model, !m.isEmpty { return m }
+        return nil
+      }()
       let snap = AgentSnapshot(
         sessionId: session.id,
         provider: session.toolType ?? "claude",
+        modelId: resolvedModelId,
+        laneName: session.laneName.isEmpty ? nil : session.laneName,
         title: session.title.isEmpty ? session.goal : session.title,
         status: isRunningRuntime ? "running" : (isIdleRuntime ? "idle" : status),
         awaitingInput: isAwaiting,
@@ -5673,18 +5729,15 @@ extension SyncService {
 
       allAgents.append(snap)
 
-      if isAwaiting {
-        awaitingInputCount += 1
-      } else if isRunningRuntime {
+      // LA roster: ONLY truly streaming chats (runtime == running and seen
+      // recently). Idle / awaiting / stale-running drop out entirely so the
+      // lock screen never shows a session that isn't producing output now.
+      if isRunningRuntime && lastActivity >= runningRecencyCutoff {
         runningAgents.append(snap)
+      } else if isAwaiting {
+        awaitingInputCount += 1
       } else if isIdleRuntime {
         idleCount += 1
-      } else if status == "running" {
-        // Transient runtimeState we don't enumerate ("starting", "spawning",
-        // anything new from the desktop). Mirror `normalizedWorkChatSessionStatus`'s
-        // default branch — if the lane still says it's running, treat it as
-        // actively running so the LA + widgets agree.
-        runningAgents.append(snap)
       }
     }
 
@@ -5711,14 +5764,15 @@ extension SyncService {
             branch: item.headBranch.isEmpty ? nil : item.headBranch
           )
         }
-      // Coordinator only sees running sessions in the roster — counts roll
-      // up into a chip / minimal glyph so the LA never carries old, idle, or
-      // pending sessions through into the user-visible roster.
+      // Header label = focused (most-recently-active) running chat's lane.
+      // Falls back to nil → "ADE" alone in the system header.
+      let focusedLaneName = runningAgents
+        .max(by: { $0.lastActivityAt < $1.lastActivityAt })?
+        .laneName
       coord.reconcile(
         with: runningAgents,
         prs: currentPrs,
-        awaitingInputCount: awaitingInputCount,
-        idleCount: idleCount
+        focusedLaneName: focusedLaneName
       )
     }
 
diff --git a/apps/ios/ADE/Shared/ADESharedModels.swift b/apps/ios/ADE/Shared/ADESharedModels.swift
index 0b79a24e2..71f95b4b4 100644
--- a/apps/ios/ADE/Shared/ADESharedModels.swift
+++ b/apps/ios/ADE/Shared/ADESharedModels.swift
@@ -14,6 +14,13 @@ public struct AgentSnapshot: Codable, Hashable, Identifiable, Sendable {
     /// Provider slug: "claude", "codex", "cursor", "opencode", "google",
     /// "mistral", "deepseek", "xai", "groq". Keyed into `ADESharedTheme`.
     public let provider: String
+    /// Specific model id (e.g. "claude-sonnet-4-6"). Rendered as the LA
+    /// subtitle in place of the generic provider slug when present.
+    public let modelId: String?
+    /// Lane name for this session ("Primary", "feature/x"). Used by the
+    /// LA header so the activity reads "ADE · Primary" instead of the
+    /// hardcoded "Workspace".
+    public let laneName: String?
     /// Goal / session title. May be nil for brand-new sessions.
     public let title: String?
     /// "running" | "idle" | "awaiting_input" | "failed" | "completed".
@@ -32,6 +39,8 @@ public struct AgentSnapshot: Codable, Hashable, Identifiable, Sendable {
     public init(
         sessionId: String,
         provider: String,
+        modelId: String? = nil,
+        laneName: String? = nil,
         title: String?,
         status: String,
         awaitingInput: Bool,
@@ -44,6 +53,8 @@ public struct AgentSnapshot: Codable, Hashable, Identifiable, Sendable {
     ) {
         self.sessionId = sessionId
         self.provider = provider
+        self.modelId = modelId
+        self.laneName = laneName
         self.title = title
         self.status = status
         self.awaitingInput = awaitingInput
@@ -54,6 +65,29 @@ public struct AgentSnapshot: Codable, Hashable, Identifiable, Sendable {
         self.phase = phase
         self.toolCalls = toolCalls
     }
+
+    private enum CodingKeys: String, CodingKey {
+        case sessionId, provider, modelId, laneName, title, status,
+             awaitingInput, lastActivityAt, elapsedSeconds, preview,
+             progress, phase, toolCalls
+    }
+
+    public init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        self.sessionId = try c.decode(String.self, forKey: .sessionId)
+        self.provider = try c.decode(String.self, forKey: .provider)
+        self.modelId = try c.decodeIfPresent(String.self, forKey: .modelId)
+        self.laneName = try c.decodeIfPresent(String.self, forKey: .laneName)
+        self.title = try c.decodeIfPresent(String.self, forKey: .title)
+        self.status = try c.decode(String.self, forKey: .status)
+        self.awaitingInput = try c.decode(Bool.self, forKey: .awaitingInput)
+        self.lastActivityAt = try c.decode(Date.self, forKey: .lastActivityAt)
+        self.elapsedSeconds = try c.decode(Int.self, forKey: .elapsedSeconds)
+        self.preview = try c.decodeIfPresent(String.self, forKey: .preview)
+        self.progress = try c.decodeIfPresent(Double.self, forKey: .progress)
+        self.phase = try c.decodeIfPresent(String.self, forKey: .phase)
+        self.toolCalls = try c.decode(Int.self, forKey: .toolCalls)
+    }
 }
 
 public struct PrSnapshot: Codable, Hashable, Identifiable, Sendable {
diff --git a/apps/ios/ADE/Views/Lanes/LaneAdvancedScreen.swift b/apps/ios/ADE/Views/Lanes/LaneAdvancedScreen.swift
new file mode 100644
index 000000000..0e01abd32
--- /dev/null
+++ b/apps/ios/ADE/Views/Lanes/LaneAdvancedScreen.swift
@@ -0,0 +1,210 @@
+import SwiftUI
+
+/// One-stop "Advanced" page for a lane: settings, branch switching, stash,
+/// and the destructive git escape hatches (rebase, force push). Each row
+/// gets a description so the user knows what it does before they tap it.
+struct LaneAdvancedScreen: View {
+  let snapshot: LaneListSnapshot
+  let canRunLiveActions: Bool
+  let disabledSubtitle: String?
+  let laneId: String
+  let branchRef: String?
+  let laneType: String?
+  let missionId: String?
+  let laneRole: String?
+  let onOpenManageSheet: () -> Void
+  let onSwitchBranch: () -> Void
+  let onStash: () -> Void
+  let onRebaseLane: () -> Void
+  let onRebaseDescendants: () -> Void
+  let onRebaseAndPush: () -> Void
+  let onForcePush: () -> Void
+
+  var body: some View {
+    ScrollView {
+      VStack(alignment: .leading, spacing: 14) {
+        if !canRunLiveActions, let disabledSubtitle {
+          HStack(spacing: 10) {
+            Image(systemName: "wifi.exclamationmark")
+              .foregroundStyle(ADEColor.warning)
+            Text(disabledSubtitle)
+              .font(.caption)
+              .foregroundStyle(ADEColor.textSecondary)
+            Spacer(minLength: 0)
+          }
+          .adeGlassCard(cornerRadius: 12, padding: 12)
+        }
+
+        groupCard(header: "Lane settings") {
+          advancedRow(
+            symbol: "gearshape.fill",
+            tint: ADEColor.textPrimary,
+            title: "Manage lane",
+            description: "Rename, archive, or change parent. Settings that don't run git on their own.",
+            action: onOpenManageSheet
+          )
+        }
+
+        groupCard(header: "Branch & working copy") {
+          advancedRow(
+            symbol: branchSwitchDisabledReason == nil ? "arrow.triangle.branch" : "lock",
+            tint: branchSwitchDisabledReason == nil ? ADEColor.tintLanes : ADEColor.textMuted,
+            title: "Switch branch",
+            description: branchSwitchDisabledReason
+              ?? (branchRef.map { "Currently on \($0). Move this lane to another branch." }
+                  ?? "Move this lane to another branch."),
+            disabled: !canRunLiveActions || branchSwitchDisabledReason != nil,
+            action: onSwitchBranch
+          )
+          divider
+          advancedRow(
+            symbol: "tray.and.arrow.down",
+            tint: ADEColor.accent,
+            title: "Stash changes",
+            description: "Move all uncommitted work aside as a stash. You can pop it back later.",
+            disabled: !canRunLiveActions,
+            action: onStash
+          )
+        }
+
+        groupCard(header: "Advanced git", warning: true) {
+          advancedRow(
+            symbol: "arrow.triangle.branch",
+            tint: ADEColor.textPrimary,
+            title: "Rebase lane",
+            description: "Replay this lane's commits on top of the latest base branch.",
+            disabled: !canRunLiveActions,
+            action: onRebaseLane
+          )
+          divider
+          advancedRow(
+            symbol: "arrow.triangle.branch",
+            tint: ADEColor.textPrimary,
+            title: "Rebase + descendants",
+            description: "Rebase this lane and every child stacked on top of it.",
+            disabled: !canRunLiveActions,
+            action: onRebaseDescendants
+          )
+          divider
+          advancedRow(
+            symbol: "arrow.up.and.down.text.horizontal",
+            tint: ADEColor.textPrimary,
+            title: "Rebase and push",
+            description: "Rebase, then push (force-with-lease if required) so the remote matches.",
+            disabled: !canRunLiveActions,
+            action: onRebaseAndPush
+          )
+          divider
+          advancedRow(
+            symbol: "arrow.up.forward.circle.fill",
+            tint: ADEColor.warning,
+            title: "Force push (with lease)",
+            description: "Overwrite the remote branch. Safe-with-lease, but still rewrites history.",
+            disabled: !canRunLiveActions,
+            destructive: true,
+            action: onForcePush
+          )
+        }
+      }
+      .padding(EdgeInsets(top: 14, leading: 16, bottom: 28, trailing: 16))
+    }
+    .adeScreenBackground()
+    .adeNavigationGlass()
+    .navigationTitle("Advanced")
+    .navigationBarTitleDisplayMode(.inline)
+  }
+
+  // MARK: - Components
+
+  @ViewBuilder
+  private func groupCard<Content: View>(
+    header: String,
+    warning: Bool = false,
+    @ViewBuilder content: () -> Content
+  ) -> some View {
+    VStack(alignment: .leading, spacing: 10) {
+      Text(header.uppercased())
+        .font(.caption.weight(.semibold))
+        .tracking(0.6)
+        .foregroundStyle(warning ? ADEColor.warning : ADEColor.textMuted)
+      VStack(spacing: 0) {
+        content()
+      }
+      .background(
+        ADEColor.surfaceBackground.opacity(0.35),
+        in: RoundedRectangle(cornerRadius: 14, style: .continuous)
+      )
+      .overlay(
+        RoundedRectangle(cornerRadius: 14, style: .continuous)
+          .stroke(
+            (warning ? ADEColor.warning.opacity(0.18) : ADEColor.border.opacity(0.18)),
+            lineWidth: 0.5
+          )
+      )
+    }
+  }
+
+  private var divider: some View {
+    Rectangle()
+      .fill(ADEColor.border.opacity(0.18))
+      .frame(height: 0.5)
+      .padding(.leading, 44)
+  }
+
+  @ViewBuilder
+  private func advancedRow(
+    symbol: String,
+    tint: Color,
+    title: String,
+    description: String,
+    disabled: Bool = false,
+    destructive: Bool = false,
+    action: @escaping () -> Void
+  ) -> some View {
+    Button(action: action) {
+      HStack(alignment: .top, spacing: 12) {
+        Image(systemName: symbol)
+          .font(.system(size: 14, weight: .semibold))
+          .foregroundStyle(tint)
+          .frame(width: 24, height: 24, alignment: .center)
+          .padding(.top, 2)
+        VStack(alignment: .leading, spacing: 4) {
+          Text(title)
+            .font(.subheadline.weight(.semibold))
+            .foregroundStyle(destructive ? ADEColor.warning : ADEColor.textPrimary)
+          Text(description)
+            .font(.caption)
+            .foregroundStyle(ADEColor.textSecondary)
+            .fixedSize(horizontal: false, vertical: true)
+        }
+        Spacer(minLength: 8)
+        Image(systemName: "chevron.right")
+          .font(.system(size: 10, weight: .bold))
+          .foregroundStyle(ADEColor.textMuted)
+          .padding(.top, 4)
+      }
+      .padding(EdgeInsets(top: 12, leading: 12, bottom: 12, trailing: 12))
+      .contentShape(Rectangle())
+    }
+    .buttonStyle(.plain)
+    .disabled(disabled)
+    .opacity(disabled ? 0.55 : 1.0)
+  }
+
+  private var branchSwitchDisabledReason: String? {
+    if laneType == "attached" {
+      return "Branch switching is disabled for attached lanes."
+    }
+    if missionId != nil {
+      // Mission lanes default to disabled. Only the explicit "result" role
+      // gets the result-specific copy; every other role (or a missing role)
+      // falls into the worker-lane bucket so we never accidentally allow
+      // branch switching on a mission lane with an unknown role.
+      if laneRole == "result" {
+        return "Branch switching is disabled for mission result lanes."
+      }
+      return "Branch switching isn't available on mission worker lanes."
+    }
+    return nil
+  }
+}
diff --git a/apps/ios/ADE/Views/Lanes/LaneCommitSheet.swift b/apps/ios/ADE/Views/Lanes/LaneCommitSheet.swift
index 1d3900801..a0cb3a53c 100644
--- a/apps/ios/ADE/Views/Lanes/LaneCommitSheet.swift
+++ b/apps/ios/ADE/Views/Lanes/LaneCommitSheet.swift
@@ -6,28 +6,69 @@ struct LaneCommitSheet: View {
   let stagedCount: Int
   let unstagedCount: Int
   let canRunLiveActions: Bool
-  let onGenerateMessage: () -> Void
+  let stagedFiles: [FileChange]
+  let unstagedFiles: [FileChange]
+  /// Returns the suggested commit message, or throws. The sheet owns the
+  /// loading + setup-hint state so the desktop's specific "AI commit messages
+  /// are off" error can be detected and surfaced inline.
+  let onGenerateMessage: () async throws -> String
   let onCommit: () -> Void
   let onDismiss: () -> Void
+  let onStageFile: (FileChange) -> Void
+  let onUnstageFile: (FileChange) -> Void
+  let onDiscardFile: (FileChange) -> Void
+  let onRestoreStaged: (FileChange) -> Void
+  let onStageAll: () -> Void
+  let onUnstageAll: () -> Void
+  let onDiscardAllUnstaged: () -> Void
+  let onRestoreAllStaged: () -> Void
+  let onOpenDiff: (FileChange, _ staged: Bool) -> Void
+  let onOpenFiles: (FileChange) -> Void
 
   @FocusState private var messageFieldFocused: Bool
   @Environment(\.dismiss) private var dismissEnv
+  @State private var isGenerating = false
+  /// When set, the desktop reported AI commit messages as not configured;
+  /// we lock the Suggest button for the remainder of this sheet session
+  /// and show the user how to enable it.
+  @State private var aiSetupHint: String?
+  @State private var aiTransientError: String?
 
   var body: some View {
     NavigationStack {
       ScrollView {
-        VStack(alignment: .leading, spacing: 16) {
-          statusRow
-          messageField
+        VStack(alignment: .leading, spacing: 18) {
+          if !unstagedFiles.isEmpty || !stagedFiles.isEmpty {
+            VStack(alignment: .leading, spacing: 12) {
+              sectionHeader(title: "Files", subtitle: filesSubtitle)
+              if !unstagedFiles.isEmpty {
+                unstagedSection
+              }
+              if !stagedFiles.isEmpty {
+                stagedSection
+              }
+            }
+          }
+
+          VStack(alignment: .leading, spacing: 10) {
+            sectionHeader(title: "Commit message", subtitle: nil, trailing: { suggestButton })
+            messageField
+            if let aiSetupHint {
+              setupHintCard(aiSetupHint)
+            } else if let aiTransientError {
+              transientErrorCard(aiTransientError)
+            }
+          }
+
           amendRow
           commitActionSection
         }
         .padding(.horizontal, 16)
-        .padding(.top, 14)
+        .padding(.top, 12)
         .padding(.bottom, 24)
       }
       .background(ADEColor.surfaceBackground.ignoresSafeArea())
-      .navigationTitle(amendCommit ? "Amend commit" : "Commit changes")
+      .navigationTitle(amendCommit ? "Amend commit" : "Review & commit")
       .navigationBarTitleDisplayMode(.inline)
       .toolbar {
         ToolbarItem(placement: .cancellationAction) {
@@ -37,59 +78,265 @@ struct LaneCommitSheet: View {
           }
         }
       }
-      .onAppear { messageFieldFocused = true }
+      .onAppear {
+        // Auto-focus the commit message field when the sheet appears so the
+        // user can start typing immediately without an extra tap.
+        messageFieldFocused = true
+      }
     }
   }
 
-  private var statusRow: some View {
-    HStack(spacing: 8) {
-      if stagedCount > 0 {
-        LaneMicroChip(icon: "checkmark.circle", text: "\(stagedCount) staged", tint: ADEColor.success)
+  // MARK: - Layout helpers
+
+  private var filesSubtitle: String? {
+    let parts: [String] = [
+      stagedCount > 0 ? "\(stagedCount) staged" : nil,
+      unstagedCount > 0 ? "\(unstagedCount) unstaged" : nil
+    ].compactMap { $0 }
+    return parts.isEmpty ? nil : parts.joined(separator: " · ")
+  }
+
+  @ViewBuilder
+  private func sectionHeader<Trailing: View>(
+    title: String,
+    subtitle: String?,
+    @ViewBuilder trailing: () -> Trailing = { EmptyView() }
+  ) -> some View {
+    HStack(alignment: .firstTextBaseline, spacing: 8) {
+      VStack(alignment: .leading, spacing: 2) {
+        Text(title.uppercased())
+          .font(.caption.weight(.semibold))
+          .tracking(0.6)
+          .foregroundStyle(ADEColor.textMuted)
+        if let subtitle {
+          Text(subtitle)
+            .font(.caption2)
+            .foregroundStyle(ADEColor.textSecondary)
+        }
       }
-      if unstagedCount > 0 {
-        LaneMicroChip(icon: "doc.badge.plus", text: "\(unstagedCount) unstaged", tint: ADEColor.warning)
+      Spacer(minLength: 8)
+      trailing()
+    }
+  }
+
+  // MARK: - Suggest button
+
+  @ViewBuilder
+  private var suggestButton: some View {
+    let disabled = !canRunLiveActions || aiSetupHint != nil || isGenerating
+    Button(action: triggerSuggest) {
+      HStack(spacing: 5) {
+        if isGenerating {
+          ProgressView()
+            .controlSize(.mini)
+            .tint(ADEColor.accent)
+        } else {
+          Image(systemName: "sparkles")
+            .font(.system(size: 11, weight: .semibold))
+        }
+        Text(suggestButtonLabel)
+          .font(.caption.weight(.semibold))
       }
-      if stagedCount == 0 && unstagedCount == 0 {
-        LaneMicroChip(icon: "checkmark.seal", text: "Nothing to commit", tint: ADEColor.textMuted)
+      .foregroundStyle(aiSetupHint == nil ? ADEColor.accent : ADEColor.textMuted)
+      .padding(EdgeInsets(top: 6, leading: 10, bottom: 6, trailing: 10))
+      .background(
+        (aiSetupHint == nil ? ADEColor.accent : ADEColor.textMuted).opacity(0.12),
+        in: Capsule()
+      )
+    }
+    .buttonStyle(.plain)
+    .disabled(disabled)
+    .opacity(disabled ? 0.6 : 1)
+    .accessibilityLabel(isGenerating ? "Generating commit message" : "Suggest commit message")
+  }
+
+  private var suggestButtonLabel: String {
+    if isGenerating { return "Generating…" }
+    if aiSetupHint != nil { return "Setup needed" }
+    return "Suggest"
+  }
+
+  private func triggerSuggest() {
+    guard !isGenerating, aiSetupHint == nil, canRunLiveActions else { return }
+    Task { @MainActor in
+      isGenerating = true
+      aiTransientError = nil
+      defer { isGenerating = false }
+      do {
+        let suggestion = try await onGenerateMessage()
+        commitMessage = suggestion
+        messageFieldFocused = true
+      } catch {
+        let text = error.localizedDescription
+        if isAiSetupError(text) {
+          aiSetupHint = aiSetupHintFor(text)
+        } else {
+          aiTransientError = text
+        }
       }
-      Spacer(minLength: 0)
     }
   }
 
-  private var messageField: some View {
-    VStack(alignment: .leading, spacing: 8) {
-      HStack {
-        Text("Message")
+  // TODO(review #3146132904): drop substring matching once the desktop's
+  // git.generateCommitMessage RPC returns a structured error code (e.g.
+  // `errorCode: "ai_commit_messages_off" | "no_commit_messages_model"`).
+  // Until then we fall back to keyword detection on the localized
+  // description, which is brittle if the desktop copy ever changes. See
+  // https://github.com/anthropic-experimental/ADE/pull/212#discussion_r3146132904
+  private func isAiSetupError(_ text: String) -> Bool {
+    let lower = text
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .lowercased()
+    let needles = [
+      "ai commit messages are off",
+      "ai commit messages are turned off",
+      "commit messages model",
+      "choose a commit messages",
+      "pick a commit messages",
+      "not currently available",
+    ]
+    return needles.contains(where: lower.contains)
+  }
+
+  private func aiSetupHintFor(_ text: String) -> String {
+    let lower = text
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .lowercased()
+    if lower.contains("are off") || lower.contains("turned off") {
+      return "AI commit messages are turned off on the desktop. Open desktop Settings → AI → Commit Messages to enable it."
+    }
+    return "Pick a Commit Messages model on the desktop in Settings → AI → Commit Messages."
+  }
+
+  @ViewBuilder
+  private func setupHintCard(_ message: String) -> some View {
+    HStack(alignment: .top, spacing: 10) {
+      Image(systemName: "wand.and.stars")
+        .font(.system(size: 13, weight: .semibold))
+        .foregroundStyle(ADEColor.warning)
+        .padding(.top, 2)
+      VStack(alignment: .leading, spacing: 4) {
+        Text("Suggest needs setup")
           .font(.caption.weight(.semibold))
+          .foregroundStyle(ADEColor.textPrimary)
+        Text(message)
+          .font(.caption)
           .foregroundStyle(ADEColor.textSecondary)
-        Spacer()
-        Button(action: onGenerateMessage) {
-          HStack(spacing: 4) {
-            Image(systemName: "sparkles")
-              .font(.system(size: 11, weight: .semibold))
-            Text("Suggest")
-              .font(.caption.weight(.semibold))
-          }
-          .foregroundStyle(ADEColor.accent)
-          .padding(EdgeInsets(top: 5, leading: 10, bottom: 5, trailing: 10))
-          .background(ADEColor.accent.opacity(0.12), in: Capsule())
-        }
-        .buttonStyle(.plain)
-        .disabled(!canRunLiveActions)
+          .fixedSize(horizontal: false, vertical: true)
       }
+      Spacer(minLength: 8)
+    }
+    .padding(EdgeInsets(top: 10, leading: 12, bottom: 10, trailing: 12))
+    .background(ADEColor.warning.opacity(0.10), in: RoundedRectangle(cornerRadius: 10, style: .continuous))
+    .overlay(
+      RoundedRectangle(cornerRadius: 10, style: .continuous)
+        .stroke(ADEColor.warning.opacity(0.25), lineWidth: 0.5)
+    )
+  }
 
-      TextField(
-        amendCommit ? "Update the previous commit message" : "Describe what this change does",
-        text: $commitMessage,
-        axis: .vertical
-      )
-      .textFieldStyle(.plain)
-      .font(.subheadline)
-      .lineLimit(4...10)
-      .focused($messageFieldFocused)
-      .frame(minHeight: 140, alignment: .topLeading)
-      .adeInsetField(cornerRadius: 12, padding: 12)
+  @ViewBuilder
+  private func transientErrorCard(_ message: String) -> some View {
+    HStack(alignment: .top, spacing: 10) {
+      Image(systemName: "exclamationmark.triangle.fill")
+        .font(.system(size: 13, weight: .semibold))
+        .foregroundStyle(ADEColor.danger)
+        .padding(.top, 2)
+      Text(message)
+        .font(.caption)
+        .foregroundStyle(ADEColor.textSecondary)
+        .fixedSize(horizontal: false, vertical: true)
+      Spacer(minLength: 8)
     }
+    .padding(EdgeInsets(top: 10, leading: 12, bottom: 10, trailing: 12))
+    .background(ADEColor.danger.opacity(0.08), in: RoundedRectangle(cornerRadius: 10, style: .continuous))
+    .overlay(
+      RoundedRectangle(cornerRadius: 10, style: .continuous)
+        .stroke(ADEColor.danger.opacity(0.22), lineWidth: 0.5)
+    )
+  }
+
+  // MARK: - File sections
+
+  @ViewBuilder
+  private var unstagedSection: some View {
+    LaneFileTreeSection(
+      title: "Unstaged files",
+      subtitle: "\(unstagedFiles.count) file\(unstagedFiles.count == 1 ? "" : "s")",
+      changes: unstagedFiles,
+      allowsLiveActions: canRunLiveActions,
+      allowsDiffInspection: true,
+      bulkActionTitle: unstagedFiles.count > 1 ? "Stage all" : nil,
+      bulkActionSymbol: "plus.circle.fill",
+      bulkActionTint: ADEColor.accent,
+      primaryActionTitle: "Stage",
+      primaryActionSymbol: "plus.circle.fill",
+      primaryActionTint: ADEColor.accent,
+      secondaryActionTitle: "Discard",
+      secondaryActionSymbol: "trash",
+      secondaryActionTint: ADEColor.danger,
+      extraBulkActions: [
+        LaneFileTreeBulkAction(
+          title: "Discard unstaged",
+          symbol: "trash",
+          tint: ADEColor.danger,
+          isDestructive: true
+        ) { onDiscardAllUnstaged() }
+      ],
+      onBulkAction: onStageAll,
+      onDiff: { file in onOpenDiff(file, false) },
+      onPrimaryAction: onStageFile,
+      onSecondaryAction: onDiscardFile,
+      onOpenFiles: onOpenFiles
+    )
+  }
+
+  @ViewBuilder
+  private var stagedSection: some View {
+    LaneFileTreeSection(
+      title: "Staged files",
+      subtitle: "\(stagedFiles.count) file\(stagedFiles.count == 1 ? "" : "s")",
+      changes: stagedFiles,
+      allowsLiveActions: canRunLiveActions,
+      allowsDiffInspection: true,
+      bulkActionTitle: stagedFiles.count > 1 ? "Unstage all" : nil,
+      bulkActionSymbol: "minus.circle",
+      bulkActionTint: ADEColor.warning,
+      primaryActionTitle: "Unstage",
+      primaryActionSymbol: "minus.circle",
+      primaryActionTint: ADEColor.warning,
+      secondaryActionTitle: "Discard",
+      secondaryActionSymbol: "trash",
+      secondaryActionTint: ADEColor.danger,
+      extraBulkActions: [
+        LaneFileTreeBulkAction(
+          title: "Discard staged",
+          symbol: "trash",
+          tint: ADEColor.danger,
+          isDestructive: true
+        ) { onRestoreAllStaged() }
+      ],
+      onBulkAction: onUnstageAll,
+      onDiff: { file in onOpenDiff(file, true) },
+      onPrimaryAction: onUnstageFile,
+      onSecondaryAction: onRestoreStaged,
+      onOpenFiles: onOpenFiles
+    )
+  }
+
+  // MARK: - Message + amend + commit
+
+  private var messageField: some View {
+    TextField(
+      amendCommit ? "Update the previous commit message" : "Describe what this change does",
+      text: $commitMessage,
+      axis: .vertical
+    )
+    .textFieldStyle(.plain)
+    .font(.subheadline)
+    .lineLimit(4...10)
+    .focused($messageFieldFocused)
+    .frame(minHeight: 130, alignment: .topLeading)
+    .adeInsetField(cornerRadius: 12, padding: 12)
   }
 
   private var amendRow: some View {
diff --git a/apps/ios/ADE/Views/Lanes/LaneDetailContentSections.swift b/apps/ios/ADE/Views/Lanes/LaneDetailContentSections.swift
index 412995f51..d7a5732ce 100644
--- a/apps/ios/ADE/Views/Lanes/LaneDetailContentSections.swift
+++ b/apps/ios/ADE/Views/Lanes/LaneDetailContentSections.swift
@@ -1,15 +1,18 @@
 import SwiftUI
 
-struct LaneDetailHeaderCard: View {
+struct LaneDetailHeaderCard<Footer: View>: View {
   let snapshot: LaneListSnapshot
   let detail: LaneDetailPayload?
   let linkedPullRequests: [PullRequestListItem]
   let transitionNamespace: Namespace.ID?
   let transitionLaneId: String?
-  let canManage: Bool
-  let onManageTapped: () -> Void
+  let canRunLiveActions: Bool
   let onStackTapped: () -> Void
   let onOpenLinkedPullRequest: (PullRequestListItem) -> Void
+  let onPush: () -> Void
+  let onPull: () -> Void
+  let onFetch: () -> Void
+  @ViewBuilder let footer: () -> Footer
 
   // transitionNamespace / transitionLaneId are retained on the init for
   // caller compatibility but intentionally unused in body:
@@ -29,6 +32,8 @@ struct LaneDetailHeaderCard: View {
           .foregroundStyle(ADEColor.textSecondary)
       }
       activeSessionsRow
+      syncActionsRow
+      footer()
     }
     .adeGlassCard(cornerRadius: 18, padding: 16)
     .accessibilityElement(children: .contain)
@@ -52,18 +57,90 @@ struct LaneDetailHeaderCard: View {
       }
 
       Spacer(minLength: 8)
+    }
+  }
 
-      Button(action: onManageTapped) {
-        Image(systemName: "gearshape.fill")
-          .font(.system(size: 13, weight: .semibold))
-          .foregroundStyle(ADEColor.textSecondary)
-          .frame(width: 44, height: 44)
-          .background(ADEColor.surfaceBackground.opacity(0.45), in: Circle())
+  /// Inline Pull / Push / Fetch row pinned to the bottom of the header card.
+  /// Sync details + the underlying full sync screen live in Advanced now —
+  /// this is the everyday "I'm done, push it" affordance.
+  @ViewBuilder
+  private var syncActionsRow: some View {
+    let ahead = snapshot.lane.status.ahead
+    let behind = snapshot.lane.status.behind
+    let summary = syncSummaryText(ahead: ahead, behind: behind)
+
+    HStack(spacing: 8) {
+      Image(systemName: "arrow.triangle.2.circlepath")
+        .font(.system(size: 12, weight: .semibold))
+        .foregroundStyle(ADEColor.textSecondary)
+      Text(summary)
+        .font(.caption)
+        .foregroundStyle(ADEColor.textSecondary)
+        .lineLimit(1)
+        .truncationMode(.tail)
+      Spacer(minLength: 8)
+
+      syncActionButton(
+        symbol: "arrow.down.to.line.compact",
+        // Action flips between Pull (when there are commits to integrate)
+        // and Fetch (when we just want to refresh remote state). The label
+        // and accessibility text must follow the action so VoiceOver users
+        // hear what the button is actually about to do.
+        label: behind > 0 ? "Pull" : "Fetch",
+        tint: behind > 0 ? ADEColor.warning : ADEColor.textPrimary,
+        emphasize: behind > 0,
+        action: behind > 0 ? onPull : onFetch
+      )
+      syncActionButton(
+        symbol: "arrow.up.to.line.compact",
+        label: "Push",
+        tint: ahead > 0 ? ADEColor.success : ADEColor.textPrimary,
+        emphasize: ahead > 0,
+        action: onPush
+      )
+    }
+    .padding(.top, 2)
+  }
+
+  private func syncSummaryText(ahead: Int, behind: Int) -> String {
+    switch (ahead, behind) {
+    case (0, 0): return "In sync with remote"
+    case (let a, 0): return "\(a) ahead"
+    case (0, let b): return "\(b) behind"
+    case (let a, let b): return "\(a) ahead · \(b) behind"
+    }
+  }
+
+  @ViewBuilder
+  private func syncActionButton(
+    symbol: String,
+    label: String,
+    tint: Color,
+    emphasize: Bool,
+    action: @escaping () -> Void
+  ) -> some View {
+    Button(action: action) {
+      HStack(spacing: 5) {
+        Image(systemName: symbol)
+          .font(.system(size: 11, weight: .bold))
+        Text(label)
+          .font(.caption.weight(.semibold))
       }
-      .buttonStyle(.plain)
-      .disabled(!canManage)
-      .accessibilityLabel("Manage lane")
+      .foregroundStyle(tint)
+      .padding(.horizontal, 10)
+      .padding(.vertical, 6)
+      .background(
+        (emphasize ? tint.opacity(0.16) : ADEColor.surfaceBackground.opacity(0.45)),
+        in: Capsule()
+      )
+      .overlay(
+        Capsule().stroke(tint.opacity(emphasize ? 0.32 : 0.16), lineWidth: 0.6)
+      )
     }
+    .buttonStyle(.plain)
+    .disabled(!canRunLiveActions)
+    .opacity(canRunLiveActions ? 1 : 0.5)
+    .accessibilityLabel(label)
   }
 
   @ViewBuilder
diff --git a/apps/ios/ADE/Views/Lanes/LaneDetailGitSection.swift b/apps/ios/ADE/Views/Lanes/LaneDetailGitSection.swift
index 984f7efb2..502cbfeb5 100644
--- a/apps/ios/ADE/Views/Lanes/LaneDetailGitSection.swift
+++ b/apps/ios/ADE/Views/Lanes/LaneDetailGitSection.swift
@@ -6,44 +6,10 @@ extension LaneDetailScreen {
   var gitSections: some View {
     if let detail {
       VStack(spacing: 14) {
-        gitStatusBanner(detail: detail)
-
         if let conflictState = detail.conflictState, conflictState.inProgress {
           conflictSection(conflictState: conflictState)
         }
 
-        if detail.lane.status.dirty || !(detail.diffChanges?.staged.isEmpty ?? true) {
-          commitCTAButton(detail: detail)
-        }
-
-        if let diffChanges = detail.diffChanges, !diffChanges.unstaged.isEmpty {
-          unstagedSection(changes: diffChanges.unstaged)
-        }
-
-        if let diffChanges = detail.diffChanges, !diffChanges.staged.isEmpty {
-          stagedSection(changes: diffChanges.staged)
-        }
-
-        NavigationLink {
-          LaneSyncDetailScreen(
-            laneName: detail.lane.name,
-            branchRef: detail.lane.branchRef,
-            syncStatus: detail.syncStatus,
-            canRunLiveActions: canRunLiveActions,
-            onFetch: { Task { await performAction("fetch") { try await syncService.fetchGit(laneId: laneId) } } },
-            onPullMerge: { Task { await performAction("pull merge") { try await syncService.pullGit(laneId: laneId) } } },
-            onPullRebase: { Task { await performAction("pull rebase") { try await syncService.syncGit(laneId: laneId, mode: "rebase") } } },
-            onPush: { Task { await performAction("push") { try await syncService.pushGit(laneId: laneId) } } }
-          )
-        } label: {
-          summaryRow(
-            symbol: "arrow.triangle.2.circlepath",
-            title: "Sync",
-            detail: detail.syncStatus.map(syncSummary) ?? "No sync status yet"
-          )
-        }
-        .buttonStyle(.plain)
-
         NavigationLink {
           LaneStashesScreen(
             laneName: detail.lane.name,
@@ -119,11 +85,49 @@ extension LaneDetailScreen {
         }
         .buttonStyle(.plain)
 
-        actionsCard
+        advancedRow(detail: detail)
       }
     }
   }
 
+  // MARK: - Advanced entry
+
+  @ViewBuilder
+  func advancedRow(detail: LaneDetailPayload) -> some View {
+    NavigationLink {
+      LaneAdvancedScreen(
+        snapshot: currentSnapshot,
+        canRunLiveActions: canRunLiveActions,
+        disabledSubtitle: liveActionDisabledSubtitle,
+        laneId: laneId,
+        branchRef: detail.lane.branchRef,
+        laneType: detail.lane.laneType,
+        missionId: detail.lane.missionId,
+        laneRole: detail.lane.laneRole,
+        onOpenManageSheet: { managePresented = true },
+        onSwitchBranch: { showBranchPicker = true },
+        onStash: {
+          Task {
+            await performAction("stash") {
+              try await syncService.stashPush(laneId: laneId, message: "", includeUntracked: true)
+            }
+          }
+        },
+        onRebaseLane: { requestGitConfirmation(.rebaseLane) },
+        onRebaseDescendants: { requestGitConfirmation(.rebaseDescendants) },
+        onRebaseAndPush: { requestGitConfirmation(.rebaseAndPush) },
+        onForcePush: { requestGitConfirmation(.forcePush) }
+      )
+    } label: {
+      summaryRow(
+        symbol: "slider.horizontal.3",
+        title: "Advanced",
+        detail: "Settings, branch tools, rebase & push"
+      )
+    }
+    .buttonStyle(.plain)
+  }
+
   // MARK: - Rebase banner
 
   @ViewBuilder
@@ -154,26 +158,28 @@ extension LaneDetailScreen {
     Button {
       showCommitSheet = true
     } label: {
-      HStack(spacing: 8) {
+      HStack(spacing: 10) {
         Image(systemName: amendCommit ? "arrow.counterclockwise" : "square.and.pencil")
-          .font(.system(size: 14, weight: .semibold))
+          .font(.system(size: 15, weight: .semibold))
         Text(amendCommit ? "Amend last commit" : commitCTALabel(stagedCount: stagedCount, unstagedCount: unstagedCount))
           .font(.subheadline.weight(.semibold))
-        Spacer()
+        Spacer(minLength: 8)
         Image(systemName: "chevron.up")
-          .font(.system(size: 11, weight: .bold))
-          .opacity(0.7)
+          .font(.system(size: 12, weight: .bold))
+          .opacity(0.85)
       }
       .foregroundStyle(ADEColor.textPrimary)
-      .padding(EdgeInsets(top: 14, leading: 16, bottom: 14, trailing: 16))
-      .background(ADEColor.accent.opacity(0.22), in: RoundedRectangle(cornerRadius: 14, style: .continuous))
+      .frame(maxWidth: .infinity)
+      .padding(EdgeInsets(top: 12, leading: 14, bottom: 12, trailing: 14))
+      .background(ADEColor.accent.opacity(0.22), in: RoundedRectangle(cornerRadius: 12, style: .continuous))
       .overlay(
-        RoundedRectangle(cornerRadius: 14, style: .continuous)
+        RoundedRectangle(cornerRadius: 12, style: .continuous)
           .stroke(ADEColor.accent.opacity(0.45), lineWidth: 0.6)
       )
     }
     .buttonStyle(.plain)
     .disabled(!canRunLiveActions)
+    .accessibilityHint("Opens the review and commit drawer.")
   }
 
   private func commitCTALabel(stagedCount: Int, unstagedCount: Int) -> String {
@@ -186,43 +192,6 @@ extension LaneDetailScreen {
     return "Commit changes"
   }
 
-  // MARK: - Actions card
-
-  @ViewBuilder
-  var actionsCard: some View {
-    if detail != nil {
-      LaneActionsCard(
-        canRunLiveActions: canRunLiveActions,
-        disabledSubtitle: liveActionDisabledSubtitle,
-        onRebaseLane: {
-          requestGitConfirmation(.rebaseLane)
-        },
-        onRebaseDescendants: {
-          requestGitConfirmation(.rebaseDescendants)
-        },
-        onRebaseAndPush: {
-          requestGitConfirmation(.rebaseAndPush)
-        },
-        onForcePush: {
-          requestGitConfirmation(.forcePush)
-        },
-        onStash: {
-          Task {
-            await performAction("stash") {
-              try await syncService.stashPush(laneId: laneId, message: "", includeUntracked: true)
-            }
-          }
-        },
-        laneId: laneId,
-        branchRef: detail?.lane.branchRef,
-        laneType: detail?.lane.laneType,
-        missionId: detail?.lane.missionId,
-        laneRole: detail?.lane.laneRole,
-        onRefresh: { await loadDetail(refreshRemote: true) }
-      )
-    }
-  }
-
   // MARK: - Summary row
 
   @ViewBuilder
@@ -251,17 +220,15 @@ extension LaneDetailScreen {
     .adeGlassCard(cornerRadius: 14, padding: 0)
   }
 
-  // MARK: - Status banner
+  // MARK: - Status banner (inline chips, no glass card — sits inside header)
 
   @ViewBuilder
   func gitStatusBanner(detail: LaneDetailPayload) -> some View {
     let unstaged = detail.diffChanges?.unstaged.count ?? 0
     let staged = detail.diffChanges?.staged.count ?? 0
     let stashCount = detail.stashes.count
-    let ahead = detail.lane.status.ahead
-    let behind = detail.lane.status.behind
 
-    if unstaged > 0 || staged > 0 || stashCount > 0 || ahead > 0 || behind > 0 {
+    if unstaged > 0 || staged > 0 || stashCount > 0 {
       ScrollView(.horizontal, showsIndicators: false) {
         HStack(spacing: 8) {
           if unstaged > 0 {
@@ -273,16 +240,8 @@ extension LaneDetailScreen {
           if stashCount > 0 {
             LaneMicroChip(icon: "tray.2", text: "\(stashCount) stash\(stashCount == 1 ? "" : "es")", tint: ADEColor.textMuted)
           }
-          if ahead > 0 {
-            LaneMicroChip(icon: "arrow.up", text: "\(ahead) ahead", tint: ADEColor.success)
-          }
-          if behind > 0 {
-            LaneMicroChip(icon: "arrow.down", text: "\(behind) behind", tint: ADEColor.warning)
-          }
         }
-        .padding(4)
       }
-      .adeGlassCard(cornerRadius: 12, padding: 10)
     }
   }
 
@@ -365,112 +324,6 @@ extension LaneDetailScreen {
     )
   }
 
-  // MARK: - Unstaged files
-
-  @ViewBuilder
-  func unstagedSection(changes: [FileChange]) -> some View {
-    LaneFileTreeSection(
-      title: "Unstaged files",
-      subtitle: "\(changes.count) file\(changes.count == 1 ? "" : "s")",
-      changes: changes,
-      allowsLiveActions: canRunLiveActions,
-      allowsDiffInspection: true,
-      bulkActionTitle: changes.count > 1 ? "Stage all" : nil,
-      bulkActionSymbol: "plus.circle.fill",
-      bulkActionTint: ADEColor.accent,
-      primaryActionTitle: "Stage",
-      primaryActionSymbol: "plus.circle.fill",
-      primaryActionTint: ADEColor.accent,
-      secondaryActionTitle: "Discard",
-      secondaryActionSymbol: "trash",
-      secondaryActionTint: ADEColor.danger,
-      extraBulkActions: [
-        LaneFileTreeBulkAction(title: "Discard unstaged", symbol: "trash", tint: ADEColor.danger, isDestructive: true) {
-          pendingFileConfirmation = .discardAllUnstaged(changes)
-        }
-      ],
-      onBulkAction: {
-        Task {
-          await performAction("stage all") {
-            try await syncService.stageAll(laneId: laneId, paths: changes.map(\.path))
-          }
-        }
-      },
-      onDiff: { file in
-        selectedDiffRequest = LaneDiffRequest(
-          laneId: laneId,
-          path: file.path,
-          mode: "unstaged",
-          compareRef: nil,
-          compareTo: nil,
-          title: (file.path as NSString).lastPathComponent
-        )
-      },
-      onPrimaryAction: { file in
-        Task { await performAction("stage file") { try await syncService.stageFile(laneId: laneId, path: file.path) } }
-      },
-      onSecondaryAction: { file in
-        pendingFileConfirmation = .discardUnstaged(file)
-      },
-      onOpenFiles: { file in
-        Task { await openFiles(path: file.path) }
-      }
-    )
-  }
-
-  // MARK: - Staged files
-
-  @ViewBuilder
-  func stagedSection(changes: [FileChange]) -> some View {
-    LaneFileTreeSection(
-      title: "Staged files",
-      subtitle: "\(changes.count) file\(changes.count == 1 ? "" : "s")",
-      changes: changes,
-      allowsLiveActions: canRunLiveActions,
-      allowsDiffInspection: true,
-      bulkActionTitle: changes.count > 1 ? "Unstage all" : nil,
-      bulkActionSymbol: "minus.circle",
-      bulkActionTint: ADEColor.warning,
-      primaryActionTitle: "Unstage",
-      primaryActionSymbol: "minus.circle",
-      primaryActionTint: ADEColor.warning,
-      secondaryActionTitle: "Discard",
-      secondaryActionSymbol: "trash",
-      secondaryActionTint: ADEColor.danger,
-      extraBulkActions: [
-        LaneFileTreeBulkAction(title: "Discard staged", symbol: "trash", tint: ADEColor.danger, isDestructive: true) {
-          pendingFileConfirmation = .restoreAllStaged(changes)
-        }
-      ],
-      onBulkAction: {
-        Task {
-          await performAction("unstage all") {
-            try await syncService.unstageAll(laneId: laneId, paths: changes.map(\.path))
-          }
-        }
-      },
-      onDiff: { file in
-        selectedDiffRequest = LaneDiffRequest(
-          laneId: laneId,
-          path: file.path,
-          mode: "staged",
-          compareRef: nil,
-          compareTo: nil,
-          title: (file.path as NSString).lastPathComponent
-        )
-      },
-      onPrimaryAction: { file in
-        Task { await performAction("unstage file") { try await syncService.unstageFile(laneId: laneId, path: file.path) } }
-      },
-      onSecondaryAction: { file in
-        pendingFileConfirmation = .restoreStaged(file)
-      },
-      onOpenFiles: { file in
-        Task { await openFiles(path: file.path) }
-      }
-    )
-  }
-
   @MainActor
   func openCommitDiffs(for commit: GitCommitSummary) async {
     do {
diff --git a/apps/ios/ADE/Views/Lanes/LaneDetailScreen.swift b/apps/ios/ADE/Views/Lanes/LaneDetailScreen.swift
index 7f72da408..e7b5560d6 100644
--- a/apps/ios/ADE/Views/Lanes/LaneDetailScreen.swift
+++ b/apps/ios/ADE/Views/Lanes/LaneDetailScreen.swift
@@ -15,7 +15,8 @@ struct LaneDetailScreen: View {
   @State private(set) var busyAction: String?
   @State var selectedDiffRequest: LaneDiffRequest?
   @State private var showStackGraph = false
-  @State private var managePresented = false
+  @State var managePresented = false
+  @State var showBranchPicker = false
   @State private var lanePullRequests: [PullRequestListItem] = []
   @State var commitMessage = ""
   @State var amendCommit = false
@@ -28,7 +29,6 @@ struct LaneDetailScreen: View {
   @State var commitDiffFiles: [String] = []
   @State var commitDiffSha = ""
   @State var commitDiffSubject = ""
-  @State private var commitMessageGenerationToken = UUID()
   @State var cachedCommitDiffFilesBySha: [String: [String]] = [:]
   @State var pendingGitConfirmation: LaneGitConfirmation?
   @State private var lastLaneDetailLocalReload = Date.distantPast
@@ -171,25 +171,14 @@ struct LaneDetailScreen: View {
         stagedCount: detail?.diffChanges?.staged.count ?? 0,
         unstagedCount: detail?.diffChanges?.unstaged.count ?? 0,
         canRunLiveActions: canRunLiveActions,
+        stagedFiles: detail?.diffChanges?.staged ?? [],
+        unstagedFiles: detail?.diffChanges?.unstaged ?? [],
         onGenerateMessage: {
-          let requestToken = UUID()
           let shouldAmend = amendCommit
-          commitMessageGenerationToken = requestToken
-          Task { @MainActor in
-            do {
-              let msg = try await syncService.generateCommitMessage(laneId: laneId, amend: shouldAmend)
-              guard commitMessageGenerationToken == requestToken, showCommitSheet else { return }
-              commitMessage = msg
-            } catch {
-              guard commitMessageGenerationToken == requestToken, showCommitSheet else { return }
-              ADEHaptics.error()
-              errorMessage = error.localizedDescription
-            }
-          }
+          return try await syncService.generateCommitMessage(laneId: laneId, amend: shouldAmend)
         },
         onCommit: {
           Task {
-            commitMessageGenerationToken = UUID()
             await performAction("commit") {
               try await syncService.commitLane(laneId: laneId, message: commitMessage, amend: amendCommit)
             }
@@ -201,14 +190,66 @@ struct LaneDetailScreen: View {
           }
         },
         onDismiss: {
-          commitMessageGenerationToken = UUID()
           showCommitSheet = false
+        },
+        onStageFile: { file in
+          Task { await performAction("stage file") { try await syncService.stageFile(laneId: laneId, path: file.path) } }
+        },
+        onUnstageFile: { file in
+          Task { await performAction("unstage file") { try await syncService.unstageFile(laneId: laneId, path: file.path) } }
+        },
+        onDiscardFile: { file in
+          pendingFileConfirmation = .discardUnstaged(file)
+        },
+        onRestoreStaged: { file in
+          pendingFileConfirmation = .restoreStaged(file)
+        },
+        onStageAll: {
+          let paths = (detail?.diffChanges?.unstaged ?? []).map(\.path)
+          guard !paths.isEmpty else { return }
+          Task { await performAction("stage all") { try await syncService.stageAll(laneId: laneId, paths: paths) } }
+        },
+        onUnstageAll: {
+          let paths = (detail?.diffChanges?.staged ?? []).map(\.path)
+          guard !paths.isEmpty else { return }
+          Task { await performAction("unstage all") { try await syncService.unstageAll(laneId: laneId, paths: paths) } }
+        },
+        onDiscardAllUnstaged: {
+          let files = detail?.diffChanges?.unstaged ?? []
+          guard !files.isEmpty else { return }
+          pendingFileConfirmation = .discardAllUnstaged(files)
+        },
+        onRestoreAllStaged: {
+          let files = detail?.diffChanges?.staged ?? []
+          guard !files.isEmpty else { return }
+          pendingFileConfirmation = .restoreAllStaged(files)
+        },
+        onOpenDiff: { file, isStaged in
+          selectedDiffRequest = LaneDiffRequest(
+            laneId: laneId,
+            path: file.path,
+            mode: isStaged ? "staged" : "unstaged",
+            compareRef: nil,
+            compareTo: nil,
+            title: (file.path as NSString).lastPathComponent
+          )
+        },
+        onOpenFiles: { file in
+          Task { await openFiles(path: file.path) }
         }
       )
       .presentationDetents([.medium, .large])
     }
+    .sheet(isPresented: $showBranchPicker) {
+      if let detail {
+        LaneBranchPickerSheet(
+          laneId: laneId,
+          branchRef: detail.lane.branchRef,
+          onComplete: { await loadDetail(refreshRemote: true) }
+        )
+      }
+    }
     .onDisappear {
-      commitMessageGenerationToken = UUID()
       syncService.releaseLaneOpen(laneId: laneId)
     }
   }
@@ -221,10 +262,47 @@ struct LaneDetailScreen: View {
       linkedPullRequests: lanePullRequests,
       transitionNamespace: transitionNamespace,
       transitionLaneId: laneId,
-      canManage: canRunLiveActions,
-      onManageTapped: { managePresented = true },
+      canRunLiveActions: canRunLiveActions,
       onStackTapped: { showStackGraph = true },
-      onOpenLinkedPullRequest: { pr in openPullRequest(pr) }
+      onOpenLinkedPullRequest: { pr in openPullRequest(pr) },
+      onPush: {
+        Task { await performAction("push") { try await syncService.pushGit(laneId: laneId) } }
+      },
+      onPull: {
+        Task { await performAction("pull rebase") { try await syncService.syncGit(laneId: laneId, mode: "rebase") } }
+      },
+      onFetch: {
+        Task { await performAction("fetch") { try await syncService.fetchGit(laneId: laneId) } }
+      },
+      footer: {
+        if let detail {
+          // Compute whether there's any actual footer content before
+          // emitting the divider. `gitStatusBanner` only renders chips when
+          // there are unstaged/staged/stashed changes; the commit CTA only
+          // shows when the lane is dirty or has staged files. If neither
+          // produces content, drawing the divider leaves a stray hairline
+          // under the section header.
+          let unstagedCount = detail.diffChanges?.unstaged.count ?? 0
+          let stagedCount = detail.diffChanges?.staged.count ?? 0
+          let stashCount = detail.stashes.count
+          let hasStatusBanner = unstagedCount > 0 || stagedCount > 0 || stashCount > 0
+          let hasCommitCTA = detail.lane.status.dirty || stagedCount > 0
+          if hasStatusBanner || hasCommitCTA {
+            VStack(spacing: 10) {
+              Rectangle()
+                .fill(ADEColor.border.opacity(0.18))
+                .frame(height: 0.5)
+                .padding(.top, 2)
+              if hasStatusBanner {
+                gitStatusBanner(detail: detail)
+              }
+              if hasCommitCTA {
+                commitCTAButton(detail: detail)
+              }
+            }
+          }
+        }
+      }
     )
   }
 
diff --git a/apps/ios/ADE/Views/Work/WorkArtifactTerminalViews.swift b/apps/ios/ADE/Views/Work/WorkArtifactTerminalViews.swift
index 1cc3817ce..61aa79b7f 100644
--- a/apps/ios/ADE/Views/Work/WorkArtifactTerminalViews.swift
+++ b/apps/ios/ADE/Views/Work/WorkArtifactTerminalViews.swift
@@ -126,17 +126,22 @@ struct WorkArtifactView: View {
 /// streams output into a monospaced buffer, and offers a one-shot input bar
 /// that forwards typed lines back to the host as `terminal_input`.
 ///
-/// Future work (tracked in PTY foundation): swap the plain `Text` renderer
-/// for a real terminal emulator (SwiftTerm) so we can render ANSI colours,
-/// cursor movement, and alt-screen apps (vim, htop, fzf). Today we strip
-/// the most common SGR/CSI sequences so the buffer reads cleanly.
+/// Future work (tracked in PTY foundation): swap this replay-backed SwiftUI
+/// view for a real terminal emulator (SwiftTerm) so we can render alt-screen
+/// apps (vim, htop, fzf). Today we replay the common cursor/erase sequences
+/// and preserve SGR colours/bold so agent CLIs stay readable on iPhone.
 struct WorkTerminalSessionView: View {
   @EnvironmentObject var syncService: SyncService
   let session: TerminalSessionSummary
   let transitionNamespace: Namespace.ID?
   let onOpenLane: (() -> Void)?
 
-  @State private var pendingCommand = ""
+  /// Termius-style char-by-char input: as the user types, each new character
+  /// is forwarded to the live PTY and the field is immediately cleared so the
+  /// PTY's own echo (rendered in the scrollback) is the only source of truth.
+  /// We never buffer a command on-device — `↵` and the keyboard return both
+  /// just send `\r` to the shell.
+  @State private var inputBuffer = ""
   @FocusState private var inputFocused: Bool
   @State private var sendingFeedback = 0
   @State private var lastSentTerminalSize: TerminalViewportSize?
@@ -149,12 +154,10 @@ struct WorkTerminalSessionView: View {
     workTerminalDisplay(raw: rawBuffer, fallback: nil)
   }
 
-  /// Best-effort ANSI/CSI strip so the plain `Text` renderer doesn't leak
-  /// raw escape sequences. Removes CSI (`ESC [ ...`), OSC (`ESC ] ... BEL`
-  /// or `ESC ] ... ESC \`), and bare cursor/reset escapes. Real emulators
-  /// will replace this once SwiftTerm lands.
-  private var renderedText: String {
-    workTerminalStripAnsi(terminalDisplay.text)
+  private var renderedText: AttributedString {
+    terminalDisplay.attributedText.characters.isEmpty
+      ? workTerminalPlainAttributedString("  ")
+      : terminalDisplay.attributedText
   }
 
   private var canSendInput: Bool {
@@ -163,54 +166,34 @@ struct WorkTerminalSessionView: View {
 
   var body: some View {
     VStack(alignment: .leading, spacing: 0) {
-      VStack(alignment: .leading, spacing: 10) {
-        WorkSessionHeader(
-          session: session,
-          chatSummary: nil,
-          transitionNamespace: transitionNamespace,
-          onOpenLane: onOpenLane
-        )
-
-        if terminalDisplay.truncated {
-          ADENoticeCard(
-            title: "Showing recent output",
-            message: "Older terminal output is hidden on iPhone so this session stays responsive.",
-            icon: "text.line.last.and.arrowtriangle.forward",
-            tint: ADEColor.accent,
-            actionTitle: nil,
-            action: nil
-          )
-        }
-      }
-      .padding(.horizontal, 16)
-      .padding(.top, 10)
-      .padding(.bottom, 8)
-      .background(.ultraThinMaterial)
+      laneStrip
 
       GeometryReader { proxy in
         ScrollView([.horizontal, .vertical]) {
-          Text(renderedText.isEmpty ? "  " : renderedText)
-            .font(.system(size: 12, weight: .regular, design: .monospaced))
-            .foregroundStyle(ADEColor.textPrimary)
+          Text(renderedText)
             .textSelection(.enabled)
-            .padding(.horizontal, 14)
-            .padding(.vertical, 12)
+            .padding(.horizontal, 12)
+            .padding(.vertical, 8)
             .fixedSize(horizontal: true, vertical: false)
             .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
         }
-        .background(ADEColor.recessedBackground.opacity(0.96))
+        .background(Color.black)
         .scrollIndicators(.visible)
-        .onAppear {
-          sendTerminalResize(for: proxy.size)
-        }
-        .onChange(of: proxy.size) { _, newSize in
-          sendTerminalResize(for: newSize)
-        }
-        .onChange(of: syncService.connectionState) { _, _ in
-          sendTerminalResize(for: proxy.size)
+        .overlay(alignment: .topTrailing) {
+          if terminalDisplay.truncated {
+            Image(systemName: "text.line.last.and.arrowtriangle.forward")
+              .font(.system(size: 10, weight: .semibold))
+              .foregroundStyle(ADEColor.textMuted)
+              .padding(6)
+              .accessibilityLabel("Older output truncated for performance")
+          }
         }
+        .onAppear { sendTerminalResize(for: proxy.size) }
+        .onChange(of: proxy.size) { _, newSize in sendTerminalResize(for: newSize) }
+        .onChange(of: syncService.connectionState) { _, _ in sendTerminalResize(for: proxy.size) }
       }
 
+      terminalKeyBar
       terminalInputBar
     }
     .adeScreenBackground()
@@ -221,87 +204,151 @@ struct WorkTerminalSessionView: View {
     }
   }
 
-  /// Bottom input bar. Sends the typed text plus a newline so shells run it
-  /// as a command. `^C` button sends raw 0x03 to interrupt the foreground
-  /// process. Not a full keyboard yet — the long-term plan is to host a
-  /// SwiftTerm view that captures every keystroke directly.
-  private var terminalInputBar: some View {
+  /// Slim, transparent context strip — no material backplate, no padding bloat.
+  /// Keeps the lane + relative time visible without stealing rows from the
+  /// terminal scrollback.
+  private var laneStrip: some View {
     HStack(spacing: 8) {
-      Button {
-        // Send Ctrl-C (0x03) so users can interrupt a runaway process from
-        // the phone without having to switch back to the desktop.
-        syncService.sendTerminalInput(sessionId: session.id, data: "\u{03}")
-        sendingFeedback &+= 1
-      } label: {
-        Text("^C")
-          .font(.system(size: 11, weight: .bold, design: .monospaced))
-          .foregroundStyle(ADEColor.danger)
-          .frame(width: 36, height: 32)
-      }
-      .buttonStyle(.plain)
-      .background(ADEColor.danger.opacity(0.12), in: RoundedRectangle(cornerRadius: 8, style: .continuous))
-      .glassEffect(in: .rect(cornerRadius: 8))
-      .overlay(
-        RoundedRectangle(cornerRadius: 8, style: .continuous)
-          .stroke(ADEColor.danger.opacity(0.32), lineWidth: 0.6)
+      WorkSessionHeader(
+        session: session,
+        chatSummary: nil,
+        transitionNamespace: transitionNamespace,
+        onOpenLane: onOpenLane
       )
-      .accessibilityLabel("Send Ctrl-C")
-      .disabled(!canSendInput)
+    }
+    .padding(.horizontal, 12)
+    .padding(.top, 4)
+    .padding(.bottom, 6)
+  }
 
-      TextField("Send command…", text: $pendingCommand)
+  /// Termius-style modifier/key strip. Horizontal scroll so we can grow it
+  /// without crowding the input row. Tapping any chip sends the matching
+  /// raw bytes through the existing terminal input channel.
+  private var terminalKeyBar: some View {
+    ScrollView(.horizontal, showsIndicators: false) {
+      HStack(spacing: 6) {
+        keyChip("Esc", send: "\u{1B}")
+        keyChip("Tab", send: "\t")
+        keyChip("↑", send: "\u{1B}[A")
+        keyChip("↓", send: "\u{1B}[B")
+        keyChip("←", send: "\u{1B}[D")
+        keyChip("→", send: "\u{1B}[C")
+        keyChip("^C", send: "\u{03}", tint: ADEColor.danger)
+        keyChip("^D", send: "\u{04}")
+        keyChip("^Z", send: "\u{1A}")
+        keyChip("^L", send: "\u{0C}")
+        keyChip("^R", send: "\u{12}")
+        keyChip("^U", send: "\u{15}")
+        keyChip("^A", send: "\u{01}")
+        keyChip("^E", send: "\u{05}")
+        keyChip("^K", send: "\u{0B}")
+        keyChip("|", send: "|")
+        keyChip("~", send: "~")
+        keyChip("/", send: "/")
+        keyChip("-", send: "-")
+      }
+      .padding(.horizontal, 10)
+      .padding(.vertical, 6)
+    }
+    .background(ADEColor.recessedBackground.opacity(0.85))
+    .overlay(alignment: .top) {
+      Rectangle().fill(ADEColor.glassBorder).frame(height: 0.5)
+    }
+    .disabled(!canSendInput)
+    .opacity(canSendInput ? 1 : 0.4)
+  }
+
+  @ViewBuilder
+  private func keyChip(_ label: String, send data: String, tint: Color? = nil) -> some View {
+    Button {
+      syncService.sendTerminalInput(sessionId: session.id, data: data)
+      sendingFeedback &+= 1
+    } label: {
+      Text(label)
+        .font(.system(size: 12, weight: .semibold, design: .monospaced))
+        .foregroundStyle(tint ?? ADEColor.textPrimary)
+        .frame(minWidth: 32, minHeight: 28)
+        .padding(.horizontal, 8)
+        .background(
+          (tint ?? ADEColor.textPrimary).opacity(tint == nil ? 0.06 : 0.12),
+          in: RoundedRectangle(cornerRadius: 6, style: .continuous)
+        )
+        .overlay(
+          RoundedRectangle(cornerRadius: 6, style: .continuous)
+            .stroke((tint ?? ADEColor.border).opacity(0.28), lineWidth: 0.6)
+        )
+    }
+    .buttonStyle(.plain)
+  }
+
+  /// Slim composer. Each typed character streams straight to the PTY and we
+  /// then clear the field so it acts as a keyboard mount, not a buffer. The
+  /// `↵` button (and keyboard Return) explicitly send `\r` so the remote
+  /// shell submits — works for plain shells AND for TUI prompts that read
+  /// input character-by-character.
+  private var terminalInputBar: some View {
+    HStack(spacing: 8) {
+      TextField("Type to send keystrokes", text: $inputBuffer)
         .textInputAutocapitalization(.never)
         .autocorrectionDisabled()
-        .submitLabel(.send)
+        .submitLabel(.return)
         .focused($inputFocused)
         .font(.system(size: 13, design: .monospaced))
         .padding(.horizontal, 10)
-        .padding(.vertical, 8)
+        .padding(.vertical, 7)
         .frame(minHeight: 32)
         .frame(maxWidth: .infinity)
-        .background(ADEColor.surfaceBackground.opacity(0.6), in: RoundedRectangle(cornerRadius: 10, style: .continuous))
-        .glassEffect(in: .rect(cornerRadius: 10))
+        .background(ADEColor.surfaceBackground.opacity(0.55), in: RoundedRectangle(cornerRadius: 9, style: .continuous))
         .overlay(
-          RoundedRectangle(cornerRadius: 10, style: .continuous)
+          RoundedRectangle(cornerRadius: 9, style: .continuous)
             .stroke(ADEColor.glassBorder, lineWidth: 0.5)
         )
-        .onSubmit { submitCommand() }
+        .onChange(of: inputBuffer) { _, newValue in
+          guard !newValue.isEmpty, canSendInput else {
+            if !newValue.isEmpty { inputBuffer = "" }
+            return
+          }
+          syncService.sendTerminalInput(sessionId: session.id, data: newValue)
+          inputBuffer = ""
+        }
+        .onSubmit { submitReturn() }
         .disabled(!canSendInput)
 
-      Button(action: submitCommand) {
-        Image(systemName: "paperplane.fill")
-          .font(.system(size: 13, weight: .semibold))
-          .foregroundStyle(canSendInput && !pendingCommand.isEmpty ? ADEColor.accent : ADEColor.textMuted)
-          .frame(width: 32, height: 32)
+      Button(action: submitReturn) {
+        Image(systemName: "return")
+          .font(.system(size: 14, weight: .semibold))
+          .foregroundStyle(canSendInput ? ADEColor.accent : ADEColor.textMuted)
+          .frame(width: 36, height: 32)
       }
       .buttonStyle(.plain)
       .background(
-        (canSendInput && !pendingCommand.isEmpty ? ADEColor.accent.opacity(0.14) : ADEColor.surfaceBackground.opacity(0.5)),
-        in: RoundedRectangle(cornerRadius: 10, style: .continuous)
+        (canSendInput ? ADEColor.accent.opacity(0.14) : ADEColor.surfaceBackground.opacity(0.5)),
+        in: RoundedRectangle(cornerRadius: 9, style: .continuous)
       )
-      .glassEffect(in: .rect(cornerRadius: 10))
       .overlay(
-        RoundedRectangle(cornerRadius: 10, style: .continuous)
+        RoundedRectangle(cornerRadius: 9, style: .continuous)
           .stroke(ADEColor.glassBorder, lineWidth: 0.5)
       )
-      .accessibilityLabel("Send command")
-      .disabled(!canSendInput || pendingCommand.isEmpty)
+      .accessibilityLabel("Send Return")
+      .disabled(!canSendInput)
     }
-    .padding(.horizontal, 12)
-    .padding(.vertical, 10)
+    .padding(.horizontal, 10)
+    .padding(.vertical, 8)
     .background(.ultraThinMaterial)
     .overlay(alignment: .top) {
-      Rectangle()
-        .fill(ADEColor.glassBorder)
-        .frame(height: 0.5)
+      Rectangle().fill(ADEColor.glassBorder).frame(height: 0.5)
     }
   }
 
-  private func submitCommand() {
-    let trimmed = pendingCommand.trimmingCharacters(in: .whitespacesAndNewlines)
-    guard !trimmed.isEmpty, canSendInput else { return }
-    syncService.sendTerminalInput(sessionId: session.id, data: trimmed + "\r")
-    pendingCommand = ""
+  private func submitReturn() {
+    guard canSendInput else { return }
+    if !inputBuffer.isEmpty {
+      syncService.sendTerminalInput(sessionId: session.id, data: inputBuffer)
+      inputBuffer = ""
+    }
+    syncService.sendTerminalInput(sessionId: session.id, data: "\r")
     sendingFeedback &+= 1
+    inputFocused = true
   }
 
   private func sendTerminalResize(for size: CGSize) {
@@ -327,33 +374,6 @@ private struct TerminalViewportSize: Equatable {
   }
 }
 
-/// Strip the ANSI escape sequences most commonly emitted by interactive
-/// CLIs (colours, cursor moves, OSC titles, simple alt-screen toggles) so a
-/// plain `Text` renderer reads cleanly. This is intentionally narrow: a
-/// real terminal emulator (SwiftTerm) is the right home for full handling.
-func workTerminalStripAnsi(_ input: String) -> String {
-  guard !input.isEmpty else { return input }
-  // CSI: ESC [ ... letter
-  var output = input.replacingOccurrences(
-    of: "\u{1B}\\[[0-?]*[ -/]*[@-~]",
-    with: "",
-    options: .regularExpression
-  )
-  // OSC: ESC ] ... BEL  or  ESC ] ... ESC \
-  output = output.replacingOccurrences(
-    of: "\u{1B}\\][^\u{07}]*?(?:\u{07}|\u{1B}\\\\)",
-    with: "",
-    options: .regularExpression
-  )
-  // Bare single-char escapes (cursor save/restore etc.)
-  output = output.replacingOccurrences(
-    of: "\u{1B}[=>78cDEHMNOP\\\\]",
-    with: "",
-    options: .regularExpression
-  )
-  return output
-}
-
 struct WorkFullscreenImageView: View {
   @Environment(\.dismiss) var dismiss
   let image: WorkFullscreenImage
diff --git a/apps/ios/ADE/Views/Work/WorkBrowserHelpers.swift b/apps/ios/ADE/Views/Work/WorkBrowserHelpers.swift
index 8bea77afd..bf6ab0c73 100644
--- a/apps/ios/ADE/Views/Work/WorkBrowserHelpers.swift
+++ b/apps/ios/ADE/Views/Work/WorkBrowserHelpers.swift
@@ -83,18 +83,6 @@ func workFilteredSessions(
     .sorted { compareWorkSessionSortOrder($0, $1, chatSummaries: chatSummaries) }
 }
 
-func workActivitySourceSessions(
-  _ displaySessions: [TerminalSessionSummary],
-  chatSummaries: [String: AgentChatSessionSummary],
-  archivedSessionIds: Set<String>
-) -> [TerminalSessionSummary] {
-  displaySessions.filter { session in
-    !archivedSessionIds.contains(session.id)
-      && isChatSession(session)
-      && normalizedWorkChatSessionStatus(session: session, summary: chatSummaries[session.id]) != "ended"
-  }
-}
-
 func workRunningBannerLiveCounts(_ liveSessions: [TerminalSessionSummary]) -> (chat: Int, terminal: Int) {
   let chatCount = liveSessions.filter(isChatSession).count
   return (chat: chatCount, terminal: max(0, liveSessions.count - chatCount))
diff --git a/apps/ios/ADE/Views/Work/WorkModels.swift b/apps/ios/ADE/Views/Work/WorkModels.swift
index 6d5362681..5735f6552 100644
--- a/apps/ios/ADE/Views/Work/WorkModels.swift
+++ b/apps/ios/ADE/Views/Work/WorkModels.swift
@@ -2,25 +2,6 @@ import SwiftUI
 import UIKit
 import AVKit
 
-struct WorkAgentActivityContext: Equatable {
-  let sessionId: String
-  let title: String
-  let laneName: String
-  let status: String
-  let startedAt: String
-}
-
-struct WorkAgentActivity: Identifiable, Equatable {
-  var id: String { "\(sessionId):\(taskId ?? "session")" }
-  let sessionId: String
-  let taskId: String?
-  let agentName: String
-  let toolName: String?
-  let laneName: String
-  let startedAt: String
-  let detail: String?
-}
-
 enum WorkToolCardStatus: String, Equatable {
   case running
   case completed
diff --git a/apps/ios/ADE/Views/Work/WorkNavigationAndTranscriptHelpers.swift b/apps/ios/ADE/Views/Work/WorkNavigationAndTranscriptHelpers.swift
index 814f0500a..951ac05d0 100644
--- a/apps/ios/ADE/Views/Work/WorkNavigationAndTranscriptHelpers.swift
+++ b/apps/ios/ADE/Views/Work/WorkNavigationAndTranscriptHelpers.swift
@@ -2,44 +2,31 @@ import SwiftUI
 import UIKit
 import AVKit
 
-struct WorkActivityTranscriptCacheEntry {
-  let fingerprint: String
-  let transcript: [WorkChatEnvelope]
-}
-
 struct WorkTerminalDisplay {
   let text: String
+  let attributedText: AttributedString
   let truncated: Bool
 }
 
 private let workTerminalDisplayMaxCharacters = 24_000
 
-/// Cheap, deterministic fingerprint for a terminal buffer. We intentionally avoid hashing the whole
-/// string on every `localStateRevision` tick — length + short head/tail windows give us >99% stability
-/// against spurious cache invalidations while still changing whenever new output actually arrives.
-func workActivityBufferFingerprint(_ buffer: String) -> String {
-  if buffer.isEmpty {
-    return "0:"
-  }
-  let count = buffer.utf8.count
-  let headLen = min(64, buffer.count)
-  let tailLen = min(64, buffer.count)
-  let head = buffer.prefix(headLen)
-  let tail = buffer.suffix(tailLen)
-  var hasher = Hasher()
-  hasher.combine(head)
-  hasher.combine(tail)
-  return "\(count):\(hasher.finalize())"
-}
-
 func workTerminalDisplay(raw: String?, fallback: String?) -> WorkTerminalDisplay {
   let source = (raw?.isEmpty == false ? raw : fallback) ?? "No output yet."
-  let sanitized = sanitizeTerminalOutputForDisplay(source)
+  let replay = WorkTerminalTextReplay()
+  replay.write(source)
+  let replayText = replay.text
+  let sanitized = collapseDuplicatedWorkStreamTextIfNeeded(replayText)
   guard sanitized.count > workTerminalDisplayMaxCharacters else {
-    return WorkTerminalDisplay(text: sanitized, truncated: false)
+    return WorkTerminalDisplay(
+      text: sanitized,
+      attributedText: sanitized == replayText ? replay.attributedText() : workTerminalPlainAttributedString(sanitized),
+      truncated: false
+    )
   }
+  let displayText = String(sanitized.suffix(workTerminalDisplayMaxCharacters))
   return WorkTerminalDisplay(
-    text: String(sanitized.suffix(workTerminalDisplayMaxCharacters)),
+    text: displayText,
+    attributedText: workTerminalPlainAttributedString(displayText),
     truncated: true
   )
 }
@@ -51,17 +38,35 @@ func sanitizeTerminalOutputForDisplay(_ input: String) -> String {
 }
 
 private final class WorkTerminalTextReplay {
-  private var lines: [[UnicodeScalar]] = [[]]
+  private var lines: [[WorkTerminalCell]] = [[]]
   private var row = 0
   private var column = 0
+  private var foreground: WorkANSIColor?
+  private var bold = false
 
   var text: String {
-    lines
-      .map { String(String.UnicodeScalarView($0)).trimmingTrailingTerminalPadding() }
+    renderedLines()
+      .map { String(String.UnicodeScalarView($0.map(\.scalar))) }
       .joined(separator: "\n")
       .trimmingCharacters(in: .whitespacesAndNewlines)
   }
 
+  func attributedText() -> AttributedString {
+    let renderedLines = renderedLines(trimEmptyEdges: true)
+    guard !renderedLines.isEmpty else {
+      return workTerminalPlainAttributedString("")
+    }
+
+    var attributed = AttributedString("")
+    for lineIndex in renderedLines.indices {
+      if lineIndex > renderedLines.startIndex {
+        attributed.append(workTerminalPlainAttributedString("\n"))
+      }
+      attributed.append(attributedLine(renderedLines[lineIndex]))
+    }
+    return attributed
+  }
+
   func write(_ input: String) {
     let scalars = Array(input.unicodeScalars)
     var index = scalars.startIndex
@@ -96,12 +101,13 @@ private final class WorkTerminalTextReplay {
   private func put(_ scalar: UnicodeScalar) {
     ensureCursor()
     while lines[row].count < column {
-      lines[row].append(" ")
+      lines[row].append(WorkTerminalCell(scalar: " "))
     }
+    let cell = WorkTerminalCell(scalar: scalar, foreground: foreground, bold: bold)
     if column < lines[row].count {
-      lines[row][column] = scalar
+      lines[row][column] = cell
     } else {
-      lines[row].append(scalar)
+      lines[row].append(cell)
     }
     column += 1
   }
@@ -132,6 +138,8 @@ private final class WorkTerminalTextReplay {
       lines = [[]]
       row = 0
       column = 0
+      foreground = nil
+      bold = false
     case "(", ")", "*", "+":
       if index < scalars.endIndex {
         index = scalars.index(after: index)
@@ -199,7 +207,7 @@ private final class WorkTerminalTextReplay {
     case "K":
       ensureCursor()
       if first == 1 {
-        let space: UnicodeScalar = " "
+        let space = WorkTerminalCell(scalar: " ")
         let endIndex = min(column + 1, lines[row].count)
         for index in 0..<endIndex {
           lines[row][index] = space
@@ -215,10 +223,186 @@ private final class WorkTerminalTextReplay {
       } else if column < lines[row].count {
         lines[row].removeSubrange(column..<lines[row].count)
       }
+    case "m":
+      applySGR(params)
     default:
       break
     }
   }
+
+  private func applySGR(_ rawParams: [Int]) {
+    let params = rawParams.isEmpty ? [0] : rawParams
+    var index = params.startIndex
+    while index < params.endIndex {
+      let code = params[index]
+      switch code {
+      case 0:
+        foreground = nil
+        bold = false
+      case 1:
+        bold = true
+      case 22:
+        bold = false
+      case 30, 90:
+        foreground = .black
+      case 31, 91:
+        foreground = .red
+      case 32, 92:
+        foreground = .green
+      case 33, 93:
+        foreground = .yellow
+      case 34, 94:
+        foreground = .blue
+      case 35, 95:
+        foreground = .magenta
+      case 36, 96:
+        foreground = .cyan
+      case 37, 97:
+        foreground = .white
+      case 38:
+        if index + 2 < params.endIndex, params[index + 1] == 5 {
+          foreground = workTerminalANSI256Color(params[index + 2])
+          index += 2
+        } else if index + 4 < params.endIndex, params[index + 1] == 2 {
+          foreground = workTerminalRGBColor(red: params[index + 2], green: params[index + 3], blue: params[index + 4])
+          index += 4
+        }
+      case 39:
+        foreground = nil
+      default:
+        break
+      }
+      index += 1
+    }
+  }
+
+  private func renderedLines(trimEmptyEdges: Bool = false) -> [[WorkTerminalCell]] {
+    var rendered = lines.map { line in
+      var trimmed = line
+      while let last = trimmed.last, CharacterSet.whitespaces.contains(last.scalar) {
+        trimmed.removeLast()
+      }
+      return trimmed
+    }
+
+    if trimEmptyEdges {
+      while rendered.first?.isEmpty == true {
+        rendered.removeFirst()
+      }
+      while rendered.last?.isEmpty == true {
+        rendered.removeLast()
+      }
+    }
+    return rendered
+  }
+
+  private func attributedLine(_ line: [WorkTerminalCell]) -> AttributedString {
+    var attributed = AttributedString("")
+    var index = line.startIndex
+    while index < line.endIndex {
+      let start = index
+      let style = line[start].style
+      index = line.index(after: index)
+      while index < line.endIndex, line[index].style == style {
+        index = line.index(after: index)
+      }
+      let text = String(String.UnicodeScalarView(line[start..<index].map(\.scalar)))
+      attributed.append(workTerminalAttributedString(text, foreground: style.foreground, bold: style.bold))
+    }
+    return attributed
+  }
+}
+
+private struct WorkTerminalCell {
+  let scalar: UnicodeScalar
+  let foreground: WorkANSIColor?
+  let bold: Bool
+
+  init(scalar: UnicodeScalar, foreground: WorkANSIColor? = nil, bold: Bool = false) {
+    self.scalar = scalar
+    self.foreground = foreground
+    self.bold = bold
+  }
+
+  var style: WorkTerminalCellStyle {
+    WorkTerminalCellStyle(foreground: foreground, bold: bold)
+  }
+}
+
+private struct WorkTerminalCellStyle: Equatable {
+  let foreground: WorkANSIColor?
+  let bold: Bool
+}
+
+func workTerminalPlainAttributedString(_ text: String, fontSize: CGFloat = 12) -> AttributedString {
+  workTerminalAttributedString(text, foreground: nil, bold: false, fontSize: fontSize)
+}
+
+private func workTerminalAttributedString(
+  _ text: String,
+  foreground: WorkANSIColor?,
+  bold: Bool,
+  fontSize: CGFloat = 12
+) -> AttributedString {
+  var attributed = AttributedString(text)
+  attributed.font = .system(size: fontSize, weight: bold ? .semibold : .regular, design: .monospaced)
+  attributed.foregroundColor = workTerminalForegroundColor(foreground)
+  return attributed
+}
+
+private func workTerminalForegroundColor(_ color: WorkANSIColor?) -> Color {
+  switch color {
+  case .red: return .red
+  case .green: return .green
+  case .yellow: return .yellow
+  case .blue: return .blue
+  case .magenta: return .purple
+  case .cyan: return .cyan
+  case .white: return .white
+  case .black: return ADEColor.textMuted
+  case .none: return ADEColor.textPrimary
+  }
+}
+
+private func workTerminalANSI256Color(_ code: Int) -> WorkANSIColor? {
+  switch code {
+  case 0, 8: return .black
+  case 1, 9: return .red
+  case 2, 10: return .green
+  case 3, 11: return .yellow
+  case 4, 12: return .blue
+  case 5, 13: return .magenta
+  case 6, 14: return .cyan
+  case 7, 15: return .white
+  case 16...231:
+    let value = code - 16
+    let red = value / 36
+    let green = (value / 6) % 6
+    let blue = value % 6
+    return workTerminalRGBColor(red: red * 51, green: green * 51, blue: blue * 51)
+  case 232...255:
+    return code >= 244 ? .white : .black
+  default:
+    return nil
+  }
+}
+
+private func workTerminalRGBColor(red: Int, green: Int, blue: Int) -> WorkANSIColor? {
+  let red = max(0, min(255, red))
+  let green = max(0, min(255, green))
+  let blue = max(0, min(255, blue))
+  let maxChannel = max(red, green, blue)
+  let minChannel = min(red, green, blue)
+  guard maxChannel >= 80 else { return .black }
+  if maxChannel - minChannel < 32 {
+    return maxChannel > 180 ? .white : nil
+  }
+  if red == maxChannel && green == maxChannel { return .yellow }
+  if green == maxChannel && blue == maxChannel { return .cyan }
+  if red == maxChannel && blue == maxChannel { return .magenta }
+  if red == maxChannel { return .red }
+  if green == maxChannel { return .green }
+  return .blue
 }
 
 private extension String {
@@ -527,67 +711,6 @@ func buildWorkToolCards(
   return orderedIds.compactMap { cards[$0] }
 }
 
-func deriveWorkAgentActivities(from transcript: [WorkChatEnvelope], session: WorkAgentActivityContext) -> [WorkAgentActivity] {
-  var activeSubagents: [String: WorkAgentActivity] = [:]
-  let toolCards = buildWorkToolCards(from: transcript)
-  let runningTool = toolCards.last(where: { $0.status == .running })
-
-  for envelope in transcript {
-    switch envelope.event {
-    case .subagentStarted(let taskId, let description, _, _):
-      activeSubagents[taskId] = WorkAgentActivity(
-        sessionId: session.sessionId,
-        taskId: taskId,
-        agentName: description.isEmpty ? session.title : description,
-        toolName: nil,
-        laneName: session.laneName,
-        startedAt: envelope.timestamp,
-        detail: nil
-      )
-    case .subagentProgress(let taskId, let description, let summary, let toolName, _):
-      let existing = activeSubagents[taskId]
-      activeSubagents[taskId] = WorkAgentActivity(
-        sessionId: session.sessionId,
-        taskId: taskId,
-        agentName: description ?? existing?.agentName ?? session.title,
-        toolName: toolName ?? existing?.toolName,
-        laneName: session.laneName,
-        startedAt: existing?.startedAt ?? envelope.timestamp,
-        detail: summary
-      )
-    case .subagentResult(let taskId, _, _, _):
-      activeSubagents.removeValue(forKey: taskId)
-    default:
-      continue
-    }
-  }
-
-  let subagents = activeSubagents.values.sorted { $0.startedAt > $1.startedAt }
-  if !subagents.isEmpty {
-    return subagents
-  }
-
-  guard session.status == "active" else { return [] }
-  let latestActivityDetail = transcript.reversed().compactMap { envelope -> String? in
-    switch envelope.event {
-    case .activity(_, let detail, _): return detail
-    case .reasoning(let text, _, _, _): return text
-    case .status(_, let message, _): return message
-    default: return nil
-    }
-  }.first
-
-  return [WorkAgentActivity(
-    sessionId: session.sessionId,
-    taskId: nil,
-    agentName: session.title,
-    toolName: runningTool?.toolName,
-    laneName: session.laneName,
-    startedAt: runningTool?.startedAt ?? session.startedAt,
-    detail: latestActivityDetail
-  )]
-}
-
 func parseANSISegments(_ input: String) -> [ANSISegment] {
   var segments: [ANSISegment] = []
   var buffer = ""
diff --git a/apps/ios/ADE/Views/Work/WorkRootComponents.swift b/apps/ios/ADE/Views/Work/WorkRootComponents.swift
index 9a46c7d9d..de4e2b63c 100644
--- a/apps/ios/ADE/Views/Work/WorkRootComponents.swift
+++ b/apps/ios/ADE/Views/Work/WorkRootComponents.swift
@@ -784,49 +784,6 @@ struct WorkSessionRow: View {
   }
 }
 
-struct WorkActivityRow: View {
-  @Environment(\.accessibilityReduceMotion) var reduceMotion
-
-  let activity: WorkAgentActivity
-  var animatesPulse: Bool = true
-  @State var pulse = false
-
-  var body: some View {
-    HStack(spacing: 12) {
-      Circle()
-        .fill(ADEColor.success)
-        .frame(width: 10, height: 10)
-        .scaleEffect(animatesPulse && pulse && !reduceMotion ? 1.25 : 1.0)
-        .animation(animatesPulse ? ADEMotion.pulse(reduceMotion: reduceMotion) : nil, value: pulse)
-        .onAppear {
-          guard !reduceMotion, animatesPulse else { return }
-          pulse = true
-        }
-      VStack(alignment: .leading, spacing: 4) {
-        Text(activity.agentName)
-          .font(.subheadline.weight(.semibold))
-          .foregroundStyle(ADEColor.textPrimary)
-        Text("\(activity.laneName) · \(activity.toolName ?? "Waiting")")
-          .font(.caption.monospaced())
-          .foregroundStyle(ADEColor.textSecondary)
-        if let detail = activity.detail, !detail.isEmpty {
-          Text(detail)
-            .font(.caption)
-            .foregroundStyle(ADEColor.textMuted)
-            .lineLimit(1)
-        }
-      }
-      Spacer()
-      Text(formattedSessionDuration(startedAt: activity.startedAt, endedAt: nil))
-        .font(.caption2.monospacedDigit())
-        .foregroundStyle(ADEColor.textMuted)
-    }
-    .adeListCard()
-    .accessibilityElement(children: .combine)
-    .accessibilityLabel("\(activity.agentName), \(activity.laneName), \(activity.toolName ?? "Waiting")")
-  }
-}
-
 struct WorkTag: View {
   let text: String
   let icon: String
diff --git a/apps/ios/ADE/Views/Work/WorkRootScreen+Actions.swift b/apps/ios/ADE/Views/Work/WorkRootScreen+Actions.swift
index fbeb4951d..d839ad8d3 100644
--- a/apps/ios/ADE/Views/Work/WorkRootScreen+Actions.swift
+++ b/apps/ios/ADE/Views/Work/WorkRootScreen+Actions.swift
@@ -2,72 +2,6 @@ import SwiftUI
 import UIKit
 import AVKit
 
-func buildWorkActivityFeed(
-  sources: [TerminalSessionSummary],
-  transcriptCache: [String: [WorkChatEnvelope]],
-  terminalBuffers: [String: String],
-  existingCache: [String: WorkActivityTranscriptCacheEntry],
-  chatSummaries: [String: AgentChatSessionSummary]
-) -> (activities: [WorkAgentActivity], cache: [String: WorkActivityTranscriptCacheEntry]) {
-  var nextCache: [String: WorkActivityTranscriptCacheEntry] = [:]
-  nextCache.reserveCapacity(sources.count)
-  var activities: [WorkAgentActivity] = []
-
-  for session in sources {
-    let transcript: [WorkChatEnvelope]
-    if let streamed = transcriptCache[session.id] {
-      transcript = streamed
-    } else {
-      let buffer = terminalBuffers[session.id] ?? ""
-      let fingerprint = workActivityBufferFingerprint(buffer)
-      if let existing = existingCache[session.id], existing.fingerprint == fingerprint {
-        transcript = existing.transcript
-        nextCache[session.id] = existing
-      } else {
-        let parsed = parseWorkChatTranscript(buffer)
-        transcript = parsed
-        nextCache[session.id] = WorkActivityTranscriptCacheEntry(fingerprint: fingerprint, transcript: parsed)
-      }
-    }
-
-    activities.append(contentsOf: deriveWorkAgentActivities(
-      from: transcript,
-      session: WorkAgentActivityContext(
-        sessionId: session.id,
-        title: session.title,
-        laneName: session.laneName,
-        status: normalizedWorkChatSessionStatus(session: session, summary: chatSummaries[session.id]),
-        startedAt: session.startedAt
-      )
-    ))
-  }
-
-  activities.sort { lhs, rhs in
-    if lhs.startedAt == rhs.startedAt {
-      return lhs.agentName < rhs.agentName
-    }
-    return lhs.startedAt > rhs.startedAt
-  }
-
-  return (activities, nextCache)
-}
-
-func workActivityTranscriptCachesEqual(
-  _ lhs: [String: WorkActivityTranscriptCacheEntry],
-  _ rhs: [String: WorkActivityTranscriptCacheEntry]
-) -> Bool {
-  guard lhs.count == rhs.count else { return false }
-  for (key, value) in lhs {
-    guard let other = rhs[key],
-      value.fingerprint == other.fingerprint,
-      value.transcript == other.transcript
-    else {
-      return false
-    }
-  }
-  return true
-}
-
 extension WorkRootScreen {
   @MainActor
   func scheduleSessionPresentationRebuild() {
@@ -231,6 +165,7 @@ extension WorkRootScreen {
     if chatSummaries != nextSummaries {
       chatSummaries = nextSummaries
     }
+    syncService.cacheChatSummaries(nextSummaries)
   }
 
   @MainActor
@@ -264,59 +199,6 @@ extension WorkRootScreen {
     }
   }
 
-  /// Rebuilds `activityFeedEntries` from cached transcripts, reusing any prior parse whose buffer
-  /// fingerprint is unchanged. Only sessions without a streamed `transcriptCache` entry fall back to
-  /// parsing the terminal buffer, and that parse is memoized in `activityTranscriptCache`.
-  @MainActor
-  func rebuildActivityFeed() {
-    let sources = activitySessions
-    guard !sources.isEmpty else {
-      activityFeedRebuildTask?.cancel()
-      activityFeedRebuildTask = nil
-      if !activityFeedEntries.isEmpty {
-        activityFeedEntries = []
-      }
-      if !activityTranscriptCache.isEmpty {
-        activityTranscriptCache = [:]
-      }
-      return
-    }
-
-    activityFeedRebuildTask?.cancel()
-    activityFeedRebuildGeneration += 1
-    let generation = activityFeedRebuildGeneration
-    let transcriptSnapshot = transcriptCache
-    let terminalBufferSnapshot = syncService.terminalBuffers
-    let existingCache = activityTranscriptCache
-    let chatSummarySnapshot = chatSummaries
-
-    activityFeedRebuildTask = Task(priority: .utility) {
-      let result = buildWorkActivityFeed(
-        sources: sources,
-        transcriptCache: transcriptSnapshot,
-        terminalBuffers: terminalBufferSnapshot,
-        existingCache: existingCache,
-        chatSummaries: chatSummarySnapshot
-      )
-      await MainActor.run {
-        guard generation == activityFeedRebuildGeneration, !Task.isCancelled else { return }
-        if activityFeedEntries != result.activities {
-          activityFeedEntries = result.activities
-        }
-        if !workActivityTranscriptCachesEqual(activityTranscriptCache, result.cache) {
-          activityTranscriptCache = result.cache
-        }
-        activityFeedRebuildTask = nil
-      }
-    }
-  }
-
-  @MainActor
-  func cancelActivityFeedRebuild() {
-    activityFeedRebuildTask?.cancel()
-    activityFeedRebuildTask = nil
-  }
-
   func toggleArchive(_ session: TerminalSessionSummary) {
     Task {
       do {
@@ -386,6 +268,7 @@ extension WorkRootScreen {
       if var summary = chatSummaries[renameTarget.id] {
         summary.title = trimmedTitle
         chatSummaries[renameTarget.id] = summary
+        syncService.cacheChatSummary(summary)
       }
       if var session = optimisticSessions[renameTarget.id] {
         session.title = trimmedTitle
diff --git a/apps/ios/ADE/Views/Work/WorkRootScreen.swift b/apps/ios/ADE/Views/Work/WorkRootScreen.swift
index 56b08dc6f..19ad19aa6 100644
--- a/apps/ios/ADE/Views/Work/WorkRootScreen.swift
+++ b/apps/ios/ADE/Views/Work/WorkRootScreen.swift
@@ -40,12 +40,6 @@ struct WorkRootScreen: View {
   @State var sessionPresentation = WorkRootSessionPresentation.empty
   @State var sessionPresentationRebuildTask: Task<Void, Never>?
   @State var sessionPresentationRebuildGeneration = 0
-  /// Memoizes parsed transcripts for the Activity feed keyed by session id + cheap buffer fingerprint,
-  /// so `localStateRevision` bumps during CRDT sync do not re-parse every terminal buffer in `body`.
-  @State var activityTranscriptCache: [String: WorkActivityTranscriptCacheEntry] = [:]
-  @State var activityFeedEntries: [WorkAgentActivity] = []
-  @State var activityFeedRebuildTask: Task<Void, Never>?
-  @State var activityFeedRebuildGeneration = 0
   @State var errorMessage: String?
   @State var path = NavigationPath()
   @State var searchText = ""
@@ -116,10 +110,6 @@ struct WorkRootScreen: View {
     sessionPresentation.liveChatSessions
   }
 
-  var activitySessions: [TerminalSessionSummary] {
-    sessionPresentation.activitySessions
-  }
-
   var hasActiveFilters: Bool {
     selectedStatus != .all
       || selectedLaneId != "all"
@@ -181,10 +171,6 @@ struct WorkRootScreen: View {
     sessionPresentation.sessionGroups
   }
 
-  var activityFeed: [WorkAgentActivity] {
-    activityFeedEntries
-  }
-
   var isWorkRootActive: Bool {
     isTabActive && path.isEmpty
   }
@@ -207,23 +193,6 @@ struct WorkRootScreen: View {
     isWorkRootActive ? syncService.localStateRevision : nil
   }
 
-  /// Composite fingerprint that changes only when the Activity feed actually needs to rebuild.
-  /// Built from the activity session ids, their streamed transcript counts, and a cheap buffer
-  /// fingerprint so typical `localStateRevision` bumps do not trigger a rebuild.
-  var activityFeedFingerprint: String {
-    guard isWorkRootActive else { return "paused" }
-    var parts: [String] = []
-    parts.reserveCapacity(activitySessions.count)
-    for session in activitySessions {
-      let streamedCount = transcriptCache[session.id]?.count ?? -1
-      let buffer = syncService.terminalBuffers[session.id] ?? ""
-      let bufferFingerprint = workActivityBufferFingerprint(buffer)
-      let status = normalizedWorkChatSessionStatus(session: session, summary: chatSummaries[session.id])
-      parts.append("\(session.id):\(streamedCount):\(bufferFingerprint):\(status)")
-    }
-    return parts.joined(separator: "|")
-  }
-
   var body: some View {
     NavigationStack(path: $path) {
       ScrollViewReader { proxy in
@@ -272,26 +241,6 @@ struct WorkRootScreen: View {
           .listRowBackground(Color.clear)
           .listRowSeparator(.hidden)
 
-          if !activityFeed.isEmpty {
-            Section {
-              ForEach(Array(activityFeed.enumerated()), id: \.element.id) { index, activity in
-                WorkActivityRow(activity: activity, animatesPulse: index == 0)
-                  .listRowInsets(EdgeInsets(top: 4, leading: 16, bottom: 4, trailing: 16))
-                  .listRowBackground(Color.clear)
-                  .listRowSeparator(.hidden)
-              }
-            } header: {
-              Text("Activity")
-                .font(.caption.weight(.semibold))
-                .foregroundStyle(ADEColor.textMuted)
-                .textCase(.uppercase)
-                .tracking(0.6)
-                .padding(.horizontal, 16)
-                .padding(.bottom, 4)
-                .listRowInsets(EdgeInsets(top: 4, leading: 0, bottom: 0, trailing: 0))
-            }
-          }
-
           if let errorMessage,
             workStatus.phase == .ready,
             !syncService.connectionState.isHostUnreachable
@@ -506,13 +455,6 @@ struct WorkRootScreen: View {
       .task(id: pollingKey) {
         await pollRunningChats()
       }
-      .task(id: activityFeedFingerprint) {
-        guard isWorkRootActive else {
-          cancelActivityFeedRebuild()
-          return
-        }
-        rebuildActivityFeed()
-      }
       .navigationDestination(for: WorkSessionRoute.self) { route in
         let routeTransitionNamespace = route.openingPrompt == nil && selectedSessionTransitionId == route.sessionId
           ? (ADEMotion.allowsMatchedGeometry(reduceMotion: reduceMotion) ? sessionTransitionNamespace : nil)
@@ -539,6 +481,7 @@ struct WorkRootScreen: View {
             let trimmed = opener.trimmingCharacters(in: .whitespacesAndNewlines)
             optimisticSessions[sessionId] = makeOptimisticSession(for: summary)
             chatSummaries[sessionId] = summary
+            syncService.cacheChatSummary(summary)
             selectedStatus = .all
             selectedLaneId = summary.laneId
             selectedSessionTransitionId = nil
diff --git a/apps/ios/ADE/Views/Work/WorkSessionGrouping.swift b/apps/ios/ADE/Views/Work/WorkSessionGrouping.swift
index 237b2b417..6dd924e22 100644
--- a/apps/ios/ADE/Views/Work/WorkSessionGrouping.swift
+++ b/apps/ios/ADE/Views/Work/WorkSessionGrouping.swift
@@ -49,7 +49,6 @@ struct WorkRootSessionPresentation: Equatable {
   let displaySessions: [TerminalSessionSummary]
   let displaySessionIds: Set<String>
   let liveChatSessions: [TerminalSessionSummary]
-  let activitySessions: [TerminalSessionSummary]
   let sessionGroups: [WorkSessionGroup]
   let globalNeedsInputCount: Int
   let globalLiveSessionCount: Int
@@ -61,7 +60,6 @@ struct WorkRootSessionPresentation: Equatable {
     displaySessions: [],
     displaySessionIds: [],
     liveChatSessions: [],
-    activitySessions: [],
     sessionGroups: [],
     globalNeedsInputCount: 0,
     globalLiveSessionCount: 0,
@@ -128,11 +126,6 @@ func buildWorkRootSessionPresentation(
     }
   }
 
-  let activitySessions = workActivitySourceSessions(
-    displaySessions,
-    chatSummaries: chatSummaries,
-    archivedSessionIds: archivedSessionIds
-  )
   let sessionGroups = workSessionGroups(
     organization: organization,
     sessions: displaySessions,
@@ -146,7 +139,6 @@ func buildWorkRootSessionPresentation(
     displaySessions: displaySessions,
     displaySessionIds: Set(displaySessions.map(\.id)),
     liveChatSessions: liveChatSessions,
-    activitySessions: activitySessions,
     sessionGroups: sessionGroups,
     globalNeedsInputCount: globalNeedsInputCount,
     globalLiveSessionCount: globalLiveSessionCount,
diff --git a/apps/ios/ADE/Views/Work/WorkStatusAndFormattingHelpers.swift b/apps/ios/ADE/Views/Work/WorkStatusAndFormattingHelpers.swift
index 8b793056a..8e601151c 100644
--- a/apps/ios/ADE/Views/Work/WorkStatusAndFormattingHelpers.swift
+++ b/apps/ios/ADE/Views/Work/WorkStatusAndFormattingHelpers.swift
@@ -149,6 +149,33 @@ func sessionSymbol(_ session: TerminalSessionSummary, provider: String?) -> Stri
 }
 
 func normalizedWorkChatSessionStatus(session: TerminalSessionSummary?, summary: AgentChatSessionSummary?) -> String {
+  let raw = rawWorkChatSessionStatus(session: session, summary: summary)
+  // Stale-session guard: a chat that's been "awaiting-input", "active", or
+  // "idle" but hasn't moved in over 7 days is almost certainly never going
+  // to resume. Desktop drops these from its Work list; iOS now does too so
+  // the two devices stay in agreement.
+  if raw == "awaiting-input" || raw == "active" || raw == "idle" {
+    let lastActivityRaw = summary?.lastActivityAt ?? session?.chatIdleSinceAt ?? session?.startedAt
+    if let last = lastActivityRaw,
+       let date = workChatLastActivityDate(last),
+       Date().timeIntervalSince(date) > workChatStaleAfterSeconds {
+      return "ended"
+    }
+  }
+  return raw
+}
+
+private let workChatStaleAfterSeconds: TimeInterval = 7 * 24 * 60 * 60
+
+private func workChatLastActivityDate(_ raw: String) -> Date? {
+  let iso = ISO8601DateFormatter()
+  iso.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+  if let d = iso.date(from: raw) { return d }
+  iso.formatOptions = [.withInternetDateTime]
+  return iso.date(from: raw)
+}
+
+private func rawWorkChatSessionStatus(session: TerminalSessionSummary?, summary: AgentChatSessionSummary?) -> String {
   if summary?.awaitingInput == true {
     return "awaiting-input"
   }
diff --git a/apps/ios/ADETests/ADETests.swift b/apps/ios/ADETests/ADETests.swift
index d3966ea94..3295ca68a 100644
--- a/apps/ios/ADETests/ADETests.swift
+++ b/apps/ios/ADETests/ADETests.swift
@@ -2,6 +2,16 @@ import XCTest
 import SQLite3
 @testable import ADE
 
+/// Default `lastActivityAt`/`startedAt` for fixture sessions. Returns "now"
+/// in ISO 8601 so the >7-day staleness guard in
+/// `normalizedWorkChatSessionStatus` doesn't reclassify default fixtures as
+/// "ended".
+private func recentIso8601Fixture() -> String {
+  let f = ISO8601DateFormatter()
+  f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+  return f.string(from: Date())
+}
+
 final class ADETests: XCTestCase {
   func testTerminalDisplayReplaysCarriageReturnProgressUpdates() {
     let output = sanitizeTerminalOutputForDisplay("Downloading 10%\rDownloading 80%\rDownloading 100%\nDone")
@@ -27,6 +37,17 @@ final class ADETests: XCTestCase {
     XCTAssertEqual(output, "errok")
   }
 
+  func testTerminalDisplayPreservesAnsiRunsForRendering() {
+    let display = workTerminalDisplay(
+      raw: "\u{001B}[31mError\u{001B}[0m plain \u{001B}[32;1mOK\u{001B}[0m",
+      fallback: nil
+    )
+
+    XCTAssertEqual(display.text, "Error plain OK")
+    XCTAssertEqual(String(display.attributedText.characters), "Error plain OK")
+    XCTAssertGreaterThan(Array(display.attributedText.runs).count, 1)
+  }
+
   func testTerminalDisplayPreservesIndentedOutput() {
     let output = sanitizeTerminalOutputForDisplay("if true {\n    print(\"ok\")\n}\n")
 
@@ -346,6 +367,46 @@ final class ADETests: XCTestCase {
     )
   }
 
+  @MainActor
+  func testSyncAutomaticReconnectDoesNotTreatGenericTailnetShortcutAsEverySavedHost() {
+    let service = SyncService(database: makeDatabase(baseURL: makeTemporaryDirectory()))
+    let profile = HostConnectionProfile(
+      hostIdentity: "host-1",
+      hostName: "Mac Studio",
+      port: 8787,
+      authKind: "paired",
+      pairedDeviceId: "phone-1",
+      lastRemoteDbVersion: 0,
+      lastHostDeviceId: "host-1",
+      lastSuccessfulAddress: "192.168.1.8",
+      savedAddressCandidates: ["192.168.1.8", "100.75.20.63"],
+      discoveredLanAddresses: ["192.168.1.8"],
+      tailscaleAddress: "100.75.20.63"
+    )
+    service.applyDiscoveredHostsForTesting([
+      DiscoveredSyncHost(
+        id: "tailnet-ade-sync:8787",
+        serviceName: "ADE Tailnet ade-sync",
+        hostName: "ade-sync",
+        hostIdentity: nil,
+        port: 8787,
+        addresses: [],
+        tailscaleAddress: "ade-sync",
+        // Use a fresh `lastResolvedAt` so the discovery row is not coalesced
+        // away by the same-bucket dedup that other tests' static 2026-04-23
+        // fixtures rely on. We need this row live in `discoveredHosts` to
+        // exercise the shortcut-vs-saved-host matching logic this test
+        // regresses against.
+        lastResolvedAt: recentIso8601Fixture()
+      ),
+    ])
+
+    XCTAssertEqual(
+      service.automaticReconnectAddressesForTesting(profile),
+      ["100.75.20.63"]
+    )
+  }
+
   @MainActor
   func testSyncPlaintextWebSocketAllowlistIncludesTrustedTailscaleRoutesOnly() {
     let service = SyncService(database: makeDatabase(baseURL: makeTemporaryDirectory()))
@@ -449,6 +510,20 @@ final class ADETests: XCTestCase {
     )
     XCTAssertEqual(SyncUserFacingError.message(for: authError), "This phone is no longer paired with the host. Pair again from Settings.")
 
+    let ambiguousTailnetAuthError = NSError(
+      domain: "ADE",
+      code: 3,
+      userInfo: [
+        NSLocalizedDescriptionKey: "Authentication failed.",
+        "ADEErrorCode": "auth_failed",
+        "ADEAmbiguousRouteAuthFailure": true,
+      ]
+    )
+    XCTAssertEqual(
+      SyncUserFacingError.message(for: ambiguousTailnetAuthError),
+      "Reached an ADE host over Tailnet, but it did not match this saved computer. ADE kept the pairing and will keep trying other routes."
+    )
+
     let invalidHelloError = NSError(
       domain: "ADE",
       code: 4,
@@ -3641,25 +3716,12 @@ final class ADETests: XCTestCase {
 
     let transcript = parseWorkChatTranscript(raw)
     let toolCards = buildWorkToolCards(from: transcript)
-    let activeAgents = deriveWorkAgentActivities(
-      from: transcript,
-      session: WorkAgentActivityContext(
-        sessionId: "chat-1",
-        title: "Claude chat",
-        laneName: "feature/work",
-        status: "running",
-        startedAt: "2026-03-25T00:00:00.000Z"
-      )
-    )
 
     XCTAssertEqual(transcript.count, 6)
     XCTAssertEqual(toolCards.count, 1)
     XCTAssertEqual(toolCards.first?.toolName, "functions.Read")
     XCTAssertEqual(toolCards.first?.status, .completed)
     XCTAssertTrue(toolCards.first?.resultText?.contains("ADE") == true)
-    XCTAssertEqual(activeAgents.count, 1)
-    XCTAssertEqual(activeAgents.first?.agentName, "Docs helper")
-    XCTAssertEqual(activeAgents.first?.toolName, "functions.Read")
   }
 
   func testWorkChatTranscriptUsesMessageIdToSplitAssistantMessages() {
@@ -4785,68 +4847,6 @@ final class ADETests: XCTestCase {
     XCTAssertEqual(resolved, "apps/ios/ADE/Helpers/WorkView.swift")
   }
 
-  func testWorkActivitySourceSessionsReuseFilteredWorkCollection() {
-    let lane1Chat = makeTerminalSessionSummary(
-      id: "chat-1",
-      laneId: "lane-1",
-      laneName: "feature/work",
-      toolType: "codex-chat",
-      title: "Fix Work root"
-    )
-    let lane2Chat = makeTerminalSessionSummary(
-      id: "chat-2",
-      laneId: "lane-2",
-      laneName: "release",
-      toolType: "claude-chat",
-      title: "Deploy release"
-    )
-    let lane2Terminal = makeTerminalSessionSummary(
-      id: "terminal-1",
-      laneId: "lane-2",
-      laneName: "release",
-      toolType: "shell",
-      runtimeState: "idle",
-      title: "Deploy logs",
-      lastOutputPreview: "Tail the deploy terminal output"
-    )
-
-    let chatSummaries = [
-      "chat-1": makeAgentChatSessionSummary(
-        sessionId: "chat-1",
-        laneId: "lane-1",
-        provider: "codex",
-        model: "gpt-5.4",
-        title: "Fix Work root",
-        status: "active"
-      ),
-      "chat-2": makeAgentChatSessionSummary(
-        sessionId: "chat-2",
-        laneId: "lane-2",
-        provider: "claude",
-        model: "sonnet",
-        title: "Deploy release",
-        status: "active"
-      ),
-    ]
-
-    let filtered = workFilteredSessions(
-      [lane1Chat, lane2Terminal, lane2Chat],
-      chatSummaries: chatSummaries,
-      archivedSessionIds: [],
-      selectedStatus: .running,
-      selectedLaneId: "lane-2",
-      searchText: "deploy"
-    )
-    let activitySessions = workActivitySourceSessions(
-      filtered,
-      chatSummaries: chatSummaries,
-      archivedSessionIds: []
-    )
-
-    XCTAssertEqual(filtered.map(\.id), ["chat-2", "terminal-1"])
-    XCTAssertEqual(activitySessions.map(\.id), ["chat-2"])
-  }
-
   func testWorkRunningBannerCopyDescribesMixedLiveSessions() {
     XCTAssertEqual(
       workRunningBannerTitle(liveChatCount: 1, liveTerminalCount: 1, attentionCount: 1),
@@ -5222,31 +5222,6 @@ final class ADETests: XCTestCase {
     XCTAssertTrue(FileManager.default.fileExists(atPath: appURL.appendingPathComponent("ade-ios-local.sqlite.phase6-backup").path))
   }
 
-  func testWorkActivityBufferFingerprintStaysStableForIdenticalBuffers() {
-    let bufferA = "hello\nworld\nrunning tool"
-    let bufferB = "hello\nworld\nrunning tool"
-    XCTAssertEqual(workActivityBufferFingerprint(bufferA), workActivityBufferFingerprint(bufferB))
-  }
-
-  func testWorkActivityBufferFingerprintChangesWhenBufferGrowsOrChanges() {
-    let base = "hello world"
-    let appended = base + " more content appended at the tail"
-    let replaced = "HELLO world"
-
-    XCTAssertNotEqual(workActivityBufferFingerprint(base), workActivityBufferFingerprint(appended))
-    XCTAssertNotEqual(workActivityBufferFingerprint(base), workActivityBufferFingerprint(replaced))
-    XCTAssertEqual(workActivityBufferFingerprint(""), "0:")
-  }
-
-  func testWorkActivityBufferFingerprintDistinguishesLongBuffersWithDifferentTails() {
-    let head = String(repeating: "a", count: 1024)
-    let bufferA = head + "tail-alpha"
-    let bufferB = head + "tail-omega"
-    // Lengths match, so only the fingerprint's tail-window distinguishes them.
-    XCTAssertEqual(bufferA.count, bufferB.count)
-    XCTAssertNotEqual(workActivityBufferFingerprint(bufferA), workActivityBufferFingerprint(bufferB))
-  }
-
   func testFilesDiffHasChangesDetectsTextAndExistenceEdits() {
     let empty = DiffSide(exists: false, text: "")
     let same = FileDiff(
@@ -5338,33 +5313,6 @@ final class ADETests: XCTestCase {
     )
   }
 
-  func testBuildWorkActivityFeedReusesCachedTerminalTranscript() {
-    let session = makeTerminalSessionSummary(toolType: "codex-chat", title: "Main chat")
-    let raw = """
-    {"sessionId":"chat-1","timestamp":"2026-03-25T00:00:01.000Z","sequence":1,"event":{"type":"subagent_started","taskId":"task-1","description":"Parsed helper"}}
-    """
-    let cachedTranscript = [
-      WorkChatEnvelope(
-        sessionId: "chat-1",
-        timestamp: "2026-03-25T00:00:01.000Z",
-        sequence: 1,
-        event: .subagentStarted(taskId: "task-1", description: "Cached helper", background: false, turnId: nil)
-      )
-    ]
-    let fingerprint = workActivityBufferFingerprint(raw)
-
-    let result = buildWorkActivityFeed(
-      sources: [session],
-      transcriptCache: [:],
-      terminalBuffers: ["chat-1": raw],
-      existingCache: ["chat-1": WorkActivityTranscriptCacheEntry(fingerprint: fingerprint, transcript: cachedTranscript)],
-      chatSummaries: [:]
-    )
-
-    XCTAssertEqual(result.activities.first?.agentName, "Cached helper")
-    XCTAssertEqual(result.cache["chat-1"]?.fingerprint, fingerprint)
-  }
-
   // MARK: - Mobile PR snapshot (prs sync contracts)
 
   func testPrMobileSnapshotDecodesStackCapabilitiesAndWorkflowCards() throws {
@@ -6278,7 +6226,7 @@ final class ADETests: XCTestCase {
     title: String? = nil,
     status: String,
     awaitingInput: Bool? = nil,
-    lastActivityAt: String = "2026-03-25T00:00:00.000Z"
+    lastActivityAt: String = recentIso8601Fixture()
   ) -> AgentChatSessionSummary {
     AgentChatSessionSummary(
       sessionId: sessionId,
@@ -6330,7 +6278,7 @@ final class ADETests: XCTestCase {
     status: String = "running",
     title: String = "Codex chat",
     lastOutputPreview: String? = nil,
-    startedAt: String = "2026-03-25T00:00:00.000Z"
+    startedAt: String = recentIso8601Fixture()
   ) -> TerminalSessionSummary {
     TerminalSessionSummary(
       id: id,
diff --git a/apps/ios/ADEWidgets/ADELiveActivity.swift b/apps/ios/ADEWidgets/ADELiveActivity.swift
index f938d8c17..e924da484 100644
--- a/apps/ios/ADEWidgets/ADELiveActivity.swift
+++ b/apps/ios/ADEWidgets/ADELiveActivity.swift
@@ -19,6 +19,9 @@ public struct ADESessionAttributes: ActivityAttributes {
         public struct ActiveSession: Codable, Hashable, Identifiable {
             public var id: String
             public var providerSlug: String
+            /// Specific model id ("claude-sonnet-4-6"). Rendered in subtitle
+            /// instead of the generic provider slug when present.
+            public var modelId: String?
             public var title: String
             /// Drives the coloured dot + progress feel on the roster row.
             public var isAwaitingInput: Bool
@@ -30,6 +33,7 @@ public struct ADESessionAttributes: ActivityAttributes {
             public init(
                 id: String,
                 providerSlug: String,
+                modelId: String? = nil,
                 title: String,
                 isAwaitingInput: Bool,
                 isFailed: Bool,
@@ -39,6 +43,7 @@ public struct ADESessionAttributes: ActivityAttributes {
             ) {
                 self.id = id
                 self.providerSlug = providerSlug
+                self.modelId = modelId
                 self.title = title
                 self.isAwaitingInput = isAwaitingInput
                 self.isFailed = isFailed
@@ -46,6 +51,24 @@ public struct ADESessionAttributes: ActivityAttributes {
                 self.progress = progress
                 self.preview = preview
             }
+
+            // Custom Decodable so older payloads (pre-modelId) still decode.
+            private enum CodingKeys: String, CodingKey {
+                case id, providerSlug, modelId, title, isAwaitingInput,
+                     isFailed, startedAt, progress, preview
+            }
+            public init(from decoder: Decoder) throws {
+                let c = try decoder.container(keyedBy: CodingKeys.self)
+                self.id = try c.decode(String.self, forKey: .id)
+                self.providerSlug = try c.decode(String.self, forKey: .providerSlug)
+                self.modelId = try c.decodeIfPresent(String.self, forKey: .modelId)
+                self.title = try c.decode(String.self, forKey: .title)
+                self.isAwaitingInput = try c.decode(Bool.self, forKey: .isAwaitingInput)
+                self.isFailed = try c.decode(Bool.self, forKey: .isFailed)
+                self.startedAt = try c.decode(Date.self, forKey: .startedAt)
+                self.progress = try c.decodeIfPresent(Double.self, forKey: .progress)
+                self.preview = try c.decodeIfPresent(String.self, forKey: .preview)
+            }
         }
 
         /// The single most important "do something" signal in the workspace.
diff --git a/apps/ios/ADEWidgets/ADELiveActivityViews.swift b/apps/ios/ADEWidgets/ADELiveActivityViews.swift
index cf92e14f0..0220f2d71 100644
--- a/apps/ios/ADEWidgets/ADELiveActivityViews.swift
+++ b/apps/ios/ADEWidgets/ADELiveActivityViews.swift
@@ -149,8 +149,15 @@ struct WorkspaceCompactTrailing: View {
                     .minimumScaleFactor(0.85)
                     .frame(maxWidth: 96, alignment: .trailing)
             } else if state.sessions.count == 1, let s = state.sessions.first {
-                // Single active session — show the chat title compactly.
-                Text(s.title.isEmpty ? s.providerSlug : s.title)
+                // Single active session — show the model id (or provider slug
+                // fallback). Title would truncate to nothing useful in this
+                // 96pt slot. Trim before the empty check so a whitespace-only
+                // `modelId` (e.g. " ", "\n") still falls back to the slug
+                // instead of rendering an invisible chip.
+                Text({
+                    let trimmed = (s.modelId ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+                    return trimmed.isEmpty ? s.providerSlug.lowercased() : trimmed
+                }())
                     .font(.system(size: 12, weight: .semibold))
                     .kerning(-0.2)
                     .foregroundStyle(Color(red: 0xF0/255, green: 0xF0/255, blue: 0xF2/255))
@@ -414,11 +421,13 @@ struct WorkspaceExpandedCenter: View {
     }
 
     private func focusedSubtitle(_ focused: ADESessionAttributes.ContentState.ActiveSession) -> String {
-        let provider = focused.providerSlug.lowercased()
+        let label = focused.modelId?.trimmingCharacters(in: .whitespaces).isEmpty == false
+            ? focused.modelId!
+            : focused.providerSlug.lowercased()
         if let preview = focused.preview, !preview.isEmpty {
-            return "\(provider) · \(preview)"
+            return "\(label) · \(preview)"
         }
-        return "\(provider) · working…"
+        return "\(label) · working…"
     }
 }
 
@@ -601,11 +610,13 @@ private struct LockRosterRow: View {
     }
 
     private var subtitleText: String {
-        let providerName = session.providerSlug.lowercased()
+        let modelLabel = session.modelId?.trimmingCharacters(in: .whitespaces).isEmpty == false
+            ? session.modelId!
+            : session.providerSlug.lowercased()
         if let preview = session.preview, !preview.isEmpty {
-            return "\(providerName) · \(preview)"
+            return "\(modelLabel) · \(preview)"
         }
-        return "\(providerName) · working…"
+        return "\(modelLabel) · working…"
     }
 
     private var accessibilityLabel: String {
@@ -742,7 +753,9 @@ private struct ExpandedRosterStrip: View {
                         .lineLimit(1)
                         .minimumScaleFactor(0.85)
                         .frame(maxWidth: .infinity, alignment: .leading)
-                    Text(session.providerSlug.lowercased())
+                    Text(session.modelId?.isEmpty == false
+                         ? session.modelId!
+                         : session.providerSlug.lowercased())
                         .font(.system(size: 10.5, weight: .medium).monospacedDigit())
                         .foregroundStyle(.secondary)
                         .lineLimit(1)
@@ -769,11 +782,13 @@ private struct FocusedCardBottom: View {
     }
 
     private var subtitle: String {
-        let provider = session.providerSlug.lowercased()
+        let label = session.modelId?.trimmingCharacters(in: .whitespaces).isEmpty == false
+            ? session.modelId!
+            : session.providerSlug.lowercased()
         if let preview = session.preview, !preview.isEmpty {
-            return "\(provider) · \(preview)"
+            return "\(label) · \(preview)"
         }
-        return "\(provider) · working…"
+        return "\(label) · working…"
     }
 }
 
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index df285be9d..b68750334 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -334,8 +334,8 @@ Full contract: [`docs/architecture/AI_INTEGRATION.md`](../docs/architecture/AI_I
 `apps/desktop/src/shared/ipc.ts` defines the single `IPC` const with ~550 named channel strings in a `ade.<domain>.<action>` namespace:
 
 ```
-ade.app.*                    # app lifecycle, clipboard, paths
-ade.project.*                # project open/close/switch/state, in-app directory browser (browseDirectories, getDetail)
+ade.app.*                    # app lifecycle, clipboard text and image (writeClipboardText, writeClipboardImage), paths, image data-URL preview (getImageDataUrl)
+ade.project.*                # project open/close/switch/state, in-app directory browser (browseDirectories, getDetail), favicon resolver (resolveIcon)
 ade.onboarding.*
 ade.lanes.*                  # lane list/create/delete/stack/template/env/port/proxy/rebase
 ade.files.*                  # file tree, read, write, search, watch
@@ -516,6 +516,8 @@ Design tokens have been intentionally trimmed. The CTO design tokens at `apps/de
 - `PaneTilingLayout` — recursive pane trees for high-density workspaces, backed by pure ops in `paneTreeOps.ts` (`reconcilePaneTree`, `splitPaneAtEdge`, `swapPanes`, `detectDropEdge`). Trees persist per `layoutId` via `window.ade.tilingTree`; panel sizes persist separately via `DockLayoutState` and are reset whenever the tree mutates.
 - `SplitPane` / resizable panels — structured 2/3-pane views.
 - Work view's grid mode is `PaneTilingLayout` seeded by `buildWorkSessionTilingTree(sessionIds)` (in `renderer/components/terminals/workSessionTiling.ts`); every session becomes a `FloatingPane` leaf with `grid-tile` chrome.
+- The Work surface mounts persistently: `App.tsx`'s `PersistentWorkSurface` keeps `WorkViewArea` in the tree across tab swaps so terminals never tear down on navigation. While inactive the surface is positioned absolute, `inert`, `aria-hidden`, opacity-0, `pointer-events: none`, and pushed behind via `z-index: -1` (the older `hidden` attribute was dropping xterm dimensions on reveal). When it goes back to active, it dispatches the `WORK_SURFACE_REVEALED_EVENT` window event on the next animation frame and again 120 ms later so terminal tiles can clear their texture atlas, force-fit, and refocus.
+- The desktop TopBar project tab strip resolves a per-project favicon via `window.ade.project.resolveIcon(rootPath)` and caches the result in a module-local `Map`. Tabs without an icon (or a missing project root) fall back to the `Folder` Phosphor glyph; the same component drives the loading-pulse animation when a tab is being switched into or closed.
 - Layout state persists to SQLite (`layout`, `tilingTree`, `graphState` domains via the `kv` table).
 
 ### 7.5 Performance contract
diff --git a/docs/features/chat/composer-and-ui.md b/docs/features/chat/composer-and-ui.md
index 024c3cdd4..04c8847dd 100644
--- a/docs/features/chat/composer-and-ui.md
+++ b/docs/features/chat/composer-and-ui.md
@@ -16,7 +16,7 @@ stream plus session metadata.
 | `AgentChatComposer.tsx` | Text input, attachments, model selector, permission controls, slash commands, pending-input answering, and parallel model-slot controls. |
 | `ChatSurfaceShell.tsx` | Floating chat header, body, footer layout. Backdrop-blur glass-morphism styling. |
 | `ChatComposerShell.tsx` | Input container chrome reused by the composer. |
-| `ChatAttachmentTray.tsx` | Inline file/image attachment tray inside the composer. |
+| `ChatAttachmentTray.tsx` | Inline file/image attachment tray inside the composer. Image attachments render an inline thumbnail (loaded through `window.ade.app.getImageDataUrl`), open a full-size lightbox on click, and expose a copy-to-clipboard button that ships the image bytes via `window.ade.app.writeClipboardImage` so the user can paste them into another app. Non-image attachments fall back to the file glyph. |
 | `ChatCommandMenu.tsx` | Popover for slash commands and `@`-prefixed file search. |
 | `ChatTasksPanel.tsx` | Todo list rendered from `todo_update` events. |
 | `ChatFileChangesPanel.tsx` | Turn-level file change summary with lazy diff expansion. |
diff --git a/docs/features/lanes/README.md b/docs/features/lanes/README.md
index d60d36b61..08cfcc53d 100644
--- a/docs/features/lanes/README.md
+++ b/docs/features/lanes/README.md
@@ -76,14 +76,24 @@ iOS companion (`apps/ios/ADE/Views/Lanes/`):
 - `LaneStackCanvasScreen.swift` and `LaneStackGraphSheet.swift` —
   mobile stack graph/canvas projection for parent-child lane chains.
 - `LaneDetailScreen.swift`, `LaneDetailGitSection.swift`,
-  `LaneDetailRebaseBanner.swift`, `LaneDiffScreen.swift`,
-  `LaneCommitSheet.swift`, `LaneCommitHistoryScreen.swift`,
-  `LaneStashesScreen.swift`, `LaneSyncDetailScreen.swift`,
-  `LaneActionsCard.swift`, `LaneManageSheet.swift`,
-  `LaneBatchManageSheet.swift`, `LaneChatLaunchSheet.swift`,
-  `LaneTreeView.swift`, `LaneFileTreeComponents.swift` — mobile
-  detail, git, rebase, diff, stash, sync, manage, chat-launch, and
-  file-tree parity surfaces.
+  `LaneDetailContentSections.swift`, `LaneDetailRebaseBanner.swift`,
+  `LaneDiffScreen.swift`, `LaneCommitSheet.swift`,
+  `LaneCommitHistoryScreen.swift`, `LaneStashesScreen.swift`,
+  `LaneSyncDetailScreen.swift`, `LaneActionsCard.swift`,
+  `LaneAdvancedScreen.swift` (single Advanced page that hosts Manage,
+  Switch branch, Stash, and the four destructive git escape hatches —
+  rebase lane, rebase descendants, rebase + push, force push — with a
+  description per row and an offline disabled banner),
+  `LaneManageSheet.swift`, `LaneBatchManageSheet.swift`,
+  `LaneChatLaunchSheet.swift`, `LaneTreeView.swift`,
+  `LaneFileTreeComponents.swift` — mobile detail, git, rebase, diff,
+  stash, sync, manage, chat-launch, and file-tree parity surfaces.
+  `LaneCommitSheet.swift` is now a "review & commit" sheet: staged
+  and unstaged files render with per-file stage / unstage / discard /
+  restore / open-diff / open-files affordances, plus a "Suggest"
+  button that calls `aiCommitMessages.generate` and shows an inline
+  setup hint when the host reports AI commit messages aren't
+  configured.
 
 Detail docs in this folder:
 
diff --git a/docs/features/project-home/README.md b/docs/features/project-home/README.md
index fd9000141..2d9804ead 100644
--- a/docs/features/project-home/README.md
+++ b/docs/features/project-home/README.md
@@ -81,12 +81,32 @@ Main process (the substrate):
   depth-2 walk capped at 2,000 files), subdirectory count, and — when
   the path matches a recent-projects row in the global state file —
   lane count and last-opened timestamp.
+- `apps/desktop/src/main/services/projects/projectIconResolver.ts` —
+  best-effort favicon discovery for a project root. Walks a fixed list
+  of common icon paths (`favicon.svg/ico/png`, `public/favicon.*`,
+  `app/favicon.*`, `app/icon.*`, `src/(app/)?favicon.*`,
+  `assets/icon.*`, `assets/logo.*`, `.idea/icon.svg`); when none of
+  those exist it scans `index.html`, `public/index.html`, the TanStack
+  Router root file (`app/routes/__root.tsx`, `src/routes/__root.tsx`),
+  and `app/root.tsx` / `src/root.tsx` for a `<link rel="icon">` href
+  (HTML attribute or JS-object form, local hrefs only) and resolves it
+  against `public/` or the project root. `resolveProjectIcon(rootPath)`
+  returns `{ dataUrl, sourcePath, mimeType }`: any matched file under 1
+  MB is base64-encoded as a data URL (svg/ico/png MIME types only),
+  larger files report only `sourcePath` so callers can render
+  themselves. Path traversal outside the project root is blocked.
+- `apps/desktop/src/main/services/projects/projectIconResolver.test.ts`
+  — vitest coverage for the resolver: direct file matches, HTML link
+  scrapes, escape-attempt rejection, and base64 data-URL emission.
 
 Shared types:
 
 - `apps/desktop/src/shared/types/config.ts` — `ProcessDefinition`,
   `ProcessRuntime`, `StackButtonDefinition`, `TestSuiteDefinition`,
   `LaneOverlayPolicy`, `ProxyConfig`, `PortLease`, `LanePreviewInfo`.
+- `apps/desktop/src/shared/types/core.ts` — `ProjectIcon` (`{ dataUrl,
+  sourcePath, mimeType }`), the return shape of `resolveProjectIcon`
+  consumed by the TopBar tab strip and the iOS project list.
 
 Preload bridge:
 
@@ -211,6 +231,28 @@ fuzzy-search over:
 
 Scoped to the current run lane.
 
+### Project icons
+
+Each project gets a best-effort favicon resolved by
+`projectIconResolver`. The renderer asks for it on demand through
+`window.ade.project.resolveIcon(rootPath)` (handler:
+`IPC.projectResolveIcon` →
+`ipcMain.handle("ade.project.resolveIcon", …)`); the desktop TopBar
+project tab strip caches the result per `rootPath` in a module-local
+`Map` so a tab swap doesn't re-scan the disk. When the resolver finds
+no icon (or the file is over the 1 MB cap), the tab falls back to the
+`Folder` Phosphor glyph. Missing-project tabs skip the lookup
+entirely.
+
+The mobile companion gets the icon through a dedicated path: the host's
+`mobileProjectSummaryForContext` / `mobileProjectSummaryForRecent` in
+`apps/desktop/src/main/main.ts` runs `resolveProjectIcon` on every
+project entry, downsamples it to 64×64 via Electron's
+`nativeImage.createFromPath(...).resize(...)` (PNG fallback for SVG /
+ICO sources that `nativeImage` can't read), and ships the resulting
+data URL to iOS as `MobileProjectSummary.iconDataUrl`. The iOS
+`ProjectHomeView` renders that string as the project tile artwork.
+
 ## Data model
 
 The dashboard is driven by:
diff --git a/docs/features/pull-requests/README.md b/docs/features/pull-requests/README.md
index f0bb58cf1..098a72d97 100644
--- a/docs/features/pull-requests/README.md
+++ b/docs/features/pull-requests/README.md
@@ -573,9 +573,19 @@ Builder responsibilities:
 - **Workflow cards** (`buildWorkflowCards`) — pulls non-terminal
   queue entries from `queue_landing_state` joined with `pr_groups`,
   active integration proposals via `listIntegrationWorkflows({ view:
-  "active" })`, and undismissed rebase suggestions from
-  `rebaseSuggestionService`. Failures in any source log a warning
-  and skip that card category rather than failing the whole snapshot.
+  "active" })`, and rebase needs from `conflictService.scanRebaseNeeds()`
+  (filtered to `kind === "lane_base"` with `behindBy > 0` and a live
+  defer window). Using the same source the desktop Rebase tab consumes
+  via `window.ade.rebase.scanNeeds` keeps the phone's rebase cards
+  in sync with the desktop — including drift against a local `main`
+  that hasn't been pushed yet, which `rebaseSuggestionService` misses
+  because it only reads `origin/<base>`. Dismiss / defer rebase from
+  the phone (`lanes.dismissRebaseSuggestion`,
+  `lanes.deferRebaseSuggestion`) updates `conflictService` first so
+  the next snapshot reflects the action immediately, then forwards to
+  `rebaseSuggestionService` for legacy parity. Failures in any source
+  log a warning and skip that card category rather than failing the
+  whole snapshot.
 
 The snapshot is read-only; create/merge/close/comment actions go
 through the existing command surface (`prs.createFromLane`,
diff --git a/docs/features/sync-and-multi-device/ios-companion.md b/docs/features/sync-and-multi-device/ios-companion.md
index 9743c8c8e..fa865cef5 100644
--- a/docs/features/sync-and-multi-device/ios-companion.md
+++ b/docs/features/sync-and-multi-device/ios-companion.md
@@ -50,8 +50,10 @@ apps/ios/
 │   │   │                            # haptics, shimmer, mobile primitives
 │   │   ├── Cto/                     # CtoRootScreen, CtoSessionDestinationView
 │   │   ├── Lanes/                   # LaneDetailScreen, LaneActionsCard,
+│   │   │                            # LaneAdvancedScreen (gearshape destination),
 │   │   │                            # LaneBatchManageSheet, LaneManageSheet,
 │   │   │                            # LaneMultiAttachSheet, LaneStackCanvasScreen,
+│   │   │                            # LaneCommitSheet (review + per-file stage/diff),
 │   │   │                            # LaneEnvInitProgressView, etc.
 │   │   ├── Files/                   # FilesRootScreen, FilesDirectoryScreen,
 │   │   │                            # FilesDetailScreen, *+Actions helpers
@@ -122,6 +124,14 @@ older `ADEConnectionPill` and the per-tab "connection notice" banner
 cards — controllers no longer ship duplicate offline / reconnect /
 hydrating cards inside each screen body.
 
+`ProjectHomeView` is the exception: with the navigation bar hidden
+(brand-mark hero only) it surfaces the same connection state through
+an inline "Attached to <host>" banner above the open-project button.
+The banner uses the same tint mapping as `ADEConnectionDot` (success
+when connected/syncing, warning when connecting/error, muted when
+disconnected) and routes taps through `syncService.settingsPresented`
+to the same Settings sheet the dot opens.
+
 Accessibility: the dot exposes `accessibilityLabel` that includes the
 host name when connected and trims the last error message for the
 error state, an `accessibilityHint` of "Opens settings to pair or
@@ -436,20 +446,29 @@ activity per app at a time; the coordinator ends stale per-session
 activities from older builds on launch.
 
 `ADESessionAttributes.ContentState` carries:
-- `sessions: [ActiveSession]` — sorted by awaiting-input → failed →
-  newest running.
+- `sessions: [ActiveSession]` — currently-streaming chats only,
+  sorted failed → newest. SyncService filters at the source by
+  `runtimeState == "running"` and a recent `lastActivityAt`, so the
+  Live Activity roster is always the streaming subset; idle, awaiting,
+  and stale chats stay in the in-app Attention Drawer.
 - `attention: Attention?` — one of `awaitingInput`, `failed`,
   `ciFailing`, `reviewRequested`, `mergeReady`. Nil when nothing
   requires immediate action.
 - `failingCheckCount`, `awaitingReviewCount`, `mergeReadyCount` — PR
   aggregate counts.
 
-`LiveActivityCoordinator` exposes a single `reconcile(with:prs:)`
-call wired from `SyncService`. Push-to-start (iOS 17.2+) and
-per-activity update tokens are collected via `pushTokenUpdates` and
-forwarded to the host through `LiveActivityHost.sendPushToken`.
-The host sends `liveactivity` APNs pushes to the update tokens via
-`notificationEventBus` whenever an attention-eligible event fires.
+`LiveActivityCoordinator.reconcile(with:prs:focusedLaneName:)` is the
+single entry point from `SyncService`. `focusedLaneName` is the
+most-recently-active running chat's lane name; the coordinator uses it
+as the system-header suffix (`ADE · <lane>`). Because
+`ActivityAttributes` are immutable across an activity's lifetime, a
+focus-lane change forces the coordinator to end the existing activity
+and request a new one, so the header always matches the lane the user
+is watching. Push-to-start (iOS 17.2+) and per-activity update tokens
+are collected via `pushTokenUpdates` and forwarded to the host through
+`LiveActivityHost.sendPushToken`. The host sends `liveactivity` APNs
+pushes to the update tokens via `notificationEventBus` whenever an
+attention-eligible event fires.
 
 The `ADELiveActivity` widget registers the `ActivityConfiguration`
 for the lock-screen / banner presentation and the Dynamic Island
@@ -493,15 +512,19 @@ when no active project is selected or the user taps the Projects toolbar
 button. It merges the host-provided catalog with projects already present
 in the local replicated DB, marks cached/unavailable rows, and requests a
 fresh bootstrap connection for the selected desktop project through
-`project_switch_request`.
+`project_switch_request`. Each tile renders `MobileProjectSummary.iconDataUrl`
+when the host's `projectIconResolver` found a favicon for the project,
+falling back to the brand glyph otherwise. The host pre-renders icons
+to a 64×64 PNG via Electron `nativeImage` before they reach the phone,
+so the iOS side can decode them with stock UIImage.
 
 ### Shipped
 
 | Tab | Icon | Desktop equivalent | Capabilities |
 |---|---|---|---|
-| **Lanes** | `square.stack.3d.up` | `/lanes` | Full lane surface: search/filter chips, open/create/attach/manage, multi-attach for unregistered worktrees, stack canvas, git/diff/rebase/conflicts, template-backed environment setup progress, lane-scoped sessions and AI chats. `devicesOpen` presence chips show which other devices currently have the lane open. |
+| **Lanes** | `square.stack.3d.up` | `/lanes` | Full lane surface: search/filter chips, open/create/attach/manage, multi-attach for unregistered worktrees, stack canvas, git/diff/rebase/conflicts, template-backed environment setup progress, lane-scoped sessions and AI chats. `devicesOpen` presence chips show which other devices currently have the lane open. The lane gear opens `LaneAdvancedScreen`, a single page that groups Manage / Switch branch / Stash and the destructive git escape hatches (rebase lane, rebase descendants, rebase + push, force push) with an inline description per row and an offline disabled banner. The commit sheet (`LaneCommitSheet`) renders staged + unstaged file lists with per-file stage / unstage / discard / restore / open-diff / open-files actions, a "Suggest" AI button gated by host capability, and a setup-hint card surfaced when the host returns "AI commit messages are off". |
 | **Files** | `doc.text` | `/files` | Lane-backed workspace picker, live file tree/search/read, protected-workspace read-only parity. `mobileReadOnly` on the workspace payload gates mutating file actions on the phone via `ensureMobileFileMutationsAllowed`; quick-open and text-search result lists cap visible rows at 40 and ask the user to refine when more matches exist. |
-| **Work** | `terminal` | `/work` | Terminal + chat session list, cached history with persisted lane names, output streaming, typed terminal input and Ctrl-C forwarding for subscribed live PTYs, quick-launch actions, session pinning, live chat-event push from the host (no polling lag once subscribed). |
+| **Work** | `terminal` | `/work` | Terminal + chat session list, cached history with persisted lane names, output streaming, character-by-character terminal input (Termius-style: each typed glyph forwards a single `terminal_input` byte and the field clears so PTY echo is the only source of truth), Ctrl-C forwarding for subscribed live PTYs, quick-launch actions, session pinning, live chat-event push from the host (no polling lag once subscribed). The terminal viewer renders ANSI SGR colors + bold and replays cursor/erase sequences via `WorkTerminalTextReplay` so agent CLI output stays readable on iPhone. The earlier "activity feed" section was retired — running chats are surfaced through the session list and the live-count chip. |
 | **PRs** | `arrow.triangle.pull` | `/prs` | PR list/detail driven by `prs.getMobileSnapshot`: stack visibility (`PrStackSheet`), create-PR wizard (`CreatePrWizardView`) gated by per-lane eligibility, workflow cards (queue / integration / rebase) rendered from `PrWorkflowCard`, per-PR action capabilities. |
 | **CTO** | `sparkles` | `/cto` | CTO snapshot: Chat / Team / Workflows segments, with the mobile workflows screen mirroring the desktop workflow policy/dashboard and preserving the shared glass navigation chrome. Drills into per-worker chat sessions via `CtoSessionDestinationView`. |
 | **Settings** | `gearshape` | `/settings` (sync subset) | PIN pairing (`SettingsPinSheet`), notification preferences (`NotificationsCenterView`), quiet hours, per-session overrides, appearance, diagnostics, connection header with QR payload and address candidates, reconnect, forget. |
diff --git a/docs/features/sync-and-multi-device/remote-commands.md b/docs/features/sync-and-multi-device/remote-commands.md
index f1a9c9119..3ac12e619 100644
--- a/docs/features/sync-and-multi-device/remote-commands.md
+++ b/docs/features/sync-and-multi-device/remote-commands.md
@@ -197,7 +197,16 @@ A handful have more logic:
   PR's action capabilities, resolves per-lane create-PR eligibility
   (using `resolveStableLaneBaseBranch`), and collects queue /
   integration / rebase workflow cards from the DB and
-  `rebaseSuggestionService`.
+  `conflictService.scanRebaseNeeds()` (the same source the desktop
+  Rebase tab consumes).
+- **`lanes.dismissRebaseSuggestion` / `lanes.deferRebaseSuggestion`** —
+  dual-write the lane state. The handler calls
+  `conflictService.dismissRebase(laneId)` /
+  `conflictService.deferRebase(laneId, until)` first so the next
+  `prs.getMobileSnapshot` rebuild reflects the action immediately,
+  then forwards to `rebaseSuggestionService.dismiss/defer` for the
+  legacy desktop banner. `defer` clamps the requested minutes to
+  `[5, 7 days]` before computing the absolute `until` ISO string.
 - **`lanes.presence.announce` / `lanes.presence.release`** — handled
   in `syncHostService` directly (not in the remote command
   registry); the host upserts a per-lane `DeviceMarker` map and
diff --git a/docs/features/terminals-and-sessions/README.md b/docs/features/terminals-and-sessions/README.md
index 162702f78..46d3ccc0a 100644
--- a/docs/features/terminals-and-sessions/README.md
+++ b/docs/features/terminals-and-sessions/README.md
@@ -119,8 +119,30 @@ Renderer surfaces:
 - `apps/desktop/src/renderer/components/terminals/useSessionDelta.ts` —
   fetches `SessionDeltaSummary` for a given session.
 - `apps/desktop/src/renderer/components/terminals/cliLaunch.ts` —
-  builds Claude/Codex CLI command strings with permission and sandbox
-  flags.
+  builds Claude/Codex CLI launch payloads with permission and sandbox
+  flags. `buildTrackedCliLaunchCommand` returns a typed
+  `TrackedCliLaunchCommand` (`{ command, args, startupCommand }`) so
+  `ptyService.create` can spawn the CLI directly via argv (preferred)
+  while `startupCommand` stays as a shell-typed fallback for systems
+  whose Claude/Codex shim only resolves through the user's shell rc.
+  Both providers get ADE session guidance injected at launch:
+  Claude through `--append-system-prompt` (text from
+  `ADE_CLI_AGENT_GUIDANCE`), Codex through a leading initial prompt
+  built from `ADE_CLI_INLINE_GUIDANCE`. The legacy
+  `buildTrackedCliStartupCommand` and `defaultTrackedCliStartupCommand`
+  are now thin wrappers over `buildTrackedCliLaunchCommand` for
+  callers that only need the shell string.
+- `apps/desktop/src/shared/adeCliGuidance.ts` — single source of truth
+  for the ADE session guidance text injected into Claude/Codex CLI
+  launches. Exported as `ADE_CLI_AGENT_GUIDANCE` and
+  `ADE_CLI_INLINE_GUIDANCE`.
+- `apps/desktop/src/renderer/components/terminals/workSurfaceVisibility.ts`
+  — exports the `WORK_SURFACE_REVEALED_EVENT` window-event constant
+  and a `dispatchWorkSurfaceRevealed()` helper. The persistent Work
+  surface fires this event whenever the work area becomes active again
+  so xterm tiles can clear their texture atlas, force a refit against
+  the new viewport, and restore focus/scroll without waiting for a
+  resize event that will never come.
 - `apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx`
   and `SessionInfoPopover.tsx` — right-click actions and info overlay.
   Ended chat sessions get an additional "Delete chat" action wired to
diff --git a/docs/features/terminals-and-sessions/pty-and-processes.md b/docs/features/terminals-and-sessions/pty-and-processes.md
index bd3c58d6e..baa3735f2 100644
--- a/docs/features/terminals-and-sessions/pty-and-processes.md
+++ b/docs/features/terminals-and-sessions/pty-and-processes.md
@@ -150,11 +150,20 @@ Each live PTY has an entry in the `ptys` map keyed by `ptyId` with:
    `running`.
 8. Best-effort capture of `headShaStart` via `computeHeadShaBestEffort`
    so `sessionDeltaService` has a git anchor.
-9. Select a shell (`/bin/zsh`, `/bin/bash`, `/bin/sh`, or Windows
-   equivalents) or spawn a direct command. Retries across candidates if
-   the first spawn fails.
-10. Write `args.startupCommand` to the PTY so the shell executes the
-    CLI. Returns `{ ptyId, sessionId, pid }`.
+9. Pick a launch strategy:
+   - When `args.command` is present (e.g. the renderer asked for
+     `claude` with explicit argv from `buildTrackedCliLaunchCommand`),
+     spawn that program directly. If the direct spawn fails, fall back
+     to a shell candidate so an `args.startupCommand` shadow command
+     can still execute the CLI through the user's shell rc — useful
+     when Claude/Codex are only resolvable through `~/.zshrc` shims.
+   - Otherwise iterate the shell candidate list (`/bin/zsh`,
+     `/bin/bash`, `/bin/sh`, or Windows equivalents), retrying across
+     candidates if the first spawn fails.
+10. If the spawn ended up in a shell (no direct launch, or direct
+    launch fell back), type `args.startupCommand` into the PTY so the
+    shell executes the CLI. Direct launches that succeeded skip this —
+    they already received argv. Returns `{ ptyId, sessionId, pid }`.
 
 ### Data, preview, and runtime state
 
@@ -245,7 +254,18 @@ resolved. Strategies, in order:
    `payload.timestamp` (or the file `mtime` when absent) and the ADE
    session's `startedAt`. The best-scoring match wins, so re-running
    Codex in the same cwd doesn't clobber the resume target of a
-   concurrent terminal.
+   concurrent terminal. The matcher accepts three optional gates so the
+   close-time pass is tighter than the on-demand pass:
+   `maxStartDeltaMs` (drop matches whose timestamp drifts more than N
+   ms from `startedAt`), `notBeforeMs` (ignore rollouts older than this
+   floor — used to refuse a recycled rollout from a previous launch),
+   and `requiredText` (reads up to 512 KB of the candidate's prefix and
+   only accepts the file when that substring appears, e.g. the
+   `"ADE session guidance"` marker that the renderer's CLI launcher
+   embeds in the initial Codex prompt). The live polling backfill that
+   runs while a Codex session is still streaming uses all three gates;
+   the close-time backfill only enforces a 10-minute drift window so
+   it can match older sessions on resume.
 
 Any found ID updates the row's `resumeMetadata.targetId` through
 `sessionService.updateMeta`. A resume command is always written even
@@ -258,6 +278,17 @@ the renderer first asks for them. Each call de-dupes IDs and logs a
 single `pty.resume_target_backfill_failed` warn per failing ID; it
 never throws.
 
+The Codex storage scan is gated by the `reason` argument that the
+backfill runs under: `"close"` and `"dispose"` (the regular end-of-
+session paths) consult `~/.codex/sessions` with the 10-minute drift
+window; `"session-list"` and `"resume-launch"` skip the storage
+lookup entirely. Lazy hydration over `sessions.list` therefore relies
+only on transcript regex matches, which keeps the list-render hot path
+off the disk and prevents one renderer's idle list refresh from
+adopting another lane's Codex rollout. Live Codex sessions still get
+their resume target through the polling path, which uses the strict
+`requiredText: "ADE session guidance"` gate.
+
 ### Dispose and orphan disposal
 
 `dispose({ ptyId, sessionId? })` kills the PTY (SIGHUP on POSIX), ends
diff --git a/docs/features/terminals-and-sessions/ui-surfaces.md b/docs/features/terminals-and-sessions/ui-surfaces.md
index b1ac1ec95..707c0d67e 100644
--- a/docs/features/terminals-and-sessions/ui-surfaces.md
+++ b/docs/features/terminals-and-sessions/ui-surfaces.md
@@ -300,6 +300,16 @@ Key behaviors:
   backgrounded, so background terminals don't stall on `rAF` ticks
   that the browser suppresses. `flushPendingFrameWrites` / `clearFrameWriteSchedule`
   own both code paths.
+- **Work-surface reveal redraw** — `TerminalView` listens for the
+  `WORK_SURFACE_REVEALED_EVENT` window event (dispatched from
+  `PersistentWorkSurface` whenever it returns to the foreground). On
+  reveal, the view clears the WebGL texture atlas, flushes any
+  pending frame writes, schedules a forced refit on the next animation
+  frame, and re-runs `term.refresh(0, rows-1)` plus a focus +
+  `scrollToBottom()` when the tile is the active one. This is the only
+  reliable signal that "the surface is back on screen at its new
+  size" since hidden surfaces no longer fire layout/resize events;
+  without it, terminals come back blank after a tab swap.
 
 Font stack defaults: `ui-monospace`, `SFMono-Regular`, `Menlo`,
 `Monaco`, `Cascadia Mono`, `JetBrains Mono`, `Geist Mono`, `monospace`.
@@ -314,12 +324,22 @@ Rendered when the Work view has no open sessions. Contains:
   permission controls (`getPermissionOptions`, `safetyColors`)
 - for terminal drafts: provider picker (Claude / Codex / Shell),
   permission mode dropdown, and a "Launch" button that calls
-  `onLaunchPtySession` with the built startup command from
-  `buildTrackedCliStartupCommand`
+  `onLaunchPtySession` with the launch payload from
+  `buildTrackedCliLaunchCommand` (`{ command, args, startupCommand }`).
+  `onLaunchPtySession` forwards `command` + `args` to `pty.create`
+  for direct argv spawn; `startupCommand` rides along as the shell
+  fallback for hosts that need rc-resolved CLI shims.
 
 Launch commands are built by `cliLaunch.ts`:
 
+- `buildTrackedCliLaunchCommand({ provider, permissionMode, ... })`
+  returns the canonical `{ command, args, startupCommand }` triple
+  used for both fresh launches and resumes. The args list now embeds
+  the ADE CLI guidance prompt — Claude through `--append-system-prompt`,
+  Codex as the leading initial prompt — so every tracked CLI session
+  starts with the agent already aware of the ADE wrappers.
 - `buildTrackedCliStartupCommand({ provider, permissionMode, ... })`
+  thin wrapper that returns just the shell-typed `startupCommand`.
 - `resolveTrackedCliResumeCommand(session)` — used for the resume
   action on the session card
 
@@ -351,7 +371,14 @@ A single hook that owns a lot of state:
 
 The hook exposes `openSessionTab`, `focusSession`, `selectLane`,
 `upsertOptimisticChatSession` (so new chats appear in the tab strip
-before the IPC round-trip completes), and `refresh`.
+before the IPC round-trip completes), and `refresh`. The
+`launchPtySession({ laneId, profile, command?, args?, startupCommand?,
+title?, tracked? })` helper (and its lane-scoped twin in
+`useLaneWorkSessions`) builds a default launch payload with
+`buildTrackedCliLaunchCommand` when the caller didn't override
+`command`/`args`, so every entry point — chat composer launch button,
+TopBar work controls, lane Work pane — produces the same argv-based
+spawn with ADE CLI guidance baked in.
 
 `useLaneWorkSessions` (same file) wraps the same state but scopes to a
 single lane for the Lanes tab.