scream-code 0.10.6 → 0.10.8

package/dist/{app-DsLBIrSM.mjs → app-D_usIcl7.mjs}

@@ -7,7 +7,7 @@ import { i as __require, o as __toESM, r as __exportAll, t as __commonJSMin } fr
 import "./suppress-sqlite-warning-C2VB0doZ.mjs";
 import { C as join$1, D as resolve$1, E as relative$1, S as isAbsolute$1, T as parse$7, a as isSupportedFile, b as basename$1, i as ingestFile, r as ingestDirectory, t as multiSearch, w as normalize, x as dirname$2, y as KnowledgeStore } from "./src-BH9W5k24.mjs";
 import { t as require_base64_js } from "./base64-js-DzVmk6Nb.mjs";
-import { a as setLocale, i as getLocale, n as assertScreamHostIdentity, o as t, r as createScreamDefaultHeaders, t as TextInputDialogComponent } from "./text-input-dialog-pClOx34t.mjs";
+import { a as setLocale, i as getLocale, n as assertScreamHostIdentity, o as t, r as createScreamDefaultHeaders, t as TextInputDialogComponent } from "./text-input-dialog-CiWeHRNJ.mjs";
 import { createRequire } from "node:module";
 import { createHash, randomBytes, randomInt, randomUUID } from "node:crypto";
 import * as fs$1 from "node:fs/promises";
@@ -28,6 +28,8 @@ import Vt, { appendFileSync, chmodSync, closeSync, constants, createReadStream,
 import * as path$8 from "node:path";
 import path, { basename, dirname as dirname$1, extname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
 import { z } from "zod";
+import { exec, execFile, execSync, spawn, spawnSync } from "node:child_process";
+import { promisify } from "node:util";
 import { DatabaseSync } from "node:sqlite";
 import * as nodeOs from "node:os";
 import { homedir, tmpdir } from "node:os";
@@ -35,7 +37,6 @@ import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import Pi from "assert";
 import ro from "node:assert";
-import { exec, execFile, execSync, spawn, spawnSync } from "node:child_process";
 import * as posixPath from "node:path/posix";
 import * as win32Path from "node:path/win32";
 import { createServer } from "node:http";
@@ -54,7 +55,6 @@ import chalk, { chalkStderr } from "chalk";
 import { CombinedAutocompleteProvider, Container, Editor, Image, Input, Key, Markdown, ProcessTerminal, Spacer, TUI, Text, decodeKittyPrintable, deleteAllKittyImages, fuzzyFilter, fuzzyMatch, getCapabilities, getImageDimensions, isKeyRelease, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@liutod-scream/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
 import { diffWords } from "diff";
-import { promisify } from "node:util";
 import { gt, valid } from "semver";
 import { createInterface as createInterface$1 } from "node:readline";
 //#region ../../packages/agent-core/src/errors/codes.ts
@@ -10336,7 +10336,7 @@ var require_gaxios = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 		static async #getFetch() {
 			const hasWindow = typeof window !== "undefined" && !!window;
-			this.#fetch ||= hasWindow ? window.fetch : (await import("./src-BMbOMRuY.mjs")).default;
+			this.#fetch ||= hasWindow ? window.fetch : (await import("./src-C8lOjRbK.mjs")).default;
 			return this.#fetch;
 		}
 		/**
@@ -55788,15 +55788,35 @@ function formatBudget(value, unit) {
 */
 /** Maximum objective length in characters. */
 const MAX_GOAL_OBJECTIVE_LENGTH = 4e3;
+/** Consecutive markBlocked calls with the same reason required before blocking. */
+const BLOCKED_STREAK_THRESHOLD = 3;
 /** Maximum number of working notes kept per goal. */
-const MAX_GOAL_NOTES = 30;
+const MAX_GOAL_NOTES = 60;
 /** Maximum characters per note. */
-const MAX_NOTE_LENGTH = 200;
+const MAX_NOTE_LENGTH = 400;
 const GOAL_CANCELLED_REMINDER = [
 	"The user cancelled the current goal.",
 	"Ignore earlier active-goal reminders for that goal.",
 	"Handle the next user request normally unless the user starts or resumes a goal."
 ].join(" ");
+/**
+* Returns true when any configured budget has less than `threshold` of its
+* allowance remaining (e.g. 0.2 = under 20% left). Budgets that are not
+* configured (null) are ignored. Used to steer the model toward convergence
+* before a hard over-budget block fires.
+*/
+function isBudgetNearExhaustion(budget, threshold) {
+	if (budget.turnBudget !== null && budget.remainingTurns !== null && budget.turnBudget > 0) {
+		if (budget.remainingTurns / budget.turnBudget < threshold) return true;
+	}
+	if (budget.tokenBudget !== null && budget.remainingTokens !== null && budget.tokenBudget > 0) {
+		if (budget.remainingTokens / budget.tokenBudget < threshold) return true;
+	}
+	if (budget.wallClockBudgetMs !== null && budget.remainingWallClockMs !== null && budget.wallClockBudgetMs > 0) {
+		if (budget.remainingWallClockMs / budget.wallClockBudgetMs < threshold) return true;
+	}
+	return false;
+}
 const GOAL_COMPLETION_REMINDER_NAME = "goal_completion_summary";
 const GOAL_BLOCKED_REMINDER_NAME = "goal_blocked_reason";
 var GoalMode = class {
@@ -55835,7 +55855,8 @@ var GoalMode = class {
 			tokensUsed: 0,
 			wallClockMs: 0,
 			budgetLimits: {},
-			notes: []
+			notes: [],
+			blockedStreak: 0
 		};
 		this.state = state;
 	}
@@ -55855,6 +55876,7 @@ var GoalMode = class {
 			state.wallClockResumedAt = void 0;
 		}
 		if (record.budgetLimits !== void 0) state.budgetLimits = record.budgetLimits;
+		if (record.objective !== void 0) state.objective = record.objective;
 	}
 	restoreClear(_record) {
 		this.state = void 0;
@@ -55887,7 +55909,8 @@ var GoalMode = class {
 			wallClockMs: 0,
 			wallClockResumedAt: Date.now(),
 			budgetLimits: {},
-			notes: []
+			notes: [],
+			blockedStreak: 0
 		};
 		this.persistState(state);
 		this.agent.records.logRecord({
@@ -55932,6 +55955,8 @@ var GoalMode = class {
 		if (state.status === "active") return this.toSnapshot(state);
 		if (state.status !== "paused" && state.status !== "blocked") throw new ScreamError(ErrorCodes.GOAL_NOT_RESUMABLE, `Cannot resume a goal in status "${state.status}"`);
 		state.terminalReason = void 0;
+		state.blockedStreak = 0;
+		state.lastBlockedReason = void 0;
 		this.applyStatus(state, "active");
 		this.persistState(state, { change: {
 			kind: "lifecycle",
@@ -55952,6 +55977,23 @@ var GoalMode = class {
 		this.appendGoalUpdate({ budgetLimits: state.budgetLimits });
 		return this.toSnapshot(state);
 	}
+	async updateObjective(input, _actor = "user") {
+		const state = this.requireState();
+		const objective = input.objective.trim();
+		if (objective.length === 0) throw new ScreamError(ErrorCodes.GOAL_OBJECTIVE_EMPTY, "Goal objective cannot be empty");
+		if (state.status === "complete") throw new ScreamError(ErrorCodes.GOAL_STATUS_INVALID, "Cannot update a completed goal.");
+		if (state.status === "blocked") throw new ScreamError(ErrorCodes.GOAL_STATUS_INVALID, "Cannot update a blocked goal. Resume it first.");
+		state.objective = objective;
+		const noteContent = `Goal objective updated by user: ${objective}`.slice(0, MAX_NOTE_LENGTH);
+		state.notes.push({
+			content: noteContent,
+			time: Date.now()
+		});
+		if (state.notes.length > MAX_GOAL_NOTES) state.notes = state.notes.slice(-60);
+		this.persistState(state);
+		this.appendGoalUpdate({ objective });
+		return this.toSnapshot(state);
+	}
 	async cancelGoal(actor = "user") {
 		const state = this.requireState();
 		const snapshot = this.toSnapshot(state);
@@ -55965,8 +56007,22 @@ var GoalMode = class {
 	async markBlocked(input = {}, actor = "runtime") {
 		const state = this.state;
 		if (state === void 0 || state.status !== "active") return null;
+		if (actor === "model") {
+			const reason = input.reason ?? "";
+			if (reason === (state.lastBlockedReason ?? "")) state.blockedStreak += 1;
+			else {
+				state.blockedStreak = 1;
+				state.lastBlockedReason = reason;
+			}
+			if (state.blockedStreak < BLOCKED_STREAK_THRESHOLD) {
+				this.persistState(state, { silent: true });
+				return null;
+			}
+		}
 		this.applyStatus(state, "blocked");
 		state.terminalReason = input.reason;
+		state.blockedStreak = 0;
+		state.lastBlockedReason = void 0;
 		this.persistState(state, { change: {
 			kind: "lifecycle",
 			status: "blocked",
@@ -56021,7 +56077,7 @@ var GoalMode = class {
 			content: trimmed,
 			time: Date.now()
 		});
-		if (state.notes.length > MAX_GOAL_NOTES) state.notes = state.notes.slice(-30);
+		if (state.notes.length > MAX_GOAL_NOTES) state.notes = state.notes.slice(-60);
 		this.persistState(state, { silent: true });
 		return this.toSnapshot(state);
 	}
@@ -56168,13 +56224,18 @@ function formatTokens$2(tokens) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.ts
-const UpdateGoalToolInputSchema = z.object({ status: z.enum([
-	"active",
-	"complete",
-	"paused",
-	"blocked"
-]).describe("The lifecycle status to set for the current goal.") }).strict();
+const UpdateGoalToolInputSchema = z.object({
+	status: z.enum([
+		"active",
+		"complete",
+		"paused",
+		"blocked"
+	]).describe("The lifecycle status to set for the current goal."),
+	reason: z.string().optional().describe("Optional reason for the status change, especially for blocked.")
+}).strict();
 const MAX_GRADER_OUTPUT_CHARS = 4e3;
+/** Maximum characters of `git diff --stat HEAD` to append to the grader input. */
+const MAX_DIFF_STAT_CHARS = 2e3;
 function extractRecentOutput(history) {
 	const parts = [];
 	for (let i = history.length - 1; i >= 0; i--) {
@@ -56187,6 +56248,51 @@ function extractRecentOutput(history) {
 	const joined = parts.join("\n\n");
 	return joined.length > MAX_GRADER_OUTPUT_CHARS ? `${joined.slice(0, MAX_GRADER_OUTPUT_CHARS)}…` : joined;
 }
+/**
+* Append cross-turn working notes to the output seen by the grader. Notes are
+* written by the agent across continuation turns, so they provide focused
+* context (key findings, constraints, partial results) without exposing the
+* full text of previously rejected outputs.
+*/
+function appendGoalNotes(output, notes) {
+	if (notes.length === 0) return output;
+	return `${output}\n\n## Cross-turn working notes\n${notes.map((note) => `• ${note.content}`).join("\n")}`;
+}
+const execFileAsync = promisify(execFile);
+/**
+* Fetch a concise git diff stat against HEAD for the current working directory.
+* Using HEAD includes both staged and unstaged changes, so the reviewer sees
+* every file touched during the turn even if the agent ran `git add`. Returns
+* `null` when there are no changes. Throws when git is unavailable or the
+* directory is not a git repository.
+*/
+/** Exported for testing only. */
+async function fetchGitDiffStat(cwd) {
+	const { stdout } = await execFileAsync("git", [
+		"diff",
+		"--stat",
+		"HEAD"
+	], { cwd });
+	const stat = stdout.trim();
+	return stat.length > 0 ? stat : null;
+}
+/**
+* Append a git diff stat to the grader input so the reviewer can correlate the
+* agent's claims with the actual files changed during the turn. Very large
+* stats are truncated to avoid overflowing the reviewer's context window. When
+* git is unavailable, a note is appended so the reviewer knows why no diff is
+* present.
+*/
+async function appendGitDiffStat(output, cwd) {
+	let stat;
+	try {
+		stat = await fetchGitDiffStat(cwd);
+	} catch {
+		return `${output}\n\n## Changes this turn\n(Git diff unavailable — workspace may not be a git repository or git is not installed.)`;
+	}
+	if (stat === null) return output;
+	return `${output}\n\n## Changes this turn\n${stat.length > MAX_DIFF_STAT_CHARS ? `${stat.slice(0, MAX_DIFF_STAT_CHARS)}…\n(diff stat truncated)` : stat}`;
+}
 var UpdateGoalTool = class {
 	agent;
 	grader;
@@ -56209,15 +56315,18 @@ var UpdateGoalTool = class {
 				}
 				if (args.status === "complete") return this.handleComplete(goal);
 				if (args.status === "blocked") {
-					const blocked = await goal.markBlocked({}, "model");
-					if (blocked !== null) this.agent.context.appendSystemReminder(buildGoalBlockedReasonPrompt(blocked), {
-						kind: "system_trigger",
-						name: GOAL_BLOCKED_REMINDER_NAME
-					});
-					return {
-						output: "Goal marked blocked.",
-						stopTurn: true
-					};
+					const blocked = await goal.markBlocked(args.reason !== void 0 ? { reason: args.reason } : {}, "model");
+					if (blocked !== null) {
+						this.agent.context.appendSystemReminder(buildGoalBlockedReasonPrompt(blocked), {
+							kind: "system_trigger",
+							name: GOAL_BLOCKED_REMINDER_NAME
+						});
+						return {
+							output: "Goal marked blocked.",
+							stopTurn: true
+						};
+					}
+					return { output: "Goal remains active. Report the same blocker in subsequent turns to confirm it cannot be resolved. Continue working on the goal in the meantime." };
 				}
 				await goal.pauseGoal({}, "model");
 				return {
@@ -56230,7 +56339,7 @@ var UpdateGoalTool = class {
 	async handleComplete(goal) {
 		const goalState = goal.getGoal().goal;
 		if (!goalState) return { output: "No active goal." };
-		const output = extractRecentOutput(this.agent.context.history);
+		const outputWithContext = await appendGitDiffStat(appendGoalNotes(extractRecentOutput(this.agent.context.history), goalState.notes), this.agent.config?.cwd ?? "");
 		try {
 			await goal.pauseGoal({ reason: "verifying" }, "system");
 		} catch (error) {
@@ -56238,7 +56347,7 @@ var UpdateGoalTool = class {
 		}
 		let rawGrade;
 		try {
-			rawGrade = await this.grader(goalState.objective, goalState.completionCriterion, output);
+			rawGrade = await this.grader(goalState.objective, goalState.completionCriterion, outputWithContext);
 		} catch (error) {
 			const resumeError = await resumeAfterGrading(goal);
 			if (resumeError !== void 0) return resumeError;
@@ -56314,7 +56423,7 @@ function errorMessage$4(error) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/write-goal-note.ts
-const WriteGoalNoteInputSchema = z.object({ content: z.string().min(1).max(200).describe("A concise note about what you learned, verified, or decided. Notes are injected into future continuation turns so you can build on prior work.") }).strict();
+const WriteGoalNoteInputSchema = z.object({ content: z.string().min(1).max(400).describe("A concise note about what you learned, verified, or decided. Notes are injected into future continuation turns so you can build on prior work.") }).strict();
 var WriteGoalNoteTool = class {
 	agent;
 	name = "WriteGoalNote";
@@ -57551,6 +57660,16 @@ function parseMemoryMemos(text) {
 	}
 	return memos;
 }
+/**
+* Strip injected memory-memo content from text before writing it back to the
+* store, preventing feedback loops where recalled/compacted content gets
+* re-stored. Removes fenced ```memory-memo blocks (the format emitted by
+* compaction and exit-time extraction) and any <memories>...</memories>
+* wrapper an injector might use.
+*/
+function stripMemoryTags(text) {
+	return text.replaceAll(/```memory-memo[\s\S]*?```/gi, "").replaceAll(/<memories>[\s\S]*?<\/memories>/gi, "").trim();
+}
 /** System prompt for exit-time extraction — instructs the LLM how to extract. */
 const EXIT_EXTRACTION_SYSTEM_PROMPT = "你是一个任务经验提取助手。任务是从对话记录中识别已完成的任务闭环，提炼出任务经验记录。用对话的主要语言输出（中文对话用中文，英文对话用英文）。只输出指定的 JSON 格式，不要调用任何工具。";
 /** Build the user prompt for exit-time extraction, including a conversation sample. */
@@ -58303,17 +58422,20 @@ var MemoryWriteTool = class {
 				};
 				const sessionId = this.agent.homedir ? basename$1(dirname$2(dirname$2(this.agent.homedir))) : "unknown";
 				const sourceSessionTitle = await this.agent.getSessionTitle();
-				const whatFailed = args.whatFailed?.trim();
-				const whatWorked = args.whatWorked?.trim();
-				const tags = normalizeTags(args.tags !== void 0 && args.tags.length > 0 ? args.tags : generateTags(`${args.userNeed} ${args.approach}`));
+				const userNeed = stripMemoryTags(args.userNeed);
+				const approach = stripMemoryTags(args.approach);
+				const outcome = stripMemoryTags(args.outcome);
+				const whatFailed = stripMemoryTags(args.whatFailed ?? "");
+				const whatWorked = stripMemoryTags(args.whatWorked ?? "");
+				const tags = normalizeTags(args.tags !== void 0 && args.tags.length > 0 ? args.tags : generateTags(`${userNeed} ${approach}`));
 				const memo = createMemoryMemo({
 					sourceSessionId: sessionId,
 					sourceSessionTitle,
-					userNeed: args.userNeed,
-					approach: args.approach,
-					outcome: args.outcome,
-					whatFailed: whatFailed === void 0 || whatFailed.length === 0 ? "none" : whatFailed,
-					whatWorked: whatWorked === void 0 || whatWorked.length === 0 ? "none" : whatWorked,
+					userNeed,
+					approach,
+					outcome,
+					whatFailed: whatFailed.length === 0 ? "none" : whatFailed,
+					whatWorked: whatWorked.length === 0 ? "none" : whatWorked,
 					tags,
 					extractionSource: "manual",
 					projectDir: this.agent.config.cwd
@@ -62680,20 +62802,20 @@ function isRecord$6(value) {
 var dream_default = "---\nname: dream\ndescription: 整理记忆库 — 合并重复、解决矛盾、清理过时条目\n---\n\n# Dream: 记忆合并整理\n\n用户调用了 `/dream`。你要对全局记忆库进行一次完整的整理和清理。\n\n记忆库是**全局**的，所有会话的记忆都保存在同一个 SQLite 数据库里（`<screamHomeDir>/memory/memos.sqlite`），不是按会话分散存放。\n\n## 前置检查\n\n1. 调用 `MemoryConsolidatePlan` 工具获取整理计划。\n   - 如果返回\"记忆库为空\"，告知用户\"记忆库为空，无需整理\"并停止。\n   - 否则你会得到一个 JSON 计划，包含：duplicateGroups（重复组）、resolved（已完成条目）、stale（过时条目）、summary（统计）。\n\n2. 不要直接修改记忆文件。所有删除和写入都通过 `MemoryConsolidateApply` 工具完成。\n\n## 整理计划展示\n\n把计划转换成用户可读的格式：\n\n```\n## Dream 整理计划\n\n### 概况\n- 当前共 X 条记忆\n- 重复组：N 组\n- 建议删除：M 条（已完成 + 过时）\n- 整理后预计：Y 条\n\n### 重复合并（N 组）\n**组 1: 修复登录 token 刷新**\n- memo-abc123 (2026-05-01, 完成) — \"登录页 token 过期需要手动刷新\"\n- memo-def456 (2026-05-10, 完成) — \"登录 token 过期问题修复\"\n→ 合并为: \"修复登录页 token 过期问题。方案: 在 axios 拦截器中添加自动 refresh 逻辑...\"\n  结果: 完成\n\n### 建议删除（M 条）\n- memo-xyz789: \"添加暗色模式\" (完成, 2026-04-01) — 已完成超过 2 个月\n- memo-old001: \"尝试某方案\" (放弃, 2026-03-01) — 过时\n\n### 总结\n- 合并: N 组 → 减少 X 条\n- 删除: M 条\n- 整理后: 共 Y 条记忆\n```\n\n用 AskUserQuestion 让用户选择：\n- \"执行整理\" — 按上述计划执行\n- \"仅显示计划\" — 不做修改，直接结束\n- \"取消\"\n\n## 执行整理\n\n如果用户选择\"执行整理\"：\n\n1. 直接把 `MemoryConsolidatePlan` 返回的完整 JSON 计划作为参数，调用 `MemoryConsolidateApply`。\n2. 工具会自动完成以下操作：\n   - 删除重复组中的原记忆\n   - 为每组重复记忆追加一条合并后的新记忆（字段格式由工具保证正确）\n   - 删除已完成和过时的记忆\n   - 更新 `dream-lock.json`，重置建议计数器\n3. 向用户报告工具返回的结果：\"已删除 X 条，创建 Y 条合并记忆。记忆库整理完成。\"\n\n## 重要规则\n\n- **仅合并高度重复的记忆**。只有当两条记忆描述的是同一件事、同一个问题、同一个修复方案时才可合并。如果只是主题相关但细节不同（如两个不同的 bug、两个不同的优化方向），**绝对不能合并**。宁可多保留十条，不可误删一条。\n- 如果 `MemoryConsolidatePlan` 标记的某组重复实际上并不是同一件事，在展示计划时把它从\"重复合并\"里去掉，只保留你确信重复的组，再把精简后的计划传给 `MemoryConsolidateApply`。\n- 不确定时保留原文，不要猜测删除。\n- 操作前必须得到用户确认，不能擅自执行。\n- 不要手动写 Bash 去修改 `entries.jsonl`，统一通过 `MemoryConsolidateApply` 工具执行。\n";
 //#endregion
 //#region ../../packages/agent-core/src/skill/builtin/dream.ts
-const PSEUDO_PATH$1 = "builtin://dream";
-const parsed$1 = parseSkillText({
+const PSEUDO_PATH$2 = "builtin://dream";
+const parsed$2 = parseSkillText({
 	skillMdPath: "/builtin/skills/dream.md",
 	skillDirName: "dream",
 	source: "builtin",
 	text: dream_default
 });
 const DREAM_SKILL = {
-	...parsed$1,
-	path: PSEUDO_PATH$1,
-	dir: PSEUDO_PATH$1,
+	...parsed$2,
+	path: PSEUDO_PATH$2,
+	dir: PSEUDO_PATH$2,
 	metadata: {
-		...parsed$1.metadata,
-		type: parsed$1.metadata.type ?? "inline",
+		...parsed$2.metadata,
+		type: parsed$2.metadata.type ?? "inline",
 		disableModelInvocation: true
 	}
 };
@@ -62702,14 +62824,36 @@ const DREAM_SKILL = {
 var make_skill_default = "---\nname: make-skill\ndescription: 从当前会话上下文沉淀工作流为可复用 Skill\n---\n\n# Make Skill: 从上下文提炼 Skill\n\n用户调用了 `/make-skill`。你的任务是通过对话引导用户，把当前会话中解决问题的方式沉淀为一个可复用的 Scream Code Skill，并安装到插件中心。\n\n## 激活参数\n\n本次激活的参数：\n\n```json\n$ARGUMENTS\n```\n\n- `initialRequest`：用户输入 `/make-skill` 时附带的一句话描述，可能为空。\n\n## 工作方式\n\n这不是一次性任务。你需要通过**多轮对话**澄清以下信息，每一轮只问一个问题，等用户回答后再进入下一阶段：\n\n1. Skill 类型（`workflow` / `code-pattern` / `troubleshooting` / `tool-chain` / `custom`）\n2. Skill 名称（kebab-case）\n3. 这个 Skill 主要解决什么问题\n4. 希望重点关注哪些内容\n5. 生成草案并确认安装\n\n## 阶段判断\n\n根据当前对话历史判断你处于哪个阶段：\n\n- **阶段 0**：本 Skill 刚激活，还没有问过任何问题。先分析会话上下文和 `initialRequest`，然后用 `AskUserQuestion` 询问 Skill 类型。\n- **阶段 1**：已经确定了 Skill 类型，但还没有确定名称。根据类型和上下文建议一个 kebab-case 名称，用 `AskUserQuestion` 询问用户是否接受或修改。\n- **阶段 2**：已经确定了名称，但还没有明确解决的问题。根据上下文总结一句话描述，用 `AskUserQuestion` 询问用户是否接受或修改。\n- **阶段 3**：已经确定了问题，但还没有明确关注重点。给出 2-4 个关注重点建议，用 `AskUserQuestion` 让用户选择或输入。\n- **阶段 4**：类型、名称、问题、重点都已确定。调用 `MakeSkillPlanTool` 生成草案，展示给用户，并用 `AskUserQuestion` 询问是否确认安装。\n- **阶段 5**：用户已确认安装。调用 `MakeSkillApplyTool` 写入插件中心。\n\n如何判断“已确定”：历史消息中已经有你提出的 `AskUserQuestion` 以及用户给出的明确回答（或选择了你建议的选项）。\n\n## 每轮提问规范\n\n除非处于阶段 4/5，否则**每轮必须也只允许使用一次 `AskUserQuestion`**。不要直接用普通文本提问，这样无法给用户结构化选项。\n\n### 阶段 0：询问 Skill 类型\n\n先分析当前会话上下文，判断最可能想沉淀什么。给出 2-4 个建议选项，不要列出全部 5 种。把最相关的放在最前面，并标记 `(Recommended)`。\n\n示例问题：\n\n```json\n{\n  \"questions\": [\n    {\n      \"question\": \"根据刚才的会话，你想把什么沉淀成 Skill？\",\n      \"header\": \"类型\",\n      \"options\": [\n        { \"label\": \"Code pattern (Recommended)\", \"description\": \"把 React 表单验证的代码模式提炼为可复用模板\" },\n        { \"label\": \"Workflow\", \"description\": \"把解决表单验证问题的步骤沉淀为流程\" },\n        { \"label\": \"Troubleshooting\", \"description\": \"把常见验证错误排查过程沉淀为诊断指南\" }\n      ],\n      \"multi_select\": false\n    }\n  ]\n}\n```\n\n注意：系统会自动添加 \"Other\" 选项，**不要自己添加**。如果用户想选未列出的类型（如 `tool-chain` 或 `custom`），他们会通过 Other 输入。\n\n### 阶段 1：询问 Skill 名称\n\n根据已确定的类型和上下文，建议一个 kebab-case 名称。用 `AskUserQuestion` 让用户接受、修改或自己输入。\n\n示例：\n\n```json\n{\n  \"questions\": [\n    {\n      \"question\": \"建议把这个 Skill 命名为 react-form-validate，是否接受？\",\n      \"header\": \"名称\",\n      \"options\": [\n        { \"label\": \"使用 react-form-validate (Recommended)\", \"description\": \"简洁直观，符合 kebab-case\" },\n        { \"label\": \"换一个名称\", \"description\": \"我给出其他建议\" },\n        { \"label\": \"我自己输入\", \"description\": \"手动指定名称\" }\n      ],\n      \"multi_select\": false\n    }\n  ]\n}\n```\n\n如果用户选择“换一个名称”或“我自己输入”，你需要在下一轮继续用 `AskUserQuestion` 给出新建议或请求输入。\n\n### 阶段 2：询问解决的问题\n\n根据上下文总结一句话描述，让用户接受、修改或自己输入。\n\n示例：\n\n```json\n{\n  \"questions\": [\n    {\n      \"question\": \"这个 Skill 主要用于：在 React 中用 zod + react-hook-form 实现表单验证。是否准确？\",\n      \"header\": \"用途\",\n      \"options\": [\n        { \"label\": \"准确 (Recommended)\", \"description\": \"保持这个描述\" },\n        { \"label\": \"不够准确\", \"description\": \"我帮你调整\" },\n        { \"label\": \"我自己描述\", \"description\": \"手动输入用途\" }\n      ],\n      \"multi_select\": false\n    }\n  ]\n}\n```\n\n### 阶段 3：询问关注重点\n\n给出 2-4 个基于上下文的关注重点建议。\n\n示例：\n\n```json\n{\n  \"questions\": [\n    {\n      \"question\": \"生成时希望重点关注哪些方面？\",\n      \"header\": \"重点\",\n      \"options\": [\n        { \"label\": \"验证 schema 定义 (Recommended)\", \"description\": \"重点提取 zod schema 的编写模式\" },\n        { \"label\": \"错误处理与提示\", \"description\": \"重点提取错误展示和反馈逻辑\" },\n        { \"label\": \"组件绑定方式\", \"description\": \"重点提取 react-hook-form 的绑定代码\" }\n      ],\n      \"multi_select\": true\n    }\n  ]\n}\n```\n\n### 阶段 4：展示草案并确认\n\n调用 `MakeSkillPlanTool`，参数：\n\n- `type`：阶段 0 确定的类型\n- `nameHint`：阶段 1 确定的名称\n- `purpose`：阶段 2 确定的问题描述\n- `focus`：阶段 3 确定的关注重点（多选用逗号连接成字符串）\n\n工具返回 JSON 后，用中文清晰展示：\n\n- Skill 名称和描述\n- 文件清单（至少包含 `SKILL.md`）\n- 适用场景\n- 安装位置：`~/.scream-code/plugins/managed/<name>/`，可通过 `/plugin` 管理\n\n然后用 `AskUserQuestion` 询问：\n\n```json\n{\n  \"questions\": [\n    {\n      \"question\": \"是否安装这个 Skill？\",\n      \"header\": \"确认\",\n      \"options\": [\n        { \"label\": \"确认安装 (Recommended)\", \"description\": \"写入插件中心并在新会话中可用\" },\n        { \"label\": \"取消\", \"description\": \"不保存任何内容\" }\n      ],\n      \"multi_select\": false\n    }\n  ]\n}\n```\n\n### 阶段 5：执行安装\n\n如果用户选择“确认安装”，调用 `MakeSkillApplyTool`，传入工具返回的完整草案 JSON（`name`、`description`、`content`、`files`）。\n\n把结果告知用户，例如：\n\n- 成功：`Skill 已安装到 ~/.scream-code/plugins/managed/<name>/。新会话中可通过 /<name> 调用。`\n- 失败：说明错误原因，不要重试。\n\n## 重要规则\n\n- 除了阶段 4 的展示文本外，**所有澄清问题都必须通过 `AskUserQuestion` 工具提出**，不要直接用文本回复提问。\n- 每轮只能问一个问题。等用户回答后再推进到下一阶段。\n- 不要在没有调用 `MakeSkillApplyTool` 的情况下直接写文件。\n- 如果用户选择“取消”或关闭问题，礼貌地告知已取消，不做任何修改。\n- 如果 `MakeSkillApplyTool` 返回错误（例如同名 Skill 已存在），向用户说明错误并停止，不要重试。\n- 新安装的 Skill 只在**新会话**中可用；当前会话不会立即加载它。\n- 安装后的 Skill 会出现在 `/plugin` 插件中心里，用户可以统一启用、禁用或卸载。\n";
 //#endregion
 //#region ../../packages/agent-core/src/skill/builtin/make-skill.ts
-const PSEUDO_PATH = "builtin://make-skill";
-const parsed = parseSkillText({
+const PSEUDO_PATH$1 = "builtin://make-skill";
+const parsed$1 = parseSkillText({
 	skillMdPath: "/builtin/skills/make-skill.md",
 	skillDirName: "make-skill",
 	source: "builtin",
 	text: make_skill_default
 });
 const MAKE_SKILL_SKILL = {
+	...parsed$1,
+	path: PSEUDO_PATH$1,
+	dir: PSEUDO_PATH$1,
+	metadata: {
+		...parsed$1.metadata,
+		type: parsed$1.metadata.type ?? "inline",
+		disableModelInvocation: true
+	}
+};
+//#endregion
+//#region ../../packages/agent-core/src/skill/builtin/tool-prompt-optimization/SKILL.md
+var SKILL_default = "---\nname: tool-prompt-optimization\ndescription: Audit and trim tool prompt text that duplicates information already inferable from the tool's JSON schema, reducing system prompt token cost.\n---\n\n# Tool Prompt Optimization\n\nA meta-skill for cutting system-prompt token waste: tool `description` text often\nrestates field names, types, and constraints that the Zod/JSON schema already\nencodes. Use a probe to measure the overlap, then trim what the model can infer\nfrom the schema alone.\n\n## When to use\n\n- System prompt token cost is high and tool descriptions are a meaningful share.\n- A tool's `description` repeats field names or types already in its schema.\n- Auditing tool definitions for redundancy before a release.\n\n## How to audit\n\n1. For each tool, lay the `description` text next to the Zod/JSON schema fields.\n2. Flag sentences that merely restate field names, types, or constraints already\n   encoded in the schema (e.g. \"command is a string\" when the schema already\n   declares `z.string()`).\n3. **Probe**: ask the model \"Given only the schema (no description), which\n   behaviors and constraints can you infer?\" The intersection is pure redundancy.\n4. Trim description text the model already infers from the schema alone.\n5. **Keep** what the schema cannot express:\n   - edge cases, gotchas, and ordering requirements\n   - cross-tool interactions and precedence rules\n   - safety-critical warnings and permission notes\n   - examples that disambiguate ambiguous schema fields\n\n## Rules\n\n- Never remove safety-critical warnings or permission notes.\n- Never remove examples that clarify ambiguous schema fields.\n- Before deleting a sentence, run `git blame` to check whether it was added to\n  fix a specific bug; if so, keep it (or confirm the bug is gone).\n- Measure the before/after token count to confirm savings actually materialized.\n- Prefer precise constraints over vague prose; if a constraint is enforceable in\n  the schema (e.g. `.min(1)`), move it there instead of describing it in text.\n";
+//#endregion
+//#region ../../packages/agent-core/src/skill/builtin/tool-prompt-optimization.ts
+const PSEUDO_PATH = "builtin://tool-prompt-optimization";
+const parsed = parseSkillText({
+	skillMdPath: "/builtin/skills/tool-prompt-optimization/SKILL.md",
+	skillDirName: "tool-prompt-optimization",
+	source: "builtin",
+	text: SKILL_default
+});
+const TOOL_PROMPT_OPTIMIZATION_SKILL = {
 	...parsed,
 	path: PSEUDO_PATH,
 	dir: PSEUDO_PATH,
@@ -62724,6 +62868,7 @@ const MAKE_SKILL_SKILL = {
 function registerBuiltinSkills(registry) {
 	registry.registerBuiltinSkill(DREAM_SKILL);
 	registry.registerBuiltinSkill(MAKE_SKILL_SKILL);
+	registry.registerBuiltinSkill(TOOL_PROMPT_OPTIMIZATION_SKILL);
 }
 //#endregion
 //#region ../../packages/agent-core/src/skill/scanner.ts
@@ -75281,17 +75426,25 @@ var ToolResultBuilder = class {
 	maxChars;
 	maxTailChars;
 	maxLineLength;
+	artifactSink;
+	maxFullOutputChars;
 	buffer = [];
 	nCharsValue = 0;
 	truncationHappened = false;
 	headTruncated = false;
 	tailBuf = [];
 	tailCharsValue = 0;
+	fullOutput;
+	fullOutputChars = 0;
+	totalLinesWritten = 0;
 	constructor(options = {}) {
 		this.maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
 		this.maxTailChars = options.maxTailChars ?? DEFAULT_TAIL_CHARS;
 		this.maxLineLength = options.maxLineLength === void 0 ? DEFAULT_MAX_LINE_LENGTH : options.maxLineLength;
 		if (this.maxLineLength !== null && this.maxLineLength <= 14) throw new Error("maxLineLength must be greater than the truncation marker length.");
+		this.artifactSink = options.artifactSink;
+		this.maxFullOutputChars = options.maxFullOutputChars ?? 1e6;
+		if (this.artifactSink !== void 0) this.fullOutput = [];
 	}
 	get nChars() {
 		return this.nCharsValue + this.tailCharsValue;
@@ -75301,12 +75454,19 @@ var ToolResultBuilder = class {
 		if (!this.headTruncated || this.tailCharsValue === 0) return head;
 		this.trimTail();
 		const tail = this.tailBuf.join("");
-		return `${head}${head.endsWith("\n") ? "" : "\n"}${TRUNCATION_MARKER}\n${tail}`;
+		const separator = head.endsWith("\n") ? "" : "\n";
+		const elided = this.computeElidedLines(head, tail);
+		return `${head}${separator}${elided > 0 ? `[…${String(elided)} lines elided…]\n${TRUNCATION_MARKER}` : TRUNCATION_MARKER}\n${tail}`;
 	}
 	write(text) {
 		if (text.length === 0) return 0;
 		const lines = text.match(/[^\r\n]*(?:\r\n|[\n\r])|[^\r\n]+/g) ?? [];
 		if (lines.length === 0) return 0;
+		this.totalLinesWritten += lines.length;
+		if (this.fullOutput !== void 0 && this.fullOutputChars < this.maxFullOutputChars) {
+			this.fullOutput.push(text);
+			this.fullOutputChars += text.length;
+		}
 		let charsWritten = 0;
 		for (const originalLine of lines) if (this.nCharsValue < this.maxChars) {
 			const remainingChars = this.maxChars - this.nCharsValue;
@@ -75354,11 +75514,36 @@ var ToolResultBuilder = class {
 		this.tailBuf.push(trimmed);
 		this.tailCharsValue = trimmed.length;
 	}
-	ok(message = "", options = {}) {
+	computeElidedLines(head, tail) {
+		if (this.totalLinesWritten === 0) return 0;
+		if (this.fullOutput !== void 0) {
+			const total = countLines(this.fullOutput.join(""));
+			return Math.max(0, total - countLines(head) - countLines(tail));
+		}
+		return Math.max(0, this.totalLinesWritten - countLines(head) - countLines(tail));
+	}
+	async maybeWriteArtifact() {
+		if (this.artifactSink === void 0 || this.fullOutput === void 0) return void 0;
+		if (!this.truncationHappened) return void 0;
+		const full = this.fullOutput.join("");
+		if (full.length === 0) return void 0;
+		try {
+			return await this.artifactSink(full);
+		} catch {
+			return;
+		}
+	}
+	appendArtifactRef(output, ref) {
+		const line = `[full output saved: ${ref}]`;
+		return output.length === 0 ? line : output.endsWith("\n") ? `${output}${line}` : `${output}\n${line}`;
+	}
+	async ok(message = "", options = {}) {
 		let finalMessage = message;
 		if (finalMessage.length > 0 && !finalMessage.endsWith(".")) finalMessage += ".";
 		if (this.truncationHappened) finalMessage = finalMessage.length === 0 ? TRUNCATION_MESSAGE : `${finalMessage} ${TRUNCATION_MESSAGE}`;
-		const output = this.toString();
+		const baseOutput = this.toString();
+		const artifactRef = await this.maybeWriteArtifact();
+		const output = artifactRef === void 0 ? baseOutput : this.appendArtifactRef(baseOutput, artifactRef);
 		return {
 			isError: false,
 			output: finalMessage.length > 0 && (this.truncationHappened || output.length === 0) ? output.length === 0 ? finalMessage : output.endsWith("\n") ? `${output}${finalMessage}` : `${output}\n${finalMessage}` : output,
@@ -75367,9 +75552,11 @@ var ToolResultBuilder = class {
 			brief: options.brief
 		};
 	}
-	error(message, options = {}) {
+	async error(message, options = {}) {
 		const finalMessage = this.truncationHappened ? message.length === 0 ? TRUNCATION_MESSAGE : `${message} ${TRUNCATION_MESSAGE}` : message;
-		const output = this.toString();
+		const baseOutput = this.toString();
+		const artifactRef = await this.maybeWriteArtifact();
+		const output = artifactRef === void 0 ? baseOutput : this.appendArtifactRef(baseOutput, artifactRef);
 		return {
 			isError: true,
 			output: finalMessage.length === 0 ? output : output.length === 0 ? finalMessage : output.endsWith("\n") ? `${output}${finalMessage}` : `${output}\n${finalMessage}`,
@@ -75379,6 +75566,10 @@ var ToolResultBuilder = class {
 		};
 	}
 };
+function countLines(text) {
+	if (text.length === 0) return 0;
+	return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+}
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/file/grep.md
 var grep_default = "Search file contents using regular expressions (powered by ripgrep).\n\nUse Grep when the task is to find unknown content or unknown file locations. Do not use shell `grep` or `rg` directly; this tool applies workspace path policy, output limits, and sensitive-file filtering.\nALWAYS use Grep tool instead of running `grep` or `rg` from a shell — direct shell calls bypass workspace policy, output limits, and sensitive-file filtering.\nIf you already know a concrete file path and need to inspect its contents, use Read directly instead.\n\nWrite patterns in ripgrep regex syntax, which differs from POSIX `grep` syntax. For example, braces are special, so escape them as `\\{` to match a literal `{`.\n\nHidden files (dotfiles such as `.gitlab-ci.yml` or `.eslintrc.json`) are searched by default. To also search files excluded by `.gitignore` (such as `node_modules` or build outputs), set `include_ignored` to `true`. Sensitive files (such as `.env`) are always skipped for safety, even when `include_ignored` is `true`.\n";
@@ -75568,7 +75759,7 @@ var GrepTool = class {
 		const combined = visibleBody === "" && messages.length === 0 ? emptyResultMessage : messages.length > 0 ? visibleBody === "" ? messages.join("\n") : `${visibleBody}\n${messages.join("\n")}` : visibleBody;
 		const builder = new ToolResultBuilder();
 		builder.write(combined);
-		const result = builder.ok(sideChannelMessages.join("\n"));
+		const result = await builder.ok(sideChannelMessages.join("\n"));
 		const display = buildSearchResultsDisplay(args, limited, mode, contentIncludesLineNumbers);
 		if (display === void 0) return result;
 		if (result.isError === true) return result;
@@ -77788,6 +77979,30 @@ function truncateUtf8$1(input, maxBytes) {
 var bash_default = "Execute a `{{ SHELL_NAME }}` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\n\n**Translate these to a dedicated tool instead:**\n- `cat` / `head` / `tail` (known path) → `Read`\n- `sed` / `awk` (in-place edit) → `Edit`\n- `echo > file` / `cat <<EOF` → `Write`\n- `find` / recursive `ls` to locate files by name pattern → `Glob` (plain `ls <known-directory>` is fine for listing a directory)\n- `grep` / `rg` (search file contents) → `Grep`\n- `echo` / `printf` (talk to the user) → just output text directly\n\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\n\n**Output:**\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command failed, the output will end with a `Command failed with exit code: N` line stating the non-zero exit code.\n\nIf `run_in_background=true`, the command will be started as a background task and this tool will return a task ID instead of waiting for command completion. When doing that, you must provide a short `description`. Background commands default to a {{ DEFAULT_BACKGROUND_TIMEOUT_S }}s timeout and `timeout` is capped at {{ MAX_BACKGROUND_TIMEOUT_S }}s; set `disable_timeout=true` only when the task should run without a timeout. You will be automatically notified when the task completes. Use `TaskOutput` for a non-blocking status/output snapshot, and only set `block=true` when you explicitly want to wait for completion. Use `TaskStop` only if the task must be cancelled. If a human user wants to inspect background tasks themselves, point them to the `/tasks` command, which opens an interactive panel; it has no subcommands.\n\n**Guidelines for safety and security:**\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls.\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running foreground commands, set the `timeout` argument in seconds. Foreground commands default to {{ DEFAULT_TIMEOUT_S }}s and allow up to {{ MAX_TIMEOUT_S }}s.\n- Avoid using `..` to access files or directories outside of the working directory.\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\n\n**Guidelines for efficiency:**\n- For multiple related commands, use `&&` to chain them in a single call, e.g. `cd /path && ls -la`\n- Use `;` to run commands sequentially regardless of success/failure\n- Use `||` for conditional execution (run second command only if first fails)\n- Use pipe operations (`|`) and redirections (`>`, `>>`) to chain input and output between commands\n- Always quote file paths containing spaces with double quotes (e.g., cd \"/path with spaces/\")\n- Compose multi-step logic in a single call with `if` / `case` / `for` / `while` control flows.\n- Prefer `run_in_background=true` for long-running builds, tests, watchers, or servers when you need the conversation to continue before the command finishes.\n\n**Commands available:**\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run `which <command>` first to confirm a command exists before relying on it.\n- Navigation and inspection: `ls`, `pwd`, `cd`, `stat`, `file`, `du`, `df`, `tree`\n- File and directory management: `cp`, `mv`, `rm`, `mkdir`, `touch`, `ln`, `chmod`, `chown`\n- Text and data processing: `wc`, `sort`, `uniq`, `cut`, `tr`, `diff`, `xargs`\n- Archives and compression: `tar`, `gzip`, `gunzip`, `zip`, `unzip`\n- Networking and transfer: `curl`, `wget`, `ping`, `ssh`, `scp`\n- Version control: `git`\n- Process and system: `ps`, `kill`, `top`, `env`, `date`, `uname`, `whoami`\n- Language and package toolchains: `node`, `npm`, `pnpm`, `yarn`, `python`, `pip` (use whichever the project actually relies on)\n";
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/shell/bash.ts
+/**
+* BashTool — execute shell commands.
+*
+* Invokes bash (POSIX) according to an injected `Environment`. On Windows
+* the shell is Git Bash; the path is resolved by `detectEnvironment`.
+*
+* Dependencies injected via constructor:
+*   - `Jian`        — shell execution abstraction (exec / execWithEnv)
+*   - `cwd`         — default working directory for commands
+*   - `Environment` — cross-platform probe (shellName / shellPath)
+*   - `BackgroundProcessManager?` — optional: required iff run_in_background=true
+*
+* Execution goes through Jian, never directly via node:child_process.
+*
+* Hardening:
+*   - `args.timeout` (seconds) and the ambient `signal` both drive
+*     `Promise.race`; fire-a-kill on either edge.
+*   - stdin is closed immediately so interactive commands (`cat`, `read`,
+*     `python -c 'input()'`) receive EOF instead of hanging.
+*   - Two-phase kill: SIGTERM → 5s grace → SIGKILL (Jian honours this
+*     contract cross-platform).
+*   - stdout/stderr stream into ToolResultBuilder; excess is replaced with a
+*     truncation marker so a runaway command cannot OOM the host.
+*/
 const MS_PER_SECOND = 1e3;
 const DEFAULT_TIMEOUT_S = 60;
 const MAX_TIMEOUT_S = 300;
@@ -78038,7 +78253,11 @@ var BashTool = class {
 			killProc();
 		}, timeoutMs);
 		try {
-			const builder = new ToolResultBuilder();
+			const builder = new ToolResultBuilder({ artifactSink: async (fullOutput) => {
+				const artifactPath = join(tmpdir(), `scream-bash-output-${randomUUID()}.log`);
+				await writeFile(artifactPath, fullOutput, "utf8");
+				return artifactPath;
+			} });
 			const [, exitCode] = await Promise.all([Promise.all([readStreamIntoBuilder(proc.stdout, builder), readStreamIntoBuilder(proc.stderr, builder)]), proc.wait()]);
 			if (timedOut) {
 				const timeoutLabel = timeoutMs % 1e3 === 0 ? `${String(timeoutMs / 1e3)}s` : `${String(timeoutMs)}ms`;
@@ -79629,7 +79848,8 @@ const DEFAULT_CONFIG = {
 	minContentTokens: 100,
 	minContextUsageRatio: .5,
 	truncatedMarker: "[Old tool result content cleared]",
-	uselessMarker: "[Uneventful result elided]"
+	uselessMarker: "[Uneventful result elided]",
+	noMatchesMarker: "[no matches]"
 };
 /**
 * Compute the cutoff index: everything at index < cutoff is eligible for
@@ -79650,30 +79870,107 @@ function computeCutoff(messages, config) {
 	}
 	return cutoff;
 }
+/** Tool names whose results are file reads eligible for supersede pruning. */
+const READ_TOOL_NAMES = new Set(["Read", "ReadGroup"]);
+/** Tool names whose empty results can be elided as a no-match marker. */
+const SEARCH_TOOL_NAMES = new Set(["Grep", "Glob"]);
+/** Exact tool-result texts that indicate a zero-match search result. */
+const ZERO_MATCH_TEXTS = new Set(["No matches found", "No non-sensitive matches found"]);
 /**
-* Walk the message list and find Read tool calls whose file paths were
-* superseded by a later Read of the same path. Returns a map from the
-* superseded tool call's ID to the file path (for the marker text).
+* Parse a tool call's arguments JSON. Returns undefined for null or malformed
+* JSON - persisted history can carry truncated arguments that must not crash
+* compaction. `ToolCall.arguments` is a JSON string (or null), never a parsed
+* object, so every consumer must go through this helper.
+*/
+function parseToolCallArguments$1(argumentsJson) {
+	if (argumentsJson === null || argumentsJson === void 0) return void 0;
+	try {
+		const parsed = JSON.parse(argumentsJson);
+		return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Extract the file paths targeted by a read tool call. `Read` carries a
+* single `path`; `ReadGroup` carries a `paths` array. Returns an empty array
+* for non-read tools or calls whose arguments don't yield usable paths.
+*/
+function extractReadFilePaths(name, args) {
+	if (args === void 0) return [];
+	if (name === "Read") {
+		const path = typeof args["path"] === "string" ? args["path"] : void 0;
+		return path !== void 0 && path.length > 0 ? [path] : [];
+	}
+	if (name === "ReadGroup") {
+		const paths = args["paths"];
+		if (!Array.isArray(paths)) return [];
+		return paths.filter((p) => typeof p === "string" && p.length > 0);
+	}
+	return [];
+}
+/** Concatenate the `text` parts of a message's content into a single string. */
+function extractTextContent(content) {
+	let text = "";
+	for (const part of content) if (typeof part === "object" && part !== null && part.type === "text") text += part.text;
+	return text;
+}
+/** Build a toolCallId -> tool-name map by scanning assistant messages. */
+function buildToolCallNameMap(messages) {
+	const names = /* @__PURE__ */ new Map();
+	for (const msg of messages) {
+		if (msg.role !== "assistant") continue;
+		for (const tc of msg.toolCalls) names.set(tc.id, tc.name);
+	}
+	return names;
+}
+/**
+* Whether a tool result is a zero-match Grep/Glob result eligible for elision.
+* Only exact-match the canonical empty-result texts so results carrying extra
+* information (sensitive-file filter notices, pagination notices, errors) are
+* preserved verbatim.
+*/
+function isZeroMatchSearchResult(toolName, content) {
+	if (toolName === void 0 || !SEARCH_TOOL_NAMES.has(toolName)) return false;
+	const text = extractTextContent(content).trim();
+	return ZERO_MATCH_TEXTS.has(text);
+}
+/**
+* Walk the message list and find Read/ReadGroup tool calls whose file paths
+* were superseded by a later read of the same path. Returns a map from the
+* superseded tool call's ID to the list of file paths covered by the newer
+* read (a ReadGroup can cover several).
 *
-* Only considers tool results before the cutoff line — newer reads are
-* protected and their results are kept verbatim.
+* Only considers tool results before the cutoff line - newer reads are
+* protected and their results are kept verbatim. The comparison uses the raw
+* path strings from the tool arguments; path canonicalization would need
+* workspace context the compaction layer doesn't have, so the same file read
+* via two different spellings is treated as two different files (safe: it
+* just misses a supersede opportunity rather than dropping a distinct result).
 */
 function findSupersededPaths(messages, cutoff) {
 	const superseded = /* @__PURE__ */ new Map();
-	const readCalls = /* @__PURE__ */ new Map();
+	const latestReadByPath = /* @__PURE__ */ new Map();
 	for (let i = 0; i < messages.length; i++) {
 		const msg = messages[i];
 		if (msg === void 0) continue;
-		if (msg.role === "assistant" && msg.toolCalls.length > 0) {
-			for (const tc of msg.toolCalls) if (tc.name === "Read" && tc.id !== void 0 && tc.arguments !== void 0) {
-				const filePath = typeof tc.arguments === "object" && tc.arguments !== null ? tc.arguments["file_path"] : void 0;
-				if (filePath !== void 0) {
-					for (const [prevId, prev] of readCalls) if (prev.filePath === filePath && prev.index < cutoff) superseded.set(prevId, filePath);
-					readCalls.set(tc.id, {
-						filePath,
-						index: i
-					});
-				}
+		if (msg.role !== "assistant" || msg.toolCalls.length === 0) continue;
+		for (const tc of msg.toolCalls) {
+			if (!READ_TOOL_NAMES.has(tc.name)) continue;
+			const args = parseToolCallArguments$1(tc.arguments);
+			const paths = extractReadFilePaths(tc.name, args);
+			if (paths.length === 0) continue;
+			for (const filePath of paths) {
+				const prev = latestReadByPath.get(filePath);
+				if (prev !== void 0 && prev.index < cutoff) {
+					const existing = superseded.get(prev.toolCallId);
+					if (existing === void 0) superseded.set(prev.toolCallId, [filePath]);
+					else if (!existing.includes(filePath)) superseded.set(prev.toolCallId, [...existing, filePath]);
+				}
+				latestReadByPath.set(filePath, {
+					toolCallId: tc.id,
+					index: i
+				});
 			}
 		}
 	}
@@ -79727,20 +80024,26 @@ var MicroCompaction = class {
 	}
 	/**
 	* Apply micro-compaction to a message list: replace old tool results
-	* before the cutoff line with truncated markers. Read results for files
-	* that were re-read later get a supersede marker so the model knows
-	* the old content is stale. Tool results explicitly marked useless are
-	* elided with a short notice regardless of size, since they carry no
-	* actionable information.
+	* before the cutoff line with truncated markers. Read/ReadGroup results
+	* for files that were re-read later get a supersede marker (listing the
+	* covered paths) so the model knows the old content is stale. Zero-match
+	* Grep/Glob results are elided to a short `[no matches]` notice regardless
+	* of size. Tool results explicitly marked useless are elided with a short
+	* notice regardless of size, since they carry no actionable information.
 	*/
 	compact(messages) {
 		const config = this.config;
 		const superseded = findSupersededPaths(messages, this.cutoff);
+		const toolNames = buildToolCallNameMap(messages);
 		const result = [];
 		let i = 0;
 		for (const msg of messages) {
-			const isUseless = i < this.cutoff && msg.role === "tool" && msg.toolCallId !== void 0 && msg.useless === true;
-			const isOversizedTruncatable = i < this.cutoff && msg.role === "tool" && msg.toolCallId !== void 0 && estimateTokensForMessages([msg]) >= config.minContentTokens;
+			const isOld = i < this.cutoff;
+			const toolCallId = msg.toolCallId;
+			const isTool = msg.role === "tool" && toolCallId !== void 0;
+			const isUseless = isOld && isTool && msg.useless === true;
+			const isZeroMatch = isOld && isTool && toolCallId !== void 0 && isZeroMatchSearchResult(toolNames.get(toolCallId), msg.content);
+			const isOversizedTruncatable = isOld && isTool && estimateTokensForMessages([msg]) >= config.minContentTokens;
 			if (isUseless) result.push({
 				...msg,
 				content: [{
@@ -79748,8 +80051,16 @@ var MicroCompaction = class {
 					text: config.uselessMarker
 				}]
 			});
+			else if (isZeroMatch) result.push({
+				...msg,
+				content: [{
+					type: "text",
+					text: config.noMatchesMarker
+				}]
+			});
 			else if (isOversizedTruncatable) {
-				const marker = msg.toolCallId !== void 0 && superseded.has(msg.toolCallId) ? `[Superseded by a newer read of ${superseded.get(msg.toolCallId)}]` : config.truncatedMarker;
+				const paths = toolCallId !== void 0 ? superseded.get(toolCallId) : void 0;
+				const marker = paths !== void 0 && paths.length > 0 ? `[Superseded by a newer read of ${paths.join(", ")}]` : config.truncatedMarker;
 				result.push({
 					...msg,
 					content: [{
@@ -79774,20 +80085,28 @@ var MicroCompaction = class {
 	measureEffect(messages, cutoff) {
 		let markerTokenCount;
 		let uselessMarkerTokenCount;
+		let noMatchesMarkerTokenCount;
 		let truncatedToolResultCount = 0;
 		let beforeTokens = 0;
 		let afterTokens = 0;
+		const toolNames = buildToolCallNameMap(messages);
 		for (let i = 0; i < messages.length && i < cutoff; i++) {
 			const message = messages[i];
 			if (message?.role !== "tool" || message.toolCallId === void 0) continue;
 			const contentTokens = estimateTokensForMessages([message]);
 			const isUseless = message.useless === true;
-			if (!isUseless && contentTokens < this.config.minContentTokens) continue;
+			const isZeroMatch = isZeroMatchSearchResult(toolNames.get(message.toolCallId), message.content);
+			if (!isUseless && !isZeroMatch && contentTokens < this.config.minContentTokens) continue;
 			if (isUseless) {
 				uselessMarkerTokenCount ??= estimateTokens$1(this.config.uselessMarker);
 				truncatedToolResultCount += 1;
 				beforeTokens += contentTokens;
 				afterTokens += uselessMarkerTokenCount;
+			} else if (isZeroMatch) {
+				noMatchesMarkerTokenCount ??= estimateTokens$1(this.config.noMatchesMarker);
+				truncatedToolResultCount += 1;
+				beforeTokens += contentTokens;
+				afterTokens += noMatchesMarkerTokenCount;
 			} else {
 				markerTokenCount ??= estimateTokens$1(this.config.truncatedMarker);
 				truncatedToolResultCount += 1;
@@ -80796,6 +81115,71 @@ var ConfigState = class {
 	}
 };
 //#endregion
+//#region ../../packages/agent-core/src/agent/context/prefix-fingerprint.ts
+/**
+* Deterministic non-crypto string hash (djb2). Fast and sufficient for change
+* detection; not used for any security purpose. Returns a compact base36
+* string so an array of fingerprints stays small.
+*/
+function hashString(input) {
+	let hash = 5381;
+	for (let i = 0; i < input.length; i++) hash = (hash << 5) + hash + (input.codePointAt(i) ?? 0) | 0;
+	return (hash >>> 0).toString(36);
+}
+/**
+* Stable JSON serialization that sorts object keys so key insertion order
+* can't affect the fingerprint. Only used for media parts whose payload is
+* already a stable base64/url string; text/think parts have a dedicated
+* fast path.
+*/
+function stableJson(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+	const obj = value;
+	return `{${Object.keys(obj).toSorted().map((k) => `${JSON.stringify(k)}:${stableJson(obj[k])}`).join(",")}}`;
+}
+function serializeContentPart(part) {
+	switch (part.type) {
+		case "text": return `text:${part.text}`;
+		case "think": return `think:${part.think}${part.encrypted !== void 0 ? `\u0003${part.encrypted}` : ""}`;
+		default: return `${part.type}:${stableJson(part)}`;
+	}
+}
+function serializeToolCall(tc) {
+	return `function|${tc.id}|${tc.name}|${tc.arguments ?? ""}`;
+}
+/**
+* Serialize a message to a deterministic string covering all
+* provider-visible bytes. Two messages with the same serialization produce
+* identical provider bytes (modulo serialization the provider adapter
+* normalizes). Separator bytes (\x00-\x03) are used so concatenated fields
+* can't alias.
+*/
+function serializeMessage$1(message) {
+	const content = message.content.map(serializeContentPart).join("
");
+	const toolCalls = message.toolCalls.map(serializeToolCall).join("");
+	return `${message.role}\u0000${message.name ?? ""}\u0000${message.toolCallId ?? ""}\u0000${content}\u0000${toolCalls}`;
+}
+/** Per-message fingerprint. Equal fingerprints => equal provider bytes. */
+function messageFingerprint(message) {
+	return hashString(serializeMessage$1(message));
+}
+/**
+* Longest common prefix length by provider-visible bytes. This is the number
+* of leading messages a provider prompt cache could reuse from the previous
+* call. When this is less than the previous call's message count, an early
+* message mutated and the cache broke from that index.
+*
+* `prev` is the array of per-message fingerprints captured last call;
+* `current` is the live messages this call.
+*/
+function stablePrefixLength(prev, current) {
+	const n = Math.min(prev.length, current.length);
+	let i = 0;
+	for (; i < n; i++) if (prev[i] !== messageFingerprint(current[i])) break;
+	return i;
+}
+//#endregion
 //#region ../../packages/agent-core/src/agent/context/types.ts
 const USER_PROMPT_ORIGIN = { kind: "user" };
 //#endregion
@@ -80818,6 +81202,18 @@ var ContextMemory = class {
 	openSteps = /* @__PURE__ */ new Map();
 	pendingToolResultIds = /* @__PURE__ */ new Set();
 	deferredMessages = [];
+	/**
+	* Per-message fingerprints captured from the last message list handed to
+	* the LLM via {@link messagesForLLM}. Used to measure prefix stability
+	* across calls: a provider prompt cache only hits when the leading
+	* messages are byte-identical to the previous request, so the length of
+	* the matching prefix here approximates the cacheable prefix length.
+	*
+	* Reset on {@link clear}; a compaction naturally produces a 0-length
+	* stable prefix (the summary replaces the head), which is the correct
+	* cache-break signal rather than a reset.
+	*/
+	lastSentFingerprints = [];
 	constructor(agent) {
 		this.agent = agent;
 	}
@@ -80867,6 +81263,7 @@ var ContextMemory = class {
 		this.openSteps.clear();
 		this.pendingToolResultIds.clear();
 		this.deferredMessages = [];
+		this.lastSentFingerprints = [];
 		this.agent.injection.onContextClear();
 		this.agent.emitStatusUpdated();
 	}
@@ -80911,6 +81308,19 @@ var ContextMemory = class {
 		}
 		if (!this.agent.records.restoring && (stoppedAtBoundary || removedUserCount < count)) {}
 	}
+	/**
+	* Apply a full compaction summary.
+	*
+	* Prefix-stability note: this is a **replaceHead** operation, not a
+	* replaceTail. The first `compactedCount` messages are collapsed into a
+	* single summary message; the trailing recent messages are preserved
+	* verbatim. This necessarily breaks the provider prompt cache for the
+	* whole prefix (the summary is new content), which is inherent to
+	* summarization and cannot be avoided. After compaction the new prefix
+	* `[summary, ...tail]` is stable again until the next compaction or
+	* micro-compaction cutoff advance, so subsequent append-only steps resume
+	* hitting the cache.
+	*/
 	applyCompaction(summary) {
 		this.agent.records.logRecord({
 			type: "context.apply_compaction",
@@ -80954,6 +81364,48 @@ var ContextMemory = class {
 		this.agent.microCompaction.detect();
 		return project(this.agent.microCompaction.compact(this.history));
 	}
+	/**
+	* Build the message list for an LLM call, with prefix-stability
+	* observation.
+	*
+	* This is the LLM-bound counterpart of the {@link messages} getter: it
+	* runs the same detect + compact + project pipeline, then fingerprints
+	* the result and logs how much of the prefix survived since the last
+	* call. A stable prefix length equal to the previous message count means
+	* the provider prompt cache should hit; a smaller value means an early
+	* message mutated (compaction summary, micro-compaction truncation, or a
+	* projection repair) and the cache broke from that index.
+	*
+	* Behavior is otherwise identical to the getter - this is observation
+	* only, it does not alter the messages returned.
+	*/
+	messagesForLLM() {
+		this.agent.microCompaction.detect();
+		const messages = project(this.agent.microCompaction.compact(this.history));
+		this.observePrefixStability(messages);
+		return messages;
+	}
+	/**
+	* Compare the projected messages against the last LLM-bound batch and
+	* log the stable-prefix length. Pure observation: no state that affects
+	* message content is mutated, only the fingerprint baseline used by the
+	* next call's comparison.
+	*/
+	observePrefixStability(messages) {
+		const prev = this.lastSentFingerprints;
+		const stable = stablePrefixLength(prev, messages);
+		this.lastSentFingerprints = messages.map(messageFingerprint);
+		if (prev.length === 0) return;
+		const appended = messages.length - prev.length;
+		if (stable >= prev.length) return;
+		this.agent.log.debug("prefix-stability: provider prompt cache prefix broke", {
+			stablePrefixLength: stable,
+			prevMessageCount: prev.length,
+			currentMessageCount: messages.length,
+			appendedSinceLast: appended,
+			breakIndex: stable
+		});
+	}
 	appendLoopEvent(event) {
 		this.agent.records.logRecord({
 			type: "context.append_loop_event",
@@ -81590,6 +82042,8 @@ function buildGoalReminder(goal) {
 	lines.push("Goal mode is iterative. Keep the self-audit brief each turn. Do not explore unrelated interpretations once the goal can be decided. If the objective is simple, already answered, impossible, unsafe, or contradictory, do not run another goal turn. Explain briefly if useful, then call UpdateGoal with `complete` or `blocked` in the same turn. Otherwise, self-audit against the objective and any completion criteria above, then do one coherent slice of work toward the objective. Use multiple turns when the task naturally has multiple phases. Call UpdateGoal with `complete` only when all required work is done, any stated validation has passed, and there is no useful next action. Do not mark complete after only producing a plan, summary, first pass, or partial result. If an external condition or required user input prevents progress, or the objective cannot be completed as stated, call UpdateGoal with `blocked`. Otherwise keep working — after your turn ends you will be prompted to continue. Call UpdateGoal as soon as the goal is genuinely done or cannot proceed; don't keep going once there is nothing left to do.");
 	lines.push("");
 	lines.push("When you call UpdateGoal with `complete`, an independent reviewer will verify that the completion criteria are met. In your final response before calling UpdateGoal, provide a structured summary: what was done, which files changed, the verification command and result, and any remaining work or blockers. Do not rely on the UpdateGoal argument alone; the reviewer and the user must see this summary in your natural-language reply.");
+	lines.push("");
+	lines.push("Important: before calling UpdateGoal with `complete`, always call WriteGoalNote first to summarize the key findings, constraints, or partial results from this turn. The reviewer will see these notes together with your final output, so include anything that helps them evaluate cross-turn context. Keep the note concise and actionable.");
 	return lines.join("\n");
 }
 function maxBudgetFraction(goal) {
@@ -97303,6 +97757,13 @@ function buildGraderPrompt(objective, criteria, output) {
 		"## Agent Output",
 		output || "(no output captured)",
 		"",
+		"The Agent Output section contains the following optional parts, in order:",
+		"1. The agent's natural-language summary of what was done this turn.",
+		"2. \"## Cross-turn working notes\" — short notes the agent recorded using the WriteGoalNote tool across continuation turns. These notes capture key findings, constraints, decisions, and partial results. Treat them as supplementary context when evaluating whether the acceptance criteria are met; they are not the deliverable itself.",
+		"3. \"## Changes this turn\" — a git diff stat (or a note if git is unavailable) showing which files were modified. Use it to verify that the claimed work has an actual code footprint.",
+		"",
+		"If the Agent Output does not contain a \"## Cross-turn working notes\" section, add a non-blocking issue: \"No cross-turn working notes were provided. Use WriteGoalNote to record key findings, constraints, and partial results across turns.\" This issue alone must not cause a FAIL.",
+		"",
 		"Evaluate each dimension independently against the acceptance criteria, then decide overall PASS/FAIL.",
 		"When FAIL, list every specific issue with an actionable fix direction so the agent knows exactly what to address next.",
 		"Respond with JSON:",
@@ -97983,14 +98444,21 @@ const GOAL_CONTINUATION_PROMPT = [
 	"reassess. Call UpdateGoal with `complete` only when all required work is done, any stated",
 	"validation has passed, and there is no useful next action. Do not mark complete after only",
 	"producing a plan, summary, first pass, or partial result. If an external condition or required",
-	"user input prevents progress, or the objective cannot be completed as stated, call UpdateGoal",
-	"with `blocked`. Otherwise keep going — use the existing conversation context and your tools,",
-	"and do not ask the user for input unless a real blocker prevents progress."
+	"user input prevents progress, call UpdateGoal with `blocked` and include a `reason`. The goal",
+	"will only be marked blocked after you report the same blocker for at least 3 consecutive",
+	"turns, so first try alternative approaches. Otherwise keep going — use the existing",
+	"conversation context and your tools, and do not ask the user for input unless a real blocker",
+	"prevents progress."
 ].join(" ");
 const GOAL_CONTINUATION_ORIGIN = {
 	kind: "system_trigger",
 	name: "goal_continuation"
 };
+const GOAL_BUDGET_STEER_PROMPT = "Budget nearly exhausted. Wrap up immediately: verify your work, run tests, and call UpdateGoal with status \"complete\" or \"blocked\". Do not start any new work.";
+const GOAL_BUDGET_STEER_ORIGIN = {
+	kind: "system_trigger",
+	name: "goal_budget_steer"
+};
 var TurnFlow = class {
 	agent;
 	steerBuffer = [];
@@ -98155,6 +98623,14 @@ var TurnFlow = class {
 				}
 			}
 			await this.agent.goal.incrementTurn();
+			const budgetSnapshot = this.agent.goal.getGoal().goal;
+			if (budgetSnapshot !== null && budgetSnapshot.status === "active" && (budgetSnapshot.budget.overBudget || isBudgetNearExhaustion(budgetSnapshot.budget, .2))) {
+				turnInput = [{
+					type: "text",
+					text: GOAL_BUDGET_STEER_PROMPT
+				}];
+				turnOrigin = GOAL_BUDGET_STEER_ORIGIN;
+			}
 			const end = await this.runOneTurn(turnId, turnInput, turnOrigin, signal, false);
 			if (end.event.reason === "cancelled") {
 				await this.agent.goal.pauseOnInterrupt({ reason: "Paused after interruption" });
@@ -98346,7 +98822,7 @@ var TurnFlow = class {
 					turnId: String(turnId),
 					signal,
 					llm: this.agent.llm,
-					buildMessages: () => this.agent.context.messages,
+					buildMessages: () => this.agent.context.messagesForLLM(),
 					dispatchEvent: this.buildDispatchEvent(turnId),
 					tools: this.agent.tools.loopTools,
 					log: this.agent.log,
@@ -98875,6 +99351,7 @@ var LtodLLM = class {
 		this.obfuscator = config.obfuscator;
 	}
 	async chat(params) {
+		const chatStartedAt = Date.now();
 		let requestStartedAt = Date.now();
 		let firstChunkAt;
 		let streamEndedAt;
@@ -98894,13 +99371,22 @@ var LtodLLM = class {
 			capability: this.capability
 		});
 		const outboundMessages = this.obfuscator && this.obfuscator.hasSecrets() ? obfuscateMessages(this.obfuscator, params.messages) : params.messages;
-		const result = await this.generate(effectiveProvider, this.systemPrompt, [...params.tools], outboundMessages, callbacks, generateOptions(params, {
+		const runGenerate = (messages) => this.generate(effectiveProvider, this.systemPrompt, [...params.tools], messages, callbacks, generateOptions(params, {
 			onRequestStart: markRequestStart,
 			onStreamEnd: () => {
 				markStreamEnd();
 				flushPending();
 			}
 		}));
+		let result;
+		try {
+			result = await runGenerate(outboundMessages);
+		} catch (error) {
+			if (!(error instanceof APIContextOverflowError)) throw error;
+			const strippedMessages = stripMediaFromMessages(outboundMessages);
+			if (strippedMessages === null) throw error;
+			result = await runGenerate(strippedMessages);
+		}
 		if (params.onTextPart !== void 0 || params.onThinkPart !== void 0) {
 			for (const part of result.message.content) if (part.type === "text" && params.onTextPart !== void 0) await params.onTextPart(part);
 			else if (part.type === "think" && params.onThinkPart !== void 0) await params.onThinkPart(part);
@@ -98910,18 +99396,21 @@ var LtodLLM = class {
 			providerFinishReason: result.finishReason ?? void 0,
 			rawFinishReason: result.rawFinishReason ?? void 0,
 			usage: result.usage ?? emptyUsage(),
-			streamTiming: firstChunkAt === void 0 ? void 0 : buildStreamTiming(requestStartedAt, firstChunkAt, streamEndedAt)
+			streamTiming: firstChunkAt === void 0 ? void 0 : buildStreamTiming(chatStartedAt, requestStartedAt, firstChunkAt, streamEndedAt)
 		};
 	}
 	isRetryableError(error) {
 		return isRetryableGenerateError(error);
 	}
 };
-function buildStreamTiming(requestStartedAt, firstChunkAt, streamEndedAt) {
+function buildStreamTiming(chatStartedAt, requestStartedAt, firstChunkAt, streamEndedAt) {
 	const outputEndedAt = streamEndedAt ?? Date.now();
 	return {
 		firstTokenLatencyMs: Math.max(0, firstChunkAt - requestStartedAt),
-		streamDurationMs: Math.max(0, outputEndedAt - firstChunkAt)
+		streamDurationMs: Math.max(0, outputEndedAt - firstChunkAt),
+		requestBuildMs: Math.max(0, requestStartedAt - chatStartedAt),
+		serverFirstTokenMs: Math.max(0, firstChunkAt - requestStartedAt),
+		serverDecodeMs: Math.max(0, outputEndedAt - firstChunkAt)
 	};
 }
 function generateOptions(params, hooks) {
@@ -99056,6 +99545,27 @@ function buildLtodCallbacks(params, markStreamOutput, obfuscator) {
 		}
 	};
 }
+/**
+* Remove image parts from messages for context-overflow retry.
+* Returns null when no media was found (no point retrying without media).
+*/
+function stripMediaFromMessages(messages) {
+	let hasMedia = false;
+	const stripped = messages.map((msg) => {
+		const newContent = msg.content.filter((part) => {
+			if (part.type !== "text" && part.type !== "think") {
+				hasMedia = true;
+				return false;
+			}
+			return true;
+		});
+		return {
+			...msg,
+			content: newContent
+		};
+	});
+	return hasMedia ? stripped : null;
+}
 //#endregion
 //#region ../../packages/agent-core/src/agent/usage/index.ts
 function copyUsage(usage) {
@@ -99447,6 +99957,9 @@ var Agent = class {
 				if (status === "paused") return this.goal.pauseGoal({}, "user");
 				return this.goal.resumeGoal({}, "user");
 			},
+			updateGoalObjective: async (payload) => {
+				return this.goal.updateObjective({ objective: payload.objective }, "user");
+			},
 			cancelGoal: async () => {
 				return this.goal.cancelGoal("user");
 			},
@@ -119503,6 +120016,9 @@ var SessionAPIImpl = class {
 	updateGoalStatus({ agentId, ...payload }) {
 		return this.getAgent(agentId).updateGoalStatus(payload);
 	}
+	updateGoalObjective({ agentId, ...payload }) {
+		return this.getAgent(agentId).updateGoalObjective(payload);
+	}
 	cancelGoal({ agentId, ...payload }) {
 		return this.getAgent(agentId).cancelGoal(payload);
 	}
@@ -121245,6 +121761,9 @@ var ScreamCore = class {
 	updateGoalStatus({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).updateGoalStatus(payload);
 	}
+	updateGoalObjective({ sessionId, ...payload }) {
+		return this.sessionApi(sessionId).updateGoalObjective(payload);
+	}
 	cancelGoal({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).cancelGoal(payload);
 	}
@@ -121698,6 +122217,13 @@ var SDKRpcClient = class {
 			status: input.status
 		});
 	}
+	async updateGoalObjective(input) {
+		return (await this.getRpc()).updateGoalObjective({
+			sessionId: input.sessionId,
+			agentId: this.interactiveAgentId,
+			objective: input.objective
+		});
+	}
 	async cancelGoal(input) {
 		return (await this.getRpc()).cancelGoal({
 			sessionId: input.sessionId,
@@ -122458,6 +122984,13 @@ var Session = class {
 			status
 		});
 	}
+	async updateGoalObjective(objective) {
+		this.ensureOpen();
+		return this.rpc.updateGoalObjective({
+			sessionId: this.id,
+			objective
+		});
+	}
 	async cancelGoal() {
 		this.ensureOpen();
 		return this.rpc.cancelGoal({ sessionId: this.id });
@@ -122917,7 +123450,7 @@ function optionalBuildString(value) {
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 const SCREAM_BUILD_INFO = {
-	version: optionalBuildString("0.10.6"),
+	version: optionalBuildString("0.10.8"),
 	channel: optionalBuildString(""),
 	commit: optionalBuildString(""),
 	buildTarget: optionalBuildString("darwin-arm64")
@@ -123910,6 +124443,7 @@ const BUILTIN_SLASH_COMMANDS = [
 		name: "goal",
 		aliases: ["goaloff"],
 		description: "registry.goal_desc",
+		argumentHint: "[objective]",
 		priority: 122,
 		availability: (args) => {
 			const trimmed = args.trim();
@@ -123920,6 +124454,7 @@ const BUILTIN_SLASH_COMMANDS = [
 		name: "memory",
 		aliases: ["memo", "mem"],
 		description: "registry.memory_desc",
+		argumentHint: "[query]",
 		priority: 120,
 		availability: "always"
 	},
@@ -123927,6 +124462,7 @@ const BUILTIN_SLASH_COMMANDS = [
 		name: "knowledge",
 		aliases: ["know"],
 		description: "registry.knowledge_desc",
+		argumentHint: "[query]",
 		priority: 119,
 		availability: "always"
 	},
@@ -123940,6 +124476,7 @@ const BUILTIN_SLASH_COMMANDS = [
 		name: "model",
 		aliases: [],
 		description: "registry.model_desc",
+		argumentHint: "[alias]",
 		priority: 120
 	},
 	{
@@ -126123,6 +126660,24 @@ function formatContextStatus(usage, tokens, maxTokens) {
 	});
 	return t("footer.context_short", { pct });
 }
+/** Format goal wall-clock duration compactly: `3m`, `1m30s`, `45s`. */
+function formatGoalDuration(ms) {
+	const totalSeconds = Math.floor(ms / 1e3);
+	if (totalSeconds < 60) return `${totalSeconds}s`;
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	return seconds > 0 ? `${minutes}m${seconds}s` : `${minutes}m`;
+}
+/** Build the footer goal badge: `GOAL 3m · 7 turns`.
+*
+* The TUI only receives `goal.updated` events on state changes, so we keep a
+* local base timestamp and add the elapsed time since the last snapshot to
+* produce a live wall-clock reading between sparse events.
+*/
+function formatGoalBadge(goal) {
+	const elapsedSinceSnapshot = Date.now() - goal.wallClockBaseAt;
+	return `GOAL ${formatGoalDuration(goal.wallClockMs + Math.max(0, elapsedSinceSnapshot))} · ${goal.turnsUsed} turns`;
+}
 const CONTEXT_WARNING_PERCENT_THRESHOLD = 60;
 const CONTEXT_ERROR_PERCENT_THRESHOLD = 90;
 function pickContextColor(usage, colors) {
@@ -126148,7 +126703,7 @@ const SPINNER_FRAMES$1 = [
 	"◎",
 	"◉"
 ];
-const SPINNER_TICK_MS = 120;
+const SPINNER_TICK_MS = 60;
 function hexToRgb$2(hex) {
 	const v = parseInt(hex.slice(1), 16);
 	return [
@@ -126172,7 +126727,7 @@ function lerpGradient(t) {
 }
 function buildStatusLine(streamingPhase, streamingStartTime, reconnectAttempt) {
 	if (streamingPhase === "idle") return t("status.idle");
-	if (reconnectAttempt > 0) return chalk.hex("#E85454").bold("◎") + " " + chalk.hex("#E85454")(`${t("status.reconnecting")} ${String(reconnectAttempt)}`);
+	if (reconnectAttempt > 0 && streamingPhase === "waiting") return chalk.hex("#E85454").bold("◎") + " " + chalk.hex("#E85454")(`${t("status.reconnecting")} ${String(reconnectAttempt)}`);
 	let label;
 	if (streamingPhase === "tool") label = t("status.tool");
 	else if (streamingPhase === "waiting") label = t("status.waiting");
@@ -126217,15 +126772,17 @@ var FooterComponent = class {
 		this.onGitStatusChange = onGitStatusChange;
 		this.gitCacheWorkDir = state.workDir;
 		this.gitCache = createGitStatusCache(state.workDir, { onChange: this.onGitStatusChange });
+		this.#restartStatusTimer(state.streamingPhase, state.goalActive);
 	}
 	setState(state) {
 		const previousPhase = this.state?.streamingPhase;
+		const previousGoalActive = this.state?.goalActive;
 		if (state.workDir !== this.gitCacheWorkDir) {
 			this.gitCacheWorkDir = state.workDir;
 			this.gitCache = createGitStatusCache(state.workDir, { onChange: this.onGitStatusChange });
 		}
 		this.state = state;
-		if (state.streamingPhase !== previousPhase) this.#restartStatusTimer(state.streamingPhase);
+		if (state.streamingPhase !== previousPhase || state.goalActive !== previousGoalActive) this.#restartStatusTimer(state.streamingPhase, state.goalActive);
 	}
 	setColors(colors) {
 		this.colors = colors;
@@ -126253,10 +126810,10 @@ var FooterComponent = class {
 	dispose() {
 		this.#stopStatusTimer();
 	}
-	#restartStatusTimer(phase) {
+	#restartStatusTimer(phase, goalActive) {
 		this.#stopStatusTimer();
-		if (phase === "idle") return;
-		const intervalMs = phase === "thinking" ? 1e3 / 30 : SPINNER_TICK_MS;
+		if (phase === "idle" && !goalActive) return;
+		const intervalMs = 1e3 / 60;
 		this.statusTimer = setInterval(() => {
 			this.ui.requestRender();
 		}, intervalMs);
@@ -126275,7 +126832,10 @@ var FooterComponent = class {
 			left.push(chalk.hex(isFusion ? colors.fusionPlanMode : colors.planMode).bold(isFusion ? t("badge.fusion") : t("badge.plan")));
 		}
 		if (state.wolfpackMode) left.push(chalk.hex(colors.wolfpackMode).bold(t("badge.wolfpack")));
-		if (state.goalActive) left.push(chalk.hex(colors.primary).bold(t("badge.goal")));
+		if (state.goalActive && state.goal) {
+			const goalLabel = formatGoalBadge(state.goal);
+			left.push(chalk.hex(colors.primary).bold(goalLabel));
+		}
 		const model = shortenModel(modelDisplayName(state));
 		if (model) if (state.streamingPhase === "thinking") left.push(shimmerText(model, colors));
 		else left.push(chalk.hex(colors.textDim)(model));
@@ -126649,10 +127209,63 @@ function createThemeStyles(colors) {
 //#endregion
 //#region src/tui/theme/pi-tui-theme.ts
 const HEADING_HASH_PREFIX = /^((?:\u001B\[[0-9;]*m)*)#{1,6}[ \t]+/;
+/**
+* Map cli-highlight syntax tokens onto the ColorPalette so code blocks follow
+* the active theme instead of cli-highlight's built-in colors. cli-highlight
+* takes one formatter function per token; tokens not listed here fall back to
+* its DEFAULT_THEME.
+*/
+function createCodeHighlightTheme(colors) {
+	const keyword = chalk.hex(colors.primary);
+	const str = chalk.hex(colors.success);
+	const comment = chalk.hex(colors.textDim);
+	const num = chalk.hex(colors.warning);
+	const fn = chalk.hex(colors.primary);
+	const cls = chalk.hex(colors.accent);
+	const text = chalk.hex(colors.text);
+	return {
+		keyword,
+		built_in: fn,
+		type: cls,
+		literal: num,
+		number: num,
+		regexp: str,
+		string: str,
+		subst: str,
+		symbol: num,
+		class: cls,
+		function: fn,
+		title: fn,
+		params: text,
+		comment,
+		doctag: comment,
+		meta: chalk.hex(colors.textMuted),
+		"meta-keyword": keyword,
+		"meta-string": str,
+		section: keyword,
+		tag: cls,
+		name: fn,
+		"builtin-name": fn,
+		attr: num,
+		attribute: num,
+		variable: text,
+		bullet: num,
+		code: str,
+		emphasis: (s) => chalk.italic(s),
+		strong: (s) => chalk.bold(s),
+		formula: text,
+		link: chalk.hex(colors.mdLink),
+		quote: chalk.hex(colors.mdQuote),
+		addition: chalk.hex(colors.diffAdded),
+		deletion: chalk.hex(colors.diffRemoved),
+		default: text
+	};
+}
 function createMarkdownTheme(colors) {
 	const stripHash = (text) => text.replace(HEADING_HASH_PREFIX, "$1");
 	const muted = chalk.hex(colors.textMuted);
 	const border = chalk.hex(colors.border);
+	const codeTheme = createCodeHighlightTheme(colors);
 	return {
 		heading: (text) => chalk.bold.hex(colors.text)(stripHash(text)),
 		link: (text) => chalk.hex(colors.mdLink)(text),
@@ -126674,7 +127287,8 @@ function createMarkdownTheme(colors) {
 			try {
 				return highlight(code, {
 					language,
-					ignoreIllegals: true
+					ignoreIllegals: true,
+					theme: codeTheme
 				}).split("\n");
 			} catch {
 				return code.split("\n");
@@ -128103,6 +128717,10 @@ function buildEmptyGoalLines(colors) {
 		value(t("goalpanel.no_goal")),
 		"",
 		`${muted("/goal")} ${value(t("goalpanel.goal_placeholder"))}   ${muted(t("goalpanel.create_goal"))}`,
+		`${muted("/goal setup")}      ${muted(t("goalpanel.setup_goal"))}`,
+		`${muted("/goal update")} ${value("<new objective>")}   ${muted(t("goalpanel.update_goal"))}`,
+		`${muted("/goal status")}      ${muted(t("goalpanel.status_goal"))}`,
+		`${muted("/goal replace")} ${value("<new objective>")}   ${muted(t("goalpanel.replace_goal"))}`,
 		`${muted("/goal pause")}       ${muted(t("goalpanel.pause_goal"))}`,
 		`${muted("/goal resume")}      ${muted(t("goalpanel.resume_goal"))}`,
 		`${muted("/goaloff")}          ${muted(t("goalpanel.cancel_goal"))}`
@@ -128165,6 +128783,19 @@ function parseGoalCommand(rawArgs) {
 	const tokens = args.split(/\s+/);
 	const first = tokens[0];
 	if (first !== void 0 && CONTROL_SUBCOMMANDS.has(first) && tokens.length === 1) return { kind: first };
+	if (first === "setup") return { kind: "setup" };
+	if (first === "update") {
+		const objective = tokens.slice(1).join(" ").trim();
+		if (objective.length === 0) return {
+			kind: "error",
+			severity: "hint",
+			message: t("goal.need_desc")
+		};
+		return {
+			kind: "update",
+			objective
+		};
+	}
 	let index = 0;
 	let replace = false;
 	if (tokens[index] === "replace") {
@@ -128194,6 +128825,9 @@ async function handleGoalCommand(host, args) {
 		case "status":
 			await showGoalStatus(host);
 			return;
+		case "setup":
+			await guidedGoalSetup(host);
+			return;
 		case "pause":
 			await pauseGoal(host);
 			return;
@@ -128203,6 +128837,9 @@ async function handleGoalCommand(host, args) {
 		case "off":
 			await handleGoalOffCommand(host);
 			return;
+		case "update":
+			await updateGoalObjective(host, parsed);
+			return;
 		case "create":
 			await createGoal(host, parsed);
 			return;
@@ -128220,8 +128857,51 @@ async function createGoal(host, parsed) {
 	}
 	await showGoalConfigWizard(host, session, parsed.objective, parsed.replace);
 }
+const GOAL_REFINER_SYSTEM_PROMPT = "You are a goal refiner. Given a brief task description, produce a single clear, actionable objective sentence (max 200 chars). Do not add explanations, quotes, or prefixes.";
+/**
+* Guided goal creation: collect a brief task description, refine it via the
+* LLM into a single objective sentence, let the user confirm/edit, then enter
+* the standard configuration wizard. Falls back to the raw description if the
+* LLM call fails.
+*/
+async function guidedGoalSetup(host) {
+	const session = host.session;
+	if (session === void 0) {
+		host.showError(t("error.no_session"));
+		return;
+	}
+	if (detectGoalConflict(host.state.appState, "enable_goal") === "goal_active") {
+		host.showNotice(t("goal.storm_breaker"), t("goal.conflict_loop"));
+		return;
+	}
+	const { TextInputDialogComponent } = await import("./text-input-dialog-B_rgO4qn.mjs");
+	const initialDesc = await promptText(host, TextInputDialogComponent, {
+		title: t("goal.setup_title_initial"),
+		subtitle: t("goal.setup_desc_hint"),
+		placeholder: t("goal.setup_desc_placeholder"),
+		allowEmpty: false
+	});
+	if (initialDesc === void 0) return;
+	host.showStatus(t("goal.setup_refining"));
+	let objective;
+	try {
+		objective = (await session.generateText(GOAL_REFINER_SYSTEM_PROMPT, initialDesc)).trim();
+		if (objective.length === 0) objective = initialDesc;
+	} catch {
+		objective = initialDesc;
+	}
+	const confirmed = await promptText(host, TextInputDialogComponent, {
+		title: t("goal.setup_title_confirm"),
+		subtitle: t("goal.setup_confirm_hint"),
+		placeholder: objective,
+		initialValue: objective,
+		allowEmpty: true
+	});
+	if (confirmed === void 0) return;
+	await showGoalConfigWizard(host, session, confirmed.trim() || objective, false);
+}
 async function showGoalConfigWizard(host, session, objective, replace) {
-	const { TextInputDialogComponent } = await import("./text-input-dialog-zZlNFEk3.mjs");
+	const { TextInputDialogComponent } = await import("./text-input-dialog-B_rgO4qn.mjs");
 	const turnInput = await promptNumber(host, TextInputDialogComponent, {
 		title: t("goal.wizard_title", { objective }),
 		subtitle: t("goal.budget_turns_hint"),
@@ -128291,6 +128971,27 @@ function promptNumber(host, TextInputDialogComponent, opts) {
 		host.mountEditorReplacement(dialog);
 	});
 }
+/** Prompt user for free-form text. Returns undefined on cancel. */
+function promptText(host, TextInputDialogComponent, opts) {
+	return new Promise((resolve) => {
+		const dialog = new TextInputDialogComponent((result) => {
+			host.restoreEditor();
+			if (result.kind !== "ok") {
+				resolve(void 0);
+				return;
+			}
+			resolve(result.value.trim());
+		}, {
+			title: opts.title,
+			subtitle: opts.subtitle,
+			placeholder: opts.placeholder,
+			initialValue: opts.initialValue,
+			allowEmpty: opts.allowEmpty,
+			colors: host.state.theme.colors
+		});
+		host.mountEditorReplacement(dialog);
+	});
+}
 async function pauseGoal(host) {
 	const session = host.session;
 	if (session === void 0) {
@@ -128331,6 +129032,24 @@ async function resumeGoal(host) {
 		host.showError(t("goal.resume_failed", { msg: message }));
 	}
 }
+async function updateGoalObjective(host, parsed) {
+	const session = host.session;
+	if (session === void 0) {
+		host.showError(t("error.no_session"));
+		return;
+	}
+	try {
+		if ((await session.getGoal()).goal === null) {
+			host.showStatus(t("goal.no_active"));
+			return;
+		}
+		await session.updateGoalObjective(parsed.objective);
+		host.showStatus(t("goal.updated", { objective: parsed.objective }));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		host.showError(t("goal.update_failed", { msg: message }));
+	}
+}
 async function handleGoalOffCommand(host) {
 	const session = host.session;
 	if (session === void 0) {
@@ -129360,6 +130079,12 @@ function easeSpeedRatio(ratio) {
 }
 //#endregion
 //#region src/tui/components/messages/thinking.ts
+/** gpt-5 reasoning summaries contain empty HTML comment padding sentinels
+* like `<!-- -->`. Strip them to keep the thinking display clean. */
+const EMPTY_COMMENT_RE = /<!--\s*-->/g;
+function filterThinkingNoise(text) {
+	return text.replace(EMPTY_COMMENT_RE, "");
+}
 var ThinkingComponent = class {
 	text;
 	color;
@@ -129398,7 +130123,7 @@ var ThinkingComponent = class {
 		this.textComponent.setText(this.styled(trimmed));
 	}
 	styled(text) {
-		return chalk.hex(this.color).italic(text);
+		return chalk.hex(this.color).italic(filterThinkingNoise(text));
 	}
 	finalize() {
 		if (this.mode === "finalized") return;
@@ -129575,6 +130300,47 @@ function makeDiffStyles(colors) {
 		meta: (s) => chalk.hex(colors.diffMeta)(s)
 	};
 }
+const ANSI_RE = /\u001B\[[0-9;]*m/;
+/** Visualize leading whitespace: tabs as `->`, leading spaces as `·`. */
+function visualizeIndent(line) {
+	let i = 0;
+	let visual = "";
+	while (i < line.length) {
+		const ch = line[i];
+		if (ch === "	") {
+			visual += "->";
+			i++;
+			continue;
+		}
+		if (ch === " ") {
+			visual += "·";
+			i++;
+			continue;
+		}
+		break;
+	}
+	return {
+		text: visual + line.slice(i),
+		indentEnd: visual.length
+	};
+}
+/**
+* Render a diff line's code with leading-whitespace visualization (tabs as
+* `->`, spaces as `·`, dimmed) and optional syntax highlighting. Highlighting
+* runs on the raw code first; indent visualization then runs on the
+* highlighted string - leading whitespace carries no token color, so it is
+* still plain and can be replaced and dimmed without disturbing the tokens.
+* When highlighting is off (streaming) or produced no token colors, the code
+* part is colored with the diff line color instead.
+*/
+function renderDiffCode(code, colorFn, highlight, lang) {
+	const { text, indentEnd } = visualizeIndent(highlight ? highlightLines(code, lang)[0] ?? code : code);
+	const indent = text.slice(0, indentEnd);
+	const rest = text.slice(indentEnd);
+	const dimIndent = indent.length > 0 ? chalk.dim(indent) : indent;
+	if (highlight && ANSI_RE.test(rest)) return dimIndent + rest;
+	return dimIndent + colorFn(rest);
+}
 /**
 * Compute word-level diff between two single lines and highlight the changed
 * words with `chalk.inverse()`. Only the first removed/added part has its
@@ -129681,6 +130447,8 @@ function computeDiffLines(oldText, newText, oldStart = 1, newStart = 1, isIncomp
 }
 function renderDiffLines(oldText, newText, path, colors, isIncomplete = false, oldStart, newStart, maxLines) {
 	const s = makeDiffStyles(colors);
+	const lang = langFromPath(path);
+	const doHighlight = !isIncomplete && lang !== void 0;
 	const changedLines = computeDiffLines(oldText, newText, oldStart ?? 1, newStart ?? 1, isIncomplete).filter((l) => l.kind !== "context");
 	const added = changedLines.filter((l) => l.kind === "add").length;
 	const removed = changedLines.filter((l) => l.kind === "delete").length;
@@ -129705,7 +130473,7 @@ function renderDiffLines(oldText, newText, path, colors, isIncomplete = false, o
 		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));
+		output.push(s.gutter(String(line.lineNum).padStart(4) + " ") + color(`${marker} `) + renderDiffCode(line.code, color, doHighlight, lang));
 		i += 1;
 	}
 	const hidden = changedLines.length - shown.length;
@@ -129756,11 +130524,11 @@ function buildClusters(diffLines, contextLines) {
 		removedCount: removed
 	};
 }
-function formatDiffRow(line, s) {
+function formatDiffRow(line, s, doHighlight, lang) {
 	const gutter = s.gutter(String(line.lineNum).padStart(4) + " ");
-	if (line.kind === "add") return gutter + s.add("+ " + line.code);
-	if (line.kind === "delete") return gutter + s.del("- " + line.code);
-	return gutter + "  " + line.code;
+	if (line.kind === "add") return gutter + s.add("+ ") + renderDiffCode(line.code, s.add, doHighlight, lang);
+	if (line.kind === "delete") return gutter + s.del("- ") + renderDiffCode(line.code, s.del, doHighlight, lang);
+	return gutter + "  " + renderDiffCode(line.code, (x) => x, doHighlight, lang);
 }
 /**
 * Render a diff with surrounding context, eliding unchanged middle
@@ -129773,6 +130541,8 @@ function formatDiffRow(line, s) {
 */
 function renderDiffLinesClustered(oldText, newText, path, colors, opts = {}) {
 	const s = makeDiffStyles(colors);
+	const lang = langFromPath(path);
+	const doHighlight = !(opts.isIncomplete ?? false) && lang !== void 0;
 	const contextLines = opts.contextLines ?? 3;
 	const maxLines = opts.maxLines;
 	const diffLines = computeDiffLines(oldText, newText, 1, 1, opts.isIncomplete ?? false);
@@ -129829,7 +130599,7 @@ function renderDiffLinesClustered(oldText, newText, path, colors, opts = {}) {
 				i += 2;
 				continue;
 			}
-			output.push(formatDiffRow(line, s));
+			output.push(formatDiffRow(line, s, doHighlight, lang));
 			body++;
 			if (line.kind !== "context") shownChanges++;
 			prevEnd = i;
@@ -138266,7 +139036,10 @@ var SessionEventHandler = class {
 			pendingApproval: null,
 			pendingQuestion: null
 		});
-		this.host.setAppState({ streamingPhase: "waiting" });
+		this.host.setAppState({
+			streamingPhase: "waiting",
+			reconnectAttempt: 0
+		});
 	}
 	handleStepCompleted(event) {
 		this.host.streamingUI.flushNow();
@@ -138564,7 +139337,12 @@ var SessionEventHandler = class {
 			goalActive: false
 		});
 		else this.host.setAppState({
-			goal: snapshot.objective,
+			goal: {
+				objective: snapshot.objective,
+				turnsUsed: snapshot.turnsUsed ?? 0,
+				wallClockMs: snapshot.wallClockMs ?? 0,
+				wallClockBaseAt: Date.now()
+			},
 			goalActive: snapshot.status === "active"
 		});
 	}
@@ -142383,9 +143161,10 @@ var FileMentionProvider = class {
 			const name = ac.value ?? ac.name ?? "";
 			const desc = ac.description ?? "";
 			const resolvedDesc = desc ? t(desc) : "";
+			const aliases = cmd.aliases;
 			return {
 				value: name,
-				label: `/${name}${resolvedDesc ? ` — ${resolvedDesc}` : ""}`
+				label: `/${name}${aliases && aliases.length > 0 ? ` (${aliases.join(", ")})` : ""}${resolvedDesc ? ` — ${resolvedDesc}` : ""}`
 			};
 		});
 		this.inner = new CombinedAutocompleteProvider(slashCommands, workDir, fdPath);
@@ -142740,10 +143519,18 @@ var InputController = class InputController {
 		this.host = host;
 	}
 	setupAutocomplete() {
-		const slashCommands = this.host.getSlashCommands().filter((cmd) => !cmd.name.startsWith("skill:")).map((cmd) => cmd);
+		const visible = this.host.getSlashCommands().filter((cmd) => !cmd.name.startsWith("skill:"));
+		const slashCommands = visible.map((cmd) => cmd);
 		const { state } = this.host;
 		const provider = new FileMentionProvider(slashCommands, state.appState.workDir, state.fdPath, state.gitLsFilesCache);
 		state.editor.setAutocompleteProvider(provider);
+		const argumentHints = /* @__PURE__ */ new Map();
+		for (const cmd of visible) {
+			if (cmd.argumentHint === void 0) continue;
+			argumentHints.set(cmd.name, cmd.argumentHint);
+			for (const alias of cmd.aliases) argumentHints.set(alias, cmd.argumentHint);
+		}
+		state.editor.setArgumentHints(argumentHints);
 		state.editor.onFirstInput = () => {
 			this.host.stopWelcomeBreathing();
 			this.#permanentlyStopBreathing();
@@ -144628,7 +145415,12 @@ var SessionManager = class {
 			maxContextTokens: status.maxContextTokens,
 			contextUsage: status.contextUsage,
 			sessionTitle: session.summary?.title ?? null,
-			goal: goal?.objective ?? null,
+			goal: goal ? {
+				objective: goal.objective,
+				turnsUsed: goal.turnsUsed ?? 0,
+				wallClockMs: goal.wallClockMs ?? 0,
+				wallClockBaseAt: Date.now()
+			} : null,
 			goalActive: goal?.status === "active",
 			goalContinuationCount: 0
 		});