dsh-code 1.0.6 → 1.0.7

package/lib/index.mjs

@@ -2,7 +2,7 @@ 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, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
@@ -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,40 @@ 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 "";
@@ -25202,6 +25615,7 @@ function createReplayAccumulator() {
 		systemPrompt: "",
 		sandbox: "",
 		goal: void 0,
+		schedules: [],
 		stats: {
 			turns: 0,
 			steps: 0,
@@ -25348,7 +25762,7 @@ function replayProjectEvent(acc, event) {
 			const text = textOf(message.content);
 			const images = imagesOf(message.content);
 			const files = filesOf(message.content);
-			if (message.source.kind === "user") {
+			if (message.source.kind === "user" || message.source.kind === "plugin" && REMINDER_PLUGINS.has(message.source.plugin)) {
 				appendReplayEntry(acc, {
 					kind: "user",
 					text,
@@ -25365,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",
@@ -25683,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;
@@ -25787,6 +26215,7 @@ function materializeReplayView(acc, copy) {
 		systemPrompt: acc.systemPrompt,
 		sandbox: acc.sandbox,
 		goal: acc.goal,
+		schedules: acc.schedules,
 		pending: {
 			"next-turn": [...acc.pendingTurn],
 			"next-step": [...acc.pendingStep]
@@ -25879,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
@@ -28384,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 = [];
@@ -28510,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)
 			},
@@ -28521,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,
@@ -29362,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
@@ -29710,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);
@@ -29756,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);
@@ -29788,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);
@@ -30469,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);
@@ -31304,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"
@@ -31882,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,
@@ -31935,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,
@@ -31958,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) => {
@@ -32498,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;
 		}
@@ -32539,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) {
@@ -32553,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",
@@ -32587,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,
@@ -32601,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, {
@@ -32613,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) {
@@ -33916,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, inspectFiles, prepareFiles, cyclePermission, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, animations, applyAnimations, waveTier, waveStyle, maxRows, onEditorRows, onMenuRows, sessionKey }) {
-	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();
@@ -34004,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;
@@ -34313,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;
@@ -34337,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;
@@ -34357,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");
 			}
@@ -34482,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();
@@ -34564,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;
@@ -34760,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);
@@ -34785,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"
@@ -35157,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));
@@ -35229,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);
@@ -35241,6 +35917,8 @@ function App(props) {
 		setPermissionOpen(false);
 		setResumeOpen(false);
 		setPluginOpen(false);
+		setUpdateOpen(false);
+		setScheduleOpen(false);
 		setStatuslineOpen(false);
 		setThemeOpen(false);
 		setHistoryOpen(false);
@@ -35306,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,
@@ -35334,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);
 	}, []);
@@ -35682,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)
@@ -35744,6 +36440,7 @@ function App(props) {
 	}, (0, import_react.createElement)(Input, {
 		active: inputActive,
 		frozen: modalVisible,
+		frozenHint,
 		busy,
 		descriptors,
 		skills,
@@ -35801,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),
@@ -35851,7 +36550,7 @@ function App(props) {
 		inspectFiles: props.inspectFiles,
 		prepareFiles: props.prepareFiles,
 		sessionKey: props.sessionKey,
-		cyclePermission: props.cyclePermission,
+		cycleMode: props.cycleMode,
 		exportTranscript: props.exportTranscript,
 		renameTitle: props.renameTitle,
 		copyLastResponse: props.copyLastResponse,
@@ -35867,6 +36566,8 @@ function App(props) {
 		waveTier,
 		waveStyle,
 		maxRows: composerEditorCap,
+		anchorRowsBelow: imeRowsBelowComposer,
+		tabTitle,
 		onEditorRows: handleEditorRows,
 		onMenuRows: handleMenuRows
 	}), (0, import_react.createElement)(StatusLine, {
@@ -35877,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 : {
@@ -35889,7 +36590,8 @@ function App(props) {
 		stats: view.stats,
 		busy,
 		columns: terminalColumns,
-		items: statuslineItems
+		items: statuslineItems,
+		onRows: handleStatusRows
 	})));
 }
 //#endregion
@@ -36144,6 +36846,7 @@ const internals = {
 		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,
@@ -37629,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);
@@ -37684,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
@@ -37876,6 +38686,32 @@ 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
@@ -38061,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
@@ -38438,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;
@@ -38521,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 "";
 		}
 	};
@@ -38751,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;
@@ -38936,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,
@@ -38960,7 +39866,7 @@ async function run(ctx, startup, io) {
 			prepareImages: (paths, signal) => saveImagePaths(paths, ctx.get("attachments"), signal),
 			inspectFiles: (paths) => inspectFilePaths(paths, ctx.get("attachments"), session?.header.cwd ?? cwd),
 			prepareFiles: (paths, signal) => saveFilePaths(paths, ctx.get("attachments"), signal),
-			cyclePermission: cyclePermission$1,
+			cycleMode,
 			setPermission: setPermissionAction,
 			selectModel,
 			subagentModel: subagentModelLabel(),
@@ -38993,6 +39899,8 @@ 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,
@@ -39088,4 +39996,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, StartupInputGate, apply, exportSessionIdSuffix, inject, name, resolveTarget, runQuitSequence, submissionBelongsToSession };
+export { Config, StartupInputGate, apply, exportSessionIdSuffix, inject, name, planCycleDecision, resolveTarget, runQuitSequence, submissionBelongsToSession };