skydive-cli 0.2.0 → 0.3.0-beta.764

package/dist/js/{boot-CGaXUEer.mjs → boot-Bs-IF23f.mjs}

@@ -1,26 +1,25 @@
 #!/usr/bin/env node
-import { O as getReviewStateDir, R as resolveWebUrl, S as DEFAULT_APP_URL, T as getConfigPath, V as saveTheme, _ as setActiveWorkspace, a as noColorRequested, c as themeMode, f as themesForMode, g as listWorkspaces, i as monoTheme, k as getSavedTheme, l as themeModeFromColorFgBg, m as getActiveWorkspaceId, n as applyTheme, o as theme, r as findTheme, s as themeForMode, t as DEFAULT_THEME_ID, u as themeVersion, x as DEFAULT_API_URL } from "./theme-CuQhvqzN.mjs";
-import { n as createRestClient, r as errorDetail, t as HttpError } from "./rest-CamHVOce.mjs";
-import { n as isRecord, t as errorMessage } from "./util-CeisaZVY.mjs";
-import { c as cardActionErrorMessage, d as reconcileMaskedInput, f as resolveConnectUrl, i as resolveAgent, l as parseExternalOauthConnectParams, p as parseConnectCard, s as MASK_CHAR, u as parseOauthConnectParams } from "./print-Bin4u16d.mjs";
-import "./api-CDTKq_5Q.mjs";
-import { t as SandboxStream } from "./client-CpEvH2Pq.mjs";
-import { t as PortalClient } from "./client-B3ZhhF7e.mjs";
-import { t as runRawPtyPassthrough } from "./raw-pty-GAvxm2ol.mjs";
+import { C as setActiveWorkspace, S as listWorkspaces, a as WORDMARK, b as getActiveWorkspaceId, c as applyTheme, d as noColorRequested, f as theme, g as themeVersion, h as themeModeFromColorFgBg, i as MARK_CELLS, l as findTheme, m as themeMode, n as buildCrashReport, p as themeForMode, r as writeCrashReport, s as DEFAULT_THEME_ID, t as installCrashHandler, u as monoTheme, v as themesForMode } from "./install-DEZmJLGH.mjs";
+import { L as saveTheme, P as resolveWebUrl, T as getSavedTheme, c as cardActionErrorMessage, d as reconcileMaskedInput, f as resolveConnectUrl, i as resolveAgent, l as parseExternalOauthConnectParams, m as specKeyFor, p as parseConnectCard, s as MASK_CHAR, u as parseOauthConnectParams, v as DEFAULT_API_URL, w as getReviewStateDir, x as getConfigPath, y as DEFAULT_APP_URL } from "./print-Cd-bVSEJ.mjs";
+import { a as errorMessage, i as sendErrorMessage, n as createRestClient, o as isRecord, r as errorDetail, t as HttpError } from "./rest-BlN_uWmL.mjs";
+import { t as PortalClient } from "./client-Dc7GZ3PG.mjs";
+import { d as makeLineParser, f as parseDaemonMessage, l as daemonPaths, n as ensureDaemonRunning, s as LOCAL_PROTOCOL_VERSION, u as encodeLine } from "./daemon-Co4CtpXZ.mjs";
+import { t as SandboxStream } from "./client-DfcJFEbh.mjs";
+import { t as runRawPtyPassthrough } from "./raw-pty-BcjbTjHJ.mjs";
 import * as os$1 from "node:os";
 import { homedir, platform, release, tmpdir } from "node:os";
 import path, { basename, extname, isAbsolute, join, win32 } from "node:path";
 import { z } from "zod";
 import open from "open";
-import { execFile, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
 import { constants } from "node:fs";
-import { MarkdownRenderable, RenderableEvents, SyntaxStyle, createCliRenderer, decodePasteBytes, detectLinks } from "@opentui/core";
+import { execFile, spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { connect, createConnection } from "node:net";
+import { access, appendFile, mkdir, mkdtemp, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { MarkdownRenderable, RenderableEvents, StyledText, SyntaxStyle, addDefaultParsers, createCliRenderer, decodePasteBytes, detectLinks, fg, link } from "@opentui/core";
 import { createRoot, extend, useKeyboard, usePaste, useRenderer, useTerminalDimensions } from "@opentui/react";
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { create } from "zustand";
-import { createConnection } from "node:net";
-import { access, appendFile, mkdir, mkdtemp, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { Fragment, jsx, jsxs } from "@opentui/react/jsx-runtime";
 import fuzzysort from "fuzzysort";
 import { fileURLToPath } from "node:url";
@@ -79,6 +78,7 @@ const useStore = create((set, get) => ({
 	toast: null,
 	seedPrompt: null,
 	autoGrantMachine: false,
+	newConversationIntent: false,
 	goTo: (screen) => set({
 		screen,
 		chatTitle: initialChatTitle(screen)
@@ -183,8 +183,8 @@ async function resolveInitialScreen({ rest, agentSelector, conversationId, newCo
 				createdAt: conversation.createdAt,
 				updatedAt: conversation.updatedAt,
 				preview: null,
-				channel: null,
-				channelLabel: null,
+				channel: conversation.channel,
+				channelLabel: conversation.channelLabel,
 				agent: {
 					id: agent.id,
 					name: agent.name,
@@ -228,23 +228,222 @@ async function resolveInitialScreen({ rest, agentSelector, conversationId, newCo
 	};
 }
 
+//#endregion
+//#region src/chat/portal/daemon-client.ts
+var PortalDaemonClient = class {
+	sessionId = randomUUID();
+	socket = null;
+	disposed = false;
+	reconnectTimer = null;
+	lastBind = null;
+	wantEnabled = false;
+	pendingGrants = /* @__PURE__ */ new Set();
+	grantedAgentIds = /* @__PURE__ */ new Set();
+	constructor(opts) {
+		this.opts = opts;
+	}
+	/** Spawn the daemon if needed and attach. Idempotent. */
+	async start() {
+		if (this.disposed) return;
+		await ensureDaemonRunning(this.opts.appUrl);
+		this.connect();
+	}
+	connect() {
+		if (this.disposed) return;
+		const { socketPath } = daemonPaths(this.opts.appUrl);
+		const socket = connect(socketPath);
+		socket.setEncoding("utf8");
+		this.socket = socket;
+		const parse = makeLineParser();
+		socket.on("connect", () => {
+			this.send({
+				t: "hello",
+				v: LOCAL_PROTOCOL_VERSION,
+				sessionId: this.sessionId,
+				token: this.opts.sessionToken
+			});
+			if (this.wantEnabled) this.send({ t: "enable" });
+			if (this.lastBind) this.send({
+				t: "bind",
+				sessionId: this.sessionId,
+				conversationId: this.lastBind.conversationId,
+				cwd: this.lastBind.cwd
+			});
+			for (const agentId of this.pendingGrants) this.send({
+				t: "grant",
+				agentId
+			});
+		});
+		socket.on("data", (chunk) => {
+			for (const line of parse(chunk)) {
+				const msg = parseDaemonMessage(line);
+				if (msg) this.onMessage(msg);
+			}
+		});
+		const onClose = () => {
+			if (this.socket === socket) this.socket = null;
+			this.scheduleReconnect();
+		};
+		socket.on("close", onClose);
+		socket.on("error", onClose);
+	}
+	scheduleReconnect() {
+		if (this.disposed || this.reconnectTimer) return;
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.start();
+		}, 500);
+		this.reconnectTimer.unref();
+	}
+	onMessage(msg) {
+		if (msg.t === "state") {
+			this.grantedAgentIds = new Set(msg.grantedAgentIds);
+			this.opts.onState({
+				status: msg.status,
+				machineName: msg.machineName,
+				friendlyName: msg.friendlyName,
+				error: msg.error,
+				grantedAgentIds: msg.grantedAgentIds
+			});
+		}
+	}
+	/** Whether this agent is currently authorized on the machine (last daemon state). */
+	isGranted(agentId) {
+		return this.grantedAgentIds.has(agentId);
+	}
+	/** Whether the user has turned machine sharing on from this CLI. */
+	isEnabled() {
+		return this.wantEnabled;
+	}
+	send(msg) {
+		if (this.socket?.writable) this.socket.write(encodeLine(msg));
+	}
+	/** Turn machine sharing on (the daemon connects the portal). */
+	enable() {
+		this.wantEnabled = true;
+		this.send({ t: "enable" });
+	}
+	/** Turn machine sharing off. */
+	disable() {
+		this.wantEnabled = false;
+		this.send({ t: "disable" });
+	}
+	/** Register / update this conversation's working directory for exec routing. */
+	bind(conversationId, cwd) {
+		this.lastBind = {
+			conversationId,
+			cwd
+		};
+		this.send({
+			t: "bind",
+			sessionId: this.sessionId,
+			conversationId,
+			cwd
+		});
+	}
+	/**
+	* Authorize one agent to run commands on this machine. Resolves once the
+	* request is sent to the daemon (the daemon performs the grant and pushes the
+	* updated state); kept async so it's a drop-in for the old in-process client's
+	* awaited `grantAgent`.
+	*/
+	grantAgent(agentId) {
+		this.pendingGrants.add(agentId);
+		this.send({
+			t: "grant",
+			agentId
+		});
+		return Promise.resolve();
+	}
+	/** Detach this CLI. The daemon keeps running for other clients. */
+	dispose() {
+		this.disposed = true;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		this.send({
+			t: "bye",
+			sessionId: this.sessionId
+		});
+		try {
+			this.socket?.destroy();
+		} catch (_error) {}
+		this.socket = null;
+	}
+};
+
+//#endregion
+//#region src/chat/portal/create-portal-client.ts
+/**
+* Escape hatch: setting `SKYDIVE_NO_DAEMON` (to any non-empty value)
+* makes the CLI bypass the portal daemon and open the portal connection
+* in-process, the pre-daemon behavior. This is a LOCAL env switch, not a remote
+* flag: it takes effect on the next CLI start and lets a user (or us) fall back
+* instantly if the daemon misbehaves in the wild, without shipping a new build.
+* The daemon is the default because it fixes the multi-process presence flap.
+*/
+function portalDaemonDisabled() {
+	return !!process.env.SKYDIVE_NO_DAEMON;
+}
+/**
+* Build the portal client the app should use: the daemon client by default, or
+* the in-process `PortalClient` when the kill switch is set. The in-process
+* client always runs exec in the launch cwd (it has no conversation map), which
+* is the exact pre-daemon behavior.
+*/
+function createPortalClient(opts) {
+	if (portalDaemonDisabled()) {
+		const client = new PortalClient({
+			appUrl: opts.appUrl,
+			sessionToken: opts.sessionToken,
+			resolveCwd: () => process.cwd(),
+			onState: (state) => opts.onState({
+				status: state.status,
+				machineName: state.machineName,
+				friendlyName: state.friendlyName,
+				error: state.error,
+				grantedAgentIds: state.grantedAgentIds
+			})
+		});
+		return {
+			start: () => Promise.resolve(),
+			enable: () => client.enable(),
+			disable: () => client.disable(),
+			grantAgent: (agentId) => client.grantAgent(agentId),
+			isGranted: (agentId) => client.isGranted(agentId),
+			bind: () => {},
+			dispose: () => client.dispose()
+		};
+	}
+	return new PortalDaemonClient(opts);
+}
+
 //#endregion
 //#region src/chat/portal/use-portal.ts
 /**
-* Owns the `PortalClient` lifecycle for the app session and keeps the store in
-* sync with its status. Constructed once from the resolved session; disabling
-* happens on unmount so quitting the TUI drops presence and kills any children.
+* Owns the portal DAEMON CLIENT lifecycle for the app session and keeps the
+* store in sync with the daemon's status.
+*
+* The CLI no longer opens the portal connection itself: it attaches to a
+* per-host daemon (spawned on demand) that owns the single portal WebSocket, so
+* multiple `skydive` processes on one machine share one portal identity instead
+* of fighting over it (the flap). This hook just wires the daemon client into
+* the store; the chat screen registers each conversation's working directory via
+* `portalClient.bind(...)` so the daemon runs that conversation's exec in the
+* right place.
+*
 * `shareMachine` opts in from launch (the `--share-machine` flag); otherwise the
-* user turns sharing on from the chat screen.
+* user turns sharing on from the chat screen. Detaching on unmount leaves the
+* daemon running for any other attached CLIs.
 */
 function usePortal({ appUrl, sessionToken, shareMachine }) {
 	const syncPortal = useStore((s) => s.syncPortal);
 	const setPortalClient = useStore((s) => s.setPortalClient);
 	useEffect(() => {
-		const client = new PortalClient({
+		const client = createPortalClient({
 			appUrl,
 			sessionToken,
-			cwd: process.cwd(),
 			onState: (state) => syncPortal({
 				status: state.status,
 				machineName: state.machineName,
@@ -253,7 +452,9 @@ function usePortal({ appUrl, sessionToken, shareMachine }) {
 			})
 		});
 		setPortalClient(client);
-		if (shareMachine) client.enable();
+		client.start().then(() => {
+			if (shareMachine) client.enable();
+		});
 		return () => {
 			client.dispose();
 			setPortalClient(null);
@@ -272,6 +473,9 @@ function usePortal({ appUrl, sessionToken, shareMachine }) {
 const noopAgentHost = {
 	transition() {},
 	setSession() {},
+	setTitle() {},
+	addPullRequest() {},
+	removePullRequest() {},
 	dispose() {}
 };
 const AgentHostContext = createContext(noopAgentHost);
@@ -293,6 +497,18 @@ function composeAgentHost(adapters) {
 			if (disposed) return;
 			for (const adapter of adapters) adapter.setSession?.(sessionId);
 		},
+		setTitle(title) {
+			if (disposed) return;
+			for (const adapter of adapters) adapter.setTitle?.(title);
+		},
+		addPullRequest(pr) {
+			if (disposed) return;
+			for (const adapter of adapters) adapter.addPullRequest?.(pr);
+		},
+		removePullRequest(pr) {
+			if (disposed) return;
+			for (const adapter of adapters) adapter.removePullRequest?.(pr);
+		},
 		dispose() {
 			if (disposed) return;
 			disposed = true;
@@ -354,6 +570,264 @@ function createTerminalNotificationsAdapter({ renderer, enabled }) {
 	};
 }
 
+//#endregion
+//#region src/chat/agent-host/adapters/terminal-title.ts
+/**
+* The title shown when there is no conversation title yet, or after the chat
+* closes. Keeps the tab identifiable as this CLI rather than leaving a stale
+* conversation name behind.
+*/
+const DEFAULT_TERMINAL_TITLE = "skydive";
+/**
+* Collapses a conversation title to a single terminal-title line. Titles arrive
+* from autoname / web / Slack and can carry newlines, tabs, or other control
+* characters (the same reason picker rows sanitize them); a raw newline in an
+* OSC title terminates the sequence early and corrupts the tab, so flatten
+* whitespace and drop C0 controls. Empty or whitespace-only input falls back to
+* the default so the tab is never blanked.
+*/
+function terminalTitleFor(title) {
+	if (!title) return DEFAULT_TERMINAL_TITLE;
+	return title.replace(/[\u0000-\u001f\u007f]+/g, " ").trim() || DEFAULT_TERMINAL_TITLE;
+}
+/**
+* Mirrors the live conversation title onto the terminal title (OSC), so a
+* multiplexer tab or window carries the conversation name instead of a bare
+* shell/binary label. OpenTUI owns the escape transport via
+* `setTerminalTitle`, so this never interleaves with the rendered frame.
+*
+* Writes are deduped, and the title is reset to a neutral default on dispose so
+* leaving the chat doesn't strand the last conversation's name on the tab.
+*/
+function createTerminalTitleAdapter({ renderer }) {
+	let last;
+	const apply = (next) => {
+		if (next === last) return;
+		last = next;
+		try {
+			renderer.setTerminalTitle(next);
+		} catch (_error) {}
+	};
+	return {
+		setTitle(title) {
+			apply(terminalTitleFor(title));
+		},
+		dispose() {
+			apply(DEFAULT_TERMINAL_TITLE);
+		}
+	};
+}
+
+//#endregion
+//#region src/chat/agent-host/adapters/cmux/workspace-title.ts
+/**
+* cmux is present only inside a cmux terminal. Reads the socket path and
+* workspace id from the environment; returns null when either is missing, so
+* the caller registers no adapter outside cmux.
+*/
+function cmuxWorkspaceEnv(env = process.env) {
+	const socketPath = env.CMUX_SOCKET_PATH?.trim();
+	const workspaceId = env.CMUX_WORKSPACE_ID?.trim();
+	if (!socketPath || !workspaceId) return null;
+	if (!socketPath.startsWith("/")) return null;
+	return {
+		socketPath,
+		workspaceId
+	};
+}
+/** The fields of a `workspace.current` result we care about. */
+const workspaceCurrentSchema = z.object({
+	workspace_id: z.string().optional(),
+	has_custom_title: z.boolean().optional()
+});
+/** True when the current workspace carries a user-set custom title. */
+async function hasUserCustomTitle(socket, workspaceId) {
+	const res = await socket.request("workspace.current", {});
+	const parsed = res?.ok ? workspaceCurrentSchema.safeParse(res.result) : void 0;
+	if (!parsed?.success) return false;
+	const result = parsed.data;
+	if (result.workspace_id && result.workspace_id !== workspaceId) return false;
+	return result.has_custom_title === true;
+}
+function createCmuxWorkspaceTitleAdapter({ socket, workspaceId }) {
+	let lastApplied;
+	let chain = Promise.resolve();
+	let pending = null;
+	const flush = async () => {
+		const desired = pending;
+		pending = null;
+		if (desired === null || desired === lastApplied) return;
+		if (await hasUserCustomTitle(socket, workspaceId)) {
+			lastApplied = desired;
+			return;
+		}
+		if ((await socket.request("workspace.rename", {
+			workspace_id: workspaceId,
+			title: desired
+		}))?.ok) lastApplied = desired;
+	};
+	return { setTitle(title) {
+		const next = title?.trim();
+		if (!next) return;
+		pending = next;
+		chain = chain.then(flush, flush);
+	} };
+}
+
+//#endregion
+//#region src/chat/agent-host/adapters/cmux/sidebar-pr.ts
+/** Neutral gray — deliberately not green/purple; we don't render PR state. */
+const PILL_COLOR = "#8b949e";
+const PILL_ICON = "git-pull-request";
+const PILL_PRIORITY = 90;
+/**
+* The cmux sidebar status key for a PR, derived from its repo-qualified
+* identity (`owner/repo#number`) so PRs from different repos never collide on a
+* shared `pr-<number>` slot. cmux keys are space-split tokens, so we sanitize
+* to `pr-<owner>-<repo>-<number>` (any non-alphanumeric run becomes `-`).
+*/
+function pillKey(prKey) {
+	return `pr-${prKey.replace(/[^a-z0-9]+/gi, "-")}`;
+}
+/**
+* A V1 socket arg value. cmux's line protocol splits on spaces, so a value
+* with spaces (our `PR #123` label) must be double-quoted; the flag values we
+* send (hex color, url, integers, the workspace id) never contain spaces or
+* quotes, so simple quoting of the label is sufficient and there is nothing to
+* escape.
+*/
+function quote(value) {
+	return `"${value}"`;
+}
+function createCmuxSidebarPrAdapter({ socket, workspaceId }) {
+	const applied = /* @__PURE__ */ new Set();
+	let chain = Promise.resolve();
+	const enqueue = (step) => {
+		chain = chain.then(step).catch((_error) => {});
+	};
+	const runSet = async (pr) => {
+		if (applied.has(pr.key)) return;
+		applied.add(pr.key);
+		const line = `set_status ${pillKey(pr.key)} ${quote(`PR #${pr.number}`)} --icon=${PILL_ICON} --color=${PILL_COLOR} --priority=${PILL_PRIORITY} --url=${pr.url} --tab=${workspaceId}`;
+		if (!await socket.command(line)) applied.delete(pr.key);
+	};
+	const runClear = async (prKey) => {
+		if (!applied.has(prKey)) return;
+		if (await socket.command(`clear_status ${pillKey(prKey)} --tab=${workspaceId}`)) applied.delete(prKey);
+	};
+	return {
+		addPullRequest(pr) {
+			enqueue(() => runSet(pr));
+		},
+		removePullRequest(pr) {
+			enqueue(() => runClear(pr.key));
+		},
+		dispose() {
+			const keys = [...applied];
+			for (const key of keys) enqueue(() => runClear(key));
+		}
+	};
+}
+
+//#endregion
+//#region src/chat/agent-host/adapters/cmux/socket.ts
+const cmuxRpcResponseSchema = z.object({
+	ok: z.boolean(),
+	result: z.unknown().optional(),
+	error: z.unknown().optional()
+});
+/** How long to wait for a single round-trip before giving up. */
+const RPC_TIMEOUT_MS = 1500;
+function createCmuxSocket({ socketPath, timeoutMs = RPC_TIMEOUT_MS }) {
+	let seq = 0;
+	const roundTrip = (requestLine, parseReply, onFailure) => new Promise((resolve) => {
+		let settled = false;
+		const finish = (value) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			try {
+				socket.destroy();
+			} catch (_error) {}
+			resolve(value);
+		};
+		const timer = setTimeout(() => finish(onFailure), timeoutMs);
+		let buffer = "";
+		const socket = connect(socketPath);
+		socket.setEncoding("utf8");
+		socket.on("connect", () => {
+			try {
+				socket.write(requestLine);
+			} catch (_error) {
+				finish(onFailure);
+			}
+		});
+		socket.on("data", (chunk) => {
+			buffer += chunk;
+			const newline = buffer.indexOf("\n");
+			if (newline === -1) return;
+			const line = buffer.slice(0, newline);
+			try {
+				finish(parseReply(line));
+			} catch (_error) {
+				finish(onFailure);
+			}
+		});
+		socket.on("error", () => finish(onFailure));
+		socket.on("close", () => finish(onFailure));
+	});
+	return {
+		command(line) {
+			`${++seq}`;
+			return roundTrip(`${line}\n`, (reply) => reply.startsWith("OK") || reply === "OK", false);
+		},
+		request(method, params) {
+			return new Promise((resolve) => {
+				let settled = false;
+				const finish = (value) => {
+					if (settled) return;
+					settled = true;
+					clearTimeout(timer);
+					try {
+						socket.destroy();
+					} catch (_error) {}
+					resolve(value);
+				};
+				const timer = setTimeout(() => finish(null), timeoutMs);
+				const id = `skydive-${++seq}`;
+				let buffer = "";
+				const socket = connect(socketPath);
+				socket.setEncoding("utf8");
+				socket.on("connect", () => {
+					try {
+						socket.write(`${JSON.stringify({
+							id,
+							method,
+							params
+						})}\n`);
+					} catch (_error) {
+						finish(null);
+					}
+				});
+				socket.on("data", (chunk) => {
+					buffer += chunk;
+					const newline = buffer.indexOf("\n");
+					if (newline === -1) return;
+					const line = buffer.slice(0, newline);
+					try {
+						const parsed = cmuxRpcResponseSchema.safeParse(JSON.parse(line));
+						finish(parsed.success ? parsed.data : null);
+					} catch (_error) {
+						finish(null);
+					}
+				});
+				socket.on("error", () => finish(null));
+				socket.on("close", () => finish(null));
+			});
+		}
+	};
+}
+
 //#endregion
 //#region src/chat/agent-host/adapters/herdr/adapter.ts
 /** Maps one complete semantic transition to one herdr state report. */
@@ -523,12 +997,161 @@ function createAgentHost({ renderer, notifications }) {
 	const adapters = [createTerminalNotificationsAdapter({
 		renderer,
 		enabled: notifications
-	})];
+	}), createTerminalTitleAdapter({ renderer })];
+	const cmux = cmuxWorkspaceEnv();
+	if (cmux) {
+		const socket = createCmuxSocket({ socketPath: cmux.socketPath });
+		adapters.push(createCmuxWorkspaceTitleAdapter({
+			socket,
+			workspaceId: cmux.workspaceId
+		}), createCmuxSidebarPrAdapter({
+			socket,
+			workspaceId: cmux.workspaceId
+		}));
+	}
 	const herdr = createHerdrReporter();
 	if (herdr) adapters.push(createHerdrAdapter(herdr));
 	return composeAgentHost(adapters);
 }
 
+//#endregion
+//#region src/chat/agent-host/pull-requests.ts
+/**
+* Matches a GitHub pull-request URL and captures its number. Scoped to
+* **github.com** on purpose, and this is a scope decision, not an oversight:
+*
+* cmux's native sidebar badge also resolves GitHub Enterprise (GHES) PRs, but
+* it does so from the workspace's **local git remote** (host-qualified
+* `(host, owner, repo)` + a per-host `gh auth token`). We parse a transcript
+* in a remote sandbox with no local `.git`, so from a bare URL we cannot tell
+* `git.acme.com/o/r/pull/5` is a GHES host from any other tool's `/pull/`
+* route — and a pill linking a misidentified URL is worse than no pill. So we
+* take the one host we can identify unambiguously (github.com, incl. `www.`),
+* which covers the common product case; GHES stays the native badge's job.
+*
+* Only the `/pull/<n>` form (not `/issues/`, not a bare `#123` — ambiguous with
+* issues without local repo context we don't have). A trailing path/query/
+* fragment (e.g. `/files`, `#discussion`) is allowed but not captured into the
+* canonical URL. Also matches inside markdown links, backticks, and trailing
+* punctuation.
+*/
+const PR_URL_RE = /https?:\/\/(?:www\.)?github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/gi;
+/**
+* Extracts every distinct GitHub PR referenced in a block of text, in first-seen
+* order, de-duplicated by **repo-qualified identity** (`owner/repo#number`) —
+* NOT by number, since `#42` can exist in many repos. Each ref carries a
+* canonicalized URL (scheme + host + `/owner/repo/pull/number`, no trailing
+* path/query/fragment) so the same PR linked twice with different fragments
+* collapses to one pill.
+*/
+function extractPullRequests(text, options) {
+	const requireCompleteNumber = options?.requireCompleteNumber ?? true;
+	const byKey = /* @__PURE__ */ new Map();
+	for (const match of text.matchAll(PR_URL_RE)) {
+		const owner = match[1];
+		const repo = match[2];
+		const numberText = match[3];
+		if (!owner || !repo || !numberText) continue;
+		if (requireCompleteNumber) {
+			if (match.index + match[0].length >= text.length) continue;
+		}
+		const number = Number.parseInt(numberText, 10);
+		if (!Number.isFinite(number) || number <= 0) continue;
+		const key = `${owner.toLowerCase()}/${repo.toLowerCase()}#${number}`;
+		if (byKey.has(key)) continue;
+		byKey.set(key, {
+			number,
+			key,
+			url: `https://github.com/${owner}/${repo}/pull/${number}`
+		});
+	}
+	return [...byKey.values()];
+}
+/**
+* Flattens an arbitrary tool-output value into one string we can scan for PR
+* URLs. A tool's output is usually a string (bash stdout, a `gh pr create`
+* line) but can be a structured payload (an object/array of content parts), so
+* we walk it and concatenate every string we find. Depth- and size-bounded so
+* a pathological payload can't blow up the scan; the cap is generous because a
+* PR URL a tool prints is short and lands early in normal output.
+*/
+function stringifyToolOutput(value) {
+	const MAX_LEN = 2e5;
+	const parts = [];
+	let total = 0;
+	const visit = (v, depth) => {
+		if (total >= MAX_LEN || depth > 6) return;
+		if (typeof v === "string") {
+			parts.push(v);
+			total += v.length;
+			return;
+		}
+		if (Array.isArray(v)) {
+			for (const item of v) {
+				if (total >= MAX_LEN) return;
+				visit(item, depth + 1);
+			}
+			return;
+		}
+		if (v && typeof v === "object") for (const item of Object.values(v)) {
+			if (total >= MAX_LEN) return;
+			visit(item, depth + 1);
+		}
+	};
+	visit(value, 0);
+	return parts.join("\n");
+}
+/**
+* A streaming PR scanner: fed run chunks as they stream, it reports each
+* distinct PR the moment its URL is seen, exactly once, without ever rescanning
+* the transcript. Two sources feed it:
+*
+* - **Assistant text** (`text-delta`): accumulated per part id (a URL can split
+*   across two deltas) and only the current part's buffer is scanned, so cost
+*   is bounded by one text block, not the whole scrollback.
+* - **Tool output** (`tool-output-available`): the settled output of a tool
+*   call (e.g. `gh pr create` stdout) arrives whole, not delta-streamed, so we
+*   flatten and scan it in one pass. This catches PRs a tool printed that the
+*   agent never restated in prose — the common case for an opened PR.
+*
+* `onPullRequest` fires once per never-before-seen PR (keyed by
+* `owner/repo#number`) for the life of the scanner, regardless of which source
+* it came from. Construct one per run (or per conversation) and feed it the
+* same chunks the transcript reducer sees.
+*/
+function createPullRequestScanner(onPullRequest) {
+	let text = "";
+	let lastPartId;
+	const seen = /* @__PURE__ */ new Set();
+	const report = (buffer, final) => {
+		for (const pr of extractPullRequests(buffer, { requireCompleteNumber: !final })) {
+			if (seen.has(pr.key)) continue;
+			seen.add(pr.key);
+			onPullRequest(pr);
+		}
+	};
+	return { addChunk(chunk) {
+		if (chunk["type"] === "tool-output-available") {
+			const outputText = stringifyToolOutput(chunk["output"]);
+			if (!outputText.includes("/pull/")) return;
+			report(outputText, true);
+			return;
+		}
+		if (chunk["type"] !== "text-delta") return;
+		const delta = typeof chunk["delta"] === "string" ? chunk["delta"] : typeof chunk["text"] === "string" ? chunk["text"] : "";
+		if (!delta) return;
+		const partId = typeof chunk["id"] === "string" ? chunk["id"] : void 0;
+		if (partId && lastPartId && partId !== lastPartId) {
+			if (text.includes("/pull/")) report(text, true);
+			text = "";
+		}
+		text += delta;
+		lastPartId = partId ?? lastPartId;
+		if (!text.includes("/pull/")) return;
+		report(text, false);
+	} };
+}
+
 //#endregion
 //#region src/chat/clipboard.ts
 /** Spawns a command with no stdin and collects its stdout. Resolves (never
@@ -840,22 +1463,52 @@ function portalIndicator(portal) {
 		};
 	}
 }
-function screenLabel(screen, chatTitle) {
+/**
+* The per-screen label, split into its parts: the screen's own `title` and,
+* when the screen belongs to an agent, that `agentName`. Kept structured so the
+* two surfaces can order the parts differently — the status bar reads
+* agent-first (a header), the terminal/workspace title reads title-first.
+*/
+function screenLabelParts(screen, chatTitle) {
 	switch (screen.kind) {
-		case "splash": return "";
-		case "error": return "";
-		case "agent-picker": return "pick an agent";
-		case "agent-create": return "create an agent";
-		case "workspace-picker": return "switch workspace";
-		case "conversation-picker": return `${screen.agent.name} · pick a conversation`;
+		case "splash": return { title: "" };
+		case "error": return { title: "" };
+		case "agent-picker": return { title: "pick an agent" };
+		case "agent-create": return { title: "create an agent" };
+		case "workspace-picker": return { title: "switch workspace" };
+		case "conversation-picker": return {
+			title: "pick a conversation",
+			agentName: screen.agent.name
+		};
 		case "chat": {
 			const c = screen.conversation;
 			const known = isNewConv(c) ? null : c.title ?? null;
-			const label = chatTitle ?? known ?? (isNewConv(c) ? "new conversation" : "untitled");
-			return `${screen.agent.name} · ${label}`;
+			return {
+				title: chatTitle ?? known ?? (isNewConv(c) ? "new conversation" : "untitled"),
+				agentName: screen.agent.name
+			};
 		}
 	}
 }
+/**
+* Status-bar label: agent-first (`agent · title`), which reads as a header of
+* who you're talking to and where.
+*/
+function screenLabel(screen, chatTitle) {
+	const { title, agentName } = screenLabelParts(screen, chatTitle);
+	if (!title) return "";
+	return agentName ? `${agentName} · ${title}` : title;
+}
+/**
+* Terminal tab / cmux workspace title: title-first (`title · agent`), so the
+* conversation reads first in a tab or sidebar entry, with the agent as the
+* trailing qualifier.
+*/
+function titleLabel(screen, chatTitle) {
+	const { title, agentName } = screenLabelParts(screen, chatTitle);
+	if (!title) return "";
+	return agentName ? `${title} · ${agentName}` : title;
+}
 function isNewConv(c) {
 	return "kind" in c && c.kind === "new";
 }
@@ -871,19 +1524,42 @@ function windowStart(highlight, total, visible) {
 
 //#endregion
 //#region src/chat/tui/fuzzy.ts
+function keyAccessor(key) {
+	return typeof key === "function" ? key : key.get;
+}
+function keyWeight(key) {
+	return typeof key === "function" ? 1 : key.weight ?? 1;
+}
 /**
 * Rank `items` against `query` across multiple keys with fuzzysort — the
 * OpenCode pattern. An empty/whitespace query returns everything in the
 * caller's original order (fuzzysort has nothing to rank); otherwise items
 * where no key matches are dropped and the rest come back best-first.
+*
+* fuzzysort's default multi-key score is the *best* single key's raw score,
+* with every key weighted equally — so an exact word sitting in a low-priority
+* field (a message preview, a co-participant's name) beats a genuine but
+* slightly-fuzzier match in the title. When keys carry weights we instead rank
+* by the best *weighted* key score, so a title match wins ties (and near-ties)
+* against secondary fields. Per-key highlight indexes are unchanged; only the
+* ordering shifts.
 */
 function fuzzyFilter(query, items, keys) {
 	const needle = query.trim();
+	const accessors = keys.map(keyAccessor);
 	if (!needle) return items.map((item) => ({
 		item,
 		highlights: keys.map(() => null)
 	}));
-	return fuzzysort.go(needle, items, { keys: [...keys] }).map((result) => ({
+	const weights = keys.map(keyWeight);
+	const weighted = weights.some((w) => w !== 1);
+	return fuzzysort.go(needle, items, {
+		keys: accessors,
+		...weighted ? { scoreFn: (r) => Math.max(...weights.map((w, i) => {
+			const keyResult = r[i];
+			return keyResult ? keyResult.score * w : 0;
+		})) } : {}
+	}).map((result) => ({
 		item: result.obj,
 		highlights: keys.map((_key, i) => {
 			const indexes = result[i]?.indexes;
@@ -931,6 +1607,76 @@ function FuzzyText({ text, indexes, fg }) {
 	}, i)) });
 }
 
+//#endregion
+//#region src/chat/tui/skydive-mark.tsx
+/**
+* The Skydive brand splash for the interactive TUI, rendered as OpenTUI React
+* nodes (not raw ANSI). Two variants:
+*
+*   - `variant="full"`  — the six-petal mark beside the SKYDIVE wordmark.
+*   - `variant="mark"`  — just the pinwheel mark (compact picker headers).
+*
+* The mark paints fixed brand hexes (a logo is a logo). The wordmark follows
+* the current theme's body text (`theme.fg`) so it reads white-ish on dark
+* themes and dark on light ones. Under NO_COLOR the theme palette is all
+* `undefined`; we detect that and render uncolored so it degrades with the
+* rest of the UI.
+*/
+function noColor() {
+	return theme.fg === void 0;
+}
+function MarkRows({ mono }) {
+	return /* @__PURE__ */ jsx("box", {
+		style: { flexDirection: "column" },
+		children: MARK_CELLS.map((row, r) => /* @__PURE__ */ jsx("text", { children: row.map((cell, c) => cell === " " ? /* @__PURE__ */ jsx("span", { children: " " }, c) : /* @__PURE__ */ jsx("span", {
+			fg: mono ? void 0 : cell[1],
+			children: cell[0]
+		}, c)) }, r))
+	});
+}
+function WordmarkRows({ mono }) {
+	const color = mono ? void 0 : theme.fg;
+	return /* @__PURE__ */ jsx("box", {
+		style: { flexDirection: "column" },
+		children: WORDMARK.map((line, r) => /* @__PURE__ */ jsx("text", { children: /* @__PURE__ */ jsx("span", {
+			fg: color,
+			children: line
+		}) }, r))
+	});
+}
+/**
+* Height-aware brand header for the pickers. Always shown (including while the
+* list is loading / empty / erroring) so the splash is never gated on data.
+* Full mark + wordmark when the terminal is tall enough; compact one-liner on
+* short terminals so the list still has room.
+*/
+function BrandHeader({ height }) {
+	if (height >= 24) return /* @__PURE__ */ jsxs("box", {
+		style: { flexDirection: "column" },
+		children: [/* @__PURE__ */ jsx(SkydiveMark, { variant: "full" }), /* @__PURE__ */ jsx("box", { style: { height: 1 } })]
+	});
+	return /* @__PURE__ */ jsx("text", {
+		fg: theme.fg,
+		children: "✦ Skydive"
+	});
+}
+/** Row budget the BrandHeader consumes; callers subtract this from visibleRows. */
+function brandHeaderRows(height) {
+	return height >= 24 ? 7 : 1;
+}
+function SkydiveMark({ variant = "full" }) {
+	const mono = noColor();
+	if (variant === "mark") return /* @__PURE__ */ jsx(MarkRows, { mono });
+	return /* @__PURE__ */ jsxs("box", {
+		style: { flexDirection: "row" },
+		children: [
+			/* @__PURE__ */ jsx(MarkRows, { mono }),
+			/* @__PURE__ */ jsx("box", { style: { width: 3 } }),
+			/* @__PURE__ */ jsx(WordmarkRows, { mono })
+		]
+	});
+}
+
 //#endregion
 //#region src/chat/tui/screens/agent-picker.tsx
 function AgentPickerScreen() {
@@ -998,17 +1744,36 @@ function AgentPickerScreen() {
 		scope,
 		cache
 	]);
-	if (state.kind === "loading") return /* @__PURE__ */ jsx("text", {
-		fg: theme.muted,
-		children: "loading agents…"
+	const { height } = useTerminalDimensions();
+	if (state.kind === "loading") return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsx("text", {
+			fg: theme.muted,
+			children: "loading agents…"
+		})]
 	});
-	if (state.kind === "error") return /* @__PURE__ */ jsxs("text", {
-		fg: theme.error,
-		children: ["error: ", state.message]
+	if (state.kind === "error") return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsxs("text", {
+			fg: theme.error,
+			children: ["error: ", state.message]
+		})]
 	});
-	if (state.agents.length === 0) return /* @__PURE__ */ jsx("text", {
-		fg: theme.muted,
-		children: scope === "mine" ? "no agents of yours yet. press tab to see all agents, ctrl+w to switch workspace, or ctrl+n to create one." : "no agents in this workspace. press ctrl+w to switch workspace, or ctrl+n to create one."
+	if (state.agents.length === 0) return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsx("text", {
+			fg: theme.muted,
+			children: scope === "mine" ? "no agents of yours yet. press tab to see all agents, ctrl+w to switch workspace, or ctrl+n to create one." : "no agents in this workspace. press ctrl+w to switch workspace, or ctrl+n to create one."
+		})]
 	});
 	return /* @__PURE__ */ jsx(FilterableAgentList, {
 		agents: state.agents,
@@ -1026,7 +1791,7 @@ function FilterableAgentList({ agents, scope, onPick }) {
 	const hits = fuzzyFilter(query, agents, agentKeys);
 	const filtered = hits.map((h) => h.item);
 	const clamped = Math.min(highlight, Math.max(0, filtered.length - 1));
-	const visibleRows = Math.max(3, height - 6);
+	const visibleRows = Math.max(3, height - 6 - brandHeaderRows(height));
 	const start = windowStart(clamped, filtered.length, visibleRows);
 	const windowed = hits.slice(start, start + visibleRows);
 	useKeyboard((key) => {
@@ -1035,7 +1800,8 @@ function FilterableAgentList({ agents, scope, onPick }) {
 		else if (key.name === "return") {
 			const agent = filtered[clamped];
 			if (!agent) return;
-			onPick(useStore.getState().seedPrompt !== null ? {
+			const store = useStore.getState();
+			onPick(store.seedPrompt !== null || store.newConversationIntent ? {
 				kind: "chat",
 				agent,
 				conversation: {
@@ -1055,6 +1821,7 @@ function FilterableAgentList({ agents, scope, onPick }) {
 			flexGrow: 1
 		},
 		children: [
+			/* @__PURE__ */ jsx(BrandHeader, { height }),
 			/* @__PURE__ */ jsxs("box", {
 				style: {
 					flexDirection: "row",
@@ -1122,9 +1889,18 @@ function FilterableAgentList({ agents, scope, onPick }) {
 	});
 }
 const agentKeys = [
-	(a) => a.name,
-	(a) => a.slug ?? "",
-	(a) => a.title ?? ""
+	{
+		get: (a) => a.name,
+		weight: 1
+	},
+	{
+		get: (a) => a.slug ?? "",
+		weight: .6
+	},
+	{
+		get: (a) => a.title ?? "",
+		weight: .4
+	}
 ];
 
 //#endregion
@@ -1153,6 +1929,17 @@ function AgentCreateScreen() {
 	const fail = useStore((s) => s.fail);
 	const [name, setName] = useState("");
 	const [state, setState] = useState({ kind: "idle" });
+	useEffect(() => {
+		if (!rest) return;
+		let cancelled = false;
+		rest.suggestAgentIdentity().then((suggestion) => {
+			if (cancelled || !suggestion) return;
+			setName((current) => current ? current : suggestion.name);
+		}).catch(() => {});
+		return () => {
+			cancelled = true;
+		};
+	}, [rest]);
 	useKeyboard((key) => {
 		if (key.name === "escape" && state.kind !== "creating") goTo({ kind: "agent-picker" });
 	});
@@ -1515,27 +2302,45 @@ function singleLine(text) {
 	return out;
 }
 /**
-* Fit a row's title and trailing detail into `width` columns. The title
-* identifies the row so it gets the space first; the detail takes what is
-* left and is dropped when nothing is.
+* Fit a row's title, an optional mid-row `tag` and a trailing detail into
+* `width` columns, each rendered separated by one space. The title identifies
+* the row so it gets the space first; the tag comes next because it carries
+* information the detail does not; the detail takes what is left and is
+* dropped when nothing is.
 */
-function fitRowText(title, detail, width) {
+function fitRowText(title, detail, width, tag = "") {
 	if (width <= 0) return {
 		title: "",
-		detail: ""
+		detail: "",
+		tag: ""
 	};
-	if ((detail ? title.length + 1 + detail.length : title.length) <= width) return {
+	const segment = (text) => text ? text.length + 1 : 0;
+	if (title.length + segment(tag) + segment(detail) <= width) return {
 		title,
-		detail
+		detail,
+		tag
 	};
 	const room = width - title.length - 1;
 	if (room < 2) return {
 		title: truncate(title, width),
-		detail: ""
+		detail: "",
+		tag: ""
+	};
+	if (title.length + segment(tag) > width) return {
+		title,
+		detail: "",
+		tag: truncate(tag, room)
+	};
+	const detailRoom = room - segment(tag);
+	if (detailRoom < 2) return {
+		title,
+		detail: "",
+		tag
 	};
 	return {
 		title,
-		detail: truncate(detail, room)
+		detail: truncate(detail, detailRoom),
+		tag
 	};
 }
 /**
@@ -1552,8 +2357,29 @@ function fitHintLine(segments, width) {
 	return truncate(kept.join(" · "), width);
 }
 
+//#endregion
+//#region src/chat/tui/use-debounced-value.ts
+/**
+* Returns a copy of `value` that only updates after it has stopped changing
+* for `delayMs`. Use it to throttle work driven by fast-changing state — e.g.
+* a search input whose every keystroke would otherwise fire a new request.
+*
+* Mirrors the web app's `useDebouncedValue` so the CLI conversation search
+* debounces its server query the same way the web sidebar does.
+*/
+function useDebouncedValue(value, delayMs) {
+	const [debounced, setDebounced] = useState(value);
+	useEffect(() => {
+		const timer = setTimeout(() => setDebounced(value), delayMs);
+		return () => clearTimeout(timer);
+	}, [value, delayMs]);
+	return debounced;
+}
+
 //#endregion
 //#region src/chat/tui/screens/conversation-picker.tsx
+const SEARCH_DEBOUNCE_MS = 250;
+const SEARCH_QUERY_MAX_LENGTH = 200;
 const humanChannels = [
 	"web",
 	"slack",
@@ -1564,9 +2390,10 @@ function ConversationPickerScreen({ agent }) {
 	const rest = useStore((s) => s.rest);
 	const goTo = useStore((s) => s.goTo);
 	const [showAutomated, setShowAutomated] = useState(false);
+	const [showArchived, setShowArchived] = useState(false);
 	const [cache, setCache] = useState({});
 	const [state, setState] = useState({ kind: "loading" });
-	const cacheKey = showAutomated ? "all" : "human";
+	const cacheKey = `${showAutomated ? "all" : "human"}:${showArchived ? "with-archived" : "active"}`;
 	useEffect(() => {
 		if (!rest) return;
 		const cached = cache[cacheKey];
@@ -1585,6 +2412,7 @@ function ConversationPickerScreen({ agent }) {
 				const conversations = await rest.listConversations({
 					agentId: agent.id,
 					channels: showAutomated ? void 0 : humanChannels,
+					archived: showArchived ? "include" : "exclude",
 					onPage: (partial) => {
 						if (!cancelled) setState({
 							kind: "ready",
@@ -1618,16 +2446,30 @@ function ConversationPickerScreen({ agent }) {
 		rest,
 		agent.id,
 		showAutomated,
+		showArchived,
 		cacheKey,
 		cache
 	]);
-	if (state.kind === "loading") return /* @__PURE__ */ jsx("text", {
-		fg: theme.muted,
-		children: "loading conversations…"
+	const { height } = useTerminalDimensions();
+	if (state.kind === "loading") return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsx("text", {
+			fg: theme.muted,
+			children: "loading conversations…"
+		})]
 	});
-	if (state.kind === "error") return /* @__PURE__ */ jsxs("text", {
-		fg: theme.error,
-		children: ["error: ", state.message]
+	if (state.kind === "error") return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsxs("text", {
+			fg: theme.error,
+			children: ["error: ", state.message]
+		})]
 	});
 	return /* @__PURE__ */ jsx(ConversationList, {
 		agent,
@@ -1635,49 +2477,125 @@ function ConversationPickerScreen({ agent }) {
 		complete: state.complete,
 		showAutomated,
 		onToggleAutomated: () => setShowAutomated((shown) => !shown),
+		showArchived,
+		onToggleArchived: () => setShowArchived((shown) => !shown),
 		onPick: goTo
 	});
 }
-function ConversationList({ agent, conversations, complete, showAutomated, onToggleAutomated, onPick }) {
+function ConversationList({ agent, conversations, complete, showAutomated, onToggleAutomated, showArchived, onToggleArchived, onPick }) {
 	const { width, height } = useTerminalDimensions();
 	const rest = useStore((s) => s.rest);
 	const [query, setQuery] = useState("");
 	const [highlight, setHighlight] = useState(0);
+	const debouncedQuery = useDebouncedValue(query.trim(), SEARCH_DEBOUNCE_MS);
+	const isSearching = debouncedQuery.length > 0;
+	const [search, setSearch] = useState(null);
+	useEffect(() => {
+		if (!rest || !isSearching) {
+			setSearch(null);
+			return;
+		}
+		let cancelled = false;
+		setSearch({
+			query: debouncedQuery,
+			state: { kind: "loading" }
+		});
+		(async () => {
+			try {
+				const results = await rest.listConversations({
+					agentId: agent.id,
+					channels: showAutomated ? void 0 : humanChannels,
+					archived: showArchived ? "include" : "exclude",
+					query: debouncedQuery,
+					onPage: (partial) => {
+						if (!cancelled) setSearch({
+							query: debouncedQuery,
+							state: {
+								kind: "ready",
+								conversations: partial
+							}
+						});
+					}
+				});
+				if (cancelled) return;
+				setSearch({
+					query: debouncedQuery,
+					state: {
+						kind: "ready",
+						conversations: results
+					}
+				});
+			} catch (err) {
+				if (cancelled) return;
+				setSearch({
+					query: debouncedQuery,
+					state: {
+						kind: "error",
+						message: err instanceof Error ? err.message : String(err)
+					}
+				});
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		rest,
+		agent.id,
+		debouncedQuery,
+		isSearching,
+		showAutomated,
+		showArchived
+	]);
 	const [removedIds, setRemovedIds] = useState(/* @__PURE__ */ new Set());
+	const [archiveOverrides, setArchiveOverrides] = useState(/* @__PURE__ */ new Map());
 	const [confirmId, setConfirmId] = useState(null);
 	const [error, setError] = useState(null);
-	const list = conversations.filter((c) => !removedIds.has(c.id));
+	const isArchived = (c) => archiveOverrides.get(c.id) ?? c.viewerArchivedAt != null;
+	const list = ((isSearching && search?.query === debouncedQuery && search.state.kind === "ready" ? search.state.conversations : null) ?? conversations).filter((c) => !removedIds.has(c.id) && (showArchived || !isArchived(c)));
 	useEffect(() => {
 		setHighlight(0);
-	}, [showAutomated]);
-	const hits = fuzzyFilter(query, list, conversationKeys);
+	}, [showAutomated, showArchived]);
+	const hits = isSearching ? list.map((item) => ({
+		item,
+		highlights: [
+			substringIndexes(singleLine(item.title ?? ""), debouncedQuery),
+			null,
+			null
+		]
+	})) : fuzzyFilter(query, list, conversationKeys);
 	const rows = [{ kind: "new" }, ...hits.map((hit) => ({
 		kind: "conv",
 		hit
 	}))];
 	const innerWidth = Math.max(1, width - 2);
 	const rowWidth = Math.max(1, innerWidth - 2);
+	const clamped = Math.min(highlight, Math.max(0, rows.length - 1));
+	const highlightRow = rows[clamped];
+	const highlightArchived = highlightRow?.kind === "conv" && isArchived(highlightRow.hit.item);
 	const confirmConv = confirmId !== null ? list.find((c) => c.id === confirmId) : void 0;
+	const searchState = isSearching ? search?.state : void 0;
+	const countSegment = isSearching && (searchState?.kind === "loading" || search === null) ? "searching…" : isSearching && searchState?.kind === "error" ? `search failed: ${searchState.message}` : `${hits.length}/${list.length}${complete || isSearching ? "" : " (loading…)"}`;
 	const status = confirmConv ? {
 		fg: theme.error,
 		text: truncate(`delete “${confirmConv.title ?? "(untitled)"}”? y/n`, innerWidth)
 	} : error ? {
 		fg: theme.error,
-		text: truncate(`delete failed: ${error}`, innerWidth)
+		text: truncate(error, innerWidth)
 	} : {
 		fg: theme.dim,
 		text: fitHintLine([
-			`${hits.length}/${list.length}${complete ? "" : " (loading…)"}`,
-			showAutomated ? "incl. agent runs" : "yours",
+			countSegment,
+			`ctrl+a ${highlightArchived ? "unarchive" : "archive"}`,
+			"ctrl+d delete",
 			`tab ${showAutomated ? "hide" : "show"} agent runs`,
+			`shift+tab ${showArchived ? "hide" : "show"} archived`,
+			"esc back",
 			"↑/↓ move",
-			"↵ open",
-			"ctrl+d delete",
-			"esc back"
+			"↵ open"
 		], innerWidth)
 	};
-	const clamped = Math.min(highlight, Math.max(0, rows.length - 1));
-	const visibleRows = Math.max(3, height - 6);
+	const visibleRows = Math.max(3, height - 6 - brandHeaderRows(height));
 	const start = windowStart(clamped, rows.length, visibleRows);
 	const windowed = rows.slice(start, start + visibleRows);
 	const open = (row) => {
@@ -1696,18 +2614,50 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 			conversation: row.hit.item
 		});
 	};
-	const deleteConversation = (id) => {
-		if (!rest) return;
+	/**
+	* Optimistically drop a row, run `mutate`, and put the row back if it fails.
+	* Delete only — archive keeps the row and flips its mark instead.
+	*/
+	const removeRow = (id, mutate, failure) => {
 		if (!list.some((c) => c.id === id)) return;
-		setConfirmId(null);
 		setRemovedIds((prev) => new Set([...prev, id]));
-		rest.deleteConversation({ conversationId: id }).catch((err) => {
+		mutate().catch((err) => {
 			setRemovedIds((prev) => {
 				const next = new Set(prev);
 				next.delete(id);
 				return next;
 			});
-			setError(err instanceof Error ? err.message : String(err));
+			setError(`${failure}: ${err instanceof Error ? err.message : String(err)}`);
+		});
+	};
+	const deleteConversation = (id) => {
+		if (!rest) return;
+		setConfirmId(null);
+		removeRow(id, () => rest.deleteConversation({ conversationId: id }), "delete failed");
+	};
+	/**
+	* Archive is per-user, private and reversible, so unlike delete it needs no
+	* y/n confirm. `ctrl+a` toggles: on a row you already archived (only
+	* reachable with archived rows shown) it restores instead — which is the
+	* only in-TUI way back.
+	*/
+	const toggleArchived = (conversation) => {
+		if (!rest) return;
+		const id = conversation.id;
+		const archived = !isArchived(conversation);
+		const revert = archiveOverrides.get(id);
+		setArchiveOverrides((prev) => new Map(prev).set(id, archived));
+		rest.setConversationArchived({
+			conversationId: id,
+			archived
+		}).catch((err) => {
+			setArchiveOverrides((prev) => {
+				const next = new Map(prev);
+				if (revert === void 0) next.delete(id);
+				else next.set(id, revert);
+				return next;
+			});
+			setError(`${archived ? "archive" : "unarchive"} failed: ${err instanceof Error ? err.message : String(err)}`);
 		});
 	};
 	useKeyboard((key) => {
@@ -1725,7 +2675,14 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 				setError(null);
 				setConfirmId(row.hit.item.id);
 			}
-		} else if (key.name === "tab") onToggleAutomated();
+		} else if (key.name === "a" && key.ctrl) {
+			const row = rows[clamped];
+			if (row?.kind === "conv") {
+				setError(null);
+				toggleArchived(row.hit.item);
+			}
+		} else if (key.name === "tab" && key.shift) onToggleArchived();
+		else if (key.name === "tab") onToggleAutomated();
 		else if (key.name === "return") {
 			const row = rows[clamped];
 			if (row) open(row);
@@ -1737,6 +2694,7 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 			flexGrow: 1
 		},
 		children: [
+			/* @__PURE__ */ jsx(BrandHeader, { height }),
 			/* @__PURE__ */ jsxs("box", {
 				style: {
 					flexDirection: "row",
@@ -1749,8 +2707,9 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 					placeholder: "type to filter…",
 					focused: confirmId === null,
 					width: Math.max(10, width - 12),
+					maxLength: SEARCH_QUERY_MAX_LENGTH,
 					onInput: (value) => {
-						setQuery(value);
+						setQuery(value.slice(0, SEARCH_QUERY_MAX_LENGTH));
 						setHighlight(0);
 					}
 				})]
@@ -1772,15 +2731,20 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 						fg,
 						children: [marker, truncate("+ new conversation", rowWidth)]
 					}, "new");
-					const { title, detail } = fitRowText(singleLine(row.hit.item.title ?? "(untitled)"), previewLine(row.hit.item), rowWidth);
+					const archived = isArchived(row.hit.item);
+					const { title, detail, tag } = fitRowText(singleLine(row.hit.item.title ?? "(untitled)"), `${archived ? "archived · " : ""}${previewLine(row.hit.item)}`, rowWidth, coAgentsTag(row.hit.item, agent.id));
 					return /* @__PURE__ */ jsxs("text", {
-						fg,
+						fg: archived && !selected ? theme.dim : fg,
 						children: [
 							marker,
 							/* @__PURE__ */ jsx(FuzzyText, {
 								text: title,
 								indexes: row.hit.item.title ? row.hit.highlights[0] : null
 							}),
+							tag ? /* @__PURE__ */ jsxs("span", {
+								fg: theme.muted,
+								children: [" ", tag]
+							}) : null,
 							detail ? /* @__PURE__ */ jsxs("span", {
 								fg: theme.dim,
 								children: [" ", detail]
@@ -1792,7 +2756,50 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 		]
 	});
 }
-const conversationKeys = [(c) => singleLine(c.title ?? ""), (c) => c.preview ?? ""];
+/**
+* Tags a row with the thread's other agents (`+Grace, Ada`). The picker is
+* entered per agent, so that agent stays implicit and only its co-participants
+* are named — this tag is the only thing in the list distinguishing a
+* multi-agent thread from a solo one. Empty for a solo thread.
+*
+* A string rather than a component because the row's one-line budget has to
+* account for it (see list-line.ts).
+*/
+function coAgentsTag(conv, viewerAgentId) {
+	const names = conversationAgents(conv).filter((a) => a.id !== viewerAgentId).map((a) => a.name);
+	return names.length > 0 ? `+${names.join(", ")}` : "";
+}
+function conversationAgents(c) {
+	return c.agents && c.agents.length > 0 ? c.agents : [c.agent];
+}
+const conversationKeys = [
+	{
+		get: (c) => singleLine(c.title ?? ""),
+		weight: 1
+	},
+	{
+		get: (c) => c.preview ?? "",
+		weight: .6
+	},
+	{
+		get: (c) => conversationAgents(c).map((a) => a.name).join(" "),
+		weight: .4
+	}
+];
+/**
+* Character indexes of the first case-insensitive occurrence of `needle` in
+* `haystack`, for highlighting a literal title match under server search (the
+* server's title branch is a substring ILIKE). Null when it doesn't occur — a
+* server row can match on message body or participant name without its title
+* containing the query, in which case nothing in the title is highlighted.
+*/
+function substringIndexes(haystack, needle) {
+	const trimmed = needle.trim();
+	if (!trimmed) return null;
+	const at = haystack.toLowerCase().indexOf(trimmed.toLowerCase());
+	if (at < 0) return null;
+	return Array.from({ length: trimmed.length }, (_, i) => at + i);
+}
 function previewLine(c) {
 	const when = relativeTime(c.updatedAt);
 	const prefix = c.preview ? c.preview.replace(/\s+/g, " ").trim() : "";
@@ -1807,6 +2814,33 @@ function relativeTime(iso) {
 	return `${Math.floor(diffMs / 864e5)}d ago`;
 }
 
+//#endregion
+//#region src/chat/conversation-ref.ts
+/**
+* Parsing the conversation reference a user hands `/conversation`.
+*
+* The whole point of the command is that you paste whatever you already have
+* in front of you, so every form the platform hands out has to work: a bare
+* id, the `https://skydive.com/c/<id>` link an agent replies with, or the
+* `skydive chat --resume <id>` line the TUI prints on exit. All three carry
+* exactly one id, so we pull the first uuid out of the string rather than
+* teaching this about URL shapes and command syntax.
+*
+* Validating here (instead of letting the API answer) is what turns a typo
+* into "not a conversation id" in the composer rather than a request that
+* cannot succeed.
+*/
+const uuidPattern = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+/**
+* The conversation id in `input`, lowercased, or null when there isn't one.
+* Trailing punctuation, query strings and surrounding prose are tolerated —
+* a pasted link or command line is the expected input, not the exception.
+*/
+function parseConversationRef(input) {
+	const match = uuidPattern.exec(input);
+	return match ? match[0].toLowerCase() : null;
+}
+
 //#endregion
 //#region src/chat/paste.ts
 const MAX_PATH_PASTE_CHARS = 4096;
@@ -2022,8 +3056,13 @@ function syntaxStyleTable() {
 		"keyword.function": { fg: theme.syntaxMagenta },
 		"keyword.return": { fg: theme.syntaxMagenta },
 		"keyword.operator": { fg: theme.syntaxMagenta },
+		conditional: { fg: theme.syntaxMagenta },
+		repeat: { fg: theme.syntaxMagenta },
+		preproc: { fg: theme.syntaxMagenta },
 		string: { fg: theme.syntaxGreen },
 		"string.special": { fg: theme.syntaxTeal },
+		escape: { fg: theme.syntaxTeal },
+		"string.escape": { fg: theme.syntaxTeal },
 		character: { fg: theme.syntaxGreen },
 		comment: {
 			fg: theme.dim,
@@ -2032,10 +3071,13 @@ function syntaxStyleTable() {
 		function: { fg: theme.syntaxBlue },
 		"function.method": { fg: theme.syntaxBlue },
 		"function.builtin": { fg: theme.syntaxCyan },
+		method: { fg: theme.syntaxBlue },
 		variable: { fg: theme.fg },
 		"variable.builtin": { fg: theme.syntaxRed },
 		"variable.parameter": { fg: theme.syntaxYellow },
 		"variable.member": { fg: theme.syntaxTeal },
+		parameter: { fg: theme.syntaxYellow },
+		field: { fg: theme.syntaxTeal },
 		type: { fg: theme.syntaxCyan },
 		"type.builtin": { fg: theme.syntaxCyan },
 		constant: { fg: theme.syntaxOrange },
@@ -2050,6 +3092,7 @@ function syntaxStyleTable() {
 		"punctuation.bracket": { fg: theme.muted },
 		"punctuation.delimiter": { fg: theme.muted },
 		"punctuation.special": { fg: theme.syntaxCyan },
+		delimiter: { fg: theme.muted },
 		constructor: { fg: theme.syntaxBlue },
 		module: { fg: theme.syntaxBlue },
 		label: { fg: theme.syntaxCyan },
@@ -2446,10 +3489,16 @@ function trimCommonIndent(hunks) {
 	for (const hunk of hunks) hunk.lines = hunk.lines.map((line) => isContentLine(line) ? line[0] + line.slice(1 + min) : line);
 }
 /**
-* OpenTUI 0.2.15 bundles tree-sitter parsers for javascript(+react),
-* typescript(+react), markdown, and zig only — anything else renders
-* unhighlighted (but still red/green). Returning undefined skips the
-* highlight pass entirely instead of asking for a parser that isn't there.
+* Maps a file extension to the tree-sitter filetype used to highlight it in
+* diffs and the file/review pane. OpenTUI bundles parsers for
+* javascript(+react), typescript(+react), markdown, and zig; the rest are
+* registered by ./grammars. An extension absent here returns
+* undefined, which skips the highlight pass (the diff still renders red/green)
+* rather than asking the client for a parser it doesn't have.
+*
+* Keep the filetype values in sync with the canonical `filetype`/`aliases`
+* registered in ./grammars/grammars.ts — an extension mapping to a filetype no
+* parser is registered for just renders plain.
 */
 const FILETYPE_BY_EXT = {
 	ts: "typescript",
@@ -2462,7 +3511,34 @@ const FILETYPE_BY_EXT = {
 	jsx: "javascriptreact",
 	md: "markdown",
 	markdown: "markdown",
-	zig: "zig"
+	zig: "zig",
+	py: "python",
+	pyi: "python",
+	pyw: "python",
+	sh: "bash",
+	bash: "bash",
+	zsh: "bash",
+	go: "go",
+	rs: "rust",
+	c: "c",
+	h: "c",
+	cpp: "cpp",
+	cxx: "cpp",
+	cc: "cpp",
+	hpp: "cpp",
+	hxx: "cpp",
+	hh: "cpp",
+	java: "java",
+	rb: "ruby",
+	css: "css",
+	html: "html",
+	htm: "html",
+	json: "json",
+	jsonc: "json",
+	yaml: "yaml",
+	yml: "yaml",
+	toml: "toml",
+	lua: "lua"
 };
 function filetypeForPath(filePath) {
 	const base = filePath.split("/").pop() ?? filePath;
@@ -3264,6 +4340,149 @@ function formatElapsed(totalSeconds) {
 	return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
 }
 
+//#endregion
+//#region src/chat/tui/chat/clamp.ts
+/** Max bytes we keep for a single clamped string field (head + tail combined). */
+const MAX_FIELD_CHARS = 24e3;
+/** Below this a string is never worth clamping (avoids churn on small fields). */
+const MIN_CLAMP_CHARS = MAX_FIELD_CHARS + 2e3;
+/** Fraction of the budget kept from the head; the rest is kept from the tail. */
+const HEAD_FRACTION = .7;
+/**
+* Clamp one string to a head + tail with an elision marker in the middle.
+* Idempotent: a string already carrying our marker is returned unchanged, so
+* re-clamping a loaded-from-history item (or a re-render) never re-slices.
+*/
+function clampString(text) {
+	if (text.length <= MIN_CLAMP_CHARS) return text;
+	if (text.includes(ELISION_MARKER_TAG)) return text;
+	const headLen = Math.floor(MAX_FIELD_CHARS * HEAD_FRACTION);
+	const tailLen = MAX_FIELD_CHARS - headLen;
+	const elided = text.length - MAX_FIELD_CHARS;
+	const head = text.slice(0, headLen);
+	const tail = text.slice(text.length - tailLen);
+	return `${head}\n${elisionMarker(elided)}\n${tail}`;
+}
+/**
+* Append to a growing output buffer while keeping it bounded, preferring the
+* TAIL — for live streaming shell output the newest bytes are what you want on
+* screen. Used by the `!` and `/sandbox` streams, whose output would otherwise
+* grow without limit for a long-running command.
+*/
+function clampedAppend(current, chunk) {
+	const next = current + chunk;
+	if (next.length <= MIN_CLAMP_CHARS) return next;
+	const priorMarkerLen = leadingMarkerLength(current);
+	const bodyLen = next.length - priorMarkerLen;
+	const kept = stripLeadingMarker(next.slice(next.length - MAX_FIELD_CHARS));
+	return `${elisionMarker(Math.max(0, bodyLen - kept.length))}\n${kept}`;
+}
+/** Length (incl. trailing newline) of a marker line at the very start of `s`. */
+function leadingMarkerLength(s) {
+	if (!s.startsWith(ELISION_MARKER_TAG)) return 0;
+	const nl = s.indexOf("\n");
+	return nl === -1 ? s.length : nl + 1;
+}
+function stripLeadingMarker(s) {
+	return s.slice(leadingMarkerLength(s));
+}
+const ELISION_MARKER_TAG = "⋯ elided";
+function elisionMarker(bytes) {
+	return `${ELISION_MARKER_TAG} ${formatBytes$2(bytes)} to save memory ⋯`;
+}
+function formatBytes$2(n) {
+	if (n < 1024) return `${n} chars`;
+	if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+	return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+* Recursively clamp the large string fields of an arbitrary tool payload
+* (input or output `value`). Structure is preserved so the tool renderers,
+* which reach for known keys like `.stdout` / `.output` / `.content`, still
+* find them — only the *size* of long strings is bounded. Depth and breadth
+* are capped so a pathological payload can't make clamping itself expensive.
+*/
+function clampPayload(value, depth = 0) {
+	if (typeof value === "string") return clampString(value);
+	if (depth >= 6) return value;
+	if (Array.isArray(value)) {
+		const overLong = value.length > 5e3;
+		const source = overLong ? value.slice(0, 5e3) : value;
+		let changed = overLong;
+		const mapped = source.map((v) => {
+			const c = clampPayload(v, depth + 1);
+			if (c !== v) changed = true;
+			return c;
+		});
+		return changed ? mapped : value;
+	}
+	if (isRecord(value)) {
+		let changed = false;
+		const out = {};
+		for (const [k, v] of Object.entries(value)) {
+			const c = clampPayload(v, depth + 1);
+			if (c !== v) changed = true;
+			out[k] = c;
+		}
+		return changed ? out : value;
+	}
+	return value;
+}
+/**
+* Clamp a single MessageItem in place-safe (returns a new object only when it
+* actually changed). Applied by the reducer when a tool settles and by the
+* history loader for every loaded item. Streaming text bubbles are left alone
+* — they're bounded by the model's output and clamping mid-stream would fight
+* the append path; only large tool/shell payloads and finished long texts are
+* worth clamping.
+*/
+function clampItem(item) {
+	switch (item.kind) {
+		case "tool": {
+			const input = item.input == null ? item.input : clampPayload(item.input);
+			const inputText = item.inputText.length > MIN_CLAMP_CHARS ? clampString(item.inputText) : item.inputText;
+			let output = item.output;
+			if (output?.kind === "ok") {
+				const value = clampPayload(output.value);
+				if (value !== output.value) output = {
+					kind: "ok",
+					value
+				};
+			} else if (output?.kind === "error") {
+				const errorText = clampString(output.errorText);
+				if (errorText !== output.errorText) output = {
+					kind: "error",
+					errorText
+				};
+			}
+			if (input === item.input && inputText === item.inputText && output === item.output) return item;
+			return {
+				...item,
+				input,
+				inputText,
+				output
+			};
+		}
+		case "shell": {
+			const clamped = clampString(item.output);
+			return clamped === item.output ? item : {
+				...item,
+				output: clamped
+			};
+		}
+		case "assistant-text":
+		case "reasoning": {
+			if (!item.done) return item;
+			const clamped = clampString(item.text);
+			return clamped === item.text ? item : {
+				...item,
+				text: clamped
+			};
+		}
+		default: return item;
+	}
+}
+
 //#endregion
 //#region src/chat/tui/chat/reducer.ts
 function str(chunk, key) {
@@ -3346,7 +4565,7 @@ function applyChunk(items, chunk, agentName = null) {
 		case "tool-input-available": {
 			const toolCallId = str(chunk, "toolCallId");
 			const toolName = str(chunk, "toolName");
-			const input = chunk.input ?? null;
+			const input = chunk.input == null ? null : clampPayload(chunk.input);
 			if (!toolCallId) return [...items];
 			if (items.find((m) => m.kind === "tool" && m.id === toolCallId)) return items.map((m) => m.kind === "tool" && m.id === toolCallId ? {
 				...m,
@@ -3367,7 +4586,7 @@ function applyChunk(items, chunk, agentName = null) {
 		case "tool-output-available": {
 			const toolCallId = str(chunk, "toolCallId");
 			if (!toolCallId) return [...items];
-			const output = chunk.output ?? null;
+			const output = chunk.output == null ? null : clampPayload(chunk.output);
 			return items.map((m) => m.kind === "tool" && m.id === toolCallId ? {
 				...m,
 				output: {
@@ -3380,7 +4599,7 @@ function applyChunk(items, chunk, agentName = null) {
 		case "tool-output-error": {
 			const toolCallId = str(chunk, "toolCallId");
 			if (!toolCallId) return [...items];
-			const errorText = str(chunk, "errorText") ?? "tool error";
+			const errorText = clampString(str(chunk, "errorText") ?? "tool error");
 			return items.map((m) => m.kind === "tool" && m.id === toolCallId ? {
 				...m,
 				output: {
@@ -3412,17 +4631,19 @@ function applyChunk(items, chunk, agentName = null) {
 			if (!isRecord(data)) return [...items];
 			const card = parseConnectCard(data.spec);
 			if (!card) return [...items];
-			const id = (typeof data.toolCallId === "string" ? data.toolCallId : null) ?? cryptoId();
-			const next = {
+			const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : null;
+			const specKey = specKeyFor(data.spec);
+			if (items.some((m) => m.kind === "card" && m.toolCallId === toolCallId && m.specKey === specKey)) return [...items];
+			return [...items, {
 				kind: "card",
-				id,
+				id: nextCardId(items, toolCallId),
+				toolCallId,
+				specKey,
 				card,
 				status: "idle",
 				detail: null,
 				agentName
-			};
-			if (items.some((m) => m.kind === "card" && m.id === id)) return items.map((m) => m.kind === "card" && m.id === id ? next : m);
-			return [...items, next];
+			}];
 		}
 		case "data-anyone-conversation-started": return [...items];
 		default: return [...items];
@@ -3525,6 +4746,38 @@ function directiveIdsFrom(data) {
 function cryptoId() {
 	return crypto.randomUUID();
 }
+/** Distinct id per card, so cards from one tool call stay independently
+* addressable (status updates and the React key both go by `id`). */
+function nextCardId(items, toolCallId) {
+	if (!toolCallId) return cryptoId();
+	return `${toolCallId}#c${items.filter((m) => m.kind === "card" && m.toolCallId === toolCallId).length}`;
+}
+
+//#endregion
+//#region src/chat/tui/chat/window.ts
+/** Max transcript rows mounted at once. */
+const MAX_MOUNTED_ROWS = 400;
+/**
+* Keep the most recent `max` rows mounted; report how many older ones were
+* dropped from the mount so the UI can show a "N earlier messages" marker.
+*/
+function windowItems(items, max = MAX_MOUNTED_ROWS) {
+	if (items.length <= max) return {
+		visible: items.map((item, index) => ({
+			item,
+			index
+		})),
+		hiddenCount: 0
+	};
+	const start = items.length - max;
+	return {
+		visible: items.slice(start).map((item, offset) => ({
+			item,
+			index: start + offset
+		})),
+		hiddenCount: start
+	};
+}
 
 //#endregion
 //#region src/chat/tui/chat/attribution.ts
@@ -3638,11 +4891,16 @@ function uiMessagesToItems(messages) {
 				if (part.type === "data-anyone-render-spec") {
 					const data = isRecord(part) && isRecord(part.data) ? part.data : null;
 					const card = data ? parseConnectCard(data.spec) : null;
-					if (card) {
-						const toolCallId = data && typeof data.toolCallId === "string" ? data.toolCallId : null;
+					if (card && data) {
+						const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : null;
+						const specKey = specKeyFor(data.spec);
+						if (out.some((item) => item.kind === "card" && item.toolCallId === toolCallId && item.specKey === specKey)) continue;
+						const ordinal = out.filter((item) => item.kind === "card" && item.toolCallId === toolCallId).length;
 						out.push({
 							kind: "card",
-							id: toolCallId ?? `${m.id}#c${textIdx++}`,
+							id: toolCallId ? `${toolCallId}#c${ordinal}` : `${m.id}#c${textIdx++}`,
+							toolCallId,
+							specKey,
 							card,
 							status: "idle",
 							detail: null,
@@ -3680,7 +4938,7 @@ function uiMessagesToItems(messages) {
 			});
 		}
 	}
-	return out;
+	return out.map(clampItem);
 }
 function mapToolState(raw) {
 	switch (raw) {
@@ -3883,13 +5141,128 @@ function TodoCardView({ todos, isActive }) {
 	});
 }
 
+//#endregion
+//#region src/chat/tui/chat/pr-links.tsx
+/**
+* Most PRs to show inline before collapsing the rest into a `+N` count. The
+* chip shares one row with the send/steer hint, so more than a couple would
+* crowd or wrap that row; the newest few are the useful ones.
+*/
+const MAX_PR_CHIPS = 3;
+/**
+* Builds the styled `· PR #123 #124` chip as OpenTUI chunks. The number chunks
+* carry a first-class `link` (OpenTUI emits it as a zero-width OSC 8 hyperlink,
+* clickable in terminals that support it) — the same mechanism the transcript's
+* linkified markdown uses. We do NOT hand-roll OSC 8 escape strings into text
+* children: OpenTUI measures width by string length and emits its own SGR, so a
+* raw escape corrupts layout and leaks bytes on screen.
+*
+* Caps at {@link MAX_PR_CHIPS} shown; any beyond that collapse into a trailing
+* `+N` so the footer row can't be flooded by a run that links many PRs. Shows
+* the most recent (last-seen) PRs, since those are what's in play.
+*/
+function prLinksStyledText(prs) {
+	const dot = fg(theme.dim ?? "#565f89");
+	const label = fg(theme.muted ?? "#7a7a7a");
+	const accent = fg(theme.accent ?? "#7aa2f7");
+	const shown = prs.slice(-MAX_PR_CHIPS);
+	const overflow = prs.length - shown.length;
+	const chunks = [dot("· "), label("PR ")];
+	shown.forEach((pr, i) => {
+		if (i > 0) chunks.push(label(" "));
+		chunks.push(accent(link(pr.url)(`#${pr.number}`)));
+	});
+	if (overflow > 0) chunks.push(label(` +${overflow}`));
+	return new StyledText(chunks);
+}
+/**
+* An inline chip for the conversation's linked PR(s), rendered on the
+* composer's status/hint row just after the send/steer hint — mirrors the
+* Claude Code affordance. Renders nothing when there are no PRs.
+*/
+function PrLinksView({ prs }) {
+	if (prs.length === 0) return null;
+	return /* @__PURE__ */ jsx("text", { content: prLinksStyledText(prs) });
+}
+
+//#endregion
+//#region src/chat/tui/chat/use-compaction.ts
+const COMPACTING_INDICATOR_TIMEOUT_MS = 12e4;
+/**
+* Owns everything about manual conversation compaction (`/compact`): the
+* persistent "compacting…" indicator state, the fire-and-forget command, the
+* reaction to conversation-stream `compaction` events, and the safety timeout
+* that clears a stranded `started` so the indicator can never pin forever.
+*
+* The screen keeps a single `streamConversation` subscription (which also
+* carries `run`/`conversation` events), so compaction events arrive there and
+* are forwarded in via {@link UseCompaction.onCompactionEvent} rather than this
+* hook opening its own stream.
+*/
+function useCompaction({ rest, conversationId }) {
+	const [compacting, setCompacting] = useState(false);
+	const timerRef = useRef(null);
+	const clearTimer = useCallback(() => {
+		if (timerRef.current) {
+			clearTimeout(timerRef.current);
+			timerRef.current = null;
+		}
+	}, []);
+	const armIndicator = useCallback(() => {
+		clearTimer();
+		setCompacting(true);
+		timerRef.current = setTimeout(() => setCompacting(false), COMPACTING_INDICATOR_TIMEOUT_MS);
+	}, [clearTimer]);
+	const onCompactionEvent = useCallback((status) => {
+		if (status === "started") {
+			armIndicator();
+			return;
+		}
+		clearTimer();
+		setCompacting(false);
+		if (status === "failed") useStore.getState().showToast({
+			variant: "error",
+			message: "compaction failed"
+		});
+	}, [armIndicator, clearTimer]);
+	const compactConversation = useCallback(() => {
+		if (!rest || !conversationId) {
+			useStore.getState().showToast({ message: "nothing to compact yet — send a message first" });
+			return;
+		}
+		armIndicator();
+		rest.compactConversation({ conversationId }).catch((err) => {
+			clearTimer();
+			setCompacting(false);
+			useStore.getState().showToast({
+				variant: "error",
+				message: `couldn't compact: ${errorDetail(err)}`
+			});
+		});
+	}, [
+		rest,
+		conversationId,
+		armIndicator,
+		clearTimer
+	]);
+	useEffect(() => clearTimer, [clearTimer]);
+	return {
+		compacting,
+		compactConversation,
+		onCompactionEvent
+	};
+}
+
 //#endregion
 //#region src/chat/tui/chat/footer-hints.ts
 /** Build the chat footer copy independently of its colors and layout. */
-function formatChatFooterStatus({ runKind, ctrlCArmed, isShared, hasPendingSteer, hasActionableCard }) {
-	const connectHint = hasActionableCard ? "ctrl+r connect · " : "";
+function formatChatFooterStatus({ runKind, ctrlCArmed, isShared, hasPendingSteer, actionableCardCount, nonWebChannel }) {
+	const connectHint = actionableCardCount > 1 ? `ctrl+r connect (${actionableCardCount}) · ` : actionableCardCount === 1 ? "ctrl+r connect · " : "";
 	switch (runKind) {
-		case "idle": return ctrlCArmed ? "press ctrl+c again to quit" : `${connectHint}↵  send · / commands · esc back · ctrl+c quit · ctrl+t ${isShared ? "revoke access" : "local access"} · ? keybinds`;
+		case "idle":
+			if (ctrlCArmed) return "press ctrl+c again to quit";
+			if (nonWebChannel) return `esc back · ctrl+c quit · ctrl+t ${isShared ? "revoke access" : "local access"} · ? keybinds`;
+			return `${connectHint}↵  send · / commands · esc back · ctrl+c quit · ctrl+t ${isShared ? "revoke access" : "local access"} · ? keybinds`;
 		case "sending": return "sending…";
 		case "streaming": return hasPendingSteer ? `${connectHint}↵ steer · esc cancel steer · ctrl+c cancel run` : `${connectHint}↵ steer · esc leave (keeps running) · ctrl+c cancel`;
 	}
@@ -3928,9 +5301,29 @@ function formatShare(share) {
 //#region src/chat/notification-preview.ts
 const MAX_NOTIFICATION_PREVIEW_CHARS = 240;
 /**
+* Flattens common inline markdown to plain text for a notification / sidebar
+* preview, which renders as raw text (no markdown). Without this the preview
+* shows literal `**bold**` and `*italic*` markers. Intentionally lightweight —
+* not a full parser, just the inline markers that show up in a one-line
+* preview: emphasis, inline code, links/images, headings, blockquotes, and
+* list bullets. Block structure is already gone by the time we preview (we
+* collapse whitespace to a single line).
+*/
+function stripInlineMarkdown(input) {
+	return input.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/(\*\*\*|\*\*|\*|___|__|_)(?=\S)(.*?\S)\1/g, "$2").replace(/(\*\*\*|\*\*|\*|___|__|_)(?=\S)(.*?\S)\1/g, "$2").replace(/~~(?=\S)(.*?\S)~~/g, "$1").replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/^\s{0,3}>\s?/gm, "").replace(/^\s{0,3}(?:[-*+]|\d+\.)\s+/gm, "");
+}
+/**
 * Collects assistant `text-delta` chunks for one run and turns them into a
-* desktop-notification-sized preview. Reasoning, tool output, cards, errors,
+* notification/side-panel-sized preview. Reasoning, tool output, cards, errors,
 * and old transcript items are intentionally excluded.
+*
+* A run is a sequence of text parts split by tool calls and reasoning
+* (text → tool → text → … → final text). The meaningful summary of a run is
+* its **last** text part: the closing answer the agent lands on after all its
+* tool work, not the "let me look into this…" preamble it opened with. So the
+* preview keeps only the final part's text, and when that part is longer than
+* the cap it keeps the **beginning** with a trailing ellipsis (the
+* conventional truncation) — the block already opens on the answer.
 */
 function createResponsePreview() {
 	let text = "";
@@ -3940,12 +5333,12 @@ function createResponsePreview() {
 			if (chunk.type !== "text-delta") return;
 			const delta = typeof chunk.delta === "string" ? chunk.delta : typeof chunk.text === "string" ? chunk.text : "";
 			const partId = typeof chunk.id === "string" ? chunk.id : void 0;
-			if (text && partId && lastPartId && partId !== lastPartId) text += " ";
+			if (partId && lastPartId && partId !== lastPartId) text = "";
 			text += delta;
 			lastPartId = partId ?? lastPartId;
 		},
 		get() {
-			const normalized = text.replace(/\s+/g, " ").trim();
+			const normalized = stripInlineMarkdown(text).replace(/\s+/g, " ").trim();
 			if (!normalized) return void 0;
 			const characters = Array.from(normalized);
 			if (characters.length <= MAX_NOTIFICATION_PREVIEW_CHARS) return normalized;
@@ -4197,6 +5590,10 @@ const keybindGroups = [
 				keys: "exit",
 				action: "quit (type it as a message)"
 			},
+			{
+				keys: "ctrl+a",
+				action: "archive this conversation (composer empty; hides it for you only)"
+			},
 			{
 				keys: "ctrl+p",
 				action: "switch model"
@@ -4225,14 +5622,26 @@ const keybindGroups = [
 				keys: "ctrl+l",
 				action: "open this conversation in the browser"
 			},
+			{
+				keys: "ctrl+f",
+				action: "fork a channel conversation into a chat you can continue here"
+			},
 			{
 				keys: "ctrl+r",
-				action: "run the newest connect card (auth cards)"
+				action: "act on a waiting connect card (auth cards)"
 			},
 			{
 				keys: "pgup / pgdn",
 				action: "scroll transcript"
 			},
+			{
+				keys: "end",
+				action: "jump to latest (when scrolled up)"
+			},
+			{
+				keys: "/plan [show|hide]",
+				action: "show / hide the pinned plan card"
+			},
 			{
 				keys: "/",
 				action: "open the command menu (start of message)"
@@ -4294,6 +5703,10 @@ const keybindGroups = [
 				keys: "1 / 2",
 				action: "switch Changes / Files"
 			},
+			{
+				keys: "\\",
+				action: "toggle side / stacked layout"
+			},
 			{
 				keys: "↵ / o / l",
 				action: "focus selected file preview"
@@ -4369,14 +5782,22 @@ const keybindGroups = [
 				keys: "↵",
 				action: "open conversation"
 			},
+			{
+				keys: "ctrl+a",
+				action: "archive conversation (hides it for you only; again to restore)"
+			},
 			{
 				keys: "ctrl+d",
-				action: "delete conversation (y/↵ confirm, n/esc keep)"
+				action: "delete conversation for everyone (y/↵ confirm, n/esc keep)"
 			},
 			{
 				keys: "tab",
 				action: "show / hide the agent's own runs (schedules, webhooks, subagents)"
 			},
+			{
+				keys: "shift+tab",
+				action: "show / hide the conversations you archived"
+			},
 			{
 				keys: "esc",
 				action: "back to agent picker"
@@ -4659,6 +6080,27 @@ const slashCommands = [
 		description: "start a new conversation with this agent",
 		action: { kind: "new-conversation" }
 	},
+	{
+		name: "fork",
+		aliases: [],
+		argsHint: null,
+		description: "fork this conversation into a new one (full copy)",
+		action: { kind: "fork" }
+	},
+	{
+		name: "archive",
+		aliases: [],
+		argsHint: null,
+		description: "archive this conversation and hide it from your list",
+		action: { kind: "archive-conversation" }
+	},
+	{
+		name: "conversation",
+		aliases: ["conversations", "conv"],
+		argsHint: "[id or link]",
+		description: "switch conversation (no id: pick from the list)",
+		action: { kind: "conversation" }
+	},
 	{
 		name: "model",
 		aliases: [],
@@ -4680,6 +6122,16 @@ const slashCommands = [
 		description: "show connection and session status",
 		action: { kind: "status" }
 	},
+	{
+		name: "plan",
+		aliases: ["todos", "todo"],
+		argsHint: "[show|hide]",
+		description: "show or hide the pinned plan card",
+		action: {
+			kind: "plan",
+			mode: "toggle"
+		}
+	},
 	{
 		name: "share",
 		aliases: [],
@@ -4698,9 +6150,30 @@ const slashCommands = [
 		name: "connect",
 		aliases: [],
 		argsHint: null,
-		description: "run the newest connect card (auth cards)",
+		description: "act on a waiting connect card (auth cards)",
 		action: { kind: "connect" }
 	},
+	{
+		name: "copy",
+		aliases: ["cp"],
+		argsHint: null,
+		description: "copy the agent's last message to the clipboard",
+		action: { kind: "copy" }
+	},
+	{
+		name: "portal",
+		aliases: ["local"],
+		argsHint: null,
+		description: "allow this agent to access your computer",
+		action: { kind: "portal" }
+	},
+	{
+		name: "compact",
+		aliases: [],
+		argsHint: null,
+		description: "summarize older turns to free up context now",
+		action: { kind: "compact" }
+	},
 	{
 		name: "help",
 		aliases: [],
@@ -4723,7 +6196,7 @@ const slashCommands = [
 *
 * An argument-less command only matches as the exact line — `/help me write
 * a plan` stays an ordinary message rather than swallowing the user's text
-* into the help modal. Only `sandbox` accepts a rest.
+* into the help modal. Only `sandbox` and `conversation` accept a rest.
 */
 function matchSlashCommand(line) {
 	if (!line.startsWith("/")) return null;
@@ -4796,6 +6269,93 @@ function printResumeHint(write = (text) => process.stdout.write(text)) {
 	lastConversationId = null;
 }
 
+//#endregion
+//#region src/chat/tui/screens/card-picker.tsx
+/**
+* Asks which connect card ctrl+r should act on. A conversation can hold
+* several cards waiting at once (a batch of `platform auth configure` calls),
+* and the chord can't guess which one the user means — picking the newest
+* silently strands the rest, since a card left in `launched` or `error` stays
+* actionable forever. Rendered as an overlay in place of the transcript, like
+* the model and theme pickers, so the conversation and any live run survive.
+*/
+function CardPicker({ cards, onSelect, onCancel }) {
+	const { height } = useTerminalDimensions();
+	const [highlight, setHighlight] = useState(0);
+	const clamped = Math.min(highlight, Math.max(0, cards.length - 1));
+	const visibleRows = Math.max(3, height - 6);
+	const start = windowStart(clamped, cards.length, visibleRows);
+	const windowed = cards.slice(start, start + visibleRows);
+	useKeyboard((key) => {
+		if (key.name === "escape") {
+			onCancel();
+			return;
+		}
+		if (key.name === "up") setHighlight(Math.max(0, clamped - 1));
+		else if (key.name === "down") setHighlight(Math.min(Math.max(0, cards.length - 1), clamped + 1));
+		else if (key.name === "return") {
+			const card = cards[clamped];
+			if (card) onSelect(card);
+		}
+	});
+	useEffect(() => {
+		if (cards.length === 0) onCancel();
+	}, [cards.length, onCancel]);
+	if (cards.length === 0) return null;
+	return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: [
+			/* @__PURE__ */ jsx("text", {
+				fg: theme.accent,
+				children: "connect"
+			}),
+			/* @__PURE__ */ jsx("box", {
+				style: {
+					flexDirection: "column",
+					flexGrow: 1,
+					marginTop: 1
+				},
+				children: windowed.map((card, i) => {
+					const selected = start + i === clamped;
+					const waiting = waitingOn(card);
+					const label = card.card.button?.label ?? "";
+					return /* @__PURE__ */ jsxs("text", {
+						fg: selected ? theme.accent : theme.fg,
+						children: [
+							selected ? "› " : "  ",
+							"⚿ ",
+							card.card.title,
+							label ? /* @__PURE__ */ jsxs("span", {
+								fg: theme.muted,
+								children: [" · ", label]
+							}) : null,
+							waiting ? /* @__PURE__ */ jsxs("span", {
+								fg: theme.dim,
+								children: [" · ", waiting]
+							}) : null
+						]
+					}, card.id);
+				})
+			}),
+			/* @__PURE__ */ jsxs("text", {
+				fg: theme.dim,
+				children: [cards.length, " waiting · ↑/↓ move · ↵ select · esc cancel"]
+			})
+		]
+	});
+}
+/** Why a card is still on the list, for the rows that aren't simply untouched. */
+function waitingOn(card) {
+	switch (card.status) {
+		case "launched": return "finish in your browser";
+		case "error": return card.detail ?? "failed";
+		default: return null;
+	}
+}
+
 //#endregion
 //#region src/chat/tui/screens/model-picker.tsx
 /**
@@ -5008,9 +6568,18 @@ function FilterableModelList({ models, currentModel, modelLocked, agentId, onSel
 	});
 }
 const modelKeys = [
-	(m) => m.displayName,
-	(m) => m.providerDisplay ?? "",
-	(m) => m.id
+	{
+		get: (m) => m.displayName,
+		weight: 1
+	},
+	{
+		get: (m) => m.providerDisplay ?? "",
+		weight: .9
+	},
+	{
+		get: (m) => m.id,
+		weight: .9
+	}
 ];
 /**
 * The REST error routes return `{ "error": "message" }`. Pull that out for a
@@ -6676,7 +8245,7 @@ function gcOnce() {
 	gcStarted = true;
 	store.gc();
 }
-function ReviewPane({ agentId, conversationId, items, viewportWidth, viewportHeight, active, shellLayout, tab, onTabChange, selectedChangeFile, onSelectedChangeFileChange, selectedWorkspaceFile, onSelectedWorkspaceFileChange, navigatorSize, onNavigatorResize, onInsertToComposer, onRequestChatFocus, onClose }) {
+function ReviewPane({ agentId, conversationId, items, viewportWidth, viewportHeight, active, shellLayout, tab, onTabChange, selectedChangeFile, onSelectedChangeFileChange, selectedWorkspaceFile, onSelectedWorkspaceFileChange, navigatorSize, onNavigatorResize, onToggleOrientation, onInsertToComposer, onRequestChatFocus, onClose }) {
 	const width = viewportWidth;
 	const height = viewportHeight;
 	const shellHeight = Math.max(6, height - 2);
@@ -6827,6 +8396,10 @@ function ReviewPane({ agentId, conversationId, items, viewportWidth, viewportHei
 			onTabChange("files");
 			return;
 		}
+		if (key.name === "\\") {
+			if (onToggleOrientation() === "unavailable") setStatus("no room to change layout in this terminal");
+			return;
+		}
 		if (key.name === "s") {
 			if (comments.length === 0) {
 				setStatus("no pending comments");
@@ -7217,18 +8790,93 @@ function PaneRowView({ row, width, isCursor, inSelection, isAnchor, isCommented
 //#endregion
 //#region src/chat/tui/file-pane-layout.ts
 /**
+* Terminal cells are about twice as tall as they are wide, so a raw
+* cols-vs-rows compare would call almost any terminal "wide". Scale rows by
+* this factor to compare the *visual* aspect: a square-looking terminal has
+* `width ≈ height * CELL_ASPECT`.
+*/
+const CELL_ASPECT = 2;
+/**
+* The automatic split follows the terminal's visual aspect: wider than tall
+* places review beside the chat (a vertical divider), taller than wide stacks
+* it underneath (a horizontal divider). This is the responsive default when
+* the user hasn't pinned an orientation.
+*/
+function autoPrefersSide({ width, height }) {
+	return width >= height * CELL_ASPECT;
+}
+/**
+* Bare-minimum room to render a split at all (as opposed to the higher
+* comfort thresholds the automatic choice uses). A user pin is honored down
+* to these: chat + review each need a usable strip, but we don't insist on
+* the roomier auto breakpoints. Mirrors the clamps in clampSidePaneWidth /
+* clampBelowPaneHeight so a pinned split never renders narrower than those.
+*/
+function canRenderSide({ width, height }) {
+	return width >= 76 && height >= 8;
+}
+function canRenderBelow({ width, height }) {
+	return height >= 24 && width >= 24;
+}
+/**
 * Responsive placement for the file pane.
 *
-* Wide terminals keep the conversation readable and place review beside it.
-* Tall terminals without enough horizontal room stack review underneath.
-* Cramped terminals give review the full body rather than rendering two
-* unusably small surfaces.
-*/
-function filePanePlacement({ width, height }) {
-	if (width >= 140 && height >= 24) return "side";
-	if (width >= 50 && height >= 40) return "below";
+* With no user pin the split follows the terminal's visual aspect (see
+* autoPrefersSide): wider than tall -> side, taller than wide -> stacked.
+* The preferred split still has to be renderable; if it isn't we use the
+* other, and cramped terminals that can render neither get the full body.
+*
+* A user `orientation` pin always wins as long as the terminal can render
+* that split at all (the lower canRender* bar) — so you get the layout you
+* asked for even on a smallish terminal. Only when the pinned split
+* genuinely can't fit do we fall back: to the other split if it can render,
+* else to `fullscreen`.
+*/
+function filePanePlacement({ width, height, orientation }) {
+	const renderSide = canRenderSide({
+		width,
+		height
+	});
+	const renderBelow = canRenderBelow({
+		width,
+		height
+	});
+	if (orientation === "side") {
+		if (renderSide) return "side";
+		if (renderBelow) return "below";
+		return "fullscreen";
+	}
+	if (orientation === "below") {
+		if (renderBelow) return "below";
+		if (renderSide) return "side";
+		return "fullscreen";
+	}
+	if (autoPrefersSide({
+		width,
+		height
+	})) {
+		if (renderSide) return "side";
+		if (renderBelow) return "below";
+		return "fullscreen";
+	}
+	if (renderBelow) return "below";
+	if (renderSide) return "side";
 	return "fullscreen";
 }
+/**
+* Whether toggling the orientation would actually change anything: both
+* splits must be renderable. When only one (or neither) can render, the
+* caller surfaces a hint instead of a silent no-op.
+*/
+function canToggleOrientation({ width, height }) {
+	return canRenderSide({
+		width,
+		height
+	}) && canRenderBelow({
+		width,
+		height
+	});
+}
 /** Keep a dragged side pane wide enough to use and leave the chat usable. */
 function clampSidePaneWidth(width, bodyWidth) {
 	return Math.max(44, Math.min(bodyWidth - 30, width));
@@ -7575,13 +9223,29 @@ function routeInput(raw) {
 				kind: "sandbox-exec",
 				command: match.rest
 			} : { kind: "sandbox-pty" };
+			case "conversation": return match.rest ? {
+				kind: "open-conversation",
+				ref: match.rest
+			} : { kind: "conversation-picker" };
+			case "plan": {
+				const arg = match.rest.toLowerCase();
+				return {
+					kind: "plan",
+					mode: arg === "show" ? "show" : arg === "hide" ? "hide" : "toggle"
+				};
+			}
 			case "new-conversation":
+			case "fork":
+			case "archive-conversation":
 			case "model-picker":
 			case "theme-picker":
 			case "status":
 			case "share":
 			case "browser":
 			case "connect":
+			case "copy":
+			case "portal":
+			case "compact":
 			case "help":
 			case "quit": return { kind: action.kind };
 			default: {
@@ -7643,6 +9307,47 @@ async function runPtySession(opts) {
 	}
 }
 
+//#endregion
+//#region src/chat/tui/screens/conversation-channel.ts
+function isNewConversation(c) {
+	return "kind" in c && c.kind === "new";
+}
+/**
+* The channel a conversation belongs to when it isn't the web channel, else
+* null. A brand-new conversation is always web, and the list route reports the
+* web channel as either `'web'` or (legacy) null — both mean "post from here".
+* Anything else (slack, email, imessage, webhook, cron) is owned by that
+* channel: the message has to go through it, so the TUI can't send here.
+* Mirrors the web app's `channel !== null && channel !== 'web'` gate.
+*/
+function nonWebChannelLabel(c) {
+	if (isNewConversation(c)) return null;
+	if (c.channel === null || c.channel === "web") return null;
+	return c.channelLabel ?? c.channel;
+}
+/**
+* The list-row shape for a conversation the TUI just forked, so the chat
+* screen can reopen on the copy without waiting for a list refetch. A fork
+* carries none of the source's channel binding — that's what makes it
+* sendable from here — so it is always a web conversation.
+*/
+function forkedConversationRef({ agent, forked }) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		id: forked.id,
+		title: forked.title,
+		createdAt: now,
+		updatedAt: now,
+		preview: null,
+		channel: "web",
+		channelLabel: null,
+		agent: {
+			id: agent.id,
+			name: agent.name
+		}
+	};
+}
+
 //#endregion
 //#region src/chat/tui/screens/chat.tsx
 /**
@@ -7679,8 +9384,14 @@ const pageScrollFraction = .75;
 /** Cap composer growth; past this the textarea scrolls its content instead. */
 const maxComposerRows = 8;
 const maxAttachments = 10;
-function isNewConversation(c) {
-	return "kind" in c && c.kind === "new";
+/**
+* A server timestamp as local epoch ms, or null when it is missing or
+* unparseable so the caller can fall back to its own clock.
+*/
+function parseStampMs(iso) {
+	if (!iso) return null;
+	const ms = Date.parse(iso);
+	return Number.isNaN(ms) ? null : ms;
 }
 function formatBytes(bytes) {
 	if (bytes < 1024) return `${bytes} B`;
@@ -7725,13 +9436,27 @@ function ChatScreen({ agent, conversation }) {
 	const isShared = portal.status !== "off";
 	const initialConversationId = isNewConversation(conversation) ? null : conversation.id;
 	const agentHost = useAgentHost();
+	const nonWebChannel = nonWebChannelLabel(conversation);
 	const [conversationId, setConversationId] = useState(initialConversationId);
+	const { compacting, compactConversation, onCompactionEvent } = useCompaction({
+		rest,
+		conversationId
+	});
 	const [items, setItems] = useState([]);
 	const [todos, setTodos] = useState(null);
+	const [planHidden, setPlanHidden] = useState(false);
+	const [scrolledUp, setScrolledUp] = useState(false);
+	const hadTodosRef = useRef(false);
+	useEffect(() => {
+		const hasTodos = !!todos && todos.length > 0;
+		if (hasTodos && !hadTodosRef.current) setPlanHidden(false);
+		hadTodosRef.current = hasTodos;
+	}, [todos]);
 	const [historyLoaded, setHistoryLoaded] = useState(initialConversationId === null);
 	const [input, setInput] = useState("");
 	const [run, setRun] = useState({ kind: "idle" });
 	const [model, setModel] = useState(agent.model ?? null);
+	const [cardPickerOpen, setCardPickerOpen] = useState(false);
 	const [modelPickerOpen, setModelPickerOpen] = useState(false);
 	const [themePickerOpen, setThemePickerOpen] = useState(false);
 	const [helpOpen, setHelpOpen] = useState(false);
@@ -7747,6 +9472,7 @@ function ChatScreen({ agent, conversation }) {
 		side: null,
 		stacked: null
 	});
+	const [reviewOrientation, setReviewOrientation] = useState(null);
 	const [reviewWorkspaceFile, setReviewWorkspaceFile] = useState(null);
 	useEffect(() => {
 		setReviewChangeFile(null);
@@ -7756,6 +9482,8 @@ function ChatScreen({ agent, conversation }) {
 	const [composerRows, setComposerRows] = useState(1);
 	const [attachments, setAttachments] = useState([]);
 	const uploadsRef = useRef(/* @__PURE__ */ new Map());
+	const [forking, setForking] = useState(false);
+	const forkingRef = useRef(false);
 	const [credPrompt, setCredPrompt] = useState(null);
 	const credPromptOpen = credPrompt !== null;
 	const [menuDismissed, setMenuDismissed] = useState(false);
@@ -7784,25 +9512,62 @@ function ChatScreen({ agent, conversation }) {
 		agentHost.transition({ state: "idle" });
 		agentHost.setSession(null);
 	}, [agentHost]);
+	const [prLinks, setPrLinks] = useState([]);
+	const reportedPrsRef = useRef(/* @__PURE__ */ new Map());
+	useEffect(() => () => {
+		for (const pr of reportedPrsRef.current.values()) agentHost.removePullRequest(pr);
+		reportedPrsRef.current = /* @__PURE__ */ new Map();
+	}, [agentHost]);
 	useEffect(() => {
 		agentHost.setSession(conversationId);
 		setResumeConversation(conversationId);
 	}, [agentHost, conversationId]);
+	const bindPortalCwd = useCallback(() => {
+		if (!conversationId || !portalClient) return;
+		if (portal.status === "off") return;
+		const cwd = shellSessionRef.current?.cwd ?? process.cwd();
+		portalClient.bind(conversationId, cwd);
+	}, [
+		conversationId,
+		portalClient,
+		portal.status
+	]);
 	const scrollRef = useRef(null);
 	const composerRef = useRef(null);
+	const jumpToBottom = useCallback(() => {
+		const box = scrollRef.current;
+		if (!box) return;
+		box.scrollTo({
+			x: box.scrollLeft,
+			y: box.scrollHeight
+		});
+		setScrolledUp(false);
+	}, []);
+	useEffect(() => {
+		const id = setInterval(() => {
+			const box = scrollRef.current;
+			if (!box) return;
+			const viewport = box.viewport.height;
+			const atBottom = box.scrollTop + viewport >= box.scrollHeight - 1;
+			setScrolledUp((prev) => prev === !atBottom ? prev : !atBottom);
+		}, 150);
+		return () => clearInterval(id);
+	}, []);
 	const reviewSideBoxRef = useRef(null);
 	const reviewBelowBoxRef = useRef(null);
 	const paneDragRef = useRef(null);
 	const composerBoxHeight = composerRows + 2;
-	const pendingVisible = !grantPrompt && !credPrompt && attachments.length > 0;
+	const pendingVisible = !grantPrompt && !credPrompt && !nonWebChannel && attachments.length > 0;
 	const pendingRows = pendingVisible ? attachments.length + 2 : 0;
 	const credPromptHeight = 4 + (credPrompt && (credPrompt.error || credPrompt.submitting) ? 1 : 0);
-	const bottomBoxHeight = credPrompt ? credPromptHeight : composerBoxHeight;
+	const nonWebNoticeHeight = 5;
+	const bottomBoxHeight = credPrompt ? credPromptHeight : nonWebChannel ? nonWebNoticeHeight : composerBoxHeight;
 	const bodyWidth = Math.max(1, width - 2);
 	const bodyHeight = Math.max(1, height - 3);
 	const reviewPlacement = filePanePlacement({
 		width,
-		height
+		height,
+		orientation: reviewOrientation
 	});
 	const reviewWidth = reviewPlacement === "side" ? clampSidePaneWidth(reviewSizePref.side ?? sidePaneWidth(bodyWidth), bodyWidth) : bodyWidth;
 	const reviewHeight = reviewPlacement === "below" ? clampBelowPaneHeight(reviewSizePref.below ?? belowPaneHeight(bodyHeight), bodyHeight) : bodyHeight;
@@ -7811,9 +9576,11 @@ function ChatScreen({ agent, conversation }) {
 	const chatHeight = bodyHeight;
 	const inlineReviewHeight = reviewOpen && reviewPlacement === "below" ? reviewHeight : 0;
 	const menuRows = menuOpen ? completionMenuHeight(menuCommands.length) : 0;
-	const todoCardVisible = !credPrompt && !!todos && todos.length > 0;
+	const todoCardVisible = !credPrompt && !planHidden && !!todos && todos.length > 0;
 	const todoRows = todoCardVisible ? todoCardHeight(todos) : 0;
-	const scrollHeight = Math.max(3, chatHeight - 2 - bottomBoxHeight - pendingRows - inlineReviewHeight - menuRows - todoRows);
+	const jumpHintVisible = scrolledUp && !credPrompt;
+	const jumpHintRows = jumpHintVisible ? 1 : 0;
+	const scrollHeight = Math.max(3, chatHeight - 2 - bottomBoxHeight - pendingRows - inlineReviewHeight - menuRows - jumpHintRows - todoRows);
 	useEffect(() => {
 		if (reviewOpen && reviewFocused) {
 			const composer = composerRef.current;
@@ -7840,11 +9607,13 @@ function ChatScreen({ agent, conversation }) {
 		};
 	}, [
 		grantPrompt,
+		cardPickerOpen,
 		modelPickerOpen,
 		themePickerOpen,
 		helpOpen,
 		reviewOpen,
 		reviewFocused,
+		reviewPlacement,
 		credPromptOpen
 	]);
 	useEffect(() => {
@@ -7861,6 +9630,16 @@ function ChatScreen({ agent, conversation }) {
 					text: recapText
 				});
 				setItems(loaded);
+				for (const item of loaded) {
+					const text = item.kind === "assistant-text" ? item.text : item.kind === "tool" && item.output?.kind === "ok" ? stringifyToolOutput(item.output.value) : null;
+					if (text === null) continue;
+					for (const pr of extractPullRequests(text, { requireCompleteNumber: false })) {
+						if (reportedPrsRef.current.has(pr.key)) continue;
+						reportedPrsRef.current.set(pr.key, pr);
+						setPrLinks((prev) => [...prev, pr]);
+						agentHost.addPullRequest(pr);
+					}
+				}
 				setTodos(latestTodosFromHistory(messages));
 			} catch (err) {
 				if (cancelled) return;
@@ -7876,24 +9655,36 @@ function ChatScreen({ agent, conversation }) {
 		return () => {
 			cancelled = true;
 		};
-	}, [rest, initialConversationId]);
-	const attachToRun = useCallback((runId, runAgentName) => {
+	}, [
+		rest,
+		initialConversationId,
+		agentHost
+	]);
+	const attachToRun = useCallback((runId, runAgentName, runStartedAtMs) => {
 		if (!rest) return;
 		seenRunsRef.current.add(runId);
 		const abort = new AbortController();
 		const responsePreview = createResponsePreview();
+		const prScanner = createPullRequestScanner((pr) => {
+			if (reportedPrsRef.current.has(pr.key)) return;
+			reportedPrsRef.current.set(pr.key, pr);
+			setPrLinks((prev) => [...prev, pr]);
+			agentHost.addPullRequest(pr);
+		});
 		const streamAgentName = runAgentName ?? agent.name;
-		setRun({
+		setRun((prev) => ({
 			kind: "streaming",
 			runId,
-			abort
-		});
+			abort,
+			startedAtMs: runStartedAtMs ?? (prev.kind === "idle" ? Date.now() : prev.startedAtMs)
+		}));
 		rest.streamRun({
 			runId,
 			signal: abort.signal,
 			onEvent: (event) => {
 				if (event.kind === "chunk") {
 					responsePreview.addChunk(event.chunk);
+					prScanner.addChunk(event.chunk);
 					if (event.chunk.type === "data-anyone-todos-updated") {
 						const next = todosFromPayload(event.chunk.data);
 						if (next) setTodos(next.length > 0 ? next : null);
@@ -7938,6 +9729,8 @@ function ChatScreen({ agent, conversation }) {
 		agentHost
 	]);
 	const multiAgent = useMemo(() => conversationAgentNames(items, agent.name), [items, agent.name]).size > 1;
+	const transcriptWindow = useMemo(() => windowItems(items), [items]);
+	const themeGeneration = themeVersion();
 	useEffect(() => {
 		if (!rest || !conversationId) return;
 		const abort = new AbortController();
@@ -7948,18 +9741,25 @@ function ChatScreen({ agent, conversation }) {
 				if (event.kind === "run") {
 					if (seenRunsRef.current.has(event.runId)) return;
 					if (runRef.current.kind !== "idle") return;
-					attachToRun(event.runId);
+					attachToRun(event.runId, null, parseStampMs(event.createdAt));
 					return;
 				}
-				if (event.title) setChatTitle(event.title);
+				if (event.kind === "compaction") {
+					onCompactionEvent(event.status);
+					return;
+				}
+				if (event.kind === "conversation" && event.title) setChatTitle(event.title);
 			}
 		}).catch(() => {});
-		return () => abort.abort();
+		return () => {
+			abort.abort();
+		};
 	}, [
 		rest,
 		conversationId,
 		setChatTitle,
-		attachToRun
+		attachToRun,
+		onCompactionEvent
 	]);
 	const sendContent = useCallback(async (content, staged, opts) => {
 		if (!rest) return;
@@ -7975,7 +9775,10 @@ function ChatScreen({ agent, conversation }) {
 			...stagedNames.length > 0 ? { attachments: stagedNames } : {}
 		}]);
 		const wasStreaming = runRef.current.kind === "streaming";
-		if (!wasStreaming) setRun({ kind: "sending" });
+		if (!wasStreaming) setRun({
+			kind: "sending",
+			startedAtMs: Date.now()
+		});
 		try {
 			const attachmentIds = [];
 			const restorable = [];
@@ -8029,7 +9832,7 @@ function ChatScreen({ agent, conversation }) {
 			setItems((prev) => [...prev.filter((m) => m.id !== optimisticId), {
 				kind: "error",
 				id: crypto.randomUUID(),
-				text: errorDetail(err)
+				text: sendErrorMessage(err)
 			}]);
 			if (echo) setInput((existing) => existing ? existing : trimmed);
 			const restore = staged.filter((a) => uploadsRef.current.has(a.tempId));
@@ -8075,6 +9878,7 @@ function ChatScreen({ agent, conversation }) {
 		portalStatus,
 		portalClient,
 		agent.id,
+		agent.name,
 		sendContent
 	]);
 	const cancelLatestSteer = useCallback(() => {
@@ -8161,7 +9965,7 @@ function ChatScreen({ agent, conversation }) {
 					detail: "already connected"
 				});
 			} else if (action.kind === "open_github_app") {
-				const url = resolveConnectUrl(action.url, appUrl);
+				const url = resolveConnectUrl(action.url, resolveWebUrl(appUrl));
 				await openUrlInBrowser(url);
 				updateCard(item.id, {
 					status: "launched",
@@ -8190,10 +9994,15 @@ function ChatScreen({ agent, conversation }) {
 		portalClient,
 		portal.status
 	]);
-	const runNewestCard = useCallback(() => {
-		const target = [...itemsRef.current].reverse().find(isActionableCard);
-		if (!target) return false;
-		runCardAction(target);
+	const promptForCards = useCallback(() => {
+		const targets = itemsRef.current.filter(isActionableCard);
+		const [only] = targets;
+		if (!only) return false;
+		if (targets.length === 1) {
+			runCardAction(only);
+			return true;
+		}
+		setCardPickerOpen(true);
 		return true;
 	}, [runCardAction]);
 	const handleCredInput = useCallback((displayed) => {
@@ -8277,10 +10086,10 @@ function ChatScreen({ agent, conversation }) {
 		}]);
 		let captured = "";
 		const appendOutput = (chunk) => {
-			captured += chunk;
+			captured = clampedAppend(captured, chunk);
 			setItems((prev) => prev.map((m) => m.id === id && m.kind === "shell" ? {
 				...m,
-				output: m.output + chunk
+				output: clampedAppend(m.output, chunk)
 			} : m));
 		};
 		let exitCode;
@@ -8294,6 +10103,7 @@ function ChatScreen({ agent, conversation }) {
 				...m,
 				exit: exitCode
 			} : m));
+			bindPortalCwd();
 		} catch (err) {
 			appendOutput(`\n${errorMessage(err)}`);
 			exitCode = 1;
@@ -8303,7 +10113,7 @@ function ChatScreen({ agent, conversation }) {
 			} : m));
 		}
 		sendContent(formatShellContext(command, captured, exitCode), [], { echo: false });
-	}, [sendContent]);
+	}, [sendContent, bindPortalCwd]);
 	const runSandboxExec = useCallback((command) => {
 		if (!appUrl || !sessionToken) return;
 		const id = crypto.randomUUID();
@@ -8317,7 +10127,7 @@ function ChatScreen({ agent, conversation }) {
 		const dec = new TextDecoder();
 		const append = (chunk) => setItems((prev) => prev.map((m) => m.id === id && m.kind === "shell" ? {
 			...m,
-			output: m.output + chunk
+			output: clampedAppend(m.output, chunk)
 		} : m));
 		const stamp = (exit) => setItems((prev) => prev.map((m) => m.id === id && m.kind === "shell" ? {
 			...m,
@@ -8438,7 +10248,7 @@ function ChatScreen({ agent, conversation }) {
 		stageAttachment(image);
 	}, [stageAttachment]);
 	usePaste((event) => {
-		if (modelPickerOpen || themePickerOpen || helpOpen || credPromptOpen || grantPrompt) return;
+		if (cardPickerOpen || modelPickerOpen || themePickerOpen || helpOpen || credPromptOpen || grantPrompt || nonWebChannel) return;
 		const text = event.metadata?.kind === "binary" ? "" : decodePasteBytes(event.bytes);
 		const route = routePaste({
 			kind: event.metadata?.kind,
@@ -8487,6 +10297,7 @@ function ChatScreen({ agent, conversation }) {
 		if (composer.plainText === "" && inputRef.current !== "") applyComposerText(inputRef.current, "end");
 	}, [
 		grantPrompt,
+		cardPickerOpen,
 		modelPickerOpen,
 		themePickerOpen,
 		helpOpen,
@@ -8508,6 +10319,17 @@ function ChatScreen({ agent, conversation }) {
 		} : m));
 		useStore.getState().showToast({ message: "run cancelled" });
 	}, [rest]);
+	const copyLastMessage = useCallback(() => {
+		const last = [...items].reverse().find((m) => m.kind === "assistant-text" && m.done && m.text.trim() !== "");
+		if (!last) {
+			useStore.getState().showToast({ message: "no agent message to copy yet" });
+			return;
+		}
+		writeClipboardText(last.text).then((ok) => useStore.getState().showToast(ok ? {
+			variant: "success",
+			message: "copied last message to clipboard"
+		} : { message: "clipboard unavailable" }));
+	}, [items]);
 	const openInBrowser = useCallback(() => {
 		if (!appUrl) return;
 		if (!conversationId) {
@@ -8524,11 +10346,141 @@ function ChatScreen({ agent, conversation }) {
 			text: `couldn't open a browser — visit ${url} (${errorMessage(err)})`
 		}]));
 	}, [appUrl, conversationId]);
+	const forkAndContinue = useCallback(() => {
+		if (!rest || !conversationId || forkingRef.current) return;
+		forkingRef.current = true;
+		setForking(true);
+		useStore.getState().showToast({ message: "forking into a new chat…" });
+		const screenAtFork = useStore.getState().screen;
+		const stillHere = () => useStore.getState().screen === screenAtFork;
+		rest.forkConversation({ conversationId }).then((forked) => {
+			if (!stillHere()) return;
+			goTo({
+				kind: "chat",
+				agent,
+				conversation: forkedConversationRef({
+					agent,
+					forked
+				})
+			});
+			useStore.getState().showToast({
+				variant: "success",
+				message: "Forked conversation"
+			});
+		}).catch((err) => {
+			forkingRef.current = false;
+			setForking(false);
+			if (!stillHere()) return;
+			useStore.getState().showToast({
+				variant: "error",
+				message: `couldn't fork this conversation: ${errorMessage(err)}`
+			});
+		});
+	}, [
+		rest,
+		conversationId,
+		agent,
+		goTo
+	]);
+	const archiveConversation = useCallback(() => {
+		if (grantPrompt || credPrompt) return;
+		if (runRef.current.kind !== "idle") {
+			useStore.getState().showToast({ message: "finish or cancel the run first (ctrl+c)" });
+			return;
+		}
+		if (!conversationId) {
+			useStore.getState().showToast({ message: "nothing to archive yet — send a message to start this one" });
+			return;
+		}
+		if (!rest) return;
+		rest.setConversationArchived({
+			conversationId,
+			archived: true
+		}).then(() => {
+			useStore.getState().showToast({
+				variant: "success",
+				message: "archived — shift+tab in the picker shows it, ctrl+a restores"
+			});
+			goTo({
+				kind: "conversation-picker",
+				agent
+			});
+		}).catch((err) => useStore.getState().showToast({
+			variant: "error",
+			message: err instanceof HttpError && err.status === 404 ? "can't archive this one — it's already gone from your list" : `couldn't archive: ${errorMessage(err)}`
+		}));
+	}, [
+		grantPrompt,
+		credPrompt,
+		conversationId,
+		rest,
+		goTo,
+		agent
+	]);
+	/**
+	* Leave this conversation for another screen without ending its run: drop
+	* our own SSE subscription and nothing else — never `rest.cancelRun` — so
+	* the agent keeps working server-side and reopening the thread reattaches.
+	* Same contract as `esc`, which is why `/conversation` is allowed mid-run
+	* where `/new` is not: what you land on still lists the thread you left,
+	* so the run is never stranded out of reach.
+	*/
+	const leaveForScreen = useCallback((next) => {
+		const current = runRef.current;
+		if (current.kind === "streaming") current.abort.abort();
+		if (current.kind !== "idle") useStore.getState().showToast({ message: `${agent.name} keeps working — reopen to reattach` });
+		goTo(next);
+	}, [agent.name, goTo]);
+	/**
+	* `/conversation <id or link>`: open that conversation without leaving the
+	* TUI — the point being that the id usually arrives *from* an agent, in the
+	* session you started to go find it.
+	*
+	* Resolution goes through `resolveInitialScreen`, the same path
+	* `--resume <id>` takes, so an id belonging to a different agent opens
+	* under that agent and the not-found / no-access wording lives in one
+	* place.
+	*/
+	const openConversationRef = useCallback(async (ref) => {
+		const target = parseConversationRef(ref);
+		if (!target) {
+			setItems((prev) => [...prev, {
+				kind: "error",
+				id: crypto.randomUUID(),
+				text: `not a conversation id: ${ref} — pass an id, its /c/<id> link, or run /conversation on its own to pick from the list`
+			}]);
+			return;
+		}
+		if (!rest) return;
+		if (target === conversationId) {
+			useStore.getState().showToast({ message: "already in this conversation" });
+			return;
+		}
+		try {
+			leaveForScreen(await resolveInitialScreen({
+				rest,
+				agentSelector: null,
+				conversationId: target,
+				newConversation: false
+			}));
+		} catch (err) {
+			setItems((prev) => [...prev, {
+				kind: "error",
+				id: crypto.randomUUID(),
+				text: `couldn't open ${target}: ${errorMessage(err)}`
+			}]);
+		}
+	}, [
+		rest,
+		conversationId,
+		leaveForScreen
+	]);
 	const toggleShare = useCallback(() => {
 		if (!portalClient) return;
 		if (portal.status === "off") {
 			declinedRef.current.delete(agent.id);
 			portalClient.enable();
+			if (conversationId) portalClient.bind(conversationId, shellSessionRef.current?.cwd ?? process.cwd());
 		} else {
 			portalClient.disable();
 			setPortalPrompt(null);
@@ -8537,7 +10489,8 @@ function ChatScreen({ agent, conversation }) {
 		portalClient,
 		portal.status,
 		agent.id,
-		setPortalPrompt
+		setPortalPrompt,
+		conversationId
 	]);
 	const confirmGrant = useCallback(() => {
 		if (!portalClient) return;
@@ -8562,8 +10515,54 @@ function ChatScreen({ agent, conversation }) {
 		setPortalPrompt(null);
 		useStore.getState().showToast({ message: "kept this machine private" });
 	}, [agent.id, setPortalPrompt]);
+	const openPortalAccess = useCallback(() => {
+		if (!portalClient) {
+			useStore.getState().showToast({ message: "local access is unavailable in this session" });
+			return;
+		}
+		switch (portal.status) {
+			case "off":
+				declinedRef.current.delete(agent.id);
+				portalClient.enable();
+				useStore.getState().showToast({ message: "enabling local access on this machine…" });
+				break;
+			case "connecting":
+				useStore.getState().showToast({ message: "local access is still connecting…" });
+				break;
+			case "connected":
+				if (portal.grantedAgentIds.includes(agent.id)) {
+					useStore.getState().showToast({ message: `${agent.name} can already run commands on this machine` });
+					break;
+				}
+				declinedRef.current.delete(agent.id);
+				setPortalPrompt({
+					agentId: agent.id,
+					agentName: agent.name
+				});
+				break;
+			case "error":
+				useStore.getState().showToast({ message: portal.error ? `local access error: ${portal.error}` : "local access hit an error" });
+				break;
+			default: {
+				const exhaustive = portal.status;
+				throw new Error(`unhandled portal status: ${String(exhaustive)}`);
+			}
+		}
+	}, [
+		portalClient,
+		portal.status,
+		portal.grantedAgentIds,
+		portal.error,
+		agent.id,
+		agent.name,
+		setPortalPrompt
+	]);
 	const executeLine = useCallback((content, staged) => {
 		if (!content && staged.length === 0) return;
+		if (forkingRef.current) {
+			useStore.getState().showToast({ message: "forking… hang on" });
+			return;
+		}
 		const routed = routeInput(content);
 		if (routed.kind !== "message") {
 			history.append(content);
@@ -8580,6 +10579,9 @@ function ChatScreen({ agent, conversation }) {
 				case "sandbox-pty":
 					runSandboxPty();
 					break;
+				case "archive-conversation":
+					archiveConversation();
+					break;
 				case "new-conversation":
 					if (runRef.current.kind !== "idle") {
 						useStore.getState().showToast({ message: "finish or cancel the run first (ctrl+c)" });
@@ -8595,6 +10597,26 @@ function ChatScreen({ agent, conversation }) {
 						}
 					});
 					break;
+				case "fork":
+					if (runRef.current.kind !== "idle") {
+						useStore.getState().showToast({ message: "finish or cancel the run first (ctrl+c)" });
+						break;
+					}
+					if (!conversationId) {
+						useStore.getState().showToast({ message: "nothing to fork yet — send a message first" });
+						break;
+					}
+					forkAndContinue();
+					break;
+				case "conversation-picker":
+					leaveForScreen({
+						kind: "conversation-picker",
+						agent
+					});
+					break;
+				case "open-conversation":
+					openConversationRef(routed.ref);
+					break;
 				case "model-picker":
 					setModelPickerOpen(true);
 					break;
@@ -8619,14 +10641,33 @@ function ChatScreen({ agent, conversation }) {
 						})
 					}]);
 					break;
+				case "plan": {
+					if (!(!!todos && todos.length > 0)) {
+						useStore.getState().showToast({ message: "no plan to show yet" });
+						break;
+					}
+					const nextHidden = routed.mode === "toggle" ? !planHidden : routed.mode === "hide";
+					setPlanHidden(nextHidden);
+					useStore.getState().showToast({ message: nextHidden ? "plan hidden (/plan show)" : "plan shown" });
+					break;
+				}
 				case "share":
 					toggleShare();
 					break;
 				case "browser":
 					openInBrowser();
 					break;
+				case "copy":
+					copyLastMessage();
+					break;
+				case "portal":
+					openPortalAccess();
+					break;
+				case "compact":
+					compactConversation();
+					break;
 				case "connect":
-					if (!runNewestCard()) useStore.getState().showToast({ message: "no connect card waiting for action" });
+					if (!promptForCards()) useStore.getState().showToast({ message: "no connect card waiting for action" });
 					break;
 				case "help":
 					setHelpOpen(true);
@@ -8653,8 +10694,15 @@ function ChatScreen({ agent, conversation }) {
 		runLocalShell,
 		runSandboxExec,
 		runSandboxPty,
+		archiveConversation,
+		forkAndContinue,
+		leaveForScreen,
+		openConversationRef,
 		toggleShare,
 		openInBrowser,
+		copyLastMessage,
+		openPortalAccess,
+		compactConversation,
 		quit,
 		sendContent,
 		goTo,
@@ -8665,7 +10713,9 @@ function ChatScreen({ agent, conversation }) {
 		model,
 		portal.status,
 		portal.grantedAgentIds,
-		runNewestCard
+		promptForCards,
+		todos,
+		planHidden
 	]);
 	const submit = useCallback(() => {
 		const staged = attachments.filter((a) => a.status !== "error");
@@ -8720,7 +10770,7 @@ function ChatScreen({ agent, conversation }) {
 			}
 			if (reviewFocused) return;
 		}
-		if (modelPickerOpen || themePickerOpen || helpOpen) return;
+		if (cardPickerOpen || modelPickerOpen || themePickerOpen || helpOpen) return;
 		if (grantPrompt) {
 			if (key.name === "y") {
 				confirmGrant();
@@ -8812,18 +10862,24 @@ function ChatScreen({ agent, conversation }) {
 			return;
 		}
 		if (key.name === "r" && key.ctrl) {
-			runNewestCard();
+			promptForCards();
 			return;
 		}
 		if (key.name === "t" && key.ctrl) {
 			toggleShare();
 			return;
 		}
+		if (nonWebChannel && key.name === "f" && key.ctrl) {
+			forkAndContinue();
+			return;
+		}
 		if (key.name === "v" && key.ctrl) {
+			if (nonWebChannel) return;
 			pasteImage();
 			return;
 		}
 		if (key.name === "x" && key.ctrl || key.name === "backspace" && attachmentsRef.current.length > 0 && !composerRef.current?.plainText) {
+			if (nonWebChannel) return;
 			const last = attachmentsRef.current.at(-1);
 			if (last) {
 				uploadsRef.current.delete(last.tempId);
@@ -8836,6 +10892,11 @@ function ChatScreen({ agent, conversation }) {
 			setThemePickerOpen(true);
 			return;
 		}
+		if (key.name === "a" && key.ctrl && input.trim() === "") {
+			key.preventDefault();
+			archiveConversation();
+			return;
+		}
 		if (key.name === "?" && !key.ctrl && !key.meta && input.trim() === "") {
 			composerRef.current?.clear();
 			setInput("");
@@ -8851,6 +10912,10 @@ function ChatScreen({ agent, conversation }) {
 			scrollRef.current?.scrollBy(pageScrollFraction, "viewport");
 			return;
 		}
+		if (key.name === "end" && scrolledUp) {
+			jumpToBottom();
+			return;
+		}
 		if (key.name === "c" && key.ctrl) {
 			if (runRef.current.kind === "streaming") {
 				cancelRun();
@@ -8882,21 +10947,31 @@ function ChatScreen({ agent, conversation }) {
 		}
 	});
 	const hasPendingSteer = items.some((m) => m.kind === "pending-steer");
-	const hasActionableCard = items.some(isActionableCard);
+	const actionableCards = useMemo(() => items.filter(isActionableCard), [items]);
 	const statusText = useMemo(() => formatChatFooterStatus({
 		runKind: run.kind,
 		ctrlCArmed,
 		isShared,
 		hasPendingSteer,
-		hasActionableCard
+		actionableCardCount: actionableCards.length,
+		nonWebChannel: nonWebChannel !== null
 	}), [
 		run.kind,
 		ctrlCArmed,
 		isShared,
 		hasPendingSteer,
-		hasActionableCard
+		actionableCards.length,
+		nonWebChannel
 	]);
 	const modelHint = formatModelHint(model);
+	if (cardPickerOpen) return /* @__PURE__ */ jsx(CardPicker, {
+		cards: actionableCards,
+		onSelect: (card) => {
+			setCardPickerOpen(false);
+			runCardAction(card);
+		},
+		onCancel: () => setCardPickerOpen(false)
+	});
 	if (modelPickerOpen) return /* @__PURE__ */ jsx(ModelPicker, {
 		agentId: agent.id,
 		currentModel: model,
@@ -8935,6 +11010,14 @@ function ChatScreen({ agent, conversation }) {
 			...prev,
 			side: size
 		}),
+		onToggleOrientation: () => {
+			if (!canToggleOrientation({
+				width,
+				height
+			})) return "unavailable";
+			setReviewOrientation(reviewPlacement === "below" ? "side" : "below");
+			return "toggled";
+		},
 		onInsertToComposer: (review) => {
 			const next = [inputRef.current.trimEnd(), review].filter((part) => part.length > 0).join("\n\n");
 			setInput(next);
@@ -9019,28 +11102,69 @@ function ChatScreen({ agent, conversation }) {
 							agent.name,
 							" below."
 						]
-					}) : /* @__PURE__ */ jsx(Fragment, { children: items.map((item, i) => {
-						const label = multiAgent ? agentLabelFor(items, i) : null;
-						return /* @__PURE__ */ jsxs("box", {
-							style: { flexDirection: "column" },
-							children: [label ? /* @__PURE__ */ jsx("box", {
-								style: {
-									paddingLeft: 3,
-									paddingRight: 1
-								},
-								children: /* @__PURE__ */ jsx("text", {
-									fg: theme.muted,
-									children: /* @__PURE__ */ jsx("b", { children: label })
-								})
-							}) : null, /* @__PURE__ */ jsx(RenderItem, { item })]
-						}, item.id);
-					}) }), run.kind !== "idle" ? /* @__PURE__ */ jsx(ActivityRow, { label: run.kind === "sending" ? "sending" : "working" }) : null]
+					}) : /* @__PURE__ */ jsxs(Fragment, { children: [transcriptWindow.hiddenCount > 0 ? /* @__PURE__ */ jsx("box", {
+						style: {
+							paddingLeft: 1,
+							paddingRight: 1
+						},
+						children: /* @__PURE__ */ jsxs("text", {
+							fg: theme.dim,
+							children: [
+								"↑ ",
+								transcriptWindow.hiddenCount,
+								" earlier message",
+								transcriptWindow.hiddenCount === 1 ? "" : "s",
+								" · kept in this session, not shown"
+							]
+						})
+					}) : null, transcriptWindow.visible.map(({ item, index }) => /* @__PURE__ */ jsx(TranscriptRow, {
+						item,
+						label: multiAgent ? agentLabelFor(items, index) : null,
+						themeVersion: themeGeneration
+					}, item.id))] }), run.kind !== "idle" ? /* @__PURE__ */ jsx(ActivityRow, {
+						label: run.kind === "sending" ? "sending" : "working",
+						startedAtMs: run.startedAtMs
+					}) : null]
 				})
 			}),
+			jumpHintVisible ? /* @__PURE__ */ jsxs("box", {
+				onMouseDown: jumpToBottom,
+				style: {
+					flexDirection: "row",
+					paddingLeft: 1,
+					paddingRight: 1,
+					height: 1,
+					flexShrink: 0
+				},
+				children: [/* @__PURE__ */ jsx("text", {
+					fg: theme.accent,
+					children: "↓ jump to latest"
+				}), /* @__PURE__ */ jsxs("text", {
+					fg: theme.dim,
+					children: ["  ", "end"]
+				})]
+			}) : null,
 			todoCardVisible && todos ? /* @__PURE__ */ jsx(TodoCardView, {
 				todos,
 				isActive: run.kind !== "idle"
 			}) : null,
+			compacting ? /* @__PURE__ */ jsxs("box", {
+				style: {
+					flexDirection: "row",
+					paddingLeft: 1,
+					paddingRight: 1,
+					height: 1,
+					flexShrink: 0,
+					marginTop: 1
+				},
+				children: [/* @__PURE__ */ jsx("text", {
+					fg: theme.accent,
+					children: "● compacting conversation…"
+				}), /* @__PURE__ */ jsxs("text", {
+					fg: theme.dim,
+					children: ["  ", "you can keep typing"]
+				})]
+			}) : null,
 			pendingVisible ? /* @__PURE__ */ jsxs("box", {
 				style: {
 					paddingLeft: 1,
@@ -9112,6 +11236,35 @@ function ChatScreen({ agent, conversation }) {
 						children: "n"
 					})
 				]
+			}) : nonWebChannel ? /* @__PURE__ */ jsxs("box", {
+				style: {
+					border: true,
+					borderColor: theme.faint,
+					paddingLeft: 1,
+					paddingRight: 1,
+					height: nonWebNoticeHeight,
+					flexShrink: 0,
+					marginTop: 1,
+					flexDirection: "column"
+				},
+				children: [
+					/* @__PURE__ */ jsxs("text", {
+						fg: theme.muted,
+						children: [
+							"this conversation is on ",
+							nonWebChannel,
+							"."
+						]
+					}),
+					/* @__PURE__ */ jsx("text", {
+						fg: theme.dim,
+						children: "reply there to continue it."
+					}),
+					/* @__PURE__ */ jsx("text", {
+						fg: theme.dim,
+						children: forking ? "forking into a new chat…" : "ctrl+f  fork it into a chat you can continue here."
+					})
+				]
 			}) : /* @__PURE__ */ jsx("box", {
 				style: {
 					border: true,
@@ -9124,7 +11277,7 @@ function ChatScreen({ agent, conversation }) {
 				},
 				children: /* @__PURE__ */ jsx("textarea", {
 					ref: composerRef,
-					placeholder: `message ${agent.name}…`,
+					placeholder: forking ? "forking into a new chat…" : `message ${agent.name}…`,
 					keyBindings: composerKeyBindings,
 					onContentChange: handleComposerChange,
 					onSubmit: submit,
@@ -9153,6 +11306,7 @@ function ChatScreen({ agent, conversation }) {
 						fg: theme.muted,
 						children: statusText
 					}),
+					prLinks.length > 0 ? /* @__PURE__ */ jsx(PrLinksView, { prs: prLinks }) : null,
 					/* @__PURE__ */ jsx("box", { style: { flexGrow: 1 } }),
 					/* @__PURE__ */ jsx("text", {
 						fg: theme.dim,
@@ -9277,18 +11431,48 @@ function CredentialPromptBox({ prompt, height, onInput, onSubmit }) {
 	});
 }
 /**
+* One transcript row: the optional agent-attribution label plus the item's own
+* rendering. Memoized on the item because the reducer rebuilds the `items`
+* array on every stream chunk while leaving finished items' objects untouched.
+* Without the memo, one text delta re-rendered every row in the scrollback, and
+* each re-render pushes content through that row's native OpenTUI text buffers,
+* which never hand their memory back — so a long session grew O(turns^2)
+* resident memory (~1GB after 6k deltas in a soak; ~190MB with the memo).
+*
+* `themeVersion` is a prop rather than a read because rows resolve colors from
+* the mutable `theme` binding during render: a swap mutates that object in
+* place, so the memo needs the version bump to know its output is stale.
+*/
+const TranscriptRow = memo(function TranscriptRow({ item, label }) {
+	return /* @__PURE__ */ jsxs("box", {
+		style: { flexDirection: "column" },
+		children: [label ? /* @__PURE__ */ jsx("box", {
+			style: {
+				paddingLeft: 3,
+				paddingRight: 1
+			},
+			children: /* @__PURE__ */ jsx("text", {
+				fg: theme.muted,
+				children: /* @__PURE__ */ jsx("b", { children: label })
+			})
+		}) : null, /* @__PURE__ */ jsx(RenderItem, { item })]
+	});
+});
+/**
 * A live indicator at the foot of the transcript while a run is in flight: an
 * animated spinner plus a label and a seconds counter, so it's obvious the
-* agent is still working even during long gaps between chunks. Owns its own
-* elapsed-time timer so ticking the counter doesn't re-render the transcript.
+* agent is still working even during long gaps between chunks. The counter
+* measures from the run's own start, not from this row appearing, so reopening
+* a conversation mid-run shows how long the agent has really been at it. Owns
+* its own clock so ticking it doesn't re-render the transcript.
 */
-function ActivityRow({ label }) {
-	const [elapsed, setElapsed] = useState(0);
+function ActivityRow({ label, startedAtMs }) {
+	const [now, setNow] = useState(() => Date.now());
 	useEffect(() => {
-		const start = Date.now();
-		const id = setInterval(() => setElapsed(Math.floor((Date.now() - start) / 1e3)), 250);
+		const id = setInterval(() => setNow(Date.now()), 250);
 		return () => clearInterval(id);
 	}, []);
+	const elapsed = Math.floor((now - startedAtMs) / 1e3);
 	return /* @__PURE__ */ jsxs("box", {
 		style: {
 			flexDirection: "row",
@@ -9357,9 +11541,10 @@ function ToastView() {
 
 //#endregion
 //#region src/chat/tui/app.tsx
-function App({ appUrl, sessionToken, shareMachine, promptHistoryPath, notifications, agentSelector, conversationId }) {
+function App({ appUrl, sessionToken, shareMachine, promptHistoryPath, notifications, agentSelector, conversationId, newConversation }) {
 	const renderer = useRenderer();
 	const screen = useStore((s) => s.screen);
+	const chatTitle = useStore((s) => s.chatTitle);
 	useStore((s) => s.themeId);
 	const rest = useStore((s) => s.rest);
 	const goTo = useStore((s) => s.goTo);
@@ -9378,6 +11563,13 @@ function App({ appUrl, sessionToken, shareMachine, promptHistoryPath, notificati
 		agentHost.transition({ state: "idle" });
 		return () => agentHost.dispose();
 	}, [agentHost]);
+	useEffect(() => {
+		agentHost.setTitle(titleLabel(screen, chatTitle));
+	}, [
+		agentHost,
+		screen,
+		chatTitle
+	]);
 	useEffect(() => {
 		const selectionCopy = createSelectionCopy({
 			renderer,
@@ -9431,7 +11623,7 @@ function App({ appUrl, sessionToken, shareMachine, promptHistoryPath, notificati
 					rest,
 					agentSelector,
 					conversationId,
-					newConversation: useStore.getState().seedPrompt !== null
+					newConversation: newConversation || useStore.getState().seedPrompt !== null
 				});
 				if (cancelled) return;
 				goTo(screen);
@@ -9453,6 +11645,7 @@ function App({ appUrl, sessionToken, shareMachine, promptHistoryPath, notificati
 		promptHistoryPath,
 		agentSelector,
 		conversationId,
+		newConversation,
 		goTo,
 		setClients,
 		fail
@@ -9748,6 +11941,183 @@ var LinkifiedMarkdownRenderable = class extends MarkdownRenderable {
 	}
 };
 
+//#endregion
+//#region src/chat/tui/chunks/grammars/index.ts
+/**
+* Register the extra tree-sitter grammars (python, go, rust, bash, …) before
+* the renderer boots its tree-sitter client, so fenced code blocks and diffs
+* in those languages highlight instead of rendering as plain text.
+*
+* `addDefaultParsers` merges by filetype into the set the client registers on
+* init, so this must run BEFORE `createCliRenderer`. The grammar definitions
+* live in ./grammars.ts, which is externalized from the tsdown bundle (it
+* imports `.wasm`/`.scm` assets rolldown can't parse) — so we reach it through
+* a dynamic import that both Bun-runtime (npm) and the compiled binary resolve.
+*/
+async function registerGrammars() {
+	const { EXTRA_GRAMMARS } = await import("./chat/tui/chunks/grammars/grammars.js");
+	addDefaultParsers(EXTRA_GRAMMARS);
+}
+
+//#endregion
+//#region src/chat/memory-watchdog.ts
+const MB = 1024 * 1024;
+/** How often to sample RSS. */
+const DEFAULT_SAMPLE_INTERVAL_MS = 15e3;
+/**
+* Soft threshold: cross it and we warn the user once. A healthy chat session
+* sits in the low hundreds of MB, so 2 GB is "something is wrong" without
+* being so eager it fires on a legitimately large conversation.
+*/
+const DEFAULT_WARN_THRESHOLD_BYTES = 2 * 1024 * MB;
+/**
+* A clean exit still writes a report if the peak got this high — so we learn
+* about near-misses that didn't quite OOM, not just the crashes.
+*/
+const DEFAULT_REPORT_THRESHOLD_BYTES = 4 * 1024 * MB;
+/** Keep the last N samples so the report shows a growth curve, not a point. */
+const MAX_SAMPLES = 240;
+function envBytes(name, fallback) {
+	const raw = process.env[name];
+	if (!raw) return fallback;
+	const n = Number(raw);
+	return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function envMs(name, fallback) {
+	const raw = process.env[name];
+	if (!raw) return fallback;
+	const n = Number(raw);
+	return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+/**
+* Start the memory watchdog. Returns a handle; call `stop()` on teardown.
+*
+* Disabled entirely when `SKYDIVE_NO_MEMORY_WATCHDOG` is set — an escape
+* hatch that also keeps the sampler out of the way in tests and CI.
+*/
+function startMemoryWatchdog(opts = {}) {
+	const disabled = Boolean(process.env["SKYDIVE_NO_MEMORY_WATCHDOG"]);
+	const now = opts.now ?? (() => Date.now());
+	const readMemory = opts.readMemory ?? (() => {
+		const u = process.memoryUsage();
+		return {
+			rss: u.rss,
+			heapUsed: u.heapUsed
+		};
+	});
+	const sampleIntervalMs = opts.sampleIntervalMs ?? envMs("SKYDIVE_MEMORY_SAMPLE_MS", DEFAULT_SAMPLE_INTERVAL_MS);
+	const warnThreshold = opts.warnThresholdBytes ?? envBytes("SKYDIVE_MEMORY_WARN_BYTES", DEFAULT_WARN_THRESHOLD_BYTES);
+	const reportThreshold = opts.reportThresholdBytes ?? envBytes("SKYDIVE_MEMORY_REPORT_BYTES", DEFAULT_REPORT_THRESHOLD_BYTES);
+	const startedAt = now();
+	const samples = [];
+	let peakRss = 0;
+	let peakHeapUsed = 0;
+	let warned = false;
+	function sample() {
+		const { rss, heapUsed } = readMemory();
+		if (rss > peakRss) peakRss = rss;
+		if (heapUsed > peakHeapUsed) peakHeapUsed = heapUsed;
+		const s = {
+			at: now() - startedAt,
+			rss,
+			heapUsed
+		};
+		samples.push(s);
+		if (samples.length > MAX_SAMPLES) samples.shift();
+		if (!warned && rss >= warnThreshold) {
+			warned = true;
+			opts.onWarn?.({
+				rss,
+				threshold: warnThreshold
+			});
+		}
+		return s;
+	}
+	function snapshot() {
+		if (disabled) return null;
+		sample();
+		return {
+			peakRss,
+			peakHeapUsed,
+			warnThreshold,
+			uptimeMs: now() - startedAt,
+			samples: samples.slice()
+		};
+	}
+	if (disabled) return {
+		peakRss: () => 0,
+		samples: () => [],
+		snapshot: () => null,
+		stop: () => {}
+	};
+	sample();
+	const timer = setInterval(sample, sampleIntervalMs);
+	if (typeof timer.unref === "function") timer.unref();
+	const onExit = () => {
+		if (peakRss < reportThreshold) return;
+		writeCrashReport(buildCrashReport({
+			reason: "high-memory-exit",
+			memory: {
+				peakRss,
+				peakHeapUsed,
+				warnThreshold,
+				uptimeMs: now() - startedAt,
+				samples: samples.slice()
+			}
+		}));
+	};
+	const installExitHandler = opts.installExitHandler ?? true;
+	if (installExitHandler) process.on("exit", onExit);
+	return {
+		peakRss: () => peakRss,
+		samples: () => samples.slice(),
+		snapshot,
+		stop: () => {
+			clearInterval(timer);
+			if (installExitHandler) process.off("exit", onExit);
+		}
+	};
+}
+
+//#endregion
+//#region src/chat/theme-boot.ts
+/**
+* How long the first paint waits for the terminal to report its background
+* colour via OSC 10/11.
+*
+* OpenTUI's own default is 1000ms, and `createCliRenderer` has already switched
+* to the alternate screen by the time we wait — so on a terminal that never
+* answers the query (no OSC theme support, or a passthrough that eats it) the
+* user watched a blank cleared screen for a flat second on every launch, which
+* measured as 68% of cold start. Bound it by our budget rather than the
+* dependency's: 20ms is a typical real answer, so 100ms is generous.
+*/
+const THEME_QUERY_GRACE_MS = 100;
+/**
+* Settle the theme for the first paint, and keep following the terminal after
+* it.
+*
+* Order is the whole point and is load-bearing:
+*
+* 1. Subscribe to `theme_mode` FIRST. It carries both a late OSC answer and
+*    every later system light/dark flip, so with the subscription in place,
+*    giving up on the query early can only cost a briefly-wrong first paint —
+*    never a permanently wrong theme.
+* 2. Apply the synchronous `COLORFGBG` sniff (iTerm2 and friends set it) so
+*    there is something correct to paint at t=0.
+* 3. Only then wait, briefly, for the real answer.
+*
+* Inverting 2 and 3 is the bug this replaced: `COLORFGBG` was consulted only
+* after the 1000ms timeout expired, i.e. we blocked the launch waiting for
+* information we already had.
+*/
+async function settleBootThemeMode({ source, applyThemeMode, graceMs = THEME_QUERY_GRACE_MS, env }) {
+	source.on("theme_mode", applyThemeMode);
+	applyThemeMode(themeModeFromColorFgBg(env) ?? "dark");
+	const answered = await source.waitForThemeMode(graceMs);
+	if (answered) applyThemeMode(answered);
+}
+
 //#endregion
 //#region src/chat/boot.tsx
 /**
@@ -9756,12 +12126,16 @@ var LinkifiedMarkdownRenderable = class extends MarkdownRenderable {
 * module — and the heavy OpenTUI dependency graph it pulls in — is
 * dynamically imported and never loaded on the Node management path.
 */
-async function runChat({ appUrl, sessionToken, shareMachine, promptHistoryPath, theme: themeOverride, notifications, agentSelector, conversationId, seedPrompt }) {
+async function runChat({ appUrl, sessionToken, shareMachine, promptHistoryPath, theme: themeOverride, notifications, agentSelector, conversationId, newConversation, seedPrompt }) {
+	await registerGrammars();
+	const watchdog = startMemoryWatchdog();
+	installCrashHandler({ memoryProvider: () => watchdog.snapshot() });
 	const renderer = await createCliRenderer({ exitOnCtrlC: false });
 	extend({ markdown: LinkifiedMarkdownRenderable });
 	useStore.setState({
 		seedPrompt: seedPrompt ?? null,
-		autoGrantMachine: Boolean(seedPrompt && shareMachine)
+		autoGrantMachine: Boolean(seedPrompt && shareMachine),
+		newConversationIntent: newConversation
 	});
 	const store = useStore.getState();
 	if (noColorRequested()) {
@@ -9771,13 +12145,10 @@ async function runChat({ appUrl, sessionToken, shareMachine, promptHistoryPath,
 			themeId: monoTheme.id
 		});
 	} else if (themeOverride && findTheme(themeOverride)) store.lockTheme(themeOverride);
-	else {
-		const detected = await renderer.waitForThemeMode() ?? themeModeFromColorFgBg() ?? "dark";
-		store.setThemeMode(detected);
-		renderer.on("theme_mode", (mode) => {
-			useStore.getState().setThemeMode(mode);
-		});
-	}
+	else await settleBootThemeMode({
+		source: renderer,
+		applyThemeMode: (mode) => useStore.getState().setThemeMode(mode)
+	});
 	createRoot(renderer).render(/* @__PURE__ */ jsx(App, {
 		appUrl,
 		sessionToken,
@@ -9785,14 +12156,17 @@ async function runChat({ appUrl, sessionToken, shareMachine, promptHistoryPath,
 		promptHistoryPath,
 		notifications,
 		agentSelector: agentSelector ?? null,
-		conversationId: conversationId ?? null
+		conversationId: conversationId ?? null,
+		newConversation
 	}));
 }
 /** Open the same workspace picker used by the initial agent screen. */
 async function runWorkspacePicker({ appUrl, sessionToken }) {
 	const renderer = await createCliRenderer({ exitOnCtrlC: false });
-	const detected = await renderer.waitForThemeMode() ?? themeModeFromColorFgBg() ?? "dark";
-	useStore.getState().setThemeMode(detected);
+	await settleBootThemeMode({
+		source: renderer,
+		applyThemeMode: (mode) => useStore.getState().setThemeMode(mode)
+	});
 	const close = () => renderer.destroy();
 	createRoot(renderer).render(/* @__PURE__ */ jsx("box", {
 		style: {