@rexvane/piweb 0.3.21 → 0.3.22

package/src/lib/agent-manager.ts

@@ -25,17 +25,18 @@ import {
 	SessionManager,
 	createAgentSession,
 	getModelRuntime,
+	refreshModelRuntime,
 	openSessionManager,
 } from "./pi";
 import { createExtensionUiBridge, type ExtensionUiBridge } from "./extension-ui";
 import { createGrowthTracker, GROWTH_TRACKER_VERSION, type GrowthTracker } from "./growth-tracker";
 import { userTurnsFromEntries } from "./growth-turns";
+import { projectedContextUsage } from "./session/metrics";
 import { TrajLedger, buildTrajectoryFromEntries, toTrajTokens } from "./trajectory";
 import { startArchivedSessionRetention } from "./session-retention";
 import { sanitizeToolOutput } from "./text-sanitize";
 import { BoundaryError } from "./path-security";
-import { estimateTokensOf } from "./process-format";
-import { getPiSettings } from "./pi-settings";
+import { newSessionThinkingLevel } from "./thinking-level";
 import { getGrowthInitConsent, setGrowthInitConsent } from "./workspace-store";
 import { clampThinkingLevel, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import type {
@@ -67,6 +68,8 @@ interface Managed {
 	viewerGraceUntil?: number;
 	/** 本轮已排队推送上下文分项（publishContextBreakdown 合并同一轮的多次触发） */
 	breakdownQueued?: boolean;
+	/** 首次运行后 pi 才会把系统分段持久化，届时用它把分类从差分换成投影口径，只换一次 */
+	breakdownProjected?: boolean;
 	buffer: { seq: number; json: string }[];
 	seq: number;
 	/**
@@ -349,36 +352,58 @@ function reapplyDesiredLevel(m: Managed, session: AgentSession): void {
 	if (target !== session.thinkingLevel) session.setThinkingLevel(target as never);
 }
 
+/**
+ * 新会话页选定模型后的思考档位：与界面显示的生效值同一规则（每模型覆盖 → 设置默认 → medium，再按模型能力钳制）。
+ * SDK 切换模型时会沿用会话原来的档位，新会话不能沿用：那个档位是 SDK 按它自己的初始模型定的。
+ */
+function applyNewSessionThinking(m: Managed, session: AgentSession): void {
+	const model = session.model;
+	if (!model) return;
+	const settings = getSettingsManager(m.cwd);
+	const level = newSessionThinkingLevel({
+		supported: session.getAvailableThinkingLevels() as unknown as string[],
+		modelOverride: settings.getModelThinkingLevel(model.provider, model.id),
+		defaultLevel: settings.getDefaultThinkingLevel(),
+	});
+	if (level !== session.thinkingLevel) session.setThinkingLevel(level as never);
+}
+
 function publishTraj(m: Managed): void {
 	for (const entry of m.ledger.drainDirty()) {
 		publish(m, { type: "traj", entry, ts: Date.now() });
 	}
 }
 
-function timingStats(m: Managed): Pick<WebStats, "llmMs" | "toolMs" | "ttftMs" | "ttftSteps" | "decodeMs" | "decodeTokens"> {
+function timingStats(m: Managed): Pick<WebStats, "llmMs" | "toolMs" | "ttftMs" | "ttftSteps" | "decodeMs" | "decodeTokens" | "llmTimedSteps" | "toolTimedCalls" | "decodeSteps"> {
 	let llmMs = 0;
 	let toolMs = 0;
 	let ttftMs = 0;
 	let ttftSteps = 0;
 	let decodeMs = 0;
 	let decodeTokens = 0;
+	let llmTimedSteps = 0;
+	let toolTimedCalls = 0;
+	let decodeSteps = 0;
 	for (const entry of m.ledger.entries) {
 		if (entry.kind === "tool") {
+			if (entry.timing?.durationMs !== undefined) toolTimedCalls++;
 			toolMs += Math.max(0, entry.timing?.durationMs ?? 0);
 			continue;
 		}
 		if (entry.kind !== "message") continue;
+		if (entry.timing?.durationMs !== undefined) llmTimedSteps++;
 		llmMs += Math.max(0, entry.timing?.durationMs ?? 0);
 		if (entry.timing?.ttftMs !== undefined) {
 			ttftMs += Math.max(0, entry.timing.ttftMs);
 			ttftSteps += 1;
 		}
-		if (entry.timing?.decodeMs !== undefined && entry.tokens?.output !== undefined) {
-			decodeMs += Math.max(0, entry.timing.decodeMs);
+		if ((entry.timing?.decodeMs ?? 0) > 0 && entry.tokens?.output !== undefined) {
+			decodeSteps++;
+			decodeMs += Math.max(0, entry.timing?.decodeMs ?? 0);
 			decodeTokens += Math.max(0, entry.tokens.output);
 		}
 	}
-	return { llmMs, toolMs, ttftMs, ttftSteps, decodeMs, decodeTokens };
+	return { llmMs, toolMs, ttftMs, ttftSteps, decodeMs, decodeTokens, llmTimedSteps, toolTimedCalls, decodeSteps };
 }
 
 function sessionStats(m: Managed): WebStats | null {
@@ -415,7 +440,7 @@ function coldSessionStats(m: Managed): WebStats {
 		cost += Number(usage.cost?.total ?? 0);
 	};
 	for (const entry of m.sm.getEntries() as any[]) {
-		if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) addUsage(entry.usage);
+		if ((entry.type === "usage" || entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) addUsage(entry.usage);
 		if (entry.type !== "message" || !entry.message) continue;
 		totalMessages += 1;
 		const message = entry.message;
@@ -497,7 +522,14 @@ function translate(m: Managed, evt: AgentSessionEvent): void {
 			// the browser receives the durable entry ID without reordering later tool events.
 			deferPublish(m, () => {
 				const msg = projectMessage(m, raw);
-				if (msg.role === "assistant") msg.endedAt = now;
+				if (msg.role === "assistant") {
+					msg.endedAt = now;
+					// 首次回复结束后 pi 已把系统分段写进会话文件，此时分类能读到投影（比 systemPrompt 差分精确）
+					if (!m.breakdownProjected) {
+						m.breakdownProjected = true;
+						publishContextBreakdown(m);
+					}
+				}
 				const usage = usageEvent(m);
 				return usage
 					? [{ type: "message", message: msg, phase: "end", ts: now }, usage]
@@ -597,8 +629,8 @@ function translate(m: Managed, evt: AgentSessionEvent): void {
 			else publish(m, { type: "model", thinkingLevel: (evt as any).level, ts: now });
 			break;
 		case "auto_retry_start":
-			// 重试是流程内通知：发一条结构化 retry 事件（界面聚合成「重试 n/max」一行），
-			// 不再走 error 通道，免得每次尝试都多出一条报错。
+			// 重试是流程内通知:发一条结构化 retry 事件(界面聚合成「重试 n/max」一行),
+			// 不再走 error 通道,免得每次尝试都多出一条报错。
 			publish(m, {
 				type: "retry",
 				attempt: Number((evt as any).attempt) || 0,
@@ -607,6 +639,13 @@ function translate(m: Managed, evt: AgentSessionEvent): void {
 				ts: now,
 			});
 			break;
+		case "auto_retry_end":
+			// 重试收尾:SDK 成功/最终失败/被中止都会发这条,而重试成功后的这轮对话
+			// agent_settled 之前界面上还留着「重试 1/5 terminated」那一行(用户看到的
+			// 就是「已经恢复了还显示错误」)。这里显式发一条清除事件,重试区间一结束
+			// 就收掉这行;真失败时紧随其后的 assistant error 消息会照常出错误块。
+			publish(m, { type: "retry_end", attempt: Number((evt as any).attempt) || 0, ts: now });
+			break;
 		default:
 			break;
 	}
@@ -742,13 +781,9 @@ const SKILLS_SECTION_START = "The following skills provide specialized instructi
 const SKILLS_SECTION_END = "</available_skills>";
 
 /**
- * 上下文占用的服务端估算分项。systemPrompt 是整段拼接（正文 + memory + skills + 工具列表），
- * 所以 Memory / Skills 从资源加载器与 systemPrompt 的资源段差分得出：
- * SDK 的拼接顺序固定为 正文 → context files → skills → 工具列表，按内容定位切块。
- *
- * 冷会话（只浏览历史、不冷启动 agent）拿不到组装后的 system prompt 和工具定义，这三项为 0、标 cold；
- * Memory / Skills / Compacted / Buffer 不依赖 agent，照常从发现缓存、会话文件和设置里算，
- * 不能因为没启动就整块归零（那样弹窗只剩消息几类）。
+ * 当前上下文的字符分类，优先读 SDK 投影中的系统分段、工具 schema 与摘要。
+ * 旧客户端仍可读取字符/4 的估算字段；新客户端仅将字符数作为分类数据。
+ * 没有持久化系统消息且尚未启动的会话，资源来自发现缓存并标记 cold。
  */
 async function buildContextBreakdown(m: Managed, resources: ContextResource[]): Promise<ContextBreakdown> {
 	const session = m.session;
@@ -758,64 +793,56 @@ async function buildContextBreakdown(m: Managed, resources: ContextResource[]):
 	};
 	// Memory：AGENTS.md 等注入文件（contextResources 的 project 部分）
 	const memoryText = resources.filter((r) => r.source === "project").map((r) => r.content).join("\n\n");
-	breakdown.memory = estimateTokensOf(memoryText);
-	if (session) {
-		try {
-			const prompt = session.systemPrompt ?? "";
-			// Skills：按 SDK 的 formatSkillsForPrompt 段落定位。该段落没有 Markdown 标题（以
-			// "The following skills provide specialized instructions…" 开头、</available_skills> 结尾），
-			// 以前按 "## Skills" 找永远找不到，技能段一直是 0。
-			try {
-				if (session.resourceLoader.getSkills().skills.length && prompt) {
-					const start = prompt.indexOf(SKILLS_SECTION_START);
-					const end = prompt.indexOf(SKILLS_SECTION_END);
-					if (start >= 0 && end > start) breakdown.skills = estimateTokensOf(prompt.slice(start, end + SKILLS_SECTION_END.length));
-				}
-			} catch {
-				/* loader 不可用则跳过 */
+	// 字符分项只读取当前投影中的内容。历史压缩摘要、未激活工具不混入当前统计。
+	const characters = { systemPrompt: 0, systemTools: 0, customTools: 0, memory: 0, skills: 0, compacted: 0 };
+	try {
+		const messages = m.sm.buildSessionProjection().messages as any[];
+		const system = messages.findLast((message) => message.role === "system");
+		if (system) {
+			const contentChars = typeof system.content === "string" ? system.content.length : textOf(system.content).length;
+			characters.memory = system.sections?.project_context?.length ?? 0;
+			characters.skills = system.sections?.skills?.length ?? 0;
+			characters.systemPrompt = contentChars + Object.entries(system.sections ?? {})
+				.filter(([key]) => key !== "project_context" && key !== "skills")
+				.reduce((sum, [, value]) => sum + (typeof value === "string" ? value.length : 0), 0);
+			const builtinNames = new Set(session
+				? session.getAllTools().filter((tool: any) => tool.sourceInfo?.source === "builtin").map((tool) => tool.name)
+				: ["read", "bash", "edit", "write", "grep", "find", "ls"]);
+			for (const tool of system.toolsAdded ?? []) {
+				characters[builtinNames.has(tool.name) ? "systemTools" : "customTools"] += JSON.stringify(tool).length;
 			}
-			// System Prompt 正文 = 全文减去资源段与 skills 段的近似差分，下限 0
-			breakdown.systemPrompt = Math.max(0, estimateTokensOf(prompt) - breakdown.memory - breakdown.skills);
-			// 工具：builtin 与扩展注册的分开统计（schema + description + guidelines 序列化估算）
-			for (const tool of session.getAllTools()) {
-				const size = estimateTokensOf(JSON.stringify({
-					name: tool.name,
-					description: tool.description,
-					parameters: tool.parameters,
-					promptGuidelines: tool.promptGuidelines,
-				}));
-				if ((tool as { sourceInfo?: { source?: string } }).sourceInfo?.source === "builtin") breakdown.systemTools += size;
-				else breakdown.customTools += size;
+			delete breakdown.cold;
+		} else if (session) {
+			const prompt = session.systemPrompt ?? "";
+			characters.memory = memoryText.length;
+			const start = prompt.indexOf(SKILLS_SECTION_START);
+			const end = prompt.indexOf(SKILLS_SECTION_END);
+			characters.skills = start >= 0 && end > start ? prompt.slice(start, end + SKILLS_SECTION_END.length).length : 0;
+			characters.systemPrompt = Math.max(0, prompt.length - characters.memory - characters.skills);
+			const active = new Set(session.getActiveToolNames());
+			for (const tool of session.getAllTools().filter((tool) => active.has(tool.name))) {
+				const size = JSON.stringify({ name: tool.name, description: tool.description, parameters: tool.parameters }).length;
+				characters[(tool as any).sourceInfo?.source === "builtin" ? "systemTools" : "customTools"] += size;
 			}
-		} catch {
-			/* systemPrompt / getAllTools 不可用则保持 0 */
-		}
-	} else {
-		// 冷会话：技能段用发现缓存里的清单按 SDK 同一个格式化函数估算（启动后改用实际 prompt 里的那段）
-		try {
+		} else {
+			// 初次启动前只能读到待注入的资源，界面保留 cold 提示。
+			characters.memory = memoryText.length;
 			const loader = peekResourceLoader(m.cwd) ?? getResourceLoader(m.cwd);
-			breakdown.skills = estimateTokensOf(formatSkillsForPrompt(loader.getSkills().skills).trim());
-		} catch {
-			/* 发现缓存还没好则跳过 */
+			characters.skills = formatSkillsForPrompt(loader.getSkills().skills).trim().length;
 		}
-	}
-	// 最新一次压缩的摘要（会话文件里就有，冷热都能算）
-	try {
-		const entries = m.sm.getEntries() as unknown as { type?: string; summary?: string }[];
-		for (let i = entries.length - 1; i >= 0; i -= 1) {
-			const entry = entries[i];
-			if (entry?.type === "compaction" && typeof entry.summary === "string") {
-				breakdown.compacted = estimateTokensOf(entry.summary);
-				break;
-			}
+		for (const message of messages) {
+			if (message.role === "compactionSummary" || message.role === "branchSummary") characters.compacted += message.summary?.length ?? 0;
 		}
+		breakdown.characters = characters;
+		// 保留旧客户端的估算字段，当前客户端直接展示实际字符数。
+		for (const key of Object.keys(characters) as Array<keyof typeof characters>) breakdown[key] = Math.ceil(characters[key] / 4);
 	} catch {
-		/* entries 不可用则跳过 */
+		/* 投影不可用时不给字符分项，不能从旧 token 估算反推字符数。 */
 	}
-	// auto-compact 预留 = compaction.reserveTokens（启用时）
+	// auto-compact 预留读本工作区、当前模型实际使用的设置。
 	try {
-		const settings = await getPiSettings();
-		if (settings.compaction.enabled) breakdown.autoCompactBuffer = settings.compaction.reserveTokens;
+		const compaction = getSettingsManager(m.cwd).getCompactionSettings(session?.model);
+		if (compaction.enabled) breakdown.autoCompactBuffer = compaction.reserveTokens;
 	} catch {
 		/* 设置读取失败则保持 0 */
 	}
@@ -1208,11 +1235,7 @@ async function reloadManagedResources(m: Managed): Promise<boolean> {
 	m.resourceReloadPending = false;
 	try {
 		await m.session.reload();
-		// SDK 的 reload 不会换当前模型对象：models.json 改了 baseUrl / contextWindow 后，
-		// 会话手里还是旧对象。按 provider/id 从（已就地刷新的）共享 runtime 取一次新的。
-		const current = m.session.model;
-		const fresh = current && m.session.modelRuntime.getModel(current.provider, current.id);
-		if (fresh && fresh !== current) m.session.agent.state.model = fresh;
+		swapCurrentModelObject(m.session);
 		return true;
 	} catch (err) {
 		publish(m, { type: "error", message: `重载扩展失败：${String((err as Error)?.message ?? err)}`, ts: Date.now() });
@@ -1222,6 +1245,32 @@ async function reloadManagedResources(m: Managed): Promise<boolean> {
 	}
 }
 
+/**
+ * SDK 的 reload 不会换当前模型对象：models.json 改了 baseUrl / contextWindow 后，会话手里还是旧对象。
+ * 按 provider/id 从（已就地刷新的）共享 runtime 取一次新的。
+ */
+function swapCurrentModelObject(session: AgentSession): void {
+	const current = session.model;
+	const fresh = current && session.modelRuntime.getModel(current.provider, current.id);
+	if (fresh && fresh !== current) session.agent.state.model = fresh;
+}
+
+/**
+ * 共享目录刷新后，给正在用这个模型的会话换上新模型对象（上下文窗口等字段跟着变），再推一次用量让圆环当场更新。
+ * 运行中的会话也换：SDK 在扩展注册 provider 时同样会中途替换 agent.state.model，已发出的请求不受影响。
+ */
+export function refreshSessionModels(provider: string, id: string): number {
+	let n = 0;
+	for (const m of sessions.values()) {
+		const current = m.session?.model;
+		if (!m.session || current?.provider !== provider || current.id !== id) continue;
+		swapCurrentModelObject(m.session);
+		publishUsage(m);
+		n += 1;
+	}
+	return n;
+}
+
 export async function reloadSessionsForCwd(cwd?: string): Promise<number> {
 	const key = (p: string) => (process.platform === "win32" ? p.replace(/\\/g, "/").toLowerCase() : p.replace(/\\/g, "/"));
 	let n = 0;
@@ -1325,42 +1374,13 @@ export async function buildSnapshot(m: Managed): Promise<WebSnapshot> {
 		const usage = session.getContextUsage() ?? null;
 		contextUsage = usage ? { tokens: usage.tokens, contextWindow: usage.contextWindow, percent: usage.percent } : null;
 	} else if (model) {
-		// 冷会话没有 SDK 实例：用最后一轮 assistant 用量（input+cache+output ≈ 该轮后的
-		// 上下文规模）除以模型窗口估算，避免上下文计量永远显示 0% / —
+		// 冷会话也使用当前分支投影，包含最后一次 API 用量之后的用户消息和工具输出。
 		try {
 			const rt = await getModelRuntime();
 			const modelMeta = (rt.getModels(model.provider) as any[]).find((x) => String(x.id) === model.id);
-			const window = Number(modelMeta?.contextWindow ?? 0);
-			let lastTurnTokens = 0;
-			// 与 SDK getContextUsage 同一条规则：最近一次压缩之后还没有新的助手回复时，上下文大小未知（不能拿压缩前的用量充数）
-			const entries = m.sm.getEntries() as Array<{ type?: string; message?: { role?: string; stopReason?: string } }>;
-			let compactedSinceLastAssistant = false;
-			for (let i = entries.length - 1; i >= 0; i--) {
-				const e = entries[i];
-				if (e.type === "compaction" || e.type === "branch_summary") {
-					compactedSinceLastAssistant = true;
-					break;
-				}
-				if (e.type === "message" && e.message?.role === "assistant" && e.message.stopReason !== "error" && e.message.stopReason !== "aborted") break;
-			}
-			for (let i = messages.length - 1; i >= 0 && !compactedSinceLastAssistant; i--) {
-				const msg = messages[i];
-				if (msg.role === "assistant" && msg.usage) {
-					lastTurnTokens =
-						Number(msg.usage.input ?? 0) +
-						Number(msg.usage.cacheRead ?? 0) +
-						Number(msg.usage.cacheWrite ?? 0) +
-						Number(msg.usage.output ?? 0);
-					break;
-				}
-			}
-			if (window > 0 && lastTurnTokens > 0) {
-				contextUsage = { tokens: lastTurnTokens, contextWindow: window, percent: (lastTurnTokens / window) * 100 };
-			} else if (window > 0) {
-				contextUsage = { tokens: null, contextWindow: window, percent: null };
-			}
+			contextUsage = projectedContextUsage(m.sm.buildSessionProjection(), m.sm.getBranch(), Number(modelMeta?.contextWindow ?? 0));
 		} catch {
-			/* 模型目录不可用则维持 null（UI 显示 0%） */
+			/* 模型或投影不可用时用量未知。 */
 		}
 	}
 
@@ -1600,6 +1620,8 @@ export async function execute(m: Managed, cmd: AgentCommand): Promise<CommandRes
 				if (!model) return { ok: false, error: `unknown model ${cmd.provider}/${cmd.modelId}` };
 				await session.setModel(model, { persist: false });
 				reapplyDesiredLevel(m, session);
+				// 新会话页选的模型（fresh）：思考档位按新会话的规则定；之后显式选的档位仍会覆盖
+				if (cmd.fresh === true && !m.desiredThinkingLevel) applyNewSessionThinking(m, session);
 				publishModelState(m, session);
 				return { ok: true, data: { thinkingLevel: session.thinkingLevel, thinkingLevels: session.getAvailableThinkingLevels() } };
 			}
@@ -1712,8 +1734,17 @@ export async function execute(m: Managed, cmd: AgentCommand): Promise<CommandRes
 			}
 			case "reload": {
 				if (isManagedBusy(m)) return { ok: false, error: "session is busy" };
+				// /reload：先就地刷新共享的模型目录（models.json / auth.json 可能是手改的）；其它会话手里的
+				// 模型对象跟着换新，忙着的等本轮结束再换；本会话重载资源后再换一次
+				await refreshModelRuntime();
+				for (const other of sessions.values()) {
+					if (other === m || !other.session) continue;
+					if (isManagedBusy(other)) other.resourceReloadPending = true;
+					else swapCurrentModelObject(other.session);
+				}
 				const session = await ensureSession(m);
 				await session.reload();
+				swapCurrentModelObject(session);
 				return { ok: true };
 			}
 			case "fork": {

package/src/lib/files-service.ts

@@ -2,13 +2,17 @@
  * files-service：会话工作区的文件浏览（详情栏「文件」面板）。
  * 安全边界：目标路径必须落在工作区根内（realpath 双重校验，防符号链接逃逸）。
  */
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { promisify } from "node:util";
 import { BoundaryError, isPathInside, resolveWorkspacePath } from "./path-security";
 import { getAgentDir } from "./pi";
+import { resolveGitBin } from "./growth-service";
 import { utf8Prefix } from "./text-sanitize";
 
+const exec = promisify(execFile);
+
 export interface FileEntry {
 	name: string;
 	kind: "dir" | "file";
@@ -29,6 +33,101 @@ const MAX_READ_BYTES = 256 * 1024;
 /** 单次目录响应上限；后续条目通过 offset 分页获取。 */
 const MAX_ENTRIES = 2000;
 
+/**
+ * @ 引用的候选索引上限。一次拉给浏览器做本地模糊匹配，所以是一份完整清单：
+ * 每敲一个字符不再发请求（实测本仓库 700 余条 ≈ 30 KB）。
+ * 超大仓库截断到上限并在界面标出，不静默少候选。
+ */
+const INDEX_LIMIT = 20_000;
+/** 非 git 工作区的退路：只跳过这些明显不该当候选的重目录，其余照常列举 */
+const INDEX_SKIP_DIRS = new Set([".git", "node_modules", ".next", ".next-dev", ".venv", "venv", "__pycache__", "dist", "build", "out", "target", ".turbo", ".cache"]);
+const INDEX_MAX_DEPTH = 12;
+
+export interface WorkspaceIndex {
+	/** 工作区根下的相对路径（"/" 分隔）。只给文件：文件夹由前端从文件路径推导 */
+	files: string[];
+	/** git = `git ls-files`（尊重 .gitignore）；disk = 不是仓库时的目录遍历退路 */
+	source: "git" | "disk";
+	/** 候选被上限截断：匹配结果可能不全，界面要说明 */
+	truncated: boolean;
+}
+
+/** `git ls-files -z` 输出 → 相对路径数组（去重） */
+export function parseLsFiles(raw: string): string[] {
+	const seen = new Set<string>();
+	for (const entry of raw.split("\0")) {
+		if (!entry) continue;
+		const rel = entry.replace(/\\/g, "/");
+		if (rel.startsWith("/") || rel.split("/").includes("..")) continue;
+		seen.add(rel);
+	}
+	return [...seen];
+}
+
+/** 不是仓库（或机器上没有 git）时的退路：广度优先遍历，只收文件 */
+async function walkWorkspaceFiles(root: string): Promise<{ files: string[]; truncated: boolean }> {
+	const files: string[] = [];
+	let queue: Array<{ rel: string; depth: number }> = [{ rel: "", depth: 0 }];
+	while (queue.length) {
+		const next: typeof queue = [];
+		for (const dir of queue) {
+			const entries = await fs.readdir(path.join(root, dir.rel), { withFileTypes: true }).catch(() => []);
+			for (const entry of entries) {
+				const rel = dir.rel ? `${dir.rel}/${entry.name}` : entry.name;
+				if (entry.isDirectory()) {
+					if (dir.depth + 1 <= INDEX_MAX_DEPTH && !INDEX_SKIP_DIRS.has(entry.name)) next.push({ rel, depth: dir.depth + 1 });
+				} else if (entry.isFile()) {
+					files.push(rel);
+					if (files.length > INDEX_LIMIT) return { files: files.slice(0, INDEX_LIMIT), truncated: true };
+				}
+			}
+		}
+		queue = next;
+	}
+	return { files, truncated: false };
+}
+
+/**
+ * git 失败时只有「不是仓库」「没装 git」两种该退回遍历——界面会把 disk 来源解释成这两种情况。
+ * 其它失败（safe.directory 拒绝、索引损坏、超时）照实报错：退回遍历会把 .gitignore 掉的文件混进候选，还给出错误的解释。
+ */
+function gitIndexFailure(error: unknown): "fallback" | Error {
+	const e = error as NodeJS.ErrnoException & { stderr?: string; killed?: boolean };
+	if (e.code === "ENOENT") return "fallback";
+	const stderr = String(e.stderr ?? "");
+	if (/not a git repository/i.test(stderr)) return "fallback";
+	if (e.killed) return new Error("git ls-files timed out");
+	const fatal = stderr.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	return new Error(`git ls-files failed: ${fatal.find((line) => line.startsWith("fatal:")) ?? fatal[0] ?? e.message}`);
+}
+
+/**
+ * @ 引用的候选清单：git 可见的文件（含未被忽略的未跟踪文件）。
+ * `git ls-files` 的路径相对当前目录，所以 cwd 就是工作区根，输出天然是工作区相对路径。
+ */
+export async function listWorkspaceIndex(cwdValue: unknown): Promise<WorkspaceIndex> {
+	const root = await resolveWorkspacePath(cwdValue);
+	const git = await resolveGitBin();
+	try {
+		const { stdout } = await exec(git, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+			cwd: root,
+			timeout: 15_000,
+			maxBuffer: 64 * 1024 * 1024,
+			windowsHide: true,
+			// LC_ALL=C：报错固定为英文，「不是仓库」才认得出来（中文界面的 git 会翻译这句）；-z 输出的路径不受影响
+			env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" },
+		});
+		const files = parseLsFiles(stdout).sort((a, b) => a.localeCompare(b));
+		return { files: files.slice(0, INDEX_LIMIT), source: "git", truncated: files.length > INDEX_LIMIT };
+	} catch (error) {
+		const failure = gitIndexFailure(error);
+		if (failure !== "fallback") throw failure;
+		const walked = await walkWorkspaceFiles(root);
+		return { files: walked.files.sort((a, b) => a.localeCompare(b)), source: "disk", truncated: walked.truncated };
+	}
+}
+
+
 function toRel(root: string, target: string): string {
 	const rel = path.relative(root, target).replace(/\\/g, "/");
 	return rel === "" ? "." : rel;

package/src/lib/format.ts

@@ -0,0 +1,56 @@
+/**
+ * 全站数字显示格式。
+ *
+ * 精度口径（用户要求「精确到小数点后两位」）：
+ * - 比率（缓存命中 / 上下文占用）、速率（tok/s）、秒级时长：一律两位小数；
+ * - token 量：≥1000 用 K、≥100 万用 M，都两位小数；<1000 原样整数（计数没有小数含义）；
+ * - 轮次 / 步数 / 文件数等计数：整数；
+ * - 分钟级时长保持 `19m30s`（`19m30.42s` 更难读）、金额保持四位（`$0.0123` 是惯例）。
+ *
+ * 以前 ChatWindow / ContextMeter / TrajectoryView 各有一份 fmtTok，同一个数字在三处
+ * 显示不同（262400 → `262K` / `262.4K` / `262.4K`；53000000 → `53M` / `53000.0K` / `53.0M`），
+ * 统一到这里。
+ */
+
+/** token 量：K / M 两位小数，<1000 整数 */
+export function fmtTokens(value: number): string {
+	if (!Number.isFinite(value)) return "—";
+	if (Math.abs(value) < 1_000) return String(Math.round(value));
+	// 先按 K 缩放；四舍五入到两位小数后已到 1000.00K 就升级成 M，避免出现「1000.00K」
+	const k = value / 1_000;
+	if (Math.abs(Number(k.toFixed(2))) < 1_000) return `${k.toFixed(2)}K`;
+	return `${(value / 1_000_000).toFixed(2)}M`;
+}
+
+/** 计数（轮次 / 步数 / 文件数）：整数 */
+export function fmtCount(value: number): string {
+	return Number.isFinite(value) ? String(Math.round(value)) : "—";
+}
+
+/** 百分比：入参是 0–100 的数值，输出两位小数 */
+export function fmtPercent(percent: number): string {
+	return `${(Number.isFinite(percent) ? percent : 0).toFixed(2)}%`;
+}
+
+/** 速率：tok/s，两位小数 */
+export function fmtThroughput(tokensPerSecond: number): string {
+	return (Number.isFinite(tokensPerSecond) ? tokensPerSecond : 0).toFixed(2);
+}
+
+/**
+ * 时长：不足 60 秒两位小数（`5.32s`），到分钟级用 `19m30s`（秒级再补小数只会更难读）。
+ */
+export function fmtDuration(ms: number): string {
+	const seconds = Math.max(0, Number.isFinite(ms) ? ms : 0) / 1_000;
+	if (seconds < 60) return `${seconds.toFixed(2)}s`;
+	const whole = Math.round(seconds);
+	return `${Math.floor(whole / 60)}m${whole % 60}s`;
+}
+
+/** 文件大小：B 整数，KB / MB 两位小数 */
+export function fmtBytes(bytes: number): string {
+	if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+	if (bytes < 1_024) return `${Math.round(bytes)} B`;
+	if (bytes < 1_024 * 1_024) return `${(bytes / 1_024).toFixed(2)} KB`;
+	return `${(bytes / 1_024 / 1_024).toFixed(2)} MB`;
+}