@rexvane/piweb 0.3.20 → 0.3.22

package/src/lib/agent-manager.ts

@@ -6,7 +6,7 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import type { AgentSession, AgentSessionEvent } from "@earendil-works/pi-coding-agent";
-import { generateUnifiedPatch } from "@earendil-works/pi-coding-agent";
+import { formatSkillsForPrompt, generateUnifiedPatch } from "@earendil-works/pi-coding-agent";
 import {
 	getResourceLoader,
 	createSessionResourceLoader,
@@ -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 {
@@ -63,6 +64,12 @@ interface Managed {
 	session: AgentSession | null;
 	creating: Promise<AgentSession> | null;
 	subscribers: Set<(seq: number, json: string) => void>;
+	/** 长轮询的浏览器在两次请求之间没有订阅，到这个时间点之前仍算有人在看（见 holdViewer） */
+	viewerGraceUntil?: number;
+	/** 本轮已排队推送上下文分项（publishContextBreakdown 合并同一轮的多次触发） */
+	breakdownQueued?: boolean;
+	/** 首次运行后 pi 才会把系统分段持久化，届时用它把分类从差分换成投影口径，只换一次 */
+	breakdownProjected?: boolean;
 	buffer: { seq: number; json: string }[];
 	seq: number;
 	/**
@@ -345,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 {
@@ -411,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;
@@ -493,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]
@@ -579,6 +615,7 @@ function translate(m: Managed, evt: AgentSessionEvent): void {
 				ts: now,
 			});
 			publishUsage(m);
+			publishContextBreakdown(m);
 			if ((evt as any).reason === "manual") {
 				publish(m, { type: "status", isStreaming: isManagedBusy(m), state: isManagedBusy(m) ? "running" : "idle", ts: now });
 				if (m.resourceReloadPending) queueMicrotask(() => void reloadManagedResources(m));
@@ -592,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,
@@ -602,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;
 	}
@@ -733,87 +777,99 @@ function loadContextResources(cwd: string, loader: AgentSession["resourceLoader"
 	];
 }
 
+const SKILLS_SECTION_START = "The following skills provide specialized instructions";
+const SKILLS_SECTION_END = "</available_skills>";
+
 /**
- * 上下文占用的服务端估算分项。systemPrompt 是整段拼接（正文 + memory + skills + 工具列表），
- * 所以 Memory / Skills 从资源加载器与 systemPrompt 的资源段差分得出：
- * SDK 的拼接顺序固定为 正文 → context files → skills → 工具列表，按内容定位切块。
+ * 当前上下文的字符分类，优先读 SDK 投影中的系统分段、工具 schema 与摘要。
+ * 旧客户端仍可读取字符/4 的估算字段；新客户端仅将字符数作为分类数据。
+ * 没有持久化系统消息且尚未启动的会话，资源来自发现缓存并标记 cold。
  */
-async function buildContextBreakdown(
-	cwd: string,
-	session: AgentSession | null,
-	resources: ContextResource[],
-): Promise<ContextBreakdown> {
+async function buildContextBreakdown(m: Managed, resources: ContextResource[]): Promise<ContextBreakdown> {
+	const session = m.session;
 	const breakdown: ContextBreakdown = {
 		systemPrompt: 0, systemTools: 0, customTools: 0, memory: 0, skills: 0, compacted: 0, autoCompactBuffer: 0,
+		...(session ? {} : { cold: true }),
 	};
-	if (!session) return breakdown;
+	// Memory：AGENTS.md 等注入文件（contextResources 的 project 部分）
+	const memoryText = resources.filter((r) => r.source === "project").map((r) => r.content).join("\n\n");
+	// 字符分项只读取当前投影中的内容。历史压缩摘要、未激活工具不混入当前统计。
+	const characters = { systemPrompt: 0, systemTools: 0, customTools: 0, memory: 0, skills: 0, compacted: 0 };
 	try {
-		const prompt = session.systemPrompt ?? "";
-		// Memory：AGENTS.md 等注入文件（contextResources 的 project 部分）
-		const memoryText = resources.filter((r) => r.source === "project").map((r) => r.content).join("\n\n");
-		breakdown.memory = estimateTokensOf(memoryText);
-		// Skills：从资源加载器取技能清单，按 SDK 的 formatSkillsForPrompt 段落定位。
-		// 该段落没有 Markdown 标题（原文以 "The following skills provide specialized instructions…" 开头，
-		// 结尾是 </available_skills>），以前按 "## Skills" 找永远找不到，技能段一直是 0。
-		try {
-			const { skills } = session.resourceLoader.getSkills();
-			if (skills.length && prompt) {
-				const start = prompt.indexOf("The following skills provide specialized instructions");
-				const end = prompt.indexOf("</available_skills>");
-				if (start >= 0 && end > start) breakdown.skills = estimateTokensOf(prompt.slice(start, end + "</available_skills>".length));
+		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;
 			}
-		} catch {
-			/* loader 不可用则跳过 */
-		}
-		// System Prompt 正文 = 全文减去资源段与 skills 段的近似差分，下限 0
-		const estimatedSections = breakdown.memory + breakdown.skills;
-		breakdown.systemPrompt = Math.max(0, estimateTokensOf(prompt) - estimatedSections);
-		// 工具：builtin 与扩展注册的分开统计（schema + description + guidelines 序列化估算）
-		try {
-			const tools = session.getAllTools();
-			for (const tool of tools) {
-				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 {
-			/* getAllTools 不可用则跳过 */
-		}
-		// 最新一次压缩的摘要
-		try {
-			const entries = m_smEntries(session);
-			for (let i = entries.length - 1; i >= 0; i -= 1) {
-				const entry = entries[i] as { type?: string; summary?: string };
-				if (entry?.type === "compaction" && typeof entry.summary === "string") {
-					breakdown.compacted = estimateTokensOf(entry.summary);
-					break;
-				}
-			}
-		} catch {
-			/* entries 不可用则跳过 */
+		} else {
+			// 初次启动前只能读到待注入的资源，界面保留 cold 提示。
+			characters.memory = memoryText.length;
+			const loader = peekResourceLoader(m.cwd) ?? getResourceLoader(m.cwd);
+			characters.skills = formatSkillsForPrompt(loader.getSkills().skills).trim().length;
 		}
-		// auto-compact 预留 = compaction.reserveTokens（启用时）
-		try {
-			const settings = await getPiSettings();
-			if (settings.compaction.enabled) breakdown.autoCompactBuffer = settings.compaction.reserveTokens;
-		} catch {
-			/* 设置读取失败则保持 0 */
+		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 {
-		/* systemPrompt 不可用则保持 0 */
+		/* 投影不可用时不给字符分项，不能从旧 token 估算反推字符数。 */
+	}
+	// auto-compact 预留读本工作区、当前模型实际使用的设置。
+	try {
+		const compaction = getSettingsManager(m.cwd).getCompactionSettings(session?.model);
+		if (compaction.enabled) breakdown.autoCompactBuffer = compaction.reserveTokens;
+	} catch {
+		/* 设置读取失败则保持 0 */
 	}
 	return breakdown;
 }
 
-/** SessionManager 的 getEntries 经由 session 暴露的形态（各版本字段名有差异，这里宽松取） */
-function m_smEntries(session: AgentSession): unknown[] {
-	const s = session as unknown as { sm?: { getEntries?: () => unknown[] }; sessionManager?: { getEntries?: () => unknown[] } };
-	return s.sm?.getEntries?.() ?? s.sessionManager?.getEntries?.() ?? [];
+/**
+ * 分项变了就推一次（会话启动、工具 / 资源重载、压缩之后）。分项以前只随快照下发：
+ * 打开冷会话时是 0，之后会话启动了弹窗也一直停在那份 0 上，直到刷新页面。
+ * 同一轮里多次触发（启动时 publishTools + publishResources）合并成一次。
+ */
+function publishContextBreakdown(m: Managed): void {
+	if (m.breakdownQueued || m.disposed) return;
+	m.breakdownQueued = true;
+	queueMicrotask(() => {
+		m.breakdownQueued = false;
+		if (m.disposed) return;
+		let resources: ContextResource[] = [];
+		try {
+			resources = loadContextResources(m.cwd, m.session?.resourceLoader);
+		} catch {
+			/* 读不到注入文件就按空算 Memory */
+		}
+		void buildContextBreakdown(m, resources).then((breakdown) => {
+			if (!m.disposed) publish(m, { type: "context_breakdown", breakdown, ts: Date.now() });
+		}, () => undefined);
+	});
 }
 
 /** resources 已经算过（快照）就传进来，免得资源发现结果再读一遍 */
@@ -877,7 +933,7 @@ export async function ensureSession(m: Managed): Promise<AgentSession> {
 			installSessionPolicy(m, session);
 			applyToolPolicy(m, session);
 			session.subscribe((evt) => { if (!m.disposed) translate(m, evt); });
-			const ui = createExtensionUiBridge({ publish: (evt) => publish(m, evt), hasViewers: () => !m.disposed && m.subscribers.size > 0 });
+			const ui = createExtensionUiBridge({ publish: (evt) => publish(m, evt), hasViewers: () => !m.disposed && hasViewers(m) });
 			m.ui = ui;
 			await session.bindExtensions({
 				mode: "rpc",
@@ -989,6 +1045,7 @@ function shutdownSession(session: AgentSession): Promise<void> {
 
 function publishTools(m: Managed, session: AgentSession): void {
 	publish(m, { type: "tools", active: listActiveTools(session), all: listAllToolNames(session), toolPreset: m.toolPreset, customActiveTools: m.customActiveTools ?? null, ts: Date.now() });
+	publishContextBreakdown(m);
 }
 
 /** SDK reload 自动启用扩展工具，注册新工具也会刷新全集；统一在激活边界收敛到服务端选择。 */
@@ -1086,13 +1143,13 @@ export async function disposeSessionPath(sessionPath: string): Promise<void> {
 export function reap(): void {
 	const now = Date.now();
 	for (const m of [...sessions.values()]) {
-		if (m.subscribers.size > 0 || now - m.lastActive <= IDLE_MS) continue;
+		if (hasViewers(m) || now - m.lastActive <= IDLE_MS) continue;
 		if (!m.creating && !isManagedBusy(m)) disposeSession(m);
 	}
 	const active = [...sessions.values()].filter((m) => m.session);
 	if (active.length > MAX_ACTIVE) {
 		const evictable = active
-			.filter((m) => !m.creating && !isManagedBusy(m) && m.subscribers.size === 0)
+			.filter((m) => !m.creating && !isManagedBusy(m) && !hasViewers(m))
 			.sort((a, b) => a.lastActive - b.lastActive);
 		for (const m of evictable.slice(0, active.length - MAX_ACTIVE)) disposeSession(m);
 	}
@@ -1166,6 +1223,7 @@ function collectResources(m: Managed): ResourceBundle {
 
 export function publishResources(m: Managed): void {
 	publish(m, { type: "resources", ...collectResources(m), ts: Date.now() });
+	publishContextBreakdown(m);
 }
 
 /**
@@ -1177,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() });
@@ -1191,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;
@@ -1198,7 +1278,7 @@ export async function reloadSessionsForCwd(cwd?: string): Promise<number> {
 		if (cwd && key(m.cwd) !== key(cwd)) continue;
 		if (!m.session) {
 			// 冷会话没有扩展运行时可重建，但页面可能开着：把新清单（模板 / 技能 / 信任）推过去
-			if (m.subscribers.size > 0) publishResources(m);
+			if (hasViewers(m)) publishResources(m);
 			continue;
 		}
 		if (m.creating || isManagedBusy(m)) {
@@ -1294,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%） */
+			/* 模型或投影不可用时用量未知。 */
 		}
 	}
 
@@ -1359,7 +1410,7 @@ export async function buildSnapshot(m: Managed): Promise<WebSnapshot> {
 	// 服务端可得的上下文分项（估算；失败不影响快照）
 	let contextBreakdown: ContextBreakdown | undefined;
 	try {
-		contextBreakdown = await buildContextBreakdown(m.cwd, m.session, contextResources);
+		contextBreakdown = await buildContextBreakdown(m, contextResources);
 	} catch {
 		contextBreakdown = undefined;
 	}
@@ -1446,6 +1497,18 @@ export function unsubscribe(m: Managed, send: (seq: number, json: string) => voi
 	m.subscribers.delete(send);
 }
 
+/**
+ * 长轮询（快速隧道）的一次请求结束时调用：下一次请求到来前的这段空档仍算有人在看，
+ * 否则扩展弹窗会被当成无人值守直接取默认值，会话也可能被当成没人开着回收掉。
+ */
+export function holdViewer(m: Managed, ms: number): void {
+	m.viewerGraceUntil = Math.max(m.viewerGraceUntil ?? 0, Date.now() + ms);
+}
+
+function hasViewers(m: Managed): boolean {
+	return m.subscribers.size > 0 || (m.viewerGraceUntil ?? 0) > Date.now();
+}
+
 // ---------- 命令执行 ----------
 
 export interface CommandResult {
@@ -1557,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() } };
 			}
@@ -1669,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/chat/event-stream.ts

@@ -0,0 +1,113 @@
+/**
+ * 会话事件的长轮询通道（浏览器端）。
+ *
+ * Cloudflare 快速隧道（远程连接的公网入口）不支持 SSE：流式响应被攒成 128KB 一块才转发，
+ * 不满一块的尾巴一直卡着——打开会话等不到完整快照（一直转圈），聊天也不流式。
+ * 隧道下改成一次次短请求：服务端把这一批事件发完就结束响应（结束时隧道一定吐干净），
+ * 浏览器带着 Last-Event-ID 立刻再来一次，漏掉的事件由服务端从环形缓冲补发。
+ * 线上格式仍是 SSE 文本，服务端两种模式共用一套写法。
+ */
+
+/** 只有快速隧道需要轮询；局域网、本机、用户自己的反向代理都照旧走 SSE */
+export function usesEventPolling(hostname: string): boolean {
+	return hostname.toLowerCase().endsWith(".trycloudflare.com");
+}
+
+export interface SseFrame {
+	id?: string;
+	event?: string;
+	data: string;
+}
+
+/** 解析一段完整的 SSE 文本（只认本项目用到的 id / event / data，注释行跳过） */
+export function parseSseText(text: string): SseFrame[] {
+	const frames: SseFrame[] = [];
+	for (const block of text.split(/\r?\n\r?\n/)) {
+		const frame: SseFrame = { data: "" };
+		const data: string[] = [];
+		for (const line of block.split(/\r?\n/)) {
+			if (!line || line.startsWith(":")) continue;
+			const colon = line.indexOf(":");
+			const field = colon === -1 ? line : line.slice(0, colon);
+			let value = colon === -1 ? "" : line.slice(colon + 1);
+			if (value.startsWith(" ")) value = value.slice(1);
+			if (field === "data") data.push(value);
+			else if (field === "id") frame.id = value;
+			else if (field === "event") frame.event = value;
+		}
+		if (!data.length) continue;
+		frame.data = data.join("\n");
+		frames.push(frame);
+	}
+	return frames;
+}
+
+export interface EventPollHandlers {
+	/** 一次请求成功返回（断开后恢复时也会再调） */
+	onOpen(): void;
+	onMessage(data: string): void;
+	/** 一次请求失败；之后按退避自动重试 */
+	onError(): void;
+}
+
+export interface EventPollOptions {
+	fetch?: typeof fetch;
+	/** 第 n 次连续失败后等多久再试 */
+	backoffMs?: (failures: number) => number;
+}
+
+const defaultBackoff = (failures: number) => Math.min(2000 * 2 ** (failures - 1), 30_000);
+
+export function pollEventStream(url: string, handlers: EventPollHandlers, { fetch: fetchImpl = fetch, backoffMs = defaultBackoff }: EventPollOptions = {}): { close(): void } {
+	const controller = new AbortController();
+	let closed = false;
+	let lastEventId: string | undefined;
+	let open = false;
+	let failures = 0;
+	const pollUrl = `${url}${url.includes("?") ? "&" : "?"}poll=1`;
+
+	const sleep = (ms: number) => new Promise<void>((resolve) => {
+		const timer = setTimeout(resolve, ms);
+		controller.signal.addEventListener("abort", () => { clearTimeout(timer); resolve(); }, { once: true });
+	});
+
+	void (async () => {
+		while (!closed) {
+			let frames: SseFrame[];
+			try {
+				const response = await fetchImpl(pollUrl, {
+					headers: lastEventId ? { "Last-Event-ID": lastEventId } : {},
+					cache: "no-store",
+					signal: controller.signal,
+				});
+				if (!response.ok) throw new Error(`events poll failed (${response.status})`);
+				frames = parseSseText(await response.text());
+			} catch {
+				if (closed) return;
+				open = false;
+				handlers.onError();
+				failures += 1;
+				await sleep(backoffMs(failures));
+				continue;
+			}
+			if (closed) return;
+			failures = 0;
+			if (!open) {
+				open = true;
+				handlers.onOpen();
+			}
+			for (const frame of frames) {
+				if (closed) return;
+				handlers.onMessage(frame.data);
+				if (frame.id !== undefined) lastEventId = frame.id;
+			}
+		}
+	})();
+
+	return {
+		close() {
+			closed = true;
+			controller.abort();
+		},
+	};
+}