pi-crew 0.9.28 → 0.9.29

package/src/worktree/worktree-manager.ts

@@ -551,6 +551,100 @@ export function overlaySeedPaths(repoRoot: string, worktreePath: string, seedPat
 	}
 }
 
+/**
+ * Snapshot uncommitted work in a reused worktree to a recovery artifact BEFORE
+ * discarding it, so the data is never silently lost. Captures tracked changes
+ * (git diff HEAD) and inlines untracked file contents so the work can be
+ * recovered via `git apply` / manual restore. Best-effort: a snapshot failure
+ * only logs (it must not block the clean-slate reuse flow).
+ */
+function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, worktreePath: string, dirtyStatus: string): void {
+	try {
+		const parts: string[] = [
+			`# Worktree recovery snapshot`,
+			`runId: ${manifest.runId}  taskId: ${task.id}  path: ${worktreePath}`,
+			`capturedAt: ${new Date().toISOString()}`,
+			"",
+		];
+		let trackedDiff = "";
+		try {
+			trackedDiff = git(worktreePath, ["diff", "HEAD"]);
+		} catch {
+			trackedDiff = "";
+		}
+		if (trackedDiff.trim()) {
+			parts.push("## Tracked changes (`git diff HEAD`)", "```diff", trackedDiff, "```", "");
+		}
+		for (const line of dirtyStatus.split("\n")) {
+			if (!line.startsWith("?? ")) continue;
+			// Strip the "?? " prefix and surrounding git quotes.
+			const rel = line.slice(3).replace(/^"|"$/g, "");
+			if (!rel) continue;
+			try {
+				const abs = path.join(worktreePath, rel);
+				if (!fs.existsSync(abs) || fs.statSync(abs).isDirectory()) continue;
+				const content = fs.readFileSync(abs, "utf-8");
+				parts.push(`## Untracked file: ${rel}`, "```", content, "```", "");
+			} catch {
+				/* skip unreadable/unstat-able entry */
+			}
+		}
+		writeArtifact(manifest.artifactsRoot, {
+			kind: "diff",
+			relativePath: `worktree-recovery/${task.id}-${Date.now()}.md`,
+			content: parts.join("\n"),
+			producer: "worktree-manager.snapshotDirtyWorktree",
+			retention: "run",
+		});
+	} catch (err) {
+		logInternalError(
+			"worktree.recovery.snapshotFailed",
+			err instanceof Error ? err : new Error(String(err)),
+			`runId=${manifest.runId}, taskId=${task.id}`,
+		);
+	}
+}
+
+/**
+ * Best-effort removal of a just-created worktree + its branch. Used when a
+ * post-creation step (setup hook, node_modules link, seed overlay) fails, so
+ * the run does not leak an orphaned worktree dir + branch that would block the
+ * next run with an "already checked out" error.
+ */
+function cleanupCreatedWorktree(repoRoot: string, worktreePath: string, branch: string): void {
+	try {
+		git(repoRoot, ["worktree", "remove", "--force", worktreePath]);
+	} catch {
+		try {
+			if (fs.existsSync(worktreePath)) fs.rmSync(worktreePath, { recursive: true, force: true });
+		} catch {
+			/* best-effort */
+		}
+	}
+	try {
+		git(repoRoot, ["branch", "-D", branch]);
+	} catch {
+		/* best-effort */
+	}
+}
+
+async function cleanupCreatedWorktreeAsync(repoRoot: string, worktreePath: string, branch: string): Promise<void> {
+	try {
+		await gitAsync(repoRoot, ["worktree", "remove", "--force", worktreePath]);
+	} catch {
+		try {
+			if (fs.existsSync(worktreePath)) fs.rmSync(worktreePath, { recursive: true, force: true });
+		} catch {
+			/* best-effort */
+		}
+	}
+	try {
+		await gitAsync(repoRoot, ["branch", "-D", branch]);
+	} catch {
+		/* best-effort */
+	}
+}
+
 export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskState, stepSeedPaths?: string[]): PreparedTaskWorkspace {
 	if (manifest.workspaceMode !== "worktree") return { cwd: task.cwd };
 	const repoRoot = findGitRoot(manifest.cwd);
@@ -626,10 +720,12 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		// Check for uncommitted changes from previous run before reusing
 		const dirtyStatus = git(worktreePath, ["status", "--porcelain"]);
 		if (dirtyStatus.trim()) {
-			// Discard uncommitted changes to ensure clean slate for new task
+			// Snapshot uncommitted work to a recovery artifact BEFORE discarding, so the
+			// previous run's changes are never silently destroyed on reuse.
+			snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
 			logInternalError(
 				"worktree.reused.dirty",
-				new Error(`Discarding uncommitted changes in reused worktree at ${worktreePath}`),
+				new Error(`Discarding uncommitted changes in reused worktree at ${worktreePath} (snapshot saved to artifacts)`),
 				`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
 			);
 			git(worktreePath, ["checkout", "--", "."]);
@@ -679,23 +775,30 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		}
 		throw error;
 	}
-	const syntheticPaths = runSetupHook(manifest, task, repoRoot, worktreePath, branch);
-	const nodeModulesLinked =
-		loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
-	// Overlay seed paths from config + step-level seedPaths
-	const globalSeedPaths = loadedConfig.config.worktree?.seedPaths ?? [];
-	const merged = normalizeSeedPaths([...globalSeedPaths, ...(stepSeedPaths ?? [])], repoRoot);
-	if (merged.length > 0) {
-		overlaySeedPaths(repoRoot, worktreePath, merged);
+	try {
+		const syntheticPaths = runSetupHook(manifest, task, repoRoot, worktreePath, branch);
+		const nodeModulesLinked =
+			loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
+		// Overlay seed paths from config + step-level seedPaths
+		const globalSeedPaths = loadedConfig.config.worktree?.seedPaths ?? [];
+		const merged = normalizeSeedPaths([...globalSeedPaths, ...(stepSeedPaths ?? [])], repoRoot);
+		if (merged.length > 0) {
+			overlaySeedPaths(repoRoot, worktreePath, merged);
+		}
+		return {
+			cwd: worktreePath,
+			worktreePath,
+			branch,
+			reused: false,
+			nodeModulesLinked,
+			syntheticPaths,
+		};
+	} catch (setupError) {
+		// Hook/link/seed failure AFTER worktree+branch creation: clean up to avoid
+		// an orphaned worktree dir + branch that would block the next run.
+		cleanupCreatedWorktree(repoRoot, worktreePath, branch);
+		throw setupError;
 	}
-	return {
-		cwd: worktreePath,
-		worktreePath,
-		branch,
-		reused: false,
-		nodeModulesLinked,
-		syntheticPaths,
-	};
 }
 
 /** Async version of prepareTaskWorkspace — yields the event loop during git operations. */
@@ -766,9 +869,10 @@ export async function prepareTaskWorkspaceAsync(
 		}
 		const dirtyStatus = await gitAsync(worktreePath, ["status", "--porcelain"]);
 		if (dirtyStatus.trim()) {
+			snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
 			logInternalError(
 				"worktree.reused.dirty",
-				new Error(`Discarding uncommitted changes in reused worktree at ${worktreePath}`),
+				new Error(`Discarding uncommitted changes in reused worktree at ${worktreePath} (snapshot saved to artifacts)`),
 				`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
 			);
 			await gitAsync(worktreePath, ["checkout", "--", "."]);
@@ -818,22 +922,29 @@ export async function prepareTaskWorkspaceAsync(
 		}
 		throw error;
 	}
-	const syntheticPaths = runSetupHook(manifest, task, repoRoot, worktreePath, branch);
-	const nodeModulesLinked =
-		loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
-	const globalSeedPaths = loadedConfig.config.worktree?.seedPaths ?? [];
-	const merged = normalizeSeedPaths([...globalSeedPaths, ...(stepSeedPaths ?? [])], repoRoot);
-	if (merged.length > 0) {
-		overlaySeedPaths(repoRoot, worktreePath, merged);
+	try {
+		const syntheticPaths = runSetupHook(manifest, task, repoRoot, worktreePath, branch);
+		const nodeModulesLinked =
+			loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
+		const globalSeedPaths = loadedConfig.config.worktree?.seedPaths ?? [];
+		const merged = normalizeSeedPaths([...globalSeedPaths, ...(stepSeedPaths ?? [])], repoRoot);
+		if (merged.length > 0) {
+			overlaySeedPaths(repoRoot, worktreePath, merged);
+		}
+		return {
+			cwd: worktreePath,
+			worktreePath,
+			branch,
+			reused: false,
+			nodeModulesLinked,
+			syntheticPaths,
+		};
+	} catch (setupError) {
+		// Hook/link/seed failure AFTER worktree+branch creation: clean up to avoid
+		// an orphaned worktree dir + branch that would block the next run.
+		await cleanupCreatedWorktreeAsync(repoRoot, worktreePath, branch);
+		throw setupError;
 	}
-	return {
-		cwd: worktreePath,
-		worktreePath,
-		branch,
-		reused: false,
-		nodeModulesLinked,
-		syntheticPaths,
-	};
 }
 
 export function captureWorktreeDiffStat(worktreePath: string): WorktreeDiffStat {