scream-code 0.16.4 → 0.16.6

package/dist/{dispatch-La1sAZPF.mjs → dispatch-fjwbqaYI.mjs}

@@ -6,7 +6,7 @@ const __dirname = __cjsShimDirname(__filename);
 import { i as __require, o as __toESM, r as __exportAll, t as __commonJSMin } from "./chunk-D90kvbyJ.mjs";
 import { C as join$1, D as resolve$2, E as relative$1, S as isAbsolute$1, T as parse$7, a as isSupportedFile, b as basename$1, i as ingestFile, r as ingestDirectory, t as multiSearch, w as normalize$1, x as dirname$2, y as KnowledgeStore } from "./src-tDEINaMV.mjs";
 import { t as require_base64_js } from "./base64-js-DzVmk6Nb.mjs";
-import { a as setLocale, i as getLocale, n as assertScreamHostIdentity, o as t, r as createScreamDefaultHeaders, t as TextInputDialogComponent } from "./text-input-dialog--J3ngWFv.mjs";
+import { a as setLocale, i as getLocale, n as assertScreamHostIdentity, o as t, r as createScreamDefaultHeaders, t as TextInputDialogComponent } from "./text-input-dialog-DBlx8pMR.mjs";
 import { createRequire } from "node:module";
 import { createHash, randomBytes, randomInt, randomUUID } from "node:crypto";
 import * as fs$1 from "node:fs/promises";
@@ -33,6 +33,7 @@ import * as nodeOs from "node:os";
 import { homedir, release, tmpdir } from "node:os";
 import * as vs from "zlib";
 import Qr from "zlib";
+import { diffLines, diffWords } from "diff";
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import Pi from "assert";
@@ -52,7 +53,6 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import chalk from "chalk";
 import { Box, Container, Image, Input, Key, Markdown, Spacer, Text, decodeKittyPrintable, fuzzyFilter, getCapabilities, getImageDimensions, matchesKey, sliceByColumn, truncateToWidth, visibleWidth } from "@liutod-scream/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
-import { diffWords } from "diff";
 import { gt, valid } from "semver";
 //#region ../../packages/agent-core/src/errors/codes.ts
 /**
@@ -48278,10 +48278,25 @@ var BackgroundProcessManager = class {
 		const outputSessionDir = this.outputSessionDirFor(taskId);
 		if (outputSessionDir !== void 0) {
 			await entry?.outputWriteQueue;
-			const persisted = await readTaskOutput(outputSessionDir, taskId);
-			if (persisted.length > 0) {
-				if (tail !== void 0 && tail < persisted.length) return persisted.slice(-tail);
-				return persisted;
+			if (tail !== void 0 && tail > 0) {
+				const size = await taskOutputSizeBytes(outputSessionDir, taskId);
+				if (size > 0) {
+					const windowBytes = Math.min(size, tail * 4 + 7);
+					const start = size - windowBytes;
+					let persisted = await readTaskOutputBytes(outputSessionDir, taskId, start, windowBytes);
+					if (persisted.length > 0) {
+						if (start > 0) {
+							let lead = 0;
+							while (lead < persisted.length && persisted.codePointAt(lead) === 65533 && lead < 3) lead += 1;
+							if (lead > 0) persisted = persisted.slice(lead);
+						}
+						return tail < persisted.length ? persisted.slice(-tail) : persisted;
+					}
+					return this.getOutput(taskId, tail);
+				}
+			} else {
+				const persisted = await readTaskOutput(outputSessionDir, taskId);
+				if (persisted.length > 0) return tail !== void 0 && tail < persisted.length ? persisted.slice(-tail) : persisted;
 			}
 		}
 		return this.getOutput(taskId, tail);
@@ -53612,16 +53627,68 @@ async function loadEmbedder(cacheDir) {
 	}
 }
 /**
-* Remove any previously downloaded model files for the fixed BGESmallZH model.
-* Called before a manual re-download so that a corrupted/partial cache does not
-* cause fastembed to fail repeatedly.
+* Cache entry names fastembed uses for the fixed BGESmallZH model: it extracts
+* into `<cacheDir>/<name>/` from the staged archive `<cacheDir>/<name>.tar.gz`.
+*/
+const BGESMALLZH_CACHE_NAME = "fast-bge-small-zh-v1.5";
+const PLATFORM_FAILURE = /@anush008\/tokenizers|Failed to load native binding|Unsupported (?:OS|platform|architecture)|ERR_DLOPEN_FAILED|invalid ELF header|Exec format error|is not a valid Win32 application|GLIBC_\d+[^"\n]*not found|Error loading shared library|cannot open shared object file/iu;
+const ARCHIVE_FAILURE = /\bTAR_[A-Z_]+|incorrect header check|unexpected end of file|invalid tar|zlib/iu;
+const NETWORK_FAILURE = /\b(?:ENOTFOUND|EAI_AGAIN|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EHOSTUNREACH|socket hang up|fetch failed)\b|network error|HTTP \d{3}/iu;
+/**
+* Classify a load failure so callers can say something true about it: the four
+* causes need four different answers (unsupported platform, corrupt cache,
+* network, unknown), and they used to be reported as one network problem.
+*/
+function classifyEmbeddingFailure(message) {
+	if (message === void 0) return "other";
+	if (PLATFORM_FAILURE.test(message)) return "platform";
+	if (ARCHIVE_FAILURE.test(message)) return "archive";
+	if (NETWORK_FAILURE.test(message)) return "network";
+	return "other";
+}
+/**
+* Loads only the module entry point — no model download — so callers can tell
+* "this machine cannot run the local model at all" apart from "the download
+* failed". fastembed imports its native tokenizer binding at module scope, which
+* is exactly the step a platform without a published binary cannot pass.
+*/
+async function probeLocalEmbeddingSupport() {
+	try {
+		await import("fastembed");
+		return { supported: true };
+	} catch (error) {
+		return {
+			supported: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* Remove every trace of a previous BGESmallZH download: the extracted model
+* directory *and* the staged archive it came from.
+*
+* The archive has to go with it. fastembed skips the download whenever
+* `<cacheDir>/<name>.tar.gz` exists, and it only deletes that file after a
+* *successful* extract — its download error paths (response error, file stream
+* error) reject and leave whatever was written behind. So an archive sitting
+* next to a failed attempt is usually a partial leftover, and keeping it makes
+* every retry extract the same junk locally: no network traffic, a few
+* milliseconds, the same failure forever.
+*
+* Never throws: a file locked by another process (on Windows a mapped ONNX file
+* stays locked) must not replace the download error the caller is reporting.
 */
 function clearEmbeddingModelCache(cacheDir) {
-	const modelDir = join(cacheDir, "fast-bge-small-zh-v1.5");
-	if (existsSync(modelDir)) rmSync(modelDir, {
-		recursive: true,
-		force: true
-	});
+	for (const name of [BGESMALLZH_CACHE_NAME, `${BGESMALLZH_CACHE_NAME}.tar.gz`]) {
+		const target = join(cacheDir, name);
+		if (!existsSync(target)) continue;
+		try {
+			rmSync(target, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
 }
 /**
 * Small config/tokenizer files that fastembed expects alongside model.onnx.
@@ -69519,6 +69586,77 @@ function withTimeout$1(promise, timeoutMs, parentSignal) {
 	});
 }
 //#endregion
+//#region ../../packages/agent-core/src/tools/support/file-diff.ts
+/**
+* Line-diff statistics for the file-mutating tools.
+*
+* Edit and Write both hold the pre-write and post-write text of the file they
+* touch, so they can report exact `+added / -removed` line counts to the UI.
+* Deriving those counts from the tool arguments instead is systematically
+* wrong (a Write overwrite hides every removed line; an Edit with
+* `replace_all` sees only one occurrence), so the tools report them here.
+*
+* Only counts leave this module: file contents must never be embedded in the
+* display payload, which is persisted with the session transcript.
+*/
+/**
+* Upper bound applied to either side of the diff. Beyond it the line diff is
+* skipped (returns `undefined`) so an oversized file cannot stall the calling
+* tool; the caller then omits the display and the UI falls back to its
+* argument-derived counts.
+*/
+const MAX_DIFF_CHARS = 1e6;
+/**
+* Wall-clock budget for a single line diff. jsdiff's Myers implementation has
+* adversarial cases that stay quadratic-ish well inside {@link MAX_DIFF_CHARS}:
+* two ~400 KB blobs with no common lines measured minutes before aborting. Past
+* the budget jsdiff gives up and the result is treated exactly like the size
+* guard (no display, argument-derived fallback) — stalling the tool, and with it
+* the event loop, is never acceptable for a UI statistic.
+*/
+const DIFF_BUDGET_MS = 250;
+/**
+* `diffLines` with the runtime `timeout` option. jsdiff honours `timeout`
+* (returning `undefined` when it gives up) but its published typings omit it.
+*/
+const diffLinesWithBudget = diffLines;
+/**
+* Count the lines in a `diffLines` part value the way `git diff --numstat`
+* counts them: a trailing newline terminates the preceding line instead of
+* opening an empty one, and the empty string has no lines.
+*/
+function countLines$1(value) {
+	if (value.length === 0) return 0;
+	const lineBreaks = value.split("\n").length - 1;
+	return value.endsWith("\n") ? lineBreaks : lineBreaks + 1;
+}
+/**
+* Exact line counts between `before` and `after`: every added / removed part
+* `diffLines` reports contributes its own line count, so a single replaced
+* line is one addition plus one removal. Whitespace is significant (jsdiff's
+* `ignoreWhitespace` is off by default) and `\r\n` endings are compared
+* literally.
+*
+* Returns `undefined` when either side exceeds {@link MAX_DIFF_CHARS} or the
+* diff does not finish within {@link DIFF_BUDGET_MS}.
+*/
+function fileDiffSummary(before, after) {
+	if (before.length > MAX_DIFF_CHARS || after.length > MAX_DIFF_CHARS) return void 0;
+	const parts = diffLinesWithBudget(before, after, { timeout: DIFF_BUDGET_MS });
+	if (parts === void 0) return void 0;
+	let added = 0;
+	let removed = 0;
+	for (const part of parts) {
+		const lines = countLines$1(part.value);
+		if (part.added) added += lines;
+		else if (part.removed) removed += lines;
+	}
+	return {
+		added,
+		removed
+	};
+}
+//#endregion
 //#region ../../packages/agent-core/src/tools/support/scan-cache.ts
 var FsScanCache = class {
 	cache = /* @__PURE__ */ new Map();
@@ -69842,6 +69980,29 @@ function replaceOnceLiteral(content, oldString, newString) {
 	if (index === -1) return content;
 	return content.slice(0, index) + newString + content.slice(index + oldString.length);
 }
+/**
+* Attach the exact `+added / -removed` line counts to a successful result so
+* the UI can total them per activity group.
+*
+* The counts come from the real pre-edit and post-edit text, so a
+* `replace_all` edit reports the whole-file delta instead of one occurrence's
+* worth. Error results carry no display: nothing was applied, or the failure
+* path never established the post-edit text.
+*/
+function withFileDiffDisplay(result, before, after) {
+	if (result.isError === true) return result;
+	const summary = fileDiffSummary(before, after);
+	if (summary === void 0) return result;
+	const display = {
+		kind: "file_diff",
+		added: summary.added,
+		removed: summary.removed
+	};
+	return {
+		...result,
+		display
+	};
+}
 var EditTool = class {
 	jian;
 	workspace;
@@ -69915,7 +70076,8 @@ var EditTool = class {
 			output: "new_string contains merge conflict markers (<<<<<<< / ======= / >>>>>>>). Remove them before writing. These markers indicate an unresolved merge and should not be introduced into files."
 		};
 		try {
-			const modelView = toModelTextView(await this.jian.readText(safePath));
+			const raw = await this.jian.readText(safePath);
+			const modelView = toModelTextView(raw);
 			const content = modelView.text;
 			const replaceAll = args.replace_all ?? false;
 			const existingBlocks = scanConflictLines(content.split("\n"));
@@ -69975,20 +70137,20 @@ var EditTool = class {
 						output: `old_string is not unique in ${args.path} (found ${String(count)} occurrences at lines: ${matchLineNumbers.join(", ")}${truncatedNote}). To replace every occurrence, set replace_all=true. To target a specific one, include more surrounding context lines from one of those line ranges in old_string.`
 					};
 				}
-				const newContent = replaceOnceLiteral(content, args.old_string, args.new_string);
-				await this.jian.writeText(safePath, materializeModelText(newContent, modelView.lineEndingStyle));
+				const writtenText = materializeModelText(replaceOnceLiteral(content, args.old_string, args.new_string), modelView.lineEndingStyle);
+				await this.jian.writeText(safePath, writtenText);
 				scanCache.clear();
 				const { notice, hasErrors } = await this.appendDiagnostics(safePath);
 				const output = `Replaced 1 occurrence in ${args.path}`;
 				const message = notice.length > 0 ? notice : void 0;
-				return hasErrors ? {
+				return withFileDiffDisplay(hasErrors ? {
 					isError: true,
 					output,
 					message
 				} : {
 					output,
 					message
-				};
+				}, raw, writtenText);
 			}
 			const parts = content.split(args.old_string);
 			const replacementCount = parts.length - 1;
@@ -69999,20 +70161,20 @@ var EditTool = class {
 					output: `old_string not found in ${args.path} (file has ${String(lineCount)} lines). The file contents may be out of date — re-read with the Read tool. If you already re-read, verify old_string matches exactly: indentation, trailing whitespace, and line endings (LF vs CRLF) must all match the Read output view.`
 				};
 			}
-			const newContent = parts.join(args.new_string);
-			await this.jian.writeText(safePath, materializeModelText(newContent, modelView.lineEndingStyle));
+			const writtenText = materializeModelText(parts.join(args.new_string), modelView.lineEndingStyle);
+			await this.jian.writeText(safePath, writtenText);
 			scanCache.clear();
 			const { notice, hasErrors } = await this.appendDiagnostics(safePath);
 			const output = `Replaced ${String(replacementCount)} occurrences in ${args.path}`;
 			const message = notice.length > 0 ? notice : void 0;
-			return hasErrors ? {
+			return withFileDiffDisplay(hasErrors ? {
 				isError: true,
 				output,
 				message
 			} : {
 				output,
 				message
-			};
+			}, raw, writtenText);
 		} catch (error) {
 			if (error?.code === "EISDIR") return {
 				isError: true,
@@ -75681,6 +75843,12 @@ var write_default = "Write does not preserve or infer the previous line-ending s
 const S_IFMT$2 = 61440;
 /** File-type bits of a directory. */
 const S_IFDIR$1 = 16384;
+/**
+* Size ceiling (bytes, from `stat`) for reading the pre-write text that feeds
+* the `file_diff` display. Mirrors the guard inside `fileDiffSummary`: past it
+* the diff is skipped anyway, so the file is never read only to be discarded.
+*/
+const MAX_DIFF_SOURCE_BYTES = 1e6;
 const WriteInputSchema = z.object({
 	path: z.string().describe("Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. The parent directory must already exist."),
 	content: z.string().describe("Raw full file content to write exactly as provided. This does not use the Read/Edit text view."),
@@ -75739,6 +75907,8 @@ var WriteTool = class {
 		};
 		try {
 			const mode = args.mode ?? "overwrite";
+			const existing = await this.readExistingText(safePath);
+			const display = mode === "append" ? this.appendFileDiffDisplay(args.content, existing) : this.overwriteFileDiffDisplay(args.content, existing);
 			if (mode === "append") await this.jian.writeText(safePath, args.content, { mode: "a" });
 			else await this.jian.writeText(safePath, args.content);
 			scanCache.clear();
@@ -75746,13 +75916,18 @@ var WriteTool = class {
 			const { notice, hasErrors } = await this.appendDiagnostics(safePath);
 			const output = `${mode === "append" ? "Appended" : "Wrote"} ${String(bytesWritten)} bytes to ${args.path}`;
 			const message = notice.length > 0 ? notice : void 0;
-			return hasErrors ? {
+			if (hasErrors) return {
 				isError: true,
 				output,
 				message
-			} : {
+			};
+			return display === void 0 ? {
 				output,
 				message
+			} : {
+				output,
+				message,
+				display
 			};
 		} catch (error) {
 			if (error?.code === "ENOENT") return {
@@ -75766,6 +75941,74 @@ var WriteTool = class {
 		}
 	}
 	/**
+	* Compute the `file_diff` line counts for an append.
+	*
+	* Appending concatenates bytes, so a file that does not end with a newline has
+	* its last line rewritten by the first appended line — counting only the new
+	* content (`+N -0`) would hide that rewritten line. Diffing the real pre-write
+	* text against that text plus the new content is exact; a target that does not
+	* exist yet can only gain lines.
+	*/
+	appendFileDiffDisplay(content, existing) {
+		if (existing.kind === "unavailable") return void 0;
+		const before = existing.kind === "missing" ? "" : existing.text;
+		const summary = fileDiffSummary(before, before + content);
+		if (summary === void 0) return void 0;
+		return {
+			kind: "file_diff",
+			added: summary.added,
+			removed: summary.removed
+		};
+	}
+	/**
+	* Compute the `file_diff` line counts for an overwrite.
+	*
+	* A file that does not exist yet can only gain lines, so the argument-derived
+	* count is exact there. Otherwise the previous text is diffed against the
+	* new text, which is the only way to see the removed lines an overwrite
+	* destroys. Returns `undefined` (no display) when the previous text is
+	* unknown or too large to diff.
+	*/
+	overwriteFileDiffDisplay(content, existing) {
+		if (existing.kind === "missing") return {
+			kind: "file_diff",
+			added: countLines$1(content),
+			removed: 0
+		};
+		if (existing.kind === "unavailable") return void 0;
+		const summary = fileDiffSummary(existing.text, content);
+		if (summary === void 0) return void 0;
+		return {
+			kind: "file_diff",
+			added: summary.added,
+			removed: summary.removed
+		};
+	}
+	/**
+	* Best-effort read of the text this call is about to overwrite, for the
+	* `file_diff` display only.
+	*
+	* The `stat` size check runs first so an oversized file is never pulled into
+	* memory just to be diffed. A failing `stat` for any reason other than
+	* `ENOENT` is inconclusive, so the read is still attempted.
+	*/
+	async readExistingText(safePath) {
+		try {
+			if ((await this.jian.stat(safePath)).stSize > MAX_DIFF_SOURCE_BYTES) return { kind: "unavailable" };
+		} catch (error) {
+			if (error?.code === "ENOENT") return { kind: "missing" };
+		}
+		try {
+			return {
+				kind: "text",
+				text: await this.jian.readText(safePath)
+			};
+		} catch (error) {
+			if (error?.code === "ENOENT") return { kind: "missing" };
+			return { kind: "unavailable" };
+		}
+	}
+	/**
 	* Best-effort check that the parent directory exists and is a directory.
 	*
 	* The path schema documents this precondition; probing it up front turns a
@@ -86069,7 +86312,8 @@ const SNAPSHOT_FOLDED_CONTEXT_TYPES = new Set([
 	"context.append_loop_event",
 	"context.apply_compaction",
 	"micro_compaction.apply",
-	"full_compaction.complete"
+	"full_compaction.complete",
+	"request.header"
 ]);
 /**
 * Serialized-line prefix of a context.snapshot record. Persisted records
@@ -86088,11 +86332,42 @@ const SNAPSHOT_FOLDED_LINE_PREFIXES = [...SNAPSHOT_FOLDED_CONTEXT_TYPES].map((ty
 const SNAPSHOT_RECORD_LINE_PREFIX_BYTES = Buffer.from(SNAPSHOT_RECORD_LINE_PREFIX, "utf8");
 /** UTF-8 bytes of each entry of {@link SNAPSHOT_FOLDED_LINE_PREFIXES}. */
 const SNAPSHOT_FOLDED_LINE_PREFIX_BYTES = SNAPSHOT_FOLDED_LINE_PREFIXES.map((prefix) => Buffer.from(prefix, "utf8"));
-function startsWithPrefix(data, prefix) {
-	return data.length >= prefix.length && data.subarray(0, prefix.length).equals(prefix);
+/**
+* Longest folded-type line prefix: the number of leading bytes a line needs
+* before the parse filter can decide whether to drop it. Until that many bytes
+* are seen the head is the only part of the line held in memory.
+*/
+const SNAPSHOT_FOLDED_MAX_PREFIX_BYTES = SNAPSHOT_FOLDED_LINE_PREFIX_BYTES.reduce((longest, prefix) => Math.max(longest, prefix.length), 0);
+/** Bytes-level prefix test for a line head that may be shorter than the prefix. */
+function headStartsWithPrefix(head, headLength, prefix) {
+	return headLength >= prefix.length && head.subarray(0, prefix.length).equals(prefix);
+}
+function headStartsWithAnyPrefix(head, headLength, prefixes) {
+	return prefixes.some((prefix) => headStartsWithPrefix(head, headLength, prefix));
+}
+/**
+* Whether folded context records that predate the last snapshot can be skipped
+* without decoding. Safe only when no wire migration is needed: a version
+* mismatch triggers migrations/rewrite that must see EVERY record, so
+* old/new-version files fall back to full parsing. The version lives in the
+* first (metadata) line. A header that cannot be parsed returns `false` here —
+* the same line is parsed again below, where the error is thrown.
+*/
+function readSkipFoldedFlag(headerText) {
+	try {
+		return JSON.parse(headerText).protocol_version === "1.4";
+	} catch {
+		return false;
+	}
 }
-function startsWithAnyPrefix(data, prefixes) {
-	return prefixes.some((prefix) => startsWithPrefix(data, prefix));
+/** File size in bytes, or `undefined` when the file does not exist yet. */
+async function fileSize(path) {
+	try {
+		return (await stat(path)).size;
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
 }
 var FileSystemAgentRecordPersistence = class {
 	filePath;
@@ -86102,6 +86377,10 @@ var FileSystemAgentRecordPersistence = class {
 	directorySynced = false;
 	rewriteSeq = 0;
 	flushPromise;
+	/** Set while `compact()` runs; writes queue up instead of draining. */
+	compacting = false;
+	/** Folded-history bytes skipped by the most recent full read(). */
+	droppedBytes = 0;
 	error;
 	constructor(filePath, options = {}) {
 		this.filePath = filePath;
@@ -86109,54 +86388,189 @@ var FileSystemAgentRecordPersistence = class {
 	}
 	async *read() {
 		await this.flush();
-		const lines = [];
-		let lastSnapshotLineNumber = -1;
+		const size = await fileSize(this.filePath);
+		if (size === void 0 || size === 0) return;
+		const lastSnapshotLineNumber = await this.scanLastSnapshotLine(size);
+		if (lastSnapshotLineNumber === void 0) return;
+		yield* this.streamRecords(size, lastSnapshotLineNumber);
+	}
+	/**
+	* Byte-level pass that returns the line number of the last
+	* `context.snapshot` line, or `-1` when the file has none. `undefined` means
+	* the file does not exist (a brand-new session has no wire yet — not an
+	* error). Nothing is decoded and no line is retained: memory stays at one
+	* stream chunk.
+	*/
+	async scanLastSnapshotLine(size) {
+		const prefix = SNAPSHOT_RECORD_LINE_PREFIX_BYTES;
+		const head = Buffer.allocUnsafe(prefix.length);
+		let headLength = 0;
 		let lineNumber = 0;
-		let openChunks = [];
-		const stream = createReadStream(this.filePath);
+		let lastSnapshotLineNumber = -1;
+		const stream = createReadStream(this.filePath, { end: size - 1 });
 		try {
 			for await (const chunk of stream) {
 				let searchFrom = 0;
 				for (;;) {
 					const newlineIndex = chunk.indexOf(10, searchFrom);
+					const end = newlineIndex === -1 ? chunk.length : newlineIndex;
+					if (end > searchFrom && headLength < prefix.length) {
+						const take = Math.min(prefix.length - headLength, end - searchFrom);
+						chunk.copy(head, headLength, searchFrom, searchFrom + take);
+						headLength += take;
+					}
 					if (newlineIndex === -1) break;
-					const parts = openChunks.length > 0 ? [...openChunks, chunk.subarray(searchFrom, newlineIndex)] : [chunk.subarray(searchFrom, newlineIndex)];
-					let lineData = Buffer.concat(parts);
-					if (lineData.length > 0 && lineData.at(-1) === 13) lineData = lineData.subarray(0, lineData.length - 1);
 					lineNumber++;
-					if (startsWithPrefix(lineData, SNAPSHOT_RECORD_LINE_PREFIX_BYTES)) lastSnapshotLineNumber = lineNumber;
-					lines.push({
-						data: lineData,
-						lineNumber,
-						allowTruncated: false
-					});
+					if (headLength === prefix.length && head.equals(prefix)) lastSnapshotLineNumber = lineNumber;
+					headLength = 0;
+					searchFrom = newlineIndex + 1;
+				}
+			}
+		} catch (error) {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		}
+		return lastSnapshotLineNumber;
+	}
+	/**
+	* Streaming replay pass. Folded records predating the last snapshot are
+	* dropped WITHOUT being decoded — the restore fast-path discards them anyway
+	* (records/index.ts snapshot branch), so the yielded stream is identical to a
+	* full decode while neither the file nor the skipped lines are ever held in
+	* memory. An unterminated trailing line is tolerated (see parseRecordLine):
+	* the last write may have crashed mid-flush.
+	*/
+	async *streamRecords(size, lastSnapshotLineNumber) {
+		const head = Buffer.allocUnsafe(SNAPSHOT_FOLDED_MAX_PREFIX_BYTES);
+		let headLength = 0;
+		let openChunks = [];
+		let decided = false;
+		let retaining = false;
+		let headerSeen = false;
+		let skipFoldedBeforeSnapshot = false;
+		let lineNumber = 0;
+		let lineBytes = 0;
+		let skippedBytes = 0;
+		const retainedLine = () => openChunks.length === 1 ? openChunks[0] : Buffer.concat(openChunks);
+		const keepLine = (currentLine) => !(skipFoldedBeforeSnapshot && currentLine < lastSnapshotLineNumber && headStartsWithAnyPrefix(head, headLength, SNAPSHOT_FOLDED_LINE_PREFIX_BYTES));
+		const stream = createReadStream(this.filePath, { end: size - 1 });
+		try {
+			for await (const chunk of stream) {
+				let searchFrom = 0;
+				for (;;) {
+					const newlineIndex = chunk.indexOf(10, searchFrom);
+					const end = newlineIndex === -1 ? chunk.length : newlineIndex;
+					if (!decided && end > searchFrom) {
+						const take = Math.min(SNAPSHOT_FOLDED_MAX_PREFIX_BYTES - headLength, end - searchFrom);
+						chunk.copy(head, headLength, searchFrom, searchFrom + take);
+						headLength += take;
+						searchFrom += take;
+						lineBytes += take;
+						if (headLength === SNAPSHOT_FOLDED_MAX_PREFIX_BYTES) {
+							decided = true;
+							retaining = keepLine(lineNumber + 1);
+							if (retaining) openChunks.push(Buffer.from(head));
+						}
+					}
+					if (retaining && end > searchFrom) openChunks.push(chunk.subarray(searchFrom, end));
+					if (newlineIndex === -1) {
+						lineBytes += end - searchFrom;
+						break;
+					}
+					lineBytes += newlineIndex + 1 - searchFrom;
+					lineNumber++;
+					if (!decided) {
+						decided = true;
+						retaining = keepLine(lineNumber);
+						if (retaining && headLength > 0) openChunks.push(Buffer.from(head.subarray(0, headLength)));
+					}
+					if (retaining) {
+						let lineData = retainedLine();
+						if (lineData.length > 0 && lineData.at(-1) === 13) lineData = lineData.subarray(0, lineData.length - 1);
+						const lineText = lineData.toString("utf8");
+						if (!headerSeen) {
+							headerSeen = true;
+							skipFoldedBeforeSnapshot = readSkipFoldedFlag(lineText);
+						}
+						const record = parseRecordLine(lineText, lineNumber, this.filePath, false);
+						if (record !== void 0) yield record;
+					}
+					if (!retaining) skippedBytes += lineBytes;
 					openChunks = [];
+					headLength = 0;
+					decided = false;
+					retaining = false;
+					lineBytes = 0;
 					searchFrom = newlineIndex + 1;
 				}
-				if (searchFrom < chunk.length) openChunks.push(chunk.subarray(searchFrom));
 			}
 		} catch (error) {
 			if (error.code === "ENOENT") return;
 			throw error;
 		}
-		if (openChunks.length > 0) {
-			lineNumber++;
-			lines.push({
-				data: Buffer.concat(openChunks),
-				lineNumber,
-				allowTruncated: true
-			});
+		if (!decided && headLength > 0) {
+			decided = true;
+			retaining = keepLine(lineNumber + 1);
+			if (retaining) openChunks.push(Buffer.from(head.subarray(0, headLength)));
 		}
-		let skipFoldedBeforeSnapshot = false;
-		if (lines.length > 0) try {
-			skipFoldedBeforeSnapshot = JSON.parse(lines[0].data.toString("utf8")).protocol_version === "1.4";
-		} catch {
-			skipFoldedBeforeSnapshot = false;
-		}
-		for (const entry of lines) {
-			if (skipFoldedBeforeSnapshot && entry.lineNumber < lastSnapshotLineNumber && startsWithAnyPrefix(entry.data, SNAPSHOT_FOLDED_LINE_PREFIX_BYTES)) continue;
-			const record = parseRecordLine(entry.data.toString("utf8"), entry.lineNumber, this.filePath, entry.allowTruncated);
+		if (retaining && openChunks.length > 0) {
+			lineNumber++;
+			let lineData = retainedLine();
+			if (lineData.length > 0 && lineData.at(-1) === 13) lineData = lineData.subarray(0, lineData.length - 1);
+			const record = parseRecordLine(lineData.toString("utf8"), lineNumber, this.filePath, true);
 			if (record !== void 0) yield record;
+		} else if (!retaining) skippedBytes += lineBytes;
+		this.droppedBytes = skippedBytes;
+	}
+	/** Folded-history bytes skipped by the most recent full read(). */
+	droppedBytesOnLastRead() {
+		return this.droppedBytes;
+	}
+	/** Whether the last read() skipped enough folded history to be worth reclaiming on disk. */
+	shouldCompactOnResume() {
+		return this.droppedBytes >= (this.options.compactThresholdBytes ?? 8388608);
+	}
+	/**
+	* Physically drop every record that predates the last `context.snapshot`
+	* (exactly the lines `read()` skips). Byte-preserving: retained lines are
+	* copied verbatim, so unknown records, CRLF framing and blob references
+	* survive untouched. Writes a temp file, fsyncs it, then atomically renames
+	* it over the wire. While it runs, appends queue up instead of draining
+	* (see compacting) and are flushed right after the swap.
+	*/
+	async compact() {
+		await this.flush();
+		this.compacting = true;
+		const tmpPath = `${this.filePath}.${process.pid}.${this.rewriteSeq++}.compact.tmp`;
+		let swapped = false;
+		try {
+			const size = await fileSize(this.filePath);
+			if (size === void 0 || size === 0) return;
+			const lastSnapshotLineNumber = await this.scanLastSnapshotLine(size);
+			if (lastSnapshotLineNumber === void 0) return;
+			const directory = dirname$2(this.filePath);
+			const tmp = await open(tmpPath, "w");
+			let written = 0;
+			try {
+				written = await copyRetainingLines(this.filePath, tmp, size, lastSnapshotLineNumber);
+				await tmp.sync();
+			} finally {
+				await tmp.close();
+			}
+			if (written === size) {
+				this.droppedBytes = 0;
+				return;
+			}
+			if (await fileSize(this.filePath) !== size) return;
+			await rename(tmpPath, this.filePath);
+			swapped = true;
+			await syncDir(directory);
+			this.directorySynced = true;
+			this.droppedBytes = 0;
+		} finally {
+			if (!swapped) await rm(tmpPath, { force: true }).catch(() => {});
+			this.compacting = false;
+			if (this.shouldClear || this.pendingRecords.length > 0) this.scheduleFlush();
 		}
 	}
 	append(input) {
@@ -86172,6 +86586,7 @@ var FileSystemAgentRecordPersistence = class {
 	}
 	async flush() {
 		this.throwIfError();
+		while (this.compacting) await new Promise((resolve) => setTimeout(resolve, 10));
 		while (this.flushPromise !== void 0 || this.shouldClear || this.pendingRecords.length > 0) {
 			await this.ensureFlush();
 			this.throwIfError();
@@ -86186,6 +86601,7 @@ var FileSystemAgentRecordPersistence = class {
 		});
 	}
 	ensureFlush() {
+		if (this.compacting) return Promise.resolve();
 		if (this.flushPromise !== void 0) return this.flushPromise;
 		const promise = this.drainPendingRecords().catch((error) => {
 			this.error = error;
@@ -86201,20 +86617,20 @@ var FileSystemAgentRecordPersistence = class {
 		if (this.error !== void 0) throw this.error;
 	}
 	async drainPendingRecords() {
-		while (this.shouldClear || this.pendingRecords.length > 0) await this.drainBatch();
+		while (!this.compacting && (this.shouldClear || this.pendingRecords.length > 0)) await this.drainBatch();
 	}
 	async drainBatch() {
 		const shouldClear = this.shouldClear;
 		const batch = this.pendingRecords.splice(0);
 		this.shouldClear = false;
-		const content = (this.options.blobStore !== void 0 ? await Promise.all(batch.map((record) => this.options.blobStore.offload(record))) : batch).map((e) => JSON.stringify(e) + "\n").join("");
+		const writable = this.options.blobStore !== void 0 ? await Promise.all(batch.map((record) => this.options.blobStore.offload(record))) : batch;
 		const directory = dirname$2(this.filePath);
 		await mkdir(directory, { recursive: true });
 		if (shouldClear) {
 			const tmpPath = `${this.filePath}.${process.pid}.${this.rewriteSeq++}.tmp`;
 			const tmp = await open(tmpPath, "w");
 			try {
-				if (content.length > 0) await tmp.writeFile(content, "utf8");
+				await writeChunked(tmp, writable);
 				await tmp.sync();
 			} finally {
 				await tmp.close();
@@ -86226,7 +86642,7 @@ var FileSystemAgentRecordPersistence = class {
 		}
 		const fh = await open(this.filePath, "a");
 		try {
-			if (content.length > 0) await fh.writeFile(content, "utf8");
+			await writeChunked(fh, writable);
 			await fh.sync();
 		} finally {
 			await fh.close();
@@ -86237,6 +86653,94 @@ var FileSystemAgentRecordPersistence = class {
 		}
 	}
 };
+const MAX_WRITE_CHUNK_CHARS = 1e6;
+/**
+* Byte-preserving filter pass for compact(): copies every line that
+* streamRecords() would retain (same fold decision, same unterminated-tail
+* tolerance) into `out`, returning the number of bytes written. Kept in the
+* same shape as streamRecords() on purpose — the two must agree on which
+* lines survive; change both together.
+*/
+async function copyRetainingLines(filePath, out, size, lastSnapshotLineNumber) {
+	const head = Buffer.allocUnsafe(SNAPSHOT_FOLDED_MAX_PREFIX_BYTES);
+	let headLength = 0;
+	let openChunks = [];
+	let decided = false;
+	let retaining = false;
+	let headerSeen = false;
+	let skipFoldedBeforeSnapshot = false;
+	let lineNumber = 0;
+	let written = 0;
+	const keepLine = (currentLine) => !(skipFoldedBeforeSnapshot && currentLine < lastSnapshotLineNumber && headStartsWithAnyPrefix(head, headLength, SNAPSHOT_FOLDED_LINE_PREFIX_BYTES));
+	const writeRetainedLine = async () => {
+		const data = openChunks.length === 1 ? openChunks[0] : Buffer.concat(openChunks);
+		if (data.length > 0) {
+			await out.write(data);
+			written += data.length;
+		}
+	};
+	const stream = createReadStream(filePath, { end: size - 1 });
+	for await (const chunk of stream) {
+		let searchFrom = 0;
+		for (;;) {
+			const newlineIndex = chunk.indexOf(10, searchFrom);
+			const end = newlineIndex === -1 ? chunk.length : newlineIndex;
+			if (!decided && end > searchFrom) {
+				const take = Math.min(SNAPSHOT_FOLDED_MAX_PREFIX_BYTES - headLength, end - searchFrom);
+				chunk.copy(head, headLength, searchFrom, searchFrom + take);
+				headLength += take;
+				searchFrom += take;
+				if (headLength === SNAPSHOT_FOLDED_MAX_PREFIX_BYTES) {
+					decided = true;
+					retaining = keepLine(lineNumber + 1);
+					if (retaining) openChunks.push(Buffer.from(head));
+				}
+			}
+			if (retaining && end > searchFrom) openChunks.push(chunk.subarray(searchFrom, end));
+			if (newlineIndex === -1) break;
+			lineNumber++;
+			if (!decided) {
+				decided = true;
+				retaining = keepLine(lineNumber);
+				if (retaining && headLength > 0) openChunks.push(Buffer.from(head.subarray(0, headLength)));
+			}
+			if (retaining) {
+				openChunks.push(chunk.subarray(newlineIndex, newlineIndex + 1));
+				if (!headerSeen) {
+					headerSeen = true;
+					let lineData = openChunks.length === 1 ? openChunks[0] : Buffer.concat(openChunks);
+					if (lineData.length > 0 && lineData.at(-1) === 10) lineData = lineData.subarray(0, lineData.length - 1);
+					if (lineData.length > 0 && lineData.at(-1) === 13) lineData = lineData.subarray(0, lineData.length - 1);
+					skipFoldedBeforeSnapshot = readSkipFoldedFlag(lineData.toString("utf8"));
+				}
+				await writeRetainedLine();
+			}
+			openChunks = [];
+			headLength = 0;
+			decided = false;
+			retaining = false;
+			searchFrom = newlineIndex + 1;
+		}
+	}
+	if (!decided && headLength > 0) {
+		decided = true;
+		retaining = keepLine(lineNumber + 1);
+		if (retaining) openChunks.push(Buffer.from(head.subarray(0, headLength)));
+	}
+	if (retaining && openChunks.length > 0) await writeRetainedLine();
+	return written;
+}
+async function writeChunked(handle, records) {
+	let chunk = "";
+	for (const record of records) {
+		chunk += JSON.stringify(record) + "\n";
+		if (chunk.length >= MAX_WRITE_CHUNK_CHARS) {
+			await handle.write(chunk, null, "utf8");
+			chunk = "";
+		}
+	}
+	if (chunk.length > 0) await handle.write(chunk, null, "utf8");
+}
 function parseRecordLine(line, lineNumber, filePath, allowTruncated) {
 	if (line.length === 0) return void 0;
 	try {
@@ -86570,6 +87074,12 @@ function restoreAgentRecord(agent, input) {
 		case "context.append_message":
 			agent.context.appendMessage(input.message);
 			return;
+		case "context.stream_draft":
+			agent.replayBuilder.replacePartialDraft(input.turnId, {
+				text: input.text,
+				think: input.think
+			});
+			return;
 		case "context.append_loop_event":
 			agent.context.appendLoopEvent(input.event);
 			return;
@@ -86651,6 +87161,7 @@ var AgentRecords = class {
 		let hasMetadata = false;
 		let shouldRewrite = false;
 		let warning;
+		let buffered = false;
 		const replayedRecords = [];
 		for await (const record of this.persistence.read()) {
 			if (!hasMetadata) {
@@ -86665,38 +87176,45 @@ var AgentRecords = class {
 					migrations = resolveWireMigrations(readVersion);
 					shouldRewrite = readVersion !== "1.4";
 				}
+				buffered = shouldRewrite || warning !== void 0;
 			}
 			let migratedRecord = migrateWireRecord(record, migrations);
 			if (migratedRecord.type === "metadata") migratedRecord = {
 				...migratedRecord,
 				protocol_version: "1.4"
 			};
-			replayedRecords.push(migratedRecord);
-		}
-		let snapshotIndex = -1;
-		for (let i = replayedRecords.length - 1; i >= 0; i--) if (replayedRecords[i]?.type === "context.snapshot") {
-			snapshotIndex = i;
-			break;
-		}
-		let foldedCompactionSummary;
-		for (let i = 0; i < replayedRecords.length; i++) {
-			const record = replayedRecords[i];
-			if (!record) continue;
-			if (i < snapshotIndex && isSnapshotFoldedContextRecord(record.type)) {
-				if (record.type === "context.apply_compaction") foldedCompactionSummary = record.summary;
+			if (buffered) {
+				replayedRecords.push(migratedRecord);
 				continue;
 			}
-			this.restore(record);
-			if (record.type === "context.snapshot" && foldedCompactionSummary !== void 0) {
-				recoverMemosFromCompactionSummary(this.agent, foldedCompactionSummary);
-				foldedCompactionSummary = void 0;
+			this.restore(migratedRecord);
+		}
+		if (buffered) {
+			let snapshotIndex = -1;
+			for (let i = replayedRecords.length - 1; i >= 0; i--) if (replayedRecords[i]?.type === "context.snapshot") {
+				snapshotIndex = i;
+				break;
+			}
+			let foldedCompactionSummary;
+			for (let i = 0; i < replayedRecords.length; i++) {
+				const record = replayedRecords[i];
+				if (!record) continue;
+				if (i < snapshotIndex && isSnapshotFoldedContextRecord(record.type)) {
+					if (record.type === "context.apply_compaction") foldedCompactionSummary = record.summary;
+					continue;
+				}
+				this.restore(record);
+				if (record.type === "context.snapshot" && foldedCompactionSummary !== void 0) {
+					recoverMemosFromCompactionSummary(this.agent, foldedCompactionSummary);
+					foldedCompactionSummary = void 0;
+				}
 			}
 		}
 		this.agent.context.dropVacuousOpenMessages();
 		if (shouldRewrite) {
 			this.persistence.rewrite(replayedRecords);
 			await this.persistence.flush();
-		}
+		} else if (this.persistence.shouldCompactOnResume?.() === true && this.persistence.compact !== void 0) await this.persistence.compact();
 		if (this.agent.blobStore !== void 0) for (const msg of this.agent.context.history) await this.agent.blobStore.rehydrateParts(msg.content);
 		return { warning };
 	}
@@ -86723,6 +87241,8 @@ var ReplayBuilder = class {
 	records = [];
 	/** Indices (into `records`) of user-turn-start records, oldest first. */
 	userTurnStarts = [];
+	/** Index (into `records`) of the partial-draft record per turn, if present. */
+	partialDraftIndices = /* @__PURE__ */ new Map();
 	constructor(agent) {
 		this.agent = agent;
 	}
@@ -86735,6 +87255,43 @@ var ReplayBuilder = class {
 		const dropBefore = this.userTurnStarts[this.userTurnStarts.length - 10];
 		this.records.splice(0, dropBefore);
 		this.userTurnStarts = this.userTurnStarts.slice(-10).map((i) => i - dropBefore);
+		for (const [turnId, index] of this.partialDraftIndices) {
+			const shifted = index - dropBefore;
+			if (shifted < 0) this.partialDraftIndices.delete(turnId);
+			else this.partialDraftIndices.set(turnId, shifted);
+		}
+	}
+	/**
+	* Track the latest surviving stream draft for a turn during restore: the
+	* first draft pushes a `stream_draft_partial` record, later drafts replace
+	* it in place (no index shifts), and a clearing draft (empty text+think)
+	* removes it. Only used while `agent.records.restoring` is true.
+	*/
+	replacePartialDraft(turnId, draft) {
+		if (!this.agent.records.restoring) return;
+		const existing = this.partialDraftIndices.get(turnId);
+		if (draft.text.length === 0 && draft.think.length === 0) {
+			if (existing !== void 0) {
+				this.records.splice(existing, 1);
+				this.partialDraftIndices.delete(turnId);
+				for (const [id, index] of this.partialDraftIndices) if (index > existing) this.partialDraftIndices.set(id, index - 1);
+				this.userTurnStarts = this.userTurnStarts.map((i) => i > existing ? i - 1 : i);
+			}
+			return;
+		}
+		const record = {
+			type: "stream_draft_partial",
+			turnId,
+			text: draft.text,
+			think: draft.think
+		};
+		if (existing !== void 0 && this.records[existing]?.type === "stream_draft_partial") {
+			this.records[existing] = record;
+			return;
+		}
+		if (existing !== void 0) this.partialDraftIndices.delete(turnId);
+		this.records.push(record);
+		this.partialDraftIndices.set(turnId, this.records.length - 1);
 	}
 	buildResult() {
 		return this.records;
@@ -95041,7 +95598,8 @@ async function executeLoopStep(deps) {
 			dispatchEvent,
 			turnId,
 			currentStep,
-			stepUuid
+			stepUuid,
+			onStreamingDraft: deps.onStreamingDraft ?? (() => {})
 		})
 	};
 	let response;
@@ -95175,18 +95733,75 @@ function stepEndProviderDiagnostics(response, stopReason) {
 		...response.rawFinishReason !== void 0 ? { rawFinishReason: response.rawFinishReason } : {}
 	};
 }
+/**
+* Accumulates the in-flight stream for the crash-recovery draft and flushes
+* it through `onDraft` at most once per 1.5s or 4k new characters, so a fast
+* stream does not write the wire on every delta while a slow stream still
+* checkpoints promptly. Failures in the sink never break the stream.
+*/
+var StreamDraftTracker = class {
+	onDraft;
+	text = "";
+	think = "";
+	charsSinceFlush = 0;
+	lastFlushAt = Date.now();
+	wireHasDraft = false;
+	constructor(onDraft) {
+		this.onDraft = onDraft;
+	}
+	onText(delta) {
+		this.text += delta;
+		this.charsSinceFlush += delta.length;
+		this.maybeFlush();
+	}
+	onThink(delta) {
+		this.think += delta;
+		this.charsSinceFlush += delta.length;
+		this.maybeFlush();
+	}
+	/**
+	* Real content parts are landing: drop the draft (persisted as empty) — but
+	* only if the wire actually carries one. A stream that finished before any
+	* draft flush (fast mock streams, short replies) must not pollute the wire
+	* with an empty clear record.
+	*/
+	clear() {
+		if (!this.wireHasDraft) return;
+		this.text = "";
+		this.think = "";
+		this.charsSinceFlush = 0;
+		this.flush();
+	}
+	maybeFlush() {
+		if (Date.now() - this.lastFlushAt < DRAFT_FLUSH_INTERVAL_MS && this.charsSinceFlush < DRAFT_FLUSH_MIN_CHARS) return;
+		this.flush();
+	}
+	flush() {
+		this.lastFlushAt = Date.now();
+		this.charsSinceFlush = 0;
+		try {
+			this.onDraft(this.text, this.think);
+			this.wireHasDraft = this.text.length > 0 || this.think.length > 0;
+		} catch {}
+	}
+};
+const DRAFT_FLUSH_INTERVAL_MS = 1500;
+const DRAFT_FLUSH_MIN_CHARS = 4096;
 function createChatStreamingCallbacks(deps) {
-	const { dispatchEvent, turnId, currentStep, stepUuid } = deps;
+	const { dispatchEvent, turnId, currentStep, stepUuid, onStreamingDraft } = deps;
 	let textIndex = 0;
 	let thinkIndex = 0;
+	const draftTracker = new StreamDraftTracker(onStreamingDraft);
 	return {
 		onTextDelta: (delta) => {
+			draftTracker.onText(delta);
 			dispatchEvent({
 				type: "text.delta",
 				delta
 			});
 		},
 		onThinkDelta: (delta) => {
+			draftTracker.onThink(delta);
 			dispatchEvent({
 				type: "thinking.delta",
 				delta
@@ -95202,6 +95817,7 @@ function createChatStreamingCallbacks(deps) {
 		},
 		onTextPart: async (part) => {
 			const index = textIndex++;
+			draftTracker.clear();
 			await dispatchEvent({
 				type: "block.start",
 				uuid: randomUUID(),
@@ -95231,6 +95847,7 @@ function createChatStreamingCallbacks(deps) {
 		},
 		onThinkPart: async (part) => {
 			const index = thinkIndex++;
+			draftTracker.clear();
 			await dispatchEvent({
 				type: "block.start",
 				uuid: randomUUID(),
@@ -95310,7 +95927,8 @@ async function runTurn(input) {
 				maxRetryAttempts,
 				recordUsage: recordStepUsage,
 				hasPendingSteer: input.hasPendingSteer,
-				mediaProjection
+				mediaProjection,
+				onStreamingDraft: input.onStreamingDraft
 			});
 			activeStep = void 0;
 			if (stepResult.totalCalls > 0) {
@@ -101542,6 +102160,15 @@ var TurnFlow = class {
 					maxSteps: loopControl?.maxStepsPerTurn,
 					maxRetryAttempts: loopControl?.maxRetriesPerStep,
 					hasPendingSteer: () => this.steerBuffer.some((steer) => steer.origin.kind === "user" && steer.interrupt !== false),
+					onStreamingDraft: (text, think) => {
+						this.agent.records.logRecord({
+							type: "context.stream_draft",
+							turnId: String(turnId),
+							text,
+							think,
+							time: Date.now()
+						});
+					},
 					hooks: {
 						beforeStep: async ({ signal: stepSignal, stepNumber }) => {
 							this.flushSteerBuffer();
@@ -102219,6 +102846,8 @@ var Agent = class {
 	/** Read-only manifest of the core engine subsystems (see {@link AgentServices}). */
 	services;
 	lastLlmConfigLogSignature;
+	/** Last rendered system prompt written to a request.header record. */
+	lastRequestHeaderSystemPrompt;
 	sharedEmbeddingEngine;
 	resolveRuntimeSystemPrompt;
 	constructor(options) {
@@ -102523,12 +103152,14 @@ var Agent = class {
 		for (const message of history) if (message.partial === true) partialMessageCount += 1;
 		const requestMetadata = { estimatedInputTokens: estimateTokens$1(systemPrompt) + estimateTokensForMessages(history) + estimateTokensForTools(tools) };
 		if (partialMessageCount > 0) requestMetadata.partialMessageCount = partialMessageCount;
+		const systemPromptReused = systemPrompt === this.lastRequestHeaderSystemPrompt;
+		this.lastRequestHeaderSystemPrompt = systemPrompt;
 		this.records.logRecord({
 			type: "request.header",
 			provider: provider.name,
 			model: provider.modelName,
 			modelAlias: this.config.modelAlias ?? "",
-			systemPrompt,
+			...systemPromptReused ? { systemPromptReused: true } : { systemPrompt },
 			activeTools: tools.map((t) => t.name),
 			messagesCount: history.length,
 			estimatedInputTokens: requestMetadata.estimatedInputTokens ?? 0
@@ -121686,7 +122317,7 @@ var LocalFetchURLProvider = class {
 	* `confident` distinguishes detection strength: a convertible Content-Type
 	* means conversion failure is a real error (corrupt document), while an
 	* extension-only guess (e.g. an HTML viewer page at a .pdf URL) falls back
-	* to the normal text extraction path instead of erroring (omp's behavior).
+	* to the normal text extraction path instead of erroring.
 	*/
 	async fetchDocument(response, extension, contentType, confident) {
 		const bytes = new Uint8Array(await response.arrayBuffer());
@@ -121797,7 +122428,7 @@ const RESULT_TITLE_RE$1 = /<a\b[^>]*\bclass="[^"]*\bresult__a\b[^"]*"[^>]*\bhref
 const RESULT_SNIPPET_RE$1 = /<(?:a|div|span)\b[^>]*\bclass="[^"]*\bresult__snippet\b[^"]*"[^>]*>([\s\S]*?)<\/(?:a|div|span)>/;
 /** Strip inline tags (DDG wraps query terms in `<b>`) and decode entities. */
 function decodeHtmlText$2(value) {
-	return value.replace(/<[^>]*>/g, " ").replace(/&#(\d+);/g, (_, code) => String.fromCharCode(Number(code))).replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCharCode(Number.parseInt(code, 16))).replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, "\"").replace(/&#39;|&apos;/gi, "'").replace(/\s+/g, " ").trim();
+	return value.replaceAll(/<[^>]*>/g, " ").replaceAll(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code))).replaceAll(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(Number.parseInt(code, 16))).replaceAll(/&nbsp;/gi, " ").replaceAll(/&amp;/gi, "&").replaceAll(/&lt;/gi, "<").replaceAll(/&gt;/gi, ">").replaceAll(/&quot;/gi, "\"").replaceAll(/&#39;|&apos;/gi, "'").replaceAll(/\s+/g, " ").trim();
 }
 /**
 * Resolve a DDG result href to the underlying target URL. DDG routes
@@ -121806,7 +122437,7 @@ function decodeHtmlText$2(value) {
 */
 function unwrapResultUrl(href) {
 	if (href === "") return void 0;
-	const decoded = href.replace(/&amp;/gi, "&");
+	const decoded = href.replaceAll(/&amp;/gi, "&");
 	const wrapMatch = decoded.match(/[?&]uddg=([^&]+)/);
 	if (wrapMatch?.[1] !== void 0) try {
 		return decodeURIComponent(wrapMatch[1]);
@@ -122125,27 +122756,32 @@ function buildExportManifest(args) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/session/export/wire-scan.ts
+/**
+* Scan a session's `wire.jsonl` for activity timestamps and the first user
+* input.
+*
+* The log is append-only and line-delimited, but a long-lived session can grow
+* it to gigabytes, so it is streamed rather than read into a single string: a
+* `StringDecoder` turns each chunk into text without splitting multi-byte
+* characters, complete lines are consumed as they arrive, and only the four
+* aggregated values are retained. Any read failure (including a missing file)
+* yields an empty scan.
+*/
 async function scanSessionWire(sessionDir) {
-	let raw;
-	try {
-		raw = await readFile(join$1(sessionDir, "wire.jsonl"), "utf-8");
-	} catch {
-		return {};
-	}
 	let firstActivityMs;
 	let lastActivityMs;
 	let lastUserMessageMs;
 	let firstUserInput;
-	for (const line of raw.split("\n")) {
+	const consumeLine = (line) => {
 		const trimmed = line.trim();
-		if (trimmed.length === 0) continue;
+		if (trimmed.length === 0) return;
 		let parsed;
 		try {
 			parsed = JSON.parse(trimmed);
 		} catch {
-			continue;
+			return;
 		}
-		if (typeof parsed !== "object" || parsed === null) continue;
+		if (typeof parsed !== "object" || parsed === null) return;
 		const record = parsed;
 		const timeMs = typeof record.time === "number" ? normalizeTimestampMs(record.time) : void 0;
 		if (timeMs !== void 0) {
@@ -122156,6 +122792,27 @@ async function scanSessionWire(sessionDir) {
 			if (timeMs !== void 0) lastUserMessageMs = timeMs;
 			if (firstUserInput === void 0 && typeof record.userInput === "string" && record.userInput.trim().length > 0) firstUserInput = record.userInput;
 		}
+	};
+	try {
+		const decoder = new StringDecoder("utf8");
+		let pending = "";
+		let scanned = 0;
+		const stream = createReadStream(join$1(sessionDir, "wire.jsonl"));
+		for await (const chunk of stream) {
+			pending += decoder.write(chunk);
+			let newlineIndex = pending.indexOf("\n", scanned);
+			while (newlineIndex !== -1) {
+				consumeLine(pending.slice(0, newlineIndex));
+				pending = pending.slice(newlineIndex + 1);
+				scanned = 0;
+				newlineIndex = pending.indexOf("\n", scanned);
+			}
+			scanned = pending.length;
+		}
+		pending += decoder.end();
+		if (pending.length > 0) consumeLine(pending);
+	} catch {
+		return {};
 	}
 	return {
 		firstActivityMs,
@@ -123053,22 +123710,56 @@ async function writeExportZip(args) {
 	await mkdir(dirname$2(args.outputPath), { recursive: true });
 	const entries = ["manifest.json"];
 	const zip = new import_yazl.ZipFile();
+	const zipFailure = new Promise((_resolve, reject) => {
+		zip.once("error", reject);
+	});
 	zip.addBuffer(Buffer.from(JSON.stringify(args.manifest, null, 2), "utf-8"), "manifest.json");
 	for (const abs of args.sessionFiles) {
 		const rel = relative$1(args.sessionDir, abs).split(/[\\/]/).join("/");
-		const data = await readFile(abs);
-		zip.addBuffer(data, rel);
+		addStreamedFile(zip, abs, rel);
 		entries.push(rel);
 	}
-	for (const extra of args.extraEntries ?? []) try {
-		const data = "data" in extra ? extra.data : await readFile(extra.source);
-		zip.addBuffer(data, extra.target);
+	for (const extra of args.extraEntries ?? []) {
+		if ("data" in extra) {
+			zip.addBuffer(extra.data, extra.target);
+			entries.push(extra.target);
+			continue;
+		}
+		try {
+			if (!(await stat(extra.source)).isFile()) continue;
+		} catch {
+			continue;
+		}
+		addStreamedFile(zip, extra.source, extra.target);
 		entries.push(extra.target);
-	} catch {}
-	zip.end();
-	await pipeline$1(zip.outputStream, createWriteStream$1(args.outputPath));
+	}
+	try {
+		zip.end();
+		await Promise.race([pipeline$1(zip.outputStream, createWriteStream$1(args.outputPath)), zipFailure]);
+	} catch (error) {
+		await rm(args.outputPath, { force: true }).catch(() => {});
+		throw error;
+	}
 	return entries;
 }
+/**
+* Add a file as a lazily-streamed zip entry.
+*
+* `ZipFile.addFile` records the size from a stat and then asserts the byte count
+* while reading, so exporting a session that is still appending to its wire or
+* log files — or that rotates them mid-export — would abort the whole export.
+* Reading lazily without a declared size keeps the entry tolerant of growth,
+* opens one file at a time, and still never holds the file in memory.
+* (`addReadStreamLazy` is the entry point yazl's own `addFile` uses; the
+* published typings just do not declare it.)
+*/
+function addStreamedFile(zip, source, target) {
+	zip.addReadStreamLazy(target, (callback) => {
+		const stream = createReadStream(source);
+		stream.on("error", (error) => zip.emit("error", error));
+		callback(null, stream);
+	});
+}
 //#endregion
 //#region ../../packages/agent-core/src/session/export/session-export.ts
 const SESSION_LOG_REL = "logs/scream-code.log";
@@ -123086,10 +123777,9 @@ async function exportSessionDirectory(input) {
 	let bundledGlobal = false;
 	const globalPath = input.globalLogPath ?? (input.homeDir === void 0 ? void 0 : resolveGlobalLogPath(input.homeDir));
 	if (input.request.includeGlobalLog === true && globalPath !== void 0) {
-		const data = await readOptionalFile(globalPath);
-		if (data !== void 0) {
+		if (await pathIsFile(globalPath)) {
 			extras.push({
-				data,
+				source: globalPath,
 				target: GLOBAL_LOG_REL
 			});
 			bundledGlobal = true;
@@ -123119,11 +123809,11 @@ async function exportSessionDirectory(input) {
 		manifest
 	};
 }
-async function readOptionalFile(path) {
+async function pathIsFile(path) {
 	try {
-		return await readFile(path);
+		return (await stat(path)).isFile();
 	} catch {
-		return;
+		return false;
 	}
 }
 //#endregion
@@ -123609,6 +124299,10 @@ function hasCustomTitle(metadata) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/session/store/session-index.ts
+let sessionIndexCache;
+function invalidateSessionIndexCache() {
+	sessionIndexCache = void 0;
+}
 function sessionIndexPath(homeDir) {
 	return join$1(homeDir, "session_index.jsonl");
 }
@@ -123619,12 +124313,24 @@ async function appendSessionIndexEntry(homeDir, entry) {
 		mode: 448
 	});
 	await appendFile(indexPath, `${JSON.stringify(entry)}\n`, "utf-8");
+	invalidateSessionIndexCache();
 }
 async function readSessionIndex(homeDir, sessionsDir) {
+	const indexPath = sessionIndexPath(homeDir);
+	let stats;
+	try {
+		stats = await stat(indexPath);
+	} catch {
+		sessionIndexCache = void 0;
+		return /* @__PURE__ */ new Map();
+	}
+	const cached = sessionIndexCache;
+	if (cached !== void 0 && cached.homeDir === homeDir && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) return cached.map;
 	let raw;
 	try {
-		raw = await readFile(sessionIndexPath(homeDir), "utf-8");
+		raw = await readFile(indexPath, "utf-8");
 	} catch {
+		sessionIndexCache = void 0;
 		return /* @__PURE__ */ new Map();
 	}
 	const result = /* @__PURE__ */ new Map();
@@ -123644,6 +124350,12 @@ async function readSessionIndex(homeDir, sessionsDir) {
 			workDir: resolve$2(entry.workDir)
 		});
 	}
+	sessionIndexCache = {
+		homeDir,
+		mtimeMs: stats.mtimeMs,
+		size: stats.size,
+		map: result
+	};
 	return result;
 }
 async function removeSessionIndexEntry(homeDir, sessionId) {
@@ -123665,6 +124377,7 @@ async function removeSessionIndexEntry(homeDir, sessionId) {
 	}
 	if (kept.length === 0) await writeFile(indexPath, "", "utf-8");
 	else await writeFile(indexPath, kept.join("\n") + "\n", "utf-8");
+	invalidateSessionIndexCache();
 }
 function parseIndexLine(line) {
 	try {
@@ -127740,7 +128453,7 @@ const backwardFrames = Array.from({ length: 6 }, (_, i) => ({
 const PULSE_WAVE_FRAMES = [...forwardFrames, ...backwardFrames];
 //#endregion
 //#region src/tui/commands/knowledge-store.ts
-let knowledgeStoreInstance;
+let knowledgeStorePromise;
 let embeddingEngineInstance;
 let embeddingStatus = "idle";
 function getEmbeddingCacheDir() {
@@ -127751,24 +128464,40 @@ function getEmbeddingCacheDir() {
 /** Subdirectory fastembed uses for the BGESmallZH model inside the cache dir. */
 const EMBEDDING_MODEL_DIR = "fast-bge-small-zh-v1.5";
 /**
-* Whether the embedding model has been downloaded to the local cache.
-* Checks the ONNX weights plus the config and tokenizer sidecars — all
-* required for FlagEmbedding.init to load without network access (a missing
-* tokenizer would trigger a network fetch and violate the warm-up's
-* offline-load guarantee).
+* Any usable cache: the model directory with its weights present.
+*
+* Such a cache can still be missing sidecars, which FlagEmbedding repairs from
+* the Hub while loading — so callers must not treat it as "no model here".
+* Flagging it as missing would block the very path that repairs it, and
+* fastembed itself skips downloading whenever the model directory exists.
 */
-function isEmbeddingModelCached() {
+function hasEmbeddingModelCache() {
 	const modelDir = join(getEmbeddingCacheDir(), EMBEDDING_MODEL_DIR);
-	return existsSync(join(modelDir, "model_optimized.onnx")) && existsSync(join(modelDir, "config.json")) && existsSync(join(modelDir, "tokenizer.json"));
-}
-async function getKnowledgeStore() {
-	if (knowledgeStoreInstance === void 0) {
-		knowledgeStoreInstance = new KnowledgeStore(getDataDir());
-		await knowledgeStoreInstance.init();
-		embeddingEngineInstance = createFastEmbedEngine(getEmbeddingCacheDir());
-		knowledgeStoreInstance.setEmbeddingEngine(embeddingEngineInstance);
-	}
-	return knowledgeStoreInstance;
+	return existsSync(modelDir) && existsSync(join(modelDir, "model_optimized.onnx"));
+}
+/**
+* The store and its embedding engine are built together and published only once
+* both exist. Publishing the store first meant a single transient failure (a
+* locked knowledge.db, a full disk, a denied directory) left a store with no
+* engine that no later call could repair: every download then failed instantly
+* with "embedding engine not initialized" for the rest of the process.
+*
+* Concurrent callers share one build, and a failed build clears the slot so the
+* next caller retries from scratch.
+*/
+function getKnowledgeStore() {
+	knowledgeStorePromise ??= (async () => {
+		const store = new KnowledgeStore(getDataDir());
+		await store.init();
+		const engine = createFastEmbedEngine(getEmbeddingCacheDir());
+		store.setEmbeddingEngine(engine);
+		embeddingEngineInstance = engine;
+		return store;
+	})().catch((error) => {
+		knowledgeStorePromise = void 0;
+		throw error;
+	});
+	return knowledgeStorePromise;
 }
 function getEmbeddingStatus() {
 	return embeddingStatus;
@@ -127777,16 +128506,12 @@ function getEmbeddingStatus() {
 * Manually trigger the embedding model download/load.
 * Only mutates embeddingStatus; the actual download is delegated to
 * EmbeddingEngine.ensureReady() and saves the model to the shared cache dir.
-* Returns { ok: true } on success, or { ok: false, error } on failure.
 * Concurrent calls join the in-flight download and share its result instead
 * of failing — the startup warm-up and a user-initiated download must never
 * race into a spurious "download already in progress" error.
 */
 async function startManualEmbeddingDownload() {
-	if (embeddingEngineInstance === void 0) return {
-		ok: false,
-		error: "embedding engine not initialized"
-	};
+	if (embeddingEngineInstance === void 0) return failureResult("embedding engine not initialized");
 	if (embeddingEngineInstance.available) {
 		embeddingStatus = "ready";
 		return {
@@ -127802,29 +128527,71 @@ async function startManualEmbeddingDownload() {
 	return downloadPromise;
 }
 let downloadPromise;
+function failureResult(error) {
+	return {
+		ok: false,
+		error,
+		failureKind: classifyEmbeddingFailure(error)
+	};
+}
 async function performDownload() {
 	try {
+		const support = await probeLocalEmbeddingSupport();
+		if (!support.supported) {
+			embeddingStatus = "failed";
+			return {
+				ok: false,
+				error: support.error,
+				failureKind: classifyEmbeddingFailure(support.error)
+			};
+		}
 		let ok = await embeddingEngineInstance.ensureReady();
 		let error = ok ? void 0 : embeddingEngineInstance.lastError;
 		if (!ok) {
-			clearEmbeddingModelCache(getEmbeddingCacheDir());
-			ok = await embeddingEngineInstance.ensureReady();
-			error = ok ? void 0 : embeddingEngineInstance.lastError;
+			if (classifyEmbeddingFailure(error) !== "platform") {
+				clearEmbeddingModelCache(getEmbeddingCacheDir());
+				ok = await embeddingEngineInstance.ensureReady();
+				error = ok ? void 0 : embeddingEngineInstance.lastError;
+			}
 		}
 		embeddingStatus = ok ? "ready" : "failed";
-		return {
-			ok,
-			error
-		};
+		return ok ? { ok } : failureResult(error);
 	} catch (error) {
 		embeddingStatus = "failed";
-		return {
-			ok: false,
-			error: error instanceof Error ? error.message : String(error)
-		};
+		return failureResult(error instanceof Error ? error.message : String(error));
 	}
 }
 //#endregion
+//#region src/tui/commands/embedding-failure-hint.ts
+/**
+* The line shown above the raw error in a failed embedding download.
+*
+* Every cause used to share one hint that blamed the network and suggested a
+* proxy, which is wrong for a machine that simply has no local model binary —
+* that single sentence is what made four different failures look like the same
+* connectivity complaint. Kept apart from the store so the copy can be read and
+* tested on its own.
+*/
+function embeddingFailureHint(kind) {
+	switch (kind) {
+		case "platform": return t("knowledge.embedding_platform_hint");
+		case "archive": return t("knowledge.embedding_cache_corrupt_hint");
+		case "network": return t("knowledge.embedding_network_hint");
+		default: return t("knowledge.embedding_unknown_hint");
+	}
+}
+/**
+* The detail block a failure notice shows: the hint, then the first line of the
+* raw error.
+*
+* Only the first line is displayed — Node appends a "Require stack:" block to
+* module errors, a local path dump no user needs (and the line we ask people to
+* send us) — while the engine keeps the full text for diagnosis.
+*/
+function embeddingFailureDetail(kind, error) {
+	return [embeddingFailureHint(kind), error?.split("\n")[0]].filter(Boolean).join("\n");
+}
+//#endregion
 //#region src/tui/commands/experimental-flags.ts
 let snapshot = {};
 /** Replace the cached flag snapshot. Call once after fetching via `harness.getExperimentalFlags()`. */
@@ -129573,8 +130340,6 @@ function contentPartsText(parts) {
 * Throws when the file is missing or contains no usable records.
 */
 function buildTraceCells({ wirePath }) {
-	const rows = readWireRows(wirePath);
-	if (rows.length === 0) throw new Error(`no wire records in ${wirePath}`);
 	const cells = [];
 	let lastTime;
 	let nextIndex = 1;
@@ -129592,6 +130357,11 @@ function buildTraceCells({ wirePath }) {
 			startedAt: time,
 			...fields
 		};
+		cell.text = truncateDetail(cell.text, MAX_TEXT) ?? "";
+		if (cell.thinkingDetail) cell.thinkingDetail = truncateDetail(cell.thinkingDetail);
+		if (cell.outputDetail) cell.outputDetail = truncateDetail(cell.outputDetail);
+		if (cell.inputDetail) cell.inputDetail = truncateDetail(cell.inputDetail);
+		if (cell.result) cell.result = truncateDetail(cell.result);
 		cells.push(cell);
 		lastCell = cell;
 		return cell;
@@ -129755,99 +130525,102 @@ function buildTraceCells({ wirePath }) {
 			default: break;
 		}
 	};
-	for (const { seq, time, record } of rows) switch (asString(record["type"])) {
-		case "context.append_loop_event": {
-			const event = asRecord(record["event"]);
-			if (!event) break;
-			handleLoopEvent(event, time, seq);
-			break;
-		}
-		case "turn.prompt": {
-			finalizeStep(time);
-			turnNo += 1;
-			flushPendingSystem(time);
-			const input = record["input"];
-			const text = contentPartsText(input).trim();
-			pushCell("user", text.replaceAll(/\s+/g, " ").slice(0, 80) || "(空输入)", {
-				opensTurn: true,
-				inputDetail: text || void 0,
-				sourceSeq: seq
-			}, time);
-			currentTurnStart = time;
-			break;
-		}
-		case "turn.steer": {
-			const input = record["input"];
-			const text = contentPartsText(input).trim();
-			pushCell("context", `转向: ${text.replaceAll(/\s+/g, " ").slice(0, 80)}`, {
-				inputDetail: text || void 0,
-				sourceSeq: seq
-			}, time);
-			break;
-		}
-		case "request.header": {
-			const provider = asString(record["provider"]) ?? "";
-			const model = asString(record["model"]) ?? "";
-			const tools = asRecordArray(record["activeTools"]).map((t) => asString(t["name"]) ?? "");
-			pushCell("system", `请求 ${provider ? `${provider}/` : ""}${model}`, {
-				requestOnly: true,
-				inputDetail: tools.length > 0 ? `工具: ${tools.join(", ")}` : void 0,
-				sourceSeq: seq
-			}, time);
-			break;
-		}
-		case "tools.set_active_tools": {
-			const names = asStringArray(record["names"]).length > 0 ? asStringArray(record["names"]) : asRecordArray(record["names"]).map((n) => asString(n["name"]) ?? "");
-			pendingSystem.push(`工具集: ${names.join(", ")}`);
-			lastSystemTime = time;
-			break;
-		}
-		case "config.update": {
-			const cfg = asRecord(record);
-			const bits = [];
-			if (asString(cfg?.["modelAlias"])) bits.push(`模型别名: ${cfg["modelAlias"]}`);
-			if (asString(cfg?.["systemPrompt"])) bits.push("系统提示词已更新");
-			if (bits.length === 0) break;
-			pendingSystem.push(bits.join(" · "));
-			lastSystemTime = time;
-			break;
-		}
-		case "usage.record":
-			if (currentStepUuid === void 0) {
-				const usage = asRecord(record["usage"]);
-				pushCell("context", "usage", {
-					input: asNumber(usage?.["inputOther"]),
-					cacheRead: asNumber(usage?.["inputCacheRead"]),
-					cacheWrite: asNumber(usage?.["inputCacheCreation"]),
-					output: asNumber(usage?.["output"]),
+	const consumeRow = ({ seq, time, record }) => {
+		switch (asString(record["type"])) {
+			case "context.append_loop_event": {
+				const event = asRecord(record["event"]);
+				if (!event) break;
+				handleLoopEvent(event, time, seq);
+				break;
+			}
+			case "turn.prompt": {
+				finalizeStep(time);
+				turnNo += 1;
+				flushPendingSystem(time);
+				const input = record["input"];
+				const text = contentPartsText(input).trim();
+				pushCell("user", text.replaceAll(/\s+/g, " ").slice(0, 80) || "(空输入)", {
+					opensTurn: true,
+					inputDetail: text || void 0,
 					sourceSeq: seq
 				}, time);
+				currentTurnStart = time;
+				break;
 			}
-			break;
-		case "full_compaction.begin": {
-			finalizeStep(time);
-			const reason = asString(record["reason"]);
-			const instruction = asString(record["instruction"]);
-			const source = asString(record["source"]);
-			pushCell("compacted", `压缩上下文${reason ? `（${reason}）` : ""}`, {
-				sourceSeq: seq,
-				startedAt: currentTurnStart,
-				inputDetail: instruction || void 0,
-				result: source ? `来源: ${source}` : void 0
-			}, time);
-			break;
-		}
-		case "micro_compaction.apply": {
-			finalizeStep(time);
-			const reason = asString(record["reason"]);
-			pushCell("compacted", `微压缩${reason ? `（${reason}）` : ""}`, {
-				sourceSeq: seq,
-				startedAt: currentTurnStart
-			}, time);
-			break;
+			case "turn.steer": {
+				const input = record["input"];
+				const text = contentPartsText(input).trim();
+				pushCell("context", `转向: ${text.replaceAll(/\s+/g, " ").slice(0, 80)}`, {
+					inputDetail: text || void 0,
+					sourceSeq: seq
+				}, time);
+				break;
+			}
+			case "request.header": {
+				const provider = asString(record["provider"]) ?? "";
+				const model = asString(record["model"]) ?? "";
+				const tools = asRecordArray(record["activeTools"]).map((t) => asString(t["name"]) ?? "");
+				pushCell("system", `请求 ${provider ? `${provider}/` : ""}${model}`, {
+					requestOnly: true,
+					inputDetail: tools.length > 0 ? `工具: ${tools.join(", ")}` : void 0,
+					sourceSeq: seq
+				}, time);
+				break;
+			}
+			case "tools.set_active_tools": {
+				const names = asStringArray(record["names"]).length > 0 ? asStringArray(record["names"]) : asRecordArray(record["names"]).map((n) => asString(n["name"]) ?? "");
+				pendingSystem.push(`工具集: ${names.join(", ")}`);
+				lastSystemTime = time;
+				break;
+			}
+			case "config.update": {
+				const cfg = asRecord(record);
+				const bits = [];
+				if (asString(cfg?.["modelAlias"])) bits.push(`模型别名: ${cfg["modelAlias"]}`);
+				if (asString(cfg?.["systemPrompt"])) bits.push("系统提示词已更新");
+				if (bits.length === 0) break;
+				pendingSystem.push(bits.join(" · "));
+				lastSystemTime = time;
+				break;
+			}
+			case "usage.record":
+				if (currentStepUuid === void 0) {
+					const usage = asRecord(record["usage"]);
+					pushCell("context", "usage", {
+						input: asNumber(usage?.["inputOther"]),
+						cacheRead: asNumber(usage?.["inputCacheRead"]),
+						cacheWrite: asNumber(usage?.["inputCacheCreation"]),
+						output: asNumber(usage?.["output"]),
+						sourceSeq: seq
+					}, time);
+				}
+				break;
+			case "full_compaction.begin": {
+				finalizeStep(time);
+				const reason = asString(record["reason"]);
+				const instruction = asString(record["instruction"]);
+				const source = asString(record["source"]);
+				pushCell("compacted", `压缩上下文${reason ? `（${reason}）` : ""}`, {
+					sourceSeq: seq,
+					startedAt: currentTurnStart,
+					inputDetail: instruction || void 0,
+					result: source ? `来源: ${source}` : void 0
+				}, time);
+				break;
+			}
+			case "micro_compaction.apply": {
+				finalizeStep(time);
+				const reason = asString(record["reason"]);
+				pushCell("compacted", `微压缩${reason ? `（${reason}）` : ""}`, {
+					sourceSeq: seq,
+					startedAt: currentTurnStart
+				}, time);
+				break;
+			}
+			default: break;
 		}
-		default: break;
-	}
+	};
+	if (forEachWireRow(wirePath, consumeRow) === 0) throw new Error(`no wire records in ${wirePath}`);
 	finalizeStep(void 0);
 	flushPendingSystem(void 0);
 	return capTraceSize(cells);
@@ -129856,25 +130629,20 @@ function buildTraceCells({ wirePath }) {
 * Long sessions produce tens of thousands of cells with multi-MB detail
 * payloads, which previously bloated the trace HTML (up to ~60MB) and froze
 * the browser. Two mitigations, applied at build time:
-*  1. Truncate per-cell detail text (thinking/output/input/result) to a cap.
+*  1. Truncate per-cell detail text (thinking/output/input/result) to a cap —
+*     done in `pushCell`, so the raw payload never outlives the cell.
 *  2. Beyond a cell-count cap, collapse the oldest cells into per-turn
 *     summary rows so the document stays bounded while early turns remain
 *     visible in the ledger.
 */
 const MAX_DETAIL = 4e3;
+const MAX_TEXT = 240;
 const MAX_CELLS = 4e3;
 function truncateDetail(value, max = MAX_DETAIL) {
 	if (!value || value.length <= max) return value;
 	return `${value.slice(0, max)}\n…[已截断 ${value.length - max} 字符]`;
 }
 function capTraceSize(cells) {
-	for (const cell of cells) {
-		cell.text = truncateDetail(cell.text, 240) ?? "";
-		if (cell.thinkingDetail) cell.thinkingDetail = truncateDetail(cell.thinkingDetail);
-		if (cell.outputDetail) cell.outputDetail = truncateDetail(cell.outputDetail);
-		if (cell.inputDetail) cell.inputDetail = truncateDetail(cell.inputDetail);
-		if (cell.result) cell.result = truncateDetail(cell.result);
-	}
 	if (cells.length <= MAX_CELLS) return cells;
 	const keep = cells.slice(-4e3);
 	const early = cells.slice(0, cells.length - MAX_CELLS);
@@ -129893,25 +130661,67 @@ function capTraceSize(cells) {
 		startedAt: early.find((c) => c.startedAt !== void 0 && c.startedAt !== null)?.startedAt ?? null
 	}, ...keep];
 }
-function readWireRows(wirePath) {
-	const content = readFileSync(wirePath, "utf8");
-	const rows = [];
+/** Bytes read per `readSync` call while scanning a wire log. */
+const WIRE_READ_CHUNK_BYTES = 1024 * 1024;
+/**
+* Stream a wire log row by row without materializing the file.
+*
+* The log is append-only and line-delimited, but a long-lived session can grow
+* it to gigabytes, so the content is never held as a single string: fixed-size
+* chunks are read into one reusable buffer and split on "\n" (0x0A) at byte
+* level. Only the currently open line is carried across reads (as a small
+* copied buffer, because the chunk buffer is reused), and each parsed row is
+* handed to `onRow` and then dropped — neither the decoded file nor a
+* parsed-record array lives beyond the line being processed.
+*
+* Returns the number of parsed rows. Throws when the file cannot be opened;
+* callers rely on that to tell a missing session log apart from an empty one.
+*/
+function forEachWireRow(wirePath, onRow) {
 	let seq = 0;
-	for (const line of content.split("\n")) {
-		if (!line.trim()) continue;
+	let parsedRows = 0;
+	const pushLine = (line) => {
+		if (!line.trim()) return;
 		seq += 1;
+		let parsed;
 		try {
-			const rec = asRecord(JSON.parse(line));
-			if (!rec) continue;
-			const time = asNumber(rec["time"]);
-			rows.push({
-				seq,
-				time,
-				record: rec
-			});
-		} catch {}
+			parsed = JSON.parse(line);
+		} catch {
+			return;
+		}
+		const rec = asRecord(parsed);
+		if (!rec) return;
+		onRow({
+			seq,
+			time: asNumber(rec["time"]),
+			record: rec
+		});
+		parsedRows += 1;
+	};
+	const fd = openSync(wirePath, "r");
+	try {
+		const chunk = Buffer.allocUnsafe(WIRE_READ_CHUNK_BYTES);
+		let openChunks = [];
+		for (;;) {
+			const bytesRead = readSync(fd, chunk, 0, chunk.length, null);
+			if (bytesRead <= 0) break;
+			const window = bytesRead === chunk.length ? chunk : chunk.subarray(0, bytesRead);
+			let searchFrom = 0;
+			for (;;) {
+				const newlineIndex = window.indexOf(10, searchFrom);
+				if (newlineIndex === -1) break;
+				const tail = window.subarray(searchFrom, newlineIndex);
+				pushLine(openChunks.length === 0 ? tail.toString("utf8") : Buffer.concat([...openChunks, tail]).toString("utf8"));
+				openChunks = [];
+				searchFrom = newlineIndex + 1;
+			}
+			if (searchFrom < window.length) openChunks.push(Buffer.from(window.subarray(searchFrom)));
+		}
+		if (openChunks.length > 0) pushLine(Buffer.concat(openChunks).toString("utf8"));
+	} finally {
+		closeSync(fd);
 	}
-	return rows;
+	return parsedRows;
 }
 //#endregion
 //#region src/utils/trace/render-trace-html.ts
@@ -131349,8 +132159,15 @@ const SPINNER_FRAMES$1 = [
 	"◉"
 ];
 const SPINNER_TICK_MS = 60;
-function buildStatusLine(streamingPhase, streamingStartTime) {
+function buildStatusLine(streamingPhase, streamingStartTime, statusFlags) {
+	if (statusFlags.pendingUserAction === "approval") return t("status.awaiting_approval");
+	if (statusFlags.pendingUserAction === "question") return t("status.awaiting_answer");
+	if (statusFlags.isCompacting) return t("status.compacting");
 	if (streamingPhase === "idle") return t("status.idle");
+	if (statusFlags.reconnectAttempt > 0) return t("status.reconnecting_short", {
+		attempt: String(statusFlags.reconnectAttempt),
+		max: String(statusFlags.reconnectMaxAttempts ?? 0)
+	});
 	let label;
 	if (streamingPhase === "tool") label = t("status.tool");
 	else if (streamingPhase === "waiting") label = t("status.waiting");
@@ -131525,7 +132342,12 @@ var FooterComponent = class {
 		let rightText;
 		if (this.transientHint) rightText = chalk.hex(colors.warning).bold(this.transientHint);
 		else {
-			const statusLine = buildStatusLine(state.streamingPhase, state.streamingStartTime);
+			const statusLine = buildStatusLine(state.streamingPhase, state.streamingStartTime, {
+				isCompacting: state.isCompacting === true,
+				pendingUserAction: state.pendingUserAction ?? null,
+				reconnectAttempt: state.reconnectAttempt ?? 0,
+				reconnectMaxAttempts: state.reconnectMaxAttempts
+			});
 			const ccDot = state.ccConnectActive ? chalk.hex(colors.success)("●") : chalk.hex(colors.textDim)("●");
 			const sessionUsage = state.sessionUsage ?? {
 				inputOther: 0,
@@ -134065,7 +134887,7 @@ async function guidedGoalSetup(host) {
 		host.showNotice(t("goal.storm_breaker"), t("goal.conflict_loop"));
 		return;
 	}
-	const { TextInputDialogComponent } = await import("./text-input-dialog-CNhL-3wm.mjs");
+	const { TextInputDialogComponent } = await import("./text-input-dialog-Cj0egbsU.mjs");
 	const initialDesc = await promptText(host, TextInputDialogComponent, {
 		title: t("goal.setup_title_initial"),
 		subtitle: t("goal.setup_desc_hint"),
@@ -134086,7 +134908,7 @@ async function guidedGoalSetup(host) {
 	await showGoalConfigWizard(host, session, confirmed.trim() || objective, false);
 }
 async function showGoalConfigWizard(host, session, objective, replace) {
-	const { TextInputDialogComponent } = await import("./text-input-dialog-CNhL-3wm.mjs");
+	const { TextInputDialogComponent } = await import("./text-input-dialog-Cj0egbsU.mjs");
 	const turnInput = await promptNumber(host, TextInputDialogComponent, {
 		title: t("goal.wizard_title", { objective }),
 		subtitle: t("goal.budget_turns_hint"),
@@ -134940,9 +135762,9 @@ function formatTokens$1(n) {
 * Builds the bullet + text of a background task notice. Shared by the standalone
 * card and the activity block row so a notice looks the same in both places.
 */
-function renderBackgroundStatus(data, colors, maxCells) {
+function renderBackgroundStatus(data, colors, maxCells, frameIndex = 0) {
 	const tone = data.phase === "started" ? colors.primary : data.phase === "completed" ? colors.success : colors.error;
-	const bullet = data.phase === "completed" ? chalk.hex(colors.success)(DONE_MARK) : data.phase === "failed" ? chalk.hex(colors.error)(FAILURE_MARK) : chalk.hex(colors.textDim)(`${BRAILLE_SPINNER_FRAMES[0] ?? "⠋"} `);
+	const bullet = data.phase === "completed" ? chalk.hex(colors.success)(DONE_MARK) : data.phase === "failed" ? chalk.hex(colors.error)(FAILURE_MARK) : chalk.hex(colors.textDim)(`${BRAILLE_SPINNER_FRAMES[frameIndex] ?? BRAILLE_SPINNER_FRAMES[0] ?? "⠋"} `);
 	const hasDetail = data.detail !== void 0 && data.detail.length > 0;
 	const plain = hasDetail ? `${data.headline} (${data.detail ?? ""})` : data.headline;
 	if (maxCells !== void 0 && visibleWidth(plain) > maxCells) return {
@@ -134957,29 +135779,81 @@ function renderBackgroundStatus(data, colors, maxCells) {
 var BackgroundAgentStatusComponent = class {
 	data;
 	colors;
-	bullet;
+	ui;
 	textComponent;
 	cachedWidth;
 	cachedLines;
-	constructor(data, colors) {
+	spinnerFrame = 0;
+	spinnerTimer;
+	lastSpinnerTickAt = 0;
+	/** Only a notice that is still running animates; a finished one is static. */
+	live;
+	constructor(data, colors, ui) {
 		this.data = data;
 		this.colors = colors;
-		const view = renderBackgroundStatus(data, colors);
-		this.bullet = view.bullet;
-		this.textComponent = new Text(view.text, 0, 0);
+		this.ui = ui;
+		this.textComponent = new Text(renderBackgroundStatus(data, colors).text, 0, 0);
+		this.live = data.phase === "started" && ui !== void 0;
+		if (this.live) this.startSpinner();
 	}
 	invalidate() {
 		this.cachedWidth = void 0;
 		this.cachedLines = void 0;
 	}
+	dispose() {
+		this.stopSpinner();
+	}
+	/**
+	* The task this card announced is over: stop the ticker and fall back to the
+	* first frame, then let the cache answer again. Without the reset a settled
+	* card would keep whatever frame it froze on, which reads as a stuck spinner.
+	*/
+	settle() {
+		this.stopSpinner();
+		this.live = false;
+		if (this.spinnerFrame === 0) return;
+		this.spinnerFrame = 0;
+		this.invalidate();
+	}
 	render(width) {
-		if (this.cachedLines !== void 0 && this.cachedWidth === width) return this.cachedLines;
+		if (!this.live && this.cachedLines !== void 0 && this.cachedWidth === width) return this.cachedLines;
+		const view = renderBackgroundStatus(this.data, this.colors, void 0, this.spinnerFrame);
 		const contentWidth = Math.max(1, width - 2);
-		const lines = ["", ...this.textComponent.render(contentWidth).map((line, index) => (index === 0 ? this.bullet : "  ") + line)];
+		const lines = ["", ...this.textComponent.render(contentWidth).map((line, index) => (index === 0 ? view.bullet : "  ") + line)];
 		this.cachedWidth = width;
 		this.cachedLines = lines;
 		return lines;
 	}
+	startSpinner() {
+		if (this.spinnerTimer !== void 0) return;
+		this.lastSpinnerTickAt = performance.now();
+		this.scheduleSpinnerTick(80);
+	}
+	stopSpinner() {
+		if (this.spinnerTimer === void 0) return;
+		clearTimeout(this.spinnerTimer);
+		this.spinnerTimer = void 0;
+	}
+	scheduleSpinnerTick(delayMs) {
+		if (this.ui === void 0) return;
+		const timer = setTimeout(() => {
+			if (this.spinnerTimer !== timer) return;
+			const startedAt = performance.now();
+			const elapsed = startedAt - this.lastSpinnerTickAt;
+			if (elapsed >= 80) {
+				const steps = Math.floor(elapsed / 80);
+				this.spinnerFrame = (this.spinnerFrame + steps) % BRAILLE_SPINNER_FRAMES.length;
+				this.lastSpinnerTickAt += steps * 80;
+				this.invalidate();
+				this.ui?.requestRender();
+			}
+			const frameCostMs = performance.now() - startedAt;
+			if (this.spinnerTimer !== timer) return;
+			const cadenceDelayMs = Math.max(0, 80 - frameCostMs);
+			this.scheduleSpinnerTick(Math.max(cadenceDelayMs, frameCostMs * 9));
+		}, delayMs);
+		this.spinnerTimer = timer;
+	}
 };
 //#endregion
 //#region src/tui/utils/activity-lines.ts
@@ -135412,7 +136286,7 @@ var ActivityGroupComponent = class extends Container {
 		this.addChild(this.bodyContainer);
 		this.startSpinner();
 	}
-	/** True when the group owns neither reasoning nor tool calls. */
+	/** True when the group owns neither reasoning nor tool calls nor approvals. */
 	isEmpty() {
 		return this.segments.every((segment) => segment.kind === "thinking" && segment.text.trim().length === 0);
 	}
@@ -135421,14 +136295,16 @@ var ActivityGroupComponent = class extends Container {
 	}
 	/**
 	* Borrows a tool card as a hidden state container. Re-attaching the same
-	* card is a no-op.
+	* card is a no-op. `callId` is what later lets an approval be filed under the
+	* call it allowed.
 	*/
-	attachTool(tc, step) {
+	attachTool(tc, step, callId) {
 		if (this.segments.some((segment) => segment.kind === "tool" && segment.tc === tc)) return;
 		this.segments.push({
 			kind: "tool",
 			tc,
-			step
+			step,
+			callId
 		});
 		if (step !== void 0) this.steps.add(step);
 		tc.setExpanded(this.expanded);
@@ -135439,14 +136315,7 @@ var ActivityGroupComponent = class extends Container {
 	}
 	/** Adds a background task notice as the newest step of the timeline. */
 	attachNotice(data) {
-		const last = this.segments.at(-1);
-		if (last !== void 0 && last.kind === "thinking" && last.live) {
-			last.live = false;
-			this.interruptedThinking = {
-				text: last.text,
-				length: last.text.length
-			};
-		}
+		this.splitLiveThinking();
 		this.segments.push({
 			kind: "notice",
 			data
@@ -135454,6 +136323,38 @@ var ActivityGroupComponent = class extends Container {
 		this.flushNow();
 	}
 	/**
+	* Adds an approval outcome as the step directly under the call it allowed, so
+	* a run of approved calls reads as call/approval pairs. Returns false when
+	* that call has no row here — a subagent's call, a card that stays standalone
+	* — leaving the caller to decide where the outcome goes.
+	*/
+	attachApproval(callId, label, detail, tone) {
+		const index = this.segments.findIndex((segment) => segment.kind === "tool" && segment.callId === callId);
+		if (index < 0) return false;
+		this.segments.splice(index + 1, 0, {
+			kind: "approval",
+			label,
+			detail,
+			tone
+		});
+		this.flushNow();
+		return true;
+	}
+	/**
+	* A step landing mid-reasoning splits the run in two: the part that already
+	* streamed is closed and its length remembered, so the continuation keeps only
+	* what is new instead of repeating the whole run.
+	*/
+	splitLiveThinking() {
+		const last = this.segments.at(-1);
+		if (last === void 0 || last.kind !== "thinking" || !last.live) return;
+		last.live = false;
+		this.interruptedThinking = {
+			text: last.text,
+			length: last.text.length
+		};
+	}
+	/**
 	* Appends to the reasoning run streaming right now, opening a new step of the
 	* timeline when the last step is a tool call or a reasoning run that already
 	* ended. `live` drives the streaming rate in the header.
@@ -135564,10 +136465,14 @@ var ActivityGroupComponent = class extends Container {
 	* Aggregate diff of the group's finished, successful file mutations
 	* (Edit/Write), shown in the header. Read-only tools contribute nothing;
 	* failed attempts changed nothing, so only successful calls count.
+	* `removed` stays undefined when any contributor could not report its
+	* deletions (replayed records carry no display payload): summing a partial
+	* number would claim a deletion count the group never measured.
 	*/
 	diffTotals() {
 		let added = 0;
 		let removed = 0;
+		let removedKnown = true;
 		let seen = false;
 		for (const segment of this.segments) {
 			if (segment.kind !== "tool") continue;
@@ -135575,12 +136480,14 @@ var ActivityGroupComponent = class extends Container {
 			if (contribution === void 0) continue;
 			seen = true;
 			added += contribution.added;
-			removed += contribution.removed;
+			if (contribution.removed === void 0) removedKnown = false;
+			else removed += contribution.removed;
 		}
-		return seen ? {
+		if (!seen) return void 0;
+		return {
 			added,
-			removed
-		} : void 0;
+			removed: removedKnown ? removed : void 0
+		};
 	}
 	buildHeader(width) {
 		const colors = this.colors;
@@ -135593,10 +136500,10 @@ var ActivityGroupComponent = class extends Container {
 		if (toolCount > 0) parts.push(t("activitygroup.tools", { count: String(toolCount) }));
 		const stats = chalk.dim(SEPARATOR + parts.join(SEPARATOR));
 		const diff = this.diffTotals();
-		const diffPart = diff ? SEPARATOR + t("activitygroup.diff", {
+		const diffPart = diff ? SEPARATOR + (diff.removed === void 0 ? t("activitygroup.diffAddedOnly", { added: chalk.hex(colors.diffAdded)(`+${diff.added}`) }) : t("activitygroup.diff", {
 			added: chalk.hex(colors.diffAdded)(`+${diff.added}`),
 			removed: chalk.hex(colors.diffRemoved)(`-${diff.removed}`)
-		}) : "";
+		})) : "";
 		const speed = this.liveThinking() ? getSharedSpeedTracker().getSpeed() : 0;
 		const rate = speed > MIN_RATE ? chalk.hex(lerpHex(colors.textDim, colors.primary, easeSpeedRatio(speed / 200)))(t("activitygroup.rate", { rate: speed.toFixed(1) })) : chalk.dim(t("activitygroup.rate", { rate: "-" }));
 		const hint = chalk.dim(this.expanded ? t("activitygroup.hint_collapse") : t("activitygroup.hint_expand"));
@@ -135630,6 +136537,10 @@ var ActivityGroupComponent = class extends Container {
 				this.bodyContainer.addChild(this.noticeRow(segment.data, width, isLast));
 				return;
 			}
+			if (segment.kind === "approval") {
+				this.bodyContainer.addChild(this.approvalRow(segment, width, isLast));
+				return;
+			}
 			this.bodyContainer.addChild(this.thinkingSummaryRow(segment, width, isLast));
 		});
 	}
@@ -135675,15 +136586,30 @@ var ActivityGroupComponent = class extends Container {
 			components: [this.noticeRow(segment.data, width, isLast)],
 			cost: 1
 		};
+		if (segment.kind === "approval") return {
+			components: [this.approvalRow(segment, width, isLast)],
+			cost: 1
+		};
 		return this.thinkingSegmentRows(segment, width, isLast);
 	}
 	/** One background task notice, kept to a single row. */
 	noticeRow(data, width, isLast) {
 		const prefix = isLast ? BRANCH_LAST : BRANCH_FIRST;
-		const view = renderBackgroundStatus(data, this.colors, Math.max(1, width - visibleWidth(prefix) - NOTICE_BULLET_WIDTH));
+		const view = renderBackgroundStatus(data, this.colors, Math.max(1, width - visibleWidth(prefix) - NOTICE_BULLET_WIDTH), this.spinnerFrame);
 		return new Text(`${prefix}${view.bullet}${view.text}`, 0, 0);
 	}
 	/**
+	* One approval outcome, kept to a single row. Approvals read as a quiet note
+	* next to the work they allowed — dim, unlike a rejection, which keeps the
+	* error tone so a denied call is never mistaken for an allowed one.
+	*/
+	approvalRow(segment, width, isLast) {
+		const prefix = isLast ? BRANCH_LAST : BRANCH_FIRST;
+		const tone = segment.tone === "rejected" ? this.colors.error : this.colors.textDim;
+		const plain = `${segment.label}${SEPARATOR}${segment.detail}`;
+		return new Text(`${prefix}${chalk.hex(tone)(truncateToWidth(plain, Math.max(1, width - visibleWidth(prefix)), "…"))}`, 0, 0);
+	}
+	/**
 	* One reasoning run: a label row plus as many of its lines as its own budget
 	* allows. Lines keep their order; the oldest end of a live run (or the newest
 	* end of a finished one) is dropped until the budget fits.
@@ -135696,7 +136622,7 @@ var ActivityGroupComponent = class extends Container {
 			cost: 0
 		};
 		const continuation = isLast ? THINKING_BODY_PREFIX : BRANCH_PIPE;
-		const components = [new Text(`${isLast ? BRANCH_LAST : BRANCH_FIRST}${chalk.hex(colors.roleThinking)(t("activitygroup.thinking_label"))}`, 0, 0)];
+		const components = [new Text(`${isLast ? BRANCH_LAST : BRANCH_FIRST}${this.thinkingGlyph(segment)}${chalk.hex(colors.roleThinking)(t("activitygroup.thinking_label"))}`, 0, 0)];
 		let cost = 1;
 		const budget = getActivityLines().expandedThinking;
 		const inner = Math.max(1, width - visibleWidth(continuation));
@@ -135757,6 +136683,16 @@ var ActivityGroupComponent = class extends Container {
 			aborted: cardMarkerChar(rawHeader) === "⊙"
 		};
 	}
+	/** Mirrors a tool row's status prefix so reasoning and tool rows line up: a
+	*  live run spins with the block frame, a finished run takes the success mark
+	*  (`DONE_MARK` carries its own trailing space, so the column stays 2 cells). */
+	thinkingGlyph(segment) {
+		if (segment.live) {
+			const frame = BRAILLE_SPINNER_FRAMES[this.spinnerFrame] ?? BRAILLE_SPINNER_FRAMES[0];
+			return `${chalk.hex(this.colors.roleThinking)(frame)} `;
+		}
+		return chalk.hex(this.colors.success)(DONE_MARK);
+	}
 	/** Mirrors the card's own status: running spins, failed/aborted stay visible. */
 	statusGlyph(row) {
 		if (row.aborted) return chalk.hex(this.colors.error)("⊙");
@@ -135775,10 +136711,27 @@ var ActivityGroupComponent = class extends Container {
 	thinkingSummaryRow(segment, width, isLast) {
 		const first = thinkingLines(segment.text)[0] ?? "";
 		const label = t("activitygroup.thinking_summary", { summary: "" });
-		const used = visibleWidth(isLast ? BRANCH_LAST : BRANCH_FIRST) + visibleWidth(label);
+		const prefix = isLast ? BRANCH_LAST : BRANCH_FIRST;
+		const used = visibleWidth(prefix) + visibleWidth(this.thinkingGlyph(segment)) + visibleWidth(label);
 		const cells = Math.max(1, width - used - 1);
 		const summary = chalk.hex(this.colors.roleThinking)(t("activitygroup.thinking_summary", { summary: truncateToWidth(first, cells, "…") }));
-		return new Text(`${isLast ? BRANCH_LAST : BRANCH_FIRST}${summary}`, 0, 0);
+		return new Text(`${prefix}${this.thinkingGlyph(segment)}${summary}`, 0, 0);
+	}
+	/**
+	* True while at least one visible row carries a live animation. Reasoning rows
+	* spin too now, and a background task that is still running keeps its glyph
+	* moving, so this can no longer be "collapsed with a pending tool": the only
+	* question is whether repainting the body on this tick would show anything new.
+	* Finished rows stay static by design.
+	*/
+	needsRowAnimation() {
+		if (!this.running) return false;
+		for (const segment of this.segments) {
+			if (segment.kind === "thinking" && segment.live) return true;
+			if (segment.kind === "notice" && segment.data.phase === "started") return true;
+			if (segment.kind === "tool" && segment.tc.resultView === void 0) return true;
+		}
+		return false;
 	}
 	scheduleSpinnerTick(delayMs) {
 		if (this.ui === void 0) return;
@@ -135791,7 +136744,7 @@ var ActivityGroupComponent = class extends Container {
 				this.spinnerFrame = (this.spinnerFrame + steps) % BRAILLE_SPINNER_FRAMES.length;
 				this.lastSpinnerTickAt += steps * 80;
 				const width = this.renderedWidth ?? 80;
-				if (!this.expanded && this.segments.some((segment) => segment.kind === "tool" && segment.tc.resultView === void 0)) this.rebuild(width);
+				if (this.needsRowAnimation()) this.rebuild(width);
 				else this.headerText.setText(this.buildHeader(width));
 				this.ui?.requestRender();
 			}
@@ -138008,9 +138961,24 @@ var ToolCallComponent = class ToolCallComponent extends CachedContainer {
 	* additions), for the group-level diff stat in the activity block header.
 	* Undefined for non-mutating tools, unfinished calls, and failed calls: a
 	* failure changed nothing, so it must not count towards the group total.
+	*
+	* The mutation tools report their exact numbers (`display.file_diff`) computed
+	* from the real before/after contents. Groups replayed from a resumed session
+	* carry no such payload (the transcript keeps message text, not the UI
+	* payload), so they fall back to deriving the numbers from the arguments — a
+	* fallback that cannot know how many lines a Write replaced, so it reports
+	* `removed: undefined` ("unknown") instead of claiming zero.
 	*/
 	diffContribution() {
 		if (this.result === void 0 || this.result.is_error) return void 0;
+		const reported = this.result.display;
+		if (reported?.kind === "file_diff") {
+			if (reported.added === 0 && reported.removed === 0) return void 0;
+			return {
+				added: reported.added,
+				removed: reported.removed
+			};
+		}
 		if (this.toolCall.name === "Edit") {
 			const stats = computeEditStats(this.toolCall.args);
 			if (stats.added === 0 && stats.removed === 0) return void 0;
@@ -138021,7 +138989,7 @@ var ToolCallComponent = class ToolCallComponent extends CachedContainer {
 			if (stats.lines === 0) return void 0;
 			return {
 				added: stats.lines,
-				removed: 0
+				removed: void 0
 			};
 		}
 	}
@@ -138493,7 +139461,7 @@ var ToolCallComponent = class ToolCallComponent extends CachedContainer {
 		if (provider === void 0) return "";
 		const text = provider(this.toolCall, result);
 		if (text.length === 0) return "";
-		return (result.is_error ? chalk.hex(this.colors.error) : chalk.dim)(` · ${text}`);
+		return chalk.dim(` · ${text}`);
 	}
 	rebuildContent() {
 		this.markDirty();
@@ -138860,7 +139828,7 @@ var ToolCallComponent = class ToolCallComponent extends CachedContainer {
 		else this.addChild(new Text(chalk.dim(plan), 2, 0));
 	}
 	computePlanBoxMaxContentLines() {
-		const rows = this.ui?.terminal.rows;
+		const rows = this.ui?.terminal?.rows;
 		if (rows === void 0 || !Number.isFinite(rows) || rows <= 0) return void 0;
 		return Math.max(8, Math.floor(rows * .6) - 4);
 	}
@@ -143736,18 +144704,18 @@ async function handleIngest(host) {
 async function ensureEmbeddingReadyInteractive(host) {
 	const engine = (await getKnowledgeStore()).getEmbeddingEngine();
 	if (engine !== void 0 && engine.available) return true;
-	if (!isEmbeddingModelCached()) {
+	if (!hasEmbeddingModelCache()) {
 		host.showError(t("knowledge.model_missing"));
 		return false;
 	}
 	const spinner = host.showProgressSpinner(t("knowledge.loading_model"));
-	const { ok, error } = await startManualEmbeddingDownload();
+	const { ok, error, failureKind } = await startManualEmbeddingDownload();
 	spinner.stop({
 		ok,
 		label: ok ? t("kw.embedding_ready") : t("kw.embedding_failed")
 	});
 	if (!ok) {
-		const detail = [t("knowledge.download_model_retry_hint"), error].filter(Boolean).join("\n");
+		const detail = embeddingFailureDetail(failureKind, error);
 		host.showNotice(t("knowledge.model_load_failed"), detail);
 		return false;
 	}
@@ -143994,17 +144962,17 @@ async function handleReembed(host) {
 	}
 }
 async function handleDownloadModel(host) {
-	await getKnowledgeStore();
 	const spinner = host.showProgressSpinner(t("kw.embedding_downloading"));
 	try {
-		const { ok, alreadyReady, error } = await startManualEmbeddingDownload();
+		await getKnowledgeStore();
+		const { ok, alreadyReady, error, failureKind } = await startManualEmbeddingDownload();
 		spinner.stop({
 			ok,
 			label: ok ? t("kw.embedding_ready") : t("kw.embedding_failed")
 		});
 		if (ok) host.showStatus(alreadyReady ? t("kw.embedding_already_installed") : t("kw.embedding_ready"));
 		else {
-			const detail = [t("knowledge.download_model_retry_hint"), error].filter(Boolean).join("\n");
+			const detail = embeddingFailureDetail(failureKind, error);
 			host.showNotice(t("kw.embedding_failed"), detail);
 		}
 	} catch (error) {
@@ -144772,4 +145740,4 @@ async function handleBuiltInSlashCommand(host, name, args) {
 	}
 }
 //#endregion
-export { handleExportMdCommand as $, readSessionIndex as $n, SubagentSlots as $t, langFromPath as A, startManualEmbeddingDownload as An, toggleEmptySessionHint as At, charsForTokenBudget as B, getLogDir as Bn, OSC11_QUERY as Bt, getDaemonInstructions as C, buildSkillSlashCommands as Cn, showStatusReport as Ct, renderDiffLines as D, setExperimentalFlags as Dn, createMarkdownTheme as Dt, ToolCallComponent as E, isExperimentalFlagEnabled as En, createEditorTheme as Et, replaceTabs as F, loadTuiConfig as Fn, parseOsc11BackgroundTheme as Ft, WelcomeComponent as G, PRODUCT_NAME as Gn, TERMINAL_FOCUS_IN as Gt, getSharedSpeedTracker as H, CLI_COMMAND_NAME as Hn, OSC11_RESPONSE_PREFIX as Ht, sanitizeShellOutput as I, saveTuiConfig as In, DISABLE_TERMINAL_FOCUS_REPORTING as It, resetBreathingClock as J, saveCatalogCache as Jn, TERMINAL_THEME_LIGHT as Jt, BREATHE_CYCLE_MS as K, DEFAULT_CATALOG_URL as Kn, TERMINAL_FOCUS_OUT as Kt, SkillActivationComponent as L, detectShellEnvironment as Ln, DISABLE_TERMINAL_THEME_REPORTING as Lt, ThinkingComponent as M, PULSE_WAVE_FRAMES as Mn, contrastTextHex as Mt, NoticeMessageComponent as N, TuiConfigParseError as Nn, getColorPalette as Nt, renderDiffLinesClustered as O, getKnowledgeStore as On, isEmptySessionHintDismissed as Ot, StatusMessageComponent as P, TuiLikePreferencesSchema as Pn, detectTerminalTheme as Pt, handleExportDebugZipCommand as Q, appendSessionIndexEntry as Qn, lerpGradient as Qt, AssistantMessageComponent as R, getDataDir as Rn, ENABLE_TERMINAL_FOCUS_REPORTING as Rt, handleCcCommand as S, getNoActiveSessionMessage as Sn, clearInfoPanelState as St, UserMessageComponent as T, sortSlashCommands as Tn, resolveThemeSync as Tt, BackgroundAgentStatusComponent as U, CLI_UI_MODE as Un, OSC11_RESPONSE_PREFIX_NO_ESC as Ut, estimateTokens as V, detectInstallSource as Vn, OSC11_RESPONSE as Vt, AgentGroupComponent as W, CLI_USER_AGENT_PRODUCT as Wn, QUERY_TERMINAL_THEME as Wt, clearGoalState as X, encodeWorkDirKey as Xn, isStreaming as Xt, CompactionComponent as Y, ScreamHarness as Yn, isBusy as Yt, refineGoal as Z, normalizeWorkDir as Zn, FooterComponent as Zt, selectUpdateTarget as _, SESSION_TIPS as _n, showModelPicker as _t, handleExtensionCommand as a, STATUS_BULLET as an, log as ar, changeThinkingLevel as at, appendJsonlLine as b, getCtrlDHint as bn, refreshProviderBalance as bt, hasDispose as c, formatErrorMessage as cn, isOrphanedToolCallError as cr, handleBotCommand as ct, MoonLoader as d, serializeToolResultOutput as dn, handleFusionPlanCommand as dt, handleTraceCommand as en, removeSessionIndexEntry as er, handleForkCommand as et, formatMemoryMemoForInjection as f, stringValue as fn, handleModelCommand as ft, handleUpdateCommand as g, MAIN_AGENT_ID$1 as gn, handleYoloCommand as gt, handleMcpCommand as h, EXIT_CONFIRM_WINDOW_MS as hn, handleWolfpackCommand as ht, buildRoleAdditionalText as i, printableChar as in, flushDiagnosticLogs as ir, toTerminalHyperlink as it, CachedContainer as j, PIXEL_PULSE_FRAMES as jn, createThemeStyles as jt, highlightLines as k, isEmbeddingModelCached as kn, isTurnElapsedEnabled as kt, isExpandable as l, isTodoItemShape as ln, ErrorCodes as lr, handleCompactCommand as lt, handleChannelCommand as m, EMPTY_SESSION_HINT_URL as mn, handleThemeCommand as mt, clearEvalPanelState as n, handleConnectCommand as nn, resolveScreamHome as nr, handleTitleCommand as nt, handleSkillCommand as o, appendStreamingArgsPreview as on, resolveGlobalLogPath as or, getModelCycleLevel as ot, handleMemoryCommand as p, truncateErrorMessage as pn, handlePlanCommand as pt, getBreathingFrame as q, fetchCatalog as qn, TERMINAL_THEME_DARK as qt, openUrl as r, handleLogoutCommand as rn, MemoryMemoStore as rr, isInternalMessage as rt, disposeChildren as s, argsRecord as sn, isScreamError as sr, handleAutoCommand as st, dispatchInput as t, handleSearchCommand as tn, MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE as tr, handleInitCommand as tt, isPlanExpandable as u, parseStreamingArgs as un, SCREAM_ERROR_INFO as ur, handleEditorCommand as ut, refreshUpdateCache as v, TIP_ROTATION_INTERVAL_MS as vn, showPermissionPicker as vt, handleRevokeCommand as w, BUILTIN_SLASH_COMMANDS as wn, showUsage as wt, readJsonlFile as x, getLlmNotSetMessage as xn, supportsBalance as xt, readUpdateCache as y, getCtrlCHint as yn, showSettingsSelector as yt, ActivityGroupComponent as z, getInputHistoryFile as zn, ENABLE_TERMINAL_THEME_REPORTING as zt };
+export { handleExportMdCommand as $, appendSessionIndexEntry as $n, SubagentSlots as $t, langFromPath as A, hasEmbeddingModelCache as An, toggleEmptySessionHint as At, charsForTokenBudget as B, getInputHistoryFile as Bn, OSC11_QUERY as Bt, getDaemonInstructions as C, buildSkillSlashCommands as Cn, showStatusReport as Ct, renderDiffLines as D, setExperimentalFlags as Dn, createMarkdownTheme as Dt, ToolCallComponent as E, isExperimentalFlagEnabled as En, createEditorTheme as Et, replaceTabs as F, TuiLikePreferencesSchema as Fn, parseOsc11BackgroundTheme as Ft, WelcomeComponent as G, CLI_USER_AGENT_PRODUCT as Gn, TERMINAL_FOCUS_IN as Gt, getSharedSpeedTracker as H, detectInstallSource as Hn, OSC11_RESPONSE_PREFIX as Ht, sanitizeShellOutput as I, loadTuiConfig as In, DISABLE_TERMINAL_FOCUS_REPORTING as It, resetBreathingClock as J, fetchCatalog as Jn, TERMINAL_THEME_LIGHT as Jt, BREATHE_CYCLE_MS as K, PRODUCT_NAME as Kn, TERMINAL_FOCUS_OUT as Kt, SkillActivationComponent as L, saveTuiConfig as Ln, DISABLE_TERMINAL_THEME_REPORTING as Lt, ThinkingComponent as M, PIXEL_PULSE_FRAMES as Mn, contrastTextHex as Mt, NoticeMessageComponent as N, PULSE_WAVE_FRAMES as Nn, getColorPalette as Nt, renderDiffLinesClustered as O, embeddingFailureDetail as On, isEmptySessionHintDismissed as Ot, StatusMessageComponent as P, TuiConfigParseError as Pn, detectTerminalTheme as Pt, handleExportDebugZipCommand as Q, normalizeWorkDir as Qn, lerpGradient as Qt, AssistantMessageComponent as R, detectShellEnvironment as Rn, ENABLE_TERMINAL_FOCUS_REPORTING as Rt, handleCcCommand as S, getNoActiveSessionMessage as Sn, clearInfoPanelState as St, UserMessageComponent as T, sortSlashCommands as Tn, resolveThemeSync as Tt, BackgroundAgentStatusComponent as U, CLI_COMMAND_NAME as Un, OSC11_RESPONSE_PREFIX_NO_ESC as Ut, estimateTokens as V, getLogDir as Vn, OSC11_RESPONSE as Vt, AgentGroupComponent as W, CLI_UI_MODE as Wn, QUERY_TERMINAL_THEME as Wt, clearGoalState as X, ScreamHarness as Xn, isStreaming as Xt, CompactionComponent as Y, saveCatalogCache as Yn, isBusy as Yt, refineGoal as Z, encodeWorkDirKey as Zn, FooterComponent as Zt, selectUpdateTarget as _, SESSION_TIPS as _n, showModelPicker as _t, handleExtensionCommand as a, STATUS_BULLET as an, flushDiagnosticLogs as ar, changeThinkingLevel as at, appendJsonlLine as b, getCtrlDHint as bn, refreshProviderBalance as bt, hasDispose as c, formatErrorMessage as cn, isScreamError as cr, handleBotCommand as ct, MoonLoader as d, serializeToolResultOutput as dn, SCREAM_ERROR_INFO as dr, handleFusionPlanCommand as dt, handleTraceCommand as en, readSessionIndex as er, handleForkCommand as et, formatMemoryMemoForInjection as f, stringValue as fn, handleModelCommand as ft, handleUpdateCommand as g, MAIN_AGENT_ID$1 as gn, handleYoloCommand as gt, handleMcpCommand as h, EXIT_CONFIRM_WINDOW_MS as hn, handleWolfpackCommand as ht, buildRoleAdditionalText as i, printableChar as in, MemoryMemoStore as ir, toTerminalHyperlink as it, CachedContainer as j, startManualEmbeddingDownload as jn, createThemeStyles as jt, highlightLines as k, getKnowledgeStore as kn, isTurnElapsedEnabled as kt, isExpandable as l, isTodoItemShape as ln, isOrphanedToolCallError as lr, handleCompactCommand as lt, handleChannelCommand as m, EMPTY_SESSION_HINT_URL as mn, handleThemeCommand as mt, clearEvalPanelState as n, handleConnectCommand as nn, MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE as nr, handleTitleCommand as nt, handleSkillCommand as o, appendStreamingArgsPreview as on, log as or, getModelCycleLevel as ot, handleMemoryCommand as p, truncateErrorMessage as pn, handlePlanCommand as pt, getBreathingFrame as q, DEFAULT_CATALOG_URL as qn, TERMINAL_THEME_DARK as qt, openUrl as r, handleLogoutCommand as rn, resolveScreamHome as rr, isInternalMessage as rt, disposeChildren as s, argsRecord as sn, resolveGlobalLogPath as sr, handleAutoCommand as st, dispatchInput as t, handleSearchCommand as tn, removeSessionIndexEntry as tr, handleInitCommand as tt, isPlanExpandable as u, parseStreamingArgs as un, ErrorCodes as ur, handleEditorCommand as ut, refreshUpdateCache as v, TIP_ROTATION_INTERVAL_MS as vn, showPermissionPicker as vt, handleRevokeCommand as w, BUILTIN_SLASH_COMMANDS as wn, showUsage as wt, readJsonlFile as x, getLlmNotSetMessage as xn, supportsBalance as xt, readUpdateCache as y, getCtrlCHint as yn, showSettingsSelector as yt, ActivityGroupComponent as z, getDataDir as zn, ENABLE_TERMINAL_THEME_REPORTING as zt };