@rexvane/piweb 0.3.24 → 0.3.26

package/src/lib/agent-manager.ts

@@ -2,11 +2,11 @@
  * agent-manager：AgentSession 池 + pi 事件 → Web 事件翻译 + SSE 订阅管理。
  * 打开会话即惰性冷启动（createAgentSession），空闲回收，事件先快照后增量。
  */
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync, readSync, 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 { formatSkillsForPrompt, generateUnifiedPatch } from "@earendil-works/pi-coding-agent";
+import { ExtensionRunner, ModelRegistry, formatSkillsForPrompt, generateUnifiedPatch } from "@earendil-works/pi-coding-agent";
 import {
 	getResourceLoader,
 	createSessionResourceLoader,
@@ -32,7 +32,7 @@ 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 { TrajLedger, buildTrajectoryFromEntries, toolStepPreview, toTrajTokens } from "./trajectory";
 import { startArchivedSessionRetention } from "./session-retention";
 import { sanitizeToolOutput } from "./text-sanitize";
 import { BoundaryError } from "./path-security";
@@ -56,8 +56,11 @@ const IDLE_MS = 10 * 60 * 1000;
 const MAX_ACTIVE = 6;
 const BUFFER_CAP = 400;
 const SHUTDOWN_TIMEOUT_MS = 5_000;
+/** 外来写入重载后，这么久之内连上的快照都带着提示 */
+const EXTERNAL_RELOAD_NOTICE_MS = 60_000;
 
 interface Managed {
+	viewerAvailable?: () => boolean;
 	sessionPath: string;
 	cwd: string;
 	sm: SessionManager;
@@ -105,6 +108,12 @@ interface Managed {
 	ui: ExtensionUiBridge | null;
 	/** 项目生长：影子仓库快照的触发器（首个会话事件时创建，dispose 时释放） */
 	growth: GrowthTracker | null;
+	/** JSONL 已核对到的字节位置（总在整行末尾）；之后多出来的行要看是不是别的进程写的（见 externalEntryCount） */
+	diskSize: number;
+	/** 已发现、还没重载进来的外来条目数（终端 pi 同时在写这个会话） */
+	externalEntries: number;
+	/** 这一份是因外来写入从磁盘重载出来的：快照带上，前端提示一次 */
+	externalReload?: { entries: number; at: number };
 }
 
 const globalForAgentManager = globalThis as typeof globalThis & {
@@ -164,10 +173,95 @@ export function toWebMessage(m: any, entryId?: string): WebMessage {
 			encodingLoss: result.encodingLoss || undefined,
 			patch: patchOf(m.details),
 		}];
+	} else if (m.role === "compactionSummary" || m.role === "branchSummary") {
+		out.role = "summary";
+		out.summaryKind = m.role === "branchSummary" ? "branch" : "compaction";
+		out.summary = typeof m.summary === "string" ? m.summary : "";
+		if (typeof m.tokensBefore === "number" && Number.isFinite(m.tokensBefore)) out.tokensBefore = m.tokensBefore;
 	}
 	return out;
 }
 
+/** 会话条目 → 显示消息：消息照常投影，压缩 / 分支摘要投影成摘要卡，其余条目（切模型、自定义状态等）不显示 */
+function entryToWebMessage(entry: any): WebMessage | null {
+	if (entry?.type === "message" && entry.message) return toWebMessage(entry.message, entry.id);
+	if (entry?.type !== "compaction" && !(entry?.type === "branch_summary" && entry.summary)) return null;
+	const timestamp = Date.parse(entry.timestamp);
+	return toWebMessage({
+		role: entry.type === "compaction" ? "compactionSummary" : "branchSummary",
+		summary: entry.summary,
+		tokensBefore: entry.tokensBefore,
+		timestamp: Number.isFinite(timestamp) ? timestamp : undefined,
+	}, entry.id);
+}
+
+/**
+ * 被压缩掉的历史：当前分支上已不在模型上下文里的条目，按原顺序照常显示（可编辑、可分叉）。
+ * 每张压缩卡挪到它保留的第一条（firstKeptEntryId）前面，和上下文部分「摘要在前、保留消息在后」一致；
+ * 这样卡片以上就是模型只看得到摘要的内容。
+ */
+function compactedHistory(sm: Pick<SessionManager, "getBranch">, context: any[]): WebMessage[] {
+	if (context[0]?.type !== "compaction") return [];
+	const inContext = new Set(context.map((entry) => entry.id));
+	const entries = (sm.getBranch() as any[]).filter((entry) => !inContext.has(entry.id));
+	const position = new Map(entries.map((entry, index) => [entry.id, index]));
+	const markersBefore = new Map<string, WebMessage[]>();
+	const moved = new Set<string>();
+	entries.forEach((entry, index) => {
+		if (entry.type !== "compaction") return;
+		const at = position.get(entry.firstKeptEntryId);
+		if (at === undefined || at >= index) return;
+		const marker = entryToWebMessage(entry)!;
+		markersBefore.set(entry.firstKeptEntryId, [...(markersBefore.get(entry.firstKeptEntryId) ?? []), marker]);
+		moved.add(entry.id);
+	});
+	const out: WebMessage[] = [];
+	for (const entry of entries) {
+		out.push(...(markersBefore.get(entry.id) ?? []));
+		if (moved.has(entry.id)) continue;
+		const message = entryToWebMessage(entry);
+		if (message) out.push(message);
+	}
+	return out;
+}
+
+/** 冷会话 / 只读接口的消息列表：被压缩掉的历史 + 当前上下文（最新一次压缩投影成分隔卡） */
+export function sessionDisplayMessages(sm: Pick<SessionManager, "getBranch" | "buildContextEntries">): WebMessage[] {
+	const context = sm.buildContextEntries() as any[];
+	const current = context.flatMap((entry, index) => {
+		// 保留区里更早的压缩条目不进模型上下文（SDK 投影只取下标 0 的那次），这里同样跳过
+		if (entry.type === "compaction" && index > 0) return [];
+		const message = entryToWebMessage(entry);
+		return message ? [message] : [];
+	});
+	return [...compactedHistory(sm, context), ...current];
+}
+
+/**
+ * 压缩刚完成（SDK 先写条目再发 compaction_end）：分隔卡 + 它该插在哪条消息前。
+ * 取保留下来的第一条用户 / 助手消息，和快照里「卡片在保留消息之前」的位置一致；没有保留消息就追加。
+ */
+function compactionMarker(m: Managed): { marker?: WebMessage; beforeId?: string; beforeStreamId?: string } {
+	try {
+		const context = m.sm.buildContextEntries() as any[];
+		if (context[0]?.type !== "compaction") return {};
+		const kept = context.find((entry) => entry.type === "message" && (entry.message?.role === "user" || entry.message?.role === "assistant"));
+		return {
+			marker: entryToWebMessage(context[0]) ?? undefined,
+			beforeId: kept?.id,
+			beforeStreamId: kept ? m.messageIds?.get(kept.message) : undefined,
+		};
+	} catch {
+		return {};
+	}
+}
+
+/** 热会话里摘要消息（SDK 每次投影新建的对象）对应的条目 ID：压缩取上下文首条，分支摘要按 fromId + 时间匹配 */
+function summaryEntryId(context: any[], message: any): string | undefined {
+	if (message?.role === "compactionSummary") return context[0]?.type === "compaction" ? context[0].id : undefined;
+	return context.find((entry) => entry.type === "branch_summary" && entry.fromId === message?.fromId && Date.parse(entry.timestamp) === message?.timestamp)?.id;
+}
+
 /** 消息对象 → 持久化条目 ID 的索引；条目数一变就重建（会话只追加，改写分支时条目数也会变） */
 const entryIdIndexes = new WeakMap<SessionManager, { count: number; ids: WeakMap<object, string> }>();
 
@@ -345,7 +439,11 @@ function publishModelState(m: Managed, session: AgentSession): void {
 	});
 }
 
-/** 切模型后恢复用户显式选过的级别（按新模型钳制） */
+/**
+ * 切模型后恢复用户显式选过的级别（按新模型钳制）。
+ * 只记进本会话（SDK 会写 thinking_level_change 条目），不写全局默认：
+ * ~/.pi/agent/settings.json 与终端 pi 共用，在 PiWeb 里切一下档位不该改掉终端 pi 的默认值。
+ */
 function reapplyDesiredLevel(m: Managed, session: AgentSession): void {
 	if (!m.desiredThinkingLevel) return;
 	const target = clampThinkingLevel(session.model as any, m.desiredThinkingLevel as any);
@@ -406,6 +504,14 @@ function timingStats(m: Managed): Pick<WebStats, "llmMs" | "toolMs" | "ttftMs" |
 	return { llmMs, toolMs, ttftMs, ttftSteps, decodeMs, decodeTokens, llmTimedSteps, toolTimedCalls, decodeSteps };
 }
 
+/**
+ * 会话级用量缓存。SDK 的 getSessionStats() 每次都全表遍历 getEntries()（浅拷贝整个会话）、
+ * getContextUsage() 再 buildSessionProjection()（又一次全表拷贝 + 逐消息估算 token）——
+ * 一轮 agent 里 publishUsage 会在每个工具结束/每条消息结束各触发一次，长会话下这是
+ * 服务端最大的重复开销。条目数与 leaf 指针没变时结果必然相同，直接复用。
+ */
+const usageCache = new WeakMap<Managed, { entryCount: number; leafId: string | null; evt: Extract<WebEvent, { type: "usage" }> }>();
+
 function sessionStats(m: Managed): WebStats | null {
 	if (!m.session) return null;
 	try {
@@ -459,17 +565,54 @@ function coldSessionStats(m: Managed): WebStats {
 
 function usageEvent(m: Managed): WebEvent | null {
 	if (!m.session) return null;
+	// 条目数与 leaf 没变（还停在同一轮事件循环的同一状态）→ 复用上次的完整 usage 事件
+	try {
+		const entryCount = (m.sm as unknown as { getEntryCount?: () => number }).getEntryCount?.() ?? m.sm.getEntries().length;
+		const leafId = m.sm.getLeafId();
+		const cached = usageCache.get(m);
+		if (cached && cached.entryCount === entryCount && cached.leafId === leafId) return { ...cached.evt, ts: Date.now() };
+	} catch {
+		/* 缓存键拿不到就走原路径 */
+	}
 	const stats = sessionStats(m);
-	const usage = m.session.getContextUsage() ?? null;
-	return {
-		type: "usage",
+	// 用量统计是旁路信息：SDK 偶发取不到时不能让调用方失败，
+	// 否则一次统计异常就会把「切模型 / 刷新目录」这类命令打回 ok:false。
+	let usage: ReturnType<AgentSession["getContextUsage"]> | null = null;
+	try {
+		usage = m.session.getContextUsage() ?? null;
+	} catch {
+		usage = null;
+	}
+	const evt = {
+		type: "usage" as const,
 		stats,
 		contextUsage: usage ? { tokens: usage.tokens, contextWindow: usage.contextWindow, percent: usage.percent } : null,
 		ts: Date.now(),
 	};
+	try {
+		const entryCount = (m.sm as unknown as { getEntryCount?: () => number }).getEntryCount?.() ?? m.sm.getEntries().length;
+		usageCache.set(m, { entryCount, leafId: m.sm.getLeafId(), evt });
+	} catch {
+		/* ignore */
+	}
+	return evt;
 }
 
-function publishUsage(m: Managed): void {
+/**
+ * 忙时节流：一轮 agent 期间 publishUsage 的调用点密（每个工具结束 + 每条消息结束），
+ * 而 usage 在条目数没变时本来就不会动。500ms 内的重复请求直接跳过；
+ * settle/compaction 等关键节点用 flush 参数强制发一次，收尾数字不缺席。
+ */
+const USAGE_MIN_INTERVAL_MS = 500;
+const usageThrottle = new WeakMap<Managed, number>();
+
+function publishUsage(m: Managed, flush = false): void {
+	const now = Date.now();
+	if (!flush) {
+		const last = usageThrottle.get(m) ?? 0;
+		if (now - last < USAGE_MIN_INTERVAL_MS) return;
+	}
+	usageThrottle.set(m, now);
 	const evt = usageEvent(m);
 	if (evt) publish(m, evt);
 }
@@ -591,7 +734,7 @@ function translate(m: Managed, evt: AgentSessionEvent): void {
 		case "agent_settled":
 			m.runActive = false;
 			publish(m, { type: "status", isStreaming: false, state: "idle", ts: now });
-			publishUsage(m);
+			publishUsage(m, true);
 			if (m.resourceReloadPending) queueMicrotask(() => void reloadManagedResources(m));
 			break;
 		case "queue_update":
@@ -612,9 +755,10 @@ function translate(m: Managed, evt: AgentSessionEvent): void {
 				phase: "end",
 				reason: (evt as any).reason,
 				errorMessage: (evt as any).errorMessage,
+				...((evt as any).result && !(evt as any).errorMessage ? compactionMarker(m) : {}),
 				ts: now,
 			});
-			publishUsage(m);
+			publishUsage(m, true);
 			publishContextBreakdown(m);
 			if ((evt as any).reason === "manual") {
 				publish(m, { type: "status", isStreaming: isManagedBusy(m), state: isManagedBusy(m) ? "running" : "idle", ts: now });
@@ -714,7 +858,8 @@ export function warmSessionResources(cwds: string[]): void {
 
 export function getManaged(sessionPath: string): Managed {
 	let m = sessions.get(sessionPath);
-	if (!m) {
+	if (m) m = syncWithDisk(m);
+	else {
 		if (!existsSync(sessionPath)) throw new BoundaryError("session not found");
 		const sm = openSessionManager(sessionPath);
 		m = registerManaged(sessionPath, sm.getCwd() || process.cwd(), sm);
@@ -723,6 +868,115 @@ export function getManaged(sessionPath: string): Managed {
 	return m;
 }
 
+/**
+ * 数出 JSONL 里自上次核对以来、不是本进程写的新条目。
+ * 自己的条目在 SessionManager._appendEntry 里先进内存索引再落盘，所以索引里找不到 id 的行就是外来的
+ * （终端 pi 同时打开了这个会话）。只读新增的字节；文件变短（被整体重写）就从头核对；没写完的最后一行留到下次。
+ */
+function externalEntryCount(m: Managed): number {
+	let size: number;
+	try {
+		size = statSync(m.sessionPath).size;
+	} catch {
+		return 0; // 还没落盘
+	}
+	if (size === m.diskSize) return 0;
+	const from = size < m.diskSize ? 0 : m.diskSize;
+	let buf = Buffer.alloc(size - from);
+	let fd: number | undefined;
+	try {
+		fd = openSync(m.sessionPath, "r");
+		buf = buf.subarray(0, readSync(fd, buf, 0, buf.length, from));
+	} catch {
+		return 0;
+	} finally {
+		if (fd !== undefined) closeSync(fd);
+	}
+	const end = buf.lastIndexOf(0x0a);
+	m.diskSize = from + end + 1;
+	let count = 0;
+	for (const line of buf.subarray(0, Math.max(0, end)).toString("utf8").split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			const entry = JSON.parse(line);
+			if (entry?.type !== "session" && typeof entry?.id === "string" && !m.sm.getEntry(entry.id)) count += 1;
+		} catch {
+			/* 从行中间读起的半行、写坏的行都不算 */
+		}
+	}
+	return count;
+}
+
+/**
+ * pi 终端和 PiWeb 共用同一份 JSONL，但各自在内存里记着会话树：一边写了，另一边不知道，
+ * 接着写就从自己的旧叶子分叉。打开会话、发消息都经过 getManaged，这里先核对磁盘：
+ * 有外来条目且本会话空闲，就丢掉内存里的旧副本从磁盘重开；正在跑就只提醒，空闲后的下一次核对再重载。
+ */
+function syncWithDisk(m: Managed): Managed {
+	const found = externalEntryCount(m);
+	if (!found && !m.externalEntries) return m;
+	m.externalEntries += found;
+	if (m.creating || isManagedBusy(m)) {
+		if (found) publish(m, { type: "external_write", entries: m.externalEntries, ts: Date.now() });
+		return m;
+	}
+	return reopenManaged(m);
+}
+
+/** 等同空闲回收后再打开：会话级的选择（工具档位、思考级别）带过去，正在看的浏览器立刻重连拿新快照 */
+function reopenManaged(m: Managed): Managed {
+	let sm: SessionManager;
+	try {
+		sm = openSessionManager(m.sessionPath);
+	} catch {
+		return m; // 读不出来（正被写坏？）就先沿用旧副本，下次再试
+	}
+	const at = Date.now();
+	const reload = { entries: m.externalEntries, at };
+	// 直接写给订阅者：publish 可能排在队列里，晚于 dispose 就送不到了
+	const frame = JSON.stringify({ type: "external_reload", ...reload, ts: at });
+	for (const send of m.subscribers) {
+		try {
+			send(m.seq, frame);
+		} catch {
+			/* ignore */
+		}
+	}
+	disposeSession(m);
+	const fresh = registerManaged(m.sessionPath, sm.getCwd() || m.cwd, sm);
+	// 核对位置沿用旧的（整行末尾）：打开时恰好没写完的那行，写完后还会被认作外来的
+	fresh.diskSize = m.diskSize;
+	fresh.toolPreset = m.toolPreset;
+	fresh.customActiveTools = m.customActiveTools;
+	fresh.desiredThinkingLevel = m.desiredThinkingLevel;
+	fresh.viewerGraceUntil = m.viewerGraceUntil;
+	fresh.externalReload = reload;
+	return fresh;
+}
+
+/**
+ * 侧栏每 3 秒拉一次会话列表，顺带核对所有开着的会话：终端写入几秒内就能提示 / 重载，
+ * 回合中途发现的外来写入也在回合结束后的下一次拉取时重载（不在 agent_settled 里做：
+ * SDK 收尾时还可能有延后的提问要开跑，那一刻回收会把它丢掉）。每个会话一次 stat，没变就不读文件。
+ */
+export function syncSessionsFromDisk(): void {
+	for (const m of [...sessions.values()]) {
+		try {
+			syncWithDisk(m);
+		} catch {
+			/* 核对失败只是晚一点发现，打开 / 发送时还会再查 */
+		}
+	}
+}
+
+function fileSize(file: string): number {
+	try {
+		return statSync(file).size;
+	} catch {
+		return 0;
+	}
+}
+
 function registerManaged(sessionPath: string, cwd: string, sm: SessionManager): Managed {
 	let initialTrajectory: TrajEntry[] = [];
 	try {
@@ -754,6 +1008,8 @@ function registerManaged(sessionPath: string, cwd: string, sm: SessionManager):
 		runActive: false,
 		disposed: false,
 		messageIds: new WeakMap(),
+		diskSize: fileSize(sessionPath),
+		externalEntries: 0,
 	};
 	sessions.set(sessionPath, m);
 	return m;
@@ -872,6 +1128,10 @@ function publishContextBreakdown(m: Managed): void {
 	});
 }
 
+/** 资源加载器注入文件的展示上限：同一份全文已经随快照的 contextResources 下发过一次，
+ *  轨迹条目的 detail 只留头部供列表预览与搜索——两处不再各带一份全文 */
+const TRAJ_CONTEXT_DETAIL_MAX_CHARS = 4_000;
+
 /** resources 已经算过（快照）就传进来，免得资源发现结果再读一遍 */
 function environmentTrajectory(m: Managed, session: AgentSession | null, known?: ContextResource[]): TrajEntry[] {
 	const ts = m.ledger.entries[0]?.ts ?? Date.now();
@@ -893,7 +1153,10 @@ function environmentTrajectory(m: Managed, session: AgentSession | null, known?:
 			kind: "context",
 			ts,
 			title: resource.path,
-			detail: resource.content,
+			// 全文在快照 contextResources 里；这里只留头部，快照不再双份序列化
+			detail: resource.content.length > TRAJ_CONTEXT_DETAIL_MAX_CHARS
+				? `${resource.content.slice(0, TRAJ_CONTEXT_DETAIL_MAX_CHARS)}…`
+				: resource.content,
 		}));
 	} catch {
 		/* Resource discovery diagnostics are already surfaced by Pi. */
@@ -913,6 +1176,7 @@ export async function ensureSession(m: Managed): Promise<AgentSession> {
 	if (m.session) return m.session;
 	m.creating = (async () => {
 		await resourceLoaderReady(m.cwd);
+		const settingsManager = getSettingsManager(m.cwd);
 		const loader = await createSessionResourceLoader(m.cwd);
 		let created: AgentSession | undefined;
 		try {
@@ -923,7 +1187,7 @@ export async function ensureSession(m: Managed): Promise<AgentSession> {
 				sessionManager: m.sm,
 				modelRuntime: await getModelRuntime(),
 				resourceLoader: loader,
-				settingsManager: getSettingsManager(m.cwd),
+				settingsManager,
 			});
 			created = session;
 			if (m.disposed) throw new Error("session is disposed");
@@ -1178,7 +1442,22 @@ startArchivedSessionRetention({ isActive: isSessionInUse, log: (message) => cons
 
 type ResourceBundle = Pick<WebSnapshot, "skills" | "promptTemplates" | "extensionCommands" | "projectTrust" | "resourceDiagnostics">;
 
-function collectResources(m: Managed): ResourceBundle {
+/**
+ * 会话还不存在时也能发现命令：不绑定运行时、不发 session_start、不启动 MCP。
+ * 新会话页和冷会话的斜杠补全都靠它，等第一次提问才建会话。
+ */
+export async function loadWorkspaceResources(cwd: string): Promise<ResourceBundle> {
+	await refreshResourceLoaderIfStale(cwd);
+	const modelRegistry = new ModelRegistry(await getModelRuntime());
+	return withResourceLock(async () => {
+		const loader = getResourceLoader(cwd);
+		const { extensions, runtime } = loader.getExtensions();
+		const runner = new ExtensionRunner(extensions, runtime, cwd, SessionManager.inMemory(cwd), modelRegistry);
+		return collectResources({ cwd, session: null }, runner);
+	});
+}
+
+function collectResources(m: Pick<Managed, "cwd" | "session">, commandRunner?: ExtensionRunner): ResourceBundle {
 	const loader = m.session?.resourceLoader ?? peekResourceLoader(m.cwd) ?? getResourceLoader(m.cwd);
 	const diagnostics: WebSnapshot["resourceDiagnostics"] = [];
 	let skills: WebSnapshot["skills"] = [];
@@ -1203,9 +1482,9 @@ function collectResources(m: Managed): ResourceBundle {
 		/* ignore */
 	}
 	let extensionCommands: WebSnapshot["extensionCommands"] = [];
-	if (m.session) {
+	if (m.session || commandRunner) {
 		try {
-			const runner = (m.session as unknown as { extensionRunner?: { getRegisteredCommands(): Array<{ invocationName: string; description?: string; sourceInfo?: { path?: string } }>; getCommandDiagnostics(): Array<{ path?: string; message: string }> } }).extensionRunner;
+			const runner = commandRunner ?? m.session?.extensionRunner;
 			if (runner) {
 				extensionCommands = runner.getRegisteredCommands().map((c) => ({
 					name: c.invocationName,
@@ -1235,6 +1514,13 @@ async function reloadManagedResources(m: Managed): Promise<boolean> {
 	m.resourceReloadPending = false;
 	try {
 		await m.session.reload();
+		// pi 1.3.0 起 reload 会保留原来的活动工具集：被移除的扩展工具会继续留在活动集里。
+		// 这里按当前注册表重算一次；策略本身出错不能把重载判成失败。
+		try {
+			applyToolPolicy(m, m.session);
+		} catch {
+			/* 工具策略是附带动作，失败下次重载/切档位会再算 */
+		}
 		swapCurrentModelObject(m.session);
 		return true;
 	} catch (err) {
@@ -1265,7 +1551,9 @@ export function refreshSessionModels(provider: string, id: string): number {
 		const current = m.session?.model;
 		if (!m.session || current?.provider !== provider || current.id !== id) continue;
 		swapCurrentModelObject(m.session);
-		publishUsage(m);
+		// 换了模型对象（contextWindow 可能变了）：条目数没变也会命中旧缓存，先失效再发
+		usageCache.delete(m);
+		publishUsage(m, true);
 		n += 1;
 	}
 	return n;
@@ -1300,8 +1588,10 @@ export async function buildSnapshot(m: Managed): Promise<WebSnapshot> {
 	// 用户刚在 prompts/skills/extensions 目录新建了文件的话顺手重载一次（只 stat 几个目录）
 	await resourceLoaderReady(m.cwd);
 	try {
-		// 运行中只标记变更，不让 snapshot 请求重新执行扩展工厂/切换绑定。
-		if (m.session && isManagedBusy(m)) {
+		// 创建还未完成时，资源版本尚未落定；快照不能把它误标成需要再次 session_start。
+		if (m.creating) {
+			// 当前创建流程会发布最终资源状态。
+		} else if (m.session && isManagedBusy(m)) {
 			if (resourceLoaderIsStale(m.cwd) || m.resourceVersion !== resourceLoaderVersion(m.cwd)) m.resourceReloadPending = true;
 		} else {
 			await refreshResourceLoaderIfStale(m.cwd);
@@ -1323,7 +1613,22 @@ export async function buildSnapshot(m: Managed): Promise<WebSnapshot> {
 
 	if (session) {
 		const hasInflightFinal = linkInflightFinal(m, session);
-		messages = session.messages.map((message) => projectMessage(m, message));
+		// session.messages 只是压缩后的模型上下文；前面补上被压缩掉的历史，压缩摘要投影成分隔卡
+		let context: any[] = [];
+		let history: WebMessage[] = [];
+		try {
+			context = m.sm.buildContextEntries() as any[];
+			history = compactedHistory(m.sm, context);
+		} catch {
+			/* 条目读不到时只显示上下文 */
+		}
+		messages = [
+			...history,
+			...session.messages.map((message: any) =>
+				message?.role === "compactionSummary" || message?.role === "branchSummary"
+					? toWebMessage(message, summaryEntryId(context, message))
+					: projectMessage(m, message)),
+		];
 		// final 已被 SDK push 时只投影一次；延后的 end 使用相同 streamId 继续更新权威内容。
 		if (!hasInflightFinal && m.inflight) {
 			const partial = projectMessage(m, m.inflight);
@@ -1340,12 +1645,9 @@ export async function buildSnapshot(m: Managed): Promise<WebSnapshot> {
 		}
 		isStreaming = isManagedBusy(m);
 	} else {
-		// 冷渲染：从 JSONL 还原上下文消息（不启动 agent）
+		// 冷渲染：从 JSONL 还原消息（不启动 agent），压缩掉的历史也照常显示
 		try {
-			const entries = m.sm.buildContextEntries();
-			messages = entries
-				.filter((e: any) => e.type === "message" && e.message)
-				.map((e: any) => toWebMessage(e.message, e.id));
+			messages = sessionDisplayMessages(m.sm);
 		} catch {
 			messages = [];
 		}
@@ -1416,7 +1718,8 @@ export async function buildSnapshot(m: Managed): Promise<WebSnapshot> {
 	}
 
 	// 斜杠命令数据源：技能 / 提示模板 / 扩展命令，加上项目信任与资源诊断
-	const resources = collectResources(m);
+	// 冷会话还没有 extensionRunner，但命令目录已经能发现；不要在第一次提问前推空列表。
+	const resources = session && !m.creating ? collectResources(m) : await loadWorkspaceResources(m.cwd);
 
 	const baseTrajectory = m.ledger.entries.length ? m.ledger.entries : coldTrajectory(m);
 	const trajectory = [...environmentTrajectory(m, session, contextResourcesLoaded ? contextResources : undefined), ...baseTrajectory];
@@ -1448,6 +1751,8 @@ export async function buildSnapshot(m: Managed): Promise<WebSnapshot> {
 		queue,
 		trajectory,
 		isStreaming,
+		// 重载时没人在看（打开会话那一刻才发现）：靠快照把提示带给随后连上的浏览器，前端按 at 去重
+		...(m.externalReload && Date.now() - m.externalReload.at < EXTERNAL_RELOAD_NOTICE_MS ? { externalReload: m.externalReload } : {}),
 	};
 }
 
@@ -1506,6 +1811,7 @@ export function holdViewer(m: Managed, ms: number): void {
 }
 
 function hasViewers(m: Managed): boolean {
+	if (m.viewerAvailable) return m.viewerAvailable();
 	return m.subscribers.size > 0 || (m.viewerGraceUntil ?? 0) > Date.now();
 }
 
@@ -1528,6 +1834,17 @@ async function prepareGrowthBriefly(m: Managed): Promise<void> {
 	]);
 }
 
+type PromptImages = NonNullable<NonNullable<Parameters<AgentSession["prompt"]>[1]>["images"]>;
+
+/** 被编辑的那条用户消息里的图片：编辑只改文字，图片原样带进重发（编辑框里也照样显示它们） */
+function userMessageImages(session: AgentSession, entryId: string): PromptImages {
+	const entry = session.sessionManager?.getEntry?.(entryId) as { type?: string; message?: { role?: string; content?: unknown } } | undefined;
+	if (entry?.type !== "message" || entry.message?.role !== "user" || !Array.isArray(entry.message.content)) return [];
+	return entry.message.content.filter(
+		(c): c is PromptImages[number] => c?.type === "image" && typeof c.data === "string" && typeof c.mimeType === "string",
+	);
+}
+
 /** 交给 SDK，并在「受理」那一刻返回，而不是等整轮跑完；受理之后的错误经 SSE 可见 */
 function submitPrompt(
 	m: Managed,
@@ -1549,7 +1866,10 @@ function submitPrompt(
 		});
 		// 同步挂好 rejection handler；接受后的错误仍经 SSE 可见，不能成为未处理拒绝。
 		void run.then(() => {
-			if (!accepted) resolve({ ok: false, error: "prompt completed without acceptance" });
+			// 上一轮的 agent_settled 还没发完时，SDK 不拒绝提问，而是把它挂进 deferredSettledActions，
+			// 立即返回并在稍后用同一份 options 重发；这条路径不会调用 preflightResult。
+			// 消息确实会发出去，不能报「未受理」——否则界面报错，消息随后照样出现。真正的拒绝只会是 rejection。
+			if (!accepted) resolve({ ok: true, data: { accepted: true } });
 		}, (error) => {
 			const message = String(error?.message ?? error);
 			if (accepted) publish(m, { type: "error", message, ts: Date.now() });
@@ -1622,7 +1942,9 @@ export async function execute(m: Managed, cmd: AgentCommand): Promise<CommandRes
 				reapplyDesiredLevel(m, session);
 				// 新会话页选的模型（fresh）：思考档位按新会话的规则定；之后显式选的档位仍会覆盖
 				if (cmd.fresh === true && !m.desiredThinkingLevel) applyNewSessionThinking(m, session);
+				usageCache.delete(m); // 换模型 = contextWindow 变了，旧 usage 缓存作废
 				publishModelState(m, session);
+				publishUsage(m, true);
 				return { ok: true, data: { thinkingLevel: session.thinkingLevel, thinkingLevels: session.getAvailableThinkingLevels() } };
 			}
 			case "setThinkingLevel": {
@@ -1631,6 +1953,7 @@ export async function execute(m: Managed, cmd: AgentCommand): Promise<CommandRes
 				// 与 pi 终端一致：不支持的档位就近钳制而不是拒绝（非推理模型 → off），并把实际生效值回传
 				const effective = clampThinkingLevel(session.model as any, requested as any);
 				m.desiredThinkingLevel = requested;
+				// 不传 persist：与终端 pi 一样，聊天里切档位只影响本会话；全局默认仍以 settings.json 为准（见 reapplyDesiredLevel）
 				session.setThinkingLevel(effective as never);
 				publishModelState(m, session);
 				return { ok: true, data: { requested, thinkingLevel: session.thinkingLevel, clamped: session.thinkingLevel !== requested } };
@@ -1638,7 +1961,8 @@ export async function execute(m: Managed, cmd: AgentCommand): Promise<CommandRes
 			case "setToolPreset": {
 				const preset = cmd.preset as ToolPreset;
 				if (!Object.hasOwn(TOOL_PRESETS, preset)) return { ok: false, error: "invalid tool preset" };
-				if (isManagedBusy(m)) return { ok: false, error: "cannot change tools while the agent is running" };
+				// 运行中也能改：SDK 的 setActiveToolsByName 不做 busy 检查，改完重建系统提示词，
+				// 在下一轮生效（本轮的请求已经发出去了，改不了）。这里不再自行拦一层。
 				if (!m.session && !m.creating) {
 					// 冷会话只记下选择，等真正启动时（ensureSession → applyToolPolicy）再生效。
 					// 不能为了切个档位就冷启动 agent：打开会话时前端会恢复本地档位，
@@ -1649,7 +1973,7 @@ export async function execute(m: Managed, cmd: AgentCommand): Promise<CommandRes
 					return { ok: true };
 				}
 				const session = await ensureSession(m);
-				if (isManagedBusy(m)) return { ok: false, error: "cannot change tools while the agent is running" };
+				if (m.disposed) return { ok: false, error: "session is disposed" };
 				m.toolPreset = preset;
 				m.customActiveTools = undefined;
 				applyToolPolicy(m, session);
@@ -1658,9 +1982,9 @@ export async function execute(m: Managed, cmd: AgentCommand): Promise<CommandRes
 				return { ok: true };
 			}
 			case "setActiveTools": {
-				if (isManagedBusy(m)) return { ok: false, error: "cannot change tools while the agent is running" };
+				// 同上：运行中允许改，下一轮生效。
 				const session = await ensureSession(m);
-				if (isManagedBusy(m)) return { ok: false, error: "cannot change tools while the agent is running" };
+				if (m.disposed) return { ok: false, error: "session is disposed" };
 				const wanted = Array.isArray(cmd.names) ? cmd.names.map(String) : [];
 				const all = listAllToolNames(session);
 				const next = [...new Set(wanted)].filter((n) => all.includes(n));
@@ -1708,13 +2032,15 @@ export async function execute(m: Managed, cmd: AgentCommand): Promise<CommandRes
 						}
 					}
 					if (m.disposed) throw new Error("session is disposed");
+					// 回到消息之前先取它带的图片：客户端只发改过的文字，不取的话重发出去图就没了
+					const images = userMessageImages(session, entryId);
 					const moved = await session.navigateTree(entryId);
 					if (moved?.cancelled) return { ok: false, error: "edit cancelled" };
 					await prepareGrowthBriefly(m);
 					if (m.disposed) throw new Error("session is disposed");
 					// 与普通 prompt 一样在受理时就返回：等整轮跑完的话，这期间 promptSubmitting 一直为真，
 					// 插话 / 排队 / 新消息全被拒，HTTP 请求也一直挂着
-					return await submitPrompt(m, session, text);
+					return await submitPrompt(m, session, text, images.length ? { images } : {});
 				} finally {
 					m.promptSubmitting = false;
 					if (!m.disposed) publish(m, { type: "status", isStreaming: isManagedBusy(m), state: isManagedBusy(m) ? "running" : "idle", ts: Date.now() });
@@ -1744,6 +2070,12 @@ export async function execute(m: Managed, cmd: AgentCommand): Promise<CommandRes
 				}
 				const session = await ensureSession(m);
 				await session.reload();
+				// 同 reloadManagedResources：pi 1.3.0 保留活动工具集，重载后按当前注册表重算
+				try {
+					applyToolPolicy(m, session);
+				} catch {
+					/* 同上：策略失败不影响 /reload 本身 */
+				}
 				swapCurrentModelObject(session);
 				return { ok: true };
 			}
@@ -1784,7 +2116,7 @@ export function activeStatus(): Record<string, { streaming: boolean; lastStep?:
 		for (let i = m.ledger.entries.length - 1; i >= 0; i -= 1) {
 			const e = m.ledger.entries[i];
 			if (e.kind === "tool") {
-				lastStep = [e.toolName, (e.preview ?? e.title ?? "").split("\n")[0].slice(0, 80)].filter(Boolean).join(" · ");
+				lastStep = [e.toolName, toolStepPreview(e)].filter(Boolean).join(" · ");
 				break;
 			}
 		}