@ferris1225/pi-subagents 4.2.2 → 4.2.5

package/src/runtime.ts

@@ -258,7 +258,7 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 			// thread whose settlement finished during the wait above already
 			// wrote (or removed) its own record; the lastResult-derived state
 			// below matches it.
-			const settledIds: number[] = [];
+			const settled: Array<{ runId: number; cwd: string }> = [];
 			const records: ThreadRecord[] = [];
 			for (const thread of runtime.threads.values()) {
 				if (thread.retired) continue;
@@ -272,11 +272,11 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 					state = "parked";
 				}
 				if (state === "parked") records.push(threadRecordFromThread(thread, state));
-				else settledIds.push(thread.id);
+				else settled.push({ runId: thread.id, cwd: thread.cwd });
 			}
 			await Promise.all([
 				...records.map((record) => upsertThreadRecord(runtime.configPath, record).catch(() => undefined)),
-				...settledIds.map((runId) => removeThreadRecord(runtime.configPath, runId).catch(() => undefined)),
+				...settled.map(({ runId, cwd }) => removeThreadRecord(runtime.configPath, runId, cwd).catch(() => undefined)),
 			]);
 			// Retained-failure recovery records are persisted by the finalization
 			// itself; shutdown only drops sessions no record claims anymore.

package/src/thread-lifecycle.ts

@@ -27,6 +27,7 @@ import {
 } from "./config.ts";
 import {
 	isCurrentBoot,
+	migrateLegacyThreadsManifest,
 	readThreadRecords,
 	referencedDurablePaths,
 	removeThreadRecord,
@@ -225,7 +226,7 @@ export function persistThreadCheckpoint(
 ): void {
 	const write = state === "parked"
 		? upsertThreadRecord(runtime.configPath, threadRecordFromThread(thread, state))
-		: removeThreadRecord(runtime.configPath, thread.id);
+		: removeThreadRecord(runtime.configPath, thread.id, thread.cwd);
 	void write.catch(() => undefined);
 }
 
@@ -927,6 +928,7 @@ export function installThreadLifecycle(thread: SubagentThread, deps: ThreadLifec
 				status: "retained",
 				integrated: false,
 				hadChanges: false,
+				originalRoot: candidate.originalRoot,
 				...(retainedPath ? { worktreePath: retainedPath } : {}),
 				...(existsSync(candidate.patchPath) ? { patchPath: candidate.patchPath } : {}),
 				error: `Discarding unused continuation failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -1144,7 +1146,7 @@ async function discardRestoredRecord(runtime: SubagentRuntime, record: ThreadRec
 		const worktree = await restoreWorktreeIsolation(record.worktree).catch(() => undefined);
 		await worktree?.discard().catch(() => undefined);
 	}
-	await removeThreadRecord(runtime.configPath, record.runId).catch(() => undefined);
+	await removeThreadRecord(runtime.configPath, record.runId, record.cwd).catch(() => undefined);
 }
 
 /** Project-scoped <projectRoot>/results for a completion's artifacts. */
@@ -1272,6 +1274,9 @@ export async function restoreDurableThreads(runtime: SubagentRuntime): Promise<n
 export function bootstrapDurableState(runtime: SubagentRuntime): Promise<void> {
 	const restore = (async () => {
 		try {
+			// Records from a pre-per-project manifest must land in their project
+			// roots before restore reads anything.
+			await migrateLegacyThreadsManifest(runtime.configPath);
 			runtime.restoredRunIds = await restoreDurableThreads(runtime);
 		} catch {
 			/* restore is best-effort */

package/src/tools.ts

@@ -344,7 +344,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 				runtime.retireThreadSession(thread);
 				// The destructive retire removes the durable record with the session;
 				// an id never resurrects after subagent_stop.
-				await removeThreadRecord(runtime.configPath, runId).catch(() => undefined);
+				await removeThreadRecord(runtime.configPath, runId, thread.cwd).catch(() => undefined);
 				if (thread.lifecycleVersion === stopVersion && thread.lifecycleOperation === "stop") {
 					thread.lifecycleOperation = undefined;
 				}

package/src/worktree.ts

@@ -11,7 +11,7 @@
 import { spawn, type ChildProcess } from "node:child_process";
 import { existsSync } from "node:fs";
 import { copyFile, mkdir, mkdtemp, realpath, rm, stat, writeFile } from "node:fs/promises";
-import { isAbsolute, join, relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { writeTempOwnerMarker } from "./temp-hygiene.ts";
 
 export type IsolationMode = "shared" | "worktree";
@@ -233,6 +233,8 @@ export interface WorktreeFinalization {
 	/** True once the patch was successfully applied to the original worktree. */
 	integrated: boolean;
 	hadChanges: boolean;
+	/** Repository a recovery path can prune stale worktree metadata against. */
+	originalRoot?: string;
 	worktreePath?: string;
 	patchPath?: string;
 	error?: string;
@@ -323,6 +325,63 @@ export function isPathInside(root: string, candidate: string): boolean {
 	return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
 }
 
+/** The temp group directory backing a worktree path, when the path actually
+ * names our `<group>/worktree` layout. Recovery deletes only paths read back
+ * from the manifest through this guard. */
+export function worktreeGroupDir(worktreePath: string): string | undefined {
+	const group = dirname(worktreePath);
+	return basename(worktreePath) === "worktree" && basename(group).startsWith(WORKTREE_TEMP_DIR_PREFIX)
+		? group
+		: undefined;
+}
+
+/** Delete one isolated worktree group: Git's own removal keeps metadata
+ * authoritative, but Git on Windows cannot always delete deep checkouts
+ * ("Filename too long"), so the Node removal decides the outcome and the prune
+ * clears any stale registration left behind. Returns an error string when
+ * artifacts still exist afterwards. */
+export async function removeWorktreeGroup(
+	paths: { originalRoot?: string; tempDir: string; worktreePath: string },
+	runner: CommandRunner = runCommand,
+): Promise<string | undefined> {
+	let removeError: string | undefined;
+	if (paths.originalRoot && existsSync(paths.worktreePath)) {
+		// core.longpaths only exists in Git for Windows, and some POSIX builds
+		// reject unknown -c core keys, so the flag stays platform-gated.
+		const longPaths = process.platform === "win32" ? ["-c", "core.longpaths=true"] : [];
+		try {
+			await runGit(
+				runner,
+				paths.originalRoot,
+				[...longPaths, "worktree", "remove", "--force", paths.worktreePath],
+				`Removing isolated worktree ${paths.worktreePath}`,
+			);
+		} catch (error) {
+			removeError = error instanceof Error ? error.message : String(error);
+		}
+	}
+	try {
+		await rm(paths.tempDir, { recursive: true, force: true });
+	} catch (error) {
+		const rmError = error instanceof Error ? error.message : String(error);
+		return removeError
+			? `${removeError}; removing temporary directory failed: ${rmError}`
+			: `Removing temporary directory failed: ${rmError}`;
+	}
+	if (!paths.originalRoot) return undefined;
+	try {
+		await runGit(
+			runner,
+			paths.originalRoot,
+			["worktree", "prune"],
+			`Pruning Git worktree metadata for ${paths.originalRoot}`,
+		);
+	} catch (error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+	return undefined;
+}
+
 interface RepositoryLocation {
 	originalCwd: string;
 	originalRoot: string;
@@ -588,6 +647,7 @@ class GitWorktreeIsolation implements WorktreeIsolation {
 			status: "retained",
 			integrated,
 			hadChanges,
+			originalRoot: this.originalRoot,
 			...(existsSync(this.worktreePath) ? { worktreePath: this.worktreePath } : {}),
 			...(patchWritten && existsSync(this.patchPath) ? { patchPath: this.patchPath } : {}),
 			error,
@@ -649,35 +709,11 @@ class GitWorktreeIsolation implements WorktreeIsolation {
 	}
 
 	/** Return an error string instead of throwing so applied work is never retried. */
-	private async removeAndPrune(): Promise<string | undefined> {
-		try {
-			await runGit(
-				this.runner,
-				this.originalRoot,
-				["worktree", "remove", "--force", this.worktreePath],
-				`Removing isolated worktree ${this.worktreePath}`,
-			);
-		} catch (error) {
-			return error instanceof Error ? error.message : String(error);
-		}
-		let pruneError: string | undefined;
-		try {
-			await runGit(
-				this.runner,
-				this.originalRoot,
-				["worktree", "prune"],
-				`Pruning Git worktree metadata for ${this.originalRoot}`,
-			);
-		} catch (error) {
-			pruneError = error instanceof Error ? error.message : String(error);
-		}
-		try {
-			await rm(this.tempDir, { recursive: true, force: true });
-		} catch (error) {
-			const rmError = error instanceof Error ? error.message : String(error);
-			return pruneError ? `${pruneError}; removing temporary directory failed: ${rmError}` : `Removing temporary directory failed: ${rmError}`;
-		}
-		return pruneError;
+	private removeAndPrune(): Promise<string | undefined> {
+		return removeWorktreeGroup(
+			{ originalRoot: this.originalRoot, worktreePath: this.worktreePath, tempDir: this.tempDir },
+			this.runner,
+		);
 	}
 }