dsh-code 1.0.4 → 1.0.6

package/lib/index.mjs

@@ -4,12 +4,12 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import { readFileSync, realpathSync } from "node:fs";
 import os, { homedir } from "node:os";
-import { mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
-import { MessageId, ReasoningEffortId, assertNever, boundContextSummary, createUserMessage, normalizeApiKey } from "@deepseek-ai/dsh-llm";
-import { SessionId } from "@deepseek-ai/dsh-session";
+import { MessageId, ReasoningEffortId, assistantStreamFirstTokenTime, boundContextSummary, createUserMessage, isTokenDelta, normalizeApiKey } from "@deepseek-ai/dsh-llm";
+import { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset } from "@deepseek-ai/dsh-session";
 import { PassThrough, Stream } from "node:stream";
 import process$1, { cwd, env } from "node:process";
 import { EventEmitter } from "node:events";
@@ -22,6 +22,7 @@ import { AuthorizationDeclinedError } from "@deepseek-ai/dsh-authorization";
 import { fileURLToPath } from "node:url";
 import { UserQuestionError } from "@deepseek-ai/dsh-user-questions";
 import { isUserInvocable } from "@deepseek-ai/dsh-skill";
+import { assertNever } from "@deepseek-ai/dsh-util-values";
 //#region node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js
 /**
 * @license React
@@ -25082,6 +25083,41 @@ function appendStreamingTail(current, delta) {
 	const next = current + delta;
 	return next.length <= MAX_STREAMING_CHARS ? next : next.slice(-65536);
 }
+/** Assemble the effective system prompt from surface nodes: head text plus every later non-empty node. */
+function assembleSystemPrompt(nodes) {
+	if (nodes.size === 0) return "";
+	return [...nodes.entries()].sort((left, right) => left[0] - right[0]).map(([, text]) => text).filter((text) => text !== "").join("\n\n");
+}
+/**
+* Apply one surface event's replace to the live system nodes. Any surface
+* event may shadow system nodes — the kernel's compaction summary lands as a
+* `user/message` replace whose range can cover later system nodes (only node
+* 0 is compaction-protected upstream) — so every surface fold retires covered
+* nodes, not just `system/message` itself.
+* @param nodes - the live system-node map (mutated when the event replaces).
+* @param surfaceOp - the surface operation the event carries, when it is a
+* surface event (log-only events have none and change nothing).
+* @returns the reassembled prompt when nodes were retired, `changed: false`
+* when the event shadows nothing.
+*/
+function retireShadowedSystemNodes(nodes, surfaceOp) {
+	if (surfaceOp === void 0 || surfaceOp === "append") return {
+		prompt: "",
+		changed: false
+	};
+	let changed = false;
+	for (const seq of nodes.keys()) if (seq >= surfaceOp.startSeq && seq <= surfaceOp.endSeq) {
+		nodes.delete(seq);
+		changed = true;
+	}
+	return changed ? {
+		prompt: assembleSystemPrompt(nodes),
+		changed
+	} : {
+		prompt: "",
+		changed: false
+	};
+}
 /** Join the text blocks of a content list; non-text blocks contribute nothing. */
 function textOf(content) {
 	return content.filter((block) => block.type === "text").map((block) => block.text).join("");
@@ -25090,6 +25126,10 @@ function textOf(content) {
 function imagesOf(content) {
 	return content.filter((block) => block.type === "image").map((block) => block.attachment);
 }
+/** Durable file references in their model-visible order. */
+function filesOf(content) {
+	return content.filter((block) => block.type === "file").map((block) => block.attachment);
+}
 /** Human-readable bounded image labels for transcript, inspector, and export surfaces. */
 function imageLabels(images) {
 	if (images === void 0 || images.length === 0) return "";
@@ -25100,9 +25140,19 @@ function imageLabels(images) {
 		return `[image: ${name} · ${original === void 0 ? `${image.width}×${image.height}` : `${image.width}×${image.height} · original ${original.width}×${original.height}`} · ${image.bytes} B]`;
 	}).join("\n");
 }
-/** Prompt text with its durable image labels, without exposing local paths or bytes. */
+/** Human-readable bounded file labels for the same surfaces (0.1.5 file blocks). */
+function fileLabels(files) {
+	if (files === void 0 || files.length === 0) return "";
+	return files.map((file, index) => {
+		const rawName = file.name?.trim() || `file ${index + 1}`;
+		return `[file: ${rawName.length <= 80 ? rawName : `${rawName.slice(0, 79)}…`} · ${file.bytes} B]`;
+	}).join("\n");
+}
+/** Prompt text with its durable image and file labels, without exposing local paths or bytes. */
 function promptDisplayText(entry) {
-	const labels = imageLabels(entry.images);
+	const imageText = imageLabels(entry.images);
+	const fileText = fileLabels(entry.files);
+	const labels = imageText === "" ? fileText : fileText === "" ? imageText : `${imageText}\n${fileText}`;
 	return entry.text === "" ? labels : labels === "" ? entry.text : `${entry.text}\n${labels}`;
 }
 /** Join the reasoning blocks of a content list; non-reasoning blocks contribute nothing. */
@@ -25149,6 +25199,7 @@ function createReplayAccumulator() {
 		plan: false,
 		permission: "",
 		title: "",
+		systemPrompt: "",
 		sandbox: "",
 		goal: void 0,
 		stats: {
@@ -25184,6 +25235,7 @@ function createReplayAccumulator() {
 		turnFiles: /* @__PURE__ */ new Map(),
 		turnSteps: /* @__PURE__ */ new Map(),
 		turnTools: /* @__PURE__ */ new Map(),
+		systemNodes: /* @__PURE__ */ new Map(),
 		ops: 0
 	};
 }
@@ -25266,6 +25318,17 @@ function retireReplayEntry(acc, index) {
 * like the copy-on-write reducer returning its input view unchanged.
 */
 function replayProjectEvent(acc, event) {
+	const shadow = retireShadowedSystemNodes(acc.systemNodes, event.surfaceOp);
+	if (shadow.changed) {
+		acc.systemPrompt = shadow.prompt;
+		acc.stats = {
+			...acc.stats,
+			contextSegments: {
+				...acc.stats.contextSegments,
+				system: estimateTokens(shadow.prompt)
+			}
+		};
+	}
 	switch (event.type) {
 		case "user/message": {
 			const message = event.data;
@@ -25284,12 +25347,14 @@ function replayProjectEvent(acc, event) {
 			}
 			const text = textOf(message.content);
 			const images = imagesOf(message.content);
+			const files = filesOf(message.content);
 			if (message.source.kind === "user") {
 				appendReplayEntry(acc, {
 					kind: "user",
 					text,
 					notice: false,
-					...images.length === 0 ? {} : { images }
+					...images.length === 0 ? {} : { images },
+					...files.length === 0 ? {} : { files }
 				});
 				acc.stats = {
 					...acc.stats,
@@ -25334,45 +25399,68 @@ function replayProjectEvent(acc, event) {
 			ids.splice(start, 0, ...inserted.map((message) => message.id));
 			for (const message of inserted) {
 				const images = imagesOf(message.content);
+				const files = filesOf(message.content);
 				appendReplayEntry(acc, {
 					kind: "pending",
 					messageId: message.id,
 					target,
 					text: pendingText(message.content),
-					...images.length === 0 ? {} : { images }
+					...images.length === 0 ? {} : { images },
+					...files.length === 0 ? {} : { files }
 				});
 				indexList(acc.pendingIndex, message.id).push(acc.entries.length - 1);
 				acc.ops += 1;
 			}
 			return true;
 		}
-		case "assistant/chunk": {
-			const chunk = event.data.chunk;
+		case "system/message": {
+			const text = textOf(event.data.message.content);
+			retireShadowedSystemNodes(acc.systemNodes, event.surfaceOp);
+			acc.systemNodes.set(event.seq, text);
+			acc.systemPrompt = assembleSystemPrompt(acc.systemNodes);
+			acc.stats = {
+				...acc.stats,
+				contextSegments: {
+					...acc.stats.contextSegments,
+					system: estimateTokens(acc.systemPrompt)
+				}
+			};
+			return true;
+		}
+		case "assistant/attempt": {
 			const key = `${event.data.turn}:${event.data.step}`;
-			if ((chunk.type === "text-delta" || chunk.type === "reasoning-delta" ? chunk.text : "") !== "" && !acc.firstChunkAt.has(key)) {
-				acc.firstChunkAt.set(key, event.time);
-				const started = acc.stepStart.get(key);
-				if (started !== void 0) acc.stats = {
-					...acc.stats,
-					ttftMs: acc.stats.ttftMs + Math.max(0, event.time - started),
-					ttftSteps: acc.stats.ttftSteps + 1
-				};
-			}
-			if (chunk.type === "text-delta") {
-				acc.streaming = appendStreamingTail(acc.streaming, chunk.text);
-				return true;
-			}
-			if (chunk.type === "reasoning-delta") {
-				acc.streamingReasoning = appendStreamingTail(acc.streamingReasoning, chunk.text);
-				return true;
+			let changed = false;
+			if (!acc.firstChunkAt.has(key)) {
+				const first = assistantStreamFirstTokenTime(event.data.stream ?? []);
+				if (first !== void 0) {
+					acc.firstChunkAt.set(key, first);
+					const started = acc.stepStart.get(key);
+					if (started !== void 0) acc.stats = {
+						...acc.stats,
+						ttftMs: acc.stats.ttftMs + Math.max(0, first - started),
+						ttftSteps: acc.stats.ttftSteps + 1
+					};
+					changed = true;
+				}
 			}
-			return false;
+			const streamed = acc.streaming !== "" || acc.streamingReasoning !== "";
+			acc.streaming = "";
+			acc.streamingReasoning = "";
+			return changed || streamed;
 		}
 		case "assistant/message": {
 			const key = `${event.data.turn}:${event.data.step}`;
 			const started = acc.stepStart.get(key);
 			acc.stepStart.delete(key);
-			const firstChunk = acc.firstChunkAt.get(key);
+			let firstChunk = acc.firstChunkAt.get(key);
+			if (firstChunk === void 0) {
+				firstChunk = assistantStreamFirstTokenTime(event.data.stream ?? []);
+				if (firstChunk !== void 0 && started !== void 0) acc.stats = {
+					...acc.stats,
+					ttftMs: acc.stats.ttftMs + Math.max(0, firstChunk - started),
+					ttftSteps: acc.stats.ttftSteps + 1
+				};
+			}
 			acc.firstChunkAt.delete(key);
 			if (acc.turnSteps.get(event.data.turn) === key) acc.turnSteps.delete(event.data.turn);
 			const usage = event.data.usage;
@@ -25631,11 +25719,7 @@ function replayProjectEvent(acc, event) {
 			acc.model = `${config.provider}/${config.model}`;
 			acc.stats = {
 				...acc.stats,
-				reasoningEffort: config.reasoningEffort === void 0 ? "" : String(config.reasoningEffort),
-				contextSegments: {
-					...acc.stats.contextSegments,
-					system: estimateTokens(event.data.header.system ?? "")
-				}
+				reasoningEffort: config.reasoningEffort === void 0 ? "" : String(config.reasoningEffort)
 			};
 			return true;
 		}
@@ -25700,6 +25784,7 @@ function materializeReplayView(acc, copy) {
 		plan: acc.plan,
 		permission: acc.permission,
 		title: acc.title,
+		systemPrompt: acc.systemPrompt,
 		sandbox: acc.sandbox,
 		goal: acc.goal,
 		pending: {
@@ -25715,11 +25800,58 @@ function materializeReplayView(acc, copy) {
 			lastPruneTokens: acc.lastPruneTokens,
 			turnFiles: new Map([...acc.turnFiles].map(([turn, files]) => [turn, new Set(files)])),
 			turnSteps: new Map(acc.turnSteps),
-			turnTools: new Map([...acc.turnTools].map(([turn, tools]) => [turn, new Set(tools)]))
+			turnTools: new Map([...acc.turnTools].map(([turn, tools]) => [turn, new Set(tools)])),
+			systemNodes: new Map(acc.systemNodes)
 		}
 	};
 }
 /**
+* Fold one process-local assistant-stream chunk frame (session-log v2+ keeps
+* durable logs settlement-only; live typing rides the `agent/assistant-stream`
+* agent event). Same first-token anchoring the durable `assistant/chunk` event
+* used to carry: the first non-empty delta anchors the TTFT and empty
+* keep-alive deltas do not count. The caller maps the frame's attempt to the
+* `turn:step` key (the start frame owns turn/step; chunk frames do not).
+* @param acc - the live replay accumulator.
+* @param key - the `turn:step` key the attempt's start frame declared.
+* @param time - the frame's safe-integer timestamp.
+* @param chunk - the model chunk the frame carries.
+* @returns whether the accumulator changed (the store stays silent otherwise).
+*/
+function applyAssistantStreamChunk(acc, key, time, chunk) {
+	if (isTokenDelta(chunk) && !acc.firstChunkAt.has(key)) {
+		acc.firstChunkAt.set(key, time);
+		const started = acc.stepStart.get(key);
+		if (started !== void 0) acc.stats = {
+			...acc.stats,
+			ttftMs: acc.stats.ttftMs + Math.max(0, time - started),
+			ttftSteps: acc.stats.ttftSteps + 1
+		};
+	}
+	if (chunk.type === "text-delta") {
+		acc.streaming = appendStreamingTail(acc.streaming, chunk.text);
+		return true;
+	}
+	if (chunk.type === "reasoning-delta") {
+		acc.streamingReasoning = appendStreamingTail(acc.streamingReasoning, chunk.text);
+		return true;
+	}
+	return false;
+}
+/**
+* Drop the live streaming tails without a settlement (an `agent/assistant-stream`
+* end frame with an `abandoned` outcome, or a session switch). The next start
+* frame rebuilds from scratch.
+* @param acc - the live replay accumulator.
+* @returns whether any tail text was discarded.
+*/
+function clearAssistantStream(acc) {
+	const streamed = acc.streaming !== "" || acc.streamingReasoning !== "";
+	acc.streaming = "";
+	acc.streamingReasoning = "";
+	return streamed;
+}
+/**
 * The append-only flush boundary for a transcript view: the count of entries
 * no later event can remove. Entries at or beyond this index are mutable and
 * must stay in the live tree.
@@ -26364,8 +26496,60 @@ const DEEPSEEK_WAVE_STYLES = [
 	"aurora",
 	"pulse"
 ];
-/** Pulse ring half-width in columns — Codex PULSE_HALF_WIDTH (4.5). */
-const PULSE_HALF_WIDTH = 4.5;
+/**
+* The water surface: ONE continuous sine line spanning the whole band,
+* mirror-symmetric about the center column, its crests flowing OUTWARD from
+* the center (phase k·|x − center| − ω·t). No sweep window, no return trip —
+* the surface fades in, flows, and fades out, symmetric in both space and
+* time. The deepseek tier adds one faster, finer HARMONIC line whose crests
+* cross the fundamental's: interleaved richness with both lines still
+* symmetric and still only ever flowing outward.
+*/
+const WAVE_SURFACE_AMPLITUDE = .8;
+const WAVE_SURFACE_HARMONIC = .45;
+/** Vertical thickness in lane units — Aurora-wide: soft gradients, no hard edges. */
+const WAVE_SURFACE_THICKNESS = 1.2;
+/**
+* The mirrored second-hue profile: the space BELOW the surface carries a
+* second blue at this strength, so color (not just brightness) varies
+* continuously across the wave — Aurora-style hue mixing instead of a
+* single flat tint.
+*/
+const WAVE_SURFACE_MIRROR = .6;
+/** Aurora-style soft alpha: low gain, capped well under the pulse ring's. */
+const WAVE_SURFACE_ALPHA_GAIN = .45;
+const WAVE_SURFACE_ALPHA_CAP = .68;
+/**
+* Pulse ring geometry, softened to the Wave standard: a WIDE band
+* (half-width 5.5) with a moderate peak riding the radius — all inside the
+* hue blend, no hard white line — and an inner profile one hue over at a
+* slightly smaller radius, so the ring's color grades continuously across
+* its width (the radial analog of the water surface's mirrored hues).
+*/
+const PULSE_HALF_WIDTH = 5.5;
+const PULSE_PEAK_HALF_WIDTH = 1.8;
+const PULSE_PEAK_GAIN = .35;
+const PULSE_INNER_OFFSET = 2.5;
+const PULSE_INNER_STRENGTH = .6;
+/** The inner edge of each ring carries the tier's third blue. */
+const PULSE_INNER_HUE = 2;
+/**
+* The trailing echo ripple: every pulse ring drags a second, weaker ring at
+* a fraction of its radius in the NEXT hue of the tier's blues, fading in a
+* little after the primary so the center hole opens first.
+*/
+const PULSE_ECHO_RADIUS = .7;
+const PULSE_ECHO_STRENGTH = .65;
+const PULSE_ECHO_DELAY = .12;
+/** Aurora-grade soft alpha for the detonation — a notch above the swell. */
+const PULSE_ALPHA_GAIN = .45;
+const PULSE_ALPHA_CAP = .72;
+/**
+* Terminal cell aspect (row height ÷ column width, ≈2.2 for common fonts).
+* A ring computed in raw cell units looks vertically squashed; weighting row
+* distance by the aspect makes the Pulse ring appear circular on screen.
+*/
+const PULSE_ROW_ASPECT = 2.2;
 /** Sparkle start and frame cadence — Codex SPARK_START / SPARK_FRAME. */
 const SPARK_START_MS = 900;
 const SPARK_FRAME_MS = 100;
@@ -26509,14 +26693,17 @@ function deepseekWaveStyleRandom(previous) {
 	return candidates[Math.floor(Math.random() * candidates.length)] ?? "wave";
 }
 /**
-* Tier for a `provider/model` label: a model id containing `flash` runs the
+* Tier for a `provider/model` label: a MODEL ID containing `flash` runs the
 * single-band flash tier; everything else (pro/reasoner/chat) runs the
-* dual-band deepseek tier. Mirrors Codex's Max→Ultra mapping.
+* dual-band deepseek tier. Mirrors Codex's Max→Ultra mapping. Only the model
+* segment (after the `/`) is matched, so a provider whose name contains
+* `flash` cannot flip an unrelated model onto the flash tier.
 * @param model - the `provider/model` label of the applied model.
 * @returns the wave tier for that model.
 */
 function deepseekWaveTier(model) {
-	return model.toLowerCase().includes("flash") ? "flash" : "deepseek";
+	const slash = model.indexOf("/");
+	return (slash < 0 ? model : model.slice(slash + 1)).toLowerCase().includes("flash") ? "flash" : "deepseek";
 }
 /**
 * Cosine window — Codex `crest`: 1 exactly under the wave center, 0 from
@@ -26529,18 +26716,6 @@ function crest(distance) {
 	return .5 * (1 + Math.cos(Math.PI * distance));
 }
 /**
-* Cubic ease-in-out — Codex `ease_in_out`: flat at both ends, steepest in
-* the middle, so the crest accelerates and eases instead of sliding linearly.
-* @param progress - raw progress (clamped to 0..1).
-* @returns the eased progress in 0..1.
-*/
-function easeInOut(progress) {
-	const p = Math.min(1, Math.max(0, progress));
-	if (p < .5) return 4 * p * p * p;
-	const inverse = -2 * p + 2;
-	return 1 - inverse * inverse * inverse / 2;
-}
-/**
 * Fade-in/fade-out envelope — Codex `envelope`: linear ramp over `fadeIn`
 * at the start and `fadeOut` at the end, plateau at 1 between, 0 outside the
 * total. The Wave style keeps the envelope at 1 (Codex paints Wave without
@@ -26558,38 +26733,98 @@ function envelope(elapsed, total, fadeIn, fadeOut) {
 	return Math.min(Math.max(Math.min(rise, fall), 0), 1);
 }
 /**
-* One band's contribution at a column — Codex `band_sample`, all three
-* branches: Wave sweeps an eased crest across the row; Aurora drifts a
-* sinusoidal center carrying a hue index; Pulse expands a ring from the row
-* center with cubic ease and decaying strength.
+* One band's contributions at a column — Codex `band_sample`, redesigned:
+* Wave is a WATER SURFACE — one continuous sine line, mirror-symmetric
+* about the center column, crests flowing outward from the center (band 1
+* of the deepseek tier is a faster harmonic line crossing it). Pulse
+* detonates in TWO dimensions: soft rings that keep expanding through a
+* symmetric fade envelope, color grading across each ring's width, with a
+* trailing echo ripple. Aurora matches Codex verbatim.
 * @param style - the ignition style.
 * @param band - the band triple (meaning depends on the style).
 * @param elapsed - seconds since the animation started.
 * @param column - column index in the content row (0..width-1).
 * @param width - content-row width in columns.
-* @returns `[hueIndex, strength]`.
+* @param context - band geometry (row position, undulation flag, pulse span).
+* @returns one or two `[hueIndex, strength, core]` contributions.
 */
-function bandSample(style, band, elapsed, column, width) {
+function bandSample(style, band, elapsed, column, width, context) {
 	const [first, second, third] = band;
 	switch (style) {
 		case "wave": {
-			const progress = (elapsed - first) / second;
-			if (progress < 0 || progress > 1) return [0, 0];
-			const center = easeInOut(progress) * (width + 18) - 9;
-			return [0, crest(Math.abs(column - center) / 9)];
+			const fadeIn = first;
+			const fadeOut = Math.max(.05, context.total - (first + second));
+			const fade = envelope(elapsed, context.total, fadeIn, fadeOut);
+			if (fade <= .01) return [[
+				0,
+				0,
+				0
+			]];
+			const harmonic = context.bandIndex % 2 === 1;
+			const wavelength = harmonic ? 40 / 1.5 : 40;
+			const omega = (harmonic ? 1.5 : 1) * 9;
+			const amplitude = (harmonic ? WAVE_SURFACE_HARMONIC : 1) * WAVE_SURFACE_AMPLITUDE;
+			const d = Math.abs(column - (width - 1) / 2);
+			const surface = amplitude * Math.sin(Math.PI * 2 * d / wavelength - omega * elapsed + (harmonic ? Math.PI / 2 : 0));
+			const fromSurface = Math.abs(context.u - surface);
+			const vertical = context.undulating ? crest(fromSurface / WAVE_SURFACE_THICKNESS) : 1;
+			const mirrorHue = harmonic ? 1 : 2;
+			const below = context.undulating ? crest(Math.abs(context.u + surface) / WAVE_SURFACE_THICKNESS) : vertical;
+			return [[
+				0,
+				fade * vertical,
+				0
+			], [
+				mirrorHue,
+				fade * below * WAVE_SURFACE_MIRROR,
+				0
+			]];
 		}
 		case "aurora": {
 			const center = (.5 + .38 * Math.sin(Math.PI * 2 * (first * elapsed + second))) * width;
 			const halfWidth = Math.max(width * .22, 4);
-			return [Math.trunc(third), crest(Math.abs(column - center) / halfWidth)];
+			return [[
+				Math.trunc(third),
+				crest(Math.abs(column - center) / halfWidth),
+				0
+			]];
 		}
 		case "pulse": {
-			const progress = (elapsed - first) / second;
-			if (progress < 0 || progress > 1) return [0, 0];
-			const inverse = 1 - progress;
-			const radius = (1 - inverse * inverse * inverse) * (width / 2 + 2 * PULSE_HALF_WIDTH);
-			const distance = Math.abs(column - width / 2);
-			return [0, crest(Math.abs(distance - radius) / PULSE_HALF_WIDTH) * third * (1 - .6 * progress)];
+			const launch = first;
+			const travel = second;
+			const fadeOut = Math.max(.05, context.total - (launch + travel));
+			const fade = envelope(elapsed, context.total, launch, fadeOut);
+			if (fade <= .01) return [[
+				0,
+				0,
+				0
+			]];
+			const progress = (elapsed - launch) / travel;
+			const radius = (1 - (1 - progress) ** 3) * context.pulseSpan;
+			const decay = third * (1 - .35 * Math.min(Math.max(progress, 0), 1));
+			const distance = Math.hypot(column - width / 2, context.dy);
+			const fromRing = Math.abs(distance - radius);
+			const band = crest(fromRing / PULSE_HALF_WIDTH) + PULSE_PEAK_GAIN * crest(fromRing / PULSE_PEAK_HALF_WIDTH);
+			const inner = crest(Math.abs(distance - (radius - PULSE_INNER_OFFSET)) / PULSE_HALF_WIDTH);
+			const echoGate = envelope(elapsed, context.total, launch + PULSE_ECHO_DELAY, fadeOut);
+			const echo = crest(Math.abs(distance - radius * PULSE_ECHO_RADIUS) / PULSE_HALF_WIDTH) * PULSE_ECHO_STRENGTH * echoGate;
+			return [
+				[
+					context.bandIndex,
+					fade * band * decay,
+					0
+				],
+				[
+					PULSE_INNER_HUE,
+					fade * inner * decay * PULSE_INNER_STRENGTH,
+					0
+				],
+				[
+					context.bandIndex + 1,
+					fade * echo * decay,
+					0
+				]
+			];
 		}
 	}
 }
@@ -26602,9 +26837,10 @@ function blendRgb(fg, bg, alpha) {
 	];
 }
 /**
-* Per-row phase share of the duration: the crest reaches the top row first
-* and the bottom row last, sweeping down the band. 0.12 keeps the bottom
-* row's lag inside the 200ms duration extension.
+* Aurora-only per-row phase share of the duration: its drifting bands reach
+* the top row first and the bottom row last, sweeping down the band. 0.12
+* keeps the bottom row's lag inside the 200ms duration extension. Wave and
+* Pulse deliberately share one timeline (see `deepseekWaveColumnBg`).
 */
 const DEEPSEEK_WAVE_ROW_PHASE = .12;
 /**
@@ -26615,9 +26851,13 @@ const DEEPSEEK_WAVE_ROW_PHASE = .12;
 * blends the mixed hue toward the blank-cell base at the style's alpha cap,
 * and Aurora applies its own fade envelope. Returns `null` when the column
 * should stay transparent, so the row returns to no `backgroundColor` on
-* both ends. With `rows > 1` each row samples the same timeline shifted by a
-* per-row phase offset, so the crest cascades down the band instead of
-* painting every row identically.
+* both ends. With `rows > 1`: Wave is a water surface — every column
+* lights the row nearest the surface's current height, so the light reads
+* as ONE continuous wavy line spanning the band, symmetric about the center
+* column and flowing outward (a single-row band falls back to a flat glow);
+* Pulse rings in two dimensions around the band's center cell with trailing
+* echo ripples; only Aurora samples the timeline shifted by a per-row phase
+* offset.
 * @param tick - wave frame (0, 1, … at DEEPSEEK_WAVE_TICK_MS).
 * @param column - column index in the content row (0..width-1).
 * @param width - content-row width in columns.
@@ -26631,16 +26871,28 @@ const DEEPSEEK_WAVE_ROW_PHASE = .12;
 */
 function deepseekWaveColumnBg(tick, column, width, tier, style, hues, base, row = 0, rows = 1) {
 	const total = deepseekWaveBaseDuration(tier, style) / 1e3;
-	const elapsed = deepseekWaveSampleElapsedMs(tick, tier, style) / 1e3 - (row - (rows - 1) / 2) * total * DEEPSEEK_WAVE_ROW_PHASE;
+	const elapsed = deepseekWaveSampleElapsedMs(tick, tier, style) / 1e3 - (style === "aurora" ? (row - (rows - 1) / 2) * total * DEEPSEEK_WAVE_ROW_PHASE : 0);
+	const dy = style === "pulse" ? (row - (rows - 1) / 2) * PULSE_ROW_ASPECT : 0;
+	const undulating = rows > 1;
+	const u = undulating ? (row - (rows - 1) / 2) / ((rows - 1) / 2) : 0;
+	const pulseSpan = Math.hypot(width / 2, (rows - 1) / 2 * PULSE_ROW_ASPECT);
 	const fade = style === "aurora" ? envelope(elapsed, total, .25, .4) : 1;
 	const weights = [
 		0,
 		0,
 		0
 	];
+	let bandIndex = 0;
 	for (const band of DEEPSEEK_WAVE_BANDS[style][tier]) {
-		const [hue, strength] = bandSample(style, band, elapsed, column, width);
-		weights[hue] = style === "aurora" ? weights[hue] + strength : Math.max(weights[hue], strength);
+		for (const [hue, strength] of bandSample(style, band, elapsed, column, width, {
+			dy,
+			u,
+			undulating,
+			pulseSpan,
+			bandIndex,
+			total
+		})) weights[hue] = style === "aurora" ? weights[hue] + strength : Math.max(weights[hue], strength);
+		bandIndex += 1;
 	}
 	const weight = weights[0] + weights[1] + weights[2];
 	if (weight <= .01) return null;
@@ -26657,7 +26909,7 @@ function deepseekWaveColumnBg(tick, column, width, tier, style, hues, base, row
 		Math.round(green / weight),
 		Math.round(blue / weight)
 	];
-	const alpha = style === "aurora" ? Math.min(weight * .4, .5) * fade : weight * .55;
+	const alpha = style === "aurora" ? Math.min(weight * .4, .5) * fade : style === "wave" ? Math.min(weight * WAVE_SURFACE_ALPHA_GAIN, WAVE_SURFACE_ALPHA_CAP) : Math.min(weight * PULSE_ALPHA_GAIN, PULSE_ALPHA_CAP);
 	if (alpha < .02) return null;
 	return blendRgb(mixed, base, alpha);
 }
@@ -26742,6 +26994,32 @@ function effortAboveHigh(effort) {
 	const rank = EFFORT_RANK[effort.trim().toLowerCase()];
 	return rank !== void 0 && rank > 3;
 }
+/**
+* Parse a persisted animations preference (`animations.json`): timed
+* animations are on by default and only an explicit `false` disables them —
+* a missing key, corrupt value, or absent file all mean enabled, so the
+* /animation toggle degrades exactly like every other user preference.
+* @param value - the raw parsed JSON value (expected boolean).
+* @returns whether timed animations should run.
+*/
+function parseAnimationsPref(value) {
+	return value !== false;
+}
+/**
+* One parsed `/animation` argument: '' toggles, `on|true|1` enables,
+* `off|false|0` disables (case-insensitive, surrounding whitespace ignored),
+* and anything else is a usage error the caller surfaces. Kept pure so the
+* command's entire decision table is unit-testable.
+* @param argument - the raw text after `/animation`.
+* @returns `{ enabled }`, `'toggle'`, or `'usage'`.
+*/
+function parseAnimationsArgument(argument) {
+	const normalized = argument.trim().toLowerCase();
+	if (normalized === "") return "toggle";
+	if (normalized === "on" || normalized === "true" || normalized === "1") return { enabled: true };
+	if (normalized === "off" || normalized === "false" || normalized === "0") return { enabled: false };
+	return "usage";
+}
 //#endregion
 //#region src/commands.ts
 /**
@@ -26760,17 +27038,41 @@ function watchCommands(ctx) {
 	let error;
 	let loadedFor;
 	const listeners = /* @__PURE__ */ new Set();
+	const descriptorFingerprint = (list) => JSON.stringify(list.map((descriptor) => [
+		descriptor.name,
+		descriptor.description,
+		descriptor.input?.hint ?? "",
+		descriptor.input?.attachments === true
+	]));
+	let lastFingerprint = "[]";
+	let lastNotifiedError;
+	const changed = (next, nextError) => descriptorFingerprint(next) !== lastFingerprint || nextError !== lastNotifiedError;
+	let notifyScheduled = false;
+	const notify = () => {
+		if (notifyScheduled) return;
+		notifyScheduled = true;
+		setImmediate(() => {
+			notifyScheduled = false;
+			for (const listener of listeners) listener();
+		});
+	};
 	const refresh = () => {
 		if (commands === void 0 || agent === void 0) return;
+		let next;
+		let nextError;
 		try {
-			descriptors = commands.list(agent);
+			next = commands.list(agent);
 			loadedFor = agent;
-			error = void 0;
 		} catch (cause) {
-			descriptors = loadedFor === agent ? [...descriptors] : [];
-			error = cause instanceof Error ? cause.message : String(cause);
+			next = loadedFor === agent ? [...descriptors] : [];
+			nextError = cause instanceof Error ? cause.message : String(cause);
 		}
-		for (const listener of listeners) listener();
+		if (!changed(next, nextError)) return;
+		descriptors = next;
+		error = nextError;
+		lastFingerprint = descriptorFingerprint(next);
+		lastNotifiedError = nextError;
+		notify();
 	};
 	if (commands !== void 0) ctx.on("commands/change", () => refresh());
 	return {
@@ -26818,6 +27120,70 @@ function submissionPayload(line) {
 	return isSlashLine(trimmed) ? trimmed : withoutTrailingNewlines;
 }
 //#endregion
+//#region src/render/fuzzy.ts
+/** Extra weight for name starts and separator boundaries. */
+function boundaryBonus(name, index) {
+	return index === 0 || name.charAt(index - 1) === "-" || name.charAt(index - 1) === "_" ? 8 : 0;
+}
+/**
+* Score the strongest ordered-subsequence alignment in O(name × query).
+* Boundary and adjacent matches earn weight; skipped and leading characters
+* cost weight. Undefined when the query is not a subsequence of the name.
+*/
+function alignmentScore(name, query) {
+	if (query.length > name.length) return void 0;
+	const noMatch = Number.NEGATIVE_INFINITY;
+	let previous = Array(name.length).fill(noMatch);
+	for (let index = 0; index < name.length; index++) if (name.charAt(index) === query.charAt(0)) previous[index] = 1 + boundaryBonus(name, index) - index;
+	for (let queryIndex = 1; queryIndex < query.length; queryIndex++) {
+		const current = Array(name.length).fill(noMatch);
+		let left = noMatch;
+		let leftLeft = noMatch;
+		let bestGapped = noMatch;
+		for (const [index, prior] of previous.entries()) {
+			if (leftLeft !== noMatch) bestGapped = Math.max(bestGapped, leftLeft + index - 2);
+			if (name.charAt(index) === query.charAt(queryIndex)) {
+				const bonus = 1 + boundaryBonus(name, index);
+				let score = noMatch;
+				if (left !== noMatch) score = left + bonus + 4;
+				if (bestGapped !== noMatch) score = Math.max(score, bestGapped + bonus + 1 - index);
+				current[index] = score;
+			}
+			leftLeft = left;
+			left = prior;
+		}
+		previous = current;
+	}
+	let best = noMatch;
+	for (const score of previous) best = Math.max(best, score);
+	return best === noMatch ? void 0 : best;
+}
+/**
+* Rank named items by a menu query.
+* @param items - candidates in source order (the caller's composition order
+* is the final tie-breaker, e.g. local commands before registry entries).
+* @param rawQuery - the text typed after the trigger, matched case-insensitively.
+* @returns the matching items: prefix hits first, then by alignment score,
+* then in source order. The input list itself for an empty query.
+*/
+function rankByName(items, rawQuery) {
+	const query = rawQuery.toLowerCase();
+	if (query === "") return items;
+	const ranked = [];
+	items.forEach((item, index) => {
+		const name = item.name.toLowerCase();
+		const score = alignmentScore(name, query);
+		if (score !== void 0) ranked.push({
+			item,
+			index,
+			prefix: name.startsWith(query),
+			score
+		});
+	});
+	ranked.sort((left, right) => Number(right.prefix) - Number(left.prefix) || right.score - left.score || left.index - right.index);
+	return ranked.map((match) => match.item);
+}
+//#endregion
 //#region src/provider-settings.ts
 /** Human text for a rejection value (mirrors the web page's `messageOf`). */
 function messageOf$1(error) {
@@ -27027,7 +27393,8 @@ async function loadProviderSettings(ctx) {
 		active: active.has(entry.provider),
 		settingsNs: entry.settingsNs,
 		settingsPath: entry.settingsPath,
-		...entry.declared === void 0 ? {} : { declared: entry.declared }
+		...entry.declared === void 0 ? {} : { declared: entry.declared },
+		...entry.error === void 0 ? {} : { error: singleLine$1(entry.error) }
 	})), ...registered.filter((provider) => !declared.has(provider.id)).map((provider) => ({
 		provider: provider.id,
 		displayName: provider.name,
@@ -27052,7 +27419,8 @@ async function loadProviderSettings(ctx) {
 			configuration: configurationOf(profile),
 			...credentialRef === void 0 ? {} : { credentialRef },
 			suggestedRef: deriveCredentialRef(base.provider),
-			...base.declared === void 0 ? {} : { declared: base.declared }
+			...base.declared === void 0 ? {} : { declared: base.declared },
+			...base.error === void 0 ? {} : { diagnostic: base.error }
 		};
 	});
 	const refs = [...new Set(rows.flatMap((row) => row.credentialRef === void 0 ? [] : [row.credentialRef]))];
@@ -27479,9 +27847,8 @@ function mergeSessionTitles(rows, observations) {
 }
 /**
 * Encode a session id the way the JSONL backend does for its on-disk layout
-* (`encodeSegment`: safe units literal, everything else `~XXXX`). Used ONLY to
-* validate that a `locate()` path really is this session's directory before
-* any deletion touches the filesystem — a local copy of the pure upstream
+* (`encodeSegment`: safe units literal, everything else `~XXXX`). Used to
+* validate and derive session directories — a local copy of the pure upstream
 * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
 */
 function encodeSessionSegment(raw) {
@@ -27497,21 +27864,91 @@ function encodeSessionSegment(raw) {
 	}
 	return out;
 }
-/** The session-log artifact names the JSONL backend may create. */
-const SESSION_ARTIFACT_NAMES = ["session.jsonl", "session.jsonl.zstd"];
 /**
-* Guard one `locate()` artifact path before deletion (codex's scoped-path
-* check, adapted to the JSONL layout): the file must be a `session.jsonl`
-* artifact sitting in the directory named exactly `encodeSegment(id)`.
-* @param artifact - the path the persistence backend located.
-* @param id - the session id the artifact claims to belong to.
-* @returns the owning session directory, or undefined when the layout is unexpected.
+* Encode a project cwd the way the JSONL backend groups sessions on disk
+* (`projectKey`: separators collapse to one `-`, everything else mirrors
+* `encodeSegment`, bounded to 251 chars). A local copy of the pure upstream
+* contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
+*/
+function encodeProjectKey(cwd) {
+	if (cwd.length === 0) throw new Error("cannot encode an empty project path");
+	let readable = "";
+	let separatorRun = false;
+	for (let i = 0; i < cwd.length; i += 1) {
+		const code = cwd.charCodeAt(i);
+		const ch = String.fromCharCode(code);
+		if (ch === "/" || ch === "\\" || ch === ":") {
+			if (!separatorRun) readable += "-";
+			separatorRun = true;
+		} else if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) {
+			readable += ch;
+			separatorRun = false;
+		} else {
+			readable += `~${code.toString(16).toUpperCase().padStart(4, "0")}`;
+			separatorRun = false;
+		}
+	}
+	return `--${(readable.replace(/^-+/, "") || "root").slice(0, 251)}--`;
+}
+/** The project-level directory name the JSONL backend uses for a missing cwd. */
+const NO_CWD_DIRECTORY = "_no-cwd";
+/**
+* Derive one session's artifact directory under the JSONL backend root,
+* mirroring the upstream `<root>/<projectKey(cwd)>/<encodeSegment(id)>/`
+* layout (0.1.5 `sessionDir`/`projectDir`).
+* @param root - the JSONL backend's configured session root.
+* @param cwd - the session's pinned working directory, when the header has one.
+* @param id - the session id.
+* @returns the absolute session directory path.
+*/
+function sessionDirectoryFor(root, cwd, id) {
+	const project = cwd === void 0 || cwd === "" ? NO_CWD_DIRECTORY : encodeProjectKey(cwd);
+	return resolve(root, project, encodeSessionSegment(id));
+}
+/**
+* The canonical session-log artifact filenames the JSONL backend may create:
+* format v0 writes the bare `session.jsonl` name; v1+ write
+* `session.vN.jsonl`, each generation optionally zstd-compressed. Multiple
+* immutable generations may coexist in one session directory (0.1.5). The
+* range follows the installed session package's `SESSION_FORMAT_VERSION`, so
+* a future generation joins the enumeration with the dependency bump.
+*/
+function sessionArtifactNames() {
+	const names = ["session.jsonl", "session.jsonl.zstd"];
+	for (let version = 1; version <= SESSION_FORMAT_VERSION; version += 1) names.push(`session.v${version}.jsonl`, `session.v${version}.jsonl.zstd`);
+	return names;
+}
+/** Canonical generation-log filenames as a lookup set (bare v0 or `vN`-suffixed, ± zstd). */
+const SESSION_ARTIFACT_NAME_SET = new Set(sessionArtifactNames());
+/** True for one canonical session-log artifact filename the backend may own. */
+function isSessionArtifactName(name) {
+	return SESSION_ARTIFACT_NAME_SET.has(name);
+}
+/**
+* Guard a derived session directory before deletion (codex's scoped-path
+* check, adapted to the JSONL layout): the directory's base name must be
+* exactly `encodeSegment(id)` beneath its project grouping.
+* @param dir - the derived session artifact directory.
+* @param id - the session id the directory claims to belong to.
+* @returns the guarded directory, or undefined when the layout is unexpected.
 */
-function sessionArtifactDirectory(artifact, id) {
-	if (basename(artifact) !== "session.jsonl" && basename(artifact) !== "session.jsonl.zstd") return void 0;
-	const dir = dirname(artifact);
+function sessionArtifactDirectory(dir, id) {
 	if (basename(dir) !== encodeSessionSegment(id)) return void 0;
-	return dir;
+	if (basename(dirname(dir)) === NO_CWD_DIRECTORY) return dir;
+	return /^--.*--$|^~/.test(basename(dirname(dir))) ? dir : void 0;
+}
+/**
+* The JSONL backend's configured session root, when the mounted backend
+* exposes one. The upstream service contract dropped `locate()` in 0.1.5
+* (artifact paths are backend-private; only refusal diagnostics carry them),
+* so the TUI derives artifact paths from the backend's public plugin config.
+* Backends without a JSONL-style config (or a foreign shape) yield undefined
+* and callers degrade: mtime sorting falls back to createdAt and /delete
+* refuses, exactly as before.
+*/
+function jsonlSessionRoot(persistence) {
+	const root = persistence?.config?.root;
+	return typeof root === "string" && root !== "" ? root : void 0;
 }
 /**
 * Collect one session's deletion subtree: the id plus every record whose
@@ -30061,6 +30498,26 @@ function parseHistoryFile(raw, max = 100) {
 	return kept.slice(-max);
 }
 /**
+* The append unit for the persistent file: one JSON line, so a multi-line
+* draft still occupies exactly one physical line. Each submission appends
+* this unit at the end of the file, so concurrent terminals add entries
+* after each other. Node chunks one append at 512 KiB: a pasted entry
+* beyond that size could interleave mid-line with another writer's
+* chunks, and the damaged line then drops out at the next parse —
+* recall tolerates the loss by design.
+*/
+function historyLine(text) {
+	return serializeHistoryEntry(text) + "\n";
+}
+/**
+* Whether the file on disk differs from its canonical form (deduped and
+* capped). True means stale lines have accumulated and the next boot
+* should rewrite it once, atomically.
+*/
+function needsCompaction(raw, max = 100) {
+	return serializeHistoryList(parseHistoryFile(raw, max)) !== raw;
+}
+/**
 * Record one in-session submission: empty text is ignored and an adjacent
 * duplicate collapses (Codex `record_local_submission` semantics). The local
 * pool shares the persistent pool's cap so the recall space stays bounded.
@@ -30075,10 +30532,10 @@ function recordLocalEntry(local, text, max = 100) {
 	return [...local, text].slice(-max);
 }
 /**
-* Serialize a capped entry list to the history file format (one JSON line per
-* entry, trailing newline). The runner writes the in-memory list as the whole
-* file, so rapid same-process submissions cannot lose entries to a
-* read-modify-write race (the file is never read back before writing).
+* Serialize a capped entry list to the history file format (one JSON line
+* per entry, trailing newline). The boot-time compaction writes this
+* canonical form once when stale lines have accumulated; submissions
+* themselves only ever append a single line.
 * @param entries - the entries to persist, oldest first.
 * @returns the file content, '' for an empty list.
 */
@@ -30565,7 +31022,14 @@ function ProviderAuthorizationLogoutPanel({ row, confirm, done, back }) {
 }
 //#endregion
 //#region src/attachments.ts
-/** Terminal image-file adapter over the Harness durable attachment service. */
+/** Terminal image- and file-attachment adapter over the Harness durable attachment service. */
+/**
+* Terminal-side file admission bounds. Upstream exposes image limits through
+* the attachment service but no file limits (files ride verbatim storage);
+* these keep a dragged file from silently ingesting a disk-sized blob and
+* bound one message the way the image batch is bounded.
+*/
+const MAX_FILE_BYTES = 8388608;
 const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".png",
 	".jpg",
@@ -30587,24 +31051,58 @@ function detectImageMediaType(data) {
 function looksLikeImagePath(path) {
 	return IMAGE_EXTENSIONS.has(extname(path).toLowerCase());
 }
-/** Parse a terminal paste/drop containing only one or more image paths. */
-function parsePastedImagePaths(input) {
+/**
+* Parse a paste/drop into its image and file paths: image-suffixed tokens
+* stay images, other path-shaped tokens ride as file attachments (0.1.5
+* file blocks), and anything that is neither leaves both empty — the caller
+* then treats the paste as plain text.
+*
+* File tokens are held to an absolute-path-with-shape bar (drive/backslash
+* or a dot-suffixed leaf after a separator): a dropped terminal path always
+* carries one of those, while prose, slash commands, and option flags never
+* do. A POSIX absolute path without any dot-suffixed leaf falls through as
+* text — the @ mention route still attaches such files deliberately.
+*/
+function parsePastedAttachmentPaths(input) {
 	const text = input.trim();
-	if (text === "") return [];
-	const tokens = [];
+	if (text === "") return {
+		images: [],
+		files: []
+	};
+	const images = [];
+	const files = [];
+	const looksLikeDroppedFile = (path) => /^[A-Za-z]:[\\/]/u.test(path) || /^\\\\/u.test(path) || /^\/|^\.\.?\//u.test(path) && /\.[A-Za-z0-9]{1,16}$/u.test(path);
 	for (const match of text.matchAll(/"([^"]+)"|'([^']+)'|(\S+)/gu)) {
 		const token = match[1] ?? match[2] ?? match[3];
 		if (token === void 0) continue;
 		let path = token;
-		if (path.startsWith("file://")) try {
-			path = fileURLToPath(path);
-		} catch {
-			return [];
+		if (path.startsWith("file://")) {
+			try {
+				path = fileURLToPath(path);
+			} catch {
+				return {
+					images: [],
+					files: []
+				};
+			}
+			if (looksLikeImagePath(path)) images.push(path);
+			else files.push(path);
+			continue;
+		}
+		if (looksLikeImagePath(path)) {
+			images.push(path);
+			continue;
 		}
-		if (!looksLikeImagePath(path)) return [];
-		tokens.push(path);
+		if (!looksLikeDroppedFile(path)) return {
+			images: [],
+			files: []
+		};
+		files.push(path);
 	}
-	return tokens;
+	return {
+		images,
+		files
+	};
 }
 /** Validate path, byte size and encoded signature without writing an attachment object. */
 async function inspectImagePaths(paths, attachments, cwd = process.cwd()) {
@@ -30675,6 +31173,60 @@ async function saveImagePaths(paths, attachments, signal) {
 		attachment
 	}));
 }
+/** Validate path and byte size for non-image file attachments without writing. */
+async function inspectFilePaths(paths, attachments, cwd = process.cwd()) {
+	if (paths.length === 0) return [];
+	if (attachments === void 0) throw new Error("file attachments are unavailable in this profile");
+	if (paths.length > 8) throw new Error(`too many files (${paths.length}; limit 8)`);
+	const inspected = [];
+	for (const raw of paths) {
+		const path = isAbsolute(raw) ? resolve(raw) : resolve(cwd, raw);
+		let facts;
+		try {
+			facts = await stat(path);
+		} catch (error) {
+			throw new Error(`cannot read file "${raw}": ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!facts.isFile()) throw new Error(`file path is not a file: "${raw}"`);
+		if (facts.size > 8388608) throw new Error(`file "${basename(path)}" is ${facts.size} bytes; limit ${MAX_FILE_BYTES}`);
+		inspected.push({
+			path,
+			name: basename(path),
+			bytes: facts.size
+		});
+	}
+	return inspected;
+}
+/** Read and persist an ordered non-image file path list as model file blocks. */
+async function saveFilePaths(paths, attachments, signal) {
+	if (paths.length === 0) return [];
+	if (attachments === void 0) throw new Error("file attachments are unavailable in this profile");
+	await inspectFilePaths(paths, attachments);
+	const checkCancelled = () => {
+		if (signal?.aborted === true) throw new Error("file submission cancelled");
+	};
+	const inputs = [];
+	for (const path of paths) {
+		checkCancelled();
+		let data;
+		try {
+			data = await readFile(path);
+		} catch (error) {
+			throw new Error(`cannot read file "${path}": ${error instanceof Error ? error.message : String(error)}`);
+		}
+		inputs.push({
+			data,
+			name: basename(path)
+		});
+	}
+	checkCancelled();
+	const refs = await Promise.all(inputs.map((input) => attachments.saveFile(input)));
+	checkCancelled();
+	return refs.map((attachment) => ({
+		type: "file",
+		attachment
+	}));
+}
 //#endregion
 //#region src/app.ts
 /**
@@ -30764,6 +31316,10 @@ const LOCAL_COMMANDS = [
 		label: "/theme",
 		description: "switch the color theme"
 	},
+	{
+		label: "/animation",
+		description: "toggle timed animations (/animation [on|off])"
+	},
 	{
 		label: "/history",
 		description: "search and recall past prompts"
@@ -30823,12 +31379,21 @@ function padColumns(text, width) {
 	const clipped = truncateColumns(singleLineText(text), width);
 	return clipped + " ".repeat(Math.max(0, width - visibleColumns(clipped)));
 }
-/** Interval-driven frame counter for one self-contained animated leaf. */
+/**
+* Wall-clock frame counter for one self-contained animated leaf. Each fire
+* derives the tick from elapsed time instead of counting intervals, so a
+* stretched interval (busy event loop, slow SSH) skips the animation ahead
+* rather than slowing it down; the tick always tracks real time.
+*/
 function useFrames(intervalMs, active = true) {
 	const [tick, setTick] = (0, import_react.useState)(0);
 	(0, import_react.useEffect)(() => {
 		if (!active) return;
-		const id = setInterval(() => setTick((current) => current + 1), intervalMs);
+		const startedAt = Date.now();
+		setTick(0);
+		const id = setInterval(() => {
+			setTick(Math.max(0, Math.floor((Date.now() - startedAt) / intervalMs)));
+		}, intervalMs);
 		return () => {
 			clearInterval(id);
 		};
@@ -30849,14 +31414,17 @@ function useStableInput(handler, active) {
 	}, []);
 	useInput(stableHandler, { isActive: active });
 }
-/** The original web StateDot chase used by the busy composer marker. */
-function BusyChase() {
-	const tick = useFrames(125);
+/**
+* The original web StateDot chase used by the busy composer marker. With
+* animations off it freezes on the first frame (still visibly busy).
+*/
+function BusyChase({ animated = true }) {
+	const tick = useFrames(125, animated);
 	return (0, import_react.createElement)(Text, { color: inkColor(getPalette().brandBright) }, busyChaseFrame(tick) + " ");
 }
-/** Blinking block caret appended to streaming text. */
-function Caret() {
-	const tick = useFrames(530);
+/** Blinking block caret appended to streaming text; solid when frozen. */
+function Caret({ animated = true }) {
+	const tick = useFrames(530, animated);
 	return (0, import_react.createElement)(Text, null, caretVisible(tick) ? "▍" : " ");
 }
 /** One resettable input-caret phase shared by the entire composer. */
@@ -30883,17 +31451,19 @@ function useCursorBlink(active) {
 * One bounded line painted with the deep-diving shimmer: a continuously
 * moving blue gradient across graphemes, the `✻` glyph in the breathing
 * spark color. Shared by the busy line and the collapsed thinking marker;
-* always exactly one row (truncate-end) so the live budget stays exact.
+* always exactly one row (truncate-end) so the live budget stays exact. With
+* animations off the same spans render in fixed colors — no timer, no
+* per-frame repaint, the `✻` keeps its highlight.
 */
-function ShimmerLine({ text }) {
-	const tick = useFrames(33);
+function ShimmerLine({ text, animated = true }) {
+	const tick = useFrames(33, animated);
 	const palette = getPalette();
 	const graphemes = splitGraphemes(text);
 	return (0, import_react.createElement)(Text, { wrap: "truncate-end" }, ...graphemes.map((grapheme, index) => {
 		const sparkle = grapheme.text === "✻";
 		return (0, import_react.createElement)(Text, {
 			key: `${grapheme.start}-${grapheme.end}`,
-			color: inkColor(sparkle ? deepDivingSparkColor(tick, palette.brandDeep, palette.brandBright) : deepDivingGradientColor(index, tick, graphemes.length, palette.brandDeep, palette.brandBright)),
+			color: inkColor(!animated ? sparkle ? palette.brandBright : palette.brandDeep : sparkle ? deepDivingSparkColor(tick, palette.brandDeep, palette.brandBright) : deepDivingGradientColor(index, tick, graphemes.length, palette.brandDeep, palette.brandBright)),
 			bold: sparkle || void 0
 		}, grapheme.text);
 	}));
@@ -30904,10 +31474,13 @@ function ShimmerLine({ text }) {
 * only once the turn has clearly been running (15s) — anchored to `turn/start`
 * so a resumed mid-turn keeps the real time.
 */
-function DeepDivingLine({ since }) {
+function DeepDivingLine({ since, animated = true }) {
 	const elapsed = since === 0 ? 0 : Date.now() - since;
 	const text = elapsed >= 15e3 ? `✻ Deep diving... ${runClock(elapsed)}` : "✻ Deep diving...";
-	return (0, import_react.createElement)(ShimmerLine, { text });
+	return (0, import_react.createElement)(ShimmerLine, {
+		text,
+		animated
+	});
 }
 /**
 * The streaming buffer rendered with a hard size cap: the live region must
@@ -32192,7 +32765,8 @@ function ProviderPanel({ directory, error, authorizations, authorizationError, o
 		const identity = row.displayName === row.provider ? row.provider : row.displayName + " (" + row.provider + ")";
 		const authorization = authorizationForProvider(authorizations, row.provider);
 		const authLabel = !(row.credential?.kind === "facts" && row.credential.configured) || authorization?.record.configured === true || authorization?.inFlight === true ? " · " + providerAuthorizationStatus(authorization) : "";
-		const label = identity + " · " + providerStateLabel(row) + authLabel + (row.removable ? " · custom" : "");
+		const diagnostic = row.diagnostic === void 0 ? "" : " · ! " + singleLineText(row.diagnostic);
+		const label = identity + " · " + providerStateLabel(row) + authLabel + (row.removable ? " · custom" : "") + diagnostic;
 		const idleColor = row.configured ? inkColor(getPalette().brandMid) : inkColor(getPalette().dim);
 		itemRows.push((0, import_react.createElement)(Text, {
 			key: row.provider,
@@ -32560,7 +33134,7 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
 		color: zone === "url" ? inkColor(getPalette().brandBright) : inkColor(getPalette().dim),
 		wrap: "truncate-end"
 	}, truncateColumns("  " + (zone === "url" ? ">" : " ") + " url   " + (baseURL === "" ? "(official default)" : baseURL) + (zone === "url" ? "▏" : ""), viewport.contentColumns));
-	const rowBudget = Math.max(0, viewport.bodyRows - stateRows.length - 3);
+	const rowBudget = Math.max(0, viewport.bodyRows - stateRows.length - (target.diagnostic === void 0 ? 0 : 1) - 3);
 	const first = selectionWindow(cursor, models.length + 1, rowBudget);
 	const modelRows = [];
 	for (let index = first; index < first + Math.max(0, Math.min(models.length + 1 - first, rowBudget)); index += 1) {
@@ -32593,7 +33167,11 @@ function ProviderSetupPanel({ target, save, saveCredential, discover, effortDono
 		color: inkColor(getPalette().brand),
 		bold: true,
 		wrap: "truncate-end"
-	}, truncateColumns("/model — configure " + target.displayName, viewport.contentColumns)), (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), keyRow, urlRow, ...stateRows, ...modelRows, (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
+	}, truncateColumns("/model — configure " + target.displayName, viewport.contentColumns)), ...target.diagnostic === void 0 ? [] : [(0, import_react.createElement)(Text, {
+		key: "diagnostic",
+		color: inkColor(getPalette().warn),
+		wrap: "truncate-end"
+	}, truncateColumns("! " + displayText(singleLineText(target.diagnostic)), viewport.contentColumns))], (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), keyRow, urlRow, ...stateRows, ...modelRows, (0, import_react.createElement)(PanelGap, { visible: viewport.gapRows > 0 }), (0, import_react.createElement)(Text, {
 		color: inkColor(getPalette().dim),
 		wrap: "truncate-end"
 	}, truncateColumns("↑↓ move · ←→ in/out · space remove · e efforts · c copy efforts · tab discover · enter save · esc back", viewport.contentColumns)));
@@ -32933,6 +33511,167 @@ function waveRowSpans(cells) {
 	}
 	return spans;
 }
+/** Index of the cell STARTING at a display column, if one does. */
+function cellIndexAtColumn(cells, target) {
+	let column = 0;
+	for (let index = 0; index < cells.length; index += 1) {
+		if (column === target) return index;
+		column += cells[index].width ?? visibleColumns(cells[index].char);
+		if (column > target) return void 0;
+	}
+}
+/**
+* Wall-clock wave frames — strictly ONE sweep per MOUNT; the mount-spanning
+* one-shot latch (surviving modal unmounts) lives in Input as `wavePlayedKey`.
+* The first gate-off after the sweep has started (it completed, a turn went
+* busy, image preparation began, animations were toggled off) latches `done`
+* for this mount, so the same mount can never resume or replay. A trigger
+* that lands while the gate is already down stays pending until the gate
+* rises once, then plays.
+*/
+function useWaveFrames(active, durationMs) {
+	const [tick, setTick] = (0, import_react.useState)(0);
+	const [done, setDone] = (0, import_react.useState)(false);
+	const startedRef = (0, import_react.useRef)(false);
+	(0, import_react.useEffect)(() => {
+		if (done) return;
+		if (!active) {
+			if (startedRef.current) setDone(true);
+			return;
+		}
+		startedRef.current = true;
+		const startedAt = Date.now();
+		const id = setInterval(() => {
+			const elapsed = Date.now() - startedAt;
+			if (elapsed >= durationMs) {
+				clearInterval(id);
+				setDone(true);
+				return;
+			}
+			setTick(Math.max(0, Math.floor(elapsed / 33)));
+		}, 33);
+		return () => {
+			clearInterval(id);
+		};
+	}, [
+		active,
+		durationMs,
+		done
+	]);
+	return {
+		tick,
+		done
+	};
+}
+/**
+* The self-contained wave leaf: it owns its 33ms tick, so the sweep
+* re-renders ONLY this component at ~30fps — Input's derived editor state
+* never re-runs per frame. Graphemes stay atomic and every background sample
+* advances by terminal display columns, so CJK and emoji cannot move the
+* caret or wrap the band. The duration gate renders the fallback band on the
+* frame the sweep completes.
+*/
+function ComposerWave(props) {
+	const { tier, style } = props;
+	const durationMs = deepseekWaveDuration(tier, style);
+	const { tick, done } = useWaveFrames(props.active, durationMs);
+	const settledRef = (0, import_react.useRef)(false);
+	const onSettledRef = (0, import_react.useRef)(props.onSettled);
+	onSettledRef.current = props.onSettled;
+	const settle = () => {
+		if (settledRef.current) return;
+		settledRef.current = true;
+		onSettledRef.current();
+	};
+	(0, import_react.useEffect)(() => {
+		if (done) settle();
+	}, [done]);
+	(0, import_react.useEffect)(() => () => {
+		settle();
+	}, []);
+	if (!props.active || done || tick * 33 >= durationMs) return props.fallback;
+	const hues = deepseekWaveHues(tier);
+	const bandRgb = getPalette().composerBand;
+	const totalBandRows = props.rows.length + 2;
+	const waveBg = (row, column) => {
+		const rgb = deepseekWaveColumnBg(tick, column, props.bandWidth, tier, style, hues, bandRgb, row, totalBandRows);
+		return rgb === null ? props.bandBg : inkColor(rgb);
+	};
+	const blankBandRow = (row) => {
+		const blanks = [];
+		for (let column = 0; column < props.bandWidth; column += 1) blanks.push({
+			char: " ",
+			width: 1,
+			backgroundColor: waveBg(row, column)
+		});
+		return (0, import_react.createElement)(Text, { key: `blank-${row}` }, ...waveRowSpans(blanks));
+	};
+	const editorWaveRows = props.rows.map((row, visibleIndex) => {
+		const sourceIndex = props.windowStart + visibleIndex;
+		const bandRow = visibleIndex + 1;
+		const parts = editorRowParts(row, sourceIndex, props.caretRow, props.cursor);
+		const placeholder = sourceIndex === 0 && props.value === "";
+		const cells = [];
+		let usedColumns = 0;
+		const push = (char, extra = {}) => {
+			const width = visibleColumns(char);
+			cells.push({
+				char,
+				width,
+				backgroundColor: waveBg(bandRow, usedColumns),
+				...extra
+			});
+			usedColumns += width;
+		};
+		if (sourceIndex === 0) {
+			push(props.promptGlyph, {
+				color: props.promptColor,
+				bold: true
+			});
+			push(" ", { color: props.promptColor });
+		} else {
+			push(" ");
+			push(" ");
+		}
+		for (const span of splitGraphemes(parts.before)) push(span.text);
+		if (parts.hasCaret) push(parts.caret, { inverse: props.caretVisible });
+		const tail = placeholder ? COMPOSER_PLACEHOLDER : parts.after;
+		for (const span of splitGraphemes(tail)) push(span.text, placeholder ? { dim: true } : {});
+		while (usedColumns < props.bandWidth) push(" ");
+		const middleBandRow = Math.floor(totalBandRows / 2);
+		if (bandRow === middleBandRow && deepseekWaveWordVisible(tick, tier, style)) {
+			const word = tier === "unknown" ? "Into the Unknown" : "deepseek";
+			const start = Math.max(2, Math.floor((props.bandWidth - word.length) / 2));
+			const indices = Array.from({ length: word.length }, (_, at) => cellIndexAtColumn(cells, start + at));
+			if (indices.every((index) => index !== void 0 && (cells[index].char === " " || cells[index].dim === true))) for (let at = 0; at < word.length; at += 1) {
+				const cell = cells[indices[at]];
+				cell.char = word[at];
+				cell.width = 1;
+				cell.color = inkColor(deepseekWaveWordHue(at, hues));
+				cell.bold = true;
+				cell.dim = false;
+			}
+		}
+		if (bandRow === middleBandRow && (tier === "deepseek" || tier === "unknown") && style === "wave") {
+			const spark = deepseekWaveSpark(tick);
+			const lastIndex = cellIndexAtColumn(cells, props.bandWidth - 1);
+			if (spark !== null && lastIndex !== void 0 && cells[lastIndex].char === " ") {
+				cells[lastIndex].char = spark;
+				cells[lastIndex].color = props.promptColor;
+				cells[lastIndex].bold = true;
+				cells[lastIndex].dim = false;
+			}
+		}
+		return (0, import_react.createElement)(Text, {
+			key: `editor-${sourceIndex}`,
+			wrap: "truncate-end"
+		}, ...waveRowSpans(cells));
+	});
+	return (0, import_react.createElement)(Box, {
+		flexDirection: "column",
+		width: props.bandWidth
+	}, blankBandRow(0), ...editorWaveRows, blankBandRow(totalBandRows - 1));
+}
 /**
 * The Ctrl+O transcript inspector: one selected durable entry at a time,
 * with independent history selection and content scrolling. The complete
@@ -33092,8 +33831,10 @@ function completionCandidates(value, descriptors, skills) {
 		seen.add(name);
 		all.push(candidate);
 	}
-	if (prefix === "") return all;
-	return all.filter((candidate) => candidate.label.slice(1).startsWith(prefix));
+	return rankByName(all.map((candidate) => ({
+		name: candidate.label.slice(1),
+		candidate
+	})), prefix).map((entry) => entry.candidate);
 }
 /**
 * Shared completion-menu geometry: the menu view and the App's dynamic-row
@@ -33175,7 +33916,7 @@ function CompletionMenu({ active, mention, index, rows, error }) {
 * While a modal (approval / question / model panel) owns the keys, the
 * box passes every key through untouched.
 */
-function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openPlugin, openJobs, openStatusline, openTheme, openHistory, openAgents, openSubagent, openTodos, openDelete, openDiff, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, applyEditorKeys, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, cyclePermission, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, cancelQueued, historyFill, historyConsumed, waveTier, waveStyle, maxRows, onEditorRows, onMenuRows }) {
+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;
 	const editorColumns = Math.max(1, columns - 6);
@@ -33190,10 +33931,13 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	const [draftImages, setDraftImages] = (0, import_react.useState)([]);
 	const draftImagesRef = (0, import_react.useRef)(draftImages);
 	draftImagesRef.current = draftImages;
+	const [draftFiles, setDraftFiles] = (0, import_react.useState)([]);
+	const draftFilesRef = (0, import_react.useRef)(draftFiles);
+	draftFilesRef.current = draftFiles;
 	const [preparingImages, setPreparingImages] = (0, import_react.useState)(false);
 	const prepareAbortRef = (0, import_react.useRef)(void 0);
 	const prepareEpochRef = (0, import_react.useRef)(0);
-	const { visible: cursorVisible, reset: resetCursorBlink } = useCursorBlink(active && !frozen && !preparingImages);
+	const { visible: cursorVisible, reset: resetCursorBlink } = useCursorBlink(active && !frozen && !preparingImages && animations);
 	(0, import_react.useEffect)(() => () => {
 		prepareEpochRef.current += 1;
 		prepareAbortRef.current?.abort();
@@ -33217,6 +33961,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		const safe = sanitizeDraftText(historyFill.text);
 		draftImagesRef.current = [];
 		setDraftImages([]);
+		draftFilesRef.current = [];
+		setDraftFiles([]);
 		valueRef.current = safe;
 		cursorRef.current = safe.length;
 		setValue(safe);
@@ -33243,6 +33989,11 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			draftImagesRef.current = next;
 			return next.length === current.length ? current : next;
 		});
+		setDraftFiles((current) => {
+			const next = current.filter((file) => value.includes(file.marker));
+			draftFilesRef.current = next;
+			return next.length === current.length ? current : next;
+		});
 	}, [value]);
 	(0, import_react.useEffect)(() => {
 		if (stdin === void 0) return;
@@ -33286,12 +34037,14 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	const [mentionError, setMentionError] = (0, import_react.useState)(void 0);
 	const mentionRequestRef = (0, import_react.useRef)(0);
 	const sameImagePath = (left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
-	const uniqueImageMarker = (name, source, reserved = []) => {
+	const uniqueImageMarker = (name, source, reserved = [], kind = "image") => {
 		const safeName = singleLineText(sanitizeDraftText(name));
-		let marker = source === "mention" ? `@${safeName}` : `[image: ${safeName}]`;
+		const label = kind === "file" ? "file" : "image";
+		let marker = source === "mention" ? `@${safeName}` : `[${label}: ${safeName}]`;
 		let suffix = 2;
-		while (valueRef.current.includes(marker) || draftImagesRef.current.some((image) => image.marker === marker) || reserved.includes(marker)) {
-			marker = source === "mention" ? `@${safeName} (${suffix})` : `[image: ${safeName} ${suffix}]`;
+		const taken = (candidate) => valueRef.current.includes(candidate) || draftImagesRef.current.some((image) => image.marker === candidate) || draftFilesRef.current.some((file) => file.marker === candidate) || reserved.includes(candidate);
+		while (taken(marker)) {
+			marker = source === "mention" ? `@${safeName} (${suffix})` : `[${label}: ${safeName} ${suffix}]`;
 			suffix += 1;
 		}
 		return marker;
@@ -33309,24 +34062,41 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		setDraftImages(next);
 		return true;
 	};
-	const insertDroppedImages = (paths) => {
+	/**
+	* Attach a paste/drop split into image and non-image paths: images ride the
+	* durable image blocks, files ride the 0.1.5 file blocks, and both register
+	* visible draft markers anchored at the drop point.
+	*/
+	const insertDroppedAttachments = (imagePaths, filePaths) => {
 		const originalValue = valueRef.current;
 		const originalCursor = cursorRef.current;
-		notify(`checking ${paths.length} image${paths.length === 1 ? "" : "s"}…`);
-		inspectImages(paths).then((inspected) => {
-			const additions = [];
+		const total = imagePaths.length + filePaths.length;
+		if (total === 0) return;
+		notify(`checking ${total} attachment${total === 1 ? "" : "s"}…`);
+		Promise.all([imagePaths.length === 0 ? Promise.resolve([]) : inspectImages(imagePaths), filePaths.length === 0 ? Promise.resolve([]) : inspectFiles(filePaths)]).then(([inspectedImages, inspectedFiles]) => {
+			const imageAdditions = [];
+			const fileAdditions = [];
 			const markers = [];
-			for (const inspection of inspected) {
-				if ([...draftImagesRef.current, ...additions].some((image) => sameImagePath(image.path, inspection.path))) continue;
+			for (const inspection of inspectedImages) {
+				if ([...draftImagesRef.current, ...imageAdditions].some((image) => sameImagePath(image.path, inspection.path))) continue;
 				const marker = uniqueImageMarker(inspection.name, "drop", markers);
-				additions.push({
+				imageAdditions.push({
+					...inspection,
+					marker
+				});
+				markers.push(marker);
+			}
+			for (const inspection of inspectedFiles) {
+				if ([...draftFilesRef.current, ...fileAdditions].some((file) => sameImagePath(file.path, inspection.path))) continue;
+				const marker = uniqueImageMarker(inspection.name, "drop", markers, "file");
+				fileAdditions.push({
 					...inspection,
 					marker
 				});
 				markers.push(marker);
 			}
-			if (additions.length === 0) {
-				notify("those images are already attached", "warning");
+			if (imageAdditions.length === 0 && fileAdditions.length === 0) {
+				notify("those attachments are already attached", "warning");
 				return;
 			}
 			const current = valueRef.current;
@@ -33335,7 +34105,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				end: originalCursor
 			});
 			if (anchor === void 0) {
-				notify("draft changed at the image drop point; drop the images again", "warning");
+				notify("draft changed at the attachment drop point; drop the files again", "warning");
 				return;
 			}
 			const at = anchor.start;
@@ -33347,12 +34117,16 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			setValue(edit.value);
 			setCursor(nextCursor);
 			resetCursorBlink();
-			const nextImages = [...draftImagesRef.current, ...additions];
+			const nextImages = [...draftImagesRef.current, ...imageAdditions];
 			draftImagesRef.current = nextImages;
 			setDraftImages(nextImages);
-			notify(`${additions.length} image${additions.length === 1 ? "" : "s"} ready for the next message`);
+			const nextFiles = [...draftFilesRef.current, ...fileAdditions];
+			draftFilesRef.current = nextFiles;
+			setDraftFiles(nextFiles);
+			const count = imageAdditions.length + fileAdditions.length;
+			notify(`${count} attachment${count === 1 ? "" : "s"} ready for the next message`);
 		}, (reason) => {
-			notify(`image attachment failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
+			notify(`attachment failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
 		});
 	};
 	(0, import_react.useEffect)(() => {
@@ -33387,7 +34161,16 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	]);
 	const menuActive = !preparingImages && (slashActive || mentionActive) && dismissedMenuValue !== value;
 	const visibleMentionRows = mentionToken !== void 0 && isPathLikeMentionQuery(mentionToken.query) ? mentionRows.filter((row) => row.kind !== "session") : mentionRows;
-	const menuRows = mentionActive ? visibleMentionRows.map((row) => ({
+	let rankedMentionRows = visibleMentionRows;
+	if (mentionToken !== void 0 && !isPathLikeMentionQuery(mentionToken.query) && mentionToken.query !== "") {
+		const hits = rankByName(visibleMentionRows.map((row) => ({
+			name: row.label.replace(/^@/u, ""),
+			row
+		})), mentionToken.query).map((entry) => entry.row);
+		const hitSet = new Set(hits);
+		rankedMentionRows = [...hits, ...visibleMentionRows.filter((row) => !hitSet.has(row))];
+	}
+	const menuRows = mentionActive ? rankedMentionRows.map((row) => ({
 		label: row.label.startsWith("@") ? row.label : `@${row.label}${row.kind === "directory" ? "/" : ""}`,
 		description: row.description,
 		origin: "mention"
@@ -33396,8 +34179,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 	/** Accept the highlighted completion-menu candidate into the draft. */
 	const acceptMenuCandidate = () => {
 		if (mentionActive && mentionToken !== void 0) {
-			if (visibleMentionRows.length === 0) return;
-			const row = visibleMentionRows[completionIndex % visibleMentionRows.length];
+			if (rankedMentionRows.length === 0) return;
+			const row = rankedMentionRows[completionIndex % rankedMentionRows.length];
 			if (row !== void 0) {
 				if (row.kind === "file" && row.path !== void 0 && looksLikeImagePath(row.path)) {
 					const tokenText = value.slice(mentionToken.start, cursor);
@@ -33600,6 +34383,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				resetCursorBlink();
 				draftImagesRef.current = [];
 				setDraftImages([]);
+				draftFilesRef.current = [];
+				setDraftFiles([]);
 				setCompletionIndex(0);
 				setDismissedMenuValue(void 0);
 			} else quit();
@@ -33645,15 +34430,19 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 			}
 			const trimmed = liveValue.trim();
 			const text = submissionPayload(liveValue);
-			if (draftImagesRef.current.length > 0) {
+			if (draftImagesRef.current.length > 0 || draftFilesRef.current.length > 0) {
+				if (isSlashLine(text)) notify("commands cannot carry attachments; the line will be sent to the model as a prompt", "warning");
+				const originSession = sessionKey;
 				const controller = new AbortController();
 				const epoch = prepareEpochRef.current + 1;
 				prepareEpochRef.current = epoch;
 				prepareAbortRef.current = controller;
 				setPreparingImages(true);
-				notify(`processing ${draftImagesRef.current.length} image${draftImagesRef.current.length === 1 ? "" : "s"}…`);
-				const snapshot = draftImagesRef.current;
-				prepareImages(snapshot.map((image) => image.path), controller.signal).then((images) => {
+				const imageSnapshot = draftImagesRef.current;
+				const fileSnapshot = draftFilesRef.current;
+				const total = imageSnapshot.length + fileSnapshot.length;
+				notify(`processing ${total} attachment${total === 1 ? "" : "s"}…`);
+				Promise.all([imageSnapshot.length === 0 ? Promise.resolve([]) : prepareImages(imageSnapshot.map((image) => image.path), controller.signal), fileSnapshot.length === 0 ? Promise.resolve([]) : prepareFiles(fileSnapshot.map((file) => file.path), controller.signal)]).then(([images, files]) => {
 					if (controller.signal.aborted || prepareEpochRef.current !== epoch) return;
 					prepareAbortRef.current = void 0;
 					setPreparingImages(false);
@@ -33663,6 +34452,8 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 					setCursor(0);
 					draftImagesRef.current = [];
 					setDraftImages([]);
+					draftFilesRef.current = [];
+					setDraftFiles([]);
 					setCompletionIndex(0);
 					setDismissedMenuValue(void 0);
 					dismissNotice();
@@ -33671,13 +34462,14 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 						recordHistory(text);
 					}
 					recall.current = beginRecall(recallSpace, "");
-					if (busy) steer(text, images);
-					else dispatch(text, images);
+					const blocks = [...images, ...files];
+					if (busy) steer(text, blocks, originSession);
+					else dispatch(text, blocks, originSession);
 				}, (reason) => {
 					if (controller.signal.aborted || prepareEpochRef.current !== epoch) return;
 					prepareAbortRef.current = void 0;
 					setPreparingImages(false);
-					notify(`image submission failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
+					notify(`attachment submission failed: ${reason instanceof Error ? reason.message : String(reason)}`, "error");
 				});
 				return;
 			}
@@ -33784,6 +34576,13 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				openTheme();
 				return;
 			}
+			if (text === "/animation" || text.startsWith("/animation ")) {
+				const parsed = parseAnimationsArgument(text.slice(10));
+				if (parsed === "toggle") applyAnimations(!animations);
+				else if (parsed === "usage") notify("usage: /animation [on|off]", "info");
+				else applyAnimations(parsed.enabled);
+				return;
+			}
 			if (text === "/history") {
 				openHistory();
 				return;
@@ -33925,48 +34724,26 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 				text = text.replaceAll(PASTE_END_MARKER, "");
 			}
 			if (text === "") return;
-			const droppedPaths = text.length > 1 ? parsePastedImagePaths(text) : [];
-			if (droppedPaths.length > 0) {
-				insertDroppedImages(droppedPaths);
-				return;
+			if (text.length > 1) {
+				const dropped = parsePastedAttachmentPaths(text);
+				if (dropped.images.length > 0 || dropped.files.length > 0) {
+					insertDroppedAttachments(dropped.images, dropped.files);
+					return;
+				}
 			}
 			applyEdit(insertText(valueRef.current, cursorRef.current, text));
 		}
 	}, active);
-	const [waveTick, setWaveTick] = (0, import_react.useState)(null);
-	const wavePrevious = (0, import_react.useRef)({
-		tier: null,
-		style: null
-	});
-	(0, import_react.useEffect)(() => {
-		const previous = wavePrevious.current;
-		wavePrevious.current = {
-			tier: waveTier,
-			style: waveStyle
-		};
-		if (waveTier === null) {
-			setWaveTick(null);
-			return;
-		}
-		if (previous.tier !== waveTier || previous.style !== waveStyle) setWaveTick(0);
-	}, [waveTier, waveStyle]);
-	const waveActive = !preparingImages && waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 < deepseekWaveDuration(waveTier, waveStyle);
-	(0, import_react.useEffect)(() => {
-		if (!waveActive) return;
-		const id = setInterval(() => {
-			setWaveTick((current) => current === null ? 0 : current + 1);
-		}, 33);
-		return () => {
-			clearInterval(id);
-		};
-	}, [waveActive]);
+	const waveKey = waveTier !== null && waveStyle !== null ? `${waveTier}:${waveStyle}` : null;
+	const [wavePlayedKey, setWavePlayedKey] = (0, import_react.useState)(null);
 	(0, import_react.useEffect)(() => {
-		if (waveTick !== null && waveTier !== null && waveStyle !== null && waveTick * 33 >= deepseekWaveDuration(waveTier, waveStyle)) setWaveTick(null);
+		if (!animations && waveKey !== null && waveKey !== wavePlayedKey) setWavePlayedKey(waveKey);
 	}, [
-		waveTick,
-		waveTier,
-		waveStyle
+		animations,
+		waveKey,
+		wavePlayedKey
 	]);
+	const waveArmed = waveKey !== null && waveKey !== wavePlayedKey;
 	const tierActive = waveTier !== null;
 	const tierHues = waveTier === null ? null : deepseekWaveHues(waveTier);
 	const promptColor = tierHues === null ? inkColor(getPalette().brand) : inkColor(tierHues[0]);
@@ -34038,7 +34815,7 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		}, index === 0 ? preparingImages ? (0, import_react.createElement)(Text, {
 			color: inkColor(getPalette().warn),
 			bold: true
-		}, "… ") : busy ? (0, import_react.createElement)(BusyChase) : (0, import_react.createElement)(Text, {
+		}, "… ") : busy ? (0, import_react.createElement)(BusyChase, { animated: animations }) : (0, import_react.createElement)(Text, {
 			color: promptColor,
 			bold: tierActive ? true : void 0
 		}, `${promptGlyph} `) : "  ", parts.before, parts.hasCaret ? (0, import_react.createElement)(Text, {
@@ -34047,100 +34824,26 @@ function Input({ active, frozen, busy, descriptors, skills, dispatch, steer, int
 		}, parts.caret) : null, placeholder ? (0, import_react.createElement)(Text, { dimColor: true }, COMPOSER_PLACEHOLDER) : parts.after, bandFill(consumed)));
 	}
 	const staticEditor = (0, import_react.createElement)(Box, { flexDirection: "column" }, ...editorRows);
-	const waveRow = () => {
-		const hues = deepseekWaveHues(waveTier);
-		const style = waveStyle;
-		const bandRgb = getPalette().composerBand;
-		const visibleRows = editorViewModel.rows.slice(editorWindowStart, editorWindowStart + editorWindowRows);
-		const totalBandRows = visibleRows.length + 2;
-		const waveBg = (row, column) => {
-			const rgb = deepseekWaveColumnBg(waveTick, column, bandWidth, waveTier, style, hues, bandRgb, row, totalBandRows);
-			return rgb === null ? bandBg : inkColor(rgb);
-		};
-		const blankBandRow = (row) => {
-			const blanks = [];
-			for (let column = 0; column < bandWidth; column += 1) blanks.push({
-				char: " ",
-				width: 1,
-				backgroundColor: waveBg(row, column)
-			});
-			return (0, import_react.createElement)(Text, { key: `blank-${row}` }, ...waveRowSpans(blanks));
-		};
-		const cellIndexAtColumn = (cells, target) => {
-			let column = 0;
-			for (let index = 0; index < cells.length; index += 1) {
-				if (column === target) return index;
-				column += cells[index].width ?? visibleColumns(cells[index].char);
-				if (column > target) return void 0;
-			}
-		};
-		const editorWaveRows = visibleRows.map((row, visibleIndex) => {
-			const sourceIndex = editorWindowStart + visibleIndex;
-			const bandRow = visibleIndex + 1;
-			const parts = editorRowParts(row, sourceIndex, caret.row, clampedCursor);
-			const placeholder = sourceIndex === 0 && value === "" && !busy;
-			const cells = [];
-			let usedColumns = 0;
-			const push = (char, extra = {}) => {
-				const width = visibleColumns(char);
-				cells.push({
-					char,
-					width,
-					backgroundColor: waveBg(bandRow, usedColumns),
-					...extra
-				});
-				usedColumns += width;
-			};
-			if (sourceIndex === 0) {
-				push(promptGlyph, {
-					color: promptColor,
-					bold: true
-				});
-				push(" ", { color: promptColor });
-			} else {
-				push(" ");
-				push(" ");
-			}
-			for (const span of splitGraphemes(parts.before)) push(span.text);
-			if (parts.hasCaret) push(parts.caret, { inverse: cursorVisible });
-			const tail = placeholder ? COMPOSER_PLACEHOLDER : parts.after;
-			for (const span of splitGraphemes(tail)) push(span.text, placeholder ? { dim: true } : {});
-			while (usedColumns < bandWidth) push(" ");
-			const middleBandRow = Math.floor(totalBandRows / 2);
-			if (bandRow === middleBandRow && deepseekWaveWordVisible(waveTick, waveTier, style)) {
-				const word = waveTier === "unknown" ? "Into the Unknown" : "deepseek";
-				const start = Math.max(2, Math.floor((bandWidth - word.length) / 2));
-				const indices = Array.from({ length: word.length }, (_, at) => cellIndexAtColumn(cells, start + at));
-				if (indices.every((index) => index !== void 0 && (cells[index].char === " " || cells[index].dim === true))) for (let at = 0; at < word.length; at += 1) {
-					const cell = cells[indices[at]];
-					cell.char = word[at];
-					cell.width = 1;
-					cell.color = inkColor(deepseekWaveWordHue(at, hues));
-					cell.bold = true;
-					cell.dim = false;
-				}
-			}
-			if (bandRow === middleBandRow && (waveTier === "deepseek" || waveTier === "unknown") && style === "wave") {
-				const spark = deepseekWaveSpark(waveTick);
-				const lastIndex = cellIndexAtColumn(cells, bandWidth - 1);
-				if (spark !== null && lastIndex !== void 0 && cells[lastIndex].char === " ") {
-					cells[lastIndex].char = spark;
-					cells[lastIndex].color = promptColor;
-					cells[lastIndex].bold = true;
-					cells[lastIndex].dim = false;
-				}
-			}
-			return (0, import_react.createElement)(Text, {
-				key: `editor-${sourceIndex}`,
-				wrap: "truncate-end"
-			}, ...waveRowSpans(cells));
-		});
-		return (0, import_react.createElement)(Box, {
-			flexDirection: "column",
-			width: bandWidth
-		}, blankBandRow(0), ...editorWaveRows, blankBandRow(totalBandRows - 1));
-	};
-	return (0, import_react.createElement)(Box, { flexDirection: "column" }, menu, waveTick !== null && waveTier !== null && waveStyle !== null && !busy && !preparingImages ? waveRow() : band(staticEditor));
+	return (0, import_react.createElement)(Box, { flexDirection: "column" }, menu, (0, import_react.createElement)(ComposerWave, {
+		key: waveKey ?? "static",
+		tier: waveTier ?? "deepseek",
+		style: waveStyle ?? "wave",
+		active: waveTier !== null && waveStyle !== null && !busy && !preparingImages && animations && waveArmed,
+		onSettled: () => {
+			if (waveKey !== null) setWavePlayedKey(waveKey);
+		},
+		fallback: band(staticEditor),
+		bandWidth,
+		bandBg,
+		rows: editorViewModel.rows.slice(editorWindowStart, editorWindowStart + editorWindowRows),
+		windowStart: editorWindowStart,
+		caretRow: caret.row,
+		cursor: clampedCursor,
+		caretVisible: cursorVisible,
+		value,
+		promptGlyph,
+		promptColor
+	}));
 }
 /** Build one settled row (row Box plus its roomy-prompt spacers and row count). */
 function buildSettledRow(entry, index, showReasoning, columns) {
@@ -34318,12 +35021,19 @@ function App(props) {
 	* to static while the prompt marker keeps the tier accent. The trigger
 	* follows the applied model label (what the status bar actually shows),
 	* never the initial paint, and the tier is derived from the label and
-	* cached at the switch. The 33ms tick itself lives inside Input, so the
-	* sweep re-renders only the composer band, not the whole tree, at 30fps;
-	* App owns the rarely-changing tier/style and Input starts the sweep
-	* whenever that pair changes. */
+	* cached at the switch. The 33ms tick itself lives inside the ComposerWave
+	* leaf, so the sweep re-renders only the composer band, not the whole tree,
+	* at 30fps; App owns the rarely-changing tier/style and the leaf plays the
+	* sweep exactly ONCE per pair change — an unchanged model+effort pair
+	* (ordinary turns, image preparation, /animation toggles) never replays. */
 	const [waveTier, setWaveTier] = (0, import_react.useState)(null);
 	const [waveStyle, setWaveStyle] = (0, import_react.useState)(null);
+	const [animations, setAnimations] = (0, import_react.useState)(props.animations ?? true);
+	const applyAnimations = (enabled) => {
+		setAnimations(enabled);
+		props.saveAnimations?.(enabled);
+		notify(`animations ${enabled ? "on" : "off"}`);
+	};
 	const previousModel = (0, import_react.useRef)(void 0);
 	const previousEffort = (0, import_react.useRef)(props.effort);
 	const previousStyle = (0, import_react.useRef)(void 0);
@@ -34883,7 +35593,10 @@ function App(props) {
 		continuationPrefix: "  ",
 		dim: true,
 		maxRows: auditedReasoningRows
-	}) : view.streaming === "" ? (0, import_react.createElement)(ShimmerLine, { text: "✻ Thinking… (Ctrl/Alt+R to expand)" }) : (0, import_react.createElement)(StreamTail, {
+	}) : view.streaming === "" ? (0, import_react.createElement)(ShimmerLine, {
+		text: "✻ Thinking… (Ctrl/Alt+R to expand)",
+		animated: animations
+	}) : (0, import_react.createElement)(StreamTail, {
 		text: "Thinking… (Ctrl/Alt+R to expand)",
 		prefix: "✻ ",
 		continuationPrefix: "  ",
@@ -34894,7 +35607,10 @@ function App(props) {
 		dim: false,
 		maxRows: auditedAnswerRows,
 		prefix: "  "
-	}, busy ? (0, import_react.createElement)(Caret) : void 0) : void 0, deepDivingVisible ? (0, import_react.createElement)(DeepDivingLine, { since: view.busySince }) : void 0) : void 0, transcriptVisible ? (0, import_react.createElement)(TodoPanel, { todos: view.todos }) : void 0, transcriptVisible ? (0, import_react.createElement)(AgentsLine, {
+	}, busy ? (0, import_react.createElement)(Caret, { animated: animations }) : void 0) : void 0, deepDivingVisible ? (0, import_react.createElement)(DeepDivingLine, {
+		since: view.busySince,
+		animated: animations
+	}) : void 0) : void 0, transcriptVisible ? (0, import_react.createElement)(TodoPanel, { todos: view.todos }) : void 0, transcriptVisible ? (0, import_react.createElement)(AgentsLine, {
 		rows: agentRows,
 		total: props.subagents.getTotalSeen()
 	}) : void 0, todosOpen && !approvalPending && !questionPending ? (0, import_react.createElement)(MemoTodoListPanel, {
@@ -35132,6 +35848,9 @@ function App(props) {
 		loadMentions: props.loadMentions,
 		inspectImages: props.inspectImages,
 		prepareImages: props.prepareImages,
+		inspectFiles: props.inspectFiles,
+		prepareFiles: props.prepareFiles,
+		sessionKey: props.sessionKey,
 		cyclePermission: props.cyclePermission,
 		exportTranscript: props.exportTranscript,
 		renameTitle: props.renameTitle,
@@ -35143,6 +35862,8 @@ function App(props) {
 		cancelQueued: props.cancelQueued,
 		historyFill,
 		historyConsumed,
+		animations,
+		applyAnimations,
 		waveTier,
 		waveStyle,
 		maxRows: composerEditorCap,
@@ -35420,26 +36141,36 @@ const internals = {
 	mount: (element) => {
 		const keyboardEnhanced = shouldEnableKeyboardEnhancement();
 		const focusReporting = isVsCodeTerminalEnv();
-		process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : "") + BRACKETED_PASTE_ENABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ""));
-		const tuiStdin = createSplitStdin(process.stdin);
-		const instance = render(element, {
-			exitOnCtrlC: false,
-			stdin: tuiStdin.stdin,
-			stdout: process.stdout
-		});
-		return {
-			rerender(element) {
-				instance.rerender(element);
-			},
-			unmount() {
-				try {
-					instance.unmount();
-				} finally {
-					tuiStdin.dispose();
-					process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : "") + BRACKETED_PASTE_DISABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ""));
+		if (process.stdin.isTTY === true) process.stdin.setRawMode?.(true);
+		try {
+			process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : "") + BRACKETED_PASTE_ENABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ""));
+			const tuiStdin = createSplitStdin(process.stdin);
+			const instance = render(element, {
+				exitOnCtrlC: false,
+				stdin: tuiStdin.stdin,
+				stdout: process.stdout
+			});
+			return {
+				rerender(element) {
+					instance.rerender(element);
+				},
+				unmount() {
+					try {
+						process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : "") + BRACKETED_PASTE_DISABLE + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ""));
+					} finally {
+						try {
+							instance.unmount();
+						} finally {
+							tuiStdin.dispose();
+							if (process.stdin.isTTY === true) process.stdin.setRawMode?.(false);
+						}
+					}
 				}
-			}
-		};
+			};
+		} catch (error) {
+			if (process.stdin.isTTY === true) process.stdin.setRawMode?.(false);
+			throw error;
+		}
 	},
 	stderr: process.stderr
 };
@@ -35789,13 +36520,15 @@ async function syncModelCapabilities(ctx, notify) {
 //#region src/questions.ts
 const ABORT_ERROR = new UserQuestionError("ask_user_question was interrupted before the user answered", "ASK_ABORTED");
 /**
-* Mount the single `ctx.userQuestions` UI provider over a FIFO queue.
-* @param ctx - context carrying the `userQuestions` service (dsh-base).
-* @returns the store the renderer subscribes to; a context without the
-* service yields a permanently empty store.
+* Mount the `user-questions/request` answerer over a FIFO queue.
+* @param ctx - plugin context whose event bus carries the waterfall.
+* @param owns - agents this terminal answers for; every other request is
+* deferred back into the waterfall (`next()`), so sibling answerers stay
+* usable. Agent-less asks are claimed: this TUI is the only human surface
+* in the process.
+* @returns the store the renderer subscribes to.
 */
-function mountQuestionProvider(ctx) {
-	const service = ctx.get("userQuestions");
+function mountQuestionProvider(ctx, owns) {
 	let snapshot = { pending: void 0 };
 	let active;
 	const queue = [];
@@ -35810,54 +36543,40 @@ function mountQuestionProvider(ctx) {
 		active = next;
 		set({ pending: next });
 	};
-	if (service !== void 0) {
-		if (typeof service.registerProvider !== "function") return {
-			subscribe(listener) {
-				listeners.add(listener);
-				return () => {
-					listeners.delete(listener);
-				};
-			},
-			getSnapshot() {
-				return snapshot;
-			},
-			submit() {},
-			cancel() {}
-		};
-		service.registerProvider({ ask(request) {
-			return new Promise((resolve, reject) => {
-				const onAbort = () => {
-					if (active === pending) {
-						active = void 0;
-						set({ pending: void 0 });
-						advance();
-					} else {
-						const at = queue.indexOf(pending);
-						if (at >= 0) queue.splice(at, 1);
-					}
-					reject(ABORT_ERROR);
-				};
-				const detachAbort = () => {
-					if (request.signal !== void 0) request.signal.removeEventListener("abort", onAbort);
-				};
-				const pending = {
-					request,
-					resolve,
-					reject,
-					detachAbort
-				};
-				if (request.signal?.aborted === true) {
-					reject(ABORT_ERROR);
-					return;
+	ctx.on("user-questions/request", (request, next) => {
+		if (request.agent !== void 0 && !owns(request.agent)) return next();
+		return new Promise((resolve, reject) => {
+			const onAbort = () => {
+				if (active === pending) {
+					active = void 0;
+					set({ pending: void 0 });
+					advance();
+				} else {
+					const at = queue.indexOf(pending);
+					if (at >= 0) queue.splice(at, 1);
 				}
-				request.signal?.addEventListener("abort", onAbort, { once: true });
-				if (active === void 0) {
-					active = pending;
-					set({ pending });
-				} else queue.push(pending);
-			});
-		} });
-	}
+				reject(ABORT_ERROR);
+			};
+			const detachAbort = () => {
+				if (request.signal !== void 0) request.signal.removeEventListener("abort", onAbort);
+			};
+			const pending = {
+				request,
+				resolve,
+				reject,
+				detachAbort
+			};
+			if (request.signal?.aborted === true) {
+				reject(ABORT_ERROR);
+				return;
+			}
+			request.signal?.addEventListener("abort", onAbort, { once: true });
+			if (active === void 0) {
+				active = pending;
+				set({ pending });
+			} else queue.push(pending);
+		});
+	});
 	return {
 		subscribe(listener) {
 			listeners.add(listener);
@@ -35908,6 +36627,7 @@ function createTranscriptStore(replay) {
 	const listeners = /* @__PURE__ */ new Set();
 	let scheduled = false;
 	let lastNotifyAt = 0;
+	const attemptKeys = /* @__PURE__ */ new Map();
 	const notify = () => {
 		if (scheduled) return;
 		scheduled = true;
@@ -35939,8 +36659,28 @@ function createTranscriptStore(replay) {
 			dirty = true;
 			notify();
 		},
+		applyStreamFrame(frame) {
+			if (frame.type === "start") {
+				attemptKeys.set(frame.attemptId, `${frame.turn}:${frame.step}`);
+				return;
+			}
+			if (frame.type === "chunk") {
+				const key = attemptKeys.get(frame.attemptId);
+				if (key === void 0) return;
+				if (!applyAssistantStreamChunk(acc, key, frame.time, frame.chunk)) return;
+				dirty = true;
+				notify();
+				return;
+			}
+			attemptKeys.delete(frame.attemptId);
+			if (frame.outcome.kind === "abandoned" && clearAssistantStream(acc)) {
+				dirty = true;
+				notify();
+			}
+		},
 		reset() {
 			acc = createReplayAccumulator();
+			attemptKeys.clear();
 			dirty = true;
 			notify();
 		}
@@ -36008,12 +36748,27 @@ function foldSubagentRow(previous, sessionId, event) {
 			activity: "prompted",
 			updatedAt: event.time
 		};
-		case "assistant/chunk": return {
+		case "assistant/attempt": return {
 			...base,
 			state: "running",
 			activity: "thinking…",
 			updatedAt: event.time
 		};
+		case "subagent/catalog": {
+			const mode = event.data.mode === "continuable" ? "continuable" : "one-shot";
+			const label = event.data.label !== void 0 && event.data.label.trim() !== "" ? bound(event.data.label) : void 0;
+			const nextLabel = label === void 0 ? base.label : label;
+			const activity = label === void 0 ? `catalog · ${mode}` : `catalog · ${mode} · ${label}`;
+			const state = previous === void 0 ? "idle" : base.state;
+			if (nextLabel === base.label && state === base.state && activity === base.activity) return base;
+			return {
+				...base,
+				state,
+				label: nextLabel,
+				activity,
+				updatedAt: event.time
+			};
+		}
 		case "assistant/message": return {
 			...base,
 			state: "idle",
@@ -36089,7 +36844,7 @@ function createSubagentFeed() {
 			const counted = !seen.has(sessionId);
 			if (counted) seen.add(sessionId);
 			if (rows.length >= 8) {
-				const evict = rows.findIndex((row) => row.state === "done");
+				const evict = rows.findIndex((row) => row.state !== "running");
 				if (evict === -1) {
 					if (counted) notify();
 					return;
@@ -36149,8 +36904,8 @@ function watchSkills(ctx, fallbackCwd) {
 	const listeners = /* @__PURE__ */ new Set();
 	const reload = () => {
 		const target = agent;
-		if (skills === void 0 || target === void 0) return;
-		Promise.resolve().then(() => skills.list({
+		if (skills === void 0) return;
+		Promise.resolve().then(() => skills.list(target === void 0 ? { cwd: fallbackCwd } : {
 			cwd: target.session.header.cwd ?? fallbackCwd,
 			scope: target
 		})).then((summaries) => {
@@ -36165,13 +36920,18 @@ function watchSkills(ctx, fallbackCwd) {
 			for (const listener of listeners) listener();
 		}).catch((cause) => {
 			if (agent !== target) return;
+			const nextError = cause instanceof Error ? cause.message : String(cause);
 			if (loadedFor !== target) rows = [];
-			else rows = [...rows];
-			error = cause instanceof Error ? cause.message : String(cause);
+			const errorChanged = nextError !== error;
+			error = nextError;
+			if (!errorChanged) return;
 			for (const listener of listeners) listener();
 		});
 	};
-	if (skills !== void 0) ctx.on("skills/change", reload);
+	if (skills !== void 0) {
+		ctx.on("skills/change", reload);
+		reload();
+	}
 	return {
 		get rows() {
 			return rows;
@@ -36206,16 +36966,22 @@ function watchSkills(ctx, fallbackCwd) {
 * @param sessionId - the full session identity for the header.
 * @returns the complete markdown text.
 */
+/** Both user and queued rows export the same attachment label block. */
+const attachmentLabels = (entry) => [imageLabels(entry.images), fileLabels(entry.files)].filter((label) => label !== "").join("\n");
 function buildExportMarkdown(view, sessionId) {
 	const out = [
 		view.title === "" ? `# dsh session ${sessionId}` : `# ${view.title}`,
 		`> session ${sessionId}`,
 		""
 	];
+	if (view.systemPrompt !== "") out.push("<details><summary>system prompt</summary>", "", view.systemPrompt, "", "</details>", "");
 	for (const entry of view.entries) switch (entry.kind) {
 		case "user":
 			if (entry.notice) out.push(`> ⤷ context: ${entry.text}`, "");
-			else out.push("## user", "", entry.text, ...imageLabels(entry.images) === "" ? [] : [imageLabels(entry.images)], "");
+			else {
+				const attachments = attachmentLabels(entry);
+				out.push("## user", "", entry.text, ...attachments === "" ? [] : [attachments], "");
+			}
 			break;
 		case "assistant":
 			if (entry.reasoning !== "") out.push("<details><summary>thinking</summary>", "", entry.reasoning, "", "</details>", "");
@@ -36248,7 +37014,7 @@ function buildExportMarkdown(view, sessionId) {
 			out.push(`> files changed: ${entry.paths.join(", ")}`, "");
 			break;
 		case "pending":
-			out.push("## user", "", entry.text, ...imageLabels(entry.images) === "" ? [] : [imageLabels(entry.images)], "");
+			out.push("## user", "", entry.text, ...attachmentLabels(entry) === "" ? [] : [attachmentLabels(entry)], "");
 			break;
 		default: assertNever(entry, "transcript entry kind");
 	}
@@ -36633,7 +37399,12 @@ function selectForkSeed(events, atSeq) {
 }
 //#endregion
 //#region src/git-workflow.ts
-/** Read-only Git inspection used by /diff and /review. */
+/**
+* Read-only Git inspection used by /diff and /review. Every diff
+* invocation carries --no-ext-diff and --no-textconv, so configured
+* external diff drivers and text converters can never execute as a
+* side effect of reading a diff.
+*/
 /** Split Git's stable `diff --git` framing without interpreting patch content. */
 function parseGitDiffFiles(text) {
 	if (text === "") return [];
@@ -36656,6 +37427,7 @@ function parseGitDiffSpec(argument) {
 		args: [
 			"diff",
 			"--no-ext-diff",
+			"--no-textconv",
 			"--unified=3",
 			"HEAD",
 			"--"
@@ -36666,6 +37438,7 @@ function parseGitDiffSpec(argument) {
 		args: [
 			"diff",
 			"--no-ext-diff",
+			"--no-textconv",
 			"--unified=3",
 			"--cached",
 			"--"
@@ -36677,6 +37450,7 @@ function parseGitDiffSpec(argument) {
 		args: [
 			"diff",
 			"--no-ext-diff",
+			"--no-textconv",
 			"--unified=3",
 			value,
 			"--"
@@ -36700,8 +37474,25 @@ function executeGit(cwd, args, signal) {
 		});
 	});
 }
+/** Arguments for the unstaged-only fallback below. */
+const UNSTAGED_DIFF_ARGS = [
+	"diff",
+	"--no-ext-diff",
+	"--no-textconv",
+	"--unified=3",
+	"--"
+];
+/** Whether the repository has at least one commit (a HEAD revision). */
+function hasHeadRevision(cwd, signal) {
+	return executeGit(cwd, [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		"HEAD"
+	], signal).then(() => true).catch(() => false);
+}
 /**
-* Load one complete textual diff without invoking external diff drivers.
+* Load one complete textual diff without invoking external programs.
 * @param signal - aborted by the caller on session switches/quit, killing the
 * git subprocess instead of letting a stale repository's diff land later.
 */
@@ -36714,15 +37505,10 @@ async function loadGitDiff(cwd, argument, signal) {
 			files: parseGitDiffFiles(text)
 		};
 	} catch (error) {
-		if (argument.trim() !== "") throw error;
+		if (argument.trim() !== "" || signal?.aborted === true || await hasHeadRevision(cwd, signal)) throw error;
 		return {
-			title: "git diff - working tree",
-			files: parseGitDiffFiles(await executeGit(cwd, [
-				"diff",
-				"--no-ext-diff",
-				"--unified=3",
-				"--"
-			], signal))
+			title: "git diff - working tree (no commits yet)",
+			files: parseGitDiffFiles(await executeGit(cwd, UNSTAGED_DIFF_ARGS, signal))
 		};
 	}
 }
@@ -36797,16 +37583,24 @@ function agentPresetsFrom(ctx) {
 function isBlankSession(events) {
 	return !events.some((event) => event.type === "turn/start");
 }
+/** Upstream renamed the shipped `code` preset to `ptc` in 0.1.2-rc.1; sessions
+* and CLI choices recorded before the rename keep resolving through this map. */
+const LEGACY_PRESET_IDS = { code: "ptc" };
+function normalizePresetId(id) {
+	return id === void 0 ? void 0 : LEGACY_PRESET_IDS[id] ?? id;
+}
 /** Latest logged selection wins; legacy sessions deliberately fall back to standard. */
 function resolvePreset(session) {
-	for (let index = session.events.length - 1; index >= 0; index -= 1) {
-		const event = session.events[index];
-		if (event.type === "agent-preset/selected" && event.data?.agentPreset !== void 0) return event.data.agentPreset;
+	const events = session.snapshotEvents();
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (event.type === "agent-preset/selected" && event.data?.agentPreset !== void 0) return normalizePresetId(event.data.agentPreset);
 	}
-	return session.header.agentPreset ?? "standard";
+	return normalizePresetId(session.header.agentPreset) ?? "standard";
 }
 /** Resolve a pre-session choice, or recompose an active blank Agent. */
 async function selectPreset(service, agent, presetId) {
+	presetId = normalizePresetId(presetId);
 	if (agent !== void 0) return switchPreset(service, agent, presetId);
 	const preset = await service.resolve(presetId);
 	if (preset.broken !== void 0) throw new Error(preset.broken);
@@ -36814,7 +37608,7 @@ async function selectPreset(service, agent, presetId) {
 }
 /** Recompose atomically from the caller's perspective, logging only success. */
 async function switchPreset(service, agent, presetId) {
-	if (!isBlankSession(agent.session.events)) throw new Error("mode is locked after the first turn; use /new <mode>");
+	if (!isBlankSession(agent.session.snapshotEvents())) throw new Error("mode is locked after the first turn; use /new <mode>");
 	const preset = await service.recompose(agent.ctx, presetId);
 	agent.session.append("agent-preset/selected", { agentPreset: preset.id });
 	return preset;
@@ -36827,7 +37621,7 @@ function permissionPresetsFrom(ctx) {
 }
 /** Effective label for either an active session or the not-yet-created first one. */
 function effectivePermission(service, session, pending) {
-	return session === void 0 ? pending ?? service.defaultPreset : service.current(session.events);
+	return session === void 0 ? pending ?? service.defaultPreset : service.current(session);
 }
 /** Validate a preset and write it only when a durable session already exists. */
 function selectPermission(service, session, preset) {
@@ -36909,6 +37703,38 @@ function listPluginRows(ctx) {
 * @module @deepseek-ai/dsh-code/settings-file
 */
 /**
+* Run one file operation with a bounded retry: one initial try plus at
+* most `retries` more. Creating or replacing a file can fail transiently
+* with EPERM/EACCES while an antivirus scanner or search indexer holds
+* it — the standard graceful-fs remedy, not a workaround for a
+* persistent permission problem. A save that still fails leaves its
+* uniquely named temp file behind, so repeated crashed saves accumulate
+* distinct leftovers rather than corrupting a shared one.
+*/
+async function withTransientRetry(operation, retries = 5) {
+	for (let attempt = 0;; attempt += 1) try {
+		await operation();
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (attempt >= retries || code !== "EPERM" && code !== "EACCES") throw error;
+		await new Promise((resolve) => setTimeout(resolve, 30 * (attempt + 1)));
+	}
+}
+/**
+* Write one file atomically: create the parent directory, write to a
+* uniquely named temp file, and rename it into place. A crash midway
+* can never leave a half-written document behind. Unique temp names
+* keep concurrent writers (two terminals, two chains in one process)
+* from sharing one temp path.
+*/
+async function writeFileAtomically(path, text) {
+	await mkdir(dirname(path), { recursive: true });
+	const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	await withTransientRetry(() => writeFile(temp, text, "utf8"));
+	await withTransientRetry(() => rename(temp, path));
+}
+/**
 * Create the shared settings-write chain. One instance per process keeps
 * every user-level JSON file mutually serialized.
 * @returns the persistence handle.
@@ -36917,12 +37743,7 @@ function createUserSettingsPersistence() {
 	let chain = Promise.resolve();
 	return {
 		save(path, text) {
-			const write = chain.then(async () => {
-				await mkdir(dirname(path), { recursive: true });
-				const temp = `${path}.tmp`;
-				await writeFile(temp, text, "utf8");
-				await rename(temp, path);
-			});
+			const write = chain.then(() => writeFileAtomically(path, text));
 			chain = write.catch(() => {});
 			return write;
 		},
@@ -37044,6 +37865,17 @@ async function runQuitSequence(steps, exit, onError) {
 	return started;
 }
 /**
+* Whether a tagged submission still belongs to the active session. Attachment
+* prepares resolve on the microtask timeline, while a queued session switch
+* remounts the app asynchronously — the composing instance's unmount cleanup
+* runs too late to abort, so the delivery itself carries the composing
+* session's full id and the runner drops it here when the world moved on.
+* An untagged (synchronous) or pending-session ('') submission always passes.
+*/
+function submissionBelongsToSession(origin, activeSessionId) {
+	return origin === void 0 || origin === "" || origin === activeSessionId;
+}
+/**
 * 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
@@ -37094,7 +37926,7 @@ async function resolveTarget(startup, persistence, cwd) {
 	};
 	if (startup.kind === "named") {
 		if (persistence !== void 0) {
-			if ((await persistence.list()).some((header) => header.id === startup.sessionId)) throw new Error(`session "${startup.sessionId}" already exists; use --resume to continue it`);
+			if ((await persistence.list()).map((snapshot) => snapshot.header).some((header) => header.id === startup.sessionId)) throw new Error(`session "${startup.sessionId}" already exists; use --resume to continue it`);
 		}
 		return {
 			sessionId: startup.sessionId,
@@ -37103,7 +37935,7 @@ async function resolveTarget(startup, persistence, cwd) {
 		};
 	}
 	if (persistence === void 0) throw new Error("cannot resolve the requested session: session persistence is not configured");
-	const headers = await persistence.list();
+	const headers = (await persistence.list()).map((snapshot) => snapshot.header);
 	if (startup.kind === "resume") {
 		const matched = matchSessionId(headers, startup.sessionId);
 		if (isSubagentSession(matched)) throw new Error("subagent conversations are read-only; resume a root session");
@@ -37161,13 +37993,13 @@ async function run(ctx, startup, io) {
 		const nextCwd = next.cwd ?? cwd;
 		const selectionState = pendingSelection === void 0 ? {} : { picked: pendingSelection };
 		let mode = next.resume ? next.mode : next.mode ?? pendingMode;
-		if (!next.resume) mode = (await presets.resolve(mode)).id;
-		const setup = async (agentCtx) => {
-			const sessionPreset = next.resume ? resolvePreset(agentCtx.agent.session) : mode;
+		if (!next.resume) mode = (await presets.resolve(normalizePresetId(mode ?? presets.defaultId))).id;
+		const setup = async (agentCtx, agent) => {
+			const sessionPreset = next.resume ? resolvePreset(agent.session) : mode;
 			mode = (await presets.mount(agentCtx, sessionPreset)).id;
 			installModelSelection(agentCtx, {
 				get current() {
-					return resolveEffectiveSelection(selectionState.picked, agentCtx.agent?.session.requestHeader()?.config, currentDefaults());
+					return resolveEffectiveSelection(selectionState.picked, agent.session.requestHeader()?.config, currentDefaults());
 				},
 				set current(value) {
 					selectionState.picked = value;
@@ -37193,8 +38025,9 @@ async function run(ctx, startup, io) {
 				cwd: nextCwd,
 				agentPreset: mode,
 				...next.parentSession === void 0 ? {} : { parentSession: next.parentSession },
-				...next.seedLength === void 0 ? {} : { seedLength: next.seedLength }
+				...next.seedLength === void 0 ? {} : { isSeeded: true }
 			},
+			...next.seedLength === void 0 ? {} : { inheritedEventCount: SessionLogOffset(next.seedLength) },
 			...next.seed === void 0 ? {} : { seed: next.seed },
 			agentOptions: seedOptions,
 			signal: quitAbort.signal,
@@ -37206,7 +38039,7 @@ async function run(ctx, startup, io) {
 			handle,
 			agent: handle.agent,
 			session,
-			store: createTranscriptStore(session.events),
+			store: createTranscriptStore(session.snapshotEvents()),
 			mentions: createMentions(ctx, handle.agent, session.header.cwd ?? nextCwd),
 			mode: mode ?? "standard",
 			selection: selectionState,
@@ -37271,10 +38104,15 @@ async function run(ctx, startup, io) {
 		if (session === void 0) return;
 		if (subject.id === session.id) {
 			store.apply(event);
+			if (event.type === "subagent/catalog" && event.data.childId !== "") subagents.apply(event.data.childId, event);
 			return;
 		}
 		if (subject.header.parentSession === session.id && subject.header.origin === "subagent") subagents.apply(subject.id, event);
 	});
+	ctx.on("agent/assistant-stream", ({ agent: source, frame }) => {
+		if (agent === void 0 || source.id !== agent.id) return;
+		store.applyStreamFrame(frame);
+	});
 	const commands = watchCommands(ctx);
 	if (agent !== void 0) commands.setAgent(agent);
 	const skills = watchSkills(ctx, cwd);
@@ -37290,7 +38128,7 @@ async function run(ctx, startup, io) {
 		const picked = subagentOverride ?? resolveEffectiveSelection(belongsToActive && activeAgent !== void 0 ? activeAgent.selection.picked ?? pendingSelection : void 0, subject.session.requestHeader()?.config, currentDefaults());
 		return next().then((resolved) => applyModelSelectionToConfig(resolved, picked));
 	});
-	const questions = mountQuestionProvider(ctx);
+	const questions = mountQuestionProvider(ctx, (candidate) => agent !== void 0 && candidate.id === agent.id);
 	const bridge = { notify: () => {} };
 	const capabilitySyncDebounceMs = 400;
 	const runCapabilitySync = () => {
@@ -37346,19 +38184,42 @@ async function run(ctx, startup, io) {
 			bridge.notify("theme save failed: " + (writeError instanceof Error ? writeError.message : String(writeError)), "error");
 		});
 	};
+	const animationsPath = join(homedir(), ".dsh", "dsh-code", "animations.json");
+	let animationsEnabled = true;
+	let animationsWarning;
+	try {
+		animationsEnabled = parseAnimationsPref((JSON.parse(readFileSync(animationsPath, "utf8")) ?? {}).animations);
+	} catch (error) {
+		if (error.code !== "ENOENT") animationsWarning = error instanceof Error ? error.message : String(error);
+	}
+	const saveAnimations = (enabled) => {
+		settingsPersistence.save(animationsPath, JSON.stringify({ animations: enabled }, null, 2) + "\n").catch((writeError) => {
+			bridge.notify("animations save failed: " + (writeError instanceof Error ? writeError.message : String(writeError)), "error");
+		});
+	};
 	const historyPath = join(homedir(), ".dsh", "dsh-code", "history.jsonl");
 	let inputHistory = [];
+	let historyWriteChain = Promise.resolve();
 	try {
-		inputHistory = parseHistoryFile(readFileSync(historyPath, "utf8"));
+		const rawHistory = readFileSync(historyPath, "utf8");
+		inputHistory = parseHistoryFile(rawHistory);
+		if (needsCompaction(rawHistory)) historyWriteChain = historyWriteChain.then(() => writeFileAtomically(historyPath, serializeHistoryList(inputHistory))).catch(() => {});
 	} catch {
 		inputHistory = [];
 	}
-	/** Serialized history writes: each submission rewrites the latest in-memory snapshot. */
-	let historyWriteChain = Promise.resolve();
+	/**
+	* Serialized history writes: each submission appends one JSON line at the
+	* end of the file, so concurrent terminals add entries after each other
+	* instead of overwriting snapshots they read at their own boot. A
+	* multi-line draft still occupies one physical line (JSON escapes the
+	* newline), and a regular-length line reaches the disk as one positioned
+	* write; an oversized paste may interleave mid-line, which the next
+	* parse simply drops.
+	*/
 	const recordHistory = (text) => {
 		if (text === "") return;
 		inputHistory = [...inputHistory, text].slice(-100);
-		historyWriteChain = historyWriteChain.then(() => mkdir(dirname(historyPath), { recursive: true })).then(() => writeFile(historyPath, serializeHistoryList(inputHistory), "utf8")).catch((writeError) => {
+		historyWriteChain = historyWriteChain.then(() => mkdir(dirname(historyPath), { recursive: true })).then(() => appendFile(historyPath, historyLine(text), "utf8")).catch((writeError) => {
 			bridge.notify("history save failed: " + (writeError instanceof Error ? writeError.message : String(writeError)), "error");
 		});
 	};
@@ -37623,7 +38484,8 @@ async function run(ctx, startup, io) {
 		});
 	};
 	/** Dispatch one submitted line: slash commands to the registry, other text to the agent. */
-	const dispatch = (text, images = []) => {
+	const dispatch = (text, images = [], origin) => {
+		if (!submissionBelongsToSession(origin, session?.id)) return;
 		send(text, "followup", images);
 	};
 	/**
@@ -37631,7 +38493,8 @@ async function run(ctx, startup, io) {
 	* boundary (the inbox delivers between steps); an idle driver just starts
 	* a turn, so this doubles as the busy-state submit path.
 	*/
-	const steer = (text, images = []) => {
+	const steer = (text, images = [], origin) => {
+		if (!submissionBelongsToSession(origin, session?.id)) return;
 		send(text, "steer", images);
 	};
 	/** Interrupt the running turn (Esc); true when a turn was actually cancelled. */
@@ -37759,14 +38622,17 @@ async function run(ctx, startup, io) {
 	const loadSessions = async (options, signal) => {
 		if (sessionQuery === void 0) throw new Error("session query is unavailable in this profile");
 		const records = await sessionQuery.listSessions(signal);
+		const root = jsonlSessionRoot(persistence);
 		const updated = /* @__PURE__ */ new Map();
-		for (const record of records) {
-			const location = persistence?.locate(record.header);
-			if (location === void 0) continue;
+		if (root !== void 0) await Promise.all(records.map(async (record) => {
 			try {
-				updated.set(record.header.id, (await stat(location.path)).mtimeMs);
+				const dir = sessionDirectoryFor(root, record.header.cwd, record.header.id);
+				const entries = await readdir(dir, { withFileTypes: true });
+				const stats = await Promise.all(entries.filter((entry) => entry.isFile() && isSessionArtifactName(entry.name)).map((entry) => stat(join(dir, entry.name))));
+				const newest = Math.max(...stats.map((info) => info.mtimeMs));
+				if (Number.isFinite(newest)) updated.set(record.header.id, newest);
 			} catch {}
-		}
+		}));
 		const projected = projectSessionRows(records, options, updated);
 		const page = projected.slice(0, 32);
 		if (page.length === 0) return projected;
@@ -37782,11 +38648,11 @@ async function run(ctx, startup, io) {
 	* 1. `planSessionDeletion` collects the subtree and refuses when the root
 	*    or ANY member is live (a live child would outlive its deleted
 	*    parent), ordering the plan children-first.
-	* 2. Every plan node must locate to a guarded artifact directory
-	*    (`encodeSegment(id)`/`session.jsonl` layout). Backends without a
-	*    locatable artifact (SQLite) refuse the WHOLE deletion here — no
-	*    file has been touched yet, so a backend or layout surprise can
-	*    never strand a half-deleted subtree.
+	* 2. Every plan node must derive to a guarded artifact directory
+	*    (`encodeSegment(id)` layout beneath the backend's config root).
+	*    Backends without a derivable artifact (non-JSONL) refuse the WHOLE
+	*    deletion here — no file has been touched yet, so a backend or layout
+	*    surprise can never strand a half-deleted subtree.
 	* 3. Artifacts are removed children-first: only an I/O error mid-delete
 	*    can stop it short (reported with removed/total counts), leaving the
 	*    shallowest lineage intact.
@@ -37800,22 +38666,23 @@ async function run(ctx, startup, io) {
 		const records = await sessionQuery.listSessions();
 		const plan = planSessionDeletion(records, id);
 		if (!plan.ok) return plan.reason;
+		const root = jsonlSessionRoot(persistence);
+		if (root === void 0) return "session backend exposes no deletable artifact (deletion is unsupported on this backend)";
 		const byId = new Map(records.map((record) => [record.header.id, record]));
 		const dirs = /* @__PURE__ */ new Map();
 		for (const node of plan.nodes) {
 			const record = byId.get(node.id);
 			if (record === void 0) return `no persisted session matches "${node.id}"`;
-			const location = persistence?.locate(record.header);
-			if (location === void 0) return `session backend exposes no deletable artifact for ${node.id.slice(-12)} (deletion is unsupported on this backend)`;
-			const dir = sessionArtifactDirectory(location.path, node.id);
-			if (dir === void 0) return `refusing to delete: unexpected artifact layout at ${location.path}`;
+			const dir = sessionArtifactDirectory(sessionDirectoryFor(root, record.header.cwd, node.id), node.id);
+			if (dir === void 0) return `refusing to delete: unexpected artifact layout for ${node.id.slice(-12)}`;
 			dirs.set(node.id, dir);
 		}
 		let removed = 0;
 		for (const node of plan.nodes) {
 			const dir = dirs.get(node.id);
 			try {
-				for (const name of SESSION_ARTIFACT_NAMES) await rm(join(dir, name), { force: true });
+				const entries = await readdir(dir, { withFileTypes: true });
+				for (const entry of entries) if (entry.isFile() && isSessionArtifactName(entry.name)) await rm(join(dir, entry.name), { force: true });
 				await rm(dir, {
 					force: true,
 					recursive: false
@@ -37977,10 +38844,6 @@ async function run(ctx, startup, io) {
 	};
 	const reviewChanges = (argument) => {
 		const currentAgent = agent;
-		if (currentAgent === void 0) {
-			bridge.notify("no session yet - submit a message to start", "warning");
-			return;
-		}
 		const atEpoch = epoch;
 		const reviewCwd = session?.header.cwd ?? cwd;
 		const controller = new AbortController();
@@ -38014,7 +38877,7 @@ async function run(ctx, startup, io) {
 			const text = argument.trim();
 			const atSeq = text === "" ? void 0 : Number(text);
 			if (text !== "" && (!Number.isSafeInteger(atSeq) || (atSeq ?? -1) < 0)) throw new Error("usage: /fork [event-seq]");
-			const seed = selectForkSeed(session.events, atSeq);
+			const seed = selectForkSeed(session.snapshotEvents(), atSeq);
 			const id = `session-${randomUUID()}`;
 			requestSwitch({
 				target: {
@@ -38057,6 +38920,7 @@ async function run(ctx, startup, io) {
 		const permission = permissionPresets === void 0 ? currentView.permission : effectivePermission(permissionPresets, session, pendingPermission);
 		return (0, import_react.createElement)(App, {
 			key: session?.id ?? "pending",
+			sessionKey: session?.id ?? "",
 			store,
 			approval,
 			questions,
@@ -38070,7 +38934,7 @@ async function run(ctx, startup, io) {
 			branch: gitBranch(sessionCwd),
 			sessionId: session === void 0 ? "" : session.id.slice(-8),
 			resumed: active?.resumed ?? false,
-			mode: active?.mode ?? pendingMode ?? presets.defaultId,
+			mode: active?.mode ?? pendingMode ?? normalizePresetId(presets.defaultId),
 			permission,
 			dispatch,
 			steer,
@@ -38094,6 +38958,8 @@ async function run(ctx, startup, io) {
 			loadMentions: (query, signal) => mentions.candidates(query, signal),
 			inspectImages: (paths) => inspectImagePaths(paths, ctx.get("attachments"), session?.header.cwd ?? cwd),
 			prepareImages: (paths, signal) => saveImagePaths(paths, ctx.get("attachments"), signal),
+			inspectFiles: (paths) => inspectFilePaths(paths, ctx.get("attachments"), session?.header.cwd ?? cwd),
+			prepareFiles: (paths, signal) => saveFilePaths(paths, ctx.get("attachments"), signal),
 			cyclePermission: cyclePermission$1,
 			setPermission: setPermissionAction,
 			selectModel,
@@ -38132,6 +38998,8 @@ async function run(ctx, startup, io) {
 			saveStatusline,
 			applyEditorKeys,
 			saveTheme,
+			animations: animationsEnabled,
+			saveAnimations,
 			history: inputHistory,
 			recordHistory,
 			cancelQueued,
@@ -38170,6 +39038,9 @@ async function run(ctx, startup, io) {
 	if (themeWarning !== void 0) setTimeout(() => {
 		bridge.notify("theme config unreadable, using dark: " + themeWarning, "warning");
 	}, 50);
+	if (animationsWarning !== void 0) setTimeout(() => {
+		bridge.notify("animations config unreadable, animations stay on: " + animationsWarning, "warning");
+	}, 50);
 	resolveEditorKeysStartupHint(editorKeysEnv).then((hint) => {
 		if (hint === void 0) return;
 		setTimeout(() => {
@@ -38217,4 +39088,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, StartupInputGate, apply, exportSessionIdSuffix, inject, name, resolveTarget, runQuitSequence };
+export { Config, StartupInputGate, apply, exportSessionIdSuffix, inject, name, resolveTarget, runQuitSequence, submissionBelongsToSession };