pi-crew 0.9.16 → 0.9.17

package/src/runtime/tool-output-pruner.ts

@@ -134,11 +134,7 @@ export function resultDigest(toolName: string, content: string, isError?: boolea
 		const files = text.match(/(\d+)\s+files?/i) ?? text.match(/filesWithMatches["']?:\s*(\d+)/i);
 		const error = firstErrorLine(text);
 		return (
-			[
-				match ? `matches=${match[1]}` : undefined,
-				files ? `files=${files[1]}` : undefined,
-				error ? `error=${error}` : undefined,
-			]
+			[match ? `matches=${match[1]}` : undefined, files ? `files=${files[1]}` : undefined, error ? `error=${error}` : undefined]
 				.filter((part): part is string => part !== undefined)
 				.join("; ") || "search digest unavailable"
 		);
@@ -289,9 +285,7 @@ export function pruneToolOutputs(results: ToolResultEntry[], config: PruneConfig
 		// Staleness waives protected-tool immunity for overridable tools
 		// (e.g. a superseded `read`); the most recent result per target is
 		// never stale, so the latest read of each file stays protected.
-		const isProtected =
-			config.protectedTools.includes(entry.toolName) &&
-			!(isStale && staleOverridable.has(entry.toolName));
+		const isProtected = config.protectedTools.includes(entry.toolName) && !(isStale && staleOverridable.has(entry.toolName));
 
 		// Stale results are prunable even inside the recency protect window —
 		// they are superseded, so recency no longer implies relevance. They
@@ -325,7 +319,10 @@ export function pruneToolOutputs(results: ToolResultEntry[], config: PruneConfig
 
 	const prunedResults = [...results];
 	for (const candidate of candidates) {
-		prunedResults[candidate.index] = { ...candidate.entry, content: candidate.notice };
+		prunedResults[candidate.index] = {
+			...candidate.entry,
+			content: candidate.notice,
+		};
 		prunedIds.push(candidate.entry.id);
 		prunedCount++;
 	}

package/src/runtime/tool-progress.ts

@@ -1,8 +1,8 @@
 /**
  * Tool Progress Event System
- * 
+ *
  * Provides real-time visibility into tool execution within child Pi workers.
- * 
+ *
  * Event flow:
  * 1. Child Pi emits JSON events on stdout (tool_execution_start, tool_execution_end, etc.)
  * 2. child-pi.ts parses these events and passes them to onJsonEvent callback
@@ -165,9 +165,7 @@ export function formatToolProgress(progress: CrewAgentProgress, maxContextTokens
 	}));
 
 	// If there's a currentTool but no endedAt, it's still running
-	const currentRunning = progress.recentTools.find(
-		(t) => !t.endedAt && t.tool === progress.currentTool,
-	);
+	const currentRunning = progress.recentTools.find((t) => !t.endedAt && t.tool === progress.currentTool);
 	if (currentRunning && progress.currentTool) {
 		recentTools.push({
 			tool: progress.currentTool,
@@ -199,13 +197,13 @@ export function formatToolProgress(progress: CrewAgentProgress, maxContextTokens
  */
 export function formatCurrentToolLine(progress: CrewAgentProgress): string {
 	if (!progress.currentTool) return "";
-	
-	const args = progress.currentToolArgs 
+
+	const args = progress.currentToolArgs
 		? ` ${progress.currentToolArgs.slice(0, 50)}${progress.currentToolArgs.length > 50 ? "..." : ""}`
 		: "";
-	
+
 	const toolCount = progress.toolCount > 0 ? ` (${progress.toolCount})` : "";
-	
+
 	return `${progress.currentTool}${args}${toolCount}`;
 }
 
@@ -229,10 +227,7 @@ export interface ProgressBarOptions {
 /**
  * Render a progress bar for tool execution
  */
-export function renderProgressBar(
-	progress: CrewAgentProgress,
-	options: ProgressBarOptions = {},
-): string {
+export function renderProgressBar(progress: CrewAgentProgress, options: ProgressBarOptions = {}): string {
 	const width = options.width ?? 20;
 	const showPercent = options.showPercent ?? true;
 	const showCount = options.showCount ?? true;
@@ -244,9 +239,7 @@ export function renderProgressBar(
 
 	const bar = "█".repeat(filled) + "░".repeat(empty);
 	const percent = showPercent ? ` ${progress.toolCount} tools` : "";
-	const tokens = progress.tokens 
-		? ` | ${(progress.tokens / 1000).toFixed(1)}k tokens` 
-		: "";
+	const tokens = progress.tokens ? ` | ${(progress.tokens / 1000).toFixed(1)}k tokens` : "";
 
 	return `[${bar}]${percent}${tokens}`;
 }
@@ -270,10 +263,7 @@ export function filterToolEvents(events: ToolProgressEvent[]): ToolProgressEvent
 /**
  * Get events for a specific tool
  */
-export function getEventsForTool(
-	events: ToolProgressEvent[],
-	toolName: string,
-): ToolProgressEvent[] {
+export function getEventsForTool(events: ToolProgressEvent[], toolName: string): ToolProgressEvent[] {
 	return events.filter((e) => {
 		if ("toolName" in e) return e.toolName === toolName;
 		return false;
@@ -285,4 +275,4 @@ export function getEventsForTool(
  */
 export function hasError(events: ToolProgressEvent[]): boolean {
 	return events.some(isToolError);
-}
+}

package/src/runtime/verification-gates.ts

@@ -1,22 +1,22 @@
 /**
  * Verification Gates — ECC VERIFICATION_LOOP Pattern Implementation
- * 
+ *
  * Implements RED/GREEN phase gates for task verification.
  * Sequential execution: cannot skip to Phase N+1 without Phase N passing.
- * 
+ *
  * Based on: docs/distillation/ECC-10-skills.md §2 (verification-loop)
- * 
+ *
  * @module verification-gates
  */
 
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
-import { redactSecretString } from "../utils/redaction.ts";
+import type { ArtifactDescriptor, GreenLevel, VerificationCommandResult, VerificationContract } from "../state/types.ts";
+import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
-import type { VerificationContract, VerificationCommandResult, GreenLevel, ArtifactDescriptor } from "../state/types.ts";
+import { redactSecretString } from "../utils/redaction.ts";
 
 /**
  * Phase 1.5 #1 (RFC 13 §6 info-disclosure mitigation): sanitize the env passed
@@ -78,9 +78,15 @@ function buildVerificationEnv(): Record<string, string> {
 		return { ...process.env, FORCE_COLOR: "0" };
 	}
 	const preserveRaw = process.env.PI_CREW_VERIFICATION_PRESERVE_ENV ?? process.env.PI_TEAMS_VERIFICATION_PRESERVE_ENV ?? "";
-	const preserve = preserveRaw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+	const preserve = preserveRaw
+		.split(",")
+		.map((s) => s.trim())
+		.filter((s) => s.length > 0);
 	const allowList = [...VERIFICATION_ENV_ALLOWLIST, ...preserve];
-	return { ...sanitizeEnvSecrets(process.env, { allowList }), FORCE_COLOR: "0" };
+	return {
+		...sanitizeEnvSecrets(process.env, { allowList }),
+		FORCE_COLOR: "0",
+	};
 }
 
 export interface PhaseGateResult {
@@ -105,7 +111,11 @@ export interface PhaseGateBundle {
  * Standard phase gate definitions for npm/TypeScript projects.
  * Sequential enforcement: each phase must pass before proceeding.
  */
-export const NPM_TYPESCRIPT_GATES: Array<{ name: string; command: string; critical: boolean }> = [
+export const NPM_TYPESCRIPT_GATES: Array<{
+	name: string;
+	command: string;
+	critical: boolean;
+}> = [
 	{ name: "build", command: "npm run build 2>&1", critical: true },
 	{ name: "typecheck", command: "npx tsc --noEmit 2>&1", critical: true },
 	{ name: "lint", command: "npm run lint 2>&1", critical: false },
@@ -115,7 +125,11 @@ export const NPM_TYPESCRIPT_GATES: Array<{ name: string; command: string; critic
 /**
  * Cargo/Rust project phase gates.
  */
-export const CARGO_RUST_GATES: Array<{ name: string; command: string; critical: boolean }> = [
+export const CARGO_RUST_GATES: Array<{
+	name: string;
+	command: string;
+	critical: boolean;
+}> = [
 	{ name: "check", command: "cargo check 2>&1", critical: true },
 	{ name: "test", command: "cargo test 2>&1", critical: true },
 	{ name: "clippy", command: "cargo clippy 2>&1", critical: false },
@@ -160,15 +174,13 @@ function validateGateCommand(command: string): void {
 		);
 	}
 	const normalized = command
-		.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')  // ANSI escape sequences
-		.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '')  // control chars
-		.replace(/\\\n/g, ' ')  // escaped newlines
-		.replace(/\s+/g, ' ')  // collapse whitespace
+		.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "") // ANSI escape sequences
+		.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "") // control chars
+		.replace(/\\\n/g, " ") // escaped newlines
+		.replace(/\s+/g, " ") // collapse whitespace
 		.trim();
 	if (DANGEROUS_SHELL_PATTERNS.test(normalized)) {
-		throw new Error(
-			`Security: verification gate command rejected (dangerous shell pattern): ${command}`,
-		);
+		throw new Error(`Security: verification gate command rejected (dangerous shell pattern): ${command}`);
 	}
 }
 
@@ -237,7 +249,7 @@ async function executeCommand(
 
 /**
  * Run phase gates sequentially, stopping on first critical failure.
- * 
+ *
  * @param gates - Array of phase gate definitions
  * @param cwd - Working directory to execute commands in
  * @param signal - Optional abort signal
@@ -312,7 +324,7 @@ export async function runPhaseGates(
 /**
  * Execute verification commands from a task's verification contract.
  * Maps the contract commands to phase gates and runs them sequentially.
- * 
+ *
  * @param contract - Verification contract with commands to execute
  * @param cwd - Working directory
  * @param runId - Run ID for artifact naming
@@ -413,15 +425,12 @@ export async function executeVerificationCommands(
 /**
  * Compute observed green level from verification results.
  * Maps verification outcomes to green levels per ECC pattern.
- * 
+ *
  * @param commands - Array of verification command results
  * @param requiredLevel - Required green level from contract
  * @returns Observed green level
  */
-export function computeGreenLevelFromResults(
-	commands: VerificationCommandResult[],
-	requiredLevel: GreenLevel,
-): GreenLevel {
+export function computeGreenLevelFromResults(commands: VerificationCommandResult[], requiredLevel: GreenLevel): GreenLevel {
 	if (commands.length === 0) {
 		return "none";
 	}

package/src/runtime/verification-integrity.ts

@@ -88,10 +88,7 @@ export function snapshotManifests(cwd: string): Record<string, string> {
  * @returns Sorted array of relative manifest paths that drifted. Identical
  * snapshots yield `[]`.
  */
-export function compareSnapshot(
-	a: Record<string, string>,
-	b: Record<string, string>,
-): string[] {
+export function compareSnapshot(a: Record<string, string>, b: Record<string, string>): string[] {
 	const drifted = new Set<string>();
 	for (const [key, hash] of Object.entries(a)) {
 		const other = b[key];

package/src/runtime/verification-worktree.ts

@@ -53,27 +53,57 @@ export function isWorktreeSandboxEnabled(): boolean {
  */
 export function checkWorktreeSandboxAvailable(cwd: string): { available: true; commitSha: string } | { available: false; reason: string } {
 	if (!isWorktreeSandboxEnabled()) {
-		return { available: false, reason: "PI_CREW_VERIFICATION_WORKTREE not set (opt-in)" };
+		return {
+			available: false,
+			reason: "PI_CREW_VERIFICATION_WORKTREE not set (opt-in)",
+		};
 	}
 	try {
 		// Is cwd inside a git repo? `git rev-parse --show-toplevel` errors out
 		// (non-zero exit) when not in a repo. execFileSync throws on non-zero.
-		const toplevel = execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-		if (!toplevel) return { available: false, reason: "git rev-parse returned empty toplevel" };
+		const toplevel = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			encoding: "utf-8",
+		}).trim();
+		if (!toplevel)
+			return {
+				available: false,
+				reason: "git rev-parse returned empty toplevel",
+			};
 		// Current commit SHA (this is what T_snap will pin to).
-		const commitSha = execFileSync("git", ["rev-parse", "HEAD"], { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-		if (!commitSha) return { available: false, reason: "git rev-parse HEAD returned empty SHA" };
+		const commitSha = execFileSync("git", ["rev-parse", "HEAD"], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			encoding: "utf-8",
+		}).trim();
+		if (!commitSha)
+			return {
+				available: false,
+				reason: "git rev-parse HEAD returned empty SHA",
+			};
 		// Dirty index? `git status --porcelain` outputs non-empty if there are
 		// uncommitted changes. We refuse to sandbox a dirty workspace because
 		// the worktree would NOT contain the in-progress edits (T_snap would
 		// pin to a stale commit). Better to fall back + warn than silently
 		// verify against the wrong code.
-		const status = execFileSync("git", ["status", "--porcelain"], { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-		if (status.length > 0) return { available: false, reason: `dirty git index (${status.split("\n").length} changed files); refusing to sandbox — worktree would pin to stale commit` };
+		const status = execFileSync("git", ["status", "--porcelain"], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			encoding: "utf-8",
+		}).trim();
+		if (status.length > 0)
+			return {
+				available: false,
+				reason: `dirty git index (${status.split("\n").length} changed files); refusing to sandbox — worktree would pin to stale commit`,
+			};
 		return { available: true, commitSha };
 	} catch (error) {
 		const msg = error instanceof Error ? error.message : String(error);
-		return { available: false, reason: `git precondition check failed: ${msg.slice(0, 200)}` };
+		return {
+			available: false,
+			reason: `git precondition check failed: ${msg.slice(0, 200)}`,
+		};
 	}
 }
 
@@ -102,13 +132,29 @@ export function prepareVerificationWorktree(cwd: string, commitSha: string): Ver
 			execFileSync("git", ["worktree", "remove", "--force", worktreePath], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 5000 });
 		} catch {
 			// Fall back to `git worktree prune` if remove fails (already gone).
-			try { execFileSync("git", ["worktree", "prune"], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 5000 }); } catch { /* best-effort */ }
+			try {
+				execFileSync("git", ["worktree", "prune"], {
+					cwd,
+					stdio: ["ignore", "pipe", "pipe"],
+					timeout: 5000,
+				});
+			} catch {
+				/* best-effort */
+			}
 		}
 		// Remove the temp parent dir.
-		try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* best-effort */ }
+		try {
+			fs.rmSync(tmpRoot, { recursive: true, force: true });
+		} catch {
+			/* best-effort */
+		}
 	};
 	try {
-		execFileSync("git", ["worktree", "add", "--detach", worktreePath, commitSha], { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 30_000 });
+		execFileSync("git", ["worktree", "add", "--detach", worktreePath, commitSha], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			timeout: 30_000,
+		});
 		return { worktreePath, commitSha, cleanup };
 	} catch (error) {
 		cleanup();
@@ -126,7 +172,11 @@ export function prepareVerificationWorktree(cwd: string, commitSha: string): Ver
  * If preparation fails, the function rethrows WITHOUT calling fn — caller
  * must handle the prep failure (typically by falling back to non-sandboxed).
  */
-export async function withVerificationWorktree<T>(cwd: string, commitSha: string, fn: (worktree: VerificationWorktree) => Promise<T> | T): Promise<T> {
+export async function withVerificationWorktree<T>(
+	cwd: string,
+	commitSha: string,
+	fn: (worktree: VerificationWorktree) => Promise<T> | T,
+): Promise<T> {
 	const worktree = prepareVerificationWorktree(cwd, commitSha);
 	try {
 		return await fn(worktree);

package/src/runtime/worker-heartbeat.ts

@@ -12,7 +12,11 @@ export function createWorkerHeartbeat(workerId: string, pid?: number, now = new
 	return { workerId, pid, lastSeenAt: now.toISOString(), alive: true };
 }
 
-export function touchWorkerHeartbeat(heartbeat: WorkerHeartbeatState, updates: Partial<Omit<WorkerHeartbeatState, "workerId">> = {}, now = new Date()): WorkerHeartbeatState {
+export function touchWorkerHeartbeat(
+	heartbeat: WorkerHeartbeatState,
+	updates: Partial<Omit<WorkerHeartbeatState, "workerId">> = {},
+	now = new Date(),
+): WorkerHeartbeatState {
 	return { ...heartbeat, ...updates, lastSeenAt: now.toISOString() };
 }
 

package/src/runtime/worker-startup.ts

@@ -1,5 +1,13 @@
 export type WorkerLifecycleState = "spawning" | "trust_required" | "ready_for_prompt" | "running" | "finished" | "failed";
-export type StartupFailureClassification = "trust_required" | "prompt_misdelivery" | "prompt_acceptance_timeout" | "transport_dead" | "worker_crashed" | "rate_limited" | "provider_error" | "unknown";
+export type StartupFailureClassification =
+	| "trust_required"
+	| "prompt_misdelivery"
+	| "prompt_acceptance_timeout"
+	| "transport_dead"
+	| "worker_crashed"
+	| "rate_limited"
+	| "provider_error"
+	| "unknown";
 
 export interface WorkerStartupEvidence {
 	lastLifecycleState: WorkerLifecycleState;
@@ -16,17 +24,28 @@ export interface WorkerStartupEvidence {
 
 export function detectTrustPrompt(text: string): boolean {
 	const lowered = text.toLowerCase();
-	return lowered.includes("do you trust") || lowered.includes("trust this") || lowered.includes("untrusted") || lowered.includes("workspace trust") || lowered.includes("allow this folder");
+	return (
+		lowered.includes("do you trust") ||
+		lowered.includes("trust this") ||
+		lowered.includes("untrusted") ||
+		lowered.includes("workspace trust") ||
+		lowered.includes("allow this folder")
+	);
 }
 
 export function classifyStartupFailure(evidence: Omit<WorkerStartupEvidence, "classification">): StartupFailureClassification {
 	if (evidence.stderrPreview && /429|rate.?limit/i.test(evidence.stderrPreview)) return "rate_limited";
-	if (evidence.stderrPreview && /5\d{2}|server.?error|internal.?error|provider.?error/i.test(evidence.stderrPreview)) return "provider_error";
+	if (evidence.stderrPreview && /5\d{2}|server.?error|internal.?error|provider.?error/i.test(evidence.stderrPreview))
+		return "provider_error";
 	if (!evidence.transportHealthy) return "transport_dead";
 	if (evidence.trustPromptDetected || evidence.lastLifecycleState === "trust_required") return "trust_required";
 	if (evidence.promptSentAt && !evidence.promptAccepted && evidence.childProcessAlive) return "prompt_acceptance_timeout";
 	if (evidence.promptSentAt && !evidence.promptAccepted && !evidence.childProcessAlive) return "worker_crashed";
-	if (evidence.stderrPreview?.toLowerCase().includes("command not found") || evidence.stderrPreview?.toLowerCase().includes("not recognized")) return "prompt_misdelivery";
+	if (
+		evidence.stderrPreview?.toLowerCase().includes("command not found") ||
+		evidence.stderrPreview?.toLowerCase().includes("not recognized")
+	)
+		return "prompt_misdelivery";
 	if (!evidence.childProcessAlive && evidence.lastLifecycleState !== "finished") return "worker_crashed";
 	return "unknown";
 }
@@ -45,7 +64,12 @@ export function createStartupEvidence(input: {
 	const trustPromptDetected = detectTrustPrompt(stderrPreview ?? "");
 	const childProcessAlive = input.exitCode === undefined || input.exitCode === null ? !input.finishedAt : false;
 	const base: Omit<WorkerStartupEvidence, "classification"> = {
-		lastLifecycleState: input.error || (input.exitCode !== undefined && input.exitCode !== null && input.exitCode !== 0) ? "failed" : input.finishedAt ? "finished" : "running",
+		lastLifecycleState:
+			input.error || (input.exitCode !== undefined && input.exitCode !== null && input.exitCode !== 0)
+				? "failed"
+				: input.finishedAt
+					? "finished"
+					: "running",
 		command: input.command,
 		promptSentAt: input.promptSentAt?.toISOString(),
 		promptAccepted: input.promptAccepted ?? !input.error,

package/src/runtime/workflow-state.ts

@@ -84,20 +84,22 @@ export function getPhaseInputs(machine: WorkflowStateMachine, phaseIndex: number
  * 3. All declared `inputs` for the target phase must appear in `completedArtifacts`.
  * 4. If a custom `guard` is supplied on a transition, it must also approve.
  */
-export function canTransitionToPhase(
-	machine: WorkflowStateMachine,
-	phaseIndex: number,
-	context: PhaseGuardContext,
-): GuardResult {
+export function canTransitionToPhase(machine: WorkflowStateMachine, phaseIndex: number, context: PhaseGuardContext): GuardResult {
 	if (phaseIndex < 0 || phaseIndex >= machine.phases.length) {
-		return { allowed: false, reason: `Phase index ${phaseIndex} is out of bounds (0..${machine.phases.length - 1}).` };
+		return {
+			allowed: false,
+			reason: `Phase index ${phaseIndex} is out of bounds (0..${machine.phases.length - 1}).`,
+		};
 	}
 
 	// Previous phase must have completed (or been skipped).
 	if (phaseIndex > 0) {
 		const prevStatus = context.previousPhaseStatus;
 		if (prevStatus !== "completed" && prevStatus !== "skipped") {
-			return { allowed: false, reason: `Previous phase status is '${prevStatus}'; expected 'completed' or 'skipped'.` };
+			return {
+				allowed: false,
+				reason: `Previous phase status is '${prevStatus}'; expected 'completed' or 'skipped'.`,
+			};
 		}
 	}
 
@@ -107,7 +109,10 @@ export function canTransitionToPhase(
 		const artifactSet = new Set(context.completedArtifacts);
 		const missing = phase.inputs.filter((input) => !artifactSet.has(input));
 		if (missing.length > 0) {
-			return { allowed: false, reason: `Missing required artifacts: ${missing.join(", ")}.` };
+			return {
+				allowed: false,
+				reason: `Missing required artifacts: ${missing.join(", ")}.`,
+			};
 		}
 	}
 
@@ -124,7 +129,10 @@ export function validatePhasePreconditions(
 ): { ready: boolean; blocking: string[] } {
 	const phase = machine.phases[machine.currentPhaseIndex];
 	if (!phase) {
-		return { ready: false, blocking: [`No phase at index ${machine.currentPhaseIndex}.`] };
+		return {
+			ready: false,
+			blocking: [`No phase at index ${machine.currentPhaseIndex}.`],
+		};
 	}
 
 	const artifactSet = new Set(context.completedArtifacts);

package/src/runtime/workspace-lock.ts

@@ -31,17 +31,7 @@
  */
 
 import { createHash } from "node:crypto";
-import {
-	existsSync,
-	mkdirSync,
-	readFileSync,
-	readdirSync,
-	unlinkSync,
-	openSync,
-	closeSync,
-	statSync,
-	writeFileSync,
-} from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import { atomicWriteJson } from "../state/atomic-write.ts";
 import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
@@ -69,7 +59,10 @@ export const defaultStartTimeResolver: StartTimeResolver = (pid: number): number
 		const stat = readFileSync(`/proc/${pid}/stat`, "utf-8");
 		const lastParen = stat.lastIndexOf(")");
 		if (lastParen === -1) return undefined;
-		const fieldsAfterComm = stat.slice(lastParen + 1).trim().split(/\s+/);
+		const fieldsAfterComm = stat
+			.slice(lastParen + 1)
+			.trim()
+			.split(/\s+/);
 		// starttime is at index 19 (the 20th field after comm) of /proc/<pid>/stat.
 		const startTimeClockTicks = Number(fieldsAfterComm[19]);
 		if (!Number.isFinite(startTimeClockTicks)) return undefined;
@@ -202,7 +195,11 @@ function claimLock(lockPath: string, contents: WorkspaceLockContents, staleRecla
 		// Caller verified the existing lock is logically stale; remove it and claim. A concurrent
 		// reclaimer might re-create between our unlink and our open — that's fine, we lose the race
 		// and return false, falling through to the queue path.
-		try { unlinkSync(lockPath); } catch { /* best-effort */ }
+		try {
+			unlinkSync(lockPath);
+		} catch {
+			/* best-effort */
+		}
 		return tryCreate();
 	}
 	if (tryCreate()) return true;
@@ -210,10 +207,16 @@ function claimLock(lockPath: string, contents: WorkspaceLockContents, staleRecla
 	try {
 		const stat = statSync(lockPath);
 		if (Date.now() - stat.mtimeMs > staleReclaimMs) {
-			try { unlinkSync(lockPath); } catch { /* fall through */ }
+			try {
+				unlinkSync(lockPath);
+			} catch {
+				/* fall through */
+			}
 			return tryCreate();
 		}
-	} catch { /* fall through to false */ }
+	} catch {
+		/* fall through to false */
+	}
 	return false;
 }
 
@@ -281,9 +284,7 @@ export async function acquireWorkspaceLock(
 	while (true) {
 		// Poll-loop: re-check the lock each tick until free/stale or aborted.
 		if (opts.signal?.aborted) {
-			throw new Error(
-				`workspace lock acquisition aborted for goal ${goalId} (cwd=${cwd})`,
-			);
+			throw new Error(`workspace lock acquisition aborted for goal ${goalId} (cwd=${cwd})`);
 		}
 		const existing = readLock(lockPath);
 		// Classify the existing lock: "absent" / "stale" (PID recycled or heartbeat dead) / "live".
@@ -293,7 +294,9 @@ export async function acquireWorkspaceLock(
 		// acquireWorkspaceLock poll loop would re-queue forever = hang.
 		const existingKind: "absent" | "stale" | "live" = !existing
 			? "absent"
-			: (isLockStale(existing, resolveStartTime, heartbeatStaleMs, now()).stale ? "stale" : "live");
+			: isLockStale(existing, resolveStartTime, heartbeatStaleMs, now()).stale
+				? "stale"
+				: "live";
 		if (existingKind !== "live") {
 			// Claim the lock (covers both no-lock and stale-lock cases).
 			// Cold-review #3 NIT #N1 fix: claim via O_EXCL (claimLock), NOT temp+rename — two
@@ -324,9 +327,7 @@ export async function acquireWorkspaceLock(
 		}
 		// Lock is held and live.
 		if (opts.failOnWorkspaceBusy) {
-			throw new Error(
-				`workspace busy: cwd=${cwd} held by goalId=${existing!.goalId} (pid=${existing!.pid})`,
-			);
+			throw new Error(`workspace busy: cwd=${cwd} held by goalId=${existing!.goalId} (pid=${existing!.pid})`);
 		}
 		// Queue: wait for the next poll interval, then re-check.
 		await sleepOrAbort(pollMs, opts.signal);
@@ -338,20 +339,10 @@ export async function acquireWorkspaceLock(
  * (goalId, pid, startTime). A stale handle (whose lock was reclaimed and
  * re-acquired by another goal) must NOT delete the new owner's lock.
  */
-function safeRelease(
-	lockPath: string,
-	goalId: string,
-	pid: number,
-	writtenStartTime: number | undefined,
-): void {
+function safeRelease(lockPath: string, goalId: string, pid: number, writtenStartTime: number | undefined): void {
 	try {
 		const current = readLock(lockPath);
-		if (
-			current &&
-			current.goalId === goalId &&
-			current.pid === pid &&
-			current.startTime === writtenStartTime
-		) {
+		if (current && current.goalId === goalId && current.pid === pid && current.startTime === writtenStartTime) {
 			unlinkSync(lockPath);
 		}
 	} catch {
@@ -390,7 +381,11 @@ function sleepOrAbort(ms: number, signal?: AbortSignal): Promise<void> {
  */
 export function isWorkspaceBusy(
 	cwd: string,
-	opts: { startTimeResolver?: StartTimeResolver; heartbeatStaleMs?: number; now?: () => number } = {},
+	opts: {
+		startTimeResolver?: StartTimeResolver;
+		heartbeatStaleMs?: number;
+		now?: () => number;
+	} = {},
 ): string | undefined {
 	const lockPath = workspaceLockPath(cwd);
 	const resolveStartTime = opts.startTimeResolver ?? defaultStartTimeResolver;