dsh-code 0.1.0 → 0.3.0

package/lib/index.mjs

@@ -1,12 +1,17 @@
 import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { basename, join } from "node:path";
-import { createElement, useState, useSyncExternalStore } from "react";
+import { createElement, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import z from "@deepseek-ai/schemastery";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { assertNever, boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { SessionId } from "@deepseek-ai/dsh-session";
-import { Box, Text, render, useInput } from "ink";
+import { Box, Text, render, useInput, useStdout } from "ink";
 import chalk from "chalk";
+import { readdir } from "node:fs/promises";
+import { formatSessionReferenceMention, parseSessionReferenceText } from "@deepseek-ai/dsh-session-reference";
+import { UserQuestionError } from "@deepseek-ai/dsh-user-questions";
+import { isUserInvocable } from "@deepseek-ai/dsh-skill";
 //#region src/theme.ts
 /**
 * Terminal color tokens for the dsh TUI, mapped from the product design
@@ -62,6 +67,18 @@ const TUI_RGB = {
 		245,
 		158,
 		11
+	],
+	/** Default foreground text — `--dsw-static-neutral-50`. */
+	text: [
+		236,
+		240,
+		246
+	],
+	/** Inline/fenced code — soft sky blue, distinct from brand accents. */
+	code: [
+		125,
+		211,
+		252
 	]
 };
 /** Paint with the primary brand blue: whale, wordmark, tool names, accents. */
@@ -76,6 +93,10 @@ function dim(text) {
 function error(text) {
 	return chalk.rgb(...TUI_RGB.error)(text);
 }
+/** Paint warnings. */
+function warn(text) {
+	return chalk.rgb(...TUI_RGB.warn)(text);
+}
 //#endregion
 //#region src/whale-glyph.ts
 /** Half-block whale glyph rows; render with the brand color. */
@@ -90,6 +111,258 @@ const WHALE_GLYPH = [
 	"     ▀▀███████▀▀ ▀▀▀      "
 ];
 //#endregion
+//#region src/render/markdown.ts
+/** Plain segment helper. */
+function seg(text, style = "plain") {
+	return {
+		text,
+		style
+	};
+}
+/** Visible width of a run in columns (CJK counts double). */
+function visibleColumns(text) {
+	let columns = 0;
+	for (const char of text) {
+		const code = char.codePointAt(0) ?? 0;
+		columns += code > 11903 ? 2 : 1;
+	}
+	return columns;
+}
+/** Walk a segment list, breaking it into lines that fit `width` columns. */
+function wrapSegments(segments, width) {
+	const lines = [];
+	let current = [];
+	let used = 0;
+	for (const segment of segments) {
+		const words = segment.text.split(/( )/u);
+		for (const word of words) {
+			if (word === "") continue;
+			const columns = visibleColumns(word);
+			if (used + columns > width && used > 0) {
+				lines.push(current);
+				current = [];
+				used = 0;
+			}
+			current.push({
+				text: word,
+				style: segment.style
+			});
+			used += columns;
+		}
+	}
+	if (current.length > 0) lines.push(current);
+	return lines.map((line) => {
+		const last = line[line.length - 1];
+		if (last !== void 0 && last.text === " " && line.length > 1) return line.slice(0, -1);
+		return line;
+	});
+}
+/** Join adjacent same-style runs so the app renders fewer elements. */
+function merge(segments) {
+	const merged = [];
+	for (const segment of segments) {
+		const last = merged[merged.length - 1];
+		if (last !== void 0 && last.style === segment.style) merged[merged.length - 1] = {
+			text: last.text + segment.text,
+			style: last.style
+		};
+		else merged.push({ ...segment });
+	}
+	return merged;
+}
+/**
+* Parse inline markdown in one line of text. Link destinations render as a
+* dim `(url)` suffix — the visible text keeps the accent.
+*/
+function parseInline(text) {
+	const runs = [];
+	let rest = text;
+	while (rest !== "") {
+		const code = /^`([^`]+)`/u.exec(rest);
+		if (code !== null) {
+			runs.push({
+				text: code[1] ?? "",
+				style: "code"
+			});
+			rest = rest.slice(code[0].length);
+			continue;
+		}
+		const boldItalic = /^\*\*\*([^*]+)\*\*\*/u.exec(rest);
+		if (boldItalic !== null) {
+			runs.push({
+				text: boldItalic[1] ?? "",
+				style: "boldItalic"
+			});
+			rest = rest.slice(boldItalic[0].length);
+			continue;
+		}
+		const bold = /^\*\*([^*]+)\*\*/u.exec(rest);
+		if (bold !== null) {
+			runs.push({
+				text: bold[1] ?? "",
+				style: "bold"
+			});
+			rest = rest.slice(bold[0].length);
+			continue;
+		}
+		const italic = /^\*([^*]+)\*/u.exec(rest) ?? /^_([^_]+)_/u.exec(rest);
+		if (italic !== null) {
+			runs.push({
+				text: italic[1] ?? "",
+				style: "italic"
+			});
+			rest = rest.slice(italic[0].length);
+			continue;
+		}
+		const strike = /^~~([^~]+)~~/u.exec(rest);
+		if (strike !== null) {
+			runs.push({
+				text: strike[1] ?? "",
+				style: "strike"
+			});
+			rest = rest.slice(strike[0].length);
+			continue;
+		}
+		const link = /^\[([^\]]+)\]\(([^)\s]+)\)/u.exec(rest);
+		if (link !== null) {
+			const label = link[1] ?? "";
+			const url = link[2] ?? "";
+			runs.push({
+				text: label,
+				style: "accent"
+			});
+			runs.push({
+				text: ` (${url})`,
+				style: "dim"
+			});
+			rest = rest.slice(link[0].length);
+			continue;
+		}
+		const next = rest.search(/[*_`~[]/u);
+		if (next === -1) {
+			runs.push({
+				text: rest,
+				style: "plain"
+			});
+			break;
+		}
+		if (next > 0) {
+			runs.push({
+				text: rest.slice(0, next),
+				style: "plain"
+			});
+			rest = rest.slice(next);
+			continue;
+		}
+		runs.push({
+			text: rest.slice(0, 1),
+			style: "plain"
+		});
+		rest = rest.slice(1);
+	}
+	return runs;
+}
+const HEADING = /^(#{1,6})\s+(.*)$/u;
+const FENCE = /^```([^\s`]*)\s*$/u;
+const RULE = /^(?:---|\*\*\*|___)\s*$/u;
+const QUOTE = /^>\s?(.*)$/u;
+const UNORDERED = /^\s*[-*+]\s+(.*)$/u;
+const ORDERED = /^\s*(\d+)[.)]\s+(.*)$/u;
+/** Render markdown text into styled lines of at most `width` columns. */
+function renderMarkdown(text, width) {
+	const lines = [];
+	const push = (segments) => {
+		for (const wrapped of wrapSegments(segments, Math.max(10, width))) lines.push({ segments: merge(wrapped) });
+	};
+	const source = text.replaceAll("\r", "").split("\n");
+	let index = 0;
+	while (index < source.length) {
+		const line = source[index] ?? "";
+		index += 1;
+		const fence = FENCE.exec(line);
+		if (fence !== null) {
+			const language = fence[1] ?? "";
+			if (language !== "") push([seg(`  ${language}`, "dim")]);
+			while (index < source.length && !FENCE.test(source[index] ?? "")) {
+				push([seg(`  ${source[index] ?? ""}`, "code")]);
+				index += 1;
+			}
+			index += 1;
+			continue;
+		}
+		if (line.trim() === "") continue;
+		if (RULE.test(line.trim())) {
+			push([seg(`  ${"─".repeat(Math.max(1, Math.floor(width / 4)))}`, "dim")]);
+			continue;
+		}
+		const heading = HEADING.exec(line);
+		if (heading !== null) {
+			push([seg(heading[2] ?? "", "accent")]);
+			continue;
+		}
+		const quote = QUOTE.exec(line);
+		if (quote !== null) {
+			push([seg("  │ ", "accent"), ...parseInline(quote[1] ?? "").map((run) => seg(run.text, run.style === "plain" ? "dim" : run.style))]);
+			continue;
+		}
+		const ordered = ORDERED.exec(line);
+		if (ordered !== null) {
+			push([seg(`  ${ordered[1] ?? ""}. `, "accent"), ...parseInline(ordered[2] ?? "").map((run) => seg(run.text, run.style))]);
+			continue;
+		}
+		const unordered = UNORDERED.exec(line);
+		if (unordered !== null) {
+			push([seg("  • ", "accent"), ...parseInline(unordered[1] ?? "").map((run) => seg(run.text, run.style))]);
+			continue;
+		}
+		const paragraph = [line];
+		while (index < source.length && (source[index] ?? "").trim() !== "") {
+			paragraph.push(source[index] ?? "");
+			index += 1;
+		}
+		const runs = [];
+		for (let at = 0; at < paragraph.length; at += 1) {
+			if (at > 0) runs.push({
+				text: " ",
+				style: "plain"
+			});
+			runs.push(...parseInline(paragraph[at] ?? ""));
+		}
+		push(runs.map((run) => seg(run.text, run.style)));
+	}
+	return lines;
+}
+//#endregion
+//#region src/render/animations.ts
+/**
+* Terminal animation frame tables derived from the web design language:
+* the StateDot "ongoing" pixel chase (3×3 ring, 125ms flat-hold brightness
+* steps, 1s cycle) becomes the single-cell stepped pulse below, and the
+* streaming caret blink is the Claude-Code convention. Pure functions only —
+* the Ink layer owns timers and colors.
+*
+* @module @deepseek-ai/dsh-code/render/animations
+*/
+/** Single-cell stepped pulse: flat holds mirroring the web's 125ms keyframes. */
+const PULSE_FRAMES = [
+	"█",
+	"█",
+	"▆",
+	"▃",
+	"▁",
+	"▃",
+	"▆",
+	"█"
+];
+/** Pulse frame for a monotonic tick. */
+function pulseFrame(tick) {
+	return PULSE_FRAMES[tick % PULSE_FRAMES.length] ?? PULSE_FRAMES[0];
+}
+/** Caret visibility: half the ticks on, half off (530ms blink). */
+function caretVisible(tick) {
+	return tick % 2 === 0;
+}
+//#endregion
 //#region src/render/status.ts
 /**
 * Compact token count: 517 / 12.2K / 517K / 1.2M (one decimal under three
@@ -133,7 +406,8 @@ function buildStatusGroups(facts, stats) {
 	const identity = [
 		facts.model,
 		facts.cwd,
-		facts.branch === "" ? void 0 : `⑂ ${facts.branch}`
+		facts.branch === "" ? void 0 : `⑂ ${facts.branch}`,
+		facts.plan ? "⧉ plan" : void 0
 	].filter((part) => part !== void 0 && part !== "");
 	if (identity.length > 0) groups.push(identity.join(" · "));
 	if (stats.turns > 0 || stats.steps > 0) {
@@ -149,42 +423,199 @@ function buildStatusGroups(facts, stats) {
 		groups.push(`↑${formatTokens(stats.usage.inputTokens)} ↓${formatTokens(stats.usage.outputTokens)}`);
 	}
 	if (facts.sessionId !== "") groups.push(facts.sessionId);
+	if (facts.permission !== void 0 && facts.permission !== "") groups.push(facts.permission);
 	return groups;
 }
 //#endregion
+//#region src/render/text.ts
+/**
+* Display-boundary sanitization for externally sourced text (model output,
+* tool payloads, skill descriptions). Control characters — including ANSI
+* CSI/OSC escape sequences — would otherwise pass through Ink into the
+* terminal, letting output rewrite the screen or inject prompts. Newlines
+* and tabs survive; everything else in C0/C1 plus DEL becomes a visible
+* `\xNN` escape.
+*
+* @module @deepseek-ai/dsh-code/render/text
+*/
+/** C0 controls except tab (0x09) and newline (0x0a), plus DEL and C1. */
+const CONTROL_ESCAPE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu;
+/**
+* Escape control characters so externally sourced text cannot drive the
+* terminal.
+* @param text - raw text from a session event, tool payload, or catalog.
+* @returns text with every control character (except `\n`, `\t`) rendered
+* as a literal `\xNN` escape.
+*/
+function displayText(text) {
+	return text.replace(CONTROL_ESCAPE, (char) => `\\x${char.charCodeAt(0).toString(16).padStart(2, "0")}`);
+}
+//#endregion
 //#region src/app.ts
 /**
 * The Ink terminal app: whale-and-wordmark header in DeepSeek blue, the live
-* transcript, the streaming line, local notices, and the input box. All state
-* arrives through the transcript store (derived from the durable session log)
-* plus local input state; the app owns no session mutation of its own.
+* transcript, the todo panel, the streaming line, the approval bar, the model
+* panel, local notices, and the input box with history and slash-command
+* completion. All state arrives through the transcript store (derived from
+* the durable session log) plus local input state; the app owns no session
+* mutation of its own.
 *
 * Element construction uses `createElement` (not JSX): the `dsh` source launch
 * compiles this file through tsx's ESM-only hook, which does not adopt this
 * package's `jsx: react-jsx` compiler option, and the classic JSX runtime
 * would demand a React global.
 *
-* @module @deepseek-ai/dsh-tui/app
+* @module @deepseek-ai/dsh-code/app
 */
 /** Ink `color` string for one palette triple. */
 function inkColor(triple) {
 	return `rgb(${triple[0]}, ${triple[1]}, ${triple[2]})`;
 }
+/** Truncate text to a visible-column budget, appending … when cut. */
+function truncateColumns(text, max) {
+	let columns = 0;
+	let out = "";
+	for (const char of text) {
+		const width = (char.codePointAt(0) ?? 0) > 11903 ? 2 : 1;
+		if (columns + width > max) return `${out}…`;
+		out += char;
+		columns += width;
+	}
+	return out;
+}
+/** Pad text with spaces to a visible-column target (menu name column). */
+function padColumns(text, width) {
+	return text + " ".repeat(Math.max(0, width - visibleColumns(text)));
+}
+/** Interval-driven frame counter for one self-contained animated leaf. */
+function useFrames(intervalMs) {
+	const [tick, setTick] = useState(0);
+	useEffect(() => {
+		const id = setInterval(() => setTick((current) => current + 1), intervalMs);
+		return () => {
+			clearInterval(id);
+		};
+	}, [intervalMs]);
+	return tick;
+}
+/** Single-cell stepped pulse: the web's 125ms flat-hold brightness steps over 1s. */
+function Pulse() {
+	const tick = useFrames(125);
+	return createElement(Text, { color: inkColor(TUI_RGB.brandBright) }, pulseFrame(tick));
+}
+/** Blinking block caret appended to streaming text. */
+function Caret() {
+	const tick = useFrames(530);
+	return createElement(Text, null, caretVisible(tick) ? "▍" : " ");
+}
+/** Blinking input cursor: inverse block while the caret phase is on. */
+function CursorBlock({ char }) {
+	const tick = useFrames(530);
+	return createElement(Text, { inverse: caretVisible(tick) || void 0 }, char);
+}
+/** Ink props for one markdown style class. */
+function segmentProps(style) {
+	switch (style) {
+		case "accent": return {
+			color: inkColor(TUI_RGB.brandBright),
+			bold: void 0,
+			italic: void 0,
+			strikethrough: void 0
+		};
+		case "code": return {
+			color: inkColor(TUI_RGB.code),
+			bold: void 0,
+			italic: void 0,
+			strikethrough: void 0
+		};
+		case "dim": return {
+			color: inkColor(TUI_RGB.dim),
+			bold: void 0,
+			italic: void 0,
+			strikethrough: void 0
+		};
+		case "bold": return {
+			color: void 0,
+			bold: true,
+			italic: void 0,
+			strikethrough: void 0
+		};
+		case "italic": return {
+			color: void 0,
+			bold: void 0,
+			italic: true,
+			strikethrough: void 0
+		};
+		case "boldItalic": return {
+			color: void 0,
+			bold: true,
+			italic: true,
+			strikethrough: void 0
+		};
+		case "strike": return {
+			color: inkColor(TUI_RGB.dim),
+			bold: void 0,
+			italic: void 0,
+			strikethrough: true
+		};
+		default: return {
+			color: void 0,
+			bold: void 0,
+			italic: void 0,
+			strikethrough: void 0
+		};
+	}
+}
+/** One settled markdown document rendered as styled lines at the terminal width. */
+function MarkdownBody({ text }) {
+	const columns = useStdout().stdout?.columns ?? 80;
+	const lines = useMemo(() => renderMarkdown(displayText(text), Math.max(20, columns - 2)), [text, columns]);
+	return createElement(Box, { flexDirection: "column" }, ...lines.map((line, index) => createElement(Text, { key: index }, ...line.segments.map((segment, at) => createElement(Text, {
+		key: at,
+		...segmentProps(segment.style)
+	}, segment.text)))));
+}
 /** One settled transcript row. */
-function EntryLine({ entry }) {
+function EntryLine({ entry, showReasoning }) {
 	switch (entry.kind) {
-		case "user": return createElement(Text, null, brand("❯ "), entry.text);
-		case "assistant": return createElement(Text, null, entry.text);
+		case "user": return entry.notice ? createElement(Text, { dimColor: true }, `⤷ ${displayText(entry.text)}`) : createElement(Text, null, brand("❯ "), displayText(entry.text));
+		case "assistant": return createElement(Box, { flexDirection: "column" }, entry.reasoning === "" ? void 0 : showReasoning ? createElement(Text, {
+			dimColor: true,
+			italic: true
+		}, `  ✻ ${displayText(entry.reasoning)}`) : createElement(Text, { dimColor: true }, `  ✻ Thinking (${entry.reasoning.length} chars, Ctrl+R to expand)`), createElement(MarkdownBody, { text: entry.text }));
 		case "tool": {
-			const mark = entry.state === "running" ? createElement(Text, { color: inkColor(TUI_RGB.brandBright) }, "◐") : entry.state === "error" ? createElement(Text, { color: inkColor(TUI_RGB.error) }, "⨯") : createElement(Text, { color: inkColor(TUI_RGB.success) }, "⏺");
-			return createElement(Text, null, mark, " ", brand(entry.name), entry.summary === "" ? "" : ` ${dim(entry.summary)}`);
+			const mark = entry.state === "running" ? createElement(Pulse) : entry.state === "error" ? createElement(Text, { color: inkColor(TUI_RGB.error) }, "⨯") : createElement(Text, { color: inkColor(TUI_RGB.success) }, "⏺");
+			return createElement(Box, { flexDirection: "column" }, createElement(Text, null, mark, " ", brand(entry.name), entry.preview === "" ? "" : ` ${dim(displayText(entry.preview))}`), entry.summary === "" ? void 0 : createElement(Text, { color: entry.state === "error" ? inkColor(TUI_RGB.error) : inkColor(TUI_RGB.dim) }, `  ⎿ ${displayText(entry.summary)}`));
+		}
+		case "command": {
+			const mark = entry.state === "running" ? createElement(Pulse) : entry.state === "error" ? createElement(Text, { color: inkColor(TUI_RGB.error) }, "⨯") : createElement(Text, { color: inkColor(TUI_RGB.success) }, "⏺");
+			return createElement(Box, { flexDirection: "column" }, createElement(Text, null, mark, " ", brand(`/${entry.name}`), entry.args === "" ? "" : ` ${dim(displayText(entry.args))}`), entry.summary === "" ? void 0 : createElement(Text, { color: inkColor(TUI_RGB.dim) }, `  ⎿ ${displayText(entry.summary)}`));
 		}
-		case "error": return createElement(Text, null, error(entry.text));
+		case "error": return createElement(Text, null, error(displayText(entry.text)));
 		default: return assertNever(entry, "transcript entry kind");
 	}
 }
-/** The whale wordmark header in DeepSeek blue, hugging its content width. */
-function Header() {
+/**
+* The whale wordmark header in DeepSeek blue, hugging its content width.
+* The 8-row half-block glyph pairs adjacent lines, so on a terminal too
+* short to show it whole (or mid-resize) the clipped pairs garble the
+* screen — below the height floor the header collapses to a single-line
+* wordmark that stays correct at any size.
+*/
+function Header({ resumed }) {
+	const rows = useStdout().stdout?.rows ?? 40;
+	const hint = resumed ? "resumed session · /help commands · Esc interrupt" : "/help commands · Esc interrupt · Ctrl+C quit";
+	if (rows < 20) return createElement(Box, {
+		flexDirection: "row",
+		gap: 1,
+		borderStyle: "round",
+		borderColor: inkColor(TUI_RGB.brand),
+		paddingX: 1,
+		alignSelf: "flex-start"
+	}, createElement(Text, {
+		color: inkColor(TUI_RGB.brand),
+		bold: true
+	}, "DeepSeek Harness"), createElement(Text, { dimColor: true }, hint));
 	return createElement(Box, {
 		flexDirection: "row",
 		gap: 1,
@@ -204,7 +635,33 @@ function Header() {
 	}, createElement(Text, {
 		color: inkColor(TUI_RGB.brand),
 		bold: true
-	}, "DeepSeek Harness"), createElement(Text, { dimColor: true }, "/help commands · Ctrl+C quit")));
+	}, "DeepSeek Harness"), createElement(Text, { dimColor: true }, hint)));
+}
+/** Todo status glyph: web TodoPanel's three-state marker. */
+function todoMark(status) {
+	return status === "completed" ? "✓" : status === "in_progress" ? "●" : "○";
+}
+/** Inline todo list (web TodoPanel's compact terminal form). */
+function TodoPanel({ todos }) {
+	if (todos.length === 0) return void 0;
+	const completed = todos.filter((todo) => todo.status === "completed").length;
+	const inProgress = todos.filter((todo) => todo.status === "in_progress").length;
+	const pending = todos.length - completed - inProgress;
+	return createElement(Box, {
+		flexDirection: "column",
+		paddingX: 1,
+		borderStyle: "round",
+		borderColor: inkColor(TUI_RGB.brandDeep),
+		alignSelf: "flex-start",
+		marginLeft: 1,
+		marginTop: 1
+	}, createElement(Text, {
+		color: inkColor(TUI_RGB.brand),
+		bold: true
+	}, `todos ${completed}/${todos.length}`, createElement(Text, { dimColor: true }, ` · ${inProgress} active · ${pending} pending`)), ...todos.map((todo, index) => createElement(Text, {
+		key: index,
+		color: todo.status === "completed" ? inkColor(TUI_RGB.success) : todo.status === "in_progress" ? inkColor(TUI_RGB.brandBright) : inkColor(TUI_RGB.dim)
+	}, `${todoMark(todo.status)} ${displayText(todo.content)}`)));
 }
 /**
 * The footer status line: Claude-Code-style identity facts (model, working
@@ -214,80 +671,753 @@ function Header() {
 */
 function StatusLine({ facts, stats, busy }) {
 	const groups = buildStatusGroups(facts, stats);
-	const children = [busy ? createElement(Text, { color: inkColor(TUI_RGB.brandBright) }, "● ") : createElement(Text, { color: inkColor(TUI_RGB.brand) }, "○ ")];
+	const children = [busy ? createElement(Pulse) : createElement(Text, { color: inkColor(TUI_RGB.brand) }, "○"), createElement(Text, null, " ")];
 	groups.forEach((group, index) => {
 		if (index > 0) children.push(createElement(Text, { dimColor: true }, dim(" | ")));
 		children.push(createElement(Text, { dimColor: true }, group));
 	});
-	return createElement(Box, { paddingX: 1 }, ...children);
+	return createElement(Box, {
+		paddingX: 1,
+		marginTop: 1
+	}, ...children);
+}
+/** The y/n approval bar rendered while an approval ask is pending. */
+function ApprovalBar({ approval, locked }) {
+	const snapshot = useSyncExternalStore(approval.subscribe, approval.getSnapshot);
+	useInput((input) => {
+		if (locked || snapshot.pending === void 0 || snapshot.answered) return;
+		if (input === "y" || input === "Y") {
+			snapshot.pending.answer("allowed-once");
+			return;
+		}
+		if (input === "n" || input === "N") snapshot.pending.answer("rejected");
+	});
+	if (snapshot.pending === void 0) return void 0;
+	const { pending, answered } = snapshot;
+	return createElement(Box, {
+		flexDirection: "column",
+		paddingX: 1,
+		borderStyle: "round",
+		borderColor: inkColor(TUI_RGB.warn),
+		alignSelf: "flex-start",
+		marginLeft: 1,
+		marginTop: 1
+	}, createElement(Text, {
+		color: inkColor(TUI_RGB.warn),
+		bold: true
+	}, "⏸ waiting for approval"), createElement(Text, null, warn(displayText(pending.headline))), pending.command === "" ? void 0 : createElement(Text, { dimColor: true }, dim(`  ${displayText(pending.command)}`)), answered ? createElement(Text, { dimColor: true }, "  submitted…") : createElement(Text, { dimColor: true }, dim("  y allow once · n reject")));
 }
-/** The prompt box: slash commands handled locally, other text submitted. */
-function Input({ busy, onSubmit, onQuit }) {
+/**
+* The ask_user_question bar: walks one request question by question,
+* renders the option menu (Claude-Code style: arrows move, space toggles a
+* multi-select, enter submits, `c` opens the custom-answer box, Esc
+* interrupts the question as aborted). Plan reviews arrive through the same
+* service with a `plan-review` intent — the approve option gets a ✓ mark,
+* the answer encoding stays identical.
+*/
+function QuestionBar({ store, locked }) {
+	const pending = useSyncExternalStore(store.subscribe, store.getSnapshot).pending;
+	const [index, setIndex] = useState(0);
+	const [cursor, setCursor] = useState(0);
+	const [selected, setSelected] = useState([]);
+	const [mode, setMode] = useState("options");
+	const [custom, setCustom] = useState("");
+	const [answers, setAnswers] = useState([]);
+	const [submitted, setSubmitted] = useState(false);
+	useEffect(() => {
+		const question = pending?.request.questions[0];
+		setIndex(0);
+		setCursor(0);
+		setSelected([]);
+		setMode(question?.options === void 0 || question.options.length === 0 ? "custom" : "options");
+		setCustom("");
+		setAnswers([]);
+		setSubmitted(false);
+	}, [pending]);
+	const question = pending?.request.questions[index];
+	const options = question?.options ?? [];
+	const isPlan = question?.intent?.kind === "plan-review";
+	const isMulti = question?.multiSelect === true;
+	const commit = (answer) => {
+		if (pending === void 0) return;
+		const next = [...answers, answer];
+		const total = pending.request.questions.length;
+		if (index + 1 >= total) {
+			setSubmitted(true);
+			store.submit(pending, { answers: next });
+			return;
+		}
+		setAnswers(next);
+		setIndex(index + 1);
+		setCursor(0);
+		setSelected([]);
+		setMode("options");
+		setCustom("");
+	};
+	const commitOption = () => {
+		if (pending === void 0 || question === void 0) return;
+		if (isMulti) {
+			const labels = selected.map((at) => options[at]?.label).filter((label) => label !== void 0);
+			const customText = custom.trim();
+			commit({
+				id: question.id,
+				selected: labels,
+				...customText === "" ? {} : { custom: customText }
+			});
+			return;
+		}
+		const option = options[cursor];
+		if (option === void 0) return;
+		commit({
+			id: question.id,
+			selected: [option.label]
+		});
+	};
+	useInput((input, key) => {
+		if (locked || pending === void 0 || question === void 0 || submitted) return;
+		if (key.escape) {
+			store.cancel(pending);
+			return;
+		}
+		if (mode === "custom" || options.length === 0) {
+			if (key.return) {
+				if (custom.trim() === "" && options.length > 0) {
+					commitOption();
+					return;
+				}
+				commit({
+					id: question.id,
+					selected: isMulti ? selected.map((at) => options[at]?.label).filter((label) => label !== void 0) : [],
+					...custom.trim() === "" ? {} : { custom: custom.trim() }
+				});
+				return;
+			}
+			if (key.backspace) {
+				setCustom((current) => current.slice(0, -1));
+				return;
+			}
+			if (input !== "" && !key.ctrl && !key.meta) setCustom((current) => current + input);
+			return;
+		}
+		if (key.upArrow) {
+			setCursor((current) => (current + options.length - 1) % options.length);
+			return;
+		}
+		if (key.downArrow) {
+			setCursor((current) => (current + 1) % options.length);
+			return;
+		}
+		if (key.return) {
+			commitOption();
+			return;
+		}
+		if (key.tab || input === "c" || input === "C") {
+			setMode("custom");
+			return;
+		}
+		if (input === " " && isMulti) setSelected((current) => current.includes(cursor) ? current.filter((at) => at !== cursor) : [...current, cursor]);
+	});
+	if (pending === void 0 || question === void 0) return void 0;
+	return createElement(Box, {
+		flexDirection: "column",
+		paddingX: 1,
+		borderStyle: "round",
+		borderColor: inkColor(isPlan ? TUI_RGB.brand : TUI_RGB.brandDeep),
+		alignSelf: "flex-start",
+		marginLeft: 1,
+		marginTop: 1
+	}, createElement(Text, {
+		color: inkColor(isPlan ? TUI_RGB.brand : TUI_RGB.brandDeep),
+		bold: true
+	}, isPlan ? `📋 plan review (${index + 1}/${pending.request.questions.length})` : `❓ question ${index + 1}/${pending.request.questions.length}`), question.header === void 0 ? void 0 : createElement(Text, { bold: true }, displayText(question.header)), createElement(Text, null, displayText(question.question)), question.detail === void 0 ? void 0 : isPlan ? createElement(MarkdownBody, { text: question.detail }) : createElement(Text, { dimColor: true }, displayText(question.detail)), submitted ? createElement(Text, { dimColor: true }, "  submitted…") : createElement(Box, {
+		flexDirection: "column",
+		marginLeft: 1
+	}, ...mode === "custom" || options.length === 0 ? [createElement(Text, { color: inkColor(TUI_RGB.brandBright) }, `  custom: ${custom}${submitted ? "" : "▌"}`), createElement(Text, { dimColor: true }, dim("  type your answer · enter submit · esc interrupt"))] : options.map((option, at) => {
+		const chosen = isMulti && selected.includes(at);
+		const approve = isPlan && question.intent?.approve === option.label;
+		const mark = approve ? "✓ " : chosen ? "◉ " : at === cursor ? "❯ " : "  ";
+		return createElement(Text, {
+			key: at,
+			color: at === cursor ? inkColor(TUI_RGB.brandBright) : chosen || approve ? inkColor(TUI_RGB.success) : inkColor(TUI_RGB.text)
+		}, `${mark}${displayText(option.label)}${option.description === void 0 ? "" : dim(` — ${displayText(option.description)}`)}`);
+	}), createElement(Text, { dimColor: true }, dim(isMulti ? "  ↑↓ move · space toggle · enter submit · c custom · esc interrupt" : "  ↑↓ move · enter submit · c custom · esc interrupt"))));
+}
+/** The /model panel: a scrolling list over the advisory model directory. */
+function ModelPanel({ directory, error, onSelect, onClose }) {
+	const [cursor, setCursor] = useState(0);
+	useInput((input, key) => {
+		if (key.escape || input === "q") {
+			onClose();
+			return;
+		}
+		const rows = directory?.rows ?? [];
+		if (key.upArrow) {
+			setCursor(cursor > 0 ? cursor - 1 : rows.length - 1);
+			return;
+		}
+		if (key.downArrow) {
+			setCursor(cursor < rows.length - 1 ? cursor + 1 : 0);
+			return;
+		}
+		if (key.return && rows[cursor] !== void 0) onSelect(rows[cursor]);
+	});
+	const rows = directory?.rows ?? [];
+	const window = 8;
+	const first = Math.max(0, Math.min(cursor - Math.floor(window / 2), rows.length - window));
+	const visible = rows.slice(Math.max(0, first), Math.max(0, first) + window);
+	return createElement(Box, {
+		flexDirection: "column",
+		paddingX: 1,
+		borderStyle: "round",
+		borderColor: inkColor(TUI_RGB.brand),
+		alignSelf: "flex-start",
+		marginLeft: 1,
+		marginTop: 1
+	}, createElement(Text, {
+		color: inkColor(TUI_RGB.brand),
+		bold: true
+	}, "/model — select the model for the next step"), directory === void 0 && error === void 0 ? createElement(Text, { dimColor: true }, "  loading models…") : void 0, error !== void 0 ? createElement(Text, { color: inkColor(TUI_RGB.error) }, `  ${error}`) : void 0, ...visible.map((row) => {
+		const index = rows.indexOf(row);
+		const label = displayText(`${row.providerName} · ${row.modelName}`);
+		return createElement(Text, {
+			key: `${row.provider}/${row.model}`,
+			color: index === cursor ? inkColor(TUI_RGB.brandBright) : inkColor(TUI_RGB.dim)
+		}, `${index === cursor ? "❯ " : "  "}${label}`);
+	}), createElement(Text, { dimColor: true }, dim("  ↑↓ move · enter select · esc close")));
+}
+/**
+* Resolve completion candidates for the current input: TUI-local commands,
+* the live registry descriptors, and user-invocable skills, filtered by the
+* typed prefix. Command names win collisions (the dispatch tries the
+* registry first and only then falls through to the skill gesture).
+*/
+function completionCandidates(value, descriptors, skills) {
+	if (!value.startsWith("/")) return [];
+	const prefix = value.slice(1).split(" ")[0] ?? "";
+	const local = [
+		{
+			label: "/help",
+			description: "show commands",
+			origin: "command"
+		},
+		{
+			label: "/model",
+			description: "switch the model",
+			origin: "command"
+		},
+		{
+			label: "/clear",
+			description: "clear the screen",
+			origin: "command"
+		},
+		{
+			label: "/quit",
+			description: "exit",
+			origin: "command"
+		}
+	];
+	const localNames = new Set(local.map((candidate) => candidate.label.slice(1)));
+	const registry = descriptors.filter((descriptor) => !localNames.has(descriptor.name)).map((descriptor) => ({
+		label: `/${descriptor.name}`,
+		description: descriptor.description,
+		origin: "command"
+	}));
+	const taken = new Set([...local, ...registry].map((candidate) => candidate.label.slice(1)));
+	const skillRows = skills.filter((skill) => !taken.has(skill.name)).map((skill) => ({
+		label: `/${skill.name}`,
+		description: skill.modelInvocable ? `skill · ${skill.description}` : `skill (user only) · ${skill.description}`,
+		origin: "skill"
+	}));
+	const all = [
+		...local,
+		...registry,
+		...skillRows
+	];
+	if (prefix === "") return all.slice(0, 10);
+	return all.filter((candidate) => candidate.label.slice(1).startsWith(prefix)).slice(0, 10);
+}
+/**
+* The completion menu, rendered after the status line — the very last
+* element in the tree. Being last in the layout flow, opening or closing it
+* moves nothing above it: the transcript, input box, and status line all
+* stay put (the Claude-Code dropdown treatment adapted to Ink, whose
+* absolute positioning cannot place children above their parent).
+*/
+function CompletionMenu({ state }) {
+	if (!state.active) return void 0;
+	const columns = useStdout().stdout?.columns ?? 80;
+	const nameWidth = Math.min(18, Math.max(0, ...state.rows.map((row) => visibleColumns(row.label))) + 2);
+	const descBudget = Math.max(24, columns - nameWidth - 8);
+	return createElement(Box, {
+		flexDirection: "column",
+		marginTop: 1,
+		marginLeft: 2
+	}, ...state.rows.length === 0 ? [createElement(Text, {
+		key: "loading",
+		dimColor: true
+	}, "searching…")] : state.rows.map((candidate, index) => createElement(Text, {
+		key: candidate.label,
+		color: index === state.index % state.rows.length ? inkColor(TUI_RGB.brandBright) : inkColor(TUI_RGB.dim)
+	}, `${index === state.index % state.rows.length ? "❯ " : "  "}${padColumns(candidate.label, nameWidth)}${dim(truncateColumns(displayText(candidate.description), descBudget))}`)), createElement(Text, { dimColor: true }, dim(state.mention ? "↑↓ choose · tab insert" : "↑↓ choose · tab complete")));
+}
+/**
+* The prompt box: TUI-local slash commands handled locally, other lines
+* dispatched; input editing keeps a cursor with history and completion.
+* While a modal (approval / question / model panel) owns the keys, the
+* box passes every key through untouched.
+*/
+function Input({ active, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, notify, toggleReasoning, loadMentions, cyclePermission, onMenuState }) {
 	const [value, setValue] = useState("");
-	const [notices, setNotices] = useState([]);
+	const [cursor, setCursor] = useState(0);
+	const history = useRef([]);
+	const historyIndex = useRef(null);
+	const draft = useRef("");
+	const [completionIndex, setCompletionIndex] = useState(0);
+	const candidates = completionCandidates(value, descriptors, skills);
+	const slashActive = candidates.length > 0 && value.startsWith("/") && !value.includes(" ") && !value.includes("\n");
+	const beforeCursor = value.slice(0, cursor);
+	const lastLine = beforeCursor.split("\n").at(-1) ?? "";
+	const tokenMatch = /(^|\s)@([^\s]*)$/u.exec(lastLine);
+	const mentionToken = tokenMatch === null ? void 0 : {
+		start: beforeCursor.length - lastLine.length + (tokenMatch.index ?? 0) + (tokenMatch[1]?.length ?? 0),
+		query: tokenMatch[2] ?? ""
+	};
+	const mentionActive = mentionToken !== void 0;
+	const [mentionRows, setMentionRows] = useState([]);
+	useEffect(() => {
+		if (!mentionActive) {
+			setMentionRows([]);
+			return;
+		}
+		const controller = new AbortController();
+		setMentionRows([]);
+		loadMentions(mentionToken.query, controller.signal).then((rows) => setMentionRows(rows), () => {});
+		return () => {
+			controller.abort();
+		};
+	}, [mentionActive, mentionToken?.query]);
+	const menuActive = (slashActive || mentionActive) && !busy;
+	const menuRows = mentionActive ? mentionRows.map((row) => ({
+		label: row.label.startsWith("@") ? row.label : `@${row.label}${row.kind === "directory" ? "/" : ""}`,
+		description: row.description,
+		origin: "mention"
+	})) : candidates;
+	const menuStateKey = useRef("");
+	useEffect(() => {
+		const key = JSON.stringify([
+			menuActive,
+			mentionActive,
+			completionIndex,
+			menuRows.map((row) => row.label)
+		]);
+		if (key === menuStateKey.current) return;
+		menuStateKey.current = key;
+		onMenuState({
+			active: menuActive,
+			mention: mentionActive,
+			index: completionIndex,
+			rows: menuRows
+		});
+	}, [
+		menuActive,
+		mentionActive,
+		completionIndex,
+		menuRows,
+		onMenuState
+	]);
 	useInput((input, key) => {
-		if (key.ctrl && (input === "c" || input === "d")) {
-			onQuit();
+		if (!active) return;
+		if (key.tab && key.shift) {
+			const next = cyclePermission();
+			if (next !== "") notify(`permission → ${next}`);
+			return;
+		}
+		if (key.ctrl && input === "r") {
+			toggleReasoning();
+			return;
+		}
+		if (key.ctrl && input === "c") {
+			if (busy) interrupt();
+			else if (value !== "") {
+				setValue("");
+				setCursor(0);
+				setCompletionIndex(0);
+			} else quit();
+			return;
+		}
+		if (key.ctrl && input === "d") {
+			if (busy) notify("cancel the running turn before exiting (Esc or Ctrl+C)");
+			else quit();
+			return;
+		}
+		if (key.escape) {
+			if (busy) interrupt();
 			return;
 		}
 		if (key.return) {
+			if (key.meta || key.ctrl && input === "j") {
+				setValue(value.slice(0, cursor) + "\n" + value.slice(cursor));
+				setCursor(cursor + 1);
+				return;
+			}
 			const text = value.trim();
 			setValue("");
+			setCursor(0);
+			setCompletionIndex(0);
 			if (text === "") return;
+			history.current = [...history.current, text];
+			historyIndex.current = null;
 			if (text === "/quit") {
-				onQuit();
+				quit();
 				return;
 			}
 			if (text === "/help") {
-				setNotices([...notices, "/help show commands · /clear clear the screen · /quit exit"]);
+				notify("/model switch · /clear clear the screen · /quit exit · Ctrl+R toggle thinking · Shift+Tab cycle permission · other /commands reach the registry · Esc or Ctrl+C interrupts the running turn");
 				return;
 			}
 			if (text === "/clear") {
-				setNotices([]);
 				console.clear();
 				return;
 			}
-			if (busy) {
-				setNotices([...notices, "the agent is working — wait for the turn to finish"]);
+			if (text === "/model" || text.startsWith("/model ")) {
+				openModel();
+				return;
+			}
+			if (busy && !text.startsWith("/")) {
+				steer(text);
 				return;
 			}
-			onSubmit(text);
+			dispatch(text);
+			return;
+		}
+		if (menuActive && key.upArrow) {
+			setCompletionIndex((index) => (index + menuRows.length - 1) % menuRows.length);
+			return;
+		}
+		if (menuActive && key.downArrow) {
+			setCompletionIndex((index) => (index + 1) % menuRows.length);
+			return;
+		}
+		if (key.upArrow) {
+			const entries = history.current;
+			if (entries.length === 0) return;
+			const next = historyIndex.current === null ? entries.length - 1 : Math.max(0, historyIndex.current - 1);
+			if (historyIndex.current === null) draft.current = value;
+			historyIndex.current = next;
+			setValue(entries[next] ?? "");
+			setCursor((entries[next] ?? "").length);
+			return;
+		}
+		if (key.downArrow) {
+			const entries = history.current;
+			if (historyIndex.current === null) return;
+			const next = historyIndex.current + 1;
+			if (next >= entries.length) {
+				historyIndex.current = null;
+				setValue(draft.current);
+				setCursor(draft.current.length);
+				return;
+			}
+			historyIndex.current = next;
+			setValue(entries[next] ?? "");
+			setCursor((entries[next] ?? "").length);
+			return;
+		}
+		if (key.tab && menuActive) {
+			if (mentionActive && mentionToken !== void 0) {
+				const row = mentionRows[completionIndex % mentionRows.length];
+				if (row !== void 0) {
+					const insertion = row.label.startsWith("@") ? row.label : `@${row.label}${row.kind === "directory" ? "/" : ""}`;
+					setValue(value.slice(0, mentionToken.start) + insertion + value.slice(cursor));
+					setCursor(mentionToken.start + insertion.length);
+				}
+			} else {
+				const candidate = candidates[completionIndex % candidates.length];
+				if (candidate !== void 0) {
+					setValue(`${candidate.label} `);
+					setCursor(candidate.label.length + 1);
+				}
+			}
+			setCompletionIndex(0);
 			return;
 		}
 		if (key.backspace || key.delete) {
-			setValue(value.slice(0, -1));
+			if (cursor > 0) {
+				setValue(value.slice(0, cursor - 1) + value.slice(cursor));
+				setCursor(cursor - 1);
+				setCompletionIndex(0);
+			}
+			return;
+		}
+		if (key.leftArrow) {
+			setCursor(Math.max(0, cursor - 1));
+			return;
+		}
+		if (key.rightArrow) {
+			setCursor(Math.min(value.length, cursor + 1));
+			return;
+		}
+		if (key.ctrl && input === "u") {
+			setValue("");
+			setCursor(0);
+			return;
+		}
+		if (key.ctrl && input === "a") {
+			setCursor(0);
 			return;
 		}
-		if (input !== "") setValue(value + input);
+		if (key.ctrl && input === "e") {
+			setCursor(value.length);
+			return;
+		}
+		if (input !== "" && !key.ctrl && !key.meta) {
+			setValue(value.slice(0, cursor) + input + value.slice(cursor));
+			setCursor(cursor + input.length);
+			setCompletionIndex(0);
+		}
 	});
-	return createElement(Box, { flexDirection: "column" }, ...notices.map((notice, index) => createElement(Text, {
-		key: index,
-		dimColor: true
-	}, notice)), createElement(Box, null, createElement(Text, { color: inkColor(TUI_RGB.brand) }, busy ? "… " : "❯ "), createElement(Text, null, value)));
+	return createElement(Box, {
+		flexDirection: "column",
+		marginTop: 1
+	}, busy && value === "" ? createElement(Text, { dimColor: true }, dim("  enter steers the running turn · esc or ctrl+c cancels")) : void 0, createElement(Box, {
+		borderStyle: "round",
+		borderColor: inkColor(TUI_RGB.dim),
+		paddingX: 1
+	}, createElement(Text, { color: inkColor(TUI_RGB.brand) }, busy ? "… " : "❯ "), value === "" ? void 0 : createElement(Text, null, value.slice(0, cursor)), createElement(CursorBlock, { char: value.slice(cursor, cursor + 1) === "" ? " " : value.slice(cursor, cursor + 1) }), value === "" && !busy ? createElement(Text, { dimColor: true }, "type a message · / commands · @ mentions") : createElement(Text, null, value.slice(cursor + 1))));
 }
 /** The whole terminal app; state arrives via the store, output via Ink. */
-function App({ store, model, cwd, branch, sessionId, onSubmit, onQuit }) {
-	const view = useSyncExternalStore(store.subscribe, store.getView);
-	return createElement(Box, { flexDirection: "column" }, createElement(Header), createElement(Box, {
+function App(props) {
+	const view = useSyncExternalStore(props.store.subscribe, props.store.getView);
+	const descriptors = useSyncExternalStore(props.commands.subscribe, () => props.commands.descriptors);
+	const skills = useSyncExternalStore(props.skills.subscribe, () => props.skills.rows);
+	const [modelLabel, setModelLabel] = useState(props.model);
+	const [modelOpen, setModelOpen] = useState(false);
+	const [directory, setDirectory] = useState(void 0);
+	const [modelError, setModelError] = useState(void 0);
+	const [notices, setNotices] = useState([]);
+	const notify = (text) => {
+		setNotices((current) => [...current, text]);
+	};
+	useEffect(() => {
+		props.onBridgeReady({ notify });
+	}, []);
+	useEffect(() => {
+		if (!modelOpen || directory !== void 0) return;
+		let cancelled = false;
+		setModelError(void 0);
+		props.loadModels().then((loaded) => {
+			if (!cancelled) setDirectory(loaded);
+		}, (error) => {
+			if (!cancelled) setModelError(error instanceof Error ? error.message : String(error));
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [modelOpen]);
+	const busy = view.busy;
+	const [showReasoning, setShowReasoning] = useState(false);
+	const [menuState, setMenuState] = useState({
+		active: false,
+		mention: false,
+		index: 0,
+		rows: []
+	});
+	const approvalSnapshot = useSyncExternalStore(props.approval.subscribe, props.approval.getSnapshot);
+	const questionSnapshot = useSyncExternalStore(props.questions.subscribe, props.questions.getSnapshot);
+	const inputActive = !modelOpen && approvalSnapshot.pending === void 0 && questionSnapshot.pending === void 0;
+	const questionPending = questionSnapshot.pending !== void 0;
+	const transcriptRows = [];
+	view.entries.forEach((entry, index) => {
+		if (entry.kind === "user" && index > 0) transcriptRows.push(createElement(Text, { key: `gap-${index}` }, " "));
+		transcriptRows.push(createElement(EntryLine, {
+			key: index,
+			entry,
+			showReasoning
+		}));
+	});
+	return createElement(Box, { flexDirection: "column" }, createElement(Header, { resumed: props.resumed }), createElement(Box, {
 		flexDirection: "column",
 		paddingX: 1
-	}, ...view.entries.map((entry, index) => createElement(EntryLine, {
+	}, ...transcriptRows, view.streamingReasoning !== "" ? createElement(Text, {
+		dimColor: true,
+		italic: true
+	}, showReasoning ? `  ✻ ${displayText(view.streamingReasoning)}` : "  ✻ Thinking…") : void 0, view.streaming !== "" ? createElement(Text, null, displayText(view.streaming), busy ? createElement(Caret) : void 0) : void 0, busy && view.streaming === "" && view.streamingReasoning === "" ? createElement(Text, { dimColor: true }, "Deep diving...") : void 0), createElement(TodoPanel, { todos: view.todos }), createElement(QuestionBar, {
+		store: props.questions,
+		locked: modelOpen
+	}), createElement(ApprovalBar, {
+		approval: props.approval,
+		locked: modelOpen || questionPending
+	}), modelOpen ? createElement(ModelPanel, {
+		directory,
+		error: modelError,
+		onSelect: (row) => {
+			setModelLabel(props.selectModel(row));
+			notify(`model → next step uses ${row.provider}/${row.model}`);
+			setModelOpen(false);
+		},
+		onClose: () => {
+			setModelOpen(false);
+		}
+	}) : void 0, createElement(Box, { flexDirection: "column" }, ...notices.slice(-3).map((notice, index) => createElement(Text, {
 		key: index,
-		entry
-	})), view.streaming !== "" ? createElement(Text, null, view.streaming) : void 0, view.busy && view.streaming === "" ? createElement(Text, { dimColor: true }, "thinking…") : void 0), createElement(Input, {
-		busy: view.busy,
-		onSubmit,
-		onQuit
+		dimColor: true
+	}, notice))), createElement(Input, {
+		active: inputActive,
+		busy,
+		descriptors,
+		skills,
+		dispatch: props.dispatch,
+		steer: props.steer,
+		interrupt: props.interrupt,
+		quit: props.quit,
+		openModel: () => {
+			setModelOpen(true);
+		},
+		notify,
+		toggleReasoning: () => {
+			setShowReasoning((current) => !current);
+		},
+		loadMentions: props.loadMentions,
+		cyclePermission: props.cyclePermission,
+		onMenuState: setMenuState
 	}), createElement(StatusLine, {
 		facts: {
-			model,
-			cwd,
-			branch,
-			sessionId
+			model: modelLabel,
+			cwd: props.cwd,
+			branch: props.branch,
+			sessionId: props.sessionId,
+			plan: view.plan,
+			permission: view.permission
 		},
 		stats: view.stats,
-		busy: view.busy
-	}));
+		busy
+	}), createElement(CompletionMenu, { state: menuState }));
+}
+//#endregion
+//#region src/approval.ts
+/**
+* Create the approval store and mount the answerer listener on the context.
+* The listener claims only requests for `owns`-owned agents and defers every
+* other request back into the waterfall (`next()`), so sibling answerers stay
+* usable. An aborted ask never reaches the human. Plugin teardown removes the
+* listener; the service then fails its own question closed.
+* @param ctx - plugin context whose event bus carries `approval/request`.
+* @param owns - agents this terminal answers for.
+* @param preview - resolves a tool-call preview for a pending request (the
+* request contract carries no arguments; the UI self-serves from the
+* transcript projection via `callId`).
+* @returns the store the renderer subscribes to.
+*/
+function mountApprovalAnswerer(ctx, owns, preview) {
+	let snapshot = {
+		pending: void 0,
+		answered: false
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	const set = (next) => {
+		snapshot = next;
+		for (const listener of listeners) listener();
+	};
+	ctx.on("approval/request", (request, next) => {
+		if (!owns(request.agent)) return next();
+		if (request.signal?.aborted === true) return Promise.resolve("cancelled");
+		let resolved = false;
+		let settle;
+		const withdraw = () => {
+			if (resolved) return;
+			resolved = true;
+			set({
+				pending: void 0,
+				answered: false
+			});
+			settle("cancelled");
+		};
+		if (request.signal !== void 0) request.signal.addEventListener("abort", withdraw, { once: true });
+		const pending = {
+			headline: request.reason ?? `tool ${request.toolName} asks for your approval`,
+			toolName: request.toolName,
+			command: preview(request),
+			answer: (outcome) => {
+				if (resolved) return;
+				resolved = true;
+				set({
+					pending,
+					answered: true
+				});
+				settle(outcome);
+			}
+		};
+		set({
+			pending,
+			answered: false
+		});
+		return new Promise((resolve) => {
+			settle = resolve;
+		}).then((outcome) => {
+			if (outcome !== "cancelled") set({
+				pending: void 0,
+				answered: false
+			});
+			return outcome;
+		});
+	});
+	return {
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		getSnapshot() {
+			return snapshot;
+		}
+	};
+}
+//#endregion
+//#region src/commands.ts
+/**
+* Watch the live command registry. Reads the current list immediately and
+* re-reads on every registry mutation or agent retarget; notification
+* failures are contained by the registry itself, so this watcher only ever
+* re-reads. Without a `commands` service the view stays empty and all lines
+* fall through to normal prompts.
+* @param ctx - context carrying the `commands` service (optional).
+* @returns the view the completion menu subscribes to.
+*/
+function watchCommands(ctx) {
+	const commands = ctx.get("commands");
+	let agent;
+	let descriptors = [];
+	const listeners = /* @__PURE__ */ new Set();
+	const refresh = () => {
+		if (commands === void 0 || agent === void 0) return;
+		descriptors = commands.list(agent);
+		for (const listener of listeners) listener();
+	};
+	if (commands !== void 0) ctx.on("commands/change", () => refresh());
+	return {
+		get descriptors() {
+			return descriptors;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		setAgent(next) {
+			agent = next;
+			refresh();
+		}
+	};
+}
+/**
+* Whether one command line is a syntactically valid slash command.
+* @param line - the complete candidate line.
+* @returns true when the line parses as `/name` or `/name input`.
+*/
+function isSlashLine(line) {
+	return /^\/[a-z][a-z0-9_-]*(?=$|[\t ])/u.test(line);
 }
 //#endregion
 //#region src/internals.ts
@@ -309,6 +1439,308 @@ const internals = {
 	stderr: process.stderr
 };
 //#endregion
+//#region src/models.ts
+/**
+* Load the selectable model directory from the live `ctx.llm` registry.
+* Providers are listed synchronously; each provider's models are discovered
+* with a bounded parallel fan-out whose failures degrade to that provider
+* contributing no rows (mirrors the web catalog's per-provider failures).
+* @param ctx - context carrying the `llm` service.
+* @returns the resolved directory; empty rows when `llm` is unavailable.
+*/
+async function loadModelDirectory(ctx) {
+	const llm = ctx.get("llm");
+	if (llm === void 0) return {
+		rows: [],
+		failures: []
+	};
+	const providers = llm.listProviders();
+	const listed = await Promise.all(providers.map(async (provider) => {
+		try {
+			const models = await llm.listModels(provider.id);
+			return {
+				provider: provider.id,
+				providerName: provider.name,
+				models: models.map((model) => ({
+					provider: provider.id,
+					providerName: provider.name,
+					model: model.id,
+					modelName: model.name
+				}))
+			};
+		} catch {
+			return {
+				provider: provider.id,
+				providerName: provider.name,
+				models: [],
+				failed: true
+			};
+		}
+	}));
+	return {
+		rows: listed.flatMap((entry) => entry.models),
+		failures: listed.filter((entry) => "failed" in entry && entry.failed === true).map((entry) => entry.provider)
+	};
+}
+//#endregion
+//#region src/mentions.ts
+/**
+* Workspace @mention support: file candidates from a bounded async scan of
+* the session cwd, session candidates from the opt-in `sessionReferenceResolver`
+* service, and submission preparation through its `prepare()` API. Picked
+* session mentions land as canonical `@[label](dsh-session:…)` tokens; on
+* submit the text is parsed back into readable `@label` text plus structured
+* references, snapshots are injected via `agent.inject()` before the readable
+* message wakes the driver (`followup` idle, `steer` running) — exactly the
+* upstream README's wiring.
+*
+* @module @deepseek-ai/dsh-code/mentions
+*/
+/** Directories never entered and files never listed during the scan. */
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	".git",
+	"node_modules",
+	"lib",
+	"dist",
+	"out",
+	".omc",
+	"coverage"
+]);
+const MAX_FILES = 4e3;
+const MAX_DEPTH = 12;
+/** Bounded async BFS scan of a workspace; unreadable entries are skipped. */
+async function scanWorkspaceFiles(root, signal) {
+	const found = [];
+	const pending = [{
+		absolute: root,
+		relative: "",
+		depth: 0
+	}];
+	const aborted = () => signal?.aborted === true;
+	while (pending.length > 0 && found.length < MAX_FILES && !aborted()) {
+		const current = pending.shift();
+		if (current === void 0) break;
+		let entries;
+		try {
+			entries = await readdir(current.absolute, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (found.length >= MAX_FILES || aborted()) return found;
+			if (entry.name.startsWith(".")) continue;
+			const relative = current.relative === "" ? entry.name : `${current.relative}/${entry.name}`;
+			if (entry.isDirectory()) {
+				if (SKIP_DIRS.has(entry.name) || current.depth + 1 > MAX_DEPTH) continue;
+				pending.push({
+					absolute: join(current.absolute, entry.name),
+					relative,
+					depth: current.depth + 1
+				});
+			} else if (entry.isFile()) found.push({
+				path: relative,
+				kind: "file"
+			});
+		}
+	}
+	return found.sort((left, right) => left.path < right.path ? -1 : 1);
+}
+/** True when every query character appears in order in the haystack. */
+function isSubsequence(query, haystack) {
+	let at = 0;
+	for (const char of haystack) {
+		if (char === query[at]) at += 1;
+		if (at >= query.length) return true;
+	}
+	return at >= query.length;
+}
+/** Rank one file path against the typed query (community-TUI scoring shape). */
+function scoreFile(path, query) {
+	const name = path.slice(path.lastIndexOf("/") + 1);
+	if (query === "") return 0;
+	if (name === query) return 1e3;
+	if (name.startsWith(query)) return 900;
+	if (name.includes(query)) return 700;
+	if (path.includes(query)) return 500;
+	if (isSubsequence(query, name)) return 300;
+	return 0;
+}
+/**
+* Create the mention API for one agent's workspace. A missing
+* session-reference service degrades to file mentions only (the scan still
+* works); `prepare` then passes text through untouched.
+* @param ctx - context carrying the optional `sessionReferenceResolver`.
+* @param agent - the session owner; excluded from its own candidates.
+* @param cwd - workspace root to scan.
+*/
+function createMentions(ctx, agent, cwd) {
+	const resolver = ctx.get("sessionReferenceResolver");
+	let filesPromise;
+	return {
+		files() {
+			filesPromise ??= scanWorkspaceFiles(cwd);
+			return filesPromise;
+		},
+		async candidates(query, signal) {
+			const needle = query.trim();
+			const [files, sessions] = await Promise.all([this.files(), resolver === void 0 ? Promise.resolve([]) : resolver.listCandidates(agent, needle, 10, signal).catch(() => [])]);
+			const fileRows = files.filter((candidate) => scoreFile(candidate.path, needle) > 0).sort((left, right) => scoreFile(right.path, needle) - scoreFile(left.path, needle)).slice(0, 20).map((candidate) => ({
+				label: candidate.path,
+				description: candidate.kind === "directory" ? "Folder" : "File",
+				kind: candidate.kind
+			}));
+			return [...sessions.map((candidate) => ({
+				label: formatSessionReferenceMention(candidate),
+				description: `Session · ${candidate.cwd ?? "(no cwd)"}`,
+				kind: "session"
+			})), ...fileRows];
+		},
+		parse(text) {
+			return parseSessionReferenceText(text);
+		},
+		async prepare(parsed, signal) {
+			if (parsed.references.length === 0 || resolver === void 0) return {
+				text: parsed.text,
+				references: parsed.references
+			};
+			const prepared = await resolver.prepare(agent, [{
+				type: "text",
+				text: parsed.text
+			}], parsed.references, signal);
+			return {
+				text: prepared.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
+				references: parsed.references,
+				additionalContext: prepared.additionalContext
+			};
+		},
+		sessionMention(candidate) {
+			return formatSessionReferenceMention({
+				sessionId: candidate.sessionId,
+				label: candidate.label
+			});
+		}
+	};
+}
+//#endregion
+//#region src/questions.ts
+const ABORT_ERROR = new UserQuestionError("ask_user_question was interrupted before the user answered", "ASK_ABORTED");
+/**
+* Mount the single `ctx.userQuestions` UI provider over a FIFO queue.
+* @param ctx - context carrying the `userQuestions` service (dsh-base).
+* @returns the store the renderer subscribes to; a context without the
+* service yields a permanently empty store.
+*/
+function mountQuestionProvider(ctx) {
+	const service = ctx.get("userQuestions");
+	let snapshot = { pending: void 0 };
+	let active;
+	const queue = [];
+	const listeners = /* @__PURE__ */ new Set();
+	const set = (next) => {
+		snapshot = next;
+		for (const listener of listeners) listener();
+	};
+	/** Settle the active request and show the next queued one, if any. */
+	const advance = () => {
+		const next = queue.shift();
+		active = next;
+		set({ pending: next });
+	};
+	if (service !== void 0) service.registerProvider({ ask(request) {
+		return new Promise((resolve, reject) => {
+			const pending = {
+				request,
+				resolve,
+				reject
+			};
+			const onAbort = () => {
+				if (active === pending) {
+					active = void 0;
+					set({ pending: void 0 });
+					advance();
+				} else {
+					const at = queue.indexOf(pending);
+					if (at >= 0) queue.splice(at, 1);
+				}
+				reject(ABORT_ERROR);
+			};
+			if (request.signal?.aborted === true) {
+				reject(ABORT_ERROR);
+				return;
+			}
+			request.signal?.addEventListener("abort", onAbort, { once: true });
+			if (active === void 0) {
+				active = pending;
+				set({ pending });
+			} else queue.push(pending);
+		});
+	} });
+	return {
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		getSnapshot() {
+			return snapshot;
+		},
+		submit(pending, answers) {
+			if (active !== pending) return;
+			active = void 0;
+			set({ pending: void 0 });
+			pending.resolve(answers);
+			advance();
+		},
+		cancel(pending) {
+			if (active !== pending) return;
+			active = void 0;
+			set({ pending: void 0 });
+			pending.reject(ABORT_ERROR);
+			advance();
+		}
+	};
+}
+//#endregion
+//#region src/render/tool-preview.ts
+/**
+* Bounded preview line for a tool invocation's raw JSON arguments: the first
+* human-meaningful string among the well-known keys (command, path, query, …)
+* with a fallback to the bounded raw JSON. Shared by the tool card in the
+* transcript and the approval bar's command preview.
+*
+* @module @deepseek-ai/dsh-code/render/tool-preview
+*/
+/** Keys searched in declaration order when building a preview. */
+const PREVIEW_KEYS = [
+	"command",
+	"cmd",
+	"description",
+	"path",
+	"pattern",
+	"query"
+];
+/**
+* Resolve one bounded preview for raw tool arguments.
+* @param args - raw JSON arguments string as the model produced it.
+* @param toolName - the tool the arguments belong to (fallback label).
+* @returns the preview line; empty when nothing useful resolves.
+*/
+function toolArgumentsPreview(args, toolName) {
+	if (args === "") return toolName;
+	try {
+		const parsed = JSON.parse(args);
+		if (parsed !== null && typeof parsed === "object") {
+			const record = parsed;
+			for (const key of PREVIEW_KEYS) {
+				const value = record[key];
+				if (typeof value === "string" && value !== "") return value;
+			}
+		}
+	} catch {}
+	return args.length > 80 ? `${args.slice(0, 77)}...` : args;
+}
+//#endregion
 //#region src/render/projection.ts
 /**
 * Pure session-event-to-view projection for the TUI transcript: one reducer
@@ -322,13 +1754,21 @@ const internals = {
 function textOf(content) {
 	return content.filter((block) => block.type === "text").map((block) => block.text).join("");
 }
+/** Join the reasoning blocks of a content list; non-reasoning blocks contribute nothing. */
+function reasoningOf(content) {
+	return content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
+}
 /** A fresh, empty transcript view. */
 function createTranscriptView() {
 	return {
 		entries: [],
 		streaming: "",
+		streamingReasoning: "",
 		todos: [],
 		busy: false,
+		model: "",
+		plan: false,
+		permission: "",
 		stats: {
 			turns: 0,
 			steps: 0,
@@ -360,7 +1800,8 @@ function projectEvent(view, event) {
 				...view,
 				entries: [...view.entries, {
 					kind: "user",
-					text: textOf(message.content)
+					text: textOf(message.content),
+					notice: false
 				}]
 			};
 			const notice = message.source.kind === "plugin" && message.source.form === "notice" ? message.source.summary : message.source.kind;
@@ -368,17 +1809,22 @@ function projectEvent(view, event) {
 				...view,
 				entries: [...view.entries, {
 					kind: "user",
-					text: boundContextSummary(notice)
+					text: boundContextSummary(notice),
+					notice: true
 				}]
 			};
 		}
 		case "assistant/chunk": {
 			const chunk = event.data.chunk;
-			if (chunk.type !== "text-delta") return view;
-			return {
+			if (chunk.type === "text-delta") return {
 				...view,
 				streaming: view.streaming + chunk.text
 			};
+			if (chunk.type === "reasoning-delta") return {
+				...view,
+				streamingReasoning: view.streamingReasoning + chunk.text
+			};
+			return view;
 		}
 		case "assistant/message": {
 			const key = `${event.data.turn}:${event.data.step}`;
@@ -389,9 +1835,11 @@ function projectEvent(view, event) {
 			return {
 				...view,
 				streaming: "",
+				streamingReasoning: "",
 				entries: [...view.entries, {
 					kind: "assistant",
-					text: textOf(event.data.message.content)
+					text: textOf(event.data.message.content),
+					reasoning: reasoningOf(event.data.message.content)
 				}],
 				stats: {
 					...view.stats,
@@ -414,6 +1862,7 @@ function projectEvent(view, event) {
 					callId: data.callId,
 					name: data.name,
 					arguments: data.arguments,
+					preview: toolArgumentsPreview(data.arguments, data.name),
 					state: "running",
 					summary: ""
 				}]
@@ -448,6 +1897,7 @@ function projectEvent(view, event) {
 		case "turn/start": return {
 			...view,
 			busy: true,
+			todos: [],
 			stats: {
 				...view.stats,
 				turns: view.stats.turns + 1
@@ -477,17 +1927,75 @@ function projectEvent(view, event) {
 				}]
 			};
 		}
+		case "request/header": {
+			const config = event.data.header.config;
+			return {
+				...view,
+				model: `${config.provider}/${config.model}`
+			};
+		}
+		case "plan/mode": return {
+			...view,
+			plan: event.data.active
+		};
+		case "permission/preset": return {
+			...view,
+			permission: event.data.preset
+		};
+		case "command/run": {
+			const data = event.data;
+			return {
+				...view,
+				entries: [...view.entries, {
+					kind: "command",
+					commandId: data.commandId,
+					name: data.name,
+					args: data.args ?? "",
+					state: "running",
+					summary: ""
+				}]
+			};
+		}
+		case "command/done": {
+			const data = event.data;
+			const entries = view.entries.map((entry) => {
+				if (entry.kind !== "command" || entry.commandId !== data.commandId) return entry;
+				return {
+					...entry,
+					state: data.kind === "success" ? "done" : "error",
+					summary: boundContextSummary(data.text ?? "")
+				};
+			});
+			return {
+				...view,
+				entries
+			};
+		}
 		default: return view;
 	}
 }
+/**
+* Fold a replayed event history into one view.
+* @param events - events in `seq` order.
+* @returns the folded view.
+*/
+function projectEvents(events) {
+	return events.reduce(projectEvent, createTranscriptView());
+}
 //#endregion
 //#region src/store.ts
 /**
-* Create one transcript store.
+* Create one transcript store, optionally seeded with replayed history. The
+* seed folds synchronously BEFORE the first render, so a resumed session
+* paints its full transcript on mount (no live `session/event` fires for
+* constructor seeds — the store's `session/event` feed only carries new
+* appends).
+* @param replay - persisted events in `seq` order (e.g. a resumed session's
+* constructor seed); folded once and never re-notified.
 * @returns the store the runner feeds and the renderer subscribes to.
 */
-function createTranscriptStore() {
-	let view = createTranscriptView();
+function createTranscriptStore(replay) {
+	let view = replay === void 0 ? createTranscriptView() : projectEvents(replay);
 	const listeners = /* @__PURE__ */ new Set();
 	return {
 		getView: () => view,
@@ -506,16 +2014,69 @@ function createTranscriptStore() {
 	};
 }
 //#endregion
+//#region src/skills.ts
+function toRows(skills) {
+	return skills.filter((skill) => isUserInvocable(skill)).map((skill) => ({
+		name: skill.name,
+		description: skill.description,
+		modelInvocable: skill.invocation.modelInvocable === true
+	})).sort((left, right) => left.name < right.name ? -1 : 1);
+}
+/**
+* Watch the user-invocable skill catalog for one agent's workspace. The first
+* load starts when the owning agent is known (`setAgent`); `skills/change`
+* and agent retargets re-read. Read failures keep the last good rows (the
+* next change notification is the retry surface) — a missing `skills`
+* service leaves the view permanently empty.
+* @param ctx - context carrying the `skills` service (optional).
+* @returns the view the completion menu subscribes to.
+*/
+function watchSkills(ctx) {
+	const skills = ctx.get("skills");
+	let agent;
+	let rows = [];
+	const listeners = /* @__PURE__ */ new Set();
+	const reload = () => {
+		if (skills === void 0 || agent === void 0) return;
+		skills.list({
+			cwd: agent.session.header.cwd,
+			scope: agent
+		}).then((summaries) => {
+			const next = toRows(summaries);
+			if (next.length === rows.length && next.every((row, index) => row.name === rows[index]?.name)) return;
+			rows = next;
+			for (const listener of listeners) listener();
+		}, () => {});
+	};
+	if (skills !== void 0) ctx.on("skills/change", reload);
+	return {
+		get rows() {
+			return rows;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		setAgent(next) {
+			agent = next;
+			reload();
+		}
+	};
+}
+//#endregion
 //#region src/index.ts
 /**
-* @deepseek-ai/dsh-tui — the interactive terminal driver. The bundle patch
+* @deepseek-ai/dsh-code — the interactive terminal driver. The bundle patch
 * rides over dsh-base without Host, HTTP, or browser plugins; this runner
-* creates one Agent through the core registry, mounts the Ink app (DeepSeek
-* blue, whale wordmark), folds submitted prompts into the same durable
-* session, streams `session/event` into the transcript, and on quit flushes
-* and requests process exit.
+* creates (or resumes) one Agent through the core registry, mounts the Ink
+* app (DeepSeek blue, whale wordmark), folds submitted prompts into the same
+* durable session, answers approval asks with a y/n bar, dispatches slash
+* commands through the shared registry, and on quit flushes and requests
+* process exit.
 *
-* @module @deepseek-ai/dsh-tui
+* @module @deepseek-ai/dsh-code
 */
 /** Stable Cordis plugin name. */
 const name = "tui-runner";
@@ -525,6 +2086,10 @@ const inject = [
 	"agents",
 	"sessions"
 ];
+const Config = z.object({ startup: z.object({
+	kind: z.string().required(),
+	sessionId: z.string()
+}) });
 /** Report an unexpected direct-driver failure and request a failing exit. */
 function fail(io, error) {
 	internals.stderr.write(`dsh: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -543,36 +2108,139 @@ function gitBranch(cwd) {
 	}
 }
 /**
-* Run the interactive terminal session: create one Agent, mount the app, and
-* keep the process alive until the user quits.
+* Resolve the invocation's target session against the persisted headers.
+* @param startup - the parsed startup flags.
+* @param persistence - the persistence service; required for resume/latest.
+* @param cwd - the working directory `--continue` filters by.
+* @returns the target identity.
+* @throws with a user-facing message when the flags name nothing resolvable.
+*/
+async function resolveTarget(startup, persistence, cwd) {
+	if (startup.kind === "fresh") return {
+		sessionId: `session-${randomUUID()}`,
+		resume: false
+	};
+	if (startup.kind === "named") return {
+		sessionId: startup.sessionId,
+		resume: false
+	};
+	if (persistence === void 0) throw new Error("cannot resolve the requested session: session persistence is not configured");
+	const headers = await persistence.list();
+	if (startup.kind === "resume") {
+		const wanted = startup.sessionId;
+		const exact = headers.filter((header) => header.id === wanted);
+		const matches = exact.length > 0 ? exact : headers.filter((header) => header.id.startsWith(wanted));
+		if (matches.length === 0) throw new Error(`no persisted session matches "${wanted}"`);
+		if (matches.length > 1) throw new Error(`session prefix "${wanted}" is ambiguous (${matches.length} matches): use more of the id`);
+		return {
+			sessionId: matches[0].id,
+			resume: true
+		};
+	}
+	const local = headers.filter((header) => header.cwd === cwd).sort((left, right) => right.createdAt - left.createdAt);
+	if (local.length === 0) throw new Error(`no persisted session for this directory (${cwd}); start one without --continue`);
+	return {
+		sessionId: local[0].id,
+		resume: true
+	};
+}
+/**
+* Resolve a bounded command preview for one pending approval: the request
+* contract carries no arguments, so the bar self-serves from the transcript
+* projection via `callId` (mirrors the web ApprovalPanel's argsRaw lookup).
+* @param events - the transcript entries to search.
+* @param callId - the tool call the question is about, when the asker had one.
+* @param toolName - the tool the question is about.
+* @returns a bounded preview line, '' when nothing useful resolves.
+*/
+function approvalCommandPreview(events, callId, toolName) {
+	if (callId === void 0) return "";
+	const entry = events.find((candidate) => candidate.kind === "tool" && candidate.callId === callId);
+	if (entry === void 0) return "";
+	return toolArgumentsPreview(entry.arguments ?? "", toolName);
+}
+/**
+* Run the interactive terminal session: resolve the target session, create or
+* resume one Agent, mount the app, and keep the process alive until the user
+* quits.
 * @param ctx - plugin context carrying the Agent, default model, Session, and launcher IO services.
+* @param startup - the parsed invocation flags.
 * @param io - process-facing effects.
 */
-async function run(ctx, io) {
+async function run(ctx, startup, io) {
 	await ctx.get("loader")?.await();
 	const agents = ctx.get("agents");
 	const defaultModel = ctx.get("agentDefaultModel");
 	const sessions = ctx.get("sessions");
+	const persistence = ctx.get("sessionPersistence");
 	if (agents === void 0 || defaultModel === void 0 || sessions === void 0) return;
-	const selection = defaultModel.currentSelection();
-	const { agent } = await agents.create({
-		sessionId: SessionId(`session-${randomUUID()}`),
-		meta: { cwd: process.cwd() },
-		agentOptions: {
-			provider: selection.provider,
-			model: selection.model
-		},
-		setup: (agentCtx) => {
-			installModelSelection(agentCtx, {
-				current: selection,
-				assembled: void 0
-			});
-		}
-	});
-	const store = createTranscriptStore();
-	const off = ctx.on("session/event", (session, event) => {
-		if (session.id === agent.session.id) store.apply(event);
+	const cwd = process.cwd();
+	const target = await resolveTarget(startup, persistence, cwd);
+	const defaults = defaultModel.currentSelection();
+	let picked;
+	let session;
+	let agent;
+	if (target.resume) {
+		agent = (await agents.resume({
+			resumeSessionId: SessionId(target.sessionId),
+			agentOptions: {
+				provider: defaults.provider,
+				model: defaults.model
+			},
+			setup: (agentCtx) => {
+				installModelSelection(agentCtx, {
+					get current() {
+						if (picked !== void 0) return picked;
+						const logged = agentCtx.agent?.session.requestHeader()?.config;
+						if (logged !== void 0) return {
+							provider: logged.provider,
+							model: logged.model,
+							...logged.reasoningEffort === void 0 ? {} : { reasoningEffort: logged.reasoningEffort }
+						};
+						return defaults;
+					},
+					set current(next) {
+						picked = next;
+					},
+					assembled: void 0
+				});
+			}
+		})).agent;
+		session = agent.session;
+	} else {
+		agent = (await agents.create({
+			sessionId: SessionId(target.sessionId),
+			meta: { cwd },
+			agentOptions: {
+				provider: defaults.provider,
+				model: defaults.model
+			},
+			setup: (agentCtx) => {
+				installModelSelection(agentCtx, {
+					get current() {
+						return picked ?? defaults;
+					},
+					set current(next) {
+						picked = next;
+					},
+					assembled: void 0
+				});
+			}
+		})).agent;
+		session = agent.session;
+	}
+	const store = createTranscriptStore(session.events);
+	const off = ctx.on("session/event", (subject, event) => {
+		if (subject.id === session.id) store.apply(event);
 	});
+	const commands = watchCommands(ctx);
+	commands.setAgent(agent);
+	const skills = watchSkills(ctx);
+	skills.setAgent(agent);
+	const approval = mountApprovalAnswerer(ctx, (candidate) => candidate.id === agent.id, (request) => approvalCommandPreview(store.getView().entries, request.callId, request.toolName));
+	const questions = mountQuestionProvider(ctx);
+	const mentions = createMentions(ctx, agent, session.header.cwd ?? cwd);
+	const bridge = { notify: () => {} };
 	const mountRef = {};
 	let quitting = false;
 	const quit = () => {
@@ -580,44 +2248,164 @@ async function run(ctx, io) {
 		quitting = true;
 		off();
 		mountRef.current?.unmount();
-		sessions.flush(agent.session).catch((flushError) => {
+		sessions.flush(session).catch((flushError) => {
 			internals.stderr.write(`dsh: session flush failed: ${flushError instanceof Error ? flushError.message : String(flushError)}\n`);
 		}).then(() => {
 			io.exit(0);
 		});
 	};
-	mountRef.current = io.mount(createElement(App, {
-		store,
-		model: `${selection.provider}/${selection.model}`,
-		cwd: basename(process.cwd()),
-		branch: gitBranch(process.cwd()),
-		sessionId: agent.session.id.slice(-8),
-		onSubmit: (text) => {
-			agent.followup(createUserMessage({
+	/** Run one slash line through the command registry (closed namespace). */
+	const runSlash = (line) => {
+		const registry = ctx.get("commands");
+		if (registry === void 0) {
+			bridge.notify("no command registry is mounted in this composition");
+			return;
+		}
+		const controller = new AbortController();
+		registry.execute(agent, line, controller.signal).then((execution) => {
+			if (execution === void 0) agent.followup(createUserMessage({
 				content: [{
 					type: "text",
-					text
+					text: line
 				}],
 				source: { kind: "user" }
 			}));
-		},
-		onQuit: quit
+		}, (error) => {
+			bridge.notify(`command failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+	};
+	/** Deliver one readable line to the agent, expanding session mentions first. */
+	const send = (text, mode) => {
+		const line = text.trim();
+		if (line === "") return;
+		if (isSlashLine(line) && mode === "followup") {
+			runSlash(line);
+			return;
+		}
+		let parsed;
+		try {
+			parsed = mentions.parse(line);
+		} catch (error) {
+			bridge.notify(`invalid session reference: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		const deliver = (readable, context) => {
+			if (context !== void 0) agent.inject(context);
+			const message = createUserMessage({
+				content: [{
+					type: "text",
+					text: readable
+				}],
+				source: { kind: "user" }
+			});
+			if (mode === "steer") {
+				agent.steer(message);
+				bridge.notify("steering queued — the next step sees it");
+			} else agent.followup(message);
+		};
+		if (parsed.references.length === 0) {
+			deliver(parsed.text);
+			return;
+		}
+		const controller = new AbortController();
+		mentions.prepare(parsed, controller.signal).then((prepared) => {
+			deliver(prepared.text, prepared.additionalContext);
+		}, (error) => {
+			if (controller.signal.aborted) return;
+			bridge.notify(`session reference failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+	};
+	/** Dispatch one submitted line: slash commands to the registry, other text to the agent. */
+	const dispatch = (text) => {
+		send(text, "followup");
+	};
+	/**
+	* Submit steering: a running driver consumes the text at its next step
+	* boundary (the inbox delivers between steps); an idle driver just starts
+	* a turn, so this doubles as the busy-state submit path.
+	*/
+	const steer = (text) => {
+		send(text, "steer");
+	};
+	/** Interrupt the running turn (Esc); true when a turn was actually cancelled. */
+	const interrupt = () => {
+		if (agent.status !== "running") return false;
+		agent.cancel({ kind: "user" });
+		bridge.notify("turn cancelled — Ctrl+C or /quit to exit");
+		return true;
+	};
+	/**
+	* Cycle to the next permission preset (Shift+Tab, the Claude-Code
+	* permission-mode convention mapped onto dsh presets). A session in a
+	* custom knob state wraps to the first declared preset.
+	*/
+	const cyclePermission = () => {
+		const service = ctx.get("permissionPresets");
+		if (service === void 0 || service.names.length === 0) {
+			bridge.notify("permission presets are not mounted in this composition");
+			return "";
+		}
+		const at = service.names.indexOf(service.current(session.events));
+		const next = service.names[(at + 1) % service.names.length] ?? "";
+		if (next === "") return "";
+		service.set(session, next);
+		return next;
+	};
+	/** Apply one /model selection: takes effect from the next assembled step. */
+	const selectModel = (row) => {
+		picked = {
+			provider: row.provider,
+			model: row.model
+		};
+		return `${row.provider}/${row.model}`;
+	};
+	const initialModel = store.getView().model !== "" ? store.getView().model : `${defaults.provider}/${defaults.model}`;
+	mountRef.current = io.mount(createElement(App, {
+		store,
+		approval,
+		questions,
+		commands,
+		skills,
+		model: initialModel,
+		cwd: basename(cwd),
+		branch: gitBranch(cwd),
+		sessionId: session.id.slice(-8),
+		resumed: target.resume,
+		dispatch,
+		steer,
+		interrupt,
+		quit,
+		loadModels: () => loadModelDirectory(ctx),
+		loadMentions: mentions.candidates,
+		cyclePermission,
+		selectModel,
+		onBridgeReady: (instance) => {
+			bridge.notify = instance.notify;
+		}
 	}));
 }
 /**
 * Mount the interactive terminal driver.
 * @param ctx - plugin context carrying core services and the launcher-provided exit request.
+* @param config - validated startup config resolved from the tuiStartup provider.
 */
-function apply(ctx) {
+function apply(ctx, config) {
+	const startup = config.startup.kind === "resume" && config.startup.sessionId !== void 0 ? {
+		kind: "resume",
+		sessionId: config.startup.sessionId
+	} : config.startup.kind === "latest" ? { kind: "latest" } : config.startup.kind === "named" && config.startup.sessionId !== void 0 ? {
+		kind: "named",
+		sessionId: config.startup.sessionId
+	} : { kind: "fresh" };
 	const exit = ctx.get("appExit");
 	if (exit === void 0) throw new Error("tui-runner: the launcher must provide ctx.appExit before the tree mounts");
 	const io = {
 		mount: internals.mount,
 		exit
 	};
-	run(ctx, io).catch((error) => {
+	run(ctx, startup, io).catch((error) => {
 		fail(io, error);
 	});
 }
 //#endregion
-export { apply, inject, name };
+export { Config, apply, inject, name };