pi-crew 0.9.16 → 0.9.17

package/src/runtime/foreground-control.ts

@@ -2,10 +2,10 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { appendEvent } from "../state/event-log.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { checkProcessLiveness, isActiveRunStatus } from "./process-status.ts";
-import { readCrewAgents } from "./crew-agent-records.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { sleepSync } from "../utils/sleep.ts";
+import { readCrewAgents } from "./crew-agent-records.ts";
+import { checkProcessLiveness, isActiveRunStatus } from "./process-status.ts";
 
 export type ForegroundControlRequestType = "interrupt" | "status";
 
@@ -36,7 +36,9 @@ export function foregroundControlPath(manifest: TeamRunManifest): string {
 function readLastRequest(controlPath: string): ForegroundControlRequest | undefined {
 	if (!fs.existsSync(controlPath)) return undefined;
 	try {
-		const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: ForegroundControlRequest[] };
+		const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as {
+			requests?: ForegroundControlRequest[];
+		};
 		return parsed.requests?.at(-1);
 	} catch {
 		return undefined;
@@ -53,13 +55,18 @@ export function readForegroundControlStatus(manifest: TeamRunManifest, tasks: Te
 		asyncPid: manifest.async?.pid,
 		asyncAlive,
 		runningTasks: tasks.filter((task) => task.status === "running").map((task) => task.id),
-		runningAgents: readCrewAgents(manifest).filter((agent) => agent.status === "running").map((agent) => agent.id),
+		runningAgents: readCrewAgents(manifest)
+			.filter((agent) => agent.status === "running")
+			.map((agent) => agent.id),
 		controlPath,
 		lastRequest: readLastRequest(controlPath),
 	};
 }
 
-export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reason = "User requested foreground interrupt."): ForegroundControlRequest {
+export function writeForegroundInterruptRequest(
+	manifest: TeamRunManifest,
+	reason = "User requested foreground interrupt.",
+): ForegroundControlRequest {
 	const controlPath = foregroundControlPath(manifest);
 	const lockDir = `${controlPath}.lock`;
 	const pidFile = path.join(lockDir, "pid");
@@ -74,7 +81,11 @@ export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reaso
 		while (true) {
 			try {
 				fs.mkdirSync(lockDir, { recursive: true });
-				try { fs.writeFileSync(pidFile, String(process.pid), "utf-8"); } catch { /* best-effort */ }
+				try {
+					fs.writeFileSync(pidFile, String(process.pid), "utf-8");
+				} catch {
+					/* best-effort */
+				}
 				break;
 			} catch {
 				if (Date.now() - start > timeout) {
@@ -84,10 +95,18 @@ export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reaso
 						const ownerPid = Number.parseInt(raw, 10);
 						if (!Number.isNaN(ownerPid) && ownerPid !== process.pid) {
 							let alive = false;
-							try { process.kill(ownerPid, 0); alive = true; } catch { /* dead */ }
+							try {
+								process.kill(ownerPid, 0);
+								alive = true;
+							} catch {
+								/* dead */
+							}
 							if (!alive) {
 								// Lock is stale — clear it and retry
-								fs.rmSync(lockDir, { recursive: true, force: true });
+								fs.rmSync(lockDir, {
+									recursive: true,
+									force: true,
+								});
 								continue;
 							}
 							// Lock held by live process — throw
@@ -95,7 +114,9 @@ export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reaso
 							logInternalError("foreground-control.lock-timeout", err, `controlPath=${controlPath}`);
 							throw err;
 						}
-					} catch { /* no pid file — continue to throw */ }
+					} catch {
+						/* no pid file — continue to throw */
+					}
 					const err = new Error(`Foreground control lock timeout for ${controlPath}`);
 					logInternalError("foreground-control.lock-timeout", err, `controlPath=${controlPath}`);
 					throw err;
@@ -106,23 +127,37 @@ export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reaso
 					const ownerPid = Number.parseInt(raw, 10);
 					if (!Number.isNaN(ownerPid) && ownerPid !== process.pid) {
 						let alive = false;
-						try { process.kill(ownerPid, 0); alive = true; } catch { /* dead */ }
+						try {
+							process.kill(ownerPid, 0);
+							alive = true;
+						} catch {
+							/* dead */
+						}
 						if (!alive) {
 							const stat = fs.statSync(lockDir);
 							if (Date.now() - stat.mtimeMs > staleMs) {
-								fs.rmSync(lockDir, { recursive: true, force: true });
+								fs.rmSync(lockDir, {
+									recursive: true,
+									force: true,
+								});
 								continue;
 							}
 						}
 					}
-				} catch { /* no pid file — fall through to sleep */ }
+				} catch {
+					/* no pid file — fall through to sleep */
+				}
 				// Brief sleep to avoid CPU spinning
 				sleepSync(10);
 			}
 		}
 	};
 	const releaseLock = (): void => {
-		try { fs.rmSync(lockDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+		try {
+			fs.rmSync(lockDir, { recursive: true, force: true });
+		} catch {
+			/* best-effort */
+		}
 	};
 
 	acquireLock();
@@ -144,7 +179,12 @@ export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reaso
 		};
 		fs.mkdirSync(path.dirname(controlPath), { recursive: true });
 		fs.writeFileSync(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}\n`, "utf-8");
-		appendEvent(manifest.eventsPath, { type: "foreground.interrupt_requested", runId: manifest.runId, message: reason, data: { requestId: request.id, controlPath } });
+		appendEvent(manifest.eventsPath, {
+			type: "foreground.interrupt_requested",
+			runId: manifest.runId,
+			message: reason,
+			data: { requestId: request.id, controlPath },
+		});
 		return request;
 	} finally {
 		releaseLock();

package/src/runtime/foreground-watchdog.ts

@@ -90,11 +90,12 @@ export function startForegroundWatchdog(opts: WatchdogOptions): void {
 			if (!isActiveRunStatus(manifest.status)) {
 				const teamName = manifest.team ?? "unknown";
 				try {
-					pi.sendUserMessage(
-						`pi-crew run ${manifest.status}: ${runId} (${teamName}/${manifest.workflow ?? "default"})`,
-						{ deliverAs: "followUp" },
-					);
-				} catch { /* non-critical */ }
+					pi.sendUserMessage(`pi-crew run ${manifest.status}: ${runId} (${teamName}/${manifest.workflow ?? "default"})`, {
+						deliverAs: "followUp",
+					});
+				} catch {
+					/* non-critical */
+				}
 				activeWatchdogs.delete(runId);
 				return;
 			}
@@ -109,7 +110,9 @@ export function startForegroundWatchdog(opts: WatchdogOptions): void {
 						`pi-crew watchdog: run ${runId} appears hung (${detail}). Consider running team action='cancel' runId='${runId}' or team action='doctor'.`,
 						{ deliverAs: "followUp" },
 					);
-				} catch { /* non-critical */ }
+				} catch {
+					/* non-critical */
+				}
 				// Don't stop — keep monitoring. The assistant or user may intervene.
 			}
 		} catch {

package/src/runtime/goal-achievement.ts

@@ -19,8 +19,8 @@
  */
 import { spawnSync } from "node:child_process";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import type { WorkflowConfig } from "../workflows/workflow-config.ts";
 import { findRepoRoot } from "../utils/paths.ts";
+import type { WorkflowConfig } from "../workflows/workflow-config.ts";
 
 /**
  * Roles whose job is to EDIT project source/test files (changes that appear in
@@ -71,18 +71,30 @@ export function assessGoalAchievement(
 	// (1) Only code-mutating workflows can be false-green. Read-only/doc runs
 	//     legitimately make no project edits — never accuse them.
 	if (!workflowIsMutating(workflow)) {
-		return { achieved: "unknown", reason: "read-only / doc-only workflow (no executor/test-engineer steps)", signals: [] };
+		return {
+			achieved: "unknown",
+			reason: "read-only / doc-only workflow (no executor/test-engineer steps)",
+			signals: [],
+		};
 	}
 
 	// (2) Need a git repo to inspect the working tree.
 	const tree = isGitWorkingTreeClean(manifest.cwd);
 	if (tree.clean === "unknown" || !tree.repoRoot) {
-		return { achieved: "unknown", reason: "not a git repo or git unavailable", signals: [] };
+		return {
+			achieved: "unknown",
+			reason: "not a git repo or git unavailable",
+			signals: [],
+		};
 	}
 
 	// (3) Non-empty working tree → the mutating run made edits. Achieved.
 	if (!tree.clean) {
-		return { achieved: true, reason: "git working tree has changes (mutating run edited project files)", signals: [`repoRoot=${tree.repoRoot}`] };
+		return {
+			achieved: true,
+			reason: "git working tree has changes (mutating run edited project files)",
+			signals: [`repoRoot=${tree.repoRoot}`],
+		};
 	}
 
 	// (4) Mutating run + CLEAN working tree → suspicious. The executor's job was
@@ -113,13 +125,18 @@ export function applyGoalAchievement(
 	manifest: TeamRunManifest,
 	assessment: GoalAchievementAssessment,
 ): { manifest: TeamRunManifest; downgraded: boolean } {
-	const note = assessment.achieved === false
-		? `goal-achievement: FALSE-GREEN — ${assessment.reason}. ${assessment.signals.join("; ")}`
-		: assessment.achieved === true
-			? `goal-achievement: OK — ${assessment.reason}`
-			: `goal-achievement: unknown — ${assessment.reason}`;
+	const note =
+		assessment.achieved === false
+			? `goal-achievement: FALSE-GREEN — ${assessment.reason}. ${assessment.signals.join("; ")}`
+			: assessment.achieved === true
+				? `goal-achievement: OK — ${assessment.reason}`
+				: `goal-achievement: unknown — ${assessment.reason}`;
 
-	const updated: TeamRunManifest = { ...manifest, goalAchieved: assessment.achieved, goalAchievementNote: note };
+	const updated: TeamRunManifest = {
+		...manifest,
+		goalAchieved: assessment.achieved,
+		goalAchievementNote: note,
+	};
 
 	// Downgrade only on the highest-confidence false-green: a failed task
 	// corroborates that the run genuinely did not succeed.

package/src/runtime/goal-evaluator.ts

@@ -23,15 +23,15 @@
  * + verification-gates results + transcript tail (~8 KiB bounded read).
  */
 
-import { readFileSync, existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import type { AgentConfig } from "../agents/agent-config.ts";
+import type { GoalVerdict } from "../state/types.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+import { redactSecretString } from "../utils/redaction.ts";
 import { runChildPi } from "./child-pi.ts";
+import { collectToolCallsFromEvent } from "./completion-guard.ts";
 import { parsePiJsonOutput } from "./pi-json-output.ts";
 import { extractStructuredResult } from "./result-extractor.ts";
-import { collectToolCallsFromEvent } from "./completion-guard.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { redactSecretString } from "../utils/redaction.ts";
-import type { AgentConfig } from "../agents/agent-config.ts";
-import type { GoalVerdict } from "../state/types.ts";
 
 export interface GoalEvidence {
 	/** Tail slice of the turn's worker transcript (bounded ~8 KiB). */
@@ -39,7 +39,11 @@ export interface GoalEvidence {
 	/** Structured tool-call summary extracted from transcript events. */
 	toolCalls: Array<{ tool: string; args?: unknown }>;
 	/** Verification command results (exit codes + output refs), if verification ran. */
-	verificationResults?: Array<{ command: string; exitCode: number | null; passed: boolean }>;
+	verificationResults?: Array<{
+		command: string;
+		exitCode: number | null;
+		passed: boolean;
+	}>;
 }
 
 export interface EvaluateGoalInput {
@@ -102,10 +106,7 @@ Respond with ONLY a single JSON object, no prose, no markdown fences:
 
 /** Build the judge task prompt: objective + scope + verification + evidence. */
 function buildJudgeTask(input: EvaluateGoalInput): string {
-	const lines: string[] = [
-		"# Goal to evaluate",
-		input.objective,
-	];
+	const lines: string[] = ["# Goal to evaluate", input.objective];
 	if (input.scope) lines.push("", "# Scope (allowed changes)", input.scope);
 	if (input.verification?.commands?.length) {
 		lines.push("", "# Acceptance verification (ALL must pass with exit code 0)", ...input.verification.commands.map((c) => `- ${c}`));
@@ -118,7 +119,9 @@ function buildJudgeTask(input: EvaluateGoalInput): string {
 		lines.push("", "# ⚠ VERIFICATION COMPROMISED — objective oracle UNRELIABLE for this turn");
 		lines.push("The following project-manifest files changed during the loop (detected by integrity snapshot):");
 		lines.push(...input.verificationCompromised.map((f) => `- ${f}`));
-		lines.push("Do NOT trust any verification-result 'PASS' for this turn. A worker may have rewritten the manifest to satisfy the command. Judge completion SOLELY from the transcript + artifact evidence, and default to achieved:false unless the transcript shows concrete finished work that does not depend on the compromised command.");
+		lines.push(
+			"Do NOT trust any verification-result 'PASS' for this turn. A worker may have rewritten the manifest to satisfy the command. Judge completion SOLELY from the transcript + artifact evidence, and default to achieved:false unless the transcript shows concrete finished work that does not depend on the compromised command.",
+		);
 	}
 	lines.push("", "# Evidence");
 	if (input.evidence.verificationResults?.length) {
@@ -170,7 +173,11 @@ function tryParseDirectVerdict(stdout: string): { achieved: boolean; reason: str
 		const parsed = JSON.parse(trimmed) as Record<string, unknown>;
 		if (typeof parsed.achieved !== "boolean" || typeof parsed.reason !== "string") return undefined;
 		const refs = Array.isArray(parsed.evidenceRefs) ? parsed.evidenceRefs.filter((r): r is string => typeof r === "string") : undefined;
-		return { achieved: parsed.achieved, reason: parsed.reason, ...(refs ? { evidenceRefs: refs } : {}) };
+		return {
+			achieved: parsed.achieved,
+			reason: parsed.reason,
+			...(refs ? { evidenceRefs: refs } : {}),
+		};
 	} catch {
 		return undefined;
 	}
@@ -205,7 +212,12 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 		});
 
 		if (result.exitCode !== 0 || result.error) {
-			return blockedVerdict(input.turn, input.model, evaluatedAt, `judge spawn failed (exit=${result.exitCode}): ${result.error ?? result.stderr.slice(0, 200)}`);
+			return blockedVerdict(
+				input.turn,
+				input.model,
+				evaluatedAt,
+				`judge spawn failed (exit=${result.exitCode}): ${result.error ?? result.stderr.slice(0, 200)}`,
+			);
 		}
 
 		const parsed = parsePiJsonOutput(result.stdout);
@@ -232,11 +244,19 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 		}
 
 		const extracted = extractStructuredResult(finalText);
-		const data = extracted.structured ? (extracted.data as { achieved?: unknown; reason?: unknown; evidenceRefs?: unknown }) : undefined;
+		const data = extracted.structured
+			? (extracted.data as {
+					achieved?: unknown;
+					reason?: unknown;
+					evidenceRefs?: unknown;
+				})
+			: undefined;
 		if (!data || typeof data.achieved !== "boolean" || typeof data.reason !== "string") {
 			return blockedVerdict(input.turn, input.model, evaluatedAt, `judge output not valid verdict JSON: ${truncate(finalText, 200)}`);
 		}
-		const evidenceRefs = Array.isArray(data.evidenceRefs) ? data.evidenceRefs.filter((r): r is string => typeof r === "string") : undefined;
+		const evidenceRefs = Array.isArray(data.evidenceRefs)
+			? data.evidenceRefs.filter((r): r is string => typeof r === "string")
+			: undefined;
 		return {
 			turn: input.turn,
 			achieved: data.achieved,
@@ -247,12 +267,23 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 		};
 	} catch (error) {
 		logInternalError("goal-evaluator.evaluateGoal", error, `turn=${input.turn}`);
-		return blockedVerdict(input.turn, input.model, evaluatedAt, `judge threw: ${error instanceof Error ? error.message : String(error)}`);
+		return blockedVerdict(
+			input.turn,
+			input.model,
+			evaluatedAt,
+			`judge threw: ${error instanceof Error ? error.message : String(error)}`,
+		);
 	}
 }
 
 function blockedVerdict(turn: number, model: string, evaluatedAt: string, reason: string): GoalVerdict {
-	return { turn, achieved: false, reason: `BLOCKED: ${reason}`, evaluatorModel: model, evaluatedAt };
+	return {
+		turn,
+		achieved: false,
+		reason: `BLOCKED: ${reason}`,
+		evaluatorModel: model,
+		evaluatedAt,
+	};
 }
 
 /**
@@ -290,5 +321,9 @@ export function bundleEvidence(
 		}
 	}
 
-	return { transcriptSlice, toolCalls: toolCalls.slice(-50), verificationResults };
+	return {
+		transcriptSlice,
+		toolCalls: toolCalls.slice(-50),
+		verificationResults,
+	};
 }