pi-crew 0.9.41 → 0.9.44

package/src/worktree/worktree-manager.ts

@@ -134,7 +134,11 @@ export function findGitRoot(cwd: string): string {
 }
 
 export function assertCleanLeader(repoRoot: string): void {
-	const status = git(repoRoot, ["status", "--porcelain"]);
+	// H-7 follow-up: --untracked-files=no so pi-crew's own auto-created .gitignore
+	// (and any other untracked files the user hasn't staged) doesn't block worktree mode.
+	// The worktree contract is "no tracked changes" — untracked files are safe since
+	// they're either in .gitignore or the user can decide later.
+	const status = git(repoRoot, ["status", "--porcelain", "--untracked-files=no"]);
 	if (status.trim()) {
 		throw new Error("Worktree mode requires a clean leader repository. Commit/stash changes or use workspaceMode: 'single'.");
 	}
@@ -168,7 +172,9 @@ export function clearCleanLeaderCache(): void {
 
 export async function assertCleanLeaderAsync(repoRoot: string): Promise<void> {
 	if (_cleanLeaderCache.has(repoRoot)) return;
-	const status = await gitAsync(repoRoot, ["status", "--porcelain"]);
+	// H-7 follow-up: --untracked-files=no so pi-crew's own auto-created .gitignore
+	// (and any other untracked files the user hasn't staged) doesn't block worktree mode.
+	const status = await gitAsync(repoRoot, ["status", "--porcelain", "--untracked-files=no"]);
 	if (status.trim()) {
 		throw new Error("Worktree mode requires a clean leader repository. Commit/stash changes or use workspaceMode: 'single'.");
 	}
@@ -558,7 +564,7 @@ export function overlaySeedPaths(repoRoot: string, worktreePath: string, seedPat
  * 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 {
+function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, worktreePath: string, dirtyStatus: string): boolean {
 	try {
 		const parts: string[] = [
 			`# Worktree recovery snapshot`,
@@ -596,12 +602,14 @@ function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, w
 			producer: "worktree-manager.snapshotDirtyWorktree",
 			retention: "run",
 		});
+		return true;
 	} catch (err) {
 		logInternalError(
 			"worktree.recovery.snapshotFailed",
 			err instanceof Error ? err : new Error(String(err)),
 			`runId=${manifest.runId}, taskId=${task.id}`,
 		);
+		return false;
 	}
 }
 
@@ -722,14 +730,24 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		if (dirtyStatus.trim()) {
 			// 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} (snapshot saved to artifacts)`),
-				`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
-			);
-			git(worktreePath, ["checkout", "--", "."]);
-			git(worktreePath, ["clean", "-fd"]);
+			const snapshotOk = snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
+			if (snapshotOk) {
+				logInternalError(
+					"worktree.reused.dirty",
+					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", "--", "."]);
+				git(worktreePath, ["clean", "-fd"]);
+			} else {
+				logInternalError(
+					"worktree.reused.dirtyPreserved",
+					new Error(
+						`Snapshot failed — preserving dirty worktree at ${worktreePath} (skipping git checkout/clean to prevent data loss)`,
+					),
+					`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
+				);
+			}
 		}
 		// Overlay seed paths from config + step-level seedPaths (reused worktree)
 		const globalSeedPaths = loadedConfig.config.worktree?.seedPaths ?? [];
@@ -869,14 +887,24 @@ 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} (snapshot saved to artifacts)`),
-				`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
-			);
-			await gitAsync(worktreePath, ["checkout", "--", "."]);
-			await gitAsync(worktreePath, ["clean", "-fd"]);
+			const snapshotOk = snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
+			if (snapshotOk) {
+				logInternalError(
+					"worktree.reused.dirty",
+					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", "--", "."]);
+				await gitAsync(worktreePath, ["clean", "-fd"]);
+			} else {
+				logInternalError(
+					"worktree.reused.dirtyPreserved",
+					new Error(
+						`Snapshot failed — preserving dirty worktree at ${worktreePath} (skipping git checkout/clean to prevent data loss)`,
+					),
+					`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
+				);
+			}
 		}
 		const globalSeedPaths = loadedConfig.config.worktree?.seedPaths ?? [];
 		const mergedReused = normalizeSeedPaths([...globalSeedPaths, ...(stepSeedPaths ?? [])], repoRoot);

package/src/state/atomic-write-v2.ts

@@ -1,108 +0,0 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-/**
- * Fallow-inspired atomic writer: write-to-.tmp → fsync → rename.
- *
- * Key differences from atomic-write.ts:
- * - Uses rename() (POSIX-atomic) instead of link()+unlink()
- * - Calls fsyncSync() on the temp file before rename
- * - Best-effort fsync (failure does not abort)
- * - Writes .gitignore to directory on first use
- * - UUID-based tmp file to prevent collisions under concurrent writes
- */
-export class AtomicWriter {
-	private initializedDirs = new Set<string>();
-	private baseDir: string;
-
-	constructor(baseDir: string) {
-		this.baseDir = baseDir;
-	}
-
-	writeSync(targetPath: string, content: string): void {
-		this.ensureParentDir(targetPath);
-		const tmpPath = this.tmpPath(targetPath);
-		const fd = fs.openSync(tmpPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
-		try {
-			fs.writeSync(fd, content, undefined, "utf8");
-			try {
-				fs.fsyncSync(fd);
-			} catch {
-				/* best-effort */
-			}
-		} finally {
-			fs.closeSync(fd);
-		}
-		try {
-			fs.renameSync(tmpPath, targetPath);
-		} catch (err) {
-			try {
-				fs.unlinkSync(tmpPath);
-			} catch {
-				/* best-effort cleanup */
-			}
-			throw err;
-		}
-	}
-
-	async writeAsync(targetPath: string, content: string): Promise<void> {
-		await fs.promises.mkdir(path.dirname(targetPath), { recursive: true });
-		const tmpPath = this.tmpPath(targetPath);
-		const fd = await fs.promises.open(tmpPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
-		try {
-			await fd.writeFile(content, "utf8");
-			try {
-				await fd.sync();
-			} catch {
-				/* best-effort */
-			}
-		} finally {
-			await fd.close();
-		}
-		try {
-			await fs.promises.rename(tmpPath, targetPath);
-		} catch (err) {
-			try {
-				await fs.promises.unlink(tmpPath);
-			} catch {
-				/* best-effort cleanup */
-			}
-			throw err;
-		}
-	}
-
-	writeJsonSync<T>(targetPath: string, value: T): void {
-		this.writeSync(targetPath, JSON.stringify(value, null, 2) + "\n");
-	}
-
-	async writeJsonAsync<T>(targetPath: string, value: T): Promise<void> {
-		await this.writeAsync(targetPath, JSON.stringify(value, null, 2) + "\n");
-	}
-
-	private tmpPath(targetPath: string): string {
-		const uuid = crypto.randomUUID();
-		return `${targetPath}.${uuid}.tmp`;
-	}
-
-	private ensureParentDir(targetPath: string): void {
-		const dir = path.dirname(targetPath);
-		fs.mkdirSync(dir, { recursive: true });
-		this.ensureGitignore(dir);
-	}
-
-	private ensureGitignore(dir: string): void {
-		if (this.initializedDirs.has(dir)) return;
-		this.initializedDirs.add(dir);
-		const gitignorePath = path.join(dir, ".gitignore");
-		try {
-			fs.accessSync(gitignorePath);
-		} catch {
-			try {
-				fs.writeFileSync(gitignorePath, "*\n", "utf8");
-			} catch {
-				/* best-effort */
-			}
-		}
-	}
-}