skydive-cli 0.5.0-beta.3 → 0.5.0-beta.30

package/dist/js/{boot-BVVbrf2k.mjs → boot-0-dpPM1_.mjs}

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
-import { D as setActiveWorkspace, E as listWorkspaces, S as themesForMode, _ as themeForMode, a as installCrashHandler, b as themeVersion, c as MARK_CELLS, d as DEFAULT_THEME_ID, f as applyTheme, g as theme, h as noColorRequested, i as writeArtifact, l as WORDMARK, m as monoTheme, n as profilingEnabled, o as buildCrashReport, p as findTheme, r as record, s as writeCrashReport, v as themeMode, w as getActiveWorkspaceId, y as themeModeFromColorFgBg } from "./profiler-DtuXkIkR.mjs";
-import { B as saveTheme, D as getSavedTheme, E as getReviewStateDir, L as resolveWebUrl, S as getConfigPath, 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, y as DEFAULT_APP_URL } from "./print-CbayCa87.mjs";
+import { A as takenAliasNames, C as themesForMode, D as dedupeAliasName, E as aliasActivationHint, F as getActiveWorkspaceId, L as listWorkspaces, N as detectShell, O as installAgentAlias, T as machineOsFromPlatform, _ as theme, a as installCrashHandler, b as themeModeFromColorFgBg, c as MARK_CELLS, d as splashFitsWidth, f as DEFAULT_THEME_ID, g as noColorRequested, h as monoTheme, i as writeArtifact, k as slugifyAliasName, l as WORDMARK, m as findTheme, n as profilingEnabled, o as buildCrashReport, p as applyTheme, r as record, s as writeCrashReport, v as themeForMode, x as themeVersion, y as themeMode, z as setActiveWorkspace } from "./profiler-BoO7ldO0.mjs";
+import { B as resolveWebUrl, C as getConfigPath, O as getReviewStateDir, P as recordDefaultAgent, U as saveTheme, b as DEFAULT_APP_URL, c as cardActionErrorMessage, d as reconcileMaskedInput, f as resolveConnectUrl, h as specKeyFor, i as resolveAgent, k as getSavedTheme, l as parseExternalOauthConnectParams, m as parseConnectCard, p as computeSettledLabel, s as MASK_CHAR, u as parseOauthConnectParams, y as DEFAULT_API_URL } from "./print-DYiQC5IW.mjs";
 import { t as HttpError } from "./http-error-DzyrsLAZ.mjs";
-import { a as isRecord, i as errorMessage, n as errorDetail, r as sendErrorMessage, t as createRestClient } from "./rest-BY2nADw5.mjs";
+import { a as isRecord, i as errorMessage, n as errorDetail, r as sendErrorMessage, t as createRestClient } from "./rest-xXfqT4SX.mjs";
 import { i as billingBlockedOutcomeFromSendResponse } from "./billing-blocked-2wju4gC_.mjs";
-import { t as PortalClient } from "./client-Dd5sMXPv.mjs";
-import "./daemon-Bq93vOIk.mjs";
-import { t as SandboxStream } from "./client-Cn2af31H.mjs";
-import { t as PortalDaemonClient } from "./daemon-client-Bewt98dE.mjs";
-import { t as runRawPtyPassthrough } from "./raw-pty-B6mAroiI.mjs";
+import { t as PortalClient } from "./client-DbqRBquD.mjs";
+import "./daemon-DuxaUuek.mjs";
+import "./api-DG5W6iwx.mjs";
+import { t as SandboxStream } from "./client-c4c5MmgN.mjs";
+import { t as PortalDaemonClient } from "./daemon-client-C4heMWTq.mjs";
+import { t as runRawPtyPassthrough } from "./raw-pty-DY4KelZW.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";
@@ -136,6 +137,7 @@ const useStore = create((set, get) => ({
 	seedPrompt: null,
 	autoGrantMachine: false,
 	newConversationIntent: false,
+	forcedOnboarding: false,
 	earlyInput: "",
 	goTo: (screen) => set({
 		screen,
@@ -212,7 +214,17 @@ const useStore = create((set, get) => ({
 /**
 * Decide the screen the chat TUI boots into.
 *
-* With no selector we open the agent picker, exactly as before.
+* With no selector we open the agent picker — unless the config stores a
+* `defaultAgent`, in which case a bare `skydive chat` opens a fresh
+* conversation with that agent directly. The default is maintained
+* automatically (every conversation the TUI opens records its agent, so a
+* bare launch returns to whoever you talked to last — the dominant launch
+* pattern), and `skydive config set defaultAgent` can seed or override it. A
+* stored selector that no longer resolves degrades silently to the agent
+* picker rather than an error screen: config goes stale (agent renamed,
+* archived, another one claiming the same name), and unlike a mistyped
+* `--agent` there is no command line to correct — and picking an agent
+* there heals the default on its own.
 *
 * With `--agent` (`skydive chat --agent grace`, no `-p`) we resolve it
 * against the org roster and open that agent's conversation list, skipping
@@ -228,20 +240,31 @@ const useStore = create((set, get) => ({
 * `--agent`. When both are given, the conversation wins (it pins the agent
 * anyway).
 *
+* None of these paths load the whole org agent roster. The only decision that
+* needs every candidate is disambiguating a fuzzy name/slug selector; an id
+* (or the `--resume` conversation's agentId) is exact and resolves with a
+* single `getAgent`, and `--new` with no selector only needs "exactly one
+* agent, or not", which a two-row page answers. A large org must never sit on
+* the `connecting…` splash while the roster streams in.
+*
 * Kept out of the React component so it's unit-testable under Node (the
 * component itself can't render without Bun + OpenTUI).
 */
-async function resolveInitialScreen({ rest, agentSelector, conversationId, newConversation }) {
+/** A selector that is a bare uuid is an exact agent id: it can be resolved
+* with a single `getAgent` fetch, so no boot path that carries one needs the
+* org roster. A name/slug selector is the only case that can be ambiguous and
+* therefore still needs the full candidate list to disambiguate. */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function resolveInitialScreen({ rest, agentSelector, conversationId, newConversation, defaultAgentSelector, forceOnboarding }) {
 	if (conversationId) {
-		const [conversation, agents] = await Promise.all([rest.getConversation({ conversationId }).catch((err) => {
+		const conversation = await rest.getConversation({ conversationId }).catch((err) => {
 			if (err instanceof HttpError && err.status === 404) throw new Error(`No conversation with id ${conversationId}. It may have been deleted, or belong to another workspace.`);
 			throw err;
-		}), rest.listAgents({
-			scope: "org",
-			onPage: null
-		})]);
-		const agent = agents.find((a) => a.id === conversation.agentId);
-		if (!agent) throw new Error(`Conversation ${conversationId} belongs to an agent you can't access.`);
+		});
+		const agent = await rest.getAgent({ agentId: conversation.agentId }).catch((err) => {
+			if (err instanceof HttpError && (err.status === 404 || err.status === 403)) throw new Error(`Conversation ${conversationId} belongs to an agent you can't access.`);
+			throw err;
+		});
 		return {
 			kind: "chat",
 			agent,
@@ -262,26 +285,68 @@ async function resolveInitialScreen({ rest, agentSelector, conversationId, newCo
 			}
 		};
 	}
-	if (!agentSelector && !newConversation) return { kind: "agent-picker" };
-	const agents = await rest.listAgents({
-		scope: "org",
-		onPage: null
-	});
-	if (!agentSelector && newConversation) {
-		const only = agents.length === 1 ? agents[0] : null;
-		if (!only) return { kind: "agent-picker" };
-		return {
+	if (forceOnboarding && !agentSelector) return { kind: "first-run" };
+	if (!agentSelector && !newConversation && !defaultAgentSelector) {
+		if ((await rest.listAgents({
+			scope: "org",
+			onPage: null
+		})).length === 0) return { kind: "first-run" };
+		return { kind: "agent-picker" };
+	}
+	if (!agentSelector && defaultAgentSelector) {
+		const agent = UUID_RE.test(defaultAgentSelector) ? await rest.getAgent({ agentId: defaultAgentSelector }).catch((err) => {
+			if (err instanceof HttpError && (err.status === 404 || err.status === 403)) return null;
+			throw err;
+		}) : resolveAgentOrNull(await rest.listAgents({
+			scope: "org",
+			onPage: null
+		}), defaultAgentSelector);
+		if (agent) return newChat(agent);
+		return { kind: "agent-picker" };
+	}
+	if (agentSelector && UUID_RE.test(agentSelector)) {
+		const agent = await rest.getAgent({ agentId: agentSelector }).catch((err) => {
+			if (err instanceof HttpError && (err.status === 404 || err.status === 403)) throw new Error(`No agent with id ${agentSelector}. It may not exist, or belong to another workspace.`);
+			throw err;
+		});
+		if (newConversation) return {
 			kind: "chat",
-			agent: only,
+			agent,
 			conversation: {
 				kind: "new",
-				agentId: only.id,
+				agentId: agent.id,
 				nonce: crypto.randomUUID()
 			}
 		};
+		return {
+			kind: "conversation-picker",
+			agent,
+			initialQuery: ""
+		};
+	}
+	if (!agentSelector && newConversation) {
+		const firstTwo = await rest.listAgents({
+			scope: "org",
+			onPage: null,
+			limit: 2
+		});
+		const only = firstTwo.length === 1 ? firstTwo[0] : null;
+		if (!only) return { kind: "agent-picker" };
+		return newChat(only);
 	}
-	const agent = resolveAgent(agents, agentSelector);
-	if (newConversation) return {
+	const agent = resolveAgent(await rest.listAgents({
+		scope: "org",
+		onPage: null
+	}), agentSelector);
+	if (newConversation) return newChat(agent);
+	return {
+		kind: "conversation-picker",
+		agent,
+		initialQuery: ""
+	};
+}
+function newChat(agent) {
+	return {
 		kind: "chat",
 		agent,
 		conversation: {
@@ -290,10 +355,17 @@ async function resolveInitialScreen({ rest, agentSelector, conversationId, newCo
 			nonce: crypto.randomUUID()
 		}
 	};
-	return {
-		kind: "conversation-picker",
-		agent
-	};
+}
+/** `resolveAgent` throws for a selector that matches nothing or matches
+* ambiguously — both phrased for a human who can retype `--agent`. A stored
+* default has no command line behind it, so both shapes just mean "no usable
+* default". */
+function resolveAgentOrNull(agents, selector) {
+	try {
+		return resolveAgent(agents, selector);
+	} catch {
+		return null;
+	}
 }
 
 //#endregion
@@ -324,6 +396,8 @@ function createPortalClient(opts) {
 				deviceToken: null
 			}),
 			resolveCwd: () => process.cwd(),
+			persistedMachineName: null,
+			onMachineName: () => {},
 			onState: (state) => opts.onState({
 				status: state.status,
 				machineName: state.machineName,
@@ -337,7 +411,7 @@ function createPortalClient(opts) {
 			start: () => Promise.resolve(),
 			enable: () => client.enable(),
 			disable: () => client.disable(),
-			grantAgent: (agentId) => client.grantAgent(agentId),
+			grantAgent: (agentId, conversationId) => client.grantAgent(agentId, conversationId),
 			decline: (_agentId, declined) => {
 				if (declined && client.grantedAgentIds().length === 0) client.disable();
 			},
@@ -1016,42 +1090,133 @@ function createAgentHost({ renderer, notifications }) {
 * 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)) {
+* Only the `/pull/<n>` form (not `/issues/`). 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.
+*
+* The `https://` (and `www.`) prefix is optional: agents and people routinely
+* write a bare `github.com/o/r/pull/7`, and that should link a PR the same way
+* the full URL does. To keep a bare host from matching inside a longer hostname
+* (`mygithub.com/...`, `notgithub.com/...`), a protocol-less match must be
+* preceded by a start-of-string or a non-host character (anything but a word
+* char or `.`) — a leading boundary the `(?:^|[^\w.])` group asserts and
+* consumes. The consumed boundary char is outside the captured groups, so it
+* never leaks into owner/repo. `matchAll` won't overlap, but the boundary is a
+* single delimiter (space, `(`, `[`, etc.) between PRs in practice, so distinct
+* back-to-back URLs still each match.
+*/
+const PR_URL_RE = /(?:^|[^\w.])(?:https?:\/\/)?(?:www\.)?github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/gi;
+/**
+* Matches a bare, human-style PR reference `#<n>` — the way people (and LLMs)
+* name a PR in prose ("opened #20858", "landed #42"). Requires a non-word
+* boundary before the `#` so a fragment tail like `/pull/7#discussion_r5` or a
+* hex color `#20858` embedded in a word doesn't count, and captures the digits
+* up to a word boundary. We only harvest these from **assistant prose**, never
+* from tool output, because `#N` is exactly the relevance signal we're after:
+* the agent chose to talk about this PR.
+*/
+const PR_HASH_RE = /(?:^|[^\w#/])#(\d+)\b/g;
+/**
+* Every full `/pull/<n>` github.com URL in `urlText`, keyed by number to the
+* candidate refs for that number. A number can map to more than one repo, so we
+* keep all candidates; a bare `#N` label can't say which repo, but the pill's
+* own URL does. Deduped by repo-qualified identity (`owner/repo#number`) so the
+* same PR linked twice — even with a different trailing path/fragment —
+* collapses to one ref.
+*
+* `deferTrailingNumber` guards the streaming truncation case: when true, a URL
+* whose number runs to the very end of `urlText` is skipped because the next
+* delta may extend those digits (`.../pull/19` now, `.../pull/19739` later).
+* Only the still-growing PROSE buffer sets this; settled tool output is always
+* complete, so its URLs are harvested with the guard off.
+*/
+function urlsByNumber(urlText, deferTrailingNumber, byNumber) {
+	for (const match of urlText.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;
+		if (deferTrailingNumber) {
+			if (match.index + match[0].length >= urlText.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, {
+		const ref = {
 			number,
-			key,
+			key: `${owner.toLowerCase()}/${repo.toLowerCase()}#${number}`,
 			url: `https://github.com/${owner}/${repo}/pull/${number}`
-		});
+		};
+		const existing = byNumber.get(number);
+		if (existing) {
+			if (!existing.some((r) => r.key === ref.key)) existing.push(ref);
+		} else byNumber.set(number, [ref]);
+	}
+}
+/** Every human-style `#N` named in `proseText` — the relevance signal. */
+function hashNumbers(proseText) {
+	const numbers = /* @__PURE__ */ new Set();
+	for (const match of proseText.matchAll(PR_HASH_RE)) {
+		const numberText = match[1];
+		if (!numberText) continue;
+		const number = Number.parseInt(numberText, 10);
+		if (Number.isFinite(number) && number > 0) numbers.add(number);
+	}
+	return numbers;
+}
+/**
+* The relevance contract, in one place.
+*
+* A GitHub PR URL is cheap to emit and shows up in bulk any time a tool dumps
+* PRs the conversation isn't actually about — `gh pr list`, `gh pr status`, a
+* `gh search` — printing dozens of `/pull/N` URLs the agent never discusses.
+* Pinning a sidebar pill for every one of those is noise.
+*
+* So a PR is surfaced only when BOTH hold:
+*   1. a fully-qualified `github.com/<o>/<r>/pull/<n>` URL exists — this may
+*      come from the assistant's prose OR from tool output (a `gh pr create`
+*      that printed the URL the agent then referenced by number), and
+*   2. the **assistant's prose** names the number as a human-style `#<n>`.
+*
+* The `#N` in prose is the intent signal — "the agent is talking about this
+* PR", as opposed to "a tool happened to list it". The full URL (from wherever)
+* proves the PR is real and pins down its repo + canonical link. A URL with no
+* `#N` in prose (the whole of a `gh pr list` dump) is dropped; a `#N` with no
+* matching URL anywhere (a bare issue-style ref) is dropped.
+*
+* `proseText` is the assistant's prose alone (the only source of the `#N`
+* relevance signal); `urlOnlyText` is settled tool output that may carry full
+* PR URLs but no `#N` intent. URLs are harvested from both; `#N` from prose
+* only.
+*/
+function collectRelevant(proseText, urlOnlyText, options, byKey) {
+	const byNumber = /* @__PURE__ */ new Map();
+	urlsByNumber(proseText, options.requireCompleteNumber, byNumber);
+	if (urlOnlyText) urlsByNumber(urlOnlyText, false, byNumber);
+	if (byNumber.size === 0) return;
+	const named = hashNumbers(proseText);
+	if (named.size === 0) return;
+	for (const [number, refs] of byNumber) {
+		if (!named.has(number)) continue;
+		for (const ref of refs) if (!byKey.has(ref.key)) byKey.set(ref.key, ref);
 	}
+}
+/**
+* Extracts every distinct GitHub PR that is both linked (a full `/pull/<n>`
+* URL) AND named (`#<n>`), de-duplicated by **repo-qualified identity**
+* (`owner/repo#number`) — NOT by number, since `#42` can exist in many repos.
+*
+* The two-argument form takes the URL pool and the prose separately, so a URL
+* from tool output can satisfy the link requirement while the `#N` stays a
+* prose-only signal. The one-argument form (prose only) is the common case: it
+* requires the URL to be in the same prose that names it.
+*
+* See {@link collectRelevant} for the contract.
+*/
+function extractPullRequests(proseText, options) {
+	const requireCompleteNumber = options?.requireCompleteNumber ?? true;
+	const urlOnly = options?.urlOnlyText ?? "";
+	const byKey = /* @__PURE__ */ new Map();
+	collectRelevant(proseText, urlOnly, { requireCompleteNumber }, byKey);
 	return [...byKey.values()];
 }
 /**
@@ -1090,28 +1255,34 @@ function stringifyToolOutput(value) {
 }
 /**
 * 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:
+* distinct PR the moment BOTH conditions hold — a full `/pull/<n>` URL has been
+* seen (in prose OR tool output) AND the assistant's prose names it `#<n>` —
+* exactly once, without ever rescanning the transcript.
 *
-* - **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.
+* Two sources feed it, with different roles:
+* - **Assistant text** (`text-delta`): the ONLY source of the `#N` relevance
+*   signal, and also a source of URLs. Accumulated per part id (a URL or `#N`
+*   can split across two deltas); only the current part's buffer is scanned.
+* - **Tool output** (`tool-output-available`): a URL-only source. A
+*   `gh pr create` prints the URL the agent then references by number, so the
+*   URL for a #N mention often lives here, not in the prose. Tool output can
+*   NEVER originate a pill on its own — a `gh pr list` dump (URLs, no `#N`)
+*   stays silent — but it satisfies the URL half for a PR the prose names.
 *
 * `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.
+* `owner/repo#number`). Construct one per run (or per conversation) and feed it
+* the same chunks the transcript reducer sees. See {@link collectRelevant}.
 */
 function createPullRequestScanner(onPullRequest) {
 	let text = "";
 	let lastPartId;
+	let toolUrlText = "";
 	const seen = /* @__PURE__ */ new Set();
-	const report = (buffer, final) => {
-		for (const pr of extractPullRequests(buffer, { requireCompleteNumber: !final })) {
+	const report = (final) => {
+		for (const pr of extractPullRequests(text, {
+			requireCompleteNumber: !final,
+			urlOnlyText: toolUrlText
+		})) {
 			if (seen.has(pr.key)) continue;
 			seen.add(pr.key);
 			onPullRequest(pr);
@@ -1121,7 +1292,8 @@ function createPullRequestScanner(onPullRequest) {
 		if (chunk["type"] === "tool-output-available") {
 			const outputText = stringifyToolOutput(chunk["output"]);
 			if (!outputText.includes("/pull/")) return;
-			report(outputText, true);
+			toolUrlText += `\n${outputText}`;
+			report(true);
 			return;
 		}
 		if (chunk["type"] !== "text-delta") return;
@@ -1129,13 +1301,12 @@ function createPullRequestScanner(onPullRequest) {
 		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);
+			report(true);
 			text = "";
 		}
 		text += delta;
 		lastPartId = partId ?? lastPartId;
-		if (!text.includes("/pull/")) return;
-		report(text, false);
+		report(false);
 	} };
 }
 
@@ -1479,6 +1650,7 @@ function screenLabelParts(screen, chatTitle) {
 		case "error": return { title: "" };
 		case "agent-picker": return { title: "pick an agent" };
 		case "agent-create": return { title: "create an agent" };
+		case "first-run": return { title: "welcome" };
 		case "workspace-picker": return { title: "switch workspace" };
 		case "conversation-picker": return {
 			title: "pick a conversation",
@@ -1649,13 +1821,15 @@ function WordmarkRows({ mono }) {
 	});
 }
 /**
-* 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.
+* Height- and width-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 only when the terminal is tall
+* enough AND wide enough that the art sits on six lines; otherwise a compact
+* one-liner. Wrapping the splash would blow the 7-row budget the list
+* subtracts, and the overflow collapses the top list rows onto each other.
 */
-function BrandHeader({ height }) {
-	if (height >= 24) return /* @__PURE__ */ jsxs("box", {
+function BrandHeader({ height, width }) {
+	if (showFullSplash(height, width)) return /* @__PURE__ */ jsxs("box", {
 		style: { flexDirection: "column" },
 		children: [/* @__PURE__ */ jsx(SkydiveMark, { variant: "full" }), /* @__PURE__ */ jsx("box", { style: { height: 1 } })]
 	});
@@ -1664,9 +1838,12 @@ function BrandHeader({ height }) {
 		children: "✦ Skydive"
 	});
 }
+function showFullSplash(height, width) {
+	return height >= 24 && splashFitsWidth(width);
+}
 /** Row budget the BrandHeader consumes; callers subtract this from visibleRows. */
-function brandHeaderRows(height) {
-	return height >= 24 ? 7 : 1;
+function brandHeaderRows(height, width) {
+	return showFullSplash(height, width) ? 7 : 1;
 }
 function SkydiveMark({ variant = "full" }) {
 	const mono = noColor();
@@ -1753,13 +1930,16 @@ function AgentPickerScreen() {
 		scope,
 		cache
 	]);
-	const { height } = useTerminalDimensions();
+	const { width, height } = useTerminalDimensions();
 	if (state.kind === "loading") return /* @__PURE__ */ jsxs("box", {
 		style: {
 			flexDirection: "column",
 			flexGrow: 1
 		},
-		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsx("text", {
+		children: [/* @__PURE__ */ jsx(BrandHeader, {
+			height,
+			width
+		}), /* @__PURE__ */ jsx("text", {
 			fg: theme.muted,
 			children: "loading agents…"
 		})]
@@ -1769,7 +1949,10 @@ function AgentPickerScreen() {
 			flexDirection: "column",
 			flexGrow: 1
 		},
-		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsxs("text", {
+		children: [/* @__PURE__ */ jsx(BrandHeader, {
+			height,
+			width
+		}), /* @__PURE__ */ jsxs("text", {
 			fg: theme.error,
 			children: ["error: ", state.message]
 		})]
@@ -1779,7 +1962,10 @@ function AgentPickerScreen() {
 			flexDirection: "column",
 			flexGrow: 1
 		},
-		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsx("text", {
+		children: [/* @__PURE__ */ jsx(BrandHeader, {
+			height,
+			width
+		}), /* @__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."
 		})]
@@ -1800,7 +1986,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 - brandHeaderRows(height));
+	const visibleRows = Math.max(3, height - 6 - brandHeaderRows(height, width));
 	const start = windowStart(clamped, filtered.length, visibleRows);
 	const windowed = hits.slice(start, start + visibleRows);
 	useKeyboard((key) => {
@@ -1822,7 +2008,8 @@ function FilterableAgentList({ agents, scope, onPick }) {
 				}
 			} : {
 				kind: "conversation-picker",
-				agent
+				agent,
+				initialQuery: ""
 			});
 		}
 	});
@@ -1832,7 +2019,10 @@ function FilterableAgentList({ agents, scope, onPick }) {
 			flexGrow: 1
 		},
 		children: [
-			/* @__PURE__ */ jsx(BrandHeader, { height }),
+			/* @__PURE__ */ jsx(BrandHeader, {
+				height,
+				width
+			}),
 			/* @__PURE__ */ jsxs("box", {
 				style: {
 					flexDirection: "row",
@@ -1954,7 +2144,54 @@ function AgentCreateScreen() {
 			cancelled = true;
 		};
 	}, [rest]);
+	const openChat = (agent) => {
+		goTo({
+			kind: "chat",
+			agent,
+			conversation: {
+				kind: "new",
+				agentId: agent.id,
+				nonce: crypto.randomUUID()
+			}
+		});
+	};
+	const acceptAlias = (agent, alias) => {
+		try {
+			const shell = detectShell();
+			if (!shell) {
+				openChat(agent);
+				return;
+			}
+			const result = installAgentAlias({
+				alias,
+				agentId: agent.id,
+				shell
+			});
+			setState({
+				kind: "aliased",
+				agent,
+				message: `Added \`${result.alias}\`. ${aliasActivationHint(result)}`
+			});
+		} catch {
+			openChat(agent);
+		}
+	};
 	useKeyboard((key) => {
+		if (state.kind === "offer-alias") {
+			if (key.name === "y") {
+				acceptAlias(state.agent, state.alias);
+				return;
+			}
+			if (key.name === "n" || key.name === "escape" || key.name === "return") {
+				openChat(state.agent);
+				return;
+			}
+			return;
+		}
+		if (state.kind === "aliased") {
+			openChat(state.agent);
+			return;
+		}
 		if (key.name === "escape" && state.kind !== "creating") goTo({ kind: "agent-picker" });
 	});
 	const createAgent = async () => {
@@ -1970,15 +2207,13 @@ function AgentCreateScreen() {
 		setState({ kind: "creating" });
 		try {
 			const agent = await rest.createAgent({ name: result.name });
-			goTo({
-				kind: "chat",
+			const shell = detectShell();
+			if (shell) setState({
+				kind: "offer-alias",
 				agent,
-				conversation: {
-					kind: "new",
-					agentId: agent.id,
-					nonce: crypto.randomUUID()
-				}
+				alias: dedupeAliasName(slugifyAliasName(agent.name), takenAliasNames(shell))
 			});
+			else openChat(agent);
 		} catch (err) {
 			if (err instanceof HttpError && err.status === 401) {
 				fail("Session expired. Run `skydive auth login --web`, then retry.");
@@ -2018,6 +2253,11 @@ function AgentCreateScreen() {
 			});
 		}
 	};
+	if (state.kind === "offer-alias") return /* @__PURE__ */ jsx(AliasOffer, {
+		agentName: state.agent.name,
+		alias: state.alias
+	});
+	if (state.kind === "aliased") return /* @__PURE__ */ jsx(AliasResult, { message: state.message });
 	return /* @__PURE__ */ jsxs("box", {
 		style: {
 			flexDirection: "column",
@@ -2070,87 +2310,341 @@ function AgentCreateScreen() {
 		]
 	});
 }
+/**
+* The post-create prompt offering to alias the agent's name to a shell
+* command. Presentational so the frame gallery can render it directly.
+*/
+function AliasOffer({ agentName, alias }) {
+	return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1,
+			gap: 1
+		},
+		children: [
+			/* @__PURE__ */ jsxs("text", {
+				fg: theme.fg,
+				children: [
+					"Created ",
+					agentName,
+					"."
+				]
+			}),
+			/* @__PURE__ */ jsxs("text", {
+				fg: theme.muted,
+				children: [
+					"Add a shell alias so you can run `",
+					alias,
+					"` to open this agent?"
+				]
+			}),
+			/* @__PURE__ */ jsx("text", {
+				fg: theme.dim,
+				children: "y add alias · n skip"
+			})
+		]
+	});
+}
+/** The confirmation shown after an alias is written. */
+function AliasResult({ message }) {
+	return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1,
+			gap: 1
+		},
+		children: [/* @__PURE__ */ jsx("text", {
+			fg: theme.fg,
+			children: message
+		}), /* @__PURE__ */ jsx("text", {
+			fg: theme.dim,
+			children: "press any key to continue"
+		})]
+	});
+}
 
 //#endregion
-//#region src/chat/tui/screens/workspace-picker.tsx
-function WorkspacePicker({ appUrl, sessionToken, onSelect, onCancel }) {
-	const { height } = useTerminalDimensions();
-	const [state, setState] = useState({ kind: "loading" });
-	const [highlight, setHighlight] = useState(0);
-	const [switching, setSwitching] = useState(false);
+//#region src/chat/tui/screens/first-run.tsx
+/** Rows the mark lockup needs before it's worth painting (matches the
+* new-chat splash): the 6-row mark, a spacer, and a couple of content rows.
+* Below this the mark is dropped and only the message renders. */
+const MARK_MIN_ROWS$1 = 12;
+/** Columns the full mark + wordmark lockup spans; below this the pinwheel
+* mark renders alone instead of wrapping the wordmark. */
+const FULL_MARK_MIN_COLS$1 = 70;
+function FirstRunScreen() {
+	const rest = useStore((s) => s.rest);
+	const goTo = useStore((s) => s.goTo);
+	const fail = useStore((s) => s.fail);
+	const authKind = useStore((s) => s.authKind);
+	const forced = useStore((s) => s.forcedOnboarding);
+	const [state, setState] = useState({ kind: "creating" });
+	const canShareMachine = authKind === "session";
 	useEffect(() => {
+		if (!rest) return;
 		let cancelled = false;
 		(async () => {
-			const [workspaces, activeId] = await Promise.all([listWorkspaces({
-				appUrl,
-				sessionToken
-			}), getActiveWorkspaceId({
-				appUrl,
-				sessionToken
-			})]);
-			if (cancelled) return;
-			if (workspaces.isErr()) {
+			try {
+				const agent = await rest.createAgent({});
+				if (cancelled) return;
 				setState({
-					kind: "error",
-					message: workspaces.error.message
+					kind: "offer",
+					agent
 				});
-				return;
-			}
-			if (activeId.isErr()) {
+			} catch (err) {
+				if (cancelled) return;
+				if (err instanceof HttpError && err.status === 401) {
+					fail("Session expired. Run `skydive auth login --web`, then retry.");
+					return;
+				}
 				setState({
 					kind: "error",
-					message: activeId.error.message
+					message: createErrorMessage(err)
 				});
-				return;
 			}
-			setHighlight(Math.max(0, workspaces.value.findIndex((workspace) => workspace.id === activeId.value)));
-			setState({
-				kind: "ready",
-				workspaces: workspaces.value,
-				activeId: activeId.value
-			});
 		})();
 		return () => {
 			cancelled = true;
 		};
-	}, [appUrl, sessionToken]);
-	const rows = state.kind === "ready" ? state.workspaces : [];
-	const clamped = Math.min(highlight, Math.max(0, rows.length - 1));
-	useKeyboard((key) => {
-		if (switching) return;
-		if (key.name === "escape" || key.name === "c" && key.ctrl) onCancel();
-		else if (key.name === "up") setHighlight(Math.max(0, clamped - 1));
-		else if (key.name === "down") setHighlight(Math.min(rows.length - 1, clamped + 1));
-		else if (key.name === "return") {
-			const workspace = rows[clamped];
-			if (!workspace) return;
-			setSwitching(true);
-			(async () => {
-				const result = await setActiveWorkspace({
-					appUrl,
-					sessionToken,
-					organizationId: workspace.id
-				});
-				if (result.isErr()) {
-					setState({
-						kind: "error",
-						message: result.error.message
-					});
-					setSwitching(false);
-					return;
+	}, [rest, fail]);
+	const openNewChat = (agent) => {
+		goTo({
+			kind: "chat",
+			agent,
+			conversation: {
+				kind: "new",
+				agentId: agent.id,
+				nonce: crypto.randomUUID()
+			}
+		});
+	};
+	const openOnboardingChat = (agent, conversationId, title) => {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		goTo({
+			kind: "chat",
+			agent,
+			conversation: {
+				id: conversationId,
+				title,
+				createdAt: now,
+				updatedAt: now,
+				preview: null,
+				channel: "web",
+				channelLabel: null,
+				agent: {
+					id: agent.id,
+					name: agent.name,
+					slug: agent.slug ?? null,
+					title: agent.title ?? null
 				}
-				onSelect(workspace);
-			})();
-		}
-	});
-	if (state.kind === "loading") return /* @__PURE__ */ jsx("text", {
-		fg: theme.muted,
-		children: "loading workspaces…"
-	});
-	if (state.kind === "error") return /* @__PURE__ */ jsxs("box", {
-		style: { flexDirection: "column" },
-		children: [/* @__PURE__ */ jsxs("text", {
-			fg: theme.error,
+			}
+		});
+	};
+	const acceptImport = async (agent) => {
+		if (!rest) return;
+		setState({ kind: "starting" });
+		const { portalClient } = useStore.getState();
+		try {
+			const os = machineOsFromPlatform(process.platform);
+			const { conversationId } = await rest.createOnboardingConversation({
+				agentId: agent.id,
+				projectDir: process.cwd(),
+				os
+			});
+			if (portalClient) {
+				portalClient.enable();
+				portalClient.grantAgent(agent.id, conversationId).catch(() => {
+					useStore.getState().showToast({
+						message: `Couldn't share this machine automatically. ${agent.name} will ask in chat.`,
+						variant: "warning"
+					});
+				});
+			}
+			openOnboardingChat(agent, conversationId, `Onboarding ${agent.name}`);
+		} catch (err) {
+			if (err instanceof HttpError && err.status === 401) {
+				fail("Session expired. Run `skydive auth login --web`, then retry.");
+				return;
+			}
+			useStore.getState().showToast({
+				message: "Couldn't start onboarding automatically. Opening a chat instead.",
+				variant: "warning"
+			});
+			openNewChat(agent);
+		}
+	};
+	const declineImport = (agent) => {
+		setState({ kind: "starting" });
+		openNewChat(agent);
+	};
+	useKeyboard((key) => {
+		if (state.kind !== "offer") return;
+		if (!canShareMachine) {
+			declineImport(state.agent);
+			return;
+		}
+		if (key.name === "return" || key.name === "y") acceptImport(state.agent);
+		else if (key.name === "n" || key.name === "escape") declineImport(state.agent);
+	});
+	return /* @__PURE__ */ jsx(Centered, { children: renderBody({
+		state,
+		forced,
+		canShareMachine
+	}) });
+}
+/** The Skydive mark centered above the screen's content, matching the
+* new-chat splash lockup and degrading by available space. */
+function Centered({ children }) {
+	const { width, height } = useTerminalDimensions();
+	return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexGrow: 1,
+			flexDirection: "column",
+			justifyContent: "center",
+			alignItems: "center"
+		},
+		children: [height >= MARK_MIN_ROWS$1 ? /* @__PURE__ */ jsx("box", {
+			style: {
+				flexDirection: "column",
+				alignItems: "center",
+				marginBottom: 1
+			},
+			children: /* @__PURE__ */ jsx(SkydiveMark, { variant: width >= FULL_MARK_MIN_COLS$1 ? "full" : "mark" })
+		}) : null, /* @__PURE__ */ jsx("box", {
+			style: {
+				flexDirection: "column",
+				alignItems: "center",
+				gap: 1
+			},
+			children
+		})]
+	});
+}
+function renderBody({ state, forced, canShareMachine }) {
+	if (state.kind === "error") return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("text", {
+		fg: theme.error,
+		children: state.message
+	}), /* @__PURE__ */ jsx("text", {
+		fg: theme.muted,
+		children: "press ctrl+c to quit, then run `skydive` again to retry."
+	})] });
+	if (state.kind === "creating") return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("text", {
+		fg: theme.fg,
+		children: "Welcome to Skydive."
+	}), /* @__PURE__ */ jsx("text", {
+		fg: theme.muted,
+		children: forced ? "creating an agent…" : "setting up your first agent…"
+	})] });
+	if (state.kind === "starting") return /* @__PURE__ */ jsx("text", {
+		fg: theme.muted,
+		children: "opening your agent…"
+	});
+	const { agent } = state;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("text", {
+		fg: theme.fg,
+		children: forced ? `${agent.name} is ready.` : `Your first agent, ${agent.name}, is ready.`
+	}), canShareMachine ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("text", {
+		fg: theme.muted,
+		children: [
+			"Want ",
+			agent.name,
+			" to learn how you already work? It can look at the coding agents set up on this machine to get up to speed fast. It will connect to your computer to read your setup, show you a plan first, and never copy credentials."
+		]
+	}), /* @__PURE__ */ jsx("text", {
+		fg: theme.dim,
+		children: "↵/y yes, learn from my setup · n skip"
+	})] }) : /* @__PURE__ */ jsx("text", {
+		fg: theme.dim,
+		children: "press any key to open the chat"
+	})] });
+}
+function createErrorMessage(err) {
+	if (err instanceof HttpError && err.status === 403) return "You don't have permission to create an agent in this workspace.";
+	if (err instanceof HttpError && err.status === 429) return "Too many requests. Wait a moment, then run `skydive` again.";
+	if (err instanceof HttpError) return "Skydive could not create your agent. Try again in a moment.";
+	return "Could not reach Skydive. Check your connection and try again.";
+}
+
+//#endregion
+//#region src/chat/tui/screens/workspace-picker.tsx
+function WorkspacePicker({ appUrl, sessionToken, onSelect, onCancel }) {
+	const { height } = useTerminalDimensions();
+	const [state, setState] = useState({ kind: "loading" });
+	const [highlight, setHighlight] = useState(0);
+	const [switching, setSwitching] = useState(false);
+	useEffect(() => {
+		let cancelled = false;
+		(async () => {
+			const [workspaces, activeId] = await Promise.all([listWorkspaces({
+				appUrl,
+				sessionToken
+			}), getActiveWorkspaceId({
+				appUrl,
+				sessionToken
+			})]);
+			if (cancelled) return;
+			if (workspaces.isErr()) {
+				setState({
+					kind: "error",
+					message: workspaces.error.message
+				});
+				return;
+			}
+			if (activeId.isErr()) {
+				setState({
+					kind: "error",
+					message: activeId.error.message
+				});
+				return;
+			}
+			setHighlight(Math.max(0, workspaces.value.findIndex((workspace) => workspace.id === activeId.value)));
+			setState({
+				kind: "ready",
+				workspaces: workspaces.value,
+				activeId: activeId.value
+			});
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [appUrl, sessionToken]);
+	const rows = state.kind === "ready" ? state.workspaces : [];
+	const clamped = Math.min(highlight, Math.max(0, rows.length - 1));
+	useKeyboard((key) => {
+		if (switching) return;
+		if (key.name === "escape" || key.name === "c" && key.ctrl) onCancel();
+		else if (key.name === "up") setHighlight(Math.max(0, clamped - 1));
+		else if (key.name === "down") setHighlight(Math.min(rows.length - 1, clamped + 1));
+		else if (key.name === "return") {
+			const workspace = rows[clamped];
+			if (!workspace) return;
+			setSwitching(true);
+			(async () => {
+				const result = await setActiveWorkspace({
+					appUrl,
+					sessionToken,
+					organizationId: workspace.id
+				});
+				if (result.isErr()) {
+					setState({
+						kind: "error",
+						message: result.error.message
+					});
+					setSwitching(false);
+					return;
+				}
+				onSelect(workspace);
+			})();
+		}
+	});
+	if (state.kind === "loading") return /* @__PURE__ */ jsx("text", {
+		fg: theme.muted,
+		children: "loading workspaces…"
+	});
+	if (state.kind === "error") return /* @__PURE__ */ jsxs("box", {
+		style: { flexDirection: "column" },
+		children: [/* @__PURE__ */ jsxs("text", {
+			fg: theme.error,
 			children: ["error: ", state.message]
 		}), /* @__PURE__ */ jsx("text", {
 			fg: theme.dim,
@@ -2419,16 +2913,81 @@ function useDebouncedValue(value, delayMs) {
 }
 
 //#endregion
-//#region src/chat/tui/screens/conversation-picker.tsx
-const SEARCH_DEBOUNCE_MS = 250;
-const SEARCH_QUERY_MAX_LENGTH = 200;
+//#region src/chat/tui/screens/conversation-channel.ts
+function isNewConversation(c) {
+	return "kind" in c && c.kind === "new";
+}
+/**
+* The channels a human can start a conversation on. Enumerated, not derived,
+* to keep `@createinc/anyone-db` out of the CLI build (see rest.ts). A newly
+* added human channel needs adding here too. The picker filters its default
+* view to these; `isAgentRunConversation` is their complement.
+*/
 const humanChannels = [
 	"web",
 	"slack",
 	"email",
 	"imessage"
 ];
-function ConversationPickerScreen({ agent }) {
+/**
+* Whether a conversation is an agent run — a thread the agent opened for
+* itself (cron firing, inbound webhook wake) rather than one a person
+* started. These have no human participant row, so per-user archive can
+* never apply to them (there is nothing to mark); delete is their only
+* cleanup affordance, and the UI should not offer archive on them.
+*
+* Best-effort: an a2a/subagent thread carries a `web` channel binding, so it
+* reads as `'web'` here and is NOT detected. Archive on one of those still
+* fails server-side with the existing error notice — this predicate only
+* removes the affordance where the client can know it's dead.
+*/
+function isAgentRunConversation(c) {
+	if (isNewConversation(c)) return false;
+	if (c.channel === null) return false;
+	const { channel } = c;
+	return !humanChannels.some((human) => human === channel);
+}
+/**
+* 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/conversation-picker.tsx
+const SEARCH_DEBOUNCE_MS = 250;
+const SEARCH_QUERY_MAX_LENGTH = 200;
+function ConversationPickerScreen({ agent, initialQuery }) {
 	const rest = useStore((s) => s.rest);
 	const goTo = useStore((s) => s.goTo);
 	const [showAutomated, setShowAutomated] = useState(false);
@@ -2492,13 +3051,16 @@ function ConversationPickerScreen({ agent }) {
 		cacheKey,
 		cache
 	]);
-	const { height } = useTerminalDimensions();
+	const { width, height } = useTerminalDimensions();
 	if (state.kind === "loading") return /* @__PURE__ */ jsxs("box", {
 		style: {
 			flexDirection: "column",
 			flexGrow: 1
 		},
-		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsx("text", {
+		children: [/* @__PURE__ */ jsx(BrandHeader, {
+			height,
+			width
+		}), /* @__PURE__ */ jsx("text", {
 			fg: theme.muted,
 			children: "loading conversations…"
 		})]
@@ -2508,13 +3070,17 @@ function ConversationPickerScreen({ agent }) {
 			flexDirection: "column",
 			flexGrow: 1
 		},
-		children: [/* @__PURE__ */ jsx(BrandHeader, { height }), /* @__PURE__ */ jsxs("text", {
+		children: [/* @__PURE__ */ jsx(BrandHeader, {
+			height,
+			width
+		}), /* @__PURE__ */ jsxs("text", {
 			fg: theme.error,
 			children: ["error: ", state.message]
 		})]
 	});
 	return /* @__PURE__ */ jsx(ConversationList, {
 		agent,
+		initialQuery,
 		conversations: state.conversations,
 		complete: state.complete,
 		showAutomated,
@@ -2524,10 +3090,10 @@ function ConversationPickerScreen({ agent }) {
 		onPick: goTo
 	});
 }
-function ConversationList({ agent, conversations, complete, showAutomated, onToggleAutomated, showArchived, onToggleArchived, onPick }) {
+function ConversationList({ agent, initialQuery, conversations, complete, showAutomated, onToggleAutomated, showArchived, onToggleArchived, onPick }) {
 	const { width, height } = useTerminalDimensions();
 	const rest = useStore((s) => s.rest);
-	const [query, setQuery] = useState("");
+	const [query, setQuery] = useState(initialQuery);
 	const [highlight, setHighlight] = useState(0);
 	const debouncedQuery = useDebouncedValue(query.trim(), SEARCH_DEBOUNCE_MS);
 	const isSearching = debouncedQuery.length > 0;
@@ -2615,6 +3181,7 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 	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 highlightAgentRun = highlightRow?.kind === "conv" && isAgentRunConversation(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…)"}`;
@@ -2628,7 +3195,7 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 		fg: theme.dim,
 		text: fitHintLine([
 			countSegment,
-			`ctrl+a ${highlightArchived ? "unarchive" : "archive"}`,
+			...highlightAgentRun ? [] : [`ctrl+a ${highlightArchived ? "unarchive" : "archive"}`],
 			"ctrl+d delete",
 			`tab ${showAutomated ? "hide" : "show"} agent runs`,
 			`shift+tab ${showArchived ? "hide" : "show"} archived`,
@@ -2637,7 +3204,7 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 			"↵ open"
 		], innerWidth)
 	};
-	const visibleRows = Math.max(3, height - 6 - brandHeaderRows(height));
+	const visibleRows = Math.max(3, height - 6 - brandHeaderRows(height, width));
 	const start = windowStart(clamped, rows.length, visibleRows);
 	const windowed = rows.slice(start, start + visibleRows);
 	const open = (row) => {
@@ -2722,6 +3289,10 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 		} else if (key.name === "a" && key.ctrl) {
 			const row = rows[clamped];
 			if (row?.kind === "conv") {
+				if (isAgentRunConversation(row.hit.item)) {
+					setError("agent runs can't be archived — ctrl+d deletes");
+					return;
+				}
 				setError(null);
 				toggleArchived(row.hit.item);
 			}
@@ -2738,7 +3309,10 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 			flexGrow: 1
 		},
 		children: [
-			/* @__PURE__ */ jsx(BrandHeader, { height }),
+			/* @__PURE__ */ jsx(BrandHeader, {
+				height,
+				width
+			}),
 			/* @__PURE__ */ jsxs("box", {
 				style: {
 					flexDirection: "row",
@@ -2755,6 +3329,7 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 					focused: confirmId === null,
 					width: Math.max(10, width - 12),
 					maxLength: SEARCH_QUERY_MAX_LENGTH,
+					value: query,
 					onInput: (value) => {
 						setQuery(value.slice(0, SEARCH_QUERY_MAX_LENGTH));
 						setHighlight(0);
@@ -2779,15 +3354,20 @@ function ConversationList({ agent, conversations, complete, showAutomated, onTog
 						children: [marker, truncate("+ new conversation", rowWidth)]
 					}, "new");
 					const archived = isArchived(row.hit.item);
+					const unread = row.hit.item.unread === true;
 					const { title, detail, tag } = fitRowText(singleLine(row.hit.item.title ?? "(untitled)"), `${archived ? "archived · " : ""}${previewLine(row.hit.item)}`, rowWidth, coAgentsTag(row.hit.item, agent.id));
+					const titleText = /* @__PURE__ */ jsx(FuzzyText, {
+						text: title,
+						indexes: row.hit.item.title ? row.hit.highlights[0] : null
+					});
 					return /* @__PURE__ */ jsxs("text", {
 						fg: archived && !selected ? theme.dim : fg,
 						children: [
-							marker,
-							/* @__PURE__ */ jsx(FuzzyText, {
-								text: title,
-								indexes: row.hit.item.title ? row.hit.highlights[0] : null
-							}),
+							!selected && unread ? /* @__PURE__ */ jsx("span", {
+								fg: theme.accent,
+								children: "● "
+							}) : marker,
+							unread ? /* @__PURE__ */ jsx("b", { children: titleText }) : titleText,
 							tag ? /* @__PURE__ */ jsxs("span", {
 								fg: theme.muted,
 								children: [" ", tag]
@@ -4169,328 +4749,547 @@ function parseMatches(output) {
 	return null;
 }
 
+//#endregion
+//#region src/chat/tui/chunks/shell-local.tsx
+/**
+* Renders a `! <cmd>` local-shell escape: the command the user ran on their own
+* machine, followed by its combined stdout/stderr. Visually distinct from agent
+* tool calls (which run in the sandbox) — a `!` sigil colored by outcome (dim
+* while running, success/error once done), so a glance tells you this executed
+* locally, not on the agent.
+*/
+function ShellLocalItem({ item }) {
+	const running = item.exit === null;
+	const failed = item.exit !== null && item.exit !== 0;
+	return /* @__PURE__ */ jsxs("box", {
+		style: { flexDirection: "column" },
+		children: [/* @__PURE__ */ jsxs("text", { children: [
+			/* @__PURE__ */ jsx("span", {
+				fg: running ? theme.dim : failed ? theme.error : theme.success,
+				children: "! "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: theme.tool,
+				children: item.command
+			}),
+			running ? /* @__PURE__ */ jsx("span", {
+				fg: theme.dim,
+				children: " · running…"
+			}) : null,
+			failed ? /* @__PURE__ */ jsxs("span", {
+				fg: theme.error,
+				children: [" · exit ", item.exit]
+			}) : null
+		] }), item.output ? /* @__PURE__ */ jsx(Indented, { children: /* @__PURE__ */ jsx("text", {
+			fg: theme.muted,
+			children: item.output.replace(/\n+$/, "")
+		}) }) : null]
+	});
+}
+
 //#endregion
 //#region src/chat/tui/chat/conversation-context.tsx
 const ConversationContext = createContext({
 	rest: null,
-	conversationId: null
+	conversationId: null,
+	collectSandboxStats: null,
+	latestComputerId: null,
+	scrolledUp: false
 });
 function useConversationContext() {
 	return useContext(ConversationContext);
 }
 
 //#endregion
-//#region src/chat/tui/spinner-frames.ts
-/** Braille dot-cycle frames — the classic smooth terminal spinner. */
-const SPINNER_FRAMES = [
-	"⠋",
-	"⠙",
-	"⠹",
-	"⠸",
-	"⠼",
-	"⠴",
-	"⠦",
-	"⠧",
-	"⠇",
-	"⠏"
-];
-/** Milliseconds between frames. ~12.5fps reads as smooth without thrashing. */
-const SPINNER_INTERVAL_MS = 80;
-/** Frame for a given tick count. Wraps at the end of the cycle; negative-safe. */
-function spinnerFrame(tick) {
-	const n = SPINNER_FRAMES.length;
-	return SPINNER_FRAMES[(Math.trunc(tick) % n + n) % n] ?? SPINNER_FRAMES[0];
-}
-
-//#endregion
-//#region src/chat/tui/spinner.tsx
+//#region src/chat/tui/chat/sandbox-stats.ts
 /**
-* An animated spinner glyph. Advances one frame every SPINNER_INTERVAL_MS via
-* a self-owned interval that's cleared on unmount, so the animation runs only
-* while the component is mounted. Returns a <span>, so render it inside a
-* <text> (matching how the rest of the TUI composes inline glyphs).
+* `/computer`: a live snapshot of the agent's sandbox as a set of bar graphs.
+*
+* The CLI runs on the USER's machine, so it can't read the sandbox's `/proc`
+* directly — it runs one small, portable shell command over the sandbox-exec
+* stream (`SandboxStream`, mode `exec`) and parses the output here. Everything
+* in this module is pure so the parse + layout are unit-testable without a
+* sandbox or a renderer.
+*
+* The command reads `/proc` and `df` only (no tools that might be missing from
+* a minimal image), emitting a tagged, tab-separated block. The leading
+* `SKYDIVE_STATS_V1` sentinel lets the parser find the block even when a shell
+* rc file prints a banner first, and versions the wire shape.
 */
-function Spinner({ color }) {
-	const [tick, setTick] = useState(0);
-	useEffect(() => {
-		const id = setInterval(() => setTick((t) => t + 1), SPINNER_INTERVAL_MS);
-		return () => clearInterval(id);
-	}, []);
-	return /* @__PURE__ */ jsx("span", {
-		fg: color,
-		children: spinnerFrame(tick)
-	});
-}
-
-//#endregion
-//#region src/chat/tui/chat/subagents.ts
-/** A run the platform hasn't settled yet — still queued or mid-run. */
-function isLiveStatus(status) {
-	return status === "queued" || status === "running";
-}
-function toTaskStatus(raw) {
-	switch (raw) {
-		case "queued":
-		case "running":
-		case "completed":
-		case "failed":
-		case "canceled": return raw;
-		default: return "queued";
-	}
-}
-const FALLBACK_TITLE = "Subagent task";
+const SANDBOX_STATS_SENTINEL = "SKYDIVE_STATS_V1";
 /**
-* Each delegated task's display title from the `subagent` call's input, in
-* call order — the short name the tool requires per task. A malformed entry
-* yields a fallback label rather than being dropped, so the row count always
-* matches the fan-out width. Mirrors the web client's `subagentTaskTitles`.
+* How often the live `/computer` card refreshes its snapshot, in ms.
+* Deliberately slow: the card is a background health readout, not a `top`, so
+* it refreshes quietly every 30s rather than flickering every second.
 */
-function subagentTaskTitles(input) {
-	if (!isRecord(input)) return [];
-	const tasks = input["tasks"];
-	if (!Array.isArray(tasks)) return [];
-	return tasks.map((task) => {
-		if (!isRecord(task)) return FALLBACK_TITLE;
-		const title = task["title"];
-		return typeof title === "string" && title.trim() ? title.trim() : FALLBACK_TITLE;
-	});
-}
-const QUEUED_TASK_ID_LINE = /^\s*-\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}):\s/i;
+const COMPUTER_POLL_INTERVAL_MS = 3e4;
 /**
-* The ids of the runs a `subagent` call queued, read back out of its own
-* output. The call returns the moment the runs exist, so the ids are there
-* long before any child finishes — they are what ties this card to the task
-* rows the status poll returns, and their order is the tasks' call order.
+* Whether a `/computer` card should refresh right now. Pure so the gating is
+* unit-testable. A card refreshes only when it is the most recent `/computer`
+* in the transcript (`isLatest`), the session can reach the sandbox
+* (`canCollect`), and the transcript is at the bottom (`!scrolledUp`) — while
+* you're scrolled up reading something else it quietly stops (no wasted polls),
+* and resumes when you scroll back down. Older cards freeze regardless, so a
+* scrolled-up history of runs isn't a fleet of background pollers. The pause is
+* silent: nothing about it is rendered.
 */
-function queuedSubagentTaskIds(output) {
-	const text = flattenOutputText(output);
-	if (!text) return [];
-	return text.split("\n").map((line) => line.match(QUEUED_TASK_ID_LINE)?.[1] ?? null).filter((id) => id !== null);
+function shouldPollComputer(opts) {
+	return opts.isLatest && opts.canCollect && !opts.scrolledUp;
 }
 /**
-* Tool output reaches the TUI as `unknown`: the raw string live, possibly
-* wrapped in content parts or arrays when loaded from history. Walk it for
-* string leaves, newline-joined — the PR scanner's `stringifyToolOutput`
-* shape, bounded small because the id list sits at the top of the output.
-*/
-function flattenOutputText(value) {
-	const MAX_LEN = 2e4;
-	const parts = [];
-	let total = 0;
-	const visit = (v, depth) => {
-		if (total >= MAX_LEN || depth > 4) return;
-		if (typeof v === "string") {
-			parts.push(v);
-			total += v.length;
-			return;
+* The command run in the sandbox to collect the snapshot. `sh`-portable, reads
+* only `/proc` and `df`. Each metric is one `key<TAB>value` line so the parser
+* never has to positionally align anything.
+*
+* The `port` lines enumerate LISTEN sockets the sandbox user's own processes
+* hold: one awk pass maps socket inodes from /proc/net/tcp{,6} to pids via
+* /proc/<pid>/fd, then a shell loop attaches each pid's cmdline. Platform
+* daemons run as root, so their /proc/<pid>/fd is unreadable here and they
+* never emit a line — the "user's servers only" filter falls out of
+* permissions rather than a curated list. Hex address:port is left for the
+* parser to decode (strtonum is gawk-only).
+*/
+const SANDBOX_STATS_COMMAND = [
+	`printf '${SANDBOX_STATS_SENTINEL}\\n'`,
+	`printf 'nproc\\t%s\\n' "$(nproc 2>/dev/null || echo 1)"`,
+	`printf 'loadavg\\t%s\\n' "$(cut -d' ' -f1-3 /proc/loadavg)"`,
+	`printf 'uptime\\t%s\\n' "$(cut -d' ' -f1 /proc/uptime)"`,
+	`awk '/^MemTotal:/{t=$2}/^MemAvailable:/{a=$2}END{printf "mem_total_kb\\t%d\\nmem_avail_kb\\t%d\\n",t,a}' /proc/meminfo`,
+	`awk '/^SwapTotal:/{t=$2}/^SwapFree:/{f=$2}END{printf "swap_total_kb\\t%d\\nswap_free_kb\\t%d\\n",t,f}' /proc/meminfo`,
+	`df -Pk / | awk 'NR==2{printf "disk_total_kb\\t%d\\ndisk_used_kb\\t%d\\n",$2,$3}'`,
+	`printf 'procs\\t%s\\n' "$(ls -1 /proc 2>/dev/null | grep -c '^[0-9]\\+$')"`,
+	`ls -l /proc/[0-9]*/fd 2>/dev/null | awk 'BEGIN { while ((getline l < "/proc/net/tcp") > 0) { split(l,f," "); if (f[4]=="0A") want[f[10]]=f[2] } close("/proc/net/tcp"); while ((getline l < "/proc/net/tcp6") > 0) { split(l,f," "); if (f[4]=="0A") want[f[10]]=f[2] } close("/proc/net/tcp6") } $0 ~ "^/proc/[0-9]+/fd:$" { pid=substr($0,7,length($0)-10) } match($0, /socket:\\[[0-9]+\\]/) { ino=substr($0,RSTART+8,RLENGTH-9); if (ino in want && !(ino in done)) { done[ino]=1; print want[ino] "\\t" pid } }' | while read addr pid; do cl=$(head -c 200 "/proc/$pid/cmdline" 2>/dev/null | tr "\\0" " "); printf 'port\\t%s\\t%s\\t%s\\n' "$addr" "$pid" "$cl"; done`
+].join(" ; ");
+const KB = 1024;
+const HIDDEN_PORTS = new Set([
+	38994,
+	49983,
+	38996
+]);
+const V6_LOOPBACK_HEX = "00000000000000000000000001000000";
+/**
+* Whether a /proc/net/tcp{,6} local-address hex field is a loopback bind.
+* v4 words are little-endian, so 127.0.0.1 is `0100007F` — the first octet
+* (127) is the LAST byte pair. Covers v4-mapped v6 (`::ffff:127.x.y.z`) via
+* the same tail check.
+*/
+function isLoopbackHex(addrHex) {
+	const hex = addrHex.toUpperCase();
+	if (hex.length === 8) return hex.slice(6) === "7F";
+	if (hex.length === 32) {
+		if (hex === V6_LOOPBACK_HEX) return true;
+		return hex.startsWith("0000000000000000FFFF0000") && hex.slice(30) === "7F";
+	}
+	return false;
+}
+const RUNTIME_NAMES = new Set([
+	"node",
+	"bun",
+	"deno",
+	"python",
+	"python3",
+	"sh",
+	"bash"
+]);
+const FLAGS_WITH_VALUE = new Set([
+	"--require",
+	"-r",
+	"--import",
+	"--loader",
+	"--experimental-loader"
+]);
+/**
+* A short display name from a raw cmdline: basename of argv[0], plus — when
+* argv[0] is a bare runtime — the basename of the first non-flag argument with
+* its extension dropped (`node …/vite/bin/vite.js` → `node vite`).
+*/
+function processDisplayName(cmdline) {
+	const argv = cmdline.trim().split(/\s+/).filter(Boolean);
+	const first = argv[0];
+	if (first === void 0) return null;
+	const base = (p) => p.split("/").pop() ?? p;
+	const name = base(first);
+	if (!RUNTIME_NAMES.has(name)) return name;
+	let script;
+	for (let i = 1; i < argv.length; i += 1) {
+		const arg = argv[i];
+		if (arg === void 0) break;
+		if (FLAGS_WITH_VALUE.has(arg)) {
+			i += 1;
+			continue;
 		}
-		if (Array.isArray(v)) {
-			for (const item of v) visit(item, depth + 1);
-			return;
+		if (arg.startsWith("-")) continue;
+		script = arg;
+		break;
+	}
+	if (!script) return name;
+	return `${name} ${base(script).replace(/\.(?:mjs|cjs|js|ts|tsx|py)$/, "")}`;
+}
+/**
+* Fold the collector's `port` lines (one per listen socket) into one entry
+* per port: v4/v6 binds of the same server dedupe, `loopbackOnly` only when
+* every bind is loopback, and the hidden platform ports drop out.
+*/
+function parsePortLines(lines) {
+	const byPort = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const port = Number.parseInt(line.portHex, 16);
+		if (!Number.isFinite(port) || port <= 0 || HIDDEN_PORTS.has(port)) continue;
+		const entry = byPort.get(port);
+		if (entry) entry.loopback.push(isLoopbackHex(line.addrHex));
+		else byPort.set(port, {
+			loopback: [isLoopbackHex(line.addrHex)],
+			cmdline: line.cmdline
+		});
+	}
+	return [...byPort.entries()].map(([port, entry]) => ({
+		port,
+		loopbackOnly: entry.loopback.every(Boolean),
+		process: entry.cmdline ? processDisplayName(entry.cmdline) : null
+	})).sort((a, b) => a.port - b.port);
+}
+/**
+* Parse the collector's output into `SandboxStats`, or return null when the
+* block is absent or malformed (so the caller can show the raw output as an
+* error instead of a broken graph). Tolerant of extra lines before the
+* sentinel (shell banners) and of a missing swap section (swap totals default
+* to 0, which the renderer treats as "no swap").
+*/
+function parseSandboxStats(raw) {
+	const start = raw.indexOf(SANDBOX_STATS_SENTINEL);
+	if (start === -1) return null;
+	const fields = /* @__PURE__ */ new Map();
+	const portLines = [];
+	for (const line of raw.slice(start).split("\n")) {
+		const tab = line.indexOf("	");
+		if (tab === -1) continue;
+		const key = line.slice(0, tab).trim();
+		if (key === "port") {
+			const parts = line.split("	");
+			const [addrHex = "", portHex = ""] = (parts[1] ?? "").split(":");
+			if (addrHex && portHex) portLines.push({
+				addrHex,
+				portHex,
+				cmdline: parts.slice(3).join(" ").trim()
+			});
+			continue;
 		}
-		if (isRecord(v)) for (const item of Object.values(v)) visit(item, depth + 1);
+		fields.set(key, line.slice(tab + 1).trim());
+	}
+	const num = (key) => {
+		const v = fields.get(key);
+		if (v === void 0) return null;
+		const n = Number(v);
+		return Number.isFinite(n) ? n : null;
+	};
+	const load = (fields.get("loadavg") ?? "").split(/\s+/).map(Number).filter((n) => Number.isFinite(n));
+	const nproc = num("nproc");
+	const uptime = num("uptime");
+	const memTotal = num("mem_total_kb");
+	const memAvail = num("mem_avail_kb");
+	const diskTotal = num("disk_total_kb");
+	const diskUsed = num("disk_used_kb");
+	const procs = num("procs");
+	const [load1, load5, load15] = load;
+	if (nproc === null || uptime === null || memTotal === null || memAvail === null || diskTotal === null || diskUsed === null || procs === null || load1 === void 0 || load5 === void 0 || load15 === void 0) return null;
+	return {
+		nproc: Math.max(1, Math.round(nproc)),
+		loadavg: [
+			load1,
+			load5,
+			load15
+		],
+		uptimeSeconds: uptime,
+		memTotalBytes: memTotal * KB,
+		memAvailBytes: memAvail * KB,
+		swapTotalBytes: (num("swap_total_kb") ?? 0) * KB,
+		swapFreeBytes: (num("swap_free_kb") ?? 0) * KB,
+		diskTotalBytes: diskTotal * KB,
+		diskUsedBytes: diskUsed * KB,
+		procs: Math.round(procs),
+		ports: parsePortLines(portLines)
 	};
-	visit(value, 0);
-	return parts.join("\n");
 }
-/**
-* The card's rows: one per queued run id (call order), each carrying the
-* freshest known state. A task the status fetch hasn't returned yet falls
-* back to the input's title and reads as queued; a fetched row's own title
-* wins over the input's (the server's copy is the one the child actually
-* ran under). Before the ids exist — the call is still streaming — rows come
-* from the input titles alone, so the card never renders empty mid-turn.
-*/
-function subagentRows({ titles, ids, fetched }) {
-	if (ids.length === 0) return titles.map((title, index) => ({
-		id: `queued:${index}`,
-		title,
-		status: "queued",
-		createdAt: null,
-		completedAt: null
+function severityFor(fraction) {
+	if (fraction >= .9) return "crit";
+	if (fraction >= .75) return "warn";
+	return "ok";
+}
+const GiB = 1024 * 1024 * 1024;
+function gb(bytes) {
+	return (bytes / GiB).toFixed(1);
+}
+/** `120050` seconds -> `1d 9h 20m`. Always at least `0m`. */
+function formatUptime(seconds) {
+	const total = Math.max(0, Math.floor(seconds));
+	const d = Math.floor(total / 86400);
+	const h = Math.floor(total % 86400 / 3600);
+	const m = Math.floor(total % 3600 / 60);
+	const parts = [];
+	if (d > 0) parts.push(`${d}d`);
+	if (h > 0 || d > 0) parts.push(`${h}h`);
+	parts.push(`${m}m`);
+	return parts.join(" ");
+}
+/**
+* Reduce a snapshot to the ordered list of gauges the `/computer` card draws:
+* CPU load (normalized to core count), memory, swap (only when the box has
+* any), and disk. Load can exceed 1.0 (oversubscribed CPU) — the bar clamps
+* but the caption shows the true number so that's still legible.
+*/
+function toGauges(stats) {
+	const gauges = [];
+	const load1 = stats.loadavg[0];
+	const loadFraction = load1 / stats.nproc;
+	gauges.push({
+		label: "cpu load",
+		fraction: loadFraction,
+		detail: `${load1.toFixed(2)} / ${stats.nproc} cores`,
+		severity: severityFor(loadFraction)
+	});
+	const memUsed = Math.max(0, stats.memTotalBytes - stats.memAvailBytes);
+	const memFraction = stats.memTotalBytes > 0 ? memUsed / stats.memTotalBytes : 0;
+	gauges.push({
+		label: "memory",
+		fraction: memFraction,
+		detail: `${gb(memUsed)} / ${gb(stats.memTotalBytes)} GB`,
+		severity: severityFor(memFraction)
+	});
+	if (stats.swapTotalBytes > 0) {
+		const swapUsed = Math.max(0, stats.swapTotalBytes - stats.swapFreeBytes);
+		const swapFraction = swapUsed / stats.swapTotalBytes;
+		gauges.push({
+			label: "swap",
+			fraction: swapFraction,
+			detail: `${gb(swapUsed)} / ${gb(stats.swapTotalBytes)} GB`,
+			severity: severityFor(swapFraction)
+		});
+	}
+	const diskFraction = stats.diskTotalBytes > 0 ? stats.diskUsedBytes / stats.diskTotalBytes : 0;
+	gauges.push({
+		label: "disk",
+		fraction: diskFraction,
+		detail: `${gb(stats.diskUsedBytes)} / ${gb(stats.diskTotalBytes)} GB`,
+		severity: severityFor(diskFraction)
+	});
+	return gauges;
+}
+/**
+* A single-line horizontal bar of `width` cells filled to `fraction`
+* (clamped 0..1), using block glyphs. The last partial cell uses one of the
+* eighth-block glyphs so a 37%% bar reads differently from a 40%% one even in a
+* narrow width. Pure string, so the renderer just colors it.
+*/
+function renderBar(fraction, width) {
+	const cells = Math.max(1, width);
+	const exact = Math.min(1, Math.max(0, fraction)) * cells;
+	const full = Math.floor(exact);
+	const remainder = exact - full;
+	const eighths = [
+		"",
+		"▏",
+		"▎",
+		"▍",
+		"▌",
+		"▋",
+		"▊",
+		"▉"
+	];
+	const partialIndex = Math.round(remainder * 8);
+	const partial = full < cells ? eighths[partialIndex] : "";
+	const filled = "█".repeat(Math.min(full, cells)) + partial;
+	return (filled + "░".repeat(Math.max(0, cells - filled.length))).slice(0, cells);
+}
+/** How many port rows the card draws before folding the rest into `+N more`. */
+const MAX_PORT_ROWS = 8;
+const WELL_KNOWN_PORTS = new Map([[3e3, "agent harness"], [3001, "agent webserver"]]);
+/**
+* Reduce the snapshot's ports to drawable rows. The well-known note wins over
+* `local only` — a loopback-bound 3001 being unreachable is a distinct problem
+* the gauges' error path already surfaces, and one annotation per row keeps
+* the table scannable.
+*/
+function toPortRows(ports) {
+	return ports.map((p) => ({
+		port: p.port,
+		process: p.process ?? "?",
+		note: WELL_KNOWN_PORTS.get(p.port) ?? (p.loopbackOnly ? "local only" : null)
 	}));
-	return ids.map((id, index) => {
-		const row = fetched?.get(id) ?? null;
-		return {
-			id,
-			title: row?.title ?? titles[index] ?? FALLBACK_TITLE,
-			status: row ? toTaskStatus(row.status) : "queued",
-			createdAt: row?.createdAt ?? null,
-			completedAt: row?.completedAt ?? null
-		};
-	});
 }
 
 //#endregion
-//#region src/chat/tui/chunks/tool-subagent.tsx
-/** How often a live batch re-reads its tasks' status. */
-const POLL_INTERVAL_MS = 3e3;
-function rowGlyph(status) {
-	switch (status) {
-		case "completed": return {
-			ch: "✔",
-			fg: theme.success
-		};
-		case "failed":
-		case "canceled": return {
-			ch: "✗",
-			fg: theme.error
-		};
-		case "running": return {
-			ch: "▶",
-			fg: theme.accent
-		};
-		case "queued": return {
-			ch: "○",
-			fg: theme.dim
-		};
-	}
-}
-function rowColor$1(status) {
-	switch (status) {
-		case "running": return theme.fg;
-		case "completed": return theme.dim;
-		default: return theme.muted;
-	}
-}
-function headerLabel(rows) {
-	const subject = rows.length === 1 ? "Subagent" : `${rows.length} subagents`;
-	return rows.some((row) => isLiveStatus(row.status)) ? `${subject} running` : subject;
-}
+//#region src/chat/tui/chunks/computer.tsx
 /**
-* The transcript block for a `subagent` tool call — the TUI analog of the web
-* chat's fan-out card. One row per delegated run: status glyph, the short
-* title the delegating agent wrote, ticking over live as children settle.
+* Renders the `/computer` card: a snapshot of the agent's sandbox as a stack of
+* colored bar graphs (cpu load, memory, swap, disk) plus a footer of scalar
+* facts (uptime, process count).
 *
-* Rows are seeded from the call itself (titles from its input, task ids from
-* its own output), so the card renders the moment the call does. Status then
-* comes from the server's task rows, polled while any run is live — the
-* delegated runs outlive the call that spawned them, so the transcript stream
-* carries nothing more about them. The poll stops the moment the batch
-* settles; reopening an old conversation does one fetch and stops there. A
-* failed poll is skipped silently (the next tick retries; stale rows beat an
-* error row in the scrollback).
-*/
-function ToolSubagent({ item }) {
-	const { rest, conversationId } = useConversationContext();
-	const titles = subagentTaskTitles(item.input);
-	const ids = item.output?.kind === "ok" ? queuedSubagentTaskIds(item.output.value) : [];
-	const idsKey = ids.join(",");
-	const [fetched, setFetched] = useState(null);
-	const rows = subagentRows({
-		titles,
-		ids,
-		fetched
-	});
-	const live = rows.length === 0 || rows.some((row) => isLiveStatus(row.status));
+* The card keeps itself current in place rather than making the user re-run the
+* command — but quietly: it refreshes on a slow interval with no "updating"
+* chrome, so the numbers just stay fresh without any flicker. Only the most
+* recent `/computer` card refreshes (older ones freeze at their last snapshot),
+* and the latest one silently stops while the transcript is scrolled up (no
+* wasted polls on a card you're not looking at) and resumes at the bottom — the
+* pause is never rendered. The refresh uses the same sandbox-exec relay
+* `/sandbox` uses, injected via context; the parse/layout math lives in
+* `sandbox-stats.ts` and this component only draws.
+*/
+function ComputerItem({ item }) {
+	const { collectSandboxStats, latestComputerId, scrolledUp } = useConversationContext();
+	const live = shouldPollComputer({
+		isLatest: latestComputerId === item.id,
+		canCollect: collectSandboxStats !== null,
+		scrolledUp
+	});
+	const [stats, setStats] = useState(item.stats);
+	const [error, setError] = useState(item.error);
+	const hasStats = useRef(item.stats !== null);
 	useEffect(() => {
-		if (!rest || !conversationId || idsKey.length === 0 || !live) return;
+		if (!live || !collectSandboxStats) return;
 		let cancelled = false;
 		let timer = null;
+		let inFlight = null;
 		const tick = async () => {
-			try {
-				const tasks = await rest.listSubagentTasks({ conversationId });
-				if (cancelled) return;
-				setFetched(tasks);
-			} catch (_error) {}
-			if (!cancelled) timer = setTimeout(tick, POLL_INTERVAL_MS);
+			const collection = collectSandboxStats();
+			inFlight = collection;
+			const result = await collection.result;
+			inFlight = null;
+			if (cancelled) return;
+			if (result.ok) {
+				hasStats.current = true;
+				setStats(result.stats);
+				setError(null);
+			} else if (!("aborted" in result)) {
+				if (!hasStats.current) setError(result.error);
+			}
+			if (!cancelled) timer = setTimeout(tick, COMPUTER_POLL_INTERVAL_MS);
 		};
 		tick();
 		return () => {
 			cancelled = true;
 			if (timer !== null) clearTimeout(timer);
+			inFlight?.abort();
 		};
-	}, [
-		rest,
-		conversationId,
-		idsKey,
-		live
-	]);
-	if (rows.length === 0) return /* @__PURE__ */ jsxs("text", { children: [/* @__PURE__ */ jsx("span", {
-		fg: theme.warning,
-		children: "◐ "
-	}), /* @__PURE__ */ jsx("span", {
-		fg: theme.tool,
-		children: "Delegating to subagents…"
-	})] });
+	}, [live, collectSandboxStats]);
+	if (stats === null && error === null) return /* @__PURE__ */ jsx(Shell, { children: /* @__PURE__ */ jsx("text", {
+		fg: theme.dim,
+		children: "reading sandbox stats…"
+	}) });
+	if (stats === null) return /* @__PURE__ */ jsx(Shell, { children: /* @__PURE__ */ jsxs("text", {
+		fg: theme.error,
+		children: ["couldn't read sandbox stats", error ? `: ${error}` : ""]
+	}) });
+	const gauges = toGauges(stats);
+	const portRows = toPortRows(stats.ports);
+	const labelWidth = Math.max(5, ...gauges.map((g) => g.label.length));
+	const barWidth = 24;
+	return /* @__PURE__ */ jsxs(Shell, { children: [
+		gauges.map((g) => /* @__PURE__ */ jsx(GaugeRow, {
+			gauge: g,
+			labelWidth,
+			barWidth
+		}, g.label)),
+		/* @__PURE__ */ jsx(PortsSection, {
+			rows: portRows,
+			labelWidth
+		}),
+		/* @__PURE__ */ jsxs("text", {
+			fg: theme.dim,
+			children: [
+				`${"uptime".padEnd(labelWidth)}  `,
+				/* @__PURE__ */ jsx("span", {
+					fg: theme.muted,
+					children: formatUptime(stats.uptimeSeconds)
+				}),
+				/* @__PURE__ */ jsx("span", {
+					fg: theme.dim,
+					children: `  ·  ${stats.procs} processes`
+				})
+			]
+		})
+	] });
+}
+/** The card frame: a bold `computer` title over the graph rows. */
+function Shell({ children }) {
 	return /* @__PURE__ */ jsxs("box", {
 		style: { flexDirection: "column" },
-		children: [/* @__PURE__ */ jsxs("text", { children: [
-			live ? /* @__PURE__ */ jsx(Spinner, { color: theme.accent }) : /* @__PURE__ */ jsx("span", {
-				fg: theme.success,
-				children: "✓"
-			}),
-			/* @__PURE__ */ jsxs("span", {
-				fg: theme.tool,
-				children: [" ", /* @__PURE__ */ jsx("b", { children: headerLabel(rows) })]
-			}),
-			/* @__PURE__ */ jsxs("span", {
+		children: [/* @__PURE__ */ jsxs("text", {
+			fg: theme.muted,
+			children: [/* @__PURE__ */ jsx("b", { children: "computer" }), /* @__PURE__ */ jsx("span", {
 				fg: theme.dim,
-				children: [
-					"  ",
-					rows.filter((row) => row.status === "completed").length,
-					"/",
-					rows.length
-				]
-			})
-		] }), /* @__PURE__ */ jsx("box", {
-			style: {
-				flexDirection: "column",
-				paddingLeft: 2
-			},
-			children: rows.map((row) => {
-				const glyph = rowGlyph(row.status);
-				return /* @__PURE__ */ jsxs("box", {
-					style: { flexDirection: "row" },
-					children: [/* @__PURE__ */ jsxs("text", {
-						fg: glyph.fg,
-						children: [glyph.ch, " "]
-					}), /* @__PURE__ */ jsx("text", {
-						fg: rowColor$1(row.status),
-						children: row.title
-					})]
-				}, row.id);
-			})
-		})]
+				children: " · agent sandbox"
+			})]
+		}), children]
 	});
 }
-
-//#endregion
-//#region src/chat/tui/chunks/shell-local.tsx
+function severityColor(severity) {
+	switch (severity) {
+		case "ok": return theme.success;
+		case "warn": return theme.warning;
+		case "crit": return theme.error;
+		default: {
+			const exhaustive = severity;
+			throw new Error(`unhandled severity: ${String(exhaustive)}`);
+		}
+	}
+}
+function GaugeRow({ gauge, labelWidth, barWidth }) {
+	const color = severityColor(gauge.severity);
+	const pct = `${Math.round(Math.min(1, Math.max(0, gauge.fraction)) * 100)}%`;
+	return /* @__PURE__ */ jsxs("text", { children: [
+		/* @__PURE__ */ jsx("span", {
+			fg: theme.muted,
+			children: `${gauge.label.padEnd(labelWidth)}  `
+		}),
+		/* @__PURE__ */ jsx("span", {
+			fg: color,
+			children: renderBar(gauge.fraction, barWidth)
+		}),
+		/* @__PURE__ */ jsx("span", {
+			fg: color,
+			children: ` ${pct.padStart(4)}`
+		}),
+		/* @__PURE__ */ jsx("span", {
+			fg: theme.dim,
+			children: `  ${gauge.detail}`
+		})
+	] });
+}
 /**
-* Renders a `! <cmd>` local-shell escape: the command the user ran on their own
-* machine, followed by its combined stdout/stderr. Visually distinct from agent
-* tool calls (which run in the sandbox) — a `!` sigil colored by outcome (dim
-* while running, success/error once done), so a glance tells you this executed
-* locally, not on the agent.
+* The listening-ports table: one row per port the sandbox user's processes
+* hold, first row carrying the `ports` gutter label to line up with the
+* gauges. Folds past MAX_PORT_ROWS into a `+N more` line so a busy box can't
+* flood the transcript.
 */
-function ShellLocalItem({ item }) {
-	const running = item.exit === null;
-	const failed = item.exit !== null && item.exit !== 0;
-	return /* @__PURE__ */ jsxs("box", {
-		style: { flexDirection: "column" },
-		children: [/* @__PURE__ */ jsxs("text", { children: [
-			/* @__PURE__ */ jsx("span", {
-				fg: running ? theme.dim : failed ? theme.error : theme.success,
-				children: "! "
-			}),
-			/* @__PURE__ */ jsx("span", {
-				fg: theme.tool,
-				children: item.command
-			}),
-			running ? /* @__PURE__ */ jsx("span", {
-				fg: theme.dim,
-				children: " · running…"
-			}) : null,
-			failed ? /* @__PURE__ */ jsxs("span", {
-				fg: theme.error,
-				children: [" · exit ", item.exit]
-			}) : null
-		] }), item.output ? /* @__PURE__ */ jsx(Indented, { children: /* @__PURE__ */ jsx("text", {
+function PortsSection({ rows, labelWidth }) {
+	if (rows.length === 0) return null;
+	const shown = rows.slice(0, MAX_PORT_ROWS);
+	const folded = rows.length - shown.length;
+	const gutter = " ".repeat(labelWidth);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [shown.map((row, i) => /* @__PURE__ */ jsxs("text", { children: [
+		/* @__PURE__ */ jsx("span", {
 			fg: theme.muted,
-			children: item.output.replace(/\n+$/, "")
-		}) }) : null]
-	});
+			children: `${i === 0 ? "ports".padEnd(labelWidth) : gutter}  `
+		}),
+		/* @__PURE__ */ jsx("span", {
+			fg: theme.fg,
+			children: String(row.port).padStart(5)
+		}),
+		/* @__PURE__ */ jsx("span", {
+			fg: theme.muted,
+			children: `  ${row.process}`
+		}),
+		row.note ? /* @__PURE__ */ jsx("span", {
+			fg: theme.dim,
+			children: `  · ${row.note}`
+		}) : null
+	] }, row.port)), folded > 0 ? /* @__PURE__ */ jsxs("text", { children: [/* @__PURE__ */ jsx("span", {
+		fg: theme.muted,
+		children: `${gutter}  `
+	}), /* @__PURE__ */ jsx("span", {
+		fg: theme.dim,
+		children: `+${folded} more`
+	})] }) : null] });
 }
 
 //#endregion
@@ -4529,20 +5328,23 @@ function RenderItem({ item }) {
 			children: [item.text ? /* @__PURE__ */ jsx("text", {
 				fg: theme.user,
 				children: item.text
-			}) : null, item.attachments && item.attachments.length > 0 ? /* @__PURE__ */ jsxs("text", {
+			}) : null, item.attachments.length > 0 ? /* @__PURE__ */ jsxs("text", {
 				fg: theme.muted,
 				children: ["⎘ ", item.attachments.join(" · ")]
 			}) : null]
 		});
-		case "pending-steer": return /* @__PURE__ */ jsx(Row, {
+		case "pending-steer": return /* @__PURE__ */ jsxs(Row, {
 			barColor: theme.dim,
-			children: /* @__PURE__ */ jsxs("text", {
+			children: [/* @__PURE__ */ jsxs("text", {
 				fg: theme.muted,
 				children: [item.text, /* @__PURE__ */ jsx("span", {
 					fg: theme.dim,
 					children: " · steering… (esc to cancel)"
 				})]
-			})
+			}), item.attachments.length > 0 ? /* @__PURE__ */ jsxs("text", {
+				fg: theme.dim,
+				children: ["⎘ ", item.attachments.join(" · ")]
+			}) : null]
 		});
 		case "assistant-text":
 			if (item.done) return /* @__PURE__ */ jsx(Row, {
@@ -4588,6 +5390,10 @@ function RenderItem({ item }) {
 				})]
 			})
 		});
+		case "computer": return /* @__PURE__ */ jsx(Row, {
+			barColor: null,
+			children: /* @__PURE__ */ jsx(ComputerItem, { item })
+		});
 		case "recap": return /* @__PURE__ */ jsx(Row, {
 			barColor: null,
 			children: /* @__PURE__ */ jsxs("text", {
@@ -4678,7 +5484,7 @@ function ToolItem({ item }) {
 		case "read": return /* @__PURE__ */ jsx(ToolRead, { item });
 		case "grep":
 		case "glob": return /* @__PURE__ */ jsx(ToolGrep, { item });
-		case "subagent": return /* @__PURE__ */ jsx(ToolSubagent, { item });
+		case "subagent": return null;
 		default: return /* @__PURE__ */ jsx(ToolGeneric, { item });
 	}
 }
@@ -5277,7 +6083,8 @@ function applyChunk(items, chunk, agentName = null) {
 			return items.map((m) => m.kind === "pending-steer" && ids.has(m.id) ? {
 				kind: "user",
 				id: m.id,
-				text: m.text
+				text: m.text,
+				attachments: m.attachments
 			} : m);
 		}
 		case "data-anyone-render-spec": {
@@ -5287,6 +6094,22 @@ function applyChunk(items, chunk, agentName = null) {
 			if (!card) return [...items];
 			const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : null;
 			const specKey = specKeyFor(data.spec);
+			if (card.computeRequestId !== null) {
+				const existingIndex = items.findIndex((m) => m.kind === "card" && m.card.computeRequestId === card.computeRequestId);
+				const existing = items[existingIndex];
+				if (existing?.kind === "card") {
+					if (existing.specKey === specKey || card.settled === null) return [...items];
+					const next = [...items];
+					next[existingIndex] = {
+						...existing,
+						specKey,
+						card,
+						status: "done",
+						detail: card.settled
+					};
+					return next;
+				}
+			}
 			if (items.some((m) => m.kind === "card" && m.toolCallId === toolCallId && m.specKey === specKey)) return [...items];
 			return [...items, {
 				kind: "card",
@@ -5294,8 +6117,8 @@ function applyChunk(items, chunk, agentName = null) {
 				toolCallId,
 				specKey,
 				card,
-				status: "idle",
-				detail: null,
+				status: card.settled === null ? "idle" : "done",
+				detail: card.settled,
 				agentName
 			}];
 		}
@@ -5518,7 +6341,7 @@ function uiMessagesToItems(messages) {
 				kind: "user",
 				id: m.id,
 				text,
-				...attachments.length > 0 ? { attachments } : {}
+				attachments
 			});
 			continue;
 		}
@@ -5557,6 +6380,20 @@ function uiMessagesToItems(messages) {
 					if (card && data) {
 						const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : null;
 						const specKey = specKeyFor(data.spec);
+						if (card.computeRequestId !== null) {
+							const existingIndex = out.findIndex((item) => item.kind === "card" && item.card.computeRequestId === card.computeRequestId);
+							const existing = out[existingIndex];
+							if (existing?.kind === "card") {
+								if (existing.specKey !== specKey && card.settled !== null) out[existingIndex] = {
+									...existing,
+									specKey,
+									card,
+									status: "done",
+									detail: card.settled
+								};
+								continue;
+							}
+						}
 						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({
@@ -5565,8 +6402,8 @@ function uiMessagesToItems(messages) {
 							toolCallId,
 							specKey,
 							card,
-							status: "idle",
-							detail: null,
+							status: card.settled === null ? "idle" : "done",
+							detail: card.settled,
 							agentName
 						});
 					}
@@ -5675,7 +6512,7 @@ function windowTodos(todos, cap = MAX_VISIBLE_ROWS) {
 	const sorted = [...todos].sort((a, b) => a.position - b.position);
 	let leadingDone = 0;
 	while (leadingDone < sorted.length && sorted[leadingDone]?.status === "completed") leadingDone += 1;
-	const head = leadingDone >= 2 || sorted.length > cap ? leadingDone : 0;
+	const head = leadingDone === sorted.length && sorted.length > 0 || leadingDone >= 2 || sorted.length > cap ? leadingDone : 0;
 	const rest = sorted.slice(head);
 	const rowBudget = Math.max(1, head > 0 ? cap - 1 : cap);
 	if (rest.length <= rowBudget) return {
@@ -5706,7 +6543,7 @@ function todoCardHeight(todos) {
 }
 
 //#endregion
-//#region src/chat/tui/chat/todo-card.tsx
+//#region src/chat/tui/chat/task-card.tsx
 function glyph(status) {
 	switch (status) {
 		case "completed": return {
@@ -5735,38 +6572,18 @@ function rowColor(status) {
 		default: return theme.muted;
 	}
 }
-/**
-* The agent's live todo list, pinned just above the composer — the TUI analog
-* of the web chat's todo card. Rendered only once the agent has actually
-* written a list (`platform todo write`) and until it clears one, so a
-* conversation the agent never wrote todos for grows no chrome for it.
-*
-* The card can't scroll like the web card, so it windows (see `windowTodos`):
-* a leading run of completed todos folds into a `✔ N done` line, the active
-* and upcoming rows fill the rest, and a `+N more` tail counts pending work
-* past the cap. The window follows the in-progress row down as todos complete.
-*
-* `isActive` dims the header while the run is idle: an in-progress row only
-* reads as "happening now" when a run is actually producing output.
-*/
-function TodoCardView({ todos, isActive }) {
-	if (todos.length === 0) return null;
-	const completed = todos.filter((t) => t.status === "completed").length;
+/** Shared plan/subagent checklist content. The caller owns outer spacing. */
+function TaskCardContent({ label, todos, isActive }) {
+	const completed = todos.filter((todo) => todo.status === "completed").length;
 	const { doneSummary, rows, moreCount } = windowTodos(todos);
 	return /* @__PURE__ */ jsxs("box", {
-		style: {
-			flexDirection: "column",
-			flexShrink: 0,
-			marginTop: 1,
-			paddingLeft: 1,
-			paddingRight: 1
-		},
+		style: { flexDirection: "column" },
 		children: [
 			/* @__PURE__ */ jsxs("box", {
 				style: { flexDirection: "row" },
 				children: [/* @__PURE__ */ jsx("text", {
 					fg: isActive ? theme.accent : theme.muted,
-					children: /* @__PURE__ */ jsx("b", { children: "Plan" })
+					children: /* @__PURE__ */ jsx("b", { children: label })
 				}), /* @__PURE__ */ jsxs("text", {
 					fg: theme.dim,
 					children: [
@@ -5811,6 +6628,260 @@ function TodoCardView({ todos, isActive }) {
 		]
 	});
 }
+function taskCardContentHeight(todos) {
+	if (todos.length === 0) return 0;
+	const window = windowTodos(todos);
+	return 1 + (window.doneSummary > 0 ? 1 : 0) + window.rows.length + (window.moreCount > 0 ? 1 : 0);
+}
+
+//#endregion
+//#region src/chat/tui/chat/todo-card.tsx
+/**
+* The agent's live todo list, pinned just above the composer — the TUI analog
+* of the web chat's todo card. Rendered only once the agent has actually
+* written a list (`platform todo write`) and until it clears one, so a
+* conversation the agent never wrote todos for grows no chrome for it.
+*
+* The card can't scroll like the web card, so it windows completed and pending
+* work. `isActive` dims the header while the run is idle.
+*/
+function TodoCardView({ todos, isActive }) {
+	if (todos.length === 0) return null;
+	return /* @__PURE__ */ jsx("box", {
+		style: {
+			flexDirection: "column",
+			flexShrink: 0,
+			marginTop: 1,
+			paddingLeft: 1,
+			paddingRight: 1
+		},
+		children: /* @__PURE__ */ jsx(TaskCardContent, {
+			label: "Plan",
+			todos,
+			isActive
+		})
+	});
+}
+
+//#endregion
+//#region src/chat/tui/chat/subagents.ts
+/** A run the platform hasn't settled yet — still queued or mid-run. */
+function isLiveStatus(status) {
+	return status === "queued" || status === "running";
+}
+function toTaskStatus(raw) {
+	switch (raw) {
+		case "queued":
+		case "running":
+		case "completed":
+		case "failed":
+		case "canceled": return raw;
+		default: return "queued";
+	}
+}
+const FALLBACK_TITLE = "Subagent task";
+/**
+* Each delegated task's display title from the `subagent` call's input, in
+* call order — the short name the tool requires per task. A malformed entry
+* yields a fallback label rather than being dropped, so the row count always
+* matches the fan-out width. Mirrors the web client's `subagentTaskTitles`.
+*/
+function subagentTaskTitles(input) {
+	if (!isRecord(input)) return [];
+	const tasks = input["tasks"];
+	if (!Array.isArray(tasks)) return [];
+	return tasks.map((task) => {
+		if (!isRecord(task)) return FALLBACK_TITLE;
+		const title = task["title"];
+		return typeof title === "string" && title.trim() ? title.trim() : FALLBACK_TITLE;
+	});
+}
+const QUEUED_TASK_ID_LINE = /^\s*-\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}):\s/i;
+/**
+* The ids of the runs a `subagent` call queued, read back out of its own
+* output. The call returns the moment the runs exist, so the ids are there
+* long before any child finishes — they are what ties this card to the task
+* rows the status poll returns, and their order is the tasks' call order.
+*/
+function queuedSubagentTaskIds(output) {
+	const text = flattenOutputText(output);
+	if (!text) return [];
+	return text.split("\n").map((line) => line.match(QUEUED_TASK_ID_LINE)?.[1] ?? null).filter((id) => id !== null);
+}
+/**
+* Tool output reaches the TUI as `unknown`: the raw string live, possibly
+* wrapped in content parts or arrays when loaded from history. Walk it for
+* string leaves, newline-joined — the PR scanner's `stringifyToolOutput`
+* shape, bounded small because the id list sits at the top of the output.
+*/
+function flattenOutputText(value) {
+	const MAX_LEN = 2e4;
+	const parts = [];
+	let total = 0;
+	const visit = (v, depth) => {
+		if (total >= MAX_LEN || depth > 4) return;
+		if (typeof v === "string") {
+			parts.push(v);
+			total += v.length;
+			return;
+		}
+		if (Array.isArray(v)) {
+			for (const item of v) visit(item, depth + 1);
+			return;
+		}
+		if (isRecord(v)) for (const item of Object.values(v)) visit(item, depth + 1);
+	};
+	visit(value, 0);
+	return parts.join("\n");
+}
+function nextAnchoredSubagentIds({ current, nextId, liveById }) {
+	if (current.includes(nextId)) return current;
+	return current.some((id) => liveById[id] ?? true) ? [...current, nextId] : [nextId];
+}
+/**
+* The card's rows: one per queued run id (call order), each carrying the
+* freshest known state. A task the status fetch hasn't returned yet falls
+* back to the input's title and reads as queued; a fetched row's own title
+* wins over the input's (the server's copy is the one the child actually
+* ran under). Before the ids exist — the call is still streaming — rows come
+* from the input titles alone, so the card never renders empty mid-turn.
+*/
+function subagentRows({ titles, ids, fetched }) {
+	if (ids.length === 0) return titles.map((title, index) => ({
+		id: `queued:${index}`,
+		title,
+		status: "queued",
+		createdAt: null,
+		completedAt: null
+	}));
+	return ids.map((id, index) => {
+		const row = fetched?.get(id) ?? null;
+		return {
+			id,
+			title: row?.title ?? titles[index] ?? FALLBACK_TITLE,
+			status: row ? toTaskStatus(row.status) : "queued",
+			createdAt: row?.createdAt ?? null,
+			completedAt: row?.completedAt ?? null
+		};
+	});
+}
+
+//#endregion
+//#region src/chat/tui/chunks/tool-subagent.tsx
+/** How often a live batch re-reads its tasks' status. */
+const POLL_INTERVAL_MS = 3e3;
+function subagentTodos(rows) {
+	return rows.map((row, position) => ({
+		id: row.id,
+		content: row.title,
+		position,
+		status: row.status === "completed" ? "completed" : row.status === "running" ? "in_progress" : row.status === "failed" || row.status === "canceled" ? "failed" : "pending"
+	}));
+}
+/**
+* The transcript block for a `subagent` tool call — the TUI analog of the web
+* chat's fan-out card. One row per delegated run: status glyph, the short
+* title the delegating agent wrote, ticking over live as children settle.
+*
+* Rows are seeded from the call itself (titles from its input, task ids from
+* its own output), so the card renders the moment the call does. Status then
+* comes from the server's task rows, polled while any run is live — the
+* delegated runs outlive the call that spawned them, so the transcript stream
+* carries nothing more about them. The poll stops the moment the batch
+* settles; reopening an old conversation does one fetch and stops there. A
+* failed poll is skipped silently (the next tick retries; stale rows beat an
+* error row in the scrollback).
+*/
+function ToolSubagent({ item, isActive, onLiveChange, onHeightChange }) {
+	const { rest, conversationId } = useConversationContext();
+	const titles = subagentTaskTitles(item.input);
+	const ids = item.output?.kind === "ok" ? queuedSubagentTaskIds(item.output.value) : [];
+	const idsKey = ids.join(",");
+	const [fetched, setFetched] = useState(null);
+	const rows = subagentRows({
+		titles,
+		ids,
+		fetched
+	});
+	const live = rows.length === 0 || rows.some((row) => isLiveStatus(row.status));
+	const todos = subagentTodos(rows);
+	useEffect(() => {
+		onLiveChange?.(live);
+	}, [live, onLiveChange]);
+	useEffect(() => {
+		onHeightChange?.(taskCardContentHeight(todos));
+	}, [onHeightChange, todos]);
+	useEffect(() => {
+		if (!rest || !conversationId || idsKey.length === 0 || !live) return;
+		let cancelled = false;
+		let timer = null;
+		const tick = async () => {
+			try {
+				const tasks = await rest.listSubagentTasks({ conversationId });
+				if (cancelled) return;
+				setFetched(tasks);
+			} catch (_error) {}
+			if (!cancelled) timer = setTimeout(tick, POLL_INTERVAL_MS);
+		};
+		tick();
+		return () => {
+			cancelled = true;
+			if (timer !== null) clearTimeout(timer);
+		};
+	}, [
+		rest,
+		conversationId,
+		idsKey,
+		live
+	]);
+	if (rows.length === 0) return /* @__PURE__ */ jsxs("text", { children: [/* @__PURE__ */ jsx("span", {
+		fg: theme.warning,
+		children: "◐ "
+	}), /* @__PURE__ */ jsx("span", {
+		fg: theme.tool,
+		children: "Delegating to subagents…"
+	})] });
+	return /* @__PURE__ */ jsx(TaskCardContent, {
+		label: rows.length === 1 ? "Subagent" : "Subagents",
+		todos,
+		isActive: isActive ?? live
+	});
+}
+
+//#endregion
+//#region src/chat/tui/chat/subagent-card.tsx
+/**
+* Delegated work pinned above the plan. Each batch owns its status polling and
+* stays as a dimmed completion summary after every run settles.
+*/
+function SubagentCardView({ items, isActive, onHeightChange, onBatchLiveChange }) {
+	const [heightById, setHeightById] = useState({});
+	const setBatchHeight = useCallback((id, height) => {
+		setHeightById((current) => current[id] === height ? current : {
+			...current,
+			[id]: height
+		});
+	}, []);
+	const height = useMemo(() => items.length === 0 ? 0 : 1 + items.reduce((rows, item) => rows + (heightById[item.id] ?? 0), 0) + (items.length - 1), [heightById, items]);
+	useEffect(() => onHeightChange?.(height), [height, onHeightChange]);
+	if (items.length === 0) return null;
+	return /* @__PURE__ */ jsx("box", {
+		style: {
+			flexDirection: "column",
+			flexShrink: 0,
+			marginTop: 1,
+			paddingLeft: 1,
+			paddingRight: 1,
+			gap: 1
+		},
+		children: items.map((item) => /* @__PURE__ */ jsx(ToolSubagent, {
+			item,
+			isActive,
+			onLiveChange: (live) => onBatchLiveChange?.(item.id, live),
+			onHeightChange: (batchHeight) => setBatchHeight(item.id, batchHeight)
+		}, item.id))
+	});
+}
 
 //#endregion
 //#region src/chat/tui/chat/pr-links.tsx
@@ -5969,6 +7040,65 @@ function formatShare(share) {
 	return share.grantedToAgent ? "shared (this agent can run commands here)" : "shared (this agent is not granted)";
 }
 
+//#endregion
+//#region src/chat/sandbox/collect-stats.ts
+function collectSandboxStats(cfg) {
+	const open = cfg.open ?? SandboxStream.open;
+	const dec = new TextDecoder();
+	let buffer = "";
+	let settled = false;
+	let stream = null;
+	let resolveRef = null;
+	return {
+		result: new Promise((resolve) => {
+			resolveRef = resolve;
+			const settle = (r) => {
+				if (settled) return;
+				settled = true;
+				resolve(r);
+			};
+			stream = open({
+				mode: "exec",
+				appUrl: cfg.appUrl,
+				sessionToken: cfg.sessionToken,
+				agentId: cfg.agentId,
+				command: SANDBOX_STATS_COMMAND,
+				onEvent: (e) => {
+					if (e.type === "data") buffer += dec.decode(e.bytes);
+					else if (e.type === "error") settle({
+						ok: false,
+						error: e.message
+					});
+					else if (e.type === "exit") {
+						const stats = parseSandboxStats(buffer);
+						if (stats) settle({
+							ok: true,
+							stats
+						});
+						else settle({
+							ok: false,
+							error: e.code === 0 ? "unexpected output from the sandbox" : `sandbox command exited ${e.code}`
+						});
+					} else if (e.type === "close") settle({
+						ok: false,
+						error: e.failure ?? "connection closed before the snapshot finished"
+					});
+				}
+			});
+		}),
+		abort: () => {
+			if (settled) return;
+			settled = true;
+			stream?.close();
+			resolveRef?.({
+				ok: false,
+				aborted: true,
+				error: "aborted"
+			});
+		}
+	};
+}
+
 //#endregion
 //#region src/chat/notification-preview.ts
 const MAX_NOTIFICATION_PREVIEW_CHARS = 240;
@@ -6019,6 +7149,101 @@ function createResponsePreview() {
 	};
 }
 
+//#endregion
+//#region src/chat/tui/new-chat-splash.tsx
+/** Rows the splash art needs before it's worth painting: the 6-row mark, a
+* spacer, the two identity/hint lines, and a row of breathing room. Below
+* this only the identity + hint render (small panes must keep every
+* transcript row). */
+const MARK_MIN_ROWS = 10;
+/** Columns the full mark + wordmark lockup spans (~68), with margin; below
+* this the pinwheel mark renders alone instead of wrapping the wordmark. */
+const FULL_MARK_MIN_COLS = 70;
+/**
+* Brand splash filling an empty conversation's transcript area: the Skydive
+* mark centered above the agent's identity and the "say hello" hint, with
+* the composer live below. The identity line matters here because nothing
+* else on this screen names the agent — a bare `skydive chat` boots straight
+* into this view via the configured default. Rendered only while the
+* transcript is empty, so the first submission replaces it with the regular
+* conversation view. Degrades by available space: full lockup → mark only →
+* identity + hint only.
+*/
+function NewChatSplash({ agentName, agentTitle, width, height }) {
+	return /* @__PURE__ */ jsxs("box", {
+		style: {
+			height,
+			flexDirection: "column",
+			justifyContent: "center",
+			alignItems: "center"
+		},
+		children: [
+			height >= MARK_MIN_ROWS ? /* @__PURE__ */ jsx("box", {
+				style: {
+					flexDirection: "column",
+					alignItems: "center",
+					marginBottom: 1
+				},
+				children: /* @__PURE__ */ jsx(SkydiveMark, { variant: width >= FULL_MARK_MIN_COLS ? "full" : "mark" })
+			}) : null,
+			/* @__PURE__ */ jsxs("text", { children: [/* @__PURE__ */ jsx("span", {
+				fg: theme.accent,
+				children: agentName
+			}), agentTitle ? /* @__PURE__ */ jsxs("span", {
+				fg: theme.muted,
+				children: [" · ", agentTitle]
+			}) : null] }),
+			/* @__PURE__ */ jsx("text", {
+				fg: theme.dim,
+				children: "say hello below"
+			})
+		]
+	});
+}
+
+//#endregion
+//#region src/chat/tui/spinner-frames.ts
+/** Braille dot-cycle frames — the classic smooth terminal spinner. */
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+/** Milliseconds between frames. ~12.5fps reads as smooth without thrashing. */
+const SPINNER_INTERVAL_MS = 80;
+/** Frame for a given tick count. Wraps at the end of the cycle; negative-safe. */
+function spinnerFrame(tick) {
+	const n = SPINNER_FRAMES.length;
+	return SPINNER_FRAMES[(Math.trunc(tick) % n + n) % n] ?? SPINNER_FRAMES[0];
+}
+
+//#endregion
+//#region src/chat/tui/spinner.tsx
+/**
+* An animated spinner glyph. Advances one frame every SPINNER_INTERVAL_MS via
+* a self-owned interval that's cleared on unmount, so the animation runs only
+* while the component is mounted. Returns a <span>, so render it inside a
+* <text> (matching how the rest of the TUI composes inline glyphs).
+*/
+function Spinner({ color }) {
+	const [tick, setTick] = useState(0);
+	useEffect(() => {
+		const id = setInterval(() => setTick((t) => t + 1), SPINNER_INTERVAL_MS);
+		return () => clearInterval(id);
+	}, []);
+	return /* @__PURE__ */ jsx("span", {
+		fg: color,
+		children: spinnerFrame(tick)
+	});
+}
+
 //#endregion
 //#region src/chat/tui/prompt-history.ts
 /**
@@ -6752,6 +7977,13 @@ const slashCommands = [
 		description: "switch conversation (no id: pick from the list)",
 		action: { kind: "conversation" }
 	},
+	{
+		name: "search",
+		aliases: ["find"],
+		argsHint: "[query]",
+		description: "search conversations by title, message, or participant",
+		action: { kind: "search" }
+	},
 	{
 		name: "model",
 		aliases: [],
@@ -6773,6 +8005,13 @@ const slashCommands = [
 		description: "show connection and session status",
 		action: { kind: "status" }
 	},
+	{
+		name: "computer",
+		aliases: ["stats"],
+		argsHint: null,
+		description: "show the agent sandbox's cpu, memory, and disk",
+		action: { kind: "computer" }
+	},
 	{
 		name: "plan",
 		aliases: ["todos", "todo"],
@@ -6847,7 +8086,8 @@ 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` and `conversation` accept a rest.
+* into the help modal. `sandbox`, `conversation`, `search` and `rename`
+* accept a rest (their argsHint is non-null).
 */
 function matchSlashCommand(line) {
 	if (!line.startsWith("/")) return null;
@@ -9950,6 +11190,10 @@ function routeInput(raw) {
 				kind: "open-conversation",
 				ref: match.rest
 			} : { kind: "conversation-picker" };
+			case "search": return {
+				kind: "conversation-search",
+				query: match.rest
+			};
 			case "rename-conversation": return {
 				kind: "rename-conversation",
 				title: match.rest
@@ -9967,6 +11211,7 @@ function routeInput(raw) {
 			case "model-picker":
 			case "theme-picker":
 			case "status":
+			case "computer":
 			case "share":
 			case "browser":
 			case "connect":
@@ -10034,47 +11279,6 @@ 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
 /**
@@ -10159,11 +11363,13 @@ function ChatScreen({ agent, conversation }) {
 	const portalClient = useStore((s) => s.portalClient);
 	const setPortalPrompt = useStore((s) => s.setPortalPrompt);
 	const declinedRef = useRef(/* @__PURE__ */ new Set());
+	const grantInFlightRef = useRef(/* @__PURE__ */ new Set());
 	const grantPrompt = portal.prompt && portal.prompt.agentId === agent.id ? portal.prompt : null;
 	const isShared = portal.status !== "off";
 	const initialConversationId = isNewConversation(conversation) ? null : conversation.id;
 	const agentHost = useAgentHost();
 	const nonWebChannel = nonWebChannelLabel(conversation);
+	const agentRunConversation = isAgentRunConversation(conversation);
 	const [conversationId, setConversationId] = useState(initialConversationId);
 	const { compacting, compactConversation, onCompactionEvent } = useCompaction({
 		rest,
@@ -10172,6 +11378,12 @@ function ChatScreen({ agent, conversation }) {
 	const [items, setItems] = useState([]);
 	const [todos, setTodos] = useState(null);
 	const [planHidden, setPlanHidden] = useState(false);
+	const [subagentRows, setSubagentRows] = useState(0);
+	const [anchoredSubagentIds, setAnchoredSubagentIds] = useState([]);
+	const anchoredSubagentLiveRef = useRef({});
+	const setAnchoredBatchLive = useCallback((id, live) => {
+		anchoredSubagentLiveRef.current[id] = live;
+	}, []);
 	const [scrolledUp, setScrolledUp] = useState(false);
 	const hadTodosRef = useRef(false);
 	useEffect(() => {
@@ -10214,14 +11426,18 @@ function ChatScreen({ agent, conversation }) {
 	const forkingRef = useRef(false);
 	const [credPrompt, setCredPrompt] = useState(null);
 	const credPromptOpen = credPrompt !== null;
+	const [computePrompt, setComputePrompt] = useState(null);
+	const computePromptOpen = computePrompt !== null;
 	const [menuDismissed, setMenuDismissed] = useState(false);
 	const [menuHighlight, setMenuHighlight] = useState(0);
-	const commandQuery = grantPrompt || credPrompt ? null : detectCommandTrigger(input);
+	const commandQuery = grantPrompt || credPrompt || computePrompt ? null : detectCommandTrigger(input);
 	const menuCommands = commandQuery === null ? [] : filterSlashCommands(commandQuery);
 	const menuOpen = commandQuery !== null && !menuDismissed;
 	const menuHighlightClamped = Math.min(menuHighlight, Math.max(0, menuCommands.length - 1));
 	const runRef = useRef(run);
 	runRef.current = run;
+	const conversationIdRef = useRef(conversationId);
+	conversationIdRef.current = conversationId;
 	const itemsRef = useRef(items);
 	itemsRef.current = items;
 	const attachmentsRef = useRef(attachments);
@@ -10232,7 +11448,7 @@ function ChatScreen({ agent, conversation }) {
 	credPromptRef.current = credPrompt;
 	const seenRunsRef = useRef(/* @__PURE__ */ new Set());
 	const shellSessionRef = useRef(null);
-	const hostState = grantPrompt || credPrompt ? "blocked" : run.kind === "idle" ? "idle" : "working";
+	const hostState = grantPrompt || credPrompt || computePrompt ? "blocked" : run.kind === "idle" ? "idle" : "working";
 	useEffect(() => {
 		agentHost.transition({ state: hostState });
 	}, [agentHost, hostState]);
@@ -10271,13 +11487,16 @@ function ChatScreen({ agent, conversation }) {
 		});
 		setScrolledUp(false);
 	}, []);
+	const scrolledUpRef = useRef(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);
+			const next = !(box.scrollTop + viewport >= box.scrollHeight - 1);
+			if (scrolledUpRef.current === next) return;
+			scrolledUpRef.current = next;
+			setScrolledUp(next);
 		}, 150);
 		return () => clearInterval(id);
 	}, []);
@@ -10285,11 +11504,12 @@ function ChatScreen({ agent, conversation }) {
 	const reviewBelowBoxRef = useRef(null);
 	const paneDragRef = useRef(null);
 	const composerBoxHeight = composerRows + 2;
-	const pendingVisible = !grantPrompt && !credPrompt && !nonWebChannel && attachments.length > 0;
+	const pendingVisible = !grantPrompt && !credPrompt && !computePrompt && !nonWebChannel && attachments.length > 0;
 	const pendingRows = pendingVisible ? attachments.length + 2 : 0;
 	const credPromptHeight = 4 + (credPrompt && (credPrompt.error || credPrompt.submitting) ? 1 : 0);
 	const nonWebNoticeHeight = 5;
-	const bottomBoxHeight = credPrompt ? credPromptHeight : nonWebChannel ? nonWebNoticeHeight : composerBoxHeight;
+	const computePromptHeight = 4;
+	const bottomBoxHeight = credPrompt ? credPromptHeight : computePrompt ? computePromptHeight : nonWebChannel ? nonWebNoticeHeight : composerBoxHeight;
 	const bodyWidth = Math.max(1, width - 2);
 	const bodyHeight = Math.max(1, height - 3);
 	const reviewPlacement = filePanePlacement({
@@ -10306,9 +11526,13 @@ function ChatScreen({ agent, conversation }) {
 	const menuRows = menuOpen ? completionMenuHeight(menuCommands.length) : 0;
 	const todoCardVisible = !credPrompt && !planHidden && !!todos && todos.length > 0;
 	const todoRows = todoCardVisible ? todoCardHeight(todos) : 0;
+	const subagentItems = useMemo(() => {
+		const ids = new Set(anchoredSubagentIds);
+		return items.filter((item) => item.kind === "tool" && item.toolName === "subagent" && ids.has(item.id));
+	}, [items, anchoredSubagentIds]);
 	const jumpHintVisible = scrolledUp && !credPrompt;
 	const jumpHintRows = jumpHintVisible ? 1 : 0;
-	const scrollHeight = Math.max(3, chatHeight - 2 - bottomBoxHeight - pendingRows - inlineReviewHeight - menuRows - jumpHintRows - todoRows);
+	const scrollHeight = Math.max(3, chatHeight - 2 - bottomBoxHeight - pendingRows - inlineReviewHeight - menuRows - jumpHintRows - subagentRows - todoRows);
 	useEffect(() => {
 		if (reviewOpen && reviewFocused) {
 			const composer = composerRef.current;
@@ -10342,7 +11566,8 @@ function ChatScreen({ agent, conversation }) {
 		reviewOpen,
 		reviewFocused,
 		reviewPlacement,
-		credPromptOpen
+		credPromptOpen,
+		computePromptOpen
 	]);
 	useEffect(() => {
 		if (!rest || !initialConversationId) return;
@@ -10358,10 +11583,13 @@ function ChatScreen({ agent, conversation }) {
 					text: recapText
 				});
 				setItems(loaded);
+				const toolUrlText = loaded.map((item) => item.kind === "tool" && item.output?.kind === "ok" ? stringifyToolOutput(item.output.value) : "").join("\n");
 				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 (item.kind !== "assistant-text") continue;
+					for (const pr of extractPullRequests(item.text, {
+						requireCompleteNumber: false,
+						urlOnlyText: toolUrlText
+					})) {
 						if (reportedPrsRef.current.has(pr.key)) continue;
 						reportedPrsRef.current.set(pr.key, pr);
 						setPrLinks((prev) => [...prev, pr]);
@@ -10388,6 +11616,15 @@ function ChatScreen({ agent, conversation }) {
 		initialConversationId,
 		agentHost
 	]);
+	const markRead = useCallback(() => {
+		const id = conversationIdRef.current;
+		if (!rest || !id) return;
+		rest.markConversationRead({ conversationId: id }).catch(() => {});
+	}, [rest]);
+	useEffect(() => {
+		if (!conversationId) return;
+		markRead();
+	}, [conversationId, markRead]);
 	const attachToRun = useCallback((runId, runAgentName, runStartedAtMs) => {
 		if (!rest) return;
 		seenRunsRef.current.add(runId);
@@ -10400,6 +11637,7 @@ function ChatScreen({ agent, conversation }) {
 			agentHost.addPullRequest(pr);
 		});
 		const streamAgentName = runAgentName ?? agent.name;
+		let sawErrorChunk = false;
 		setRun((prev) => ({
 			kind: "streaming",
 			runId,
@@ -10411,8 +11649,21 @@ function ChatScreen({ agent, conversation }) {
 			signal: abort.signal,
 			onEvent: (event) => {
 				if (event.kind === "chunk") {
+					if (event.chunk.type === "error") sawErrorChunk = true;
 					responsePreview.addChunk(event.chunk);
 					prScanner.addChunk(event.chunk);
+					if ((event.chunk.type === "tool-input-start" || event.chunk.type === "tool-input-available") && event.chunk.toolName === "subagent" && typeof event.chunk.toolCallId === "string") {
+						const id = event.chunk.toolCallId;
+						setAnchoredSubagentIds((current) => {
+							const next = nextAnchoredSubagentIds({
+								current,
+								nextId: id,
+								liveById: anchoredSubagentLiveRef.current
+							});
+							if (next.length === 1 && next[0] === id) anchoredSubagentLiveRef.current = { [id]: true };
+							return next;
+						});
+					}
 					if (event.chunk.type === "data-anyone-todos-updated") {
 						const next = todosFromPayload(event.chunk.data);
 						if (next) setTodos(next.length > 0 ? next : null);
@@ -10428,7 +11679,7 @@ function ChatScreen({ agent, conversation }) {
 					id: crypto.randomUUID(),
 					text: billingOutcome.message
 				}]);
-				else if (event.status !== "ok" && errorText) setItems((prev) => [...prev, {
+				else if (event.status !== "ok" && errorText && !sawErrorChunk) setItems((prev) => [...prev, {
 					kind: "error",
 					id: crypto.randomUUID(),
 					text: errorText
@@ -10436,9 +11687,11 @@ function ChatScreen({ agent, conversation }) {
 				setItems((prev) => prev.map((m) => m.kind === "pending-steer" ? {
 					kind: "user",
 					id: m.id,
-					text: m.text
+					text: m.text,
+					attachments: m.attachments
 				} : m));
 				setRun({ kind: "idle" });
+				markRead();
 				agentHost.transition({
 					state: "idle",
 					notification: {
@@ -10460,7 +11713,8 @@ function ChatScreen({ agent, conversation }) {
 	}, [
 		rest,
 		agent.name,
-		agentHost
+		agentHost,
+		markRead
 	]);
 	const multiAgent = useMemo(() => conversationAgentNames(items, agent.name), [items, agent.name]).size > 1;
 	const transcriptWindow = useMemo(() => windowItems(items), [items]);
@@ -10513,7 +11767,7 @@ function ChatScreen({ agent, conversation }) {
 			kind: "user",
 			id: optimisticId,
 			text: trimmed,
-			...stagedNames.length > 0 ? { attachments: stagedNames } : {}
+			attachments: stagedNames
 		}]);
 		const wasStreaming = runRef.current.kind === "streaming";
 		if (!wasStreaming) setRun({
@@ -10562,7 +11816,8 @@ function ChatScreen({ agent, conversation }) {
 				if (directiveId) setItems((prev) => prev.map((m) => m.id === optimisticId ? {
 					kind: "pending-steer",
 					id: directiveId,
-					text: trimmed
+					text: trimmed,
+					attachments: m.kind === "user" || m.kind === "pending-steer" ? m.attachments : []
 				} : m));
 				const current = runRef.current;
 				if (!(current.kind === "streaming" && current.runId === result.runId)) attachToRun(result.runId, result.agentName ?? null);
@@ -10609,12 +11864,14 @@ function ChatScreen({ agent, conversation }) {
 		});
 		(async () => {
 			if (autoGrantMachine && portalClient && portalStatus === "connected" && !portalClient.isGranted(agent.id)) try {
-				await portalClient.grantAgent(agent.id);
+				grantInFlightRef.current.add(agent.id);
+				await portalClient.grantAgent(agent.id, null);
 				useStore.getState().showToast({
-					message: `Shared this machine with ${agent.name} for the import. The grant persists. Revoke anytime: skydive portal revoke --agent ${agent.name}`,
+					message: `Shared this machine with ${agent.name} for the import. The grant persists. Revoke anytime: skydive portal revoke --agent "${agent.name}"`,
 					durationMs: 1e4
 				});
 			} catch (err) {
+				grantInFlightRef.current.delete(agent.id);
 				useStore.getState().showToast({
 					message: `Couldn't grant machine access automatically (${errorMessage(err)}). The agent will ask in chat instead.`,
 					variant: "warning"
@@ -10669,6 +11926,14 @@ function ChatScreen({ agent, conversation }) {
 			});
 			return;
 		}
+		if (action.kind === "decide_compute") {
+			setComputePrompt({
+				cardId: item.id,
+				requestId: action.requestId,
+				summary: item.card.subtitle
+			});
+			return;
+		}
 		updateCard(item.id, {
 			status: "busy",
 			detail: null
@@ -10678,9 +11943,12 @@ function ChatScreen({ agent, conversation }) {
 				if (!portalClient) throw new Error("portal is unavailable in this session");
 				const justEnabled = portal.status === "off";
 				if (justEnabled) portalClient.enable();
+				grantInFlightRef.current.add(action.agentId);
+				if (useStore.getState().portal.prompt?.agentId === action.agentId) setPortalPrompt(null);
 				try {
-					await portalClient.grantAgent(action.agentId);
+					await portalClient.grantAgent(action.agentId, action.conversationId);
 				} catch (grantErr) {
+					grantInFlightRef.current.delete(action.agentId);
 					if (justEnabled) portalClient.disable();
 					throw grantErr;
 				}
@@ -10741,8 +12009,45 @@ function ChatScreen({ agent, conversation }) {
 		appUrl,
 		updateCard,
 		portalClient,
-		portal.status
+		portal.status,
+		setPortalPrompt
 	]);
+	const decideCompute = useCallback((prompt, decision) => {
+		setComputePrompt(null);
+		if (!rest) return;
+		updateCard(prompt.cardId, {
+			status: "busy",
+			detail: null
+		});
+		const settleIfStillDeciding = (patch) => {
+			setItems((prev) => prev.map((m) => m.kind === "card" && m.id === prompt.cardId && m.status === "busy" && m.card.settled === null ? {
+				...m,
+				...patch
+			} : m));
+		};
+		(async () => {
+			try {
+				const { status } = await rest.decideComputeRequest({
+					requestId: prompt.requestId,
+					decision
+				});
+				settleIfStillDeciding({
+					status: "done",
+					detail: computeSettledLabel(status) ?? status
+				});
+			} catch (err) {
+				settleIfStillDeciding({
+					status: "error",
+					detail: cardActionErrorMessage(err)
+				});
+			}
+		})();
+	}, [rest, updateCard]);
+	useEffect(() => {
+		if (!computePrompt) return;
+		const target = items.find((m) => m.kind === "card" && m.id === computePrompt.cardId);
+		if (!target || target.card.settled !== null || target.status === "done") setComputePrompt(null);
+	}, [computePrompt, items]);
 	const promptForCards = useCallback(() => {
 		const targets = itemsRef.current.filter(isActionableCard);
 		const [only] = targets;
@@ -10905,6 +12210,16 @@ function ChatScreen({ agent, conversation }) {
 		sessionToken,
 		agent.id
 	]);
+	const runComputerStats = useCallback(() => {
+		if (!appUrl || !sessionToken) return;
+		setItems((prev) => [...prev, {
+			kind: "computer",
+			id: crypto.randomUUID(),
+			state: "loading",
+			stats: null,
+			error: null
+		}]);
+	}, [appUrl, sessionToken]);
 	const runSandboxPty = useCallback(async () => {
 		if (!appUrl || !sessionToken) return;
 		const result = await runPtySession({
@@ -10999,7 +12314,7 @@ function ChatScreen({ agent, conversation }) {
 		stageAttachment(image);
 	}, [stageAttachment]);
 	usePaste((event) => {
-		if (cardPickerOpen || modelPickerOpen || themePickerOpen || helpOpen || credPromptOpen || grantPrompt || nonWebChannel) return;
+		if (cardPickerOpen || modelPickerOpen || themePickerOpen || helpOpen || credPromptOpen || grantPrompt || computePromptOpen || nonWebChannel) return;
 		const text = event.metadata?.kind === "binary" ? "" : decodePasteBytes(event.bytes);
 		const route = routePaste({
 			kind: event.metadata?.kind,
@@ -11053,6 +12368,7 @@ function ChatScreen({ agent, conversation }) {
 		themePickerOpen,
 		helpOpen,
 		credPromptOpen,
+		computePromptOpen,
 		applyComposerText
 	]);
 	const cancelRun = useCallback(async () => {
@@ -11066,7 +12382,8 @@ function ChatScreen({ agent, conversation }) {
 		setItems((prev) => prev.map((m) => m.kind === "pending-steer" ? {
 			kind: "user",
 			id: m.id,
-			text: m.text
+			text: m.text,
+			attachments: m.attachments
 		} : m));
 		useStore.getState().showToast({ message: "run cancelled" });
 	}, [rest]);
@@ -11134,7 +12451,11 @@ function ChatScreen({ agent, conversation }) {
 		goTo
 	]);
 	const archiveConversation = useCallback(() => {
-		if (grantPrompt || credPrompt) return;
+		if (grantPrompt || credPrompt || computePrompt) return;
+		if (agentRunConversation) {
+			useStore.getState().showToast({ message: "agent runs can't be archived — ctrl+d in the picker deletes" });
+			return;
+		}
 		if (runRef.current.kind !== "idle") {
 			useStore.getState().showToast({ message: "finish or cancel the run first (ctrl+c)" });
 			return;
@@ -11154,7 +12475,8 @@ function ChatScreen({ agent, conversation }) {
 			});
 			goTo({
 				kind: "conversation-picker",
-				agent
+				agent,
+				initialQuery: ""
 			});
 		}).catch((err) => useStore.getState().showToast({
 			variant: "error",
@@ -11163,6 +12485,8 @@ function ChatScreen({ agent, conversation }) {
 	}, [
 		grantPrompt,
 		credPrompt,
+		computePrompt,
+		agentRunConversation,
 		conversationId,
 		rest,
 		goTo,
@@ -11244,7 +12568,9 @@ function ChatScreen({ agent, conversation }) {
 				rest,
 				agentSelector: null,
 				conversationId: target,
-				newConversation: false
+				newConversation: false,
+				defaultAgentSelector: null,
+				forceOnboarding: false
 			}));
 		} catch (err) {
 			setItems((prev) => [...prev, {
@@ -11283,19 +12609,24 @@ function ChatScreen({ agent, conversation }) {
 		if (!portalClient) return;
 		const agentName = agent.name;
 		setPortalPrompt(null);
-		portalClient.grantAgent(agent.id).then(() => useStore.getState().showToast({
+		grantInFlightRef.current.add(agent.id);
+		portalClient.grantAgent(agent.id, conversationId).then(() => useStore.getState().showToast({
 			variant: "success",
 			message: `shared this machine with ${agentName}`
-		})).catch((err) => setItems((prev) => [...prev, {
-			kind: "error",
-			id: crypto.randomUUID(),
-			text: `couldn't share machine: ${errorDetail(err)}`
-		}]));
+		})).catch((err) => {
+			grantInFlightRef.current.delete(agent.id);
+			setItems((prev) => [...prev, {
+				kind: "error",
+				id: crypto.randomUUID(),
+				text: `couldn't share machine: ${errorDetail(err)}`
+			}]);
+		});
 	}, [
 		portalClient,
 		agent.id,
 		agent.name,
-		setPortalPrompt
+		setPortalPrompt,
+		conversationId
 	]);
 	const declineGrant = useCallback(() => {
 		declinedRef.current.add(agent.id);
@@ -11408,7 +12739,15 @@ function ChatScreen({ agent, conversation }) {
 				case "conversation-picker":
 					leaveForScreen({
 						kind: "conversation-picker",
-						agent
+						agent,
+						initialQuery: ""
+					});
+					break;
+				case "conversation-search":
+					leaveForScreen({
+						kind: "conversation-picker",
+						agent,
+						initialQuery: routed.query
 					});
 					break;
 				case "open-conversation":
@@ -11438,6 +12777,9 @@ function ChatScreen({ agent, conversation }) {
 						})
 					}]);
 					break;
+				case "computer":
+					runComputerStats();
+					break;
 				case "plan": {
 					if (!(!!todos && todos.length > 0)) {
 						useStore.getState().showToast({ message: "no plan to show yet" });
@@ -11490,6 +12832,7 @@ function ChatScreen({ agent, conversation }) {
 		history,
 		runLocalShell,
 		runSandboxExec,
+		runComputerStats,
 		runSandboxPty,
 		archiveConversation,
 		renameConversation,
@@ -11535,6 +12878,7 @@ function ChatScreen({ agent, conversation }) {
 		if (portal.grantedAgentIds.includes(agent.id)) return;
 		if (portal.declinedAgentIds.includes(agent.id)) return;
 		if (declinedRef.current.has(agent.id)) return;
+		if (grantInFlightRef.current.has(agent.id)) return;
 		if (portal.prompt?.agentId === agent.id) return;
 		setPortalPrompt({
 			agentId: agent.id,
@@ -11558,6 +12902,14 @@ function ChatScreen({ agent, conversation }) {
 		setPortalPrompt,
 		agentHost
 	]);
+	useEffect(() => {
+		for (const agentId of portal.grantedAgentIds) grantInFlightRef.current.delete(agentId);
+		if (portal.prompt && portal.grantedAgentIds.includes(portal.prompt.agentId)) setPortalPrompt(null);
+	}, [
+		portal.grantedAgentIds,
+		portal.prompt,
+		setPortalPrompt
+	]);
 	useKeyboard((key) => {
 		if (reviewOpen) {
 			if (key.name === "g" && key.ctrl) {
@@ -11581,6 +12933,20 @@ function ChatScreen({ agent, conversation }) {
 				return;
 			}
 		}
+		if (computePrompt) {
+			if (key.name === "y") {
+				decideCompute(computePrompt, "approve");
+				return;
+			}
+			if (key.name === "n") {
+				decideCompute(computePrompt, "deny");
+				return;
+			}
+			if (key.name === "escape") {
+				setComputePrompt(null);
+				return;
+			}
+		}
 		if (credPrompt) {
 			if (key.name === "escape") {
 				if (!credPrompt.submitting) setCredPrompt(null);
@@ -11736,21 +13102,51 @@ function ChatScreen({ agent, conversation }) {
 				useStore.getState().showToast({ message: `${agent.name} keeps working; reopen to reattach` });
 				goTo({
 					kind: "conversation-picker",
-					agent
+					agent,
+					initialQuery: ""
 				});
 				return;
 			}
 			if (runRef.current.kind === "idle") goTo({
 				kind: "conversation-picker",
-				agent
+				agent,
+				initialQuery: ""
 			});
 		}
 	});
 	const hasPendingSteer = items.some((m) => m.kind === "pending-steer");
+	const latestComputerId = useMemo(() => {
+		for (let i = items.length - 1; i >= 0; i--) {
+			const item = items[i];
+			if (item && item.kind === "computer") return item.id;
+		}
+		return null;
+	}, [items]);
+	const boundCollectSandboxStats = useMemo(() => {
+		if (!appUrl || !sessionToken) return null;
+		return () => collectSandboxStats({
+			appUrl,
+			sessionToken,
+			agentId: agent.id
+		});
+	}, [
+		appUrl,
+		sessionToken,
+		agent.id
+	]);
 	const conversationContext = useMemo(() => ({
 		rest,
-		conversationId
-	}), [rest, conversationId]);
+		conversationId,
+		collectSandboxStats: boundCollectSandboxStats,
+		latestComputerId,
+		scrolledUp
+	}), [
+		rest,
+		conversationId,
+		boundCollectSandboxStats,
+		latestComputerId,
+		scrolledUp
+	]);
 	const actionableCards = useMemo(() => items.filter(isActionableCard), [items]);
 	const statusText = useMemo(() => formatChatFooterStatus({
 		runKind: run.kind,
@@ -11899,13 +13295,11 @@ function ChatScreen({ agent, conversation }) {
 					children: [!historyLoaded ? /* @__PURE__ */ jsx("text", {
 						fg: theme.muted,
 						children: "loading history…"
-					}) : items.length === 0 ? /* @__PURE__ */ jsxs("text", {
-						fg: theme.muted,
-						children: [
-							"say hello to ",
-							agent.name,
-							" below."
-						]
+					}) : items.length === 0 ? /* @__PURE__ */ jsx(NewChatSplash, {
+						agentName: agent.name,
+						agentTitle: agent.title ?? null,
+						width: reviewView && reviewPlacement === "side" ? Math.max(1, bodyWidth - reviewWidth - 1) : bodyWidth,
+						height: Math.max(1, scrollHeight - 1)
 					}) : /* @__PURE__ */ jsxs(Fragment, { children: [transcriptWindow.hiddenCount > 0 ? /* @__PURE__ */ jsx("box", {
 						style: {
 							paddingLeft: 1,
@@ -11948,6 +13342,12 @@ function ChatScreen({ agent, conversation }) {
 					children: ["  ", "end"]
 				})]
 			}) : null,
+			/* @__PURE__ */ jsx(SubagentCardView, {
+				items: subagentItems,
+				isActive: run.kind !== "idle",
+				onHeightChange: setSubagentRows,
+				onBatchLiveChange: setAnchoredBatchLive
+			}),
 			todoCardVisible && todos ? /* @__PURE__ */ jsx(TodoCardView, {
 				todos,
 				isActive: run.kind !== "idle"
@@ -12040,6 +13440,46 @@ function ChatScreen({ agent, conversation }) {
 						children: "n"
 					})
 				]
+			}) : computePrompt ? /* @__PURE__ */ jsxs("box", {
+				style: {
+					border: true,
+					borderColor: theme.warning,
+					paddingLeft: 1,
+					paddingRight: 1,
+					height: computePromptHeight,
+					flexShrink: 0,
+					marginTop: 1,
+					flexDirection: "column"
+				},
+				children: [/* @__PURE__ */ jsx("text", {
+					fg: theme.warning,
+					children: computePrompt.summary ?? "more compute requested"
+				}), /* @__PURE__ */ jsxs("text", { children: [
+					/* @__PURE__ */ jsx("span", {
+						fg: theme.success,
+						children: "y"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: theme.muted,
+						children: " upgrade / "
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: theme.error,
+						children: "n"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: theme.muted,
+						children: " keep current / "
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: theme.dim,
+						children: "esc"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: theme.muted,
+						children: " later"
+					})
+				] })]
 			}) : nonWebChannel ? /* @__PURE__ */ jsxs("box", {
 				style: {
 					border: true,
@@ -12336,13 +13776,16 @@ function ToastView() {
 		return () => clearTimeout(handle);
 	}, [toast, dismissToast]);
 	if (!toast) return null;
+	const cap = Math.min(60, Math.max(20, width - 6));
+	const chrome = 4;
+	const contentWidth = Math.max(...toast.message.split("\n").map((line) => Bun.stringWidth(line)));
 	return /* @__PURE__ */ jsx("box", {
 		style: {
 			position: "absolute",
 			top: 1,
 			right: 1,
 			zIndex: 100,
-			maxWidth: Math.min(60, Math.max(20, width - 6)),
+			width: Math.min(cap, contentWidth + chrome),
 			border: true,
 			borderColor: toastColor(toast.variant),
 			backgroundColor: theme.surface ?? "#1a1a1a",
@@ -12359,9 +13802,12 @@ function ToastView() {
 
 //#endregion
 //#region src/chat/tui/app.tsx
-function App({ appUrl, sessionToken, authKind, shareMachine, promptHistoryPath, notifications, agentSelector, conversationId, newConversation }) {
+function App({ appUrl, sessionToken, authKind, workspaceId, shareMachine, promptHistoryPath, notifications, agentSelector, conversationId, newConversation, defaultAgentSelector, forceOnboarding }) {
 	const renderer = useRenderer();
 	const screen = useStore((s) => s.screen);
+	useEffect(() => {
+		if (screen.kind === "chat") recordDefaultAgent(screen.agent.id);
+	}, [screen]);
 	const chatTitle = useStore((s) => s.chatTitle);
 	useStore((s) => s.themeId);
 	const rest = useStore((s) => s.rest);
@@ -12429,7 +13875,8 @@ function App({ appUrl, sessionToken, authKind, shareMachine, promptHistoryPath,
 	useEffect(() => {
 		const rest = createRestClient({
 			appUrl,
-			sessionToken
+			sessionToken,
+			workspaceId
 		});
 		setClients({
 			appUrl,
@@ -12444,7 +13891,9 @@ function App({ appUrl, sessionToken, authKind, shareMachine, promptHistoryPath,
 					rest,
 					agentSelector,
 					conversationId,
-					newConversation: newConversation || useStore.getState().seedPrompt !== null
+					newConversation: newConversation || useStore.getState().seedPrompt !== null,
+					defaultAgentSelector,
+					forceOnboarding
 				});
 				if (cancelled) return;
 				goTo(screen);
@@ -12463,10 +13912,13 @@ function App({ appUrl, sessionToken, authKind, shareMachine, promptHistoryPath,
 	}, [
 		appUrl,
 		sessionToken,
+		workspaceId,
 		promptHistoryPath,
 		agentSelector,
 		conversationId,
 		newConversation,
+		defaultAgentSelector,
+		forceOnboarding,
 		goTo,
 		setClients,
 		fail
@@ -12507,6 +13959,7 @@ function App({ appUrl, sessionToken, authKind, shareMachine, promptHistoryPath,
 						screen.kind === "error" && /* @__PURE__ */ jsx(ErrorScreen, { message: screen.message }),
 						screen.kind === "agent-picker" && rest && /* @__PURE__ */ jsx(AgentPickerScreen, {}),
 						screen.kind === "agent-create" && rest && /* @__PURE__ */ jsx(AgentCreateScreen, {}),
+						screen.kind === "first-run" && rest && /* @__PURE__ */ jsx(FirstRunScreen, {}),
 						screen.kind === "workspace-picker" && /* @__PURE__ */ jsx(WorkspacePicker, {
 							appUrl,
 							sessionToken,
@@ -12516,7 +13969,10 @@ function App({ appUrl, sessionToken, authKind, shareMachine, promptHistoryPath,
 								goTo({ kind: "agent-picker" });
 							}
 						}),
-						screen.kind === "conversation-picker" && rest && /* @__PURE__ */ jsx(ConversationPickerScreen, { agent: screen.agent }),
+						screen.kind === "conversation-picker" && rest && /* @__PURE__ */ jsx(ConversationPickerScreen, {
+							agent: screen.agent,
+							initialQuery: screen.initialQuery
+						}),
 						screen.kind === "chat" && rest && /* @__PURE__ */ jsx(ChatScreen, {
 							agent: screen.agent,
 							conversation: screen.conversation
@@ -13045,7 +14501,7 @@ function onRenderCommit(id, phase, actualDuration, baseDuration, startTime, comm
 * 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, authKind = "session", shareMachine, promptHistoryPath, theme: themeOverride, notifications, agentSelector, conversationId, newConversation, seedPrompt }) {
+async function runChat({ appUrl, sessionToken, authKind = "session", workspaceId, shareMachine, promptHistoryPath, theme: themeOverride, notifications, agentSelector, conversationId, newConversation, defaultAgentSelector, forceOnboarding, seedPrompt }) {
 	await registerGrammars();
 	const watchdog = startMemoryWatchdog();
 	installCrashHandler({ memoryProvider: () => watchdog.snapshot() });
@@ -13060,7 +14516,8 @@ async function runChat({ appUrl, sessionToken, authKind = "session", shareMachin
 		authKind,
 		seedPrompt: seedPrompt ?? null,
 		autoGrantMachine: Boolean(seedPrompt && shareMachine),
-		newConversationIntent: newConversation
+		newConversationIntent: newConversation,
+		forcedOnboarding: forceOnboarding
 	});
 	const store = useStore.getState();
 	if (noColorRequested()) {
@@ -13081,12 +14538,15 @@ async function runChat({ appUrl, sessionToken, authKind = "session", shareMachin
 			appUrl,
 			sessionToken,
 			authKind,
+			workspaceId,
 			shareMachine,
 			promptHistoryPath,
 			notifications,
 			agentSelector: agentSelector ?? null,
 			conversationId: conversationId ?? null,
-			newConversation
+			newConversation,
+			defaultAgentSelector: defaultAgentSelector ?? null,
+			forceOnboarding
 		})
 	}));
 }