dsh-code 1.0.5 → 1.0.7

package/lib/index.mjs

@@ -2,14 +2,14 @@ import { n as __require, r as __toESM, t as __commonJSMin } from "./rolldown-run
 import { a as inkColor, c as chalk, i as getTheme, n as dim, o as parseThemeName, r as getPalette, s as setTheme } from "./theme-DCT8Y2xf.mjs";
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
-import { readFileSync, realpathSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import os, { homedir } from "node:os";
-import { appendFile, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
-import { MessageId, ReasoningEffortId, boundContextSummary, createUserMessage, normalizeApiKey } from "@deepseek-ai/dsh-llm";
-import { SessionId } from "@deepseek-ai/dsh-session";
+import { MessageId, ReasoningEffortId, assistantStreamFirstTokenTime, boundContextSummary, createUserMessage, isTokenDelta, normalizeApiKey } from "@deepseek-ai/dsh-llm";
+import { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset } from "@deepseek-ai/dsh-session";
 import { PassThrough, Stream } from "node:stream";
 import process$1, { cwd, env } from "node:process";
 import { EventEmitter } from "node:events";
@@ -24732,6 +24732,225 @@ function ThemePanel({ current, select, close }) {
 		wrap: "truncate-end"
 	}, truncateColumns(`↑↓ choose · enter apply · esc/q close${hiddenThemes > 0 ? ` · +${hiddenThemes} more` : ""}`, viewport.contentColumns)));
 }
+/** Keep the newest UPDATE_OUTPUT_CAP lines of streamed update output. */
+function clipUpdateLines(lines) {
+	return lines.length <= 800 ? lines : lines.slice(lines.length - 800);
+}
+/** Rendered facts of one probe: current/target versions, actions, refusals. */
+function updatePlanView(status) {
+	const rows = [];
+	const latest = status.code.latest ?? "unknown";
+	rows.push(status.code.latest !== null && status.code.latest === status.code.running ? {
+		key: "code",
+		text: `dsh-code    ${status.code.running} (latest)`
+	} : {
+		key: "code",
+		text: `dsh-code    ${status.code.running} → ${latest}`
+	});
+	if (status.host.targetLine === null) rows.push({
+		key: "host",
+		text: "harness     pinned line unreadable — update would install @deepseek-ai/dsh@latest",
+		tone: "warn"
+	});
+	else if (status.host.installed === null) rows.push({
+		key: "host",
+		text: `harness     not installed → ${status.host.targetLine}`
+	});
+	else if (status.host.installed === status.host.targetLine) rows.push({
+		key: "host",
+		text: `harness     ${status.host.installed} (on pinned line)`
+	});
+	else rows.push({
+		key: "host",
+		text: `harness     ${status.host.installed} → ${status.host.targetLine}`
+	});
+	const mounted = status.profile.mounted === null ? status.profile.spec ?? "not mounted" : `dsh-code ${status.profile.mounted}`;
+	rows.push({
+		key: "profile",
+		text: `profile     ${mounted}${status.profile.localCheckout ? " · local checkout" : ""}`,
+		tone: status.profile.localCheckout ? "dim" : void 0
+	});
+	for (const plugin of status.plan.pluginSpecs) rows.push({
+		key: `plugin:${plugin}`,
+		text: `plugin      ${plugin}`,
+		tone: "dim"
+	});
+	const registryBlocker = status.blockers.registry ?? null;
+	if (registryBlocker !== null) rows.push({
+		key: "blocker:registry",
+		text: registryBlocker,
+		tone: "error"
+	});
+	if (status.blockers.downgrade) rows.push({
+		key: "blocker:downgrade",
+		text: `refusing to downgrade the host: dsh-code@${latest} needs ${status.host.targetLine ?? "the pinned line"}, but ${status.host.installed ?? "the installed host"} is newer — wait for the next dsh-code release`,
+		tone: "error"
+	});
+	const checkoutBlocker = status.blockers.localCheckout ?? null;
+	if (checkoutBlocker !== null) for (const [index, line] of checkoutBlocker.entries()) rows.push({
+		key: `blocker:checkout:${index}`,
+		text: line,
+		tone: "error"
+	});
+	if (status.upToDate) rows.push({
+		key: "uptodate",
+		text: "everything is already on the pinned line — nothing to update",
+		tone: "ok"
+	});
+	return {
+		rows,
+		runnable: status.upToDate !== true && registryBlocker === null && status.blockers.downgrade !== true && checkoutBlocker === null
+	};
+}
+/** Footer hint line per phase; the plan phase names the confirm key only when runnable. */
+function updateFooter(phase, runnable, upToDate) {
+	if (phase === "probe") return "checking… · esc close";
+	if (phase === "error") return "r recheck · esc close";
+	if (phase === "apply") return "updating… · ↑↓ scroll · esc waits";
+	if (phase === "done") return "r recheck · esc close";
+	if (upToDate) return "up to date · r recheck · esc close";
+	return runnable ? "enter update · r recheck · esc close" : "blocked · r recheck · esc close";
+}
+/**
+* The /update surface: probe on open (and on r), confirm with enter/y,
+* stream the aligned apply, and land on a bounded result view. Escape is
+* locked while the apply child runs — killing npm mid-install is exactly
+* the half-updated state this command exists to prevent.
+*/
+function UpdatePanel({ probe, apply, close, notify }) {
+	const [phase, setPhase] = (0, import_react.useState)("probe");
+	const [status, setStatus] = (0, import_react.useState)();
+	const [probeError, setProbeError] = (0, import_react.useState)();
+	const [lines, setLines] = (0, import_react.useState)([]);
+	const [exit, setExit] = (0, import_react.useState)();
+	const [applyError, setApplyError] = (0, import_react.useState)();
+	const [anchor, setAnchor] = (0, import_react.useState)("tail");
+	const [epoch, setEpoch] = (0, import_react.useState)(0);
+	(0, import_react.useEffect)(() => {
+		let disposed = false;
+		setPhase("probe");
+		setStatus(void 0);
+		setProbeError(void 0);
+		setAnchor("tail");
+		probe().then((value) => {
+			if (disposed) return;
+			setStatus(value);
+			setPhase("plan");
+		}, (reason) => {
+			if (disposed) return;
+			setProbeError(reason instanceof Error ? reason.message : String(reason));
+			setPhase("error");
+		});
+		return () => {
+			disposed = true;
+		};
+	}, [epoch, probe]);
+	const stdout = useStdout().stdout;
+	const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+	const start = () => {
+		if (phase !== "plan" || status === void 0) return;
+		if (!updatePlanView(status).runnable) return;
+		setPhase("apply");
+		setLines([]);
+		setExit(void 0);
+		setApplyError(void 0);
+		setAnchor("tail");
+		apply((line) => {
+			setLines((previous) => clipUpdateLines([...previous, singleLineText(line)]));
+		}).then((code) => {
+			setExit(code);
+			setPhase("done");
+			notify(code === 0 ? "update installed — restart dsh to activate" : `update failed (exit ${code})`, code === 0 ? "info" : "error");
+		}, (reason) => {
+			const message = reason instanceof Error ? reason.message : String(reason);
+			setApplyError(message);
+			setPhase("done");
+			notify(`update failed: ${message}`, "error");
+		});
+	};
+	const planView = status === void 0 ? void 0 : updatePlanView(status);
+	const rows = phase === "probe" ? [{
+		key: "probe",
+		text: "checking npm for the aligned update…",
+		tone: "dim"
+	}] : phase === "error" ? [{
+		key: "error",
+		text: singleLineText(probeError ?? "probe failed"),
+		tone: "error"
+	}] : phase === "plan" && planView !== void 0 ? planView.rows : phase === "apply" ? lines.map((line, index) => ({
+		key: `out:${index}`,
+		text: line,
+		tone: "dim"
+	})) : [
+		...exit === 0 ? [{
+			key: "ok",
+			text: "update installed — restart dsh to load the new version (/quit or ctrl+c)",
+			tone: "ok"
+		}] : [],
+		...exit !== void 0 && exit !== 0 ? [{
+			key: "fail",
+			text: `update failed (exit ${exit})`,
+			tone: "error"
+		}] : [],
+		...applyError !== void 0 ? [{
+			key: "fail:start",
+			text: singleLineText(applyError),
+			tone: "error"
+		}] : [],
+		...lines.map((line, index) => ({
+			key: `out:${index}`,
+			text: line,
+			tone: "dim"
+		}))
+	];
+	const budget = Math.max(1, viewport.bodyRows);
+	const tailOffset = clampScroll(Math.max(0, rows.length - budget), rows.length, budget);
+	const offset = anchor === "tail" ? tailOffset : clampScroll(anchor, rows.length, budget);
+	useInput((input, key) => {
+		if (phase === "apply") {
+			if (key.upArrow) setAnchor(offset <= 0 ? 0 : offset - 1);
+			if (key.downArrow && offset >= tailOffset) setAnchor("tail");
+			else if (key.downArrow) setAnchor(offset + 1);
+			return;
+		}
+		if (key.escape || input === "q") return close();
+		if (input === "r") {
+			setEpoch((value) => value + 1);
+			return;
+		}
+		if (key.return || input === "y") {
+			start();
+			return;
+		}
+		if (key.upArrow) setAnchor(offset <= 0 ? 0 : offset - 1);
+		if (key.downArrow && offset >= tailOffset) setAnchor("tail");
+		else if (key.downArrow) setAnchor(offset + 1);
+	});
+	if (viewport.maxHeight === 0 || viewport.compact) {
+		const summary = phase === "probe" ? "checking…" : phase === "error" ? "probe failed" : phase === "apply" ? singleLineText(lines[lines.length - 1] ?? "updating…") : phase === "done" ? exit === 0 ? "installed — restart to activate" : "failed" : status?.upToDate === true ? "up to date" : planView?.runnable === true ? "enter updates" : "blocked";
+		return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns(singleLineText(`/update · ${summary}`), viewport.contentColumns));
+	}
+	const visible = rows.slice(offset, offset + budget);
+	const toneColor = (tone) => tone === "ok" ? inkColor(getPalette().success) : tone === "error" ? inkColor(getPalette().error) : tone === "warn" ? inkColor(getPalette().warn) : tone === "dim" ? inkColor(getPalette().dim) : void 0;
+	const title = status === void 0 ? "/update · aligned upgrade" : `/update · dsh-code ${status.code.running}${status.code.latest !== null && status.code.latest !== status.code.running ? ` → ${status.code.latest}` : ""}`;
+	return (0, import_react.createElement)(Box, {
+		width: viewport.outerColumns,
+		borderStyle: "round",
+		borderColor: inkColor(getPalette().dim),
+		flexDirection: "column",
+		paddingX: 1
+	}, (0, import_react.createElement)(Text, {
+		color: inkColor(getPalette().brandBright),
+		wrap: "truncate-end"
+	}, truncateColumns(singleLineText(title), viewport.contentColumns)), ...visible.map((row) => (0, import_react.createElement)(Text, {
+		key: row.key,
+		color: toneColor(row.tone),
+		wrap: "truncate-end"
+	}, truncateColumns(`  ${singleLineText(row.text)}`, viewport.contentColumns))), (0, import_react.createElement)(Text, {
+		dimColor: true,
+		wrap: "truncate-end"
+	}, truncateColumns(singleLineText(updateFooter(phase, planView?.runnable ?? false, status?.upToDate === true)), viewport.contentColumns)));
+}
 //#endregion
 //#region src/whale-glyph.ts
 /** Half-block whale glyph rows; render with the brand color. */
@@ -24797,6 +25016,166 @@ function dshKernelVersion() {
 	return cachedDshKernelVersion;
 }
 //#endregion
+//#region src/terminal-title.ts
+/**
+* Terminal tab/window title management for the TUI.
+*
+* Terminals label their tab from the window title, which an application sets
+* with an OSC 0 sequence; without one the tab shows the process name ("node").
+* The title text is untrusted display content (session names arrive through
+* events and user input), so it is sanitized before emission: control
+* characters and bidi/invisible formatting codepoints are stripped, whitespace
+* runs collapse to single spaces, and the result is bounded. Clearing writes
+* an empty OSC payload and the terminal falls back to its own default; the
+* previously set title is not portable to read back and is never restored.
+*
+* @module @deepseek-ai/dsh-code/terminal-title
+*/
+/** The host process title at module load, restored on unmount. On Windows
+* this reaches the tab through SetConsoleTitleW (ConPTY reflects it to VS
+* Code and friends without any user setting); on POSIX it becomes the ps
+* name. Node replaces the argv memory, so the original must be saved before
+* the first assignment. */
+const initialProcessTitle = process.title;
+/** Tab label before a session carries a name. */
+const DEFAULT_TERMINAL_TITLE = "deepseek";
+/** Control characters, DEL/C1 range, and bidi or invisible formatting
+* codepoints that could terminate the OSC sequence or visually reorder the
+* title relative to its underlying text. */
+const DISALLOWED_TITLE_CHARS = /[\u0000-\u001F\u007F-\u009F\u00AD\u034F\u061C\u180E\u200B-\u200F\u202A-\u202E\u2060-\u206F\uFEFF]/;
+/** Normalize untrusted title text into one bounded display line: disallowed
+* codepoints dropped, whitespace runs collapsed to single spaces, leading and
+* trailing whitespace removed, length bounded. */
+function sanitizeTerminalTitle(text) {
+	const chars = [];
+	let pendingSpace = false;
+	for (const ch of text) {
+		if (DISALLOWED_TITLE_CHARS.test(ch)) continue;
+		if (ch.trim() === "") {
+			if (chars.length > 0) pendingSpace = true;
+			continue;
+		}
+		if (pendingSpace) {
+			if (chars.length + 1 >= 240) break;
+			chars.push(" ");
+			pendingSpace = false;
+		}
+		if (chars.length >= 240) break;
+		chars.push(ch);
+	}
+	return chars.join("");
+}
+/** Build one OSC 0 title sequence. An empty sanitized title yields an empty
+* string: emitting nothing is distinct from clearing, which is a separate
+* policy decision made by the caller. */
+function terminalTitleSequence(text) {
+	const title = sanitizeTerminalTitle(text);
+	return title === "" ? "" : `\x1b]0;${title}\x07`;
+}
+/** Clear the managed title with an empty OSC payload; the terminal falls back
+* to its own default label. */
+function clearTerminalTitleSequence() {
+	return "\x1B]0;\x07";
+}
+/** VS Code renders an application-set tab title only when
+* "terminal.integrated.tabs.title" maps to the sequence variable; the editor
+* default shows the process name instead ("node" for a Node CLI). Inside a VS
+* Code integrated terminal, align the user settings once: if the key is
+* absent, insert it and keep a one-shot backup of the original file. A value
+* the user already set is never overwritten, an unparseable file is never
+* touched, and every failure degrades to a no-op - the OSC and process-title
+* channels keep working everywhere else. */
+function ensureVsCodeTabTitleSetting(options = {}) {
+	const env = options.env ?? process.env;
+	if (env["TERM_PROGRAM"] !== "vscode") return {
+		wrote: false,
+		reason: "not-vscode"
+	};
+	if ((options.isTTY ?? process.stdout.isTTY) !== true) return {
+		wrote: false,
+		reason: "not-vscode"
+	};
+	let file = options.settingsFile;
+	if (file === void 0) {
+		const base = process.platform === "win32" ? env["APPDATA"] : env["HOME"];
+		if (base === void 0 || base === "") return {
+			wrote: false,
+			reason: "error"
+		};
+		file = process.platform === "win32" ? join(base, "Code", "User", "settings.json") : join(base, ".config", "Code", "User", "settings.json");
+	}
+	try {
+		if (!existsSync(file)) {
+			mkdirSync(dirname(file), { recursive: true });
+			writeFileSync(file, "{\n  \"terminal.integrated.tabs.title\": \"${sequence}\"\n}\n", "utf8");
+			return { wrote: true };
+		}
+		const text = readFileSync(file, "utf8");
+		if (text.includes("\"terminal.integrated.tabs.title\"")) return {
+			wrote: false,
+			reason: "key-present"
+		};
+		try {
+			JSON.parse(text);
+		} catch {
+			return {
+				wrote: false,
+				reason: "unparseable"
+			};
+		}
+		const close = text.lastIndexOf("}");
+		if (close < 0) return {
+			wrote: false,
+			reason: "unparseable"
+		};
+		const before = text.slice(0, close);
+		const trimmedBefore = before.replace(/[ \t\r\n]+$/, "");
+		const tail = before.slice(trimmedBefore.length);
+		const inserted = (trimmedBefore.trim() !== "" && !trimmedBefore.trimEnd().endsWith("{") ? "," : "") + "\n    \"terminal.integrated.tabs.title\": \"${sequence}\"\n";
+		writeFileSync(file + ".dsh-backup", text, "utf8");
+		writeFileSync(file, trimmedBefore + inserted + tail + text.slice(close), "utf8");
+		return { wrote: true };
+	} catch {
+		return {
+			wrote: false,
+			reason: "error"
+		};
+	}
+}
+/**
+* Keep the terminal tab label on `title` (sanitized; empty titles leave the
+* current label alone). Two delivery channels run in parallel: the OSC 0
+* sequence to stdout, and the host process title. Writes are deduplicated by
+* title, and on unmount the managed title is cleared and the process title
+* restored so the host shell regains its default label.
+*/
+function useTerminalTitle(title, options = {}) {
+	const { clearOnUnmount = true } = options;
+	const { stdout } = useStdout();
+	const writtenRef = (0, import_react.useRef)(void 0);
+	const processTitleRef = (0, import_react.useRef)(false);
+	(0, import_react.useLayoutEffect)(() => {
+		if (stdout === void 0) return void 0;
+		return () => {
+			if (processTitleRef.current) {
+				processTitleRef.current = false;
+				process.title = initialProcessTitle;
+			}
+			if (clearOnUnmount && writtenRef.current !== void 0) stdout.write(clearTerminalTitleSequence());
+		};
+	}, [stdout, clearOnUnmount]);
+	(0, import_react.useLayoutEffect)(() => {
+		if (stdout === void 0) return;
+		if (title === writtenRef.current) return;
+		const sequence = terminalTitleSequence(title);
+		if (sequence === "") return;
+		stdout.write(sequence);
+		process.title = sanitizeTerminalTitle(title);
+		processTitleRef.current = true;
+		writtenRef.current = title;
+	}, [stdout, title]);
+}
+//#endregion
 //#region src/render/tool-preview.ts
 /**
 * Bounded preview line for a tool invocation's raw JSON arguments: the first
@@ -25083,6 +25462,75 @@ function appendStreamingTail(current, delta) {
 	const next = current + delta;
 	return next.length <= MAX_STREAMING_CHARS ? next : next.slice(-65536);
 }
+/** Fold one `schedule/change` into the active-reminder list (create/delete/dispatch). */
+function applyScheduleChange(rows, data) {
+	if (data.operation === "create" && data.schedule !== void 0) {
+		const schedule = data.schedule;
+		const row = {
+			id: schedule.id,
+			kind: schedule.kind,
+			prompt: schedule.prompt,
+			targetAt: Date.parse(schedule.scheduledAt),
+			...schedule.kind === "every" ? { everySeconds: schedule.everySeconds ?? 0 } : {}
+		};
+		return [...rows.filter((existing) => existing.id !== schedule.id), row];
+	}
+	if (data.operation === "delete" && data.id !== void 0) return rows.filter((existing) => existing.id !== data.id);
+	if (data.operation === "dispatch" && data.id !== void 0) {
+		if (data.acceptedAt === void 0) return rows.filter((existing) => existing.id !== data.id);
+		const accepted = Date.parse(data.acceptedAt);
+		return rows.map((existing) => existing.id === data.id ? {
+			...existing,
+			targetAt: nextEveryTarget(existing.targetAt, accepted, existing.everySeconds ?? 0)
+		} : existing);
+	}
+	return rows;
+}
+/** First anchor-aligned target after `acceptedAt`, stepping from the previous aligned target. */
+function nextEveryTarget(previousTarget, acceptedAt, everySeconds) {
+	const interval = Math.max(1, everySeconds) * 1e3;
+	if (acceptedAt <= previousTarget) return previousTarget + interval;
+	return previousTarget + Math.ceil((acceptedAt - previousTarget + 1) / interval) * interval;
+}
+/** Plugin snapshot sources folded into token stats but never rendered as rows. */
+const HIDDEN_SNAPSHOT_PLUGINS = /* @__PURE__ */ new Set(["time-context", "tmux-context"]);
+/** Plugin prompt sources rendered as full user rows (they ARE the conversation). */
+const REMINDER_PLUGINS = /* @__PURE__ */ new Set(["schedule"]);
+/** Assemble the effective system prompt from surface nodes: head text plus every later non-empty node. */
+function assembleSystemPrompt(nodes) {
+	if (nodes.size === 0) return "";
+	return [...nodes.entries()].sort((left, right) => left[0] - right[0]).map(([, text]) => text).filter((text) => text !== "").join("\n\n");
+}
+/**
+* Apply one surface event's replace to the live system nodes. Any surface
+* event may shadow system nodes — the kernel's compaction summary lands as a
+* `user/message` replace whose range can cover later system nodes (only node
+* 0 is compaction-protected upstream) — so every surface fold retires covered
+* nodes, not just `system/message` itself.
+* @param nodes - the live system-node map (mutated when the event replaces).
+* @param surfaceOp - the surface operation the event carries, when it is a
+* surface event (log-only events have none and change nothing).
+* @returns the reassembled prompt when nodes were retired, `changed: false`
+* when the event shadows nothing.
+*/
+function retireShadowedSystemNodes(nodes, surfaceOp) {
+	if (surfaceOp === void 0 || surfaceOp === "append") return {
+		prompt: "",
+		changed: false
+	};
+	let changed = false;
+	for (const seq of nodes.keys()) if (seq >= surfaceOp.startSeq && seq <= surfaceOp.endSeq) {
+		nodes.delete(seq);
+		changed = true;
+	}
+	return changed ? {
+		prompt: assembleSystemPrompt(nodes),
+		changed
+	} : {
+		prompt: "",
+		changed: false
+	};
+}
 /** Join the text blocks of a content list; non-text blocks contribute nothing. */
 function textOf(content) {
 	return content.filter((block) => block.type === "text").map((block) => block.text).join("");
@@ -25091,6 +25539,10 @@ function textOf(content) {
 function imagesOf(content) {
 	return content.filter((block) => block.type === "image").map((block) => block.attachment);
 }
+/** Durable file references in their model-visible order. */
+function filesOf(content) {
+	return content.filter((block) => block.type === "file").map((block) => block.attachment);
+}
 /** Human-readable bounded image labels for transcript, inspector, and export surfaces. */
 function imageLabels(images) {
 	if (images === void 0 || images.length === 0) return "";
@@ -25101,9 +25553,19 @@ function imageLabels(images) {
 		return `[image: ${name} · ${original === void 0 ? `${image.width}×${image.height}` : `${image.width}×${image.height} · original ${original.width}×${original.height}`} · ${image.bytes} B]`;
 	}).join("\n");
 }
-/** Prompt text with its durable image labels, without exposing local paths or bytes. */
+/** Human-readable bounded file labels for the same surfaces (0.1.5 file blocks). */
+function fileLabels(files) {
+	if (files === void 0 || files.length === 0) return "";
+	return files.map((file, index) => {
+		const rawName = file.name?.trim() || `file ${index + 1}`;
+		return `[file: ${rawName.length <= 80 ? rawName : `${rawName.slice(0, 79)}…`} · ${file.bytes} B]`;
+	}).join("\n");
+}
+/** Prompt text with its durable image and file labels, without exposing local paths or bytes. */
 function promptDisplayText(entry) {
-	const labels = imageLabels(entry.images);
+	const imageText = imageLabels(entry.images);
+	const fileText = fileLabels(entry.files);
+	const labels = imageText === "" ? fileText : fileText === "" ? imageText : `${imageText}\n${fileText}`;
 	return entry.text === "" ? labels : labels === "" ? entry.text : `${entry.text}\n${labels}`;
 }
 /** Join the reasoning blocks of a content list; non-reasoning blocks contribute nothing. */
@@ -25150,8 +25612,10 @@ function createReplayAccumulator() {
 		plan: false,
 		permission: "",
 		title: "",
+		systemPrompt: "",
 		sandbox: "",
 		goal: void 0,
+		schedules: [],
 		stats: {
 			turns: 0,
 			steps: 0,
@@ -25185,6 +25649,7 @@ function createReplayAccumulator() {
 		turnFiles: /* @__PURE__ */ new Map(),
 		turnSteps: /* @__PURE__ */ new Map(),
 		turnTools: /* @__PURE__ */ new Map(),
+		systemNodes: /* @__PURE__ */ new Map(),
 		ops: 0
 	};
 }
@@ -25267,6 +25732,17 @@ function retireReplayEntry(acc, index) {
 * like the copy-on-write reducer returning its input view unchanged.
 */
 function replayProjectEvent(acc, event) {
+	const shadow = retireShadowedSystemNodes(acc.systemNodes, event.surfaceOp);
+	if (shadow.changed) {
+		acc.systemPrompt = shadow.prompt;
+		acc.stats = {
+			...acc.stats,
+			contextSegments: {
+				...acc.stats.contextSegments,
+				system: estimateTokens(shadow.prompt)
+			}
+		};
+	}
 	switch (event.type) {
 		case "user/message": {
 			const message = event.data;
@@ -25285,12 +25761,14 @@ function replayProjectEvent(acc, event) {
 			}
 			const text = textOf(message.content);
 			const images = imagesOf(message.content);
-			if (message.source.kind === "user") {
+			const files = filesOf(message.content);
+			if (message.source.kind === "user" || message.source.kind === "plugin" && REMINDER_PLUGINS.has(message.source.plugin)) {
 				appendReplayEntry(acc, {
 					kind: "user",
 					text,
 					notice: false,
-					...images.length === 0 ? {} : { images }
+					...images.length === 0 ? {} : { images },
+					...files.length === 0 ? {} : { files }
 				});
 				acc.stats = {
 					...acc.stats,
@@ -25301,7 +25779,17 @@ function replayProjectEvent(acc, event) {
 				};
 				return true;
 			}
-			const notice = message.source.kind === "plugin" && message.source.form === "notice" ? message.source.summary : message.source.kind;
+			if (message.source.kind === "plugin" && HIDDEN_SNAPSHOT_PLUGINS.has(message.source.plugin)) {
+				acc.stats = {
+					...acc.stats,
+					contextSegments: {
+						...acc.stats.contextSegments,
+						system: acc.stats.contextSegments.system + estimateTokens(text)
+					}
+				};
+				return true;
+			}
+			const notice = message.source.kind === "plugin" && message.source.form === "notice" ? message.source.summary : message.source.kind === "plugin" ? message.source.plugin : message.source.kind;
 			const summary = boundContextSummary(notice);
 			appendReplayEntry(acc, {
 				kind: "user",
@@ -25335,45 +25823,68 @@ function replayProjectEvent(acc, event) {
 			ids.splice(start, 0, ...inserted.map((message) => message.id));
 			for (const message of inserted) {
 				const images = imagesOf(message.content);
+				const files = filesOf(message.content);
 				appendReplayEntry(acc, {
 					kind: "pending",
 					messageId: message.id,
 					target,
 					text: pendingText(message.content),
-					...images.length === 0 ? {} : { images }
+					...images.length === 0 ? {} : { images },
+					...files.length === 0 ? {} : { files }
 				});
 				indexList(acc.pendingIndex, message.id).push(acc.entries.length - 1);
 				acc.ops += 1;
 			}
 			return true;
 		}
-		case "assistant/chunk": {
-			const chunk = event.data.chunk;
+		case "system/message": {
+			const text = textOf(event.data.message.content);
+			retireShadowedSystemNodes(acc.systemNodes, event.surfaceOp);
+			acc.systemNodes.set(event.seq, text);
+			acc.systemPrompt = assembleSystemPrompt(acc.systemNodes);
+			acc.stats = {
+				...acc.stats,
+				contextSegments: {
+					...acc.stats.contextSegments,
+					system: estimateTokens(acc.systemPrompt)
+				}
+			};
+			return true;
+		}
+		case "assistant/attempt": {
 			const key = `${event.data.turn}:${event.data.step}`;
-			if ((chunk.type === "text-delta" || chunk.type === "reasoning-delta" ? chunk.text : "") !== "" && !acc.firstChunkAt.has(key)) {
-				acc.firstChunkAt.set(key, event.time);
-				const started = acc.stepStart.get(key);
-				if (started !== void 0) acc.stats = {
-					...acc.stats,
-					ttftMs: acc.stats.ttftMs + Math.max(0, event.time - started),
-					ttftSteps: acc.stats.ttftSteps + 1
-				};
-			}
-			if (chunk.type === "text-delta") {
-				acc.streaming = appendStreamingTail(acc.streaming, chunk.text);
-				return true;
-			}
-			if (chunk.type === "reasoning-delta") {
-				acc.streamingReasoning = appendStreamingTail(acc.streamingReasoning, chunk.text);
-				return true;
+			let changed = false;
+			if (!acc.firstChunkAt.has(key)) {
+				const first = assistantStreamFirstTokenTime(event.data.stream ?? []);
+				if (first !== void 0) {
+					acc.firstChunkAt.set(key, first);
+					const started = acc.stepStart.get(key);
+					if (started !== void 0) acc.stats = {
+						...acc.stats,
+						ttftMs: acc.stats.ttftMs + Math.max(0, first - started),
+						ttftSteps: acc.stats.ttftSteps + 1
+					};
+					changed = true;
+				}
 			}
-			return false;
+			const streamed = acc.streaming !== "" || acc.streamingReasoning !== "";
+			acc.streaming = "";
+			acc.streamingReasoning = "";
+			return changed || streamed;
 		}
 		case "assistant/message": {
 			const key = `${event.data.turn}:${event.data.step}`;
 			const started = acc.stepStart.get(key);
 			acc.stepStart.delete(key);
-			const firstChunk = acc.firstChunkAt.get(key);
+			let firstChunk = acc.firstChunkAt.get(key);
+			if (firstChunk === void 0) {
+				firstChunk = assistantStreamFirstTokenTime(event.data.stream ?? []);
+				if (firstChunk !== void 0 && started !== void 0) acc.stats = {
+					...acc.stats,
+					ttftMs: acc.stats.ttftMs + Math.max(0, firstChunk - started),
+					ttftSteps: acc.stats.ttftSteps + 1
+				};
+			}
 			acc.firstChunkAt.delete(key);
 			if (acc.turnSteps.get(event.data.turn) === key) acc.turnSteps.delete(event.data.turn);
 			const usage = event.data.usage;
@@ -25596,6 +26107,10 @@ function replayProjectEvent(acc, event) {
 			});
 			return true;
 		}
+		case "schedule/change":
+			acc.schedules = applyScheduleChange(acc.schedules, event.data);
+			acc.ops += 1;
+			return true;
 		case "session/title":
 			acc.title = event.data.title;
 			return true;
@@ -25632,11 +26147,7 @@ function replayProjectEvent(acc, event) {
 			acc.model = `${config.provider}/${config.model}`;
 			acc.stats = {
 				...acc.stats,
-				reasoningEffort: config.reasoningEffort === void 0 ? "" : String(config.reasoningEffort),
-				contextSegments: {
-					...acc.stats.contextSegments,
-					system: estimateTokens(event.data.header.system ?? "")
-				}
+				reasoningEffort: config.reasoningEffort === void 0 ? "" : String(config.reasoningEffort)
 			};
 			return true;
 		}
@@ -25701,8 +26212,10 @@ function materializeReplayView(acc, copy) {
 		plan: acc.plan,
 		permission: acc.permission,
 		title: acc.title,
+		systemPrompt: acc.systemPrompt,
 		sandbox: acc.sandbox,
 		goal: acc.goal,
+		schedules: acc.schedules,
 		pending: {
 			"next-turn": [...acc.pendingTurn],
 			"next-step": [...acc.pendingStep]
@@ -25716,11 +26229,58 @@ function materializeReplayView(acc, copy) {
 			lastPruneTokens: acc.lastPruneTokens,
 			turnFiles: new Map([...acc.turnFiles].map(([turn, files]) => [turn, new Set(files)])),
 			turnSteps: new Map(acc.turnSteps),
-			turnTools: new Map([...acc.turnTools].map(([turn, tools]) => [turn, new Set(tools)]))
+			turnTools: new Map([...acc.turnTools].map(([turn, tools]) => [turn, new Set(tools)])),
+			systemNodes: new Map(acc.systemNodes)
 		}
 	};
 }
 /**
+* Fold one process-local assistant-stream chunk frame (session-log v2+ keeps
+* durable logs settlement-only; live typing rides the `agent/assistant-stream`
+* agent event). Same first-token anchoring the durable `assistant/chunk` event
+* used to carry: the first non-empty delta anchors the TTFT and empty
+* keep-alive deltas do not count. The caller maps the frame's attempt to the
+* `turn:step` key (the start frame owns turn/step; chunk frames do not).
+* @param acc - the live replay accumulator.
+* @param key - the `turn:step` key the attempt's start frame declared.
+* @param time - the frame's safe-integer timestamp.
+* @param chunk - the model chunk the frame carries.
+* @returns whether the accumulator changed (the store stays silent otherwise).
+*/
+function applyAssistantStreamChunk(acc, key, time, chunk) {
+	if (isTokenDelta(chunk) && !acc.firstChunkAt.has(key)) {
+		acc.firstChunkAt.set(key, time);
+		const started = acc.stepStart.get(key);
+		if (started !== void 0) acc.stats = {
+			...acc.stats,
+			ttftMs: acc.stats.ttftMs + Math.max(0, time - started),
+			ttftSteps: acc.stats.ttftSteps + 1
+		};
+	}
+	if (chunk.type === "text-delta") {
+		acc.streaming = appendStreamingTail(acc.streaming, chunk.text);
+		return true;
+	}
+	if (chunk.type === "reasoning-delta") {
+		acc.streamingReasoning = appendStreamingTail(acc.streamingReasoning, chunk.text);
+		return true;
+	}
+	return false;
+}
+/**
+* Drop the live streaming tails without a settlement (an `agent/assistant-stream`
+* end frame with an `abandoned` outcome, or a session switch). The next start
+* frame rebuilds from scratch.
+* @param acc - the live replay accumulator.
+* @returns whether any tail text was discarded.
+*/
+function clearAssistantStream(acc) {
+	const streamed = acc.streaming !== "" || acc.streamingReasoning !== "";
+	acc.streaming = "";
+	acc.streamingReasoning = "";
+	return streamed;
+}
+/**
 * The append-only flush boundary for a transcript view: the count of entries
 * no later event can remove. Entries at or beyond this index are mutable and
 * must stay in the live tree.
@@ -25748,6 +26308,132 @@ function settledEntryCount(entries) {
 	return entries.length;
 }
 //#endregion
+//#region src/render/ime-cursor.ts
+/**
+* IME cursor anchoring for the composer.
+*
+* Ink keeps the real terminal cursor hidden and parks it just below the
+* dynamic tree (after the status row). IME composition text and candidate
+* windows anchor to that real cursor cell - VS Code's integrated terminal
+* positions its hidden IME textarea there, and Windows consoles behave the
+* same - so CJK input appeared at the bottom of the screen instead of at the
+* caret. The anchor moves the real cursor onto the caret cell without
+* touching Ink's relative erase ledger:
+*
+* - the displacement is owned: before any foreign write or re-anchor, the
+*   wrapper cancels it (cursor down, column 1), so every writer - Ink's
+*   log-update rewrites, the resize replay, protocol pushes - keeps seeing
+*   the cursor exactly where it was left;
+* - log-update frame chunks (which start with the erase-line sequence) get
+*   the anchor re-appended inside the same write, so a repaint can never
+*   leave the cursor behind - in particular the caret blink keeps the anchor
+*   stable while an IME composition is open, because the terminal parses the
+*   rewrite and the re-anchor as one atomic update.
+*
+* @module @deepseek-ai/dsh-code/render/ime-cursor
+*/
+/** Cancel `rows` of owned upward displacement and return to column 1. */
+function imeCursorRestore(rows) {
+	return rows > 0 ? `\x1b[${rows}B\r` : "";
+}
+/** Move onto the caret cell: `rows` up from Ink's parked row, 0-based column. */
+function imeCursorMove(rows, column) {
+	return rows > 0 ? `\x1b[${rows}A\x1b[${column + 1}G` : "";
+}
+/**
+* Rows between the caret cell and Ink's parked cursor row: the band's bottom
+* blank row, the editor window rows below the caret, the status footer, and
+* Ink's own below-frame row. Rows above the composer (gutter, live content)
+* never enter this distance.
+*/
+function imeCursorRowsUp(input) {
+	return Math.max(1, input.editorWindowRows - input.caretRowInWindow + input.rowsBelowComposer);
+}
+/** log-update chunks start with the erase-line sequence; a chunk without it
+* leaves no frame behind, so the next commit re-applies the anchor. */
+const FRAME_CHUNK_MARKER = "\x1B[2K";
+const ANCHOR_STATE = Symbol.for("dsh-code.ime-cursor-anchor");
+/**
+* Take over `stream.write` so the anchor displacement stays invisible to every
+* other writer. Idempotent per stream: a second install returns the live
+* handle. Returns `undefined` on non-TTY streams where anchoring is meaningless.
+*/
+function installImeCursorAnchor(stream) {
+	if (stream?.isTTY !== true) return void 0;
+	const target = stream;
+	const installed = target[ANCHOR_STATE];
+	if (installed !== void 0) return installed;
+	const originalWrite = target.write.bind(target);
+	let rows = 0;
+	let column = -1;
+	let detached = false;
+	const anchor = {
+		anchor(nextRows, nextColumn) {
+			if (detached) return;
+			if (nextRows <= 0) {
+				if (rows !== 0) originalWrite(imeCursorRestore(rows));
+				rows = 0;
+				column = -1;
+				return;
+			}
+			if (rows === nextRows && column === nextColumn) return;
+			originalWrite(imeCursorRestore(rows) + imeCursorMove(nextRows, nextColumn));
+			rows = nextRows;
+			column = nextColumn;
+		},
+		release() {
+			if (detached) return;
+			detached = true;
+			if (rows !== 0) originalWrite(imeCursorRestore(rows));
+			rows = 0;
+			column = -1;
+			target.write = originalWrite;
+			delete target[ANCHOR_STATE];
+		}
+	};
+	target.write = ((chunk, ...rest) => {
+		const ownedRows = rows;
+		const ownedColumn = column;
+		if (ownedRows === 0 || typeof chunk !== "string") {
+			if (ownedRows !== 0) {
+				originalWrite(imeCursorRestore(ownedRows));
+				rows = 0;
+				column = -1;
+			}
+			return originalWrite(chunk, ...rest);
+		}
+		const reanchor = chunk.startsWith(FRAME_CHUNK_MARKER);
+		rows = reanchor ? ownedRows : 0;
+		column = reanchor ? ownedColumn : -1;
+		return originalWrite(imeCursorRestore(ownedRows) + chunk + (reanchor ? imeCursorMove(ownedRows, ownedColumn) : ""), ...rest);
+	});
+	target[ANCHOR_STATE] = anchor;
+	return anchor;
+}
+/**
+* Keep the real terminal cursor on the composer's caret cell while `active`
+* (the editable composer). The second effect runs after every commit without
+* a dep list: frame rewrites restore the anchor themselves, but any other
+* write (protocol push, resize replay) leaves the cursor at Ink's parked
+* position, and the next commit re-anchors it.
+*/
+function useImeCursorAnchor(active, rows, column) {
+	const { stdout } = useStdout();
+	const anchorRef = (0, import_react.useRef)(void 0);
+	(0, import_react.useEffect)(() => {
+		if (stdout === void 0) return void 0;
+		const installed = installImeCursorAnchor(stdout);
+		anchorRef.current = installed;
+		return () => {
+			installed?.release();
+			if (anchorRef.current === installed) anchorRef.current = void 0;
+		};
+	}, [stdout]);
+	(0, import_react.useEffect)(() => {
+		anchorRef.current?.anchor(active && rows > 0 ? rows : 0, column);
+	});
+}
+//#endregion
 //#region src/render/markdown.ts
 /**
 * Terminal markdown renderer for assistant replies: a pure GFM-subset
@@ -26365,8 +27051,60 @@ const DEEPSEEK_WAVE_STYLES = [
 	"aurora",
 	"pulse"
 ];
-/** Pulse ring half-width in columns — Codex PULSE_HALF_WIDTH (4.5). */
-const PULSE_HALF_WIDTH = 4.5;
+/**
+* The water surface: ONE continuous sine line spanning the whole band,
+* mirror-symmetric about the center column, its crests flowing OUTWARD from
+* the center (phase k·|x − center| − ω·t). No sweep window, no return trip —
+* the surface fades in, flows, and fades out, symmetric in both space and
+* time. The deepseek tier adds one faster, finer HARMONIC line whose crests
+* cross the fundamental's: interleaved richness with both lines still
+* symmetric and still only ever flowing outward.
+*/
+const WAVE_SURFACE_AMPLITUDE = .8;
+const WAVE_SURFACE_HARMONIC = .45;
+/** Vertical thickness in lane units — Aurora-wide: soft gradients, no hard edges. */
+const WAVE_SURFACE_THICKNESS = 1.2;
+/**
+* The mirrored second-hue profile: the space BELOW the surface carries a
+* second blue at this strength, so color (not just brightness) varies
+* continuously across the wave — Aurora-style hue mixing instead of a
+* single flat tint.
+*/
+const WAVE_SURFACE_MIRROR = .6;
+/** Aurora-style soft alpha: low gain, capped well under the pulse ring's. */
+const WAVE_SURFACE_ALPHA_GAIN = .45;
+const WAVE_SURFACE_ALPHA_CAP = .68;
+/**
+* Pulse ring geometry, softened to the Wave standard: a WIDE band
+* (half-width 5.5) with a moderate peak riding the radius — all inside the
+* hue blend, no hard white line — and an inner profile one hue over at a
+* slightly smaller radius, so the ring's color grades continuously across
+* its width (the radial analog of the water surface's mirrored hues).
+*/
+const PULSE_HALF_WIDTH = 5.5;
+const PULSE_PEAK_HALF_WIDTH = 1.8;
+const PULSE_PEAK_GAIN = .35;
+const PULSE_INNER_OFFSET = 2.5;
+const PULSE_INNER_STRENGTH = .6;
+/** The inner edge of each ring carries the tier's third blue. */
+const PULSE_INNER_HUE = 2;
+/**
+* The trailing echo ripple: every pulse ring drags a second, weaker ring at
+* a fraction of its radius in the NEXT hue of the tier's blues, fading in a
+* little after the primary so the center hole opens first.
+*/
+const PULSE_ECHO_RADIUS = .7;
+const PULSE_ECHO_STRENGTH = .65;
+const PULSE_ECHO_DELAY = .12;
+/** Aurora-grade soft alpha for the detonation — a notch above the swell. */
+const PULSE_ALPHA_GAIN = .45;
+const PULSE_ALPHA_CAP = .72;
+/**
+* Terminal cell aspect (row height ÷ column width, ≈2.2 for common fonts).
+* A ring computed in raw cell units looks vertically squashed; weighting row
+* distance by the aspect makes the Pulse ring appear circular on screen.
+*/
+const PULSE_ROW_ASPECT = 2.2;
 /** Sparkle start and frame cadence — Codex SPARK_START / SPARK_FRAME. */
 const SPARK_START_MS = 900;
 const SPARK_FRAME_MS = 100;
@@ -26510,14 +27248,17 @@ function deepseekWaveStyleRandom(previous) {
 	return candidates[Math.floor(Math.random() * candidates.length)] ?? "wave";
 }
 /**
-* Tier for a `provider/model` label: a model id containing `flash` runs the
+* Tier for a `provider/model` label: a MODEL ID containing `flash` runs the
 * single-band flash tier; everything else (pro/reasoner/chat) runs the
-* dual-band deepseek tier. Mirrors Codex's Max→Ultra mapping.
+* dual-band deepseek tier. Mirrors Codex's Max→Ultra mapping. Only the model
+* segment (after the `/`) is matched, so a provider whose name contains
+* `flash` cannot flip an unrelated model onto the flash tier.
 * @param model - the `provider/model` label of the applied model.
 * @returns the wave tier for that model.
 */
 function deepseekWaveTier(model) {
-	return model.toLowerCase().includes("flash") ? "flash" : "deepseek";
+	const slash = model.indexOf("/");
+	return (slash < 0 ? model : model.slice(slash + 1)).toLowerCase().includes("flash") ? "flash" : "deepseek";
 }
 /**
 * Cosine window — Codex `crest`: 1 exactly under the wave center, 0 from
@@ -26530,18 +27271,6 @@ function crest(distance) {
 	return .5 * (1 + Math.cos(Math.PI * distance));
 }
 /**
-* Cubic ease-in-out — Codex `ease_in_out`: flat at both ends, steepest in
-* the middle, so the crest accelerates and eases instead of sliding linearly.
-* @param progress - raw progress (clamped to 0..1).
-* @returns the eased progress in 0..1.
-*/
-function easeInOut(progress) {
-	const p = Math.min(1, Math.max(0, progress));
-	if (p < .5) return 4 * p * p * p;
-	const inverse = -2 * p + 2;
-	return 1 - inverse * inverse * inverse / 2;
-}
-/**
 * Fade-in/fade-out envelope — Codex `envelope`: linear ramp over `fadeIn`
 * at the start and `fadeOut` at the end, plateau at 1 between, 0 outside the
 * total. The Wave style keeps the envelope at 1 (Codex paints Wave without
@@ -26559,38 +27288,98 @@ function envelope(elapsed, total, fadeIn, fadeOut) {
 	return Math.min(Math.max(Math.min(rise, fall), 0), 1);
 }
 /**
-* One band's contribution at a column — Codex `band_sample`, all three
-* branches: Wave sweeps an eased crest across the row; Aurora drifts a
-* sinusoidal center carrying a hue index; Pulse expands a ring from the row
-* center with cubic ease and decaying strength.
+* One band's contributions at a column — Codex `band_sample`, redesigned:
+* Wave is a WATER SURFACE — one continuous sine line, mirror-symmetric
+* about the center column, crests flowing outward from the center (band 1
+* of the deepseek tier is a faster harmonic line crossing it). Pulse
+* detonates in TWO dimensions: soft rings that keep expanding through a
+* symmetric fade envelope, color grading across each ring's width, with a
+* trailing echo ripple. Aurora matches Codex verbatim.
 * @param style - the ignition style.
 * @param band - the band triple (meaning depends on the style).
 * @param elapsed - seconds since the animation started.
 * @param column - column index in the content row (0..width-1).
 * @param width - content-row width in columns.
-* @returns `[hueIndex, strength]`.
+* @param context - band geometry (row position, undulation flag, pulse span).
+* @returns one or two `[hueIndex, strength, core]` contributions.
 */
-function bandSample(style, band, elapsed, column, width) {
+function bandSample(style, band, elapsed, column, width, context) {
 	const [first, second, third] = band;
 	switch (style) {
 		case "wave": {
-			const progress = (elapsed - first) / second;
-			if (progress < 0 || progress > 1) return [0, 0];
-			const center = easeInOut(progress) * (width + 18) - 9;
-			return [0, crest(Math.abs(column - center) / 9)];
+			const fadeIn = first;
+			const fadeOut = Math.max(.05, context.total - (first + second));
+			const fade = envelope(elapsed, context.total, fadeIn, fadeOut);
+			if (fade <= .01) return [[
+				0,
+				0,
+				0
+			]];
+			const harmonic = context.bandIndex % 2 === 1;
+			const wavelength = harmonic ? 40 / 1.5 : 40;
+			const omega = (harmonic ? 1.5 : 1) * 9;
+			const amplitude = (harmonic ? WAVE_SURFACE_HARMONIC : 1) * WAVE_SURFACE_AMPLITUDE;
+			const d = Math.abs(column - (width - 1) / 2);
+			const surface = amplitude * Math.sin(Math.PI * 2 * d / wavelength - omega * elapsed + (harmonic ? Math.PI / 2 : 0));
+			const fromSurface = Math.abs(context.u - surface);
+			const vertical = context.undulating ? crest(fromSurface / WAVE_SURFACE_THICKNESS) : 1;
+			const mirrorHue = harmonic ? 1 : 2;
+			const below = context.undulating ? crest(Math.abs(context.u + surface) / WAVE_SURFACE_THICKNESS) : vertical;
+			return [[
+				0,
+				fade * vertical,
+				0
+			], [
+				mirrorHue,
+				fade * below * WAVE_SURFACE_MIRROR,
+				0
+			]];
 		}
 		case "aurora": {
 			const center = (.5 + .38 * Math.sin(Math.PI * 2 * (first * elapsed + second))) * width;
 			const halfWidth = Math.max(width * .22, 4);
-			return [Math.trunc(third), crest(Math.abs(column - center) / halfWidth)];
+			return [[
+				Math.trunc(third),
+				crest(Math.abs(column - center) / halfWidth),
+				0
+			]];
 		}
 		case "pulse": {
-			const progress = (elapsed - first) / second;
-			if (progress < 0 || progress > 1) return [0, 0];
-			const inverse = 1 - progress;
-			const radius = (1 - inverse * inverse * inverse) * (width / 2 + 2 * PULSE_HALF_WIDTH);
-			const distance = Math.abs(column - width / 2);
-			return [0, crest(Math.abs(distance - radius) / PULSE_HALF_WIDTH) * third * (1 - .6 * progress)];
+			const launch = first;
+			const travel = second;
+			const fadeOut = Math.max(.05, context.total - (launch + travel));
+			const fade = envelope(elapsed, context.total, launch, fadeOut);
+			if (fade <= .01) return [[
+				0,
+				0,
+				0
+			]];
+			const progress = (elapsed - launch) / travel;
+			const radius = (1 - (1 - progress) ** 3) * context.pulseSpan;
+			const decay = third * (1 - .35 * Math.min(Math.max(progress, 0), 1));
+			const distance = Math.hypot(column - width / 2, context.dy);
+			const fromRing = Math.abs(distance - radius);
+			const band = crest(fromRing / PULSE_HALF_WIDTH) + PULSE_PEAK_GAIN * crest(fromRing / PULSE_PEAK_HALF_WIDTH);
+			const inner = crest(Math.abs(distance - (radius - PULSE_INNER_OFFSET)) / PULSE_HALF_WIDTH);
+			const echoGate = envelope(elapsed, context.total, launch + PULSE_ECHO_DELAY, fadeOut);
+			const echo = crest(Math.abs(distance - radius * PULSE_ECHO_RADIUS) / PULSE_HALF_WIDTH) * PULSE_ECHO_STRENGTH * echoGate;
+			return [
+				[
+					context.bandIndex,
+					fade * band * decay,
+					0
+				],
+				[
+					PULSE_INNER_HUE,
+					fade * inner * decay * PULSE_INNER_STRENGTH,
+					0
+				],
+				[
+					context.bandIndex + 1,
+					fade * echo * decay,
+					0
+				]
+			];
 		}
 	}
 }
@@ -26603,9 +27392,10 @@ function blendRgb(fg, bg, alpha) {
 	];
 }
 /**
-* Per-row phase share of the duration: the crest reaches the top row first
-* and the bottom row last, sweeping down the band. 0.12 keeps the bottom
-* row's lag inside the 200ms duration extension.
+* Aurora-only per-row phase share of the duration: its drifting bands reach
+* the top row first and the bottom row last, sweeping down the band. 0.12
+* keeps the bottom row's lag inside the 200ms duration extension. Wave and
+* Pulse deliberately share one timeline (see `deepseekWaveColumnBg`).
 */
 const DEEPSEEK_WAVE_ROW_PHASE = .12;
 /**
@@ -26616,9 +27406,13 @@ const DEEPSEEK_WAVE_ROW_PHASE = .12;
 * blends the mixed hue toward the blank-cell base at the style's alpha cap,
 * and Aurora applies its own fade envelope. Returns `null` when the column
 * should stay transparent, so the row returns to no `backgroundColor` on
-* both ends. With `rows > 1` each row samples the same timeline shifted by a
-* per-row phase offset, so the crest cascades down the band instead of
-* painting every row identically.
+* both ends. With `rows > 1`: Wave is a water surface — every column
+* lights the row nearest the surface's current height, so the light reads
+* as ONE continuous wavy line spanning the band, symmetric about the center
+* column and flowing outward (a single-row band falls back to a flat glow);
+* Pulse rings in two dimensions around the band's center cell with trailing
+* echo ripples; only Aurora samples the timeline shifted by a per-row phase
+* offset.
 * @param tick - wave frame (0, 1, … at DEEPSEEK_WAVE_TICK_MS).
 * @param column - column index in the content row (0..width-1).
 * @param width - content-row width in columns.
@@ -26632,16 +27426,28 @@ const DEEPSEEK_WAVE_ROW_PHASE = .12;
 */
 function deepseekWaveColumnBg(tick, column, width, tier, style, hues, base, row = 0, rows = 1) {
 	const total = deepseekWaveBaseDuration(tier, style) / 1e3;
-	const elapsed = deepseekWaveSampleElapsedMs(tick, tier, style) / 1e3 - (row - (rows - 1) / 2) * total * DEEPSEEK_WAVE_ROW_PHASE;
+	const elapsed = deepseekWaveSampleElapsedMs(tick, tier, style) / 1e3 - (style === "aurora" ? (row - (rows - 1) / 2) * total * DEEPSEEK_WAVE_ROW_PHASE : 0);
+	const dy = style === "pulse" ? (row - (rows - 1) / 2) * PULSE_ROW_ASPECT : 0;
+	const undulating = rows > 1;
+	const u = undulating ? (row - (rows - 1) / 2) / ((rows - 1) / 2) : 0;
+	const pulseSpan = Math.hypot(width / 2, (rows - 1) / 2 * PULSE_ROW_ASPECT);
 	const fade = style === "aurora" ? envelope(elapsed, total, .25, .4) : 1;
 	const weights = [
 		0,
 		0,
 		0
 	];
+	let bandIndex = 0;
 	for (const band of DEEPSEEK_WAVE_BANDS[style][tier]) {
-		const [hue, strength] = bandSample(style, band, elapsed, column, width);
-		weights[hue] = style === "aurora" ? weights[hue] + strength : Math.max(weights[hue], strength);
+		for (const [hue, strength] of bandSample(style, band, elapsed, column, width, {
+			dy,
+			u,
+			undulating,
+			pulseSpan,
+			bandIndex,
+			total
+		})) weights[hue] = style === "aurora" ? weights[hue] + strength : Math.max(weights[hue], strength);
+		bandIndex += 1;
 	}
 	const weight = weights[0] + weights[1] + weights[2];
 	if (weight <= .01) return null;
@@ -26658,7 +27464,7 @@ function deepseekWaveColumnBg(tick, column, width, tier, style, hues, base, row
 		Math.round(green / weight),
 		Math.round(blue / weight)
 	];
-	const alpha = style === "aurora" ? Math.min(weight * .4, .5) * fade : weight * .55;
+	const alpha = style === "aurora" ? Math.min(weight * .4, .5) * fade : style === "wave" ? Math.min(weight * WAVE_SURFACE_ALPHA_GAIN, WAVE_SURFACE_ALPHA_CAP) : Math.min(weight * PULSE_ALPHA_GAIN, PULSE_ALPHA_CAP);
 	if (alpha < .02) return null;
 	return blendRgb(mixed, base, alpha);
 }
@@ -26743,6 +27549,32 @@ function effortAboveHigh(effort) {
 	const rank = EFFORT_RANK[effort.trim().toLowerCase()];
 	return rank !== void 0 && rank > 3;
 }
+/**
+* Parse a persisted animations preference (`animations.json`): timed
+* animations are on by default and only an explicit `false` disables them —
+* a missing key, corrupt value, or absent file all mean enabled, so the
+* /animation toggle degrades exactly like every other user preference.
+* @param value - the raw parsed JSON value (expected boolean).
+* @returns whether timed animations should run.
+*/
+function parseAnimationsPref(value) {
+	return value !== false;
+}
+/**
+* One parsed `/animation` argument: '' toggles, `on|true|1` enables,
+* `off|false|0` disables (case-insensitive, surrounding whitespace ignored),
+* and anything else is a usage error the caller surfaces. Kept pure so the
+* command's entire decision table is unit-testable.
+* @param argument - the raw text after `/animation`.
+* @returns `{ enabled }`, `'toggle'`, or `'usage'`.
+*/
+function parseAnimationsArgument(argument) {
+	const normalized = argument.trim().toLowerCase();
+	if (normalized === "") return "toggle";
+	if (normalized === "on" || normalized === "true" || normalized === "1") return { enabled: true };
+	if (normalized === "off" || normalized === "false" || normalized === "0") return { enabled: false };
+	return "usage";
+}
 //#endregion
 //#region src/commands.ts
 /**
@@ -26761,17 +27593,41 @@ function watchCommands(ctx) {
 	let error;
 	let loadedFor;
 	const listeners = /* @__PURE__ */ new Set();
+	const descriptorFingerprint = (list) => JSON.stringify(list.map((descriptor) => [
+		descriptor.name,
+		descriptor.description,
+		descriptor.input?.hint ?? "",
+		descriptor.input?.attachments === true
+	]));
+	let lastFingerprint = "[]";
+	let lastNotifiedError;
+	const changed = (next, nextError) => descriptorFingerprint(next) !== lastFingerprint || nextError !== lastNotifiedError;
+	let notifyScheduled = false;
+	const notify = () => {
+		if (notifyScheduled) return;
+		notifyScheduled = true;
+		setImmediate(() => {
+			notifyScheduled = false;
+			for (const listener of listeners) listener();
+		});
+	};
 	const refresh = () => {
 		if (commands === void 0 || agent === void 0) return;
+		let next;
+		let nextError;
 		try {
-			descriptors = commands.list(agent);
+			next = commands.list(agent);
 			loadedFor = agent;
-			error = void 0;
 		} catch (cause) {
-			descriptors = loadedFor === agent ? [...descriptors] : [];
-			error = cause instanceof Error ? cause.message : String(cause);
+			next = loadedFor === agent ? [...descriptors] : [];
+			nextError = cause instanceof Error ? cause.message : String(cause);
 		}
-		for (const listener of listeners) listener();
+		if (!changed(next, nextError)) return;
+		descriptors = next;
+		error = nextError;
+		lastFingerprint = descriptorFingerprint(next);
+		lastNotifiedError = nextError;
+		notify();
 	};
 	if (commands !== void 0) ctx.on("commands/change", () => refresh());
 	return {
@@ -26819,6 +27675,70 @@ function submissionPayload(line) {
 	return isSlashLine(trimmed) ? trimmed : withoutTrailingNewlines;
 }
 //#endregion
+//#region src/render/fuzzy.ts
+/** Extra weight for name starts and separator boundaries. */
+function boundaryBonus(name, index) {
+	return index === 0 || name.charAt(index - 1) === "-" || name.charAt(index - 1) === "_" ? 8 : 0;
+}
+/**
+* Score the strongest ordered-subsequence alignment in O(name × query).
+* Boundary and adjacent matches earn weight; skipped and leading characters
+* cost weight. Undefined when the query is not a subsequence of the name.
+*/
+function alignmentScore(name, query) {
+	if (query.length > name.length) return void 0;
+	const noMatch = Number.NEGATIVE_INFINITY;
+	let previous = Array(name.length).fill(noMatch);
+	for (let index = 0; index < name.length; index++) if (name.charAt(index) === query.charAt(0)) previous[index] = 1 + boundaryBonus(name, index) - index;
+	for (let queryIndex = 1; queryIndex < query.length; queryIndex++) {
+		const current = Array(name.length).fill(noMatch);
+		let left = noMatch;
+		let leftLeft = noMatch;
+		let bestGapped = noMatch;
+		for (const [index, prior] of previous.entries()) {
+			if (leftLeft !== noMatch) bestGapped = Math.max(bestGapped, leftLeft + index - 2);
+			if (name.charAt(index) === query.charAt(queryIndex)) {
+				const bonus = 1 + boundaryBonus(name, index);
+				let score = noMatch;
+				if (left !== noMatch) score = left + bonus + 4;
+				if (bestGapped !== noMatch) score = Math.max(score, bestGapped + bonus + 1 - index);
+				current[index] = score;
+			}
+			leftLeft = left;
+			left = prior;
+		}
+		previous = current;
+	}
+	let best = noMatch;
+	for (const score of previous) best = Math.max(best, score);
+	return best === noMatch ? void 0 : best;
+}
+/**
+* Rank named items by a menu query.
+* @param items - candidates in source order (the caller's composition order
+* is the final tie-breaker, e.g. local commands before registry entries).
+* @param rawQuery - the text typed after the trigger, matched case-insensitively.
+* @returns the matching items: prefix hits first, then by alignment score,
+* then in source order. The input list itself for an empty query.
+*/
+function rankByName(items, rawQuery) {
+	const query = rawQuery.toLowerCase();
+	if (query === "") return items;
+	const ranked = [];
+	items.forEach((item, index) => {
+		const name = item.name.toLowerCase();
+		const score = alignmentScore(name, query);
+		if (score !== void 0) ranked.push({
+			item,
+			index,
+			prefix: name.startsWith(query),
+			score
+		});
+	});
+	ranked.sort((left, right) => Number(right.prefix) - Number(left.prefix) || right.score - left.score || left.index - right.index);
+	return ranked.map((match) => match.item);
+}
+//#endregion
 //#region src/provider-settings.ts
 /** Human text for a rejection value (mirrors the web page's `messageOf`). */
 function messageOf$1(error) {
@@ -27028,7 +27948,8 @@ async function loadProviderSettings(ctx) {
 		active: active.has(entry.provider),
 		settingsNs: entry.settingsNs,
 		settingsPath: entry.settingsPath,
-		...entry.declared === void 0 ? {} : { declared: entry.declared }
+		...entry.declared === void 0 ? {} : { declared: entry.declared },
+		...entry.error === void 0 ? {} : { error: singleLine$1(entry.error) }
 	})), ...registered.filter((provider) => !declared.has(provider.id)).map((provider) => ({
 		provider: provider.id,
 		displayName: provider.name,
@@ -27053,7 +27974,8 @@ async function loadProviderSettings(ctx) {
 			configuration: configurationOf(profile),
 			...credentialRef === void 0 ? {} : { credentialRef },
 			suggestedRef: deriveCredentialRef(base.provider),
-			...base.declared === void 0 ? {} : { declared: base.declared }
+			...base.declared === void 0 ? {} : { declared: base.declared },
+			...base.error === void 0 ? {} : { diagnostic: base.error }
 		};
 	});
 	const refs = [...new Set(rows.flatMap((row) => row.credentialRef === void 0 ? [] : [row.credentialRef]))];
@@ -27480,9 +28402,8 @@ function mergeSessionTitles(rows, observations) {
 }
 /**
 * Encode a session id the way the JSONL backend does for its on-disk layout
-* (`encodeSegment`: safe units literal, everything else `~XXXX`). Used ONLY to
-* validate that a `locate()` path really is this session's directory before
-* any deletion touches the filesystem — a local copy of the pure upstream
+* (`encodeSegment`: safe units literal, everything else `~XXXX`). Used to
+* validate and derive session directories — a local copy of the pure upstream
 * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
 */
 function encodeSessionSegment(raw) {
@@ -27498,21 +28419,91 @@ function encodeSessionSegment(raw) {
 	}
 	return out;
 }
-/** The session-log artifact names the JSONL backend may create. */
-const SESSION_ARTIFACT_NAMES = ["session.jsonl", "session.jsonl.zstd"];
 /**
-* Guard one `locate()` artifact path before deletion (codex's scoped-path
-* check, adapted to the JSONL layout): the file must be a `session.jsonl`
-* artifact sitting in the directory named exactly `encodeSegment(id)`.
-* @param artifact - the path the persistence backend located.
-* @param id - the session id the artifact claims to belong to.
-* @returns the owning session directory, or undefined when the layout is unexpected.
+* Encode a project cwd the way the JSONL backend groups sessions on disk
+* (`projectKey`: separators collapse to one `-`, everything else mirrors
+* `encodeSegment`, bounded to 251 chars). A local copy of the pure upstream
+* contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
+*/
+function encodeProjectKey(cwd) {
+	if (cwd.length === 0) throw new Error("cannot encode an empty project path");
+	let readable = "";
+	let separatorRun = false;
+	for (let i = 0; i < cwd.length; i += 1) {
+		const code = cwd.charCodeAt(i);
+		const ch = String.fromCharCode(code);
+		if (ch === "/" || ch === "\\" || ch === ":") {
+			if (!separatorRun) readable += "-";
+			separatorRun = true;
+		} else if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) {
+			readable += ch;
+			separatorRun = false;
+		} else {
+			readable += `~${code.toString(16).toUpperCase().padStart(4, "0")}`;
+			separatorRun = false;
+		}
+	}
+	return `--${(readable.replace(/^-+/, "") || "root").slice(0, 251)}--`;
+}
+/** The project-level directory name the JSONL backend uses for a missing cwd. */
+const NO_CWD_DIRECTORY = "_no-cwd";
+/**
+* Derive one session's artifact directory under the JSONL backend root,
+* mirroring the upstream `<root>/<projectKey(cwd)>/<encodeSegment(id)>/`
+* layout (0.1.5 `sessionDir`/`projectDir`).
+* @param root - the JSONL backend's configured session root.
+* @param cwd - the session's pinned working directory, when the header has one.
+* @param id - the session id.
+* @returns the absolute session directory path.
 */
-function sessionArtifactDirectory(artifact, id) {
-	if (basename(artifact) !== "session.jsonl" && basename(artifact) !== "session.jsonl.zstd") return void 0;
-	const dir = dirname(artifact);
+function sessionDirectoryFor(root, cwd, id) {
+	const project = cwd === void 0 || cwd === "" ? NO_CWD_DIRECTORY : encodeProjectKey(cwd);
+	return resolve(root, project, encodeSessionSegment(id));
+}
+/**
+* The canonical session-log artifact filenames the JSONL backend may create:
+* format v0 writes the bare `session.jsonl` name; v1+ write
+* `session.vN.jsonl`, each generation optionally zstd-compressed. Multiple
+* immutable generations may coexist in one session directory (0.1.5). The
+* range follows the installed session package's `SESSION_FORMAT_VERSION`, so
+* a future generation joins the enumeration with the dependency bump.
+*/
+function sessionArtifactNames() {
+	const names = ["session.jsonl", "session.jsonl.zstd"];
+	for (let version = 1; version <= SESSION_FORMAT_VERSION; version += 1) names.push(`session.v${version}.jsonl`, `session.v${version}.jsonl.zstd`);
+	return names;
+}
+/** Canonical generation-log filenames as a lookup set (bare v0 or `vN`-suffixed, ± zstd). */
+const SESSION_ARTIFACT_NAME_SET = new Set(sessionArtifactNames());
+/** True for one canonical session-log artifact filename the backend may own. */
+function isSessionArtifactName(name) {
+	return SESSION_ARTIFACT_NAME_SET.has(name);
+}
+/**
+* Guard a derived session directory before deletion (codex's scoped-path
+* check, adapted to the JSONL layout): the directory's base name must be
+* exactly `encodeSegment(id)` beneath its project grouping.
+* @param dir - the derived session artifact directory.
+* @param id - the session id the directory claims to belong to.
+* @returns the guarded directory, or undefined when the layout is unexpected.
+*/
+function sessionArtifactDirectory(dir, id) {
 	if (basename(dir) !== encodeSessionSegment(id)) return void 0;
-	return dir;
+	if (basename(dirname(dir)) === NO_CWD_DIRECTORY) return dir;
+	return /^--.*--$|^~/.test(basename(dirname(dir))) ? dir : void 0;
+}
+/**
+* The JSONL backend's configured session root, when the mounted backend
+* exposes one. The upstream service contract dropped `locate()` in 0.1.5
+* (artifact paths are backend-private; only refusal diagnostics carry them),
+* so the TUI derives artifact paths from the backend's public plugin config.
+* Backends without a JSONL-style config (or a foreign shape) yield undefined
+* and callers degrade: mtime sorting falls back to createdAt and /delete
+* refuses, exactly as before.
+*/
+function jsonlSessionRoot(persistence) {
+	const root = persistence?.config?.root;
+	return typeof root === "string" && root !== "" ? root : void 0;
 }
 /**
 * Collect one session's deletion subtree: the id plus every record whose
@@ -27948,14 +28939,6 @@ function buildCandidates(facts, stats, busy, enabled, contextWidth) {
 	}];
 	const right = [];
 	const row2 = [];
-	if (facts.plan && enabled.has("plan")) row2.push({
-		group: { spans: [{
-			text: "⧉ plan",
-			tone: "accent"
-		}] },
-		rank: RANK2_PLAN,
-		id: "plan"
-	});
 	if (stats.turns > 0 || stats.steps > 0) {
 		if (enabled.has("turns")) {
 			const counts = [];
@@ -28074,9 +29057,13 @@ function buildCandidates(facts, stats, busy, enabled, contextWidth) {
 	});
 	const permission = safe(facts.permission);
 	let badge = -1;
+	const planStation = facts.plan && permissionTone(permission) === "success";
 	if (permission !== "" && enabled.has("permission")) {
 		right.push({
-			span: {
+			span: planStation ? {
+				text: "plan on",
+				tone: "plan"
+			} : {
 				text: permission,
 				tone: permissionTone(permission)
 			},
@@ -28085,6 +29072,14 @@ function buildCandidates(facts, stats, busy, enabled, contextWidth) {
 		});
 		badge = right.length - 1;
 	}
+	if (facts.plan && enabled.has("plan")) row2.push({
+		group: { spans: [{
+			text: "⧉ plan",
+			tone: "accent"
+		}] },
+		rank: RANK2_PLAN,
+		id: "plan"
+	});
 	return {
 		left,
 		right,
@@ -28926,14 +29921,15 @@ function composerMaxRows(terminalRows) {
 	return Math.max(1, Math.min(6, Math.floor((Math.max(1, terminalRows) - 10) / 3)));
 }
 /**
-* History navigation starts with Up on an empty draft, or after visual
-* movement has reached the directional text edge of an unchanged recalled
-* entry. Every other position remains under textarea movement.
+* History navigation starts with Up on an empty draft, or continues from an
+* unchanged recalled entry whenever the caret sits on either text edge
+* (start or end) - moving the caret into the interior returns the keys to
+* ordinary editing until an edge is reached again.
 */
 function shouldRecallNavigate(value, cursor, lastRecalled, direction) {
 	if (value === "") return direction < 0;
 	if (lastRecalled !== value) return false;
-	return direction < 0 ? cursor === 0 : cursor === value.length;
+	return cursor === 0 || cursor === value.length;
 }
 //#endregion
 //#region src/keyboard.ts
@@ -29274,7 +30270,8 @@ function ModePanel({ current, load, select, close }) {
 	const visible = (0, import_react.useMemo)(() => rows.filter((row) => `${row.id} ${row.name ?? ""} ${row.description ?? ""}`.toLowerCase().includes(query.toLowerCase())), [rows, query]);
 	(0, import_react.useEffect)(() => setCursor((value) => Math.min(value, Math.max(0, visible.length - 1))), [visible.length]);
 	useInput((input, key) => {
-		if (key.escape || input === "q") return close();
+		if (key.escape) return close();
+		if (input === "q" && query === "") return close();
 		if (input === "r" && query === "") return refresh();
 		if (key.upArrow) return setCursor((value) => visible.length === 0 ? 0 : (value + visible.length - 1) % visible.length);
 		if (key.downArrow) return setCursor((value) => visible.length === 0 ? 0 : (value + 1) % visible.length);
@@ -29320,7 +30317,8 @@ function PermissionPanel({ current, load, select, close }) {
 	const visible = (0, import_react.useMemo)(() => rows.filter((row) => `${row.id} ${row.description ?? ""}`.toLowerCase().includes(query.toLowerCase())), [rows, query]);
 	(0, import_react.useEffect)(() => setCursor((value) => Math.min(value, Math.max(0, visible.length - 1))), [visible.length]);
 	useInput((input, key) => {
-		if (key.escape || input === "q") return close();
+		if (key.escape) return close();
+		if (input === "q" && query === "") return close();
 		if (input === "r" && query === "") return refresh();
 		if (key.upArrow) return setCursor((value) => visible.length === 0 ? 0 : (value + visible.length - 1) % visible.length);
 		if (key.downArrow) return setCursor((value) => visible.length === 0 ? 0 : (value + 1) % visible.length);
@@ -29352,7 +30350,8 @@ function PluginPanel({ load, close, initialQuery = "" }) {
 	const rows = (0, import_react.useMemo)(() => load().filter((row) => `${row.entryId} ${row.moduleName} ${row.phase ?? ""}`.toLowerCase().includes(query.toLowerCase())), [epoch, query]);
 	(0, import_react.useEffect)(() => setCursor((value) => Math.min(value, Math.max(0, rows.length - 1))), [rows.length]);
 	useInput((input, key) => {
-		if (key.escape || input === "q") return close();
+		if (key.escape) return close();
+		if (input === "q" && query === "") return close();
 		if (input === "r" && query === "") return setEpoch((value) => value + 1);
 		if (key.upArrow) return setCursor((value) => rows.length === 0 ? 0 : (value + rows.length - 1) % rows.length);
 		if (key.downArrow) return setCursor((value) => rows.length === 0 ? 0 : (value + 1) % rows.length);
@@ -30033,6 +31032,69 @@ function SubagentPanel({ current, load, pick, inherit, close }) {
 		footer: "↑↓ choose · enter apply · r refresh · esc close"
 	});
 }
+/** Human frequency label: one-shot kinds read as Once, every rows carry the interval. */
+function scheduleFrequency(row) {
+	if (row.kind !== "every") return "Once";
+	const seconds = row.everySeconds ?? 0;
+	if (seconds >= 3600 && seconds % 3600 === 0) return `Every ${seconds / 3600}h`;
+	if (seconds >= 60 && seconds % 60 === 0) return `Every ${seconds / 60}m`;
+	return `Every ${seconds}s`;
+}
+/** Relative label for the next target: in N unit, or N unit overdue. */
+function scheduleRelative(targetAt, now) {
+	const delta = Math.max(0, Math.abs(targetAt - now));
+	const minutes = Math.floor(delta / 6e4);
+	const unit = minutes === 0 ? "<1m" : minutes >= 60 ? `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, "0")}` : `${minutes}m`;
+	return targetAt <= now ? `${unit} overdue` : `in ${unit}`;
+}
+/** Ordered display rows: overdue first (error tone), then ascending target. */
+function scheduleDisplayRows(rows, now) {
+	return [...rows].sort((left, right) => Number(left.targetAt > now) - Number(right.targetAt > now) || left.targetAt - right.targetAt).map((row) => ({
+		key: row.id,
+		text: `${row.prompt} · ${scheduleFrequency(row)} · ${new Date(row.targetAt).toLocaleString()} (${scheduleRelative(row.targetAt, now)})`,
+		tone: row.targetAt <= now ? "error" : void 0
+	}));
+}
+function SchedulePanel({ rows, close }) {
+	const [, setTick] = (0, import_react.useState)(0);
+	(0, import_react.useEffect)(() => {
+		const id = setInterval(() => setTick((value) => value + 1), 1e3);
+		return () => clearInterval(id);
+	}, []);
+	const display = scheduleDisplayRows(rows(), Date.now());
+	const stdout = useStdout().stdout;
+	const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+	useInput((input, key) => {
+		if (key.escape || input === "q") return close();
+	});
+	if (viewport.maxHeight === 0 || viewport.compact) {
+		const summary = display.length === 0 ? "no active reminders" : singleLineText(display[0].text);
+		return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns(`/schedule · ${summary}`, viewport.contentColumns));
+	}
+	const budget = Math.max(1, viewport.bodyRows);
+	const visible = display.slice(0, budget);
+	const hidden = display.length - visible.length;
+	return (0, import_react.createElement)(Box, {
+		width: viewport.outerColumns,
+		borderStyle: "round",
+		borderColor: inkColor(getPalette().dim),
+		flexDirection: "column",
+		paddingX: 1
+	}, (0, import_react.createElement)(Text, {
+		color: inkColor(getPalette().brandBright),
+		wrap: "truncate-end"
+	}, truncateColumns(`/schedule · ${display.length} active reminder${display.length === 1 ? "" : "s"}`, viewport.contentColumns)), ...display.length === 0 ? [(0, import_react.createElement)(Text, {
+		dimColor: true,
+		wrap: "truncate-end"
+	}, truncateColumns("  no active reminders — the model creates them with schedule_create", viewport.contentColumns))] : visible.map((row) => (0, import_react.createElement)(Text, {
+		key: row.key,
+		color: row.tone === "error" ? inkColor(getPalette().error) : void 0,
+		wrap: "truncate-end"
+	}, truncateColumns(`  ${singleLineText(row.text)}`, viewport.contentColumns))), (0, import_react.createElement)(Text, {
+		dimColor: true,
+		wrap: "truncate-end"
+	}, truncateColumns(`esc/q close${hidden > 0 ? ` · +${hidden} more` : ""} · the model schedules via schedule_create`, viewport.contentColumns)));
+}
 /** Encode one entry for the history file (JSON keeps multi-line drafts intact). */
 function serializeHistoryEntry(text) {
 	return JSON.stringify(text);
@@ -30586,7 +31648,14 @@ function ProviderAuthorizationLogoutPanel({ row, confirm, done, back }) {
 }
 //#endregion
 //#region src/attachments.ts
-/** Terminal image-file adapter over the Harness durable attachment service. */
+/** Terminal image- and file-attachment adapter over the Harness durable attachment service. */
+/**
+* Terminal-side file admission bounds. Upstream exposes image limits through
+* the attachment service but no file limits (files ride verbatim storage);
+* these keep a dragged file from silently ingesting a disk-sized blob and
+* bound one message the way the image batch is bounded.
+*/
+const MAX_FILE_BYTES = 8388608;
 const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".png",
 	".jpg",
@@ -30608,24 +31677,58 @@ function detectImageMediaType(data) {
 function looksLikeImagePath(path) {
 	return IMAGE_EXTENSIONS.has(extname(path).toLowerCase());
 }
-/** Parse a terminal paste/drop containing only one or more image paths. */
-function parsePastedImagePaths(input) {
+/**
+* Parse a paste/drop into its image and file paths: image-suffixed tokens
+* stay images, other path-shaped tokens ride as file attachments (0.1.5
+* file blocks), and anything that is neither leaves both empty — the caller
+* then treats the paste as plain text.
+*
+* File tokens are held to an absolute-path-with-shape bar (drive/backslash
+* or a dot-suffixed leaf after a separator): a dropped terminal path always
+* carries one of those, while prose, slash commands, and option flags never
+* do. A POSIX absolute path without any dot-suffixed leaf falls through as
+* text — the @ mention route still attaches such files deliberately.
+*/
+function parsePastedAttachmentPaths(input) {
 	const text = input.trim();
-	if (text === "") return [];
-	const tokens = [];
+	if (text === "") return {
+		images: [],
+		files: []
+	};
+	const images = [];
+	const files = [];
+	const looksLikeDroppedFile = (path) => /^[A-Za-z]:[\\/]/u.test(path) || /^\\\\/u.test(path) || /^\/|^\.\.?\//u.test(path) && /\.[A-Za-z0-9]{1,16}$/u.test(path);
 	for (const match of text.matchAll(/"([^"]+)"|'([^']+)'|(\S+)/gu)) {
 		const token = match[1] ?? match[2] ?? match[3];
 		if (token === void 0) continue;
 		let path = token;
-		if (path.startsWith("file://")) try {
-			path = fileURLToPath(path);
-		} catch {
-			return [];
+		if (path.startsWith("file://")) {
+			try {
+				path = fileURLToPath(path);
+			} catch {
+				return {
+					images: [],
+					files: []
+				};
+			}
+			if (looksLikeImagePath(path)) images.push(path);
+			else files.push(path);
+			continue;
+		}
+		if (looksLikeImagePath(path)) {
+			images.push(path);
+			continue;
 		}
-		if (!looksLikeImagePath(path)) return [];
-		tokens.push(path);
+		if (!looksLikeDroppedFile(path)) return {
+			images: [],
+			files: []
+		};
+		files.push(path);
 	}
-	return tokens;
+	return {
+		images,
+		files
+	};
 }
 /** Validate path, byte size and encoded signature without writing an attachment object. */
 async function inspectImagePaths(paths, attachments, cwd = process.cwd()) {
@@ -30696,6 +31799,60 @@ async function saveImagePaths(paths, attachments, signal) {
 		attachment
 	}));
 }
+/** Validate path and byte size for non-image file attachments without writing. */
+async function inspectFilePaths(paths, attachments, cwd = process.cwd()) {
+	if (paths.length === 0) return [];
+	if (attachments === void 0) throw new Error("file attachments are unavailable in this profile");
+	if (paths.length > 8) throw new Error(`too many files (${paths.length}; limit 8)`);
+	const inspected = [];
+	for (const raw of paths) {
+		const path = isAbsolute(raw) ? resolve(raw) : resolve(cwd, raw);
+		let facts;
+		try {
+			facts = await stat(path);
+		} catch (error) {
+			throw new Error(`cannot read file "${raw}": ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!facts.isFile()) throw new Error(`file path is not a file: "${raw}"`);
+		if (facts.size > 8388608) throw new Error(`file "${basename(path)}" is ${facts.size} bytes; limit ${MAX_FILE_BYTES}`);
+		inspected.push({
+			path,
+			name: basename(path),
+			bytes: facts.size
+		});
+	}
+	return inspected;
+}
+/** Read and persist an ordered non-image file path list as model file blocks. */
+async function saveFilePaths(paths, attachments, signal) {
+	if (paths.length === 0) return [];
+	if (attachments === void 0) throw new Error("file attachments are unavailable in this profile");
+	await inspectFilePaths(paths, attachments);
+	const checkCancelled = () => {
+		if (signal?.aborted === true) throw new Error("file submission cancelled");
+	};
+	const inputs = [];
+	for (const path of paths) {
+		checkCancelled();
+		let data;
+		try {
+			data = await readFile(path);
+		} catch (error) {
+			throw new Error(`cannot read file "${path}": ${error instanceof Error ? error.message : String(error)}`);
+		}
+		inputs.push({
+			data,
+			name: basename(path)
+		});
+	}
+	checkCancelled();
+	const refs = await Promise.all(inputs.map((input) => attachments.saveFile(input)));
+	checkCancelled();
+	return refs.map((attachment) => ({
+		type: "file",
+		attachment
+	}));
+}
 //#endregion
 //#region src/app.ts
 /**
@@ -30773,10 +31930,18 @@ const LOCAL_COMMANDS = [
 		label: "/plugin",
 		description: "inspect the live plugin composition"
 	},
+	{
+		label: "/update",
+		description: "update dsh-code, the harness host, and profile plugins in one aligned step"
+	},
 	{
 		label: "/jobs",
 		description: "inspect background jobs"
 	},
+	{
+		label: "/schedule",
+		description: "inspect active reminders (created through schedule tools)"
+	},
 	{
 		label: "/statusline",
 		description: "customize the status line items"
@@ -30785,6 +31950,10 @@ const LOCAL_COMMANDS = [
 		label: "/theme",
 		description: "switch the color theme"
 	},
+	{
+		label: "/animation",
+		description: "toggle timed animations (/animation [on|off])"
+	},
 	{
 		label: "/history",
 		description: "search and recall past prompts"
@@ -30844,12 +32013,21 @@ function padColumns(text, width) {
 	const clipped = truncateColumns(singleLineText(text), width);
 	return clipped + " ".repeat(Math.max(0, width - visibleColumns(clipped)));
 }
-/** Interval-driven frame counter for one self-contained animated leaf. */
+/**
+* Wall-clock frame counter for one self-contained animated leaf. Each fire
+* derives the tick from elapsed time instead of counting intervals, so a
+* stretched interval (busy event loop, slow SSH) skips the animation ahead
+* rather than slowing it down; the tick always tracks real time.
+*/
 function useFrames(intervalMs, active = true) {
 	const [tick, setTick] = (0, import_react.useState)(0);
 	(0, import_react.useEffect)(() => {
 		if (!active) return;
-		const id = setInterval(() => setTick((current) => current + 1), intervalMs);
+		const startedAt = Date.now();
+		setTick(0);
+		const id = setInterval(() => {
+			setTick(Math.max(0, Math.floor((Date.now() - startedAt) / intervalMs)));
+		}, intervalMs);
 		return () => {
 			clearInterval(id);
 		};
@@ -30870,14 +32048,17 @@ function useStableInput(handler, active) {
 	}, []);
 	useInput(stableHandler, { isActive: active });
 }
-/** The original web StateDot chase used by the busy composer marker. */
-function BusyChase() {
-	const tick = useFrames(125);
+/**
+* The original web StateDot chase used by the busy composer marker. With
+* animations off it freezes on the first frame (still visibly busy).
+*/
+function BusyChase({ animated = true }) {
+	const tick = useFrames(125, animated);
 	return (0, import_react.createElement)(Text, { color: inkColor(getPalette().brandBright) }, busyChaseFrame(tick) + " ");
 }
-/** Blinking block caret appended to streaming text. */
-function Caret() {
-	const tick = useFrames(530);
+/** Blinking block caret appended to streaming text; solid when frozen. */
+function Caret({ animated = true }) {
+	const tick = useFrames(530, animated);
 	return (0, import_react.createElement)(Text, null, caretVisible(tick) ? "▍" : " ");
 }
 /** One resettable input-caret phase shared by the entire composer. */
@@ -30904,17 +32085,19 @@ function useCursorBlink(active) {
 * One bounded line painted with the deep-diving shimmer: a continuously
 * moving blue gradient across graphemes, the `✻` glyph in the breathing
 * spark color. Shared by the busy line and the collapsed thinking marker;
-* always exactly one row (truncate-end) so the live budget stays exact.
+* always exactly one row (truncate-end) so the live budget stays exact. With
+* animations off the same spans render in fixed colors — no timer, no
+* per-frame repaint, the `✻` keeps its highlight.
 */
-function ShimmerLine({ text }) {
-	const tick = useFrames(33);
+function ShimmerLine({ text, animated = true }) {
+	const tick = useFrames(33, animated);
 	const palette = getPalette();
 	const graphemes = splitGraphemes(text);
 	return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, ...graphemes.map((grapheme, index) => {
 		const sparkle = grapheme.text === "✻";
 		return (0, import_react.createElement)(Text, {
 			key: `${grapheme.start}-${grapheme.end}`,
-			color: inkColor(sparkle ? deepDivingSparkColor(tick, palette.brandDeep, palette.brandBright) : deepDivingGradientColor(index, tick, graphemes.length, palette.brandDeep, palette.brandBright)),
+			color: inkColor(!animated ? sparkle ? palette.brandBright : palette.brandDeep : sparkle ? deepDivingSparkColor(tick, palette.brandDeep, palette.brandBright) : deepDivingGradientColor(index, tick, graphemes.length, palette.brandDeep, palette.brandBright)),
 			bold: sparkle || void 0
 		}, grapheme.text);
 	}));
@@ -30925,10 +32108,13 @@ function ShimmerLine({ text }) {
 * only once the turn has clearly been running (15s) — anchored to `turn/start`
 * so a resumed mid-turn keeps the real time.
 */
-function DeepDivingLine({ since }) {
+function DeepDivingLine({ since, animated = true }) {
 	const elapsed = since === 0 ? 0 : Date.now() - since;
 	const text = elapsed >= 15e3 ? `✻ Deep diving... ${runClock(elapsed)}` : "✻ Deep diving...";
-	return (0, import_react.createElement)(ShimmerLine, { text });
+	return (0, import_react.createElement)(ShimmerLine, {
+		text,
+		animated
+	});
 }
 /**
 * The streaming buffer rendered with a hard size cap: the live region must
@@ -31330,6 +32516,11 @@ function statusToneProps(tone) {
 			bold: true,
 			dimColor: void 0
 		};
+		case "plan": return {
+			color: inkColor(getPalette().success),
+			bold: true,
+			dimColor: void 0
+		};
 		case "warn": return {
 			color: inkColor(getPalette().warn),
 			bold: true,
@@ -31383,7 +32574,7 @@ function deepseekWaveHues(tier) {
 		palette.brandMid
 	];
 }
-function StatusLine({ facts, stats, busy, columns, items }) {
+function StatusLine({ facts, stats, busy, columns, items, onRows }) {
 	const layout = (0, import_react.useMemo)(() => layoutStatusBar(facts, stats, Math.max(8, columns - 2), {
 		busy,
 		items,
@@ -31406,6 +32597,10 @@ function StatusLine({ facts, stats, busy, columns, items }) {
 		columns,
 		items
 	]);
+	const statusRowCount = layout.row2.left.length > 0 ? 2 : 1;
+	(0, import_react.useEffect)(() => {
+		onRows?.(statusRowCount);
+	}, [onRows, statusRowCount]);
 	const renderRow = (row, key, indent = 0) => {
 		const leftParts = [];
 		row.left.forEach((group, groupIndex) => {
@@ -31946,36 +33141,44 @@ function QuestionBar({ store, snapshot, locked }) {
 }
 /** The /model panel: a scrolling list over the advisory model directory. */
 function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry, onClose }) {
+	const [query, setQuery] = (0, import_react.useState)("");
 	const [cursor, setCursor] = (0, import_react.useState)(0);
 	const stdout = useStdout().stdout;
 	const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
 	const rows = directory?.rows ?? [];
+	const filtered = (0, import_react.useMemo)(() => {
+		if (query === "") return rows;
+		const needle = query.toLowerCase();
+		return rows.filter((row) => `${row.provider} ${row.providerName ?? ""} ${row.model} ${row.modelName}`.toLowerCase().includes(needle));
+	}, [rows, query]);
 	const positioned = (0, import_react.useRef)(false);
 	(0, import_react.useEffect)(() => {
 		if (positioned.current || rows.length === 0 || current === void 0) {
-			if (rows.length === 0) {
+			if (filtered.length === 0) {
 				if (cursor !== 0) setCursor(0);
 				return;
 			}
-			if (cursor >= rows.length) setCursor(rows.length - 1);
+			if (cursor >= filtered.length) setCursor(filtered.length - 1);
 			return;
 		}
 		const index = rows.findIndex((row) => `${row.provider}/${row.model}` === current);
 		if (index >= 0) {
 			positioned.current = true;
-			setCursor(index);
-		} else if (cursor >= rows.length) setCursor(Math.max(0, rows.length - 1));
+			const filteredIndex = filtered.indexOf(rows[index]);
+			setCursor(filteredIndex >= 0 ? filteredIndex : 0);
+		} else if (cursor >= filtered.length) setCursor(Math.max(0, filtered.length - 1));
 	}, [
 		rows,
+		filtered,
 		cursor,
 		current
 	]);
 	useInput((input, key) => {
-		if (key.escape || input === "q") {
+		if (key.escape || input === "q" && query === "") {
 			onClose();
 			return;
 		}
-		if (input === "r") {
+		if (input === "r" && query === "") {
 			onRetry();
 			return;
 		}
@@ -31987,13 +33190,19 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
 			onClose();
 			return;
 		}
-		if (rows.length === 0) return;
+		const next = editQuery(query, input, key);
+		if (next !== void 0) {
+			setQuery(next);
+			setCursor(0);
+			return;
+		}
+		if (filtered.length === 0) return;
 		if (key.upArrow) {
-			setCursor(cursor > 0 ? cursor - 1 : rows.length - 1);
+			setCursor(cursor > 0 ? cursor - 1 : filtered.length - 1);
 			return;
 		}
 		if (key.downArrow) {
-			setCursor(cursor < rows.length - 1 ? cursor + 1 : 0);
+			setCursor(cursor < filtered.length - 1 ? cursor + 1 : 0);
 			return;
 		}
 		if (key.pageUp) {
@@ -32001,23 +33210,15 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
 			return;
 		}
 		if (key.pageDown) {
-			setCursor((current) => Math.min(rows.length - 1, current + Math.max(1, viewport.bodyRows - 1)));
-			return;
-		}
-		if (input === "g") {
-			setCursor(0);
-			return;
-		}
-		if (input === "G") {
-			setCursor(rows.length - 1);
+			setCursor((current) => Math.min(filtered.length - 1, current + Math.max(1, viewport.bodyRows - 1)));
 			return;
 		}
-		if (key.return && rows[cursor] !== void 0) onSelect(rows[cursor]);
+		if (key.return && filtered[cursor] !== void 0) onSelect(filtered[cursor]);
 	});
 	if (viewport.maxHeight === 0 || viewport.compact) {
 		const providers = onProviders === void 0 ? "" : " · tab providers";
-		const state = rows.length === 0 ? directory === void 0 && error === void 0 ? "loading…" : error !== void 0 ? "error" : "no models" : `❯ ${rows[cursor]?.modelName ?? rows[cursor]?.model ?? ""}`;
-		return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns(`/model · ${state}${providers} · r retry · esc/q close`, viewport.contentColumns));
+		const state = filtered.length === 0 ? directory === void 0 && error === void 0 ? "loading…" : error !== void 0 ? "error" : query === "" ? "no models" : `no match for '${singleLineText(query)}'` : `❯ ${filtered[cursor]?.modelName ?? filtered[cursor]?.model ?? ""}`;
+		return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, truncateColumns(`/model · ${state}${providers} · ${query === "" ? "type to filter · r retry · esc/q close" : "backspace edits · esc close"}`, viewport.contentColumns));
 	}
 	const visibleStateRows = (directory === void 0 && error === void 0 ? [(0, import_react.createElement)(Text, {
 		key: "loading",
@@ -32035,10 +33236,14 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
 		key: "empty",
 		dimColor: true,
 		wrap: "truncate-end"
-	}, "  no models available")] : []]).slice(0, viewport.bodyRows);
+	}, "  no models available")] : filtered.length === 0 ? [(0, import_react.createElement)(Text, {
+		key: "no-match",
+		dimColor: true,
+		wrap: "truncate-end"
+	}, truncateColumns(`  no models match '${singleLineText(query)}'`, viewport.contentColumns))] : []]).slice(0, viewport.bodyRows);
 	const rowBudget = Math.max(0, viewport.bodyRows - visibleStateRows.length);
-	const first = selectionWindow(cursor, rows.length, rowBudget);
-	const visible = rowBudget === 0 ? [] : rows.slice(first, first + rowBudget);
+	const first = selectionWindow(cursor, filtered.length, rowBudget);
+	const visible = rowBudget === 0 ? [] : filtered.slice(first, first + rowBudget);
 	return (0, import_react.createElement)(Box, {
 		flexDirection: "column",
 		width: viewport.outerColumns,
@@ -32049,8 +33254,8 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
 		color: inkColor(getPalette().brand),
 		bold: true,
 		wrap: "truncate-end"
-	}, truncateColumns(`/model — select model${rows.length === 0 ? "" : ` · ${cursor + 1}/${rows.length}`}`, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), ...visibleStateRows, ...visible.map((row) => {
-		const index = rows.indexOf(row);
+	}, truncateColumns(query === "" ? `/model — select model${rows.length === 0 ? "" : ` · ${cursor + 1}/${rows.length}`}` : `/model — select model · ${filtered.length} of ${rows.length} match '${singleLineText(query)}'`, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), ...visibleStateRows, ...visible.map((row) => {
+		const index = filtered.indexOf(row);
 		const capability = row.inputModalities?.includes("image") === true ? " · image" : "";
 		const label = displayText(`${row.providerName} · ${row.modelName}${capability}`);
 		return (0, import_react.createElement)(Text, {
@@ -32061,7 +33266,7 @@ function ModelPanel({ directory, error, current, onSelect, onProviders, onRetry,
 	}), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
 		dimColor: true,
 		wrap: "truncate-end"
-	}, dim(truncateColumns(`↑↓ move · pgup/pgdn page · enter select${onProviders === void 0 ? "" : " · tab providers"} · r retry · esc/q close`, viewport.contentColumns))));
+	}, dim(truncateColumns(query === "" ? `type to filter · ↑↓ move · pgup/pgdn page · enter select${onProviders === void 0 ? "" : " · tab providers"} · r retry · esc/q close` : `↑↓ move · pgup/pgdn page · enter select · backspace edits · esc close`, viewport.contentColumns))));
 }
 /** Compact provider-state copy; only value-free credential facts cross this boundary. */
 function providerStateLabel(row) {
@@ -32213,7 +33418,8 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
 		const identity = row.displayName === row.provider ? row.provider : row.displayName + " (" + row.provider + ")";
 		const authorization = authorizationForProvider(authorizations, row.provider);
 		const authLabel = !(row.credential?.kind === "facts" && row.credential.configured) || authorization?.record.configured === true || authorization?.inFlight === true ? " · " + providerAuthorizationStatus(authorization) : "";
-		const label = identity + " · " + providerStateLabel(row) + authLabel + (row.removable ? " · custom" : "");
+		const diagnostic = row.diagnostic === void 0 ? "" : " · ! " + singleLineText(row.diagnostic);
+		const label = identity + " · " + providerStateLabel(row) + authLabel + (row.removable ? " · custom" : "") + diagnostic;
 		const idleColor = row.configured ? inkColor(getPalette().brandMid) : inkColor(getPalette().dim);
 		itemRows.push((0, import_react.createElement)(Text, {
 			key: row.provider,
@@ -32581,7 +33787,7 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
 		color: zone === "url" ? inkColor(getPalette().brandBright) : inkColor(getPalette().dim),
 		wrap: "truncate-end"
 	}, truncateColumns("  " + (zone === "url" ? ">" : " ") + " url   " + (baseURL === "" ? "(official default)" : baseURL) + (zone === "url" ? "▏" : ""), viewport.contentColumns));
-	const rowBudget = Math.max(0, viewport.bodyRows - stateRows.length - 3);
+	const rowBudget = Math.max(0, viewport.bodyRows - stateRows.length - (target.diagnostic === void 0 ? 0 : 1) - 3);
 	const first = selectionWindow(cursor, models.length + 1, rowBudget);
 	const modelRows = [];
 	for (let index = first; index < first + Math.max(0, Math.min(models.length + 1 - first, rowBudget)); index += 1) {
@@ -32614,7 +33820,11 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
 		color: inkColor(getPalette().brand),
 		bold: true,
 		wrap: "truncate-end"
-	}, truncateColumns("/model — configure " + target.displayName, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), keyRow, urlRow, ...stateRows, ...modelRows, (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
+	}, truncateColumns("/model — configure " + target.displayName, viewport.contentColumns)), ...target.diagnostic === void 0 ? [] : [(0, import_react.createElement)(Text, {
+		key: "diagnostic",
+		color: inkColor(getPalette().warn),
+		wrap: "truncate-end"
+	}, truncateColumns("! " + displayText(singleLineText(target.diagnostic)), viewport.contentColumns))], (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), keyRow, urlRow, ...stateRows, ...modelRows, (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
 		color: inkColor(getPalette().dim),
 		wrap: "truncate-end"
 	}, truncateColumns("↑↓ move · ←→ in/out · space remove · e efforts · c copy efforts · tab discover · enter save · esc back", viewport.contentColumns)));
@@ -32954,6 +34164,167 @@ function waveRowSpans(cells) {
 	}
 	return spans;
 }
+/** Index of the cell STARTING at a display column, if one does. */
+function cellIndexAtColumn(cells, target) {
+	let column = 0;
+	for (let index = 0; index < cells.length; index += 1) {
+		if (column === target) return index;
+		column += cells[index].width ?? visibleColumns(cells[index].char);
+		if (column > target) return void 0;
+	}
+}
+/**
+* Wall-clock wave frames — strictly ONE sweep per MOUNT; the mount-spanning
+* one-shot latch (surviving modal unmounts) lives in Input as `wavePlayedKey`.
+* The first gate-off after the sweep has started (it completed, a turn went
+* busy, image preparation began, animations were toggled off) latches `done`
+* for this mount, so the same mount can never resume or replay. A trigger
+* that lands while the gate is already down stays pending until the gate
+* rises once, then plays.
+*/
+function useWaveFrames(active, durationMs) {
+	const [tick, setTick] = (0, import_react.useState)(0);
+	const [done, setDone] = (0, import_react.useState)(false);
+	const startedRef = (0, import_react.useRef)(false);
+	(0, import_react.useEffect)(() => {
+		if (done) return;
+		if (!active) {
+			if (startedRef.current) setDone(true);
+			return;
+		}
+		startedRef.current = true;
+		const startedAt = Date.now();
+		const id = setInterval(() => {
+			const elapsed = Date.now() - startedAt;
+			if (elapsed >= durationMs) {
+				clearInterval(id);
+				setDone(true);
+				return;
+			}
+			setTick(Math.max(0, Math.floor(elapsed / 33)));
+		}, 33);
+		return () => {
+			clearInterval(id);
+		};
+	}, [
+		active,
+		durationMs,
+		done
+	]);
+	return {
+		tick,
+		done
+	};
+}
+/**
+* The self-contained wave leaf: it owns its 33ms tick, so the sweep
+* re-renders ONLY this component at ~30fps — Input's derived editor state
+* never re-runs per frame. Graphemes stay atomic and every background sample
+* advances by terminal display columns, so CJK and emoji cannot move the
+* caret or wrap the band. The duration gate renders the fallback band on the
+* frame the sweep completes.
+*/
+function ComposerWave(props) {
+	const { tier, style } = props;
+	const durationMs = deepseekWaveDuration(tier, style);
+	const { tick, done } = useWaveFrames(props.active, durationMs);
+	const settledRef = (0, import_react.useRef)(false);
+	const onSettledRef = (0, import_react.useRef)(props.onSettled);
+	onSettledRef.current = props.onSettled;
+	const settle = () => {
+		if (settledRef.current) return;
+		settledRef.current = true;
+		onSettledRef.current();
+	};
+	(0, import_react.useEffect)(() => {
+		if (done) settle();
+	}, [done]);
+	(0, import_react.useEffect)(() => () => {
+		settle();
+	}, []);
+	if (!props.active || done || tick * 33 >= durationMs) return props.fallback;
+	const hues = deepseekWaveHues(tier);
+	const bandRgb = getPalette().composerBand;
+	const totalBandRows = props.rows.length + 2;
+	const waveBg = (row, column) => {
+		const rgb = deepseekWaveColumnBg(tick, column, props.bandWidth, tier, style, hues, bandRgb, row, totalBandRows);
+		return rgb === null ? props.bandBg : inkColor(rgb);
+	};
+	const blankBandRow = (row) => {
+		const blanks = [];
+		for (let column = 0; column < props.bandWidth; column += 1) blanks.push({
+			char: " ",
+			width: 1,
+			backgroundColor: waveBg(row, column)
+		});
+		return (0, import_react.createElement)(Text, { key: `blank-${row}` }, ...waveRowSpans(blanks));
+	};
+	const editorWaveRows = props.rows.map((row, visibleIndex) => {
+		const sourceIndex = props.windowStart + visibleIndex;
+		const bandRow = visibleIndex + 1;
+		const parts = editorRowParts(row, sourceIndex, props.caretRow, props.cursor);
+		const placeholder = sourceIndex === 0 && props.value === "";
+		const cells = [];
+		let usedColumns = 0;
+		const push = (char, extra = {}) => {
+			const width = visibleColumns(char);
+			cells.push({
+				char,
+				width,
+				backgroundColor: waveBg(bandRow, usedColumns),
+				...extra
+			});
+			usedColumns += width;
+		};
+		if (sourceIndex === 0) {
+			push(props.promptGlyph, {
+				color: props.promptColor,
+				bold: true
+			});
+			push(" ", { color: props.promptColor });
+		} else {
+			push(" ");
+			push(" ");
+		}
+		for (const span of splitGraphemes(parts.before)) push(span.text);
+		if (parts.hasCaret) push(parts.caret, { inverse: props.caretVisible });
+		const tail = placeholder ? COMPOSER_PLACEHOLDER : parts.after;
+		for (const span of splitGraphemes(tail)) push(span.text, placeholder ? { dim: true } : {});
+		while (usedColumns < props.bandWidth) push(" ");
+		const middleBandRow = Math.floor(totalBandRows / 2);
+		if (bandRow === middleBandRow && deepseekWaveWordVisible(tick, tier, style)) {
+			const word = tier === "unknown" ? "Into the Unknown" : "deepseek";
+			const start = Math.max(2, Math.floor((props.bandWidth - word.length) / 2));
+			const indices = Array.from({ length: word.length }, (_, at) => cellIndexAtColumn(cells, start + at));
+			if (indices.every((index) => index !== void 0 && (cells[index].char === " " || cells[index].dim === true))) for (let at = 0; at < word.length; at += 1) {
+				const cell = cells[indices[at]];
+				cell.char = word[at];
+				cell.width = 1;
+				cell.color = inkColor(deepseekWaveWordHue(at, hues));
+				cell.bold = true;
+				cell.dim = false;
+			}
+		}
+		if (bandRow === middleBandRow && (tier === "deepseek" || tier === "unknown") && style === "wave") {
+			const spark = deepseekWaveSpark(tick);
+			const lastIndex = cellIndexAtColumn(cells, props.bandWidth - 1);
+			if (spark !== null && lastIndex !== void 0 && cells[lastIndex].char === " ") {
+				cells[lastIndex].char = spark;
+				cells[lastIndex].color = props.promptColor;
+				cells[lastIndex].bold = true;
+				cells[lastIndex].dim = false;
+			}
+		}
+		return (0, import_react.createElement)(Text, {
+			key: `editor-${sourceIndex}`,
+			wrap: "truncate-end"
+		}, ...waveRowSpans(cells));
+	});
+	return (0, import_react.createElement)(Box, {
+		flexDirection: "column",
+		width: props.bandWidth
+	}, blankBandRow(0), ...editorWaveRows, blankBandRow(totalBandRows - 1));
+}
 /**
 * The Ctrl+O transcript inspector: one selected durable entry at a time,
 * with independent history selection and content scrolling. The complete
@@ -33113,8 +34484,10 @@ function completionCandidates(value, descriptors, skills) {
 		seen.add(name);
 		all.push(candidate);
 	}
-	if (prefix === "") return all;
-	return all.filter((candidate) => candidate.label.slice(1).startsWith(prefix));
+	return rankByName(all.map((candidate) => ({
+		name: candidate.label.slice(1),
+		candidate
+	})), prefix).map((entry) => entry.candidate);
 }
 /**
 * Shared completion-menu geometry: the menu view and the App's dynamic-row
@@ -33196,9 +34569,12 @@ function CompletionMenu({ active, mention, index, rows, error }) {
 * While a modal (approval / question / model panel) owns the keys, the
 * box passes every key through untouched.
 */
-function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openPlugin, openJobs, openStatusline, openTheme, openHistory, openAgents, openSubagent, openTodos, openDelete, openDiff, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, applyEditorKeys, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, cyclePermission, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, waveTier, waveStyle, maxRows, onEditorRows, onMenuRows }) {
-	const columns = useStdout().stdout?.columns ?? 80;
-	const inputTerminalRows = useStdout().stdout?.rows ?? 30;
+function Input({ active, frozen, frozenHint, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openPlugin, openUpdate, openSchedule, openJobs, openStatusline, openTheme, openHistory, openAgents, openSubagent, openTodos, openDelete, openDiff, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, applyEditorKeys, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, inspectFiles, prepareFiles, cycleMode, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, animations, applyAnimations, waveTier, waveStyle, maxRows, anchorRowsBelow, tabTitle, onEditorRows, onMenuRows, sessionKey }) {
+	const { stdout: inputStdout } = useStdout();
+	const columns = inputStdout?.columns ?? 80;
+	const inputTerminalRows = inputStdout?.rows ?? 30;
+	const tabTitleRef = (0, import_react.useRef)(tabTitle);
+	tabTitleRef.current = tabTitle;
 	const editorColumns = Math.max(1, columns - 6);
 	const stdin = useStdin().stdin;
 	const focusReporting = isVsCodeTerminalEnv();
@@ -33211,10 +34587,13 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	const [draftImages, setDraftImages] = (0, import_react.useState)([]);
 	const draftImagesRef = (0, import_react.useRef)(draftImages);
 	draftImagesRef.current = draftImages;
+	const [draftFiles, setDraftFiles] = (0, import_react.useState)([]);
+	const draftFilesRef = (0, import_react.useRef)(draftFiles);
+	draftFilesRef.current = draftFiles;
 	const [preparingImages, setPreparingImages] = (0, import_react.useState)(false);
 	const prepareAbortRef = (0, import_react.useRef)(void 0);
 	const prepareEpochRef = (0, import_react.useRef)(0);
-	const { visible: cursorVisible, reset: resetCursorBlink } = useCursorBlink(active && !frozen && !preparingImages);
+	const { visible: cursorVisible, reset: resetCursorBlink } = useCursorBlink(active && !frozen && !preparingImages && animations);
 	(0, import_react.useEffect)(() => () => {
 		prepareEpochRef.current += 1;
 		prepareAbortRef.current?.abort();
@@ -33238,6 +34617,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		const safe = sanitizeDraftText(historyFill.text);
 		draftImagesRef.current = [];
 		setDraftImages([]);
+		draftFilesRef.current = [];
+		setDraftFiles([]);
 		valueRef.current = safe;
 		cursorRef.current = safe.length;
 		setValue(safe);
@@ -33264,6 +34645,11 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			draftImagesRef.current = next;
 			return next.length === current.length ? current : next;
 		});
+		setDraftFiles((current) => {
+			const next = current.filter((file) => value.includes(file.marker));
+			draftFilesRef.current = next;
+			return next.length === current.length ? current : next;
+		});
 	}, [value]);
 	(0, import_react.useEffect)(() => {
 		if (stdin === void 0) return;
@@ -33274,6 +34660,10 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			const normalized = normalizeKeyboardChunk(typeof chunk === "string" ? chunk : String(chunk));
 			const input = focusReporting ? stripTerminalFocusEvents(normalized, (focused) => {
 				terminalFocusedRef.current = focused;
+				if (focused && inputStdout !== void 0) {
+					inputStdout.write(terminalTitleSequence(tabTitleRef.current));
+					process.title = sanitizeTerminalTitle(tabTitleRef.current);
+				}
 			}) : normalized;
 			rawEditorTokens.current = tokenizeRawEditorChunk(input);
 			return input;
@@ -33307,12 +34697,14 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	const [mentionError, setMentionError] = (0, import_react.useState)(void 0);
 	const mentionRequestRef = (0, import_react.useRef)(0);
 	const sameImagePath = (left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
-	const uniqueImageMarker = (name, source, reserved = []) => {
+	const uniqueImageMarker = (name, source, reserved = [], kind = "image") => {
 		const safeName = singleLineText(sanitizeDraftText(name));
-		let marker = source === "mention" ? `@${safeName}` : `[image: ${safeName}]`;
+		const label = kind === "file" ? "file" : "image";
+		let marker = source === "mention" ? `@${safeName}` : `[${label}: ${safeName}]`;
 		let suffix = 2;
-		while (valueRef.current.includes(marker) || draftImagesRef.current.some((image) => image.marker === marker) || reserved.includes(marker)) {
-			marker = source === "mention" ? `@${safeName} (${suffix})` : `[image: ${safeName} ${suffix}]`;
+		const taken = (candidate) => valueRef.current.includes(candidate) || draftImagesRef.current.some((image) => image.marker === candidate) || draftFilesRef.current.some((file) => file.marker === candidate) || reserved.includes(candidate);
+		while (taken(marker)) {
+			marker = source === "mention" ? `@${safeName} (${suffix})` : `[${label}: ${safeName} ${suffix}]`;
 			suffix += 1;
 		}
 		return marker;
@@ -33330,24 +34722,41 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		setDraftImages(next);
 		return true;
 	};
-	const insertDroppedImages = (paths) => {
+	/**
+	* Attach a paste/drop split into image and non-image paths: images ride the
+	* durable image blocks, files ride the 0.1.5 file blocks, and both register
+	* visible draft markers anchored at the drop point.
+	*/
+	const insertDroppedAttachments = (imagePaths, filePaths) => {
 		const originalValue = valueRef.current;
 		const originalCursor = cursorRef.current;
-		notify(`checking ${paths.length} image${paths.length === 1 ? "" : "s"}…`);
-		inspectImages(paths).then((inspected) => {
-			const additions = [];
+		const total = imagePaths.length + filePaths.length;
+		if (total === 0) return;
+		notify(`checking ${total} attachment${total === 1 ? "" : "s"}…`);
+		Promise.all([imagePaths.length === 0 ? Promise.resolve([]) : inspectImages(imagePaths), filePaths.length === 0 ? Promise.resolve([]) : inspectFiles(filePaths)]).then(([inspectedImages, inspectedFiles]) => {
+			const imageAdditions = [];
+			const fileAdditions = [];
 			const markers = [];
-			for (const inspection of inspected) {
-				if ([...draftImagesRef.current, ...additions].some((image) => sameImagePath(image.path, inspection.path))) continue;
+			for (const inspection of inspectedImages) {
+				if ([...draftImagesRef.current, ...imageAdditions].some((image) => sameImagePath(image.path, inspection.path))) continue;
 				const marker = uniqueImageMarker(inspection.name, "drop", markers);
-				additions.push({
+				imageAdditions.push({
 					...inspection,
 					marker
 				});
 				markers.push(marker);
 			}
-			if (additions.length === 0) {
-				notify("those images are already attached", "warning");
+			for (const inspection of inspectedFiles) {
+				if ([...draftFilesRef.current, ...fileAdditions].some((file) => sameImagePath(file.path, inspection.path))) continue;
+				const marker = uniqueImageMarker(inspection.name, "drop", markers, "file");
+				fileAdditions.push({
+					...inspection,
+					marker
+				});
+				markers.push(marker);
+			}
+			if (imageAdditions.length === 0 && fileAdditions.length === 0) {
+				notify("those attachments are already attached", "warning");
 				return;
 			}
 			const current = valueRef.current;
@@ -33356,7 +34765,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				end: originalCursor
 			});
 			if (anchor === void 0) {
-				notify("draft changed at the image drop point; drop the images again", "warning");
+				notify("draft changed at the attachment drop point; drop the files again", "warning");
 				return;
 			}
 			const at = anchor.start;
@@ -33368,12 +34777,16 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			setValue(edit.value);
 			setCursor(nextCursor);
 			resetCursorBlink();
-			const nextImages = [...draftImagesRef.current, ...additions];
+			const nextImages = [...draftImagesRef.current, ...imageAdditions];
 			draftImagesRef.current = nextImages;
 			setDraftImages(nextImages);
-			notify(`${additions.length} image${additions.length === 1 ? "" : "s"} ready for the next message`);
+			const nextFiles = [...draftFilesRef.current, ...fileAdditions];
+			draftFilesRef.current = nextFiles;
+			setDraftFiles(nextFiles);
+			const count = imageAdditions.length + fileAdditions.length;
+			notify(`${count} attachment${count === 1 ? "" : "s"} ready for the next message`);
 		}, (reason) => {
-			notify(`image attachment failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
+			notify(`attachment failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
 		});
 	};
 	(0, import_react.useEffect)(() => {
@@ -33408,7 +34821,16 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	]);
 	const menuActive = !preparingImages && (slashActive || mentionActive) && dismissedMenuValue !== value;
 	const visibleMentionRows = mentionToken !== void 0 && isPathLikeMentionQuery(mentionToken.query) ? mentionRows.filter((row) => row.kind !== "session") : mentionRows;
-	const menuRows = mentionActive ? visibleMentionRows.map((row) => ({
+	let rankedMentionRows = visibleMentionRows;
+	if (mentionToken !== void 0 && !isPathLikeMentionQuery(mentionToken.query) && mentionToken.query !== "") {
+		const hits = rankByName(visibleMentionRows.map((row) => ({
+			name: row.label.replace(/^@/u, ""),
+			row
+		})), mentionToken.query).map((entry) => entry.row);
+		const hitSet = new Set(hits);
+		rankedMentionRows = [...hits, ...visibleMentionRows.filter((row) => !hitSet.has(row))];
+	}
+	const menuRows = mentionActive ? rankedMentionRows.map((row) => ({
 		label: row.label.startsWith("@") ? row.label : `@${row.label}${row.kind === "directory" ? "/" : ""}`,
 		description: row.description,
 		origin: "mention"
@@ -33417,8 +34839,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	/** Accept the highlighted completion-menu candidate into the draft. */
 	const acceptMenuCandidate = () => {
 		if (mentionActive && mentionToken !== void 0) {
-			if (visibleMentionRows.length === 0) return;
-			const row = visibleMentionRows[completionIndex % visibleMentionRows.length];
+			if (rankedMentionRows.length === 0) return;
+			const row = rankedMentionRows[completionIndex % rankedMentionRows.length];
 			if (row !== void 0) {
 				if (row.kind === "file" && row.path !== void 0 && looksLikeImagePath(row.path)) {
 					const tokenText = value.slice(mentionToken.start, cursor);
@@ -33551,20 +34973,12 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		dismissNotice();
 		notify("image submission cancelled", "warning");
 	};
-	/** Move through visual rows first, then cross history at the true edge. */
+	/** Cross history while an unchanged recalled draft rests its caret on
+	* either text edge; between the edges (or inside ordinary drafts) the
+	* arrows move through visual rows first. */
 	const navigateVertical = (direction) => {
 		const currentValue = valueRef.current;
 		const currentCursor = cursorRef.current;
-		const model = editorModel(currentValue, editorColumns);
-		const preferred = preferredColumnRef.current ?? caretSite(model, currentCursor).column;
-		const next = moveCursorVertically(model, currentCursor, preferred, direction);
-		if (next !== currentCursor) {
-			cursorRef.current = next;
-			setCursor(next);
-			resetCursorBlink();
-			preferredColumnRef.current = preferred;
-			return;
-		}
 		if (recall.current.entries.length > 0 && shouldRecallNavigate(currentValue, currentCursor, recall.current.lastRecalled, direction)) {
 			const step = direction < 0 ? recallOlder(recall.current, currentValue) : recallNewer(recall.current);
 			recall.current = step.state;
@@ -33575,10 +34989,20 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				setValue(safe);
 				setCursor(safe.length);
 				preferredColumnRef.current = null;
-				setDismissedMenuValue(void 0);
+				setDismissedMenuValue(safe);
 			}
+			resetCursorBlink();
+			return;
+		}
+		const model = editorModel(currentValue, editorColumns);
+		const preferred = preferredColumnRef.current ?? caretSite(model, currentCursor).column;
+		const next = moveCursorVertically(model, currentCursor, preferred, direction);
+		if (next !== currentCursor) {
+			cursorRef.current = next;
+			setCursor(next);
+			resetCursorBlink();
+			preferredColumnRef.current = preferred;
 		}
-		resetCursorBlink();
 	};
 	useStableInput((input, key) => {
 		if (!active) return;
@@ -33595,8 +35019,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		}
 		if (key.tab && key.shift) {
 			try {
-				const next = cyclePermission();
-				if (next !== "") notify(`permission → ${next}`);
+				const label = cycleMode();
+				if (label !== "") notify(label);
 			} catch (error) {
 				notify(`permission change failed: ${error instanceof Error ? error.message : String(error)}`, "error");
 			}
@@ -33621,6 +35045,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				resetCursorBlink();
 				draftImagesRef.current = [];
 				setDraftImages([]);
+				draftFilesRef.current = [];
+				setDraftFiles([]);
 				setCompletionIndex(0);
 				setDismissedMenuValue(void 0);
 			} else quit();
@@ -33666,15 +35092,19 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			}
 			const trimmed = liveValue.trim();
 			const text = submissionPayload(liveValue);
-			if (draftImagesRef.current.length > 0) {
+			if (draftImagesRef.current.length > 0 || draftFilesRef.current.length > 0) {
+				if (isSlashLine(text)) notify("commands cannot carry attachments; the line will be sent to the model as a prompt", "warning");
+				const originSession = sessionKey;
 				const controller = new AbortController();
 				const epoch = prepareEpochRef.current + 1;
 				prepareEpochRef.current = epoch;
 				prepareAbortRef.current = controller;
 				setPreparingImages(true);
-				notify(`processing ${draftImagesRef.current.length} image${draftImagesRef.current.length === 1 ? "" : "s"}…`);
-				const snapshot = draftImagesRef.current;
-				prepareImages(snapshot.map((image) => image.path), controller.signal).then((images) => {
+				const imageSnapshot = draftImagesRef.current;
+				const fileSnapshot = draftFilesRef.current;
+				const total = imageSnapshot.length + fileSnapshot.length;
+				notify(`processing ${total} attachment${total === 1 ? "" : "s"}…`);
+				Promise.all([imageSnapshot.length === 0 ? Promise.resolve([]) : prepareImages(imageSnapshot.map((image) => image.path), controller.signal), fileSnapshot.length === 0 ? Promise.resolve([]) : prepareFiles(fileSnapshot.map((file) => file.path), controller.signal)]).then(([images, files]) => {
 					if (controller.signal.aborted || prepareEpochRef.current !== epoch) return;
 					prepareAbortRef.current = void 0;
 					setPreparingImages(false);
@@ -33684,6 +35114,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 					setCursor(0);
 					draftImagesRef.current = [];
 					setDraftImages([]);
+					draftFilesRef.current = [];
+					setDraftFiles([]);
 					setCompletionIndex(0);
 					setDismissedMenuValue(void 0);
 					dismissNotice();
@@ -33692,13 +35124,14 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 						recordHistory(text);
 					}
 					recall.current = beginRecall(recallSpace, "");
-					if (busy) steer(text, images);
-					else dispatch(text, images);
+					const blocks = [...images, ...files];
+					if (busy) steer(text, blocks, originSession);
+					else dispatch(text, blocks, originSession);
 				}, (reason) => {
 					if (controller.signal.aborted || prepareEpochRef.current !== epoch) return;
 					prepareAbortRef.current = void 0;
 					setPreparingImages(false);
-					notify(`image submission failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
+					notify(`attachment submission failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
 				});
 				return;
 			}
@@ -33711,10 +35144,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			setDismissedMenuValue(void 0);
 			if (trimmed === "") return;
 			dismissNotice();
-			if (!text.startsWith("/")) {
-				recordLocal(text);
-				recordHistory(text);
-			}
+			recordLocal(text);
+			recordHistory(text);
 			recall.current = beginRecall(recallSpace, "");
 			if (text === "/quit") {
 				quit();
@@ -33793,6 +35224,14 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				openPlugin(text.slice(7).trim());
 				return;
 			}
+			if (text === "/update") {
+				openUpdate();
+				return;
+			}
+			if (text === "/schedule") {
+				openSchedule();
+				return;
+			}
 			if (text === "/jobs" || text.startsWith("/jobs ")) {
 				openJobs();
 				return;
@@ -33805,6 +35244,13 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				openTheme();
 				return;
 			}
+			if (text === "/animation" || text.startsWith("/animation ")) {
+				const parsed = parseAnimationsArgument(text.slice(10));
+				if (parsed === "toggle") applyAnimations(!animations);
+				else if (parsed === "usage") notify("usage: /animation [on|off]", "info");
+				else applyAnimations(parsed.enabled);
+				return;
+			}
 			if (text === "/history") {
 				openHistory();
 				return;
@@ -33946,48 +35392,26 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				text = text.replaceAll(PASTE_END_MARKER, "");
 			}
 			if (text === "") return;
-			const droppedPaths = text.length > 1 ? parsePastedImagePaths(text) : [];
-			if (droppedPaths.length > 0) {
-				insertDroppedImages(droppedPaths);
-				return;
+			if (text.length > 1) {
+				const dropped = parsePastedAttachmentPaths(text);
+				if (dropped.images.length > 0 || dropped.files.length > 0) {
+					insertDroppedAttachments(dropped.images, dropped.files);
+					return;
+				}
 			}
 			applyEdit(insertText(valueRef.current, cursorRef.current, text));
 		}
 	}, active);
-	const [waveTick, setWaveTick] = (0, import_react.useState)(null);
-	const wavePrevious = (0, import_react.useRef)({
-		tier: null,
-		style: null
-	});
+	const waveKey = waveTier !== null && waveStyle !== null ? `${waveTier}:${waveStyle}` : null;
+	const [wavePlayedKey, setWavePlayedKey] = (0, import_react.useState)(null);
 	(0, import_react.useEffect)(() => {
-		const previous = wavePrevious.current;
-		wavePrevious.current = {
-			tier: waveTier,
-			style: waveStyle
-		};
-		if (waveTier === null) {
-			setWaveTick(null);
-			return;
-		}
-		if (previous.tier !== waveTier || previous.style !== waveStyle) setWaveTick(0);
-	}, [waveTier, waveStyle]);
-	const waveActive = !preparingImages && waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 < deepseekWaveDuration(waveTier, waveStyle);
-	(0, import_react.useEffect)(() => {
-		if (!waveActive) return;
-		const id = setInterval(() => {
-			setWaveTick((current) => current === null ? 0 : current + 1);
-		}, 33);
-		return () => {
-			clearInterval(id);
-		};
-	}, [waveActive]);
-	(0, import_react.useEffect)(() => {
-		if (waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 >= deepseekWaveDuration(waveTier, waveStyle)) setWaveTick(null);
+		if (!animations && waveKey !== null && waveKey !== wavePlayedKey) setWavePlayedKey(waveKey);
 	}, [
-		waveTick,
-		waveTier,
-		waveStyle
+		animations,
+		waveKey,
+		wavePlayedKey
 	]);
+	const waveArmed = waveKey !== null && waveKey !== wavePlayedKey;
 	const tierActive = waveTier !== null;
 	const tierHues = waveTier === null ? null : deepseekWaveHues(waveTier);
 	const promptColor = tierHues === null ? inkColor(getPalette().brand) : inkColor(tierHues[0]);
@@ -34004,6 +35428,12 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	(0, import_react.useEffect)(() => {
 		onEditorRows(editorRowCount);
 	}, [editorRowCount, onEditorRows]);
+	const caretRowInWindow = Math.max(0, Math.min(caret.row - editorWindowStart, editorWindowRows - 1));
+	useImeCursorAnchor(!frozen, imeCursorRowsUp({
+		editorWindowRows,
+		caretRowInWindow,
+		rowsBelowComposer: anchorRowsBelow
+	}), 2 + caret.column);
 	(0, import_react.useEffect)(() => {
 		onMenuRows(menuHeightRows);
 		return () => onMenuRows(0);
@@ -34029,7 +35459,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				bold: true
 			}, warning), bandFill(2 + visibleColumns(warning))));
 		}
-		const frozenLine = value === "" ? "type a message" : verboseLine(value, Math.max(1, columns - 6));
+		const frozenLine = value === "" ? frozenHint ?? "type a message" : verboseLine(value, Math.max(1, columns - 6));
 		return band((0, import_react.createElement)(Text, {
 			backgroundColor: bandBg,
 			wrap: "truncate-end"
@@ -34059,7 +35489,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		}, index === 0 ? preparingImages ? (0, import_react.createElement)(Text, {
 			color: inkColor(getPalette().warn),
 			bold: true
-		}, "… ") : busy ? (0, import_react.createElement)(BusyChase) : (0, import_react.createElement)(Text, {
+		}, "… ") : busy ? (0, import_react.createElement)(BusyChase, { animated: animations }) : (0, import_react.createElement)(Text, {
 			color: promptColor,
 			bold: tierActive ? true : void 0
 		}, `${promptGlyph} `) : "  ", parts.before, parts.hasCaret ? (0, import_react.createElement)(Text, {
@@ -34068,100 +35498,26 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		}, parts.caret) : null, placeholder ? (0, import_react.createElement)(Text, { dimColor: true }, COMPOSER_PLACEHOLDER) : parts.after, bandFill(consumed)));
 	}
 	const staticEditor = (0, import_react.createElement)(Box, { flexDirection: "column" }, ...editorRows);
-	const waveRow = () => {
-		const hues = deepseekWaveHues(waveTier);
-		const style = waveStyle;
-		const bandRgb = getPalette().composerBand;
-		const visibleRows = editorViewModel.rows.slice(editorWindowStart, editorWindowStart + editorWindowRows);
-		const totalBandRows = visibleRows.length + 2;
-		const waveBg = (row, column) => {
-			const rgb = deepseekWaveColumnBg(waveTick, column, bandWidth, waveTier, style, hues, bandRgb, row, totalBandRows);
-			return rgb === null ? bandBg : inkColor(rgb);
-		};
-		const blankBandRow = (row) => {
-			const blanks = [];
-			for (let column = 0; column < bandWidth; column += 1) blanks.push({
-				char: " ",
-				width: 1,
-				backgroundColor: waveBg(row, column)
-			});
-			return (0, import_react.createElement)(Text, { key: `blank-${row}` }, ...waveRowSpans(blanks));
-		};
-		const cellIndexAtColumn = (cells, target) => {
-			let column = 0;
-			for (let index = 0; index < cells.length; index += 1) {
-				if (column === target) return index;
-				column += cells[index].width ?? visibleColumns(cells[index].char);
-				if (column > target) return void 0;
-			}
-		};
-		const editorWaveRows = visibleRows.map((row, visibleIndex) => {
-			const sourceIndex = editorWindowStart + visibleIndex;
-			const bandRow = visibleIndex + 1;
-			const parts = editorRowParts(row, sourceIndex, caret.row, clampedCursor);
-			const placeholder = sourceIndex === 0 && value === "" && !busy;
-			const cells = [];
-			let usedColumns = 0;
-			const push = (char, extra = {}) => {
-				const width = visibleColumns(char);
-				cells.push({
-					char,
-					width,
-					backgroundColor: waveBg(bandRow, usedColumns),
-					...extra
-				});
-				usedColumns += width;
-			};
-			if (sourceIndex === 0) {
-				push(promptGlyph, {
-					color: promptColor,
-					bold: true
-				});
-				push(" ", { color: promptColor });
-			} else {
-				push(" ");
-				push(" ");
-			}
-			for (const span of splitGraphemes(parts.before)) push(span.text);
-			if (parts.hasCaret) push(parts.caret, { inverse: cursorVisible });
-			const tail = placeholder ? COMPOSER_PLACEHOLDER : parts.after;
-			for (const span of splitGraphemes(tail)) push(span.text, placeholder ? { dim: true } : {});
-			while (usedColumns < bandWidth) push(" ");
-			const middleBandRow = Math.floor(totalBandRows / 2);
-			if (bandRow === middleBandRow && deepseekWaveWordVisible(waveTick, waveTier, style)) {
-				const word = waveTier === "unknown" ? "Into the Unknown" : "deepseek";
-				const start = Math.max(2, Math.floor((bandWidth - word.length) / 2));
-				const indices = Array.from({ length: word.length }, (_, at) => cellIndexAtColumn(cells, start + at));
-				if (indices.every((index) => index !== void 0 && (cells[index].char === " " || cells[index].dim === true))) for (let at = 0; at < word.length; at += 1) {
-					const cell = cells[indices[at]];
-					cell.char = word[at];
-					cell.width = 1;
-					cell.color = inkColor(deepseekWaveWordHue(at, hues));
-					cell.bold = true;
-					cell.dim = false;
-				}
-			}
-			if (bandRow === middleBandRow && (waveTier === "deepseek" || waveTier === "unknown") && style === "wave") {
-				const spark = deepseekWaveSpark(waveTick);
-				const lastIndex = cellIndexAtColumn(cells, bandWidth - 1);
-				if (spark !== null && lastIndex !== void 0 && cells[lastIndex].char === " ") {
-					cells[lastIndex].char = spark;
-					cells[lastIndex].color = promptColor;
-					cells[lastIndex].bold = true;
-					cells[lastIndex].dim = false;
-				}
-			}
-			return (0, import_react.createElement)(Text, {
-				key: `editor-${sourceIndex}`,
-				wrap: "truncate-end"
-			}, ...waveRowSpans(cells));
-		});
-		return (0, import_react.createElement)(Box, {
-			flexDirection: "column",
-			width: bandWidth
-		}, blankBandRow(0), ...editorWaveRows, blankBandRow(totalBandRows - 1));
-	};
-	return (0, import_react.createElement)(Box, { flexDirection: "column" }, menu, waveTick !== null && waveTier !== null && waveStyle !== null && !busy && !preparingImages ? waveRow() : band(staticEditor));
+	return (0, import_react.createElement)(Box, { flexDirection: "column" }, menu, (0, import_react.createElement)(ComposerWave, {
+		key: waveKey ?? "static",
+		tier: waveTier ?? "deepseek",
+		style: waveStyle ?? "wave",
+		active: waveTier !== null && waveStyle !== null && !busy && !preparingImages && animations && waveArmed,
+		onSettled: () => {
+			if (waveKey !== null) setWavePlayedKey(waveKey);
+		},
+		fallback: band(staticEditor),
+		bandWidth,
+		bandBg,
+		rows: editorViewModel.rows.slice(editorWindowStart, editorWindowStart + editorWindowRows),
+		windowStart: editorWindowStart,
+		caretRow: caret.row,
+		cursor: clampedCursor,
+		caretVisible: cursorVisible,
+		value,
+		promptGlyph,
+		promptColor
+	}));
 }
 /** Build one settled row (row Box plus its roomy-prompt spacers and row count). */
 function buildSettledRow(entry, index, showReasoning, columns) {
@@ -34339,12 +35695,19 @@ function App(props) {
 	* to static while the prompt marker keeps the tier accent. The trigger
 	* follows the applied model label (what the status bar actually shows),
 	* never the initial paint, and the tier is derived from the label and
-	* cached at the switch. The 33ms tick itself lives inside Input, so the
-	* sweep re-renders only the composer band, not the whole tree, at 30fps;
-	* App owns the rarely-changing tier/style and Input starts the sweep
-	* whenever that pair changes. */
+	* cached at the switch. The 33ms tick itself lives inside the ComposerWave
+	* leaf, so the sweep re-renders only the composer band, not the whole tree,
+	* at 30fps; App owns the rarely-changing tier/style and the leaf plays the
+	* sweep exactly ONCE per pair change — an unchanged model+effort pair
+	* (ordinary turns, image preparation, /animation toggles) never replays. */
 	const [waveTier, setWaveTier] = (0, import_react.useState)(null);
 	const [waveStyle, setWaveStyle] = (0, import_react.useState)(null);
+	const [animations, setAnimations] = (0, import_react.useState)(props.animations ?? true);
+	const applyAnimations = (enabled) => {
+		setAnimations(enabled);
+		props.saveAnimations?.(enabled);
+		notify(`animations ${enabled ? "on" : "off"}`);
+	};
 	const previousModel = (0, import_react.useRef)(void 0);
 	const previousEffort = (0, import_react.useRef)(props.effort);
 	const previousStyle = (0, import_react.useRef)(void 0);
@@ -34468,6 +35831,8 @@ function App(props) {
 	const [resumeOpen, setResumeOpen] = (0, import_react.useState)(false);
 	const [pluginOpen, setPluginOpen] = (0, import_react.useState)(false);
 	const [pluginQuery, setPluginQuery] = (0, import_react.useState)("");
+	const [updateOpen, setUpdateOpen] = (0, import_react.useState)(false);
+	const [scheduleOpen, setScheduleOpen] = (0, import_react.useState)(false);
 	const [jobsOpen, setJobsOpen] = (0, import_react.useState)(false);
 	const [statuslineOpen, setStatuslineOpen] = (0, import_react.useState)(false);
 	const [statuslineItems, setStatuslineItems] = (0, import_react.useState)(() => parseStatuslineItems(props.statusline));
@@ -34540,7 +35905,7 @@ function App(props) {
 	const agentRows = (0, import_react.useSyncExternalStore)(props.subagents.subscribe, props.subagents.getSnapshot);
 	const approvalPending = approvalSnapshot.pending !== void 0;
 	const questionPending = questionSnapshot.pending !== void 0;
-	const inputActive = deleteConfirmId !== void 0 ? !approvalPending && !questionPending : !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !jobsOpen && !statuslineOpen && !themeOpen && !historyOpen && !agentsOpen && !subagentOpen && !todosOpen && !verboseOpen && diffView === void 0 && !approvalPending && !questionPending;
+	const inputActive = deleteConfirmId !== void 0 ? !approvalPending && !questionPending : !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !historyOpen && !agentsOpen && !subagentOpen && !todosOpen && !verboseOpen && diffView === void 0 && !approvalPending && !questionPending;
 	(0, import_react.useEffect)(() => {
 		if (!approvalPending && !questionPending) return;
 		setModelOpen(false);
@@ -34552,6 +35917,8 @@ function App(props) {
 		setPermissionOpen(false);
 		setResumeOpen(false);
 		setPluginOpen(false);
+		setUpdateOpen(false);
+		setScheduleOpen(false);
 		setStatuslineOpen(false);
 		setThemeOpen(false);
 		setHistoryOpen(false);
@@ -34617,11 +35984,18 @@ function App(props) {
 	const handleMenuRows = (0, import_react.useCallback)((rows) => {
 		setMenuRows((current) => current === rows ? current : rows);
 	}, []);
+	const [statusBarRows, setStatusBarRows] = (0, import_react.useState)(1);
+	const handleStatusRows = (0, import_react.useCallback)((rows) => {
+		setStatusBarRows((current) => current === rows ? current : rows);
+	}, []);
+	const imeRowsBelowComposer = statusBarRows + 1;
 	const composerEditorCap = composerMaxRows(terminalRows);
 	const MENU_RESERVE_ROWS = 5;
 	const dynamicRows = Math.max(1, terminalRows - 8 - MENU_RESERVE_ROWS - composerGutterRows - (composerRows - 1) - Math.max(0, menuRows - MENU_RESERVE_ROWS));
 	const streamingActive = view.streaming !== "" || view.streamingReasoning !== "";
 	const deepDivingVisible = busy && !streamingActive;
+	const tabTitle = view.title === "" ? DEFAULT_TERMINAL_TITLE : view.title;
+	useTerminalTitle(tabTitle);
 	const allLiveLines = (0, import_react.useMemo)(() => view.entries.slice(settled).flatMap((entry) => transcriptEntryLines(entry, Math.max(1, terminalColumns - 2), showReasoning)), [
 		view.entries,
 		settled,
@@ -34645,8 +36019,11 @@ function App(props) {
 	const auditedLiveLines = liveAudit.allocation.live === visibleLiveLines.length ? visibleLiveLines : visibleLiveLines.slice(-liveAudit.allocation.live);
 	const auditedReasoningRows = liveAudit.allocation.reasoning;
 	const auditedAnswerRows = liveAudit.allocation.answer;
-	const transcriptVisible = !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !jobsOpen && !statuslineOpen && !themeOpen && !historyOpen && !agentsOpen && !subagentOpen && !todosOpen && !verboseOpen && diffView === void 0 && !approvalPending && !questionPending;
-	const modalVisible = modelOpen || helpOpen || modeOpen || permissionOpen || resumeOpen || pluginOpen || jobsOpen || statuslineOpen || themeOpen || historyOpen || agentsOpen || subagentOpen || todosOpen || verboseOpen && !approvalPending && !questionPending || diffView !== void 0 || approvalPending || questionPending;
+	const transcriptVisible = !modelOpen && !helpOpen && !modeOpen && !permissionOpen && !resumeOpen && !pluginOpen && !updateOpen && !scheduleOpen && !jobsOpen && !statuslineOpen && !themeOpen && !historyOpen && !agentsOpen && !subagentOpen && !todosOpen && !verboseOpen && diffView === void 0 && !approvalPending && !questionPending;
+	const inspectorVisible = verboseOpen && !approvalPending && !questionPending;
+	const modalVisible = modelOpen || helpOpen || modeOpen || permissionOpen || resumeOpen || pluginOpen || updateOpen || scheduleOpen || jobsOpen || statuslineOpen || themeOpen || historyOpen || agentsOpen || subagentOpen || todosOpen || inspectorVisible || diffView !== void 0 || approvalPending || questionPending;
+	const keyboardOwner = approvalPending ? "the approval prompt" : questionPending ? "the question" : diffView !== void 0 ? "the diff review" : modelOpen ? "/model" : helpOpen ? "/help" : modeOpen ? "/mode" : permissionOpen ? "/permission" : resumeOpen ? "/resume" : pluginOpen ? "/plugin" : updateOpen ? "/update" : scheduleOpen ? "/schedule" : jobsOpen ? "/jobs" : statuslineOpen ? "/statusline" : themeOpen ? "/theme" : historyOpen ? "/history" : agentsOpen ? "/agents" : subagentOpen ? "/subagent" : todosOpen ? "/todos" : inspectorVisible ? "history details" : void 0;
+	const frozenHint = keyboardOwner === void 0 ? void 0 : `keys go to ${keyboardOwner} · esc ${approvalPending ? "rejects" : questionPending ? "cancels" : "closes"}`;
 	const closeInspector = (0, import_react.useCallback)(() => {
 		setVerboseOpen(false);
 	}, []);
@@ -34904,7 +36281,10 @@ function App(props) {
 		continuationPrefix: "  ",
 		dim: true,
 		maxRows: auditedReasoningRows
-	}) : view.streaming === "" ? (0, import_react.createElement)(ShimmerLine, { text: "✻ Thinking… (Ctrl/Alt+R to expand)" }) : (0, import_react.createElement)(StreamTail, {
+	}) : view.streaming === "" ? (0, import_react.createElement)(ShimmerLine, {
+		text: "✻ Thinking… (Ctrl/Alt+R to expand)",
+		animated: animations
+	}) : (0, import_react.createElement)(StreamTail, {
 		text: "Thinking… (Ctrl/Alt+R to expand)",
 		prefix: "✻ ",
 		continuationPrefix: "  ",
@@ -34915,7 +36295,10 @@ function App(props) {
 		dim: false,
 		maxRows: auditedAnswerRows,
 		prefix: "  "
-	}, busy ? (0, import_react.createElement)(Caret) : void 0) : void 0, deepDivingVisible ? (0, import_react.createElement)(DeepDivingLine, { since: view.busySince }) : void 0) : void 0, transcriptVisible ? (0, import_react.createElement)(TodoPanel, { todos: view.todos }) : void 0, transcriptVisible ? (0, import_react.createElement)(AgentsLine, {
+	}, busy ? (0, import_react.createElement)(Caret, { animated: animations }) : void 0) : void 0, deepDivingVisible ? (0, import_react.createElement)(DeepDivingLine, {
+		since: view.busySince,
+		animated: animations
+	}) : void 0) : void 0, transcriptVisible ? (0, import_react.createElement)(TodoPanel, { todos: view.todos }) : void 0, transcriptVisible ? (0, import_react.createElement)(AgentsLine, {
 		rows: agentRows,
 		total: props.subagents.getTotalSeen()
 	}) : void 0, todosOpen && !approvalPending && !questionPending ? (0, import_react.createElement)(MemoTodoListPanel, {
@@ -34987,6 +36370,14 @@ function App(props) {
 		load: props.loadPlugins,
 		initialQuery: pluginQuery,
 		close: () => setPluginOpen(false)
+	}) : void 0, updateOpen && !approvalPending && !questionPending ? (0, import_react.createElement)(UpdatePanel, {
+		probe: props.probeUpdate,
+		apply: props.applyUpdate,
+		notify: (text, tone) => notify(text, tone),
+		close: () => setUpdateOpen(false)
+	}) : void 0, scheduleOpen && !approvalPending && !questionPending ? (0, import_react.createElement)(SchedulePanel, {
+		rows: () => view.schedules,
+		close: () => setScheduleOpen(false)
 	}) : void 0, jobsOpen && !approvalPending && !questionPending ? (0, import_react.createElement)(JobsPanel, {
 		load: props.loadJobs,
 		close: () => setJobsOpen(false)
@@ -35049,6 +36440,7 @@ function App(props) {
 	}, (0, import_react.createElement)(Input, {
 		active: inputActive,
 		frozen: modalVisible,
+		frozenHint,
 		busy,
 		descriptors,
 		skills,
@@ -35106,6 +36498,8 @@ function App(props) {
 			setPluginQuery(query);
 			setPluginOpen(true);
 		},
+		openUpdate: () => setUpdateOpen(true),
+		openSchedule: () => setScheduleOpen(true),
 		openJobs: () => setJobsOpen(true),
 		openStatusline: () => setStatuslineOpen(true),
 		openTheme: () => setThemeOpen(true),
@@ -35153,7 +36547,10 @@ function App(props) {
 		loadMentions: props.loadMentions,
 		inspectImages: props.inspectImages,
 		prepareImages: props.prepareImages,
-		cyclePermission: props.cyclePermission,
+		inspectFiles: props.inspectFiles,
+		prepareFiles: props.prepareFiles,
+		sessionKey: props.sessionKey,
+		cycleMode: props.cycleMode,
 		exportTranscript: props.exportTranscript,
 		renameTitle: props.renameTitle,
 		copyLastResponse: props.copyLastResponse,
@@ -35164,9 +36561,13 @@ function App(props) {
 		cancelQueued: props.cancelQueued,
 		historyFill,
 		historyConsumed,
+		animations,
+		applyAnimations,
 		waveTier,
 		waveStyle,
 		maxRows: composerEditorCap,
+		anchorRowsBelow: imeRowsBelowComposer,
+		tabTitle,
 		onEditorRows: handleEditorRows,
 		onMenuRows: handleMenuRows
 	}), (0, import_react.createElement)(StatusLine, {
@@ -35177,7 +36578,7 @@ function App(props) {
 			branch: props.branch,
 			sessionId: props.sessionId,
 			title: view.title,
-			plan: view.plan,
+			plan: view.plan || props.pendingPlan === true,
 			permission: view.permission !== "" ? view.permission : props.permission,
 			sandbox: view.sandbox,
 			goal: view.goal === void 0 ? void 0 : {
@@ -35189,7 +36590,8 @@ function App(props) {
 		stats: view.stats,
 		busy,
 		columns: terminalColumns,
-		items: statuslineItems
+		items: statuslineItems,
+		onRows: handleStatusRows
 	})));
 }
 //#endregion
@@ -35441,26 +36843,37 @@ const internals = {
 	mount: (element) => {
 		const keyboardEnhanced = shouldEnableKeyboardEnhancement();
 		const focusReporting = isVsCodeTerminalEnv();
-		process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : "") + BRACKETED_PASTE_ENABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ""));
-		const tuiStdin = createSplitStdin(process.stdin);
-		const instance = render(element, {
-			exitOnCtrlC: false,
-			stdin: tuiStdin.stdin,
-			stdout: process.stdout
-		});
-		return {
-			rerender(element) {
-				instance.rerender(element);
-			},
-			unmount() {
-				try {
-					instance.unmount();
-				} finally {
-					tuiStdin.dispose();
-					process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : "") + BRACKETED_PASTE_DISABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ""));
+		if (process.stdin.isTTY === true) process.stdin.setRawMode?.(true);
+		try {
+			process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : "") + BRACKETED_PASTE_ENABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ""));
+			ensureVsCodeTabTitleSetting();
+			const tuiStdin = createSplitStdin(process.stdin);
+			const instance = render(element, {
+				exitOnCtrlC: false,
+				stdin: tuiStdin.stdin,
+				stdout: process.stdout
+			});
+			return {
+				rerender(element) {
+					instance.rerender(element);
+				},
+				unmount() {
+					try {
+						process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : "") + BRACKETED_PASTE_DISABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ""));
+					} finally {
+						try {
+							instance.unmount();
+						} finally {
+							tuiStdin.dispose();
+							if (process.stdin.isTTY === true) process.stdin.setRawMode?.(false);
+						}
+					}
 				}
-			}
-		};
+			};
+		} catch (error) {
+			if (process.stdin.isTTY === true) process.stdin.setRawMode?.(false);
+			throw error;
+		}
 	},
 	stderr: process.stderr
 };
@@ -35917,6 +37330,7 @@ function createTranscriptStore(replay) {
 	const listeners = /* @__PURE__ */ new Set();
 	let scheduled = false;
 	let lastNotifyAt = 0;
+	const attemptKeys = /* @__PURE__ */ new Map();
 	const notify = () => {
 		if (scheduled) return;
 		scheduled = true;
@@ -35948,8 +37362,28 @@ function createTranscriptStore(replay) {
 			dirty = true;
 			notify();
 		},
+		applyStreamFrame(frame) {
+			if (frame.type === "start") {
+				attemptKeys.set(frame.attemptId, `${frame.turn}:${frame.step}`);
+				return;
+			}
+			if (frame.type === "chunk") {
+				const key = attemptKeys.get(frame.attemptId);
+				if (key === void 0) return;
+				if (!applyAssistantStreamChunk(acc, key, frame.time, frame.chunk)) return;
+				dirty = true;
+				notify();
+				return;
+			}
+			attemptKeys.delete(frame.attemptId);
+			if (frame.outcome.kind === "abandoned" && clearAssistantStream(acc)) {
+				dirty = true;
+				notify();
+			}
+		},
 		reset() {
 			acc = createReplayAccumulator();
+			attemptKeys.clear();
 			dirty = true;
 			notify();
 		}
@@ -36017,12 +37451,27 @@ function foldSubagentRow(previous, sessionId, event) {
 			activity: "prompted",
 			updatedAt: event.time
 		};
-		case "assistant/chunk": return {
+		case "assistant/attempt": return {
 			...base,
 			state: "running",
 			activity: "thinking…",
 			updatedAt: event.time
 		};
+		case "subagent/catalog": {
+			const mode = event.data.mode === "continuable" ? "continuable" : "one-shot";
+			const label = event.data.label !== void 0 && event.data.label.trim() !== "" ? bound(event.data.label) : void 0;
+			const nextLabel = label === void 0 ? base.label : label;
+			const activity = label === void 0 ? `catalog · ${mode}` : `catalog · ${mode} · ${label}`;
+			const state = previous === void 0 ? "idle" : base.state;
+			if (nextLabel === base.label && state === base.state && activity === base.activity) return base;
+			return {
+				...base,
+				state,
+				label: nextLabel,
+				activity,
+				updatedAt: event.time
+			};
+		}
 		case "assistant/message": return {
 			...base,
 			state: "idle",
@@ -36098,7 +37547,7 @@ function createSubagentFeed() {
 			const counted = !seen.has(sessionId);
 			if (counted) seen.add(sessionId);
 			if (rows.length >= 8) {
-				const evict = rows.findIndex((row) => row.state === "done");
+				const evict = rows.findIndex((row) => row.state !== "running");
 				if (evict === -1) {
 					if (counted) notify();
 					return;
@@ -36158,8 +37607,8 @@ function watchSkills(ctx, fallbackCwd) {
 	const listeners = /* @__PURE__ */ new Set();
 	const reload = () => {
 		const target = agent;
-		if (skills === void 0 || target === void 0) return;
-		Promise.resolve().then(() => skills.list({
+		if (skills === void 0) return;
+		Promise.resolve().then(() => skills.list(target === void 0 ? { cwd: fallbackCwd } : {
 			cwd: target.session.header.cwd ?? fallbackCwd,
 			scope: target
 		})).then((summaries) => {
@@ -36174,13 +37623,18 @@ function watchSkills(ctx, fallbackCwd) {
 			for (const listener of listeners) listener();
 		}).catch((cause) => {
 			if (agent !== target) return;
+			const nextError = cause instanceof Error ? cause.message : String(cause);
 			if (loadedFor !== target) rows = [];
-			else rows = [...rows];
-			error = cause instanceof Error ? cause.message : String(cause);
+			const errorChanged = nextError !== error;
+			error = nextError;
+			if (!errorChanged) return;
 			for (const listener of listeners) listener();
 		});
 	};
-	if (skills !== void 0) ctx.on("skills/change", reload);
+	if (skills !== void 0) {
+		ctx.on("skills/change", reload);
+		reload();
+	}
 	return {
 		get rows() {
 			return rows;
@@ -36215,16 +37669,22 @@ function watchSkills(ctx, fallbackCwd) {
 * @param sessionId - the full session identity for the header.
 * @returns the complete markdown text.
 */
+/** Both user and queued rows export the same attachment label block. */
+const attachmentLabels = (entry) => [imageLabels(entry.images), fileLabels(entry.files)].filter((label) => label !== "").join("\n");
 function buildExportMarkdown(view, sessionId) {
 	const out = [
 		view.title === "" ? `# dsh session ${sessionId}` : `# ${view.title}`,
 		`> session ${sessionId}`,
 		""
 	];
+	if (view.systemPrompt !== "") out.push("<details><summary>system prompt</summary>", "", view.systemPrompt, "", "</details>", "");
 	for (const entry of view.entries) switch (entry.kind) {
 		case "user":
 			if (entry.notice) out.push(`> ⤷ context: ${entry.text}`, "");
-			else out.push("## user", "", entry.text, ...imageLabels(entry.images) === "" ? [] : [imageLabels(entry.images)], "");
+			else {
+				const attachments = attachmentLabels(entry);
+				out.push("## user", "", entry.text, ...attachments === "" ? [] : [attachments], "");
+			}
 			break;
 		case "assistant":
 			if (entry.reasoning !== "") out.push("<details><summary>thinking</summary>", "", entry.reasoning, "", "</details>", "");
@@ -36257,7 +37717,7 @@ function buildExportMarkdown(view, sessionId) {
 			out.push(`> files changed: ${entry.paths.join(", ")}`, "");
 			break;
 		case "pending":
-			out.push("## user", "", entry.text, ...imageLabels(entry.images) === "" ? [] : [imageLabels(entry.images)], "");
+			out.push("## user", "", entry.text, ...attachmentLabels(entry) === "" ? [] : [attachmentLabels(entry)], "");
 			break;
 		default: assertNever(entry, "transcript entry kind");
 	}
@@ -36872,13 +38332,6 @@ function selectPermission(service, session, preset) {
 	if (session !== void 0) service.set(session, preset);
 	return preset;
 }
-/** Cycle table order from the active, pending, or configured-default value. */
-function cyclePermission(service, session, pending) {
-	if (service.names.length === 0) return "";
-	const at = service.names.indexOf(effectivePermission(service, session, pending));
-	const next = service.names[(at + 1) % service.names.length] ?? "";
-	return next === "" ? "" : selectPermission(service, session, next);
-}
 /** Materialize a pre-session choice after Harness creates the first session. */
 function applyPendingPermission(service, session, pending) {
 	if (pending !== void 0 && effectivePermission(service, session, void 0) !== pending) selectPermission(service, session, pending);
@@ -36927,6 +38380,120 @@ function listPluginRows(ctx) {
 	return rows;
 }
 //#endregion
+//#region src/update.ts
+/**
+* Child-process adapter for the launcher update pipeline. The launcher
+* (bin/deepseek.mjs) stays the single owner of update semantics — plan,
+* guards, and the aligned install sequence — so the TUI only spawns
+* `update --json` (read-only probe) and `update --apply` (streamed run)
+* and never re-implements version-line decisions.
+*/
+/** The launcher entrypoint that ships beside this bundle (lib/../bin). */
+function launcherUpdateCommand(args, moduleUrl = import.meta.url) {
+	return {
+		command: process.execPath,
+		args: [fileURLToPath(new URL("../bin/deepseek.mjs", moduleUrl)), ...args]
+	};
+}
+/**
+* Split a streamed chunk sequence into complete display lines: CR is
+* stripped, a chunk boundary may split a line, and the trailing partial
+* stays pending until its newline arrives (npm writes whole lines, but a
+* pipe may cut anywhere). Blank lines carry no progress information and
+* are dropped so the panel budget is not spent on gaps.
+*/
+function createLineSplitter(onLine) {
+	let pending = "";
+	return (chunk) => {
+		pending += chunk;
+		for (let index = pending.indexOf("\n"); index >= 0; index = pending.indexOf("\n")) {
+			const line = pending.slice(0, index).replace(/\r$/u, "");
+			pending = pending.slice(index + 1);
+			if (line !== "") onLine(line);
+		}
+	};
+}
+/**
+* Probe the aligned update status. Read-only: `update --json` never
+* installs anything. The probe is bounded (npm view may hang on a broken
+* network) and resolves with the parsed status.
+*/
+async function probeLauncherUpdate(spawnProcess = spawn) {
+	const command = launcherUpdateCommand(["update", "--json"]);
+	return await new Promise((resolve, reject) => {
+		const child = spawnProcess(command.command, command.args, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: true
+		});
+		const timer = setTimeout(() => {
+			child.kill();
+			reject(/* @__PURE__ */ new Error("update probe timed out"));
+		}, 3e4);
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.once("error", (error) => {
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error(`update probe failed to start: ${error.message}`));
+		});
+		child.once("exit", (code) => {
+			clearTimeout(timer);
+			if (code === 0) {
+				try {
+					resolve(JSON.parse(stdout));
+				} catch {
+					reject(/* @__PURE__ */ new Error("update probe returned an unreadable status"));
+				}
+				return;
+			}
+			const tail = stderr.trim().split(/\r?\n/u).pop() ?? "";
+			reject(/* @__PURE__ */ new Error(`update probe failed${tail === "" ? "" : `: ${tail}`}`));
+		});
+	});
+}
+/**
+* Run the aligned update (`update --apply`) as a child process and stream
+* its sanitized progress lines to the caller. Resolves with the child
+* exit code (0 success); rejects only when the process could not start.
+* No timeout: an npm install may legitimately take minutes.
+*/
+function applyLauncherUpdate(onLine, spawnProcess = spawn) {
+	const command = launcherUpdateCommand(["update", "--apply"]);
+	return new Promise((resolve, reject) => {
+		const child = spawnProcess(command.command, command.args, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: true
+		});
+		const split = createLineSplitter(onLine);
+		child.stdout?.on("data", (chunk) => {
+			split(chunk.toString());
+		});
+		child.stderr?.on("data", (chunk) => {
+			split(chunk.toString());
+		});
+		child.once("error", (error) => {
+			reject(/* @__PURE__ */ new Error(`update failed to start: ${error.message}`));
+		});
+		child.once("close", (code, signal) => {
+			split("\n");
+			resolve(code ?? (signal === null ? 0 : 1));
+		});
+	});
+}
+//#endregion
 //#region src/settings-file.ts
 /**
 * Serialized, crash-atomic persistence for the small user-level JSON files
@@ -37108,6 +38675,43 @@ async function runQuitSequence(steps, exit, onError) {
 	return started;
 }
 /**
+* Whether a tagged submission still belongs to the active session. Attachment
+* prepares resolve on the microtask timeline, while a queued session switch
+* remounts the app asynchronously — the composing instance's unmount cleanup
+* runs too late to abort, so the delivery itself carries the composing
+* session's full id and the runner drops it here when the world moved on.
+* An untagged (synchronous) or pending-session ('') submission always passes.
+*/
+function submissionBelongsToSession(origin, activeSessionId) {
+	return origin === void 0 || origin === "" || origin === activeSessionId;
+}
+/**
+* Decide the next Shift+Tab station. The cycle keeps the preset table's
+* own order (most restrictive first) and inserts ONE plan station between
+* the most restrictive preset and the wrap target: with the shipped three
+* presets the user sees workspace-write → danger-full-access → read-only
+* → plan → workspace-write. Plan IS the most restrictive preset plus the
+* plan prompt layer — entering it switches nothing (the cycle is already
+* parked on read-only), and leaving it lands on the next preset after the
+* most restrictive one. Without the /plan command the cycle is exactly the
+* preset table.
+*/
+function planCycleDecision(input) {
+	const names = input.names;
+	if (names.length === 0) return void 0;
+	const first = names[0];
+	if (input.inPlan) return {
+		kind: "plan-off",
+		preset: names[1] ?? first
+	};
+	const at = names.indexOf(input.current);
+	if (at === 0 && input.planAvailable) return { kind: "plan-on" };
+	return {
+		kind: "permission",
+		preset: names[(at + 1) % names.length] ?? first
+	};
+}
+/**
 * Order-preserving gate for composer input while the startup prompt/images
 * are still preparing. Anything submitted before the startup delivery settles
 * queues and flushes afterwards in submit order, so the initial request can
@@ -37158,7 +38762,7 @@ async function resolveTarget(startup, persistence, cwd) {
 	};
 	if (startup.kind === "named") {
 		if (persistence !== void 0) {
-			if ((await persistence.list()).some((header) => header.id === startup.sessionId)) throw new Error(`session "${startup.sessionId}" already exists; use --resume to continue it`);
+			if ((await persistence.list()).map((snapshot) => snapshot.header).some((header) => header.id === startup.sessionId)) throw new Error(`session "${startup.sessionId}" already exists; use --resume to continue it`);
 		}
 		return {
 			sessionId: startup.sessionId,
@@ -37167,7 +38771,7 @@ async function resolveTarget(startup, persistence, cwd) {
 		};
 	}
 	if (persistence === void 0) throw new Error("cannot resolve the requested session: session persistence is not configured");
-	const headers = await persistence.list();
+	const headers = (await persistence.list()).map((snapshot) => snapshot.header);
 	if (startup.kind === "resume") {
 		const matched = matchSessionId(headers, startup.sessionId);
 		if (isSubagentSession(matched)) throw new Error("subagent conversations are read-only; resume a root session");
@@ -37226,12 +38830,12 @@ async function run(ctx, startup, io) {
 		const selectionState = pendingSelection === void 0 ? {} : { picked: pendingSelection };
 		let mode = next.resume ? next.mode : next.mode ?? pendingMode;
 		if (!next.resume) mode = (await presets.resolve(normalizePresetId(mode ?? presets.defaultId))).id;
-		const setup = async (agentCtx) => {
-			const sessionPreset = next.resume ? resolvePreset(agentCtx.agent.session) : mode;
+		const setup = async (agentCtx, agent) => {
+			const sessionPreset = next.resume ? resolvePreset(agent.session) : mode;
 			mode = (await presets.mount(agentCtx, sessionPreset)).id;
 			installModelSelection(agentCtx, {
 				get current() {
-					return resolveEffectiveSelection(selectionState.picked, agentCtx.agent?.session.requestHeader()?.config, currentDefaults());
+					return resolveEffectiveSelection(selectionState.picked, agent.session.requestHeader()?.config, currentDefaults());
 				},
 				set current(value) {
 					selectionState.picked = value;
@@ -37257,8 +38861,9 @@ async function run(ctx, startup, io) {
 				cwd: nextCwd,
 				agentPreset: mode,
 				...next.parentSession === void 0 ? {} : { parentSession: next.parentSession },
-				...next.seedLength === void 0 ? {} : { seedLength: next.seedLength }
+				...next.seedLength === void 0 ? {} : { isSeeded: true }
 			},
+			...next.seedLength === void 0 ? {} : { inheritedEventCount: SessionLogOffset(next.seedLength) },
 			...next.seed === void 0 ? {} : { seed: next.seed },
 			agentOptions: seedOptions,
 			signal: quitAbort.signal,
@@ -37292,6 +38897,37 @@ async function run(ctx, startup, io) {
 	/** Permission preset selected before the first session exists. */
 	let pendingPermission;
 	/**
+	* Plan-mode choice made before the first session exists: materialized as a
+	* /plan registry command delivered ahead of the first queued input when the
+	* session composes, so the first assembled step already plans.
+	*/
+	let pendingPlan = false;
+	/**
+	* Whether the pre-session effective preset composes plan mode, answered by
+	* the presets service composition inventory (minimal does not). Cached and
+	* refreshed whenever the pending mode moves; unknown reads as unavailable
+	* so one keypress at most lands before the answer arrives.
+	*/
+	let preSessionPlanAvailable = false;
+	let preSessionPlanKnown = false;
+	const refreshPreSessionPlan = () => {
+		if (presets === void 0) {
+			preSessionPlanAvailable = false;
+			preSessionPlanKnown = true;
+			return;
+		}
+		preSessionPlanKnown = false;
+		presets.compositionInventory().then((inventory) => {
+			const id = pendingMode ?? normalizePresetId(presets.defaultId);
+			preSessionPlanAvailable = inventory.some((composition) => composition.id === id && composition.rows.some((row) => row.moduleName === "@deepseek-ai/dsh-plan-mode" && row.enabled !== false));
+			preSessionPlanKnown = true;
+		}, () => {
+			preSessionPlanAvailable = false;
+			preSessionPlanKnown = true;
+		});
+	};
+	refreshPreSessionPlan();
+	/**
 	* Monotonic session epoch: bumped on every successful activation, on every
 	* first-session creation, and on quit. Async callbacks (mention prepares,
 	* command executions) capture it at call time and drop their result when it
@@ -37335,10 +38971,15 @@ async function run(ctx, startup, io) {
 		if (session === void 0) return;
 		if (subject.id === session.id) {
 			store.apply(event);
+			if (event.type === "subagent/catalog" && event.data.childId !== "") subagents.apply(event.data.childId, event);
 			return;
 		}
 		if (subject.header.parentSession === session.id && subject.header.origin === "subagent") subagents.apply(subject.id, event);
 	});
+	ctx.on("agent/assistant-stream", ({ agent: source, frame }) => {
+		if (agent === void 0 || source.id !== agent.id) return;
+		store.applyStreamFrame(frame);
+	});
 	const commands = watchCommands(ctx);
 	if (agent !== void 0) commands.setAgent(agent);
 	const skills = watchSkills(ctx, cwd);
@@ -37410,6 +39051,19 @@ async function run(ctx, startup, io) {
 			bridge.notify("theme save failed: " + (writeError instanceof Error ? writeError.message : String(writeError)), "error");
 		});
 	};
+	const animationsPath = join(homedir(), ".dsh", "dsh-code", "animations.json");
+	let animationsEnabled = true;
+	let animationsWarning;
+	try {
+		animationsEnabled = parseAnimationsPref((JSON.parse(readFileSync(animationsPath, "utf8")) ?? {}).animations);
+	} catch (error) {
+		if (error.code !== "ENOENT") animationsWarning = error instanceof Error ? error.message : String(error);
+	}
+	const saveAnimations = (enabled) => {
+		settingsPersistence.save(animationsPath, JSON.stringify({ animations: enabled }, null, 2) + "\n").catch((writeError) => {
+			bridge.notify("animations save failed: " + (writeError instanceof Error ? writeError.message : String(writeError)), "error");
+		});
+	};
 	const historyPath = join(homedir(), ".dsh", "dsh-code", "history.jsonl");
 	let inputHistory = [];
 	let historyWriteChain = Promise.resolve();
@@ -37651,6 +39305,10 @@ async function run(ctx, startup, io) {
 				abortPendingControllers();
 				epoch += 1;
 				const queued = pendingInputs.splice(0);
+				if (pendingPlan) {
+					pendingPlan = false;
+					deliverLine("/plan", "followup");
+				}
 				for (const item of queued) deliverLine(item.text, item.mode, item.images);
 			} finally {
 				creating = false;
@@ -37697,7 +39355,8 @@ async function run(ctx, startup, io) {
 		});
 	};
 	/** Dispatch one submitted line: slash commands to the registry, other text to the agent. */
-	const dispatch = (text, images = []) => {
+	const dispatch = (text, images = [], origin) => {
+		if (!submissionBelongsToSession(origin, session?.id)) return;
 		send(text, "followup", images);
 	};
 	/**
@@ -37705,7 +39364,8 @@ async function run(ctx, startup, io) {
 	* 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, images = []) => {
+	const steer = (text, images = [], origin) => {
+		if (!submissionBelongsToSession(origin, session?.id)) return;
 		send(text, "steer", images);
 	};
 	/** Interrupt the running turn (Esc); true when a turn was actually cancelled. */
@@ -37732,24 +39392,56 @@ async function run(ctx, startup, io) {
 		return selected;
 	};
 	/**
-	* Cycle to the next permission preset (Shift+Tab). Before the first session,
-	* the choice remains process-local and is materialized when Harness creates
-	* that session; afterwards the canonical service writes durable events.
+	* Shift+Tab mode cycle: permission presets in table order, then the plan
+	* station when the composition offers the /plan command (preset-mounted,
+	* so minimal sessions and the pre-session state cycle permissions only).
+	* Plan transitions submit the upstream registry command — it stays the
+	* single owner of plan state; the TUI renders the durable plan/mode event
+	* it appends. Returns the notice label, or '' when nothing changed.
 	*/
-	const cyclePermission$1 = () => {
+	const cycleMode = () => {
 		if (permissionPresets === void 0 || permissionPresets.names.length === 0) {
 			bridge.notify("permission presets are not mounted in this composition", "warning");
 			return "";
 		}
 		try {
-			const next = cyclePermission(permissionPresets, session, pendingPermission);
-			if (session === void 0 && next !== "") {
-				pendingPermission = next;
+			const preSession = session === void 0;
+			if (preSession && !preSessionPlanKnown) refreshPreSessionPlan();
+			const decision = planCycleDecision({
+				names: permissionPresets.names,
+				current: effectivePermission(permissionPresets, session, pendingPermission),
+				inPlan: preSession ? pendingPlan : store.getView().plan === true,
+				planAvailable: preSession ? preSessionPlanAvailable : commands.descriptors.some((descriptor) => descriptor.name === "plan")
+			});
+			if (decision === void 0) return "";
+			if (decision.kind === "permission") {
+				const next = selectPermission(permissionPresets, session, decision.preset);
+				if (preSession) {
+					pendingPermission = next;
+					renderCurrent();
+				}
+				return `permission → ${next}`;
+			}
+			if (decision.kind === "plan-on") {
+				if (preSession) {
+					pendingPlan = true;
+					renderCurrent();
+					return "plan → on (applies to the first session)";
+				}
+				send("/plan", "followup");
+				return "plan → on";
+			}
+			if (preSession) {
+				pendingPlan = false;
+				pendingPermission = decision.preset;
 				renderCurrent();
+				return `plan → off · permission → ${decision.preset}`;
 			}
-			return next;
+			send("/plan off", "followup");
+			selectPermission(permissionPresets, session, decision.preset);
+			return `plan → off · permission → ${decision.preset}`;
 		} catch (error) {
-			bridge.notify(`permission change failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+			bridge.notify(`mode change failed: ${error instanceof Error ? error.message : String(error)}`, "error");
 			return "";
 		}
 	};
@@ -37833,14 +39525,17 @@ async function run(ctx, startup, io) {
 	const loadSessions = async (options, signal) => {
 		if (sessionQuery === void 0) throw new Error("session query is unavailable in this profile");
 		const records = await sessionQuery.listSessions(signal);
+		const root = jsonlSessionRoot(persistence);
 		const updated = /* @__PURE__ */ new Map();
-		for (const record of records) {
-			const location = persistence?.locate(record.header);
-			if (location === void 0) continue;
+		if (root !== void 0) await Promise.all(records.map(async (record) => {
 			try {
-				updated.set(record.header.id, (await stat(location.path)).mtimeMs);
+				const dir = sessionDirectoryFor(root, record.header.cwd, record.header.id);
+				const entries = await readdir(dir, { withFileTypes: true });
+				const stats = await Promise.all(entries.filter((entry) => entry.isFile() && isSessionArtifactName(entry.name)).map((entry) => stat(join(dir, entry.name))));
+				const newest = Math.max(...stats.map((info) => info.mtimeMs));
+				if (Number.isFinite(newest)) updated.set(record.header.id, newest);
 			} catch {}
-		}
+		}));
 		const projected = projectSessionRows(records, options, updated);
 		const page = projected.slice(0, 32);
 		if (page.length === 0) return projected;
@@ -37856,11 +39551,11 @@ async function run(ctx, startup, io) {
 	* 1. `planSessionDeletion` collects the subtree and refuses when the root
 	*    or ANY member is live (a live child would outlive its deleted
 	*    parent), ordering the plan children-first.
-	* 2. Every plan node must locate to a guarded artifact directory
-	*    (`encodeSegment(id)`/`session.jsonl` layout). Backends without a
-	*    locatable artifact (SQLite) refuse the WHOLE deletion here — no
-	*    file has been touched yet, so a backend or layout surprise can
-	*    never strand a half-deleted subtree.
+	* 2. Every plan node must derive to a guarded artifact directory
+	*    (`encodeSegment(id)` layout beneath the backend's config root).
+	*    Backends without a derivable artifact (non-JSONL) refuse the WHOLE
+	*    deletion here — no file has been touched yet, so a backend or layout
+	*    surprise can never strand a half-deleted subtree.
 	* 3. Artifacts are removed children-first: only an I/O error mid-delete
 	*    can stop it short (reported with removed/total counts), leaving the
 	*    shallowest lineage intact.
@@ -37874,22 +39569,23 @@ async function run(ctx, startup, io) {
 		const records = await sessionQuery.listSessions();
 		const plan = planSessionDeletion(records, id);
 		if (!plan.ok) return plan.reason;
+		const root = jsonlSessionRoot(persistence);
+		if (root === void 0) return "session backend exposes no deletable artifact (deletion is unsupported on this backend)";
 		const byId = new Map(records.map((record) => [record.header.id, record]));
 		const dirs = /* @__PURE__ */ new Map();
 		for (const node of plan.nodes) {
 			const record = byId.get(node.id);
 			if (record === void 0) return `no persisted session matches "${node.id}"`;
-			const location = persistence?.locate(record.header);
-			if (location === void 0) return `session backend exposes no deletable artifact for ${node.id.slice(-12)} (deletion is unsupported on this backend)`;
-			const dir = sessionArtifactDirectory(location.path, node.id);
-			if (dir === void 0) return `refusing to delete: unexpected artifact layout at ${location.path}`;
+			const dir = sessionArtifactDirectory(sessionDirectoryFor(root, record.header.cwd, node.id), node.id);
+			if (dir === void 0) return `refusing to delete: unexpected artifact layout for ${node.id.slice(-12)}`;
 			dirs.set(node.id, dir);
 		}
 		let removed = 0;
 		for (const node of plan.nodes) {
 			const dir = dirs.get(node.id);
 			try {
-				for (const name of SESSION_ARTIFACT_NAMES) await rm(join(dir, name), { force: true });
+				const entries = await readdir(dir, { withFileTypes: true });
+				for (const entry of entries) if (entry.isFile() && isSessionArtifactName(entry.name)) await rm(join(dir, entry.name), { force: true });
 				await rm(dir, {
 					force: true,
 					recursive: false
@@ -37958,6 +39654,7 @@ async function run(ctx, startup, io) {
 				subagents.reset();
 				pendingMode = void 0;
 				pendingPermission = void 0;
+				pendingPlan = false;
 			} catch (error) {
 				active = previous;
 				agent = previous?.agent;
@@ -38127,6 +39824,7 @@ async function run(ctx, startup, io) {
 		const permission = permissionPresets === void 0 ? currentView.permission : effectivePermission(permissionPresets, session, pendingPermission);
 		return (0, import_react.createElement)(App, {
 			key: session?.id ?? "pending",
+			sessionKey: session?.id ?? "",
 			store,
 			approval,
 			questions,
@@ -38142,6 +39840,8 @@ async function run(ctx, startup, io) {
 			resumed: active?.resumed ?? false,
 			mode: active?.mode ?? pendingMode ?? normalizePresetId(presets.defaultId),
 			permission,
+			/** Pre-session plan choice for the status badge until a session composes. */
+			pendingPlan: session === void 0 && pendingPlan,
 			dispatch,
 			steer,
 			interrupt,
@@ -38164,7 +39864,9 @@ async function run(ctx, startup, io) {
 			loadMentions: (query, signal) => mentions.candidates(query, signal),
 			inspectImages: (paths) => inspectImagePaths(paths, ctx.get("attachments"), session?.header.cwd ?? cwd),
 			prepareImages: (paths, signal) => saveImagePaths(paths, ctx.get("attachments"), signal),
-			cyclePermission: cyclePermission$1,
+			inspectFiles: (paths) => inspectFilePaths(paths, ctx.get("attachments"), session?.header.cwd ?? cwd),
+			prepareFiles: (paths, signal) => saveFilePaths(paths, ctx.get("attachments"), signal),
+			cycleMode,
 			setPermission: setPermissionAction,
 			selectModel,
 			subagentModel: subagentModelLabel(),
@@ -38197,11 +39899,15 @@ async function run(ctx, startup, io) {
 			switchSession,
 			cancelSessionSwitch,
 			loadPlugins: () => listPluginRows(ctx),
+			probeUpdate: () => probeLauncherUpdate(),
+			applyUpdate: (onLine) => applyLauncherUpdate(onLine),
 			loadJobs: () => listJobs(ctx, active?.agent),
 			statusline: statuslineItems,
 			saveStatusline,
 			applyEditorKeys,
 			saveTheme,
+			animations: animationsEnabled,
+			saveAnimations,
 			history: inputHistory,
 			recordHistory,
 			cancelQueued,
@@ -38240,6 +39946,9 @@ async function run(ctx, startup, io) {
 	if (themeWarning !== void 0) setTimeout(() => {
 		bridge.notify("theme config unreadable, using dark: " + themeWarning, "warning");
 	}, 50);
+	if (animationsWarning !== void 0) setTimeout(() => {
+		bridge.notify("animations config unreadable, animations stay on: " + animationsWarning, "warning");
+	}, 50);
 	resolveEditorKeysStartupHint(editorKeysEnv).then((hint) => {
 		if (hint === void 0) return;
 		setTimeout(() => {
@@ -38287,4 +39996,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, StartupInputGate, apply, exportSessionIdSuffix, inject, name, resolveTarget, runQuitSequence };
+export { Config, StartupInputGate, apply, exportSessionIdSuffix, inject, name, planCycleDecision, resolveTarget, runQuitSequence, submissionBelongsToSession };