@songtonyli/dsh-cli 0.1.12 → 0.1.14

package/node_modules/@deepseek-ai/dsh-tui-app/lib/index.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { CURSOR_MARKER, Container, Editor, Input, Loader, Markdown, ProcessTerminal, SelectList, Text, TuiMainScreen, decodeKittyPrintable, fuzzyFilter, matchesKey, sliceByColumn, stripTerminalSequences, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { CURSOR_MARKER, Container, Editor, Input, Loader, Markdown, ProcessTerminal, SelectList, Text, TuiMainScreen, decodeKittyPrintable, fuzzyFilter, matchesKey, sliceByColumn, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import z from "@deepseek-ai/schemastery";
 import { brandString } from "@deepseek-ai/dsh-brand";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
@@ -444,9 +444,11 @@ function previewLines(lines, previewLines, expanded) {
 //#region lib/types/catalog.js
 /**
 * Terminal rows for the browser's settings, plugins, subagents, deliverables,
-* and turn-outline pages. Each reader resolves its service through `ctx.get`
-* and throws an `Error` naming the absent service; the app prints the message.
-* `subagentDetail` is the exception: it returns that message as a row.
+* changed-files, and turn-outline pages, and the plugin-management verbs the
+* browser's Plugins page offers. Each reader resolves its service through
+* `ctx.get` and throws an `Error` naming the absent service; the app prints
+* the message. `subagentDetail` is the exception: it returns that message as a
+* row.
 * @module @deepseek-ai/dsh-tui-app/catalog
 */
 var __addDisposableResource$1 = function(env, value, async) {
@@ -797,6 +799,191 @@ function sessionOutline(ctx, session) {
 	if (outline === void 0) throw new Error("the turnOutline projection is not registered in this profile");
 	return outline.flatMap(outlineRows);
 }
+/** The workspace-changes service, or a printable error naming its absence. */
+function requireWorkspaceChanges(ctx) {
+	const changes = ctx.get("workspaceChanges");
+	if (changes === void 0) throw new Error("workspace changes are not recorded in this profile");
+	return changes;
+}
+/** `N file` or `N files`. */
+function fileCount(total) {
+	return `${String(total)} file${total === 1 ? "" : "s"}`;
+}
+/**
+* The files one turn changed, as `/changes` picker rows: the latest
+* `workspace/changes` announcement of `turn`, or of the newest announced turn
+* when `turn` is undefined, resolved through the Host's summary.
+* @param ctx - plugin context carrying the optional workspace-changes service and session query engine.
+* @param sessionId - the session whose log is read.
+* @param turn - the turn to list, or undefined for the latest announced one.
+* @param signal - cancels a cold log read.
+* @returns the rows under the turn's totals, or undefined when no such turn was announced.
+* @throws {Error} when either service is not mounted, or when the Host no longer holds the announced summary.
+*/
+async function listTurnChanges(ctx, sessionId, turn, signal) {
+	const env_3 = {
+		stack: [],
+		error: void 0,
+		hasError: false
+	};
+	try {
+		const changes = requireWorkspaceChanges(ctx);
+		const query = ctx.get("sessionQuery");
+		if (query === void 0) throw new Error("the session query engine is not mounted in this profile");
+		const observation = __addDisposableResource$1(env_3, await query.observeSession(sessionId, {
+			signal,
+			projectionMode: "none"
+		}), false);
+		let announced;
+		for (const event of observation.events) {
+			if (event.type !== "workspace/changes") continue;
+			if (turn !== void 0 && event.data.turn !== turn) continue;
+			announced = {
+				seq: event.seq,
+				turn: event.data.turn
+			};
+		}
+		if (announced === void 0) return void 0;
+		const summary = changes.summary(sessionId, announced.seq);
+		if (summary === void 0) throw new Error(`the changed files of turn ${String(announced.turn)} are no longer held by this host`);
+		const listed = summary.files.length === summary.total ? "" : ` (${String(summary.files.length)} listed)`;
+		return {
+			heading: `turn ${String(summary.turn)} · ${fileCount(summary.total)}${listed} · +${String(summary.added)} −${String(summary.deleted)}`,
+			choices: summary.files.map((file, index) => ({
+				index,
+				seq: announced.seq,
+				label: file.display,
+				description: file.binary === true ? "binary" : file.oversized === true ? "oversized" : `+${String(file.added)} −${String(file.deleted)}`
+			}))
+		};
+	} catch (e_3) {
+		env_3.error = e_3;
+		env_3.hasError = true;
+	} finally {
+		__disposeResources$1(env_3);
+	}
+}
+/**
+* The one-row notice a `workspace/changes` event prints once its summary is read.
+* @param summary - the announced turn's summary.
+* @returns the turn's file and line totals, naming `/changes` for the files.
+*/
+function changesNotice(summary) {
+	return `turn ${String(summary.turn)} changed ${fileCount(summary.total)} (+${String(summary.added)} −${String(summary.deleted)}) · /changes`;
+}
+/**
+* The comparison one `/changes` row opens: the file's turn-start and turn-end
+* contents as unified hunks in the tool cards' diff row form, `@@` headers
+* between them and `…` where hunks are apart.
+* @param ctx - plugin context carrying the optional workspace-changes service.
+* @param sessionId - the session the summary belongs to.
+* @param choice - the entered picker row.
+* @param signal - cancels the snapshot reads.
+* @returns the rows; explanatory rows when no lines can be shown.
+* @throws {Error} when the service is not mounted or a snapshot read fails.
+*/
+async function changeDiffRows(ctx, sessionId, choice, signal) {
+	const diff = await requireWorkspaceChanges(ctx).diff(sessionId, choice.seq, choice.index, signal);
+	if (diff === void 0) return [`${choice.label}: the comparison is no longer held by this host`];
+	switch (diff.kind) {
+		case "binary": return [`${diff.display}: binary content, no line comparison`];
+		case "oversized": return [`${diff.display}: larger than the comparison limit, no line comparison`];
+		case "text": {
+			const rows = [];
+			if (!diff.before) rows.push("new file");
+			if (!diff.after) rows.push("deleted");
+			if (diff.coarse) rows.push("comparison timed out: every line is shown as replaced");
+			if (diff.hunks.length === 0) rows.push("no line changes");
+			diff.hunks.forEach((hunk, index) => {
+				if (index > 0) rows.push("  …");
+				rows.push(`@@ -${String(hunk.oldStart)},${String(hunk.oldLines)} +${String(hunk.newStart)},${String(hunk.newLines)} @@`);
+				for (const line of hunk.lines) rows.push(`${line.slice(0, 1)} ${line.slice(1)}`);
+			});
+			return rows;
+		}
+		/* v8 ignore next -- closed-union exhaustiveness guard */
+		default: return assertNever(diff, "tui workspace file diff");
+	}
+}
+/** The plugin manager, or a printable error naming its absence. */
+function requirePluginManager(ctx) {
+	const manager = ctx.get("pluginManager");
+	if (manager === void 0) throw new Error("plugin management is not mounted in this profile");
+	return manager;
+}
+/**
+* One row per bundle the profile can manage: name, version, enablement, how
+* the profile holds it, whether it can be removed, and its management error.
+* @param ctx - plugin context carrying the optional plugin manager.
+* @returns the rows in the manager's order.
+* @throws {Error} when no plugin manager is mounted.
+*/
+async function listBundles(ctx) {
+	return (await requirePluginManager(ctx).listBundles()).map(bundleRow);
+}
+/** One bundle's facts, two spaces apart. */
+function bundleRow(bundle) {
+	const held = bundle.installed ? "installed" : bundle.optional ? "optional" : "shipped";
+	const facts = [
+		bundle.name,
+		bundle.version ?? "-",
+		bundle.enabled ? "enabled" : "disabled",
+		held
+	];
+	if (bundle.removable) facts.push("removable");
+	if (bundle.readOnlyReason !== void 0) facts.push(`read-only (${bundle.readOnlyReason})`);
+	if (bundle.error !== void 0) facts.push(`error ${bundle.error.code}`);
+	return facts.join("  ");
+}
+/**
+* Switch one plugin entry or one bundle on or off in the profile's persistent
+* composition. A target naming a plugin entry id changes that entry;
+* otherwise it names a bundle.
+* @param ctx - plugin context carrying the optional plugin manager.
+* @param target - a plugin entry id or a bundle name.
+* @param enabled - the wanted state.
+* @returns a confirmation row: the persisted change and how it applied.
+* @throws {Error} when no plugin manager is mounted, when `target` names neither, or when the change failed.
+*/
+async function setPluginEnabled(ctx, target, enabled) {
+	const manager = requirePluginManager(ctx);
+	const plugin = (await manager.listPlugins()).find((candidate) => candidate.entryId === target);
+	if (plugin !== void 0) return reportChange(await manager.setPluginEnabled(plugin.entryId, enabled));
+	const bundle = (await manager.listBundles()).find((candidate) => candidate.name === target);
+	if (bundle !== void 0) return reportChange(await manager.setBundleEnabled(bundle.name, enabled));
+	throw new Error(`"${target}" is neither a plugin entry nor a bundle of this profile`);
+}
+/**
+* Install one bundle into the profile and enable it.
+* @param ctx - plugin context carrying the optional plugin manager.
+* @param spec - what pnpm should add: a registry name, a path, a git address, or a tarball.
+* @returns a confirmation row: the installation and how it applied.
+* @throws {Error} when no plugin manager is mounted or the installation failed.
+*/
+async function installBundle(ctx, spec) {
+	return reportChange(await requirePluginManager(ctx).installBundle(spec));
+}
+/**
+* Remove one installed bundle from the profile.
+* @param ctx - plugin context carrying the optional plugin manager.
+* @param name - the bundle's package name.
+* @returns a confirmation row: the removal and how it applied.
+* @throws {Error} when no plugin manager is mounted or the removal failed.
+*/
+async function removeBundle(ctx, name) {
+	return reportChange(await requirePluginManager(ctx).removeBundle(name));
+}
+/** One row over a change result; a failed change is thrown so the surface prints the row as an error. */
+function reportChange(result) {
+	const facts = [`${result.stage} ${result.target}: ${result.changed ? result.application : `unchanged, ${result.application}`}`];
+	if (result.bundle !== void 0 && result.bundle !== result.target) facts.push(`bundle ${result.bundle}`);
+	if (result.error !== void 0) facts.push(result.error.diagnostic === void 0 ? result.error.code : `${result.error.code}: ${result.error.diagnostic}`);
+	if (result.pendingBuilds !== void 0 && result.pendingBuilds.length > 0) facts.push(`scripts awaiting approval: ${result.pendingBuilds.join(", ")}`);
+	if (result.warnings !== void 0) facts.push(...result.warnings);
+	const text = facts.join(" · ");
+	if (result.application === "failed") throw new Error(text);
+	return text;
+}
 /** Control Sequence Introducer. */
 const CSI = "\x1B[";
 /**
@@ -827,6 +1014,10 @@ const LUMINANCE = {
 };
 /** Largest value one color channel encodes. */
 const CHANNEL_MAX = 255;
+/** Channel scale SGR faint applies when a float-out reads a dim run. */
+const DIM_CHANNEL = .5;
+/** How far a float-out lifts a color that is already brighter than `fg` toward white. */
+const LIFT_TOWARD_WHITE = .5;
 /** Encoded sRGB value below which the transfer function is the linear segment. */
 const SRGB_LINEAR_CUT = .04045;
 /** Linear intensity below which the sRGB transfer function is the linear segment. */
@@ -906,6 +1097,34 @@ function mix(from, to, ratio) {
 	return toSrgb(linear + (toLinear(to) - linear) * ratio);
 }
 /**
+* Mix `from` toward `to` with the same smoothstep-in-linear-light interpolation
+* {@link buildFadeRamp} uses. Positions at or below 0 and at or above 1 return
+* that endpoint's bytes, so a float-out's last computed mix can match the
+* settled color it recedes toward.
+* @param from - the color at t = 0.
+* @param to - the color at t = 1.
+* @param t - position along the mix; values outside 0..1 clamp to an endpoint.
+* @returns the mixed sRGB color.
+*/
+function mixFadeColor(from, to, t) {
+	if (t <= 0) return {
+		r: from.r,
+		g: from.g,
+		b: from.b
+	};
+	if (t >= 1) return {
+		r: to.r,
+		g: to.g,
+		b: to.b
+	};
+	const eased = t * t * (3 - 2 * t);
+	return {
+		r: mix(from.r, to.r, eased),
+		g: mix(from.g, to.g, eased),
+		b: mix(from.b, to.b, eased)
+	};
+}
+/**
 * Decode one sRGB channel to linear light, by the sRGB transfer function.
 * @param value - the channel byte.
 * @returns the linear intensity in 0..1.
@@ -934,7 +1153,7 @@ function toSrgb(value) {
 function fadeSgr(style, age) {
 	if (style.capability === "none") return "";
 	if (style.capability === "dim") return age < DIM_AGES ? DIM : "";
-	const level = style.ramp[Math.max(0, Math.min(age, style.ramp.length - 1))];
+	const level = style.ramp[Math.max(0, Math.min(Math.floor(age), style.ramp.length - 1))];
 	if (level === void 0) return "";
 	return style.capability === "truecolor" ? truecolorSgr(level) : grayscaleSgr(level);
 }
@@ -976,31 +1195,340 @@ function restoreFor(capability) {
 /** Every SGR sequence, the sequences a block's own palette styling writes. */
 const SGR_SEQUENCE = /\u001b\[[0-9;]*m/g;
 /**
-* Draw whole rendered lines at one brightness level, for a block that fades in
-* as a unit rather than word by word.
+* Draw whole rendered lines as a float-out: each SGR run starts at a lifted
+* mix toward the assumed foreground and recedes to the run's own settled
+* color. At `age >= ramp.length` the lines come back byte-identical, so the
+* palette sequences win without a snap. The two-level mode overlays faint for
+* the whole flight; the caller stops invoking this once the clock settles.
 *
-* The level is opened at the start of the line and reasserted after every SGR
-* the line already carries, so the palette colors inside a card - the status
-* glyph, the dim body rule, the bold tool name - are overridden while the card
-* fades and come back on their own once it settles. Each line ends with the
-* sequence that undoes what the level set - the terminal's own foreground, or
-* its normal intensity in the two-level mode - so the level never leaks past
-* the line it was applied to. Empty lines come back byte-identical, so
-* the renderer leaves the blank rows around a card alone.
+* The mix is opened after every SGR the line already carries, so the status
+* glyph, the dim body rule, and the bold tool name each recede toward their
+* own color. Each line ends with the sequence that undoes the overlay, so the
+* mix never leaks past the line it was applied to. Empty lines come back
+* byte-identical, so the renderer leaves the blank rows around a card alone.
 * @param lines - the rendered lines of the block.
-* @param age - the brightness level to draw them at.
-* @param style - the capability and the ramp.
-* @param from - first line the level is applied to; the lines before it come
+* @param age - elapsed time in units of `stepMs`; `ramp.length` is t = 1.
+* @param style - the capability and the ramp whose last level is the assumed foreground.
+* @param from - first line the mix is applied to; the lines before it come
 * back byte-identical, which is how a caller keeps rows the renderer can no
 * longer repaint out of the fade.
-* @returns the lines at that level; copies when the style writes no sequence
-* for this age, which is what the `none` capability and a settled age yield.
+* @returns the lines at that mix; copies when the style writes no sequence,
+* which is what the `none` capability and a settled age yield.
 */
 function recolorLines(lines, age, style, from = 0) {
-	const sgr = fadeSgr(style, age);
-	if (sgr === "") return [...lines];
-	const restore = restoreFor(style.capability);
-	return lines.map((line, index) => index < from || line === "" ? line : `${sgr}${line.replace(SGR_SEQUENCE, (match) => match + sgr)}${restore}`);
+	const capability = style.capability;
+	if (capability === "none") return [...lines];
+	if (capability === "dim") return lines.map((line, index) => index < from || line === "" ? line : `${DIM}${line}${RESET_INTENSITY}`);
+	const steps = style.ramp.length;
+	const fg = style.ramp[steps - 1];
+	if (fg === void 0 || age >= steps) return [...lines];
+	const t = age / steps;
+	return lines.map((line, index) => index < from || line === "" ? line : floatOutLine(line, t, capability, fg));
+}
+/** Assumed terminal white, used only to lift a settled color that is already brighter than `fg`. */
+const WHITE_RGB = {
+	r: CHANNEL_MAX,
+	g: CHANNEL_MAX,
+	b: CHANNEL_MAX
+};
+/** xterm 16-color palette, indices 0..15. */
+const ANSI16 = [
+	{
+		r: 0,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 205,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 205,
+		b: 0
+	},
+	{
+		r: 205,
+		g: 205,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 0,
+		b: 238
+	},
+	{
+		r: 205,
+		g: 0,
+		b: 205
+	},
+	{
+		r: 0,
+		g: 205,
+		b: 205
+	},
+	{
+		r: 229,
+		g: 229,
+		b: 229
+	},
+	{
+		r: 127,
+		g: 127,
+		b: 127
+	},
+	{
+		r: 255,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 255,
+		b: 0
+	},
+	{
+		r: 255,
+		g: 255,
+		b: 0
+	},
+	{
+		r: 92,
+		g: 92,
+		b: 255
+	},
+	{
+		r: 255,
+		g: 0,
+		b: 255
+	},
+	{
+		r: 0,
+		g: 255,
+		b: 255
+	},
+	{
+		r: 255,
+		g: 255,
+		b: 255
+	}
+];
+/**
+* Relative luminance of one sRGB color, using the same weights as the grayscale encoder.
+* @param color - the color.
+* @returns the weighted sum of the channels.
+*/
+function colorLuminance(color) {
+	return LUMINANCE.r * color.r + LUMINANCE.g * color.g + LUMINANCE.b * color.b;
+}
+/**
+* The color a float-out starts from: the assumed foreground when that is
+* brighter than the settle, otherwise a mix toward white.
+* @param settled - the run's color at t = 1.
+* @param fg - the assumed terminal foreground.
+* @returns the lifted color at t = 0.
+*/
+function liftColor(settled, fg) {
+	return colorLuminance(fg) >= colorLuminance(settled) ? fg : mixFadeColor(settled, WHITE_RGB, LIFT_TOWARD_WHITE);
+}
+/**
+* Apply SGR faint as a channel scale, matching what a dim palette run looks like.
+* @param color - the undimmed RGB.
+* @returns the dimmed RGB.
+*/
+function dimColor(color) {
+	return {
+		r: Math.round(color.r * DIM_CHANNEL),
+		g: Math.round(color.g * DIM_CHANNEL),
+		b: Math.round(color.b * DIM_CHANNEL)
+	};
+}
+/**
+* The RGB a run settles at, given the SGR in force and the assumed default foreground.
+* @param state - the SGR foreground and dim flag.
+* @param fg - the assumed default foreground.
+* @returns the settled color the mix recedes toward.
+*/
+function settledRgb(state, fg) {
+	const base = state.color ?? fg;
+	return state.dim ? dimColor(base) : base;
+}
+/**
+* Encode one mixed color under a color capability.
+* @param capability - `truecolor` or `ansi256`.
+* @param color - the mixed RGB.
+* @returns the SGR sequence, or empty when the capability cannot encode a mix.
+*/
+function encodeMix(capability, color) {
+	return capability === "truecolor" ? truecolorSgr(color) : `${CSI}38;5;${String(nearestAnsi256(color))}m`;
+}
+/**
+* Rebuild one card row as a per-run float-out mix.
+* @param line - the rendered line.
+* @param t - 0 at lift, 1 at settle.
+* @param capability - how the mix is encoded.
+* @param fg - the assumed default foreground.
+* @returns the line with each run overlaid, closed by {@link RESET_FOREGROUND}.
+*/
+function floatOutLine(line, t, capability, fg) {
+	let out = "";
+	let last = 0;
+	const state = {
+		color: void 0,
+		dim: false
+	};
+	for (const match of line.matchAll(SGR_SEQUENCE)) {
+		const start = match.index;
+		if (start > last) out += paintSegment(line.slice(last, start), state, t, capability, fg);
+		applySgr(state, match[0]);
+		out += match[0];
+		last = start + match[0].length;
+	}
+	if (last < line.length) out += paintSegment(line.slice(last), state, t, capability, fg);
+	return `${out}${RESET_FOREGROUND}`;
+}
+/**
+* Overlay one text run with the float-out mix for the SGR in force.
+* @param text - the run's characters, with no SGR.
+* @param state - the SGR in force.
+* @param t - 0 at lift, 1 at settle.
+* @param capability - how the mix is encoded.
+* @param fg - the assumed default foreground.
+* @returns the run prefixed by intensity-reset and the mixed color.
+*/
+function paintSegment(text, state, t, capability, fg) {
+	const settled = settledRgb(state, fg);
+	return `${RESET_INTENSITY}${encodeMix(capability, mixFadeColor(liftColor(settled, fg), settled, t))}${text}`;
+}
+/**
+* The float-out sequence one reasoning span draws under, toward dimmed `fg`.
+* @param style - the capability and the ramp.
+* @param age - elapsed time in units of `stepMs`.
+* @returns the sequence, or empty once `age` reaches the ramp length.
+*/
+function floatOutSpanSgr(style, age) {
+	if (style.capability === "dim") return DIM;
+	if (style.capability !== "truecolor" && style.capability !== "ansi256") return "";
+	const steps = style.ramp.length;
+	const fg = style.ramp[steps - 1];
+	if (fg === void 0 || age >= steps) return "";
+	const settled = dimColor(fg);
+	const mixed = mixFadeColor(liftColor(settled, fg), settled, age / steps);
+	return `${RESET_INTENSITY}${encodeMix(style.capability, mixed)}`;
+}
+/**
+* Apply one SGR sequence to the float-out foreground state.
+* @param state - the state to update.
+* @param sequence - a CSI SGR including the trailing `m`.
+*/
+function applySgr(state, sequence) {
+	const body = sequence.slice(2, -1);
+	const parts = body === "" ? [0] : body.split(";").map((part) => part === "" ? 0 : Number(part));
+	for (let index = 0; index < parts.length; index += 1) {
+		const code = colorParam(parts, index);
+		if (code === 0) {
+			state.color = void 0;
+			state.dim = false;
+		} else if (code === 2) state.dim = true;
+		else if (code === 22) state.dim = false;
+		else if (code === 39) state.color = void 0;
+		else if (code >= 30 && code <= 37) state.color = ANSI16[code - 30];
+		else if (code >= 90 && code <= 97) state.color = ANSI16[code - 90 + 8];
+		else if (code === 38) {
+			const read = readExtendedColor(parts, index);
+			state.color = read.color;
+			index += read.skip;
+		} else if (code === 48) index += readExtendedColor(parts, index).skip;
+	}
+}
+/**
+* Consume an ITU T.416 extended color (`38`/`48` plus `2;R;G;B` or `5;N`).
+* @param parts - the SGR parameter list.
+* @param index - index of the `38` or `48` code.
+* @returns the RGB for a foreground read, and how many following parameters were consumed.
+*/
+function readExtendedColor(parts, index) {
+	const mode = parts[index + 1];
+	if (mode === 2) return {
+		color: {
+			r: channel(colorParam(parts, index + 2)),
+			g: channel(colorParam(parts, index + 3)),
+			b: channel(colorParam(parts, index + 4))
+		},
+		skip: 4
+	};
+	if (mode === 5) return {
+		color: ansi256Rgb(colorParam(parts, index + 2)),
+		skip: 2
+	};
+	return {
+		color: void 0,
+		skip: mode === void 0 ? 0 : 1
+	};
+}
+/**
+* Read one SGR numeric parameter, defaulting a missing slot to 0.
+* @param parts - the SGR parameter list.
+* @param index - the slot to read.
+* @returns the parameter, or 0 when it is absent.
+*/
+function colorParam(parts, index) {
+	return parts[index] ?? 0;
+}
+/**
+* RGB for one xterm 256-color index.
+* @param index - 0..255.
+* @returns the palette color, clamped onto the table.
+*/
+function ansi256Rgb(index) {
+	const n = Math.max(0, Math.min(255, Math.floor(index)));
+	if (n < 16) {
+		const color = ANSI16[n];
+		/* v8 ignore next -- ANSI16 has 16 entries and n is already clamped to 0..15 */
+		if (color === void 0) return {
+			r: 0,
+			g: 0,
+			b: 0
+		};
+		return color;
+	}
+	if (n >= GRAY_FIRST_INDEX) {
+		const value = GRAY_FIRST_VALUE + (n - GRAY_FIRST_INDEX) * GRAY_VALUE_STEP;
+		return {
+			r: value,
+			g: value,
+			b: value
+		};
+	}
+	const cube = n - 16;
+	const r = Math.floor(cube / 36);
+	const g = Math.floor(cube % 36 / 6);
+	const b = cube % 6;
+	const level = (step) => step === 0 ? 0 : 55 + step * 40;
+	return {
+		r: level(r),
+		g: level(g),
+		b: level(b)
+	};
+}
+/**
+* Nearest xterm 256-color index to one RGB, by squared channel distance.
+* @param color - the mixed RGB.
+* @returns an index in 0..255.
+*/
+function nearestAnsi256(color) {
+	let best = 0;
+	let bestDist = Infinity;
+	for (let n = 0; n < 256; n += 1) {
+		const candidate = ansi256Rgb(n);
+		const dist = (candidate.r - color.r) ** 2 + (candidate.g - color.g) ** 2 + (candidate.b - color.b) ** 2;
+		if (dist < bestDist) {
+			bestDist = dist;
+			best = n;
+		}
+	}
+	return best;
 }
 /**
 * The tail of one streaming region - the visible text or the reasoning of one
@@ -1015,8 +1543,8 @@ function recolorLines(lines, age, style, from = 0) {
 * Ages are read, never counted. A chunk's age is the elapsed time since it
 * became visible divided by `stepMs`, computed at the moment a render asks for
 * it, so a render triggered by a delta between two fade periods draws every
-* word at its own level and words do not move in lockstep. That is what makes
-* the trailing edge continuous rather than banded.
+* word at its own mix and words do not move in lockstep. Fade-in floors that
+* age onto a ramp slot; float-out uses the fractional value.
 *
 * Arrival rate changes the tail's length, never its depth: whatever the rate,
 * a chunk is at the foreground `steps * stepMs` after it appeared, so a fast
@@ -1065,7 +1593,7 @@ var FadeTracker = class {
 	* Drop the chunks that reached the step count, which the application runs
 	* once per fade period so a settled chunk stops being matched against the
 	* rendered lines.
-	* @returns whether a chunk still draws below the last brightness level, and
+	* @returns whether a chunk is still younger than `steps * stepMs`, and
 	* so whether the tail keeps moving after this period.
 	*/
 	tick() {
@@ -1076,11 +1604,10 @@ var FadeTracker = class {
 	}
 	/**
 	* Whether the current frame still differs from the settled rendering.
-	* @returns true while a tracked chunk draws below the last ramp level, which
-	* is the only reason to keep ticking.
+	* @returns true while a tracked chunk is younger than `steps * stepMs`.
 	*/
 	needsRepaint() {
-		return this.chunks.some((chunk) => this.ageOf(chunk) < this.steps - 1);
+		return this.chunks.some((chunk) => this.ageOf(chunk) < this.steps);
 	}
 	/**
 	* The tail {@link recolorTail} recolors.
@@ -1103,21 +1630,22 @@ var FadeTracker = class {
 		this.openChunk = void 0;
 	}
 	/**
-	* The brightness level one chunk draws at right now.
+	* The brightness age one chunk draws at right now.
 	* @param chunk - the tracked chunk.
-	* @returns levels elapsed since it became visible, 0 for a chunk younger than one level.
+	* @returns elapsed time since it became visible, in units of `stepMs`.
 	*/
 	ageOf(chunk) {
-		return Math.floor((this.now() - chunk.bornAt) / this.stepMs);
+		return (this.now() - chunk.bornAt) / this.stepMs;
 	}
 };
 /**
-* The age of one whole block that fades in as a unit - a tool card's rows,
+* The age of one whole block that floats out as a unit - a tool card's rows,
 * which arrive complete rather than word by word.
 *
-* The last level is withheld the way the word tail withholds it: that level is
-* an assumed foreground, so a block one level below the end is handed back to
-* the terminal's own colors instead, and nothing jumps color as it settles.
+* Progress is `elapsed / (steps * stepMs)`, eased by the same smoothstep the
+* ramp uses. {@link BlockFadeClock.age} stays defined until that progress
+* reaches 1, so the last overlay frame can sit near the settled colors and
+* the next frame is the component's own bytes.
 */
 var BlockFadeClock = class {
 	options;
@@ -1125,18 +1653,25 @@ var BlockFadeClock = class {
 		this.options = options;
 	}
 	/**
-	* The brightness level the block draws at right now.
-	* @returns the level, or undefined once the block reached the last drawn
-	* level and renders in the colors the component itself produced.
+	* How far through the float-out this block is.
+	* @returns 0 at birth, 1 at or after `steps * stepMs`.
 	*/
-	age() {
+	progress() {
 		const { bornAt, stepMs, steps, now } = this.options;
-		const age = Math.floor((now() - bornAt) / stepMs);
-		return age < steps - 1 ? age : void 0;
+		return Math.min(1, Math.max(0, (now() - bornAt) / (steps * stepMs)));
 	}
 	/**
-	* Whether this block still draws below the last brightness level.
-	* @returns true while {@link BlockFadeClock.age} yields a level.
+	* The fractional age the block draws at right now, in units of `stepMs`.
+	* @returns `progress * steps`, or undefined once progress has reached 1 and
+	* the block renders in the colors the component itself produced.
+	*/
+	age() {
+		const t = this.progress();
+		return t >= 1 ? void 0 : t * this.options.steps;
+	}
+	/**
+	* Whether this block still draws below the settled colors.
+	* @returns true while {@link BlockFadeClock.age} yields a value.
 	*/
 	needsRepaint() {
 		return this.age() !== void 0;
@@ -1189,27 +1724,32 @@ var FadeRegistry = class {
 *
 * Styling inside a recolored run survives. The run reasserts the sequences in
 * force at its start, so an enclosing bold or italic continues across it; an
-* enclosing foreground color reasserted there wins over the ramp, and that run
-* simply does not fade. Each recolored line ends with `ESC[39m` (or `ESC[22m`
-* in the two-level mode, which also ends bold) after the line's own closing
-* sequences, so the recolor never leaks past the line it was applied to.
+* enclosing foreground color reasserted there wins over the fade-in ramp, and
+* that run simply does not fade. Each recolored line ends with `ESC[39m` (or
+* `ESC[22m` in the two-level mode, which also ends bold) after the line's own
+* closing sequences, so the recolor never leaks past the line it was applied
+* to. Float-out resets intensity before the mixed color so a dim wrapper does
+* not stack on the overlay, and at t >= 1 the original lines come back
+* unchanged.
 * @param lines - the rendered lines of the streaming block, newest text last.
 * @param spans - the tail from {@link FadeTracker.spans}, oldest first.
 * @param style - the capability and the ramp.
 * @param from - first line the tail may recolor; the lines before it come back
 * byte-identical, which is how a caller keeps rows the renderer can no longer
 * repaint out of the fade.
+* @param mode - `in` climbs {@link buildFadeRamp}; `out` recedes toward the
+* dim foreground reasoning settles in. Defaults to `in`.
 * @returns the lines with the tail recolored; lines the tail does not cover
 * are returned byte-identical, so the renderer leaves them alone.
 */
-function recolorTail(lines, spans, style, from = 0) {
-	if (style.capability === "none" || spans.length === 0 || lines.length === 0) return [...lines];
+function recolorTail(lines, spans, style, from = 0, mode = "in") {
+	if (spans.length === 0 || lines.length === 0) return [...lines];
 	const cells = cellsFromEnd(lines);
 	const runs = [];
 	for (const span of [...spans].reverse()) {
 		const covered = consumeSpan(cells, span.text);
 		if (covered === void 0) break;
-		const sgr = fadeSgr(style, span.age);
+		const sgr = mode === "out" ? floatOutSpanSgr(style, span.age) : fadeSgr(style, span.age);
 		if (sgr !== "") collectRuns(runs, covered, sgr);
 	}
 	const byLine = /* @__PURE__ */ new Map();
@@ -1513,8 +2053,9 @@ var NoticeBlock = class {
 * durable `assistant/message` replaces both with the committed content.
 *
 * A block that is streaming right now can carry a {@link FadeRender} for its
-* text and another for its reasoning, each drawing that region's newest words
-* dimmed and brightening. A block rebuilt from history carries neither, and
+* text and another for its reasoning. Visible text draws newest words dimmed
+* and brightening; reasoning floats out from a lifted color toward the dim
+* italic it settles in. A block rebuilt from history carries neither, and
 * {@link AssistantBlock.commit} drops the ones a streaming block had, so
 * settled text is never recolored.
 */
@@ -1596,7 +2137,7 @@ var AssistantBlock = class {
 	setRepaintFloor(floor) {
 		if (floor <= this.repaintFloor) return false;
 		this.repaintFloor = floor;
-		return drawnSpans(this.fade).length > 0 || drawnSpans(this.reasoningFade).length > 0;
+		return this.fade !== void 0 && fadingInSpans(this.fade).length > 0 || this.reasoningFade !== void 0 && floatingOutSpans(this.reasoningFade).length > 0;
 	}
 	/**
 	* Append streamed visible text.
@@ -1662,13 +2203,11 @@ var AssistantBlock = class {
 		return withGutter(this.theme.palette, lines, (index) => index >= section.from && index < section.to);
 	}
 	/**
-	* The reasoning lines, with the streaming tail recolored.
+	* The reasoning lines, with the streaming tail floated out toward dim italic.
 	*
-	* The ramp climbs towards the assumed terminal foreground, but the reasoning
-	* draws inside the faint and italic sequences `appendReasoning` wrapped it
-	* in, and a recolored run reasserts the styling in force at its start. The
-	* tail therefore arrives at the dim foreground the settled reasoning carries,
-	* not at the plain one.
+	* The mix starts at a lifted color and recedes to the faint foreground the
+	* settled reasoning already carries. At full age the original dim italic
+	* bytes come back unchanged.
 	* @param width - the width the reasoning lays out in.
 	* @param at - index of the region's first line in this block's render.
 	* @returns the lines to draw.
@@ -1679,7 +2218,7 @@ var AssistantBlock = class {
 		if (fade === void 0) return lines;
 		if (this.reasoningFadeWidth !== void 0 && this.reasoningFadeWidth !== width) fade.flush();
 		this.reasoningFadeWidth = width;
-		return recolorTail(lines, drawnSpans(fade), fade.style(), this.repaintFloor - at);
+		return recolorTail(lines, floatingOutSpans(fade), fade.style(), this.repaintFloor - at, "out");
 	}
 	/**
 	* The Markdown lines, with the streaming tail recolored.
@@ -1698,14 +2237,14 @@ var AssistantBlock = class {
 		if (fade === void 0) return lines;
 		if (this.fadeWidth !== void 0 && this.fadeWidth !== width) fade.flush();
 		this.fadeWidth = width;
-		return recolorTail(lines, drawnSpans(fade), fade.style(), this.repaintFloor - at);
+		return recolorTail(lines, fadingInSpans(fade), fade.style(), this.repaintFloor - at);
 	}
 };
 /**
 * A tool call card: status glyph, tool name, headline, then a foldable body.
 *
-* The card arrives in two pieces, and each fades in on its own: the header and
-* the call rows when the call is logged, the result rows when the tool
+* The card arrives in two pieces, and each floats out on its own: the header
+* and the call rows when the call is logged, the result rows when the tool
 * answers. A card rebuilt from history carries neither fade.
 */
 var ToolBlock = class {
@@ -1774,7 +2313,7 @@ var ToolBlock = class {
 	}
 	/**
 	* Hand the rows the renderer can no longer repaint back to the colors this
-	* card drew them in, so a fade that is still climbing never rewrites them.
+	* card drew them in, so a fade that is still moving never rewrites them.
 	* @param floor - this card's own first repaintable line; the application
 	* raises it as the frame grows and never lowers it.
 	* @returns whether the floor took rows away from a fade that is drawing
@@ -1835,11 +2374,11 @@ var ToolBlock = class {
 	}
 };
 /**
-* Draw one group of a card's rows at the level its fade reports.
+* Draw one group of a card's rows at the mix its fade reports.
 * @param lines - the group's final rendered lines.
 * @param fade - the group's fade; absent for a card that never faded.
 * @param from - first line of the group the fade may recolor.
-* @returns the lines at that level, or the lines themselves once the fade
+* @returns the lines at that mix, or the lines themselves once the fade
 * settled or was never attached.
 */
 function faded(lines, fade, from) {
@@ -1848,18 +2387,30 @@ function faded(lines, fade, from) {
 	return age === void 0 ? lines : recolorLines(lines, age, fade.style(), from);
 }
 /**
-* The tail chunks one streaming region still draws below the terminal's own
+* The tail chunks one streaming reply still draws below the terminal's own
 * foreground.
 *
 * The last ramp level is an assumed foreground - pi-tui reports the terminal
 * background but not its foreground - so a chunk that reached it is left to
 * draw in the terminal's own foreground, which is also what it draws in once it
 * leaves the tail. No chunk can therefore jump color as it settles.
-* @param fade - the region's fade; absent for a region that never faded.
+* @param fade - the region's fade.
 * @returns the spans to recolor, oldest first.
 */
-function drawnSpans(fade) {
-	return fade === void 0 ? [] : fade.spans().filter((span) => span.age < fade.steps - 1);
+function fadingInSpans(fade) {
+	return fade.spans().filter((span) => span.age < fade.steps - 1);
+}
+/**
+* The tail chunks one streaming reasoning region still floats out.
+*
+* Overlay continues until `age >= steps`, which is `steps * stepMs` after the
+* word appeared. The last overlay sits near the dim settle; the next frame is
+* the original dim italic bytes.
+* @param fade - the region's fade.
+* @returns the spans to recolor, oldest first.
+*/
+function floatingOutSpans(fade) {
+	return fade.spans().filter((span) => span.age < fade.steps);
 }
 //#endregion
 //#region lib/types/completion.js
@@ -2116,22 +2667,40 @@ const STRIP_ENDS = ["‹ ", " ›"];
 const OFF_SCREEN = " · off screen";
 /** The keys the inspector answers, drawn dim under its rows. */
 const HINT = "↑ ↓ blocks · ← → parts · Enter page · Esc back";
+/** What ends a line the width cut short; one column, so the mark itself fits. */
+const ELLIPSIS$1 = "…";
 /**
 * Draw the focused section.
 * @param view - the section to show.
 * @param render - the palette, the row budget, and the width.
-* @returns the inspector's lines: a blank separator, the heading, the parts
-* strip when the block has more than one part, the folded rows, and the hints.
+* @returns the inspector's lines, none wider than `width`: a blank separator,
+* the heading, the parts strip when the block has more than one part, the
+* folded rows, and the hints.
 */
 function renderInspector(view, render) {
-	const { palette, width } = render;
-	const suffix = view.highlighted ? "" : palette.dim(OFF_SCREEN);
-	const lines = ["", `${palette.bold(palette.accent(view.heading))}${suffix}`];
+	const { palette } = render;
+	const width = Math.max(1, render.width);
+	const lines = ["", heading(view, palette, width)];
 	if (view.parts.length > 1) lines.push(partsStrip(view.parts, palette));
-	const wrapped = view.rows.flatMap((row) => wrapTextWithAnsi(row, Math.max(1, width)));
+	const wrapped = view.rows.flatMap((row) => wrapTextWithAnsi(row, width));
 	lines.push(...foldRows(wrapped, render.previewLines, (hidden) => palette.dim(`… ${String(hidden)} more row${hidden === 1 ? "" : "s"} · Enter opens the page`)));
 	lines.push(palette.dim(HINT));
-	return lines;
+	return lines.map((line) => truncateToWidth(line, width, ELLIPSIS$1));
+}
+/**
+* The heading line. A tool title can run past any terminal, so the subject is
+* cut first and the off-screen mark stays whole: where the marked block went
+* must never be what the width hides.
+* @param view - the section to show.
+* @param palette - the palette the heading is styled with.
+* @param width - the width the line must fit; at least 1.
+* @returns the heading, with the mark when the block is not on screen.
+*/
+function heading(view, palette, width) {
+	const subject = palette.bold(palette.accent(view.heading));
+	if (view.highlighted) return subject;
+	const suffix = palette.dim(OFF_SCREEN);
+	return `${truncateToWidth(subject, Math.max(1, width - visibleWidth(suffix)), ELLIPSIS$1)}${suffix}`;
 }
 /**
 * Draw the parts of the focused block as one row of choices.
@@ -2738,10 +3307,11 @@ function plural(count, noun) {
 * The status bar under the editor: plain session facts become an ordered list
 * of segments, each with a stable id, the short label the bar draws, and what
 * `Enter` on it does — the rows the app prints, or the app's own navigable
-* page; a second function renders the segments as the footer's two lines, dim
-* while the editor holds focus and with the selected segment accented while
-* the bar does. Everything here is pure — no Context, no services, no
-* terminal, and no clock: elapsed values arrive already formatted.
+* page; a second function renders those segments as one unfocused line of key
+* facts, or as two focused lines whose first is a sliding window that always
+* includes the selected segment. Everything here is pure — no Context, no
+* services, no terminal, and no clock: elapsed values arrive already formatted,
+* and the terminal width arrives as an input so every line fits it.
 * @module @deepseek-ai/dsh-tui-app/footer
 */
 /** The segment focus enters the bar on; `buildFooterSegments` always emits it first. */
@@ -2757,10 +3327,20 @@ const SEPARATOR$1 = " · ";
 const WORKSPACE_LABEL_WIDTH = 24;
 /** The last two segments of a path, with the separators that precede them. */
 const PATH_TAIL = /[/\\][^/\\]+[/\\][^/\\]+$/u;
-/** The keys the focused bar answers, replacing the usual hints. */
+/** The keys the focused bar answers, drawn on the expansion line. */
 const FOCUS_HINTS$1 = `← → select${SEPARATOR$1}↑ ↓ regions${SEPARATOR$1}Enter details${SEPARATOR$1}Esc back`;
-/** What the unfocused hints advertise as the two ways out of the editor. */
-const ENTRY_HINT = `Shift+↑ transcript${SEPARATOR$1}Shift+↓ status bar`;
+/** The one entry key the unfocused line keeps, trailing the facts. */
+const ENTRY_HINT = "Shift+↓";
+/** What ends a line the width cut short; one column, so the mark itself fits. */
+const ELLIPSIS = "…";
+/** Facts the unfocused line keeps; every other present segment folds into `+N`. */
+const KEY_SEGMENT_IDS = new Set([
+	"model",
+	"effort",
+	"turn",
+	"context",
+	"workspace"
+]);
 /** The command that prints every projection section at once. */
 const STATUS_COMMAND_ROW = "/status prints all of these sections";
 /**
@@ -2811,10 +3391,24 @@ function startsWithDirectory(path, directory) {
 	return next === "" || next === "/" || next === "\\";
 }
 /**
+* The effort segment: always present, labelled `effort default` when the
+* selection leaves reasoning effort to the model.
+* @param effort - the selection's reasoning effort; absent is the model's own default.
+* @returns the segment.
+*/
+function effortSegment(effort) {
+	const unset = effort === void 0;
+	return {
+		id: "effort",
+		label: unset ? "effort default" : `effort ${effort}`,
+		detail: printed([unset ? "reasoning effort: the model's own default" : `reasoning effort: ${effort}`, `Shift+Tab cycles it${SEPARATOR$1}/effort picks one`])
+	};
+}
+/**
 * Build the status bar's segments in the order it draws them: model, effort,
-* permission, turn, usage, the projection facts, workspace, attachments. Only
-* the model and workspace segments are always present; every other segment
-* needs its fact.
+* permission, turn, usage, the projection facts, workspace, attachments. The
+* model, effort, and workspace segments are always present; every other
+* segment needs its fact.
 * @param inputs - the facts the app read for the bound session.
 * @returns the segments, the model segment first.
 */
@@ -2830,12 +3424,7 @@ function buildFooterSegments(inputs) {
 			effort === void 0 ? "reasoning effort: the model's own default" : `reasoning effort: ${effort}`,
 			"/model picks the provider and model for the next request"
 		])
-	}];
-	if (effort !== void 0) segments.push({
-		id: "effort",
-		label: `effort ${effort}`,
-		detail: printed([`reasoning effort: ${effort}`, `Shift+Tab cycles it${SEPARATOR$1}/effort picks one`])
-	});
+	}, effortSegment(effort)];
 	if (inputs.permission !== void 0) {
 		const projected = permissionLines(facts);
 		segments.push({
@@ -2894,20 +3483,142 @@ function footerSelectionIndex(segments, selected) {
 	return index === -1 ? 0 : index;
 }
 /**
-* Render the footer's two lines: the segment labels, then the key hints.
-* Unfocused the whole bar is dim and the hints advertise the entry key;
-* focused the selected segment is accented and the hints name the navigation
-* keys instead.
+* Inclusive span of `widths` that contains `selected` and fits `budget`.
+* @param widths - visible width of each part, in order.
+* @param selected - the index that must stay in the span.
+* @param budget - maximum visible width of the joined span.
+* @param sep - visible width of the separator between two parts.
+* @returns start and end indices, inclusive.
+*/
+function windowSpan(widths, selected, budget, sep) {
+	let start = selected;
+	let end = selected;
+	let used = widths[selected];
+	if (used >= budget) return {
+		start,
+		end
+	};
+	while (end + 1 < widths.length) {
+		const next = used + sep + widths[end + 1];
+		if (next > budget) break;
+		end += 1;
+		used = next;
+	}
+	while (start > 0) {
+		const next = used + sep + widths[start - 1];
+		if (next > budget) break;
+		start -= 1;
+		used = next;
+	}
+	return {
+		start,
+		end
+	};
+}
+/**
+* Cut `line` to `width` columns.
+* @param line - the already-styled line.
+* @param width - terminal columns the line must fit; at least 1.
+* @returns the line, ellipsized when it was wider.
+*/
+function fitLine(line, width) {
+	return truncateToWidth(line, Math.max(1, width), ELLIPSIS);
+}
+/**
+* The unfocused line: key facts, a `+N` token for the rest, and the entry key.
 * @param segments - the segments in bar order.
-* @param render - the palette, the selected index, and the unfocused hints.
-* @returns the footer text, two lines separated by a newline.
+* @param palette - the palette the line is dimmed with.
+* @param width - terminal columns the line must fit.
+* @returns one dim line.
+*/
+function unfocusedLine(segments, palette, width) {
+	const key = segments.filter((segment) => KEY_SEGMENT_IDS.has(segment.id)).map((segment) => segment.label);
+	const folded = segments.length - key.length;
+	if (folded > 0) key.push(`+${String(folded)}`);
+	key.push(ENTRY_HINT);
+	return fitLine(palette.dim(key.join(SEPARATOR$1)), width);
+}
+/**
+* The first detail row of a printed segment, or the label of a page segment.
+* @param segment - the selected segment; absent when the bar has none.
+* @returns the expansion body.
+*/
+function expansionBody(segment) {
+	if (segment === void 0) return "";
+	if (segment.detail.kind === "page") return segment.label;
+	return segment.detail.rows[0];
+}
+/**
+* The focused second line: the selected segment's summary plus the navigation keys.
+* @param segment - the selected segment.
+* @param palette - the palette the line is dimmed with.
+* @param width - terminal columns the line must fit.
+* @returns one dim line that keeps the hints when they fit.
+*/
+function expansionLine(segment, palette, width) {
+	const body = expansionBody(segment);
+	const suffix = palette.dim(body === "" ? FOCUS_HINTS$1 : `${SEPARATOR$1}${FOCUS_HINTS$1}`);
+	const prefix = palette.dim(body);
+	const rest = width - visibleWidth(suffix);
+	if (rest < 1) return fitLine(`${prefix}${suffix}`, width);
+	return `${truncateToWidth(prefix, rest, ELLIPSIS)}${suffix}`;
+}
+/**
+* The focused bar: a sliding window of segment labels, then the expansion line.
+* @param segments - the segments in bar order.
+* @param selected - index of the held segment.
+* @param palette - the palette the labels and hints are styled with.
+* @param width - terminal columns each line must fit.
+* @returns two lines, the selected label always in the first.
+*/
+function focusedLines(segments, selected, palette, width) {
+	const held = Math.min(Math.max(0, selected), Math.max(0, segments.length - 1));
+	const styled = segments.map((segment, index) => index === held ? palette.bold(palette.accent(segment.label)) : palette.dim(segment.label));
+	const sep = palette.dim(SEPARATOR$1);
+	const { start, end } = windowSpan(styled.map(visibleWidth), held, width, visibleWidth(sep));
+	return [fitLine(styled.slice(start, end + 1).join(sep), width), expansionLine(segments[held], palette, width)];
+}
+/**
+* Render the footer. Unfocused it is one dim line of key facts with a trailing
+* `Shift+↓`; focused it is the navigable segments (windowed to `width` so the
+* selected one is never dropped) and an expansion of that segment plus the
+* navigation keys. Every returned line fits `width`.
+* @param segments - the segments in bar order.
+* @param render - the palette, optional selected index, and terminal width.
+* @returns the footer lines, one when unfocused and two when focused.
 */
 function renderFooter(segments, render) {
-	const { palette, selected, hints } = render;
-	const labels = segments.map((segment) => segment.label);
-	if (selected === void 0) return `${palette.dim(labels.join(SEPARATOR$1))}\n${palette.dim(`${hints}${SEPARATOR$1}${ENTRY_HINT}`)}`;
-	return `${labels.map((label, index) => index === selected ? palette.bold(palette.accent(label)) : palette.dim(label)).join(palette.dim(SEPARATOR$1))}\n${palette.dim(FOCUS_HINTS$1)}`;
+	const width = Math.max(1, render.width);
+	if (render.selected === void 0) return [unfocusedLine(segments, render.palette, width)];
+	return focusedLines(segments, render.selected, render.palette, width);
 }
+/**
+* The status bar as a mounted component. The view is read once per render
+* rather than pushed in, so the terminal width of that frame windows and
+* truncates the lines.
+*/
+var FooterBar = class {
+	view;
+	/**
+	* @param view - reads the segments and selection the bar draws.
+	*/
+	constructor(view) {
+		this.view = view;
+	}
+	invalidate() {}
+	/**
+	* Draw the status bar at `width`.
+	* @param width - the total width the bar lays out in.
+	* @returns the footer lines, each no wider than `width`.
+	*/
+	render(width) {
+		const { segments, render } = this.view();
+		return renderFooter(segments, {
+			...render,
+			width
+		});
+	}
+};
 //#endregion
 //#region lib/types/prompts.js
 /**
@@ -3630,18 +4341,25 @@ function subagentPanelView(inputs) {
 	};
 }
 /**
-* Render the panel: a heading counting the listed children, one line per
-* drawn row, the overflow count, and the last listing failure. The whole
-* panel is dim while the keyboard is elsewhere; the selected row is accented
-* while the panel holds it.
+* Render the panel. Unfocused it is one dim summary line — the listed count
+* and the first child's key label. Focused it is the heading with navigation
+* keys, one line per drawn row, the overflow count, and the last listing
+* failure. The selected row is accented while the panel holds the keyboard.
 * @param view - the rows one draw produced.
 * @param render - the palette, the selected row, and the listing failure.
-* @returns the panel text, one line per row.
+* @returns the panel text, one line when unfocused and one line per row when focused.
 */
 function renderSubagentPanel(view, render) {
 	const { palette, selected } = render;
 	const total = view.rows.length + view.hidden;
-	const heading = `subagents${SEPARATOR}${String(total)} listed${selected === void 0 ? "" : `${SEPARATOR}${FOCUS_HINTS}`}`;
+	if (selected === void 0) {
+		const first = view.rows[0]?.text.trimStart().split(SEPARATOR)[0];
+		const parts = [`subagents${SEPARATOR}${String(total)} listed`];
+		if (first) parts.push(first);
+		if (render.failure !== void 0) parts.push(`listing failed: ${render.failure}`);
+		return palette.dim(parts.join(SEPARATOR));
+	}
+	const heading = `subagents${SEPARATOR}${String(total)} listed${SEPARATOR}${FOCUS_HINTS}`;
 	const lines = [palette.dim(heading)];
 	for (const [index, row] of view.rows.entries()) lines.push(index === selected ? palette.bold(palette.accent(row.text)) : palette.dim(row.text));
 	if (view.hidden > 0) lines.push(palette.dim(`+${String(view.hidden)} more${SEPARATOR}/subagents lists them all`));
@@ -3658,8 +4376,8 @@ function renderSubagentPanel(view, render) {
 * the editor it keeps two docked regions the keyboard can take over — the
 * subagent panel and the status bar — and one repeating tick advances their
 * elapsed counters and re-reads a stale subagent listing. A second tick, at
-* its own period, brightens the text of the message streaming right now and
-* the tool cards that just landed, each only as far up the frame as the
+* its own period, brightens streamed reply text and floats out reasoning and
+* tool cards that just landed, each only as far up the frame as the
 * renderer repaints without discarding the terminal's scrollback
 * (`./screen.ts`).
 * @module @deepseek-ai/dsh-tui-app/app
@@ -3797,6 +4515,10 @@ const LOCAL_COMMANDS = [
 		name: "deliverables",
 		description: "List the files the agent presented in this session"
 	},
+	{
+		name: "changes",
+		description: "Browse the files the last turn changed (/changes <turn> for an earlier one; Enter shows a file's diff)"
+	},
 	{
 		name: "subagents",
 		description: "Browse the subagent sessions under this session (Enter shows one session's details)"
@@ -3807,7 +4529,7 @@ const LOCAL_COMMANDS = [
 	},
 	{
 		name: "plugins",
-		description: "List the composed plugins and their state"
+		description: "List the composed plugins (/plugins bundles, /plugins enable|disable <id>, /plugins add <spec>, /plugins remove <name>)"
 	},
 	{
 		name: "tools",
@@ -3940,7 +4662,13 @@ var TuiApp = class {
 			this.onSubmit(text);
 		};
 		this.panel = new Text("", 0, 0);
-		this.footer = new Text("", 0, 0);
+		this.footer = new FooterBar(() => ({
+			segments: this.segments,
+			render: {
+				palette: this.deps.palette,
+				...this.focus === "bar" ? { selected: footerSelectionIndex(this.segments, this.barSelection) } : {}
+			}
+		}));
 		this.modals = new ModalQueue({
 			tui: this.tui,
 			slot: this.modalSlot,
@@ -4184,7 +4912,6 @@ var TuiApp = class {
 		this.tui.requestRender();
 	}
 	refreshFooter() {
-		const palette = this.deps.palette;
 		const permission = this.deps.ctx.get("permissionPresets")?.current(this.agent.session);
 		const started = this.turnStartedAt;
 		const inbox = this.agent.inbox;
@@ -4207,12 +4934,6 @@ var TuiApp = class {
 				kind: attachment.block.type
 			}))
 		});
-		const hints = this.agent.status === "running" ? "Enter queues for the next turn · Ctrl+S steers this turn · Esc stops it · Ctrl+O tool output · Ctrl+C twice quits" : "Enter sends · Esc stops the turn · Ctrl+O tool output · Ctrl+C twice quits";
-		this.footer.setText(renderFooter(this.segments, {
-			palette,
-			...this.focus === "bar" ? { selected: footerSelectionIndex(this.segments, this.barSelection) } : {},
-			hints
-		}));
 		this.tui.requestRender();
 	}
 	/**
@@ -4464,6 +5185,67 @@ var TuiApp = class {
 		})), TODO_ROW_LAYOUT);
 	}
 	/**
+	* Walk the files one turn changed: one row per file with its line counts,
+	* and entering a row shows the file's turn-start to turn-end comparison.
+	* @param turn - the turn to browse; the latest announced one when undefined.
+	*/
+	async browseChanges(turn) {
+		const sessionId = this.agent.session.id;
+		const signal = new AbortController().signal;
+		const changes = await listTurnChanges(this.deps.ctx, sessionId, turn, signal);
+		if (changes === void 0) {
+			this.notice(turn === void 0 ? "no changed files recorded yet" : `no changed files recorded for turn ${String(turn)}`);
+			return;
+		}
+		if (changes.choices.length === 0) {
+			this.notice(`${changes.heading}: no file listed`);
+			return;
+		}
+		await this.browse(changes.heading, changes.choices.map((choice) => ({
+			item: {
+				value: String(choice.index),
+				label: choice.label,
+				description: choice.description
+			},
+			heading: choice.label,
+			detail: () => changeDiffRows(this.deps.ctx, sessionId, choice, signal)
+		})));
+	}
+	/**
+	* `/plugins` and its management verbs over the profile's plugin manager:
+	* the composed plugins alone, the bundles, a switch of one entry or bundle,
+	* an installation, or a removal.
+	* @param argument - the verb and its operand; empty lists the composed plugins.
+	*/
+	async plugins(argument) {
+		const [verb = "", ...rest] = argument.split(/\s+/).filter((word) => word !== "");
+		const operand = rest.join(" ");
+		switch (verb) {
+			case "":
+				this.showRows(listPlugins(this.deps.ctx), "no plugins are listed");
+				return;
+			case "bundles":
+				this.showRows(await listBundles(this.deps.ctx), "no bundles are listed");
+				return;
+			case "enable":
+			case "disable":
+				if (operand === "") break;
+				this.notice(await setPluginEnabled(this.deps.ctx, operand, verb === "enable"), "success");
+				return;
+			case "add":
+				if (operand === "") break;
+				this.notice(`installing ${operand}…`);
+				this.notice(await installBundle(this.deps.ctx, operand), "success");
+				return;
+			case "remove":
+				if (operand === "") break;
+				this.notice(await removeBundle(this.deps.ctx, operand), "success");
+				return;
+			default: break;
+		}
+		this.notice("usage: /plugins · /plugins bundles · /plugins enable|disable <entry id or bundle> · /plugins add <spec> · /plugins remove <bundle>", "error");
+	}
+	/**
 	* The browsable entry behind one subagent row: the same detail page the
 	* `/subagents` list and the live panel open.
 	* @param choice - the listing row.
@@ -4616,7 +5398,8 @@ var TuiApp = class {
 	}
 	/**
 	* Answer one key while the status bar holds focus. Every key is consumed
-	* here, so nothing typed at the bar reaches the editor.
+	* here, so nothing typed at the bar reaches the editor. `Shift+Left` and
+	* `Shift+Right` move between segments the same way as `Left` and `Right`.
 	* @param data - the raw key bytes.
 	* @returns the consume marker the input listener returns.
 	*/
@@ -4628,11 +5411,11 @@ var TuiApp = class {
 			else this.focusTranscript();
 			return { consume: true };
 		}
-		if (matchesKey(data, "left") || matchesKey(data, "shift+tab")) {
+		if (matchesKey(data, "left") || matchesKey(data, "shift+left") || matchesKey(data, "shift+tab")) {
 			this.moveStatusBar(-1);
 			return { consume: true };
 		}
-		if (matchesKey(data, "right") || matchesKey(data, "tab")) {
+		if (matchesKey(data, "right") || matchesKey(data, "shift+right") || matchesKey(data, "tab")) {
 			this.moveStatusBar(1);
 			return { consume: true };
 		}
@@ -4990,6 +5773,15 @@ var TuiApp = class {
 			case "deliverables":
 				this.showRows(await listDeliverables(this.deps.ctx, this.agent.session.id, new AbortController().signal), "nothing presented yet");
 				return;
+			case "changes": {
+				const turn = argument === "" ? void 0 : Number(argument);
+				if (turn !== void 0 && !(Number.isSafeInteger(turn) && turn > 0)) {
+					this.notice("usage: /changes · /changes <turn>", "error");
+					return;
+				}
+				await this.browseChanges(turn);
+				return;
+			}
 			case "subagents": {
 				const choices = await listSubagentChoices(this.deps.ctx, this.agent.session.id, new AbortController().signal);
 				if (choices.length === 0) {
@@ -5003,7 +5795,7 @@ var TuiApp = class {
 				await this.settings(argument);
 				return;
 			case "plugins":
-				this.showRows(listPlugins(this.deps.ctx), "no plugins are listed");
+				await this.plugins(argument);
 				return;
 			default: await this.runSharedCommand(line, name);
 		}
@@ -5018,7 +5810,7 @@ var TuiApp = class {
 			"Esc stops the running turn · Ctrl+O expands or collapses tool output",
 			"Shift+Tab cycles the current model's reasoning effort for the next request",
 			"Shift+Up focuses the transcript, Shift+Down the subagent panel or the status bar",
-			"Then ↑ ↓ move between blocks, panel rows, and the bar; ← → move between a block's parts or the bar's segments",
+			"Then ↑ ↓ move between blocks, panel rows, and the bar; ← → move between a block's parts or the bar's segments (Shift+← → also move the bar)",
 			"Enter opens the focused section or segment, Esc returns to the input",
 			"Ctrl+C clears the input (twice quits) · Ctrl+D on an empty input quits"
 		];
@@ -5483,9 +6275,9 @@ var TuiApp = class {
 		this.updateFadeTicker();
 	}
 	/**
-	* Take one reasoning delta, which fades in on its own tail: the reasoning
-	* and the visible text of one message stream at different times and each
-	* brightens from the moment its own words appeared.
+	* Take one reasoning delta, which floats out on its own tail: the reasoning
+	* and the visible text of one message stream at different times, and each
+	* ages from the moment its own words appeared.
 	* @param delta - the streamed reasoning delta.
 	*/
 	appendStreamedReasoning(delta) {
@@ -5760,6 +6552,12 @@ var TuiApp = class {
 			case "compaction/summary":
 				this.notice(compactionNotice(event.data));
 				break;
+			case "workspace/changes": {
+				const summary = this.deps.ctx.get("workspaceChanges")?.summary(session.id, event.seq);
+				if (summary === void 0) return;
+				this.notice(changesNotice(summary));
+				break;
+			}
 			case "llm/retry":
 				this.loader.setMessage(retryMessage(event.data));
 				break;