skydive-cli 0.5.0-beta.2 → 0.5.0-beta.21

package/dist/js/{boot-DFYFjlht.mjs → boot-DcQhJadu.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-y43HVmq7.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 setActiveWorkspace, C as themesForMode, D as getActiveWorkspaceId, 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 listWorkspaces, 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 } from "./profiler-Bl25cyUp.mjs";
+import { D as getReviewStateDir, H as saveTheme, N as recordDefaultAgent, O as getSavedTheme, 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, z as resolveWebUrl } from "./print-OvYyj6Uk.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-Dx6b-Nq_.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-Dj9tGT12.mjs";
+import "./api-DG5W6iwx.mjs";
+import { t as SandboxStream } from "./client-c4c5MmgN.mjs";
+import { t as PortalDaemonClient } from "./daemon-client-BNK77jX_.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,66 @@ 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
+		};
 	}
-	const agent = resolveAgent(agents, agentSelector);
-	if (newConversation) return {
+	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(await rest.listAgents({
+		scope: "org",
+		onPage: null
+	}), agentSelector);
+	if (newConversation) return newChat(agent);
+	return {
+		kind: "conversation-picker",
+		agent
+	};
+}
+function newChat(agent) {
+	return {
 		kind: "chat",
 		agent,
 		conversation: {
@@ -290,10 +353,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 +394,8 @@ function createPortalClient(opts) {
 				deviceToken: null
 			}),
 			resolveCwd: () => process.cwd(),
+			persistedMachineName: null,
+			onMachineName: () => {},
 			onState: (state) => opts.onState({
 				status: state.status,
 				machineName: state.machineName,
@@ -337,7 +409,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 +1088,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 +1253,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 +1290,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 +1299,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 +1648,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 +1819,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 +1836,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 +1928,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 +1947,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 +1960,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 +1984,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) => {
@@ -1832,7 +2016,10 @@ function FilterableAgentList({ agents, scope, onPick }) {
 			flexGrow: 1
 		},
 		children: [
-			/* @__PURE__ */ jsx(BrandHeader, { height }),
+			/* @__PURE__ */ jsx(BrandHeader, {
+				height,
+				width
+			}),
 			/* @__PURE__ */ jsxs("box", {
 				style: {
 					flexDirection: "row",
@@ -2071,6 +2258,208 @@ function AgentCreateScreen() {
 	});
 }
 
+//#endregion
+//#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 () => {
+			try {
+				const agent = await rest.createAgent({});
+				if (cancelled) return;
+				setState({
+					kind: "offer",
+					agent
+				});
+			} 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: createErrorMessage(err)
+				});
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [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
+				}
+			}
+		});
+	};
+	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 }) {
@@ -2419,15 +2808,80 @@ 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"
 ];
+/**
+* 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 }) {
 	const rest = useStore((s) => s.rest);
 	const goTo = useStore((s) => s.goTo);
@@ -2492,13 +2946,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,7 +2965,10 @@ 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]
 		})]
@@ -2615,6 +3075,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 +3089,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 +3098,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 +3183,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 +3203,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",
@@ -2779,15 +3247,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]
@@ -4173,7 +4646,10 @@ function parseMatches(output) {
 //#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);
@@ -4493,6 +4969,329 @@ function ShellLocalItem({ item }) {
 	});
 }
 
+//#endregion
+//#region src/chat/tui/chat/sandbox-stats.ts
+/**
+* `/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.
+*/
+const SANDBOX_STATS_SENTINEL = "SKYDIVE_STATS_V1";
+/**
+* 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.
+*/
+const COMPUTER_POLL_INTERVAL_MS = 3e4;
+/**
+* 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 shouldPollComputer(opts) {
+	return opts.isLatest && opts.canCollect && !opts.scrolledUp;
+}
+/**
+* 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.
+*/
+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]\\+$')"`
+].join(" ; ");
+const KB = 1024;
+/**
+* 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();
+	for (const line of raw.slice(start).split("\n")) {
+		const tab = line.indexOf("	");
+		if (tab === -1) continue;
+		fields.set(line.slice(0, tab).trim(), 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)
+	};
+}
+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);
+}
+
+//#endregion
+//#region src/chat/tui/chunks/computer.tsx
+/**
+* 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).
+*
+* 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 (!live || !collectSandboxStats) return;
+		let cancelled = false;
+		let timer = null;
+		let inFlight = null;
+		const tick = async () => {
+			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();
+		};
+	}, [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 labelWidth = Math.max(...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__ */ 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", {
+			fg: theme.muted,
+			children: [/* @__PURE__ */ jsx("b", { children: "computer" }), /* @__PURE__ */ jsx("span", {
+				fg: theme.dim,
+				children: " · agent sandbox"
+			})]
+		}), children]
+	});
+}
+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}`
+		})
+	] });
+}
+
 //#endregion
 //#region src/chat/tui/chunks/index.tsx
 /**
@@ -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", {
@@ -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": {
@@ -5518,7 +6325,7 @@ function uiMessagesToItems(messages) {
 				kind: "user",
 				id: m.id,
 				text,
-				...attachments.length > 0 ? { attachments } : {}
+				attachments
 			});
 			continue;
 		}
@@ -5969,6 +6776,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 +6885,58 @@ 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/prompt-history.ts
 /**
@@ -6773,6 +7691,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"],
@@ -9967,6 +10892,7 @@ function routeInput(raw) {
 			case "model-picker":
 			case "theme-picker":
 			case "status":
+			case "computer":
 			case "share":
 			case "browser":
 			case "connect":
@@ -10034,47 +10960,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 +11044,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,
@@ -10222,6 +11109,8 @@ function ChatScreen({ agent, conversation }) {
 	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);
@@ -10271,13 +11160,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);
 	}, []);
@@ -10358,10 +11250,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 +11283,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 +11304,7 @@ function ChatScreen({ agent, conversation }) {
 			agentHost.addPullRequest(pr);
 		});
 		const streamAgentName = runAgentName ?? agent.name;
+		let sawErrorChunk = false;
 		setRun((prev) => ({
 			kind: "streaming",
 			runId,
@@ -10411,6 +11316,7 @@ 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 === "data-anyone-todos-updated") {
@@ -10428,7 +11334,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 +11342,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 +11368,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 +11422,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 +11471,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 +11519,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"
@@ -10678,9 +11590,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,7 +11656,8 @@ function ChatScreen({ agent, conversation }) {
 		appUrl,
 		updateCard,
 		portalClient,
-		portal.status
+		portal.status,
+		setPortalPrompt
 	]);
 	const promptForCards = useCallback(() => {
 		const targets = itemsRef.current.filter(isActionableCard);
@@ -10905,6 +11821,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({
@@ -11066,7 +11992,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]);
@@ -11135,6 +12062,10 @@ function ChatScreen({ agent, conversation }) {
 	]);
 	const archiveConversation = useCallback(() => {
 		if (grantPrompt || credPrompt) 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;
@@ -11163,6 +12094,7 @@ function ChatScreen({ agent, conversation }) {
 	}, [
 		grantPrompt,
 		credPrompt,
+		agentRunConversation,
 		conversationId,
 		rest,
 		goTo,
@@ -11244,7 +12176,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 +12217,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);
@@ -11438,6 +12377,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 +12432,7 @@ function ChatScreen({ agent, conversation }) {
 		history,
 		runLocalShell,
 		runSandboxExec,
+		runComputerStats,
 		runSandboxPty,
 		archiveConversation,
 		renameConversation,
@@ -11535,6 +12478,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 +12502,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) {
@@ -11747,10 +12699,38 @@ function ChatScreen({ agent, conversation }) {
 		}
 	});
 	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 +12879,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,
@@ -12359,9 +13337,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, 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);
@@ -12444,7 +13425,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);
@@ -12467,6 +13450,8 @@ function App({ appUrl, sessionToken, authKind, shareMachine, promptHistoryPath,
 		agentSelector,
 		conversationId,
 		newConversation,
+		defaultAgentSelector,
+		forceOnboarding,
 		goTo,
 		setClients,
 		fail
@@ -12507,6 +13492,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,
@@ -13045,7 +14031,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", shareMachine, promptHistoryPath, theme: themeOverride, notifications, agentSelector, conversationId, newConversation, defaultAgentSelector, forceOnboarding, seedPrompt }) {
 	await registerGrammars();
 	const watchdog = startMemoryWatchdog();
 	installCrashHandler({ memoryProvider: () => watchdog.snapshot() });
@@ -13060,7 +14046,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()) {
@@ -13086,7 +14073,9 @@ async function runChat({ appUrl, sessionToken, authKind = "session", shareMachin
 			notifications,
 			agentSelector: agentSelector ?? null,
 			conversationId: conversationId ?? null,
-			newConversation
+			newConversation,
+			defaultAgentSelector: defaultAgentSelector ?? null,
+			forceOnboarding
 		})
 	}));
 }