scream-code 0.6.7 → 0.6.9

package/dist/{app-NYV7g66W.mjs → app-BRE6Pm0i.mjs}

@@ -43,10 +43,11 @@ import * as z4mini from "zod/v4-mini";
 import process$1 from "node:process";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Command, Option } from "commander";
-import { CombinedAutocompleteProvider, Container, Editor, Image, Input, Key, Markdown, ProcessTerminal, Spacer, TUI, Text, decodeKittyPrintable, deleteAllKittyImages, fuzzyFilter, fuzzyMatch, getCapabilities, isKeyRelease, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { CombinedAutocompleteProvider, Container, Editor, Image, Input, Key, Markdown, ProcessTerminal, Spacer, TUI, Text, decodeKittyPrintable, deleteAllKittyImages, fuzzyFilter, fuzzyMatch, getCapabilities, getImageDimensions, isKeyRelease, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import chalk, { chalkStderr } from "chalk";
 import { createInterface } from "node:readline/promises";
 import { highlight, supportsLanguage } from "cli-highlight";
+import { diffWords } from "diff";
 import { gt, valid } from "semver";
 import { createInterface as createInterface$1 } from "node:readline";
 //#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
@@ -731,6 +732,49 @@ function createToolMessage(toolCallId, output) {
 	};
 }
 //#endregion
+//#region ../../packages/ltod/src/rate-limit-utils.ts
+const QUOTA_EXHAUSTED_BACKOFF_MS = 1800 * 1e3;
+const RATE_LIMIT_EXCEEDED_BACKOFF_MS = 30 * 1e3;
+const MODEL_CAPACITY_BASE_MS = 45 * 1e3;
+const MODEL_CAPACITY_JITTER_MS = 30 * 1e3;
+const SERVER_ERROR_BACKOFF_MS = 20 * 1e3;
+const ACCOUNT_RATE_LIMIT_PATTERN = /\baccount(?:'s)?\b[^\n]{0,80}\brate.?limit\b|\brate.?limit\b[^\n]{0,80}\baccount\b/i;
+const INSUFFICIENT_BALANCE_PATTERN = /insufficient.?balance/i;
+/**
+* Classify a rate-limit error message into a reason category.
+*
+* Priority: QUOTA (explicit "quota will reset") > MODEL_CAPACITY > QUOTA (account)
+* > RATE_LIMIT > QUOTA (generic) > SERVER_ERROR > UNKNOWN.
+*
+* "quota will reset" / "exhausted your capacity" short-circuits to QUOTA before
+* the MODEL_CAPACITY fallthrough — the word "capacity" appears in both but the
+* long-wait signal means credential rotation, not a 60s backoff.
+*/
+function parseRateLimitReason(errorMessage) {
+	const lower = errorMessage.toLowerCase();
+	if (lower.includes("quota will reset") || lower.includes("exhausted your capacity")) return "QUOTA_EXHAUSTED";
+	if (lower.includes("capacity") || lower.includes("overloaded") || lower.includes("529") || lower.includes("503") || lower.includes("resource exhausted")) return "MODEL_CAPACITY_EXHAUSTED";
+	if (ACCOUNT_RATE_LIMIT_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
+	if (lower.includes("per minute") || lower.includes("rate limit") || lower.includes("too many requests")) return "RATE_LIMIT_EXCEEDED";
+	if (lower.includes("exhausted") || lower.includes("quota") || lower.includes("usage limit") || INSUFFICIENT_BALANCE_PATTERN.test(errorMessage)) return "QUOTA_EXHAUSTED";
+	if (lower.includes("500") || lower.includes("internal error") || lower.includes("internal server error")) return "SERVER_ERROR";
+	return "UNKNOWN";
+}
+/**
+* Backoff in ms for a given reason. MODEL_CAPACITY gets jitter to avoid
+* thundering herd. UNKNOWN falls back to the conservative QUOTA backoff
+* — safer to wait too long than to hammer a rate-limited endpoint.
+*/
+function calculateRateLimitBackoffMs(reason) {
+	switch (reason) {
+		case "QUOTA_EXHAUSTED": return QUOTA_EXHAUSTED_BACKOFF_MS;
+		case "RATE_LIMIT_EXCEEDED": return RATE_LIMIT_EXCEEDED_BACKOFF_MS;
+		case "MODEL_CAPACITY_EXHAUSTED": return MODEL_CAPACITY_BASE_MS + Math.random() * MODEL_CAPACITY_JITTER_MS;
+		case "SERVER_ERROR": return SERVER_ERROR_BACKOFF_MS;
+		default: return QUOTA_EXHAUSTED_BACKOFF_MS;
+	}
+}
+//#endregion
 //#region ../../packages/ltod/src/errors.ts
 /**
 * Base error for all chat provider errors.
@@ -784,12 +828,16 @@ var APIContextOverflowError = class extends APIStatusError {
 };
 /**
 * HTTP status error that specifically means the provider rate-limited the
-* request.
+* request. Carries a `reason` so retry logic can pick the right backoff
+* (quota exhaustion needs 30min or a credential switch; a transient 529
+* just needs 45s) instead of treating every 429 the same.
 */
 var APIProviderRateLimitError = class extends APIStatusError {
-	constructor(message, requestId) {
+	reason;
+	constructor(message, requestId, reason) {
 		super(429, message, requestId);
 		this.name = "APIProviderRateLimitError";
+		this.reason = reason ?? "UNKNOWN";
 	}
 };
 /**
@@ -804,6 +852,7 @@ var APIEmptyResponseError = class extends ChatProviderError {
 function isRetryableGenerateError(error) {
 	if (error instanceof APIConnectionError$3 || error instanceof APITimeoutError) return true;
 	if (error instanceof APIEmptyResponseError) return true;
+	if (error instanceof APIProviderRateLimitError) return error.reason !== "QUOTA_EXHAUSTED";
 	return error instanceof APIStatusError && [
 		429,
 		500,
@@ -826,7 +875,7 @@ function isContextOverflowErrorCode(code) {
 	return code === "context_length_exceeded";
 }
 function normalizeAPIStatusError(statusCode, message, requestId) {
-	if (statusCode === 429) return new APIProviderRateLimitError(message, requestId);
+	if (statusCode === 429) return new APIProviderRateLimitError(message, requestId, parseRateLimitReason(message));
 	if (isContextOverflowStatusError(statusCode, message)) return new APIContextOverflowError(statusCode, message, requestId);
 	return new APIStatusError(statusCode, message, requestId);
 }
@@ -8951,6 +9000,7 @@ function convertAnthropicError(error) {
 		const reqId = error.requestID ?? null;
 		return normalizeAPIStatusError(error.status, error.message, reqId);
 	}
+	if (error instanceof APIUserAbortError$2) throw new DOMException("The operation was aborted.", "AbortError");
 	if (error instanceof AnthropicError) return new ChatProviderError(`Anthropic error: ${error.message}`);
 	if (error instanceof Error) return new ChatProviderError(`Error: ${error.message}`);
 	return new ChatProviderError(`Error: ${String(error)}`);
@@ -9079,7 +9129,7 @@ var AnthropicStreamedMessage = class {
 								type: "function",
 								id: block.id,
 								name: block.name,
-								arguments: "",
+								arguments: null,
 								_streamIndex: blockIndex
 							};
 							break;
@@ -48130,6 +48180,7 @@ function convertOpenAIError(error) {
 		return normalizeAPIStatusError(error.status, error.message, reqId);
 	}
 	if (error instanceof APIError && error.constructor === APIError && error.error === void 0) return classifyBaseApiError(error.message);
+	if (error instanceof APIUserAbortError) throw new DOMException("The operation was aborted.", "AbortError");
 	if (error instanceof OpenAIError) return new ChatProviderError(`Error: ${error.message}`);
 	if (error instanceof Error) return classifyBaseApiError(error.message);
 	return new ChatProviderError(`Error: ${String(error)}`);
@@ -48187,7 +48238,7 @@ function extractUsage(usage) {
 		if (typeof details["cached_tokens"] === "number") cached = details["cached_tokens"];
 	}
 	return {
-		inputOther: promptTokens - cached,
+		inputOther: Math.max(0, promptTokens - cached),
 		output: completionTokens,
 		inputCacheRead: cached,
 		inputCacheCreation: 0
@@ -48426,6 +48477,10 @@ function convertChatCompletionStreamToolCall(toolCall, bufferedByIndex) {
 }
 //#endregion
 //#region ../../packages/ltod/src/providers/scream.ts
+const OPENAI_CHAT_TOOL_CALL_ID_POLICY$1 = {
+	normalize: (id) => sanitizeToolCallId(id, 64),
+	maxLength: 64
+};
 function isEffectivelyEmptyContent(parts) {
 	for (const part of parts) {
 		if (part.type !== "text") return false;
@@ -48632,12 +48687,13 @@ var ScreamChatProvider = class {
 		};
 	}
 	async generate(systemPrompt, tools, history, options) {
+		const normalizedHistory = normalizeToolCallIdsForProvider(history, OPENAI_CHAT_TOOL_CALL_ID_POLICY$1);
 		const messages = [];
 		if (systemPrompt) messages.push({
 			role: "system",
 			content: systemPrompt
 		});
-		for (const msg of history) messages.push(convertMessage$2(msg));
+		for (const msg of normalizedHistory) messages.push(convertMessage$2(msg));
 		const kwargs = { ...this._generationKwargs };
 		for (const key of Object.keys(kwargs)) if (kwargs[key] === void 0) delete kwargs[key];
 		if (kwargs["max_completion_tokens"] === void 0 && kwargs["max_tokens"] !== void 0) kwargs["max_completion_tokens"] = kwargs["max_tokens"];
@@ -49324,7 +49380,7 @@ var OpenAIResponsesStreamedMessage = class {
 		const details = readObjectField(usage, "input_tokens_details");
 		const cached = details ? readNumberField(details, "cached_tokens") ?? 0 : 0;
 		this._usage = {
-			inputOther: inputTokens - cached,
+			inputOther: Math.max(0, inputTokens - cached),
 			output: outputTokens,
 			inputCacheRead: cached,
 			inputCacheCreation: 0
@@ -49718,6 +49774,227 @@ function catalogProviderModels(entry) {
 	return Object.values(models).map((model) => catalogModelToCapability(model)).filter((model) => model !== void 0);
 }
 //#endregion
+//#region ../../packages/ltod/src/idle-iterator.ts
+/**
+* Idle-stream watchdog.
+*
+* Ported from oh-my-pi `packages/ai/src/utils/idle-iterator.ts:154-382`.
+* Reasoning models (deepseek-reasoner, mimo thinking) can sit silent for
+* 30s+ between tokens; without a watchdog the stream hangs forever and the
+* user thinks the agent died. This wraps any async iterable with a per-item
+* idle deadline, turning a stalled stream into a retryable `APITimeoutError`.
+*
+* Simplified from the upstream version: no `armPreResponseTimeout`, no
+* `iterateWithTerminalGrace`, no per-provider env-var aliases. The core
+* racer-reuse and single-timer-self-rearm design is preserved verbatim.
+*/
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 6e4;
+const DEFAULT_STREAM_FIRST_ITEM_TIMEOUT_MS = 12e4;
+const RACER_REMINT_INTERVAL = 1024;
+function withResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+function normalizeTimeoutMs$1(value, fallback) {
+	if (value === void 0) return fallback;
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) return fallback;
+	if (parsed <= 0) return void 0;
+	return Math.trunc(parsed);
+}
+function getStreamIdleTimeoutMs(fallback = DEFAULT_STREAM_IDLE_TIMEOUT_MS) {
+	return normalizeTimeoutMs$1(process.env["SCREAM_STREAM_IDLE_TIMEOUT_MS"], fallback);
+}
+function getStreamFirstItemTimeoutMs(idleTimeoutMs, fallback = DEFAULT_STREAM_FIRST_ITEM_TIMEOUT_MS) {
+	const floor = idleTimeoutMs === void 0 ? fallback : Math.max(fallback, idleTimeoutMs);
+	return normalizeTimeoutMs$1(process.env["SCREAM_STREAM_FIRST_ITEM_TIMEOUT_MS"], floor);
+}
+/**
+* Thrown when the stream stalls longer than the configured idle deadline.
+* Extends `APITimeoutError` so `isRetryableGenerateError` picks it up
+* automatically — the agent retries instead of dying.
+*/
+var StreamIdleTimeoutError = class extends APITimeoutError {
+	phase;
+	constructor(phase, message) {
+		super(message);
+		this.name = "StreamIdleTimeoutError";
+		this.phase = phase;
+	}
+};
+/**
+* Yields items from an async iterable while enforcing a maximum idle gap.
+*
+* The first item may use a longer timeout (reasoning models can take 60s+ to
+* emit the first token); subsequent gaps use the shorter idle timeout.
+*/
+async function* iterateWithIdleTimeout(iterable, options) {
+	const firstItemTimeoutMs = options.firstItemTimeoutMs ?? options.idleTimeoutMs;
+	const firstItemDeadlineMs = firstItemTimeoutMs !== void 0 && firstItemTimeoutMs > 0 ? Date.now() + firstItemTimeoutMs : void 0;
+	const abortSignal = options.abortSignal;
+	const iterator = iterable[Symbol.asyncIterator]();
+	let iteratorClosed = false;
+	const closeIterator = () => {
+		if (iteratorClosed) return;
+		iteratorClosed = true;
+		const returnPromise = iterator.return?.();
+		if (returnPromise) returnPromise.catch(() => {});
+	};
+	if (abortSignal?.aborted) {
+		closeIterator();
+		throw abortReason(abortSignal);
+	}
+	const withRacy = (promise) => promise.then((result) => ({
+		kind: "next",
+		result
+	}), (error) => ({
+		kind: "error",
+		error
+	}));
+	let awaitingFirstItem = true;
+	const isProgressItem = (item) => {
+		if (!options.isProgressItem) return true;
+		try {
+			return options.isProgressItem(item);
+		} catch {
+			return true;
+		}
+	};
+	let lastProgressAt = Date.now();
+	const noTimeoutEnforced = (firstItemTimeoutMs === void 0 || firstItemTimeoutMs <= 0) && (options.idleTimeoutMs === void 0 || options.idleTimeoutMs <= 0);
+	let abortPromise;
+	let abortListener;
+	let resolveAbort;
+	if (abortSignal) {
+		const { promise, resolve } = withResolvers();
+		resolveAbort = resolve;
+		abortListener = () => resolveAbort?.({ kind: "abort" });
+		abortSignal.addEventListener("abort", abortListener, { once: true });
+		abortPromise = promise;
+	}
+	let timeoutPromise;
+	let resolveTimeout;
+	let timeoutFired = false;
+	let timer;
+	let timerFireAtMs = Infinity;
+	const currentDeadlineMs = () => {
+		if (awaitingFirstItem) return firstItemDeadlineMs;
+		if (options.idleTimeoutMs !== void 0 && options.idleTimeoutMs > 0) return lastProgressAt + options.idleTimeoutMs;
+	};
+	const onTimerFire = () => {
+		timer = void 0;
+		timerFireAtMs = Infinity;
+		const deadlineMs = currentDeadlineMs();
+		if (deadlineMs === void 0) return;
+		const remainingMs = deadlineMs - Date.now();
+		if (remainingMs > 0) {
+			timerFireAtMs = deadlineMs;
+			timer = setTimeout(onTimerFire, remainingMs);
+			return;
+		}
+		timeoutFired = true;
+		resolveTimeout?.({ kind: "timeout" });
+	};
+	const armTimer = (deadlineMs) => {
+		if (timeoutPromise === void 0 || timeoutFired) {
+			const { promise, resolve } = withResolvers();
+			timeoutPromise = promise;
+			resolveTimeout = resolve;
+			timeoutFired = false;
+		}
+		if (timer !== void 0) {
+			if (timerFireAtMs <= deadlineMs) return;
+			clearTimeout(timer);
+		}
+		timerFireAtMs = deadlineMs;
+		timer = setTimeout(onTimerFire, Math.max(0, deadlineMs - Date.now()));
+	};
+	try {
+		let raceCount = 0;
+		while (true) {
+			if (++raceCount % RACER_REMINT_INTERVAL === 0) {
+				if (abortPromise !== void 0 && !abortSignal.aborted) {
+					const { promise, resolve } = withResolvers();
+					resolveAbort = resolve;
+					abortPromise = promise;
+				}
+				if (timeoutPromise !== void 0 && !timeoutFired) {
+					const { promise, resolve } = withResolvers();
+					resolveTimeout = resolve;
+					timeoutPromise = promise;
+				}
+			}
+			let activeTimeoutMs;
+			if (awaitingFirstItem) {
+				if (firstItemDeadlineMs !== void 0) {
+					activeTimeoutMs = firstItemDeadlineMs - Date.now();
+					if (activeTimeoutMs <= 0) {
+						closeIterator();
+						throw new StreamIdleTimeoutError("first-item", options.firstItemErrorMessage ?? options.errorMessage);
+					}
+				}
+			} else if (options.idleTimeoutMs !== void 0 && options.idleTimeoutMs > 0) {
+				activeTimeoutMs = options.idleTimeoutMs - (Date.now() - lastProgressAt);
+				if (activeTimeoutMs <= 0) {
+					closeIterator();
+					throw new StreamIdleTimeoutError("idle", options.errorMessage);
+				}
+			}
+			const racers = [withRacy(iterator.next())];
+			if (!noTimeoutEnforced && activeTimeoutMs !== void 0 && activeTimeoutMs > 0 && activeTimeoutMs !== void 0) {
+				armTimer(Date.now() + activeTimeoutMs);
+				racers.push(timeoutPromise);
+			}
+			if (abortPromise) racers.push(abortPromise);
+			let continuing = false;
+			try {
+				const outcome = await Promise.race(racers);
+				if (outcome.kind === "abort") {
+					closeIterator();
+					throw abortReason(abortSignal);
+				}
+				if (outcome.kind === "timeout") {
+					closeIterator();
+					throw new StreamIdleTimeoutError(!awaitingFirstItem ? "idle" : "first-item", !awaitingFirstItem ? options.errorMessage : options.firstItemErrorMessage ?? options.errorMessage);
+				}
+				if (outcome.kind === "error") throw outcome.error;
+				if (outcome.result.done) {
+					awaitingFirstItem = false;
+					return;
+				}
+				const item = outcome.result.value;
+				if (isProgressItem(item)) {
+					awaitingFirstItem = false;
+					lastProgressAt = Date.now();
+				}
+				yield item;
+				continuing = true;
+			} finally {
+				if (!continuing) closeIterator();
+			}
+		}
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+		resolveTimeout?.({ kind: "timeout" });
+		if (abortListener && abortSignal) abortSignal.removeEventListener("abort", abortListener);
+		resolveAbort?.({ kind: "abort" });
+	}
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	if (typeof reason === "string") return new Error(reason);
+	return /* @__PURE__ */ new Error("Request was aborted");
+}
+//#endregion
 //#region ../../packages/ltod/src/generate.ts
 /**
 * Generate one assistant message by streaming from the given provider.
@@ -49755,7 +50032,16 @@ async function generate(provider, systemPrompt, tools, history, callbacks, optio
 	options?.onRequestStart?.();
 	const stream = await provider.generate(systemPrompt, tools, history, options);
 	await throwIfAborted(options?.signal, stream);
-	for await (const part of stream) {
+	const idleTimeoutMs = getStreamIdleTimeoutMs();
+	const firstItemTimeoutMs = getStreamFirstItemTimeoutMs(idleTimeoutMs);
+	const watchedStream = iterateWithIdleTimeout(stream, {
+		idleTimeoutMs,
+		firstItemTimeoutMs,
+		abortSignal: options?.signal,
+		errorMessage: `Stream stalled — no data for ${idleTimeoutMs ?? 0}ms. Provider: ${provider.name}, model: ${provider.modelName}`,
+		firstItemErrorMessage: `Stream stalled — no first token within ${firstItemTimeoutMs ?? 0}ms. Provider: ${provider.name}, model: ${provider.modelName}`
+	});
+	for await (const part of watchedStream) {
 		await throwIfAborted(options?.signal, stream);
 		if (callbacks?.onMessagePart !== void 0) {
 			await callbacks.onMessagePart(deepCopyPart(part));
@@ -49799,13 +50085,7 @@ function throwAbortError() {
 	throw new DOMException("The operation was aborted.", "AbortError");
 }
 async function cancelStream(stream) {
-	const cancelable = stream;
-	try {
-		await cancelable.cancel?.();
-	} catch {}
-	try {
-		await cancelable.return?.();
-	} catch {}
+	await stream[Symbol.asyncIterator]().return?.();
 }
 async function throwIfAborted(signal, stream) {
 	if (!signal?.aborted) return;
@@ -49893,8 +50173,8 @@ function addUsage(a, b) {
 /**
 * Concrete provider adapters stay off the root barrel because their SDK type
 * graphs pollute downstream declaration bundles. Import them from subpaths:
-* `@scream-cli/ltod/providers/scream`,
-* `@scream-cli/ltod/providers/openai-legacy`, etc.
+* `@scream-code/ltod/providers/scream`,
+* `@scream-code/ltod/providers/openai-legacy`, etc.
 */
 //#endregion
 //#region ../../packages/agent-core/src/errors/serialize.ts
@@ -50727,7 +51007,7 @@ function resolveGlobalLogPath(homeDir) {
 * and supersedes this value. Used to keep `tokenCountWithPending`
 * monotonic between LLM round-trips without paying for a tokenizer.
 */
-function estimateTokens(text) {
+function estimateTokens$1(text) {
 	let asciiCount = 0;
 	let nonAsciiCount = 0;
 	for (const char of text) if (char.codePointAt(0) <= 127) asciiCount++;
@@ -50742,24 +51022,24 @@ function estimateTokensForMessages(messages) {
 function estimateTokensForTools(tools) {
 	let total = 0;
 	for (const tool of tools) {
-		total += estimateTokens(tool.name);
-		total += estimateTokens(tool.description);
-		total += estimateTokens(JSON.stringify(tool.parameters));
+		total += estimateTokens$1(tool.name);
+		total += estimateTokens$1(tool.description);
+		total += estimateTokens$1(JSON.stringify(tool.parameters));
 	}
 	return total;
 }
 function estimateTokensForMessage(message) {
-	let total = estimateTokens(message.role);
+	let total = estimateTokens$1(message.role);
 	for (const part of message.content) total += estimateTokensForContentPart(part);
 	if (message.toolCalls !== void 0) for (const call of message.toolCalls) {
-		total += estimateTokens(call.name);
-		total += estimateTokens(JSON.stringify(call.arguments));
+		total += estimateTokens$1(call.name);
+		total += estimateTokens$1(JSON.stringify(call.arguments));
 	}
 	return total;
 }
 function estimateTokensForContentPart(part) {
-	if (part.type === "text") return estimateTokens(part.text);
-	else if (part.type === "think") return estimateTokens(part.think);
+	if (part.type === "text") return estimateTokens$1(part.text);
+	else if (part.type === "think") return estimateTokens$1(part.think);
 	return 0;
 }
 //#endregion
@@ -54586,7 +54866,7 @@ function fractionFromId(id) {
 		if (Number.isFinite(n)) return n / 4294967296;
 	}
 	let hash = 5381;
-	for (let i = 0; i < id.length; i++) hash = (hash << 5) + hash + id.charCodeAt(i) | 0;
+	for (let i = 0; i < id.length; i++) hash = (hash << 5) + hash + id.codePointAt(i) | 0;
 	return (hash >>> 0) / 4294967296;
 }
 function jitterDisabledByEnv() {
@@ -54691,10 +54971,10 @@ var CronCreateTool = class {
 		let parsed;
 		try {
 			parsed = parseCronExpression(normalizedCron);
-		} catch (err) {
+		} catch (error) {
 			return {
 				isError: true,
-				output: `Invalid cron expression: ${err instanceof Error ? err.message : String(err)}`
+				output: `Invalid cron expression: ${error instanceof Error ? error.message : String(error)}`
 			};
 		}
 		const nowAtPrepare = this.manager.clocks.wallNow();
@@ -54711,7 +54991,7 @@ var CronCreateTool = class {
 			isError: true,
 			output: `Prompt exceeds ${String(MAX_PROMPT_BYTES)} bytes (got ${String(byteLen)}).`
 		};
-		const recurring = args.recurring !== false;
+		const recurring = args.recurring;
 		if (!recurring) {
 			const firstFire = computeNextCronRun(parsed, nowAtPrepare);
 			if (firstFire !== null && firstFire - nowAtPrepare > ONE_SHOT_MAX_FUTURE_MS) return {
@@ -56518,7 +56798,7 @@ function createFastEmbedEngine() {
 			if (texts.length === 0) return [];
 			try {
 				if (embedder === null) {
-					if (initPromise === null) initPromise = loadEmbedder();
+					initPromise ??= loadEmbedder();
 					embedder = await initPromise;
 					if (embedder === null) {
 						loadFailed = true;
@@ -56594,16 +56874,33 @@ var MemoryMemoStore = class MemoryMemoStore {
 	* the types catch up, the synchronous calls here should be migrated to the
 	* async API to avoid blocking the event loop on large operations.
 	*/
+	initPromise = null;
 	async init() {
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this._doInit();
+		return this.initPromise;
+	}
+	async _doInit() {
 		if (this.initialized) return;
 		await this.ensureDir();
 		this.db = new DatabaseSync(this.dbPath);
 		this.db.exec("PRAGMA journal_mode = WAL;");
 		this.db.exec("PRAGMA foreign_keys = ON;");
+		this.db.exec("PRAGMA busy_timeout = 5000;");
 		this.createSchema();
 		await this.migrateFromJsonl();
 		this.initialized = true;
 	}
+	/** Close the database handle and checkpoint WAL. */
+	close() {
+		if (this.db !== void 0) {
+			this.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+			this.db.close();
+			this.db = void 0;
+		}
+		this.initialized = false;
+		this.initPromise = null;
+	}
 	/** Iterate all memos from the database, newest first. Optionally filter by project directory. */
 	async *read(options) {
 		await this.init();
@@ -56709,9 +57006,7 @@ var MemoryMemoStore = class MemoryMemoStore {
 			let stream;
 			try {
 				stream = createReadStream(legacyPath, { encoding: "utf8" });
-			} catch {
-				continue;
-			}
+			} catch {}
 			stream.on("error", () => {});
 			let line = "";
 			try {
@@ -56763,6 +57058,12 @@ var MemoryMemoStore = class MemoryMemoStore {
 					projectDir: str(entry["projectDir"])
 				};
 			}
+			const src = entry["extractionSource"];
+			if (typeof src === "string" && ![
+				"compaction",
+				"exit",
+				"manual"
+			].includes(src)) return;
 			return entry;
 		} catch {
 			return;
@@ -56854,7 +57155,7 @@ var MemoryMemoStore = class MemoryMemoStore {
 	}
 	insertMany(memos) {
 		if (this.db === void 0 || memos.length === 0) return;
-		const insert = this.db.prepare(`INSERT INTO memos (
+		const insert = this.db.prepare(`INSERT OR IGNORE INTO memos (
         id, source_session_id, source_session_title, user_need, approach,
         outcome, what_failed, what_worked, extraction_source, recorded_at, project_dir, tags
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -56868,9 +57169,9 @@ var MemoryMemoStore = class MemoryMemoStore {
 				insertFts.run(row.rowid, toFtsText(memo.userNeed), toFtsText(memo.approach), toFtsText(memo.whatFailed), toFtsText(memo.whatWorked), toFtsText(memo.sourceSessionTitle ?? ""));
 			}
 			this.db.exec("COMMIT");
-		} catch (err) {
+		} catch (error) {
 			this.db.exec("ROLLBACK");
-			throw new Error(`Failed to migrate memos to SQLite: ${err instanceof Error ? err.message : String(err)}`);
+			throw new Error(`Failed to migrate memos to SQLite: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
 		}
 	}
 	async appendInternal(entry) {
@@ -56983,6 +57284,10 @@ var MemoryMemoStore = class MemoryMemoStore {
 	* Search memos by vector similarity. Returns memos sorted by cosine
 	* similarity (highest first). Falls back to empty if no embeddings exist.
 	*
+	* NOTE: candidates are ordered by created_at DESC, so only the newest
+	* N embeddings are considered. Older but highly relevant memos may be
+	* omitted when the store has more than candidateLimit embeddings.
+	* This is a known limitation — see M-M5 in project review notes.
 	* Performance notes:
 	* - candidateLimit bounds the SQL query so we never load every embedding.
 	* - recencyCutoffDays lets callers ignore very old memos.
@@ -57088,12 +57393,12 @@ var MemoryMemoStore = class MemoryMemoStore {
 			try {
 				for (let i = 0; i < pending.length; i++) insert.run(pending[i].id, JSON.stringify([...vectors[i]]), "bge-small-zh-v1.5", now);
 				this.db.exec("COMMIT");
-			} catch (err) {
+			} catch (error) {
 				this.db.exec("ROLLBACK");
-				this.markEmbeddingFailure(err instanceof Error ? err : new Error(String(err)));
+				this.markEmbeddingFailure(error instanceof Error ? error : new Error(String(error)));
 			}
-		} catch (err) {
-			this.markEmbeddingFailure(err instanceof Error ? err : new Error(String(err)));
+		} catch (error) {
+			this.markEmbeddingFailure(error instanceof Error ? error : new Error(String(error)));
 		} finally {
 			this.embeddingFlushing = false;
 		}
@@ -57195,7 +57500,7 @@ function memoMatchesSearch(memo, search) {
 		memo.whatWorked,
 		memo.sourceSessionTitle ?? "",
 		...memo.tags ?? []
-	].join(" ").toLowerCase().includes(search);
+	].join(" ").toLowerCase().replaceAll(/\s+/g, "").includes(search.replaceAll(/\s+/g, ""));
 }
 /**
 * Tokenize text so FTS5's unicode61 tokenizer can index mixed CJK/ASCII text.
@@ -57336,13 +57641,41 @@ async function buildConsolidationPlan(store, options) {
 async function applyConsolidation(store, plan) {
 	let deleted = 0;
 	let created = 0;
-	for (const memo of plan.resolved) {
-		await store.delete(memo.id);
-		deleted++;
-	}
-	for (const memo of plan.stale) {
-		await store.delete(memo.id);
-		deleted++;
+	if (plan.resolved.length > 0) {
+		const worked = plan.resolved.filter((m) => m.whatWorked).map((m) => m.whatWorked).join("; ");
+		const failed = plan.resolved.filter((m) => m.whatFailed).map((m) => m.whatFailed).join("; ");
+		if (worked || failed) {
+			const archive = createMemoryMemo({
+				sourceSessionId: plan.resolved[0].sourceSessionId,
+				userNeed: "已解决任务的经验归档（dream 整理）",
+				approach: "多次尝试后解决",
+				outcome: "已完成",
+				whatWorked: worked || "none",
+				whatFailed: failed || "none",
+				tags: normalizeTags(plan.resolved.flatMap((m) => m.tags ?? [])),
+				extractionSource: "compaction"
+			});
+			await store.append(archive);
+			created++;
+		}
+	}
+	if (plan.stale.length > 0) {
+		const worked = plan.stale.filter((m) => m.whatWorked).map((m) => m.whatWorked).join("; ");
+		const failed = plan.stale.filter((m) => m.whatFailed).map((m) => m.whatFailed).join("; ");
+		if (worked || failed) {
+			const archive = createMemoryMemo({
+				sourceSessionId: plan.stale[0].sourceSessionId,
+				userNeed: "过期记忆的经验归档（dream 整理）",
+				approach: "距今超过30天未使用",
+				outcome: "已归档",
+				whatWorked: worked || "none",
+				whatFailed: failed || "none",
+				tags: normalizeTags(plan.stale.flatMap((m) => m.tags ?? [])),
+				extractionSource: "compaction"
+			});
+			await store.append(archive);
+			created++;
+		}
 	}
 	for (const group of plan.duplicateGroups) {
 		const newest = group.memos.reduce((a, b) => a.recordedAt > b.recordedAt ? a : b);
@@ -57358,13 +57691,21 @@ async function applyConsolidation(store, plan) {
 			tags: group.merged.tags ?? mergedTags,
 			extractionSource: "compaction"
 		});
-		for (const memo of group.memos) {
-			await store.delete(memo.id);
-			deleted++;
-		}
 		await store.append(merged);
 		created++;
 	}
+	for (const group of plan.duplicateGroups) for (const memo of group.memos) {
+		await store.delete(memo.id);
+		deleted++;
+	}
+	for (const memo of plan.resolved) {
+		await store.delete(memo.id);
+		deleted++;
+	}
+	for (const memo of plan.stale) {
+		await store.delete(memo.id);
+		deleted++;
+	}
 	return {
 		deleted,
 		created
@@ -57381,7 +57722,7 @@ function findDuplicateGroups(memos) {
 			const candidate = memos[j];
 			if (!candidate || used.has(candidate.id)) continue;
 			if (cluster.some((m) => {
-				return computeRelevanceScore(candidate, `${m.userNeed} ${m.approach}`) >= SIMILARITY_THRESHOLD;
+				return computeKeywordSimilarity(candidate, `${m.userNeed} ${m.approach}`) >= SIMILARITY_THRESHOLD;
 			})) cluster.push(candidate);
 		}
 		if (cluster.length > 1) {
@@ -57967,7 +58308,7 @@ var MemoryWriteTool = class {
 				const sourceSessionTitle = await this.agent.getSessionTitle();
 				const whatFailed = args.whatFailed?.trim();
 				const whatWorked = args.whatWorked?.trim();
-				const tags = args.tags !== void 0 && args.tags.length > 0 ? args.tags : generateTags(`${args.userNeed} ${args.approach}`);
+				const tags = normalizeTags(args.tags !== void 0 && args.tags.length > 0 ? args.tags : generateTags(`${args.userNeed} ${args.approach}`));
 				const memo = createMemoryMemo({
 					sourceSessionId: sessionId,
 					sourceSessionTitle,
@@ -58032,7 +58373,14 @@ var LspClient = class {
 		await this.request("initialize", {
 			processId: process.pid,
 			rootUri: pathToUri(this.workspaceRoot),
-			capabilities: {}
+			capabilities: { textDocument: {
+				synchronization: {
+					willSave: false,
+					willSaveWaitUntil: false,
+					didSave: false
+				},
+				rename: { prepareSupport: false }
+			} }
 		});
 		this.notify("initialized", {});
 	}
@@ -58079,6 +58427,16 @@ var LspClient = class {
 		if (result === null) return [];
 		return Array.isArray(result) ? result : [result];
 	}
+	async rename(path, line, character, newName) {
+		return await this.request("textDocument/rename", {
+			textDocument: { uri: pathToUri(path) },
+			position: {
+				line,
+				character
+			},
+			newName
+		});
+	}
 	async diagnostics(path, timeoutMs = 5e3) {
 		const uri = pathToUri(path);
 		this.collectedDiagnostics.delete(uri);
@@ -58174,6 +58532,19 @@ function pathToUri(path) {
 	}
 	return `file://${path.startsWith("/") ? path : `/${path}`}`;
 }
+/**
+* Convert a `file://` URI back to a filesystem path. Tolerates
+* percent-encoded characters and lax servers that send raw paths.
+*/
+function uriToPath(uri) {
+	if (!uri.startsWith("file://")) return uri;
+	let filePath = uri.slice(7);
+	try {
+		filePath = decodeURIComponent(filePath);
+	} catch {}
+	if (process.platform === "win32" && filePath.startsWith("/") && /^[A-Za-z]:/.test(filePath.slice(1))) filePath = filePath.slice(1);
+	return filePath;
+}
 function sleep$1(ms) {
 	return new Promise((resolve) => {
 		setTimeout(resolve, ms);
@@ -58189,24 +58560,141 @@ function formatDiagnostic(diagnostic) {
 	return `- ${diagnostic.severity !== void 0 ? SEVERITY_LABELS[diagnostic.severity - 1] ?? "Unknown" : "Diagnostic"} at ${start.line + 1}:${start.character + 1}: ${diagnostic.message}`;
 }
 //#endregion
+//#region ../../packages/agent-core/src/lsp/edits.ts
+function comparePosition(a, b) {
+	return a.line === b.line ? a.character - b.character : a.line - b.line;
+}
+/**
+* Sort edits bottom-to-top for in-place application and reject overlaps.
+* Equal start positions tiebreak by original array index descending so that,
+* applied bottom-up, inserts at the same position land in array order
+* (LSP spec: the order of edits in the array defines the order in the result).
+*/
+function sortAndValidateTextEdits(edits) {
+	const sorted = edits.map((edit, index) => ({
+		edit,
+		index
+	})).sort((a, b) => {
+		const sa = a.edit.range.start;
+		const sb = b.edit.range.start;
+		if (sa.line !== sb.line) return sb.line - sa.line;
+		if (sa.character !== sb.character) return sb.character - sa.character;
+		return b.index - a.index;
+	}).map((entry) => entry.edit);
+	for (let i = 0; i < sorted.length - 1; i++) {
+		const later = sorted[i].range;
+		const earlier = sorted[i + 1].range;
+		if (comparePosition(earlier.end, later.start) > 0) throw new Error(`overlapping LSP edits at ${earlier.start.line + 1}:${earlier.start.character + 1} conflict with ${later.start.line + 1}:${later.start.character + 1}; multi-server rename produced inconsistent edits`);
+	}
+	return sorted;
+}
+/**
+* Apply text edits to a string in-memory. Edits are applied in reverse
+* order (bottom-to-top) to preserve line/character indices.
+*/
+function applyTextEditsToString(content, edits) {
+	const lines = content.split("\n");
+	const sortedEdits = sortAndValidateTextEdits(edits);
+	for (const edit of sortedEdits) {
+		const { start, end } = edit.range;
+		if (start.line === end.line) {
+			const line = lines[start.line] ?? "";
+			lines[start.line] = line.slice(0, start.character) + edit.newText + line.slice(end.character);
+		} else {
+			const startLine = lines[start.line] ?? "";
+			const endLine = lines[end.line] ?? "";
+			const newContent = startLine.slice(0, start.character) + edit.newText + endLine.slice(end.character);
+			lines.splice(start.line, end.line - start.line + 1, ...newContent.split("\n"));
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Flatten a WorkspaceEdit's text edits into a Map<path, TextEdit[]>.
+* Resource operations (create/rename/delete) are ignored — callers handle
+* them separately.
+*/
+function flattenWorkspaceTextEdits(edit) {
+	const out = /* @__PURE__ */ new Map();
+	const push = (uri, edits) => {
+		if (edits.length === 0) return;
+		const path = uriToPath(uri);
+		const prev = out.get(path);
+		if (prev) prev.push(...edits);
+		else out.set(path, [...edits]);
+	};
+	if (edit.changes) for (const uri of Object.keys(edit.changes)) push(uri, edit.changes[uri]);
+	if (edit.documentChanges) {
+		for (const change of edit.documentChanges) if (change && change.textDocument && change.edits) push(change.textDocument.uri, change.edits);
+	}
+	return out;
+}
+/**
+* Apply a workspace edit (collection of file changes) to disk via Jian.
+*
+* All text-edit batches are overlap-validated before anything is written
+* so a conflict throws without leaving the workspace half-applied. Every
+* target path is passed through `validatePath` first — throws
+* `LspEditPathValidationError` if any path is outside the allowed root.
+*/
+async function applyWorkspaceEdit(edit, jian, validatePath) {
+	const flattened = flattenWorkspaceTextEdits(edit);
+	for (const edits of flattened.values()) sortAndValidateTextEdits(edits);
+	if (validatePath !== void 0) for (const filePath of flattened.keys()) validatePath(filePath);
+	const applied = [];
+	for (const [filePath, edits] of flattened) {
+		const result = applyTextEditsToString(await jian.readText(filePath), edits);
+		await jian.writeText(filePath, result);
+		applied.push({
+			filePath,
+			editCount: edits.length
+		});
+	}
+	return applied;
+}
+/**
+* Format a workspace edit as a summary list (one entry per affected file).
+* Used for the preview mode (`apply: false`) where we show what *would*
+* change without writing to disk.
+*/
+function formatWorkspaceEditPreview(edit) {
+	const lines = [];
+	if (edit.changes) for (const uri of Object.keys(edit.changes)) {
+		const edits = edit.changes[uri];
+		const path = uriToPath(uri);
+		lines.push(`${path}: ${String(edits.length)} edit${edits.length > 1 ? "s" : ""}`);
+	}
+	if (edit.documentChanges) {
+		for (const change of edit.documentChanges) if (change && change.textDocument && change.edits) {
+			const path = uriToPath(change.textDocument.uri);
+			lines.push(`${path}: ${String(change.edits.length)} edit${change.edits.length > 1 ? "s" : ""}`);
+		}
+	}
+	return lines;
+}
+//#endregion
 //#region ../../packages/agent-core/src/tools/builtin/lsp-tool.ts
 const LspInputSchema = z.object({
 	path: z.string().describe("Path to the source file. Relative paths resolve against the working directory; a path outside the working directory must be absolute."),
 	operation: z.enum([
 		"references",
 		"definition",
-		"diagnostics"
-	]).describe("LSP operation to perform: 'references', 'definition', or 'diagnostics'."),
-	line: z.number().int().min(1).optional().describe("1-based line number for references/definition."),
-	character: z.number().int().min(0).optional().describe("0-based column/character offset for references/definition."),
-	include_declaration: z.boolean().optional().describe("For 'references': whether to include the declaration site in the results.")
+		"diagnostics",
+		"rename"
+	]).describe("LSP operation to perform: 'references', 'definition', 'diagnostics', or 'rename'."),
+	line: z.number().int().min(1).optional().describe("1-based line number for references/definition/rename."),
+	character: z.number().int().min(0).optional().describe("0-based column/character offset for references/definition/rename."),
+	include_declaration: z.boolean().optional().describe("For 'references': whether to include the declaration site in the results."),
+	new_name: z.string().optional().describe("For 'rename': the new symbol name. Required for rename. The rename is applied to disk unless `apply` is false."),
+	apply: z.boolean().optional().describe("For 'rename': when true, apply the rename to disk across all affected files. When false (default), return a preview of the changes without writing. Pass true only after previewing.")
 });
 /**
-* LSP tool — read-only code intelligence via language servers.
+* LSP tool — code intelligence via language servers.
 *
-* Supports references, go-to-definition, and diagnostics. The file content is
-* opened in the language server so results reflect the current editor state
-* even when the file has not been saved to disk.
+* Supports references, go-to-definition, diagnostics, and rename. The file
+* content is opened in the language server so results reflect the current
+* editor state even when the file has not been saved to disk. Rename is the
+* only write op; pass `apply: false` to preview without writing.
 */
 var LspTool = class {
 	agent;
@@ -58214,10 +58702,10 @@ var LspTool = class {
 	lspRegistry;
 	name = "LSP";
 	description = [
-		"Query a language server for read-only code intelligence.",
-		"Use 'references' to find all usages of a symbol, 'definition' to jump to where a symbol is defined, and 'diagnostics' to get type errors and warnings for a file.",
+		"Query a language server for code intelligence.",
+		"Use 'references' to find all usages of a symbol, 'definition' to jump to where a symbol is defined, 'diagnostics' to get type errors and warnings for a file, and 'rename' to rename a symbol across all its references.",
 		"The language server is started automatically for supported file types (TypeScript/JavaScript, Python, Rust, Go).",
-		"This tool does not edit files; use the results to inform Read/Edit operations."
+		"Rename requires the typescript-language-server (or equivalent) binary on PATH for the file type."
 	].join(" ");
 	parameters = toInputJsonSchema(LspInputSchema);
 	constructor(agent, workspace, lspRegistry) {
@@ -58226,13 +58714,14 @@ var LspTool = class {
 		this.lspRegistry = lspRegistry;
 	}
 	resolveExecution(args) {
+		const isWrite = args.operation === "rename" && args.apply === true;
 		const path = resolvePathAccessPath(args.path, {
 			jian: this.agent.jian,
 			workspace: this.workspace,
-			operation: "read"
+			operation: isWrite ? "write" : "read"
 		});
 		return {
-			accesses: ToolAccesses.readFile(path),
+			accesses: isWrite ? ToolAccesses.writeFile(path) : ToolAccesses.readFile(path),
 			description: `LSP ${args.operation} ${args.path}`,
 			approvalRule: this.name,
 			execute: () => this.execution(args, path)
@@ -58315,6 +58804,44 @@ var LspTool = class {
 						].join("\n")
 					};
 				}
+				case "rename": {
+					if (args.line === void 0 || args.character === void 0) return {
+						isError: true,
+						output: "'rename' requires both 'line' and 'character'."
+					};
+					if (args.new_name === void 0 || args.new_name === "") return {
+						isError: true,
+						output: "'rename' requires 'new_name'."
+					};
+					const workspaceEdit = await client.rename(safePath, args.line - 1, args.character, args.new_name);
+					if (workspaceEdit === null) return {
+						isError: false,
+						output: "Rename returned no edits."
+					};
+					if (args.apply === true) {
+						const applied = await applyWorkspaceEdit(workspaceEdit, this.agent.jian, (p) => {
+							if (!isWithinWorkspace(p, this.workspace, this.agent.jian.pathClass())) throw new Error(`Refusing to apply rename: LSP returned edits for a file outside the workspace: ${p}`);
+						});
+						if (applied.length === 0) return {
+							isError: false,
+							output: "Rename produced no file changes."
+						};
+						const lines = applied.map((a) => `  Applied ${String(a.editCount)} edit(s) to ${a.filePath}`);
+						return {
+							isError: false,
+							output: [`Applied rename to ${String(applied.length)} file(s):`, ...lines].join("\n")
+						};
+					}
+					const preview = formatWorkspaceEditPreview(workspaceEdit);
+					if (preview.length === 0) return {
+						isError: false,
+						output: "Rename preview is empty."
+					};
+					return {
+						isError: false,
+						output: [`Rename preview (${String(preview.length)} file(s)):`, ...preview].join("\n")
+					};
+				}
 				default: return {
 					isError: true,
 					output: `Unsupported operation: ${String(args.operation)}`
@@ -68759,7 +69286,9 @@ async function resolveGithubSource(input) {
 		}
 	};
 	const headController = new AbortController();
-	const headTimeout = setTimeout(() => headController.abort(), 3e4);
+	const headTimeout = setTimeout(() => {
+		headController.abort();
+	}, 3e4);
 	let headProbe;
 	try {
 		headProbe = await fetch(`https://codeload.github.com/${owner}/${repo}/zip/HEAD`, {
@@ -68795,7 +69324,9 @@ async function resolveGithubSource(input) {
 async function tryResolveLatestReleaseTag(owner, repo) {
 	const url = `https://github.com/${owner}/${repo}/releases/latest`;
 	const controller = new AbortController();
-	const timeoutHandle = setTimeout(() => controller.abort(), 3e4);
+	const timeoutHandle = setTimeout(() => {
+		controller.abort();
+	}, 3e4);
 	let resp;
 	try {
 		resp = await fetch(url, {
@@ -69487,7 +70018,7 @@ async function discoverSkillDirs(root, maxDepth) {
 		}
 	}
 	await walk(root, 1);
-	const sorted = found.sort((a, b) => a.length - b.length);
+	const sorted = found.toSorted((a, b) => a.length - b.length);
 	const result = [];
 	for (const dir of sorted) if (!result.some((parent) => dir.startsWith(parent + path$1.sep))) result.push(dir);
 	return result;
@@ -70442,7 +70973,7 @@ var wolfpack_default = "Use WolfPack to spawn multiple subagents in parallel for
 *
 * Spawns multiple subagents in parallel using a template + items pattern.
 * Each item gets its own subagent; results are batched together.
-* V1 uses Promise.allSettled — no concurrency control or rate-limit handling.
+* Concurrency capped at WOLFPACK_CONCURRENCY to avoid provider rate-limit exhaustion.
 */
 const MAX_ITEMS = 20;
 const WolfPackToolInputSchema = z.object({
@@ -70489,27 +71020,51 @@ var WolfPackTool = class {
 		};
 		const profileName = args.subagent_type ?? "coder";
 		const template = args.prompt_template;
+		const WOLFPACK_CONCURRENCY = 8;
 		const handlePromises = args.items.map(async (item) => {
 			ctx.signal.throwIfAborted();
-			const prompt = template.replace(/\{\{item\}\}/g, item);
-			return {
-				item,
-				handle: await this.subagentHost.spawn(profileName, {
-					parentToolCallId: ctx.toolCallId,
-					prompt,
-					description: `${args.description}: ${item}`,
-					runInBackground: false,
-					signal: ctx.signal
-				})
-			};
+			try {
+				const prompt = template.replaceAll("{{item}}", () => item);
+				return {
+					item,
+					handle: await this.subagentHost.spawn(profileName, {
+						parentToolCallId: ctx.toolCallId,
+						prompt,
+						description: `${args.description}: ${item}`,
+						runInBackground: false,
+						signal: ctx.signal
+					})
+				};
+			} catch (error) {
+				return {
+					item,
+					error
+				};
+			}
 		});
-		const completionPromises = (await Promise.allSettled(handlePromises)).map(async (settled) => {
+		const handleResults = [];
+		for (let i = 0; i < handlePromises.length; i += WOLFPACK_CONCURRENCY) {
+			ctx.signal.throwIfAborted();
+			const batch = handlePromises.slice(i, i + WOLFPACK_CONCURRENCY);
+			const batchResults = await Promise.allSettled(batch);
+			handleResults.push(...batchResults);
+		}
+		const completionPromises = handleResults.map(async (settled) => {
 			if (settled.status === "rejected") return {
 				item: "unknown",
 				result: `Spawn failed: ${settled.reason instanceof Error ? settled.reason.message : String(settled.reason)}`,
 				success: false
 			};
-			const { item, handle } = settled.value;
+			const value = settled.value;
+			if ("error" in value) {
+				const msg = value.error instanceof Error ? value.error.message : String(value.error);
+				return {
+					item: value.item,
+					result: `Spawn failed: ${msg}`,
+					success: false
+				};
+			}
+			const { item, handle } = value;
 			try {
 				return {
 					item,
@@ -75655,7 +76210,7 @@ var ReadGroupTool = class {
 			});
 		}
 		const accesses = executions.filter((e) => "exec" in e).flatMap((e) => e.exec.accesses ?? ToolAccesses.none());
-		const sortedPaths = [...paths].sort();
+		const sortedPaths = [...paths].toSorted();
 		const approvalRule = literalRulePattern(this.name, sortedPaths.join("\n"));
 		const deniedCount = executions.filter((e) => "error" in e).length;
 		return {
@@ -76267,7 +76822,7 @@ function commandNotFoundHint(command) {
 	return "Hint: The command binary was not found. Check that the required toolchain is installed and use the project-specific script when available.";
 }
 function validateCommand(command, isWindows) {
-	const cmd = command;
+	const cmd = command.replace(/^(?:command\s+|builtin\s+)+/, "");
 	if (/\bkill\s+-9\s+-1\b/.test(cmd) || /\bkill\s+-KILL\s+-1\b/.test(cmd)) return rejectDangerousCommand("kill -9 -1", "Use 'kill <pid>' with a specific PID to terminate the target process.");
 	if (/\b(killall|pkill)\b.*\b(node|scream)/i.test(cmd)) return rejectDangerousCommand("killall/pkill node", "Use 'kill <pid>' with a specific PID, or use the server's own stop command.");
 	if (isWindows) {
@@ -76555,7 +77110,7 @@ const TodoItemSchema = z.object({
 	]).describe("Current status of the todo."),
 	phase: z.string().optional().describe("Optional phase/group for the todo. Items in the same phase are rendered together. Complete one phase before starting the next.")
 });
-const TodoListInputSchema = z.object({ todos: z.array(TodoItemSchema).optional().describe("The updated todo list. Omit to read the current todo list without making changes. Pass an empty array to clear the list.") });
+const TodoListInputSchema = z.object({ todos: z.array(TodoItemSchema).max(200).optional().describe("The updated todo list. Omit to read the current todo list without making changes. Pass an empty array to clear the list.") });
 function renderTodoList(todos) {
 	if (todos.length === 0) return "Todo list is empty.";
 	const groups = /* @__PURE__ */ new Map();
@@ -77070,11 +77625,15 @@ async function chatWithRetry(input) {
 			logRequestFailure(input, error, attempt, maxAttempts);
 			throw error;
 		}
+		if (error instanceof APIProviderRateLimitError && error.reason === "QUOTA_EXHAUSTED") {
+			logRequestFailure(input, error, attempt, maxAttempts);
+			throw error;
+		}
 		if (attempt >= maxAttempts || !input.llm.isRetryableError(error)) {
 			logRequestFailure(input, error, attempt, maxAttempts);
 			throw error;
 		}
-		const delayMs = delays[attempt - 1] ?? 0;
+		const delayMs = computeDelayMs(error, delays, attempt);
 		input.params.signal.throwIfAborted();
 		input.dispatchEvent({
 			type: "step.retrying",
@@ -77090,6 +77649,10 @@ async function chatWithRetry(input) {
 		await sleepForRetry(delayMs, input.params.signal);
 	}
 }
+function computeDelayMs(error, delays, attempt) {
+	if (error instanceof APIProviderRateLimitError) return calculateRateLimitBackoffMs(error.reason);
+	return delays[attempt - 1] ?? 0;
+}
 function logRequestFailure(input, error, attempt, maxAttempts) {
 	if (isAbortError$1(error) || input.params.signal.aborted) return;
 	input.log?.warn("llm request failed", {
@@ -77334,6 +77897,7 @@ var DefaultCompactionStrategy = class {
 	}
 	shouldCompactProactively(usedSize, maxOutputTokens) {
 		if (this.maxSize <= 0) return false;
+		if (this.config.triggerRatio >= 1) return false;
 		return usedSize + this.estimateTurnGrowth(maxOutputTokens) >= this.maxSize;
 	}
 	get checkAfterStep() {
@@ -77377,6 +77941,8 @@ var FullCompaction = class {
 	agent;
 	compactionCountInTurn = 0;
 	consecutiveCompactionFailures = 0;
+	_shouldInjectSessionSummary = false;
+	compactionTimedOut = false;
 	compacting = null;
 	_compactedHistory = [];
 	strategy;
@@ -77394,6 +77960,14 @@ var FullCompaction = class {
 	get compactedHistory() {
 		return this._compactedHistory;
 	}
+	/** One-shot: true if session memory summary should be injected at the next step. */
+	shouldInjectSessionSummary() {
+		if (this._shouldInjectSessionSummary) {
+			this._shouldInjectSessionSummary = false;
+			return true;
+		}
+		return false;
+	}
 	begin(data) {
 		if (this.compacting) return;
 		if (data.source === "manual") this.compactionCountInTurn = 0;
@@ -77449,13 +78023,22 @@ var FullCompaction = class {
 		this.consecutiveCompactionFailures = 0;
 	}
 	async handleOverflowError(signal, error) {
-		if (!this.beginAutoCompaction() && !this.compacting) throw error;
-		await this.block(signal);
+		if (!this.beginAutoCompaction(false) && !this.compacting) {
+			if (this.consecutiveCompactionFailures >= MAX_CONSECUTIVE_FAILURES) this.agent.emitEvent({
+				type: "warning",
+				message: "压缩熔断器已打开，使用 /compact 手动重试。",
+				code: "compaction_circuit_open_overflow"
+			});
+			throw error;
+		}
 	}
 	async beforeStep(signal) {
 		this.agent.microCompaction.detect();
 		const effectiveTokens = this.effectiveTokenCount;
-		if (this.strategy.shouldCompact(effectiveTokens) || this.strategy.shouldCompactProactively(effectiveTokens, this.estimatedMaxOutputTokens)) this.checkAutoCompaction();
+		const isReactiveTrigger = this.strategy.shouldCompact(effectiveTokens);
+		const isProactiveTrigger = !isReactiveTrigger && this.strategy.shouldCompactProactively(effectiveTokens, this.estimatedMaxOutputTokens);
+		if (isReactiveTrigger) this.checkAutoCompaction();
+		else if (isProactiveTrigger) this.beginAutoCompaction();
 		if (this.strategy.shouldBlock(effectiveTokens)) await this.block(signal);
 	}
 	/** Conservative estimate of max output tokens for one API call. */
@@ -77497,7 +78080,10 @@ var FullCompaction = class {
 		if (!active) return;
 		active.blockedByTurn = true;
 		const timeoutId = setTimeout(() => {
-			if (this.compacting === active) this.markCanceled("压缩超时（60秒），已取消。请使用 /compact 手动重试。");
+			if (this.compacting === active) {
+				this.compactionTimedOut = true;
+				this.markCanceled("压缩超时（60秒），已取消。请使用 /compact 手动重试。");
+			}
 		}, 6e4);
 		const onAbort = () => {
 			clearTimeout(timeoutId);
@@ -77558,7 +78144,7 @@ var FullCompaction = class {
 				return;
 			}
 			const recent = originalHistory.slice(compactedCount);
-			const tokensAfter = estimateTokens(summary) + estimateTokensForMessages(recent);
+			const tokensAfter = estimateTokens$1(summary) + estimateTokensForMessages(recent);
 			const result = {
 				summary,
 				compactedCount,
@@ -77574,8 +78160,11 @@ var FullCompaction = class {
 			await this.extractAndStoreMemos(summary);
 			this.triggerPostCompactHook(data, result);
 			this.consecutiveCompactionFailures = 0;
+			this._shouldInjectSessionSummary = true;
 		} catch (error) {
-			if (!isAbortError$1(error)) {
+			const wasTimedOut = this.compactionTimedOut;
+			this.compactionTimedOut = false;
+			if (!isAbortError$1(error) || wasTimedOut) {
 				const blockedByTurn = this.compacting?.blockedByTurn === true;
 				this.consecutiveCompactionFailures += 1;
 				if (this.consecutiveCompactionFailures >= MAX_CONSECUTIVE_FAILURES) this.agent.emitEvent({
@@ -77751,7 +78340,7 @@ var MicroCompaction = class {
 		const { history } = this.agent.context;
 		const maxContextTokens = this.agent.config.modelCapabilities.max_context_tokens;
 		const contextTokens = this.agent.context.tokenCountWithPending;
-		if ((maxContextTokens !== void 0 && maxContextTokens > 0 ? contextTokens / maxContextTokens : 1) < config.minContextUsageRatio) return;
+		if ((maxContextTokens !== void 0 && maxContextTokens > 0 ? contextTokens / maxContextTokens : 0) < config.minContextUsageRatio) return;
 		const nextCutoff = Math.max(0, history.length - config.keepRecentMessages);
 		this.apply(nextCutoff);
 	}
@@ -77800,7 +78389,7 @@ var MicroCompaction = class {
 			if (message?.role !== "tool" || message.toolCallId === void 0) continue;
 			const contentTokens = estimateTokensForMessages([message]);
 			if (contentTokens < this.config.minContentTokens) continue;
-			markerTokenCount ??= estimateTokens(this.config.truncatedMarker);
+			markerTokenCount ??= estimateTokens$1(this.config.truncatedMarker);
 			truncatedToolResultCount += 1;
 			beforeTokens += contentTokens;
 			afterTokens += markerTokenCount;
@@ -78275,7 +78864,7 @@ function createCronScheduler(opts) {
 			const parsed = getParsed(task.cron);
 			const seen = lastSeenAt.get(task.id);
 			const persistedCursor = task.lastFiredAt !== void 0 && Number.isFinite(task.lastFiredAt) && task.lastFiredAt <= clocks.wallNow() ? task.lastFiredAt : void 0;
-			const cursor = seen !== void 0 ? seen : persistedCursor !== void 0 ? persistedCursor : void 0;
+			const cursor = seen ?? persistedCursor ?? void 0;
 			return computeJitteredNext(task, parsed, cursor !== void 0 && cursor > task.createdAt ? cursor : task.createdAt);
 		} catch (error) {
 			debugLog(`getNextFireFor skipping task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
@@ -78371,7 +78960,9 @@ var CronManager = class {
 			source: () => this.store.list(),
 			isIdle: () => !agent.turn.hasActiveTurn,
 			isKilled: () => process.env["SCREAM_DISABLE_CRON"] === "1",
-			onFire: (task, ctx) => this.handleFire(task, ctx),
+			onFire: (task, ctx) => {
+				this.handleFire(task, ctx);
+			},
 			removeOneShot: (id) => {
 				this.removeTasks([id]);
 			},
@@ -78464,8 +79055,8 @@ var CronManager = class {
 	*/
 	persistEnqueue(id, work) {
 		if (this.persistStore === void 0) return;
-		const next = (this.persistQueues.get(id) ?? Promise.resolve()).catch(() => {}).then(() => work()).catch((err) => {
-			this.agent.log?.warn?.("cron persist failed", err);
+		const next = (this.persistQueues.get(id) ?? Promise.resolve()).catch(() => {}).then(() => work()).catch((error) => {
+			this.agent.log?.warn?.("cron persist failed", error);
 		}).finally(() => {
 			if (this.persistQueues.get(id) === next) this.persistQueues.delete(id);
 		});
@@ -78911,10 +79502,12 @@ var ContextMemory = class {
 				if (removedUserCount >= count) break;
 			}
 		}
-		this.openSteps.clear();
-		this.pendingToolResultIds.clear();
-		this.deferredMessages = [];
-		this.agent.emitStatusUpdated();
+		for (let i = this._history.length - 1; i >= 0; i--) {
+			if (this._history[i]?.origin?.kind !== "injection") continue;
+			const prev = this._history[i - 1];
+			const next = this._history[i + 1];
+			if (prev?.origin?.kind === "injection" || next?.origin?.kind === "injection" || i === 0) this._history.splice(i, 1);
+		}
 		if (!this.agent.records.restoring && (stoppedAtBoundary || removedUserCount < count)) {}
 	}
 	applyCompaction(summary) {
@@ -78937,6 +79530,7 @@ var ContextMemory = class {
 		this.tokenCountCoveredMessageCount = this._history.length;
 		this.agent.injection.onContextCompacted(summary.compactedCount);
 		this.agent.emitStatusUpdated();
+		this.agent.microCompaction.reset();
 	}
 	data() {
 		return {
@@ -79068,8 +79662,8 @@ function toolResultOutputForModel(result) {
 }
 /** Truncate a plain-text tool output that exceeds MAX_TOOL_RESULT_TOKENS. */
 function truncateToolOutput(text) {
-	if (estimateTokens(text) <= MAX_TOOL_RESULT_TOKENS) return text;
-	const budget = MAX_TOOL_RESULT_TOKENS - estimateTokens(TOOL_TRUNCATION_NOTICE);
+	if (estimateTokens$1(text) <= MAX_TOOL_RESULT_TOKENS) return text;
+	const budget = MAX_TOOL_RESULT_TOKENS - estimateTokens$1(TOOL_TRUNCATION_NOTICE);
 	if (budget <= 0) return TOOL_TRUNCATION_NOTICE.trim();
 	let kept = "";
 	let tokens = 0;
@@ -79084,9 +79678,9 @@ function truncateToolOutput(text) {
 /** Truncate oversized text parts in a ContentPart array. */
 function truncateContentParts(parts) {
 	let totalTokens = 0;
-	for (const p of parts) if (p.type === "text") totalTokens += estimateTokens(p.text);
+	for (const p of parts) if (p.type === "text") totalTokens += estimateTokens$1(p.text);
 	if (totalTokens <= MAX_TOOL_RESULT_TOKENS) return [...parts];
-	const budget = MAX_TOOL_RESULT_TOKENS - estimateTokens(TOOL_TRUNCATION_NOTICE);
+	const budget = MAX_TOOL_RESULT_TOKENS - estimateTokens$1(TOOL_TRUNCATION_NOTICE);
 	if (budget <= 0) return [{
 		type: "text",
 		text: TOOL_TRUNCATION_NOTICE.trim()
@@ -79098,7 +79692,7 @@ function truncateContentParts(parts) {
 			result.push(p);
 			continue;
 		}
-		const partTokens = estimateTokens(p.text);
+		const partTokens = estimateTokens$1(p.text);
 		if (used + partTokens <= budget) {
 			result.push(p);
 			used += partTokens;
@@ -79520,15 +80114,25 @@ var DynamicInjector = class {
 };
 //#endregion
 //#region ../../packages/agent-core/src/agent/injection/goal.ts
+const GOAL_REMINDER_INTERVAL = 5;
 var GoalInjector = class extends DynamicInjector {
 	injectionVariant = "goal";
 	getInjection() {
 		const goal = this.agent.goal.getGoal().goal;
 		if (goal === null) return void 0;
+		if (this.injectedAt !== null) {
+			if (this.countAssistantTurnsSince(this.injectedAt) < GOAL_REMINDER_INTERVAL) return void 0;
+		}
 		if (goal.status === "active") return buildGoalReminder(goal);
 		if (goal.status === "blocked") return buildBlockedNote(goal);
 		if (goal.status === "paused") return buildPausedNote(goal);
 	}
+	countAssistantTurnsSince(from) {
+		let count = 0;
+		const history = this.agent.context.history;
+		for (let i = from; i < history.length; i++) if (history[i]?.role === "assistant") count++;
+		return count;
+	}
 };
 function buildBlockedNote(goal) {
 	const reason = goal.terminalReason;
@@ -79932,11 +80536,15 @@ var WolfPackModeInjector = class extends DynamicInjector {
 };
 //#endregion
 //#region ../../packages/agent-core/src/agent/injection/working-set.ts
+const WORKING_SET_REMINDER_INTERVAL = 3;
 var WorkingSetInjector = class extends DynamicInjector {
 	injectionVariant = "working-set";
 	getInjection() {
 		const paths = this.agent.workingSet.getPaths();
 		if (paths.length === 0) return void 0;
+		if (this.injectedAt !== null) {
+			if (this.countAssistantTurnsSince(this.injectedAt) < WORKING_SET_REMINDER_INTERVAL) return void 0;
+		}
 		return [
 			"## Working Set",
 			"",
@@ -79946,6 +80554,12 @@ var WorkingSetInjector = class extends DynamicInjector {
 			"优先检查这些文件，避免重复读取未修改文件。"
 		].join("\n");
 	}
+	countAssistantTurnsSince(from) {
+		let count = 0;
+		const history = this.agent.context.history;
+		for (let i = from; i < history.length; i++) if (history[i]?.role === "assistant") count++;
+		return count;
+	}
 };
 //#endregion
 //#region ../../packages/agent-core/src/agent/injection/manager.ts
@@ -81203,21 +81817,14 @@ var WolfPackMode = class {
 //#region ../../packages/agent-core/src/agent/session-memory.ts
 const MAX_EVENTS = 50;
 const MAX_SUMMARY_LENGTH = 1500;
-/**
-* In-memory session running notes.
-*
-* Tracks tool executions and errors during the current session so a brief
-* summary can be injected after compaction, preventing the model from losing
-* its bearings when detailed conversation history is compressed away.
-*/
 var SessionMemory = class {
 	agent;
 	events = [];
-	lastInjectedStep = -1;
+	lastInjectedSeq = -1;
+	nextSeq = 1;
 	constructor(agent) {
 		this.agent = agent;
 	}
-	/** Record a tool execution (success or failure). */
 	recordToolExecution(toolName, argsSummary, isError, step) {
 		this.events.push({
 			type: "tool_execution",
@@ -81225,26 +81832,26 @@ var SessionMemory = class {
 			argsSummary,
 			isError,
 			timestamp: Date.now(),
-			step
+			step,
+			seq: this.nextSeq++
 		});
 		if (this.events.length > MAX_EVENTS) this.events = this.events.slice(-50);
 	}
-	/** Record a session-level error. */
 	recordError(message, step) {
 		this.events.push({
 			type: "error",
 			message,
 			isError: true,
 			timestamp: Date.now(),
-			step
+			step,
+			seq: this.nextSeq++
 		});
 		if (this.events.length > MAX_EVENTS) this.events = this.events.slice(-50);
 	}
-	/** Build a markdown summary of recent activity since the last injection. */
 	getSessionSummary() {
-		const newEvents = this.events.filter((e) => e.step > this.lastInjectedStep);
+		const newEvents = this.events.filter((e) => e.seq > this.lastInjectedSeq);
 		if (newEvents.length === 0) return "";
-		this.lastInjectedStep = this.events[this.events.length - 1]?.step ?? this.lastInjectedStep;
+		this.lastInjectedSeq = this.events.at(-1)?.seq ?? this.lastInjectedSeq;
 		const recent = newEvents.slice(-15);
 		const toolExecs = recent.filter((e) => e.type === "tool_execution");
 		const errors = recent.filter((e) => e.type === "error");
@@ -81267,10 +81874,10 @@ var SessionMemory = class {
 		const joined = lines.join("\n");
 		return joined.length > MAX_SUMMARY_LENGTH ? joined.slice(0, MAX_SUMMARY_LENGTH - 3) + "..." : joined;
 	}
-	/** Reset for a new session. */
 	clear() {
 		this.events.length = 0;
-		this.lastInjectedStep = -1;
+		this.lastInjectedSeq = -1;
+		this.nextSeq = 1;
 	}
 };
 const VERIFICATION_DEDUP_MS = 6e4;
@@ -81812,7 +82419,7 @@ var BlobStore = class {
 			if (typeof url !== "string") continue;
 			const newUrl = await this.maybeOffloadString(url);
 			if (newUrl === url) continue;
-			if (updated === void 0) updated = { ...part };
+			updated ??= { ...part };
 			updated[key] = {
 				...value,
 				url: newUrl
@@ -95505,6 +96112,7 @@ var TurnFlow = class {
 		});
 		if (turnId !== void 0 && turnId !== this.currentId) return;
 		const cancelReason = reason ?? userCancellationReason();
+		this.agent.usage.endTurn();
 		this.abortTurn(cancelReason);
 		this.agent.subagentHost?.cancelAll(cancelReason);
 	}
@@ -95613,7 +96221,6 @@ var TurnFlow = class {
 			turnId,
 			origin
 		});
-		this.agent.context.appendUserMessage(input, origin);
 		const ended = {
 			type: "turn.ended",
 			turnId,
@@ -95645,6 +96252,7 @@ var TurnFlow = class {
 		this.turnStartWorkingSetPathCount = this.agent.workingSet.getPaths().length;
 		this.turnStartVerificationCount = this.agent.workingSet.getVerificationCount();
 		this.currentStepByTurn.set(turnId, 0);
+		this.currentStep = 0;
 		this.agent.fullCompaction.resetForTurn();
 		this.agent.injection.resetForTurn();
 		this.agent.usage.beginTurn();
@@ -95793,11 +96401,13 @@ var TurnFlow = class {
 								kind: "system_trigger",
 								name: "todo_suggested"
 							});
-							const sessionSummary = this.agent.sessionMemory.getSessionSummary();
-							if (sessionSummary.length > 0) this.agent.context.appendSystemReminder(sessionSummary, {
-								kind: "injection",
-								variant: "session_memory"
-							});
+							if (stepNumber === 1 || this.agent.fullCompaction.shouldInjectSessionSummary()) {
+								const sessionSummary = this.agent.sessionMemory.getSessionSummary();
+								if (sessionSummary.length > 0) this.agent.context.appendSystemReminder(sessionSummary, {
+									kind: "injection",
+									variant: "session_memory"
+								});
+							}
 							if (stepNumber === 1 && this.agent.dreamTracker.shouldSuggest()) this.agent.context.appendSystemReminder(this.agent.dreamTracker.getSuggestionMessage(), {
 								kind: "injection",
 								variant: "dream_suggestion"
@@ -95955,6 +96565,7 @@ var TurnFlow = class {
 			}
 		}
 	}
+	/** Track files touched by builtin tools. Bash-modified files are NOT tracked. */
 	recordWorkingSetPaths(toolName, args, turnId) {
 		const workingSet = this.agent.workingSet;
 		if (toolName === "Read" || toolName === "ReadGroup" || toolName === "ReadMediaFile") {
@@ -96040,7 +96651,23 @@ var TurnFlow = class {
 			/(^|;\s*|&&\s*)\s*pnp[ms]\s+add\s+(--global\s+)?typescript/,
 			/(^|;\s*|&&\s*)\s*pnp[ms]\s+add\s+(--global\s+)?tsx/,
 			/(^|;\s*|&&\s*)\s*yarn\s+add\s+(--dev\s+)?typescript/,
-			/(^|;\s*|&&\s*)\s*yarn\s+add\s+(--dev\s+)?tsx/
+			/(^|;\s*|&&\s*)\s*yarn\s+add\s+(--dev\s+)?tsx/,
+			/\bgit\s+status\b/,
+			/\bgit\s+diff\b/,
+			/\bgit\s+log\b/,
+			/\bgrep\s+/,
+			/\brg\s+/,
+			/\bnode\s+-e\s+/,
+			/\bpython\b/,
+			/\bpython3\b/,
+			/\bwc\s+/,
+			/\bsort\s+/,
+			/\buniq\b/,
+			/\bdiff\s+/,
+			/\bfile\s+/,
+			/\bstat\s+/,
+			/\bdf\s+/,
+			/\bdu\s+/
 		].some((pattern) => pattern.test(normalized));
 	}
 };
@@ -96289,7 +96916,7 @@ var LtodLLM = class {
 			streamEndedAt = Date.now();
 		};
 		const markStreamOutput = () => {
-			if (firstChunkAt === void 0) firstChunkAt = Date.now();
+			firstChunkAt ??= Date.now();
 		};
 		const callbacks = buildLtodCallbacks(params, markStreamOutput);
 		const effectiveProvider = applyCompletionBudget({
@@ -96613,7 +97240,7 @@ var Agent = class {
 		this.logLlmConfigIfChanged(context, configMetadata, buildLlmConfigSignature(configMetadata, systemPrompt, tools));
 		let partialMessageCount = 0;
 		for (const message of history) if (message.partial === true) partialMessageCount += 1;
-		const requestMetadata = { estimatedInputTokens: estimateTokens(systemPrompt) + estimateTokensForMessages(history) + estimateTokensForTools(tools) };
+		const requestMetadata = { estimatedInputTokens: estimateTokens$1(systemPrompt) + estimateTokensForMessages(history) + estimateTokensForTools(tools) };
 		if (partialMessageCount > 0) requestMetadata.partialMessageCount = partialMessageCount;
 		this.log.info("llm request", {
 			...context,
@@ -96844,6 +97471,7 @@ var Agent = class {
 		}
 		const conversationContext = contextParts.join("\n\n");
 		const system = conversationContext ? `${SIDE_QUESTION_SYSTEM}\n\n<conversation_context>\n${conversationContext}\n</conversation_context>` : SIDE_QUESTION_SYSTEM;
+		if (!this.config.hasModel) return "No model configured. Run `scream config` or use `/model` to set a default model.";
 		return (await this.generate(this.config.provider, system, [], [{
 			role: "user",
 			content: [{
@@ -100985,7 +101613,7 @@ function findParentMcpJsonPaths(cwd) {
 		paths.push(join$1(dir, ".scream-code", "mcp.json"));
 		dir = dirname$2(dir);
 	}
-	return paths.reverse();
+	return paths.toReversed();
 }
 /**
 * Load MCP server declarations from:
@@ -114909,7 +115537,7 @@ const LITE_RESULT_RE = /<a\s[^>]*?\bclass\s*=\s*["'][^"']*result-link[^"']*["'][
 const LITE_SNIPPET_RE = /<td\s[^>]*?\bclass\s*=\s*["'][^"']*result-snippet[^"']*["'][^>]*>([\s\S]*?)<\/td>/gi;
 /** Strip HTML tags and decode common HTML entities. */
 function stripHtmlAndDecode(text) {
-	return text.replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#x27;/g, "'").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").trim();
+	return text.replaceAll(/<[^>]*>/g, "").replaceAll("&amp;", "&").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&quot;", "\"").replaceAll("&#x27;", "'").replaceAll("&#39;", "'").replaceAll("&nbsp;", " ").trim();
 }
 /** Unwrap a DuckDuckGo redirect URL to the real target if possible. */
 function unwrapDdgRedirect(url) {
@@ -117095,7 +117723,7 @@ function ccSessionToSummary(cc, agentSessionId, projectName) {
 	const createdAt = parseCcTimestamp(cc.created_at);
 	const updatedAt = parseCcTimestamp(cc.updated_at) ?? createdAt;
 	if (createdAt === void 0 && updatedAt === void 0) return void 0;
-	const title = cc.name?.trim() || cc.id;
+	const title = cc.name?.trim() ?? cc.id;
 	const lastPrompt = lastPromptFromCcHistory(cc.history);
 	const metadata = {
 		source: "cc-connect",
@@ -117167,6 +117795,17 @@ var JianPathOutsideRootError = class extends JianError {
 		this.name = "JianPathOutsideRootError";
 	}
 };
+/** Thrown when process execution fails (spawn error, ENOENT, EACCES). */
+var JianExecError = class extends JianError {
+	command;
+	code;
+	constructor(message, command, code) {
+		super(message);
+		this.command = command;
+		this.code = code;
+		this.name = "JianExecError";
+	}
+};
 //#endregion
 //#region ../../packages/jian/src/environment.ts
 /**
@@ -117651,16 +118290,19 @@ var LocalProcess = class {
 				"/PID",
 				String(this.pid)
 			];
-			return new Promise((resolve) => {
+			return new Promise((resolve, reject) => {
 				const killer = spawn("taskkill", taskkillArgs, {
 					stdio: "ignore",
 					windowsHide: true
 				});
-				const done = () => {
-					resolve();
-				};
-				killer.once("error", done);
-				killer.once("close", done);
+				killer.once("error", (err) => {
+					reject(/* @__PURE__ */ new Error(`taskkill failed to start: ${err.message}`));
+				});
+				killer.once("close", (code) => {
+					if (code === 0) resolve();
+					else reject(/* @__PURE__ */ new Error(`taskkill exited with code ${code ?? "null"}`));
+				});
+				killer.unref();
 			});
 		}
 		try {
@@ -117720,6 +118362,14 @@ var LocalJian = class LocalJian {
 		if (isWithinDirectory(resolvedPath, this._rootDir)) return;
 		throw new JianPathOutsideRootError(`Path outside allowed root directory: ${resolvedPath}`, resolvedPath, this._rootDir);
 	}
+	/** Resolve path for sandboxed operations — lexical check + realpath. */
+	async _resolveSandboxedPath(path) {
+		const lexical = isAbsolute$1(path) ? normalize(path) : join$1(this._cwd, path);
+		if (!isWithinDirectory(lexical, this._rootDir)) throw new JianPathOutsideRootError(`Path outside allowed root directory: ${lexical}`, lexical, this._rootDir);
+		const realPath = await realpath(lexical);
+		if (!isWithinDirectory(realPath, await realpath(this._rootDir))) throw new JianPathOutsideRootError(`Path outside allowed root directory (via symlink): ${lexical}`, lexical, this._rootDir);
+		return realPath;
+	}
 	pathClass() {
 		return isWindows ? "win32" : "posix";
 	}
@@ -117742,13 +118392,14 @@ var LocalJian = class LocalJian {
 	* call `process.chdir(x)` directly.
 	*/
 	async chdir(path) {
-		const resolved = this._resolvePath(path);
+		const resolved = this._rootDir !== void 0 ? await this._resolveSandboxedPath(path) : this._resolvePath(path);
 		if (!(await stat(resolved)).isDirectory()) throw new Error(`Not a directory: ${resolved}`);
 		this._cwd = resolved;
 	}
 	async stat(path, options) {
-		const resolved = this._resolvePath(path);
-		const s = options?.followSymlinks ?? true ? await stat(resolved) : await lstat(resolved);
+		const followSymlinks = options?.followSymlinks ?? true;
+		const resolved = this._rootDir !== void 0 && followSymlinks ? await this._resolveSandboxedPath(path) : this._resolvePath(path);
+		const s = followSymlinks ? await stat(resolved) : await lstat(resolved);
 		return {
 			stMode: s.mode,
 			stIno: s.ino,
@@ -117792,6 +118443,7 @@ var LocalJian = class LocalJian {
 			}
 			for (const entry of entries) {
 				const fullPath = join$1(basePath, entry);
+				if (this._rootDir && !isWithinDirectory(fullPath, this._rootDir)) continue;
 				let entryStat;
 				try {
 					entryStat = await stat(fullPath);
@@ -117815,6 +118467,7 @@ var LocalJian = class LocalJian {
 			for (const entry of entries) {
 				if (!regex.test(entry)) continue;
 				const fullPath = join$1(basePath, entry);
+				if (this._rootDir && !isWithinDirectory(fullPath, this._rootDir)) continue;
 				if (remainingParts.length === 0) yield fullPath;
 				else {
 					let entryStat;
@@ -117851,16 +118504,21 @@ var LocalJian = class LocalJian {
 		return decodeTextWithErrors(await readFile(resolved), encoding, errors);
 	}
 	async *readLines(path, options) {
-		const resolved = this._resolvePath(path);
-		const encoding = options?.encoding ?? "utf-8";
-		const errors = options?.errors ?? "strict";
-		const lines = decodeTextWithErrors(await readFile(resolved), encoding, errors).split("\n");
-		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i];
-			if (line === void 0) continue;
-			if (i < lines.length - 1) yield line + "\n";
-			else if (line !== "") yield line;
+		const stream = createReadStream(this._resolvePath(path), {
+			encoding: options?.encoding ?? "utf-8",
+			highWaterMark: 64 * 1024
+		});
+		let remainder = "";
+		try {
+			for await (const chunk of stream) {
+				const lines = (remainder + chunk).split("\n");
+				remainder = lines.pop() ?? "";
+				for (const line of lines) yield line + "\n";
+			}
+		} finally {
+			stream.destroy();
 		}
+		if (remainder !== "") yield remainder;
 	}
 	async writeBytes(path, data) {
 		await writeFile(this._resolvePath(path), data);
@@ -117913,7 +118571,12 @@ var LocalJian = class LocalJian {
 			detached: !isWindows,
 			env: buildSafeEnv(env)
 		});
-		await waitForSpawn(child);
+		try {
+			await waitForSpawn(child);
+		} catch (error) {
+			if (error instanceof Error) throw new JianExecError(`Failed to spawn ${command}: ${error.message}`, command, error.code);
+			throw error;
+		}
 		return new LocalProcess(child);
 	}
 };
@@ -118923,26 +119586,28 @@ var SDKRpcClient = class {
 	async getStatus(input) {
 		const rpc = await this.getRpc();
 		const agentId = this.interactiveAgentId;
-		const config = await rpc.getConfig({
-			sessionId: input.sessionId,
-			agentId
-		});
-		const context = await rpc.getContext({
-			sessionId: input.sessionId,
-			agentId
-		});
-		const permission = await rpc.getPermission({
-			sessionId: input.sessionId,
-			agentId
-		});
-		const plan = await rpc.getPlan({
-			sessionId: input.sessionId,
-			agentId
-		});
-		const usage = await rpc.getUsage({
-			sessionId: input.sessionId,
-			agentId
-		});
+		const [config, context, permission, plan, usage] = await Promise.all([
+			rpc.getConfig({
+				sessionId: input.sessionId,
+				agentId
+			}),
+			rpc.getContext({
+				sessionId: input.sessionId,
+				agentId
+			}),
+			rpc.getPermission({
+				sessionId: input.sessionId,
+				agentId
+			}),
+			rpc.getPlan({
+				sessionId: input.sessionId,
+				agentId
+			}),
+			rpc.getUsage({
+				sessionId: input.sessionId,
+				agentId
+			})
+		]);
 		const maxContextTokens = config.modelCapabilities?.max_context_tokens ?? 0;
 		const contextTokens = context.tokenCount;
 		const contextUsage = maxContextTokens > 0 ? contextTokens / maxContextTokens : 0;
@@ -119085,7 +119750,9 @@ var SDKRpcClient = class {
 		};
 	}
 	receiveEvent(event) {
-		for (const listener of this.eventListeners) listener(event);
+		for (const listener of this.eventListeners) try {
+			listener(event);
+		} catch {}
 	}
 	setApprovalHandler(sessionId, handler) {
 		if (handler === void 0) {
@@ -119206,19 +119873,24 @@ var Session = class {
 		this.resumeState = options.resumeState ?? resumeStateFromSummary(options.summary);
 		this.rpc = options.rpc;
 		this.onClose = options.onClose;
-		const resumedMeta = this.resumeState?.sessionMetadata;
-		this.metadata = resumedMeta ?? options.summary?.metadata ?? {};
-		if (!this.metadata["custom"]) this.metadata["custom"] = {};
+		const customBag = (this.resumeState?.sessionMetadata)?.custom ?? options.summary?.metadata ?? {};
+		this.metadata = customBag;
 	}
 	getResumeState() {
 		this.ensureOpen();
 		return this.resumeState;
 	}
+	eventUnsubscribers = /* @__PURE__ */ new Set();
 	onEvent(listener) {
 		this.ensureOpen();
-		return this.rpc.onEvent((event) => {
+		const unsub = this.rpc.onEvent((event) => {
 			if (event.sessionId === this.id) listener(event);
 		});
+		this.eventUnsubscribers.add(unsub);
+		return () => {
+			unsub();
+			this.eventUnsubscribers.delete(unsub);
+		};
 	}
 	setApprovalHandler(handler) {
 		this.ensureOpen();
@@ -119545,11 +120217,13 @@ var Session = class {
 	}
 	async close(options = {}) {
 		if (this.closed) return;
-		if (options.extractMemories !== false) try {
-			const extract = this.extractMemoriesOnExit().catch(() => {});
-			await Promise.race([extract, new Promise((resolve) => setTimeout(resolve, 3e4))]);
-		} catch {}
+		if (options.extractMemories !== false) {
+			const extract = this.extractMemoriesOnExit();
+			await Promise.race([extract.catch(() => {}), new Promise((r) => setTimeout(r, 3e4))]);
+		}
 		this.closed = true;
+		for (const unsub of this.eventUnsubscribers) unsub();
+		this.eventUnsubscribers.clear();
 		try {
 			await this.rpc.closeSession({ sessionId: this.id });
 		} finally {
@@ -120067,11 +120741,11 @@ function detectMultiplexer() {
 }
 function detectShellEnvironment() {
 	return {
-		term: process.env["TERM"] || void 0,
-		termProgram: process.env["TERM_PROGRAM"] || void 0,
-		termProgramVersion: process.env["TERM_PROGRAM_VERSION"] || void 0,
+		term: process.env["TERM"] ?? void 0,
+		termProgram: process.env["TERM_PROGRAM"] ?? void 0,
+		termProgramVersion: process.env["TERM_PROGRAM_VERSION"] ?? void 0,
 		multiplexer: detectMultiplexer(),
-		shell: process.env["SHELL"] || void 0
+		shell: process.env["SHELL"] ?? void 0
 	};
 }
 //#endregion
@@ -121283,6 +121957,19 @@ function formatErrorMessage(error) {
 	if (isScreamError(error)) return `[${error.code}] ${error.message}`;
 	return error instanceof Error ? error.message : String(error);
 }
+/**
+* Cap an error message body for inline transcript display. Drops blank lines,
+* keeps the first `maxLines` non-blank lines, and appends a `… (N more lines)`
+* hint when truncated. Full text is preserved in the persisted session — this
+* only bounds the live transcript render.
+*/
+function truncateErrorMessage(message, maxLines = 8) {
+	const lines = message.split("\n").filter((line) => line.trim().length > 0);
+	if (lines.length <= maxLines) return lines.join("\n");
+	const kept = lines.slice(0, maxLines);
+	const remaining = lines.length - maxLines;
+	return `${kept.join("\n")}\n… (${String(remaining)} more lines)`;
+}
 function stringValue(value) {
 	return typeof value === "string" ? value : void 0;
 }
@@ -121408,7 +122095,7 @@ var ApiKeyInputDialogComponent = class extends Container {
 };
 //#endregion
 //#region src/tui/constant/symbols.ts
-const STATUS_BULLET = "● ";
+const STATUS_BULLET = "■ ";
 const USER_MESSAGE_BULLET = "┃ ";
 const FAILURE_MARK = "✗ ";
 //#endregion
@@ -122197,7 +122884,7 @@ async function handleDiyConfig(host) {
 	const maxContextTokens = parseInt(maxContextStr, 10) || 131072;
 	const thinking = await promptThinkingMode(host);
 	if (thinking === void 0) return;
-	const providerId = `custom-${modelId.replace(/[^A-Za-z0-9._-]/g, "-")}`;
+	const providerId = `custom-${modelId.replaceAll(/[^A-Za-z0-9._-]/g, "-")}`;
 	const catalogModel = {
 		id: modelId,
 		name: modelId,
@@ -122588,7 +123275,7 @@ const darkColors = {
 const lightColors = {
 	primary: light.green,
 	accent: light.tangerine700,
-	planMode: "#00FFFF",
+	planMode: "#00838F",
 	text: light.gray900,
 	textStrong: light.gray900,
 	textDim: light.gray700,
@@ -124027,7 +124714,9 @@ async function showGoalStatus(host) {
 		const panel = new GoalStatusMessageComponent(result.goal, host.state.theme.colors);
 		host.state.transcriptContainer.addChild(panel);
 		activeGoalPanel = panel;
-		activeGoalTimer = setTimeout(() => dismissGoalPanel(host), GOAL_STATUS_DISMISS_MS);
+		activeGoalTimer = setTimeout(() => {
+			dismissGoalPanel(host);
+		}, GOAL_STATUS_DISMISS_MS);
 		host.state.ui.requestRender();
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
@@ -124787,10 +125476,109 @@ var SkillActivationComponent = class extends Container {
 	}
 };
 //#endregion
+//#region src/tui/utils/speed-tracker.ts
+/**
+* Streaming-speed gauge for the live thinking indicator.
+*
+* Ported from oh-my-pi `packages/coding-agent/src/modes/components/assistant-message.ts:120-178`.
+* scream-code adaptation: the provider does not report cumulative token counts
+* during streaming (only character deltas), so instantaneous tok/s is estimated
+* from delta length via {@link CHARS_PER_TOKEN_ESTIMATE}. The badge is a progress
+* indicator, not a precise meter.
+*/
+/** Rolling window (ms) over which streaming-rate observations are averaged. */
+const SPEED_WINDOW_MS = 3e3;
+/**
+* Chars-per-token estimate for converting character deltas to an approximate
+* token count. 2.5 is a middle ground between English (~4 chars/token) and
+* Chinese (~1 char/token). Pure Chinese underestimates ~2.5x, pure English
+* overestimates ~1.6x — acceptable for a progress indicator.
+*/
+const CHARS_PER_TOKEN_ESTIMATE = 2.5;
+var SpeedTracker = class {
+	observations = [];
+	prune(now) {
+		const threshold = now - SPEED_WINDOW_MS;
+		while (this.observations.length > 0 && this.observations[0].time < threshold) this.observations.shift();
+	}
+	/**
+	* Record one instantaneous tok/s reading, clamped to {@link SPEED_MAX} so a
+	* single oversized delta can't poison the windowed average. Non-finite or
+	* negative rates are ignored.
+	*/
+	observe(rate, now = performance.now()) {
+		if (!Number.isFinite(rate) || rate < 0) return;
+		this.observations.push({
+			time: now,
+			rate: Math.min(rate, 200)
+		});
+		this.prune(now);
+	}
+	/** Windowed-average tok/s; 0 once observations age out of the window. */
+	getSpeed(now = performance.now()) {
+		this.prune(now);
+		if (this.observations.length === 0) return 0;
+		let sum = 0;
+		for (const o of this.observations) sum += o.rate;
+		return sum / this.observations.length;
+	}
+	reset() {
+		this.observations = [];
+	}
+};
+/**
+* One gauge for the whole session. Only the single live thinking block feeds it
+* (via {@link StreamingUIController.appendThinkingDelta} / {@link appendAssistantDelta}),
+* and only the live {@link ThinkingComponent} reads it. Reset on turn boundaries
+* so a previous turn's trailing rate doesn't leak onto a fresh block.
+*/
+const sharedSpeedTracker = new SpeedTracker();
+function getSharedSpeedTracker() {
+	return sharedSpeedTracker;
+}
+/**
+* Linear-interpolate two `#rrggbb` colors in sRGB space. `t` clamps to [0,1]:
+* `t = 0` → `from`, `t = 1` → `to`. Drives the streaming speed badge, fading
+* from a dim gray toward the theme accent as tok/s rises.
+*/
+function lerpHex(from, to, t) {
+	const k = t < 0 ? 0 : t > 1 ? 1 : t;
+	const fr = Number.parseInt(from.slice(1, 3), 16);
+	const fg = Number.parseInt(from.slice(3, 5), 16);
+	const fb = Number.parseInt(from.slice(5, 7), 16);
+	const tr = Number.parseInt(to.slice(1, 3), 16);
+	const tg = Number.parseInt(to.slice(3, 5), 16);
+	const tb = Number.parseInt(to.slice(5, 7), 16);
+	const r = Math.round(fr + (tr - fr) * k);
+	const g = Math.round(fg + (tg - fg) * k);
+	const b = Math.round(fb + (tb - fb) * k);
+	return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+}
+/**
+* Estimate token count from a character delta. At least 1 to avoid zero-rate
+* observations when a tiny delta arrives.
+*/
+function estimateTokens(delta) {
+	return Math.max(1, Math.round(delta.length / CHARS_PER_TOKEN_ESTIMATE));
+}
+/**
+* Ease the normalized speed ratio [0,1] for color interpolation. Uses smoothstep
+* (zero derivative at both endpoints) so the badge stays mostly gray at low
+* rates — subtle rather than distracting — and only reaches the full accent
+* color at high rates. Smoother than sqrt, whose infinite derivative at t=0
+* makes the color jump toward accent as soon as any tokens flow.
+*/
+function easeSpeedRatio(ratio) {
+	const t = ratio < 0 ? 0 : ratio > 1 ? 1 : ratio;
+	return t * t * (3 - 2 * t);
+}
+//#endregion
 //#region src/tui/components/messages/thinking.ts
 var ThinkingComponent = class {
 	text;
 	color;
+	dimColor;
+	accentColor;
 	showMarker;
 	mode;
 	expanded = false;
@@ -124803,6 +125591,8 @@ var ThinkingComponent = class {
 	constructor(text, colors, showMarker = true, mode = "finalized", ui) {
 		this.text = text;
 		this.color = colors.roleThinking;
+		this.dimColor = colors.textDim;
+		this.accentColor = colors.primary;
 		this.showMarker = showMarker;
 		this.mode = mode;
 		this.ui = ui;
@@ -124845,9 +125635,12 @@ var ThinkingComponent = class {
 		const contentLines = this.text.length > 0 ? this.textComponent.render(contentWidth) : [""];
 		if (this.mode === "live") {
 			const visibleLines = contentLines.length > 2 ? contentLines.slice(contentLines.length - 2) : contentLines;
+			const spinner = chalk.hex(this.color)(`${BRAILLE_SPINNER_FRAMES[this.spinnerFrame] ?? BRAILLE_SPINNER_FRAMES[0]} `);
+			const rate = Math.min(200, getSharedSpeedTracker().getSpeed());
+			const rateSuffix = rate > .05 ? chalk.hex(lerpHex(this.dimColor, this.accentColor, easeSpeedRatio(rate / 200)))(` · ${rate.toFixed(1)} toks/s`) : "";
 			return [
 				"",
-				chalk.hex(this.color)(`${BRAILLE_SPINNER_FRAMES[this.spinnerFrame] ?? BRAILLE_SPINNER_FRAMES[0]} `) + chalk.hex(this.color)("思考中..."),
+				spinner + chalk.hex(this.color)("思考中...") + rateSuffix,
 				...visibleLines.map((line) => "  " + line)
 			];
 		}
@@ -124949,6 +125742,66 @@ function makeDiffStyles(colors) {
 		meta: (s) => chalk.hex(colors.diffMeta)(s)
 	};
 }
+/**
+* Compute word-level diff between two single lines and highlight the changed
+* words with `chalk.inverse()`. Only the first removed/added part has its
+* leading whitespace stripped, so indentation isn't highlighted.
+*
+* Ported from oh-my-pi `packages/coding-agent/src/modes/components/diff.ts:55-95`.
+* Returns the two lines with inline inverse highlighting applied; caller wraps
+* them in the usual add/del gutter + line color.
+*/
+function renderIntraLineDiff(oldContent, newContent) {
+	const wordDiff = diffWords(oldContent, newContent);
+	let removedLine = "";
+	let addedLine = "";
+	let isFirstRemoved = true;
+	let isFirstAdded = true;
+	for (const part of wordDiff) if (part.removed) {
+		let value = part.value;
+		if (isFirstRemoved) {
+			const leadingWs = value.match(/^(\s*)/)?.[1] ?? "";
+			value = value.slice(leadingWs.length);
+			removedLine += leadingWs;
+			isFirstRemoved = false;
+		}
+		if (value) removedLine += chalk.inverse(value);
+	} else if (part.added) {
+		let value = part.value;
+		if (isFirstAdded) {
+			const leadingWs = value.match(/^(\s*)/)?.[1] ?? "";
+			value = value.slice(leadingWs.length);
+			addedLine += leadingWs;
+			isFirstAdded = false;
+		}
+		if (value) addedLine += chalk.inverse(value);
+	} else {
+		removedLine += part.value;
+		addedLine += part.value;
+	}
+	return {
+		removedLine,
+		addedLine
+	};
+}
+/**
+* Check whether a delete line at index `i` and an add line at index `i+1`
+* form an isolated single-line replacement — the only case where intra-line
+* word diff is meaningful. We require both sides to be single-line blocks
+* (prev of delete is not delete; next of add is not add) so multi-line
+* delete/add blocks stay as whole-line coloring.
+*/
+function isIsolatedSingleLinePair(lines, i) {
+	const curr = lines[i];
+	const next = lines[i + 1];
+	if (curr === void 0 || next === void 0) return false;
+	if (curr.kind !== "delete" || next.kind !== "add") return false;
+	const prev = lines[i - 1];
+	if (prev !== void 0 && prev.kind === "delete") return false;
+	const after = lines[i + 2];
+	if (after !== void 0 && after.kind === "add") return false;
+	return true;
+}
 function computeDiffLines(oldText, newText, oldStart = 1, newStart = 1, isIncomplete = false) {
 	const oldLines = oldText ? oldText.split("\n") : [];
 	const newLines = newText ? newText.split("\n") : [];
@@ -125005,10 +125858,22 @@ function renderDiffLines(oldText, newText, path, colors, isIncomplete = false, o
 	header += path;
 	output.push(header);
 	const shown = maxLines !== void 0 && maxLines >= 0 && changedLines.length > maxLines ? changedLines.slice(0, maxLines) : changedLines;
-	for (const line of shown) {
+	let i = 0;
+	while (i < shown.length) {
+		if (isIsolatedSingleLinePair(shown, i)) {
+			const line = shown[i];
+			const next = shown[i + 1];
+			const { removedLine, addedLine } = renderIntraLineDiff(line.code, next.code);
+			output.push(s.gutter(String(line.lineNum).padStart(4) + " ") + s.del("- " + removedLine));
+			output.push(s.gutter(String(next.lineNum).padStart(4) + " ") + s.add("+ " + addedLine));
+			i += 2;
+			continue;
+		}
+		const line = shown[i];
 		const marker = line.kind === "add" ? "+" : "-";
 		const color = line.kind === "add" ? s.add : s.del;
 		output.push(s.gutter(String(line.lineNum).padStart(4) + " ") + color(marker + " " + line.code));
+		i += 1;
 	}
 	const hidden = changedLines.length - shown.length;
 	if (hidden > 0) output.push(s.meta(`     … ${String(hidden)} more change${hidden > 1 ? "s" : ""} hidden (ctrl+o to expand)`));
@@ -125107,16 +125972,35 @@ function renderDiffLinesClustered(oldText, newText, path, colors, opts = {}) {
 				body++;
 			}
 		}
-		for (let i = cluster.start; i <= cluster.end; i++) {
+		let i = cluster.start;
+		while (i <= cluster.end) {
 			if (body >= cap) {
 				truncated = true;
 				break outer;
 			}
 			const line = diffLines[i];
+			if (i + 1 <= cluster.end && isIsolatedSingleLinePair(diffLines, i)) {
+				const next = diffLines[i + 1];
+				const { removedLine, addedLine } = renderIntraLineDiff(line.code, next.code);
+				output.push(s.gutter(String(line.lineNum).padStart(4) + " ") + s.del("- " + removedLine));
+				body++;
+				if (body >= cap) {
+					truncated = true;
+					prevEnd = i;
+					break outer;
+				}
+				output.push(s.gutter(String(next.lineNum).padStart(4) + " ") + s.add("+ " + addedLine));
+				body++;
+				shownChanges += 2;
+				prevEnd = i + 1;
+				i += 2;
+				continue;
+			}
 			output.push(formatDiffRow(line, s));
 			body++;
 			if (line.kind !== "context") shownChanges++;
 			prevEnd = i;
+			i += 1;
 		}
 	}
 	if (truncated) {
@@ -125351,7 +126235,66 @@ const shellExecutionResultRenderer = (toolCall, result, ctx) => [new ShellExecut
 	commandPreviewLines: void 0
 })];
 //#endregion
+//#region src/tui/components/media/image-thumbnail.ts
+/**
+* Transcript-side rendering of a pasted image.
+*
+* On terminals that speak the Kitty graphics protocol or iTerm2 inline
+* image protocol (detected by pi-tui's `getCapabilities()`), we show
+* the actual image. Everywhere else we fall back to a one-line text
+* marker matching the placeholder the user sees in the input box —
+* this keeps the transcript readable on Terminal.app / Linux default
+* terminals / `script` recordings without extra chrome.
+*
+* Height is capped at ~12 rows so a single screenshot can't monopolize
+* the viewport; pi-tui handles proportional scaling internally.
+*/
+const MAX_IMAGE_ROWS = 12;
+const MAX_IMAGE_WIDTH = 40;
+function createImageComponent(opts, colors) {
+	const caps = getCapabilities();
+	if (!(caps.images === "kitty" || caps.images === "iterm2")) {
+		const label = opts.filename ?? `[${opts.mime}]`;
+		return new Text(chalk.hex(colors.accent)(label), 0, 0);
+	}
+	return new Image(opts.base64, opts.mime, { fallbackColor: (s) => chalk.hex(colors.textDim)(s) }, {
+		maxHeightCells: MAX_IMAGE_ROWS,
+		maxWidthCells: MAX_IMAGE_WIDTH,
+		filename: opts.filename
+	}, {
+		widthPx: opts.width,
+		heightPx: opts.height
+	});
+}
+var ImageThumbnail = class extends Container {
+	constructor(attachment, colors) {
+		super();
+		const base64 = Buffer.from(attachment.bytes).toString("base64");
+		this.addChild(createImageComponent({
+			base64,
+			mime: attachment.mime,
+			width: attachment.width,
+			height: attachment.height,
+			filename: attachment.placeholder
+		}, colors));
+	}
+};
+//#endregion
 //#region src/tui/components/messages/tool-renderers/media.ts
+/**
+* ReadMediaFile renderer.
+*
+* The ReadMediaFile tool `output` is the JSON-serialized array of
+* content parts the tool returned — which includes the full base64 of
+* the image/video. Dumping that string into the transcript blasts a
+* multi-screen blob of base64. This renderer parses the envelope and
+* surfaces just the human-readable bits (kind, path, mime, size) via
+* a header chip + a tiny expanded body. It never emits the base64.
+*
+* On error, or when the output isn't the expected media envelope, we
+* fall back to the truncated renderer so the user still sees the raw
+* message.
+*/
 const PATH_TAG_RE = /^<(image|video)\s+path="([^"]+)">$/;
 const ORIGINAL_SIZE_RE = /original size\s+(\d+x\d+px)/;
 const DATA_URL_RE = /^data:([^;]+);base64,(.*)$/s;
@@ -125373,6 +126316,7 @@ function parseReadMediaOutput(output) {
 	let path;
 	let mimeType;
 	let bytes;
+	let base64;
 	let url;
 	let originalSize;
 	let foundMedia = false;
@@ -125403,6 +126347,7 @@ function parseReadMediaOutput(output) {
 					if (data && data[1] !== void 0 && data[2] !== void 0) {
 						mimeType = data[1];
 						bytes = bytesFromBase64(data[2]);
+						base64 = data[2];
 					} else url = u;
 				}
 			}
@@ -125413,6 +126358,7 @@ function parseReadMediaOutput(output) {
 	if (path !== void 0) summary.path = path;
 	if (mimeType !== void 0) summary.mimeType = mimeType;
 	if (bytes !== void 0) summary.bytes = bytes;
+	if (base64 !== void 0) summary.base64 = base64;
 	if (url !== void 0) summary.url = url;
 	if (originalSize !== void 0) summary.originalSize = originalSize;
 	return summary;
@@ -125441,15 +126387,33 @@ const readMediaSummary = (toolCall, result, ctx) => {
 	if (result.is_error) return renderTruncated(toolCall, result, ctx);
 	const summary = parseReadMediaOutput(result.output);
 	if (summary === null) return renderTruncated(toolCall, result, ctx);
-	if (!ctx.expanded) return [];
 	const dim = chalk.dim;
 	const out = [];
-	if (summary.path !== void 0) out.push(new Text(`  ${dim(summary.path)}`, 0, 0));
-	const meta = metaSegments(summary);
-	const tail = [summary.kind];
-	if (meta.length > 0) tail.push(meta.join(", "));
-	if (summary.url !== void 0) tail.push(summary.url);
-	out.push(new Text(`  ${dim(tail.join(" · "))}`, 0, 0));
+	if (ctx.expanded) {
+		if (summary.path !== void 0) out.push(new Text(`  ${dim(summary.path)}`, 0, 0));
+		const meta = metaSegments(summary);
+		const tail = [summary.kind];
+		if (meta.length > 0) tail.push(meta.join(", "));
+		if (summary.url !== void 0) tail.push(summary.url);
+		out.push(new Text(`  ${dim(tail.join(" · "))}`, 0, 0));
+	}
+	if (summary.kind === "image" && summary.base64 !== void 0 && summary.mimeType !== void 0) {
+		const caps = getCapabilities();
+		const supportsInline = caps.images === "kitty" || caps.images === "iterm2";
+		if (ctx.expanded || supportsInline) {
+			const dims = getImageDimensions(summary.base64, summary.mimeType) ?? {
+				widthPx: 800,
+				heightPx: 600
+			};
+			out.push(createImageComponent({
+				base64: summary.base64,
+				mime: summary.mimeType,
+				width: dims.widthPx,
+				height: dims.heightPx,
+				filename: summary.path
+			}, ctx.colors));
+		}
+	}
 	return out;
 };
 //#endregion
@@ -126868,42 +127832,6 @@ function formatActivityLine(verb, toolName, args, workspaceDir) {
 	return keyArg ? `${verb} ${toolName} (${keyArg})` : `${verb} ${toolName}`;
 }
 //#endregion
-//#region src/tui/components/media/image-thumbnail.ts
-/**
-* Transcript-side rendering of a pasted image.
-*
-* On terminals that speak the Kitty graphics protocol or iTerm2 inline
-* image protocol (detected by pi-tui's `getCapabilities()`), we show
-* the actual image. Everywhere else we fall back to a one-line text
-* marker matching the placeholder the user sees in the input box —
-* this keeps the transcript readable on Terminal.app / Linux default
-* terminals / `script` recordings without extra chrome.
-*
-* Height is capped at ~12 rows so a single screenshot can't monopolize
-* the viewport; pi-tui handles proportional scaling internally.
-*/
-const MAX_IMAGE_ROWS = 12;
-const MAX_IMAGE_WIDTH = 40;
-var ImageThumbnail = class extends Container {
-	constructor(attachment, colors) {
-		super();
-		const caps = getCapabilities();
-		if (!(caps.images === "kitty" || caps.images === "iterm2")) {
-			this.addChild(new Text(chalk.hex(colors.accent)(attachment.placeholder), 0, 0));
-			return;
-		}
-		const image = new Image(Buffer.from(attachment.bytes).toString("base64"), attachment.mime, { fallbackColor: (s) => chalk.hex(colors.textDim)(s) }, {
-			maxHeightCells: MAX_IMAGE_ROWS,
-			maxWidthCells: MAX_IMAGE_WIDTH,
-			filename: attachment.placeholder
-		}, {
-			widthPx: attachment.width,
-			heightPx: attachment.height
-		});
-		this.addChild(image);
-	}
-};
-//#endregion
 //#region src/tui/components/messages/user-message.ts
 var UserMessageComponent = class {
 	color;
@@ -127695,7 +128623,7 @@ async function loadServers(host) {
 }
 /** Replace newlines so error messages don't break single-line terminal rendering. */
 function sanitizeDesc(s) {
-	return s.replace(/\r?\n/g, " ").replace(/\s+/g, " ").trim();
+	return s.replaceAll(/\r?\n/g, " ").replaceAll(/\s+/g, " ").trim();
 }
 function buildRows(servers) {
 	const rows = [];
@@ -127933,7 +128861,8 @@ var McpPickerComponent = class extends Container {
 			this.selectedIndex = this.nextSelectable(this.selectedIndex);
 			return;
 		}
-		if (data === "d" || data === "D") {
+		const key = printableChar(data);
+		if (key === "d" || key === "D") {
 			const row = this.rows[this.selectedIndex];
 			if (row && row.kind === "installed" && row.status && row.status !== "__section" && row.status !== "__empty") this.onDelete(row);
 			return;
@@ -128098,7 +129027,7 @@ function readConfiguredType() {
 	}
 }
 function escapeSingleQuotes(str) {
-	return str.replace(/'/g, "\\'");
+	return str.replaceAll("'", "\\'");
 }
 function generateConfig$1(platform) {
 	const dir = dirname$1(CONFIG_PATH);
@@ -130137,11 +131066,18 @@ var EditorKeyboardController = class {
 	}
 };
 //#endregion
+//#region src/tui/utils/sanitize.ts
+/** Replace tabs with spaces, keeping column alignment. Default tab width 4. */
+function replaceTabs(text, tabWidth = 4) {
+	return text.replaceAll("	", " ".repeat(tabWidth));
+}
+//#endregion
 //#region src/tui/components/messages/status-message.ts
 var StatusMessageComponent = class extends Container {
 	constructor(content, colors, color) {
 		super();
-		const text = color === void 0 ? chalk.hex(colors.textDim)(content) : chalk.hex(color)(content);
+		const sanitized = replaceTabs(content);
+		const text = color === void 0 ? chalk.hex(colors.textDim)(sanitized) : chalk.hex(color)(sanitized);
 		this.addChild(new Text(`  ${text}`, 0, 0));
 	}
 };
@@ -130149,8 +131085,8 @@ var NoticeMessageComponent = class extends Container {
 	constructor(title, detail, colors) {
 		super();
 		this.addChild(new Spacer(1));
-		this.addChild(new Text(`  ${chalk.hex(colors.textStrong)(title)}`, 0, 0));
-		if (detail !== void 0 && detail.length > 0) this.addChild(new Text(`  ${chalk.hex(colors.textDim)(detail)}`, 0, 0));
+		this.addChild(new Text(`  ${chalk.hex(colors.textStrong)(replaceTabs(title))}`, 0, 0));
+		if (detail !== void 0 && detail.length > 0) this.addChild(new Text(`  ${chalk.hex(colors.textDim)(replaceTabs(detail))}`, 0, 0));
 	}
 };
 //#endregion
@@ -131964,6 +132900,7 @@ var StreamingUIController = class {
 	_currentStep = 0;
 	_assistantDraft = "";
 	_thinkingDraft = "";
+	lastDeltaAt;
 	_thinkingEntry = void 0;
 	_compactionEntry = void 0;
 	_streamingBlock = null;
@@ -131996,11 +132933,30 @@ var StreamingUIController = class {
 	appendThinkingDelta(delta) {
 		this._thinkingDraft += delta;
 		this.pendingThinkingFlush = true;
+		this.recordSpeedObservation(delta);
 	}
 	appendAssistantDelta(delta) {
 		if (this._streamingBlock === null) this.onStreamingTextStart();
 		this._assistantDraft += delta;
 		this.pendingAssistantFlush = true;
+		this.recordSpeedObservation(delta);
+	}
+	/**
+	* Feed an estimated tok/s observation into the shared speed gauge. Uses the
+	* inter-delta elapsed time so a burst of small deltas produces an accurate
+	* instantaneous rate. The gauge's 3s rolling window smooths jitter.
+	*/
+	recordSpeedObservation(delta) {
+		const now = performance.now();
+		const tokens = estimateTokens(delta);
+		if (this.lastDeltaAt !== void 0) {
+			const elapsedMs = now - this.lastDeltaAt;
+			if (elapsedMs > 0) {
+				const rate = tokens / elapsedMs * 1e3;
+				getSharedSpeedTracker().observe(rate, now);
+			}
+		}
+		this.lastDeltaAt = now;
 	}
 	hasThinkingDraft() {
 		return this._thinkingDraft.length > 0;
@@ -132267,6 +133223,8 @@ var StreamingUIController = class {
 		this._assistantDraft = "";
 		this._streamingBlock = null;
 		this._thinkingDraft = "";
+		this.lastDeltaAt = void 0;
+		getSharedSpeedTracker().reset();
 		this.disposeActiveThinkingComponent();
 	}
 	resetToolUi() {
@@ -133984,7 +134942,7 @@ var TranscriptController = class TranscriptController {
 		this.host.state.ui.requestRender();
 	}
 	showError(message) {
-		this.showStatus(`错误：${message}`, this.host.state.theme.colors.error);
+		this.showStatus(`错误：${truncateErrorMessage(replaceTabs(message))}`, this.host.state.theme.colors.error);
 	}
 	showProgressSpinner(label) {
 		const tint = (s) => chalk.hex(this.host.state.theme.colors.primary)(s);
@@ -134106,7 +135064,7 @@ function pgrep(pattern) {
 	});
 }
 function escapeShell(pattern) {
-	return `'${pattern.replace(/'/g, "'\\''")}'`;
+	return `'${pattern.replaceAll("'", "'\\''")}'`;
 }
 async function checkWindows() {
 	const pm2Active = await checkPm2();
@@ -135476,7 +136434,7 @@ const BOLD_OPEN = "\x1B[1m";
 const BOLD_CLOSE = "\x1B[22m";
 function hexToAnsi(hex) {
 	const v = parseInt(hex.slice(1), 16);
-	return `\x1b[38;2;${v >> 16 & 255};${v >> 8 & 255};${v & 255}m`;
+	return `\u001B[38;2;${v >> 16 & 255};${v >> 8 & 255};${v & 255}m`;
 }
 function compilePalette(palette) {
 	const lowOpen = hexToAnsi(palette.low);
@@ -135971,6 +136929,22 @@ function formatContextStatus(usage, tokens, maxTokens) {
 	if (maxTokens && maxTokens > 0 && tokens !== void 0) return `上下文：${pct} (${formatTokenCount(tokens)}/${formatTokenCount(maxTokens)})`;
 	return `上下文：${pct}`;
 }
+const CONTEXT_WARNING_PERCENT_THRESHOLD = 70;
+const CONTEXT_WARNING_TOKEN_THRESHOLD = 14e4;
+const CONTEXT_ERROR_PERCENT_THRESHOLD = 90;
+const CONTEXT_ERROR_TOKEN_THRESHOLD = 18e4;
+function reachesThreshold(percent, maxTokens, percentThreshold, tokenThreshold) {
+	if (!Number.isFinite(percent) || percent <= 0) return false;
+	if (maxTokens === void 0 || !Number.isFinite(maxTokens) || maxTokens <= 0) return percent >= percentThreshold;
+	const tokenPercentThreshold = tokenThreshold / maxTokens * 100;
+	return percent >= Math.min(percentThreshold, tokenPercentThreshold);
+}
+function pickContextColor(usage, maxTokens, colors) {
+	const percent = safeUsage(usage) * 100;
+	if (reachesThreshold(percent, maxTokens, CONTEXT_ERROR_PERCENT_THRESHOLD, CONTEXT_ERROR_TOKEN_THRESHOLD)) return colors.error;
+	if (reachesThreshold(percent, maxTokens, CONTEXT_WARNING_PERCENT_THRESHOLD, CONTEXT_WARNING_TOKEN_THRESHOLD)) return colors.warning;
+	return colors.textDim;
+}
 const BRAND_COLORS = [
 	"#72A4E9",
 	"#A78BFA",
@@ -136138,7 +137112,8 @@ var FooterComponent = class {
 		else {
 			const statusLine = buildStatusLine(state.streamingPhase, state.livePaneMode, state.streamingStartTime);
 			const ccDot = state.ccConnectActive ? chalk.hex(colors.success)("●") : chalk.hex(colors.textDim)("●");
-			rightText = chalk.hex(colors.textDim)(ccDot + " " + formatContextStatus(state.contextUsage, state.contextTokens, state.maxContextTokens) + "  " + statusLine);
+			const contextColor = pickContextColor(state.contextUsage, state.maxContextTokens, colors);
+			rightText = `${ccDot} ${chalk.hex(contextColor)(formatContextStatus(state.contextUsage, state.contextTokens, state.maxContextTokens))}${chalk.hex(colors.textDim)(`  ${statusLine}`)}`;
 		}
 		const rightWidth = visibleWidth(rightText);
 		const gap = 3;
@@ -136250,7 +137225,7 @@ function renderRow(todo, colors) {
 }
 function statusMarker(status, colors) {
 	switch (status) {
-		case "in_progress": return chalk.hex(colors.primary).bold("●");
+		case "in_progress": return chalk.hex(colors.primary).bold("■");
 		case "done": return chalk.hex(colors.success)("✓");
 		case "pending": return chalk.hex(colors.textDim)("○");
 	}
@@ -137487,14 +138462,14 @@ function makeBlockStyles(colors) {
 }
 function renderDisplayBlock(block, s, colors) {
 	switch (block.type) {
-		case "diff": return renderDiffLinesClustered(block.old_text, block.new_text, block.path, colors, {
+		case "diff": return renderDiffLinesClustered(replaceTabs(block.old_text), replaceTabs(block.new_text), block.path, colors, {
 			contextLines: 3,
 			expandKeyHint: "ctrl+e to preview",
 			maxLines: DIFF_SUMMARY_MAX_LINES
 		});
 		case "file_content": {
 			const lang = block.language ?? langFromPath(block.path);
-			const allLines = highlightLines(block.content, lang);
+			const allLines = highlightLines(replaceTabs(block.content), lang);
 			const shown = allLines.slice(0, CONTENT_SUMMARY_MAX_LINES);
 			const lines = [s.strong(block.path)];
 			for (const [i, line] of shown.entries()) lines.push(s.gutter(String(i + 1).padStart(4) + "  ") + line);
@@ -137506,11 +138481,12 @@ function renderDisplayBlock(block, s, colors) {
 			const lines = [];
 			if (block.cwd !== void 0 && block.cwd.length > 0) lines.push(s.dim(`cwd: ${block.cwd}`));
 			if (block.danger !== void 0) lines.push(s.errorBold(`Dangerous: ${block.danger}`));
-			(block.command.length > 0 ? block.command.split("\n") : [""]).forEach((cmdLine, idx) => {
+			const command = replaceTabs(block.command);
+			(command.length > 0 ? command.split("\n") : [""]).forEach((cmdLine, idx) => {
 				const prefix = idx === 0 ? s.accent("$") : s.dim("·");
 				lines.push(`${prefix} ${s.strong(cmdLine)}`);
 			});
-			if (block.description !== void 0 && block.description.length > 0) lines.push(`  ${s.dim(block.description)}`);
+			if (block.description !== void 0 && block.description.length > 0) lines.push(`  ${s.dim(replaceTabs(block.description))}`);
 			return lines;
 		}
 		case "file_op": {
@@ -137529,14 +138505,14 @@ function renderDisplayBlock(block, s, colors) {
 			if (block.description !== void 0 && block.description.length > 0) lines.push(s.dim(truncateOneLine(block.description, 200)));
 			return lines;
 		}
-		case "brief": return block.text ? block.text.split("\n").map((line) => line.length > 0 ? s.strong(line) : "") : [];
+		case "brief": return block.text ? replaceTabs(block.text).split("\n").map((line) => line.length > 0 ? s.strong(line) : "") : [];
 		case "background_task": return [s.strong(`${block.status} ${block.kind} task ${block.task_id}: ${block.description}`)];
 		case "todo": return block.items.map((item) => s.strong(`- [${item.status}] ${item.title}`));
 		default: return [];
 	}
 }
 function normalizeApprovalText(text) {
-	return text.replaceAll("\r\n", "\n").trim();
+	return replaceTabs(text.replaceAll("\r\n", "\n").trim());
 }
 function isDuplicateBriefBlock(block, description) {
 	if (block.type !== "brief" || block.text.trim().length === 0) return false;
@@ -139962,7 +140938,7 @@ const DIM_RGB = [
 	85
 ];
 function fg(r, g, b) {
-	return `\x1b[38;2;${r};${g};${b}m`;
+	return `\u001B[38;2;${r};${g};${b}m`;
 }
 const RESET = "\x1B[0m";
 const BOLD = "\x1B[1m";
@@ -140011,7 +140987,7 @@ function getTerminalSize() {
 }
 function visualWidth(s) {
 	let w = 0;
-	for (const ch of s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "")) w += /[一-鿿　-〿＀-￯]/.test(ch) ? 2 : 1;
+	for (const ch of s.replaceAll(/\u001B\[[0-9;]*[a-zA-Z]/g, "")) w += /[一-鿿　-〿＀-￯]/.test(ch) ? 2 : 1;
 	return w;
 }
 function centerPad(text, width) {
@@ -140297,7 +141273,9 @@ const PLATFORMS = [
 ];
 async function question(rl, prompt) {
 	return new Promise((resolve) => {
-		rl.question(prompt, (answer) => resolve(answer.trim()));
+		rl.question(prompt, (answer) => {
+			resolve(answer.trim());
+		});
 	});
 }
 function checkCcConnect() {
@@ -140774,10 +141752,10 @@ async function runStreamJson(opts) {
 				if (existing.length > 0) try {
 					session = await harness.resumeSession({ id: sessionKey });
 					log.info("stream-json: resumed session", { sessionId: session.id });
-				} catch (err) {
+				} catch (error) {
 					log.warn("stream-json: resume failed, repairing session", {
 						sessionKey,
-						error: String(err)
+						error: String(error)
 					});
 					await harness.deleteSession(sessionKey).catch(() => {});
 					const orphanDir = existing[0]?.sessionDir;