scream-code 0.16.4 → 0.16.5

package/dist/{dispatch-La1sAZPF.mjs → dispatch-VY-K2oXV.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-KaFgI_Ko.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);
@@ -69519,6 +69534,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 +69928,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 +70024,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 +70085,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 +70109,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 +75791,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 +75855,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 +75864,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 +75889,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 +86260,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 +86280,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 startsWithAnyPrefix(data, prefixes) {
-	return prefixes.some((prefix) => startsWithPrefix(data, 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;
+	}
+}
+/** 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 +86325,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 +86336,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 +86534,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 +86549,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 +86565,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 +86590,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 +86601,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 +87022,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 +87109,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 +87124,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 +87189,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 +87203,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 +95546,8 @@ async function executeLoopStep(deps) {
 			dispatchEvent,
 			turnId,
 			currentStep,
-			stepUuid
+			stepUuid,
+			onStreamingDraft: deps.onStreamingDraft ?? (() => {})
 		})
 	};
 	let response;
@@ -95175,18 +95681,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 +95765,7 @@ function createChatStreamingCallbacks(deps) {
 		},
 		onTextPart: async (part) => {
 			const index = textIndex++;
+			draftTracker.clear();
 			await dispatchEvent({
 				type: "block.start",
 				uuid: randomUUID(),
@@ -95231,6 +95795,7 @@ function createChatStreamingCallbacks(deps) {
 		},
 		onThinkPart: async (part) => {
 			const index = thinkIndex++;
+			draftTracker.clear();
 			await dispatchEvent({
 				type: "block.start",
 				uuid: randomUUID(),
@@ -95310,7 +95875,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 +102108,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 +102794,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 +103100,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 +122265,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 +122376,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 +122385,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 +122704,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 +122740,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 +123658,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 +123725,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 +123757,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 +124247,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 +124261,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 +124298,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 +124325,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 {
@@ -129573,8 +130234,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 +130251,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 +130419,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 +130523,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 +130555,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
@@ -134065,7 +134769,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-CQ6R2lns.mjs");
 	const initialDesc = await promptText(host, TextInputDialogComponent, {
 		title: t("goal.setup_title_initial"),
 		subtitle: t("goal.setup_desc_hint"),
@@ -134086,7 +134790,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-CQ6R2lns.mjs");
 	const turnInput = await promptNumber(host, TextInputDialogComponent, {
 		title: t("goal.wizard_title", { objective }),
 		subtitle: t("goal.budget_turns_hint"),
@@ -135564,10 +136268,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 +136283,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 +136303,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"));
@@ -138008,9 +138718,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 +138746,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 +139218,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();