@ferris1225/pi-subagents 4.2.2 → 4.2.4

package/README.md

@@ -127,7 +127,9 @@ main agent inspects the actual changes before calling anything done.
   as a lane wait, not as slot queueing, and its process slot is already released.
 - Setup and integration failures keep the useful patch and worktree, and record
   where they are in `~/.pi/agent/pi-subagents-recovery.json`. Every later session
-  start repeats that notice until you remove the artifacts.
+  start repeats that notice until you remove the artifacts. When the changes had
+  already been applied and only the cleanup failed, the next session start
+  removes the retained copy itself and clears the notice.
 
 ## Threads: resume, stop
 

package/agents/explorer.md

@@ -26,15 +26,12 @@ Thoroughness scales with the task (default medium): quick = targeted lookups in
 
 ## Final response
 
-Return only actionable retrieval results:
+Return only retrieval results, one bare bullet per finding — a single line: path, the fact, nothing else:
 
 ```text
-## Findings
-- `path/to/file.ts:10-50` — fact the caller needs
-## Start Here
-- `path/to/file.ts` — first symbol/section to verify and why
-## Gaps
-- unresolved uncertainty (omit this section when none)
+- `path/to/file.ts:10-50` — the fact
+Start here: `path/to/file.ts` — entry symbol and why (only when the caller could not guess it)
+Gaps: unresolved uncertainty (only when real)
 ```
 
-Do not repeat the task brief, inventory every file opened, paste nonessential code, or narrate search/tool chronology; report only unresolved blockers. Terse and factual: exact paths and line numbers, compressed evidence. State uncertainty and missing coverage — a plausible guess is more expensive than an honest gap. Keep the final response comfortably below the 40-line delivery cap unless the requested findings genuinely require more.
+No preamble or closing summary. Do not repeat the task brief, inventory every file opened, paste nonessential code, or narrate the search; every line must carry a path with a fact or name a gap — delete anything else. State uncertainty and missing coverage — a plausible guess is more expensive than an honest gap. Stay under 15 lines by default; go longer only when the brief genuinely demands a wide survey — the 40-line delivery cap truncates your tail (usually the Gaps) and the caller pays for every line.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "4.2.2",
+  "version": "4.2.4",
   "description": "A managed sub-agent team for pi: specialized roles, pre-commit documentation sync, retained threads, auto-fix chains, model fallback, and Git worktree isolation.",
   "type": "module",
   "license": "MIT",

package/src/recovery.ts

@@ -5,7 +5,7 @@ import { existsSync } from "node:fs";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { stripVTControlCharacters } from "node:util";
-import type { WorktreeFinalization } from "./worktree.ts";
+import { removeWorktreeGroup, worktreeGroupDir, type WorktreeFinalization } from "./worktree.ts";
 
 export const RECOVERY_MANIFEST_FILE_NAME = "pi-subagents-recovery.json";
 const RECOVERY_MANIFEST_VERSION = 1;
@@ -14,6 +14,8 @@ export interface RecoveryRecord {
 	runId: number;
 	createdAt: number;
 	integrated: boolean;
+	/** Repository a cleanup retry can prune stale worktree metadata against. */
+	originalRoot?: string;
 	worktreePath?: string;
 	patchPath?: string;
 	error?: string;
@@ -37,6 +39,7 @@ function normalizeRecord(value: unknown): RecoveryRecord | undefined {
 		runId: raw.runId,
 		createdAt: raw.createdAt,
 		integrated: raw.integrated === true,
+		...(typeof raw.originalRoot === "string" && raw.originalRoot ? { originalRoot: raw.originalRoot } : {}),
 		...(typeof raw.worktreePath === "string" && raw.worktreePath ? { worktreePath: raw.worktreePath } : {}),
 		...(typeof raw.patchPath === "string" && raw.patchPath ? { patchPath: raw.patchPath } : {}),
 		...(typeof raw.error === "string" && raw.error ? { error: raw.error } : {}),
@@ -105,6 +108,7 @@ export function recoveryRecordFromFinalization(
 		runId,
 		createdAt: now,
 		integrated: finalization.integrated,
+		...(finalization.originalRoot ? { originalRoot: finalization.originalRoot } : {}),
 		...(finalization.worktreePath ? { worktreePath: finalization.worktreePath } : {}),
 		...(finalization.patchPath ? { patchPath: finalization.patchPath } : {}),
 		...(finalization.error ? { error: finalization.error } : {}),
@@ -112,7 +116,10 @@ export function recoveryRecordFromFinalization(
 }
 
 /** Show retained recovery paths on every later session start until the user
- * removes the artifacts. Stale records are pruned automatically. */
+ * removes the artifacts. Records whose changes already landed only need the
+ * worktree group deleted — the step whose failure retained them — so each
+ * session start retries that removal first and forgets records it completes.
+ * Stale records are pruned automatically. */
 export async function announceRecoveryRecords(
 	configPath: string,
 	ctx: {
@@ -123,6 +130,17 @@ export async function announceRecoveryRecords(
 	if (ctx.hasUI === false) return;
 	const records = await readRecoveryRecords(configPath);
 	if (records.length === 0) return;
+	for (const record of records) {
+		if (!record.integrated || !record.worktreePath) continue;
+		const groupDir = worktreeGroupDir(record.worktreePath);
+		if (!groupDir) continue;
+		if (!existsSync(record.worktreePath) && !(record.patchPath ? existsSync(record.patchPath) : false)) continue;
+		await removeWorktreeGroup({
+			originalRoot: record.originalRoot,
+			worktreePath: record.worktreePath,
+			tempDir: groupDir,
+		});
+	}
 	const live = records.filter((record) =>
 		(record.worktreePath ? existsSync(record.worktreePath) : false) ||
 		(record.patchPath ? existsSync(record.patchPath) : false),

package/src/thread-lifecycle.ts

@@ -927,6 +927,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)}`,

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,
+		);
 	}
 }