@rexvane/piweb 0.3.16 → 0.3.18

package/src/lib/growth-tracker.ts

@@ -1,88 +1,57 @@
 /**
- * growth-tracker：把 pi 会话事件接到项目生长快照引擎上。
+ * growth-tracker：把 pi 会话事件接到「每轮一个 git commit」上。
  *
- * - agent_start：确保本会话有基线步，并启动工作区目录监听
- * - 改盘类工具（bash / powershell / write / edit / 未知扩展工具）结束：去抖 200ms 拍一张快照（并行工具合并成一步）
- * - agent_end：兜底再拍一次（tree 没变就不记步）
- * - 目录监听：改盘类工具运行期间看到的新路径先以「生成中」推给浏览器；空闲时的改动去抖 1.5s 记成「外部修改」
- * 快照失败不影响 pi，只向浏览器报一次错；项目过大 / 没有 git 时本会话停用。
+ * - prepare()（发 prompt 前）：把两轮之间用户自己的修改单独提交一次，不混进 pi 这一轮
+ *   （工作区还没有任何提交时记成基线）
+ * - agent_start → agent_settled 是一轮：结束时提交本轮，提问首行做标题、用户消息 entryId 写进 trailers；
+ *   没有改动也提交空 commit，轮号与对话一一对应
+ * 提交失败不影响 pi，只向浏览器报一次错；项目过大 / 没有 git 时本会话停用。
  */
-import fs from "node:fs";
-import { realpathSync } from "node:fs";
-import path from "node:path";
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
-import { GrowthError, hasSessionSteps, isExcludedRelPath, snapshot } from "./growth-service";
-import type { GrowthStep, GrowthStepKind, WebEvent } from "./types";
+import { GrowthError, commitRound, recordWorkspaceChanges } from "./growth-service";
+import { promptsFromEntries } from "./growth-turns";
+import type { GrowthRound, GrowthRoundStatus, WebEvent } from "./types";
 
-const READ_ONLY_TOOLS = new Set(["read", "grep", "find", "ls"]);
-const SNAPSHOT_DEBOUNCE_MS = 200;
-const PENDING_THROTTLE_MS = 300;
-const EXTERNAL_DEBOUNCE_MS = 1500;
-const MAX_PENDING = 500;
 const ERROR_THROTTLE_MS = 60_000;
-export const GROWTH_TRACKER_VERSION = 3;
+export const GROWTH_TRACKER_VERSION = 4;
 
-interface QueuedMeta {
-	kind: GrowthStepKind;
-	label: string;
-	toolCallId?: string;
-	toolName?: string;
-	/** 归属时刻：轮次内的步传轮次开始时间，避免慢快照落账晚被切进下一轮窗口 */
-	ts?: number;
+interface SessionEntryLike {
+	type?: string;
+	id?: string;
+	message?: { role?: string; content?: unknown; stopReason?: string };
 }
 
 export interface GrowthTracker {
 	version: number;
 	getError(): string | null;
-	/** 在首轮 prompt 前完成基线，避免快速写盘被误算进基线。 */
+	/** 发 prompt 前完成「你的修改」提交，避免它被算进 pi 这一轮 */
 	prepare(): Promise<void>;
 	onEvent(evt: AgentSessionEvent): void;
-	/** 手动快照（API 触发）；返回记下的步，tree 没变返回 null */
-	snapshotNow(label?: string): Promise<GrowthStep | null>;
+	/** 立即记录（项目栏按钮）：把当前改动提交为「你的修改」；没改动返回 null */
+	recordNow(): Promise<GrowthRound | null>;
 	dispose(): void;
 }
 
-export function isMutatingTool(name: string): boolean {
-	return !READ_ONLY_TOOLS.has(name.toLowerCase());
+/** 本轮最后一条助手消息的结束原因 → 轮次状态（用户中止 / 模型报错 / 正常） */
+function roundStatus(entries: readonly SessionEntryLike[]): GrowthRoundStatus {
+	for (let i = entries.length - 1; i >= 0; i -= 1) {
+		const message = entries[i].type === "message" ? entries[i].message : undefined;
+		if (message?.role !== "assistant") continue;
+		if (message.stopReason === "aborted") return "aborted";
+		if (message.stopReason === "error") return "error";
+		return "done";
+	}
+	return "done";
 }
 
-/** 「bash · mkdir -p src」：工具名 + 命令首行 / 相对路径，截到 60 字 */
-export function labelForTool(cwd: string, name: string, args: unknown): string {
-	const a = args && typeof args === "object" ? (args as Record<string, unknown>) : {};
-	let detail = "";
-	if (typeof a.command === "string") detail = a.command;
-	else if (typeof a.path === "string") detail = relativeToCwd(cwd, a.path);
-	else if (typeof a.file_path === "string") detail = relativeToCwd(cwd, a.file_path);
-	detail = detail.split("\n").map((s) => s.trim()).find(Boolean) ?? "";
-	detail = detail.replace(/\s+/g, " ");
-	if (detail.length > 60) detail = `${detail.slice(0, 59)}…`;
-	return detail ? `${name} · ${detail}` : name;
-}
-
-function relativeToCwd(cwd: string, p: string): string {
-	if (!path.isAbsolute(p)) return p.replace(/\\/g, "/");
-	const rel = path.relative(cwd, p);
-	if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return p.replace(/\\/g, "/");
-	return rel.replace(/\\/g, "/");
-}
-
-/** 工具链自动生成/频繁改写的文件：进 pending 只会制造蓝点噪音，快照侧由 .gitignore 与影子仓库 exclude 兜底 */
-const WATCHER_FILE_NOISE = /(?:^|\/)(?:\.DS_Store|Thumbs\.db|[^/]*\.log|[^/]*\.tsbuildinfo|next-env\.d\.ts)$/;
-
-export function createGrowthTracker(opts: { cwd: string; sessionPath: string; publish: (evt: WebEvent) => void }): GrowthTracker {
-	const { cwd, sessionPath, publish } = opts;
-	const running = new Set<string>();
-	const argsById = new Map<string, unknown>();
-	const queue: QueuedMeta[] = [];
-	const pending = new Set<string>();
-	let pendingStats = 0;
-	let flushTimer: ReturnType<typeof setTimeout> | undefined;
-	let pendingTimer: ReturnType<typeof setTimeout> | undefined;
-	let externalTimer: ReturnType<typeof setTimeout> | undefined;
-	let watcher: fs.FSWatcher | null = null;
-	let watcherFailed = false;
-	let baselineChecked = false;
-	let baselinePending: Promise<void> | null = null;
+export function createGrowthTracker(opts: {
+	cwd: string;
+	sessionPath: string;
+	publish: (evt: WebEvent) => void;
+	/** 会话的持久条目（SessionManager.getEntries）：轮结束时从中取本轮的提问 */
+	entries: () => readonly SessionEntryLike[];
+}): GrowthTracker {
+	const { cwd, sessionPath, publish, entries } = opts;
 	let disabled = false;
 	let disabledFailure: GrowthError | null = null;
 	let disposed = false;
@@ -90,243 +59,83 @@ export function createGrowthTracker(opts: { cwd: string; sessionPath: string; pu
 	let errorActive = false;
 	let lastErrorMessage: string | null = null;
 	let chain: Promise<void> = Promise.resolve();
-	/** 当前轮次的开始时刻：本轮所有步的归属 ts（慢快照不再把改动算给下一轮） */
-	let turnTs: number | undefined;
+	/** 本轮开始时会话条目的数量；null = 不在一轮之中 */
+	let runStart: number | null = null;
 
-	// 快照失败不打扰用户（项目栏退化成普通文件树 + 查看器）：只在服务端日志记一次，没 git / 项目过大就停用本会话的跟踪
+	// 提交失败不打扰用户（项目栏退化成普通文件树 + 查看器）：只在服务端日志记一次，没 git / 项目过大就停用本会话的跟踪
 	const reportError = (error: unknown) => {
 		const message = error instanceof Error ? error.message : String(error);
 		const terminal = error instanceof GrowthError && (error.code === "unavailable" || error.code === "too-large");
 		if (terminal) {
 			disabled = true;
 			disabledFailure = error;
-			try {
-				watcher?.close();
-			} catch {
-				/* ignore watcher close errors after a terminal snapshot failure */
-			}
-			watcher = null;
-			if (flushTimer) clearTimeout(flushTimer);
-			if (pendingTimer) clearTimeout(pendingTimer);
-			if (externalTimer) clearTimeout(externalTimer);
-			flushTimer = pendingTimer = externalTimer = undefined;
-			queue.length = 0;
-			running.clear();
-			argsById.clear();
-			if (pending.size) {
-				pending.clear();
-				publish({ type: "growth_pending", paths: [], ts: Date.now() });
-			}
+			runStart = null;
 		}
 		errorActive = true;
 		lastErrorMessage = message;
 		const now = Date.now();
 		if (!terminal && now - lastErrorAt < ERROR_THROTTLE_MS) return;
 		lastErrorAt = now;
-		console.warn(`[piweb] growth snapshot failed for ${cwd}: ${message}`);
+		console.warn(`[piweb] growth commit failed for ${cwd}: ${message}`);
 		publish({ type: "growth_error", message, ts: now });
 	};
 
-	const publishPending = () => {
-		pendingTimer = undefined;
-		publish({ type: "growth_pending", paths: [...pending].slice(0, 200), ts: Date.now() });
-	};
-
 	const enqueue = (fn: () => Promise<void>) => {
 		chain = chain.then(fn, fn).catch(reportError);
 		return chain;
 	};
 
-	// 真正拍快照的函数不能再 enqueue（链上任务里嵌套排队会等自己，整条链永久卡死）
-	const doRecord = async (meta: QueuedMeta, force = false) => {
-		if (disabled || disposed) return;
-		const step = await snapshot(cwd, { ...meta, session: sessionPath, force });
+	const published = (round: GrowthRound | null) => {
 		if (errorActive) {
 			errorActive = false;
 			lastErrorMessage = null;
 			publish({ type: "growth_error", message: null, ts: Date.now() });
 		}
-		if (!step || disposed) return;
-		publish({ type: "growth", step, ts: Date.now() });
-		if (pending.size) {
-			pending.clear();
-			if (pendingTimer) clearTimeout(pendingTimer);
-			publishPending();
-		}
-	};
-	const record = (meta: QueuedMeta, force = false) => enqueue(() => doRecord(meta, force));
-
-	const ensureBaseline = (): Promise<void> => {
-		if (baselineChecked) return chain;
-		if (baselinePending) return baselinePending;
-		baselinePending = enqueue(async () => {
-			if (disabled || disposed) return;
-			if (!(await hasSessionSteps(cwd, sessionPath))) await doRecord({ kind: "baseline", label: "", ts: turnTs }, true);
-			baselineChecked = true;
-		});
-		void baselinePending.finally(() => { baselinePending = null; });
-		return baselinePending;
-	};
-
-	const flush = () => {
-		flushTimer = undefined;
-		const metas = queue.splice(0);
-		if (!metas.length) return;
-		const tools = metas.filter((x) => x.kind === "tool");
-		const head = tools[0] ?? metas[0];
-		const extra = tools.length > 1 ? ` +${tools.length - 1}` : "";
-		// 归属时刻优先用队里最新的（同轮多个工具取最后一个工具结束时也在轮内）；
-		// 没有就退回当前轮开始时刻，再退回落账时刻。
-		const ts = metas.reduce<number | undefined>((acc, m) => m.ts ?? acc, undefined) ?? turnTs;
-		// 首轮工具快照前确保基线已在链上排队：基线落账晚于首轮工具时，
-		// buildGrowthRounds 按时间戳切窗会把首轮误判成「快照启用前，未记录」。
-		const recordAfterBaseline = baselineChecked
-			? Promise.resolve()
-			: ensureBaseline().catch(() => undefined);
-		void recordAfterBaseline.then(() => {
-			if (disposed || disabled) return;
-			record({ kind: head.kind, label: `${head.label}${extra}`, toolCallId: head.toolCallId, toolName: head.toolName, ts });
-		});
-	};
-
-	const schedule = (meta: QueuedMeta) => {
-		if (disabled) return;
-		if (externalTimer) {
-			clearTimeout(externalTimer);
-			externalTimer = undefined;
-		}
-		// 轮内工具步继承轮次开始时刻（外部修改步不标 ts，按实际发生时间归属）
-		queue.push(meta.kind === "tool" && turnTs !== undefined ? { ...meta, ts: meta.ts ?? turnTs } : meta);
-		if (flushTimer) clearTimeout(flushTimer);
-		flushTimer = setTimeout(flush, SNAPSHOT_DEBOUNCE_MS);
-	};
-
-	const onFsChange = (_type: string, filename: string | Buffer | null) => {
-		if (disabled || disposed) return;
-		const rel = filename == null ? "" : String(filename).replace(/\\/g, "/");
-		if (rel && (isExcludedRelPath(rel) || WATCHER_FILE_NOISE.test(rel))) return;
-		if (running.size > 0) {
-			if (!rel || pending.size + pendingStats >= MAX_PENDING) return;
-			pendingStats += 1;
-			// fs.watch 回调不能同步 stat；目录标记允许异步到达。
-			void fs.promises.stat(path.join(cwd, rel)).then(
-				(info) => info.isDirectory(),
-				() => false,
-			).then((isDir) => {
-				if (disposed || disabled) return;
-				const livePath = isDir ? `${rel}/` : rel;
-				if (pending.size >= MAX_PENDING || pending.has(livePath)) return;
-				pending.add(livePath);
-				if (!pendingTimer) pendingTimer = setTimeout(publishPending, PENDING_THROTTLE_MS);
-			}).finally(() => { pendingStats -= 1; });
-			return;
-		}
-		// 工具刚结束、快照还没拍：这次改动归它，不另记外部修改
-		if (queue.length || flushTimer) return;
-		if (externalTimer) clearTimeout(externalTimer);
-		externalTimer = setTimeout(() => {
-			externalTimer = undefined;
-			if (running.size > 0 || queue.length) return;
-			void record({ kind: "external", label: "" });
-		}, EXTERNAL_DEBOUNCE_MS);
-	};
-
-	const startWatcher = () => {
-		if (watcher || watcherFailed || disabled) return;
-		try {
-			// Watch the canonical path: on Windows an 8.3 short name (RUNNER~1) can make
-			// libuv's directory watcher compare mismatched spellings and crash the process.
-			let watchRoot = cwd;
-			try {
-				watchRoot = realpathSync.native(cwd);
-			} catch {
-				/* keep the given path when it cannot be resolved */
-			}
-			watcher = fs.watch(watchRoot, { recursive: true, persistent: false }, onFsChange);
-			watcher.on("error", () => {
-				watcherFailed = true;
-				try {
-					watcher?.close();
-				} catch {
-					/* ignore */
-				}
-				watcher = null;
-			});
-		} catch {
-			watcherFailed = true;
-			watcher = null;
-		}
+		if (round && !disposed) publish({ type: "growth", round, ts: Date.now() });
+		return round;
 	};
 
 	return {
 		version: GROWTH_TRACKER_VERSION,
 		getError: () => lastErrorMessage,
-		async prepare() {
-			// prepare 在首条 prompt 前同步执行：此刻就是轮次开始时刻，基线带上
-			// （晚落账时轮次窗口仍能对上；基线本身不进轮，但 fromTree 归属要用）
-			turnTs = Date.now();
-			startWatcher();
-			await ensureBaseline();
+		prepare() {
+			if (disabled || disposed) return chain;
+			return enqueue(async () => {
+				if (disabled || disposed) return;
+				published(await recordWorkspaceChanges(cwd, sessionPath));
+			});
 		},
 		onEvent(evt) {
 			if (disposed || disabled) return;
 			switch (evt.type) {
 				case "agent_start":
-					// 轮次开始时刻：本轮所有步的归属 ts（用户消息时间戳与之对齐，切窗才准）
-					turnTs = (evt as { ts?: number }).ts ?? Date.now();
-					startWatcher();
-					void ensureBaseline();
+					// 自动重试会再次 agent_start：一轮只从第一次开始算
+					if (runStart === null) runStart = entries().length;
 					break;
-				case "tool_execution_start": {
-					if (!isMutatingTool(evt.toolName)) break;
-					running.add(evt.toolCallId);
-					if (argsById.size > 64) argsById.delete(argsById.keys().next().value as string);
-					argsById.set(evt.toolCallId, (evt as { args?: unknown }).args);
-					if (externalTimer) {
-						clearTimeout(externalTimer);
-						externalTimer = undefined;
-					}
+				case "agent_settled": {
+					if (runStart === null) break;
+					const all = entries();
+					const run = all.slice(runStart);
+					const { ids, title } = promptsFromEntries(run);
+					runStart = null;
+					void enqueue(async () => {
+						if (disabled || disposed) return;
+						published(await commitRound(cwd, { kind: "round", session: sessionPath, title, promptIds: ids, status: roundStatus(run) }));
+					});
 					break;
 				}
-				case "tool_execution_end": {
-					if (!isMutatingTool(evt.toolName)) break;
-					running.delete(evt.toolCallId);
-					const args = argsById.get(evt.toolCallId);
-					argsById.delete(evt.toolCallId);
-					schedule({ kind: "tool", label: labelForTool(cwd, evt.toolName, args), toolCallId: evt.toolCallId, toolName: evt.toolName });
-					break;
-				}
-				case "agent_end":
-					running.clear();
-					// 先落下本轮最后一批工具快照，再写不依赖文件变化的轮次终点。
-					if (flushTimer) clearTimeout(flushTimer);
-					flush();
-					// 无文件变更的回合也持久化终点，轮数才能与真实用户轮次一致。
-					// turn 步同样按轮次开始时刻归属，防晚落账切错窗口。
-					if (!evt.willRetry) void enqueue(() => doRecord({ kind: "turn", label: "", ts: turnTs }, true));
-					turnTs = undefined;
-					break;
 				default:
 					break;
 			}
 		},
-		async snapshotNow(label = "") {
+		async recordNow() {
 			if (disabled) throw disabledFailure ?? new GrowthError("growth tracking is disabled for this workspace", "unavailable");
-			let result: GrowthStep | null = null;
+			let result: GrowthRound | null = null;
 			let failure: unknown;
 			await enqueue(async () => {
 				try {
 					if (disabled) throw disabledFailure ?? new GrowthError("growth tracking is disabled for this workspace", "unavailable");
-					const step = await snapshot(cwd, { kind: "manual", label, session: sessionPath });
-					if (errorActive) {
-						errorActive = false;
-						lastErrorMessage = null;
-						publish({ type: "growth_error", message: null, ts: Date.now() });
-					}
-					if (step) {
-						result = step;
-						publish({ type: "growth", step, ts: Date.now() });
-					}
+					result = published(await recordWorkspaceChanges(cwd, sessionPath));
 				} catch (error) {
 					failure = error;
 					reportError(error);
@@ -337,15 +146,6 @@ export function createGrowthTracker(opts: { cwd: string; sessionPath: string; pu
 		},
 		dispose() {
 			disposed = true;
-			if (flushTimer) clearTimeout(flushTimer);
-			if (pendingTimer) clearTimeout(pendingTimer);
-			if (externalTimer) clearTimeout(externalTimer);
-			try {
-				watcher?.close();
-			} catch {
-				/* ignore */
-			}
-			watcher = null;
 		},
 	};
 }

package/src/lib/growth-turns.ts

@@ -7,7 +7,7 @@ interface SessionEntry {
 	type?: string;
 	id?: string;
 	timestamp?: string | number;
-	message?: { role?: string; timestamp?: number };
+	message?: { role?: string; timestamp?: number; content?: unknown };
 }
 
 /** 与会话统计一样遍历全部 JSONL 条目，不使用压缩后的渲染消息列表。 */
@@ -21,3 +21,33 @@ export function userTurnsFromEntries(entries: readonly SessionEntry[]): SessionT
 	}
 	return turns;
 }
+
+export interface RoundPrompts {
+	/** 本轮的用户消息 entryId（按出现顺序） */
+	ids: string[];
+	/** 第一条用户消息的首个非空行（纯图片提问为空） */
+	title: string;
+}
+
+function textOf(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((part) => (part && typeof part === "object" && (part as { type?: unknown }).type === "text" ? String((part as { text?: unknown }).text ?? "") : ""))
+		.join("");
+}
+
+/**
+ * 一次运行（agent_start → agent_settled）新增的用户消息：首条提问 + steer / followUp 追加的消息。
+ * 遍历原始 JSONL 条目而不是渲染消息：上下文压缩后不再渲染的消息也算。
+ */
+export function promptsFromEntries(entries: readonly SessionEntry[], fromIndex = 0): RoundPrompts {
+	const ids: string[] = [];
+	let title = "";
+	for (const entry of entries.slice(Math.max(0, fromIndex))) {
+		if (entry.type !== "message" || entry.message?.role !== "user" || !entry.id) continue;
+		ids.push(entry.id);
+		if (!title) title = textOf(entry.message.content).split("\n").map((line) => line.trim()).find(Boolean) ?? "";
+	}
+	return { ids, title };
+}

package/src/lib/models/model-scope.ts

@@ -0,0 +1,15 @@
+import { resolveModelScopeWithDiagnostics } from "@earendil-works/pi-coding-agent";
+
+export type ModelScopeRuntime = Parameters<typeof resolveModelScopeWithDiagnostics>[1];
+
+/** 用 pi 自己的模型通配规则过滤 PiWeb 选择器里的模型 */
+export async function filterModelsByPiScope<T extends { provider: string; id: string }>(
+	models: T[],
+	patterns: string[],
+	runtime: ModelScopeRuntime,
+): Promise<T[]> {
+	if (patterns.length === 0) return models;
+	const { scopedModels } = await resolveModelScopeWithDiagnostics(patterns, runtime);
+	const allowed = new Set(scopedModels.map(({ model }) => `${model.provider}/${model.id}`));
+	return models.filter((model) => allowed.has(`${model.provider}/${model.id}`));
+}

package/src/lib/models-service.ts

@@ -10,7 +10,9 @@ import { request as httpsRequest } from "node:https";
 import { BlockList, isIP } from "node:net";
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import { getNodeValue, parseTree, printParseErrorCode, type ParseError } from "jsonc-parser";
+import { filterModelsByPiScope } from "./models/model-scope";
 import { getAgentDir, getModelRuntime, resetModelRuntime } from "./pi";
+import { getEnabledModelPatterns } from "./pi-settings";
 import { reloadSessionsForCwd } from "./agent-manager";
 import {
 	getSupportedThinkingLevels, InMemoryCredentialStore, InMemoryModelsStore,
@@ -103,6 +105,20 @@ export function listModels(): Promise<{
 	return value;
 }
 
+/** 对话里的模型选择器遵循 pi 的 enabledModels；设置页仍用完整目录 */
+export async function listModelsForPiWeb(): Promise<{ providers: ProviderView[]; models: ModelView[] }> {
+	const data = await listModels();
+	const patterns = await getEnabledModelPatterns();
+	if (!patterns?.length) return data;
+	const models = await filterModelsByPiScope(data.models, patterns, await getModelRuntime());
+	const counts = new Map<string, number>();
+	for (const model of models) counts.set(model.provider, (counts.get(model.provider) ?? 0) + 1);
+	return {
+		models,
+		providers: data.providers.map((provider) => ({ ...provider, modelCount: counts.get(provider.id) ?? 0 })),
+	};
+}
+
 /** auth.json 各条目的凭证类型（与 storedCredentialFor 同样的两层数据结构）；读取失败不影响目录 */
 async function readStoredAuthTypes(): Promise<Map<string, "api_key" | "oauth">> {
 	const out = new Map<string, "api_key" | "oauth">();

package/src/lib/pi-settings.ts

@@ -43,6 +43,13 @@ async function readSettingsFileStrict(): Promise<Record<string, unknown>> {
 	return parsed as Record<string, unknown>;
 }
 
+/** enabledModels 是 pi 的模型范围；没写或写错就不过滤 PiWeb 的选择器 */
+export async function getEnabledModelPatterns(): Promise<string[] | null> {
+	const patterns = (await readSettingsFileStrict()).enabledModels;
+	if (!Array.isArray(patterns) || patterns.some((pattern) => typeof pattern !== "string")) return null;
+	return patterns;
+}
+
 function section(raw: Record<string, unknown>, key: "compaction" | "retry"): Record<string, unknown> {
 	const value = raw[key];
 	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};

package/src/lib/pi.ts

@@ -9,7 +9,6 @@ import {
 	type SettingsManager,
 	DefaultPackageManager,
 	DefaultResourceLoader,
-	type InlineExtension,
 	ModelRuntime,
 	ProjectTrustStore,
 	SessionManager,
@@ -158,10 +157,10 @@ function loaderKey(cwd: string): string {
 }
 
 /** 每个热会话必须拥有自己的扩展 runtime；这里只创建，不加入发现缓存。 */
-export async function createSessionResourceLoader(cwd: string, extensionFactories: InlineExtension[] = []): Promise<DefaultResourceLoader> {
+export async function createSessionResourceLoader(cwd: string): Promise<DefaultResourceLoader> {
 	const settingsManager = getSettingsManager(cwd);
 	settingsManager.setProjectTrusted(resolveProjectTrust(cwd).trusted);
-	const loader = new DefaultResourceLoader({ cwd: path.resolve(cwd), agentDir: getAgentDir(), settingsManager, extensionFactories });
+	const loader = new DefaultResourceLoader({ cwd: path.resolve(cwd), agentDir: getAgentDir(), settingsManager });
 	const reload = loader.reload.bind(loader);
 	loader.reload = async (options) => {
 		settingsManager.setProjectTrusted(resolveProjectTrust(cwd).trusted);

package/src/lib/session-import/claude.ts

@@ -160,7 +160,6 @@ export const claudeSource: ImportSourceModule = {
 		const skipped: string[] = [];
 		let sidechains = 0;
 		let synthetic = 0;
-		let runtimeContext = 0;
 		let projectPath = summary.projectPath;
 		let model = summary.model;
 		let provider: string | undefined;
@@ -170,12 +169,6 @@ export const claudeSource: ImportSourceModule = {
 				sidechains += 1;
 				continue;
 			}
-			// Claude 的 attachment/system 是技能列表、token 提醒、环境快照等运行时上下文；
-			// pi 会按目标工作区生成自己的版本，不能伪装成真人 user 消息，但要在报告中明确告知。
-			if (record.type === "attachment" || record.type === "system") {
-				runtimeContext += 1;
-				continue;
-			}
 			if (typeof record.cwd === "string" && record.cwd.trim()) projectPath = projectPath ?? record.cwd;
 			const message = record.message as Record<string, unknown> | undefined;
 			if (!message) continue;
@@ -213,12 +206,9 @@ export const claudeSource: ImportSourceModule = {
 			if (record.type === "user") {
 				const { text: textBlocks, results } = splitUserContent((message as { content?: unknown }).content);
 				const plain = textBlocks.filter((block) => block.type === "text").map((block) => block.text).join("\n");
-				const nonText = textBlocks.filter((block) => block.type !== "text");
+				const keepText = textBlocks.filter((block) => block.type !== "text");
 				if (plain && !isSynthetic(plain.trim()) && !/^Caveat:/i.test(plain.trim())) {
-					entries.push({ type: "message", message: { role: "user", content: [...nonText, { type: "text", text: plain }], timestamp } as ImportedMessage });
-				} else if (!plain && nonText.length) {
-					// 图片可以是用户消息的全部内容，不能因为没有文字就把整轮丢掉
-					entries.push({ type: "message", message: { role: "user", content: nonText, timestamp } as ImportedMessage });
+					entries.push({ type: "message", message: { role: "user", content: [...keepText, { type: "text", text: plain }], timestamp } as ImportedMessage });
 				} else if (plain) {
 					synthetic += 1;
 				}
@@ -233,7 +223,6 @@ export const claudeSource: ImportSourceModule = {
 
 		if (sidechains) skipped.push(`跳过 ${sidechains} 条侧链（子代理）记录`);
 		if (synthetic) skipped.push(`跳过 ${synthetic} 条合成输入（命令回显/系统提醒）`);
-		if (runtimeContext) skipped.push(`跳过 ${runtimeContext} 条源工具运行时上下文（pi 会按当前工作区重新生成）`);
 		if (!entries.some((entry) => entry.type === "message")) return null;
 		return { summary: { ...summary, projectPath, model, provider }, entries, skipped };
 	},