@davideasden/pi-undo 0.2.24 → 0.2.25

package/README.md

@@ -19,7 +19,7 @@ Each completed agent run creates a checkpoint that captures both the Pi session
 
 ## Requirements
 
-- Pi `0.80.10` 或更高版本（已在 0.84.4 上验证）。
+- Pi `0.86.1` 或更高版本（已在 0.86.1 上验证）。`0.84.4` 及更早版本不再受支持，也不在 CI 中测试：早期版本的会话树与扩展生命周期行为不同，不保证撤回语义正确。
 - Node.js `22.19.0` or later.
 - Git available on `PATH` (used internally for content-addressed snapshots).
 
@@ -104,6 +104,29 @@ Returns to the previous completed run on the current branch. Before restoring, i
 
 After a successful undo, text entered during the operation is replayed into the editor. RPC mode reports the refill request; print and JSON modes do not replay prompts.
 
+撤回会等待当前轮次的输入快照和检查点完成，再选择撤回目标；Pi 已空闲但检查点仍在生成时，不会提前撤回上一轮。检查点生成失败会明确暂停历史。
+
+### 取消与超时
+
+执行较慢时，状态栏会显示当前阶段、经过的秒数和操作 ID。可以输入：
+
+```text
+/undo-cancel
+```
+
+此命令请求安全停止正在执行的撤回或重做。已开始的文件写入会先结束，未提交的事务随后按日志恢复。已经持久提交的操作会继续完成清理。取消或超时分别报告 `operation_cancelled`、`operation_timeout`；无法确认子进程停止或恢复一致性时，保留隔离并报告 `recovery_required`。
+
+默认单次 Git 调用预算为 120 秒，每次撤回、捕获及恢复预算为 300 秒。可在启动 Pi 前用正整数毫秒调整：
+
+```bash
+export PI_UNDO_GIT_TIMEOUT_MS=180000
+export PI_UNDO_OPERATION_TIMEOUT_MS=600000
+```
+
+补偿使用独立预算，避免继承前向操作的取消信号。磁盘 I/O 若无法中断，状态会保留到在途任务结束；超时不表示可以立即释放仍在写入的工作区锁。
+
+长操作或失败会在 `<sessionDir>/.pi-undo/diagnostics/<sessionId>-latest.json` 保存最近一次诊断，包含操作 ID、阶段、耗时、Git 子命令名和退出结果，不包含提示词、文件内容、完整参数或子进程输出。重新运行 `/undo-recover`、切换会话或退出时，会先等待旧 runtime 的任务和后台持久化结束。
+
 ### Redo
 
 ```text
@@ -138,6 +161,16 @@ recovery_required
 
 ### Performance Notes
 
+本次优化将普通文件原生恢复路径的完整拓扑扫描从 7 次减到 5 次，并以有界并发枚举目录。仍会发现 Git 忽略目录中的嵌套仓库，保留路径枚举后与文件恢复后的拓扑复核。没有使用 TTL 缓存或默认跳过 `node_modules`。
+
+可通过真实 Pi 0.86.1 SDK 和离线 faux provider 运行大型工作区基准；它覆盖 3,000／10,000 个依赖包、修改 1／100 个文件，每组撤回三次并验证重做：
+
+```bash
+PI_UNDO_LARGE_WORKSPACE=1 npx vitest run test/large-workspace.test.ts
+```
+
+输出包含扫描次数、每次耗时、进程峰值 RSS 和事件循环延迟；常规测试以扫描次数作为性能门槛，避免使用易受机器负载影响的墙钟阈值。
+
 Real-world measurements from a 104-file undo operation before optimizations:
 
 ```text

package/extensions/pi-undo.ts

@@ -9,7 +9,7 @@ import type {
 	SessionTreeEvent as PiSessionTreeEvent,
 } from "@earendil-works/pi-coding-agent";
 
-import type { OperationResult, UndoController } from "../src/controller.ts";
+import type { OperationResult, SessionTreeEvent, UndoController } from "../src/controller.ts";
 import { browseDiff } from "../src/diff-ui.ts";
 import { computeCheckpointDiff, type DiffSource, formatDiffSummary, sanitizeDisplayText } from "../src/diff-view.ts";
 import { createPiUndoRuntime } from "../src/pi-runtime.ts";
@@ -22,6 +22,8 @@ export interface PiUndoRuntime {
 	readonly recovery?: { readonly reason?: string; readonly files?: number; readonly opId?: string };
 	setCommandContext?(context: ExtensionCommandContext | undefined): void;
 	isInternalNavigation?(): boolean;
+	normalizeTreeEvent?(event: PiSessionTreeEvent): SessionTreeEvent;
+	dispose?(): Promise<void>;
 }
 
 export type PiUndoRuntimeFactory = (
@@ -55,9 +57,24 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 		let activeAction: "undo" | "redo" | undefined;
 		let captureFailureNotified = false;
 		let recoveryHintNotified = false;
+		let clearTreeWatch: (() => void) | undefined;
+		let initializing = false;
 
 		const initialize = async (context: ExtensionContext): Promise<void> => {
+			if (initializing) return;
+			initializing = true;
+			try {
+				clearTreeWatch?.();
+				if (runtime?.dispose !== undefined) await runtime.dispose();
+				else await runtime?.controller.dispose?.();
+			} catch (error) {
+				initializing = false;
+				runtime?.reporter.setRecoveryRequired(errorMessage(error));
+				context.ui.notify(`旧任务尚未安全结束：${errorMessage(error)}`, "error");
+				return;
+			}
 			const currentGeneration = ++generation;
+			restoreDeferredPrompts(context);
 			runtimeContext = context;
 			deferredPrompts = [];
 			replaying = undefined;
@@ -82,19 +99,21 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 				if (currentGeneration !== generation) return;
 				runtime = undefined;
 				new StatusReporter(context).setRecoveryRequired(errorMessage(error));
+			} finally {
+				initializing = false;
 			}
 		};
 
 		const dispatchDeferredPrompt = (active: PiUndoRuntime, expectedGeneration: number): void => {
 			if (
-				expectedGeneration !== generation || runtime !== active || activeCommands.size > 0 ||
+				initializing || expectedGeneration !== generation || runtime !== active || activeCommands.size > 0 ||
 				replaying !== undefined || deferredPrompts.length === 0 || active.controller.history().locked
 			) return;
 			const prompt = deferredPrompts[0]!;
 			replaying = prompt;
 			acceptedReplay = undefined;
 			queueMicrotask(() => {
-				if (expectedGeneration !== generation || runtime !== active || replaying !== prompt) return;
+				if (initializing || expectedGeneration !== generation || runtime !== active || replaying !== prompt) return;
 				try {
 					pi.sendUserMessage(prompt.images === undefined || prompt.images.length === 0
 						? prompt.text
@@ -144,7 +163,7 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 		): Promise<void> => {
 			const active = runtime;
 			const commandGeneration = generation;
-			if (active === undefined) {
+			if (active === undefined || initializing) {
 				context.ui.notify("pi-undo session unavailable", "warning");
 				return;
 			}
@@ -153,8 +172,8 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 			// 只有当前执行命令能安装/清理导航上下文；busy 的第二个命令不得覆盖或清空它。
 			const ownsCommandContext = commandSet.size === 0;
 			commandSet.add(commandToken);
-			activeAction = action;
-			active.reporter.setPhase(action === "undo" ? "undoing" : "redoing");
+			if (ownsCommandContext) activeAction = action;
+			if (ownsCommandContext) active.reporter.setPhase(action === "undo" ? "undoing" : "redoing");
 			if (ownsCommandContext) active.setCommandContext?.(context);
 			const commandStarted = performance.now();
 			let result: OperationResult;
@@ -176,6 +195,10 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 					message: active.controller.recoveryReason?.() ?? "pending journal",
 				};
 			}
+			if (!ownsCommandContext) {
+				context.ui.notify(`${result.code} files:${result.changedFiles}`, "warning");
+				return;
+			}
 			active.reporter.result(result, performance.now() - commandStarted);
 			if (result.code === "recovery_required" && !recoveryHintNotified) {
 				recoveryHintNotified = true;
@@ -240,6 +263,13 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 			description: "Review files changed by an Agent run (latest, or /diff N)",
 			handler: async (args: string, context: ExtensionCommandContext) => runDiff(args, context),
 		});
+		pi.registerCommand("undo-cancel", {
+			description: "安全停止正在执行的撤回或重做",
+			handler: async (_args: string, context: ExtensionCommandContext) => {
+				const requested = runtime?.controller.cancelOperation?.() ?? false;
+				context.ui.notify(requested ? "已请求停止，正在等待写入结束并恢复一致状态" : "当前没有可取消的撤回操作", "info");
+			},
+		});
 		pi.registerCommand("undo-recover", {
 			description: "Re-run pi-undo recovery and refresh undo history",
 			handler: async (_args: string, context: ExtensionCommandContext) => {
@@ -266,6 +296,10 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 		pi.on("session_start", async (_event: unknown, context: ExtensionContext) => initialize(context));
 		pi.on("input", async (event: InputEvent, context: ExtensionContext) => {
 			const active = runtime;
+			if (initializing) {
+				restoreEditorText(context, event.text);
+				return { action: "handled" as const };
+			}
 			if (active === undefined) return { action: "continue" as const };
 			const inputContext = { streaming: event.streamingBehavior !== undefined };
 			const result = active.controller.beginInput !== undefined
@@ -354,29 +388,52 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 			if (active === undefined) return;
 			await active.controller.agentSettled();
 			if (runtime !== active || generation !== settledGeneration) return;
-			resumeDeferredPrompts(
+			if (activeCommands.size === 0) resumeDeferredPrompts(
 				active,
 				settledGeneration,
 				active.controller.recoveryReason?.() ?? "session state ambiguous",
 			);
 		});
-		pi.on("session_before_tree", async (event: PiSessionBeforeTreeEvent) => {
-			if (runtime === undefined) return { cancel: true };
+		pi.on("session_before_tree", async (event: PiSessionBeforeTreeEvent, context: ExtensionContext) => {
+			if (runtime === undefined || initializing) return { cancel: true };
 			if (runtime.isInternalNavigation?.()) return undefined;
 			const active = runtime;
-			const result = await active.controller.beforeTree({ targetLeafId: event.preparation.targetId });
-			if (result === undefined) {
-				event.signal?.addEventListener("abort", () => { void active.controller.cancelTree?.(); }, { once: true });
+			if (event.signal?.aborted) return { cancel: true };
+			clearTreeWatch?.();
+			let timer: ReturnType<typeof setInterval> | undefined;
+			const clear = (): void => {
+				if (timer !== undefined) clearInterval(timer);
+				event.signal?.removeEventListener("abort", cancel);
+				if (clearTreeWatch === clear) clearTreeWatch = undefined;
+			};
+			const cancel = (): void => { void active.controller.cancelTree?.().catch(() => {}); };
+			clearTreeWatch = clear;
+			event.signal?.addEventListener("abort", cancel, { once: true });
+			const result = await active.controller.beforeTree({ targetLeafId: event.preparation.targetId, signal: event.signal });
+			if (result !== undefined || event.signal?.aborted) {
+				await active.controller.cancelTree?.();
+				clear();
+				return { cancel: true };
 			}
-			return result;
+			// 摘要错误或其他扩展取消可能没有 session_tree；Pi 离开导航后才终结准备事务。
+			timer = setInterval(() => {
+				if (!context.isIdle()) return;
+				clear();
+				void active.controller.cancelTree?.().then(() => {
+					resumeDeferredPrompts(active, generation, "tree_navigation_incomplete");
+				});
+			}, 100);
+			timer.unref();
+			return undefined;
 		});
 		pi.on("session_tree", async (event: PiSessionTreeEvent) => {
 			const active = runtime;
 			if (active?.isInternalNavigation?.()) return;
 			const treeGeneration = generation;
-			await active?.controller.afterTree({
+			clearTreeWatch?.();
+			await active?.controller.afterTree(active.normalizeTreeEvent?.(event) ?? {
 				newLeafId: event.newLeafId,
-				navigationTargetLeafId: event.summaryEntry?.parentId ?? event.newLeafId,
+				navigationTargetLeafId: event.summaryEntry === undefined ? event.newLeafId : event.summaryEntry.parentId,
 			});
 			if (active !== undefined && runtime === active && generation === treeGeneration) {
 				resumeDeferredPrompts(
@@ -387,6 +444,7 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 			}
 		});
 		pi.on("session_shutdown", async () => {
+			clearTreeWatch?.();
 			generation += 1;
 			deferredPrompts = [];
 			replaying = undefined;
@@ -394,6 +452,8 @@ export function createPiUndoExtension(runtimeFactory: PiUndoRuntimeFactory): (pi
 			activeCommands = new Set<symbol>();
 			activeAction = undefined;
 			runtimeContext = undefined;
+			if (runtime?.dispose !== undefined) await runtime.dispose();
+			else await runtime?.controller.dispose?.();
 			await runtime?.controller.cancelTree?.();
 			runtime?.reporter.clear();
 			runtime = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@davideasden/pi-undo",
-	"version": "0.2.24",
+	"version": "0.2.25",
 	"description": "Persistent workspace undo and redo for Pi",
 	"license": "MIT",
 	"type": "module",
@@ -39,22 +39,23 @@
 	"scripts": {
 		"test": "vitest run",
 		"test:watch": "vitest",
-		"test:integration": "vitest run test/extension.integration.test.ts test/pi-runtime.test.ts",
+		"test:integration": "vitest run test/extension.integration.test.ts test/pi-runtime.test.ts test/pi-sdk.integration.test.ts",
 		"test:native": "cargo test --manifest-path native/pi-undo-fs/Cargo.toml && vitest run test/native-restore.test.ts test/durable-pack.test.ts test/packed-recovery.test.ts",
 		"build:native": "cargo build --release --manifest-path native/pi-undo-fs/Cargo.toml",
 		"typecheck": "tsc --noEmit",
 		"pack:dry-run": "npm pack --dry-run"
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-coding-agent": ">=0.80.10",
-		"@earendil-works/pi-tui": "*"
+		"@earendil-works/pi-coding-agent": ">=0.86.1",
+		"@earendil-works/pi-tui": ">=0.86.1"
 	},
 	"dependencies": {
 		"proper-lockfile": "4.1.2"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-coding-agent": "0.84.4",
-		"@earendil-works/pi-tui": "0.84.4",
+		"@earendil-works/pi-ai": "0.86.1",
+		"@earendil-works/pi-coding-agent": "0.86.1",
+		"@earendil-works/pi-tui": "0.86.1",
 		"@types/node": "24.12.4",
 		"@types/proper-lockfile": "4.1.4",
 		"typescript": "5.9.3",