zidane 7.2.4 → 8.0.4

package/dist/{turn-operations-DrbJlpq9.js → tool-formatters-IQFDrdrs.js}

@@ -1,1555 +1,67 @@
-import { _ as resolveOldString, y as styleReplacementForVia } from "./panels-B6gRk4bf.js";
+import { i as readFileInputPaths, t as formatBytes } from "./format-bytes-C7tfc3Zm.js";
+import { a as fmtTokens, c as formatElapsed, d as previewLine, f as shortId, s as formatDuration, t as ageString } from "./format-C2NQEVUH.js";
 import { r as utf8ByteLength } from "./utils-ngQzYzZD.js";
-import { a as formatDuration, i as fmtTokens, l as shortId, t as ageString } from "./format-BF745pLL.js";
-import { t as escapeXml } from "./xml-D5HBhJle.js";
 import { t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
-import { a as searchHighlightRanges } from "./history-search-C4bk1Wz_.js";
+import { _ as shortSessionId } from "./orchestration-BCGmB8Ps.js";
+import { a as searchHighlightRanges } from "./history-search-CcYzF8-0.js";
 import { Fzf } from "fzf";
-//#region src/chat/completion-chats.ts
-const CHATS_TRIGGER = "#";
-const DEFAULT_RESULT_LIMIT$1 = 50;
-const MIN_TOKEN_LENGTH = 6;
-function normalizeId(id) {
-	return id.replace(/-/g, "").toLowerCase();
-}
-function projectLabel(projectRoot) {
-	if (!projectRoot) return "";
-	const parts = projectRoot.split(/[\\/]/).filter(Boolean);
-	return parts[parts.length - 1] ?? projectRoot;
-}
+//#region src/chat/todo-glyphs.ts
+const TODO_STATUS_GLYPHS = {
+	pending: "☐",
+	in_progress: "◐",
+	completed: "☑",
+	cancelled: "☒"
+};
+//#endregion
+//#region src/chat/agent-accent.ts
 /**
-* Per-catalog memo for `tokenFor`, keyed on catalog reference identity.
-* Token derivation is O(catalog) per id, and both `suggest()` (every
-* keystroke) and `parseReferences()` (every submit/highlight pass) need
-* a token for EVERY entry — quadratic over catalogs that can reach
-* thousands of sessions. The catalog getters return a stable array until
-* a refresh swaps it, so a WeakMap invalidates exactly when it should.
+* Resolve a profile's `accent` token to a concrete hex color via the
+* caller's color palette. Renderer-agnostic — accepts the four-role
+* subset of `ThemeColors` that's relevant to accent surfaces, so this
+* helper composes against either `useColors()` (TUI) or a CSS-variable
+* lookup (GUI). Omitted / unknown tokens fall back to `accent`.
 */
-const tokensByCatalog = /* @__PURE__ */ new WeakMap();
-function catalogTokens(catalog) {
-	let cached = tokensByCatalog.get(catalog);
-	if (!cached) {
-		cached = {
-			normalizedIds: catalog.map((entry) => normalizeId(entry.id)),
-			tokens: /* @__PURE__ */ new Map()
-		};
-		tokensByCatalog.set(catalog, cached);
-	}
-	return cached;
-}
-function tokenFor(id, catalog) {
-	const { normalizedIds, tokens } = catalogTokens(catalog);
-	const known = tokens.get(id);
-	if (known !== void 0) return known;
-	const normalized = normalizeId(id);
-	let result;
-	for (let len = Math.min(MIN_TOKEN_LENGTH, normalized.length); len <= normalized.length; len++) {
-		const token = normalized.slice(0, len);
-		if (normalizedIds.filter((candidate) => candidate.startsWith(token)).length === 1) {
-			result = token;
-			break;
-		}
-	}
-	result ??= normalized || shortId(id);
-	tokens.set(id, result);
-	return result;
-}
-function stripTrailingPunctuation(candidate) {
-	return candidate.replace(/[.,;:)\]}!?]+$/, "");
-}
-function descriptionFor(entry, token, scope) {
-	const bits = [
-		`#${token}`,
-		ageString(entry.updatedAt),
-		`${entry.userMessageCount} msg${entry.userMessageCount === 1 ? "" : "s"}`
-	];
-	if ((entry.artifactCount ?? 0) > 0) bits.push(`${entry.artifactCount} artifact${entry.artifactCount === 1 ? "" : "s"}`);
-	const project = projectLabel(entry.projectRoot);
-	if (scope === "all" && project) bits.push(project);
-	return bits.join(" · ");
-}
-function scoreChats(catalog, tokenCatalog, query, limit, scope) {
-	const q = query.trim().toLowerCase();
-	const rows = catalog.map((entry) => ({
-		entry,
-		token: tokenFor(entry.id, tokenCatalog),
-		project: projectLabel(entry.projectRoot)
-	}));
-	const fuzzyHits = q.length > 0 ? new Set(new Fzf(rows, {
-		selector: (r) => `${r.entry.title} ${r.token} ${r.project}`,
-		casing: "case-insensitive"
-	}).find(q).map((r) => r.item)) : null;
-	const scored = [];
-	for (const row of rows) {
-		const title = row.entry.title.toLowerCase();
-		const token = row.token.toLowerCase();
-		const project = row.project.toLowerCase();
-		if (q.length === 0) {
-			scored.push({
-				entry: row.entry,
-				token: row.token,
-				rank: 5
-			});
-			continue;
-		}
-		if (token.startsWith(q)) {
-			scored.push({
-				entry: row.entry,
-				token: row.token,
-				rank: 0
-			});
-			continue;
-		}
-		if (title.startsWith(q)) {
-			scored.push({
-				entry: row.entry,
-				token: row.token,
-				rank: 1
-			});
-			continue;
-		}
-		if (title.includes(q)) {
-			scored.push({
-				entry: row.entry,
-				token: row.token,
-				rank: 2
-			});
-			continue;
-		}
-		if (project.includes(q)) {
-			scored.push({
-				entry: row.entry,
-				token: row.token,
-				rank: 3
-			});
-			continue;
-		}
-		if (fuzzyHits?.has(row)) scored.push({
-			entry: row.entry,
-			token: row.token,
-			rank: 4
-		});
-	}
-	scored.sort((a, b) => {
-		if (a.rank !== b.rank) return a.rank - b.rank;
-		return b.entry.updatedAt - a.entry.updatedAt;
-	});
-	return scored.slice(0, limit).map(({ entry, token }) => ({
-		id: token,
-		label: entry.title,
-		description: descriptionFor(entry, token, scope),
-		insertText: `#${token} `,
-		data: {
-			entry,
-			token
-		}
-	}));
-}
-function createChatsCompletionProvider(opts) {
-	const limit = opts.limit ?? DEFAULT_RESULT_LIMIT$1;
-	const scope = () => opts.getScope?.() ?? "project";
-	return {
-		id: "chats",
-		trigger: "#",
-		label: "Chats",
-		suggest(query) {
-			const current = opts.getCatalog();
-			const tokenCatalog = opts.getReferenceCatalog?.() ?? current;
-			const effectiveTokenCatalog = tokenCatalog.length > 0 ? tokenCatalog : current;
-			if (current.length > 0) return scoreChats(current, effectiveTokenCatalog, query, limit, scope());
-			if (opts.ensureCatalog) return opts.ensureCatalog().then((loaded) => {
-				const refreshed = opts.getReferenceCatalog?.() ?? loaded;
-				return scoreChats(loaded, refreshed.length > 0 ? refreshed : loaded, query, limit, scope());
-			});
-			return [];
-		},
-		parseReferences(text, _ctx) {
-			const catalog = opts.getReferenceCatalog?.() ?? opts.getCatalog();
-			if (catalog.length === 0) return [];
-			const byToken = /* @__PURE__ */ new Map();
-			for (const entry of catalog) {
-				const token = tokenFor(entry.id, catalog);
-				byToken.set(token, {
-					entry,
-					token
-				});
-			}
-			const refs = [];
-			for (const m of text.matchAll(/(^|\s)#(\S+)/g)) {
-				const candidate = stripTrailingPunctuation(m[2]);
-				const data = byToken.get(candidate.toLowerCase());
-				if (!data) continue;
-				const start = m.index + m[1].length;
-				refs.push({
-					providerId: "chats",
-					start,
-					end: start + 1 + candidate.length,
-					itemId: data.entry.id,
-					data
-				});
-			}
-			return refs;
-		}
-	};
-}
-function uniqueChatIdsFromReferences(references) {
-	const out = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const ref of references) {
-		if (ref.providerId !== "chats") continue;
-		if (seen.has(ref.itemId)) continue;
-		seen.add(ref.itemId);
-		out.push(ref.itemId);
-	}
-	return out;
-}
-function chatReferenceTokensFromText(text) {
-	const out = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const m of text.matchAll(/(^|\s)#(\S+)/g)) {
-		const token = stripTrailingPunctuation(m[2]).toLowerCase();
-		if (!token || seen.has(token)) continue;
-		seen.add(token);
-		out.push(token);
+function accentColor(accent, COLOR) {
+	switch (accent) {
+		case "brand": return COLOR.brand;
+		case "warn": return COLOR.warn;
+		case "model": return COLOR.model;
+		default: return COLOR.accent;
 	}
-	return out;
 }
 //#endregion
-//#region src/chat/edit-approval.ts
+//#region src/chat/turn-selection.ts
+/** Tools whose `tool-result` event is suppressed when `showEditDiffs` is on. */
+const EDIT_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"edit",
+	"multi_edit",
+	"write_file"
+]);
 /**
-* Convert a per-hunk approval mask into an `EditOutcome[]`. `true` →
-* `applied`; `false` → `denied` with the supplied reason.
-*
-* Length is `Math.max(mask.length, fallbackLength)` so callers passing a
-* shorter mask still get a fully-populated array — missing entries
-* default to applied, matching the "no decision => keep" convention.
+* Keep turn-selection mode alive after deleting its active row. Prefer the
+* row that slides into the deleted index; at the tail, select the new last
+* row. Returns null only when no selectable rows survive.
 */
-function maskToOutcomeKinds(mask, fallbackLength, deniedReason = "denied by user") {
-	const len = Math.max(mask.length, fallbackLength);
-	const out = [];
-	for (let i = 0; i < len; i++) {
-		const keep = i < mask.length ? mask[i] : true;
-		out.push(keep ? { kind: "applied" } : {
-			kind: "denied",
-			reason: deniedReason
-		});
-	}
-	return out;
-}
-function resolveApprovalForPayload(decision, payload) {
-	const total = payload.hunks.length;
-	if (decision === "deny") {
-		const outcomes = Array.from({ length: total }, () => ({
-			kind: "denied",
-			reason: "denied by user"
-		}));
-		return {
-			outcomes,
-			shouldBlock: true,
-			syntheticEvent: {
-				...payload,
-				outcomes
-			}
-		};
-	}
-	if (typeof decision === "object" && decision.kind === "partial") {
-		const outcomes = maskToOutcomeKinds(decision.mask, total);
-		return {
-			outcomes,
-			shouldBlock: !outcomes.some((o) => o.kind === "applied"),
-			syntheticEvent: {
-				...payload,
-				outcomes
-			}
-		};
-	}
-	return {
-		outcomes: Array.from({ length: total }, () => ({ kind: "applied" })),
-		shouldBlock: false,
-		syntheticEvent: null
-	};
-}
-/** Sentinel tags used by {@link buildEditOutcomesAnnotation} / parser. */
-const ANNOTATION_OPEN = "<edit-outcomes>";
-const ANNOTATION_CLOSE = "</edit-outcomes>";
-const OUTCOME_KIND_RE = /^applied|denied|skipped|failed$/;
-const OUTCOME_LINE_RE = /^#(\d+) (applied|denied|skipped|failed)(?:: ?(.*))?$/;
-/**
-* Render an `EditOutcome[]` as the wire-format annotation block. Returns
-* the body to APPEND to a tool result; callers join with a leading
-* `\n\n` separator. Idempotent on missing reasons — bare `applied` lines
-* stay terse.
-*/
-function buildEditOutcomesAnnotation(outcomes) {
-	const lines = [ANNOTATION_OPEN];
-	for (let i = 0; i < outcomes.length; i++) {
-		const o = outcomes[i];
-		if (!OUTCOME_KIND_RE.test(o.kind)) continue;
-		const reason = o.reason ? `: ${o.reason}` : "";
-		lines.push(`#${i + 1} ${o.kind}${reason}`);
-	}
-	lines.push(ANNOTATION_CLOSE);
-	return lines.join("\n");
+function selectionAfterTurnRemoval(before, removedId, after) {
+	if (after.includes(removedId)) return removedId;
+	if (after.length === 0) return null;
+	const index = before.indexOf(removedId);
+	return after[Math.min(Math.max(0, index), after.length - 1)] ?? null;
 }
 /**
-* Parse an `<edit-outcomes>…</edit-outcomes>` annotation block out of a
-* tool result body. Returns the outcomes keyed by 1-based hunk index, or
-* `null` when the block is missing / malformed.
-*
-* Anchored on the explicit tag pair so the parser doesn't false-positive
-* on natural prose that happens to contain `#1 applied`.
-*/
-function parseEditOutcomesFromResult(result) {
-	const text = typeof result === "string" ? result : result.filter((b) => b.type === "text").map((b) => b.text).join("\n");
-	if (!text) return null;
-	const openIdx = text.indexOf(`\n${ANNOTATION_OPEN}\n`);
-	const startIdx = openIdx >= 0 ? openIdx + 1 : text.startsWith(`${ANNOTATION_OPEN}\n`) ? 0 : -1;
-	if (startIdx < 0) return null;
-	const closeNeedle = `\n${ANNOTATION_CLOSE}`;
-	const closeIdx = text.indexOf(closeNeedle, startIdx);
-	if (closeIdx < 0) return null;
-	const body = text.slice(startIdx + 15 + 1, closeIdx);
-	const found = [];
-	for (const line of body.split("\n")) {
-		if (line.length === 0) continue;
-		const m = OUTCOME_LINE_RE.exec(line);
-		if (!m) return null;
-		const idx = Number.parseInt(m[1], 10);
-		if (!Number.isFinite(idx) || idx < 1) return null;
-		const kind = m[2];
-		const reason = m[3]?.trim();
-		found.push({
-			idx,
-			outcome: {
-				kind,
-				...reason ? { reason } : {}
-			}
-		});
-	}
-	if (found.length === 0) return null;
-	const maxIdx = Math.max(...found.map((f) => f.idx));
-	const outcomes = Array.from({ length: maxIdx }, () => ({ kind: "applied" }));
-	for (const { idx, outcome } of found) outcomes[idx - 1] = outcome;
-	return outcomes;
-}
-/**
-* Strip the first `<edit-outcomes>…</edit-outcomes>` block out of a tool
-* result body, returning the surrounding text. Used by the
-* `tool:transform` hook to peel a body-emitted annotation before
-* re-appending the merged (approval ∪ body) version — otherwise the
-* result would carry two annotation blocks and
-* {@link parseEditOutcomesFromResult} would only see the first.
+* Recognize a tool-result body as carrying NON-success information so the
+* renderer doesn't suppress it under `showEditDiffs`. Three categories:
 *
-* Anchored on the same `\n<edit-outcomes>\n` / start-of-string newline
-* shape the parser uses, so prose that incidentally mentions
-* `<edit-outcomes>` (e.g. a model summarizing its own format) isn't
-* mistakenly stripped. Trims a single leading `\n\n` separator when
-* present so successive strips don't leave dangling blank lines.
-* Idempotent on inputs that don't contain a properly-anchored block.
-*/
-function stripEditOutcomesAnnotation(text) {
-	const newlineNeedle = `\n${ANNOTATION_OPEN}\n`;
-	const newlineIdx = text.indexOf(newlineNeedle);
-	let openIdx;
-	if (newlineIdx >= 0) openIdx = newlineIdx + 1;
-	else if (text.startsWith(`${ANNOTATION_OPEN}\n`)) openIdx = 0;
-	else return text;
-	const closeIdx = text.indexOf(ANNOTATION_CLOSE, openIdx);
-	if (closeIdx < 0) return text;
-	const blockEnd = closeIdx + 16;
-	const sepStart = openIdx >= 2 && text.slice(openIdx - 2, openIdx) === "\n\n" ? openIdx - 2 : openIdx;
-	return text.slice(0, sepStart) + text.slice(blockEnd);
-}
-/**
-* Merge body-side outcomes (keyed against the approved subset the tool
-* actually ran on, in subset-position order) into approval-side outcomes
-* (1:1 with the model's ORIGINAL `edits` list, with `denied` entries for
-* every hunk the user dropped).
-*
-* Algorithm: walk the approval array; every `applied` placeholder
-* corresponds to one approved hunk that the body ran. Consume body's
-* outcomes in order against those placeholders. Non-`applied` approval
-* entries (`denied`, `skipped`) stay untouched — they describe gate-
-* level decisions the body never saw.
-*
-* Pure. Returns a fresh array; never mutates either input.
-*
-* Edge cases:
-*  - `body` is empty / shorter than the approved count → remaining
-*    approval `applied` placeholders stay as `applied` (the body ran
-*    happily; absence of a body entry means nothing failed).
-*  - `body` longer than approved count → trailing body entries are
-*    ignored. Shouldn't happen in practice (body sees the rebound
-*    subset), but the guard keeps the merge total-pure.
-*/
-function mergeApprovalAndBodyOutcomes(approval, body) {
-	if (!body || body.length === 0) return approval.slice();
-	const out = [];
-	let bi = 0;
-	for (const entry of approval) if (entry.kind === "applied" && bi < body.length) {
-		out.push(body[bi]);
-		bi++;
-	} else out.push(entry);
-	return out;
-}
-/**
-* Rewrite a `multi_edit` body header so the totals reflect the model's
-* ORIGINAL edit list (the merged outcomes count) instead of the subset
-* the body actually saw after gate rebinding. Without this, a partially
-* approved call surfaces a misleading `applied 2 of 2 edits` (subset
-* counts) on the wire even when the original was `applied 2 of 3`.
-*
-* Three body-side shapes are handled (matching `multi_edit`'s emit):
-*   1. `Edited <path>: applied N edits (R replacements).`
-*   2. `Edited <path>: applied N of M edits (R replacements).`
-*   3. `multi_edit error: no edits applied to <path> (M attempted).`
-*
-* The replacements count is preserved verbatim — it's a body-side stat
-* the chat layer can't recompute. When the first line doesn't look like
-* any of the three shapes (e.g. an unrelated error preamble bubbled up),
-* the text is returned unchanged.
-*/
-function rewriteMultiEditHeader(text, merged, path) {
-	const newlineIdx = text.indexOf("\n");
-	const firstLine = newlineIdx < 0 ? text : text.slice(0, newlineIdx);
-	const rest = newlineIdx < 0 ? "" : text.slice(newlineIdx);
-	const successMatch = firstLine.match(/^Edited .+: applied \d+(?: of \d+)? edits? \((\d+) replacement/);
-	const isFailedShape = firstLine.startsWith("multi_edit error: no edits applied to ") && firstLine.endsWith(" attempted).");
-	if (!successMatch && !isFailedShape) return text;
-	const replacements = successMatch ? Number.parseInt(successMatch[1], 10) || 0 : 0;
-	const applied = summarizeOutcomes(merged).applied;
-	const total = merged.length;
-	let newHeader;
-	if (applied === total) newHeader = `Edited ${path}: applied ${total} edit${total === 1 ? "" : "s"} (${replacements} replacement${replacements === 1 ? "" : "s"}).`;
-	else if (applied > 0) newHeader = `Edited ${path}: applied ${applied} of ${total} edits (${replacements} replacement${replacements === 1 ? "" : "s"}).`;
-	else newHeader = `multi_edit error: no edits applied to ${path} (${total} attempted).`;
-	return newHeader + rest;
-}
-/**
-* Aggregate counts for the transcript's summary badge (`3 applied · 1
-* denied · 1 skipped`). Exported so renderers don't reimplement the
-* tally. Pure / O(n).
-*/
-function summarizeOutcomes(outcomes) {
-	const counts = {
-		applied: 0,
-		denied: 0,
-		skipped: 0,
-		failed: 0,
-		pending: 0
-	};
-	if (!outcomes) return {
-		...counts,
-		total: 0
-	};
-	for (const o of outcomes) counts[o.kind] += 1;
-	return {
-		...counts,
-		total: outcomes.length
-	};
-}
-//#endregion
-//#region src/chat/edit-diff.ts
-function extractEditPayload(name, input, priorContent) {
-	const path = input.path;
-	if (typeof path !== "string" || path === "") return void 0;
-	if (name === "edit") {
-		const oldString = input.old_string;
-		const newString = input.new_string;
-		if (typeof oldString !== "string" || typeof newString !== "string") return void 0;
-		return {
-			tool: "edit",
-			path,
-			hunks: [{
-				oldString,
-				newString,
-				...input.replace_all === true ? { replaceAll: true } : {}
-			}],
-			...priorContent !== void 0 ? { priorContent } : {}
-		};
-	}
-	if (name === "multi_edit") {
-		const steps = input.edits;
-		if (!Array.isArray(steps) || steps.length === 0) return void 0;
-		const hunks = [];
-		for (const raw of steps) {
-			if (typeof raw?.old_string !== "string" || typeof raw?.new_string !== "string") return void 0;
-			hunks.push({
-				oldString: raw.old_string,
-				newString: raw.new_string,
-				...raw.replace_all === true ? { replaceAll: true } : {}
-			});
-		}
-		return {
-			tool: "multi_edit",
-			path,
-			hunks,
-			...priorContent !== void 0 ? { priorContent } : {}
-		};
-	}
-	if (name === "write_file") {
-		const content = input.content;
-		if (typeof content !== "string") return void 0;
-		return {
-			tool: "write_file",
-			path,
-			hunks: [{
-				oldString: priorContent ?? "",
-				newString: content
-			}],
-			...priorContent !== void 0 ? { priorContent } : {}
-		};
-	}
-}
-/**
-* LCS table cell budget shared by the line- and token-level diffs. 4M
-* cells ≈ low tens of MB of `number[]` rows — imperceptible — while
-* anything needing more (multi-thousand-line change cores) wouldn't
-* produce a human-readable minimal diff anyway.
-*/
-const LCS_CELL_BUDGET = 4e6;
-function computeLineDiff(oldString, newString) {
-	const oldLines = splitLines(oldString);
-	const newLines = splitLines(newString);
-	let lo = 0;
-	while (lo < oldLines.length && lo < newLines.length && oldLines[lo] === newLines[lo]) lo++;
-	let oldHi = oldLines.length;
-	let newHi = newLines.length;
-	while (oldHi > lo && newHi > lo && oldLines[oldHi - 1] === newLines[newHi - 1]) {
-		oldHi--;
-		newHi--;
-	}
-	const out = [];
-	for (let k = 0; k < lo; k++) out.push({
-		op: "context",
-		text: oldLines[k]
-	});
-	const n = oldHi - lo;
-	const m = newHi - lo;
-	if ((n + 1) * (m + 1) > LCS_CELL_BUDGET) {
-		for (let k = lo; k < oldHi; k++) out.push({
-			op: "remove",
-			text: oldLines[k]
-		});
-		for (let k = lo; k < newHi; k++) out.push({
-			op: "add",
-			text: newLines[k]
-		});
-	} else if (n > 0 || m > 0) appendLcsDiff(out, oldLines, newLines, lo, oldHi, newHi);
-	for (let k = oldHi; k < oldLines.length; k++) out.push({
-		op: "context",
-		text: oldLines[k]
-	});
-	return out;
-}
-/**
-* The classic LCS table + reverse walk over `old[lo..oldHi) ×
-* new[lo..newHi)`, appending ops to `out` in forward order. Diagonals at
-* equal lines → context; otherwise step into the higher of (up, left)
-* and emit remove/add respectively. Ties break so adjacent remove/add
-* pairs stay grouped (the intra-line highlighter pairs them up).
-*/
-function appendLcsDiff(out, oldLines, newLines, lo, oldHi, newHi) {
-	const n = oldHi - lo;
-	const m = newHi - lo;
-	const lcs = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }).fill(0));
-	for (let i = 0; i < n; i++) for (let j = 0; j < m; j++) lcs[i + 1][j + 1] = oldLines[lo + i] === newLines[lo + j] ? lcs[i][j] + 1 : Math.max(lcs[i][j + 1], lcs[i + 1][j]);
-	const core = [];
-	let i = n;
-	let j = m;
-	while (i > 0 || j > 0) {
-		if (i > 0 && j > 0 && oldLines[lo + i - 1] === newLines[lo + j - 1]) {
-			core.push({
-				op: "context",
-				text: oldLines[lo + i - 1]
-			});
-			i--;
-			j--;
-			continue;
-		}
-		if (j > 0 && (i === 0 || lcs[i][j - 1] >= lcs[i - 1][j])) {
-			core.push({
-				op: "add",
-				text: newLines[lo + j - 1]
-			});
-			j--;
-			continue;
-		}
-		core.push({
-			op: "remove",
-			text: oldLines[lo + i - 1]
-		});
-		i--;
-	}
-	core.reverse();
-	out.push(...core);
-}
-/**
-* Split a string into lines preserving empty lines but dropping the
-* implicit trailing `""` produced by a final `\n`. Exported only for
-* its tests — callers should use `computeLineDiff`.
-*/
-function splitLines(s) {
-	if (s === "") return [];
-	const parts = s.split("\n");
-	if (parts[parts.length - 1] === "") parts.pop();
-	return parts;
-}
-function computeInlineDiff(oldLine, newLine) {
-	const oldTokens = tokenize(oldLine);
-	const newTokens = tokenize(newLine);
-	const n = oldTokens.length;
-	const m = newTokens.length;
-	if ((n + 1) * (m + 1) > LCS_CELL_BUDGET) return {
-		oldSegments: oldLine === "" ? [] : [{
-			text: oldLine,
-			changed: true
-		}],
-		newSegments: newLine === "" ? [] : [{
-			text: newLine,
-			changed: true
-		}]
-	};
-	const lcs = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }).fill(0));
-	for (let i = 0; i < n; i++) for (let j = 0; j < m; j++) lcs[i + 1][j + 1] = oldTokens[i] === newTokens[j] ? lcs[i][j] + 1 : Math.max(lcs[i][j + 1], lcs[i + 1][j]);
-	const oldSegments = [];
-	const newSegments = [];
-	let i = n;
-	let j = m;
-	while (i > 0 || j > 0) {
-		if (i > 0 && j > 0 && oldTokens[i - 1] === newTokens[j - 1]) {
-			pushSegment(oldSegments, {
-				text: oldTokens[i - 1],
-				changed: false
-			});
-			pushSegment(newSegments, {
-				text: newTokens[j - 1],
-				changed: false
-			});
-			i--;
-			j--;
-			continue;
-		}
-		if (j > 0 && (i === 0 || lcs[i][j - 1] >= lcs[i - 1][j])) {
-			pushSegment(newSegments, {
-				text: newTokens[j - 1],
-				changed: true
-			});
-			j--;
-			continue;
-		}
-		pushSegment(oldSegments, {
-			text: oldTokens[i - 1],
-			changed: true
-		});
-		i--;
-	}
-	oldSegments.reverse();
-	newSegments.reverse();
-	return {
-		oldSegments,
-		newSegments
-	};
-}
-/**
-* Coalesce adjacent same-state segments so the renderer emits one
-* `<span>` per run instead of one per token — keeps the React tree
-* shallow on dense lines without changing the visual output.
-*
-* Walking direction is reverse (we push during the reverse walk, then
-* the caller reverses the array), so we coalesce against the *tail*.
-*/
-function pushSegment(buf, seg) {
-	const tail = buf[buf.length - 1];
-	if (tail && tail.changed === seg.changed) tail.text = seg.text + tail.text;
-	else buf.push(seg);
-}
-/**
-* Tokenize on word / non-word boundaries. Each run of `\w+` is one
-* token; each run of `\W+` (whitespace, punctuation) is another. This
-* gives the right granularity for renames (`oldName` → `newName`) and
-* for symbol swaps (`+ → -`) without exploding into per-char segments.
-*
-* Exported only for its tests.
-*/
-function tokenize(s) {
-	if (s === "") return [];
-	const out = [];
-	for (const match of s.matchAll(/\w+|\W+/g)) out.push(match[0]);
-	return out;
-}
-/**
-* Apply the payload's hunks against `priorContent` and return the
-* resulting file body. Mirrors the agent's tool-side semantics:
-*   - `replaceAll === true`  → `String.replaceAll`
-*   - otherwise              → first-occurrence `String.replace`
-*
-* Hunks are applied in order — a `multi_edit` later hunk operates on
-* the output of the earlier ones, just like the actual tool.
-*/
-function applyEditPayload(payload, priorContent) {
-	let out = priorContent;
-	for (const hunk of payload.hunks) out = hunk.replaceAll ? out.replaceAll(hunk.oldString, hunk.newString) : out.replace(hunk.oldString, hunk.newString);
-	return out;
-}
-/**
-* Like `buildUnifiedDiff` but operating against the full file content
-* so the diff carries *real* file line numbers and configurable
-* surrounding context.
-*
-* Strategy:
-*   1. Apply the payload to `priorContent` → `newContent`.
-*   2. Run `computeLineDiff` over the whole file.
-*   3. Group non-context ops into hunks, padding each with up to
-*      `contextLines` of context above and below. Adjacent hunks
-*      whose context regions touch are merged so we don't emit two
-*      `@@` headers separated by zero context lines.
-*
-* The output line numbers in the `@@` header are 1-based and reflect
-* the change's position in the actual file — what the user expects
-* when reading a diff alongside their editor.
-*
-* For `write_file` creating a new file (priorContent === ''), this
-* falls back to the same `--- /dev/null` convention as
-* `buildUnifiedDiff`.
-*/
-function buildContextualDiff(payload, priorContent, contextLines = 3) {
-	const newContent = applyEditPayload(payload, priorContent);
-	const isNewFile = priorContent === "";
-	const ops = computeLineDiff(priorContent, newContent);
-	const oldLineFor = [];
-	const newLineFor = [];
-	let ol = 1;
-	let nl = 1;
-	for (const op of ops) {
-		oldLineFor.push(ol);
-		newLineFor.push(nl);
-		if (op.op !== "add") ol++;
-		if (op.op !== "remove") nl++;
-	}
-	const hunks = [];
-	for (let i = 0; i < ops.length; i++) {
-		if (ops[i].op === "context") continue;
-		const start = Math.max(0, i - contextLines);
-		const end = Math.min(ops.length - 1, i + contextLines);
-		const last = hunks[hunks.length - 1];
-		if (last && start <= last[1] + 1) last[1] = Math.max(last[1], end);
-		else hunks.push([start, end]);
-	}
-	if (hunks.length === 0) return "";
-	const parts = [];
-	parts.push(isNewFile ? "--- /dev/null" : `--- a/${payload.path}`);
-	parts.push(`+++ b/${payload.path}`);
-	for (const [start, end] of hunks) {
-		const slice = ops.slice(start, end + 1);
-		const oldCount = slice.filter((l) => l.op !== "add").length;
-		const newCount = slice.filter((l) => l.op !== "remove").length;
-		const oldStart = oldCount === 0 ? Math.max(0, oldLineFor[start] - 1) : oldLineFor[start];
-		const newStart = newCount === 0 ? Math.max(0, newLineFor[start] - 1) : newLineFor[start];
-		parts.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
-		for (const line of slice) {
-			const prefix = line.op === "add" ? "+" : line.op === "remove" ? "-" : " ";
-			parts.push(`${prefix}${line.text}`);
-		}
-	}
-	return `${parts.join("\n")}\n`;
-}
-/**
-* Build a per-hunk digest used by the compact diff view.
-*
-* Strategy:
-*  - When `priorContent` is present and the payload describes a real
-*    file transformation, compute the contextual diff once, then walk
-*    the LCS ops splitting at runs of `add` / `remove` to anchor each
-*    summary entry to the **real** file line. This guarantees the
-*    summary's `L<n>` matches what the user sees in their editor.
-*  - Otherwise, fall back to per-hunk LCS over the (oldString,
-*    newString) snippet pair. Line numbers are absent because the
-*    snippet has no file position.
-*/
-function summarizeEditPayload(payload) {
-	const prior = payload.priorContent;
-	if (prior !== void 0) return summarizeOpsByHunk(computeLineDiff(prior, applyEditPayload(payload, prior)));
-	const hunks = [];
-	let totalAdded = 0;
-	let totalRemoved = 0;
-	for (const hunk of payload.hunks) {
-		const ops = computeLineDiff(hunk.oldString, hunk.newString);
-		let added = 0;
-		let removed = 0;
-		let firstOld;
-		let firstNew;
-		for (const op of ops) if (op.op === "add") {
-			added++;
-			if (firstNew === void 0) firstNew = op.text;
-		} else if (op.op === "remove") {
-			removed++;
-			if (firstOld === void 0) firstOld = op.text;
-		}
-		totalAdded += added;
-		totalRemoved += removed;
-		hunks.push({
-			added,
-			removed,
-			...firstOld !== void 0 ? { firstOld } : {},
-			...firstNew !== void 0 ? { firstNew } : {}
-		});
-	}
-	return {
-		totalAdded,
-		totalRemoved,
-		hunks
-	};
-}
-/**
-* Walk an LCS op stream and emit one summary entry per *run* of
-* non-context ops, with the new-file line number where each run
-* starts. Adjacent add/remove ops collapse into the same entry —
-* matches git's hunk grouping at zero context.
-*/
-function summarizeOpsByHunk(ops) {
-	const hunks = [];
-	let totalAdded = 0;
-	let totalRemoved = 0;
-	let nl = 1;
-	let i = 0;
-	while (i < ops.length) {
-		if (ops[i].op === "context") {
-			nl++;
-			i++;
-			continue;
-		}
-		const runStartLine = nl;
-		let added = 0;
-		let removed = 0;
-		let firstOld;
-		let firstNew;
-		while (i < ops.length && ops[i].op !== "context") {
-			const cur = ops[i];
-			if (cur.op === "add") {
-				added++;
-				if (firstNew === void 0) firstNew = cur.text;
-				nl++;
-			} else {
-				removed++;
-				if (firstOld === void 0) firstOld = cur.text;
-			}
-			i++;
-		}
-		totalAdded += added;
-		totalRemoved += removed;
-		hunks.push({
-			line: runStartLine,
-			added,
-			removed,
-			...firstOld !== void 0 ? { firstOld } : {},
-			...firstNew !== void 0 ? { firstNew } : {}
-		});
-	}
-	return {
-		totalAdded,
-		totalRemoved,
-		hunks
-	};
-}
-function previewEditPayload(payload, priorContent, contextLines = 3) {
-	const resolution = [];
-	const resolvedHunks = [];
-	const perHunkDiff = [];
-	let running = priorContent;
-	for (const hunk of payload.hunks) {
-		if (hunk.oldString === "" || hunk.oldString === running) {
-			resolution.push({
-				resolved: true,
-				via: "exact",
-				occurrences: 1
-			});
-			resolvedHunks.push(hunk);
-			perHunkDiff.push(buildContextualDiff({
-				...payload,
-				hunks: [hunk]
-			}, running, contextLines));
-			running = hunk.newString;
-			continue;
-		}
-		const match = resolveOldString(running, hunk.oldString);
-		if (!match) {
-			resolution.push({ resolved: false });
-			resolvedHunks.push(hunk);
-			perHunkDiff.push("");
-			continue;
-		}
-		const ambiguous = match.occurrences > 1 && !hunk.replaceAll;
-		const styledNew = styleReplacementForVia(hunk.newString, match.via, match.actual);
-		const resolvedHunk = {
-			oldString: match.actual,
-			newString: styledNew,
-			...hunk.replaceAll ? { replaceAll: true } : {}
-		};
-		resolution.push({
-			resolved: !ambiguous,
-			via: match.via,
-			occurrences: match.occurrences,
-			...ambiguous ? { ambiguous: true } : {}
-		});
-		resolvedHunks.push(resolvedHunk);
-		perHunkDiff.push(ambiguous ? "" : buildContextualDiff({
-			...payload,
-			hunks: [resolvedHunk]
-		}, running, contextLines));
-		if (!ambiguous) running = hunk.replaceAll ? running.replaceAll(match.actual, styledNew) : running.replace(match.actual, styledNew);
-	}
-	const resolvedPayload = {
-		...payload,
-		hunks: resolvedHunks
-	};
-	const applicableHunks = resolvedHunks.filter((_, i) => resolution[i].resolved);
-	return {
-		diffText: applicableHunks.length === 0 ? "" : buildContextualDiff({
-			...payload,
-			hunks: applicableHunks
-		}, priorContent, contextLines),
-		resolution,
-		perHunkDiff,
-		resolvedPayload
-	};
-}
-/** Default size budget (UTF-16 code units) for transcript diff rows. */
-const DIFF_RENDER_MAX_BYTES = 512 * 1024;
-/** Marker appended to a line hard-truncated mid-content by the size cap. */
-const CLIP_LINE_MARKER = " …⟨line clipped⟩";
-/**
-* Truncate `line` so it fits `budget` code units including the marker,
-* without splitting a UTF-16 surrogate pair. Returns the line unchanged
-* when it already fits.
-*/
-function clipLine(line, budget) {
-	if (line.length <= budget) return line;
-	let end = Math.max(0, budget - 16);
-	const code = line.charCodeAt(end - 1);
-	if (end > 0 && code >= 55296 && code <= 56319) end--;
-	return line.slice(0, end) + CLIP_LINE_MARKER;
-}
-function clipDiffForRender(diff, maxLines = 600, maxBytes = DIFF_RENDER_MAX_BYTES) {
-	const lines = diff.split("\n");
-	const totalLines = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
-	if (totalLines <= maxLines && diff.length <= maxBytes) return {
-		text: diff,
-		hiddenLines: 0,
-		totalLines
-	};
-	const kept = [];
-	let used = 0;
-	for (let i = 0; i < totalLines; i++) {
-		if (kept.length >= maxLines) break;
-		const line = lines[i];
-		const cost = line.length + 1;
-		if (used + cost > maxBytes) {
-			if (kept.length === 0) kept.push(clipLine(line, maxBytes));
-			break;
-		}
-		kept.push(line);
-		used += cost;
-	}
-	return {
-		text: kept.join("\n"),
-		hiddenLines: totalLines - kept.length,
-		totalLines
-	};
-}
-function buildUnifiedDiff(payload) {
-	const parts = [];
-	const isNewFile = payload.tool === "write_file" && payload.hunks[0]?.oldString === "";
-	parts.push(isNewFile ? `--- /dev/null` : `--- a/${payload.path}`);
-	parts.push(`+++ b/${payload.path}`);
-	for (const hunk of payload.hunks) {
-		const lines = computeLineDiff(hunk.oldString, hunk.newString);
-		const oldCount = lines.filter((l) => l.op !== "add").length;
-		const newCount = lines.filter((l) => l.op !== "remove").length;
-		const oldStart = oldCount === 0 ? 0 : 1;
-		const newStart = newCount === 0 ? 0 : 1;
-		parts.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
-		for (const line of lines) {
-			const prefix = line.op === "add" ? "+" : line.op === "remove" ? "-" : " ";
-			parts.push(`${prefix}${line.text}`);
-		}
-	}
-	return `${parts.join("\n")}\n`;
-}
-const FILETYPE_BY_EXT = {
-	ts: "typescript",
-	mts: "typescript",
-	cts: "typescript",
-	tsx: "typescriptreact",
-	js: "javascript",
-	mjs: "javascript",
-	cjs: "javascript",
-	jsx: "javascriptreact",
-	py: "python",
-	pyi: "python",
-	rs: "rust",
-	go: "go",
-	json: "json",
-	jsonc: "json",
-	sh: "bash",
-	bash: "bash",
-	zsh: "bash",
-	yaml: "yaml",
-	yml: "yaml",
-	html: "html",
-	htm: "html",
-	css: "css",
-	md: "markdown",
-	markdown: "markdown",
-	zig: "zig",
-	lua: "lua",
-	toml: "toml",
-	sql: "sql"
-};
-function filetypeFromPath(path) {
-	const cleaned = path.split(/[?#]/, 1)[0];
-	const lastDot = cleaned.lastIndexOf(".");
-	if (lastDot === -1 || lastDot === cleaned.length - 1) return void 0;
-	const ext = cleaned.slice(lastDot + 1).toLowerCase();
-	return FILETYPE_BY_EXT[ext];
-}
-/** `1.2k` / `48k` / `1.3M` — token counts are read at a glance, not counted. */
-function formatTokenCount(tokens) {
-	if (tokens >= 1e6) return `${(tokens / 1e6).toFixed(1)}M`;
-	if (tokens >= 1e3) return `${(tokens / 1e3).toFixed(tokens >= 1e4 ? 0 : 1)}k`;
-	return String(tokens);
-}
-/** `2m18s` / `48s` / `<1s` / `1h05m`. Compact — this is a receipt, not a profiler. */
-function formatRunDuration(ms) {
-	if (ms < 1e3) return "<1s";
-	const s = Math.round(ms / 1e3);
-	if (s < 60) return `${s}s`;
-	const m = Math.floor(s / 60);
-	const rest = s % 60;
-	if (m < 60) return rest ? `${m}m${String(rest).padStart(2, "0")}s` : `${m}m`;
-	return `${Math.floor(m / 60)}h${String(m % 60).padStart(2, "0")}m`;
-}
-/** `$0.04`, or four decimals under a cent so a cheap run is not shown as `$0.00`. */
-function formatCostUsd(cost) {
-	return `$${cost.toFixed(cost < .01 ? 4 : 2)}`;
-}
-/**
-* Build the receipt for a run record. `now` stands in for `endedAt` when the
-* record is not finalized yet (`run:end` is broadcast a beat before it is).
-*/
-function runReceiptFromRun(run, now = Date.now()) {
-	const sumIn = (u) => u.input + (u.cacheRead ?? 0) + (u.cacheCreation ?? 0);
-	const usage = run.totalUsage ? {
-		input: sumIn(run.totalUsage),
-		output: run.totalUsage.output
-	} : run.turnUsage?.reduce((acc, u) => ({
-		input: acc.input + sumIn(u),
-		output: acc.output + u.output
-	}), {
-		input: 0,
-		output: 0
-	});
-	const models = (run.turnUsage ?? []).map((u) => u.modelId).filter((m) => typeof m === "string" && m.length > 0);
-	const modelId = models.at(-1);
-	const otherModels = modelId ? new Set(models).size - 1 : 0;
-	const durationMs = (run.endedAt ?? now) - run.startedAt;
-	const cost = run.cost ?? run.turnUsage?.reduce((n, u) => n + (u.cost ?? 0), 0) ?? 0;
-	const turns = run.turns ?? run.turnUsage?.length ?? 0;
-	let genMs = 0;
-	let genOut = 0;
-	for (const u of run.turnUsage ?? []) {
-		if (u.streamDurationMs === void 0 || u.output <= 0) continue;
-		const ms = u.streamDurationMs - (u.timeToFirstTokenMs ?? 0);
-		if (ms <= 0) continue;
-		genMs += ms;
-		genOut += u.output;
-	}
-	const tokensPerSecond = genMs > 0 && genOut > 0 ? genOut * 1e3 / genMs : void 0;
-	return {
-		...modelId ? { modelId } : {},
-		...otherModels > 0 ? { otherModels } : {},
-		...durationMs > 0 ? { durationMs } : {},
-		...turns > 0 ? { turns } : {},
-		...cost > 0 ? { costUsd: cost } : {},
-		...usage && usage.input > 0 ? { tokensIn: usage.input } : {},
-		...usage && usage.output > 0 ? { tokensOut: usage.output } : {},
-		...tokensPerSecond !== void 0 ? { tokensPerSecond } : {}
-	};
-}
-/** `42 tk/s`; one decimal under 10 so a slow model is not shown as `0 tk/s`. */
-function formatTokensPerSecond(tps) {
-	return `${tps < 10 ? tps.toFixed(1) : Math.round(tps).toString()} tk/s`;
-}
-/**
-* The receipt's cells, in display order. Renderers join them with their own
-* separator, tint them by `kind`, and truncate to their own width; the CONTENT
-* is fixed here.
-*/
-function formatRunReceiptCells(r) {
-	const cells = [];
-	if (r.modelId) cells.push({
-		kind: "model",
-		text: r.otherModels ? `${r.modelId} +${r.otherModels}` : r.modelId
-	});
-	if (r.durationMs !== void 0) cells.push({
-		kind: "duration",
-		text: formatRunDuration(r.durationMs)
-	});
-	if (r.turns !== void 0) cells.push({
-		kind: "turns",
-		text: `↻${r.turns}`
-	});
-	if (r.costUsd !== void 0) cells.push({
-		kind: "cost",
-		text: formatCostUsd(r.costUsd)
-	});
-	if (r.tokensIn !== void 0 || r.tokensOut !== void 0) {
-		const segments = [{
-			kind: "tokens-in",
-			text: `↑${formatTokenCount(r.tokensIn ?? 0)}`
-		}, {
-			kind: "tokens-out",
-			text: `↓${formatTokenCount(r.tokensOut ?? 0)}`
-		}];
-		cells.push({
-			kind: "tokens",
-			text: segments.map((seg) => seg.text).join(" "),
-			segments
-		});
-	}
-	if (r.tokensPerSecond !== void 0) cells.push({
-		kind: "speed",
-		text: formatTokensPerSecond(r.tokensPerSecond)
-	});
-	return cells;
-}
-/** The glyph that leads the line on every surface. */
-const RUN_RECEIPT_GLYPH = "≡";
-/**
-* Fit cells to `width` columns for a tinted renderer: returns the cells that
-* fit whole, plus whether the last one was cut. A cut cell is truncated with
-* `…`; anything after it is dropped. Never wraps. `prefix` is the columns the
-* renderer already spent (glyph + space).
-*/
-function fitRunReceiptCells(cells, width, prefix = 0) {
-	let used = prefix;
-	const out = [];
-	for (const cell of cells) {
-		const need = (out.length ? 3 : 0) + cell.text.length;
-		if (used + need <= width) {
-			out.push(cell);
-			used += need;
-			continue;
-		}
-		const room = width - used - (out.length ? 3 : 0);
-		if (room >= 2) out.push({
-			kind: cell.kind,
-			text: `${cell.text.slice(0, room - 1).trimEnd()}…`
-		});
-		break;
-	}
-	return out;
-}
-/** One line, ` · `-joined, ellipsized to `width` columns. Never wraps. */
-function formatRunReceiptLine(r, width = Number.POSITIVE_INFINITY) {
-	const line = formatRunReceiptCells(r).map((c) => c.text).join(" · ");
-	if (line.length <= width) return line;
-	if (width <= 1) return width === 1 ? "…" : "";
-	return `${line.slice(0, width - 1).trimEnd()}…`;
-}
-/** Anything to show? A run with no record data renders no line at all. */
-function hasRunReceipt(r) {
-	return formatRunReceiptCells(r).length > 0;
-}
-//#endregion
-//#region src/chat/orchestration.ts
-/**
-* Orchestration — the pure model for a "main" session that drives others.
-*
-* A main session is an ordinary session with a role, and a worker is an
-* ordinary session with a parent pointer. Both are `metadata` keys, so every
-* existing surface (sidebar, history, attach, search, replay) works on them
-* with no special cases; only the surfaces that WANT to treat them specially
-* (pinning, the event row, the jump shortcut) read these keys.
-*
-* This is deliberately not `spawn`. A spawned child is ephemeral, inline, and
-* dies with the parent's run; a worker is a persistent, resumable session with
-* its own cwd, model chain, todos and history, visible in every window, and it
-* outlives the main's run. The parent pointer is what makes them a tree.
-*
-* Node-free: re-exported from `zidane/chat/pure` for the Electron renderer,
-* which needs `isMainSession` / `orchestratedBy` for pinning and the event row.
-*/
-/** Title the main session is created with. Users can rename it; the ROLE is what matters. */
-const MAIN_SESSION_TITLE = "Main";
-/** `session.metadata.role` — present and `'main'` on the one orchestrating session. */
-const SESSION_ROLE_KEY = "role";
-/** `session.metadata.orchestratedBy` — the main session's id, on a worker. */
-const ORCHESTRATED_BY_KEY = "orchestratedBy";
-/** Type guard over untrusted metadata. */
-function isMainSession(metadata) {
-	return metadata?.[SESSION_ROLE_KEY] === "main";
-}
-/** The main session id a worker reports to, or `null` for an ordinary session. */
-function orchestratedBy(metadata) {
-	const value = metadata?.[ORCHESTRATED_BY_KEY];
-	return typeof value === "string" && value.length > 0 ? value : null;
-}
-/** Tools whose `path` input means "this file changed". */
-const CHANGE_TOOLS = /* @__PURE__ */ new Set([
-	"edit",
-	"multi_edit",
-	"write_file"
-]);
-const ARTIFACT_PATH_CAP = 12;
-/**
-* What a run touched, read off its assistant turns' tool calls. Only the
-* tools that MUTATE count as "changed" — reads are not artifacts. Capped so a
-* refactor across a hundred files does not turn the event into a manifest;
-* the count still tells the truth.
-*/
-function artifactsFromTurns(turns) {
-	const changed = [];
-	const seen = /* @__PURE__ */ new Set();
-	let commands = 0;
-	let toolCalls = 0;
-	for (const turn of turns) {
-		if (turn.role !== "assistant") continue;
-		for (const block of turn.content) {
-			if (block.type !== "tool_call" || !block.name) continue;
-			toolCalls++;
-			if (block.name === "shell") commands++;
-			if (CHANGE_TOOLS.has(block.name)) {
-				const path = block.input?.path;
-				if (typeof path === "string" && path && !seen.has(path)) {
-					seen.add(path);
-					changed.push(path);
-				}
-			}
-		}
-	}
-	if (toolCalls === 0) return void 0;
-	return {
-		changed: changed.slice(0, ARTIFACT_PATH_CAP),
-		commands,
-		toolCalls
-	};
-}
-const STATUSES = [
-	"done",
-	"error",
-	"cancelled",
-	"needs-attention"
-];
-/**
-* Wire format between the harness and the model — and, because it is persisted
-* inside the user turn's text block, between a live session and its replay.
-*
-* Follows `<task-notification>` exactly: child-tag XML, one block per event,
-* escaped with `escapeXml`. The model already knows this shape as "the harness
-* telling me something", which is the point — a main that mistook a worker
-* report for a human instruction would act on it as one. `eventsFromTurns`
-* detects the block on replay and re-synthesizes the structured row instead of
-* painting the raw XML as a user prompt.
-*/
-function renderSessionEventXml(event) {
-	const tag = (name, value) => value === void 0 ? [] : [`  <${name}>${escapeXml(String(value))}</${name}>`];
-	return [
-		"<session-event>",
-		...tag("session-id", event.sessionId),
-		...tag("title", event.title),
-		...tag("status", event.status),
-		...tag("at", event.at),
-		...tag("cwd", event.cwd ?? ""),
-		...tag("cost-usd", event.costUsd),
-		...tag("duration-ms", event.durationMs),
-		...tag("tokens", event.tokens),
-		...tag("turns", event.turns),
-		...tag("worker", event.worker === void 0 ? void 0 : String(event.worker)),
-		...tag("seq", event.seq),
-		...tag("finish-reason", event.finishReason),
-		...tag("error", event.error),
-		...tag("detail", event.detail),
-		...tag("goal", event.goal),
-		...event.artifacts ? [
-			`  <artifacts tool-calls="${event.artifacts.toolCalls}" commands="${event.artifacts.commands}">`,
-			...event.artifacts.changed.map((p) => `    <changed>${escapeXml(p)}</changed>`),
-			"  </artifacts>"
-		] : [],
-		...tag("summary", event.summary),
-		"</session-event>"
-	].join("\n");
-}
-const SESSION_EVENT_RE = /^\s*<session-event>([\s\S]*?)<\/session-event>\s*$/;
-const FIELD = {
-	sessionId: /<session-id>([\s\S]*?)<\/session-id>/,
-	title: /<title>([\s\S]*?)<\/title>/,
-	status: /<status>([\s\S]*?)<\/status>/,
-	at: /<at>([\s\S]*?)<\/at>/,
-	cwd: /<cwd>([\s\S]*?)<\/cwd>/,
-	costUsd: /<cost-usd>([\s\S]*?)<\/cost-usd>/,
-	durationMs: /<duration-ms>([\s\S]*?)<\/duration-ms>/,
-	tokens: /<tokens>([\s\S]*?)<\/tokens>/,
-	turns: /<turns>([\s\S]*?)<\/turns>/,
-	worker: /<worker>([\s\S]*?)<\/worker>/,
-	error: /<error>([\s\S]*?)<\/error>/,
-	detail: /<detail>([\s\S]*?)<\/detail>/,
-	seq: /<seq>([\s\S]*?)<\/seq>/,
-	goal: /<goal>([\s\S]*?)<\/goal>/,
-	finishReason: /<finish-reason>([\s\S]*?)<\/finish-reason>/,
-	artifacts: /<artifacts tool-calls="(\d+)" commands="(\d+)">([\s\S]*?)<\/artifacts>/,
-	summary: /<summary>([\s\S]*?)<\/summary>/
-};
-const CHANGED_RE = /<changed>([\s\S]*?)<\/changed>/g;
-const FINISH_REASONS = /* @__PURE__ */ new Set([
-	"length",
-	"pause",
-	"content-filter"
-]);
-/**
-* Inverse of {@link renderSessionEventXml}. Untrusted input — it comes off disk
-* and outlives this module's versions — so it validates each field and returns
-* `null` for anything malformed, in which case the turn replays as the plain
-* user text it structurally is.
-*/
-function parseSessionEventXml(text) {
-	const m = text.match(SESSION_EVENT_RE);
-	if (!m) return null;
-	const body = m[1];
-	const pick = (re) => {
-		const inner = body.match(re);
-		return inner ? unescapeXml(inner[1].trim()) : void 0;
-	};
-	const sessionId = pick(FIELD.sessionId);
-	const title = pick(FIELD.title);
-	const status = pick(FIELD.status);
-	const at = Number(pick(FIELD.at));
-	const summary = pick(FIELD.summary);
-	if (!sessionId || title === void 0 || summary === void 0) return null;
-	if (!status || !STATUSES.includes(status)) return null;
-	if (!Number.isFinite(at)) return null;
-	const cost = Number(pick(FIELD.costUsd));
-	const cwd = pick(FIELD.cwd);
-	const positive = (raw) => {
-		const n = Number(raw);
-		return Number.isFinite(n) && n > 0 ? n : void 0;
-	};
-	const durationMs = positive(pick(FIELD.durationMs));
-	const tokens = positive(pick(FIELD.tokens));
-	const turns = positive(pick(FIELD.turns));
-	const worker = pick(FIELD.worker);
-	const error = pick(FIELD.error);
-	const detail = pick(FIELD.detail);
-	const seq = positive(pick(FIELD.seq));
-	const goal = pick(FIELD.goal);
-	const finishReason = pick(FIELD.finishReason);
-	const art = body.match(FIELD.artifacts);
-	const artifacts = art ? {
-		toolCalls: Number(art[1]),
-		commands: Number(art[2]),
-		changed: [...art[3].matchAll(CHANGED_RE)].map((m) => unescapeXml(m[1].trim()))
-	} : void 0;
-	return {
-		sessionId,
-		title,
-		status,
-		summary,
-		at,
-		...Number.isFinite(cost) && cost > 0 ? { costUsd: cost } : {},
-		...cwd !== void 0 ? { cwd } : {},
-		...durationMs !== void 0 ? { durationMs } : {},
-		...tokens !== void 0 ? { tokens } : {},
-		...turns !== void 0 ? { turns } : {},
-		...worker === "true" ? { worker: true } : worker === "false" ? { worker: false } : {},
-		...error ? { error } : {},
-		...detail ? { detail } : {},
-		...seq !== void 0 ? { seq } : {},
-		...goal ? { goal } : {},
-		...finishReason && FINISH_REASONS.has(finishReason) ? { finishReason } : {},
-		...artifacts ? { artifacts } : {}
-	};
-}
-function unescapeXml(s) {
-	return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
-}
-/**
-* The short label a transcript row shows — `api-refactor · done`. Status words
-* are chosen to read as a verb phrase after the title.
-*/
-function sessionEventLabel(event) {
-	return `${event.title} ${{
-		"done": "finished",
-		"error": "failed",
-		"cancelled": "was cancelled",
-		"needs-attention": "needs attention"
-	}[event.status]}`;
-}
-/**
-* Status → how it reads. `needs-attention` is deliberately the loudest: it is
-* the one status where the human, not the main, has to act.
-*/
-const SESSION_EVENT_STATUS_STYLE = {
-	"done": {
-		glyph: "✓",
-		tone: "accent",
-		verb: "finished"
-	},
-	"error": {
-		glyph: "✗",
-		tone: "error",
-		verb: "failed"
-	},
-	"cancelled": {
-		glyph: "⊘",
-		tone: "dim",
-		verb: "was cancelled"
-	},
-	"needs-attention": {
-		glyph: "!",
-		tone: "warn",
-		verb: "needs your input"
-	}
-};
-/**
-* The directory name a session lives in — the same basename label the sidebar
-* groups by. `undefined` for a directory-less session (the main) or no cwd.
-*/
-function sessionDirLabel(cwd) {
-	if (!cwd) return void 0;
-	const parts = cwd.split(/[\\/]+/).filter(Boolean);
-	return parts[parts.length - 1];
-}
-/** Short, stable id fragment for the header — enough to disambiguate, not to read. */
-function shortSessionId(id) {
-	return id.length <= 8 ? id : id.slice(0, 8);
-}
-/**
-* The header's metadata cells, in display order, omitting anything unknown.
-* Renderers join them with their own separator; the CONTENT is fixed here so
-* both surfaces show the same receipt for the same run.
-*
-* The session id is deliberately NOT a cell: it is the least legible datum and
-* exists only to disambiguate. Renderers append `shortSessionId` LAST and
-* dimmer than the rest.
-*/
-function sessionEventMeta(event) {
-	const cells = [];
-	const dir = sessionDirLabel(event.cwd);
-	if (dir) cells.push(dir);
-	if (event.durationMs !== void 0) cells.push(formatRunDuration(event.durationMs));
-	if (event.tokens !== void 0) cells.push(`${formatTokenCount(event.tokens)} tok`);
-	if (event.turns !== void 0) cells.push(`${event.turns} turn${event.turns === 1 ? "" : "s"}`);
-	if (event.costUsd !== void 0) cells.push(formatCostUsd(event.costUsd));
-	return cells;
-}
-/**
-* The dimmed second line: the last thing the session said, collapsed to one
-* paragraph and capped. Renderers may clamp further (line-clamp in the GUI,
-* width in the TUI); this is the upper bound and the shared ellipsis rule.
-*/
-function sessionEventExcerpt(event, max = 240) {
-	const flat = (event.status === "needs-attention" && event.detail ? event.detail : event.status === "error" && event.error ? event.error : event.summary).replace(/\s+/g, " ").trim();
-	return flat.length <= max ? flat : `${flat.slice(0, max - 1).trimEnd()}…`;
-}
-/** Ellipsize a title to `max` characters; titles are user text and can be a paragraph. */
-function truncateTitle(title, max = 48) {
-	const flat = title.replace(/\s+/g, " ").trim();
-	return flat.length <= max ? flat : `${flat.slice(0, max - 1).trimEnd()}…`;
-}
-/**
-* System-prompt fragment appended to every WORKER's agent. A worker's last
-* message becomes the main's `summary`, so it must be a report, not a sign-off
-* — the main should be able to act on it without reading the transcript.
-*/
-const WORKER_REPORT_FRAGMENT = `You are a worker session created by an orchestrating main session. Your final message of a run is delivered to it verbatim as your report, so end every run with a short structured report:
-
-## Report
-- **Goal**: what you were asked, in one line
-- **Outcome**: done / partial / blocked — one line, and why if not done
-- **Changed**: files or artifacts touched (paths), or "none"
-- **Checks**: what you ran and the result (tests, typecheck, lint), or "none"
-- **Open questions**: anything the main or a human must decide, or "none"
-- **Next**: the concrete next step you recommend, or "none"
-
-Keep it factual and under ~15 lines. This block is what the main decides on; prose before it is fine, prose instead of it is not.`;
-/**
-* System-prompt fragment appended to the MAIN's agent: how to delegate without
-* wasting calls. The `sessions` tool description says what each verb does;
-* this says which one to reach for, and when not to call at all.
-*/
-const MAIN_PLAYBOOK_FRAGMENT = `You are the main session: an orchestrator. Work happens in worker sessions; you brief them, integrate their reports, and keep the human informed. Do not do the workers' work here.
-
-Work efficiently with the \`sessions\` tool:
-- Never poll. After create or send you WILL receive a <session-event> when the worker finishes, fails, or blocks. Do not read or list a worker that has not reported yet.
-- Reuse before creating. To continue work in a project, send to its existing idle session (listed under Projects below; its context is already warm). Create a worker only for a new, independent unit of work, or when the project has no suitable session.
-- You already know the ids. Take them from Projects below, from a <session-event>, or from an earlier list. Do not list just to find an id you have.
-- send vs steer: send when the worker is idle or the new prompt should queue after its current run; steer only to change course mid-run.
-- Fire-and-forget when you can. For work you will not act on when it lands (docs, cleanup, low-stakes checks), pass wake: false on create or send; the report still reaches your history, you just are not woken for it.
-- Brief completely. A worker prompt states the goal, the constraints, what to check (tests, typecheck, lint), and that it must end with its report. Follow-up questions cost a full round trip.
-- read is cheap (last message); transcript is not. Use transcript only when a report is unclear.
-- Report to the human briefly: what went where, what came back, what needs a decision. Do not re-narrate worker reports.`;
-/**
-* The main's "Projects" briefing: which directories have ongoing work and
-* the session to address in each, so the main does not rediscover them with
-* a list call every run. Snapshot at agent start — live state is one `list`
-* away and the text says so.
-*/
-function renderProjectsBriefing(projects, now) {
-	const lines = ["## Projects", "Known as of this session's start; live state comes from `sessions list`. Directory-less sessions are omitted."];
-	if (projects.length === 0) {
-		lines.push("- none yet");
-		return lines.join("\n");
-	}
-	for (const p of projects) {
-		const cells = [`${p.sessions} session${p.sessions === 1 ? "" : "s"}`, `last active ${agoLabel(now - p.lastActiveAt)}`];
-		if (p.active > 0) cells.push(`${p.active} active`);
-		lines.push(`- ${sessionDirLabel(p.root) ?? p.root} (${p.root}) · ${cells.join(" · ")}`);
-		lines.push(`  latest: ${p.latest.sessionId} "${truncateTitle(p.latest.title, 60)}" (${p.latest.state})`);
-	}
-	return lines.join("\n");
-}
-/** Coarse relative time for the briefing: `just now`, `12m ago`, `3h ago`, `5d ago`. */
-function agoLabel(elapsedMs) {
-	const m = Math.floor(Math.max(0, elapsedMs) / 6e4);
-	if (m < 1) return "just now";
-	if (m < 60) return `${m}m ago`;
-	const h = Math.floor(m / 60);
-	if (h < 48) return `${h}h ago`;
-	return `${Math.floor(h / 24)}d ago`;
-}
-//#endregion
-//#region src/chat/turn-selection.ts
-/** Tools whose `tool-result` event is suppressed when `showEditDiffs` is on. */
-const EDIT_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"edit",
-	"multi_edit",
-	"write_file"
-]);
-/**
-* Keep turn-selection mode alive after deleting its active row. Prefer the
-* row that slides into the deleted index; at the tail, select the new last
-* row. Returns null only when no selectable rows survive.
-*/
-function selectionAfterTurnRemoval(before, removedId, after) {
-	if (after.includes(removedId)) return removedId;
-	if (after.length === 0) return null;
-	const index = before.indexOf(removedId);
-	return after[Math.min(Math.max(0, index), after.length - 1)] ?? null;
-}
-/**
-* Recognize a tool-result body as carrying NON-success information so the
-* renderer doesn't suppress it under `showEditDiffs`. Three categories:
-*
-*   - `edit` → "Edit error: …"
-*   - `write_file` permission errors wrapped by the loop → "Tool failed: …"
-*   - `multi_edit` → legacy single-line error `multi_edit error: …`, OR
-*     a result carrying an `<edit-outcomes>…</edit-outcomes>` annotation
-*     block. The TUI only appends the annotation when at least one hunk
-*     was NOT applied, so its mere presence is the signal — the result
-*     body needs to stay visible next to the diff so the user can read
-*     denial / skip / failure reasons longer than the per-hunk badge.
-*   - Fully-denied gate emit (`[fully denied] <edit-outcomes>…`) likewise
-*     stays visible.
+*   - `edit` → "Edit error: …"
+*   - `write_file` permission errors wrapped by the loop → "Tool failed: …"
+*   - `multi_edit` → legacy single-line error `multi_edit error: …`, OR
+*     a result carrying an `<edit-outcomes>…</edit-outcomes>` annotation
+*     block. The TUI only appends the annotation when at least one hunk
+*     was NOT applied, so its mere presence is the signal — the result
+*     body needs to stay visible next to the diff so the user can read
+*     denial / skip / failure reasons longer than the per-hunk badge.
+*   - Fully-denied gate emit (`[fully denied] <edit-outcomes>…`) likewise
+*     stays visible.
 *
 * Exported for unit-testability of the visibility matrix.
 */
@@ -1562,8 +74,8 @@ function isEditErrorResult(text) {
 	return false;
 }
 /**
-* `callId` prefix minted by the TUI's `!` bash mode (see `runBashCommand`
-* in `src/tui/app.tsx`). The prefix is the durable signal — it survives
+* `callId` prefix minted by the TUI's `!` bash mode (see `runBashMode`
+* in `src/tui/commands/run-bash-mode.ts`). The prefix is the durable signal — it survives
 * persistence and replay — that a `shell` tool exchange was USER-initiated,
 * so renderers can keep it visible even when the tool-display settings
 * hide model-driven plumbing: the user typed the command and expects to
@@ -1692,7 +204,7 @@ function isVisibleDuringSearch(event, settings, query) {
 * Renderer-agnostic — returns plain `boolean` so TUI / GUI consumers
 * can filter events identically.
 */
-/** `notice.label` the host stamps on prompt-cache break/expiry rows (`host/engine.ts`). */
+/** `notice.label` the host stamps on prompt-cache break/expiry rows (`host/notices/index.ts`). */
 const CACHE_NOTICE_LABEL = "cache";
 function isVisible(event, settings) {
 	if (settings.hideSubagentOutput) {
@@ -1706,6 +218,7 @@ function isVisible(event, settings) {
 		case "tool-result": return settings.showToolResults || isUserBashEvent(event);
 		case "run-summary": return settings.showRunReceipt;
 		case "info": return settings.showCacheNotices || event.notice?.label !== "cache";
+		case "spawn-queued": return settings.transcriptDensity === "compact";
 		default: return true;
 	}
 }
@@ -1768,68 +281,621 @@ function turnSelectionOwnership(events) {
 			else if (lastToolEmitterTurnId) ownership.set(tid, lastToolEmitterTurnId);
 			continue;
 		}
-		if (kinds.includes("tool")) lastToolEmitterTurnId = tid;
-	}
-	return ownership;
-}
-/**
-* Render-time check: should `event` paint with the selection accent?
-*
-* `true` when the event's own turn is selected, OR when the selected turn
-* `owns` the event's turn via {@link turnSelectionOwnership} (the call and
-* its tool-result rows highlight together). `false` when nothing is
-* selected or the relationship doesn't apply.
-*
-* Pure. Renderer-agnostic — the TUI's `<Transcript>` uses it; a GUI's
-* equivalent walks the same rule.
-*/
-function isTurnHighlighted(event, selectedTurnId, ownership) {
-	if (selectedTurnId === null || !event.turnId) return false;
-	if (event.turnId === selectedTurnId) return true;
-	return ownership.get(event.turnId) === selectedTurnId || ownership.get(selectedTurnId) === event.turnId;
+		if (kinds.includes("tool")) lastToolEmitterTurnId = tid;
+	}
+	return ownership;
+}
+/**
+* Render-time check: should `event` paint with the selection accent?
+*
+* `true` when the event's own turn is selected, OR when the selected turn
+* `owns` the event's turn via {@link turnSelectionOwnership} (the call and
+* its tool-result rows highlight together). `false` when nothing is
+* selected or the relationship doesn't apply.
+*
+* Pure. Renderer-agnostic — the TUI's `<Transcript>` uses it; a GUI's
+* equivalent walks the same rule.
+*/
+function isTurnHighlighted(event, selectedTurnId, ownership) {
+	if (selectedTurnId === null || !event.turnId) return false;
+	if (event.turnId === selectedTurnId) return true;
+	return ownership.get(event.turnId) === selectedTurnId || ownership.get(selectedTurnId) === event.turnId;
+}
+/**
+* Ownership for "one selection stop per message": result-only turns fold
+* into their assistant turn (`turnSelectionOwnership`), and turns that only
+* did work (thinking, tool calls, worker markers) fold into the answer that
+* follows them in the same exchange. "Read three files, then answered" is
+* one stop, so ↑ moves one visible message at a time. An exchange that ends
+* in work alone stops on its first work turn. Same rule as the GUI's
+* `computeSelectStops`.
+*/
+function messageSelectionOwnership(events) {
+	const base = turnSelectionOwnership(events);
+	const resolve = (id) => base.get(id) ?? id;
+	const stops = /* @__PURE__ */ new Set();
+	const merged = /* @__PURE__ */ new Map();
+	let pending = [];
+	const settle = (into) => {
+		const target = into ?? pending[0];
+		for (const id of pending) if (target !== void 0 && id !== target) merged.set(id, target);
+		if (target !== void 0) stops.add(target);
+		pending = [];
+	};
+	for (const event of events) {
+		if (event.childId !== void 0 || (event.depth ?? 0) > 0) continue;
+		if (event.kind === "separator" || event.kind === "user-prompt" || event.kind === "compact-summary") settle(null);
+		if (!event.turnId) continue;
+		const owner = resolve(event.turnId);
+		const work = event.kind === "tool" || event.kind === "tool-result" || event.kind === "thinking" || event.kind === "spawn-start" || event.kind === "spawn-end" || event.kind === "command-detail" || event.kind === "info" && event.notice === void 0;
+		if (event.kind === "markdown" && event.text.trim()) {
+			stops.add(owner);
+			settle(owner);
+		} else if (work) {
+			if (!stops.has(owner) && !pending.includes(owner)) pending.push(owner);
+		} else if (event.kind !== "user-prompt" && event.kind !== "compact-summary") {
+			settle(null);
+			stops.add(owner);
+		} else stops.add(owner);
+	}
+	settle(null);
+	const out = /* @__PURE__ */ new Map();
+	const final = (id) => merged.get(id) ?? id;
+	for (const [raw, owner] of base) {
+		const stop = final(owner);
+		if (stop !== raw) out.set(raw, stop);
+	}
+	for (const [id, stop] of merged) out.set(id, stop);
+	return out;
+}
+/**
+* Deduplicated, in-order list of **parent-conversation** turn ids that appear
+* in a rendered transcript — the navigation index for the TUI's select-turn
+* mode. Three classes of turns are deliberately skipped:
+*
+*   - **Subagent turns** (`childId` set). Nested execution detail; the
+*     user's mental model of a "message" is the conversational exchange,
+*     not each spawn turn. Also filtered out by `isVisible` under
+*     `hideSubagentOutput: true` — selecting them would highlight nothing.
+*   - **Result-only turns** — see {@link turnSelectionOwnership}. These get
+*     coalesced into the assistant turn that emitted their tool_calls.
+*   - **Settings-hidden turns** (when `settings` is supplied). A turn whose
+*     every event fails {@link isVisible} would render no rows — landing
+*     the cursor there hides it from the user entirely. The check is opt-
+*     in so SDK callers without a Settings object keep the legacy
+*     "everything visible" behavior.
+*
+* Synthetic events (separator, spawn-start, spawn-end) have no `turnId` and
+* are skipped naturally.
+*/
+function selectableTurnIds(events, settings, visible, opts) {
+	const ownership = opts?.byMessage ? messageSelectionOwnership(events) : turnSelectionOwnership(events);
+	const visibleCount = settings ? /* @__PURE__ */ new Map() : null;
+	if (settings && visibleCount) for (const e of events) {
+		if (!e.turnId || e.childId) continue;
+		if (!(visible ? visible(e) : isVisible(e, settings))) continue;
+		visibleCount.set(e.turnId, (visibleCount.get(e.turnId) ?? 0) + 1);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const e of events) {
+		if (!e.turnId) continue;
+		if (e.childId) continue;
+		if (seen.has(e.turnId)) continue;
+		if (ownership.has(e.turnId)) continue;
+		if (visibleCount && (visibleCount.get(e.turnId) ?? 0) === 0) continue;
+		seen.add(e.turnId);
+		ordered.push(e.turnId);
+	}
+	return ordered;
+}
+//#endregion
+//#region src/chat/machine-protocol.ts
+/** Bumped on an incompatible change; a host refuses another major. */
+const MACHINE_PROTOCOL_VERSION = 1;
+/** Largest `data` chunk (decoded bytes) of one `exec.stream.data` notification or `exec.stream.write`. */
+const MACHINE_STREAM_CHUNK_BYTES = 262144;
+/**
+* Calls whose re-send after a lost reply cannot change anything (reads, and
+* the idempotent handle calls: the machine keys handles by the host's id).
+* Everything else that was sent is reported as a lost result, never re-sent.
+*/
+const MACHINE_IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+	"machine.ping",
+	"exec.spawn",
+	"exec.cancel",
+	"exec.destroy",
+	"fs.read",
+	"fs.list",
+	"fs.size",
+	"bg.list",
+	"bg.wait",
+	"env.checkFolder",
+	"terminal.attach"
+]);
+/** Error codes of the machine protocol (JSON-RPC server-error range, apart from `IpcErrorCode`). */
+const MachineErrorCode = {
+	/** A machine connection called a client method, or a client a machine one. */
+	MethodNotAllowed: -32040,
+	/** `machine.register` from another major `MACHINE_PROTOCOL_VERSION`. */
+	VersionSkew: -32041,
+	/** The name is held by another machine on this host. */
+	NameTaken: -32042,
+	/** A path or cwd outside the machine's roots, or in its data dir. */
+	OutsideRoots: -32043,
+	/** The machine id is bound to another (live) token, or this token was used by the machine before the host forgot it. */
+	IdBound: -32044,
+	/** No room now (a capacity limit): try again later, unlike a refusal. */
+	Busy: -32045
+};
+/** Where a local host keeps the machine token a saved server gave it (credentials store). */
+function machineCredentialKey(hostId) {
+	return `machine:${hostId}`;
+}
+/** A machine name from a free-form one (a server's display name): the valid characters kept, the rest dashed. */
+function toMachineName(raw) {
+	return raw.trim().replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "machine";
+}
+/** A machine-qualified environment kind: `<base>@<machine name>`. */
+function machineKind(base, name) {
+	return `${base}@${name}`;
+}
+/** `{ base, name }` of a machine-qualified kind, `null` for any other. */
+function parseMachineKind(kind) {
+	const match = /^(local|worktree)@(.+)$/.exec(kind);
+	return match ? {
+		base: match[1],
+		name: match[2]
+	} : null;
+}
+/** A machine name: one path-safe segment, so `local@<name>` is unambiguous. */
+function isValidMachineName(name) {
+	return /^[\w.-]{1,64}$/.test(name);
+}
+//#endregion
+//#region src/chat/feature-gate.ts
+/** `process.env` when there is one; a renderer has no `process`. */
+function ambientEnv() {
+	return globalThis.process?.env ?? {};
+}
+function defineFeatureGate({ setting, killSwitchEnv, flag }) {
+	const isKilled = (env = ambientEnv()) => env[killSwitchEnv] === "1";
+	return {
+		setting,
+		killSwitchEnv,
+		flag,
+		isKilled,
+		isEnabled: (settings, env) => settings[setting] === true && !isKilled(env)
+	};
+}
+/**
+* The shared daemon runtime. `ZIDANE_NO_DAEMON=1` is set by
+* `zidane --no-daemon`.
+*/
+const daemonGate = defineFeatureGate({
+	setting: "useDaemon",
+	killSwitchEnv: "ZIDANE_NO_DAEMON",
+	flag: "--no-daemon"
+});
+/**
+* Remote hosts (zidane-server). The setting ("Remote hosts")
+* gates the saved servers: the Hosts settings, the per-host session groups
+* and picking a host for a new session. Connecting through an explicit `--host` /
+* `ZIDANE_HOST_URL` is its own opt-in, but `ZIDANE_NO_REMOTE=1` still wins
+* over it (`src/tui/host-target.ts`). `ZIDANE_NO_REMOTE=1` is set by
+* `zidane --no-remote`.
+*/
+const remoteHostsGate = defineFeatureGate({
+	setting: "remoteHosts",
+	killSwitchEnv: "ZIDANE_NO_REMOTE",
+	flag: "--no-remote"
+});
+/** Every gate, so a client can report which kill switches are engaged. */
+const FEATURE_GATES = [daemonGate, remoteHostsGate];
+/**
+* The kill-switch env vars engaged in `env`, sorted. The GUI main process
+* hands this to its renderer (which has no `process.env`) so settings rows
+* can say why they are inert.
+*/
+function engagedKillSwitches(env = ambientEnv()) {
+	return FEATURE_GATES.filter((g) => g.isKilled(env)).map((g) => g.killSwitchEnv).sort();
+}
+/** `name` is set to `'1'` in `env`: the kill-switch test, for a row that only knows the variable. */
+function isKillSwitchEngaged(name, env = ambientEnv()) {
+	return env[name] === "1";
+}
+//#endregion
+//#region src/chat/footer-chips.ts
+/**
+* Abbreviate a re-billed token count: `1200` → `1.2k`, `800` → `800`.
+* Thousands only — a cache prefix large enough to need `M` would be past any
+* provider's window.
+*/
+function formatTokens(tokens) {
+	return tokens >= 1e3 ? `${(tokens / 1e3).toFixed(1)}k` : String(tokens);
+}
+/**
+* Build the chip for a cache break.
+*
+* `costUsd` is OPTIONAL and omitted entirely on a rate miss — never rendered
+* as `$0.00`. A fabricated zero would read as "this was free", which is the
+* opposite of what the chip exists to say. When present it is prefixed `~`
+* because it is an estimate (registry rates × re-billed prefix), and clamped
+* to `<0.01` rather than rounding a real charge down to nothing.
+*/
+function cacheBreakChip(info) {
+	const rebilled = formatTokens(info.rebilledTokens);
+	const cost = info.costUsd !== void 0 ? ` · ~$${info.costUsd < .01 ? "<0.01" : info.costUsd.toFixed(2)}` : "";
+	if (info.changed.length === 0) return {
+		tone: "dim",
+		glyph: "⚡",
+		label: `cache expired · +${rebilled} tok${cost}`
+	};
+	return {
+		tone: "warn",
+		glyph: "⚡",
+		label: `cache break · ${info.changed.join(",")} · +${rebilled} tok${cost}`
+	};
+}
+/**
+* Transcript-row text for a persisted cache-break notice. Multi-line, one
+* fact per line, so both hosts can show a short headline and fold or list
+* the rest:
+*
+*   cache break ↑116.9k tokens ~$0.48
+*   messagePrefix: message 16 of 41→43 rewritten
+*   likely compaction or history trimming
+*
+* The footer chip stays terse; the row carries the culprit so a break is
+* diagnosable from the transcript. Only the headline on a TTL / eviction
+* break (nothing was done wrong).
+*/
+function cacheBreakNoticeText(info) {
+	const rebilled = formatTokens(info.rebilledTokens);
+	const cost = info.costUsd !== void 0 ? ` ~$${info.costUsd < .01 ? "<0.01" : info.costUsd.toFixed(2)}` : "";
+	return [`${info.changed.length === 0 ? "cache expired" : "cache break"} ↑${rebilled} tokens${cost}`, ...info.changed.flatMap((dim) => {
+		const detail = info.details[dim];
+		if (typeof detail !== "string" || detail.length === 0) return [`${dim} changed`];
+		const [first, ...rest] = detail.split("\n");
+		return [`${dim}: ${first}`, ...rest];
+	})].join("\n");
+}
+/**
+* Provider-retry label — `retrying 2/5`, or `retrying 2/5 · child-3` when the
+* stalled stream belongs to a subagent rather than the parent.
+*
+* Naming the source matters: with subagents in flight, an unattributed
+* "retrying" leaves the user unable to tell whether their own turn is stuck or
+* a delegated worker is.
+*/
+function retryLabel(info) {
+	const suffix = info.source === "parent" ? "" : ` · ${info.source}`;
+	return `retrying ${info.attempt}/${info.max}${suffix}`;
+}
+/**
+* Footer label while a compaction summary is being generated:
+* `Compacting...`, then `~12k` once the loop reports a token estimate, then
+* ` · 8s` once a second has passed. Same rule on every surface so a
+* minutes-long compaction of a large transcript reads as progress — not a
+* hang — identically in the TUI and the GUI.
+*
+* `now` is injectable so callers driving a 1 Hz tick don't have to re-read
+* the clock, and so tests are deterministic.
+*/
+/**
+* The live run readout: `1m 15s · ↓1.2k · 41 tok/s`. Time runs from the
+* run's start, the count covers the whole run (settled turns plus the one
+* streaming), and the rate is the honest windowed figure from
+* `stepStreamRate` (`null` until it has one). `↓~` marks a count that is
+* still the character heuristic. A tool-only stretch shows just the time.
+*
+* `detail` drops the least useful part first when space runs out:
+* `'full'` → `'count'` (no rate) → `'time'`.
+*/
+function runStatusLabel(run, detail = "full") {
+	const parts = [formatElapsed(Math.max(0, Math.floor(run.elapsedSec)))];
+	if (detail !== "time" && run.outputTokens > 0) parts.push(`↓${run.estimated ? "~" : ""}${fmtTokens(run.outputTokens)}`);
+	if (detail === "full" && run.outputTokens > 0 && run.rate !== null && run.rate > 0) parts.push(`${run.rate} tok/s`);
+	return parts.join(" · ");
+}
+/**
+* Live counter for one streaming turn: `↓1.2k`, `↓~1.2k` for the character
+* heuristic, `↓1.2k · 41 tok/s` when an honest rate is passed in (see
+* `stepStreamRate`; dividing tokens by time since the request counted the
+* wait for the first token and the estimate correction). Empty until the
+* first token.
+*/
+function streamingLabel(progress, opts = {}) {
+	if (!progress || progress.outputTokens <= 0) return "";
+	const count = `↓${progress.estimated ? "~" : ""}${fmtTokens(progress.outputTokens)}`;
+	return opts.rate ? `${count} · ${opts.rate} tok/s` : count;
+}
+/**
+* Session cost while a turn streams: settled figure plus the running estimate
+* for the in-flight turn. `estimated` tells the surface to render it dimmed
+* (the number will move, then snap to the settled value at turn end). `null`
+* when there is nothing to show — never `$0.00`.
+*/
+function liveSessionCost(settledUsd, progress) {
+	const live = progress?.estCostUsd ?? 0;
+	const total = settledUsd + live;
+	if (total <= 0) return null;
+	return {
+		usd: total,
+		estimated: live > 0
+	};
+}
+function compactingLabel(estTokens, startedAt, now = Date.now()) {
+	const base = "Compacting...";
+	const elapsedMs = typeof startedAt === "number" ? now - startedAt : 0;
+	const elapsed = elapsedMs >= 1e3 ? ` · ${formatDuration(elapsedMs)}` : "";
+	return typeof estTokens === "number" && estTokens > 0 ? `${base} ~${fmtTokens(estTokens)}${elapsed}` : `${base}${elapsed}`;
+}
+//#endregion
+//#region src/chat/completion-chats.ts
+const CHATS_TRIGGER = "#";
+const DEFAULT_RESULT_LIMIT$1 = 50;
+const MIN_TOKEN_LENGTH = 6;
+function normalizeId(id) {
+	return id.replace(/-/g, "").toLowerCase();
+}
+function projectLabel(projectRoot) {
+	if (!projectRoot) return "";
+	const parts = projectRoot.split(/[\\/]/).filter(Boolean);
+	return parts[parts.length - 1] ?? projectRoot;
+}
+/**
+* Per-catalog memo for `tokenFor`, keyed on catalog reference identity.
+* Token derivation is O(catalog) per id, and both `suggest()` (every
+* keystroke) and `parseReferences()` (every submit/highlight pass) need
+* a token for EVERY entry — quadratic over catalogs that can reach
+* thousands of sessions. The catalog getters return a stable array until
+* a refresh swaps it, so a WeakMap invalidates exactly when it should.
+*/
+const tokensByCatalog = /* @__PURE__ */ new WeakMap();
+function catalogTokens(catalog) {
+	let cached = tokensByCatalog.get(catalog);
+	if (!cached) {
+		cached = {
+			normalizedIds: catalog.map((entry) => normalizeId(entry.id)),
+			tokens: /* @__PURE__ */ new Map()
+		};
+		tokensByCatalog.set(catalog, cached);
+	}
+	return cached;
+}
+function tokenFor(id, catalog) {
+	const { normalizedIds, tokens } = catalogTokens(catalog);
+	const known = tokens.get(id);
+	if (known !== void 0) return known;
+	const normalized = normalizeId(id);
+	let result;
+	for (let len = Math.min(MIN_TOKEN_LENGTH, normalized.length); len <= normalized.length; len++) {
+		const token = normalized.slice(0, len);
+		if (normalizedIds.filter((candidate) => candidate.startsWith(token)).length === 1) {
+			result = token;
+			break;
+		}
+	}
+	result ??= normalized || shortId(id);
+	tokens.set(id, result);
+	return result;
+}
+function stripTrailingPunctuation(candidate) {
+	return candidate.replace(/[.,;:)\]}!?]+$/, "");
+}
+function descriptionFor(entry, token, scope) {
+	const bits = [
+		`#${token}`,
+		ageString(entry.updatedAt),
+		`${entry.userMessageCount} msg${entry.userMessageCount === 1 ? "" : "s"}`
+	];
+	if ((entry.artifactCount ?? 0) > 0) bits.push(`${entry.artifactCount} artifact${entry.artifactCount === 1 ? "" : "s"}`);
+	const project = projectLabel(entry.projectRoot);
+	if (scope === "all" && project) bits.push(project);
+	return bits.join(" · ");
+}
+function scoreChats(catalog, tokenCatalog, query, limit, scope) {
+	const q = query.trim().toLowerCase();
+	const rows = catalog.map((entry) => ({
+		entry,
+		token: tokenFor(entry.id, tokenCatalog),
+		project: projectLabel(entry.projectRoot)
+	}));
+	const fuzzyHits = q.length > 0 ? new Set(new Fzf(rows, {
+		selector: (r) => `${r.entry.title} ${r.token} ${r.project}`,
+		casing: "case-insensitive"
+	}).find(q).map((r) => r.item)) : null;
+	const scored = [];
+	for (const row of rows) {
+		const title = row.entry.title.toLowerCase();
+		const token = row.token.toLowerCase();
+		const project = row.project.toLowerCase();
+		if (q.length === 0) {
+			scored.push({
+				entry: row.entry,
+				token: row.token,
+				rank: 5
+			});
+			continue;
+		}
+		if (token.startsWith(q)) {
+			scored.push({
+				entry: row.entry,
+				token: row.token,
+				rank: 0
+			});
+			continue;
+		}
+		if (title.startsWith(q)) {
+			scored.push({
+				entry: row.entry,
+				token: row.token,
+				rank: 1
+			});
+			continue;
+		}
+		if (title.includes(q)) {
+			scored.push({
+				entry: row.entry,
+				token: row.token,
+				rank: 2
+			});
+			continue;
+		}
+		if (project.includes(q)) {
+			scored.push({
+				entry: row.entry,
+				token: row.token,
+				rank: 3
+			});
+			continue;
+		}
+		if (fuzzyHits?.has(row)) scored.push({
+			entry: row.entry,
+			token: row.token,
+			rank: 4
+		});
+	}
+	scored.sort((a, b) => {
+		if (a.rank !== b.rank) return a.rank - b.rank;
+		return b.entry.updatedAt - a.entry.updatedAt;
+	});
+	return scored.slice(0, limit).map(({ entry, token }) => ({
+		id: token,
+		label: entry.title,
+		description: descriptionFor(entry, token, scope),
+		insertText: `#${token} `,
+		data: {
+			entry,
+			token
+		}
+	}));
+}
+function createChatsCompletionProvider(opts) {
+	const limit = opts.limit ?? DEFAULT_RESULT_LIMIT$1;
+	const scope = () => opts.getScope?.() ?? "project";
+	return {
+		id: "chats",
+		trigger: "#",
+		label: "Chats",
+		suggest(query) {
+			const current = opts.getCatalog();
+			const tokenCatalog = opts.getReferenceCatalog?.() ?? current;
+			const effectiveTokenCatalog = tokenCatalog.length > 0 ? tokenCatalog : current;
+			if (current.length > 0) return scoreChats(current, effectiveTokenCatalog, query, limit, scope());
+			if (opts.ensureCatalog) return opts.ensureCatalog().then((loaded) => {
+				const refreshed = opts.getReferenceCatalog?.() ?? loaded;
+				return scoreChats(loaded, refreshed.length > 0 ? refreshed : loaded, query, limit, scope());
+			});
+			return [];
+		},
+		parseReferences(text, _ctx) {
+			const catalog = opts.getReferenceCatalog?.() ?? opts.getCatalog();
+			if (catalog.length === 0) return [];
+			const byToken = /* @__PURE__ */ new Map();
+			for (const entry of catalog) {
+				const token = tokenFor(entry.id, catalog);
+				byToken.set(token, {
+					entry,
+					token
+				});
+			}
+			const refs = [];
+			for (const m of text.matchAll(/(^|\s)#(\S+)/g)) {
+				const candidate = stripTrailingPunctuation(m[2]);
+				const data = byToken.get(candidate.toLowerCase());
+				if (!data) continue;
+				const start = m.index + m[1].length;
+				refs.push({
+					providerId: "chats",
+					start,
+					end: start + 1 + candidate.length,
+					itemId: data.entry.id,
+					data
+				});
+			}
+			return refs;
+		}
+	};
 }
-/**
-* Deduplicated, in-order list of **parent-conversation** turn ids that appear
-* in a rendered transcript — the navigation index for the TUI's select-turn
-* mode. Three classes of turns are deliberately skipped:
-*
-*   - **Subagent turns** (`childId` set). Nested execution detail; the
-*     user's mental model of a "message" is the conversational exchange,
-*     not each spawn turn. Also filtered out by `isVisible` under
-*     `hideSubagentOutput: true` — selecting them would highlight nothing.
-*   - **Result-only turns** — see {@link turnSelectionOwnership}. These get
-*     coalesced into the assistant turn that emitted their tool_calls.
-*   - **Settings-hidden turns** (when `settings` is supplied). A turn whose
-*     every event fails {@link isVisible} would render no rows — landing
-*     the cursor there hides it from the user entirely. The check is opt-
-*     in so SDK callers without a Settings object keep the legacy
-*     "everything visible" behavior.
-*
-* Synthetic events (separator, spawn-start, spawn-end) have no `turnId` and
-* are skipped naturally.
-*/
-function selectableTurnIds(events, settings, visible) {
-	const ownership = turnSelectionOwnership(events);
-	const visibleCount = settings ? /* @__PURE__ */ new Map() : null;
-	if (settings && visibleCount) for (const e of events) {
-		if (!e.turnId || e.childId) continue;
-		if (!(visible ? visible(e) : isVisible(e, settings))) continue;
-		visibleCount.set(e.turnId, (visibleCount.get(e.turnId) ?? 0) + 1);
+function uniqueChatIdsFromReferences(references) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const ref of references) {
+		if (ref.providerId !== "chats") continue;
+		if (seen.has(ref.itemId)) continue;
+		seen.add(ref.itemId);
+		out.push(ref.itemId);
 	}
+	return out;
+}
+function chatReferenceTokensFromText(text) {
+	const out = [];
 	const seen = /* @__PURE__ */ new Set();
-	const ordered = [];
-	for (const e of events) {
-		if (!e.turnId) continue;
-		if (e.childId) continue;
-		if (seen.has(e.turnId)) continue;
-		if (ownership.has(e.turnId)) continue;
-		if (visibleCount && (visibleCount.get(e.turnId) ?? 0) === 0) continue;
-		seen.add(e.turnId);
-		ordered.push(e.turnId);
+	for (const m of text.matchAll(/(^|\s)#(\S+)/g)) {
+		const token = stripTrailingPunctuation(m[2]).toLowerCase();
+		if (!token || seen.has(token)) continue;
+		seen.add(token);
+		out.push(token);
 	}
-	return ordered;
+	return out;
 }
 //#endregion
+//#region src/chat/browser/protocol.ts
+const BROWSER_OPS = [
+	"open",
+	"navigate",
+	"snapshot",
+	"screenshot",
+	"click",
+	"type",
+	"press",
+	"scroll",
+	"wait_for",
+	"evaluate",
+	"console"
+];
+var BrowserOpError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "BrowserOpError";
+	}
+};
+/** Default and ceiling for an action's own wait (element to become actionable, text to appear). */
+const BROWSER_ACTION_TIMEOUT_MS = 5e3;
+const BROWSER_WAIT_TIMEOUT_MS = 1e4;
+const BROWSER_MAX_WAIT_MS = 3e4;
+/** How long the host waits for a page to mount and register before `open` gives up. */
+const BROWSER_OPEN_MOUNT_MS = 15e3;
+/** Transport budget on top of the action's own wait. */
+const BROWSER_REQUEST_SLACK_MS = 5e3;
+const BROWSER_EVALUATE_MAX_BYTES = 65536;
+const BROWSER_OUTLINE_MAX_ELEMENTS = 250;
+const BROWSER_TEXT_MAX_CHARS = 8e3;
+//#endregion
+//#region src/chat/terminal/protocol.ts
+/** Characters a client may be behind before the host stops sending to it. */
+const TERMINAL_OUTPUT_WINDOW = 262144;
+/** History kept per terminal for new views (characters). */
+const TERMINAL_HISTORY_MAX_CHARS = 4194304;
+/** Plain-text lines kept per terminal for the agent. */
+const TERMINAL_TEXT_MAX_LINES = 5e3;
+/** Most the agent gets from one read (characters). */
+const TERMINAL_READ_MAX_CHARS = 16384;
+/** Terminals a session may have open at once. */
+const TERMINAL_MAX_PER_SESSION = 12;
+var TerminalError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "TerminalError";
+	}
+};
+//#endregion
 //#region src/chat/color-gradient.ts
 /** Parse `#rrggbb` (case-insensitive) into `[r, g, b]` 0–255 integers. */
 function parseHex(hex) {
@@ -2349,326 +1415,43 @@ function createSkillsCompletionProvider(opts) {
 				});
 			}
 			return refs;
-		}
-	};
-}
-/**
-* Walk a parsed prompt for skill references and return the deduplicated
-* list of skill names — input to `agent.activateSkill(name)` calls on
-* submit.
-*/
-function uniqueSkillNamesFromReferences(references) {
-	const out = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const ref of references) {
-		if (ref.providerId !== "skills") continue;
-		if (seen.has(ref.itemId)) continue;
-		seen.add(ref.itemId);
-		out.push(ref.itemId);
-	}
-	return out;
-}
-//#endregion
-//#region src/chat/model-chain.ts
-/** Identity of a chain entry — the pair, not object identity. */
-function chainEntryKey(entry) {
-	return `${entry.provider}\u0000${entry.model}`;
-}
-/** Toggle `entry`: absent → appended, present → removed. Pure. */
-function toggleKeyed(chain, entry, keyOf) {
-	const key = keyOf(entry);
-	const idx = chain.findIndex((e) => keyOf(e) === key);
-	if (idx === -1) return [...chain, entry];
-	return [...chain.slice(0, idx), ...chain.slice(idx + 1)];
-}
-/**
-* Make `entry` the primary (position 0), keeping the rest in order. Inserts
-* when absent, promotes when present; no-op when it already leads.
-*
-* This is `↵` in the picker. It exists because toggling APPENDS: with a chain
-* of `[current]`, toggling a new model produced `[current, new]` — the pick
-* became a fallback and the active model never changed. "Highlight and ↵"
-* means "use this one", so that gesture promotes; building a fallback list is
-* the secondary gesture (`⇥`) and keeps toggle semantics.
-*/
-function pickPrimaryKeyed(chain, entry, keyOf) {
-	const key = keyOf(entry);
-	return [entry, ...chain.filter((e) => keyOf(e) !== key)];
-}
-/** 1-based position of `key` in the chain, or `null` when absent. */
-function positionKeyed(chain, key, keyOf) {
-	const idx = chain.findIndex((e) => keyOf(e) === key);
-	return idx === -1 ? null : idx + 1;
-}
-/** Same entries in the same order. */
-function chainsEqualKeyed(a, b, keyOf) {
-	return a.length === b.length && a.every((e, i) => keyOf(e) === keyOf(b[i]));
-}
-/** Move the entry with `key` by one priority slot; boundary or missing = identity. */
-function reorderKeyed(chain, key, delta, keyOf) {
-	const from = chain.findIndex((e) => keyOf(e) === key);
-	const to = from + delta;
-	if (from < 0 || to < 0 || to >= chain.length) return chain;
-	const next = [...chain];
-	const [entry] = next.splice(from, 1);
-	next.splice(to, 0, entry);
-	return next;
-}
-function toggleChainEntry(chain, entry) {
-	return toggleKeyed(chain, entry, chainEntryKey);
-}
-function pickChainPrimary(chain, entry) {
-	return pickPrimaryKeyed(chain, entry, chainEntryKey);
-}
-/** 1-based chain position of a provider+model pair, or `null` when not in the chain. */
-function chainPositionOf(chain, provider, model) {
-	return positionKeyed(chain, chainEntryKey({
-		provider,
-		model
-	}), chainEntryKey);
-}
-function chainsEqual(a, b) {
-	return chainsEqualKeyed(a, b, chainEntryKey);
-}
-/**
-* Did the SET of provider keys change between two chains? The agent is
-* built with one provider instance per distinct chain key, so a set
-* change requires a session re-activation (rebuild); a pure model /
-* order change within the same providers does not.
-*/
-function providerKeySetChanged(prev, next) {
-	const prevKeys = new Set(prev.map((e) => e.provider));
-	const nextKeys = new Set(next.map((e) => e.provider));
-	if (prevKeys.size !== nextKeys.size) return true;
-	for (const k of nextKeys) if (!prevKeys.has(k)) return true;
-	return false;
-}
-/**
-* Assemble the `agent.run` `model` option from a chain.
-*
-* - Single-entry chain → the bare model id string (byte-identical to the
-*   pre-chain behavior).
-* - Multi-entry chain → pinned `{ provider, model }` targets, where
-*   `provider` is the runtime `Provider.name` resolved via
-*   `providerNameFor` (chain entries carry chat-level `ProviderKey`s,
-*   which need not equal the instance names the agent loop matches on).
-*
-* Throws only on an empty chain — a programmer error, since chains
-* always carry a primary. Stale or unresolvable entries degrade
-* defensively instead (never throw, never produce an entry the agent
-* would reject):
-* - Entries whose key has no resolvable name (provider not constructed
-*   into the current agent) are dropped.
-* - If the PRIMARY itself doesn't resolve, or fewer than two entries
-*   survive, fall back to the bare primary model string.
-*
-* `contextWindowFor` (optional) stamps each target with its model's
-* context window from the host catalog, so the loop re-bases the
-* auto-compact trigger when a fallback advances onto it (the host's
-* explicit window is sized for the PRIMARY otherwise).
-*/
-function buildRunModel(chain, providerNameFor, contextWindowFor) {
-	const primary = chain[0];
-	if (!primary) throw new Error("buildRunModel: chain must not be empty");
-	if (chain.length === 1 || providerNameFor(primary.provider) === void 0) return primary.model;
-	const resolved = [];
-	for (const entry of chain) {
-		const name = providerNameFor(entry.provider);
-		if (name === void 0) continue;
-		const contextWindow = contextWindowFor?.(entry);
-		resolved.push({
-			provider: name,
-			model: entry.model,
-			...typeof contextWindow === "number" && contextWindow > 0 ? { contextWindow } : {}
-		});
-	}
-	return resolved.length > 1 ? resolved : primary.model;
-}
-/**
-* Validate a persisted chain read back from `state.json`. The state file
-* is user-editable JSON, so the value can be arbitrarily malformed —
-* return only the well-shaped `{ provider, model }` entries (both
-* non-empty strings), or `[]` for anything else. Never throws.
-*/
-function sanitizeModelChain(value) {
-	if (!Array.isArray(value)) return [];
-	const entries = [];
-	for (const item of value) {
-		if (typeof item !== "object" || item === null || !("provider" in item) || !("model" in item)) continue;
-		const { provider, model } = item;
-		if (typeof provider === "string" && provider.length > 0 && typeof model === "string" && model.length > 0) entries.push({
-			provider,
-			model
-		});
-	}
-	return entries;
-}
-/**
-* Restore the fallback tail of a persisted chain for a resolved primary
-* pair. Returns entries 1+ only when the persisted chain's entry 0
-* matches `primary` — a divergent chain belongs to a different selection
-* (e.g. a `--model` launch override) and silently attaching it would
-* surprise. Entries whose provider isn't registered, entries equal to
-* the primary, and exact duplicates drop. Accepts the raw persisted
-* value (`state.json` is user-editable) — shape validation included.
-*/
-function restoreChainFallbacks(saved, primary, isRegistered) {
-	const chain = sanitizeModelChain(saved);
-	const head = chain[0];
-	if (chain.length < 2 || !head || head.provider !== primary.provider || head.model !== primary.model) return [];
-	return filterChainFallbacks(chain.slice(1), primary, isRegistered);
-}
-/**
-* Filter candidate fallback entries against a primary pair, preserving
-* picked order: entries whose provider `isAvailable` rejects, entries
-* equal to the primary, and exact duplicates drop. Shared by the
-* picker's apply path (live-auth availability) and persisted-chain
-* restore (registry availability).
-*/
-function filterChainFallbacks(entries, primary, isAvailable) {
-	const fallbacks = [];
-	for (const entry of entries) {
-		if (!isAvailable(entry.provider)) continue;
-		if (entry.provider === primary.provider && entry.model === primary.model) continue;
-		if (fallbacks.some((f) => f.provider === entry.provider && f.model === entry.model)) continue;
-		fallbacks.push({
-			provider: entry.provider,
-			model: entry.model
-		});
-	}
-	return fallbacks;
-}
-//#endregion
-//#region src/chat/daemon-health.ts
-const DAEMON_HEALTH_GLYPH = "●";
-const DAEMON_HEALTH_STYLE = {
-	connected: {
-		tone: "accent",
-		label: "daemon connected"
-	},
-	connecting: {
-		tone: "warn",
-		label: "connecting to daemon…"
-	},
-	disconnected: {
-		tone: "error",
-		label: "daemon unreachable"
-	}
-};
-//#endregion
-//#region src/chat/footer-chips.ts
-/**
-* Abbreviate a re-billed token count: `1200` → `1.2k`, `800` → `800`.
-* Thousands only — a cache prefix large enough to need `M` would be past any
-* provider's window.
-*/
-function formatTokens(tokens) {
-	return tokens >= 1e3 ? `${(tokens / 1e3).toFixed(1)}k` : String(tokens);
-}
-/**
-* Build the chip for a cache break.
-*
-* `costUsd` is OPTIONAL and omitted entirely on a rate miss — never rendered
-* as `$0.00`. A fabricated zero would read as "this was free", which is the
-* opposite of what the chip exists to say. When present it is prefixed `~`
-* because it is an estimate (registry rates × re-billed prefix), and clamped
-* to `<0.01` rather than rounding a real charge down to nothing.
-*/
-function cacheBreakChip(info) {
-	const rebilled = formatTokens(info.rebilledTokens);
-	const cost = info.costUsd !== void 0 ? ` · ~$${info.costUsd < .01 ? "<0.01" : info.costUsd.toFixed(2)}` : "";
-	if (info.changed.length === 0) return {
-		tone: "dim",
-		glyph: "⚡",
-		label: `cache expired · +${rebilled} tok${cost}`
-	};
-	return {
-		tone: "warn",
-		glyph: "⚡",
-		label: `cache break · ${info.changed.join(",")} · +${rebilled} tok${cost}`
-	};
-}
-/**
-* Transcript-row text for a persisted cache-break notice. Multi-line, one
-* fact per line, so both hosts can show a short headline and fold or list
-* the rest:
-*
-*   cache break ↑116.9k tokens ~$0.48
-*   messagePrefix: message 16 of 41→43 rewritten
-*   likely compaction or history trimming
-*
-* The footer chip stays terse; the row carries the culprit so a break is
-* diagnosable from the transcript. Only the headline on a TTL / eviction
-* break (nothing was done wrong).
-*/
-function cacheBreakNoticeText(info) {
-	const rebilled = formatTokens(info.rebilledTokens);
-	const cost = info.costUsd !== void 0 ? ` ~$${info.costUsd < .01 ? "<0.01" : info.costUsd.toFixed(2)}` : "";
-	return [`${info.changed.length === 0 ? "cache expired" : "cache break"} ↑${rebilled} tokens${cost}`, ...info.changed.flatMap((dim) => {
-		const detail = info.details[dim];
-		if (typeof detail !== "string" || detail.length === 0) return [`${dim} changed`];
-		const [first, ...rest] = detail.split("\n");
-		return [`${dim}: ${first}`, ...rest];
-	})].join("\n");
-}
-/**
-* Provider-retry label — `retrying 2/5`, or `retrying 2/5 · child-3` when the
-* stalled stream belongs to a subagent rather than the parent.
-*
-* Naming the source matters: with subagents in flight, an unattributed
-* "retrying" leaves the user unable to tell whether their own turn is stuck or
-* a delegated worker is.
-*/
-function retryLabel(info) {
-	const suffix = info.source === "parent" ? "" : ` · ${info.source}`;
-	return `retrying ${info.attempt}/${info.max}${suffix}`;
-}
-/**
-* Footer label while a compaction summary is being generated:
-* `Compacting...`, then `~12k` once the loop reports a token estimate, then
-* ` · 8s` once a second has passed. Same rule on every surface so a
-* minutes-long compaction of a large transcript reads as progress — not a
-* hang — identically in the TUI and the GUI.
-*
-* `now` is injectable so callers driving a 1 Hz tick don't have to re-read
-* the clock, and so tests are deterministic.
-*/
-/**
-* Live counter for the parent turn currently streaming: `↓1.2k` when the
-* provider counted the tokens, `↓~1.2k` when it is the character heuristic.
-* Empty until the first token so a tool-only turn shows just the spinner.
-* Tokens-per-second appears after two seconds (`↓1.2k · 41 tok/s`) — earlier
-* the rate is dominated by time-to-first-token and would swing wildly.
-*/
-function streamingLabel(progress, opts = {}) {
-	if (!progress || progress.outputTokens <= 0) return "";
-	const count = `↓${progress.estimated ? "~" : ""}${fmtTokens(progress.outputTokens)}`;
-	if (opts.rate === false || progress.elapsedMs < 2e3) return count;
-	const perSecond = Math.round(progress.outputTokens / (progress.elapsedMs / 1e3));
-	return perSecond > 0 ? `${count} · ${perSecond} tok/s` : count;
-}
-/**
-* Session cost while a turn streams: settled figure plus the running estimate
-* for the in-flight turn. `estimated` tells the surface to render it dimmed
-* (the number will move, then snap to the settled value at turn end). `null`
-* when there is nothing to show — never `$0.00`.
-*/
-function liveSessionCost(settledUsd, progress) {
-	const live = progress?.estCostUsd ?? 0;
-	const total = settledUsd + live;
-	if (total <= 0) return null;
-	return {
-		usd: total,
-		estimated: live > 0
-	};
-}
-function compactingLabel(estTokens, startedAt, now = Date.now()) {
-	const base = "Compacting...";
-	const elapsedMs = typeof startedAt === "number" ? now - startedAt : 0;
-	const elapsed = elapsedMs >= 1e3 ? ` · ${formatDuration(elapsedMs)}` : "";
-	return typeof estTokens === "number" && estTokens > 0 ? `${base} ~${fmtTokens(estTokens)}${elapsed}` : `${base}${elapsed}`;
+		}
+	};
+}
+/**
+* Walk a parsed prompt for skill references and return the deduplicated
+* list of skill names — input to `agent.activateSkill(name)` calls on
+* submit.
+*/
+function uniqueSkillNamesFromReferences(references) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const ref of references) {
+		if (ref.providerId !== "skills") continue;
+		if (seen.has(ref.itemId)) continue;
+		seen.add(ref.itemId);
+		out.push(ref.itemId);
+	}
+	return out;
 }
 //#endregion
+//#region src/chat/daemon-health.ts
+const DAEMON_HEALTH_GLYPH = "●";
+const DAEMON_HEALTH_STYLE = {
+	connected: {
+		tone: "accent",
+		label: "daemon connected"
+	},
+	connecting: {
+		tone: "warn",
+		label: "connecting to daemon…"
+	},
+	disconnected: {
+		tone: "error",
+		label: "daemon unreachable"
+	}
+};
+//#endregion
 //#region src/chat/markdown-segments.ts
 /**
 * Split markdown text into alternating prose / fenced-code segments.
@@ -3058,6 +1841,160 @@ function isSpaceOrBreak(ch) {
 	return ch === "\n" || ch === "\r" || ch === " " || ch === "	";
 }
 //#endregion
+//#region src/chat/mcp-allowlist.ts
+/**
+* Edits to the `enabledMcps` allowlist. Without an explicit list every
+* server is on, so there is nothing to change. Servers that merely appear
+* in a config file stay off once a list exists (they don't opt in
+* silently); a server the user adds in Settings is turned on with it.
+*/
+/** The list with `name` turned on, or `undefined` when it already is. */
+function enabledMcpsWith(list, name) {
+	return list === void 0 || list.includes(name) ? void 0 : [...list, name];
+}
+/** The list without `name`, or `undefined` when it isn't listed. */
+function enabledMcpsWithout(list, name) {
+	return list?.includes(name) ? list.filter((n) => n !== name) : void 0;
+}
+//#endregion
+//#region src/chat/mcp-auth-state.ts
+/**
+* The status words both apps show for a server, so the desktop app's badge
+* and the TUI's read the same. `idle` says nothing.
+*/
+const MCP_STATUS_LABEL = {
+	"authed": "Signed in",
+	"needs-auth": "Needs sign-in",
+	"authorizing": "Signing in…",
+	"error": "Sign-in failed",
+	"bootstrap-error": "Couldn't connect",
+	"key-refused": "Key refused"
+};
+/**
+* Apply one event to the state map. Pure, immutable — returns a new map
+* with only the affected key reassigned.
+*
+* State transitions are simple "last write wins"; we don't gate (e.g.) a
+* `login:start` from overriding `authorizing` because the loop layer
+* never doubles those up — interactive login is serialized in the TUI.
+*/
+function reduceMcpAuth(state, event) {
+	const next = (status) => ({
+		...state,
+		[event.name]: status
+	});
+	switch (event.type) {
+		case "auth-required": return next({
+			kind: "needs-auth",
+			reason: event.reason
+		});
+		case "auth-url": return next({
+			kind: "authorizing",
+			url: event.url
+		});
+		case "auth-success": return next({ kind: "authed" });
+		case "auth-error": return next({
+			kind: "error",
+			error: event.error
+		});
+		case "bootstrap-error": return next({
+			kind: "bootstrap-error",
+			error: event.error
+		});
+		case "key-refused": return next({
+			kind: "key-refused",
+			error: event.error
+		});
+		case "connected":
+			if (state[event.name]?.kind === "needs-auth" && state[event.name].reason === "refused") {
+				const { [event.name]: _, ...rest } = state;
+				return rest;
+			}
+			if (state[event.name]?.kind === "authorizing" || state[event.name]?.kind === "needs-auth" || state[event.name]?.kind === "authed") return next({ kind: "authed" });
+			if (state[event.name]?.kind === "bootstrap-error" || state[event.name]?.kind === "key-refused") {
+				const { [event.name]: _, ...rest } = state;
+				return rest;
+			}
+			return state;
+		case "login:start": return next({ kind: "authorizing" });
+		case "login:cancel": return next({
+			kind: "needs-auth",
+			reason: "no-tokens"
+		});
+		case "logout":
+		case "reset": {
+			const { [event.name]: _, ...rest } = state;
+			return rest;
+		}
+	}
+}
+/**
+* The status a failed connection leaves, from `classifyMcpTest`'s answer
+* (never called with `ok`: a connection that worked leaves no failure).
+* A server that asked for OAuth keeps "sign-in failed" for an unexplained
+* failure (its tokens are the likely cause, and sign-in stays offered).
+*/
+function mcpFailureEvent(name, outcome, oauthTagged) {
+	if (outcome.kind === "needs-auth") return {
+		type: "auth-required",
+		name,
+		reason: "refused"
+	};
+	if (outcome.kind === "token-rejected") return {
+		type: "key-refused",
+		name,
+		error: outcome.message ?? ""
+	};
+	return oauthTagged ? {
+		type: "auth-error",
+		name,
+		error: outcome.message ?? ""
+	} : {
+		type: "bootstrap-error",
+		name,
+		error: outcome.message ?? ""
+	};
+}
+/** Convenience getter — treats `undefined` as `idle`. */
+function getMcpAuthStatus(state, name) {
+	return state[name] ?? { kind: "idle" };
+}
+//#endregion
+//#region src/chat/mcp-test-outcome.ts
+/** What to do about a refused key, under the "Key refused" headline. */
+const MCP_KEY_REFUSED_HINT = "Check the headers in mcps.json.";
+/** A refusal for want of credentials: HTTP 401 / 403, however the SDK words it. */
+function isMcpAuthRefusal(error) {
+	const code = error?.code;
+	if (code === 401 || code === 403) return true;
+	const message = error instanceof Error ? error.message : String(error ?? "");
+	return /\b(?:401|403)\b|unauthori[sz]ed|forbidden|invalid_token/i.test(message);
+}
+/** The first line of a failure, never empty. */
+function mcpFailureLine(error) {
+	const code = error?.code;
+	return (error instanceof Error && error.message ? error.message : code !== void 0 ? `The server answered ${String(code)}.` : typeof error === "string" ? error : "").split("\n")[0]?.trim() || "Couldn't connect.";
+}
+function classifyMcpTest(config, result) {
+	const http = config.transport !== "stdio";
+	const ownKey = Object.keys(config.headers ?? {}).length > 0;
+	if (http && (result.authRequired || result.error !== void 0 && isMcpAuthRefusal(result.error))) return ownKey ? {
+		kind: "token-rejected",
+		message: MCP_KEY_REFUSED_HINT
+	} : {
+		kind: "needs-auth",
+		message: "Sign in to connect."
+	};
+	if (result.error !== void 0) return {
+		kind: "error",
+		message: mcpFailureLine(result.error)
+	};
+	return {
+		kind: "ok",
+		tools: result.tools ?? 0
+	};
+}
+//#endregion
 //#region src/chat/model-catalog.ts
 /**
 * Build the unified catalog from a list of available providers.
@@ -3163,24 +2100,60 @@ function indexOfEntry(catalog, target) {
 * provider name.
 */
 function parseCustomModelQuery(query, providers, fallbackProviderKey) {
+	const { modelId, named } = splitProviderPrefix(query, providers);
+	const provider = named ?? providers.find((p) => p.key === fallbackProviderKey);
+	if (!provider || !modelId) return null;
+	return {
+		providerKey: provider.key,
+		providerLabel: provider.label,
+		modelId
+	};
+}
+/**
+* Every route for a typed model id, one per provider: the provider the query
+* names first (`xai grok-9`), then `fallbackProviderKey` (the current pick),
+* then the rest in the given order. Lets a picker offer "use this id via…"
+* for each signed-in provider instead of guessing one. Empty when the query
+* names no model id.
+*/
+function customModelTargets(query, providers, fallbackProviderKey) {
+	const { modelId, named } = splitProviderPrefix(query, providers);
+	if (!modelId) return [];
+	const rank = (p) => p.key === named?.key ? 0 : p.key === fallbackProviderKey ? 1 : 2;
+	return providers.map((p, i) => ({
+		p,
+		i
+	})).sort((a, b) => rank(a.p) - rank(b.p) || a.i - b.i).map(({ p }) => ({
+		providerKey: p.key,
+		providerLabel: p.label,
+		modelId,
+		...p.key === named?.key ? { named: true } : {}
+	}));
+}
+/**
+* Split an optional leading provider name off a typed query. Longest prefix
+* wins, so a multi-word label ("OpenAI Codex gpt-9") beats the bare key it
+* starts with. The trailing space is required: a query that is only a
+* provider name has no id in it and reads as an id itself. Only the prefix
+* is dropped; the rest is kept verbatim, so an id with spaces round-trips.
+*/
+function splitProviderPrefix(query, providers) {
 	const trimmed = query.trim().replace(/\s+/g, " ");
-	if (!trimmed) return null;
+	if (!trimmed) return {
+		modelId: "",
+		named: void 0
+	};
 	const lower = trimmed.toLowerCase();
-	const named = providers.flatMap((p) => [{
+	const match = providers.flatMap((p) => [{
 		provider: p,
 		token: p.label.toLowerCase()
 	}, {
 		provider: p,
 		token: p.key.toLowerCase()
 	}]).filter((candidate) => lower.startsWith(`${candidate.token} `)).sort((a, b) => b.token.length - a.token.length)[0];
-	const provider = named?.provider ?? providers.find((p) => p.key === fallbackProviderKey);
-	if (!provider) return null;
-	const modelId = named ? trimmed.slice(named.token.length).trim() : trimmed;
-	if (!modelId) return null;
 	return {
-		providerKey: provider.key,
-		providerLabel: provider.label,
-		modelId
+		modelId: match ? trimmed.slice(match.token.length).trim() : trimmed,
+		named: match?.provider
 	};
 }
 function buildSearchCorpus(provider, model) {
@@ -3193,57 +2166,159 @@ function buildSearchCorpus(provider, model) {
 	].join(" ").toLowerCase();
 }
 //#endregion
-//#region src/chat/prompt-segments.ts
+//#region src/chat/model-lineup.ts
+const DATE_DASHED = /-(\d{4})-(\d{2})-(\d{2})(?=$|[-:])/;
+const SIZE = /^(?:\d+(?:\.\d+)?[bkm]|a\d+(?:\.\d+)?b|e\d+b|\d+x\d+b)$/;
+const SNAPSHOT = /^\d{4}$|^\d{6,8}$/;
+const NUMBER = /^\d+(?:\.\d+)*$/;
+/** Zero-padded short number (`001`, `05`): a revision or a date part, never a version. */
+const PADDED = /^0\d{1,2}$/;
+/** Bedrock's `-v1` / `-v2:0` revision suffix. Only a revision once a version was read. */
+const REVISION = /^v\d+$/;
+/** `v4.1`, `k2.5`, `r1`, `o3`, `qwen3.5`: letters then a version. */
+const LETTERS_VERSION = /^([a-z]+)(\d+(?:\.\d+)*)$/;
+/** `4o`: a version then letters. */
+const VERSION_LETTERS = /^(\d+(?:\.\d+)*)([a-z]+)$/;
+/** Words that mark a pre-release or an alias of the same model, not a different one. */
+const NOISE = /* @__PURE__ */ new Set([
+	"preview",
+	"latest",
+	"exp",
+	"experimental"
+]);
+function parseModelId(id) {
+	let rest = id.toLowerCase();
+	let variant = "";
+	const colon = rest.indexOf(":");
+	if (colon >= 0) {
+		variant = rest.slice(colon + 1);
+		rest = rest.slice(0, colon);
+	}
+	let vendor = "";
+	const slash = rest.lastIndexOf("/");
+	if (slash >= 0) {
+		vendor = rest.slice(0, slash);
+		rest = rest.slice(slash + 1);
+	}
+	let snapshot = "";
+	const dated = DATE_DASHED.exec(rest);
+	if (dated) {
+		snapshot = `${dated[1]}${dated[2]}${dated[3]}`;
+		rest = rest.slice(0, dated.index) + rest.slice(dated.index + dated[0].length);
+	}
+	const words = [];
+	const version = [];
+	const sizes = [];
+	const snapParts = [];
+	let afterNoise = false;
+	const pushVersion = (v) => {
+		for (const n of v.split(".")) version.push(Number(n));
+	};
+	for (const token of rest.split(/[-_\s]+/).filter(Boolean)) {
+		if (NOISE.has(token)) {
+			afterNoise = true;
+			continue;
+		}
+		if (SIZE.test(token)) {
+			sizes.push(token);
+			continue;
+		}
+		if ((words.length > 0 || version.length > 0) && (SNAPSHOT.test(token) || afterNoise && NUMBER.test(token) || version.length > 0 && (PADDED.test(token) || REVISION.test(token)))) {
+			snapParts.push(token);
+			continue;
+		}
+		if (NUMBER.test(token)) {
+			pushVersion(token);
+			continue;
+		}
+		const lv = LETTERS_VERSION.exec(token);
+		if (lv) {
+			words.push(lv[1]);
+			pushVersion(lv[2]);
+			continue;
+		}
+		const vl = VERSION_LETTERS.exec(token);
+		if (vl) {
+			pushVersion(vl[1]);
+			words.push(vl[2]);
+			continue;
+		}
+		words.push(token);
+	}
+	if (!snapshot && snapParts.length > 0) snapshot = snapParts.length === 2 && /^\d{2}$/.test(snapParts[0]) && /^\d{4}$/.test(snapParts[1]) ? `${snapParts[1]}${snapParts[0]}` : snapParts.join("");
+	return {
+		vendor,
+		family: words.join("-"),
+		version,
+		size: sizes.join("-"),
+		snapshot,
+		variant
+	};
+}
+/** Numeric, segment by segment; a longer version wins a tie on the shared prefix (`5.5` > `5`). */
+function compareModelVersion(a, b) {
+	const n = Math.max(a.length, b.length);
+	for (let i = 0; i < n; i++) {
+		const x = a[i];
+		const y = b[i];
+		if (x === void 0) return -1;
+		if (y === void 0) return 1;
+		if (x !== y) return x - y;
+	}
+	return 0;
+}
 /**
-* Split a prompt buffer into word-sized atomic segments suitable for a
-* flex-row + flex-wrap renderer (TUI) or a `display: inline` flow with
-* inline-block chips (GUI). Each chip becomes one segment (atomic —
-* never broken across rows); each plain run is split into "word +
-* trailing space" units so wraps land at clean word boundaries.
-*
-* Robust to:
-*   - Overlapping refs — sorted by start; later refs that overlap are
-*     dropped via the first-wins rule.
-*   - Out-of-bounds refs — dropped entirely when `end > text.length` or
-*     `start >= text.length`. Partial clipping would silently truncate
-*     a chip's label; the caller is in a better position to surface the
-*     mismatch (typically a stale `refs` array referencing a previous text).
-*   - Whitespace-only plain runs — emitted as their own plain segment
-*     so chip-adjacent-to-chip cases keep the original spacing.
-*
-* Word splitter rationale: `\S+\s*` keeps trailing whitespace attached
-* to its preceding word so wrap boundaries land between words (cleanly).
-* A leading-whitespace-only segment is captured by `\s+` so we don't
-* drop it entirely when the plain run starts with a space.
+* Among ids naming the same model (family, version and size equal), the one
+* a picker should show: the plain alias over a dated snapshot, the newest
+* snapshot among snapshots, no routing variant over a variant, then the
+* shorter id. Negative when `a` is preferred.
 */
-function splitPromptSegments(text, refs) {
-	const sorted = [...refs].filter((r) => r.end > r.start && r.start < text.length && r.end <= text.length).sort((a, b) => a.start - b.start);
-	const out = [];
-	let cursor = 0;
-	for (const ref of sorted) {
-		if (ref.start < cursor) continue;
-		if (ref.start > cursor) {
-			const matches = text.slice(cursor, ref.start).match(/\S+\s*|\s+/g) ?? [];
-			for (const m of matches) out.push({
-				kind: "plain",
-				text: m
-			});
-		}
-		out.push({
-			kind: "chip",
-			text: text.slice(ref.start, ref.end),
-			providerId: ref.providerId
-		});
-		cursor = ref.end;
+function preferAlias(a, b) {
+	const sa = a.parts.snapshot;
+	const sb = b.parts.snapshot;
+	if (!sa !== !sb) return sa ? 1 : -1;
+	if (sa !== sb) return sa < sb ? 1 : -1;
+	if (!a.parts.variant !== !b.parts.variant) return a.parts.variant ? 1 : -1;
+	return a.id.length - b.id.length || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+const lineupKey = (e) => `${e.providerKey}\u0000${e.modelId}`;
+/**
+* Keys (`provider\0model`) of the current models: per provider and family,
+* the newest version, one entry per size. `keep` entries (the active model,
+* fallback chain, off-catalog ids) are always included.
+*/
+function currentModelKeys(entries, keep = []) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const parts = parseModelId(entry.modelId);
+		const group = `${entry.providerKey}\u0000${parts.vendor}\u0000${parts.family}`;
+		const list = groups.get(group);
+		const item = {
+			id: entry.modelId,
+			key: lineupKey(entry),
+			parts
+		};
+		if (list) list.push(item);
+		else groups.set(group, [item]);
 	}
-	if (cursor < text.length) {
-		const matches = text.slice(cursor).match(/\S+\s*|\s+/g) ?? [];
-		for (const m of matches) out.push({
-			kind: "plain",
-			text: m
-		});
+	const kept = new Set(keep.map(lineupKey));
+	for (const list of groups.values()) {
+		let newest = [];
+		for (const item of list) if (compareModelVersion(item.parts.version, newest) > 0) newest = item.parts.version;
+		const bySize = /* @__PURE__ */ new Map();
+		for (const item of list) {
+			if (compareModelVersion(item.parts.version, newest) !== 0) continue;
+			const best = bySize.get(item.parts.size);
+			if (!best || preferAlias(item, best) < 0) bySize.set(item.parts.size, item);
+		}
+		for (const item of bySize.values()) kept.add(item.key);
 	}
-	return out;
+	return kept;
+}
+/** `entries` in their original order, current models only (see {@link currentModelKeys}). */
+function currentModels(entries, keep = []) {
+	const kept = currentModelKeys(entries, keep);
+	return entries.filter((entry) => kept.has(lineupKey(entry)));
 }
 //#endregion
 //#region src/chat/provider-usage-format.ts
@@ -3328,11 +2403,192 @@ function formatBalance(credits) {
 	return credits.total === null ? remaining : `${remaining} / ${formatCredits(credits.total)}`;
 }
 //#endregion
+//#region src/chat/spawn-tree.ts
+/** Worker id → the worker that spawned it, from nested spawn markers. */
+function spawnParents(rows) {
+	const parents = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const parent = row.spawn?.parentChildId;
+		if (row.childId !== void 0 && parent !== void 0 && (row.kind === "spawn-start" || row.kind === "spawn-end")) parents.set(row.childId, parent);
+	}
+	return parents;
+}
+/**
+* The worker `childId`'s rows belong under: its outermost ancestor that is
+* itself one of the `present` workers (the ones owning rows in this view).
+* A view that already re-based its owner's rows (a worker opened in a fold)
+* leaves that owner out of `present`, so the owner's direct children become
+* the lanes there. `childId` itself when no ancestor is present.
+*/
+function spawnLane(childId, parents, present) {
+	let lane = childId;
+	const seen = /* @__PURE__ */ new Set([lane]);
+	for (let parent = parents.get(lane); parent !== void 0 && present.has(parent) && !seen.has(parent); parent = parents.get(lane)) {
+		lane = parent;
+		seen.add(lane);
+	}
+	return lane;
+}
+/**
+* Lane resolver over one view's rows: precomputes the parent map and the
+* present-worker set, then maps a row's `childId` to its lane.
+*/
+function spawnLaneResolver(rows) {
+	const parents = spawnParents(rows);
+	if (parents.size === 0) return (childId) => childId;
+	const present = /* @__PURE__ */ new Set();
+	for (const row of rows) if (row.childId !== void 0) present.add(row.childId);
+	return (childId) => spawnLane(childId, parents, present);
+}
+//#endregion
 //#region src/chat/streaming-pure.ts
 const PARENT_OWNER = "parent";
 function ownerOf(event) {
 	return event.childId ?? PARENT_OWNER;
 }
+/** Is this event owned by a subagent (rather than the top-level agent)? */
+function isChildOwned(event) {
+	return event.childId !== void 0 || (event.depth ?? 0) > 0;
+}
+/**
+* Index of the event `owner`'s next delta may coalesce into, or `-1` when the
+* owner has no open lane at the tail.
+*
+* Walks backwards over events owned by OTHER subagents — concurrent siblings
+* whose rows carry no ordering relation to this owner's output, and which a
+* per-owner drain interleaves at ~60Hz — and stops at the first event that is
+* either this owner's or a real ordering boundary (parent output, user
+* prompts, banners). The caller decides whether the event found is mergeable
+* for its kind. A tail-only check splits every concurrent child's message
+* into fragments braided with its siblings'.
+*/
+function mergeTargetIndex(events, owner) {
+	for (let i = events.length - 1; i >= 0; i--) {
+		const event = events[i];
+		if (ownerOf(event) === owner) return i;
+		if (!isChildOwned(event)) return -1;
+	}
+	return -1;
+}
+/**
+* Default segment bound for a growing streaming markdown event. Coalescing
+* copies the ENTIRE accumulated string into fresh state on every drain tick,
+* so one long streamed message costs O(L²) aggregate — past this threshold
+* the event is split and the copy re-bounded. The split reuses
+* {@link chunkMarkdownForRender} (blank-line boundaries outside fences,
+* unsafe-continuation guard), so the finalized segments are byte-identical
+* to the chunks the renderer would have produced inside a single event, and
+* the one-row markdown/markdown margin stands in for the consumed blank line
+* exactly like the renderer's inter-chunk gap. When no safe boundary exists
+* (one giant fence/list) the event keeps growing until one arrives.
+*/
+const STREAMING_MARKDOWN_SEGMENT_CHARS = 65536;
+/**
+* Backoff for over-threshold events `chunkMarkdownForRender` could not
+* split (one giant fence/list): records the text length at the last failed
+* attempt, keyed on the streaming event object (re-keyed onto each tick's
+* replacement). Without it a single unsplittable segment re-runs the full
+* O(L) chunk walk on every drain tick. Growth is geometric (retry at +25%),
+* so total re-chunk work stays O(L) amortized.
+*/
+const unsplittableAtLength = /* @__PURE__ */ new WeakMap();
+const SEGMENT_SPLIT_RETRY_GROWTH = 1.25;
+/**
+* Stamp owner (parent vs subagent) + depth + optional `turnId` onto a
+* freshly-minted event so consumers can identify the producer and the
+* source turn. Parent-owned events leave `childId` / `depth` off; `depth` is
+* also left off when the source never named one.
+*/
+function tagEvent(evt, owner, depth, turnId) {
+	const withTurn = turnId ? {
+		...evt,
+		turnId
+	} : evt;
+	if (owner === PARENT_OWNER) return withTurn;
+	return {
+		...withTurn,
+		childId: owner,
+		...depth !== void 0 ? { depth } : {}
+	};
+}
+/** Coalesce a markdown delta into `owner`'s open streaming block, or open one. */
+function appendMarkdownDelta(prev, delta, owner, depth, turnId, options = {}) {
+	const segmentChars = options.segmentChars ?? 65536;
+	const at = mergeTargetIndex(prev, owner);
+	const target = at >= 0 ? prev[at] : void 0;
+	if (target && target.kind === "markdown" && target.streaming) {
+		const merged = target.text + delta;
+		const next = prev.slice();
+		if (merged.length > segmentChars) {
+			const lastFailed = unsplittableAtLength.get(target);
+			if (lastFailed === void 0 || merged.length > lastFailed * SEGMENT_SPLIT_RETRY_GROWTH) {
+				const chunks = chunkMarkdownForRender(merged);
+				if (chunks.length > 1) {
+					const segments = chunks.map((chunk, i) => i === chunks.length - 1 ? {
+						...target,
+						text: chunk
+					} : {
+						...target,
+						text: chunk,
+						streaming: false
+					});
+					next.splice(at, 1, ...segments);
+					return next;
+				}
+				const grown = {
+					...target,
+					text: merged
+				};
+				unsplittableAtLength.set(grown, merged.length);
+				next[at] = grown;
+				return next;
+			}
+			const grown = {
+				...target,
+				text: merged
+			};
+			unsplittableAtLength.set(grown, lastFailed);
+			next[at] = grown;
+			return next;
+		}
+		next[at] = {
+			...target,
+			text: merged
+		};
+		return next;
+	}
+	return [...prev, tagEvent({
+		kind: "markdown",
+		text: delta,
+		streaming: true
+	}, owner, depth, turnId)];
+}
+/** Coalesce a thinking delta into `owner`'s open lane, one row per line. */
+function appendThinkingLines(prev, delta, owner, depth, turnId, options = {}) {
+	const lines = delta.split("\n");
+	const at = mergeTargetIndex(prev, owner);
+	const target = at >= 0 ? prev[at] : void 0;
+	const row = (text) => tagEvent({
+		kind: "thinking",
+		text
+	}, owner, depth, turnId);
+	if (target && target.kind === "thinking") {
+		const next = prev.slice();
+		next[at] = {
+			...target,
+			text: target.text + lines[0]
+		};
+		if (lines.length > 1) next.splice(at + 1, 0, ...lines.slice(1).map(row));
+		return next;
+	}
+	const result = [...prev];
+	if (lines[0] || lines.length > 1) {
+		const first = row(lines[0]);
+		result.push(options.onLaneOpen ? options.onLaneOpen(first) : first);
+	}
+	for (let i = 1; i < lines.length; i++) result.push(row(lines[i]));
+	return result;
+}
 /** Flip any trailing streaming markdown blocks (any owner) to finalized. */
 function finalizeStreamingMarkdown(events) {
 	let changed = false;
@@ -3417,10 +2673,8 @@ function hiddenMarkerEvent(count) {
 	};
 }
 /**
-* Reveal one older page while retaining everything currently visible.
-* The default transcript is memory-bounded; memory grows only when the user
-* deliberately scrolls into the marker. The cut expands to a turn boundary
-* so tool-call/result groups are never split.
+* Swap one turn's rows for its rebuilt ones, in place; `null` when the turn
+* is not on show.
 */
 function replaceTranscriptTurnEvents(displayed, rebuilt, turnId) {
 	const replacements = rebuilt.filter((event) => event.turnId === turnId);
@@ -3433,6 +2687,26 @@ function replaceTranscriptTurnEvents(displayed, rebuilt, turnId) {
 	});
 	return inserted ? patched : null;
 }
+/**
+* A run in the transcript: everything from one of the user's own prompts
+* up to the next one. Revealing and capping move in whole runs, so the top
+* of the transcript always opens on a prompt, not halfway through what the
+* agent did for it.
+*/
+function isRunStart(e) {
+	return e !== void 0 && isTopLevelPrompt(e);
+}
+/** A run longer than this many reveal pages on its own is revealed in pieces of that size. */
+const WHOLE_RUN_REVEAL_PAGES = 5;
+/**
+* Reveal the earlier history while keeping everything on show: the whole
+* run right before it, and the runs before that while they fit `pageSize`
+* events together (several small runs at once, never part of one). A run
+* longer than {@link WHOLE_RUN_REVEAL_PAGES} pages on its own comes in
+* pieces that size, cut at a turn boundary so a tool call keeps its result.
+* The default transcript is memory-bounded; memory grows only when the user
+* deliberately scrolls into the marker.
+*/
 function revealEarlierTranscriptEvents(all, displayed, pageSize = 600) {
 	const hidden = hiddenEarlierTranscriptCount(displayed);
 	if (hidden <= 0) return displayed;
@@ -3440,12 +2714,63 @@ function revealEarlierTranscriptEvents(all, displayed, pageSize = 600) {
 	const anchorTurnId = tail.find((e) => e.turnId !== void 0)?.turnId;
 	const anchorIndex = anchorTurnId !== void 0 ? all.findIndex((e) => e.turnId === anchorTurnId) : -1;
 	const seam = anchorIndex >= 0 ? anchorIndex : Math.min(hidden, all.length);
-	let from = Math.max(0, seam - Math.max(1, pageSize));
-	while (from > 0 && all[from]?.turnId !== void 0 && all[from]?.turnId === all[from - 1]?.turnId) from--;
+	if (seam <= 0) return displayed;
+	const page = Math.max(1, pageSize);
+	/** Where the run holding `all[end - 1]` starts (0 when no prompt precedes it). */
+	const runStart = (end) => {
+		let i = end - 1;
+		while (i > 0 && !isRunStart(all[i])) i--;
+		return i;
+	};
+	let from = runStart(seam);
+	if (seam - from > page * WHOLE_RUN_REVEAL_PAGES) {
+		from = seam - page * WHOLE_RUN_REVEAL_PAGES;
+		while (from < seam - 1 && all[from]?.turnId !== void 0 && all[from]?.turnId === all[from - 1]?.turnId) from++;
+	} else while (from > 0) {
+		const previous = runStart(from);
+		if (seam - previous > page) break;
+		from = previous;
+	}
 	const out = [...all.slice(from, seam), ...tail];
 	if (from > 0) out.unshift(hiddenMarkerEvent(from));
 	return out;
 }
+/** The user's own prompt, not a subagent's. */
+function isTopLevelPrompt(e) {
+	return e.kind === "user-prompt" && !e.depth && (!e.childId || e.childId === "parent");
+}
+/** Index of the `n`-th last top-level user prompt at or after `from` (the earliest one when fewer); -1 with none. */
+function nthLastPrompt(events, n, from) {
+	let seen = 0;
+	let at = -1;
+	for (let i = events.length - 1; i >= from; i--) {
+		const e = events[i];
+		if (isTopLevelPrompt(e)) {
+			at = i;
+			if (++seen >= n) break;
+		}
+	}
+	return at;
+}
+/**
+* A transcript's end, with `earlier` events of the whole replay before it:
+* the hidden-count marker in front, as a cap would have left it.
+*/
+function withEarlierHidden(events, earlier) {
+	return earlier > 0 ? [hiddenMarkerEvent(earlier), ...events] : events;
+}
+/**
+* Whether the end of a transcript (from a turn boundary) is enough for
+* {@link capTranscriptEvents} at the default bounds: capping it behind its
+* hidden-count marker cuts exactly where capping the whole transcript
+* would. Over the cap, and holding the prompts the cut reaches back to.
+*/
+function coversTranscriptCap(events) {
+	if (events.length <= 1500) return false;
+	let prompts = 0;
+	for (const e of events) if (isTopLevelPrompt(e) && ++prompts >= 10) return true;
+	return false;
+}
 /**
 * Bound a transcript event array for display. Identity below the cap
 * (no re-render churn on the hot append path); above it, drops the
@@ -3469,7 +2794,14 @@ function capTranscriptEvents(events, max = MAX_TRANSCRIPT_EVENTS, trimTo = TRANS
 	}
 	let cut = events.length - keep;
 	if (cut <= start) return events;
+	const promptAt = nthLastPrompt(events, 10, start);
+	if (promptAt >= 0 && promptAt < cut) cut = Math.max(promptAt, events.length - Math.floor((max + keep) / 2), start + 1);
 	const turnAtCut = (i) => events[i]?.turnId;
+	if (!isRunStart(events[cut])) {
+		let next = cut + 1;
+		while (next < events.length && !isRunStart(events[next])) next++;
+		if (next < events.length) cut = next;
+	}
 	while (cut < events.length) {
 		const turn = turnAtCut(cut);
 		if (turn === void 0 || turn !== turnAtCut(cut - 1)) break;
@@ -3512,7 +2844,14 @@ const TOOL_DISPLAY = {
 		displayName: "Read",
 		format: (input) => {
 			const path = stringField(input, "path");
-			if (!path) return null;
+			if (!path) {
+				const paths = readFileInputPaths(input);
+				if (paths.length === 0) return null;
+				return {
+					target: paths[0],
+					meta: paths.length > 1 ? [`+${paths.length - 1} more`] : []
+				};
+			}
 			const meta = [];
 			const offset = numberField(input, "offset");
 			const limit = numberField(input, "limit");
@@ -3568,14 +2907,16 @@ const TOOL_DISPLAY = {
 		}
 	},
 	shell: {
-		displayName: (input) => input?.run_in_background === true ? "Shell (background)" : "Shell",
+		displayName: (input) => {
+			const description = input ? stringField(input, "description")?.trim() : void 0;
+			if (description) return previewLine(description, 120);
+			return input?.run_in_background === true ? "Shell (background)" : "Shell";
+		},
 		format: (input) => {
 			const command = stringField(input, "command");
 			if (!command) return null;
-			const description = stringField(input, "description");
-			const line = { target: truncate(command, 200) };
-			if (description && description.trim() !== "") line.meta = [truncate(description, 100)];
-			return line;
+			if (stringField(input, "description")?.trim()) return input.run_in_background === true ? { meta: ["background"] } : {};
+			return { target: previewLine(command, 200) };
 		}
 	},
 	shell_kill: {
@@ -3645,11 +2986,103 @@ const TOOL_DISPLAY = {
 			if (!task) return null;
 			const resume = stringField(input, "resume");
 			return {
-				target: truncate(task, 200),
+				target: previewLine(task, 200),
 				...resume ? { meta: [`resumed ${resume}`] } : {}
 			};
 		}
 	},
+	codemode: {
+		displayName: (input) => {
+			const description = input ? stringField(input, "description")?.trim() : void 0;
+			return description ? previewLine(description, 120) : "Codemode";
+		},
+		format: (input) => {
+			const description = stringField(input, "description")?.trim();
+			const code = stringField(input, "code");
+			const lines = code ? code.split("\n").filter((line) => line.trim() !== "" && !line.trimStart().startsWith("// @options:")) : [];
+			const meta = lines.length > 0 ? [`${lines.length} line${lines.length === 1 ? "" : "s"}`] : [];
+			if (description) return { meta };
+			if (lines.length === 0) return null;
+			return {
+				target: previewLine(lines[0].trim(), 120),
+				meta
+			};
+		}
+	},
+	browser_open: {
+		displayName: "Browser",
+		format: (input) => ({ target: stringField(input, "url") ?? "open" })
+	},
+	browser_navigate: {
+		displayName: "Navigate",
+		format: (input) => ({ target: stringField(input, "url") ?? stringField(input, "action") ?? "" })
+	},
+	browser_snapshot: {
+		displayName: "Snapshot",
+		format: () => ({ target: "page" })
+	},
+	browser_screenshot: {
+		displayName: "Screenshot",
+		format: (input) => ({ target: stringField(input, "ref") ?? "viewport" })
+	},
+	browser_click: {
+		displayName: "Click",
+		format: (input) => ({ target: browserTarget(input) })
+	},
+	browser_type: {
+		displayName: "Type",
+		format: (input) => {
+			const text = stringField(input, "text") ?? "";
+			const where = browserTarget(input);
+			return {
+				target: previewLine(JSON.stringify(text), 80),
+				...where ? { meta: [`into ${where}`] } : {}
+			};
+		}
+	},
+	browser_press: {
+		displayName: "Press",
+		format: (input) => {
+			return { target: [...Array.isArray(input.modifiers) ? input.modifiers.map(String) : [], stringField(input, "key") ?? ""].join("+") };
+		}
+	},
+	browser_scroll: {
+		displayName: "Scroll",
+		format: (input) => ({ target: `${numberField(input, "dx") ?? 0}, ${numberField(input, "dy") ?? 0}` })
+	},
+	browser_wait_for: {
+		displayName: "Wait for",
+		format: (input) => ({ target: stringField(input, "text") ?? stringField(input, "selector") ?? stringField(input, "urlIncludes") ?? "" })
+	},
+	browser_evaluate: {
+		displayName: "Evaluate",
+		format: (input) => ({ target: previewLine(stringField(input, "expression") ?? "", 120) })
+	},
+	browser_console: {
+		displayName: "Console",
+		format: (input) => ({ target: stringField(input, "level") ?? "all" })
+	},
+	terminal_list: {
+		displayName: "Terminals",
+		format: () => ({ target: "list" })
+	},
+	terminal_read: {
+		displayName: "Read terminal",
+		format: (input) => ({ target: stringField(input, "id") ?? "" })
+	},
+	terminal_write: {
+		displayName: "Type in terminal",
+		format: (input) => {
+			const text = stringField(input, "text");
+			const keys = Array.isArray(input.keys) ? input.keys.map(String).filter(Boolean) : [];
+			const typed = [text ? previewLine(JSON.stringify(text), 80) : "", ...keys].filter(Boolean).join(" + ");
+			const id = stringField(input, "id");
+			return {
+				target: typed || (id ?? ""),
+				...id && typed ? { meta: [id] } : {}
+			};
+		}
+	},
 	tool_search: {
 		displayName: "Search tools",
 		format: (input) => {
@@ -3697,7 +3130,7 @@ const TOOL_DISPLAY = {
 			if (!name || !script) return null;
 			const meta = [`skill ${name}`];
 			const args = Array.isArray(input.args) ? input.args : null;
-			if (args && args.length > 0) meta.push(truncate(args.map(String).join(" "), 80));
+			if (args && args.length > 0) meta.push(previewLine(args.map(String).join(" "), 80));
 			return {
 				target: script,
 				meta
@@ -3817,6 +3250,35 @@ function displayNameFor(name, input) {
 	return sentenceCase(name.startsWith("mcp_") ? name.slice(4) : name);
 }
 /**
+* The source code a tool call runs, for renderers that show it highlighted
+* instead of the raw JSON input: Codemode's script as JavaScript, a `shell`
+* / `bash` command as bash (the command alone: the label carries the
+* description, the rest is plumbing). `null` for
+* every other tool and for calls without the code field. `language` is a
+* fence-style name both highlighters accept (Shiki in the GUI, OpenTUI's
+* tree-sitter in the TUI).
+*/
+function toolInputCode(name, input) {
+	if (!input) return null;
+	if (name === "codemode") {
+		const code = stringField(input, "code");
+		if (!code || code.trim() === "") return null;
+		return {
+			code: code.replace(/^\n+|\s+$/g, ""),
+			language: "javascript"
+		};
+	}
+	if (name === "shell" || name === "bash") {
+		const command = stringField(input, "command");
+		if (!command || command.trim() === "") return null;
+		return {
+			code: command.replace(/^\n+|\s+$/g, ""),
+			language: "bash"
+		};
+	}
+	return null;
+}
+/**
 * Run a tool's curated formatter and return the result, or `null` when
 * no formatter is registered / the input shape doesn't match. Renderer
 * decides what to do with `null` — typically: show `↳ <displayName>`
@@ -3831,6 +3293,12 @@ function formatToolCall(name, input) {
 		return null;
 	}
 }
+/** A browser tool's target as written: ref, selector, or point. */
+function browserTarget(input) {
+	const x = numberField(input, "x");
+	const y = numberField(input, "y");
+	return stringField(input, "ref") ?? stringField(input, "selector") ?? (x !== void 0 && y !== void 0 ? `${x}, ${y}` : "");
+}
 function stringField(input, key) {
 	const v = input[key];
 	return typeof v === "string" && v.length > 0 ? v : void 0;
@@ -3846,139 +3314,7 @@ function sentenceCase(s) {
 	words[0] = (words[0][0]?.toUpperCase() ?? "") + words[0].slice(1);
 	return words.join(" ");
 }
-/**
-* Collapse internal whitespace (including newlines) to single spaces
-* and clip to `max` columns with a trailing `…`. The whitespace
-* normalisation is the load-bearing bit — tool input strings like a
-* shell heredoc or a multi-line Python `-c` script otherwise render
-* across several rows in the transcript even though the `↳ Tool …`
-* line is meant to be a single-line scannable summary.
-*/
-function truncate(s, max) {
-	const clean = s.replace(/\s+/g, " ").trim();
-	return clean.length <= max ? clean : `${clean.slice(0, max - 1)}…`;
-}
-function formatBytes(bytes) {
-	if (bytes < 1024) return `${bytes} B`;
-	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-//#endregion
-//#region src/chat/turn-operations.ts
-/**
-* Fork — keep every turn up to and including `turnId`, then strip any
-* `tool_call` blocks left without a matching `tool_result` in the slice.
-*
-* Semantics:
-*   - Include the selected turn ("branch from HERE" mental model — the
-*     user wants the selected message to be the latest in the fork).
-*   - If the selected turn is an assistant turn with unresolved
-*     `tool_call` blocks (their `tool_result`s live in turns AFTER the
-*     slice), strip those calls. Otherwise the fork would post an
-*     assistant turn with no matching tool results, breaking the next
-*     provider call.
-*   - Drop turns that become empty (all blocks stripped).
-*
-* Returns `null` when `turnId` doesn't exist in `turns` — caller should
-* surface a "turn not found" error rather than silently no-op.
-*/
-function truncateTurnsAt(turns, turnId) {
-	const idx = turns.findIndex((t) => t.id === turnId);
-	if (idx === -1) return null;
-	return stripOrphanToolBlocks(turns.slice(0, idx + 1));
-}
-/**
-* Delete — remove the turn with `turnId` and any tool blocks left
-* orphaned by the removal. Returns `null` when `turnId` doesn't exist.
-*
-* Strategy:
-*   1. Drop the target turn.
-*   2. Scan the remaining turns for `tool_call`s without a matching
-*      `tool_result` (orphaned by removing the user turn that carried
-*      the result), and `tool_result`s without a matching `tool_call`
-*      (orphaned by removing the assistant turn that issued the call).
-*      Strip both sides.
-*   3. Drop turns whose content is now empty.
-*
-* This guarantees the resulting history is protocol-clean — a follow-up
-* `agent.run()` against the modified session can post turns without the
-* provider rejecting the history.
-*/
-function deleteTurnSafely(turns, turnId) {
-	const idx = turns.findIndex((t) => t.id === turnId);
-	if (idx === -1) return null;
-	return stripOrphanToolBlocks([...turns.slice(0, idx), ...turns.slice(idx + 1)]);
-}
-/**
-* Walk a turn list and remove any tool blocks whose counterpart is
-* missing. Drops turns left empty. Used by `truncateTurnsAt` (which can
-* leave `tool_call`s orphaned when their results are past the cut) and
-* `deleteTurnSafely` (which can orphan either side of a pair).
-*
-* Pure / total: returns a new array; never throws.
-*/
-function stripOrphanToolBlocks(turns) {
-	const callIds = /* @__PURE__ */ new Set();
-	const resultIds = /* @__PURE__ */ new Set();
-	for (const turn of turns) for (const block of turn.content) if (block.type === "tool_call") callIds.add(block.id);
-	else if (block.type === "tool_result") resultIds.add(block.callId);
-	const result = [];
-	for (const turn of turns) {
-		const filtered = [];
-		for (const block of turn.content) {
-			if (block.type === "tool_call") {
-				if (!resultIds.has(block.id)) continue;
-			} else if (block.type === "tool_result") {
-				if (!callIds.has(block.callId)) continue;
-			}
-			filtered.push(block);
-		}
-		if (filtered.length === 0) continue;
-		result.push(filtered.length === turn.content.length ? turn : {
-			...turn,
-			content: filtered
-		});
-	}
-	return result;
-}
-/**
-* Serialize a turn's content to a clean text representation suited for
-* the clipboard. Joins text + thinking blocks verbatim; tool calls and
-* tool results get bracketed labels so the user can paste a readable
-* record of what happened without losing structure.
-*
-* Empty turns return `''`.
-*/
-function turnAsText(turn) {
-	const parts = [];
-	for (const block of turn.content) if (block.type === "text" && block.text.trim()) parts.push(block.text);
-	else if (block.type === "thinking" && block.text.trim()) parts.push(`[thinking]\n${block.text}`);
-	else if (block.type === "tool_call") parts.push(`[tool call · ${block.name}]\n${stringifyArgs(block.input)}`);
-	else if (block.type === "tool_result") parts.push(`[tool result]\n${typeof block.output === "string" ? block.output : JSON.stringify(block.output, null, 2)}`);
-	else if (block.type === "compact-summary") parts.push(`[compaction summary · ${block.replacesTurnIds.length} turn${block.replacesTurnIds.length === 1 ? "" : "s"}]\n${block.summary}`);
-	return parts.join("\n\n");
-}
-function stringifyArgs(input) {
-	try {
-		return JSON.stringify(input, null, 2);
-	} catch {
-		return String(input);
-	}
-}
-/**
-* Count turns before / after the one identified by `turnId` in the
-* given list. Returns `null` when the id is missing. Used to label the
-* turn-details modal with `N before · M after`.
-*/
-function countNeighbors(turnIds, turnId) {
-	const idx = turnIds.indexOf(turnId);
-	if (idx === -1) return null;
-	return {
-		before: idx,
-		after: turnIds.length - 1 - idx
-	};
-}
 //#endregion
-export { pickChainPrimary as $, fitRunReceiptCells as $t, indexOfEntry as A, createChatsCompletionProvider as An, selectableTurnIds as At, cacheBreakNoticeText as B, artifactsFromTurns as Bt, resetLabel as C, parseEditOutcomesFromResult as Cn, isUserBashEvent as Ct, splitPromptSegments as D, summarizeOutcomes as Dn, promptTurnRefs as Dt, usageTone as E, stripEditOutcomesAnnotation as En, promptHistoryFromEvents as Et, codeTokenHasClosingFence as F, MAIN_SESSION_TITLE as Ft, DAEMON_HEALTH_GLYPH as G, renderSessionEventXml as Gt, liveSessionCost as H, orchestratedBy as Ht, normalizeMarkdownCodeFences as I, ORCHESTRATED_BY_KEY as It, chainEntryKey as J, sessionEventLabel as Jt, DAEMON_HEALTH_STYLE as K, sessionDirLabel as Kt, splitMarkdownCodeBlocks as L, SESSION_EVENT_STATUS_STYLE as Lt, MARKDOWN_RENDER_CHUNK_TARGET_BYTES as M, streamEventSearchText as Mt, chunkMarkdownForRender as N, turnSelectionOwnership as Nt, buildModelCatalog as O, CHATS_TRIGGER as On, retagUserPromptEvents as Ot, closeDanglingCodeFence as P, MAIN_PLAYBOOK_FRAGMENT as Pt, filterChainFallbacks as Q, RUN_RECEIPT_GLYPH as Qt, stripHtmlCommentsOutsideCode as R, SESSION_ROLE_KEY as Rt, mostConstrainedWindow as S, mergeApprovalAndBodyOutcomes as Sn, isTurnHighlighted as St, updatedLabel as T, rewriteMultiEditHeader as Tn, isVisibleDuringSearch as Tt, retryLabel as U, parseSessionEventXml as Ut, compactingLabel as V, isMainSession as Vt, streamingLabel as W, renderProjectsBriefing as Wt, chainsEqual as X, shortSessionId as Xt, chainPositionOf as Y, sessionEventMeta as Yt, chainsEqualKeyed as Z, truncateTitle as Zt, turnContextSize as _, splitLines as _n, buildLinearRamp as _t, TOOL_DISPLAY as a, formatTokensPerSecond as an, sanitizeModelChain as at, formatCredits as b, buildEditOutcomesAnnotation as bn, EDIT_TOOL_NAMES as bt, MAX_TRANSCRIPT_EVENTS as c, applyEditPayload as cn, SKILLS_TRIGGER as ct, finalizeStreamingMarkdown as d, clipDiffForRender as dn, FILES_TRIGGER as dt, formatCostUsd as en, pickPrimaryKeyed as et, finalizeStreamingMarkdownForOwner as f, computeInlineDiff as fn, createFilesCompletionProvider as ft, revealEarlierTranscriptEvents as g, previewEditPayload as gn, blendHsl as gt, replaceTranscriptTurnEvents as h, filetypeFromPath as hn, createCommandsCompletionProvider as ht, turnAsText as i, formatTokenCount as in, restoreChainFallbacks as it, parseCustomModelQuery as j, uniqueChatIdsFromReferences as jn, selectionAfterTurnRemoval as jt, filterModelCatalog as k, chatReferenceTokensFromText as kn, retagUserPromptEventsFromRefs as kt, TRANSCRIPT_TRIM_TO_EVENTS as l, buildContextualDiff as ln, createSkillsCompletionProvider as lt, ownerOf as m, extractEditPayload as mn, COMMANDS_TRIGGER as mt, deleteTurnSafely as n, formatRunReceiptCells as nn, providerKeySetChanged as nt, displayNameFor as o, hasRunReceipt as on, toggleChainEntry as ot, hiddenEarlierTranscriptCount as p, computeLineDiff as pn, uniqueFilesFromReferences as pt, buildRunModel as q, sessionEventExcerpt as qt, truncateTurnsAt as r, formatRunReceiptLine as rn, reorderKeyed as rt, formatToolCall as s, runReceiptFromRun as sn, toggleKeyed as st, countNeighbors as t, formatRunDuration as tn, positionKeyed as tt, capTranscriptEvents as u, buildUnifiedDiff as un, uniqueSkillNamesFromReferences as ut, activeSnapshotFor as v, summarizeEditPayload as vn, BASH_CALL_ID_PREFIX as vt, showsAccount as w, resolveApprovalForPayload as wn, isVisible as wt, formatUsagePercent as x, maskToOutcomeKinds as xn, isEditErrorResult as xt, formatBalance as y, tokenize as yn, CACHE_NOTICE_LABEL as yt, cacheBreakChip as z, WORKER_REPORT_FRAGMENT as zt };
+export { chunkMarkdownForRender as $, MachineErrorCode as $t, showsAccount as A, BROWSER_TEXT_MAX_CHARS as At, indexOfEntry as B, liveSessionCost as Bt, spawnParents as C, TODO_STATUS_GLYPHS as Cn, BROWSER_ACTION_TIMEOUT_MS as Ct, formatUsagePercent as D, BROWSER_OPS as Dt, formatCredits as E, BROWSER_OPEN_MOUNT_MS as Et, currentModels as F, createChatsCompletionProvider as Ft, mcpFailureLine as G, daemonGate as Gt, MCP_KEY_REFUSED_HINT as H, runStatusLabel as Ht, parseModelId as I, uniqueChatIdsFromReferences as It, mcpFailureEvent as J, isKillSwitchEngaged as Jt, MCP_STATUS_LABEL as K, defineFeatureGate as Kt, buildModelCatalog as L, cacheBreakChip as Lt, usageTone as M, BrowserOpError as Mt, compareModelVersion as N, CHATS_TRIGGER as Nt, mostConstrainedWindow as O, BROWSER_OUTLINE_MAX_ELEMENTS as Ot, currentModelKeys as P, chatReferenceTokensFromText as Pt, MARKDOWN_RENDER_CHUNK_TARGET_BYTES as Q, MACHINE_STREAM_CHUNK_BYTES as Qt, customModelTargets as R, cacheBreakNoticeText as Rt, spawnLaneResolver as S, accentColor as Sn, TerminalError as St, formatBalance as T, BROWSER_MAX_WAIT_MS as Tt, classifyMcpTest as U, streamingLabel as Ut, parseCustomModelQuery as V, retryLabel as Vt, isMcpAuthRefusal as W, FEATURE_GATES as Wt, enabledMcpsWith as X, MACHINE_IDEMPOTENT_METHODS as Xt, reduceMcpAuth as Y, remoteHostsGate as Yt, enabledMcpsWithout as Z, MACHINE_PROTOCOL_VERSION as Zt, replaceTranscriptTurnEvents as _, retagUserPromptEventsFromRefs as _n, TERMINAL_HISTORY_MAX_CHARS as _t, MAX_TRANSCRIPT_EVENTS as a, BASH_CALL_ID_PREFIX as an, DAEMON_HEALTH_GLYPH as at, withEarlierHidden as b, streamEventSearchText as bn, TERMINAL_READ_MAX_CHARS as bt, appendMarkdownDelta as c, isEditErrorResult as cn, createSkillsCompletionProvider as ct, coversTranscriptCap as d, isVisible as dn, createFilesCompletionProvider as dt, isValidMachineName as en, closeDanglingCodeFence as et, finalizeStreamingMarkdown as f, isVisibleDuringSearch as fn, uniqueFilesFromReferences as ft, ownerOf as g, retagUserPromptEvents as gn, buildLinearRamp as gt, mergeTargetIndex as h, promptTurnRefs as hn, blendHsl as ht, toolInputCode as i, toMachineName as in, stripHtmlCommentsOutsideCode as it, updatedLabel as j, BROWSER_WAIT_TIMEOUT_MS as jt, resetLabel as k, BROWSER_REQUEST_SLACK_MS as kt, appendThinkingLines as l, isTurnHighlighted as ln, uniqueSkillNamesFromReferences as lt, hiddenEarlierTranscriptCount as m, promptHistoryFromEvents as mn, createCommandsCompletionProvider as mt, displayNameFor as n, machineKind as nn, normalizeMarkdownCodeFences as nt, STREAMING_MARKDOWN_SEGMENT_CHARS as o, CACHE_NOTICE_LABEL as on, DAEMON_HEALTH_STYLE as ot, finalizeStreamingMarkdownForOwner as p, messageSelectionOwnership as pn, COMMANDS_TRIGGER as pt, getMcpAuthStatus as q, engagedKillSwitches as qt, formatToolCall as r, parseMachineKind as rn, splitMarkdownCodeBlocks as rt, TRANSCRIPT_TRIM_TO_EVENTS as s, EDIT_TOOL_NAMES as sn, SKILLS_TRIGGER as st, TOOL_DISPLAY as t, machineCredentialKey as tn, codeTokenHasClosingFence as tt, capTranscriptEvents as u, isUserBashEvent as un, FILES_TRIGGER as ut, revealEarlierTranscriptEvents as v, selectableTurnIds as vn, TERMINAL_MAX_PER_SESSION as vt, activeSnapshotFor as w, BROWSER_EVALUATE_MAX_BYTES as wt, spawnLane as x, turnSelectionOwnership as xn, TERMINAL_TEXT_MAX_LINES as xt, turnContextSize as y, selectionAfterTurnRemoval as yn, TERMINAL_OUTPUT_WINDOW as yt, filterModelCatalog as z, compactingLabel as zt };
 
-//# sourceMappingURL=turn-operations-DrbJlpq9.js.map
+//# sourceMappingURL=tool-formatters-IQFDrdrs.js.map