dsh-code 0.7.0 → 0.8.0

package/lib/index.mjs

@@ -8,7 +8,7 @@ import { mkdir, readdir, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
-import { MessageId, ReasoningEffortId, assertNever, boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { MessageId, ReasoningEffortId, assertNever, boundContextSummary, createUserMessage, normalizeApiKey } from "@deepseek-ai/dsh-llm";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { PassThrough, Stream } from "node:stream";
 import process$1, { cwd, env } from "node:process";
@@ -24356,22 +24356,35 @@ function followInspectorCursor(cursor, previousLength, nextLength) {
 * tool payloads, skill descriptions). Control characters — including ANSI
 * CSI/OSC escape sequences — would otherwise pass through Ink into the
 * terminal, letting output rewrite the screen or inject prompts. Newlines
-* and tabs survive; everything else in C0/C1 plus DEL becomes a visible
-* `\xNN` escape.
+* survive; everything else in C0/C1 plus DEL becomes a visible `\xNN`
+* escape, and bidi overrides / invisible format controls / Unicode line and
+* paragraph separators become a visible `\uXXXX` escape (terminal emulators
+* that render bidirectional text would otherwise reorder the displayed
+* glyphs and let a command read as something it is not).
 *
 * @module @deepseek-ai/dsh-code/render/text
 */
 /** C0 controls except tab (0x09) and newline (0x0a), plus DEL and C1. */
 const CONTROL_ESCAPE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu;
 /**
-* Escape control characters so externally sourced text cannot drive the
-* terminal.
+* Bidi overrides and isolates (U+202A-202E, U+2066-2069), the Arabic Letter
+* Mark (U+061C), directional and zero-width format characters (U+200B,
+* U+200E/200F, U+2060-2064, U+FEFF), and Unicode line/paragraph separators
+* (U+2028/2029). Terminal emulators with bidi support (Windows Terminal,
+* iTerm2, kitty, WezTerm) reorder or hide these, so they must never reach
+* the terminal raw.
+*/
+const INVISIBLE_ESCAPE = /[\u061c\u200b\u200e\u200f\u2028\u2029\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu;
+/**
+* Escape control and deceptive characters so externally sourced text cannot
+* drive the terminal. C0/C1/DEL render as a literal `\xNN` escape; bidi,
+* invisible-format, and separator controls render as a literal `\uXXXX`
+* escape. Newlines and tabs survive (budgeted callers normalize tabs).
 * @param text - raw text from a session event, tool payload, or catalog.
-* @returns text with every control character (except `\n`, `\t`) rendered
-* as a literal `\xNN` escape.
+* @returns display-safe text with every injectable character made visible.
 */
 function displayText(text) {
-	return text.replace(CONTROL_ESCAPE, (char) => `\\x${char.charCodeAt(0).toString(16).padStart(2, "0")}`);
+	return text.replace(CONTROL_ESCAPE, (char) => `\\x${char.charCodeAt(0).toString(16).padStart(2, "0")}`).replace(INVISIBLE_ESCAPE, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
 }
 /** Collapse external text to one terminal-safe logical row. */
 function singleLineText(text) {
@@ -24423,7 +24436,10 @@ function previousCharacter(text, end) {
 * Keep only the newest display-safe text that fits a terminal rectangle.
 * The scan walks backward and stops as soon as the suffix is full, so a long
 * reasoning stream does not rescan its entire accumulated prefix per chunk.
-* Explicit newlines and terminal wrapping both consume rows.
+* Explicit newlines and terminal wrapping both consume rows; tabs expand to
+* two spaces so terminal tab stops (which render at contextual column 8
+* boundaries, not at the budgeted cell count) cannot inflate the physical
+* row count of the live region.
 * @param text - raw externally sourced text.
 * @param columns - available terminal columns.
 * @param rows - available terminal rows.
@@ -24446,7 +24462,7 @@ function displayTail(text, columns, rows) {
 			end = previous.start;
 			continue;
 		}
-		const safe = displayText(previous.char);
+		const safe = previous.char === "	" ? "  " : displayText(previous.char);
 		const width = cellWidth(safe);
 		if (used > 0 && used + width > columnLimit) {
 			if (row >= rowLimit) break;
@@ -24551,12 +24567,29 @@ const WHALE_GLYPH = [
 	"     ▀▀███████▀▀ ▀▀▀      "
 ];
 //#endregion
+//#region src/version.ts
+/** Installed dsh-code version exposed by the terminal header. */
+/** Read one package manifest version without making terminal startup depend on it. */
+function readPackageVersion(manifest = new URL("../package.json", import.meta.url)) {
+	try {
+		const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+		return typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+}
+/** Version of the installed dsh-code package. */
+const DSH_CODE_VERSION = readPackageVersion();
+//#endregion
 //#region src/render/tool-preview.ts
 /**
 * Bounded preview line for a tool invocation's raw JSON arguments: the first
 * human-meaningful string among the well-known keys (command, path, query, …)
 * with a fallback to the bounded raw JSON. Shared by the tool card in the
-* transcript and the approval bar's command preview.
+* transcript and the approval bar's command preview. Arguments longer than
+* {@link MAX_PARSE_CHARS} are never parsed: the preview is a display concern,
+* and a synchronous `JSON.parse` plus string copies of an unbounded model
+* payload must not run on the approval or projection paths.
 *
 * @module @deepseek-ai/dsh-code/render/tool-preview
 */
@@ -24570,6 +24603,16 @@ const PREVIEW_KEYS = [
 	"query"
 ];
 /**
+* Raw arguments longer than this are skipped without parsing and fall back
+* to the bounded raw preview. Well above any realistic command/path/query
+* string while keeping the synchronous parse cost negligible.
+*/
+const MAX_PARSE_CHARS = 4096;
+/** Bounded raw-arguments fallback shared by the skip-parse and parse-failure paths. */
+function boundedRawPreview(args) {
+	return args.length > 80 ? `${args.slice(0, 77)}...` : args;
+}
+/**
 * Resolve one bounded preview for raw tool arguments.
 * @param args - raw JSON arguments string as the model produced it.
 * @param toolName - the tool the arguments belong to (fallback label).
@@ -24577,6 +24620,7 @@ const PREVIEW_KEYS = [
 */
 function toolArgumentsPreview(args, toolName) {
 	if (args === "") return toolName;
+	if (args.length > MAX_PARSE_CHARS) return boundedRawPreview(args);
 	try {
 		const parsed = JSON.parse(args);
 		if (parsed !== null && typeof parsed === "object") {
@@ -24587,7 +24631,7 @@ function toolArgumentsPreview(args, toolName) {
 			}
 		}
 	} catch {}
-	return args.length > 80 ? `${args.slice(0, 77)}...` : args;
+	return boundedRawPreview(args);
 }
 //#endregion
 //#region src/render/tool-detail.ts
@@ -24609,6 +24653,9 @@ const MAX_READ_LINES = 120;
 const MAX_SOURCES = 10;
 const MAX_RAW_CHARS = 6e3;
 const MAX_LINE_COLUMNS = 240;
+/** Hard caps on adversarial `tool/result.meta` before any row is built. */
+const MAX_DIFFS = 8;
+const MAX_DIFF_TEXT_CHARS = 24e3;
 /** Truncate one line to the visible-column budget with an ellipsis marker. */
 function clipLine(text) {
 	return text.length > MAX_LINE_COLUMNS ? `${text.slice(0, 239)}…` : text;
@@ -24622,35 +24669,51 @@ function toLines(text) {
 * Render one change as removed-then-added rows, hunked by common prefix and
 * suffix. A null before-image (file create) renders as pure additions. The
 * budget caps emitted rows and reports the cut, so a whole-file overwrite
-* never floods the transcript.
+* never floods the transcript. Inputs are hard-capped before line splitting
+* and the row list is built incrementally up to the budget — a crafted or
+* replayed giant diff cannot force a full intermediate rows array.
 * @param oldText - prior content, or null for a create.
 * @param newText - content after the change.
 * @param budget - maximum rows to emit.
 * @returns the bounded rows and whether they were cut.
 */
 function diffRows(oldText, newText, budget) {
-	const oldLines = oldText === null ? [] : toLines(oldText);
-	const newLines = toLines(newText);
+	const oldRaw = oldText ?? "";
+	const newRaw = newText;
+	let inputTruncated = false;
+	let oldSource = oldRaw;
+	let newSource = newRaw;
+	const combined = oldRaw.length + newRaw.length;
+	if (combined > MAX_DIFF_TEXT_CHARS) {
+		inputTruncated = true;
+		const oldShare = Math.min(oldRaw.length, Math.floor(MAX_DIFF_TEXT_CHARS * oldRaw.length / combined));
+		const newShare = Math.min(newRaw.length, MAX_DIFF_TEXT_CHARS - oldShare);
+		oldSource = oldRaw.slice(0, oldShare);
+		newSource = newRaw.slice(0, newShare);
+	}
+	const oldLines = oldText === null ? [] : toLines(oldSource);
+	const newLines = toLines(newSource);
 	let prefix = 0;
 	while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) prefix += 1;
 	let suffix = 0;
 	while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix && oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]) suffix += 1;
-	const removed = oldLines.slice(prefix, oldLines.length - suffix);
-	const added = newLines.slice(prefix, newLines.length - suffix);
-	const rows = [...removed.map((text) => ({
+	const removedCount = oldLines.length - prefix - suffix;
+	const addedCount = newLines.length - prefix - suffix;
+	const truncated = inputTruncated || removedCount + addedCount > budget;
+	const rows = [];
+	const removedLimit = Math.min(removedCount, Math.max(0, budget));
+	for (let index = 0; index < removedLimit; index += 1) rows.push({
 		mark: "-",
-		text: clipLine(text)
-	})), ...added.map((text) => ({
+		text: clipLine(oldLines[prefix + index] ?? "")
+	});
+	const addedLimit = Math.min(addedCount, Math.max(0, budget - removedLimit));
+	for (let index = 0; index < addedLimit; index += 1) rows.push({
 		mark: "+",
-		text: clipLine(text)
-	}))];
-	if (rows.length <= budget) return {
-		lines: rows,
-		truncated: false
-	};
+		text: clipLine(newLines[prefix + index] ?? "")
+	});
 	return {
-		lines: rows.slice(0, budget),
-		truncated: true
+		lines: rows,
+		truncated
 	};
 }
 /** Whether `value` is a valid upstream FileDiff (defensive narrowing). */
@@ -24684,44 +24747,60 @@ function toolResultDetail(meta, rawText) {
 	if (typeof meta === "object" && meta !== null && !Array.isArray(meta)) {
 		const record = meta;
 		const diffs = record["diffs"];
-		if (Array.isArray(diffs) && diffs.length > 0 && diffs.every(isFileDiff)) {
-			const budget = Math.max(8, Math.floor(MAX_DIFF_LINES / diffs.length));
-			return {
-				kind: "diff",
-				diffs: diffs.map((diff) => ({
-					path: diff.path,
-					...diffRows(diff.oldText, diff.newText, budget)
-				}))
-			};
+		if (Array.isArray(diffs) && diffs.length > 0) {
+			const capped = diffs.slice(0, MAX_DIFFS);
+			if (capped.every(isFileDiff)) {
+				const budget = Math.max(8, Math.floor(MAX_DIFF_LINES / capped.length));
+				const dropped = diffs.length > capped.length;
+				return {
+					kind: "diff",
+					diffs: capped.map((diff, index) => {
+						const rows = diffRows(diff.oldText, diff.newText, budget);
+						return dropped && index === capped.length - 1 ? {
+							path: diff.path,
+							...rows,
+							truncated: true
+						} : {
+							path: diff.path,
+							...rows
+						};
+					})
+				};
+			}
 		}
 		const { path, offset, lines, totalLines } = record;
-		if (typeof path === "string" && Number.isInteger(offset) && offset >= 1 && Number.isInteger(totalLines) && totalLines >= 0 && Array.isArray(lines) && lines.every(isReadLine)) {
-			const window = lines;
-			const truncated = window.length > MAX_READ_LINES;
-			return {
-				kind: "read",
-				path,
-				offset,
-				lines: (truncated ? window.slice(0, MAX_READ_LINES) : window).map((line) => ({
-					number: line.number,
-					text: clipLine(line.text)
-				})),
-				totalLines,
-				truncated
-			};
+		if (typeof path === "string" && Number.isInteger(offset) && offset >= 1 && Number.isInteger(totalLines) && totalLines >= 0 && Array.isArray(lines)) {
+			const window = lines.slice(0, MAX_READ_LINES);
+			if (window.every(isReadLine)) {
+				const truncated = lines.length > MAX_READ_LINES;
+				return {
+					kind: "read",
+					path,
+					offset,
+					lines: window.map((line) => ({
+						number: line.number,
+						text: clipLine(line.text)
+					})),
+					totalLines,
+					truncated
+				};
+			}
 		}
 		const sources = record["sources"];
-		if (Array.isArray(sources) && sources.every(isWebSource)) {
-			const truncated = sources.length > MAX_SOURCES;
-			return {
-				kind: "web-search",
-				sources: (truncated ? sources.slice(0, MAX_SOURCES) : sources).map((source) => ({
-					url: source.url,
-					title: typeof source.title === "string" ? source.title : void 0,
-					snippet: typeof source.snippet === "string" ? clipLine(source.snippet) : ""
-				})),
-				truncated
-			};
+		if (Array.isArray(sources)) {
+			const capped = sources.slice(0, MAX_SOURCES);
+			if (capped.every(isWebSource)) {
+				const truncated = sources.length > MAX_SOURCES;
+				return {
+					kind: "web-search",
+					sources: capped.map((source) => ({
+						url: source.url,
+						title: typeof source.title === "string" ? source.title : void 0,
+						snippet: typeof source.snippet === "string" ? clipLine(source.snippet) : ""
+					})),
+					truncated
+				};
+			}
 		}
 		const { url, statusCode } = record;
 		if (typeof url === "string" && typeof statusCode === "number") return {
@@ -24750,6 +24829,15 @@ function toolResultDetail(meta, rawText) {
 */
 /** In-flight UI buffers are tails; the assembled assistant message is authoritative. */
 const MAX_STREAMING_CHARS = 65536;
+/**
+* Upper bound on remembered `compaction/summary` shadow prices waiting for a
+* matching `compaction/end`. Compactions are sequential and rare, so a few
+* slots suffice; an aborted compaction (summary without end) otherwise leaves
+* an unbounded residue in `anchors.compactionTokens`. An evicted price
+* degrades to the documented `lastPruneTokens` fallback, exactly like a
+* missing summary.
+*/
+const MAX_COMPACTION_SUMMARY_RESIDUE = 16;
 /** Append one delta without retaining an unbounded duplicate of the live reply. */
 function appendStreamingTail(current, delta) {
 	const next = current + delta;
@@ -24828,7 +24916,9 @@ function createTranscriptView() {
 			firstChunkAt: /* @__PURE__ */ new Map(),
 			compactionTokens: /* @__PURE__ */ new Map(),
 			lastPruneTokens: 0,
-			turnFiles: /* @__PURE__ */ new Map()
+			turnFiles: /* @__PURE__ */ new Map(),
+			turnSteps: /* @__PURE__ */ new Map(),
+			turnTools: /* @__PURE__ */ new Map()
 		}
 	};
 }
@@ -24954,6 +25044,7 @@ function projectEvent(view, event) {
 			view.anchors.stepStart.delete(key);
 			const firstChunk = view.anchors.firstChunkAt.get(key);
 			view.anchors.firstChunkAt.delete(key);
+			if (view.anchors.turnSteps.get(event.data.turn) === key) view.anchors.turnSteps.delete(event.data.turn);
 			const usage = event.data.usage;
 			const totals = view.stats.usage;
 			const text = textOf(event.data.message.content);
@@ -24989,6 +25080,9 @@ function projectEvent(view, event) {
 		case "tool/call": {
 			const data = event.data;
 			view.anchors.toolStart.set(data.callId, event.time);
+			const turnTools = view.anchors.turnTools.get(data.turn) ?? /* @__PURE__ */ new Set();
+			turnTools.add(data.callId);
+			view.anchors.turnTools.set(data.turn, turnTools);
 			return {
 				...view,
 				entries: [...view.entries, {
@@ -25014,6 +25108,11 @@ function projectEvent(view, event) {
 			const block = event.data.message.content[0];
 			const started = view.anchors.toolStart.get(block.toolCallId);
 			view.anchors.toolStart.delete(block.toolCallId);
+			const turnTools = view.anchors.turnTools.get(event.data.turn);
+			if (turnTools !== void 0) {
+				turnTools.delete(block.toolCallId);
+				if (turnTools.size === 0) view.anchors.turnTools.delete(event.data.turn);
+			}
 			const rawText = textOf(block.content);
 			const summary = boundContextSummary(rawText);
 			const detail = toolResultDetail(event.data.meta, rawText);
@@ -25058,8 +25157,15 @@ function projectEvent(view, event) {
 				turns: view.stats.turns + 1
 			}
 		};
-		case "step/start":
-			view.anchors.stepStart.set(`${event.data.turn}:${event.data.step}`, event.time);
+		case "step/start": {
+			const key = `${event.data.turn}:${event.data.step}`;
+			const previous = view.anchors.turnSteps.get(event.data.turn);
+			if (previous !== void 0 && previous !== key) {
+				view.anchors.stepStart.delete(previous);
+				view.anchors.firstChunkAt.delete(previous);
+			}
+			view.anchors.turnSteps.set(event.data.turn, key);
+			view.anchors.stepStart.set(key, event.time);
 			return {
 				...view,
 				stats: {
@@ -25067,14 +25173,17 @@ function projectEvent(view, event) {
 					steps: view.stats.steps + 1
 				}
 			};
+		}
 		case "turn/end": {
 			const reason = event.data.reason;
 			const appended = [];
-			if (reason.kind === "error") appended.push({
-				kind: "error",
-				text: `${reason.error.code}: ${reason.error.message}`
-			});
-			else {
+			if (reason.kind === "error") {
+				const recovery = reason.error.code === "MISSING_CREDENTIAL" ? " · open /model to add an API key" : "";
+				appended.push({
+					kind: "error",
+					text: `${reason.error.code}: ${reason.error.message}${recovery}`
+				});
+			} else {
 				const marker = reason.kind === "aborted" ? reason.reason.kind === "user" ? "turn cancelled by the user" : `turn cancelled (${reason.reason.kind})` : reason.kind === "max-tokens" ? "turn hit the output-token ceiling (max-tokens)" : reason.kind === "blocked" ? "turn ended blocked" : reason.kind === "interrupted" ? "turn was interrupted by a restart" : void 0;
 				if (marker !== void 0) appended.push({
 					kind: "turn-marker",
@@ -25087,6 +25196,17 @@ function projectEvent(view, event) {
 				kind: "files",
 				paths: [...files].slice(0, 12)
 			});
+			const stepKey = view.anchors.turnSteps.get(event.data.turn);
+			if (stepKey !== void 0) {
+				view.anchors.stepStart.delete(stepKey);
+				view.anchors.firstChunkAt.delete(stepKey);
+				view.anchors.turnSteps.delete(event.data.turn);
+			}
+			const turnToolSet = view.anchors.turnTools.get(event.data.turn);
+			if (turnToolSet !== void 0) {
+				for (const callId of turnToolSet) view.anchors.toolStart.delete(callId);
+				view.anchors.turnTools.delete(event.data.turn);
+			}
 			if (appended.length === 0) return {
 				...view,
 				busy: false,
@@ -25165,6 +25285,10 @@ function projectEvent(view, event) {
 			title: event.data.title
 		};
 		case "compaction/summary":
+			if (view.anchors.compactionTokens.size >= MAX_COMPACTION_SUMMARY_RESIDUE) {
+				const oldest = view.anchors.compactionTokens.keys().next().value;
+				if (oldest !== void 0) view.anchors.compactionTokens.delete(oldest);
+			}
 			view.anchors.compactionTokens.set(event.data.compactionId, event.data.shadowedTokenCount);
 			return view;
 		case "compaction/prune": return {
@@ -25250,13 +25374,561 @@ function projectEvent(view, event) {
 		default: return view;
 	}
 }
+/** @internal A fresh replay accumulator whose state mirrors `createTranscriptView()`. */
+function createReplayAccumulator() {
+	return {
+		entries: [],
+		toolIndex: /* @__PURE__ */ new Map(),
+		commandIndex: /* @__PURE__ */ new Map(),
+		retryIndex: /* @__PURE__ */ new Map(),
+		pendingIndex: /* @__PURE__ */ new Map(),
+		removedCount: 0,
+		pendingTurn: [],
+		pendingStep: [],
+		streaming: "",
+		streamingReasoning: "",
+		todos: [],
+		busy: false,
+		busySince: 0,
+		model: "",
+		plan: false,
+		permission: "",
+		title: "",
+		sandbox: "",
+		goal: void 0,
+		stats: {
+			turns: 0,
+			steps: 0,
+			llmMs: 0,
+			toolMs: 0,
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0
+			},
+			lastPromptTokens: 0,
+			contextWindow: 0,
+			contextSegments: {
+				system: 0,
+				prompt: 0,
+				assistant: 0,
+				thinking: 0,
+				tools: 0
+			},
+			ttftMs: 0,
+			ttftSteps: 0,
+			decodeMs: 0,
+			decodeTokens: 0,
+			reasoningEffort: ""
+		},
+		stepStart: /* @__PURE__ */ new Map(),
+		toolStart: /* @__PURE__ */ new Map(),
+		firstChunkAt: /* @__PURE__ */ new Map(),
+		compactionTokens: /* @__PURE__ */ new Map(),
+		lastPruneTokens: 0,
+		turnFiles: /* @__PURE__ */ new Map(),
+		turnSteps: /* @__PURE__ */ new Map(),
+		turnTools: /* @__PURE__ */ new Map(),
+		ops: 0
+	};
+}
+/** Append one entry (O(1)) and account the push. */
+function appendReplayEntry(acc, entry) {
+	acc.entries.push(entry);
+	acc.ops += 1;
+}
+/**
+* Get (or create) the index list an id owns. Lists are never removed: every
+* appended row registers its index, so a lookup miss later proves no matching
+* row exists and the caller can no-op in O(1).
+*/
+function indexList(map, id) {
+	let list = map.get(id);
+	if (list === void 0) {
+		list = [];
+		map.set(id, list);
+	}
+	return list;
+}
+/**
+* Apply an id-keyed update to every row that registered the id, mirroring the
+* copy-on-write reducer's full-array map semantics (all matching rows update,
+* in order). Each registered index is O(1), so a duplicate id costs
+* O(#duplicates) — never a full-array scan. The kind+id re-check is defensive:
+* registered indices are valid by construction, because tool/command/retry
+* rows are never removed and tombstones never shift indices.
+*/
+function updateReplayById(acc, map, id, isMatch, update) {
+	const list = map.get(id);
+	if (list === void 0) return;
+	for (const index of list) {
+		const entry = acc.entries[index];
+		if (entry === void 0 || !isMatch(entry)) continue;
+		acc.entries[index] = update(entry);
+		acc.ops += 1;
+	}
+}
+/** Tombstone a retired pending row, keeping every other index stable. */
+function retireReplayEntry(acc, index) {
+	if (acc.entries[index] !== void 0) {
+		acc.entries[index] = void 0;
+		acc.removedCount += 1;
+		acc.ops += 1;
+	}
+}
+/**
+* Fold one session event into a replay accumulator. This mirrors
+* {@link projectEvent} case for case — same stats arithmetic, same anchor
+* set/delete behavior, same entry shapes — so the finished view is identical
+* to a sequential fold; only the `entries` container operations are mutable.
+*
+* @internal Test-instrumentation path; `projectEvents` is the public entry.
+*/
+function replayProjectEvent(acc, event) {
+	switch (event.type) {
+		case "user/message": {
+			const message = event.data;
+			for (const target of ["next-turn", "next-step"]) {
+				const ids = target === "next-turn" ? acc.pendingTurn : acc.pendingStep;
+				const index = ids.indexOf(message.id);
+				acc.ops += index < 0 ? ids.length : index + 1;
+				if (index < 0) continue;
+				ids.splice(index, 1);
+				acc.ops += 1;
+				const list = acc.pendingIndex.get(message.id);
+				if (list !== void 0) {
+					for (const entryIndex of list) retireReplayEntry(acc, entryIndex);
+					acc.ops += 1;
+				}
+			}
+			const text = textOf(message.content);
+			if (message.source.kind === "user") {
+				appendReplayEntry(acc, {
+					kind: "user",
+					text,
+					notice: false
+				});
+				acc.stats = {
+					...acc.stats,
+					contextSegments: {
+						...acc.stats.contextSegments,
+						prompt: acc.stats.contextSegments.prompt + estimateTokens(text)
+					}
+				};
+				return;
+			}
+			const notice = message.source.kind === "plugin" && message.source.form === "notice" ? message.source.summary : message.source.kind;
+			const summary = boundContextSummary(notice);
+			appendReplayEntry(acc, {
+				kind: "user",
+				text: summary,
+				notice: true
+			});
+			acc.stats = {
+				...acc.stats,
+				contextSegments: {
+					...acc.stats.contextSegments,
+					system: acc.stats.contextSegments.system + estimateTokens(summary)
+				}
+			};
+			return;
+		}
+		case "agent/inbox/spliced": {
+			const { target, start, removedCount = 0, inserted } = event.data;
+			const ids = target === "next-turn" ? acc.pendingTurn : acc.pendingStep;
+			const removed = ids.slice(start, start + removedCount);
+			acc.ops += removed.length;
+			ids.splice(start, removedCount);
+			acc.ops += removed.length;
+			for (const id of removed) {
+				const list = acc.pendingIndex.get(id);
+				if (list === void 0) continue;
+				for (const entryIndex of list) {
+					const entry = acc.entries[entryIndex];
+					if (entry !== void 0 && entry.kind === "pending" && entry.target === target) retireReplayEntry(acc, entryIndex);
+				}
+			}
+			for (const message of inserted) {
+				appendReplayEntry(acc, {
+					kind: "pending",
+					messageId: message.id,
+					target,
+					text: pendingText(message.content)
+				});
+				indexList(acc.pendingIndex, message.id).push(acc.entries.length - 1);
+				ids.push(message.id);
+				acc.ops += 1;
+			}
+			return;
+		}
+		case "assistant/chunk": {
+			const chunk = event.data.chunk;
+			const key = `${event.data.turn}:${event.data.step}`;
+			if ((chunk.type === "text-delta" || chunk.type === "reasoning-delta" ? chunk.text : "") !== "" && !acc.firstChunkAt.has(key)) {
+				acc.firstChunkAt.set(key, event.time);
+				const started = acc.stepStart.get(key);
+				if (started !== void 0) acc.stats = {
+					...acc.stats,
+					ttftMs: acc.stats.ttftMs + Math.max(0, event.time - started),
+					ttftSteps: acc.stats.ttftSteps + 1
+				};
+			}
+			if (chunk.type === "text-delta") {
+				acc.streaming = appendStreamingTail(acc.streaming, chunk.text);
+				return;
+			}
+			if (chunk.type === "reasoning-delta") {
+				acc.streamingReasoning = appendStreamingTail(acc.streamingReasoning, chunk.text);
+				return;
+			}
+			return;
+		}
+		case "assistant/message": {
+			const key = `${event.data.turn}:${event.data.step}`;
+			const started = acc.stepStart.get(key);
+			acc.stepStart.delete(key);
+			const firstChunk = acc.firstChunkAt.get(key);
+			acc.firstChunkAt.delete(key);
+			if (acc.turnSteps.get(event.data.turn) === key) acc.turnSteps.delete(event.data.turn);
+			const usage = event.data.usage;
+			const totals = acc.stats.usage;
+			const text = textOf(event.data.message.content);
+			const reasoning = reasoningOf(event.data.message.content);
+			acc.streaming = "";
+			acc.streamingReasoning = "";
+			appendReplayEntry(acc, {
+				kind: "assistant",
+				text,
+				reasoning
+			});
+			acc.stats = {
+				...acc.stats,
+				llmMs: acc.stats.llmMs + (started === void 0 ? 0 : Math.max(0, event.time - started)),
+				usage: usage === void 0 ? totals : {
+					inputTokens: totals.inputTokens + usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
+					outputTokens: totals.outputTokens + usage.outputTokens,
+					cacheReadTokens: totals.cacheReadTokens + (usage.cacheReadTokens ?? 0)
+				},
+				lastPromptTokens: usage === void 0 ? acc.stats.lastPromptTokens : usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
+				decodeMs: acc.stats.decodeMs + (firstChunk === void 0 ? 0 : Math.max(0, event.time - firstChunk)),
+				decodeTokens: acc.stats.decodeTokens + (firstChunk === void 0 || usage === void 0 ? 0 : usage.outputTokens),
+				contextSegments: {
+					...acc.stats.contextSegments,
+					thinking: acc.stats.contextSegments.thinking + estimateTokens(reasoning),
+					assistant: acc.stats.contextSegments.assistant + estimateTokens(text)
+				}
+			};
+			return;
+		}
+		case "tool/call": {
+			const data = event.data;
+			acc.toolStart.set(data.callId, event.time);
+			const turnTools = acc.turnTools.get(data.turn) ?? /* @__PURE__ */ new Set();
+			turnTools.add(data.callId);
+			acc.turnTools.set(data.turn, turnTools);
+			appendReplayEntry(acc, {
+				kind: "tool",
+				callId: data.callId,
+				name: data.name,
+				arguments: data.arguments,
+				preview: toolArgumentsPreview(data.arguments, data.name),
+				state: "running",
+				summary: "",
+				detail: void 0
+			});
+			indexList(acc.toolIndex, data.callId).push(acc.entries.length - 1);
+			acc.stats = {
+				...acc.stats,
+				contextSegments: {
+					...acc.stats.contextSegments,
+					tools: acc.stats.contextSegments.tools + (typeof data.arguments === "string" ? estimateTokens(data.arguments) : 0)
+				}
+			};
+			return;
+		}
+		case "tool/result": {
+			const block = event.data.message.content[0];
+			const started = acc.toolStart.get(block.toolCallId);
+			acc.toolStart.delete(block.toolCallId);
+			const turnTools = acc.turnTools.get(event.data.turn);
+			if (turnTools !== void 0) {
+				turnTools.delete(block.toolCallId);
+				if (turnTools.size === 0) acc.turnTools.delete(event.data.turn);
+			}
+			const rawText = textOf(block.content);
+			const summary = boundContextSummary(rawText);
+			const detail = toolResultDetail(event.data.meta, rawText);
+			if (detail?.kind === "diff") {
+				const set = acc.turnFiles.get(event.data.turn) ?? /* @__PURE__ */ new Set();
+				for (const diff of detail.diffs) set.add(diff.path);
+				acc.turnFiles.set(event.data.turn, set);
+			}
+			const update = (entry) => ({
+				...entry,
+				state: block.isError === true ? "error" : "done",
+				summary,
+				detail
+			});
+			updateReplayById(acc, acc.toolIndex, block.toolCallId, (entry) => entry.callId === block.toolCallId, update);
+			acc.stats = {
+				...acc.stats,
+				toolMs: acc.stats.toolMs + (started === void 0 ? 0 : Math.max(0, event.time - started)),
+				contextSegments: {
+					...acc.stats.contextSegments,
+					tools: acc.stats.contextSegments.tools + estimateTokens(rawText)
+				}
+			};
+			return;
+		}
+		case "todo/write":
+			acc.todos = event.data.todos;
+			return;
+		case "turn/start": {
+			const wasBusy = acc.busy;
+			acc.busy = true;
+			acc.busySince = wasBusy ? acc.busySince : event.time;
+			acc.todos = [];
+			acc.stats = {
+				...acc.stats,
+				turns: acc.stats.turns + 1
+			};
+			return;
+		}
+		case "step/start": {
+			const key = `${event.data.turn}:${event.data.step}`;
+			const previous = acc.turnSteps.get(event.data.turn);
+			if (previous !== void 0 && previous !== key) {
+				acc.stepStart.delete(previous);
+				acc.firstChunkAt.delete(previous);
+			}
+			acc.turnSteps.set(event.data.turn, key);
+			acc.stepStart.set(key, event.time);
+			acc.stats = {
+				...acc.stats,
+				steps: acc.stats.steps + 1
+			};
+			return;
+		}
+		case "turn/end": {
+			const reason = event.data.reason;
+			const appended = [];
+			if (reason.kind === "error") {
+				const recovery = reason.error.code === "MISSING_CREDENTIAL" ? " · open /model to add an API key" : "";
+				appended.push({
+					kind: "error",
+					text: `${reason.error.code}: ${reason.error.message}${recovery}`
+				});
+			} else {
+				const marker = reason.kind === "aborted" ? reason.reason.kind === "user" ? "turn cancelled by the user" : `turn cancelled (${reason.reason.kind})` : reason.kind === "max-tokens" ? "turn hit the output-token ceiling (max-tokens)" : reason.kind === "blocked" ? "turn ended blocked" : reason.kind === "interrupted" ? "turn was interrupted by a restart" : void 0;
+				if (marker !== void 0) appended.push({
+					kind: "turn-marker",
+					text: marker
+				});
+			}
+			const files = acc.turnFiles.get(event.data.turn);
+			acc.turnFiles.delete(event.data.turn);
+			if (files !== void 0 && files.size > 0) appended.push({
+				kind: "files",
+				paths: [...files].slice(0, 12)
+			});
+			const stepKey = acc.turnSteps.get(event.data.turn);
+			if (stepKey !== void 0) {
+				acc.stepStart.delete(stepKey);
+				acc.firstChunkAt.delete(stepKey);
+				acc.turnSteps.delete(event.data.turn);
+			}
+			const turnToolSet = acc.turnTools.get(event.data.turn);
+			if (turnToolSet !== void 0) {
+				for (const callId of turnToolSet) acc.toolStart.delete(callId);
+				acc.turnTools.delete(event.data.turn);
+			}
+			acc.busy = false;
+			acc.busySince = 0;
+			for (const entry of appended) appendReplayEntry(acc, entry);
+			return;
+		}
+		case "llm/retry": {
+			const data = event.data;
+			appendReplayEntry(acc, {
+				kind: "retry",
+				retryId: data.retryId,
+				attempt: data.retry,
+				max: "maxRetries" in data ? data.maxRetries : data.retry,
+				code: data.failure.code,
+				delayMs: data.delayMs,
+				state: "running"
+			});
+			indexList(acc.retryIndex, data.retryId).push(acc.entries.length - 1);
+			return;
+		}
+		case "llm/retry-started": {
+			const data = event.data;
+			updateReplayById(acc, acc.retryIndex, data.retryId, (entry) => entry.retryId === data.retryId, (entry) => ({
+				...entry,
+				state: "done"
+			}));
+			return;
+		}
+		case "sandbox/mode":
+			acc.sandbox = event.data.mode;
+			return;
+		case "goal/change": {
+			const data = event.data;
+			const clip = (text) => text.length > 60 ? `${text.slice(0, 59)}…` : text;
+			if (data.operation === "clear") {
+				acc.goal = void 0;
+				appendReplayEntry(acc, {
+					kind: "turn-marker",
+					text: "◎ goal cleared"
+				});
+				return;
+			}
+			const goal = {
+				objective: data.goal.objective,
+				phase: data.goal.phase,
+				rounds: data.roundsStarted,
+				max: data.goal.maxGoalRounds,
+				blocked: data.goal.blockedReason?.message ?? ""
+			};
+			const line = data.operation === "create" ? `◎ goal: ${clip(data.goal.objective)}` : data.operation === "complete" ? "◎ goal complete" : data.operation === "pause" ? "◎ goal paused" : data.operation === "resume" ? "◎ goal resumed" : data.operation === "block" ? `◎ goal blocked: ${clip(goal.blocked)}` : void 0;
+			acc.goal = goal;
+			if (line !== void 0) appendReplayEntry(acc, {
+				kind: "turn-marker",
+				text: line
+			});
+			return;
+		}
+		case "session/title":
+			acc.title = event.data.title;
+			return;
+		case "compaction/summary":
+			if (acc.compactionTokens.size >= MAX_COMPACTION_SUMMARY_RESIDUE) {
+				const oldest = acc.compactionTokens.keys().next().value;
+				if (oldest !== void 0) acc.compactionTokens.delete(oldest);
+			}
+			acc.compactionTokens.set(event.data.compactionId, event.data.shadowedTokenCount);
+			return;
+		case "compaction/prune":
+			acc.lastPruneTokens = event.data.shadowedTokenCount;
+			return;
+		case "compaction/end": {
+			const ok = event.data.error === void 0;
+			const tokens = acc.compactionTokens.get(event.data.compactionId) ?? acc.lastPruneTokens;
+			acc.compactionTokens.delete(event.data.compactionId);
+			appendReplayEntry(acc, {
+				kind: "compaction",
+				ok,
+				tokens,
+				error: event.data.error ?? ""
+			});
+			return;
+		}
+		case "request/context":
+			acc.stats = {
+				...acc.stats,
+				contextWindow: event.data.contextWindow ?? acc.stats.contextWindow
+			};
+			return;
+		case "request/header": {
+			const config = event.data.header.config;
+			acc.model = `${config.provider}/${config.model}`;
+			acc.stats = {
+				...acc.stats,
+				reasoningEffort: config.reasoningEffort === void 0 ? "" : String(config.reasoningEffort),
+				contextSegments: {
+					...acc.stats.contextSegments,
+					system: estimateTokens(event.data.header.system ?? "")
+				}
+			};
+			return;
+		}
+		case "plan/mode":
+			acc.plan = event.data.active;
+			return;
+		case "permission/preset":
+			acc.permission = event.data.preset;
+			return;
+		case "command/run": {
+			const data = event.data;
+			appendReplayEntry(acc, {
+				kind: "command",
+				commandId: data.commandId,
+				name: data.name,
+				args: data.args ?? "",
+				state: "running",
+				summary: ""
+			});
+			indexList(acc.commandIndex, data.commandId).push(acc.entries.length - 1);
+			return;
+		}
+		case "command/done": {
+			const data = event.data;
+			const update = (candidate) => ({
+				...candidate,
+				state: data.kind === "success" ? "done" : "error",
+				summary: boundContextSummary(data.text ?? "")
+			});
+			updateReplayById(acc, acc.commandIndex, data.commandId, (entry) => entry.commandId === data.commandId, update);
+			return;
+		}
+		default: return;
+	}
+}
+/**
+* Materialize the accumulated fold as a `TranscriptView`, compacting any
+* retired tombstones. The anchors maps are handed through as-is (their
+* content is identical to a sequential fold's).
+*
+* @internal Test-instrumentation path; `projectEvents` is the public entry.
+*/
+function finishReplay(acc) {
+	const entries = acc.removedCount === 0 ? acc.entries : acc.entries.filter((entry) => entry !== void 0);
+	if (acc.removedCount > 0) acc.ops += acc.entries.length;
+	return {
+		entries,
+		streaming: acc.streaming,
+		streamingReasoning: acc.streamingReasoning,
+		todos: acc.todos,
+		busy: acc.busy,
+		busySince: acc.busySince,
+		model: acc.model,
+		plan: acc.plan,
+		permission: acc.permission,
+		title: acc.title,
+		sandbox: acc.sandbox,
+		goal: acc.goal,
+		pending: {
+			"next-turn": [...acc.pendingTurn],
+			"next-step": [...acc.pendingStep]
+		},
+		stats: acc.stats,
+		anchors: {
+			stepStart: acc.stepStart,
+			toolStart: acc.toolStart,
+			firstChunkAt: acc.firstChunkAt,
+			compactionTokens: acc.compactionTokens,
+			lastPruneTokens: acc.lastPruneTokens,
+			turnFiles: acc.turnFiles,
+			turnSteps: acc.turnSteps,
+			turnTools: acc.turnTools
+		}
+	};
+}
 /**
 * Fold a replayed event history into one view.
+*
+* Folding is near-linear in the log size: the mutable replay accumulator
+* appends in place and resolves id-keyed updates through index maps, so a
+* long persisted session replays without the O(N²) copy-on-write rebuilds a
+* naive sequential fold would incur. The result is identical to folding
+* {@link projectEvent} per event in order.
 * @param events - events in `seq` order.
 * @returns the folded view.
 */
 function projectEvents(events) {
-	return events.reduce(projectEvent, createTranscriptView());
+	const acc = createReplayAccumulator();
+	for (const event of events) replayProjectEvent(acc, event);
+	return finishReplay(acc);
 }
 /**
 * The append-only flush boundary for a transcript view: the count of entries
@@ -25267,8 +25939,11 @@ function projectEvents(events) {
 * the inbox claims or cancels them durably (`agent/inbox/spliced` removals,
 * `user/message` retirement), and an append-only `<Static>` flush cannot
 * erase a row that vanishes from the view — the retired row would ghost on
-* screen until the next source-backed replay. Everything else (including a
-* completed tail) is final: later events only APPEND new rows.
+* screen until the next source-backed replay. Running commands join the
+* mutable boundary for the same reason in reverse: `command/done` mutates the
+* row's state/summary, so a flushed row would keep its stale running mark
+* until a resize-triggered replay. Everything else (including a completed
+* tail) is final: later events only APPEND new rows.
 * @param entries - the view's transcript entries in order.
 * @returns the count of entries safe to flush (0 for an empty transcript).
 */
@@ -25278,6 +25953,7 @@ function settledEntryCount(entries) {
 		if (entry.kind === "pending") return index;
 		if (entry.kind === "tool" && entry.state === "running") return index;
 		if (entry.kind === "retry" && entry.state === "running") return index;
+		if (entry.kind === "command" && entry.state === "running") return index;
 	}
 	return entries.length;
 }
@@ -25439,6 +26115,259 @@ const RULE = /^(?:---|\*\*\*|___)\s*$/u;
 const QUOTE = /^>\s?(.*)$/u;
 const UNORDERED = /^\s*[-*+]\s+(.*)$/u;
 const ORDERED = /^\s*(\d+)[.)]\s+(.*)$/u;
+const TABLE_DELIMITER = /^(:)?-+(:)?$/u;
+const TABLE_COLUMN_GAP = 2;
+const TABLE_CELL_PADDING = 1;
+const TABLE_MIN_COLUMN_WIDTH = 3;
+const TABLE_MIN_ALIGNED_VALUE_WIDTH = 16;
+const MAX_TABLE_COLUMNS = 12;
+/** Split one pipe row without treating escaped or inline-code pipes as cells. */
+function splitTableRow(line) {
+	const source = line.trim();
+	if (!source.includes("|")) return void 0;
+	const cells = [];
+	let current = "";
+	let inCode = false;
+	let sawSeparator = false;
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index] ?? "";
+		if (char === "\\" && source[index + 1] === "|") {
+			current += "|";
+			index += 1;
+			continue;
+		}
+		if (char === "`") {
+			inCode = !inCode;
+			current += char;
+			continue;
+		}
+		if (char === "|" && !inCode) {
+			cells.push(current.trim());
+			current = "";
+			sawSeparator = true;
+			continue;
+		}
+		current += char;
+	}
+	if (!sawSeparator) return void 0;
+	cells.push(current.trim());
+	if (source.startsWith("|") && cells[0] === "") cells.shift();
+	if (source.endsWith("|") && cells.at(-1) === "") cells.pop();
+	return cells.length === 0 ? void 0 : cells;
+}
+/** Parse the alignment marker carried by one GFM delimiter cell. */
+function tableAlignment(cell) {
+	const match = TABLE_DELIMITER.exec(cell);
+	if (match === null) return void 0;
+	if (match[1] !== void 0 && match[2] !== void 0) return "center";
+	if (match[2] !== void 0) return "right";
+	return "left";
+}
+/** Recognize one complete GFM pipe table at `startIndex`. */
+function parseTable(source, startIndex) {
+	const headers = splitTableRow(source[startIndex] ?? "");
+	const delimiters = splitTableRow(source[startIndex + 1] ?? "");
+	if (headers === void 0 || delimiters === void 0 || headers.length !== delimiters.length) return void 0;
+	if (headers.length === 0 || headers.length > MAX_TABLE_COLUMNS) return void 0;
+	const alignments = delimiters.map(tableAlignment);
+	if (alignments.some((alignment) => alignment === void 0)) return void 0;
+	const rows = [];
+	let nextIndex = startIndex + 2;
+	while (nextIndex < source.length) {
+		const cells = splitTableRow(source[nextIndex] ?? "");
+		if (cells === void 0) break;
+		rows.push(Array.from({ length: headers.length }, (_, column) => cells[column] ?? ""));
+		nextIndex += 1;
+	}
+	return {
+		headers,
+		alignments,
+		rows,
+		nextIndex
+	};
+}
+/** Visible width of one styled cell line. */
+function segmentsWidth(segments) {
+	return segments.reduce((total, segment) => total + visibleColumns(segment.text), 0);
+}
+/** Drop wrapping-only leading spaces while preserving styles. */
+function trimLeadingSpaces(segments) {
+	const trimmed = segments.map((segment) => ({ ...segment }));
+	while (trimmed[0]?.text.startsWith(" ") === true) {
+		const first = trimmed[0];
+		const text = first.text.replace(/^ +/u, "");
+		if (text === "") trimmed.shift();
+		else trimmed[0] = {
+			...first,
+			text
+		};
+	}
+	return trimmed;
+}
+/** Hard-split an oversized soft-wrapped row while retaining inline styles. */
+function hardWrapSegments(segments, width) {
+	const out = [];
+	let current = [];
+	let used = 0;
+	const flush = () => {
+		out.push(current);
+		current = [];
+		used = 0;
+	};
+	for (const segment of segments) for (const char of segment.text) {
+		const cells = visibleColumns(char);
+		if (used > 0 && used + cells > width) flush();
+		const previous = current.at(-1);
+		if (previous?.style === segment.style) previous.text += char;
+		else current.push({
+			text: char,
+			style: segment.style
+		});
+		used += cells;
+	}
+	if (current.length > 0 || out.length === 0) flush();
+	return out;
+}
+/** Wrap one table cell to its allocated content width. */
+function wrapTableCell(runs, width) {
+	const soft = wrapSegments(runs.map((run) => seg(run.text, run.style)), Math.max(1, width));
+	if (soft.length === 0) return [[]];
+	const wrapped = [];
+	for (const line of soft) {
+		const trimmed = trimLeadingSpaces(line);
+		if (segmentsWidth(trimmed) <= width) wrapped.push(trimmed.map((segment) => ({ ...segment })));
+		else wrapped.push(...hardWrapSegments(trimmed, width));
+	}
+	return wrapped;
+}
+/** Visible width after removing inline Markdown delimiters. */
+function tableCellWidth(cell) {
+	return segmentsWidth(parseInline(cell).map((run) => seg(run.text, run.style)));
+}
+/** Allocate readable grid widths or request the vertical record fallback. */
+function tableColumnWidths(table, width) {
+	const columnCount = table.headers.length;
+	const available = width - (columnCount * TABLE_CELL_PADDING + (columnCount - 1) * TABLE_COLUMN_GAP);
+	if (available < columnCount * TABLE_MIN_COLUMN_WIDTH) return void 0;
+	const widths = table.headers.map((header, column) => Math.max(TABLE_MIN_COLUMN_WIDTH, tableCellWidth(header), ...table.rows.map((row) => tableCellWidth(row[column] ?? ""))));
+	let overflow = widths.reduce((total, value) => total + value, 0) - available;
+	while (overflow > 0) {
+		let widest = -1;
+		for (let column = 0; column < widths.length; column += 1) {
+			if ((widths[column] ?? 0) <= TABLE_MIN_COLUMN_WIDTH) continue;
+			if (widest < 0 || (widths[column] ?? 0) > (widths[widest] ?? 0)) widest = column;
+		}
+		if (widest < 0) return void 0;
+		widths[widest] = (widths[widest] ?? TABLE_MIN_COLUMN_WIDTH) - 1;
+		overflow -= 1;
+	}
+	return widths;
+}
+/**
+* Reject grids whose headers or body values become fragmented vertical strips.
+* This mirrors Codex's readability fallback without importing its larger table
+* classification machinery: systemic long-token breaks or a seven-line prose
+* cell are clearer as vertical field records.
+*/
+function tableGridIsReadable(table, widths) {
+	if (table.headers.filter((header, column) => tableCellWidth(header) > (widths[column] ?? 0)).length >= 2) return false;
+	let affectedRows = 0;
+	for (const row of table.rows) {
+		let affected = false;
+		for (let column = 0; column < table.headers.length; column += 1) {
+			const width = widths[column] ?? TABLE_MIN_COLUMN_WIDTH;
+			const runs = parseInline(row[column] ?? "");
+			const plain = runs.map((run) => run.text).join("");
+			const fragmentedToken = plain.split(/\s+/u).some((token) => visibleColumns(token) > width);
+			const wrappedHeight = wrapTableCell(runs, width).length;
+			const catastrophicProse = plain.trim().split(/\s+/u).length >= 4 && width < 12 && wrappedHeight >= 7;
+			if (fragmentedToken || catastrophicProse) {
+				affected = true;
+				break;
+			}
+		}
+		if (affected) affectedRows += 1;
+	}
+	const threshold = table.rows.length <= 1 ? 1 : Math.max(2, Math.ceil(table.rows.length / 3));
+	return affectedRows < threshold;
+}
+/** Apply one table-cell alignment to a wrapped content row. */
+function alignedCell(segments, width, alignment) {
+	const remaining = Math.max(0, width - segmentsWidth(segments));
+	if (alignment === "right") return {
+		left: remaining,
+		right: 0
+	};
+	if (alignment === "center") return {
+		left: Math.floor(remaining / 2),
+		right: Math.ceil(remaining / 2)
+	};
+	return {
+		left: 0,
+		right: remaining
+	};
+}
+/** Render one logical grid row, including wrapped cell continuations. */
+function renderTableGridRow(cells, widths, alignments, header) {
+	const wrapped = cells.map((cell, column) => wrapTableCell(parseInline(cell), widths[column] ?? TABLE_MIN_COLUMN_WIDTH));
+	const height = Math.max(1, ...wrapped.map((lines) => lines.length));
+	return Array.from({ length: height }, (_, rowIndex) => {
+		const segments = [];
+		for (let column = 0; column < cells.length; column += 1) {
+			const line = wrapped[column]?.[rowIndex] ?? [];
+			const styled = header ? line.map((segment) => ({
+				...segment,
+				style: "accentBold"
+			})) : line;
+			const alignment = alignedCell(styled, widths[column] ?? TABLE_MIN_COLUMN_WIDTH, alignments[column] ?? "left");
+			segments.push(seg(" ".repeat(TABLE_CELL_PADDING + alignment.left)));
+			segments.push(...styled);
+			if (column + 1 < cells.length) segments.push(seg(" ".repeat(alignment.right + TABLE_COLUMN_GAP)));
+		}
+		return { segments: merge(segments) };
+	});
+}
+/** Render a table as Codex-style borderless rows with measured separators. */
+function renderTableGrid(table, widths) {
+	const separator = (char) => ({ segments: [seg(widths.map((width) => char.repeat(width + TABLE_CELL_PADDING)).join(" ".repeat(TABLE_COLUMN_GAP)), "dim")] });
+	const lines = [...renderTableGridRow(table.headers, widths, table.alignments, true), separator("━")];
+	for (let row = 0; row < table.rows.length; row += 1) {
+		lines.push(...renderTableGridRow(table.rows[row] ?? [], widths, table.alignments, false));
+		if (row + 1 < table.rows.length) lines.push(separator("─"));
+	}
+	return lines;
+}
+/** Render an unreadably narrow grid as vertically scannable field records. */
+function renderTableRecords(table, width) {
+	const labelWidth = Math.max(...table.headers.map(tableCellWidth));
+	const prefixWidth = TABLE_CELL_PADDING + labelWidth + TABLE_COLUMN_GAP;
+	const aligned = prefixWidth + TABLE_MIN_ALIGNED_VALUE_WIDTH <= width;
+	const lines = [];
+	for (let rowIndex = 0; rowIndex < table.rows.length; rowIndex += 1) {
+		const row = table.rows[rowIndex] ?? [];
+		for (let column = 0; column < table.headers.length; column += 1) {
+			const label = table.headers[column] ?? "";
+			const value = row[column] ?? "";
+			const labelRuns = parseInline(label).map((run) => seg(run.text, "accentBold"));
+			if (aligned) {
+				const valueLines = wrapTableCell(parseInline(value), Math.max(1, width - prefixWidth));
+				for (let lineIndex = 0; lineIndex < valueLines.length; lineIndex += 1) {
+					const prefix = lineIndex === 0 ? [
+						seg(" "),
+						...labelRuns,
+						seg(" ".repeat(labelWidth - tableCellWidth(label) + TABLE_COLUMN_GAP))
+					] : [seg(" ".repeat(prefixWidth))];
+					lines.push({ segments: merge([...prefix, ...valueLines[lineIndex] ?? []]) });
+				}
+			} else {
+				lines.push({ segments: merge([seg(" "), ...labelRuns]) });
+				for (const valueLine of wrapTableCell(parseInline(value), Math.max(1, width - 2))) lines.push({ segments: merge([seg("  "), ...valueLine]) });
+			}
+		}
+		if (rowIndex + 1 < table.rows.length) lines.push({ segments: [seg("─".repeat(width), "dim")] });
+	}
+	return lines;
+}
 /** Render markdown text into styled lines of at most `width` columns. */
 function renderMarkdown(text, width) {
 	const lines = [];
@@ -25450,7 +26379,7 @@ function renderMarkdown(text, width) {
 		if (separatorPending && lines.length > 0 && lines.at(-1)?.segments.length !== 0) lines.push({ segments: [] });
 		separatorPending = false;
 	};
-	const source = text.replaceAll("\r", "").split("\n");
+	const source = text.replaceAll("\r", "").replaceAll("	", "  ").split("\n");
 	let index = 0;
 	while (index < source.length) {
 		const line = source[index] ?? "";
@@ -25460,6 +26389,14 @@ function renderMarkdown(text, width) {
 			continue;
 		}
 		startBlock();
+		const table = parseTable(source, index - 1);
+		if (table !== void 0) {
+			const tableWidth = Math.max(10, Math.floor(width));
+			const columnWidths = tableColumnWidths(table, tableWidth);
+			lines.push(...columnWidths === void 0 || !tableGridIsReadable(table, columnWidths) ? renderTableRecords(table, tableWidth) : renderTableGrid(table, columnWidths));
+			index = table.nextIndex;
+			continue;
+		}
 		const fence = FENCE.exec(line);
 		if (fence !== null) {
 			const language = fence[1] ?? "";
@@ -25628,19 +26565,28 @@ const DEEPSEEK_WAVE_BANDS = {
 		]]
 	}
 };
+/** Original Codex duration used as the animation's sampling timeline. */
+function deepseekWaveBaseDuration(tier, style) {
+	switch (style) {
+		case "aurora": return tier === "flash" ? 1300 : 1600;
+		case "pulse": return tier === "flash" ? 900 : 1250;
+		case "wave": return tier === "flash" ? 1e3 : 1300;
+	}
+}
 /**
-* Total animation duration — Codex `IgnitionStyle::total_duration`: three
-* styles × two tiers.
+* Total visible duration: the Codex ignition duration plus 200ms so its motion
+* remains readable in a busy terminal.
 * @param tier - the active wave tier.
 * @param style - the active ignition style.
 * @returns the duration in milliseconds.
 */
 function deepseekWaveDuration(tier, style = "wave") {
-	switch (style) {
-		case "aurora": return tier === "flash" ? 1300 : 1600;
-		case "pulse": return tier === "flash" ? 900 : 1250;
-		case "wave": return tier === "flash" ? 1e3 : 1300;
-	}
+	return deepseekWaveBaseDuration(tier, style) + 200;
+}
+/** Map the extended display timeline back onto the original Codex samples. */
+function deepseekWaveSampleElapsedMs(tick, tier, style) {
+	const base = deepseekWaveBaseDuration(tier, style);
+	return tick * 33 * base / deepseekWaveDuration(tier, style);
 }
 /**
 * Pick one ignition style at random, never repeating the previous one —
@@ -25780,8 +26726,8 @@ function blendRgb(fg, bg, alpha) {
 * @returns the blended RGB background, or null for transparent.
 */
 function deepseekWaveColumnBg(tick, column, width, tier, style, hues, base) {
-	const total = deepseekWaveDuration(tier, style) / 1e3;
-	const elapsed = tick * 33 / 1e3;
+	const total = deepseekWaveBaseDuration(tier, style) / 1e3;
+	const elapsed = deepseekWaveSampleElapsedMs(tick, tier, style) / 1e3;
 	const fade = style === "aurora" ? envelope(elapsed, total, .25, .4) : 1;
 	const weights = [
 		0,
@@ -25812,14 +26758,14 @@ function deepseekWaveColumnBg(tick, column, width, tier, style, hues, base) {
 	return blendRgb(mixed, base, alpha);
 }
 /**
-* The sparkle glyph for a tick — Codex `spark_frame`: from 900ms on, one
-* glyph every 100ms through `· ✦ ✧`, then silent. The deepseek (Ultra) tier
-* only; the Ink layer still must skip occupied cells.
+* The sparkle glyph for a tick — Codex `spark_frame`, sampled on the same
+* proportionally slowed DeepSeek Wave timeline as the composer background.
+* The Ink layer still must skip occupied cells.
 * @param tick - wave frame at DEEPSEEK_WAVE_TICK_MS.
-* @returns the sparkle glyph, or null outside the 900..1200ms window.
+* @returns the sparkle glyph, or null outside the stretched tail window.
 */
 function deepseekWaveSpark(tick) {
-	const elapsed = tick * 33;
+	const elapsed = deepseekWaveSampleElapsedMs(tick, "deepseek", "wave");
 	if (elapsed < 900) return null;
 	const frame = Math.floor((elapsed - 900) / 100);
 	return SPARK_GLYPHS[frame] ?? null;
@@ -25836,8 +26782,8 @@ function deepseekWaveSpark(tick) {
 * @returns the blended border RGB.
 */
 function deepseekWaveBorderColor(tick, tier, style, hues, dim) {
-	const total = deepseekWaveDuration(tier, style) / 1e3;
-	const glow = envelope(tick * 33 / 1e3, total, total * .25, total * .4);
+	const total = deepseekWaveBaseDuration(tier, style) / 1e3;
+	const glow = envelope(deepseekWaveSampleElapsedMs(tick, tier, style) / 1e3, total, total * .25, total * .4);
 	return blendRgb(hues[0], dim, .25 + glow * .6);
 }
 /**
@@ -25850,8 +26796,8 @@ function deepseekWaveBorderColor(tick, tier, style, hues, dim) {
 * @returns true while the wordmark should be visible.
 */
 function deepseekWaveWordVisible(tick, tier, style = "wave") {
-	const total = deepseekWaveDuration(tier, style) / 1e3;
-	return envelope(tick * 33 / 1e3, total, total * .2, total * .35) > .25;
+	const total = deepseekWaveBaseDuration(tier, style) / 1e3;
+	return envelope(deepseekWaveSampleElapsedMs(tick, tier, style) / 1e3, total, total * .2, total * .35) > .25;
 }
 /**
 * The per-character color for the `deepseek` wordmark: the tier's hues
@@ -25916,136 +26862,43 @@ function formatDuration(ms) {
 * Compact decode rate: one decimal under a hundred, whole below a thousand,
 * then thousands (15.3 / 124 / 1.2K).
 * @param n - tokens per second.
-* @returns display string.
-*/
-function formatRate(n) {
-	if (n < 100) return String(Math.round(n * 10) / 10);
-	if (n < 1e3) return String(Math.round(n));
-	return String(Math.round(n / 100) / 10) + "K";
-}
-/**
-* Cache-hit share of billed prompt-side input.
-* @param usage - cumulative token totals.
-* @returns rounded integer percent, or null when no input was billed.
-*/
-function cacheHitPercent(usage) {
-	return usage.inputTokens === 0 ? null : Math.round(usage.cacheReadTokens / usage.inputTokens * 100);
-}
-/** Separator between trailing state spans. */
-const STATUS_ITEM_SEPARATOR = " · ";
-/** The Codex-style mode cycle hint appended to the permission badge. */
-const STATUS_CYCLE_HINT = " (shift+tab to cycle)";
-/** Free-tail floor in columns: wide enough for the bare percent readout, so
-* the warning stays visible even at 100%+ occupancy. */
-const CONTEXT_MIN_FREE = 5;
-/** The five content types in conversation order, dark → light blue. */
-const CONTEXT_SEGMENTS = [
-	{
-		key: "system",
-		tone: "ctxSystem",
-		labels: [
-			"system",
-			"sys",
-			"s"
-		]
-	},
-	{
-		key: "prompt",
-		tone: "ctxPrompt",
-		labels: [
-			"prompt",
-			"pr",
-			"p"
-		]
-	},
-	{
-		key: "assistant",
-		tone: "ctxAssistant",
-		labels: [
-			"assistant",
-			"ast",
-			"a"
-		]
-	},
-	{
-		key: "thinking",
-		tone: "ctxThinking",
-		labels: [
-			"think",
-			"th",
-			"t"
-		]
-	},
-	{
-		key: "tools",
-		tone: "ctxTools",
-		labels: [
-			"tools",
-			"tl",
-			"x"
-		]
-	}
-];
-/** First label whose visible width fits the segment; empty only when none do. */
-function chooseContextLabel(labels, width) {
-	for (const label of labels) if (visibleColumns(label) <= width) return label;
-	return "";
-}
-/** Center a label inside its segment width; the padding spaces carry the tone. */
-function centerInSegment(text, width) {
-	const textWidth = visibleColumns(text);
-	const left = Math.floor((width - textWidth) / 2);
-	return " ".repeat(Math.max(0, left)) + text + " ".repeat(Math.max(0, width - textWidth - left));
+* @returns display string.
+*/
+function formatRate(n) {
+	if (n < 100) return String(Math.round(n * 10) / 10);
+	if (n < 1e3) return String(Math.round(n));
+	return String(Math.round(n / 100) / 10) + "K";
 }
 /**
-* Largest-remainder allocation: distribute `columns` across `values`
-* proportionally, handing each leftover column to the largest remainder.
+* Cache-hit share of billed prompt-side input.
+* @param usage - cumulative token totals.
+* @returns rounded integer percent, or null when no input was billed.
 */
-function allocateProportionally(values, columns) {
-	if (columns <= 0) return values.map(() => 0);
-	const total = values.reduce((sum, value) => sum + value, 0);
-	if (total <= 0) return values.map(() => 0);
-	const raw = values.map((value) => value / total * columns);
-	const allocated = raw.map(Math.floor);
-	let remaining = columns - allocated.reduce((sum, value) => sum + value, 0);
-	const remainders = raw.map((value, index) => ({
-		index,
-		remainder: value - Math.floor(value)
-	})).sort((left, right) => right.remainder - left.remainder);
-	for (const slot of remainders) {
-		if (remaining <= 0) break;
-		allocated[slot.index] = (allocated[slot.index] ?? 0) + 1;
-		remaining -= 1;
-	}
-	return allocated;
-}
-/** Bar column widths: every non-zero segment keeps at least one column before
-* the remaining columns share by token proportion. */
-function allocateBarColumns(values, width) {
-	const visible = values.map((value, index) => value > 0 ? index : -1).filter((index) => index >= 0);
-	if (visible.length === 0 || visible.length >= width) return allocateProportionally(values, width);
-	const minimum = values.map(() => 0);
-	for (const index of visible) minimum[index] = 1;
-	const remaining = allocateProportionally(values, width - visible.length);
-	return minimum.map((min, index) => min + (remaining[index] ?? 0));
+function cacheHitPercent(usage) {
+	return usage.inputTokens === 0 ? null : Math.round(usage.cacheReadTokens / usage.inputTokens * 100);
 }
+/** Separator between trailing state spans. */
+const STATUS_ITEM_SEPARATOR = " · ";
+/** The Codex-style mode cycle hint appended to the permission badge. */
+const STATUS_CYCLE_HINT = " (shift+tab to cycle)";
+/** Free-tail floor in columns: wide enough for the bare percent readout, so
+* the warning stays visible even at 100%+ occupancy. */
+const CONTEXT_MIN_FREE = 5;
 /**
-* Render context occupancy as a segmented bar: one DeepSeek-blue run per
-* content type (system/prompt/assistant/thinking/tools), column widths
-* proportional to their estimated token share, each with a centered label
-* that shortens to fit (system→sys→s). The remaining free tail is a dim
-* track whose right edge carries the usage readout (`12.3K/1.0M 25%`,
-* shrinking to the bare percent as the tail narrows). The readout flips to
-* amber once occupancy reaches the warning threshold; the segment blues stay
-* untouched so the composition remains readable at full context. The used
-* total comes from the reported `lastPromptTokens`, never from the estimates.
-* @param segments - estimated used tokens per content type.
+* Render context occupancy as ONE stepless bar: a solid DeepSeek-blue fill
+* run, a dim dotted free track, and the usage readout riding the track's
+* right edge (`12.3K/1.0M 25%`, shrinking to the bare percent as the track
+* narrows). No per-content-type segmentation. Column split is deterministic:
+* the free share is `Math.round(free/window*width)` clamped to at least
+* CONTEXT_MIN_FREE columns and at most the full width; the fill takes every
+* remaining column, so a given occupancy always renders the identical bar.
+* The readout flips to amber once occupancy reaches the warning threshold.
 * @param usedTokens - reported used tokens (drives the readout and percent).
 * @param contextWindow - route capacity.
 * @param width - total bar interior columns.
 * @returns tone-split spans for the footer to paint.
 */
-function contextBar(segments, usedTokens, contextWindow, width) {
+function contextBar(usedTokens, contextWindow, width) {
 	if (width <= 0 || contextWindow <= 0) return [];
 	const used = Math.max(0, usedTokens);
 	const percent = Math.round(used / contextWindow * 100);
@@ -26056,26 +26909,14 @@ function contextBar(segments, usedTokens, contextWindow, width) {
 	const total = `${formatTokens(used)}/${formatTokens(contextWindow)}`;
 	const percentText = `${percent}%`;
 	const readout = freeColumns >= visibleColumns(`${total} ${percentText}`) ? `${total} ${percentText}` : freeColumns >= visibleColumns(percentText) ? percentText : "";
-	const values = CONTEXT_SEGMENTS.map((segment) => segments[segment.key]);
-	const allocation = allocateBarColumns(values.reduce((sum, value) => sum + value, 0) > 0 ? values : [
-		0,
-		used,
-		0,
-		0,
-		0
-	], usedColumns);
 	const spans = [];
-	for (let index = 0; index < CONTEXT_SEGMENTS.length; index += 1) {
-		const columns = allocation[index] ?? 0;
-		if (columns <= 0) continue;
-		spans.push({
-			text: centerInSegment(chooseContextLabel(CONTEXT_SEGMENTS[index].labels, columns), columns),
-			tone: CONTEXT_SEGMENTS[index].tone
-		});
-	}
+	if (usedColumns > 0) spans.push({
+		text: "█".repeat(usedColumns),
+		tone: "ctxFill"
+	});
 	const pad = freeColumns - visibleColumns(readout);
 	if (pad > 0) spans.push({
-		text: "▱".repeat(pad),
+		text: "░".repeat(pad),
 		tone: "label"
 	});
 	if (readout !== "") spans.push({
@@ -26098,6 +26939,12 @@ const STATUS_ITEMS = [
 		description: "working-directory basename",
 		side: "left"
 	},
+	{
+		id: "mode",
+		label: "mode",
+		description: "agent preset composing the session",
+		side: "left"
+	},
 	{
 		id: "branch",
 		label: "branch",
@@ -26105,15 +26952,21 @@ const STATUS_ITEMS = [
 		side: "left"
 	},
 	{
-		id: "plan",
-		label: "plan",
-		description: "plan-mode state mark",
+		id: "context",
+		label: "context",
+		description: "context-window occupancy meter",
 		side: "left"
 	},
 	{
-		id: "mode",
-		label: "mode",
-		description: "agent preset composing the session",
+		id: "permission",
+		label: "permission",
+		description: "permission preset badge with cycle hint",
+		side: "right"
+	},
+	{
+		id: "plan",
+		label: "plan",
+		description: "plan-mode state mark",
 		side: "left"
 	},
 	{
@@ -26134,12 +26987,6 @@ const STATUS_ITEMS = [
 		description: "cache-hit share of billed input",
 		side: "left"
 	},
-	{
-		id: "context",
-		label: "context",
-		description: "context-window occupancy meter",
-		side: "left"
-	},
 	{
 		id: "tokens",
 		label: "tokens",
@@ -26156,19 +27003,13 @@ const STATUS_ITEMS = [
 		id: "goal",
 		label: "goal",
 		description: "live goal phase and round progress",
-		side: "right"
+		side: "left"
 	},
 	{
 		id: "sandbox",
 		label: "sandbox",
 		description: "divergent sandbox-mode override",
-		side: "right"
-	},
-	{
-		id: "permission",
-		label: "permission",
-		description: "permission preset badge with cycle hint",
-		side: "right"
+		side: "left"
 	}
 ];
 /**
@@ -26199,23 +27040,22 @@ const WIDTH_SAFETY = 1;
 /** Column budget for the session title before it ellipsizes. */
 const TITLE_BUDGET = 48;
 /**
-* Row 1 drop ranks (lowest drops first): the session title, then the token
-* figures, then turn/step counts, then the goal and divergent-sandbox badges,
-* with the permission badge last. The identity cluster never drops — it
-* ellipsizes instead.
+* Primary-row drop ranks: context drops before permission; the identity
+* cluster never drops and ellipsizes only after the right badge is gone.
+* Secondary-row groups reuse the remaining ranks independently.
 */
 const RANK_TITLE = 10;
 const RANK_TOKENS = 50;
 const RANK_COUNTS = 90;
+const RANK_CONTEXT = 90;
 const RANK_SANDBOX = 92;
 const RANK_GOAL = 95;
 const RANK_BADGE = 100;
 const RANK_IDENTITY = Number.POSITIVE_INFINITY;
-/** Row 2 drop ranks: duration figures go first, then cache, then the context bar, and mode survives longest. */
+/** Row 2 drop ranks: title and durations go first; state and counts survive longest. */
 const RANK2_DURATIONS = 40;
 const RANK2_CACHE = 50;
-const RANK2_CONTEXT = 60;
-const RANK2_MODE = 70;
+const RANK2_PLAN = 70;
 /**
 * Traffic-light tone for a permission preset: read-only stays success green,
 * full access reads error red, and every workspace-scoped middle ground
@@ -26276,15 +27116,22 @@ function buildCandidates(facts, stats, busy, enabled) {
 		text: cwd,
 		tone: "path"
 	});
+	const mode = safe(facts.mode ?? "");
+	if (mode !== "" && enabled.has("mode")) {
+		push({
+			text: "/mode ",
+			tone: "label"
+		});
+		identity.push({
+			text: mode,
+			tone: "accent"
+		});
+	}
 	const branch = safe(facts.branch);
 	if (branch !== "" && enabled.has("branch")) push({
 		text: "⑂ " + branch,
 		tone: "branch"
 	});
-	if (facts.plan && enabled.has("plan")) push({
-		text: "⧉ plan",
-		tone: "accent"
-	});
 	const left = [{
 		group: { spans: identity },
 		rank: RANK_IDENTITY,
@@ -26292,17 +27139,13 @@ function buildCandidates(facts, stats, busy, enabled) {
 	}];
 	const right = [];
 	const row2 = [];
-	const mode = safe(facts.mode ?? "");
-	if (mode !== "" && enabled.has("mode")) row2.push({
+	if (facts.plan && enabled.has("plan")) row2.push({
 		group: { spans: [{
-			text: "mode ",
-			tone: "label"
-		}, {
-			text: mode,
+			text: "⧉ plan",
 			tone: "accent"
 		}] },
-		rank: RANK2_MODE,
-		id: "mode"
+		rank: RANK2_PLAN,
+		id: "plan"
 	});
 	if (stats.turns > 0 || stats.steps > 0) {
 		if (enabled.has("turns")) {
@@ -26319,7 +27162,7 @@ function buildCandidates(facts, stats, busy, enabled) {
 			};
 			pair("turns", String(stats.turns));
 			pair("steps", String(stats.steps));
-			left.push({
+			row2.push({
 				group: { spans: counts },
 				rank: RANK_COUNTS,
 				id: "turns"
@@ -26369,12 +27212,12 @@ function buildCandidates(facts, stats, busy, enabled) {
 		rank: RANK2_CACHE,
 		id: "cache"
 	});
-	if (stats.contextWindow > 0 && stats.lastPromptTokens > 0 && enabled.has("context")) row2.push({
+	if (stats.contextWindow > 0 && stats.lastPromptTokens > 0 && enabled.has("context")) left.push({
 		group: { spans: [{
 			text: "context ",
 			tone: "label"
-		}, ...contextBar(stats.contextSegments, stats.lastPromptTokens, stats.contextWindow, 24)] },
-		rank: RANK2_CONTEXT,
+		}, ...contextBar(stats.lastPromptTokens, stats.contextWindow, 24)] },
+		rank: RANK_CONTEXT,
 		id: "context"
 	});
 	if ((stats.usage.inputTokens > 0 || stats.usage.outputTokens > 0) && enabled.has("tokens")) {
@@ -26391,14 +27234,14 @@ function buildCandidates(facts, stats, busy, enabled) {
 		};
 		pair("in", formatTokens(stats.usage.inputTokens));
 		pair("out", formatTokens(stats.usage.outputTokens));
-		left.push({
+		row2.push({
 			group: { spans: tokens },
 			rank: RANK_TOKENS,
 			id: "tokens"
 		});
 	}
 	const label = truncateColumns(safe(facts.title !== void 0 && facts.title !== "" ? facts.title : facts.sessionId), TITLE_BUDGET);
-	if (label !== "" && enabled.has("title")) left.push({
+	if (label !== "" && enabled.has("title")) row2.push({
 		group: { spans: [{
 			text: label,
 			tone: "meta"
@@ -26406,20 +27249,20 @@ function buildCandidates(facts, stats, busy, enabled) {
 		rank: RANK_TITLE,
 		id: "title"
 	});
-	if (facts.goal !== void 0 && enabled.has("goal")) right.push({
-		span: {
+	if (facts.goal !== void 0 && enabled.has("goal")) row2.push({
+		group: { spans: [{
 			text: facts.goal.phase === "active" ? "◎ round " + facts.goal.rounds + "/" + facts.goal.max : "◎ " + safe(facts.goal.phase),
 			tone: "accent"
-		},
+		}] },
 		rank: RANK_GOAL,
 		id: "goal"
 	});
 	const sandbox = safe(facts.sandbox ?? "");
-	if (sandbox !== "" && sandbox.toLowerCase() !== facts.permission.toLowerCase() && enabled.has("sandbox")) right.push({
-		span: {
+	if (sandbox !== "" && sandbox.toLowerCase() !== facts.permission.toLowerCase() && enabled.has("sandbox")) row2.push({
+		group: { spans: [{
 			text: "sandbox " + sandbox,
 			tone: "warn"
-		},
+		}] },
 		rank: RANK_SANDBOX,
 		id: "sandbox"
 	});
@@ -26444,12 +27287,10 @@ function buildCandidates(facts, stats, busy, enabled) {
 	};
 }
 /**
-* Compose the two-row footer layout under a column budget. Row 1 (identity
-* and state badges) degrades in a fixed order — cycle hint, then title, token
-* figures, turn/step counts, goal, divergent sandbox, permission badge — and
-* only then ellipsizes the identity cluster, so the row never wraps. Row 2
-* (mode, context bar, cache, duration figures) fits its own budget and
-* degrades to empty before any row-1 content is touched.
+* Compose the two-row footer layout under a column budget. Row 1 keeps model,
+* cwd, mode, branch, context, then the right-pinned permission badge and cycle
+* hint. It drops hint, context, and permission before ellipsizing identity.
+* Row 2 fits all secondary figures and state within its own budget.
 * @param facts - identity facts resolved by the runner.
 * @param stats - session figures folded from the durable log.
 * @param columns - usable columns for each row (before their left padding).
@@ -26525,8 +27366,9 @@ function layoutStatusBar(facts, stats, columns, options = {}) {
 		};
 	}
 	const row2Kept = [...orderedRow2];
+	const row2Budget = Math.max(1, budget - 2);
 	const row2Width = () => joinWidth(row2Kept.map((entry) => spansWidth(entry.group.spans)), groupSeparator);
-	while (row2Width() > budget && row2Kept.length > 0) {
+	while (row2Width() > row2Budget && row2Kept.length > 0) {
 		let dropIndex = 0;
 		let dropRank = Number.POSITIVE_INFINITY;
 		for (let index = 0; index < row2Kept.length; index += 1) if (row2Kept[index].rank < dropRank) {
@@ -26612,6 +27454,17 @@ function markdownLines(text, columns) {
 	const width = Math.max(1, Math.floor(columns));
 	return renderMarkdown(displayText(text), Math.max(10, width)).flatMap((line) => styledLines(line.segments.map((segment) => lineSegment(segment.text, segment.style)), width));
 }
+/**
+* Codex-style reasoning rows: the marker occupies the reply gutter and every
+* wrapped or explicit continuation starts with the same two-column indent, so
+* reasoning content and assistant Markdown share one left edge.
+*/
+function reasoningLines(text, columns) {
+	const width = Math.max(1, Math.floor(columns));
+	if (width < 3) return textLines(text, width, "dimItalic");
+	const contentWidth = width - 2;
+	return displayText(text).replaceAll("	", "  ").replaceAll("\r", "").split("\n").flatMap((line) => styledLines([lineSegment(line, "dimItalic")], contentWidth)).map((line, index) => ({ segments: [lineSegment(index === 0 ? "✻ " : "  ", "dimItalic"), ...line.segments] }));
+}
 /** Expanded structured tool detail as scrollable, width-safe rows. */
 function toolDetailLines(detail, columns) {
 	switch (detail.kind) {
@@ -26637,7 +27490,7 @@ function transcriptEntryLines(entry, columns) {
 		case "user": return styledLines([lineSegment(entry.notice ? "⤷ " : "❯ ", entry.notice ? "dim" : "brand"), lineSegment(entry.text, entry.notice ? "dim" : "plain")], width);
 		case "pending": return styledLines([lineSegment("❯ ", "brand"), lineSegment(entry.text, "plain")], width);
 		case "assistant": {
-			const reasoning = entry.reasoning === "" ? [] : styledLines([lineSegment("  ✻ ", "dimItalic"), lineSegment(entry.reasoning, "dimItalic")], width);
+			const reasoning = entry.reasoning === "" ? [] : reasoningLines(entry.reasoning, width);
 			const body = markdownLines(entry.text, Math.max(10, width - 2)).map((line) => ({ segments: [{
 				text: "  ",
 				style: "plain"
@@ -26681,7 +27534,7 @@ function ListFrame(props) {
 	const stdout = useStdout().stdout;
 	const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
 	if (viewport.maxHeight === 0) return (0, import_react.createElement)(Box, { display: "none" });
-	if (viewport.compact) return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns(`${props.title} · esc close`, viewport.contentColumns));
+	if (viewport.compact) return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns(singleLineText(`${props.title} · esc close`), viewport.contentColumns));
 	const stateRows = props.loading ? [{
 		key: "loading",
 		text: "  loading…"
@@ -26704,10 +27557,10 @@ function ListFrame(props) {
 	}, (0, import_react.createElement)(Text, {
 		color: inkColor(getPalette().brandBright),
 		wrap: "truncate-end"
-	}, truncateColumns(props.title, viewport.contentColumns)), (0, import_react.createElement)(Text, {
+	}, truncateColumns(singleLineText(props.title), viewport.contentColumns)), (0, import_react.createElement)(Text, {
 		dimColor: true,
 		wrap: "truncate-end"
-	}, truncateColumns(`search: ${props.query === "" ? "type to filter" : props.query}`, viewport.contentColumns)), ...visible.map((row, index) => {
+	}, truncateColumns(singleLineText(`search: ${props.query === "" ? "type to filter" : props.query}`), viewport.contentColumns)), ...visible.map((row, index) => {
 		const absolute = offset + index;
 		const selected = !props.loading && props.error === void 0 && props.rows.length > 0 && absolute === props.cursor;
 		return (0, import_react.createElement)(Text, {
@@ -26715,11 +27568,11 @@ function ListFrame(props) {
 			color: selected ? inkColor(getPalette().brandBright) : row.disabled ? inkColor(getPalette().dim) : void 0,
 			dimColor: row.disabled,
 			wrap: "truncate-end"
-		}, truncateColumns(`${selected ? "› " : "  "}${row.text}`, viewport.contentColumns));
+		}, truncateColumns(`${selected ? "› " : "  "}${singleLineText(row.text)}`, viewport.contentColumns));
 	}), (0, import_react.createElement)(Text, {
 		dimColor: true,
 		wrap: "truncate-end"
-	}, truncateColumns(props.footer, viewport.contentColumns)));
+	}, truncateColumns(singleLineText(props.footer), viewport.contentColumns)));
 }
 function editQuery(query, input, key) {
 	if (key.backspace || key.delete) return query.slice(0, -1);
@@ -26771,6 +27624,51 @@ function ModePanel({ current, load, select, close }) {
 		footer: "↑↓ choose · enter switch · r refresh · esc close"
 	});
 }
+function PermissionPanel({ current, load, select, close }) {
+	const [rows, setRows] = (0, import_react.useState)([]);
+	const [query, setQuery] = (0, import_react.useState)("");
+	const [cursor, setCursor] = (0, import_react.useState)(0);
+	const [loading, setLoading] = (0, import_react.useState)(true);
+	const [error, setError] = (0, import_react.useState)();
+	const refresh = () => {
+		setLoading(true);
+		setError(void 0);
+		Promise.resolve().then(load).then((value) => {
+			setRows(value);
+			setLoading(false);
+		}, (reason) => {
+			setError(reason instanceof Error ? reason.message : String(reason));
+			setLoading(false);
+		});
+	};
+	(0, import_react.useEffect)(refresh, []);
+	const visible = (0, import_react.useMemo)(() => rows.filter((row) => `${row.id} ${row.description ?? ""}`.toLowerCase().includes(query.toLowerCase())), [rows, query]);
+	(0, import_react.useEffect)(() => setCursor((value) => Math.min(value, Math.max(0, visible.length - 1))), [visible.length]);
+	useInput((input, key) => {
+		if (key.escape || input === "q") return close();
+		if (input === "r" && query === "") return refresh();
+		if (key.upArrow) return setCursor((value) => visible.length === 0 ? 0 : (value + visible.length - 1) % visible.length);
+		if (key.downArrow) return setCursor((value) => visible.length === 0 ? 0 : (value + 1) % visible.length);
+		if (key.return && visible[cursor] !== void 0) return select(visible[cursor].id);
+		const next = editQuery(query, input, key);
+		if (next !== void 0) {
+			setQuery(next);
+			setCursor(0);
+		}
+	});
+	return (0, import_react.createElement)(ListFrame, {
+		title: `/permission · current ${current}`,
+		rows: visible.map((row) => ({
+			key: row.id,
+			text: `${row.id === current ? "●" : "○"} ${row.id}${row.description === void 0 ? "" : ` · ${row.description}`}`
+		})),
+		cursor,
+		loading,
+		error,
+		query,
+		footer: "↑↓ choose · enter select · r refresh · esc close"
+	});
+}
 function PluginPanel({ load, close, initialQuery = "" }) {
 	const [epoch, setEpoch] = (0, import_react.useState)(0);
 	const [query, setQuery] = (0, import_react.useState)(initialQuery);
@@ -26950,7 +27848,7 @@ function DocumentPanel({ title, text, error, close }) {
 	}, (0, import_react.createElement)(Text, {
 		color: inkColor(getPalette().brandBright),
 		wrap: "truncate-end"
-	}, truncateColumns(title, viewport.contentColumns)), ...body.map((line, index) => (0, import_react.createElement)(Text, {
+	}, truncateColumns(singleLineText(title), viewport.contentColumns)), ...body.map((line, index) => (0, import_react.createElement)(Text, {
 		key: `${scroll}-${index}`,
 		wrap: "truncate-end"
 	}, truncateColumns(line, viewport.contentColumns))), (0, import_react.createElement)(Text, {
@@ -27020,7 +27918,7 @@ function HistoryPanel({ entries, fill, close }) {
 			key: `history-${absolute}`,
 			color: selected ? inkColor(getPalette().brandBright) : void 0,
 			wrap: "truncate-end"
-		}, truncateColumns((selected ? "› " : "  ") + displayText(entry), viewport.contentColumns));
+		}, truncateColumns((selected ? "› " : "  ") + singleLineText(entry), viewport.contentColumns));
 	}), (0, import_react.createElement)(Text, {
 		dimColor: true,
 		wrap: "truncate-end"
@@ -27168,7 +28066,7 @@ function serializeHistoryEntry(text) {
 * @param max - entry cap.
 * @returns persistent entries, oldest first.
 */
-function parseHistoryFile(raw, max = 500) {
+function parseHistoryFile(raw, max = 100) {
 	const kept = [];
 	for (const line of raw.split("\n")) {
 		if (line === "") continue;
@@ -27185,27 +28083,30 @@ function parseHistoryFile(raw, max = 500) {
 	return kept.slice(-max);
 }
 /**
-* Append one entry to the persistent file content: JSON line, capped to the
-* newest `max` entries with a trailing newline.
-* @param current - existing file content.
-* @param text - submission to persist.
-* @param max - entry cap.
-* @returns the new file content.
-*/
-function appendHistoryContent(current, text, max = 500) {
-	return [...parseHistoryFile(current, max), text].slice(-max).map(serializeHistoryEntry).join("\n") + "\n";
-}
-/**
 * Record one in-session submission: empty text is ignored and an adjacent
-* duplicate collapses (Codex `record_local_submission` semantics).
+* duplicate collapses (Codex `record_local_submission` semantics). The local
+* pool shares the persistent pool's cap so the recall space stays bounded.
 * @param local - current in-session entries, oldest first.
 * @param text - the submitted prompt.
+* @param max - the local pool cap.
 * @returns the updated local list.
 */
-function recordLocalEntry(local, text) {
+function recordLocalEntry(local, text, max = 100) {
 	if (text === "") return local;
 	if (local.length > 0 && local[local.length - 1] === text) return local;
-	return [...local, text];
+	return [...local, text].slice(-max);
+}
+/**
+* Serialize a capped entry list to the history file format (one JSON line per
+* entry, trailing newline). The runner writes the in-memory list as the whole
+* file, so rapid same-process submissions cannot lose entries to a
+* read-modify-write race (the file is never read back before writing).
+* @param entries - the entries to persist, oldest first.
+* @returns the file content, '' for an empty list.
+*/
+function serializeHistoryList(entries) {
+	if (entries.length === 0) return "";
+	return entries.map(serializeHistoryEntry).join("\n") + "\n";
 }
 /**
 * Build the recall space, newest first: local entries, then persistent
@@ -27386,13 +28287,18 @@ function DeepDivingLine({ since }) {
 * the freshest tokens stay visible while a long reply streams; the complete
 * text lands in the flushed scrollback once the turn assembles it.
 */
-function StreamTail({ text, dim, maxRows, prefix, children }) {
+function StreamTail({ text, dim, maxRows, prefix = "", continuationPrefix = prefix, children }) {
 	const columns = useStdout().stdout?.columns ?? 80;
 	const safeRows = Math.max(1, maxRows);
-	const contentColumns = Math.max(10, columns - 3 - visibleColumns(prefix ?? ""));
+	const prefixColumns = Math.max(visibleColumns(prefix), visibleColumns(continuationPrefix));
+	const contentColumns = Math.max(10, columns - 3 - prefixColumns);
 	const initial = displayTail(text, contentColumns, safeRows);
 	const tail = initial.truncated && safeRows > 1 ? displayTail(text, contentColumns, safeRows - 1) : initial;
-	return (0, import_react.createElement)(Box, { flexDirection: "column" }, tail.truncated && safeRows > 1 ? (0, import_react.createElement)(Text, { dimColor: true }, "  …") : void 0, (0, import_react.createElement)(Text, { dimColor: dim || void 0 }, prefix, tail.text, children));
+	const rows = tail.text.split("\n");
+	return (0, import_react.createElement)(Box, { flexDirection: "column" }, tail.truncated && safeRows > 1 ? (0, import_react.createElement)(Text, { color: inkColor(getPalette().dim) }, continuationPrefix, "…") : void 0, ...rows.map((row, index) => (0, import_react.createElement)(Text, {
+		key: index,
+		dimColor: dim || void 0
+	}, index === 0 ? prefix : continuationPrefix, row, index + 1 === rows.length ? children : void 0)));
 }
 /** Ink props for one markdown style class. */
 function segmentProps(style) {
@@ -27403,6 +28309,12 @@ function segmentProps(style) {
 			italic: void 0,
 			strikethrough: void 0
 		};
+		case "accentBold": return {
+			color: inkColor(getPalette().brandBright),
+			bold: true,
+			italic: void 0,
+			strikethrough: void 0
+		};
 		case "code": return {
 			color: inkColor(getPalette().code),
 			bold: void 0,
@@ -27479,11 +28391,11 @@ function lineStyleProps(style) {
 			dimColor: void 0
 		};
 		case "dimItalic": return {
-			color: void 0,
+			color: inkColor(getPalette().dim),
 			bold: void 0,
 			italic: true,
 			strikethrough: void 0,
-			dimColor: true
+			dimColor: void 0
 		};
 		default: return {
 			...segmentProps(style),
@@ -27521,6 +28433,12 @@ function MarkdownBody({ text, indent = 0 }) {
 		...segmentProps(segment.style)
 	}, segment.text)))));
 }
+/** Expanded reasoning with the same two-column content edge as the reply. */
+function ReasoningBody({ text }) {
+	const columns = useStdout().stdout?.columns ?? 80;
+	const lines = (0, import_react.useMemo)(() => reasoningLines(text, Math.max(10, columns - 2)), [text, columns]);
+	return (0, import_react.createElement)(StyledRows, { lines });
+}
 /**
 * One expanded tool-card body for the verbose transcript (Ctrl+O): the
 * presentation contract's structured cards — inline diffs, read windows,
@@ -27568,23 +28486,20 @@ function ToolDetailBody({ detail }) {
 function EntryLine({ entry, showReasoning, verbose }) {
 	switch (entry.kind) {
 		case "user": return entry.notice ? (0, import_react.createElement)(Text, { dimColor: true }, `⤷ ${displayText(entry.text)}`) : (0, import_react.createElement)(Text, null, brand("❯ "), displayText(entry.text));
-		case "assistant": return (0, import_react.createElement)(Box, { flexDirection: "column" }, entry.reasoning === "" ? void 0 : showReasoning ? (0, import_react.createElement)(Text, {
-			dimColor: true,
-			italic: true
-		}, `  ✻ ${displayText(entry.reasoning)}`) : (0, import_react.createElement)(Text, { dimColor: true }, `  ✻ Thinking (${entry.reasoning.length} chars, Ctrl+R to expand)`), (0, import_react.createElement)(MarkdownBody, {
+		case "assistant": return (0, import_react.createElement)(Box, { flexDirection: "column" }, entry.reasoning === "" ? void 0 : showReasoning ? (0, import_react.createElement)(ReasoningBody, { text: entry.reasoning }) : (0, import_react.createElement)(Text, { color: inkColor(getPalette().dim) }, `✻ Thinking (${entry.reasoning.length} chars, Ctrl+R to expand)`), (0, import_react.createElement)(MarkdownBody, {
 			text: entry.text,
 			indent: 2
 		}));
 		case "tool": {
 			const mark = entry.state === "running" ? (0, import_react.createElement)(Pulse) : entry.state === "error" ? (0, import_react.createElement)(Text, { color: inkColor(getPalette().error) }, "⨯") : (0, import_react.createElement)(Text, { color: inkColor(getPalette().success) }, "⏺");
-			return (0, import_react.createElement)(Box, { flexDirection: "column" }, (0, import_react.createElement)(Text, { wrap: verbose ? "truncate-end" : void 0 }, mark, " ", brand(entry.name), entry.preview === "" ? "" : ` ${dim(displayText(entry.preview))}`), entry.summary === "" ? void 0 : (0, import_react.createElement)(Text, {
+			return (0, import_react.createElement)(Box, { flexDirection: "column" }, (0, import_react.createElement)(Text, { wrap: verbose ? "truncate-end" : void 0 }, mark, " ", brand(displayText(entry.name)), entry.preview === "" ? "" : ` ${dim(displayText(entry.preview))}`), entry.summary === "" ? void 0 : (0, import_react.createElement)(Text, {
 				color: entry.state === "error" ? inkColor(getPalette().error) : inkColor(getPalette().dim),
 				wrap: verbose ? "truncate-end" : void 0
 			}, `  ⎿ ${displayText(entry.summary)}`), verbose && entry.detail !== void 0 ? (0, import_react.createElement)(ToolDetailBody, { detail: entry.detail }) : void 0);
 		}
 		case "command": {
 			const mark = entry.state === "running" ? (0, import_react.createElement)(Pulse) : entry.state === "error" ? (0, import_react.createElement)(Text, { color: inkColor(getPalette().error) }, "⨯") : (0, import_react.createElement)(Text, { color: inkColor(getPalette().success) }, "⏺");
-			return (0, import_react.createElement)(Box, { flexDirection: "column" }, (0, import_react.createElement)(Text, { wrap: verbose ? "truncate-end" : void 0 }, mark, " ", brand(`/${entry.name}`), entry.args === "" ? "" : ` ${dim(displayText(entry.args))}`), entry.summary === "" ? void 0 : (0, import_react.createElement)(Text, {
+			return (0, import_react.createElement)(Box, { flexDirection: "column" }, (0, import_react.createElement)(Text, { wrap: verbose ? "truncate-end" : void 0 }, mark, " ", brand(displayText(`/${entry.name}`)), entry.args === "" ? "" : ` ${dim(displayText(entry.args))}`), entry.summary === "" ? void 0 : (0, import_react.createElement)(Text, {
 				color: inkColor(getPalette().dim),
 				wrap: verbose ? "truncate-end" : void 0
 			}, `  ⎿ ${displayText(entry.summary)}`));
@@ -27615,26 +28530,30 @@ function EntryLine({ entry, showReasoning, verbose }) {
 	}
 }
 /**
-* The whale wordmark header in DeepSeek blue, hugging its content width.
-* The 8-row half-block glyph pairs adjacent lines, so on a terminal too
-* short to show it whole (or mid-resize) the clipped pairs garble the
-* screen — below the height floor the header collapses to a single-line
-* wordmark that stays correct at any size.
+* The whale header with a compact three-line copy lockup. The title, bilingual
+* slogan, and key hint stay centered inside the existing eight content rows,
+* preserving the Static header's ten physical rows. Short or narrow terminals
+* keep a one-line form.
 */
 function Header({ resumed }) {
-	const rows = useStdout().stdout?.rows ?? 40;
-	const hint = resumed ? "resumed session · /help commands · Esc interrupt" : "/help commands · Esc interrupt · Ctrl+C quit";
-	if (rows < 20) return (0, import_react.createElement)(Box, {
-		flexDirection: "row",
-		gap: 1,
+	const stdout = useStdout().stdout;
+	const rows = stdout?.rows ?? 40;
+	const columns = stdout?.columns ?? 80;
+	const title = `DeepSeek Harness · v${DSH_CODE_VERSION}`;
+	const slogan = "Into the Unknown  探索未至之境";
+	const hint = resumed ? "resumed · /help · Esc interrupt" : "/help · Esc interrupt · Ctrl+C quit";
+	const copyColumns = Math.max(visibleColumns(title), visibleColumns(slogan), visibleColumns(hint));
+	const compact = `${title} · ${hint}`;
+	if (rows < 20 || columns < 26 + copyColumns + 8) return (0, import_react.createElement)(Box, {
+		width: Math.max(1, columns - 1),
 		borderStyle: "round",
 		borderColor: inkColor(getPalette().brand),
-		paddingX: 1,
-		alignSelf: "flex-start"
+		paddingX: 1
 	}, (0, import_react.createElement)(Text, {
 		color: inkColor(getPalette().brandBright),
-		bold: true
-	}, "DeepSeek Harness"), (0, import_react.createElement)(Text, { dimColor: true }, hint));
+		bold: true,
+		wrap: "truncate-end"
+	}, truncateColumns(compact, Math.max(1, columns - 5))));
 	return (0, import_react.createElement)(Box, {
 		flexDirection: "row",
 		gap: 2,
@@ -27651,11 +28570,19 @@ function Header({ resumed }) {
 		color: inkColor(getPalette().brand)
 	}, row))), (0, import_react.createElement)(Box, {
 		flexDirection: "column",
+		width: copyColumns,
 		justifyContent: "center"
 	}, (0, import_react.createElement)(Text, {
 		color: inkColor(getPalette().brandBright),
-		bold: true
-	}, "DeepSeek Harness"), (0, import_react.createElement)(Text, { dimColor: true }, hint)));
+		bold: true,
+		wrap: "truncate-end"
+	}, title), (0, import_react.createElement)(Text, {
+		color: inkColor(getPalette().code),
+		wrap: "truncate-end"
+	}, (0, import_react.createElement)(Text, { bold: true }, "Into the Unknown"), "  探索未至之境"), (0, import_react.createElement)(Text, {
+		color: inkColor(getPalette().dim),
+		wrap: "truncate-end"
+	}, hint)));
 }
 /** Todo status glyph: web TodoPanel's three-state marker. */
 function todoMark(status) {
@@ -27718,31 +28645,11 @@ function statusToneProps(tone) {
 			bold: void 0,
 			dimColor: void 0
 		};
-		case "ctxSystem": return {
-			color: inkColor(getPalette().brandDeep),
-			bold: void 0,
-			dimColor: void 0
-		};
-		case "ctxPrompt": return {
+		case "ctxFill": return {
 			color: inkColor(getPalette().brand),
 			bold: void 0,
 			dimColor: void 0
 		};
-		case "ctxAssistant": return {
-			color: inkColor(getPalette().brandMid),
-			bold: void 0,
-			dimColor: void 0
-		};
-		case "ctxThinking": return {
-			color: inkColor(getPalette().brandBright),
-			bold: void 0,
-			dimColor: void 0
-		};
-		case "ctxTools": return {
-			color: inkColor(getPalette().code),
-			bold: void 0,
-			dimColor: void 0
-		};
 		case "success": return {
 			color: inkColor(getPalette().code),
 			bold: true,
@@ -27805,7 +28712,7 @@ function StatusLine({ facts, stats, busy, columns, items }) {
 		busy,
 		items
 	});
-	const renderRow = (row, key) => {
+	const renderRow = (row, key, indent = 0) => {
 		const leftParts = [];
 		row.left.forEach((group, groupIndex) => {
 			if (groupIndex > 0) leftParts.push((0, import_react.createElement)(Text, {
@@ -27837,12 +28744,12 @@ function StatusLine({ facts, stats, busy, columns, items }) {
 			color: inkColor(getPalette().dim)
 		}, STATUS_CYCLE_HINT));
 		return (0, import_react.createElement)(Box, {
-			paddingLeft: 2,
+			paddingLeft: 2 + indent,
 			justifyContent: rightParts.length > 0 ? "space-between" : void 0
 		}, (0, import_react.createElement)(Text, { wrap: "truncate-end" }, ...leftParts), rightParts.length > 0 ? (0, import_react.createElement)(Text, { wrap: "truncate-end" }, ...rightParts) : void 0);
 	};
 	const row2Present = layout.row2.left.length > 0;
-	return (0, import_react.createElement)(Box, { flexDirection: "column" }, renderRow(layout.row1, "s1"), row2Present ? renderRow(layout.row2, "s2") : void 0);
+	return (0, import_react.createElement)(Box, { flexDirection: "column" }, renderRow(layout.row1, "s1"), row2Present ? renderRow(layout.row2, "s2", 2) : void 0);
 }
 /**
 * One fixed-height local feedback row. Errors remain visible while a slash
@@ -28149,22 +29056,132 @@ function QuestionBar({ store, snapshot, locked }) {
 		width: viewport.outerColumns,
 		paddingX: 1,
 		borderStyle: "round",
-		borderColor: inkColor(isPlan ? getPalette().brand : getPalette().brandDeep)
+		borderColor: inkColor(isPlan ? getPalette().brand : getPalette().brandDeep)
+	}, (0, import_react.createElement)(Text, {
+		color: inkColor(isPlan ? getPalette().brand : getPalette().brandDeep),
+		bold: true,
+		wrap: "truncate-end"
+	}, truncateColumns(`${isPlan ? "📋 plan review" : "❓ question"} ${index + 1}/${pending.request.questions.length} · lines ${rendered.lines.length === 0 ? 0 : visibleScroll + 1}-${Math.min(rendered.lines.length, visibleScroll + viewport.bodyRows)}/${rendered.lines.length}`, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(StyledRows, { lines: rendered.lines.slice(visibleScroll, visibleScroll + viewport.bodyRows) }), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
+		dimColor: true,
+		wrap: "truncate-end"
+	}, dim(truncateColumns(footer, viewport.contentColumns))));
+}
+/** The /model panel: a scrolling list over the advisory model directory. */
+function ModelPanel({ directory, error, onSelect, onProviders, onRetry, onClose }) {
+	const [cursor, setCursor] = (0, import_react.useState)(0);
+	const stdout = useStdout().stdout;
+	const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+	const rows = directory?.rows ?? [];
+	(0, import_react.useEffect)(() => {
+		if (rows.length === 0) {
+			if (cursor !== 0) setCursor(0);
+			return;
+		}
+		if (cursor >= rows.length) setCursor(rows.length - 1);
+	}, [rows.length, cursor]);
+	useInput((input, key) => {
+		if (key.escape || input === "q") {
+			onClose();
+			return;
+		}
+		if (input === "r") {
+			onRetry();
+			return;
+		}
+		if (input === "a" && onProviders !== void 0) {
+			onProviders();
+			return;
+		}
+		if (rows.length === 0) return;
+		if (key.upArrow) {
+			setCursor(cursor > 0 ? cursor - 1 : rows.length - 1);
+			return;
+		}
+		if (key.downArrow) {
+			setCursor(cursor < rows.length - 1 ? cursor + 1 : 0);
+			return;
+		}
+		if (key.pageUp) {
+			setCursor((current) => Math.max(0, current - Math.max(1, viewport.bodyRows - 1)));
+			return;
+		}
+		if (key.pageDown) {
+			setCursor((current) => Math.min(rows.length - 1, current + Math.max(1, viewport.bodyRows - 1)));
+			return;
+		}
+		if (input === "g") {
+			setCursor(0);
+			return;
+		}
+		if (input === "G") {
+			setCursor(rows.length - 1);
+			return;
+		}
+		if (key.return && rows[cursor] !== void 0) onSelect(rows[cursor]);
+	});
+	if (viewport.maxHeight === 0) return (0, import_react.createElement)(Box, { display: "none" });
+	if (viewport.compact) return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns(`/model${onProviders === void 0 ? "" : " · a providers"} · r retry · esc/q close`, viewport.contentColumns));
+	const visibleStateRows = (directory === void 0 && error === void 0 ? [(0, import_react.createElement)(Text, {
+		key: "loading",
+		dimColor: true,
+		wrap: "truncate-end"
+	}, "  loading models…")] : error !== void 0 ? [(0, import_react.createElement)(Text, {
+		key: "error",
+		color: inkColor(getPalette().error),
+		wrap: "truncate-end"
+	}, truncateColumns(`  ${singleLineText(error)}`, viewport.contentColumns))] : [...directory?.failures.length === 0 ? [] : [(0, import_react.createElement)(Text, {
+		key: "failures",
+		color: inkColor(getPalette().warn),
+		wrap: "truncate-end"
+	}, truncateColumns(`  unavailable providers: ${directory?.failures.join(", ")}`, viewport.contentColumns))], ...rows.length === 0 ? [(0, import_react.createElement)(Text, {
+		key: "empty",
+		dimColor: true,
+		wrap: "truncate-end"
+	}, "  no models available")] : []]).slice(0, viewport.bodyRows);
+	const rowBudget = Math.max(0, viewport.bodyRows - visibleStateRows.length);
+	const first = selectionWindow(cursor, rows.length, rowBudget);
+	const visible = rowBudget === 0 ? [] : rows.slice(first, first + rowBudget);
+	return (0, import_react.createElement)(Box, {
+		flexDirection: "column",
+		width: viewport.outerColumns,
+		paddingX: 1,
+		borderStyle: "round",
+		borderColor: inkColor(getPalette().brand)
 	}, (0, import_react.createElement)(Text, {
-		color: inkColor(isPlan ? getPalette().brand : getPalette().brandDeep),
+		color: inkColor(getPalette().brand),
 		bold: true,
 		wrap: "truncate-end"
-	}, truncateColumns(`${isPlan ? "📋 plan review" : "❓ question"} ${index + 1}/${pending.request.questions.length} · lines ${rendered.lines.length === 0 ? 0 : visibleScroll + 1}-${Math.min(rendered.lines.length, visibleScroll + viewport.bodyRows)}/${rendered.lines.length}`, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(StyledRows, { lines: rendered.lines.slice(visibleScroll, visibleScroll + viewport.bodyRows) }), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
+	}, truncateColumns(`/model — select model${rows.length === 0 ? "" : ` · ${cursor + 1}/${rows.length}`}`, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), ...visibleStateRows, ...visible.map((row) => {
+		const index = rows.indexOf(row);
+		const label = displayText(`${row.providerName} · ${row.modelName}`);
+		return (0, import_react.createElement)(Text, {
+			key: `${row.provider}/${row.model}`,
+			color: index === cursor ? inkColor(getPalette().brandBright) : inkColor(getPalette().dim),
+			wrap: "truncate-end"
+		}, truncateColumns(`${index === cursor ? "❯ " : "  "}${label}`, viewport.contentColumns));
+	}), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
 		dimColor: true,
 		wrap: "truncate-end"
-	}, dim(truncateColumns(footer, viewport.contentColumns))));
+	}, dim(truncateColumns(`↑↓ move · pgup/pgdn page · enter select${onProviders === void 0 ? "" : " · a providers"} · r retry · esc/q close`, viewport.contentColumns))));
 }
-/** The /model panel: a scrolling list over the advisory model directory. */
-function ModelPanel({ directory, error, onSelect, onRetry, onClose }) {
-	const [cursor, setCursor] = (0, import_react.useState)(0);
+/** Compact provider-state copy; only value-free credential facts cross this boundary. */
+function providerStateLabel(row) {
+	const route = row.active ? "active" : "dormant";
+	const credential = row.credential;
+	if (credential?.kind === "error") return `${route} · key status unavailable`;
+	if (credential?.kind === "facts") {
+		if (!credential.configured) return `${route} · key missing`;
+		return `${route} · key ${credential.source === void 0 ? "configured" : singleLineText(credential.source)}${credential.writable ? "" : " · read-only"}`;
+	}
+	return `${route} · ${row.configured ? "provider auth" : "not configured"}`;
+}
+/** The provider-management stage reached from /model with `a`. */
+function ProviderPanel({ directory, error, onCredential, onUnset, onRemove, onRetry, onBack }) {
 	const stdout = useStdout().stdout;
 	const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
 	const rows = directory?.rows ?? [];
+	const [cursor, setCursor] = (0, import_react.useState)(0);
+	const [actionError, setActionError] = (0, import_react.useState)(void 0);
 	(0, import_react.useEffect)(() => {
 		if (rows.length === 0) {
 			if (cursor !== 0) setCursor(0);
@@ -28172,62 +29189,87 @@ function ModelPanel({ directory, error, onSelect, onRetry, onClose }) {
 		}
 		if (cursor >= rows.length) setCursor(rows.length - 1);
 	}, [rows.length, cursor]);
-	useInput((input, key) => {
+	useStableInput((input, key) => {
 		if (key.escape || input === "q") {
-			onClose();
+			onBack();
 			return;
 		}
 		if (input === "r") {
+			setActionError(void 0);
 			onRetry();
 			return;
 		}
 		if (rows.length === 0) return;
 		if (key.upArrow) {
+			setActionError(void 0);
 			setCursor(cursor > 0 ? cursor - 1 : rows.length - 1);
 			return;
 		}
 		if (key.downArrow) {
+			setActionError(void 0);
 			setCursor(cursor < rows.length - 1 ? cursor + 1 : 0);
 			return;
 		}
 		if (key.pageUp) {
+			setActionError(void 0);
 			setCursor((current) => Math.max(0, current - Math.max(1, viewport.bodyRows - 1)));
 			return;
 		}
 		if (key.pageDown) {
+			setActionError(void 0);
 			setCursor((current) => Math.min(rows.length - 1, current + Math.max(1, viewport.bodyRows - 1)));
 			return;
 		}
-		if (input === "g") {
-			setCursor(0);
+		const target = rows[cursor];
+		if (target === void 0) return;
+		if (input === "d") {
+			const facts = target.credential;
+			if (facts?.kind !== "facts" || !facts.configured) setActionError("this provider has no configured API key to remove");
+			else if (!facts.writable) setActionError("this API key is supplied read-only by the environment");
+			else onUnset(target);
 			return;
 		}
-		if (input === "G") {
-			setCursor(rows.length - 1);
+		if (input === "x") {
+			if (!target.removable) setActionError("this provider profile is not removable");
+			else onRemove(target);
 			return;
 		}
-		if (key.return && rows[cursor] !== void 0) onSelect(rows[cursor]);
-	});
+		if (key.return) {
+			if (target.settingsNs.length === 0) setActionError("this provider is not managed by Harness settings");
+			else if (target.credential?.kind === "error") setActionError("credential status is unavailable; retry before writing");
+			else if (target.credential?.kind === "facts" && !target.credential.writable) setActionError("this API key is supplied read-only by the environment");
+			else if (target.credentialRef === void 0 && directory?.writable !== true) setActionError("settings are read-only; this provider cannot be activated here");
+			else onCredential(target);
+		}
+	}, true);
 	if (viewport.maxHeight === 0) return (0, import_react.createElement)(Box, { display: "none" });
-	if (viewport.compact) return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns("/model · r retry · esc/q close", viewport.contentColumns));
-	const stateRows = directory === void 0 && error === void 0 ? [(0, import_react.createElement)(Text, {
+	if (viewport.compact) return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns("/model providers · enter key · d remove key · esc back", viewport.contentColumns));
+	const visibleStateRows = (directory === void 0 && error === void 0 ? [(0, import_react.createElement)(Text, {
 		key: "loading",
-		dimColor: true,
+		color: inkColor(getPalette().dim),
 		wrap: "truncate-end"
-	}, "  loading models…")] : error !== void 0 ? [(0, import_react.createElement)(Text, {
+	}, "  loading providers…")] : error !== void 0 ? [(0, import_react.createElement)(Text, {
 		key: "error",
 		color: inkColor(getPalette().error),
 		wrap: "truncate-end"
-	}, truncateColumns(`  ${singleLineText(error)}`, viewport.contentColumns))] : [...directory?.failures.length === 0 ? [] : [(0, import_react.createElement)(Text, {
-		key: "failures",
-		color: inkColor(getPalette().warn),
-		wrap: "truncate-end"
-	}, truncateColumns(`  unavailable providers: ${directory?.failures.join(", ")}`, viewport.contentColumns))], ...rows.length === 0 ? [(0, import_react.createElement)(Text, {
-		key: "empty",
-		dimColor: true,
-		wrap: "truncate-end"
-	}, "  no models available")] : []];
-	const rowBudget = Math.max(0, viewport.bodyRows - stateRows.length);
+	}, truncateColumns(`  ${singleLineText(error)}`, viewport.contentColumns))] : [
+		...actionError === void 0 ? [] : [(0, import_react.createElement)(Text, {
+			key: "action-error",
+			color: inkColor(getPalette().error),
+			wrap: "truncate-end"
+		}, truncateColumns(`  ${actionError}`, viewport.contentColumns))],
+		...(directory?.failures ?? []).map((failure, index) => (0, import_react.createElement)(Text, {
+			key: `failure-${index}`,
+			color: inkColor(getPalette().warn),
+			wrap: "truncate-end"
+		}, truncateColumns(`  ${singleLineText(failure)}`, viewport.contentColumns))),
+		...rows.length === 0 ? [(0, import_react.createElement)(Text, {
+			key: "empty",
+			color: inkColor(getPalette().dim),
+			wrap: "truncate-end"
+		}, "  no configurable providers")] : []
+	]).slice(0, viewport.bodyRows);
+	const rowBudget = Math.max(0, viewport.bodyRows - visibleStateRows.length);
 	const first = selectionWindow(cursor, rows.length, rowBudget);
 	const visible = rowBudget === 0 ? [] : rows.slice(first, first + rowBudget);
 	return (0, import_react.createElement)(Box, {
@@ -28240,18 +29282,168 @@ function ModelPanel({ directory, error, onSelect, onRetry, onClose }) {
 		color: inkColor(getPalette().brand),
 		bold: true,
 		wrap: "truncate-end"
-	}, truncateColumns(`/model — select model${rows.length === 0 ? "" : ` · ${cursor + 1}/${rows.length}`}`, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), ...stateRows, ...visible.map((row) => {
+	}, truncateColumns(`/model — providers${rows.length === 0 ? "" : ` · ${cursor + 1}/${rows.length}`}`, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), ...visibleStateRows, ...visible.map((row) => {
 		const index = rows.indexOf(row);
-		const label = displayText(`${row.providerName} · ${row.modelName}`);
+		const label = `${row.displayName === row.provider ? row.provider : `${row.displayName} (${row.provider})`} · ${providerStateLabel(row)}${row.removable ? " · custom" : ""}`;
 		return (0, import_react.createElement)(Text, {
-			key: `${row.provider}/${row.model}`,
+			key: row.provider,
 			color: index === cursor ? inkColor(getPalette().brandBright) : inkColor(getPalette().dim),
 			wrap: "truncate-end"
-		}, truncateColumns(`${index === cursor ? "❯ " : "  "}${label}`, viewport.contentColumns));
+		}, truncateColumns(`${index === cursor ? "❯ " : "  "}${displayText(label)}`, viewport.contentColumns));
 	}), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
-		dimColor: true,
+		color: inkColor(getPalette().dim),
+		wrap: "truncate-end"
+	}, truncateColumns("↑↓ move · enter add/update key · d remove key · x remove custom provider · r retry · esc back", viewport.contentColumns)));
+}
+/** Write-only masked API-key editor; the secret lives only in this mounted component. */
+function ProviderCredentialPanel({ target, save, done, back }) {
+	const stdout = useStdout().stdout;
+	const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+	const [draft, setDraft] = (0, import_react.useState)("");
+	const [busy, setBusy] = (0, import_react.useState)(false);
+	const [error, setError] = (0, import_react.useState)(void 0);
+	const submit = () => {
+		if (busy) return;
+		setBusy(true);
+		setError(void 0);
+		Promise.resolve().then(() => save(target, draft)).then(() => {
+			setDraft("");
+			done();
+		}, (reason) => {
+			setError(singleLineText(reason instanceof Error ? reason.message : String(reason)));
+			setBusy(false);
+		});
+	};
+	useStableInput((input, key) => {
+		if (busy) return;
+		if (key.escape) {
+			setDraft("");
+			back();
+			return;
+		}
+		if (key.return) {
+			submit();
+			return;
+		}
+		if (key.backspace || key.delete) {
+			setError(void 0);
+			setDraft((current) => [...current].slice(0, -1).join(""));
+			return;
+		}
+		if (key.ctrl && input === "u") {
+			setError(void 0);
+			setDraft("");
+			return;
+		}
+		if (key.ctrl || key.meta || input.length === 0) return;
+		const next = draft + input;
+		if (next.length > 4096) {
+			setError("API key input is too long");
+			return;
+		}
+		setError(void 0);
+		setDraft(next);
+	}, true);
+	if (viewport.maxHeight === 0) return (0, import_react.createElement)(Box, { display: "none" });
+	const keyBudget = Math.max(1, viewport.contentColumns - 4);
+	const bullets = "•".repeat(Math.min([...draft].length, keyBudget));
+	if (viewport.compact) return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns(`API key ${bullets}${busy ? " saving…" : " ▏"} · esc back`, viewport.contentColumns));
+	const identity = target.displayName === target.provider ? target.provider : `${target.displayName} (${target.provider})`;
+	const source = target.credential?.kind === "facts" && target.credential.configured ? `replaces ${singleLineText(target.credential.source ?? "stored key")}` : "new key";
+	const providerRow = (0, import_react.createElement)(Text, {
+		key: "provider",
+		wrap: "truncate-end"
+	}, truncateColumns(`  provider  ${displayText(identity)}`, viewport.contentColumns));
+	const referenceRow = (0, import_react.createElement)(Text, {
+		key: "reference",
+		color: inkColor(getPalette().dim),
+		wrap: "truncate-end"
+	}, truncateColumns(`  reference ${displayText(target.credentialRef ?? target.suggestedRef)} · ${source}`, viewport.contentColumns));
+	const keyRow = (0, import_react.createElement)(Text, {
+		key: "key",
+		color: error === void 0 ? inkColor(getPalette().brandBright) : inkColor(getPalette().error),
+		wrap: "truncate-end"
+	}, truncateColumns(`  key       ${bullets}${busy ? " saving…" : " ▏"}`, viewport.contentColumns));
+	const errorRow = error === void 0 ? void 0 : (0, import_react.createElement)(Text, {
+		key: "error",
+		color: inkColor(getPalette().error),
+		wrap: "truncate-end"
+	}, truncateColumns(`  ${error}`, viewport.contentColumns));
+	const detailRows = errorRow === void 0 ? [providerRow, referenceRow] : [providerRow, errorRow];
+	const primaryRow = viewport.bodyRows === 1 && errorRow !== void 0 ? errorRow : keyRow;
+	const detailBudget = Math.max(0, viewport.bodyRows - 1);
+	const bodyRows = [...detailBudget === 0 ? [] : detailRows.slice(-detailBudget), ...viewport.bodyRows === 0 ? [] : [primaryRow]];
+	return (0, import_react.createElement)(Box, {
+		flexDirection: "column",
+		width: viewport.outerColumns,
+		paddingX: 1,
+		borderStyle: "round",
+		borderColor: inkColor(getPalette().brand)
+	}, (0, import_react.createElement)(Text, {
+		color: inkColor(getPalette().brand),
+		bold: true,
+		wrap: "truncate-end"
+	}, truncateColumns("/model — add API key", viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), ...bodyRows, (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
+		color: inkColor(getPalette().dim),
+		wrap: "truncate-end"
+	}, truncateColumns("type or paste key · enter save · ctrl+u clear · esc back", viewport.contentColumns)));
+}
+/** Bounded destructive-action confirmation for credential or provider removal. */
+function ProviderConfirmPanel({ target, kind, confirm, done, back }) {
+	const stdout = useStdout().stdout;
+	const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+	const [busy, setBusy] = (0, import_react.useState)(false);
+	const [error, setError] = (0, import_react.useState)(void 0);
+	const run = () => {
+		if (busy) return;
+		setBusy(true);
+		setError(void 0);
+		Promise.resolve().then(() => confirm(target)).then(done, (reason) => {
+			setError(singleLineText(reason instanceof Error ? reason.message : String(reason)));
+			setBusy(false);
+		});
+	};
+	useStableInput((input, key) => {
+		if (busy) return;
+		if (key.escape || input === "n") {
+			back();
+			return;
+		}
+		if (input === "y") run();
+	}, true);
+	if (viewport.maxHeight === 0) return (0, import_react.createElement)(Box, { display: "none" });
+	const action = kind === "credential" ? "remove API key" : "remove provider";
+	if (viewport.compact) return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns(`${action} ${target.displayName}? · y confirm · n/esc back`, viewport.contentColumns));
+	const identity = target.displayName === target.provider ? target.provider : `${target.displayName} (${target.provider})`;
+	const identityRow = (0, import_react.createElement)(Text, {
+		key: "identity",
+		wrap: "truncate-end"
+	}, truncateColumns(`  ${displayText(identity)}`, viewport.contentColumns));
+	const descriptionRow = (0, import_react.createElement)(Text, {
+		key: "description",
+		color: inkColor(getPalette().dim),
 		wrap: "truncate-end"
-	}, dim(truncateColumns("↑↓ move · pgup/pgdn page · g/G ends · enter select · r retry · esc/q close", viewport.contentColumns))));
+	}, truncateColumns(kind === "credential" ? "  the provider profile and selected model stay available" : "  the user settings profile and its managed key will be removed", viewport.contentColumns));
+	const errorRow = error === void 0 ? void 0 : (0, import_react.createElement)(Text, {
+		key: "error",
+		color: inkColor(getPalette().error),
+		wrap: "truncate-end"
+	}, truncateColumns(`  ${error}`, viewport.contentColumns));
+	const bodyRows = errorRow === void 0 ? [identityRow, descriptionRow].slice(0, viewport.bodyRows) : [identityRow, errorRow].slice(-viewport.bodyRows);
+	return (0, import_react.createElement)(Box, {
+		flexDirection: "column",
+		width: viewport.outerColumns,
+		paddingX: 1,
+		borderStyle: "round",
+		borderColor: inkColor(getPalette().warn)
+	}, (0, import_react.createElement)(Text, {
+		color: inkColor(getPalette().warn),
+		bold: true,
+		wrap: "truncate-end"
+	}, truncateColumns(`/model — ${action}`, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), ...bodyRows, (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
+		color: inkColor(getPalette().dim),
+		wrap: "truncate-end"
+	}, truncateColumns(busy ? "working…" : "y confirm · n/esc back", viewport.contentColumns)));
 }
 /**
 * The /help overlay: one scrolling card with the keyboard map, the TUI-local
@@ -28319,6 +29511,7 @@ function HelpPanel({ descriptors, skills, commandError, skillError, onClose }) {
 		(0, import_react.createElement)(Box, { key: "local-model" }, row("/model", "switch the model")),
 		(0, import_react.createElement)(Box, { key: "local-effort" }, row("/effort", "adjust reasoning effort for the current model")),
 		(0, import_react.createElement)(Box, { key: "local-mode" }, row("/mode", "inspect or select the agent preset (/mode [preset])")),
+		(0, import_react.createElement)(Box, { key: "local-permission" }, row("/permission", "inspect or select the permission preset (/permission [preset])")),
 		(0, import_react.createElement)(Box, { key: "local-new" }, row("/new", "create and switch to a fresh session (/new [preset])")),
 		(0, import_react.createElement)(Box, { key: "local-resume" }, row("/resume", "browse or switch root sessions (/resume [id|prefix])")),
 		(0, import_react.createElement)(Box, { key: "local-plugin" }, row("/plugin", "inspect the live plugin composition")),
@@ -28591,6 +29784,11 @@ function completionCandidates(value, descriptors, skills) {
 			description: "select the agent preset",
 			origin: "command"
 		},
+		{
+			label: "/permission",
+			description: "inspect or select the permission preset",
+			origin: "command"
+		},
 		{
 			label: "/new",
 			description: "start a fresh session",
@@ -28722,7 +29920,7 @@ function CompletionMenu({ active, mention, index, rows }) {
 * While a modal (approval / question / model panel) owns the keys, the
 * box passes every key through untouched.
 */
-function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, openEffort, openHelp, openMode, openResume, openPlugin, openStatusline, openTheme, openHistory, createSession, cancelSessionSwitch, notify, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, cyclePermission, exportTranscript, renameTitle, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, waveTick, waveTier, waveStyle }) {
+function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openPlugin, openStatusline, openTheme, openHistory, createSession, cancelSessionSwitch, notify, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, cyclePermission, exportTranscript, renameTitle, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, waveTier, waveStyle }) {
 	const columns = useStdout().stdout?.columns ?? 80;
 	const [value, setValue] = (0, import_react.useState)("");
 	const [cursor, setCursor] = (0, import_react.useState)(0);
@@ -28922,6 +30120,14 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				openEffort();
 				return;
 			}
+			if (text === "/permission") {
+				openPermission();
+				return;
+			}
+			if (text.startsWith("/permission ")) {
+				dispatch(text);
+				return;
+			}
 			if (text === "/mode" || text.startsWith("/mode ")) {
 				if (text.slice(5).trim() === "") openMode();
 				else dispatch(text);
@@ -29066,6 +30272,40 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			setDismissedMenuValue(void 0);
 		}
 	});
+	const [waveTick, setWaveTick] = (0, import_react.useState)(null);
+	const wavePrevious = (0, import_react.useRef)({
+		tier: null,
+		style: null
+	});
+	(0, import_react.useEffect)(() => {
+		const previous = wavePrevious.current;
+		wavePrevious.current = {
+			tier: waveTier,
+			style: waveStyle
+		};
+		if (waveTier === null) {
+			setWaveTick(null);
+			return;
+		}
+		if (previous.tier !== waveTier || previous.style !== waveStyle) setWaveTick(0);
+	}, [waveTier, waveStyle]);
+	const waveActive = waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 < deepseekWaveDuration(waveTier, waveStyle);
+	(0, import_react.useEffect)(() => {
+		if (!waveActive) return;
+		const id = setInterval(() => {
+			setWaveTick((current) => current === null ? 0 : current + 1);
+		}, 33);
+		return () => {
+			clearInterval(id);
+		};
+	}, [waveActive]);
+	(0, import_react.useEffect)(() => {
+		if (waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 >= deepseekWaveDuration(waveTier, waveStyle)) setWaveTick(null);
+	}, [
+		waveTick,
+		waveTier,
+		waveStyle
+	]);
 	const tierActive = waveTier !== null;
 	const tierHues = waveTier === null ? null : deepseekWaveHues(waveTier);
 	const promptColor = tierHues === null ? inkColor(getPalette().brand) : inkColor(tierHues[0]);
@@ -29179,13 +30419,156 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	};
 	return (0, import_react.createElement)(Box, { flexDirection: "column" }, menu, waveTick !== null && waveTier !== null && !busy ? waveRow() : frame(staticRow));
 }
+/** Build one settled row (row Box plus its roomy-prompt spacers). */
+function buildSettledRow(entry, index, showReasoning) {
+	const row = (0, import_react.createElement)(EntryLine, {
+		entry,
+		showReasoning,
+		verbose: false
+	});
+	const roomyPrompt = entry.kind === "user" && !entry.notice;
+	return {
+		box: (0, import_react.createElement)(Box, {
+			key: index,
+			paddingX: 1
+		}, row),
+		before: roomyPrompt ? (0, import_react.createElement)(Box, {
+			key: `prompt-before-${index}`,
+			paddingX: 1
+		}, (0, import_react.createElement)(Text, null, " ")) : void 0,
+		after: roomyPrompt ? (0, import_react.createElement)(Box, {
+			key: `prompt-after-${index}`,
+			paddingX: 1
+		}, (0, import_react.createElement)(Text, null, " ")) : void 0,
+		reasonSensitive: entry.kind === "assistant" && entry.reasoning !== "",
+		showReasoning
+	};
+}
+/**
+* The settled `<Static>` row set as a PURE incremental state machine (App
+* drives it from the memo; tests drive it directly and read `built`).
+*
+* The settled prefix is permanently final: the projection only APPENDS below
+* the flush boundary, removes pending rows at or beyond it, and replaces
+* running tool/retry/command rows there too. So extending the cache never
+* rescans the old prefix — a grown boundary builds ONLY the newly settled
+* suffix and reuses every cached element, letting React bail out of unchanged
+* rows and keeping long histories out of the per-durable-event path (no O(N)
+* rebuild of rows, Map, or MarkdownBody parses). `records` is mutated in place
+* on the append/toggle paths to stay O(delta).
+*
+* Full rebuilds run only on the rare, deliberate paths: no cache yet, a
+* source-backed replay (`epoch` bump: resize / Ctrl+L / Ctrl+R remounts
+* `<Static>` and must re-flush the CURRENT rows), a `resumed` change, or a shrink
+* (`store.reset`). A reasoning toggle rebuilds only the rows whose text
+* depends on it, preserving the other rows' element identity.
+*/
+function computeSettledRows(previous, entries, settled, showReasoning, resumed, epoch) {
+	if (previous === void 0 || previous.epoch !== epoch || previous.resumed !== resumed || settled < previous.entries.length) {
+		const records = /* @__PURE__ */ new Map();
+		const flat = [(0, import_react.createElement)(Header, {
+			key: "header",
+			resumed
+		})];
+		for (let index = 0; index < settled; index++) {
+			const entry = entries[index];
+			const record = buildSettledRow(entry, index, showReasoning);
+			records.set(entry, record);
+			if (record.before !== void 0) flat.push(record.before);
+			flat.push(record.box);
+			if (record.after !== void 0) flat.push(record.after);
+		}
+		return {
+			cache: {
+				entries: entries.slice(0, settled),
+				records,
+				header: flat[0],
+				resumed,
+				showReasoning,
+				epoch,
+				flat
+			},
+			built: settled
+		};
+	}
+	if (previous.showReasoning !== showReasoning) {
+		const records = previous.records;
+		const flat = [previous.header];
+		let built = 0;
+		for (let index = 0; index < previous.entries.length; index++) {
+			const entry = previous.entries[index];
+			const record = records.get(entry);
+			const current = record.reasonSensitive ? {
+				...record,
+				box: (0, import_react.createElement)(Box, {
+					key: index,
+					paddingX: 1
+				}, (0, import_react.createElement)(EntryLine, {
+					entry,
+					showReasoning,
+					verbose: false
+				})),
+				showReasoning
+			} : record;
+			if (current !== record) {
+				records.set(entry, current);
+				built += 1;
+			}
+			if (current.before !== void 0) flat.push(current.before);
+			flat.push(current.box);
+			if (current.after !== void 0) flat.push(current.after);
+		}
+		return {
+			cache: {
+				...previous,
+				records,
+				showReasoning,
+				flat
+			},
+			built
+		};
+	}
+	if (settled === previous.entries.length) return {
+		cache: previous,
+		built: 0
+	};
+	const records = previous.records;
+	const suffix = [];
+	const added = [];
+	for (let index = previous.entries.length; index < settled; index++) {
+		const entry = entries[index];
+		const record = buildSettledRow(entry, index, showReasoning);
+		records.set(entry, record);
+		suffix.push(entry);
+		if (record.before !== void 0) added.push(record.before);
+		added.push(record.box);
+		if (record.after !== void 0) added.push(record.after);
+	}
+	return {
+		cache: {
+			entries: previous.entries.concat(suffix),
+			records,
+			header: previous.header,
+			resumed: previous.resumed,
+			showReasoning,
+			epoch: previous.epoch,
+			flat: previous.flat.concat(added)
+		},
+		built: settled - previous.entries.length
+	};
+}
 /** The whole terminal app; state arrives via the store, output via Ink. */
 function App(props) {
 	const view = (0, import_react.useSyncExternalStore)(props.store.subscribe, props.store.getView);
-	const descriptors = (0, import_react.useSyncExternalStore)(props.commands.subscribe, () => props.commands.descriptors);
-	const skills = (0, import_react.useSyncExternalStore)(props.skills.subscribe, () => props.skills.rows);
+	const readDescriptors = (0, import_react.useCallback)(() => props.commands.descriptors, [props.commands]);
+	const readSkills = (0, import_react.useCallback)(() => props.skills.rows, [props.skills]);
+	const descriptors = (0, import_react.useSyncExternalStore)(props.commands.subscribe, readDescriptors);
+	const skills = (0, import_react.useSyncExternalStore)(props.skills.subscribe, readSkills);
 	const [modelLabel, setModelLabel] = (0, import_react.useState)(props.model);
 	const [modelOpen, setModelOpen] = (0, import_react.useState)(false);
+	/** Nested /model stages; only one owns terminal input at a time. */
+	const [providerOpen, setProviderOpen] = (0, import_react.useState)(false);
+	const [providerAction, setProviderAction] = (0, import_react.useState)(void 0);
 	/** The model row whose effort levels the /model stage lists; undefined shows the model list. */
 	const [effortFor, setEffortFor] = (0, import_react.useState)(void 0);
 	/** Effective reasoning effort, shown in the /model picker and switch notice. */
@@ -29196,8 +30579,10 @@ function App(props) {
 	* per-style durations), then the band returns to static while the prompt
 	* marker keeps the tier accent. The trigger follows the applied model
 	* label (what the status bar actually shows), never the initial paint,
-	* and the tier is derived from the label and cached at the switch. */
-	const [waveTick, setWaveTick] = (0, import_react.useState)(null);
+	* and the tier is derived from the label and cached at the switch. The
+	* 33ms tick itself lives inside Input, so the sweep re-renders only the
+	* composer row, not the whole tree, at 30fps; App owns the rarely-changing
+	* tier/style and Input starts the sweep whenever that pair changes. */
 	const [waveTier, setWaveTier] = (0, import_react.useState)(null);
 	const [waveStyle, setWaveStyle] = (0, import_react.useState)(null);
 	const previousModel = (0, import_react.useRef)(void 0);
@@ -29212,7 +30597,6 @@ function App(props) {
 		if (!isOfficialDeepSeekLabel(modelLabel)) {
 			setWaveTier(null);
 			setWaveStyle(null);
-			setWaveTick(null);
 			return;
 		}
 		if (modelChanged || effortChanged) {
@@ -29220,28 +30604,12 @@ function App(props) {
 			const nextStyle = deepseekWaveStyleRandom(previousStyle.current);
 			previousStyle.current = nextStyle;
 			setWaveStyle(nextStyle);
-			setWaveTick(0);
 		}
 	}, [modelLabel, effortLabel]);
-	const waveActive = waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 < deepseekWaveDuration(waveTier, waveStyle);
-	(0, import_react.useEffect)(() => {
-		if (!waveActive) return;
-		const id = setInterval(() => {
-			setWaveTick((current) => current === null ? 0 : current + 1);
-		}, 33);
-		return () => {
-			clearInterval(id);
-		};
-	}, [waveActive]);
-	(0, import_react.useEffect)(() => {
-		if (waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 >= deepseekWaveDuration(waveTier, waveStyle)) setWaveTick(null);
-	}, [
-		waveTick,
-		waveTier,
-		waveStyle
-	]);
 	const [directory, setDirectory] = (0, import_react.useState)(void 0);
 	const [modelError, setModelError] = (0, import_react.useState)(void 0);
+	const [providerDirectory, setProviderDirectory] = (0, import_react.useState)(void 0);
+	const [providerError, setProviderError] = (0, import_react.useState)(void 0);
 	const [modelLoadEpoch, setModelLoadEpoch] = (0, import_react.useState)(0);
 	const [notice, setNotice] = (0, import_react.useState)(void 0);
 	const notify = (0, import_react.useCallback)((text, tone = "info") => {
@@ -29271,11 +30639,39 @@ function App(props) {
 		modelLoadEpoch,
 		props.loadModels
 	]);
+	(0, import_react.useEffect)(() => {
+		if (!modelOpen || props.loadModelProviders === void 0) return;
+		let cancelled = false;
+		setProviderDirectory(void 0);
+		setProviderError(void 0);
+		Promise.resolve().then(() => props.loadModelProviders()).then((loaded) => {
+			if (!cancelled) setProviderDirectory(loaded);
+		}, (error) => {
+			if (!cancelled) setProviderError(error instanceof Error ? error.message : String(error));
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		modelOpen,
+		modelLoadEpoch,
+		props.loadModelProviders
+	]);
+	(0, import_react.useEffect)(() => {
+		const subscribe = props.subscribeModelProviders;
+		if (!modelOpen || subscribe === void 0) return;
+		try {
+			return subscribe(() => setModelLoadEpoch((epoch) => epoch + 1));
+		} catch (error) {
+			setProviderError(error instanceof Error ? error.message : String(error));
+		}
+	}, [modelOpen, props.subscribeModelProviders]);
 	const busy = view.busy;
 	const [showReasoning, setShowReasoning] = (0, import_react.useState)(false);
 	const [verboseOpen, setVerboseOpen] = (0, import_react.useState)(false);
 	const [helpOpen, setHelpOpen] = (0, import_react.useState)(false);
 	const [modeOpen, setModeOpen] = (0, import_react.useState)(false);
+	const [permissionOpen, setPermissionOpen] = (0, import_react.useState)(false);
 	const [resumeOpen, setResumeOpen] = (0, import_react.useState)(false);
 	const [pluginOpen, setPluginOpen] = (0, import_react.useState)(false);
 	const [pluginQuery, setPluginQuery] = (0, import_react.useState)("");
@@ -29295,20 +30691,39 @@ function App(props) {
 	const historyConsumed = (0, import_react.useCallback)(() => {
 		setHistoryFill(void 0);
 	}, []);
-	/** Live queued inbox rows (event-sourced from `agent/inbox/spliced`). */
-	const queuedRows = (0, import_react.useMemo)(() => view.entries.filter((entry) => entry.kind === "pending"), [view.entries]);
+	/** The append-only flush boundary (see `settledEntryCount`): entries below
+	* this index are final and ride the `<Static>` scrollback; everything at or
+	* beyond stays in the live tree. Pending inbox rows always live at
+	* index >= settled, so the queued-inbox scan below only walks the mutable
+	* tail instead of the whole history. */
+	const settled = (0, import_react.useMemo)(() => settledEntryCount(view.entries), [view.entries]);
+	/** Live queued inbox rows (event-sourced from `agent/inbox/spliced`). The
+	* projection only appends and removes pending rows at index >= settled, so
+	* a bounded tail scan replaces an unconditional O(history) filter on every
+	* event. */
+	const queuedRows = (0, import_react.useMemo)(() => {
+		const rows = [];
+		for (let index = settled; index < view.entries.length; index++) {
+			const entry = view.entries[index];
+			if (entry.kind === "pending") rows.push(entry);
+		}
+		return rows;
+	}, [view.entries, settled]);
 	const [refreshEpoch, setRefreshEpoch] = (0, import_react.useState)(0);
 	const approvalSnapshot = (0, import_react.useSyncExternalStore)(props.approval.subscribe, props.approval.getSnapshot);
 	const questionSnapshot = (0, import_react.useSyncExternalStore)(props.questions.subscribe, props.questions.getSnapshot);
 	const approvalPending = approvalSnapshot.pending !== void 0;
 	const questionPending = questionSnapshot.pending !== void 0;
-	const inputActive = !modelOpen && !helpOpen && !modeOpen && !resumeOpen && !pluginOpen && !statuslineOpen && !themeOpen && !historyOpen && !verboseOpen && !approvalPending && !questionPending;
+	const inputActive = !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !statuslineOpen && !themeOpen && !historyOpen && !verboseOpen && !approvalPending && !questionPending;
 	(0, import_react.useEffect)(() => {
 		if (!approvalPending && !questionPending) return;
 		setModelOpen(false);
+		setProviderOpen(false);
+		setProviderAction(void 0);
 		setEffortFor(void 0);
 		setHelpOpen(false);
 		setModeOpen(false);
+		setPermissionOpen(false);
 		setResumeOpen(false);
 		setPluginOpen(false);
 		setStatuslineOpen(false);
@@ -29316,38 +30731,17 @@ function App(props) {
 		setHistoryOpen(false);
 		setVerboseOpen(false);
 	}, [approvalPending, questionPending]);
-	const settled = (0, import_react.useMemo)(() => settledEntryCount(view.entries), [view.entries]);
+	const settledRowsCache = (0, import_react.useRef)(void 0);
 	const settledRows = (0, import_react.useMemo)(() => {
-		const rows = [(0, import_react.createElement)(Header, {
-			key: "header",
-			resumed: props.resumed
-		})];
-		view.entries.slice(0, settled).forEach((entry, index) => {
-			const row = (0, import_react.createElement)(EntryLine, {
-				entry,
-				showReasoning,
-				verbose: false
-			});
-			const roomyPrompt = entry.kind === "user" && !entry.notice;
-			if (roomyPrompt) rows.push((0, import_react.createElement)(Box, {
-				key: `prompt-before-${index}`,
-				paddingX: 1
-			}, (0, import_react.createElement)(Text, null, " ")));
-			rows.push((0, import_react.createElement)(Box, {
-				key: index,
-				paddingX: 1
-			}, row));
-			if (roomyPrompt) rows.push((0, import_react.createElement)(Box, {
-				key: `prompt-after-${index}`,
-				paddingX: 1
-			}, (0, import_react.createElement)(Text, null, " ")));
-		});
-		return rows;
+		const result = computeSettledRows(settledRowsCache.current, view.entries, settled, showReasoning, props.resumed, refreshEpoch);
+		settledRowsCache.current = result.cache;
+		return result.cache.flat;
 	}, [
 		view.entries,
 		settled,
 		showReasoning,
-		props.resumed
+		props.resumed,
+		refreshEpoch
 	]);
 	const appStdout = useStdout().stdout;
 	const [terminalSize, setTerminalSize] = (0, import_react.useState)(() => ({
@@ -29394,8 +30788,8 @@ function App(props) {
 	const streamRows = Math.max(1, dynamicRows - visibleLiveLines.length);
 	const reasoningRows = view.streamingReasoning === "" ? 0 : view.streaming === "" ? streamRows : streamRows <= 1 ? 0 : showReasoning ? Math.max(1, Math.floor(streamRows / 3)) : 1;
 	const answerRows = view.streaming === "" ? 0 : Math.max(1, streamRows - reasoningRows);
-	const transcriptVisible = !modelOpen && !helpOpen && !modeOpen && !resumeOpen && !pluginOpen && !statuslineOpen && !themeOpen && !historyOpen && !verboseOpen && !approvalPending && !questionPending;
-	const modalVisible = modelOpen || helpOpen || modeOpen || resumeOpen || pluginOpen || statuslineOpen || themeOpen || historyOpen || verboseOpen && !approvalPending && !questionPending || approvalPending || questionPending;
+	const transcriptVisible = !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !statuslineOpen && !themeOpen && !historyOpen && !verboseOpen && !approvalPending && !questionPending;
+	const modalVisible = modelOpen || helpOpen || modeOpen || permissionOpen || resumeOpen || pluginOpen || statuslineOpen || themeOpen || historyOpen || verboseOpen && !approvalPending && !questionPending || approvalPending || questionPending;
 	const closeInspector = (0, import_react.useCallback)(() => {
 		setVerboseOpen(false);
 	}, []);
@@ -29411,11 +30805,120 @@ function App(props) {
 			setEffortLabel(effortId);
 			notify(`model → next step uses ${label}${effortId === void 0 || effortId === "" ? "" : `@${effortId}`}`);
 			setModelOpen(false);
+			setProviderOpen(false);
+			setProviderAction(void 0);
 			setEffortFor(void 0);
 		} catch (error) {
 			notify(`model switch failed: ${error instanceof Error ? error.message : String(error)}`, "error");
 		}
 	};
+	const reloadModelSurfaces = () => {
+		setModelLoadEpoch((epoch) => epoch + 1);
+	};
+	const closeModelSurface = () => {
+		setModelOpen(false);
+		setProviderOpen(false);
+		setProviderAction(void 0);
+		setEffortFor(void 0);
+	};
+	let modelSurface;
+	if (modelOpen && !approvalPending && !questionPending) {
+		if (providerAction?.kind === "credential" && props.saveModelProviderCredential !== void 0) modelSurface = (0, import_react.createElement)(ProviderCredentialPanel, {
+			target: providerAction.target,
+			save: props.saveModelProviderCredential,
+			done: () => {
+				const target = providerAction.target;
+				setProviderAction(void 0);
+				setProviderOpen(false);
+				reloadModelSurfaces();
+				notify(`API key saved for ${target.displayName}; select a model`);
+			},
+			back: () => setProviderAction(void 0)
+		});
+		else if (providerAction?.kind === "unset" && props.unsetModelProviderCredential !== void 0) modelSurface = (0, import_react.createElement)(ProviderConfirmPanel, {
+			target: providerAction.target,
+			kind: "credential",
+			confirm: props.unsetModelProviderCredential,
+			done: () => {
+				const target = providerAction.target;
+				setProviderAction(void 0);
+				setProviderOpen(true);
+				reloadModelSurfaces();
+				notify(`API key removed for ${target.displayName}`);
+			},
+			back: () => setProviderAction(void 0)
+		});
+		else if (providerAction?.kind === "remove" && props.removeModelProvider !== void 0) modelSurface = (0, import_react.createElement)(ProviderConfirmPanel, {
+			target: providerAction.target,
+			kind: "provider",
+			confirm: props.removeModelProvider,
+			done: () => {
+				const target = providerAction.target;
+				setProviderAction(void 0);
+				setProviderOpen(true);
+				reloadModelSurfaces();
+				notify(`provider removed: ${target.displayName}`);
+			},
+			back: () => setProviderAction(void 0)
+		});
+		else if (providerOpen) modelSurface = (0, import_react.createElement)(ProviderPanel, {
+			directory: providerDirectory,
+			error: providerError,
+			onCredential: (target) => {
+				if (props.saveModelProviderCredential === void 0) {
+					notify("API key storage is unavailable in this profile", "warning");
+					return;
+				}
+				setProviderAction({
+					kind: "credential",
+					target
+				});
+			},
+			onUnset: (target) => {
+				if (props.unsetModelProviderCredential === void 0) {
+					notify("API key removal is unavailable in this profile", "warning");
+					return;
+				}
+				setProviderAction({
+					kind: "unset",
+					target
+				});
+			},
+			onRemove: (target) => {
+				if (props.removeModelProvider === void 0) {
+					notify("provider removal is unavailable in this profile", "warning");
+					return;
+				}
+				setProviderAction({
+					kind: "remove",
+					target
+				});
+			},
+			onRetry: reloadModelSurfaces,
+			onBack: () => setProviderOpen(false)
+		});
+		else if (effortFor !== void 0) modelSurface = (0, import_react.createElement)(EffortPanel, {
+			row: effortFor,
+			current: effortLabel,
+			select: (effortId) => applyModel(effortFor, effortId),
+			back: () => setEffortFor(void 0)
+		});
+		else modelSurface = (0, import_react.createElement)(ModelPanel, {
+			directory,
+			error: modelError,
+			onSelect: (row) => {
+				if (row.reasoning !== void 0 && row.reasoning.efforts.length > 1) {
+					setEffortFor(row);
+					return;
+				}
+				const effortId = row.reasoning?.efforts.length === 1 ? row.reasoning.efforts[0].id : void 0;
+				applyModel(row, effortId);
+			},
+			...props.loadModelProviders === void 0 || props.saveModelProviderCredential === void 0 ? {} : { onProviders: () => setProviderOpen(true) },
+			onRetry: reloadModelSurfaces,
+			onClose: closeModelSurface
+		});
+	}
 	return (0, import_react.createElement)(Box, { flexDirection: "column" }, (0, import_react.createElement)(MemoStaticTranscript, {
 		key: refreshEpoch,
 		items: settledRows
@@ -29424,7 +30927,8 @@ function App(props) {
 		paddingX: 2
 	}, visibleLiveLines.length === 0 ? void 0 : (0, import_react.createElement)(StyledRows, { lines: visibleLiveLines }), view.streamingReasoning !== "" && reasoningRows > 0 ? (0, import_react.createElement)(StreamTail, {
 		text: showReasoning ? view.streamingReasoning : "Thinking…",
-		prefix: "  ✻ ",
+		prefix: "✻ ",
+		continuationPrefix: "  ",
 		dim: true,
 		maxRows: reasoningRows
 	}) : void 0, view.streaming !== "" && answerRows > 0 ? (0, import_react.createElement)(StreamTail, {
@@ -29439,30 +30943,7 @@ function App(props) {
 	}), (0, import_react.createElement)(ApprovalBar, {
 		snapshot: approvalSnapshot,
 		locked: questionPending
-	}), modelOpen && !approvalPending && !questionPending ? effortFor === void 0 ? (0, import_react.createElement)(ModelPanel, {
-		directory,
-		error: modelError,
-		onSelect: (row) => {
-			if (row.reasoning !== void 0 && row.reasoning.efforts.length > 1) {
-				setEffortFor(row);
-				return;
-			}
-			const effortId = row.reasoning?.efforts.length === 1 ? row.reasoning.efforts[0].id : void 0;
-			applyModel(row, effortId);
-		},
-		onRetry: () => {
-			setModelLoadEpoch((epoch) => epoch + 1);
-		},
-		onClose: () => {
-			setModelOpen(false);
-			setEffortFor(void 0);
-		}
-	}) : (0, import_react.createElement)(EffortPanel, {
-		row: effortFor,
-		current: effortLabel,
-		select: (effortId) => applyModel(effortFor, effortId),
-		back: () => setEffortFor(void 0)
-	}) : void 0, helpOpen && !approvalPending && !questionPending ? (0, import_react.createElement)(HelpPanel, {
+	}), modelSurface, helpOpen && !approvalPending && !questionPending ? (0, import_react.createElement)(HelpPanel, {
 		descriptors,
 		skills,
 		commandError: props.commands.error,
@@ -29483,6 +30964,19 @@ function App(props) {
 			}, (reason) => notify(`mode switch failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error"));
 		},
 		close: () => setModeOpen(false)
+	}) : void 0, permissionOpen && !approvalPending && !questionPending ? (0, import_react.createElement)(PermissionPanel, {
+		current: props.permission,
+		load: props.loadPermissions,
+		select: (id) => {
+			try {
+				const selected = props.setPermission(id);
+				notify(`permission → ${selected}`);
+				setPermissionOpen(false);
+			} catch (reason) {
+				notify(`permission change failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
+			}
+		},
+		close: () => setPermissionOpen(false)
 	}) : void 0, resumeOpen && !approvalPending && !questionPending ? (0, import_react.createElement)(ResumePanel, {
 		currentCwd: props.workspaceRoot,
 		load: props.loadSessions,
@@ -29542,6 +31036,10 @@ function App(props) {
 		openModel: () => {
 			setDirectory(void 0);
 			setModelError(void 0);
+			setProviderDirectory(void 0);
+			setProviderError(void 0);
+			setProviderOpen(false);
+			setProviderAction(void 0);
 			setEffortFor(void 0);
 			setModelOpen(true);
 		},
@@ -29572,6 +31070,7 @@ function App(props) {
 			setHelpOpen(true);
 		},
 		openMode: () => setModeOpen(true),
+		openPermission: () => setPermissionOpen(true),
 		openResume: () => setResumeOpen(true),
 		openPlugin: (query = "") => {
 			setPluginQuery(query);
@@ -29609,7 +31108,6 @@ function App(props) {
 		cancelQueued: props.cancelQueued,
 		historyFill,
 		historyConsumed,
-		waveTick,
 		waveTier,
 		waveStyle
 	}), (0, import_react.createElement)(StatusLine, {
@@ -29621,7 +31119,7 @@ function App(props) {
 			sessionId: props.sessionId,
 			title: view.title,
 			plan: view.plan,
-			permission: view.permission,
+			permission: view.permission !== "" ? view.permission : props.permission,
 			sandbox: view.sandbox,
 			goal: view.goal === void 0 ? void 0 : {
 				phase: view.goal.phase,
@@ -29665,16 +31163,22 @@ function mountApprovalAnswerer(ctx, owns, preview) {
 		if (request.signal?.aborted === true) return Promise.resolve("cancelled");
 		let resolved = false;
 		let settle;
+		const signal = request.signal;
+		const onAbort = () => withdraw();
+		const detachAbort = () => {
+			if (signal !== void 0) signal.removeEventListener("abort", onAbort);
+		};
 		const withdraw = () => {
 			if (resolved) return;
 			resolved = true;
+			detachAbort();
 			set({
 				pending: void 0,
 				answered: false
 			});
 			settle("cancelled");
 		};
-		if (request.signal !== void 0) request.signal.addEventListener("abort", withdraw, { once: true });
+		if (signal !== void 0) signal.addEventListener("abort", onAbort, { once: true });
 		const pending = {
 			headline: request.reason ?? `tool ${request.toolName} asks for your approval`,
 			toolName: request.toolName,
@@ -29682,6 +31186,7 @@ function mountApprovalAnswerer(ctx, owns, preview) {
 			answer: (outcome) => {
 				if (resolved) return;
 				resolved = true;
+				detachAbort();
 				set({
 					pending,
 					answered: true
@@ -29914,6 +31419,292 @@ async function loadModelDirectory(ctx) {
 	};
 }
 //#endregion
+//#region src/provider-settings.ts
+/** Human text for a rejection value (mirrors the web page's `messageOf`). */
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Collapse every whitespace/control run to one space so a notice stays one line. */
+function singleLine(message) {
+	return message.replace(/[\u0000-\u001F\u007F]/g, " ").replace(/\s+/g, " ").trim();
+}
+/** Keep a misbehaving credential provider from reflecting the submitted secret. */
+function credentialWriteMessage(error, secret) {
+	const message = singleLine(messageOf(error));
+	return message.includes(secret) ? "credentials service rejected the API key" : message;
+}
+/** Obvious shell-assignment paste; mirrors the official Web Models editor. */
+const ENV_ASSIGNMENT = /^[A-Z][A-Z0-9_]*=[^=]/;
+/** Whether the whole draft is wrapped in one matching quote pair. */
+function hasWrappingQuotes(value) {
+	const first = value[0];
+	return (first === "\"" || first === "'" || first === "`") && value.length > 1 && value.endsWith(first);
+}
+/** Read the value at a path through plain objects; undefined when any segment misses. */
+function getPath(value, path) {
+	let current = value;
+	for (const segment of path) {
+		if (typeof current !== "object" || current === null) return void 0;
+		current = current[segment];
+	}
+	return current;
+}
+/** Whether a path resolves to a defined value (the empty path reads the root). */
+function hasPath(value, path) {
+	return path.length === 0 ? value !== void 0 : getPath(value, path) !== void 0;
+}
+/** The credential reference a resolved profile names (its `apiKeyEnv` field). */
+function profileRefOf(profile) {
+	if (typeof profile !== "object" || profile === null) return void 0;
+	const ref = profile.apiKeyEnv;
+	return typeof ref === "string" && ref.length > 0 ? ref : void 0;
+}
+/**
+* The conventional credential reference for a provider route: `<ROUTE>_API_KEY`
+* with the route uppercased and every non-alphanumeric run collapsed to one
+* underscore — the exact derivation the official Models page uses
+* (`deriveKeyRef` in `ui-settings-models`), so a key saved here is found there.
+* @param provider - provider route id (e.g. `pi-ai`, `minimax-cn`).
+* @returns the derived reference name (e.g. `PI_AI_API_KEY`).
+*/
+function deriveCredentialRef(provider) {
+	return `${provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`;
+}
+/** Events that invalidate the official Models provider/settings/credential join. */
+const PROVIDER_SETTINGS_EVENTS = [
+	"credentials/updated",
+	"settings/document-updated",
+	"llm/adapters-updated"
+];
+/** Subscribe to the same provider-directory invalidations as the official Web Models page. */
+function subscribeProviderSettings(ctx, listener) {
+	const events = ctx;
+	const disposers = PROVIDER_SETTINGS_EVENTS.map((event) => events.on(event, () => listener()));
+	return () => {
+		for (const dispose of disposers) dispose();
+	};
+}
+/** A single-line, bounded error from the provider-management adapter. */
+var ProviderSettingsError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ProviderSettingsError";
+	}
+};
+/**
+* Join the configurable-provider directory, the redacted settings
+* namespaces, and the referenced credentials into panel rows, web-parity:
+* - directory entries merge with `listProviders()` to mark each live or
+*   dormant, and routes registered without a directory declaration appear as
+*   read-only/unmanaged rows (no settings address);
+* - a whole-section entry is configured whenever its namespace resolves;
+*   a path-addressed one only when the profile resolves there;
+* - a row is removable when the user layer alone carries its profile;
+* - only refs named by resolved profiles are described, and a per-ref failure
+*   degrades to that row's bounded error instead of losing it.
+* Absent `settings`/`credentials` services are tolerated the same way.
+* @param ctx - context carrying the `llm` service (settings/credentials optional).
+* @returns the resolved directory; empty rows when `llm` is unavailable.
+*/
+async function loadProviderSettings(ctx) {
+	const llm = ctx.get("llm");
+	if (llm === void 0) return {
+		rows: [],
+		writable: false,
+		failures: []
+	};
+	const registered = llm.listProviders();
+	const failures = [];
+	const directoryEntries = [];
+	if (llm.listConfigurableProviders !== void 0) try {
+		directoryEntries.push(...llm.listConfigurableProviders());
+	} catch (error) {
+		failures.push(`configurable-provider directory failed: ${singleLine(messageOf(error))}`);
+	}
+	const settings = ctx.get("settings");
+	let descriptors = [];
+	let writable = false;
+	if (settings !== void 0) try {
+		descriptors = settings.describe({ redactSecrets: true });
+		writable = settings.writable === true;
+	} catch (error) {
+		failures.push(`settings describe failed: ${singleLine(messageOf(error))}`);
+	}
+	const namespaces = new Map(descriptors.map((descriptor) => [descriptor.ns, descriptor]));
+	const active = new Set(registered.map((provider) => provider.id));
+	const declared = new Set(directoryEntries.map((entry) => entry.provider));
+	const rows = [...directoryEntries.map((entry) => ({
+		provider: entry.provider,
+		displayName: entry.displayName,
+		active: active.has(entry.provider),
+		settingsNs: entry.settingsNs,
+		settingsPath: entry.settingsPath,
+		...entry.declared === void 0 ? {} : { declared: entry.declared }
+	})), ...registered.filter((provider) => !declared.has(provider.id)).map((provider) => ({
+		provider: provider.id,
+		displayName: provider.name,
+		active: true,
+		settingsNs: "",
+		settingsPath: []
+	}))].map((base) => {
+		const namespace = base.settingsNs.length === 0 ? void 0 : namespaces.get(base.settingsNs);
+		const profile = namespace === void 0 ? void 0 : base.settingsPath.length === 0 ? namespace.value : getPath(namespace.value, base.settingsPath);
+		const configured = namespace !== void 0 && (base.settingsPath.length === 0 || profile !== void 0);
+		const removable = namespace !== void 0 && base.settingsPath.length > 0 && hasPath(namespace.user, base.settingsPath) && !hasPath(namespace.base, base.settingsPath);
+		const credentialRef = profileRefOf(profile);
+		return {
+			provider: base.provider,
+			displayName: base.displayName,
+			active: base.active,
+			settingsNs: base.settingsNs,
+			settingsPath: base.settingsPath,
+			settingsRevision: namespace?.revision ?? 0,
+			configured,
+			removable,
+			...credentialRef === void 0 ? {} : { credentialRef },
+			suggestedRef: deriveCredentialRef(base.provider),
+			...base.declared === void 0 ? {} : { declared: base.declared }
+		};
+	});
+	const refs = [...new Set(rows.flatMap((row) => row.credentialRef === void 0 ? [] : [row.credentialRef]))];
+	const credentialViews = /* @__PURE__ */ new Map();
+	const credentials = ctx.get("credentials");
+	if (refs.length > 0) {
+		if (credentials === void 0) for (const ref of refs) credentialViews.set(ref, {
+			kind: "error",
+			message: "credentials service is unavailable"
+		});
+		else await Promise.all(refs.map(async (ref) => {
+			try {
+				const facts = await credentials.describe(ref);
+				credentialViews.set(ref, {
+					kind: "facts",
+					configured: facts.configured,
+					writable: facts.writable,
+					...facts.source === void 0 ? {} : { source: facts.source }
+				});
+			} catch (error) {
+				credentialViews.set(ref, {
+					kind: "error",
+					message: singleLine(messageOf(error))
+				});
+			}
+		}));
+	}
+	return {
+		rows: rows.map((row) => ({
+			...row,
+			credential: row.credentialRef === void 0 ? void 0 : credentialViews.get(row.credentialRef) ?? {
+				kind: "error",
+				message: "credential describe returned no view"
+			}
+		})),
+		writable,
+		failures
+	};
+}
+/**
+* Store a provider API key, web-parity: validate with `normalizeApiKey`
+* (single-line, actionable errors that never echo the key), materialize the
+* profile/`apiKeyEnv` through `settings.mutate` first when the resolved
+* profile names no reference (dormant route or ref-less profile), then store
+* under the trusted named ref or the derived conventional ref. An existing
+* whole-section DeepSeek whose resolved profile already names
+* `DEEPSEEK_API_KEY` needs no settings mutation. Env-supplied read-only keys
+* are refused before any service call.
+* @param ctx - context carrying `settings` (when materializing) and `credentials`.
+* @param target - the joined row to write through.
+* @param rawKey - the key exactly as typed; surrounding whitespace is trimmed.
+* @throws {@link ProviderSettingsError} with a single-line, key-free message.
+*/
+async function saveProviderCredential(ctx, target, rawKey) {
+	const trimmed = rawKey.trim();
+	if (ENV_ASSIGNMENT.test(trimmed) || hasWrappingQuotes(trimmed)) throw new ProviderSettingsError("paste only the API key, without an environment-variable name or wrapping quotes");
+	const checked = normalizeApiKey(rawKey);
+	if (!checked.ok) throw new ProviderSettingsError(checked.reason === "empty" ? "the API key is empty after trimming surrounding whitespace" : "the API key contains characters an HTTP header cannot carry; type a plain printable-ASCII key");
+	if (target.settingsNs.length === 0) throw new ProviderSettingsError(`provider "${target.provider}" has no managed settings namespace; configure it in settings.yaml`);
+	if (target.credential?.kind === "facts" && target.credential.writable === false) throw new ProviderSettingsError(`the key for provider "${target.provider}" is supplied read-only by the environment; unset it in the shell instead of overwriting it here`);
+	const credentials = ctx.get("credentials");
+	if (credentials === void 0) throw new ProviderSettingsError("credentials service is unavailable; cannot store the API key");
+	const ref = target.credentialRef ?? deriveCredentialRef(target.provider);
+	if (target.credentialRef === void 0) {
+		const settings = ctx.get("settings");
+		if (settings === void 0) throw new ProviderSettingsError("settings service is unavailable; cannot materialize the credential reference");
+		try {
+			await settings.mutate(target.settingsNs, [{
+				op: "set",
+				path: [...target.settingsPath, "apiKeyEnv"],
+				value: ref
+			}]);
+		} catch (error) {
+			throw new ProviderSettingsError(singleLine(messageOf(error)));
+		}
+	}
+	try {
+		await credentials.set(ref, checked.value);
+	} catch (error) {
+		throw new ProviderSettingsError(credentialWriteMessage(error, checked.value));
+	}
+}
+/**
+* Remove the currently named credential without touching the provider
+* profile. Only the resolved profile's own reference is unset; a dormant or
+* ref-less row (nothing to remove), an already-absent key, and an
+* env-supplied read-only key are rejected safely before any service call.
+* @param ctx - context carrying the `credentials` service.
+* @param target - the joined row whose named credential to unset.
+* @throws {@link ProviderSettingsError} with a single-line, key-free message.
+*/
+async function unsetProviderCredential(ctx, target) {
+	const ref = target.credentialRef;
+	if (ref === void 0) throw new ProviderSettingsError(`provider "${target.provider}" names no credential reference to remove`);
+	const facts = target.credential;
+	if (facts?.kind === "facts" && facts.configured === false) throw new ProviderSettingsError(`provider "${target.provider}" has no configured credential to remove`);
+	if (facts?.kind === "facts" && facts.writable === false) throw new ProviderSettingsError(`the key for provider "${target.provider}" is supplied read-only by the environment; unset it in the shell instead`);
+	const credentials = ctx.get("credentials");
+	if (credentials === void 0) throw new ProviderSettingsError("credentials service is unavailable; cannot remove the API key");
+	try {
+		await credentials.unset(ref);
+	} catch (error) {
+		throw new ProviderSettingsError(singleLine(messageOf(error)));
+	}
+}
+/**
+* Remove a user-added provider profile, web-parity: only `removable` rows may
+* be removed; a page-managed credential — the derived ref, configured and
+* writable — is unset first (so a second-step failure leaves the row visible
+* and the operation retryable), then `settings.mutate` unsets
+* `target.settingsPath`. Both steps are idempotent. A hand-named credential
+* ref may be shared elsewhere and is left alone.
+* @param ctx - context carrying `credentials` and `settings`.
+* @param target - the joined row to remove.
+* @throws {@link ProviderSettingsError} with a single-line, key-free message.
+*/
+async function removeProviderSettings(ctx, target) {
+	if (!target.removable) throw new ProviderSettingsError(`provider "${target.provider}" is not removable from the user settings layer`);
+	if (target.settingsNs.length === 0) throw new ProviderSettingsError(`provider "${target.provider}" has no managed settings profile to remove`);
+	const managedRef = target.credentialRef === target.suggestedRef && target.credential?.kind === "facts" && target.credential.configured === true && target.credential.writable === true ? target.credentialRef : void 0;
+	if (managedRef !== void 0) {
+		const credentials = ctx.get("credentials");
+		if (credentials === void 0) throw new ProviderSettingsError("credentials service is unavailable; cannot remove the managed API key");
+		try {
+			await credentials.unset(managedRef);
+		} catch (error) {
+			throw new ProviderSettingsError(singleLine(messageOf(error)));
+		}
+	}
+	const settings = ctx.get("settings");
+	if (settings === void 0) throw new ProviderSettingsError("settings service is unavailable; cannot remove the provider profile");
+	try {
+		await settings.mutate(target.settingsNs, [{
+			op: "unset",
+			path: [...target.settingsPath]
+		}]);
+	} catch (error) {
+		throw new ProviderSettingsError(singleLine(messageOf(error)));
+	}
+}
+//#endregion
 //#region src/mentions.ts
 /**
 * Workspace @mention support: file and directory candidates from a bounded
@@ -30106,11 +31897,6 @@ function mountQuestionProvider(ctx) {
 	};
 	if (service !== void 0) service.registerProvider({ ask(request) {
 		return new Promise((resolve, reject) => {
-			const pending = {
-				request,
-				resolve,
-				reject
-			};
 			const onAbort = () => {
 				if (active === pending) {
 					active = void 0;
@@ -30122,6 +31908,15 @@ function mountQuestionProvider(ctx) {
 				}
 				reject(ABORT_ERROR);
 			};
+			const detachAbort = () => {
+				if (request.signal !== void 0) request.signal.removeEventListener("abort", onAbort);
+			};
+			const pending = {
+				request,
+				resolve,
+				reject,
+				detachAbort
+			};
 			if (request.signal?.aborted === true) {
 				reject(ABORT_ERROR);
 				return;
@@ -30147,6 +31942,7 @@ function mountQuestionProvider(ctx) {
 			if (active !== pending) return;
 			active = void 0;
 			set({ pending: void 0 });
+			pending.detachAbort?.();
 			pending.resolve(answers);
 			advance();
 		},
@@ -30154,6 +31950,7 @@ function mountQuestionProvider(ctx) {
 			if (active !== pending) return;
 			active = void 0;
 			set({ pending: void 0 });
+			pending.detachAbort?.();
 			pending.reject(ABORT_ERROR);
 			advance();
 		}
@@ -30174,6 +31971,15 @@ function mountQuestionProvider(ctx) {
 function createTranscriptStore(replay) {
 	let view = replay === void 0 ? createTranscriptView() : projectEvents(replay);
 	const listeners = /* @__PURE__ */ new Set();
+	let scheduled = false;
+	const notify = () => {
+		if (scheduled) return;
+		scheduled = true;
+		queueMicrotask(() => {
+			scheduled = false;
+			for (const listener of listeners) listener();
+		});
+	};
 	return {
 		getView: () => view,
 		subscribe(listener) {
@@ -30186,11 +31992,11 @@ function createTranscriptStore(replay) {
 			const next = projectEvent(view, event);
 			if (next === view) return;
 			view = next;
-			for (const listener of listeners) listener();
+			notify();
 		},
 		reset() {
 			view = createTranscriptView();
-			for (const listener of listeners) listener();
+			notify();
 		}
 	};
 }
@@ -30219,12 +32025,13 @@ function watchSkills(ctx) {
 	let error;
 	const listeners = /* @__PURE__ */ new Set();
 	const reload = () => {
-		const currentAgent = agent;
-		if (skills === void 0 || currentAgent === void 0) return;
+		const target = agent;
+		if (skills === void 0 || target === void 0) return;
 		Promise.resolve().then(() => skills.list({
-			cwd: currentAgent.session.header.cwd,
-			scope: currentAgent
+			cwd: target.session.header.cwd,
+			scope: target
 		})).then((summaries) => {
+			if (agent !== target) return;
 			const next = toRows(summaries);
 			const unchanged = next.length === rows.length && next.every((row, index) => row.name === rows[index]?.name);
 			rows = next;
@@ -30233,6 +32040,7 @@ function watchSkills(ctx) {
 			if (unchanged && !recovered) return;
 			for (const listener of listeners) listener();
 		}).catch((cause) => {
+			if (agent !== target) return;
 			rows = [...rows];
 			error = cause instanceof Error ? cause.message : String(cause);
 			for (const listener of listeners) listener();
@@ -30393,6 +32201,13 @@ function resolvePreset(session) {
 	}
 	return session.header.agentPreset ?? "standard";
 }
+/** Resolve a pre-session choice, or recompose an active blank Agent. */
+async function selectPreset(service, agent, presetId) {
+	if (agent !== void 0) return switchPreset(service, agent, presetId);
+	const preset = await service.resolve(presetId);
+	if (preset.broken !== void 0) throw new Error(preset.broken);
+	return preset;
+}
 /** Recompose atomically from the caller's perspective, logging only success. */
 async function switchPreset(service, agent, presetId) {
 	if (!isBlankSession(agent.session.events)) throw new Error("mode is locked after the first turn; use /new <mode>");
@@ -30401,6 +32216,51 @@ async function switchPreset(service, agent, presetId) {
 	return preset;
 }
 //#endregion
+//#region src/permissions.ts
+/** Read the optional Harness service without importing its runtime package. */
+function permissionPresetsFrom(ctx) {
+	return ctx.get("permissionPresets");
+}
+/** Effective label for either an active session or the not-yet-created first one. */
+function effectivePermission(service, session, pending) {
+	return session === void 0 ? pending ?? service.defaultPreset : service.current(session.events);
+}
+/** Validate a preset and write it only when a durable session already exists. */
+function selectPermission(service, session, preset) {
+	service.resolve(preset);
+	if (session !== void 0) service.set(session, preset);
+	return preset;
+}
+/** Cycle table order from the active, pending, or configured-default value. */
+function cyclePermission(service, session, pending) {
+	if (service.names.length === 0) return "";
+	const at = service.names.indexOf(effectivePermission(service, session, pending));
+	const next = service.names[(at + 1) % service.names.length] ?? "";
+	return next === "" ? "" : selectPermission(service, session, next);
+}
+/** Materialize a pre-session choice after Harness creates the first session. */
+function applyPendingPermission(service, session, pending) {
+	if (pending !== void 0 && effectivePermission(service, session, void 0) !== pending) selectPermission(service, session, pending);
+}
+/**
+* List every switchable preset for the /permission panel, table order kept.
+* Description lookup failures degrade to an undocumented row, never a failed
+* panel load — `optionOf` rejects names its table no longer knows.
+*/
+function listPermissionRows(service) {
+	return service.names.map((id) => {
+		if (service.optionOf === void 0) return { id };
+		try {
+			return {
+				id,
+				description: service.optionOf(id)?.description
+			};
+		} catch {
+			return { id };
+		}
+	});
+}
+//#endregion
 //#region src/plugin-inventory.ts
 const PHASES = {
 	0: "pending",
@@ -30429,16 +32289,46 @@ function listPluginRows(ctx) {
 //#endregion
 //#region src/session-directory.ts
 /** Lightweight session-directory projection for the /resume picker. */
+/** Case-insensitive filesystems (Windows, macOS) compare paths by lowercased form. */
+const CASE_INSENSITIVE_FS = process.platform === "win32" || process.platform === "darwin";
+/** True when the header describes a subagent conversation (durable lineage). */
+function isSubagentSession(header) {
+	return header.origin === "subagent" || header.parentSession !== void 0;
+}
+function comparablePath(value) {
+	const resolved = resolve(value);
+	return CASE_INSENSITIVE_FS ? resolved.toLowerCase() : resolved;
+}
+/** Platform-consistent path equality for session cwd comparisons. */
 function samePath(left, right) {
 	if (left === void 0) return false;
-	return resolve(left).toLowerCase() === resolve(right).toLowerCase();
+	return comparablePath(left) === comparablePath(right);
+}
+/**
+* Unique header match by exact id or unique id prefix (root and subagent
+* headers alike); the caller applies any lineage gate.
+* @param headers - the persisted headers.
+* @param wanted - the id or id prefix.
+* @returns the uniquely matched header.
+* @throws when nothing matches or the prefix is ambiguous.
+*/
+function matchSessionId(headers, wanted) {
+	const exact = headers.filter((header) => header.id === wanted);
+	const matches = exact.length > 0 ? exact : headers.filter((header) => header.id.startsWith(wanted));
+	if (matches.length === 0) throw new Error(`no persisted session matches "${wanted}"`);
+	if (matches.length > 1) throw new Error(`session prefix "${wanted}" is ambiguous (${matches.length} matches): use more of the id`);
+	return matches[0];
+}
+/** The newest persisted ROOT session pinned to this cwd, or undefined. */
+function newestRootForCwd(headers, cwd) {
+	return headers.filter((header) => !isSubagentSession(header) && samePath(header.cwd, cwd)).sort((left, right) => right.createdAt - left.createdAt)[0];
 }
 /** Filter/sort header-only records. No session log is loaded here. */
 function projectSessionRows(records, options) {
 	const needle = options.query.trim().toLowerCase();
-	return records.filter((record) => options.sessions === "all" || record.header.parentSession === void 0 && record.header.origin !== "subagent").filter((record) => options.cwd === "all" || samePath(record.header.cwd, options.currentCwd)).map((record) => {
+	return records.filter((record) => options.sessions === "all" || !isSubagentSession(record.header)).filter((record) => options.cwd === "all" || samePath(record.header.cwd, options.currentCwd)).map((record) => {
 		const cwd = record.header.cwd ?? "";
-		const subagent = record.header.origin === "subagent" || record.header.parentSession !== void 0;
+		const subagent = isSubagentSession(record.header);
 		return {
 			id: record.header.id,
 			createdAt: record.header.createdAt,
@@ -30510,6 +32400,46 @@ function gitBranch(cwd) {
 	}
 }
 /**
+* Reduce a session id to a filename-safe /export default-name suffix. Session
+* ids are normally minted `session-<uuid>`, but `--session` accepts arbitrary
+* user text: path separators must never leak into the default export filename
+* (which would escape the session cwd).
+* @param id - the session id.
+* @returns at most the last 8 filename-safe characters.
+*/
+function exportSessionIdSuffix(id) {
+	return id.replace(/[^a-zA-Z0-9._-]/gu, "_").slice(-8);
+}
+/**
+* Run the ordered quit cleanup, then request exit. Every step rejection is
+* contained (reported through `onError`) so a failed flush or dispose never
+* skips the remaining cleanup; the exit request is always reached exactly
+* once.
+* @param steps - the cleanup steps in dependency order (settle the visible
+* session, await the final in-flight composition, await durable recall).
+* @param exit - the terminal exit request (code 0).
+* @param onError - optional failure sink; called once per failing step and
+* itself contained, so a throwing sink cannot abort the sequence.
+* @returns the names of the steps that started, in order (for tests).
+*/
+async function runQuitSequence(steps, exit, onError) {
+	const started = [];
+	for (const step of steps) {
+		started.push(step.name);
+		try {
+			await step.run();
+		} catch (error) {
+			try {
+				onError?.(step.name, error);
+			} catch {}
+		}
+	}
+	try {
+		exit(0);
+	} catch {}
+	return started;
+}
+/**
 * Resolve the invocation's target session against the persisted headers.
 * @param startup - the parsed startup flags.
 * @param persistence - the persistence service; required for resume/latest.
@@ -30523,28 +32453,30 @@ async function resolveTarget(startup, persistence, cwd) {
 		resume: false,
 		mode: startup.mode
 	};
-	if (startup.kind === "named") return {
-		sessionId: startup.sessionId,
-		resume: false,
-		mode: startup.mode
-	};
+	if (startup.kind === "named") {
+		if (persistence !== void 0) {
+			if ((await persistence.list()).some((header) => header.id === startup.sessionId)) throw new Error(`session "${startup.sessionId}" already exists; use --resume to continue it`);
+		}
+		return {
+			sessionId: startup.sessionId,
+			resume: false,
+			mode: startup.mode
+		};
+	}
 	if (persistence === void 0) throw new Error("cannot resolve the requested session: session persistence is not configured");
 	const headers = await persistence.list();
 	if (startup.kind === "resume") {
-		const wanted = startup.sessionId;
-		const exact = headers.filter((header) => header.id === wanted);
-		const matches = exact.length > 0 ? exact : headers.filter((header) => header.id.startsWith(wanted));
-		if (matches.length === 0) throw new Error(`no persisted session matches "${wanted}"`);
-		if (matches.length > 1) throw new Error(`session prefix "${wanted}" is ambiguous (${matches.length} matches): use more of the id`);
+		const matched = matchSessionId(headers, startup.sessionId);
+		if (isSubagentSession(matched)) throw new Error("subagent conversations are read-only; resume a root session");
 		return {
-			sessionId: matches[0].id,
+			sessionId: matched.id,
 			resume: true
 		};
 	}
-	const local = headers.filter((header) => header.cwd === cwd).sort((left, right) => right.createdAt - left.createdAt);
-	if (local.length === 0) throw new Error(`no persisted session for this directory (${cwd}); start one without --continue`);
+	const newest = newestRootForCwd(headers, cwd);
+	if (newest === void 0) throw new Error(`no persisted session for this directory (${cwd}); start one without --continue`);
 	return {
-		sessionId: local[0].id,
+		sessionId: newest.id,
 		resume: true
 	};
 }
@@ -30583,12 +32515,13 @@ async function run(ctx, startup, io) {
 	const defaults = defaultModel.currentSelection();
 	const presets = agentPresetsFrom(ctx);
 	if (presets === void 0) throw new Error("agent preset service is unavailable; check the dsh-code bundle patch");
+	const permissionPresets = permissionPresetsFrom(ctx);
 	const lazy = startup.kind === "fresh" && startup.mode === void 0;
 	/** Prepare a complete next session before disturbing the currently visible one. */
 	const prepare = async (next) => {
 		const nextCwd = next.cwd ?? cwd;
 		const selectionState = pendingSelection === void 0 ? {} : { picked: pendingSelection };
-		let mode = next.mode;
+		let mode = next.resume ? next.mode : next.mode ?? pendingMode;
 		if (!next.resume) mode = (await presets.resolve(mode)).id;
 		const setup = async (agentCtx) => {
 			const sessionPreset = next.resume ? resolvePreset(agentCtx.agent.session) : mode;
@@ -30609,6 +32542,7 @@ async function run(ctx, startup, io) {
 				provider: defaults.provider,
 				model: defaults.model
 			},
+			signal: quitAbort.signal,
 			setup
 		}) : await agents.create({
 			sessionId: SessionId(next.sessionId),
@@ -30620,9 +32554,11 @@ async function run(ctx, startup, io) {
 				provider: defaults.provider,
 				model: defaults.model
 			},
+			signal: quitAbort.signal,
 			setup
 		});
 		const session = handle.agent.session;
+		if (!next.resume && permissionPresets !== void 0) applyPendingPermission(permissionPresets, session, pendingPermission);
 		const sessionCwd = session.header.cwd ?? nextCwd;
 		return {
 			handle,
@@ -30642,6 +32578,44 @@ async function run(ctx, startup, io) {
 	let mentions = createMentions(ctx, void 0, cwd);
 	/** Explicit model pick made before any session exists (a bare launch). */
 	let pendingSelection;
+	/** Agent preset selected before the first session exists. */
+	let pendingMode;
+	/** Ordered pre-session preset resolutions; first composition awaits them. */
+	let pendingModeWork = Promise.resolve();
+	/** Permission preset selected before the first session exists. */
+	let pendingPermission;
+	/**
+	* Monotonic session epoch: bumped on every successful activation, on every
+	* first-session creation, and on quit. Async callbacks (mention prepares,
+	* command executions) capture it at call time and drop their result when it
+	* changed, so a stale callback can never deliver to an agent that is no
+	* longer on screen.
+	*/
+	let epoch = 0;
+	/** Aborted on quit: an in-flight agent composition (create/resume) races this signal. */
+	const quitAbort = new AbortController();
+	/** In-flight mention-prepare / command-execute controllers, aborted on any session transition. */
+	const pendingControllers = /* @__PURE__ */ new Set();
+	const abortPendingControllers = () => {
+		for (const controller of [...pendingControllers]) {
+			pendingControllers.delete(controller);
+			controller.abort();
+		}
+	};
+	/** The in-flight session-composition turn (create/resume/activate), if any. */
+	let composing;
+	/**
+	* Run one session composition exclusively: concurrent compositions wait
+	* their turn, so a bare-launch first-session creation and a /resume
+	* activation can never compose agents in parallel (the loser would leak its
+	* agent or mis-deliver). Errors propagate to the caller; the shared slot
+	* always continues.
+	*/
+	const compose = (work) => {
+		const turn = (composing ?? Promise.resolve()).catch(() => {}).then(work);
+		composing = turn.catch(() => {});
+		return turn;
+	};
 	if (!lazy) {
 		const prepared = await prepare(await resolveTarget(startup, persistence, cwd));
 		active = prepared;
@@ -30696,16 +32670,12 @@ async function run(ctx, startup, io) {
 	} catch {
 		inputHistory = [];
 	}
+	/** Serialized history writes: each submission rewrites the latest in-memory snapshot. */
+	let historyWriteChain = Promise.resolve();
 	const recordHistory = (text) => {
 		if (text === "") return;
-		inputHistory = [...inputHistory, text].slice(-500);
-		let current = "";
-		try {
-			current = readFileSync(historyPath, "utf8");
-		} catch {
-			current = "";
-		}
-		mkdir(dirname(historyPath), { recursive: true }).then(() => writeFile(historyPath, appendHistoryContent(current, text), "utf8")).catch((writeError) => {
+		inputHistory = [...inputHistory, text].slice(-100);
+		historyWriteChain = historyWriteChain.then(() => mkdir(dirname(historyPath), { recursive: true })).then(() => writeFile(historyPath, serializeHistoryList(inputHistory), "utf8")).catch((writeError) => {
 			bridge.notify("history save failed: " + (writeError instanceof Error ? writeError.message : String(writeError)), "error");
 		});
 	};
@@ -30724,30 +32694,40 @@ async function run(ctx, startup, io) {
 		if (quitting) return;
 		quitting = true;
 		switchQueue.cancel();
+		abortPendingControllers();
+		quitAbort.abort();
+		epoch += 1;
 		off();
 		mountRef.current?.unmount();
 		const currentSession = session;
 		const currentActive = active;
-		if (currentSession === void 0 || currentActive === void 0) {
-			io.exit(0);
-			return;
-		}
-		sessions.flush(currentSession).catch((flushError) => {
-			internals.stderr.write(`dsh: session flush failed: ${flushError instanceof Error ? flushError.message : String(flushError)}\n`);
-		}).then(() => currentActive.handle.dispose()).catch((disposeError) => {
-			internals.stderr.write(`dsh: agent disposal failed: ${disposeError instanceof Error ? disposeError.message : String(disposeError)}\n`);
-		}).then(() => {
-			io.exit(0);
-		});
+		const report = (name, error) => {
+			internals.stderr.write(`dsh: quit ${name} failed: ${error instanceof Error ? error.message : String(error)}\n`);
+		};
+		runQuitSequence([
+			...currentSession === void 0 || currentActive === void 0 ? [] : [{
+				name: "flush",
+				run: async () => {
+					await sessions.flush(currentSession);
+				}
+			}, {
+				name: "dispose",
+				run: () => currentActive.handle.dispose()
+			}],
+			{
+				name: "composing",
+				run: () => composing ?? Promise.resolve()
+			},
+			{
+				name: "history",
+				run: () => historyWriteChain
+			}
+		], io.exit, report);
 	};
 	/** Run one slash line through the command registry (closed namespace). */
 	const runSlash = (line) => {
 		const currentAgent = agent;
 		if (currentAgent === void 0) return;
-		if (line.startsWith("/mode ")) {
-			switchModeAction(line.slice(6).trim());
-			return;
-		}
 		if (line.startsWith("/resume ")) {
 			requestResume(line.slice(8).trim());
 			return;
@@ -30758,7 +32738,14 @@ async function run(ctx, startup, io) {
 			return;
 		}
 		const controller = new AbortController();
+		const atEpoch = epoch;
+		pendingControllers.add(controller);
+		const finish = () => {
+			pendingControllers.delete(controller);
+		};
 		Promise.resolve().then(() => registry.execute(currentAgent, line, controller.signal)).then((execution) => {
+			finish();
+			if (epoch !== atEpoch || agent !== currentAgent) return;
 			if (execution === void 0) try {
 				currentAgent.followup(createUserMessage({
 					content: [{
@@ -30771,6 +32758,8 @@ async function run(ctx, startup, io) {
 				bridge.notify(`command fallback failed: ${error instanceof Error ? error.message : String(error)}`, "error");
 			}
 		}, (error) => {
+			finish();
+			if (epoch !== atEpoch || agent !== currentAgent) return;
 			bridge.notify(`command failed: ${error instanceof Error ? error.message : String(error)}`, "error");
 		});
 	};
@@ -30789,7 +32778,9 @@ async function run(ctx, startup, io) {
 			bridge.notify(`invalid session reference: ${error instanceof Error ? error.message : String(error)}`, "error");
 			return;
 		}
+		const atEpoch = epoch;
 		const deliver = (readable, context) => {
+			if (epoch !== atEpoch || agent !== currentAgent) return;
 			try {
 				if (context !== void 0) currentAgent.inject(context);
 				const message = createUserMessage({
@@ -30810,49 +32801,78 @@ async function run(ctx, startup, io) {
 			return;
 		}
 		const controller = new AbortController();
+		pendingControllers.add(controller);
 		currentMentions.prepare(parsed, controller.signal).then((prepared) => {
+			pendingControllers.delete(controller);
 			deliver(prepared.text, prepared.additionalContext);
 		}, (error) => {
-			if (controller.signal.aborted) return;
+			pendingControllers.delete(controller);
+			if (controller.signal.aborted || epoch !== atEpoch) return;
 			bridge.notify(`session reference failed: ${error instanceof Error ? error.message : String(error)}`, "error");
 		});
 	};
 	const pendingInputs = [];
-	let creating;
+	let creating = false;
 	const ensureSession = (mode) => {
-		if (creating !== void 0) return;
-		creating = (async () => {
-			const next = await prepare({
-				sessionId: `session-${randomUUID()}`,
-				resume: false,
-				...mode === void 0 ? {} : { mode }
-			});
-			if (quitting) {
-				next.handle.dispose().catch(() => {});
-				return;
+		if (creating) return;
+		creating = true;
+		compose(async () => {
+			try {
+				await pendingModeWork;
+				if (session !== void 0) {
+					const queued = pendingInputs.splice(0);
+					for (const item of queued) deliverLine(item.text, item.mode);
+					return;
+				}
+				const next = await prepare({
+					sessionId: `session-${randomUUID()}`,
+					resume: false,
+					...mode === void 0 ? {} : { mode }
+				});
+				if (quitting) {
+					next.handle.dispose().catch(() => {});
+					return;
+				}
+				active = next;
+				agent = next.agent;
+				session = next.session;
+				store = next.store;
+				mentions = next.mentions;
+				pendingMode = void 0;
+				pendingPermission = void 0;
+				commands.setAgent(agent);
+				skills.setAgent(agent);
+				process.stdout.write("\x1B[r\x1B[0m\x1B[H\x1B[2J\x1B[3J\x1B[H");
+				renderCurrent();
+				abortPendingControllers();
+				epoch += 1;
+				const queued = pendingInputs.splice(0);
+				for (const item of queued) deliverLine(item.text, item.mode);
+			} finally {
+				creating = false;
 			}
-			active = next;
-			agent = next.agent;
-			session = next.session;
-			store = next.store;
-			mentions = next.mentions;
-			commands.setAgent(agent);
-			skills.setAgent(agent);
-			process.stdout.write("\x1B[r\x1B[0m\x1B[H\x1B[2J\x1B[3J\x1B[H");
-			renderCurrent();
-			const queued = pendingInputs.splice(0);
-			for (const item of queued) deliverLine(item.text, item.mode);
-		})().catch((error) => {
+		}).catch((error) => {
 			pendingInputs.length = 0;
 			bridge.notify(`session creation failed: ${error instanceof Error ? error.message : String(error)}`, "error");
-		}).finally(() => {
-			creating = void 0;
 		});
 	};
 	/** Deliver one readable line to the agent, expanding session mentions first. */
 	const send = (text, mode) => {
 		const line = text.trim();
 		if (line === "") return;
+		if (line.startsWith("/mode ")) {
+			switchModeAction(line.slice(6).trim()).then((selected) => bridge.notify(`mode → ${selected}`), (error) => bridge.notify(`mode switch failed: ${error instanceof Error ? error.message : String(error)}`, "error"));
+			return;
+		}
+		if (line.startsWith("/permission ")) {
+			try {
+				const selected = setPermissionAction(line.slice(12).trim());
+				bridge.notify(`permission → ${selected}`);
+			} catch (error) {
+				bridge.notify(`permission change failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+			}
+			return;
+		}
 		if (session === void 0) {
 			pendingInputs.push({
 				text: line,
@@ -30887,23 +32907,33 @@ async function run(ctx, startup, io) {
 			return false;
 		}
 	};
+	/** Select one permission preset before the first session or on the active one. */
+	const setPermissionAction = (id) => {
+		if (permissionPresets === void 0 || permissionPresets.names.length === 0) throw new Error("permission presets are not mounted in this composition");
+		if (id === "") throw new Error("usage: /permission <preset>");
+		const selected = selectPermission(permissionPresets, session, id);
+		if (session === void 0) {
+			pendingPermission = selected;
+			renderCurrent();
+		}
+		return selected;
+	};
 	/**
-	* Cycle to the next permission preset (Shift+Tab, the Claude-Code
-	* permission-mode convention mapped onto dsh presets). A session in a
-	* custom knob state wraps to the first declared preset.
+	* Cycle to the next permission preset (Shift+Tab). Before the first session,
+	* the choice remains process-local and is materialized when Harness creates
+	* that session; afterwards the canonical service writes durable events.
 	*/
-	const cyclePermission = () => {
-		if (session === void 0) throw new Error("no session yet — submit a message to start");
-		const service = ctx.get("permissionPresets");
-		if (service === void 0 || service.names.length === 0) {
+	const cyclePermission$1 = () => {
+		if (permissionPresets === void 0 || permissionPresets.names.length === 0) {
 			bridge.notify("permission presets are not mounted in this composition", "warning");
 			return "";
 		}
-		const at = service.names.indexOf(service.current(session.events));
-		const next = service.names[(at + 1) % service.names.length] ?? "";
-		if (next === "") return "";
 		try {
-			service.set(session, next);
+			const next = cyclePermission(permissionPresets, session, pendingPermission);
+			if (session === void 0 && next !== "") {
+				pendingPermission = next;
+				renderCurrent();
+			}
 			return next;
 		} catch (error) {
 			bridge.notify(`permission change failed: ${error instanceof Error ? error.message : String(error)}`, "error");
@@ -30934,7 +32964,7 @@ async function run(ctx, startup, io) {
 		}
 		const wanted = argument.trim();
 		const sessionCwd = session.header.cwd ?? cwd;
-		const defaultName = `dsh-session-${session.id.slice(-8)}.md`;
+		const defaultName = `dsh-session-${exportSessionIdSuffix(session.id)}.md`;
 		const target = wanted === "" ? join(sessionCwd, defaultName) : /^[a-zA-Z]:[\\/]/u.test(wanted) || wanted.startsWith("/") ? wanted : join(sessionCwd, wanted);
 		const markdown = buildExportMarkdown(store.getView(), session.id);
 		try {
@@ -30977,56 +33007,78 @@ async function run(ctx, startup, io) {
 	const switchModeAction = async (id) => {
 		if (id === "") throw new Error("usage: /mode <preset>");
 		const currentAgent = agent;
-		const currentActive = active;
-		if (currentAgent === void 0 || currentActive === void 0) throw new Error("no session yet — submit a message to start");
-		const preset = await switchPreset(presets, currentAgent, id);
-		currentActive.mode = preset.id;
+		if (currentAgent === void 0) {
+			const choice = pendingModeWork.then(async () => {
+				const preset = await selectPreset(presets, void 0, id);
+				if (agent === void 0) {
+					pendingMode = preset.id;
+					renderCurrent();
+				}
+				return preset.id;
+			});
+			pendingModeWork = choice.then(() => {}, () => {});
+			return choice;
+		}
+		const preset = await selectPreset(presets, currentAgent, id);
+		if (active === void 0) throw new Error("active Agent has no session state");
+		active.mode = preset.id;
 		commands.setAgent(currentAgent);
 		skills.setAgent(currentAgent);
 		renderCurrent();
 		return preset.id;
 	};
-	const activate = async (nextTarget) => {
-		const previous = active;
-		const next = await prepare(nextTarget);
-		active = next;
-		agent = next.agent;
-		session = next.session;
-		store = next.store;
-		mentions = next.mentions;
-		commands.setAgent(agent);
-		skills.setAgent(agent);
-		try {
-			process.stdout.write("\x1B[r\x1B[0m\x1B[H\x1B[2J\x1B[3J\x1B[H");
-			renderCurrent();
-		} catch (error) {
-			active = previous;
-			agent = previous?.agent;
-			session = previous?.session;
-			store = previous === void 0 ? createTranscriptStore() : previous.store;
-			mentions = previous === void 0 ? createMentions(ctx, void 0, cwd) : previous.mentions;
-			if (agent !== void 0) commands.setAgent(agent);
-			if (agent !== void 0) skills.setAgent(agent);
-			await next.handle.dispose();
-			renderCurrent();
-			throw error;
-		}
-		if (previous === void 0) {
-			bridge.notify(`${next.resumed ? "resumed" : "created"} ${next.session.id.slice(-12)} · mode ${next.mode}`);
-			return;
-		}
-		let cleanupWarning;
-		try {
-			await sessions.flush(previous.session);
-		} catch (error) {
-			cleanupWarning = `previous session flush failed: ${error instanceof Error ? error.message : String(error)}`;
-		}
-		try {
-			await previous.handle.dispose();
-		} catch (error) {
-			cleanupWarning = `${cleanupWarning === void 0 ? "" : `${cleanupWarning}; `}previous agent release failed: ${error instanceof Error ? error.message : String(error)}`;
-		}
-		bridge.notify(cleanupWarning === void 0 ? `${next.resumed ? "resumed" : "created"} ${next.session.id.slice(-12)} · mode ${next.mode}` : `switched to ${next.session.id.slice(-12)}, but ${cleanupWarning}`, cleanupWarning === void 0 ? "info" : "warning");
+	const activate = (nextTarget) => {
+		if (quitting) return Promise.resolve();
+		return compose(async () => {
+			const previous = active;
+			const next = await prepare(nextTarget);
+			if (quitting) {
+				await next.handle.dispose().catch(() => {});
+				return;
+			}
+			active = next;
+			agent = next.agent;
+			session = next.session;
+			store = next.store;
+			mentions = next.mentions;
+			pendingMode = void 0;
+			pendingPermission = void 0;
+			commands.setAgent(agent);
+			skills.setAgent(agent);
+			try {
+				process.stdout.write("\x1B[r\x1B[0m\x1B[H\x1B[2J\x1B[3J\x1B[H");
+				renderCurrent();
+			} catch (error) {
+				active = previous;
+				agent = previous?.agent;
+				session = previous?.session;
+				store = previous === void 0 ? createTranscriptStore() : previous.store;
+				mentions = previous === void 0 ? createMentions(ctx, void 0, cwd) : previous.mentions;
+				if (agent !== void 0) commands.setAgent(agent);
+				if (agent !== void 0) skills.setAgent(agent);
+				await next.handle.dispose();
+				if (!quitting) renderCurrent();
+				throw error;
+			}
+			abortPendingControllers();
+			epoch += 1;
+			if (previous === void 0) {
+				bridge.notify(`${next.resumed ? "resumed" : "created"} ${next.session.id.slice(-12)} · mode ${next.mode}`);
+				return;
+			}
+			let cleanupWarning;
+			try {
+				await sessions.flush(previous.session);
+			} catch (error) {
+				cleanupWarning = `previous session flush failed: ${error instanceof Error ? error.message : String(error)}`;
+			}
+			try {
+				await previous.handle.dispose();
+			} catch (error) {
+				cleanupWarning = `${cleanupWarning === void 0 ? "" : `${cleanupWarning}; `}previous agent release failed: ${error instanceof Error ? error.message : String(error)}`;
+			}
+			bridge.notify(cleanupWarning === void 0 ? `${next.resumed ? "resumed" : "created"} ${next.session.id.slice(-12)} · mode ${next.mode}` : `switched to ${next.session.id.slice(-12)}, but ${cleanupWarning}`, cleanupWarning === void 0 ? "info" : "warning");
+		});
 	};
 	const switchQueue = new SessionSwitchQueue(async (request) => {
 		if (!quitting) await activate(request.target);
@@ -31052,9 +33104,10 @@ async function run(ctx, startup, io) {
 		const matches = exact.length > 0 ? exact : records.filter((record) => record.header.id.startsWith(wanted));
 		if (matches.length === 0) throw new Error(`no session matches "${wanted}"`);
 		if (matches.length > 1) throw new Error(`session prefix "${wanted}" is ambiguous (${matches.length} matches)`);
-		if (matches[0].header.parentSession !== void 0 || matches[0].header.origin === "subagent") throw new Error("subagent conversations are read-only in /resume; resume a root session");
-		if (session !== void 0 && agents.get(SessionId(matches[0].header.id)) !== void 0 && matches[0].header.id !== session.id) throw new Error("that session is already live in another owner");
-		return matches[0].header.id;
+		const matched = matches[0];
+		if (isSubagentSession(matched.header)) throw new Error("subagent conversations are read-only; resume a root session");
+		if (session !== void 0 && agents.get(SessionId(matched.header.id)) !== void 0 && matched.header.id !== session.id) throw new Error("that session is already live in another owner");
+		return matched.header.id;
 	};
 	const requestResume = (wanted) => {
 		resolveResumeId(wanted).then((id) => {
@@ -31102,8 +33155,10 @@ async function run(ctx, startup, io) {
 	};
 	const appElement = () => {
 		const sessionCwd = session?.header.cwd ?? cwd;
-		const model = store.getView().model !== "" ? store.getView().model : pendingSelection !== void 0 ? `${pendingSelection.provider}/${pendingSelection.model}` : `${defaults.provider}/${defaults.model}`;
+		const currentView = store.getView();
+		const model = currentView.model !== "" ? currentView.model : pendingSelection !== void 0 ? `${pendingSelection.provider}/${pendingSelection.model}` : `${defaults.provider}/${defaults.model}`;
 		const effort = resolveEffectiveSelection(active?.selection.picked ?? pendingSelection, session?.requestHeader()?.config, defaults).reasoningEffort;
+		const permission = permissionPresets === void 0 ? currentView.permission : effectivePermission(permissionPresets, session, pendingPermission);
 		return (0, import_react.createElement)(App, {
 			key: session?.id ?? "pending",
 			store,
@@ -31118,19 +33173,27 @@ async function run(ctx, startup, io) {
 			branch: gitBranch(sessionCwd),
 			sessionId: session === void 0 ? "" : session.id.slice(-8),
 			resumed: active?.resumed ?? false,
-			mode: active?.mode ?? "",
+			mode: active?.mode ?? pendingMode ?? presets.defaultId,
+			permission,
 			dispatch,
 			steer,
 			interrupt,
 			quit,
 			loadModels: () => loadModelDirectory(ctx),
+			loadModelProviders: () => loadProviderSettings(ctx),
+			subscribeModelProviders: (listener) => subscribeProviderSettings(ctx, listener),
+			saveModelProviderCredential: (target, key) => saveProviderCredential(ctx, target, key),
+			unsetModelProviderCredential: (target) => unsetProviderCredential(ctx, target),
+			removeModelProvider: (target) => removeProviderSettings(ctx, target),
 			loadMentions: (query, signal) => mentions.candidates(query, signal),
-			cyclePermission,
+			cyclePermission: cyclePermission$1,
+			setPermission: setPermissionAction,
 			selectModel,
 			exportTranscript,
 			renameTitle,
 			loadPresets: () => presets.list(),
 			switchMode: switchModeAction,
+			loadPermissions: () => permissionPresets === void 0 ? Promise.reject(/* @__PURE__ */ new Error("permission presets are not mounted in this composition")) : Promise.resolve(listPermissionRows(permissionPresets)),
 			createSession,
 			loadSessions,
 			loadSessionTranscript,
@@ -31194,4 +33257,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, apply, inject, name };
+export { Config, apply, exportSessionIdSuffix, inject, name, resolveTarget, runQuitSequence };