@xmoon76/dsh-pi-tui 0.1.1 → 0.1.2

package/dist/index.mjs

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 import { randomUUID } from "node:crypto";
 import { execSync, spawn } from "node:child_process";
 import * as fs from "node:fs";
-import { readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { closeSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import * as os from "node:os";
 import { homedir, tmpdir } from "node:os";
 import * as path from "node:path";
@@ -21,7 +21,7 @@ import { foldSessionTitle } from "@deepseek-ai/dsh-session-title";
 import { Chalk } from "chalk";
 import { Marked, Tokenizer } from "marked";
 import { spawn as spawn$1 } from "child_process";
-import { readdirSync as readdirSync$1, statSync } from "fs";
+import { readdirSync as readdirSync$1, statSync as statSync$1 } from "fs";
 import { homedir as homedir$1 } from "os";
 import { basename, dirname as dirname$1, join as join$1 } from "path";
 import { eastAsianWidth } from "get-east-asian-width";
@@ -81,7 +81,8 @@ const TUI_TOOL_TITLES = {
 	workflow: "Workflow",
 	"workflow-member": "Workflow Agent",
 	error: "Error",
-	interrupted: "Interrupted"
+	interrupted: "Interrupted",
+	ask_user_question: "Question"
 };
 /** Summary key preference per variant (args-derived). */
 const SUMMARY_KEYS = {
@@ -106,12 +107,6 @@ function firstLine(text) {
 	const newline = text.indexOf("\n");
 	return newline === -1 ? text : text.slice(0, newline);
 }
-/** The last line of a text (the Web's running-reasoning summary). */
-function latestLine(text) {
-	const visible = text.trimEnd();
-	const newline = visible.lastIndexOf("\n");
-	return newline === -1 ? visible : visible.slice(newline + 1);
-}
 /**
 * Strip the workspace root from a workspace-rooted absolute path (display
 * only), exactly like the Web's relativizeToCwd: only the workspace-root
@@ -162,7 +157,8 @@ const TOOL_EMOJIS = {
 	workflow: "🧵",
 	"workflow-member": "🤖",
 	error: "❌",
-	interrupted: "⏹️"
+	interrupted: "⏹️",
+	ask_user_question: "❓"
 };
 /** Emoji per row variant, applied to every registered tool of that class. */
 const VARIANT_EMOJIS = {
@@ -187,6 +183,61 @@ function toolEmoji(name) {
 	return VARIANT_EMOJIS[classifyTool(name)];
 }
 /**
+* Parse the read tool's model-facing envelopes from a result: one
+* `<path>…</path> <type>…</type> <content>…numbered lines…</content>` block
+* per file read. A merged group card (groupConsecutiveReads) carries several
+* consecutive envelopes, hence the plural form; the single-envelope helper
+* below is the common-case convenience.
+* @param result - the tool result text.
+* @returns every parsed envelope; empty when the result is not a read envelope.
+*/
+function parseReadEnvelopes(result) {
+	const out = [];
+	const block = /<path>([\s\S]*?)<\/path>\s*<type>[^<]*<\/type>\s*<content>([\s\S]*?)<\/content>/g;
+	let match;
+	while ((match = block.exec(result)) !== null) {
+		const path = match[1] ?? "";
+		const body = match[2] ?? "";
+		const lines = [];
+		let totalLines;
+		for (const raw of body.split("\n")) {
+			const numbered = /^(\d+): (.*)$/.exec(raw);
+			if (numbered !== null) {
+				lines.push({
+					number: Number(numbered[1]),
+					text: numbered[2] ?? ""
+				});
+				continue;
+			}
+			const end = /^\(End of file - total (\d+) lines\)$/.exec(raw);
+			if (end !== null) {
+				totalLines = Number(end[1]);
+				continue;
+			}
+			const showing = /^\(Showing lines \d+-\d+ of (\d+) lines/.exec(raw);
+			if (showing !== null) totalLines = Number(showing[1]);
+		}
+		out.push({
+			path,
+			lines,
+			...totalLines === void 0 ? {} : { totalLines }
+		});
+	}
+	return out;
+}
+/**
+* The folded preview suffix for a read card: `— {N} lines` when the envelope
+* reports a total (or a line count), empty otherwise. A merged group card
+* (multiple envelopes) yields nothing — its head already carries "N files".
+*/
+function readFoldedPreview(result) {
+	const envelopes = parseReadEnvelopes(result);
+	if (envelopes.length !== 1) return "";
+	const envelope = envelopes[0];
+	const total = envelope.totalLines ?? (envelope.lines.length > 0 ? envelope.lines.length : void 0);
+	return total === void 0 ? "" : ` — ${total} lines`;
+}
+/**
 * The Web row-model header for one tool card: title = tool-owned title or the
 * variant design title; summary = SUMMARY_KEYS-derived args summary relativized
 * to the workspace root. Unknown variants carry the tool name alongside the
@@ -480,7 +531,7 @@ var TranscriptFolder = class {
 	commandNames = /* @__PURE__ */ new Map();
 	/** Workflow run cards by runId, for member/run settlement. */
 	workflowRuns = /* @__PURE__ */ new Map();
-	/** Workflow member cards by `${runId}/${seq}`, for agent-end settlement. */
+	/** Workflow member rows by `${runId}/${seq}`, for agent-end settlement. */
 	workflowMembers = /* @__PURE__ */ new Map();
 	/** The turn most recently opened by turn/start. */
 	currentTurn = 0;
@@ -681,7 +732,8 @@ var TranscriptFolder = class {
 					name: "workflow",
 					args: event.data.name,
 					result: "",
-					status: "running"
+					status: "running",
+					members: []
 				};
 				this.workflowRuns.set(event.data.runId, card);
 				this.items.push(card);
@@ -689,25 +741,20 @@ var TranscriptFolder = class {
 			}
 			case "tool-workflow/agent-start": {
 				const { runId, seq, label, phase } = event.data;
-				const card = {
-					kind: "tool",
-					turn: this.currentTurn,
-					name: "workflow-member",
-					args: label,
-					result: phase ?? "",
+				const run = this.workflowRuns.get(runId);
+				const member = {
+					label,
+					...phase === void 0 ? {} : { phase },
 					status: "running"
 				};
-				this.workflowMembers.set(`${runId}/${seq}`, card);
-				this.items.push(card);
+				this.workflowMembers.set(`${runId}/${seq}`, member);
+				run?.members?.push(member);
 				break;
 			}
 			case "tool-workflow/agent-end": {
-				const card = this.workflowMembers.get(`${event.data.runId}/${event.data.seq}`);
+				const member = this.workflowMembers.get(`${event.data.runId}/${event.data.seq}`);
 				const outcome = event.data.outcome;
-				if (card !== void 0) {
-					card.status = outcome === "completed" ? "ok" : "error";
-					card.result = outcome === "completed" ? "completed" : `outcome: ${outcome}`;
-				}
+				if (member !== void 0) member.status = outcome === "completed" ? "ok" : "error";
 				break;
 			}
 			case "tool-workflow/run-end": {
@@ -814,7 +861,8 @@ const EMPTY = {
 	cacheHitPct: 0,
 	inputTokens: 0,
 	outputTokens: 0,
-	cacheReadTokens: 0
+	cacheReadTokens: 0,
+	cacheWriteTokens: 0
 };
 /** Key identifying one step's model output (turn + step). */
 function stepKey(turn, step) {
@@ -827,10 +875,9 @@ function stepKey(turn, step) {
 */
 function computeStats(events) {
 	const stats = { ...EMPTY };
-	const stepStart = /* @__PURE__ */ new Map();
-	const firstDelta = /* @__PURE__ */ new Map();
-	const lastDelta = /* @__PURE__ */ new Map();
+	const perStep = /* @__PURE__ */ new Map();
 	const outputMs = [];
+	let decodeTokens = 0;
 	let firstTokenTotal = 0;
 	let firstTokenCount = 0;
 	for (const event of events) switch (event.type) {
@@ -839,50 +886,76 @@ function computeStats(events) {
 			break;
 		case "step/start":
 			stats.steps += 1;
-			stepStart.set(stepKey(event.data.turn, event.data.step), event.time);
+			perStep.set(stepKey(event.data.turn, event.data.step), { start: event.time });
 			break;
 		case "step/end": {
-			const key = stepKey(event.data.turn, event.data.step);
-			const start = stepStart.get(key);
-			if (start !== void 0) stats.llmMs += event.time - start;
-			const first = firstDelta.get(key);
-			const last = lastDelta.get(key);
-			if (first !== void 0 && last !== void 0) outputMs.push(last - first);
+			const timing = perStep.get(stepKey(event.data.turn, event.data.step));
+			if (timing === void 0) break;
+			settleStep(stats, timing, event.time, outputMs, (ms) => {
+				decodeTokens += ms;
+			});
+			perStep.delete(stepKey(event.data.turn, event.data.step));
 			break;
 		}
 		case "assistant/chunk": {
 			const { chunk } = event.data;
 			if (chunk.type === "text-delta") {
-				const key = stepKey(event.data.turn, event.data.step);
-				if (!firstDelta.has(key)) {
-					firstDelta.set(key, event.time);
-					const start = stepStart.get(key);
+				const timing = perStep.get(stepKey(event.data.turn, event.data.step));
+				if (timing !== void 0 && timing.firstDelta === void 0) {
+					timing.firstDelta = event.time;
+					const start = timing.start;
 					if (start !== void 0) {
 						firstTokenTotal += event.time - start;
 						firstTokenCount += 1;
 					}
 				}
-				lastDelta.set(key, event.time);
-			} else if (chunk.type === "usage") addUsage(stats, chunk.usage);
+			} else if (chunk.type === "usage") {
+				const key = stepKey(event.data.turn, event.data.step);
+				const timing = perStep.get(key);
+				if (timing !== void 0) {
+					if (timing.usage === void 0) timing.usage = chunk.usage;
+				} else addUsage(stats, chunk.usage);
+			}
 			break;
 		}
-		case "assistant/message":
-			if (event.data.usage !== void 0) addUsage(stats, event.data.usage);
+		case "assistant/message": {
+			const timing = perStep.get(stepKey(event.data.turn, event.data.step));
+			if (timing !== void 0) {
+				timing.completed = event.time;
+				if (event.data.usage !== void 0) timing.usage = event.data.usage;
+			} else if (event.data.usage !== void 0) addUsage(stats, event.data.usage);
 			break;
+		}
 		case "request/context": if (event.data.contextWindow !== void 0) stats.contextWindow = event.data.contextWindow;
 	}
 	if (firstTokenCount > 0) stats.firstTokenMsAvg = firstTokenTotal / firstTokenCount;
 	const streamMs = outputMs.reduce((sum, ms) => sum + ms, 0);
-	if (streamMs > 0) stats.tokensPerSec = Math.round(stats.outputTokens * 1e3 / streamMs);
-	const totalInput = stats.inputTokens + stats.cacheReadTokens;
-	if (totalInput > 0) stats.cacheHitPct = stats.cacheReadTokens * 100 / totalInput;
+	if (streamMs > 0) stats.tokensPerSec = Math.round(decodeTokens * 1e3 / streamMs);
+	const billedInput = stats.inputTokens + stats.cacheReadTokens + stats.cacheWriteTokens;
+	if (billedInput > 0) stats.cacheHitPct = stats.cacheReadTokens * 100 / billedInput;
 	return stats;
 }
-/** Token totals from one usage record (cache reads counted separately). */
+/** Settle one step at its end boundary: wall time, decode window, usage. */
+function settleStep(stats, timing, endTime, outputMs, addDecodeTokens) {
+	const completed = timing.completed ?? endTime;
+	const start = timing.start;
+	if (start !== void 0) stats.llmMs += Math.max(0, completed - start);
+	const usage = timing.usage;
+	if (usage !== void 0) {
+		addUsage(stats, usage);
+		const first = timing.firstDelta;
+		if (first !== void 0) {
+			outputMs.push(Math.max(0, completed - first));
+			addDecodeTokens(usage.outputTokens);
+		}
+	}
+}
+/** Token totals from one usage record (cache fields counted separately). */
 function addUsage(stats, usage) {
 	stats.inputTokens += usage.inputTokens;
 	stats.outputTokens += usage.outputTokens;
 	stats.cacheReadTokens += usage.cacheReadTokens ?? 0;
+	stats.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
 }
 /**
 * Incremental stats folding: apply appended events and read `snapshot()`
@@ -892,10 +965,9 @@ function addUsage(stats, usage) {
 */
 var StatsFolder = class {
 	stats = { ...EMPTY };
-	stepStart = /* @__PURE__ */ new Map();
-	firstDelta = /* @__PURE__ */ new Map();
-	lastDelta = /* @__PURE__ */ new Map();
+	perStep = /* @__PURE__ */ new Map();
 	outputMs = [];
+	decodeTokens = 0;
 	firstTokenTotal = 0;
 	firstTokenCount = 0;
 	/**
@@ -910,9 +982,9 @@ var StatsFolder = class {
 		const derived = { ...this.stats };
 		if (this.firstTokenCount > 0) derived.firstTokenMsAvg = this.firstTokenTotal / this.firstTokenCount;
 		const streamMs = this.outputMs.reduce((sum, ms) => sum + ms, 0);
-		if (streamMs > 0) derived.tokensPerSec = Math.round(derived.outputTokens * 1e3 / streamMs);
-		const totalInput = derived.inputTokens + derived.cacheReadTokens;
-		if (totalInput > 0) derived.cacheHitPct = derived.cacheReadTokens * 100 / totalInput;
+		if (streamMs > 0) derived.tokensPerSec = Math.round(this.decodeTokens * 1e3 / streamMs);
+		const billedInput = derived.inputTokens + derived.cacheReadTokens + derived.cacheWriteTokens;
+		if (billedInput > 0) derived.cacheHitPct = derived.cacheReadTokens * 100 / billedInput;
 		return derived;
 	}
 	applyEvent(event) {
@@ -922,36 +994,49 @@ var StatsFolder = class {
 				break;
 			case "step/start":
 				this.stats.steps += 1;
-				this.stepStart.set(stepKey(event.data.turn, event.data.step), event.time);
+				this.perStep.set(stepKey(event.data.turn, event.data.step), { start: event.time });
 				break;
 			case "step/end": {
 				const key = stepKey(event.data.turn, event.data.step);
-				const start = this.stepStart.get(key);
-				if (start !== void 0) this.stats.llmMs += event.time - start;
-				const first = this.firstDelta.get(key);
-				const last = this.lastDelta.get(key);
-				if (first !== void 0 && last !== void 0) this.outputMs.push(last - first);
+				const timing = this.perStep.get(key);
+				if (timing === void 0) break;
+				settleStep(this.stats, timing, event.time, this.outputMs, (tokens) => {
+					this.decodeTokens += tokens;
+				});
+				this.perStep.delete(key);
 				break;
 			}
 			case "assistant/chunk": {
 				const { chunk } = event.data;
 				if (chunk.type === "text-delta") {
 					const key = stepKey(event.data.turn, event.data.step);
-					if (!this.firstDelta.has(key)) {
-						this.firstDelta.set(key, event.time);
-						const start = this.stepStart.get(key);
+					const timing = this.perStep.get(key);
+					if (timing !== void 0 && timing.firstDelta === void 0) {
+						timing.firstDelta = event.time;
+						const start = timing.start;
 						if (start !== void 0) {
 							this.firstTokenTotal += event.time - start;
 							this.firstTokenCount += 1;
 						}
 					}
-					this.lastDelta.set(key, event.time);
-				} else if (chunk.type === "usage") addUsage(this.stats, chunk.usage);
+				} else if (chunk.type === "usage") {
+					const key = stepKey(event.data.turn, event.data.step);
+					const timing = this.perStep.get(key);
+					if (timing !== void 0) {
+						if (timing.usage === void 0) timing.usage = chunk.usage;
+					} else addUsage(this.stats, chunk.usage);
+				}
 				break;
 			}
-			case "assistant/message":
-				if (event.data.usage !== void 0) addUsage(this.stats, event.data.usage);
+			case "assistant/message": {
+				const key = stepKey(event.data.turn, event.data.step);
+				const timing = this.perStep.get(key);
+				if (timing !== void 0) {
+					timing.completed = event.time;
+					if (event.data.usage !== void 0) timing.usage = event.data.usage;
+				} else if (event.data.usage !== void 0) addUsage(this.stats, event.data.usage);
 				break;
+			}
 			case "request/context": if (event.data.contextWindow !== void 0) this.stats.contextWindow = event.data.contextWindow;
 		}
 	}
@@ -987,7 +1072,8 @@ function formatStats(stats) {
 		`↑${formatTokens(stats.inputTokens)}`,
 		`↓${formatTokens(stats.outputTokens)}`,
 		stats.cacheReadTokens > 0 ? `R${formatTokens(stats.cacheReadTokens)}` : "",
-		stats.cacheReadTokens > 0 ? `CH${stats.cacheHitPct.toFixed(1)}%` : ""
+		stats.cacheWriteTokens > 0 ? `W${formatTokens(stats.cacheWriteTokens)}` : "",
+		stats.cacheReadTokens > 0 || stats.cacheWriteTokens > 0 ? `CH${stats.cacheHitPct.toFixed(1)}%` : ""
 	].filter((part) => part !== "");
 	const ownParts = [
 		`LLM ${formatSeconds(stats.llmMs)}`,
@@ -1099,7 +1185,11 @@ const color = {
 	warning: (text) => hex("warning")(text),
 	error: (text) => hex("error")(text),
 	roleUser: (text) => hex("roleUser")(text),
-	shellMode: (text) => hex("shellMode")(text)
+	shellMode: (text) => hex("shellMode")(text),
+	/** Plain italics (kimi thinking parity). */
+	italic: (text) => chalk.italic(text),
+	/** Dim + italic for reasoning: intermediate thinking never reads like output. */
+	textDimItalic: (text) => chalk.italic.hex(currentPalette.textDim)(text)
 };
 /** SelectList palette from the semantic tokens. */
 const selectListTheme = {
@@ -1551,7 +1641,7 @@ var CombinedAutocompleteProvider = class {
 		if (displayBase.startsWith("~/") || displayBase.startsWith("/")) {
 			const baseDir = displayBase.startsWith("~/") ? this.expandHomePath(displayBase) : displayBase;
 			try {
-				if (!statSync(baseDir).isDirectory()) return null;
+				if (!statSync$1(baseDir).isDirectory()) return null;
 			} catch {
 				return null;
 			}
@@ -1602,7 +1692,7 @@ var CombinedAutocompleteProvider = class {
 				let isDirectory = entry.isDirectory();
 				if (!isDirectory && entry.isSymbolicLink()) try {
 					const fullPath = join$1(searchDir, entry.name);
-					isDirectory = statSync(fullPath).isDirectory();
+					isDirectory = statSync$1(fullPath).isDirectory();
 				} catch {}
 				let relativePath;
 				const name = entry.name;
@@ -1685,7 +1775,7 @@ var CombinedAutocompleteProvider = class {
 				const baseDir = join$1(root, scoped.displayBase);
 				let isDir = false;
 				try {
-					isDir = statSync(baseDir).isDirectory();
+					isDir = statSync$1(baseDir).isDirectory();
 				} catch {
 					isDir = false;
 				}
@@ -8338,6 +8428,73 @@ var StrictStrikethroughTokenizer = class extends Tokenizer {
 		};
 	}
 };
+const FULLWIDTH_LEFT_PAREN = 65288;
+const FULLWIDTH_RIGHT_PAREN = 65289;
+const CJK_URL_TERMINATOR_REGEX = /[\u3000-\u303f\uff01-\uff07\uff0a-\uff0f\uff1a-\uff20\uff3b-\uff40\uff5b-\uff65\u2013\u2014\u2018\u2019\u201c\u201d\u2026]/;
+/**
+* Index at which to cut an autolink match, or -1 to keep it whole. Non-paren
+* CJK punctuation terminates the URL outside of full-width parens; full-width
+* parens only terminate it when unbalanced. Punctuation inside a balanced
+* parenthetical (e.g. the ，in （北京，1949年）) stays part of the URL —
+* prose parentheticals contain spaces and never survive marked's match this
+* far, so a balanced group is almost always deliberate URL content.
+*/
+function findCjkUrlBoundary(match) {
+	let parenDepth = 0;
+	let unmatchedOpen = -1;
+	for (let i = 0; i < match.length; i++) {
+		const code = match.charCodeAt(i);
+		if (code === FULLWIDTH_LEFT_PAREN) {
+			parenDepth++;
+			if (unmatchedOpen === -1) unmatchedOpen = i;
+		} else if (code === FULLWIDTH_RIGHT_PAREN) {
+			if (parenDepth === 0) return i;
+			parenDepth--;
+			if (parenDepth === 0) unmatchedOpen = -1;
+		} else if (parenDepth === 0 && CJK_URL_TERMINATOR_REGEX.test(match[i])) return i;
+	}
+	return parenDepth > 0 ? unmatchedOpen : -1;
+}
+var CjkBoundaryUrlTokenizer = class extends StrictStrikethroughTokenizer {
+	url(src) {
+		const cap = this.rules.inline.url.exec(src);
+		if (!cap) return;
+		if (cap[2] === "@") {
+			const text = cap[0];
+			return {
+				type: "link",
+				raw: text,
+				text,
+				href: `mailto:${text}`,
+				tokens: [{
+					type: "text",
+					raw: text,
+					text
+				}]
+			};
+		}
+		const boundary = findCjkUrlBoundary(cap[0]);
+		if (boundary !== -1) cap[0] = cap[0].slice(0, boundary);
+		if (!cap[0]) return;
+		let previous;
+		do {
+			previous = cap[0];
+			cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? "";
+		} while (previous !== cap[0]);
+		const text = cap[0];
+		return {
+			type: "link",
+			raw: text,
+			text,
+			href: cap[1] === "www." ? `http://${text}` : text,
+			tokens: [{
+				type: "text",
+				raw: text,
+				text
+			}]
+		};
+	}
+};
 function isEscaped(source, index) {
 	let backslashes = 0;
 	for (let position = index - 1; position >= 0 && source[position] === "\\"; position--) backslashes++;
@@ -8453,7 +8610,7 @@ function trimPartialClosingFences(tokens) {
 	token.text = token.text.slice(0, -lastLine.length).replace(/\n$/, "");
 }
 const markdownParser = new Marked();
-markdownParser.setOptions({ tokenizer: new StrictStrikethroughTokenizer() });
+markdownParser.setOptions({ tokenizer: new CjkBoundaryUrlTokenizer() });
 markdownParser.use({ extensions: [...LATEX_MARKDOWN_EXTENSIONS] });
 var Markdown = class {
 	text;
@@ -11837,22 +11994,204 @@ function renderDiffLines(text) {
 	return text.split("\n").map(renderDiffLine);
 }
 /**
+* Above this combined input size the O(n·m) LCS table is skipped and the
+* diff degrades to a naive all-delete/all-add listing (still correct, just
+* without alignment).
+*/
+const DIFF_LCS_MAX_LINES = 2e3;
+/**
+* Compute a line-level diff by DP longest-common-subsequence (kimi
+* `computeDiffLines` parity): context rows for identical lines, add/delete
+* rows for the differing runs, each carrying its source-side line number.
+* @param oldText - the before side.
+* @param newText - the after side.
+* @param oldStart - first line number of the old side (default 1).
+* @param newStart - first line number of the new side (default 1).
+* @returns the diff rows in document order.
+*/
+function computeDiffLines(oldText, newText, oldStart = 1, newStart = 1) {
+	const oldLines = oldText.split("\n");
+	const newLines = newText.split("\n");
+	const m = oldLines.length;
+	const n = newLines.length;
+	if (m + n > DIFF_LCS_MAX_LINES) {
+		const out = [];
+		for (let i = 0; i < m; i++) out.push({
+			kind: "delete",
+			lineNum: oldStart + i,
+			code: oldLines[i]
+		});
+		for (let j = 0; j < n; j++) out.push({
+			kind: "add",
+			lineNum: newStart + j,
+			code: newLines[j]
+		});
+		return out;
+	}
+	const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) dp[i][j] = oldLines[i - 1] === newLines[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+	const reversed = [];
+	let i = m;
+	let j = n;
+	while (i > 0 || j > 0) if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+		reversed.push({
+			kind: "context",
+			lineNum: newStart + j - 1,
+			code: newLines[j - 1]
+		});
+		i--;
+		j--;
+	} else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+		reversed.push({
+			kind: "add",
+			lineNum: newStart + j - 1,
+			code: newLines[j - 1]
+		});
+		j--;
+	} else {
+		reversed.push({
+			kind: "delete",
+			lineNum: oldStart + i - 1,
+			code: oldLines[i - 1]
+		});
+		i--;
+	}
+	return reversed.reverse();
+}
+/**
+* Group change rows into clusters with `contextLines` of context on each
+* side, merging clusters whose unchanged gap is ≤ 2·contextLines.
+* @returns the clusters plus add/delete/change counts over all diff rows.
+*/
+function buildDiffClusters(diffLines, contextLines) {
+	const changeIndices = [];
+	let added = 0;
+	let removed = 0;
+	for (const [i, line] of diffLines.entries()) if (line.kind === "add") {
+		added++;
+		changeIndices.push(i);
+	} else if (line.kind === "delete") {
+		removed++;
+		changeIndices.push(i);
+	}
+	if (changeIndices.length === 0) return {
+		clusters: [],
+		changedCount: 0,
+		addedCount: added,
+		removedCount: removed
+	};
+	const clusters = [];
+	const mergeGap = 2 * contextLines;
+	let groupStart = changeIndices[0];
+	let groupEnd = changeIndices[0];
+	for (let k = 1; k < changeIndices.length; k++) {
+		const idx = changeIndices[k];
+		if (idx - groupEnd <= mergeGap) groupEnd = idx;
+		else {
+			clusters.push({
+				start: Math.max(0, groupStart - contextLines),
+				end: Math.min(diffLines.length - 1, groupEnd + contextLines)
+			});
+			groupStart = idx;
+			groupEnd = idx;
+		}
+	}
+	clusters.push({
+		start: Math.max(0, groupStart - contextLines),
+		end: Math.min(diffLines.length - 1, groupEnd + contextLines)
+	});
+	return {
+		clusters,
+		changedCount: changeIndices.length,
+		addedCount: added,
+		removedCount: removed
+	};
+}
+/** One diff body row: dim line-number gutter plus the colored/plain code. */
+function formatDiffRow(line) {
+	const gutter = color.textDim(`${String(line.lineNum).padStart(4)} `);
+	if (line.kind === "add") return gutter + color.success(`+ ${line.code}`);
+	if (line.kind === "delete") return gutter + color.error(`- ${line.code}`);
+	return gutter + `  ${line.code}`;
+}
+/**
 * Render a result-side diff view (a `card: 'diff'` presentResult intent) as
-* colored lines: one dimmed File: header per hunk, prior lines as `-` (red),
-* new lines as `+` (green). Hunks whose oldText is null (creates) show only
-* the new lines. Paths relativize against the workspace root when given.
+* colored lines: one `+N -M path` header per hunk (kimi parity; counts in
+* add/remove colors, path workspace-relative), then the LCS-aligned body
+* with context clustering — unchanged runs between clusters elide to a
+* `… N unchanged lines …` separator, and `maxLines` caps the body at a
+* cluster boundary with a `… N more changes hidden (hint)` footer. A hunk
+* with `oldText: null` (create) shows only new lines; an empty newText
+* (pure deletion) shows only old lines.
 * @param diffs - the diff view's hunks.
 * @param cwd - workspace root for path relativization; optional.
+* @param options - context/cap/hint tuning.
 * @returns the colored render lines.
 */
-function renderDiffView(diffs, cwd) {
-	const lines = [];
+function renderDiffView(diffs, cwd, options = {}) {
+	const contextLines = options.contextLines ?? 3;
+	const cap = options.maxLines !== void 0 && options.maxLines >= 0 ? options.maxLines : Number.POSITIVE_INFINITY;
+	const out = [];
 	for (const hunk of diffs) {
-		lines.push(color.textDim("File: " + relativizeToCwd(hunk.path, cwd)));
-		if (hunk.oldText !== null) for (const line of hunk.oldText.split("\n")) lines.push(renderDiffLine("-" + line));
-		for (const line of hunk.newText.split("\n")) lines.push(renderDiffLine("+" + line));
+		const oldSide = hunk.oldText === null || hunk.oldText === "" ? [] : hunk.oldText.split("\n");
+		const newSide = hunk.newText === "" ? [] : hunk.newText.split("\n");
+		const diffLines = oldSide.length === 0 ? newSide.map((code, index) => ({
+			kind: "add",
+			lineNum: index + 1,
+			code
+		})) : newSide.length === 0 ? oldSide.map((code, index) => ({
+			kind: "delete",
+			lineNum: index + 1,
+			code
+		})) : computeDiffLines(hunk.oldText, hunk.newText);
+		const { clusters, changedCount, addedCount, removedCount } = buildDiffClusters(diffLines, contextLines);
+		let header = "";
+		if (addedCount > 0) header += color.success(`+${addedCount} `);
+		if (removedCount > 0) header += color.error(`-${removedCount} `);
+		header += relativizeToCwd(hunk.path, cwd);
+		out.push(header);
+		if (clusters.length === 0) continue;
+		let body = 0;
+		let prevEnd = -1;
+		let truncated = false;
+		let shownChanges = 0;
+		outer: for (const cluster of clusters) {
+			if (body >= cap) {
+				truncated = true;
+				break;
+			}
+			if (prevEnd >= 0) {
+				const gap = cluster.start - prevEnd - 1;
+				if (gap > 0) {
+					if (body + 1 > cap) {
+						truncated = true;
+						break;
+					}
+					out.push(color.textMuted(`     … ${gap} unchanged line${gap > 1 ? "s" : ""} …`));
+					body++;
+				}
+			}
+			for (let i = cluster.start; i <= cluster.end; i++) {
+				if (body >= cap) {
+					truncated = true;
+					break outer;
+				}
+				const line = diffLines[i];
+				out.push(formatDiffRow(line));
+				body++;
+				if (line.kind !== "context") shownChanges++;
+				prevEnd = i;
+			}
+		}
+		if (truncated) {
+			const hidden = changedCount - shownChanges;
+			if (hidden > 0) {
+				const hint = options.expandHint ?? "click to expand";
+				out.push(color.textMuted(`     … ${hidden} more change${hidden > 1 ? "s" : ""} hidden (${hint})`));
+			}
+		}
 	}
-	return lines;
+	return out;
 }
 //#endregion
 //#region src/search.ts
@@ -11906,6 +12245,378 @@ var TranscriptSearchComponent = class {
 	}
 };
 //#endregion
+//#region src/question.ts
+/**
+* The user-questions dialog flow (ask_user_question v2): a focusable overlay
+* component that walks one question at a time, collects drafts per question,
+* and submits the whole batch at the end — the Web QuestionComposer
+* semantics (per-question paging, batch submit, skip) with pi/kimi keyboard
+* ergonomics (↑↓ highlight, digits, real Input for free text, review page).
+*
+* Pure component: the app layer owns the promise/abort plumbing and routes
+* input here while the flow is active.
+* @module @xmoon76/dsh-pi-tui/question
+*/
+/** The "type your own answer" row shown below options (pi isOther parity). */
+const OTHER_ROW = "\0other";
+/** The current question's tab label: `Q{n}` or Submit. */
+function tabLabel(index, total) {
+	return index === total ? "Submit" : `Q${index + 1}`;
+}
+/** Split a conventional recommendation suffix off the DISPLAY label (the
+* answer value keeps the full label — Web parseRecommendedLabel parity). */
+function parseRecommended(label) {
+	const suffix = /\s*(?:\((?:recommended|推荐)\)|（(?:recommended|推荐)）)\s*$/i;
+	return suffix.test(label) ? {
+		label: label.replace(suffix, ""),
+		recommended: true
+	} : {
+		label,
+		recommended: false
+	};
+}
+/**
+* The interactive question flow. Renders one question at a time with a tab
+* strip (answered marks), a navigable option list (↑↓/digits/Enter), a real
+* Input for free text, and a final review page (Submit/Cancel). Esc cancels
+* the whole flow; the app layer resolves the batch on done().
+*/
+var QuestionFlow = class {
+	questions;
+	onDone;
+	onCancel;
+	drafts;
+	/** Current question index; `questions.length` is the review page. */
+	tab = 0;
+	/** Highlighted option index within the current question. */
+	cursor = 0;
+	/** Free-text editing mode (the "Type something." row or an optionless question). */
+	editingOther = false;
+	otherInput = new Input();
+	/** Review-page action highlight (0 = Submit, 1 = Cancel). */
+	submitIdx = 0;
+	focused = false;
+	constructor(questions, onDone, onCancel) {
+		this.questions = questions;
+		this.onDone = onDone;
+		this.onCancel = onCancel;
+		this.drafts = questions.map(() => ({
+			selected: /* @__PURE__ */ new Set(),
+			custom: "",
+			skipped: false
+		}));
+		this.otherInput.onSubmit = (value) => this.commitOther(value);
+		this.otherInput.onEscape = () => this.exitOther();
+		this.syncEditMode();
+	}
+	/** The rows of the current question (options plus the free-text row). */
+	rows() {
+		const question = this.questions[this.tab];
+		if (question === void 0) return [];
+		const rows = (question.options ?? []).map((option, index) => {
+			const { label, recommended } = parseRecommended(option.label);
+			const approve = question.intent?.approve;
+			return {
+				key: String(index),
+				label,
+				recommended: recommended || approve !== void 0 && option.label === approve,
+				...option.description === void 0 ? {} : { description: option.description }
+			};
+		});
+		if ((question.options?.length ?? 0) > 0) rows.push({
+			key: OTHER_ROW,
+			label: "Type something.",
+			recommended: false
+		});
+		return rows;
+	}
+	/** The current question's draft. */
+	draft() {
+		return this.drafts[this.tab];
+	}
+	/** Whether the current question has an answer (selected, custom, or skipped). */
+	answered() {
+		const draft = this.draft();
+		if (draft === void 0) return false;
+		return draft.selected.size > 0 || draft.custom !== "" || draft.skipped;
+	}
+	/** The free-text row of the current question (present when options exist). */
+	otherRowIndex() {
+		return this.rows().findIndex((row) => row.key === OTHER_ROW);
+	}
+	/** Enter on the highlighted row, or in text mode: commit and advance. */
+	confirm() {
+		const draft = this.draft();
+		if (draft === void 0) return;
+		const row = this.rows()[this.cursor];
+		if (row !== void 0 && row.key !== OTHER_ROW) {
+			const option = this.questions[this.tab]?.options?.[Number(row.key)];
+			if (option !== void 0) {
+				const label = option.label;
+				if (this.questions[this.tab]?.multiSelect === true) {
+					if (draft.selected.has(label)) draft.selected.delete(label);
+					else draft.selected.add(label);
+					draft.skipped = false;
+					return;
+				}
+				draft.selected.clear();
+				draft.selected.add(label);
+				draft.skipped = false;
+				this.advance();
+			}
+			return;
+		}
+		if (row?.key === OTHER_ROW) this.enterOther();
+	}
+	/** Move to the next question (or the review page on the last one). */
+	advance() {
+		this.tab += 1;
+		this.cursor = 0;
+		this.submitIdx = 0;
+		this.syncEditMode();
+	}
+	/** Optionless questions edit text directly; options start in list mode. */
+	syncEditMode() {
+		const question = this.questions[this.tab];
+		const optionless = question !== void 0 && (question.options?.length ?? 0) === 0;
+		this.editingOther = optionless;
+		if (optionless) {
+			const draft = this.draft();
+			this.otherInput.setValue(draft?.custom ?? "");
+		} else {
+			const recommended = this.rows().findIndex((row) => row.recommended);
+			this.cursor = recommended >= 0 ? recommended : 0;
+		}
+		this.otherInput.focused = this.focused && this.editingOther;
+	}
+	/** Skip the current question (empty answer) and move on. */
+	skip() {
+		const draft = this.draft();
+		if (draft === void 0) return;
+		draft.selected.clear();
+		draft.custom = "";
+		draft.skipped = true;
+		this.advance();
+	}
+	/** Enter the free-text editing mode for the current question. */
+	enterOther() {
+		this.editingOther = true;
+		const draft = this.draft();
+		this.otherInput.setValue(draft?.custom ?? "");
+		this.otherInput.focused = this.focused;
+	}
+	/** Leave text mode back to the option list. */
+	exitOther() {
+		this.editingOther = false;
+		this.otherInput.focused = false;
+	}
+	/** Commit the typed text into the draft and advance. */
+	commitOther(value) {
+		const draft = this.draft();
+		if (draft === void 0) return;
+		const text = value.trim();
+		draft.custom = text;
+		if (text === "") draft.skipped = true;
+		else {
+			if (this.questions[this.tab]?.multiSelect !== true) draft.selected.clear();
+			draft.skipped = false;
+		}
+		this.exitOther();
+		this.advance();
+	}
+	/** Submit the whole batch from the review page. */
+	submit() {
+		const answers = this.questions.map((question, index) => {
+			const draft = this.drafts[index];
+			if (draft.skipped) return {
+				id: question.id,
+				selected: []
+			};
+			const custom = draft.custom.trim();
+			if (custom !== "" && question.multiSelect !== true) return {
+				id: question.id,
+				selected: [],
+				custom
+			};
+			return {
+				id: question.id,
+				selected: [...draft.selected],
+				...custom === "" ? {} : { custom }
+			};
+		});
+		this.onDone(answers);
+	}
+	handleInput(data) {
+		if (data === "\0") return;
+		if (this.editingOther) {
+			if (data === "\r" || data === "\n") this.commitOther(this.otherInput.getValue());
+			else if (data === "\x1B") this.exitOther();
+			else if (data === "\x1B[D") {
+				if (this.tab > 0) {
+					this.tab -= 1;
+					this.cursor = 0;
+					this.submitIdx = 0;
+					this.syncEditMode();
+				}
+			} else if (data === "\x1B[C") {
+				if (this.tab < this.questions.length - 1) {
+					this.tab += 1;
+					this.cursor = 0;
+					this.submitIdx = 0;
+					this.syncEditMode();
+				} else {
+					this.tab = this.questions.length;
+					this.submitIdx = 0;
+					this.syncEditMode();
+				}
+			} else this.otherInput.handleInput(data);
+			return;
+		}
+		const rows = this.rows();
+		if (this.tab >= this.questions.length) {
+			if (data === "\r" || data === "\n") {
+				if (this.submitIdx === 0) this.submit();
+				else this.onCancel();
+			} else if (data === "\x1B") this.onCancel();
+			else if (data === "\x1B[D" || data === "h") this.submitIdx = 0;
+			else if (data === "\x1B[C" || data === "l") this.submitIdx = 1;
+			else if (data === "b") {
+				this.tab = Math.max(0, this.questions.length - 1);
+				this.cursor = 0;
+				this.submitIdx = 0;
+				this.syncEditMode();
+			}
+			return;
+		}
+		const digit = /^[1-9]$/.exec(data);
+		if (digit !== null) {
+			const row = rows[Number(digit[0]) - 1];
+			if (row !== void 0) {
+				this.cursor = rows.indexOf(row);
+				this.confirm();
+			}
+			return;
+		}
+		if (data === "\x1B[A" || data === "k") {
+			if (rows.length > 0) this.cursor = (this.cursor - 1 + rows.length) % rows.length;
+			return;
+		}
+		if (data === "\x1B[B" || data === "j") {
+			if (rows.length > 0) this.cursor = (this.cursor + 1) % rows.length;
+			return;
+		}
+		if (data === "\r" || data === "\n") {
+			this.confirm();
+			return;
+		}
+		if (data === "\x1B[D" || data === "h") {
+			if (this.tab > 0) {
+				this.tab -= 1;
+				this.cursor = 0;
+				this.submitIdx = 0;
+				this.syncEditMode();
+			}
+			return;
+		}
+		if (data === "\x1B[C" || data === "l") {
+			if (this.tab < this.questions.length - 1) {
+				this.tab += 1;
+				this.cursor = 0;
+				this.submitIdx = 0;
+			} else {
+				this.tab = this.questions.length;
+				this.cursor = 0;
+				this.submitIdx = 0;
+				this.syncEditMode();
+			}
+			return;
+		}
+		if (data === "s") {
+			this.skip();
+			return;
+		}
+		if (data === "\x1B") this.onCancel();
+	}
+	invalidate() {
+		this.otherInput.invalidate();
+	}
+	render(width) {
+		const safeWidth = Math.max(1, width);
+		const lines = [];
+		const tabs = this.questions.map((_, index) => {
+			const draft = this.drafts[index];
+			const answered = draft !== void 0 && (draft.selected.size > 0 || draft.custom !== "" || draft.skipped);
+			const label = tabLabel(index, this.questions.length);
+			const mark = answered ? color.success("✓") : color.textDim("○");
+			return this.tab === index ? color.textStrong(` ${mark} ${label} `) : color.textDim(` ${mark} ${label} `);
+		});
+		const submitAnswered = this.drafts.every((draft) => draft.selected.size > 0 || draft.custom !== "" || draft.skipped);
+		const submitTab = this.tab === this.questions.length;
+		tabs.push(submitTab ? color.textStrong(` ${submitAnswered ? color.success("✓") : color.textDim("○")} Submit `) : color.textDim(` ${submitAnswered ? color.success("✓") : color.textDim("○")} Submit `));
+		lines.push(tabs.join(""));
+		if (this.tab >= this.questions.length) {
+			lines.push("");
+			lines.push(color.textStrong("Review your answer before submit"));
+			this.questions.forEach((question, index) => {
+				const draft = this.drafts[index];
+				if (draft === void 0) return;
+				const value = draft.skipped ? "(skipped)" : draft.custom !== "" && question.multiSelect !== true ? draft.custom : [...draft.selected].join(", ") + (draft.custom !== "" ? ` + ${draft.custom}` : "");
+				lines.push(`${color.textDim(`Q${index + 1}`)} ${question.question}`);
+				lines.push(`  ${value === "" ? color.textDim("(no answer)") : value}`);
+			});
+			lines.push("");
+			const submit = this.submitIdx === 0 ? color.textStrong("Submit") : color.textDim("Submit");
+			const cancel = this.submitIdx === 1 ? color.textStrong("Cancel") : color.textDim("Cancel");
+			lines.push(`${submit}   ${cancel}`);
+			lines.push(color.textDim("← → choose · b back · enter confirm · esc cancel"));
+			return lines;
+		}
+		const question = this.questions[this.tab];
+		const draft = this.draft();
+		if (question === void 0 || draft === void 0) return lines;
+		if (question.header !== void 0 && question.header !== "") lines.push(color.textDim(question.header));
+		lines.push(color.textStrong(question.question));
+		if (question.detail !== void 0 && question.detail !== "") for (const line of question.detail.split("\n")) lines.push(color.textDim(truncateToWidth(line, safeWidth, "…")));
+		const rows = this.rows();
+		const multi = question.multiSelect === true;
+		this.editingOther && rows.some((row) => row.key === OTHER_ROW);
+		if (rows.length > 0 && !(rows.length === 1 && rows[0]?.key === OTHER_ROW)) rows.forEach((row, index) => {
+			if (row.key === OTHER_ROW && this.editingOther) {
+				const prefix = color.primary("→");
+				const inputLine = this.otherInput.render(Math.max(1, safeWidth - visibleWidth(prefix) - 2))[0] ?? "";
+				const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
+				lines.push(`${prefix} ${color.textDim(`[${index + 1}]`)} ${stripped}`);
+				return;
+			}
+			const selected = row.key === OTHER_ROW ? draft.custom !== "" : draft.selected.has(question.options?.[Number(row.key)]?.label ?? "");
+			const marker = multi || row.key === OTHER_ROW ? selected ? color.success("[✓]") : color.textDim("[ ]") : selected ? color.success(`[${Number(row.key) + 1}]`) : color.textDim(`[${Number(row.key) + 1}]`);
+			const pointer = index === this.cursor ? color.primary("→") : " ";
+			const badge = row.recommended ? ` ${color.primary("[recommended]")}` : "";
+			const desc = row.description === void 0 ? "" : color.textDim(` — ${row.description}`);
+			const label = index === this.cursor ? color.textStrong(row.label) : row.label;
+			lines.push(`${pointer} ${marker} ${label}${badge}${desc}`);
+		});
+		else if (this.editingOther || (question.options?.length ?? 0) === 0) {
+			const inputLine = this.otherInput.render(Math.max(1, safeWidth - 2))[0] ?? "";
+			const stripped = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
+			lines.push(` ${stripped}`);
+			lines.push(color.textDim("type your answer, enter to confirm"));
+		}
+		if (draft.skipped) lines.push(color.textDim("(skipped)"));
+		lines.push("");
+		const hintParts = [
+			"↑↓ navigate",
+			"1-9 choose",
+			multi ? "enter toggle" : "enter confirm",
+			"←→ switch",
+			"s skip",
+			"esc cancel"
+		];
+		lines.push(color.textDim(hintParts.join(" · ")));
+		return lines;
+	}
+};
+//#endregion
 //#region src/working.ts
 /**
 * The animated busy indicator shown on the row directly above the editor
@@ -11960,7 +12671,7 @@ var WorkingIndicator = class extends Text {
 	}
 	updateDisplay() {
 		const frame = this.frames[this.currentFrame] ?? "";
-		const indicator = frame === "" ? "" : frame + " ";
+		const indicator = frame === "" ? "" : frame + "  ";
 		this.setText(indicator + color.textDim(this.message));
 		this.ui.requestRender();
 	}
@@ -11996,12 +12707,13 @@ var Frame = class {
 	render(width) {
 		const inner = Math.max(1, Math.floor(width) - 4);
 		const lines = this.child.render(inner).map((line) => truncateToWidth(line, inner, "…"));
-		const frameWidth = Math.min(inner, Math.max(1, ...lines.map((line) => visibleWidth(line)))) + 4;
+		const contentWidth = Math.min(inner, Math.max(1, ...lines.map((line) => visibleWidth(line))));
+		const frameWidth = contentWidth + 4;
 		const b = color.border;
 		const out = [b(`╭${"─".repeat(frameWidth - 2)}╮`)];
 		for (const line of lines) {
 			const vis = visibleWidth(line);
-			const pad = Math.max(0, inner - vis);
+			const pad = Math.max(0, contentWidth - vis);
 			out.push(`${b("│")} ${line}${" ".repeat(pad)} ${b("│")}`);
 		}
 		out.push(b(`╰${"─".repeat(frameWidth - 2)}╯`));
@@ -12013,11 +12725,22 @@ var Frame = class {
 * border below it (a fixed-width rule looked misaligned next to the frame). */
 var WelcomeCard = class {
 	facts;
+	idle = false;
 	lastWidth = -1;
 	cached = [];
 	/** Replace the facts; the next render rebuilds the card. */
 	setFacts(facts) {
 		this.facts = facts;
+		this.idle = false;
+		this.cached = [];
+	}
+	/**
+	* The pre-session state (deferred session creation): the card invites the
+	* first message instead of naming a session that does not exist yet.
+	*/
+	setIdle(idle) {
+		if (this.idle === idle) return;
+		this.idle = idle;
 		this.cached = [];
 	}
 	invalidate() {
@@ -12025,29 +12748,47 @@ var WelcomeCard = class {
 	}
 	render(width) {
 		const facts = this.facts;
+		const b = color.border;
+		const inner = Math.max(1, width - 4);
+		const renderRow = (line) => wrapTextWithAnsi(line, inner).map((wrapped) => {
+			const vis = visibleWidth(wrapped);
+			return `${b("│")} ${wrapped}${" ".repeat(Math.max(0, inner - vis))} ${b("│")}`;
+		});
+		if (this.idle) {
+			if (this.lastWidth === width && this.cached.length > 0) return this.cached;
+			this.lastWidth = width;
+			this.cached = [
+				b(`╭${"─".repeat(Math.max(0, width - 2))}╮`),
+				...renderRow(color.textMuted("🐋  dsh-pi-tui — type a message to start a session")),
+				b(`╰${"─".repeat(Math.max(0, width - 2))}╯`)
+			];
+			return this.cached;
+		}
 		if (facts === void 0) return [];
 		if (this.lastWidth === width && this.cached.length > 0) return this.cached;
 		this.lastWidth = width;
-		const line1 = `🐋 session ${color.textDim(facts.sessionId)}`;
-		const line2 = [color.text(facts.model), facts.preset === void 0 ? "" : `preset ${color.textMuted(facts.preset)}`].filter((part) => part !== "").join(" · ");
-		const line3 = [color.textMuted(facts.cwd), `v${facts.version}`].filter((part) => part !== "").join(" · ");
-		const inner = Math.max(1, width - 4);
-		const b = color.border;
+		const line1 = `🐋  session ${color.textMuted(facts.sessionId)}`;
+		const line2 = [color.textMuted(facts.model), facts.preset === void 0 ? "" : `preset ${color.textMuted(facts.preset)}`].filter((part) => part !== "").join(" · ");
+		const line3 = [color.textMuted(facts.cwd), color.textMuted(`v${facts.version}`)].filter((part) => part !== "").join(" · ");
 		this.cached = [
 			b(`╭${"─".repeat(Math.max(0, width - 2))}╮`),
 			...[
 				line1,
 				line2,
 				line3
-			].flatMap((line) => wrapTextWithAnsi(line, inner).map((wrapped) => {
-				const vis = visibleWidth(wrapped);
-				return `${b("│")} ${wrapped}${" ".repeat(Math.max(0, inner - vis))} ${b("│")}`;
-			})),
+			].flatMap(renderRow),
 			b(`╰${"─".repeat(Math.max(0, width - 2))}╯`)
 		];
 		return this.cached;
 	}
 };
+/** One blank row between consecutive transcript blocks (kimi/pi Spacer(1) parity). */
+var Spacer = class {
+	invalidate() {}
+	render() {
+		return [""];
+	}
+};
 /** Pi-style context progress bar: `[███░░░░░░░░░] 25%`. */
 function contextBar(used, window) {
 	const ratio = Math.min(1, Math.max(0, used / window));
@@ -12094,6 +12835,22 @@ var TuiApp = class TuiApp {
 	todoPanelVisible = false;
 	/** The todo panel Text; empty when hidden. */
 	todoPanel;
+	/**
+	* The persistent dock strip directly above the todo panel: one line each
+	* for the current permission, the live goal, the todo summary, and running
+	* background tasks (kimi chrome parity). Empty lines drop out entirely.
+	*/
+	dock;
+	/** Active background tasks for the dock line (label + status). */
+	dockTasks = [];
+	/**
+	* The queued-input pane below the todo panel (kimi QueuePane parity):
+	* a border rule plus one `❯ text` row per pending message and a dim hint.
+	* Renders nothing while the queue is empty.
+	*/
+	queuePane;
+	/** The pending inbox messages (next-turn followups and next-step steers). */
+	queueItems = [];
 	/** Whether the Ctrl+O expansion master switch is on. */
 	isToolOutputExpanded() {
 		return this.toolOutputExpanded;
@@ -12111,6 +12868,9 @@ var TuiApp = class TuiApp {
 	searchComponent;
 	/** Overlay handles currently mounted on the active screen, for mode switches. */
 	overlayHandles = /* @__PURE__ */ new Set();
+	/** Capturing overlays hidden beneath a newer one (modal stacking), keyed by
+	* the newer overlay's handle; restored when it hides. */
+	overlayDependents = /* @__PURE__ */ new Map();
 	/** Footer state. */
 	status = {
 		model: "",
@@ -12121,7 +12881,7 @@ var TuiApp = class TuiApp {
 		statsLine: ""
 	};
 	/** Header text (todo summary), kept for theme-swap repaints. */
-	headerText = "🐋 dsh-pi-tui";
+	headerText = "🐋  dsh-pi-tui";
 	/** Footer text, kept for theme-swap repaints. */
 	footerText = "";
 	/** Plan-mode badge state; appended to the header and footer when active. */
@@ -12135,6 +12895,9 @@ var TuiApp = class TuiApp {
 	/** Transient error line shown under the transcript; cleared by the next
 	* repaint or after {@link TuiApp.NOTIFY_DURATION_MS}, whichever comes first. */
 	notifyText = "";
+	/** Styling of the current notify line: info (default) is dim with a ℹ,
+	* errors are red with a ✗. */
+	notifyKind = "info";
 	/** The pending auto-clear for {@link notifyText}, while one is armed. */
 	notifyTimer;
 	/** How long a notify line stays before it auto-clears, in ms. */
@@ -12175,21 +12938,48 @@ var TuiApp = class TuiApp {
 		this.editorBorder = this.editor.borderColor;
 		this.editor.onSubmit = (text) => {
 			this.rememberInput(text);
+			this.clearNotify();
 			this.events.onSubmit(text);
 		};
-		this.header = new Text("🐋 dsh-pi-tui", 0, 0);
+		this.header = new Text("🐋  dsh-pi-tui", 0, 0);
 		this.messagesView = new Container();
+		this.dock = new Text("", 0, 0);
 		this.todoPanel = new Text("", 0, 0);
+		this.queuePane = new Text("", 0, 0);
 		this.working = new WorkingIndicator(this.tui, options.workingIntervalMs === void 0 ? {} : { intervalMs: options.workingIntervalMs });
 		this.footer = new Text("", 0, 0);
 		this.tui.addChild(this.header);
 		this.tui.addChild(this.messagesView);
+		this.tui.addChild(this.dock);
 		this.tui.addChild(this.todoPanel);
+		this.tui.addChild(this.queuePane);
 		this.tui.addChild(this.working);
 		this.tui.addChild(this.editor);
 		this.tui.addChild(this.footer);
 		this.tui.setFocus(this.editor);
-		this.tui.addInputListener((data) => this.handleInput(data));
+		this.tui.addInputListener((data) => this.routeInput(data));
+	}
+	/**
+	* App-level input routing plus the autocomplete repaint. The editor's
+	* slash-command autocomplete resolves on a promise microtask AFTER the
+	* keystroke's own paint, and the editor's own render requests go to the
+	* MAIN screen — which is STOPPED while the alt screen renders (fullscreen),
+	* so its renderRequested flag is stuck true and every request is dropped:
+	* the fresh suggestion list would never paint (the visible frame always
+	* shows the previous query's results — typing /res keeps showing /reload
+	* first). Schedule a forced frame on the ACTIVE screen once the provider's
+	* continuation has applied the fresh list. Deliberately a dsh-side fix:
+	* the vendored fork stays pristine (see AGENTS.md decision 8).
+	* @param data - the raw input sequence.
+	*/
+	routeInput(data) {
+		const result = this.handleInput(data);
+		queueMicrotask(() => {
+			queueMicrotask(() => {
+				if (this.editor.isShowingAutocomplete()) this.requestRender(true);
+			});
+		});
+		return result;
 	}
 	/** Enter raw mode and start rendering. */
 	start() {
@@ -12231,6 +13021,16 @@ var TuiApp = class TuiApp {
 			this.startTranscriptSearch();
 			return { consume: true };
 		}
+		if (matchesKey(data, "shift+tab")) {
+			if (this.overlayHost.hasOverlayEntries) return void 0;
+			this.events.onCyclePermission?.();
+			return { consume: true };
+		}
+		if (matchesKey(data, "alt+up")) {
+			if (this.overlayHost.hasOverlayEntries) return void 0;
+			this.events.onDequeue?.();
+			return { consume: true };
+		}
 		if (matchesKey(data, "escape")) {
 			if (this.overlayHost.hasOverlayEntries) return void 0;
 			if (this.events.onSingleEscape?.() === true) return { consume: true };
@@ -12257,7 +13057,6 @@ var TuiApp = class TuiApp {
 		if (matchesKey(data, "ctrl+s")) {
 			if (this.overlayHost.hasOverlayEntries) return { consume: true };
 			const draft = this.editor.getText();
-			if (draft.trim() === "") return { consume: true };
 			this.editor.setText("");
 			this.events.onSteer?.(draft);
 			return { consume: true };
@@ -12283,6 +13082,11 @@ var TuiApp = class TuiApp {
 	/**
 	* Show an overlay on the active screen and track its handle, so a
 	* fullscreen toggle can hide every mounted overlay on the old screen.
+	* Capturing overlays stack modally: every other capturing overlay is
+	* hidden beneath the new one and restored when it hides — the fork's
+	* compositor interleaves stacked boxes line by line (two different-width
+	* dialogs would garble into one frame), and modal hiding is done here so
+	* the vendored fork stays pristine.
 	* @param component - the overlay content.
 	* @param options - overlay sizing/positioning.
 	* @returns the handle; hide() also forgets the handle.
@@ -12290,9 +13094,19 @@ var TuiApp = class TuiApp {
 	showOverlayOnHost(component, options) {
 		const handle = this.overlayHost.showOverlay(component, options);
 		this.overlayHandles.add(handle);
+		if (options?.nonCapturing !== true) {
+			const hidden = /* @__PURE__ */ new Set();
+			for (const other of this.overlayHandles) if (other !== handle && !other.isHidden()) {
+				other.setHidden(true);
+				hidden.add(other);
+			}
+			if (hidden.size > 0) this.overlayDependents.set(handle, hidden);
+		}
 		return {
 			...handle,
 			hide: () => {
+				this.overlayDependents.get(handle)?.forEach((other) => other.setHidden(false));
+				this.overlayDependents.delete(handle);
 				this.overlayHandles.delete(handle);
 				handle.hide();
 			}
@@ -12416,10 +13230,18 @@ var TuiApp = class TuiApp {
 					component: this.fullscreenScroll,
 					grow: 1
 				},
+				{
+					component: this.dock,
+					shrink: 0
+				},
 				{
 					component: this.todoPanel,
 					shrink: 0
 				},
+				{
+					component: this.queuePane,
+					shrink: 0
+				},
 				{
 					component: this.working,
 					shrink: 0
@@ -12434,7 +13256,7 @@ var TuiApp = class TuiApp {
 				}
 			]);
 			alt.setLayoutRoot(root);
-			alt.addInputListener((data) => this.handleInput(data));
+			alt.addInputListener((data) => this.routeInput(data));
 			this.tui.stop();
 			alt.start();
 			alt.setFocus(this.editor);
@@ -12496,7 +13318,6 @@ var TuiApp = class TuiApp {
 	*/
 	setTranscript(messages) {
 		this.messages = messages;
-		this.clearNotify();
 		this.rebuildMessages();
 	}
 	/** Rebuild the message component tree from the current transcript state. */
@@ -12506,24 +13327,21 @@ var TuiApp = class TuiApp {
 		const boundary = this.expandBoundary();
 		const width = this.terminal.columns;
 		const rows = [];
-		for (const message of this.messages) {
-			if (message.kind === "thinking" && this.hideThinking) continue;
-			const component = this.renderMessage(message, boundary);
-			this.messagesView.addChild(component);
-			rows.push({
-				message,
-				height: component.render(width).length
-			});
-		}
-		for (const message of this.localMessages) {
+		const blocks = [...this.messages.filter((message) => !(message.kind === "thinking" && this.hideThinking)), ...this.localMessages];
+		blocks.forEach((message, index) => {
 			const component = this.renderMessage(message, boundary);
 			this.messagesView.addChild(component);
+			const height = component.render(width).length + (index < blocks.length - 1 ? 1 : 0);
 			rows.push({
 				message,
-				height: component.render(width).length
+				height
 			});
+			if (index < blocks.length - 1) this.messagesView.addChild(new Spacer());
+		});
+		if (this.notifyText !== "") {
+			const line = this.notifyKind === "info" ? color.textDim(`ℹ ${this.notifyText}`) : color.error(`✗ ${this.notifyText}`);
+			this.messagesView.addChild(new Text(line, 0, 0));
 		}
-		if (this.notifyText !== "") this.messagesView.addChild(new Text(color.error(`✗ ${this.notifyText}`), 0, 0));
 		this.messageRows = rows;
 		this.renderTodoPanel();
 		this.requestRender();
@@ -12589,12 +13407,16 @@ var TuiApp = class TuiApp {
 		this.requestRender();
 	}
 	/**
-	* Show a transient error line under the transcript. Cleared by the next
+	* Show a transient line under the transcript. Cleared by the next
 	* `setTranscript` repaint or after {@link TuiApp.NOTIFY_DURATION_MS},
 	* whichever comes first, so a one-off notice never lingers forever.
+	* @param text - the notice text.
+	* @param kind - `'info'` renders dim with a ℹ (default, the common case);
+	* `'error'` renders red with a ✗ — pass it explicitly for failures.
 	*/
-	notify(text) {
+	notify(text, kind = "info") {
 		this.notifyText = text;
+		this.notifyKind = kind;
 		if (this.notifyTimer !== void 0) clearTimeout(this.notifyTimer);
 		this.notifyTimer = setTimeout(() => {
 			this.notifyTimer = void 0;
@@ -12603,13 +13425,25 @@ var TuiApp = class TuiApp {
 		}, this.notifyDurationMs);
 		this.rebuildMessages();
 	}
-	/** Clear the transient notify line and its pending auto-clear timer. */
+	/** Clear the transient notify line and its pending auto-clear timer.
+	* Called on fresh user input and session switches; repaints alone never
+	* clear it (an active session would flash every notice away). Rebuilds
+	* the transcript when a notice was actually showing. */
 	clearNotify() {
+		if (this.notifyText === "" && this.notifyTimer === void 0) return;
 		this.notifyText = "";
 		if (this.notifyTimer !== void 0) {
 			clearTimeout(this.notifyTimer);
 			this.notifyTimer = void 0;
 		}
+		this.rebuildMessages();
+	}
+	/**
+	* Replace the editor draft. The runner restores a submission that the
+	* divergence guard blocked, so the user's text survives for a retry.
+	*/
+	setEditorText(text) {
+		this.editor.setText(text);
 	}
 	/**
 	* Set the session head rendered above the transcript: the session identity,
@@ -12621,6 +13455,14 @@ var TuiApp = class TuiApp {
 		this.welcomeCard.setFacts(facts);
 		this.rebuildMessages();
 	}
+	/**
+	* Toggle the pre-session welcome state (deferred session creation): the
+	* card invites the first message; the first real facts replace it.
+	*/
+	setWelcomeIdle(idle) {
+		this.welcomeCard.setIdle(idle);
+		this.rebuildMessages();
+	}
 	/** The turn threshold at or above which collapsible entries expand. */
 	expandBoundary() {
 		if (!this.toolOutputExpanded || false) return Number.POSITIVE_INFINITY;
@@ -12632,29 +13474,49 @@ var TuiApp = class TuiApp {
 	}
 	/** Render one transcript message as a pi-tui component. */
 	renderMessage(message, boundary) {
-		if (message.kind === "user") return new Text(`${color.roleUser("❯")} ${message.text}`, 0, 0);
+		if (message.kind === "user") {
+			const prefix = `${color.roleUser("❯")} `;
+			const indent = " ".repeat(visibleWidth(prefix));
+			return new Text(new Text(message.text, 0, 0).render(Math.max(1, this.terminal.columns - visibleWidth(prefix))).map((line, index) => (index === 0 ? prefix : indent) + line).join("\n"), 0, 0);
+		}
 		if (message.kind === "assistant") {
-			const row = new Container();
-			row.addChild(new Text(`${color.primary("🐋")} `, 0, 0));
-			row.addChild(new Markdown(message.text, 0, 0, markdownTheme));
-			return row;
+			const prefix = `${color.primary("🐋")}  `;
+			const indent = " ".repeat(visibleWidth(prefix));
+			return new Text(new Markdown(message.text, 0, 0, markdownTheme).render(Math.max(1, this.terminal.columns - visibleWidth(prefix))).map((line, index) => (index === 0 ? prefix : indent) + line).join("\n"), 0, 0);
+		}
+		if (message.kind === "thinking") {
+			if (message.turn >= boundary || this.expandedOverride.get(message) === true) return new Text(color.textDimItalic(`🐳  ${message.text}`), 0, 0);
+			const lines = message.text.split("\n").filter((line) => line !== "");
+			const shown = message.running === true ? lines.slice(-2) : lines.slice(0, 2);
+			const prefix = "🐳  ";
+			const prefixWidth = visibleWidth(prefix);
+			const contentWidth = Math.max(1, this.terminal.columns - prefixWidth);
+			const rows = Array.from({ length: 2 }, (_, index) => {
+				const text = shown[index] ?? "";
+				const body = text === "" ? "" : truncateToWidth(text, contentWidth, "…");
+				const pad = index === 0 ? prefix : " ".repeat(prefixWidth);
+				return color.textDimItalic(pad + body);
+			});
+			const remaining = lines.length - 2;
+			const hint = remaining > 0 ? `... (${remaining} more lines, ctrl+o to expand)` : "(ctrl+o to expand)";
+			rows.push(color.textDim(`${" ".repeat(prefixWidth)}${truncateToWidth(hint, contentWidth, "…")}`));
+			return new Text(rows.join("\n"), 0, 0);
 		}
-		if (message.kind === "thinking") return new Text(message.turn >= boundary || this.expandedOverride.get(message) === true ? color.textDim(`🐳 ${message.text}`) : color.textDim(`🐳 ${message.running === true ? preview(latestLine(message.text), 1) : preview(firstLine(message.text), 1)} (ctrl+o to expand)`), 0, 0);
 		if (message.kind === "system") {
 			const expanded = message.turn >= boundary || this.expandedOverride.get(message) === true;
 			if (message.label !== void 0) {
 				const row = new Container();
 				const emoji = message.emoji ?? "📎";
 				if (expanded) {
-					row.addChild(new Text(color.textMuted(`${emoji} Context injection ${message.label}`), 0, 0));
+					row.addChild(new Text(color.textMuted(`${emoji}  Context injection ${message.label}`), 0, 0));
 					row.addChild(new Text(color.textDim(message.text), 0, 0));
 				} else {
 					const summary = message.summary === void 0 ? "" : ` — ${message.summary}`;
-					row.addChild(new Text(color.textMuted(`${emoji} Context injection ${message.label}${summary} (ctrl+o to expand)`), 0, 0));
+					row.addChild(new Text(truncateToWidth(color.textMuted(`${emoji}  Context injection ${message.label}${summary} (ctrl+o to expand)`), this.terminal.columns, "…"), 0, 0));
 				}
 				return row;
 			}
-			return new Text(expanded ? `${color.textMuted("§")} ${message.text}` : color.textMuted(`§ ${preview(message.text, 2)} (ctrl+o to expand)`), 0, 0);
+			return new Text(expanded ? `${color.textMuted("§")} ${color.textDim(message.text)}` : color.textMuted(`§ ${truncateToWidth(preview(message.text, 2), Math.max(1, this.terminal.columns - 22), "…")} (ctrl+o to expand)`), 0, 0);
 		}
 		if (message.kind === "summary") return new Text(color.textDim(message.text), 0, 0);
 		const card = new Container();
@@ -12662,13 +13524,13 @@ var TuiApp = class TuiApp {
 		const summary = header.summary === "" ? "" : ` ${header.summary}`;
 		const emoji = toolEmoji(message.name);
 		const pill = message.status === "ok" ? color.success("[ok]") : message.status === "error" ? color.error("[error]") : color.textDim("[running]");
-		const head = `${emoji} ${header.title}${summary} ${pill}`;
+		const head = `${color.textDim(`${emoji}  ${header.title}${summary}`)} ${pill}`;
 		if (message.turn >= boundary || this.expandedOverride.get(message) === true) {
 			card.addChild(new Text(head, 0, 0));
-			this.renderToolBody(card, message);
+			this.renderToolBody(card, message, this.expandedOverride.get(message) === true);
 		} else {
-			const resultPreview = message.result === "" ? "" : ` — ${preview(message.result, 3)}`;
-			card.addChild(new Text(`${head}${resultPreview}`, 0, 0));
+			const resultPreview = message.name === "read" ? readFoldedPreview(message.result) : message.result === "" ? "" : ` — ${preview(message.result, 3)}`;
+			card.addChild(new Text(truncateToWidth(`${head}${resultPreview}`, this.terminal.columns, "…"), 0, 0));
 		}
 		return card;
 	}
@@ -12677,18 +13539,47 @@ var TuiApp = class TuiApp {
 	* the body follows the tool's own render intent (presentResult): a read
 	* card shows numbered lines plus the relativized path and total line
 	* count, a search card groups matches by file and marks truncation, a
-	* terminal card shows the output and exit status, and a diff card colors
-	* the hunks. Without a view the raw result text renders, diff-colored
-	* when it looks like one.
+	* terminal card shows the output and exit status, and a diff card shows
+	* the LCS-aligned, clustered diff (capped in the default view, full when
+	* the card was explicitly expanded). Without a view the raw result text
+	* renders, diff-colored when it looks like one; a diff-card call whose
+	* result carried no view reuses the call-time diff so the block never
+	* collapses (kimi parity).
 	* @param card - the card container to fill.
 	* @param message - the tool message.
+	* @param explicitlyExpanded - whether the user expanded this card by hand.
 	*/
-	renderToolBody(card, message) {
+	renderToolBody(card, message, explicitlyExpanded) {
+		if (message.name === "workflow" && message.members !== void 0) {
+			const groups = /* @__PURE__ */ new Map();
+			for (const member of message.members) {
+				const key = member.phase ?? "";
+				const list = groups.get(key);
+				if (list === void 0) groups.set(key, [member]);
+				else list.push(member);
+			}
+			for (const [phase, members] of groups) {
+				if (phase !== "") card.addChild(new Text(color.textMuted(`  ${phase}`), 0, 0));
+				for (const member of members) {
+					const mark = member.status === "ok" ? color.success("•") : member.status === "error" ? color.error("✗") : color.primary("●");
+					const statusText = member.status === "ok" ? "completed" : member.status === "error" ? "failed" : "running";
+					card.addChild(new Text(`  ${mark} ${member.label} — ${color.textDim(statusText)}`, 0, 0));
+				}
+			}
+			return;
+		}
 		if (message.status === "running") {
 			const callView = this.present?.call(message.name, message.args);
-			if (callView !== void 0 && callView.card === "generic" && callView.rawInput !== void 0) {
-				const raw = typeof callView.rawInput === "string" ? callView.rawInput : JSON.stringify(callView.rawInput, null, 2);
-				card.addChild(new Text(color.textDim(raw), 0, 0));
+			if (callView !== void 0) {
+				if (callView.card === "diff" && callView.diffs.length > 0) {
+					this.renderDiffBody(card, callView.diffs, explicitlyExpanded);
+					return;
+				}
+				if (callView.card === "generic" && callView.rawInput !== void 0) {
+					const raw = typeof callView.rawInput === "string" ? callView.rawInput : JSON.stringify(callView.rawInput, null, 2);
+					card.addChild(new Text(color.textDim(raw), 0, 0));
+					return;
+				}
 			}
 			return;
 		}
@@ -12723,16 +13614,52 @@ var TuiApp = class TuiApp {
 				return;
 			}
 			case "diff":
-				for (const line of renderDiffView(resultView.diffs, this.workspaceRoot)) card.addChild(new Text(line, 0, 0));
+				this.renderDiffBody(card, resultView.diffs, explicitlyExpanded);
 				return;
 		}
-		if (isDiffResult(message.name, message.result)) for (const line of renderDiffLines(message.result)) card.addChild(new Text(line, 0, 0));
-		else card.addChild(new Text(color.textDim(message.result), 0, 0));
+		if (resultView === void 0) {
+			const callView = this.present?.call(message.name, message.args);
+			if (callView !== void 0 && callView.card === "diff" && callView.diffs.length > 0) {
+				this.renderDiffBody(card, callView.diffs, explicitlyExpanded);
+				return;
+			}
+		}
+		if (message.name === "read") {
+			const envelopes = parseReadEnvelopes(message.result);
+			if (envelopes.length > 0) {
+				if (envelopes.length === 1) {
+					const envelope = envelopes[0];
+					for (const line of envelope.lines) card.addChild(new Text(color.textDim(`  ${line.number} │ ${line.text}`), 0, 0));
+					if (envelope.path !== "") card.addChild(new Text(color.textMuted(`  path: ${relativizeToCwd(envelope.path, this.workspaceRoot)}`), 0, 0));
+					if (envelope.totalLines !== void 0) card.addChild(new Text(color.textMuted(`  total lines: ${envelope.totalLines}`), 0, 0));
+				} else envelopes.forEach((envelope, index) => {
+					const branch = index === envelopes.length - 1 ? "└─" : "├─";
+					const count = envelope.totalLines ?? (envelope.lines.length > 0 ? envelope.lines.length : void 0);
+					card.addChild(new Text(color.textDim(`  ${branch} ${relativizeToCwd(envelope.path, this.workspaceRoot)}${count === void 0 ? "" : ` · ${count} lines`}`), 0, 0));
+				});
+				return;
+			}
+		}
+		if (isDiffResult(message.name, message.result)) for (const line of renderDiffLines(message.result)) card.addChild(new Text(line, 0, 0));
+		else card.addChild(new Text(color.textDim(message.result), 0, 0));
+	}
+	/**
+	* Fill a tool card with a diff body: LCS-aligned clustered lines, capped
+	* at {@link DIFF_PREVIEW_LINES} in the default recent-turn view and full
+	* when the card was explicitly expanded (kimi parity).
+	* @param card - the card container to fill.
+	* @param diffs - the diff hunks.
+	* @param explicitlyExpanded - explicit expansion disables the cap.
+	*/
+	renderDiffBody(card, diffs, explicitlyExpanded) {
+		for (const line of renderDiffView(diffs, this.workspaceRoot, { maxLines: explicitlyExpanded ? void 0 : 10 })) card.addChild(new Text(line, 0, 0));
 	}
 	/** Request a render on the active screen. Public so in-place submenu
-	* components (async content swaps) can trigger the next frame. */
-	requestRender() {
-		(this.fullscreen ?? this.tui).requestRender();
+	* components (async content swaps) can trigger the next frame. `force`
+	* bypasses the render throttle (used to repaint the autocomplete list on
+	* the keystroke's own frame). */
+	requestRender(force = false) {
+		(this.fullscreen ?? this.tui).requestRender(force);
 	}
 	/**
 	* Reflect the todo list in the header line: active (non-completed) count
@@ -12750,6 +13677,7 @@ var TuiApp = class TuiApp {
 			this.todoText = ` · ${active.length} active · ${label}`;
 		}
 		this.renderHeader();
+		this.renderDock();
 		if (this.todoPanelVisible) this.renderTodoPanel();
 	}
 	/** Toggle the todo panel between the transcript and the editor. */
@@ -12802,7 +13730,7 @@ var TuiApp = class TuiApp {
 	renderHeader() {
 		const badge = this.planMode ? ` ${color.warning("[plan]")}` : "";
 		const title = this.sessionTitleText === "" ? "" : ` · ${color.textMuted(this.sessionTitleText)}`;
-		this.headerText = `🐋 dsh-pi-tui${title}${this.todoText}${badge}`;
+		this.headerText = `🐋  dsh-pi-tui${title}${this.todoText}${badge}`;
 		this.header.setText(this.headerText);
 		this.requestRender();
 	}
@@ -12818,6 +13746,87 @@ var TuiApp = class TuiApp {
 			...status
 		};
 		this.renderFooter();
+		this.renderDock();
+	}
+	/**
+	* Replace the active background-task list for the dock line.
+	* @param tasks - active jobs (label + lifecycle status), empty to hide.
+	*/
+	setTasks(tasks) {
+		this.dockTasks = tasks;
+		this.renderDock();
+	}
+	/**
+	* Replace the pending inbox rows for the queue pane (kimi QueuePane
+	* parity): a border rule, one `❯ text` row per message, and a dim hint.
+	* An empty queue renders nothing at all.
+	* @param items - pending followups/steers, in delivery order.
+	*/
+	setQueueItems(items) {
+		this.queueItems = items;
+		this.renderQueuePane();
+	}
+	/** Rebuild the queue pane text from the current inbox rows. */
+	renderQueuePane() {
+		const items = this.queueItems;
+		if (items.length === 0) {
+			this.queuePane.setText("");
+			this.requestRender();
+			return;
+		}
+		const width = Math.max(1, this.terminal.columns);
+		const lines = [color.border("─".repeat(width))];
+		for (const item of items) {
+			const prefix = `${color.accent("❯")} `;
+			const truncated = truncateToWidth(item.text.replace(/\s+/g, " ").trim(), Math.max(1, width - visibleWidth(prefix)), "…");
+			lines.push(prefix + truncated);
+		}
+		lines.push(color.textDim(truncateToWidth(`  ctrl+s to steer all · alt+↑ to edit all · /queue for per-item actions`, Math.max(1, width - 2), "…")));
+		this.queuePane.setText(lines.join("\n"));
+		this.requestRender();
+	}
+	/**
+	* Replace the editor draft wholesale (the Alt+↑ dequeue path pulls every
+	* queued message back into the editor for editing).
+	*/
+	setDraft(text) {
+		this.editor.setText(text);
+		this.requestRender();
+	}
+	/** The editor's current draft text (the Alt+↑ dequeue merge reads it). */
+	getDraft() {
+		return this.editor.getText();
+	}
+	/**
+	* Rebuild the persistent dock strip above the todo panel: goal, todo
+	* summary, and background tasks — one truncated line each, only while
+	* non-empty (kimi chrome parity). The dock is the "at a glance" surface
+	* under the transcript; the full todo list stays on Ctrl+T. The
+	* permission preset badges in the footer only, so the mode has exactly
+	* one home (no dock/footer duplication).
+	*/
+	renderDock() {
+		const lines = [];
+		if (this.status.goal !== void 0 && this.status.goal !== "") lines.push(color.text(`⚑  ${this.status.goal}`));
+		if (this.todoItems.length > 0) {
+			const active = this.todoItems.filter((todo) => todo.status !== "completed");
+			const done = this.todoItems.length - active.length;
+			const first = active[0];
+			const label = first === void 0 ? "" : first.content.length > 40 ? `${first.content.slice(0, 40)}…` : first.content;
+			const summary = [
+				done > 0 ? `${done} done` : "",
+				active.length > 0 ? `${active.length} active` : "",
+				label
+			].filter((part) => part !== "").join(" · ");
+			lines.push(color.textDim(`☑  ${summary}`));
+		}
+		if (this.dockTasks.length > 0) {
+			const first = this.dockTasks[0];
+			const label = first.label.length > 40 ? `${first.label.slice(0, 40)}…` : first.label;
+			lines.push(color.textDim(`⏳  ${this.dockTasks.length} task${this.dockTasks.length === 1 ? "" : "s"} · ${label}`));
+		}
+		this.dock.setText(lines.join("\n"));
+		this.requestRender();
 	}
 	/** Footer density presets: full keeps the stats line, compact drops it. */
 	footerPreset = "full";
@@ -12834,6 +13843,7 @@ var TuiApp = class TuiApp {
 	renderFooter() {
 		const context = this.status.contextTokens !== void 0 && this.status.contextWindow !== void 0 && this.status.contextWindow > 0 ? contextBar(this.status.contextTokens, this.status.contextWindow) : "";
 		const line1 = [
+			this.status.permission === "danger-full-access" ? color.warning("[yolo]") : this.status.permission === "read-only" ? color.textMuted("[read-only]") : this.status.permission === "workspace-write" ? color.text("[workspace-write]") : this.status.permission === "custom" ? color.warning("[custom]") : "",
 			this.planMode ? color.warning("[plan]") : "",
 			this.status.goal === void 0 || this.status.goal === "" ? "" : color.primary(this.status.goal),
 			this.status.model === "" ? "" : `[${this.status.model}]`,
@@ -13045,11 +14055,15 @@ var TuiApp = class TuiApp {
 				return;
 			}
 			const state = {
-				questions,
-				index: 0,
-				selected: /* @__PURE__ */ new Map(),
-				custom: /* @__PURE__ */ new Map(),
-				customText: "",
+				flow: new QuestionFlow(questions.map((question) => ({
+					id: question.id,
+					question: question.question,
+					...question.header !== void 0 ? { header: question.header } : {},
+					...question.detail !== void 0 ? { detail: question.detail } : {},
+					...question.options !== void 0 ? { options: question.options } : {},
+					...question.multiSelect !== void 0 ? { multiSelect: question.multiSelect } : {},
+					...question.intent !== void 0 ? { intent: question.intent } : {}
+				})), (answers) => this.settleQuestions(state, answers), () => this.settleQuestions(state, void 0)),
 				resolve,
 				reject,
 				signal
@@ -13059,123 +14073,36 @@ var TuiApp = class TuiApp {
 				return;
 			}
 			if (signal !== void 0) {
-				const onAbort = () => this.settleQuestions(state, "cancelled");
+				const onAbort = () => this.settleQuestions(state, void 0);
 				state.onAbort = onAbort;
 				signal.addEventListener("abort", onAbort, { once: true });
 			}
 			this.activeQuestions = state;
-			this.renderQuestion(state);
-		});
-	}
-	/** Build and mount the dialog for the state's current question. */
-	renderQuestion(state) {
-		const question = state.questions[state.index];
-		if (question === void 0) {
-			this.settleQuestions(state, "done");
-			return;
-		}
-		const dialog = new Box(1, 1);
-		if (question.header !== void 0 && question.header !== "") dialog.addChild(new Text(color.textDim(question.header)));
-		dialog.addChild(new Text(question.question));
-		const options = question.options ?? [];
-		if (options.length > 0) options.forEach((option, index) => {
-			const checked = state.selected.get(question.id)?.has(option.label) === true ? color.success("✓") : " ";
-			dialog.addChild(new Text(`${checked} ${index + 1}) ${option.label}${option.description === void 0 ? "" : ` — ${option.description}`}`));
-		});
-		else if (question.multiSelect !== true) {
-			dialog.addChild(new Text(`> ${state.customText}`));
-			dialog.addChild(new Text("(type an answer, enter to confirm)"));
-		}
-		dialog.addChild(new Text(""));
-		const verb = question.multiSelect === true ? "toggle" : "select";
-		dialog.addChild(new Text(`[1-9] ${verb}   [enter] confirm   [esc] cancel   (${state.index + 1}/${state.questions.length})`));
-		state.handle?.hide();
-		state.handle = this.showOverlayOnHost(new Frame(dialog), {
-			width: 72,
-			maxHeight: 24
+			state.handle = this.showOverlayOnHost(new Frame(state.flow), {
+				width: 76,
+				maxHeight: 26
+			});
 		});
 	}
-	/** Route a key while a question is showing; every key is consumed. */
+	/** Route a key while a question flow is showing; every key is consumed. */
 	handleQuestionKey(data) {
 		const state = this.activeQuestions;
 		if (state === void 0) return void 0;
-		const question = state.questions[state.index];
-		if (question === void 0) {
-			this.settleQuestions(state, "done");
-			return { consume: true };
-		}
-		const options = question.options ?? [];
-		const digit = /^[1-9]$/.exec(data);
-		if (digit !== null) {
-			const option = options[Number(digit[0]) - 1];
-			if (option !== void 0) {
-				const selected = state.selected.get(question.id) ?? /* @__PURE__ */ new Set();
-				if (question.multiSelect === true) {
-					if (selected.has(option.label)) selected.delete(option.label);
-					else selected.add(option.label);
-				} else {
-					selected.clear();
-					selected.add(option.label);
-				}
-				state.selected.set(question.id, selected);
-				this.renderQuestion(state);
-			}
-			return { consume: true };
-		}
-		if (matchesKey(data, "enter")) {
-			if (options.length > 0) {
-				state.index += 1;
-				this.renderQuestion(state);
-			} else if (question.multiSelect !== true) {
-				state.custom.set(question.id, state.customText);
-				state.customText = "";
-				state.index += 1;
-				this.renderQuestion(state);
-			}
-			return { consume: true };
-		}
-		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
-			this.settleQuestions(state, "cancelled");
-			return { consume: true };
-		}
-		if (options.length === 0 && question.multiSelect !== true) {
-			if (data === "" || data === "\b") {
-				state.customText = [...state.customText].slice(0, -1).join("");
-				this.renderQuestion(state);
-			} else {
-				let appended = false;
-				for (const char of data) if (char.charCodeAt(0) >= 32) {
-					state.customText += char;
-					appended = true;
-				}
-				if (appended) this.renderQuestion(state);
-			}
-		}
+		state.flow.handleInput(data);
+		this.requestRender();
 		return { consume: true };
 	}
-	/** Resolve the question flow with its answers, or reject on cancel. */
-	settleQuestions(state, outcome) {
+	/** Resolve the question flow with its answers, or reject on cancel/abort. */
+	settleQuestions(state, answers) {
 		if (this.activeQuestions !== state) return;
 		this.activeQuestions = void 0;
 		state.handle?.hide();
 		if (state.onAbort !== void 0 && state.signal !== void 0) state.signal.removeEventListener("abort", state.onAbort);
 		this.overlayHost.setFocus(this.editor);
-		if (outcome === "cancelled") {
+		if (answers === void 0) {
 			state.reject(/* @__PURE__ */ new Error("question flow cancelled"));
 			return;
 		}
-		const answers = state.questions.map((question) => {
-			const selected = [...state.selected.get(question.id) ?? []];
-			const custom = (question.options ?? []).length === 0 && question.multiSelect !== true ? state.custom.get(question.id) : void 0;
-			return custom === void 0 ? {
-				id: question.id,
-				selected
-			} : {
-				id: question.id,
-				selected,
-				custom
-			};
-		});
 		state.resolve(answers);
 	}
 };
@@ -13455,15 +14382,30 @@ function metaOf(cwd, presetId) {
 /**
 * Register the TUI-owned slash commands on the commands service. The
 * completion list is refreshed after every registration so TUI-owned
-* commands appear in the editor's tab list.
+* commands appear in the editor's tab list. Registration is sessionless:
+* the commands service's global layer needs no agent, so the whole surface
+* is available before the first session exists (deferred start).
 * @param runner - the live runner surface.
+* @returns a hook that rebuilds the per-skill slash commands (a no-op until
+*   the first session exists, since the skill catalog scope is the agent).
 */
 function registerTuiCommands(runner) {
 	const { ctx, app } = runner;
 	const cwd = runner.cwd;
 	const signal = runner.signal;
 	const commands = ctx.get("commands");
-	if (commands === void 0) return;
+	if (commands === void 0) throw new Error("commands service unavailable");
+	/**
+	* Resolve the live agent for a session-backed command, creating the first
+	* session lazily when the deferred start has not run yet. Throws when the
+	* creation failed — the executor surfaces the error to the user.
+	*/
+	const requireAgent = async () => {
+		await runner.ensureSession();
+		const agent = runner.liveAgent;
+		if (agent === void 0) throw new Error("session could not be created");
+		return agent;
+	};
 	const refreshCompletions = () => {
 		app.setCommandCompletions(commands.list(runner.liveAgent).map((command) => ({
 			name: command.name,
@@ -13478,7 +14420,8 @@ function registerTuiCommands(runner) {
 		handler: () => {
 			const liveAgent = runner.liveAgent;
 			app.stop();
-			runner.sessions.flush(liveAgent.session).then(() => runner.exit(0));
+			if (liveAgent === void 0) runner.exit(0);
+			else runner.sessions.flush(liveAgent.session).then(() => runner.exit(0));
 			return { kind: "success" };
 		}
 	});
@@ -13490,14 +14433,27 @@ function registerTuiCommands(runner) {
 			const tuiSettings = runner.tuiSettings;
 			const theme = tuiSettings?.get().theme ?? "auto";
 			const themeValue = theme.startsWith("custom:") ? theme.slice(7) : theme;
+			const settings = ctx.get("settings");
+			const permissionNames = [...ctx.get("permissionPresets")?.names ?? []];
+			let defaultPermission;
+			if (settings !== void 0) try {
+				defaultPermission = settings.get(settingsNamespace("permission"))?.defaultPreset;
+			} catch {}
 			app.openSettings([
-				{
+				...liveAgent === void 0 ? [] : [{
 					id: "approval",
-					label: "Approval policy",
+					label: "Approval policy (this session)",
 					description: "How tool approvals are handled in this session",
 					currentValue: effectiveApprovalPolicy(liveAgent.session.events) ?? "ask",
 					values: ["ask", "never"]
-				},
+				}],
+				...permissionNames.length > 0 ? [{
+					id: "default-permission",
+					label: "Default permission",
+					description: "Preset new sessions start with (persisted; Shift+Tab cycles this session)",
+					currentValue: defaultPermission ?? permissionNames[0] ?? "",
+					values: permissionNames
+				}] : [],
 				{
 					id: "theme",
 					label: "Theme",
@@ -13543,24 +14499,26 @@ function registerTuiCommands(runner) {
 					label: color.border("─".repeat(34)),
 					currentValue: ""
 				},
-				{
-					id: "session",
-					label: color.textDim("Session"),
-					description: color.textDim(liveAgent.session.id),
-					currentValue: color.textDim(displaySessionId(liveAgent.session.id))
-				},
-				{
-					id: "model",
-					label: color.textDim("Model"),
-					description: color.textDim("Provider and model routing this session"),
-					currentValue: color.textDim(`${liveAgent.options.provider}/${liveAgent.options.model}`)
-				},
-				{
-					id: "preset",
-					label: color.textDim("Agent preset"),
-					description: color.textDim("Composition this session runs on (see /preset)"),
-					currentValue: color.textDim(runner.currentPreset() ?? "none")
-				},
+				...liveAgent === void 0 ? [] : [
+					{
+						id: "session",
+						label: color.textDim("Session"),
+						description: color.textDim(liveAgent.session.id),
+						currentValue: color.textDim(displaySessionId(liveAgent.session.id))
+					},
+					{
+						id: "model",
+						label: color.textDim("Model"),
+						description: color.textDim("Provider and model routing this session"),
+						currentValue: color.textDim(`${liveAgent.options.provider}/${liveAgent.options.model}`)
+					},
+					{
+						id: "preset",
+						label: color.textDim("Agent preset"),
+						description: color.textDim("Composition this session runs on (see /preset)"),
+						currentValue: color.textDim(runner.currentPreset() ?? "none")
+					}
+				],
 				{
 					id: "cwd",
 					label: color.textDim("Working directory"),
@@ -13569,7 +14527,17 @@ function registerTuiCommands(runner) {
 				}
 			], (id, value) => {
 				if (id === "approval") {
-					if (value === "ask" || value === "never") ctx.get("approval")?.setPolicy(liveAgent, value);
+					if ((value === "ask" || value === "never") && liveAgent !== void 0) {
+						ctx.get("approval")?.setPolicy(liveAgent, value);
+						runner.refreshStatus();
+					}
+				} else if (id === "default-permission") {
+					const settings = ctx.get("settings");
+					if (settings !== void 0 && permissionNames.includes(value)) settings.mutate(settingsNamespace("permission"), [{
+						op: "set",
+						path: ["defaultPreset"],
+						value
+					}]);
 				} else if (id === "theme") {
 					if (value === "auto" || value === "dark" || value === "light" || customThemeNames().includes(value)) {
 						if (value === "auto") app.autoDetectTheme();
@@ -13578,7 +14546,7 @@ function registerTuiCommands(runner) {
 							const palette = loadCustomTheme(value);
 							if (palette !== void 0) app.applyPalette(palette);
 							else {
-								app.notify(`theme ${value} not found`);
+								app.notify(`theme ${value} not found`, "error");
 								return;
 							}
 						}
@@ -13606,7 +14574,7 @@ function registerTuiCommands(runner) {
 		}
 	});
 	const openSessionPicker = async (invocation, header) => {
-		const liveAgent = runner.liveAgent;
+		const currentId = runner.liveAgent?.session.id;
 		const persistence = ctx.get("sessionPersistence");
 		if (persistence === void 0) return {
 			kind: "error",
@@ -13615,17 +14583,17 @@ function registerTuiCommands(runner) {
 		const query = ctx.get("sessionQuery");
 		let rows;
 		if (query !== void 0) rows = (await query.listSessions()).map((record) => headerToPickerRow(record.header, record.live));
-		else rows = (await persistence.list()).map((header) => headerToPickerRow(header, header.id === liveAgent.session.id));
+		else rows = (await persistence.list()).map((header) => headerToPickerRow(header, header.id === currentId));
 		rows.sort((a, b) => b.createdAt - a.createdAt);
 		if (rows.length === 0) return {
 			kind: "error",
 			text: "no persisted sessions"
 		};
 		const shown = rows.slice(0, 200);
-		const picker = app.openPicker(shown.map((row) => sessionPickerItem(row, liveAgent.session.id)), (id) => {
-			if (id === liveAgent.session.id) return;
+		const picker = app.openPicker(shown.map((row) => sessionPickerItem(row, currentId ?? "")), (id) => {
+			if (id === currentId) return;
 			runner.switchSession(id).then((error) => {
-				if (error !== void 0) app.notify(error);
+				if (error !== void 0) app.notify(error, "error");
 			});
 		}, () => {}, {
 			enableSearch: true,
@@ -13641,7 +14609,7 @@ function registerTuiCommands(runner) {
 			picker.setItems(shown.map((row) => sessionPickerItem({
 				...row,
 				title: titles.get(row.id)
-			}, liveAgent.session.id)));
+			}, runner.liveAgent?.session.id ?? "")));
 		}).catch(() => {});
 		return { kind: "success" };
 	};
@@ -13658,22 +14626,22 @@ function registerTuiCommands(runner) {
 		handler: async (invocation) => {
 			const raw = invocation.rawInput.trim();
 			if (raw !== "") {
-				const liveAgent = runner.liveAgent;
+				const currentId = runner.liveAgent?.session.id;
 				const persistence = ctx.get("sessionPersistence");
 				if (persistence !== void 0) {
 					const query = ctx.get("sessionQuery");
 					let rows;
 					if (query !== void 0) rows = (await query.listSessions()).map((record) => headerToPickerRow(record.header, record.live));
-					else rows = (await persistence.list()).map((header) => headerToPickerRow(header, header.id === liveAgent.session.id));
+					else rows = (await persistence.list()).map((header) => headerToPickerRow(header, header.id === currentId));
 					rows.sort((a, b) => b.createdAt - a.createdAt);
 					const match = findSessionMatch(rows, raw);
 					if (match !== void 0) {
-						if (match.id === liveAgent.session.id) return {
+						if (match.id === currentId) return {
 							kind: "error",
 							text: "already on this session"
 						};
 						runner.switchSession(match.id).then((error) => {
-							if (error !== void 0) app.notify(error);
+							if (error !== void 0) app.notify(error, "error");
 						});
 						return { kind: "success" };
 					}
@@ -13682,28 +14650,26 @@ function registerTuiCommands(runner) {
 			return openSessionPicker(invocation, "resume");
 		}
 	});
-	const skillService = () => {
-		const liveAgent = runner.liveAgent;
-		return ctx.get("agentPresets")?.serviceFor(liveAgent, "skills") ?? ctx.get("skills");
+	const skillService = (agent) => {
+		return ctx.get("agentPresets")?.serviceFor(agent, "skills") ?? ctx.get("skills");
 	};
 	/** The workspace the live session runs in; fallback to the TUI's cwd. */
-	const sessionCwd = () => runner.liveAgent.session.header.cwd ?? cwd;
-	const loadSkill = async (name) => {
-		const liveAgent = runner.liveAgent;
-		const skills = skillService();
+	const sessionCwd = (agent) => agent.session.header.cwd ?? cwd;
+	const loadSkill = async (agent, name) => {
+		const skills = skillService(agent);
 		if (skills === void 0) return {
 			kind: "error",
 			text: "skill service unavailable"
 		};
 		const skill = await skills.get(name, {
-			cwd: sessionCwd(),
-			scope: liveAgent
+			cwd: sessionCwd(agent),
+			scope: agent
 		});
 		if (skill === void 0) return {
 			kind: "error",
 			text: "unknown skill \"" + name + "\""
 		};
-		liveAgent.inject(createUserMessage({
+		agent.inject(createUserMessage({
 			content: [{
 				type: "text",
 				text: "Skill loaded by the user: **" + skill.name + "**\n\n" + (skill.content ?? skill.description)
@@ -13723,11 +14689,12 @@ function registerTuiCommands(runner) {
 		for (const dispose of skillDisposers.values()) dispose();
 		skillDisposers.clear();
 		const liveAgent = runner.liveAgent;
-		const skills = skillService();
+		if (liveAgent === void 0) return 0;
+		const skills = skillService(liveAgent);
 		if (skills === void 0) return 0;
 		const taken = new Set(commands.list(liveAgent).map((command) => command.name));
 		const catalog = await skills.list({
-			cwd: sessionCwd(),
+			cwd: sessionCwd(liveAgent),
 			scope: liveAgent
 		});
 		for (const skill of catalog) {
@@ -13736,7 +14703,10 @@ function registerTuiCommands(runner) {
 				const dispose = commands.register({
 					name: skill.name,
 					description: "[skill] " + skill.description,
-					handler: async () => loadSkill(skill.name)
+					handler: async () => {
+						const agent = await requireAgent();
+						return loadSkill(agent, skill.name);
+					}
 				});
 				skillDisposers.set(skill.name, dispose);
 			} catch {}
@@ -13750,16 +14720,16 @@ function registerTuiCommands(runner) {
 		description: "Load a skill into the session context",
 		input: { hint: "<name>" },
 		handler: async (invocation) => {
-			const liveAgent = runner.liveAgent;
-			const skills = skillService();
+			const liveAgent = await requireAgent();
+			const skills = skillService(liveAgent);
 			if (skills === void 0) return {
 				kind: "error",
 				text: "skill service unavailable"
 			};
 			const name = invocation.rawInput.trim();
-			if (name !== "") return loadSkill(name);
+			if (name !== "") return loadSkill(liveAgent, name);
 			const catalog = await skills.list({
-				cwd: sessionCwd(),
+				cwd: sessionCwd(liveAgent),
 				scope: liveAgent
 			});
 			if (catalog.length === 0) return {
@@ -13773,7 +14743,7 @@ function registerTuiCommands(runner) {
 				currentValue: "",
 				values: ["✓"]
 			})), (id) => {
-				loadSkill(id).then((result) => {
+				loadSkill(liveAgent, id).then((result) => {
 					if (result.kind === "error") app.notify(result.text);
 				});
 			}, () => {});
@@ -13800,7 +14770,7 @@ function registerTuiCommands(runner) {
 				app.setFooterPreset(doc.footer === "compact" ? "compact" : "full");
 				app.setFullscreen(doc.fullscreen === "on");
 			}
-			app.notify(`reloaded — ${skillCount} skills \u00b7 settings reapplied`);
+			app.notify(`reloaded — ${skillCount} skills \u00b7 settings reapplied`, "info");
 			return { kind: "success" };
 		}
 	});
@@ -13849,24 +14819,117 @@ function registerTuiCommands(runner) {
 				sessionId: SessionId(`session-${randomUUID()}`),
 				meta: metaOf(cwd, presetId),
 				agentOptions: {
-					provider: liveAgent.options.provider,
-					model: liveAgent.options.model
+					provider: liveAgent?.options.provider ?? runner.selected.current?.provider,
+					model: liveAgent?.options.model ?? runner.selected.current?.model
 				},
 				setup: composition.setup
 			});
 			const error = await runner.swapTo(next);
-			if (error !== void 0) app.notify(error);
+			if (error !== void 0) app.notify(error, "error");
 			return {
 				kind: "success",
 				text: "started a fresh session"
 			};
 		}
 	});
+	commands.register({
+		name: "queue",
+		description: "Manage queued input: edit, delete, steer, or insert",
+		handler: async () => {
+			const liveAgent = await requireAgent();
+			const inbox = liveAgent.inbox;
+			const queued = [...inbox.nextTurn.map((message, index) => ({
+				message,
+				slot: `next ${index + 1}`,
+				list: "next-turn"
+			})), ...inbox.nextStep.map((message, index) => ({
+				message,
+				slot: `steer ${index + 1}`,
+				list: "next-step"
+			}))];
+			if (queued.length === 0) return {
+				kind: "success",
+				text: "no queued input"
+			};
+			app.openSettings(queued.map(({ message, slot }) => ({
+				id: message.id,
+				label: `[${slot}] ${textOf(message.content).replace(/\s+/g, " ").trim().slice(0, 40)}`,
+				description: message.id,
+				currentValue: "",
+				submenu: (value, done) => new SettingsList([
+					{
+						id: "edit",
+						label: "Edit",
+						description: "Rewrite this queued message",
+						currentValue: "",
+						values: ["✓"]
+					},
+					{
+						id: "delete",
+						label: "Delete",
+						description: "Remove it from the queue",
+						currentValue: "",
+						values: ["✓"]
+					},
+					{
+						id: "steer",
+						label: "Steer",
+						description: "Send it now: into the running turn, or start one when idle",
+						currentValue: "",
+						values: ["✓"]
+					},
+					{
+						id: "insert",
+						label: "Insert before",
+						description: "Queue a new message ahead of this one",
+						currentValue: "",
+						values: ["✓"]
+					}
+				], 6, settingsListTheme, (action) => done(action), () => done(), {})
+			})), (id, action) => {
+				const target = queued.find((item) => item.message.id === id);
+				if (target === void 0) return;
+				const message = target.message;
+				if (action === "delete") {
+					inbox.remove(message.id);
+					app.notify("queued message deleted", "info");
+				} else if (action === "steer") {
+					inbox.remove(message.id);
+					if (liveAgent.status === "running") liveAgent.steer(message);
+					else liveAgent.followup(message);
+					app.notify("steering queued message", "info");
+				} else if (action === "edit" || action === "insert") app.askQuestions([{
+					id: "q",
+					question: action === "edit" ? "Edit queued message:" : "New message to insert:"
+				}]).then((answers) => {
+					const text = answers[0]?.custom?.trim() ?? "";
+					if (text === "") return;
+					const next = createUserMessage({
+						content: [{
+							type: "text",
+							text
+						}],
+						source: { kind: "user" }
+					});
+					if (action === "edit") {
+						inbox.replace(message.id, next);
+						app.notify("queued message updated", "info");
+					} else {
+						const position = (target.list === "next-turn" ? inbox.nextTurn : inbox.nextStep).findIndex((item) => item.id === message.id);
+						if (position < 0) return;
+						inbox.splice(target.list, position, 0, [next]);
+						app.notify("message inserted before the selected one", "info");
+					}
+				}).catch(() => {});
+			}, () => {});
+			return { kind: "success" };
+		}
+	});
 	commands.register({
 		name: "tasks",
 		description: "List background jobs for this session",
-		handler: () => {
-			const liveAgent = runner.liveAgent;
+		handler: async () => {
+			const liveAgent = await requireAgent();
 			const jobs = ctx.get("jobs");
 			if (jobs === void 0) return {
 				kind: "error",
@@ -13886,12 +14949,32 @@ function registerTuiCommands(runner) {
 			return { kind: "success" };
 		}
 	});
+	commands.register({
+		name: "yolo",
+		description: "Switch to danger-full-access (alias of /permission danger-full-access)",
+		handler: async () => {
+			const liveAgent = await requireAgent();
+			const commands = ctx.get("commands");
+			if (commands === void 0) return {
+				kind: "error",
+				text: "commands service unavailable"
+			};
+			if (await commands.execute(liveAgent, "/permission danger-full-access", signal) === void 0) return {
+				kind: "error",
+				text: "/permission unavailable (permission presets not composed)"
+			};
+			return {
+				kind: "success",
+				text: "danger-full-access — approvals off"
+			};
+		}
+	});
 	commands.register({
 		name: "preset",
 		description: "Show or switch the session agent preset",
 		input: { hint: "[status|<id>|default [<id>]]" },
 		handler: async (invocation) => {
-			const liveAgent = runner.liveAgent;
+			const liveAgent = await requireAgent();
 			const presets = ctx.get("agentPresets");
 			if (presets === void 0) return {
 				kind: "error",
@@ -13967,7 +15050,7 @@ function registerTuiCommands(runner) {
 		name: "subagents",
 		description: "List child agents; view a transcript or interrupt one",
 		handler: async () => {
-			const liveAgent = runner.liveAgent;
+			const liveAgent = await requireAgent();
 			const subagents = ctx.get("subagents");
 			if (subagents === void 0) return {
 				kind: "error",
@@ -14006,7 +15089,7 @@ function registerTuiCommands(runner) {
 						kind: "user",
 						parentSessionId: liveAgent.session.id
 					});
-					app.notify(`interrupting ${labelOf(child)}`);
+					app.notify(`interrupting ${labelOf(child)}`, "info");
 				}
 			}, () => {});
 			return { kind: "success" };
@@ -14017,7 +15100,7 @@ function registerTuiCommands(runner) {
 		description: "Search persisted sessions for text and switch to a hit",
 		input: { hint: "<query>" },
 		handler: async (invocation) => {
-			const liveAgent = runner.liveAgent;
+			const currentId = runner.liveAgent?.session.id;
 			const persistence = ctx.get("sessionPersistence");
 			if (persistence === void 0) return {
 				kind: "error",
@@ -14060,9 +15143,9 @@ function registerTuiCommands(runner) {
 				label: hit.id.length > 26 ? `${hit.id.slice(0, 26)}…` : hit.id,
 				description: `${Math.max(0, Math.floor((now - hit.createdAt) / 6e4))}m ago · …${hit.snippet}…`
 			})), (id) => {
-				if (id === liveAgent.session.id) return;
+				if (id === currentId) return;
 				runner.switchSession(id).then((error) => {
-					if (error !== void 0) app.notify(error);
+					if (error !== void 0) app.notify(error, "error");
 				});
 			}, () => {});
 			return { kind: "success" };
@@ -14072,8 +15155,8 @@ function registerTuiCommands(runner) {
 		name: "title",
 		description: "Set or show the session title",
 		input: { hint: "<title>" },
-		handler: (invocation) => {
-			const liveAgent = runner.liveAgent;
+		handler: async (invocation) => {
+			const liveAgent = await requireAgent();
 			const titles = ctx.get("sessionTitle");
 			if (titles === void 0) return {
 				kind: "error",
@@ -14097,8 +15180,8 @@ function registerTuiCommands(runner) {
 	commands.register({
 		name: "copy",
 		description: "Copy the last assistant message (OSC 52 clipboard)",
-		handler: () => {
-			const last = runner.liveAgent.session.events.findLast((event) => event.type === "assistant/message");
+		handler: async () => {
+			const last = (await requireAgent()).session.events.findLast((event) => event.type === "assistant/message");
 			if (last === void 0) return {
 				kind: "error",
 				text: "no assistant message yet"
@@ -14124,7 +15207,7 @@ function registerTuiCommands(runner) {
 		description: "Export this session log (JSONL by default, `md` for a readable transcript)",
 		input: { hint: "[md|<path>]" },
 		handler: async (invocation) => {
-			const liveAgent = runner.liveAgent;
+			const liveAgent = await requireAgent();
 			const persistence = ctx.get("sessionPersistence");
 			if (persistence === void 0) return {
 				kind: "error",
@@ -14165,7 +15248,7 @@ function registerTuiCommands(runner) {
 		description: "Fork this session at the last completed turn",
 		handler: async () => {
 			const liveAgent = runner.liveAgent;
-			const seed = forkSeed(liveAgent.session.events);
+			const seed = liveAgent === void 0 ? void 0 : forkSeed(liveAgent.session.events);
 			if (seed === void 0) return {
 				kind: "error",
 				text: "no completed turn to fork from"
@@ -14187,7 +15270,7 @@ function registerTuiCommands(runner) {
 				seed
 			});
 			const error = await runner.swapTo(next);
-			if (error !== void 0) app.notify(error);
+			if (error !== void 0) app.notify(error, "error");
 			return {
 				kind: "success",
 				text: `forked as ${next.agent.session.id}`
@@ -14197,8 +15280,8 @@ function registerTuiCommands(runner) {
 	commands.register({
 		name: "status",
 		description: "Show session stats and identity",
-		handler: () => {
-			const liveAgent = runner.liveAgent;
+		handler: async () => {
+			const liveAgent = await requireAgent();
 			const stats = computeStats(liveAgent.session.events);
 			let contextTokens;
 			const meter = ctx.get("tokenMeter");
@@ -14373,6 +15456,225 @@ function registerTuiCommands(runner) {
 		}
 	});
 	refreshCompletions();
+	return { refreshSkills: () => registerSkillCommands() };
+}
+//#endregion
+//#region src/diag.ts
+/**
+* Structured process diagnostics for the TUI.
+*
+* The TUI cannot rely on `ctx.logger` for human-visible troubleshooting:
+* no dsh server-side package registers a logger exporter, so those lines
+* only fill cordis's in-memory buffer. This module owns a dedicated
+* diagnostics channel instead — one line per event, written to stderr
+* (warn/error by default, matching the legacy `[tui]` fd-2 lines) and to a
+* log file (info by default) under `$DSH_HOME/logs/`.
+*
+* Configuration (env):
+* - `DSH_PI_TUI_LOG` — log file path, or `off` to disable the file sink.
+* - `DSH_PI_TUI_LOG_LEVEL` — one of debug/info/warn/error (default `info`).
+*
+* Writes are best-effort and never throw; a failed file sink is disabled
+* silently so diagnostics can never take the TUI down.
+* @module @xmoon76/dsh-pi-tui/diag
+*/
+const LEVEL_RANK = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+/** `2026-08-15T10:00:00.000+08:00` — local wall time with the zone offset. */
+function formatDiagTime(date) {
+	const pad = (value, width = 2) => String(value).padStart(width, "0");
+	const offsetMinutes = -date.getTimezoneOffset();
+	const offset = `${offsetMinutes >= 0 ? "+" : "-"}${pad(Math.floor(Math.abs(offsetMinutes) / 60))}:${pad(Math.abs(offsetMinutes) % 60)}`;
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}${offset}`;
+}
+/** Render a single field value for the `k=v` line format. */
+function formatField(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) return String(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+/** The dsh home directory (`$DSH_HOME`, defaulting to `~/.dsh`). */
+function dshHome(env) {
+	const explicit = env.DSH_HOME;
+	if (explicit !== void 0 && explicit !== "") return explicit;
+	return join(homedir(), ".dsh");
+}
+/** Build the default diagnostics log path: `$DSH_HOME/logs/pi-tui-<pid>.log`. */
+function defaultDiagLogPath(env) {
+	const configured = env.DSH_PI_TUI_LOG;
+	if (configured === "off" || configured === "") return void 0;
+	if (configured !== void 0) return configured;
+	return join(dshHome(env), "logs", `pi-tui-${process.pid}.log`);
+}
+/** Resolve the effective file level from `DSH_PI_TUI_LOG_LEVEL`. */
+function diagLevelFromEnv(env) {
+	const configured = env.DSH_PI_TUI_LOG_LEVEL;
+	if (configured === "debug" || configured === "info" || configured === "warn" || configured === "error") return configured;
+	return "info";
+}
+/** Create the diagnostics channel from the process environment. */
+function diagFromEnv(env) {
+	return createDiag({
+		fileLevel: diagLevelFromEnv(env),
+		filePath: defaultDiagLogPath(env)
+	});
+}
+/** Create one diagnostics channel. Writes are best-effort, never throw. */
+function createDiag(options = {}) {
+	const fileLevel = options.fileLevel ?? "info";
+	const stderrLevel = options.stderrLevel ?? "warn";
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const sinks = [...options.sinks ?? []];
+	let fileHandle;
+	let fileDisabled = false;
+	if (options.filePath !== void 0) try {
+		const dir = options.filePath.slice(0, Math.max(options.filePath.lastIndexOf("/"), 0));
+		if (dir !== "") mkdirSync(dir, { recursive: true });
+		fileHandle = openSync(options.filePath, "a");
+	} catch {
+		fileDisabled = true;
+	}
+	const emit = (level, message, fields) => {
+		const stamp = formatDiagTime(now());
+		const suffix = fields === void 0 ? "" : ` ${Object.entries(fields).map(([key, value]) => `${key}=${formatField(value)}`).join(" ")}`;
+		const line = `[tui] ${stamp} ${level.toUpperCase()} ${message}${suffix}\n`;
+		for (const sink of sinks) try {
+			sink.write(line);
+		} catch {}
+		if (stderrLevel !== "off" && LEVEL_RANK[level] >= LEVEL_RANK[stderrLevel]) try {
+			writeSync(2, line);
+		} catch {}
+		if (fileHandle !== void 0 && !fileDisabled && LEVEL_RANK[level] >= LEVEL_RANK[fileLevel]) try {
+			writeSync(fileHandle, line);
+		} catch {
+			fileDisabled = true;
+			try {
+				writeSync(2, `[tui] ${formatDiagTime(now())} WARN diag file sink disabled\n`);
+			} catch {}
+		}
+	};
+	return {
+		debug: (message, fields) => emit("debug", message, fields),
+		info: (message, fields) => emit("info", message, fields),
+		warn: (message, fields) => emit("warn", message, fields),
+		error: (message, fields) => emit("error", message, fields),
+		dispose: () => {
+			if (fileHandle !== void 0) {
+				try {
+					closeSync(fileHandle);
+				} catch {}
+				fileHandle = void 0;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/guard.ts
+/** Fresh guard state: forces one real read on the first check. */
+function freshGuardState() {
+	return {
+		revision: "",
+		diverged: false,
+		fileEvents: 0,
+		error: void 0
+	};
+}
+function statRevision(stat) {
+	return `${stat.size}:${stat.mtimeMs}`;
+}
+/**
+* Check whether an external process has written the session since the last
+* consistent observation. Mutates `state` (revision + divergence latch).
+* Never throws.
+*/
+async function checkDivergence(persistence, session, stat, state) {
+	if (persistence === void 0) return {
+		kind: "unavailable",
+		revision: state.revision,
+		reason: "no-persistence"
+	};
+	const artifact = persistence.locate({
+		id: session.id,
+		cwd: session.header?.cwd
+	});
+	if (artifact === void 0) return {
+		kind: "unavailable",
+		revision: state.revision,
+		reason: "no-artifact"
+	};
+	let current;
+	try {
+		current = stat(artifact.path);
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			kind: "ok",
+			revision: state.revision
+		};
+		state.diverged = true;
+		return {
+			kind: "unreadable",
+			revision: state.revision,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+	const revision = statRevision(current);
+	if (revision === state.revision) {
+		if (!state.diverged) return {
+			kind: "ok",
+			revision
+		};
+		return state.error !== void 0 ? {
+			kind: "unreadable",
+			revision,
+			error: state.error
+		} : {
+			kind: "diverged",
+			revision,
+			fileEvents: state.fileEvents,
+			memoryEvents: session.events.length
+		};
+	}
+	let fileEvents;
+	try {
+		fileEvents = (await persistence.readFrom(session.id, 0)).events.length;
+	} catch (error) {
+		state.revision = revision;
+		state.diverged = true;
+		state.fileEvents = -1;
+		state.error = error instanceof Error ? error.message : String(error);
+		return {
+			kind: "unreadable",
+			revision,
+			error: state.error
+		};
+	}
+	const memoryEvents = session.events.length;
+	state.revision = revision;
+	state.fileEvents = fileEvents;
+	state.error = void 0;
+	if (fileEvents > memoryEvents) {
+		state.diverged = true;
+		return {
+			kind: "diverged",
+			revision,
+			fileEvents,
+			memoryEvents
+		};
+	}
+	state.diverged = false;
+	return {
+		kind: "ok",
+		revision,
+		fileEvents
+	};
 }
 //#endregion
 //#region src/index.ts
@@ -14402,6 +15704,27 @@ const WINDOW_TURNS = 15;
 /** Coalesced repaint interval for streaming events, in ms. */
 const REPAINT_FLUSH_MS = 50;
 /**
+* Slash commands that need no session: before the first user message
+* (deferred start) they run locally without creating one. Everything else
+* dispatches through `commands.execute`, which creates the session lazily
+* (the command line IS the first user input). Commands in this set must
+* tolerate `liveAgent === undefined` in their handlers.
+*/
+const SESSIONLESS_COMMANDS = /* @__PURE__ */ new Set([
+	"exit",
+	"settings",
+	"help",
+	"login",
+	"logout",
+	"model",
+	"reload",
+	"sessions",
+	"resume",
+	"search",
+	"new",
+	"fork"
+]);
+/**
 * The installed dsh version (e.g. `0.1.0-rc.6`), resolved from the launcher's
 * real path: `process.argv[1]` is the `dsh` bin, whose realpath walks up to
 * the `@deepseek-ai/dsh/package.json` that owns it. The version the welcome
@@ -14465,18 +15788,6 @@ function gitBranch(cwd) {
 function shortCwd(cwd) {
 	return cwd.split("/").filter(Boolean).slice(-2).join("/") || cwd;
 }
-/**
-* Write raw bytes to a file descriptor, bypassing the cordis-wrapped
-* `process.stderr` (whose `writeSync` is missing). Startup diagnostics go to
-* fd 2 so they never corrupt the TUI frame on stdout.
-* @param fd - the file descriptor (2 for stderr).
-* @param text - the bytes to write.
-*/
-function writeFd2(fd, text) {
-	try {
-		writeFileSync(fd, text);
-	} catch {}
-}
 /** Shell commands the approval dialog flags as dangerous (kimi-inspired). */
 const DANGER_PATTERNS = [
 	/\bmkfs(\.\w+)?\b/,
@@ -14488,6 +15799,9 @@ const DANGER_PATTERNS = [
 	/>+\s*\/dev\/sd/,
 	/\bcurl\b[^\n|]*\|\s*(ba)?sh\b/
 ];
+/** Divergence-guard notices (user-facing, English like the rest of the TUI). */
+const GUARD_BLOCKED_NOTIFY = "This session may be open in another dsh process (TUI/web); send blocked. Press Enter again to force (may corrupt the session log)";
+const GUARD_FORCED_NOTIFY = "Forced send — the session may be written by another process; the log may be damaged";
 /**
 * Whether a shell command matches a destructive pattern. `rm` is treated
 * specially: any spelling of recursive + force flags (`rm -rf`, `rm -r -f`,
@@ -14502,6 +15816,36 @@ function dangerCommand(command) {
 	return DANGER_PATTERNS.some((pattern) => pattern.test(command));
 }
 /**
+* The dsh profile this process was launched with (the `--profile` flag),
+* so the exit-time resume hint names the profile the TUI actually runs
+* under. Falls back to `pi-tui` when the flag is absent (the TUI bundle
+* cannot load without a profile, so this is defensive only).
+* @param argv - the process argument vector.
+* @param fallback - the default profile.
+*/
+function runningProfile(argv = process.argv, fallback = "pi-tui") {
+	for (let i = argv.length - 1; i >= 0; i--) {
+		const arg = argv[i];
+		if (arg.startsWith("--profile=")) return arg.slice(10);
+		if (arg === "--profile" && i + 1 < argv.length && argv[i + 1] !== void 0 && argv[i + 1] !== "") return argv[i + 1];
+	}
+	return fallback;
+}
+/**
+* The interactive-quit resume hint (pi parity): `dsh --profile <p>
+* --session <id>`, printed after the terminal restores so the user can
+* re-enter the session later. Returns undefined when there is no session
+* to resume (deferred start never created one).
+* @param profile - the running profile ({@link runningProfile}).
+* @param sessionId - the live session id.
+* @returns the resume command line, or undefined without a session.
+*/
+function resumeCommand(profile, sessionId) {
+	const id = sessionId.trim();
+	if (id === "") return void 0;
+	return `dsh --profile ${profile} --session ${id}`;
+}
+/**
 * The active goal badge text from the session log, or undefined. The latest
 * `goal/change` wins; a clear or completed goal hides the badge.
 * @param events - the session log.
@@ -14630,6 +15974,7 @@ function apply(ctx, config) {
 	if (exit === void 0) throw new Error("tui-runner: the launcher must provide ctx.appExit before the tree mounts");
 	const startup = ctx.get(TUI_STARTUP_SERVICE);
 	if (startup === void 0) return;
+	const diag = diagFromEnv(process.env);
 	const sessionId = config.sessionId !== void 0 && config.sessionId !== "" ? config.sessionId : startup.sessionId;
 	(async () => {
 		await ctx.get("loader")?.await();
@@ -14649,6 +15994,14 @@ function apply(ctx, config) {
 		const compose = (presetId) => composeAgent(ctx, selected, presetId);
 		const withPresetMeta = (composition) => composition.agentPreset === void 0 ? {} : { agentPreset: composition.agentPreset };
 		const launchPreset = startup.presetId ?? (process.env.DSH_PI_TUI_PRESET?.trim() || void 0);
+		diag.info("boot", {
+			pid: process.pid,
+			dsh: dshVersion() ?? "unknown",
+			bundle: packageVersion(),
+			cwd: process.cwd(),
+			session: sessionId ?? "(deferred)",
+			preset: launchPreset ?? "default"
+		});
 		/** Resolve the launch composition, falling back to the default on an unknown id. */
 		const launchComposition = async () => {
 			try {
@@ -14656,6 +16009,10 @@ function apply(ctx, config) {
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
 				ctx.logger.warn(`tui-runner: launch preset unavailable: ${message}`);
+				diag.warn("preset unavailable", {
+					preset: launchPreset ?? "default",
+					error: message
+				});
 				return {
 					composition: await compose(),
 					failure: `preset "${launchPreset}" unavailable; started with the default`
@@ -14672,14 +16029,36 @@ function apply(ctx, config) {
 				agentOptions,
 				setup: composition.setup
 			});
+			diag.info("resume ok", {
+				session: sessionId,
+				seq: handle.agent.session.events.length,
+				preset: recorded ?? "default"
+			});
 			if (launchPreset !== void 0 && launchPreset !== recorded) try {
-				if ((await recomposeBlank(ctx, handle.agent, launchPreset)).kind === "locked") ctx.logger.warn(`tui-runner: session ${sessionId} has started; its agent preset ${recorded} is fixed, ignoring --preset ${launchPreset}`);
+				if ((await recomposeBlank(ctx, handle.agent, launchPreset)).kind === "locked") {
+					const message = `session ${sessionId} has started; its agent preset ${recorded} is fixed, ignoring --preset ${launchPreset}`;
+					ctx.logger.warn(`tui-runner: ${message}`);
+					diag.warn("preset ignored on resume", {
+						session: sessionId,
+						preset: launchPreset
+					});
+				}
 			} catch (error) {
-				ctx.logger.warn(`tui-runner: --preset ${launchPreset} not applied on resume: ${error instanceof Error ? error.message : String(error)}`);
+				const message = `--preset ${launchPreset} not applied on resume: ${error instanceof Error ? error.message : String(error)}`;
+				ctx.logger.warn(`tui-runner: ${message}`);
+				diag.warn("preset not applied on resume", {
+					session: sessionId,
+					preset: launchPreset,
+					error: message
+				});
 			}
 		} catch (error) {
-			ctx.logger.warn(`tui-runner: resume ${sessionId} failed: ${error instanceof Error ? error.message : String(error)}`);
-			writeFd2(2, `[tui] resume ${sessionId} failed: ${error instanceof Error ? error.message : String(error)}\n`);
+			const message = error instanceof Error ? error.message : String(error);
+			ctx.logger.warn(`tui-runner: resume ${sessionId} failed: ${message}`);
+			diag.error("resume failed", {
+				session: sessionId,
+				error: message
+			});
 			resumeFailure = `session ${sessionId} could not be resumed; started a fresh session`;
 			const launched = await launchComposition();
 			if (launched.failure !== void 0) resumeFailure = launched.failure;
@@ -14693,52 +16072,86 @@ function apply(ctx, config) {
 				setup: launched.composition.setup
 			});
 		}
-		else {
-			const launched = await launchComposition();
-			if (launched.failure !== void 0) resumeFailure = launched.failure;
-			try {
-				handle = await agents.create({
-					sessionId: SessionId(`session-${randomUUID()}`),
-					meta: {
-						cwd: process.cwd(),
-						...withPresetMeta(launched.composition)
-					},
-					agentOptions,
-					setup: launched.composition.setup
-				});
-			} catch (error) {
-				ctx.logger.warn(`tui-runner: failed to start with preset "${launchPreset ?? "default"}": ${error instanceof Error ? error.message : String(error)}`);
-				resumeFailure = `failed to start with preset "${launchPreset ?? "default"}": ${error instanceof Error ? error.message : String(error)}`;
-				const fallback = await compose();
-				handle = await agents.create({
-					sessionId: SessionId(`session-${randomUUID()}`),
-					meta: {
-						cwd: process.cwd(),
-						...withPresetMeta(fallback)
-					},
-					agentOptions,
-					setup: fallback.setup
-				});
-			}
-		}
 		let liveHandle = handle;
-		let liveAgent = handle.agent;
-		await liveAgent.whenIdle();
+		let liveAgent = handle?.agent;
+		if (liveAgent !== void 0) await liveAgent.whenIdle();
+		let guardState = freshGuardState();
+		let guardForced = false;
+		/**
+		* Run the divergence guard before a session-writing submission. Returns
+		* 'ok' to proceed, 'blocked' to refuse (the caller restores the draft),
+		* 'forced' when the user overrode a still-bad state, and 'unavailable'
+		* when the deployment cannot guard (proceed).
+		*/
+		const guardSend = async () => {
+			if (liveAgent === void 0) return "ok";
+			const session = {
+				id: liveAgent.session.id,
+				header: liveAgent.session.header,
+				events: liveAgent.session.events
+			};
+			const outcome = await checkDivergence(ctx.get("sessionPersistence"), session, (path) => statSync(path), guardState);
+			switch (outcome.kind) {
+				case "ok":
+					guardForced = false;
+					diag.debug("guard ok", {
+						session: session.id,
+						fileEvents: outcome.fileEvents ?? 0,
+						memoryEvents: session.events.length
+					});
+					return "ok";
+				case "diverged":
+					diag.warn("guard diverged", {
+						session: session.id,
+						fileEvents: outcome.fileEvents,
+						memoryEvents: outcome.memoryEvents
+					});
+					if (guardForced) {
+						guardForced = false;
+						return "forced";
+					}
+					return "blocked";
+				case "unreadable":
+					diag.error("guard unreadable", {
+						session: session.id,
+						error: outcome.error
+					});
+					if (guardForced) {
+						guardForced = false;
+						return "forced";
+					}
+					return "blocked";
+				case "unavailable":
+					guardForced = false;
+					return "ok";
+			}
+		};
 		/** The preset the live agent runs on, when the deployment composes one. */
-		const currentPreset = () => ctx.get("agentPresets")?.composedPreset(liveAgent.ctx) ?? resolveSessionPreset(liveAgent.session);
+		const currentPreset = () => {
+			if (liveAgent === void 0) return void 0;
+			return ctx.get("agentPresets")?.composedPreset(liveAgent.ctx) ?? resolveSessionPreset(liveAgent.session);
+		};
 		ctx.effect(function* () {
 			yield () => {
 				app?.stop();
+				diag.dispose();
 			};
 		});
 		let folder = new TranscriptFolder();
-		folder.apply(liveAgent.session.events);
 		let statsFolder = new StatsFolder();
-		statsFolder.apply(liveAgent.session.events);
-		let goalText = foldGoal(liveAgent.session.events);
+		let goalText;
+		if (liveAgent !== void 0) {
+			folder.apply(liveAgent.session.events);
+			statsFolder.apply(liveAgent.session.events);
+			goalText = foldGoal(liveAgent.session.events);
+		}
 		/** Repaint the welcome card from the live agent's current facts. Re-read
 		* on every call so a still-blank session's preset switch shows up. */
 		const updateWelcomeCard = () => {
+			if (liveAgent === void 0) {
+				app.setWelcomeIdle(true);
+				return;
+			}
 			app.setWelcomeCard({
 				cwd,
 				sessionId: liveAgent.session.id,
@@ -14749,28 +16162,31 @@ function apply(ctx, config) {
 		};
 		/** Swap the live agent to a new handle, repainting for its session. */
 		const swapTo = async (next) => {
+			const from = liveAgent?.session.id;
 			try {
-				await sessions.flush(liveAgent.session);
-				await liveHandle.dispose();
+				if (liveAgent !== void 0) {
+					await sessions.flush(liveAgent.session);
+					await liveHandle?.dispose();
+				}
 				liveHandle = next;
 				liveAgent = next.agent;
 				await liveAgent.whenIdle();
 			} catch (error) {
-				process.stderr.write(`[tui] swap failed: ${error instanceof Error ? error.message : String(error)}\n`);
-				return `swap failed: ${error instanceof Error ? error.message : String(error)}`;
+				const message = error instanceof Error ? error.message : String(error);
+				diag.error("swap failed", {
+					from,
+					error: message
+				});
+				return `swap failed: ${message}`;
 			}
-			folder = new TranscriptFolder();
-			folder.apply(liveAgent.session.events);
-			statsFolder = new StatsFolder();
-			statsFolder.apply(liveAgent.session.events);
-			goalText = foldGoal(liveAgent.session.events);
-			app.setWorking(workingFromLog(liveAgent.session.events));
-			app.setSessionTitle(foldSessionTitle(liveAgent.session.events)?.title);
-			app.clearLocalMessages();
-			repaint(app, folder);
-			refreshStatus();
-			setTerminalTitle(`dsh-pi-tui · ${shortCwd(cwd)} · ${liveAgent.session.id}`);
-			updateWelcomeCard();
+			guardState = freshGuardState();
+			guardForced = false;
+			await initLiveSession(next.agent);
+			diag.info("switch ok", {
+				from: from ?? "(none)",
+				to: next.agent.session.id,
+				seq: next.agent.session.events.length
+			});
 		};
 		/** Hand the TUI over to another persisted session. Never throws: every
 		* failure (unknown session, broken log, preset mount) returns an error
@@ -14781,31 +16197,38 @@ function apply(ctx, config) {
 				const next = await agents.resume({
 					resumeSessionId: SessionId(sessionId),
 					agentOptions: {
-						provider: liveAgent.options.provider,
-						model: liveAgent.options.model
+						provider: liveAgent?.options.provider ?? selection.provider,
+						model: liveAgent?.options.model ?? selection.model
 					},
 					setup: composition.setup
 				});
 				return swapTo(next);
 			} catch (error) {
-				ctx.logger.warn(`tui-runner: switch to ${sessionId} failed: ${error instanceof Error ? error.message : String(error)}`);
-				return `switch failed: ${error instanceof Error ? error.message : String(error)}`;
+				const message = error instanceof Error ? error.message : String(error);
+				ctx.logger.warn(`tui-runner: switch to ${sessionId} failed: ${message}`);
+				diag.error("switch failed", {
+					session: sessionId,
+					error: message
+				});
+				return `switch failed: ${message}`;
 			}
 		};
 		const cwd = process.cwd();
 		/** The footer model label: the live selection (with effort) when one exists. */
 		const modelLabel = () => {
 			const selection = selected.current;
-			if (selection === void 0) return `${liveAgent.options.provider}/${liveAgent.options.model}`;
-			return selection.reasoningEffort === void 0 ? `${selection.provider}/${selection.model}` : `${selection.provider}/${selection.model} @${selection.reasoningEffort}`;
+			if (selection !== void 0) return selection.reasoningEffort === void 0 ? `${selection.provider}/${selection.model}` : `${selection.provider}/${selection.model} @${selection.reasoningEffort}`;
+			if (liveAgent === void 0) return "no model";
+			return `${liveAgent.options.provider}/${liveAgent.options.model}`;
 		};
 		const refreshStatus = () => {
 			const stats = statsFolder.snapshot();
 			let contextTokens;
 			const meter = ctx.get("tokenMeter");
-			if (meter !== void 0) try {
+			if (meter !== void 0 && liveAgent !== void 0) try {
 				contextTokens = meter.measure(liveAgent.session).totalTokens;
 			} catch {}
+			const permission = ctx.get("permissionPresets");
 			app.setStatus({
 				model: modelLabel(),
 				cwd: shortCwd(cwd),
@@ -14814,6 +16237,7 @@ function apply(ctx, config) {
 				turns: stats.turns,
 				steps: stats.steps,
 				statsLine: formatStats(stats),
+				...permission === void 0 || liveAgent === void 0 ? {} : { permission: permission.current(liveAgent.session.events) },
 				...contextTokens !== void 0 ? {
 					contextTokens,
 					contextWindow: stats.contextWindow
@@ -14822,7 +16246,10 @@ function apply(ctx, config) {
 		};
 		let app;
 		const tools = ctx.get("tools");
-		const present = toolPresenterFrom((name) => tools?.get(name, liveAgent.ctx));
+		const present = toolPresenterFrom((name) => {
+			if (liveAgent === void 0) return void 0;
+			return tools?.get(name, liveAgent);
+		});
 		const signal = new AbortController().signal;
 		let localShellController;
 		/** Run a `!` command locally; the output renders as a local card. */
@@ -14831,6 +16258,7 @@ function apply(ctx, config) {
 			const command = text.replace(/^!+/, "").trim();
 			if (command === "") return;
 			if (includeInContext) {
+				if (liveAgent === void 0) return;
 				liveAgent.followup(createUserMessage({
 					content: [{
 						type: "text",
@@ -14966,37 +16394,45 @@ function apply(ctx, config) {
 				folder: childFolder
 			};
 			repaint(app, childFolder);
-			app.notify(`viewing subagent ${label ?? childId} — Esc returns`);
+			app.notify(`viewing subagent ${label ?? childId} — Esc returns`, "info");
 		};
 		/** Leave the subagent viewer (single Esc). Returns whether it exited. */
 		const exitView = () => {
 			if (viewing === void 0) return false;
 			viewing = void 0;
 			app.clearLocalMessages();
+			app.clearNotify();
 			repaint(app, folder);
 			refreshStatus();
 			return true;
 		};
-		app = startProcessTui({
-			onSubmit: (text) => {
-				const history = app.getInputHistory();
-				if (history.length > 0) tuiSettings?.replace({
-					...tuiSettings.get(),
-					history: {
-						...tuiSettings.get().history,
-						[cwd]: history
-					}
-				});
-				if (text.startsWith("!")) {
-					runLocalShell(text);
+		/** Error sink for a failed session creation: restore the draft and
+		* surface the reason instead of silently dropping the submission. */
+		const failSubmission = (draft) => (error) => {
+			const message = error instanceof Error ? error.message : String(error);
+			ctx.logger.error(`tui-runner: session creation failed: ${message}`);
+			diag.error("session creation failed", { error: message });
+			app.setEditorText(draft);
+			app.notify(`could not start a session: ${message}`, "error");
+		};
+		/** The session-backed dispatch: create the session lazily (the first
+		* user input is the deferred trigger), guard against cross-process
+		* divergence, then execute a registered slash command or follow up. */
+		const dispatchViaSession = (text) => {
+			ensureSession().then(async () => {
+				const verdict = await guardSend();
+				if (verdict === "blocked") {
+					app.setEditorText(text);
+					app.notify(GUARD_BLOCKED_NOTIFY, "error");
 					return;
 				}
+				if (verdict === "forced") app.notify(GUARD_FORCED_NOTIFY, "error");
 				const commands = ctx.get("commands");
 				if (commands !== void 0) {
 					const parsed = parseCommand(text);
-					const toggled = parsed?.name === "plan" && parsed.rawInput.trim() === "" && foldPlanMode(liveAgent.session.events) ? "/plan off" : text;
+					const toggled = parsed?.name === "plan" && parsed.rawInput.trim() === "" && foldPlanMode(liveAgent?.session.events ?? []) ? "/plan off" : text;
 					commands.execute(liveAgent, toggled, signal).then((execution) => {
-						if (execution === void 0) liveAgent.followup(createUserMessage({
+						if (execution === void 0 && liveAgent !== void 0) liveAgent.followup(createUserMessage({
 							content: [{
 								type: "text",
 								text
@@ -15004,40 +16440,142 @@ function apply(ctx, config) {
 							source: { kind: "user" }
 						}));
 					}).catch((error) => {
-						ctx.logger.error(`tui-runner: command execution failed: ${error instanceof Error ? error.message : String(error)}`);
-						app.notify(error instanceof Error ? error.message : String(error));
+						const message = error instanceof Error ? error.message : String(error);
+						ctx.logger.error(`tui-runner: command execution failed: ${message}`);
+						diag.error("command execution failed", { error: message });
+						app.notify(message, "error");
 					});
 					return;
 				}
-				liveAgent.followup(createUserMessage({
+				liveAgent?.followup(createUserMessage({
 					content: [{
 						type: "text",
 						text
 					}],
 					source: { kind: "user" }
 				}));
+			}).catch(failSubmission(text));
+		};
+		/**
+		* Run a sessionless slash command locally — no session, no log, no
+		* persistence. The handler comes from the commands service's global
+		* layer (in-process lookup with no agent is safe: it reads the global
+		* layer only). A sessionless command that failed to register falls back
+		* to the session dispatch, which reports unknown commands as messages.
+		*/
+		const runLocalCommand = (parsed, text) => {
+			const commands = ctx.get("commands");
+			const definition = commands?.find(void 0, parsed.name);
+			if (commands === void 0 || definition === void 0) {
+				dispatchViaSession(text);
+				return;
+			}
+			const invocation = {
+				commandId: `cmd-local-${randomUUID()}`,
+				agent: void 0,
+				rawInput: parsed.rawInput,
+				signal
+			};
+			Promise.resolve(definition.handler(invocation)).then((result) => {
+				if (result !== void 0 && result.kind === "error") app.notify(result.text);
+			}).catch((error) => {
+				const message = error instanceof Error ? error.message : String(error);
+				ctx.logger.error(`tui-runner: local command failed: ${message}`);
+				diag.error("local command failed", { error: message });
+				app.notify(message, "error");
+			});
+		};
+		app = startProcessTui({
+			onSubmit: (text) => {
+				const history = app.getInputHistory();
+				if (history.length > 0) tuiSettings?.replace({
+					...tuiSettings.get(),
+					history: {
+						...tuiSettings.get().history,
+						[cwd]: history
+					}
+				});
+				if (text.startsWith("!")) {
+					if (text.startsWith("!!")) ensureSession().then(() => runLocalShell(text)).catch(failSubmission(text));
+					else runLocalShell(text);
+					return;
+				}
+				const parsed = parseCommand(text);
+				if (parsed !== void 0 && liveAgent === void 0 && SESSIONLESS_COMMANDS.has(parsed.name)) {
+					runLocalCommand(parsed, text);
+					return;
+				}
+				dispatchViaSession(text);
 			},
 			onExit: () => {
 				(async () => {
-					await sessions.flush(liveAgent.session);
+					if (liveAgent !== void 0) {
+						const started = Date.now();
+						try {
+							await sessions.flush(liveAgent.session);
+							diag.info("flush ok", {
+								session: liveAgent.session.id,
+								events: liveAgent.session.events.length,
+								tookMs: Date.now() - started
+							});
+						} catch (error) {
+							diag.error("flush failed", {
+								session: liveAgent.session.id,
+								error: error instanceof Error ? error.message : String(error)
+							});
+						}
+					}
+					diag.info("exit", { code: 0 });
+					diag.dispose();
 					app.stop();
+					const resume = resumeCommand(runningProfile(), liveAgent?.session.id ?? "");
+					if (resume !== void 0) process.stdout.write(`\n${color.textDim("To resume this session:")} ${resume}\n`);
 					exit(0);
 				})();
 			},
 			onCancel: () => {
 				localShellController?.abort();
-				liveAgent.cancel({ kind: "user" });
+				liveAgent?.cancel({ kind: "user" });
 			},
 			onSteer: (text) => {
-				const message = createUserMessage({
-					content: [{
-						type: "text",
-						text
-					}],
-					source: { kind: "user" }
-				});
-				if (liveAgent.status === "running") liveAgent.steer(message);
-				else liveAgent.followup(message);
+				if (liveAgent !== void 0) {
+					if ([...liveAgent.inbox.nextTurn, ...liveAgent.inbox.nextStep].length === 0 && text.trim() === "") return;
+				} else if (text.trim() === "") return;
+				ensureSession().then(async () => {
+					if (liveAgent === void 0) return;
+					const verdict = await guardSend();
+					if (verdict === "blocked") {
+						app.setEditorText(text);
+						app.notify(GUARD_BLOCKED_NOTIFY, "error");
+						return;
+					}
+					const forced = verdict === "forced";
+					if (forced) app.notify(GUARD_FORCED_NOTIFY, "error");
+					const queued = [...liveAgent.inbox.nextTurn, ...liveAgent.inbox.nextStep];
+					if (queued.length > 0) {
+						const draft = text.trim();
+						const messages = [...queued, ...draft === "" ? [] : [createUserMessage({
+							content: [{
+								type: "text",
+								text: draft
+							}],
+							source: { kind: "user" }
+						})]];
+						liveAgent.inbox.clear();
+						for (const message of messages) liveAgent.steer(message);
+						if (!forced) app.notify(messages.length === 1 ? "steering 1 message" : `steering ${messages.length} messages`, "info");
+					} else {
+						const message = createUserMessage({
+							content: [{
+								type: "text",
+								text
+							}],
+							source: { kind: "user" }
+						});
+						if (liveAgent.status === "running") liveAgent.steer(message);
+						else liveAgent.followup(message);
+					}
+				}).catch(failSubmission(text));
 			},
 			openExternalEditor: async (draft) => {
 				const editor = process.env.VISUAL ?? process.env.EDITOR ?? "vi";
@@ -15084,15 +16622,34 @@ function apply(ctx, config) {
 				searchCurrent = -1;
 				repaint(app, activeFolder());
 			},
-			onSingleEscape: () => exitView()
+			onSingleEscape: () => exitView(),
+			onCyclePermission: () => {
+				if (liveAgent === void 0) return;
+				const permission = ctx.get("permissionPresets");
+				if (permission === void 0) return;
+				const names = permission.names;
+				if (names.length === 0) return;
+				const current = permission.current(liveAgent.session.events);
+				const next = names[(names.indexOf(current) + 1) % names.length] ?? names[0];
+				if (next === void 0 || next === current) return;
+				permission.set(liveAgent.session, next);
+				app.notify(next === "danger-full-access" ? `⚠ ${next} — no approvals` : `permission: ${next}`, next === "danger-full-access" ? "error" : "info");
+				refreshStatus();
+			},
+			onDequeue: () => {
+				if (liveAgent === void 0) return;
+				const queued = [...liveAgent.inbox.nextTurn, ...liveAgent.inbox.nextStep];
+				if (queued.length === 0) return;
+				liveAgent.inbox.clear();
+				const queuedText = queued.map((message) => textOf(message.content)).join("\n\n");
+				const current = app.getDraft();
+				app.setDraft([queuedText, current].filter((part) => part.trim() !== "").join("\n\n"));
+				refreshQueue();
+			}
 		}, {
 			present,
 			workspaceRoot: cwd
 		});
-		paintNow();
-		setTerminalTitle(`dsh-pi-tui · ${shortCwd(cwd)} · ${liveAgent.session.id}`);
-		updateWelcomeCard();
-		if (resumeFailure !== void 0) app.notify(resumeFailure);
 		const tuiSettings = ctx.get("settings")?.register(settingsNamespace("dsh-pi-tui"), z.object({
 			theme: z.string(),
 			footer: z.string(),
@@ -15119,12 +16676,125 @@ function apply(ctx, config) {
 		if (tuiSettings?.get().fullscreen === "on") app.setFullscreen(true);
 		const storedHistory = tuiSettings?.get().history[cwd];
 		if (storedHistory !== void 0 && storedHistory.length > 0) app.seedInputHistory(storedHistory);
-		if (ctx.get("commands") !== void 0) registerTuiCommands({
+		refreshStatus();
+		const jobs = ctx.get("jobs");
+		if (jobs !== void 0) {
+			const refreshTasks = () => {
+				let tasks = [];
+				try {
+					tasks = jobs.list(liveAgent).filter((job) => job.status === "running" || job.status === "stopping").map((job) => ({
+						label: job.label,
+						status: job.status
+					}));
+				} catch {}
+				app.setTasks(tasks);
+			};
+			jobs.onJobsChanged(() => refreshTasks());
+			refreshTasks();
+		}
+		const refreshQueue = () => {
+			if (liveAgent === void 0) {
+				app.setQueueItems([]);
+				return;
+			}
+			const queue = [...liveAgent.inbox.nextTurn.map((message) => ({
+				id: message.id,
+				text: textOf(message.content),
+				mode: "followup"
+			})), ...liveAgent.inbox.nextStep.map((message) => ({
+				id: message.id,
+				text: textOf(message.content),
+				mode: "steer"
+			}))];
+			app.setQueueItems(queue);
+		};
+		refreshQueue();
+		/** Rebuild every live-session surface after resume, create, or swap. */
+		const initLiveSession = async (agent) => {
+			folder = new TranscriptFolder();
+			folder.apply(agent.session.events);
+			statsFolder = new StatsFolder();
+			statsFolder.apply(agent.session.events);
+			goalText = foldGoal(agent.session.events);
+			app.setWorking(workingFromLog(agent.session.events));
+			app.setSessionTitle(foldSessionTitle(agent.session.events)?.title);
+			app.clearLocalMessages();
+			app.clearNotify();
+			repaint(app, folder);
+			refreshStatus();
+			refreshQueue();
+			setTerminalTitle(`dsh-pi-tui · ${shortCwd(cwd)} · ${agent.session.id}`);
+			updateWelcomeCard();
+			registerCommands();
+			refreshSkillCommands();
+		};
+		/**
+		* Create the first session lazily — the FIRST user message triggers it
+		* (deferred session creation). Opening the TUI with no --session carries
+		* zero session side-effects: no agent, no log, no persistence.
+		*/
+		let creating;
+		const ensureSession = async () => {
+			if (liveAgent !== void 0) return;
+			if (creating !== void 0) return creating;
+			creating = (async () => {
+				const launched = await launchComposition();
+				if (launched.failure !== void 0) resumeFailure = launched.failure;
+				try {
+					const created = await agents.create({
+						sessionId: SessionId(`session-${randomUUID()}`),
+						meta: {
+							cwd: process.cwd(),
+							...withPresetMeta(launched.composition)
+						},
+						agentOptions,
+						setup: launched.composition.setup
+					});
+					liveHandle = created;
+					liveAgent = created.agent;
+					await liveAgent.whenIdle();
+					await initLiveSession(liveAgent);
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					ctx.logger.warn(`tui-runner: failed to start with preset "${launchPreset ?? "default"}": ${message}`);
+					diag.warn("preset mount failed", {
+						preset: launchPreset ?? "default",
+						error: message
+					});
+					resumeFailure = `failed to start with preset "${launchPreset ?? "default"}": ${message}`;
+					const fallback = await compose();
+					const created = await agents.create({
+						sessionId: SessionId(`session-${randomUUID()}`),
+						meta: {
+							cwd: process.cwd(),
+							...withPresetMeta(fallback)
+						},
+						agentOptions,
+						setup: fallback.setup
+					});
+					liveHandle = created;
+					liveAgent = created.agent;
+					await liveAgent.whenIdle();
+					await initLiveSession(liveAgent);
+				}
+				if (resumeFailure !== void 0) {
+					app.notify(resumeFailure, "error");
+					resumeFailure = void 0;
+				}
+			})().finally(() => {
+				creating = void 0;
+			});
+			return creating;
+		};
+		let commandsRegistered = false;
+		let refreshSkills;
+		const runner = {
 			ctx,
 			app,
 			get liveAgent() {
 				return liveAgent;
 			},
+			ensureSession,
 			get selected() {
 				return selected;
 			},
@@ -15144,9 +16814,43 @@ function apply(ctx, config) {
 			updateWelcomeCard,
 			enterView,
 			exit
-		});
-		refreshStatus();
+		};
+		const registerCommands = () => {
+			if (commandsRegistered) return;
+			if (ctx.get("commands") === void 0) return;
+			commandsRegistered = true;
+			try {
+				refreshSkills = registerTuiCommands(runner).refreshSkills;
+			} catch (error) {
+				commandsRegistered = false;
+				const message = error instanceof Error ? error.message : String(error);
+				ctx.logger.error(`tui-runner: command registration failed: ${message}`);
+				diag.error("command registration failed", { error: message });
+				app.notify(`command registration failed: ${message}`, "error");
+			}
+		};
+		/** Rebuild the agent-scoped per-skill commands after a session exists. */
+		const refreshSkillCommands = () => {
+			if (refreshSkills === void 0) return;
+			refreshSkills().catch((error) => {
+				const message = error instanceof Error ? error.message : String(error);
+				ctx.logger.warn(`tui-runner: skill command refresh failed: ${message}`);
+				diag.warn("skill command refresh failed", { error: message });
+			});
+		};
+		if (liveAgent !== void 0) await initLiveSession(liveAgent);
+		else {
+			app.setWelcomeIdle(true);
+			refreshStatus();
+			setTerminalTitle(`dsh-pi-tui · ${shortCwd(cwd)}`);
+		}
+		registerCommands();
+		if (resumeFailure !== void 0) {
+			app.notify(resumeFailure, "error");
+			resumeFailure = void 0;
+		}
 		ctx.on("session/event", (session, event) => {
+			if (liveAgent === void 0) return;
 			if (viewing !== void 0) {
 				if (session.id !== viewing.id) return;
 				viewing.folder.apply([event]);
@@ -15160,10 +16864,13 @@ function apply(ctx, config) {
 			folder.apply([event]);
 			statsFolder.apply([event]);
 			if (event.type === "goal/change") goalText = foldGoal([event]);
-			schedulePaint();
+			const isKnob = event.type === "permission/preset" || event.type === "approval/policy" || event.type === "sandbox/mode";
+			if (!isKnob) schedulePaint();
 			if (event.type === "todo/write") app.setTodoSummary(event.data.todos);
 			if (event.type === "plan/mode") app.setPlanMode(event.data.active);
 			if (event.type === "session/title") app.setSessionTitle(foldSessionTitle([event])?.title);
+			if (isKnob) refreshStatus();
+			if (event.type === "agent/inbox/spliced") queueMicrotask(refreshQueue);
 			if (event.type === "turn/start") app.setWorking(true);
 			else if (event.type === "turn/end") {
 				app.setWorking(false);
@@ -15172,14 +16879,16 @@ function apply(ctx, config) {
 				sessions.flush(liveAgent.session);
 			} else if (event.type === "step/start") refreshStatus();
 		});
-		app.setPlanMode(foldPlanMode(liveAgent.session.events));
-		app.setWorking(workingFromLog(liveAgent.session.events));
-		app.setSessionTitle(foldSessionTitle(liveAgent.session.events)?.title);
-		for (let index = liveAgent.session.events.length - 1; index >= 0; index -= 1) {
-			const event = liveAgent.session.events[index];
-			if (event.type === "todo/write") {
-				app.setTodoSummary(event.data.todos);
-				break;
+		if (liveAgent !== void 0) {
+			app.setPlanMode(foldPlanMode(liveAgent.session.events));
+			app.setWorking(workingFromLog(liveAgent.session.events));
+			app.setSessionTitle(foldSessionTitle(liveAgent.session.events)?.title);
+			for (let index = liveAgent.session.events.length - 1; index >= 0; index -= 1) {
+				const event = liveAgent.session.events[index];
+				if (event.type === "todo/write") {
+					app.setTodoSummary(event.data.todos);
+					break;
+				}
 			}
 		}
 		ctx.on("approval/request", (req, next) => {
@@ -15199,8 +16908,10 @@ function apply(ctx, config) {
 				id: question.id,
 				question: question.question,
 				...question.header !== void 0 ? { header: question.header } : {},
+				...question.detail !== void 0 ? { detail: question.detail } : {},
 				...question.options !== void 0 ? { options: question.options } : {},
-				...question.multiSelect !== void 0 ? { multiSelect: question.multiSelect } : {}
+				...question.multiSelect !== void 0 ? { multiSelect: question.multiSelect } : {},
+				...question.intent !== void 0 ? { intent: question.intent } : {}
 			})), request.signal)).map((answer) => ({
 				id: answer.id,
 				selected: answer.selected,
@@ -15208,9 +16919,12 @@ function apply(ctx, config) {
 			})) };
 		} });
 	})().catch((error) => {
-		ctx.logger.error(`tui-runner: ${error instanceof Error ? error.message : String(error)}`);
+		const message = error instanceof Error ? error.message : String(error);
+		ctx.logger.error(`tui-runner: ${message}`);
+		diag.error("fatal", { error: message });
+		diag.dispose();
 		exit(1);
 	});
 }
 //#endregion
-export { Config, apply, composeAgent, dangerCommand, forkSeed, inject, name, recomposeBlank, recordedPreset };
+export { Config, apply, composeAgent, dangerCommand, forkSeed, inject, name, recomposeBlank, recordedPreset, resumeCommand, runningProfile };