@rexvane/piweb 0.3.14 → 0.3.16

package/src/lib/managed-niubash.ts

@@ -0,0 +1,231 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import * as nodeModule from "node:module";
+import path from "node:path";
+import { createBashToolDefinition, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { APP_ROOT } from "./app-root";
+
+const DISTRIBUTION_VERSION = "1.1.4-piweb.0";
+const NIUBASH_VERSION = "1.1.4";
+const SOURCE_REPOSITORY = "https://github.com/unixwin/niubash";
+const SOURCE_TAG = "v1.1.4";
+
+const PACKAGE_BY_ARCH = {
+	x64: {
+		packageName: "@rexvane/piweb-niubash-win32-x64",
+		directory: "piweb-niubash-win32-x64",
+		asset: "niubash-v1.1.4-win-x64.zip",
+		assetSha256: "9f543634288a316f7ed8e5a76ff794eca402cb21e74b8f8a551daffafde162f5",
+		machine: 0x8664,
+	},
+	arm64: {
+		packageName: "@rexvane/piweb-niubash-win32-arm64",
+		directory: "piweb-niubash-win32-arm64",
+		asset: "niubash-v1.1.4-win-arm64.zip",
+		assetSha256: "77e98ba8d7f6be70c35388bcc28bdbc883c06bcaafffbe186a88788ad32ccf00",
+		machine: 0xaa64,
+	},
+} as const;
+
+const LICENSE_HASHES = {
+	"NIUBASH.txt": "1290aae99e71239ee3154e7847830e49e7a36c758fa6d659d73fa752dc9f81c8",
+	"RUBASH.txt": "e426a75a20633f3088da22aef61a5a44d06f1f884c600f6011d00702c3989079",
+	"WINUXCMD.txt": "8ffc4ed56f5e6ab8183a7ece2e3aa6ea4800b0a4e8170d11bd60856f2dd760f3",
+} as const;
+
+export type SupportedArch = keyof typeof PACKAGE_BY_ARCH;
+
+type PackageExport = {
+	schema?: unknown;
+	packageName?: unknown;
+	distributionVersion?: unknown;
+	niubashVersion?: unknown;
+	platform?: unknown;
+	arch?: unknown;
+	runtimeDir?: unknown;
+	shellPath?: unknown;
+	manifestPath?: unknown;
+};
+
+type LoadedPackage = { entryPath: string; value: unknown };
+
+/**
+ * npm 安装（全局或本地）普通情况下由 Node 解析：npm 会把可选包提升到任意祖先
+ * node_modules，所以解析必须从包自己的 package.json 出发。仓库检出（开发 / CI /
+ * 发布前的 runtime 准备）没有安装这一步，此时按约定找 platform-packages/<dir>——
+ * 这与平台包发布后的目录布局一一对应，不引入第二套解析规则。
+ */
+export function resolveManagedNiubashPackageEntry(packageName: string, arch: SupportedArch, root = APP_ROOT): LoadedPackage {
+	// 必须通过命名空间调用。webpack 会改写从 node:module 具名导入的 createRequire：
+	// 参数不是字符串字面量时把调用擦掉，运行时变成对 undefined 调用 resolve。
+	const loadPackage = nodeModule.createRequire(path.join(root, "package.json"));
+	const resolveEntry = loadPackage.resolve.bind(loadPackage);
+	try {
+		const entryPath = resolveEntry(packageName);
+		return { entryPath, value: loadPackage(packageName) };
+	} catch (error) {
+		const checkoutEntry = path.join(root, "platform-packages", PACKAGE_BY_ARCH[arch].directory, "index.cjs");
+		if (fs.existsSync(checkoutEntry)) return { entryPath: checkoutEntry, value: loadPackage(checkoutEntry) };
+		throw error;
+	}
+}
+
+export type ManagedNiubashRuntime = {
+	packageName: string;
+	distributionVersion: string;
+	niubashVersion: string;
+	arch: SupportedArch;
+	runtimeDir: string;
+	shellPath: string;
+};
+
+export type ManagedNiubashResolveOptions = {
+	platform?: string;
+	arch?: string;
+	/** Base for package resolution; tests and the prepare script point it at a checkout root. */
+	root?: string;
+	loadPackage?: (packageName: string, arch: SupportedArch) => LoadedPackage;
+	warn?: (message: string) => void;
+};
+
+function sha256File(filename: string): string {
+	return crypto.createHash("sha256").update(fs.readFileSync(filename)).digest("hex");
+}
+
+function readJson(filename: string): any {
+	const stat = fs.statSync(filename);
+	if (!stat.isFile() || stat.size > 2 * 1024 * 1024) throw new Error(`${path.basename(filename)} is missing or too large`);
+	return JSON.parse(fs.readFileSync(filename, "utf8"));
+}
+
+function samePath(left: string, right: string): boolean {
+	const a = path.resolve(left);
+	const b = path.resolve(right);
+	return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+
+function peMachine(filename: string): number {
+	const data = fs.readFileSync(filename);
+	if (data.length < 64 || data[0] !== 0x4d || data[1] !== 0x5a) throw new Error(`${path.basename(filename)} is not a PE executable`);
+	const offset = data.readUInt32LE(0x3c);
+	if (offset + 6 > data.length || data.toString("ascii", offset, offset + 4) !== "PE\0\0") {
+		throw new Error(`${path.basename(filename)} has an invalid PE header`);
+	}
+	return data.readUInt16LE(offset + 4);
+}
+
+function validatePackage(loaded: LoadedPackage, arch: SupportedArch): ManagedNiubashRuntime {
+	const expected = PACKAGE_BY_ARCH[arch];
+	if (!loaded.value || typeof loaded.value !== "object") throw new Error(`${expected.packageName} has no runtime export`);
+	const exported = loaded.value as PackageExport;
+	const packageRoot = path.dirname(path.resolve(loaded.entryPath));
+	const runtimeDir = path.join(packageRoot, "runtime");
+	const shellPath = path.join(runtimeDir, "niu.exe");
+	const manifestPath = path.join(packageRoot, "runtime-manifest.json");
+
+	const checks: Array<[unknown, unknown, string]> = [
+		[exported.schema, 1, "export schema"],
+		[exported.packageName, expected.packageName, "export package name"],
+		[exported.distributionVersion, DISTRIBUTION_VERSION, "export distribution version"],
+		[exported.niubashVersion, NIUBASH_VERSION, "export niubash version"],
+		[exported.platform, "win32", "export platform"],
+		[exported.arch, arch, "export architecture"],
+	];
+	for (const [actual, wanted, label] of checks) {
+		if (actual !== wanted) throw new Error(`${label} mismatch`);
+	}
+	if (typeof exported.runtimeDir !== "string" || !samePath(exported.runtimeDir, runtimeDir)) throw new Error("runtime directory escapes its package");
+	if (typeof exported.shellPath !== "string" || !samePath(exported.shellPath, shellPath)) throw new Error("shell path escapes its package");
+	if (typeof exported.manifestPath !== "string" || !samePath(exported.manifestPath, manifestPath)) throw new Error("manifest path escapes its package");
+
+	const packageInfo = readJson(path.join(packageRoot, "package.json"));
+	if (packageInfo.name !== expected.packageName || packageInfo.version !== DISTRIBUTION_VERSION) throw new Error("package identity mismatch");
+	if (packageInfo.os?.length !== 1 || packageInfo.os[0] !== "win32") throw new Error("package OS restriction mismatch");
+	if (packageInfo.cpu?.length !== 1 || packageInfo.cpu[0] !== arch) throw new Error("package CPU restriction mismatch");
+
+	const manifest = readJson(manifestPath);
+	if (manifest.schema !== 1
+		|| manifest.source?.repository !== SOURCE_REPOSITORY
+		|| manifest.source?.tag !== SOURCE_TAG
+		|| manifest.source?.asset !== expected.asset
+		|| manifest.source?.sha256 !== expected.assetSha256) {
+		throw new Error("runtime provenance mismatch");
+	}
+	if (!manifest.files || typeof manifest.files !== "object" || Array.isArray(manifest.files)) throw new Error("runtime file manifest is missing");
+	const files = Object.entries(manifest.files) as Array<[string, unknown]>;
+	if (files.length < 300 || files.length > 1000) throw new Error(`runtime file count is invalid (${files.length})`);
+	for (const [relative, digest] of files) {
+		if (!relative || relative.includes("\\") || path.posix.isAbsolute(relative) || /^[A-Za-z]:/.test(relative) || relative.split("/").includes("..")) {
+			throw new Error(`unsafe runtime path: ${relative}`);
+		}
+		if (typeof digest !== "string" || !/^[a-f0-9]{64}$/.test(digest)) throw new Error(`invalid runtime hash: ${relative}`);
+		const filename = path.join(runtimeDir, ...relative.split("/"));
+		if (!fs.statSync(filename).isFile()) throw new Error(`runtime file is missing: ${relative}`);
+		if (sha256File(filename) !== digest) throw new Error(`runtime file failed integrity check: ${relative}`);
+	}
+	for (const required of ["niu.exe", "winuxcmd/usr/bin/winuxcmd.exe", "bundles/oh-my-niu/bundle.toml"]) {
+		if (!(required in manifest.files)) throw new Error(`runtime file is missing: ${required}`);
+	}
+	for (const executable of [shellPath, path.join(runtimeDir, "winuxcmd", "usr", "bin", "winuxcmd.exe")]) {
+		if (peMachine(executable) !== expected.machine) throw new Error(`${path.basename(executable)} architecture mismatch`);
+	}
+	for (const [name, digest] of Object.entries(LICENSE_HASHES)) {
+		if (sha256File(path.join(packageRoot, "licenses", name)) !== digest) throw new Error(`license integrity check failed: ${name}`);
+	}
+
+	return Object.freeze({
+		packageName: expected.packageName,
+		distributionVersion: DISTRIBUTION_VERSION,
+		niubashVersion: NIUBASH_VERSION,
+		arch,
+		runtimeDir,
+		shellPath,
+	});
+}
+
+function reasonOf(error: unknown, packageName: string): string {
+	if ((error as NodeJS.ErrnoException | undefined)?.code === "MODULE_NOT_FOUND") return `${packageName} is not installed`;
+	return error instanceof Error ? error.message : String(error);
+}
+
+/** Resolve and fully validate the platform package. Failures deliberately fall back to Pi's normal Bash. */
+export function resolveManagedNiubash(options: ManagedNiubashResolveOptions = {}): ManagedNiubashRuntime | null {
+	const platform = options.platform ?? process.platform;
+	const arch = options.arch ?? process.arch;
+	if (platform !== "win32") return null;
+	const expected = PACKAGE_BY_ARCH[arch as SupportedArch];
+	if (!expected) {
+		(options.warn ?? console.warn)(`[piweb] Managed niubash does not support Windows ${arch}; using Pi's configured/default Bash.`);
+		return null;
+	}
+	const supported = arch as SupportedArch;
+	try {
+		const loaded = options.loadPackage
+			? options.loadPackage(expected.packageName, supported)
+			: resolveManagedNiubashPackageEntry(expected.packageName, supported, options.root);
+		return validatePackage(loaded, supported);
+	} catch (error) {
+		(options.warn ?? console.warn)(
+			`[piweb] Managed niubash is unavailable (${reasonOf(error, expected.packageName)}); using Pi's configured/default Bash. `
+			+ "Reinstall @rexvane/piweb to restore the bundled Windows shell (`npm run prepare:niubash` in a checkout).",
+		);
+		return null;
+	}
+}
+
+const globalForManagedNiubash = globalThis as typeof globalThis & {
+	__piWebManagedNiubash?: { resolved: ManagedNiubashRuntime | null };
+};
+
+function defaultRuntime(): ManagedNiubashRuntime | null {
+	if (!globalForManagedNiubash.__piWebManagedNiubash) {
+		globalForManagedNiubash.__piWebManagedNiubash = { resolved: resolveManagedNiubash() };
+	}
+	return globalForManagedNiubash.__piWebManagedNiubash.resolved;
+}
+
+/** Same-name custom tool intentionally replaces Pi's built-in bash only inside PiWeb sessions. */
+export function createManagedNiubashTools(cwd: string, options?: ManagedNiubashResolveOptions): ToolDefinition[] {
+	const runtime = options ? resolveManagedNiubash(options) : defaultRuntime();
+	return runtime ? [createBashToolDefinition(cwd, { shellPath: runtime.shellPath }) as ToolDefinition] : [];
+}

package/src/lib/pi.ts

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

package/src/lib/runtime-activity.ts

@@ -0,0 +1,27 @@
+type ActivityKind = "session" | "swarm" | "tests";
+interface Registry { active: Map<symbol, ActivityKind>; maintenance: boolean }
+
+// Route bundles must share a process-wide gate, not separate module-local registries.
+const globals = globalThis as typeof globalThis & { __piwebRuntimeActivity?: Registry };
+const registry = globals.__piwebRuntimeActivity ??= { active: new Map(), maintenance: false };
+
+export class RuntimeBusyError extends Error {}
+
+export function beginActivity(kind: ActivityKind): () => void {
+  if (registry.maintenance) throw new RuntimeBusyError("update maintenance is active; wait for the release to finish");
+  const token = Symbol(kind);
+  registry.active.set(token, kind);
+  return () => { registry.active.delete(token); };
+}
+
+export function beginMaintenance(): () => void {
+  if (registry.maintenance || registry.active.size) {
+    throw new RuntimeBusyError("work is active; wait for sessions, swarms and tests to finish before entering the maintenance window");
+  }
+  registry.maintenance = true;
+  let released = false;
+  return () => {
+    if (!released) registry.maintenance = false;
+    released = true;
+  };
+}

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

@@ -160,6 +160,7 @@ 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;
@@ -169,6 +170,12 @@ 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;
@@ -206,9 +213,12 @@ 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 keepText = textBlocks.filter((block) => block.type !== "text");
+				const nonText = textBlocks.filter((block) => block.type !== "text");
 				if (plain && !isSynthetic(plain.trim()) && !/^Caveat:/i.test(plain.trim())) {
-					entries.push({ type: "message", message: { role: "user", content: [...keepText, { type: "text", text: plain }], timestamp } as ImportedMessage });
+					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 });
 				} else if (plain) {
 					synthetic += 1;
 				}
@@ -223,6 +233,7 @@ 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 };
 	},

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

@@ -7,10 +7,10 @@
  */
 import path from "node:path";
 import fs from "node:fs/promises";
-import { eachJsonLine, listFiles, readHead, reachedLimit, sortByRecency } from "./files";
+import { eachJsonLine, listFiles, readHead, readTail, reachedLimit, statMtime } from "./files";
 import { codexRoot } from "./paths";
 import type { ExternalSessionSummary, ImportedBlock, ImportedEntry, ImportedSession, ImportSourceModule, ScanOptions } from "./types";
-import { cleanTitle, compactBlocks, outputBlocks, parseArguments, textBlock, toEpochMs } from "./types";
+import { cleanTitle, compactBlocks, dataUrlImageBlock, outputBlocks, parseArguments, textBlock, toEpochMs } from "./types";
 
 const ROOT = codexRoot;
 
@@ -80,6 +80,7 @@ function messageBlocks(payload: Record<string, unknown>): ImportedBlock[] {
 	if (!Array.isArray(content)) return compactBlocks([textBlock(typeof content === "string" ? content : undefined)]);
 	return compactBlocks(content.flatMap((raw): Array<ImportedBlock | null> => {
 		const block = raw as Record<string, unknown>;
+		if (block?.type === "input_image") return [dataUrlImageBlock(block.image_url, block.mime_type)];
 		if (typeof block?.text === "string") return [textBlock(block.text)];
 		return [];
 	}));
@@ -95,6 +96,17 @@ function reasoningText(payload: Record<string, unknown>): ImportedBlock | null {
 	return null;
 }
 
+/** 文件 mtime 可能因复制/恢复失真；Codex 每行自带时间，末尾记录才是权威的最近活动时间 */
+function latestTimestamp(records: Record<string, unknown>[]): number | undefined {
+	let latest: number | undefined;
+	for (const record of records) {
+		const payload = record.payload as Record<string, unknown> | undefined;
+		const at = toEpochMs(record.timestamp) ?? toEpochMs(payload?.timestamp);
+		if (at !== undefined) latest = Math.max(latest ?? at, at);
+	}
+	return latest;
+}
+
 /** 标题：Codex 不写标题字段，用首条真人用户消息（rollout 头几十行里就有） */
 function titleFrom(records: Record<string, unknown>[]): string | undefined {
 	for (const record of records) {
@@ -113,10 +125,22 @@ export const codexSource: ImportSourceModule = {
 
 	async scan(options?: ScanOptions): Promise<ExternalSessionSummary[]> {
 		const limit = options?.limit ?? 0;
-		const candidates = await sortByRecency(await listFiles(ROOT(), { match: (name) => name.startsWith("rollout-") && name.endsWith(".jsonl") }));
+		const files = await listFiles(ROOT(), { match: (name) => name.startsWith("rollout-") && name.endsWith(".jsonl") });
+		// 只读每个文件末尾 64KB 就能按记录时间正确排序；不能先按 mtime 截断，否则复制过的旧文件会挤掉真正最近的会话。
+		const candidates = await Promise.all(files.map(async (file) => {
+			const mtime = await statMtime(file);
+			try {
+				const updatedAt = latestTimestamp([...eachJsonLine(await readTail(file))]);
+				return { file, mtime, updatedAt: updatedAt ?? mtime };
+			} catch {
+				return { file, mtime, updatedAt: mtime };
+			}
+		}));
+		candidates.sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0));
+
 		const out: ExternalSessionSummary[] = [];
-		for (const { file, mtime } of candidates) {
-			if (reachedLimit(out.length, limit)) break; // 只读最近的若干条
+		for (const { file, mtime, updatedAt } of candidates) {
+			if (reachedLimit(out.length, limit)) break;
 			let head: string;
 			try {
 				head = await readHead(file);
@@ -136,7 +160,7 @@ export const codexSource: ImportSourceModule = {
 				model: meta.model,
 				provider: meta.provider,
 				createdAt: meta.createdAt ?? mtime,
-				updatedAt: mtime,
+				updatedAt,
 				location: file,
 			});
 		}
@@ -154,11 +178,18 @@ export const codexSource: ImportSourceModule = {
 		const skipped: string[] = [];
 		let synthetic = 0;
 		let reasoningSkipped = 0;
+		let runtimeContext = 0;
 		let meta: Meta = { cwd: summary.projectPath, createdAt: summary.createdAt, model: summary.model, provider: summary.provider };
 
 		for (const record of eachJsonLine(text)) {
 			if (record.type === "session_meta") {
 				meta = { ...meta, ...metaFrom([record]) };
+				const payload = record.payload as Record<string, unknown> | undefined;
+				if (payload?.base_instructions) runtimeContext += 1;
+				continue;
+			}
+			if (record.type === "world_state" || record.type === "turn_context") {
+				runtimeContext += 1;
 				continue;
 			}
 			if (record.type !== "response_item") continue;
@@ -169,11 +200,15 @@ export const codexSource: ImportSourceModule = {
 			switch (payload.type) {
 				case "message": {
 					const role = payload.role;
-					if (role === "developer") continue; // 系统提示，不进对话
+					if (role === "developer") {
+						runtimeContext += 1; // 系统/开发者上下文由 pi 按当前工作区重新生成
+						continue;
+					}
 					const blocks = messageBlocks(payload);
 					const plain = blocks.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
 					if (role === "user") {
-						if (!plain || isSynthetic(plain)) {
+						// 只有图片的真人输入也必须保留；纯文本的环境/AGENTS 注入仍不冒充用户消息
+						if (!blocks.length || (plain && isSynthetic(plain))) {
 							synthetic += 1;
 							continue;
 						}
@@ -217,6 +252,7 @@ export const codexSource: ImportSourceModule = {
 
 		if (synthetic) skipped.push(`跳过 ${synthetic} 条合成输入`);
 		if (reasoningSkipped) skipped.push(`跳过 ${reasoningSkipped} 条仅含加密内容的推理记录`);
+		if (runtimeContext) skipped.push(`跳过 ${runtimeContext} 条源工具运行时上下文（pi 会按当前工作区重新生成）`);
 		if (!entries.some((entry) => entry.type === "message")) return null;
 		return { summary: { ...summary, ...meta, projectPath: meta.cwd, model: meta.model, provider: meta.provider }, entries, skipped };
 	},

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

@@ -13,6 +13,20 @@ export async function readHead(file: string, bytes = 64 * 1024): Promise<string>
 	}
 }
 
+/** 读文件末尾若干字节；首行可能是被截断的半行，JSONL 解析时会自然跳过 */
+export async function readTail(file: string, bytes = 64 * 1024): Promise<string> {
+	const handle = await fs.open(file, "r");
+	try {
+		const size = (await handle.stat()).size;
+		const length = Math.min(size, bytes);
+		const buffer = Buffer.alloc(length);
+		const { bytesRead } = await handle.read(buffer, 0, length, size - length);
+		return buffer.subarray(0, bytesRead).toString("utf8");
+	} finally {
+		await handle.close();
+	}
+}
+
 /** 逐行解析 JSONL；单行坏掉只跳过该行，不放弃整个文件 */
 export function* eachJsonLine(text: string): Generator<Record<string, unknown>> {
 	for (const line of text.split("\n")) {

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

@@ -6,10 +6,10 @@
  */
 import path from "node:path";
 import fs from "node:fs/promises";
-import { eachJsonLine, listFiles, readHead, reachedLimit, sortByRecency } from "./files";
+import { eachJsonLine, listFiles, readHead, reachedLimit, statMtime } from "./files";
 import { grokRoot } from "./paths";
 import type { ExternalSessionSummary, ImportedBlock, ImportedEntry, ImportedSession, ImportSourceModule, ScanOptions } from "./types";
-import { cleanTitle, compactBlocks, outputBlocks, parseArguments, textBlock, toEpochMs } from "./types";
+import { cleanTitle, compactBlocks, dataUrlImageBlock, outputBlocks, parseArguments, textBlock, toEpochMs } from "./types";
 
 const ROOT = grokRoot;
 
@@ -30,10 +30,10 @@ function decodeProjectDir(name: string): string | undefined {
 function importable(records: Record<string, unknown>[]): boolean {
 	for (const record of records) {
 		if (record.type === "assistant" || record.type === "tool_result") return true;
-		if (record.type === "reasoning" && typeof record.summary === "string" && record.summary.trim()) return true;
+		if (record.type === "reasoning" && reasoningText(record.summary)) return true;
 		if (record.type !== "user" || record.synthetic_reason) continue;
 		const blocks = userBlocks(record.content);
-		if (blocks.some((block) => block.type === "text" && block.text.replace(/<[^>]+>/g, "").trim())) return true;
+		if (blocks.some((block) => block.type === "image" || (block.type === "text" && block.text.replace(/<[^>]+>/g, "").trim()))) return true;
 	}
 	return false;
 }
@@ -46,41 +46,69 @@ async function hasRealMessage(history: string): Promise<boolean> {
 	}
 }
 
-/** user 的 content 可能是字符串或块数组 */function userBlocks(content: unknown): ImportedBlock[] {
+/** user 的 content 可能是字符串、文本块或 data URL 图片块 */
+function userBlocks(content: unknown): ImportedBlock[] {
 	if (typeof content === "string") return compactBlocks([textBlock(content)]);
 	if (!Array.isArray(content)) return [];
 	return compactBlocks(content.flatMap((raw): Array<ImportedBlock | null> => {
 		if (typeof raw === "string") return [textBlock(raw)];
 		const block = raw as Record<string, unknown>;
 		if (typeof block?.text === "string") return [textBlock(block.text)];
+		if (block?.type === "image") return [dataUrlImageBlock(block.url, block.mime ?? block.mimeType)];
 		return [];
 	}));
 }
 
+/** Grok 新版把 reasoning.summary 从字符串改成了 summary_text 块数组；两代格式都要读 */
+function reasoningText(summary: unknown): string {
+	if (typeof summary === "string") return summary.trim();
+	if (!Array.isArray(summary)) return "";
+	return summary
+		.map((item) => {
+			if (typeof item === "string") return item;
+			const block = item as { text?: unknown; summary_text?: unknown };
+			return typeof block?.text === "string" ? block.text : typeof block?.summary_text === "string" ? block.summary_text : "";
+		})
+		.filter(Boolean)
+		.join("\n")
+		.trim();
+}
+
 export const grokSource: ImportSourceModule = {
 	id: "grok",
 
 	async scan(options?: ScanOptions): Promise<ExternalSessionSummary[]> {
-		// 先按 chat_history 的 mtime 排序（只 stat，不读内容），再从最近往下读：
-		// summary.json 里有标题/模型/时间/消息数，读它即可，正文只在确认有真实对话时碰一下头部
 		const limit = options?.limit ?? 0;
 		const files = await listFiles(ROOT(), { match: (name) => name === "summary.json" });
-		const candidates = await sortByRecency(files.map((file) => path.join(path.dirname(file), "chat_history.jsonl")));
-		const out: ExternalSessionSummary[] = [];
-		for (const { file: history, mtime } of candidates) {
-			if (reachedLimit(out.length, limit)) break; // 只读最近的若干条
-			const dir = path.dirname(history);
-			let summary: Record<string, unknown>;
+		// summary.updated_at / last_active_at 是 Grok 的权威活动时间。必须先按它排序再 LIMIT，
+		// 不能用复制、恢复备份时会变化的 chat_history mtime 决定“最近 15 条”。
+		const candidates = (await Promise.all(files.map(async (summaryFile) => {
+			const dir = path.dirname(summaryFile);
+			const history = path.join(dir, "chat_history.jsonl");
 			try {
-				summary = JSON.parse(await fs.readFile(path.join(dir, "summary.json"), "utf8")) as Record<string, unknown>;
+				const summary = JSON.parse(await fs.readFile(summaryFile, "utf8")) as Record<string, unknown>;
+				const mtime = await statMtime(history);
+				if (mtime === undefined) return null;
+				return {
+					dir,
+					history,
+					summary,
+					mtime,
+					updatedAt: toEpochMs(summary.updated_at ?? summary.last_active_at) ?? mtime,
+				};
 			} catch {
-				continue;
+				return null;
 			}
-			if (mtime === undefined) continue; // 没有正文就没什么可导
+		}))).filter((candidate): candidate is NonNullable<typeof candidate> => candidate !== null)
+			.sort((left, right) => right.updatedAt - left.updatedAt);
+
+		const out: ExternalSessionSummary[] = [];
+		for (const { dir, history, summary, mtime, updatedAt } of candidates) {
+			if (reachedLimit(out.length, limit)) break;
 			const info = summary.info as Record<string, unknown> | undefined;
-			const numMessages = Number(summary.num_messages ?? summary.num_chat_messages);
+			// num_messages 包含 trace/内部事件；num_chat_messages 才对应 chat_history 的会话记录数
+			const numMessages = Number(summary.num_chat_messages ?? summary.num_messages);
 			// 子代理会话（grok 的 spawn_subagent：subagent / subagent_fork / subagent_resume，本机 24 条）
-			// 以及它们的派生：agent_name 是 general-purpose / explore 之类，不是你在用的那条对话
 			if (typeof summary.session_kind === "string" && summary.session_kind.startsWith("subagent")) continue;
 			if (numMessages === 0) continue; // 开了没用的空会话
 			// 只有系统提示与合成提醒（system_reminder）的会话读不出对话，别列进列表
@@ -92,7 +120,7 @@ export const grokSource: ImportSourceModule = {
 				projectPath: typeof info?.cwd === "string" ? info.cwd : decodeProjectDir(path.basename(path.dirname(dir))),
 				model: typeof summary.current_model_id === "string" ? summary.current_model_id : undefined,
 				createdAt: toEpochMs(summary.created_at) ?? mtime,
-				updatedAt: toEpochMs(summary.updated_at ?? summary.last_active_at) ?? mtime,
+				updatedAt,
 				...(Number.isFinite(numMessages) ? { messageCount: numMessages } : {}),
 				location: history,
 			});
@@ -111,17 +139,18 @@ export const grokSource: ImportSourceModule = {
 		const skipped: string[] = [];
 		let encryptedReasoning = 0;
 		let synthetic = 0;
+		let runtimeContext = 0;
 		let model = summary.model;
 
 		for (const record of eachJsonLine(text)) {
 			const timestamp = toEpochMs(record.timestamp ?? record.time ?? record.created_at) ?? summary.createdAt ?? Date.now();
 			switch (record.type) {
 				case "system":
-					continue; // 系统提示不进对话
+					runtimeContext += 1;
+					continue; // 系统提示由 pi 按目标工作区重新生成，不冒充用户消息
 				case "user": {
 					const blocks = userBlocks(record.content);
-					const plain = blocks.map((block) => (block.type === "text" ? block.text : "")).join("\n").trim();
-					if (record.synthetic_reason || !plain) {
+					if (record.synthetic_reason || !blocks.length) {
 						synthetic += 1;
 						continue;
 					}
@@ -145,8 +174,8 @@ export const grokSource: ImportSourceModule = {
 					continue;
 				}
 				case "reasoning": {
-					const text = typeof record.summary === "string" ? record.summary : "";
-					if (text.trim()) entries.push({ type: "message", message: { role: "assistant", content: [{ type: "thinking", thinking: text }], timestamp, ...(model ? { model } : {}) } });
+					const text = reasoningText(record.summary);
+					if (text) entries.push({ type: "message", message: { role: "assistant", content: [{ type: "thinking", thinking: text }], timestamp, ...(model ? { model } : {}) } });
 					else encryptedReasoning += 1; // 加密推理无正文可导：计数后汇总成一行，不要刷屏
 					continue;
 				}
@@ -163,6 +192,7 @@ export const grokSource: ImportSourceModule = {
 
 		if (synthetic) skipped.push(`跳过 ${synthetic} 条合成输入`);
 		if (encryptedReasoning) skipped.push(`跳过 ${encryptedReasoning} 条仅含加密内容的推理记录`);
+		if (runtimeContext) skipped.push(`跳过 ${runtimeContext} 条源工具运行时上下文（pi 会按当前工作区重新生成）`);
 		if (!entries.some((entry) => entry.type === "message")) return null;
 		return { summary: { ...summary, model }, entries, skipped };
 	},

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

@@ -18,6 +18,7 @@ import { dshSource } from "./dsh";
 import { zcodeSource } from "./zcode";
 import { opencodeSource } from "./opencode";
 import { importedKey, listImportedKeys, findImported, writeImportedSession } from "./writer";
+import { withImportLock } from "./lock";
 
 export const IMPORT_SOURCE_MODULES: Record<ImportSource, ImportSourceModule> = {
 	claude: claudeSource,
@@ -146,6 +147,10 @@ async function oversize(location: string): Promise<boolean> {
 }
 
 export async function importSessions(items: ImportSelection[], options: ImportOptions): Promise<ImportReport> {
+	return withImportLock(options.agentDir, () => importSessionsLocked(items, options));
+}
+
+async function importSessionsLocked(items: ImportSelection[], options: ImportOptions): Promise<ImportReport> {
 	const results: ImportOutcome[] = [];
 	const workspaces = new Set<string>();
 	const fallback = (await isDirectory(options.fallbackCwd)) ? path.resolve(options.fallbackCwd as string) : undefined;