pi-crew 0.9.41 → 0.9.44

package/src/runtime/goal-loop-runner.ts

@@ -16,6 +16,7 @@
 
 import { randomBytes } from "node:crypto";
 import { existsSync, readdirSync } from "node:fs";
+import { createRequire } from "node:module";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import { loadConfig } from "../config/config.ts";
 import { effectiveRunConfig } from "../extension/team-tool/config-patch.ts";
@@ -65,21 +66,29 @@ export const stubGoalEvaluator = async (
 	_m?: import("../state/types.ts").TeamRunManifest,
 	_t?: import("../state/types.ts").TeamTaskState[],
 	_s?: AbortSignal,
-): Promise<GoalVerdict> => ({
-	turn: goal.turnsUsed,
-	achieved: false,
-	reason: `not-achieved: stub evaluator (P0). Turn ${goal.turnsUsed}/${goal.maxTurns} completed; P1 will judge against objective + verification.`,
-	evaluatorModel: "stub",
-	evaluatedAt: new Date().toISOString(),
+): Promise<GoalEvaluatorResult> => ({
+	verdict: {
+		turn: goal.turnsUsed,
+		achieved: false,
+		reason: `not-achieved: stub evaluator (P0). Turn ${goal.turnsUsed}/${goal.maxTurns} completed; P1 will judge against objective + verification.`,
+		evaluatorModel: "stub",
+		evaluatedAt: new Date().toISOString(),
+	},
+	judgeUsage: undefined,
 });
 
+export type GoalEvaluatorResult = {
+	verdict: GoalVerdict;
+	judgeUsage?: { totalTokens: number; inputTokens?: number; outputTokens?: number };
+};
+
 export type GoalEvaluatorFn = (
 	goal: GoalLoopState,
 	turnRunId: string,
 	turnManifest: import("../state/types.ts").TeamRunManifest,
 	turnTasks: import("../state/types.ts").TeamTaskState[],
 	signal: AbortSignal,
-) => Promise<GoalVerdict>;
+) => Promise<GoalEvaluatorResult>;
 
 /**
  * Production evaluator (P1): bundles turn evidence + calls the LLM judge.
@@ -93,7 +102,7 @@ export const realGoalEvaluator = async (
 	turnManifest: import("../state/types.ts").TeamRunManifest,
 	turnTasks: import("../state/types.ts").TeamTaskState[],
 	signal: AbortSignal,
-): Promise<GoalVerdict> => {
+): Promise<GoalEvaluatorResult> => {
 	const transcriptPath = deriveTranscriptPath(turnManifest.artifactsRoot, turnTasks);
 	// Fix round-7 F1: execute verification commands (if configured) so the judge has real evidence.
 	// Previously bundleEvidence received `undefined` — the judge was told commands "MUST pass"
@@ -260,8 +269,11 @@ function resolveGoalTurnWorkflow(goal: GoalLoopState): WorkflowConfig {
 	const wrapName = (goal as GoalLoopState & { goalWrapWorkflow?: string }).goalWrapWorkflow;
 	if (!wrapName) return buildTurnWorkflow();
 	try {
-		const { discoverWorkflows, allWorkflows } =
-			require("../workflows/discover-workflows.ts") as typeof import("../workflows/discover-workflows.ts");
+		// LAZY: createRequire for synchronous module resolution in ESM context
+		const requireFromHere = createRequire(import.meta.url);
+		const { discoverWorkflows, allWorkflows } = requireFromHere(
+			"../workflows/discover-workflows.ts",
+		) as typeof import("../workflows/discover-workflows.ts");
 		const found = allWorkflows(discoverWorkflows(goal.cwd)).find((w) => w.name === wrapName && w.source === "builtin");
 		if (found) return found;
 		logInternalError(
@@ -672,17 +684,38 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 				logInternalError("goal-loop.saveTurnTasks", error, `turnRunId=${created.manifest.runId}`);
 			}
 
+			// GL-1: if the turn ended in blocked/failed status, stop the loop without spawning the judge.
+			// Previously the loop continued to evaluateGoal on blocked/failed turns, burning maxTurns.
+			const turnStatus = turnResult.manifest.status;
+			if (turnStatus === "blocked" || turnStatus === "failed") {
+				goal = safeSetStatus(store, goal.goalId, "blocked", goal, eventsPath);
+				appendEvent(eventsPath, {
+					type: "goal.turn_terminal_status",
+					runId: manifest.runId,
+					data: {
+						goalId: goal.goalId,
+						turn: turnIndex,
+						turnRunId: created.manifest.runId,
+						turnStatus,
+					},
+				});
+				break;
+			}
+
 			// ── BUDGET accumulation (§0c C2: collectRunMetrics) ──────────────────────
-			const updatedBudget = accumulateBudget(goal, created.manifest.runId);
+			const turnBudget = accumulateBudget(goal, created.manifest.runId);
 
 			// ── EVALUATE (P1: real LLM judge; pass turn manifest + tasks for transcript lookup) ──
-			const verdict = await evaluator(
-				{ ...goal, budgetUsed: updatedBudget },
+			const { verdict, judgeUsage } = await evaluator(
+				{ ...goal, budgetUsed: turnBudget },
 				created.manifest.runId,
 				turnResult.manifest,
 				turnResult.tasks,
 				signal,
 			);
+			// BDG-1: accumulate judge token usage into budget alongside the turn's worker tokens.
+			const judgeTokens = judgeUsage?.totalTokens ?? 0;
+			const updatedBudget = turnBudget + judgeTokens;
 			const historyEntry = {
 				runId: created.manifest.runId,
 				outcome: verdict.achieved ? "achieved" : "not-achieved",

package/src/runtime/goal-state-store.ts

@@ -13,7 +13,7 @@
  * per-turn usage stays on each turn's TeamRunManifest/tasks.json.
  */
 
-import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
 import { atomicWriteJson } from "../state/atomic-write.ts";
 import { appendEvent } from "../state/event-log.ts";

package/src/runtime/handoff-manager.ts

@@ -54,8 +54,6 @@ export function isValidHandoffSummary(value: unknown): value is HandoffSummary {
  * @see docs/pi-boomerang-integration-plan.md
  */
 
-import type { TeamEvent } from "../state/event-log.ts";
-
 /**
  * Represents a key decision made during task execution.
  */

package/src/runtime/intercom-bridge.ts

@@ -8,8 +8,6 @@
  * The actual tool registration happens in task-runner.ts.
  */
 
-import { logInternalError } from "../utils/internal-error.ts";
-
 // ── Types ────────────────────────────────────────────────────────────────
 
 export type IntercomUrgency = "low" | "medium" | "high" | "critical";

package/src/runtime/live-agent-manager.ts

@@ -2,6 +2,7 @@ import type { appendEvent } from "../state/event-log.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import type { CrewAgentRecord } from "./crew-agent-runtime.ts";
 import type { IrcMessage } from "./live-irc.ts";
+import { checkProcessLiveness } from "./process-status.ts";
 
 const MAX_PENDING_MESSAGES = 1000;
 
@@ -263,10 +264,34 @@ export function evictStaleLiveAgentHandles(now = Date.now()): number {
 				evicted++;
 			}
 		} else if (age > STALE_RUNNING_HANDLE_MS) {
-			// Active-status handle with no update for 30min — presumed dead
-			liveAgents.delete(agentId);
-			safeDisposeLiveSession(handle);
-			evicted++;
+			// Active-status handle with no update for 30min — check process liveness
+			// before evicting. Only evict if the process is dead, to avoid evicting
+			// slow-but-alive agents.
+			const sessionPid = (handle.session as Record<string, unknown>)?.pid as number | undefined;
+			if (sessionPid === undefined) {
+				// In-process live-session agents have no pid — the Pi SDK returns
+				// in-process objects, not child processes. checkProcessLiveness(undefined)
+				// returns {alive:false} which would wrongly evict a running agent.
+				// Check session-level activity signals first. If the session is
+				// actively streaming or has pending messages, it is alive — skip.
+				// Otherwise, rely on the idle timeout alone: do NOT dispose just
+				// because pid is undefined.
+				const session = handle.session as Record<string, unknown>;
+				const isStreaming = session?.isStreaming === true;
+				const pendingCount = (session?.pendingMessageCount as number | undefined) ?? 0;
+				if (isStreaming || pendingCount > 0) {
+					// Session is active — skip eviction.
+					continue;
+				}
+				// No activity signals and no pid — do NOT evict based on PID liveness.
+				continue;
+			}
+			const liveness = checkProcessLiveness(sessionPid);
+			if (!liveness.alive) {
+				liveAgents.delete(agentId);
+				safeDisposeLiveSession(handle);
+				evicted++;
+			}
 		}
 	}
 	return evicted;
@@ -282,7 +307,7 @@ export function listActiveLiveAgents(): LiveAgentHandle[] {
 
 export function getLiveAgentContextPercent(agentIdOrTaskId: string): number | null {
 	const handle = getLiveAgent(agentIdOrTaskId);
-	if (!handle || handle.status !== "running") return null;
+	if (handle?.status !== "running") return null;
 	try {
 		return handle.session.getSessionStats?.().contextUsage?.percent ?? null;
 	} catch {

package/src/runtime/live-extension-bridge.ts

@@ -29,8 +29,6 @@
  *   - setActiveTools / getActiveTools / getAllTools
  */
 
-import type { YieldResult } from "./yield-handler.ts";
-
 export interface ExtensionBridgeApis {
 	sendMessage: (message: unknown, options?: Record<string, unknown>) => void;
 	sendUserMessage: (content: unknown, options?: Record<string, unknown>) => void;

package/src/runtime/live-session-runtime.ts

@@ -27,7 +27,7 @@ import {
 } from "./live-agent-manager.ts";
 import { subscribeLiveControlRealtime } from "./live-control-realtime.ts";
 import { buildExtensionBridge } from "./live-extension-bridge.ts";
-import { collectLiveSessionHealth, formatLiveSessionDiagnostics, type LiveSessionHealth } from "./live-session-health.ts";
+import { collectLiveSessionHealth, formatLiveSessionDiagnostics } from "./live-session-health.ts";
 import { buildMcpProxyFromSession } from "./mcp-proxy.ts";
 import { buildConfiguredModelRouting } from "./model-fallback.ts";
 import { readEnabledModelsPatterns } from "./model-scope.ts";
@@ -231,7 +231,7 @@ function eventText(event: unknown): string[] {
 
 function finalAssistantText(event: unknown): string[] {
 	const obj = asRecord(event);
-	if (!obj || obj.type !== "message_end") return [];
+	if (obj?.type !== "message_end") return [];
 	const message = asRecord(obj.message);
 	if (message?.role !== "assistant") return [];
 	return textFromContent(message.content);
@@ -266,7 +266,7 @@ async function resolveScopeModelsPatterns(cwd: string, agentDir?: string): Promi
 }
 
 function modelFromRegistry(modelRegistry: unknown, modelId: string | undefined): unknown {
-	if (!modelId || !modelId.includes("/")) return undefined;
+	if (!modelId?.includes("/")) return undefined;
 	const registry = asRecord(modelRegistry);
 	const find = registry?.find;
 	if (typeof find !== "function") return undefined;
@@ -450,7 +450,7 @@ function filterActiveTools(session: LiveSessionLike, agent: AgentConfig, role?:
 	const allowed = policy.tools?.length ? new Set(policy.tools) : undefined;
 	const active = session
 		.getActiveToolNames()
-		.filter((name) => !recursiveTools.has(name) && (!disallowed || !disallowed.has(name)) && (!allowed || allowed.has(name)));
+		.filter((name) => !recursiveTools.has(name) && !disallowed?.has(name) && (!allowed || allowed.has(name)));
 	session.setActiveToolsByName(active);
 }
 
@@ -822,61 +822,69 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 		});
 		if (typeof session.subscribe === "function") {
 			unsubscribe = session.subscribe((event) => {
-				if (!isCurrent()) return;
-				jsonEvents += 1;
-				appendTranscript(input.transcriptPath, event);
-				const sidechainType = eventToSidechainType(event);
-				if (sidechainType)
-					writeSidechainEntry(sidechainPath, {
-						agentId,
-						type: sidechainType,
-						message: event,
-						cwd: input.task.cwd,
-					});
-				const obj = asRecord(event);
-				if (obj?.type === "turn_end") {
-					turnCount += 1;
-					trackLiveAgentTurnEnd(agentId);
-					if (maxTurns !== undefined && !softLimitReached && turnCount >= maxTurns) {
-						softLimitReached = true;
-						void session?.steer?.("You have reached your turn limit. Wrap up immediately — provide your final answer now.");
-					} else if (maxTurns !== undefined && softLimitReached && turnCount >= maxTurns + graceTurns) {
-						void session?.abort?.();
-					}
-				}
-				// Accumulate lifetime usage that survives compaction
-				if (obj?.type === "message_end" && extractMessageRole(obj) === "assistant") {
-					const u = extractMessageUsage(obj);
-					if (u) {
-						trackTaskUsage(input.task.id, {
-							input: typeof u.input === "number" ? u.input : 0,
-							output: typeof u.output === "number" ? u.output : 0,
-							cacheWrite: typeof u.cacheWrite === "number" ? u.cacheWrite : 0,
+				// Wrap callback body in try/catch to prevent unguarded exceptions from
+				// propagating into the session internals and crashing the live session.
+				try {
+					if (!isCurrent()) return;
+					jsonEvents += 1;
+					appendTranscript(input.transcriptPath, event);
+					const sidechainType = eventToSidechainType(event);
+					if (sidechainType)
+						writeSidechainEntry(sidechainPath, {
+							agentId,
+							type: sidechainType,
+							message: event,
+							cwd: input.task.cwd,
 						});
+					const obj = asRecord(event);
+					if (obj?.type === "turn_end") {
+						turnCount += 1;
+						trackLiveAgentTurnEnd(agentId);
+						if (maxTurns !== undefined && !softLimitReached && turnCount >= maxTurns) {
+							softLimitReached = true;
+							void session?.steer?.("You have reached your turn limit. Wrap up immediately — provide your final answer now.");
+						} else if (maxTurns !== undefined && softLimitReached && turnCount >= maxTurns + graceTurns) {
+							void session?.abort?.();
+						}
 					}
-				}
-				input.onEvent?.(event);
-				const text = [...eventText(event), ...finalAssistantText(event)].join("\n");
-				if (text.trim()) {
-					stdout += `${text}\n`;
-					streamOut?.write(text + "\n");
-					trackLiveAgentResponseText(agentId, text);
-					input.onOutput?.(text);
-				}
-				// G2: Track tool start/end for activity display
-				if (obj?.type === "tool_use" || obj?.type === "tool_execution_start") {
-					const toolName = extractToolName(obj) ?? "unknown";
-					trackLiveAgentToolStart(agentId, toolName);
-				}
-				if (obj?.type === "tool_result" || obj?.type === "tool_execution_end") {
-					const toolName = extractToolName(obj) ?? "unknown";
-					trackLiveAgentToolEnd(agentId, toolName);
-				}
-				// Phase 1: collect events for yield detection
-				if (collectedJsonEvents && event && typeof event === "object" && !Array.isArray(event)) {
-					collectedJsonEvents.push(event as Record<string, unknown>);
-					if (collectedJsonEvents.length > maxCollectedJsonEvents)
-						collectedJsonEvents.splice(0, collectedJsonEvents.length - maxCollectedJsonEvents);
+					// Accumulate lifetime usage that survives compaction
+					if (obj?.type === "message_end" && extractMessageRole(obj) === "assistant") {
+						const u = extractMessageUsage(obj);
+						if (u) {
+							trackTaskUsage(input.task.id, {
+								input: typeof u.input === "number" ? u.input : 0,
+								output: typeof u.output === "number" ? u.output : 0,
+								cacheWrite: typeof u.cacheWrite === "number" ? u.cacheWrite : 0,
+							});
+						}
+					}
+					input.onEvent?.(event);
+					const text = [...eventText(event), ...finalAssistantText(event)].join("\n");
+					if (text.trim()) {
+						stdout += `${text}\n`;
+						streamOut?.write(text + "\n");
+						trackLiveAgentResponseText(agentId, text);
+						input.onOutput?.(text);
+					}
+					// G2: Track tool start/end for activity display
+					if (obj?.type === "tool_use" || obj?.type === "tool_execution_start") {
+						const toolName = extractToolName(obj) ?? "unknown";
+						trackLiveAgentToolStart(agentId, toolName);
+					}
+					if (obj?.type === "tool_result" || obj?.type === "tool_execution_end") {
+						const toolName = extractToolName(obj) ?? "unknown";
+						trackLiveAgentToolEnd(agentId, toolName);
+					}
+					// Phase 1: collect events for yield detection
+					if (collectedJsonEvents && event && typeof event === "object" && !Array.isArray(event)) {
+						collectedJsonEvents.push(event as Record<string, unknown>);
+						if (collectedJsonEvents.length > maxCollectedJsonEvents)
+							collectedJsonEvents.splice(0, collectedJsonEvents.length - maxCollectedJsonEvents);
+					}
+				} catch (error) {
+					// Prevent unguarded exceptions in the subscribe callback from crashing
+					// the live session or propagating into the session internals.
+					logInternalError("live-session.subscribe-callback", error, `agentId=${agentId}`);
 				}
 			});
 		}

package/src/runtime/manifest-cache.ts

@@ -9,6 +9,15 @@ import { isSafePathId, resolveContainedRelativePath, resolveRealContainedPath }
 
 export interface ManifestCache {
 	list(limit?: number): TeamRunManifest[];
+	/**
+	 * Return ONLY running manifests, capped only by `limit`.
+	 *
+	 * RT-F3: unlike `list(limit)`, this filters `status === "running"` BEFORE
+	 * the limit is applied so stale orphaned runs that have been pushed past
+	 * the top-N by recent activity are not silently hidden from crash-recovery
+	 * and zombie-detection scans.
+	 */
+	listActive(limit: number): TeamRunManifest[];
 	get(runId: string): TeamRunManifest | undefined;
 	clear(runId?: string): void;
 	dispose(): void;
@@ -203,6 +212,15 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 		return undefined;
 	}
 
+	/**
+	 * NOTE (RT-F10): This function performs a full FS scan + JSON.parse of all
+	 * manifests on every TTL expiry (default 500ms). This is a known performance
+	 * tradeoff: fs.watch provides real-time invalidation (see constructor above)
+	 * so the TTL cache is only consulted when the watcher fires, but the list()
+	 * call itself still re-reads all entries to pick up changes. Incremental
+	 * updates via fs.watch-driven delta tracking are planned for a future
+	 * iteration to avoid the full scan on each expiry.
+	 */
 	function list(limit = DEFAULT_CACHE.manifestMaxEntries): TeamRunManifest[] {
 		const now = Date.now();
 		const cached = listCache.get(limit);
@@ -248,6 +266,46 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 		return undefined;
 	}
 
+	/**
+	 * RT-F3: filter to `status === "running"` BEFORE applying the limit so an
+	 * orphaned run that has been pushed past the top-N by recent successful
+	 * runs is still surfaced to crash-recovery. The cap is the LIMIT, not the
+	 * "top-N most recent"; callers (e.g. zombie detection) explicitly want
+	 * EVERY currently-running run, in any order.
+	 *
+	 * Internally performs a full scan (NOT via list()) so the cap doesn't
+	 * silently drop "running" runs that fell past the top-N createdAt cutoff.
+	 * Still goes through parseManifestIfChanged for stat+size memoization, so
+	 * the per-run I/O cost is the same as list().
+	 */
+	function listActive(limit: number): TeamRunManifest[] {
+		const cap = Math.max(0, limit);
+		const parsedEntries = [
+			...roots.flatMap((root) => collectRoots(root)),
+			...activeRunEntries().map((entry) => ({
+				runId: entry.runId,
+				path: entry.manifestPath,
+			})),
+		];
+		const unique = new Map<string, CachedManifest | undefined>();
+		for (const entry of parsedEntries) {
+			if (entry.runId.length === 0) continue;
+			let cached = manifestIndex.get(entry.runId);
+			const root = path.dirname(path.dirname(entry.path));
+			const parsed = parseManifestIfChanged(root, entry.runId, entry.path, cached);
+			if (parsed) {
+				cached = parsed;
+				manifestIndex.set(entry.runId, cached);
+			}
+			if (cached) unique.set(entry.runId, cached);
+		}
+		const running = [...unique.values()]
+			.filter((value): value is CachedManifest => value !== undefined)
+			.map((value) => value.manifest)
+			.filter((manifest) => manifest.status === "running");
+		return running.slice(0, cap);
+	}
+
 	if (options.watch ?? true) {
 		for (const root of roots) {
 			const watcher = watchWithErrorHandler(
@@ -268,6 +326,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 
 	return {
 		list,
+		listActive,
 		get,
 		clear(runId) {
 			invalidate(runId);

package/src/runtime/mcp-proxy.ts

@@ -17,7 +17,7 @@
  */
 
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { Static, TSchema } from "@sinclair/typebox";
+import type { TSchema } from "@sinclair/typebox";
 
 export interface McpProxyConfig {
 	/** Whether to enable MCP in the child session. */

package/src/runtime/orphan-worker-registry.ts

@@ -22,10 +22,10 @@
  * writes from causing lost updates.
  */
 
-import { execFileSync, execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { isSymlinkSafePath } from "../state/atomic-write.ts";
+import { atomicWriteFile, isSymlinkSafePath } from "../state/atomic-write.ts";
 import { withFileLockSync } from "../state/locks.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { userPiRoot } from "../utils/paths.ts";
@@ -252,7 +252,7 @@ function writeRegistry(entries: OrphanWorkerEntry[]): void {
 		fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
 	}
 	try {
-		fs.writeFileSync(p, JSON.stringify(entries, null, 2), { mode: 0o600 });
+		atomicWriteFile(p, JSON.stringify(entries, null, 2), { mode: 0o600 });
 	} catch (error) {
 		logInternalError("orphan-worker-registry.write", error, `path=${p} entries=${entries.length}`);
 	}

package/src/runtime/output-validator.ts

@@ -42,7 +42,7 @@ export function validateWorkerOutput(role: string, output: string): OutputValida
 	const issues: string[] = [];
 
 	// Empty output always fails
-	if (!output || !output.trim()) {
+	if (!output?.trim()) {
 		return {
 			valid: false,
 			formatMatch: false,

package/src/runtime/path-overlap.ts

@@ -124,7 +124,7 @@ export function filterReadyByWriteOverlap(
 	for (const taskId of readyTaskIds) {
 		if (pickedTaskIds.length >= maxCount) break;
 		const task = taskById.get(taskId);
-		if (!task || !task.stepId) {
+		if (!task?.stepId) {
 			// No step reference: treat as no declared write path → never conflicts.
 			pickedTaskIds.push(taskId);
 			continue;

package/src/runtime/pi-args.ts

@@ -1,9 +1,9 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { fileURLToPath } from "node:url";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import { resolveToolPolicy } from "../agents/agent-config.ts";
+import { atomicWriteFile } from "../state/atomic-write.ts";
 import { packageRoot, userPiRoot } from "../utils/paths.ts";
 
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
@@ -323,7 +323,7 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 		const tmpBase = getPiTempBase();
 		tempDir = createSafeTempDir(tmpBase, `pi-crew-${process.pid}-`);
 		const promptPath = path.join(tempDir, `${input.agent.name.replace(/[^\w.-]/g, "_")}.md`);
-		fs.writeFileSync(promptPath, input.agent.systemPrompt, { mode: 0o600 });
+		atomicWriteFile(promptPath, input.agent.systemPrompt, { mode: 0o600 });
 		args.push(input.agent.systemPromptMode === "append" ? "--append-system-prompt" : "--system-prompt", promptPath);
 	}
 
@@ -333,7 +333,7 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 			tempDir = createSafeTempDir(tmpBase, `pi-crew-${process.pid}-`);
 		}
 		const taskPath = path.join(tempDir, "task.md");
-		fs.writeFileSync(taskPath, input.task, { mode: 0o600 });
+		atomicWriteFile(taskPath, input.task, { mode: 0o600 });
 		args.push(`@${taskPath}`);
 	} else {
 		args.push(`Task: ${input.task}`);

package/src/runtime/pi-json-output.ts

@@ -55,7 +55,8 @@ function extractUsage(value: unknown): ParsedPiUsage | undefined {
 		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
 	};
 	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
-	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
+	// Pi --mode json nests usage under message for message_end / turn_end events.
+	for (const key of ["usage", "message", "tokenUsage", "tokens", "stats"]) {
 		const nested = extractUsage(obj[key]);
 		if (nested) return nested;
 	}
@@ -151,14 +152,14 @@ function extractErrorMessage(event: unknown): string | undefined {
  */
 function extractPatch(event: unknown, patches: string[]): void {
 	const obj = asRecord(event);
-	if (!obj || obj.type !== "tool_result") return;
+	if (obj?.type !== "tool_result") return;
 
 	const content = obj.content;
 	if (!Array.isArray(content)) return;
 
 	for (const item of content) {
 		const part = asRecord(item);
-		if (!part || part.type !== "text") continue;
+		if (part?.type !== "text") continue;
 		const text = typeof part.text === "string" ? part.text : "";
 
 		// Check if this looks like a unified patch (starts with "---" or "+++")

package/src/runtime/pi-spawn.ts

@@ -189,7 +189,13 @@ function resolvePiCliScript(): string | undefined {
 	const argv1 = process.argv[1];
 	if (argv1) {
 		const argvPath = path.isAbsolute(argv1) ? argv1 : path.resolve(argv1);
-		if (isRunnableNodeScript(argvPath)) return argvPath;
+		// Only trust argv1 if we can confirm the current process is running from
+		// the pi-coding-agent package directory. Otherwise, when pi-crew is invoked
+		// from a standalone test script (process.argv[1] = test script path),
+		// resolvePiCliScript would incorrectly return the test script as the pi
+		// CLI. resolvePiPackageRoot walks up from argv1 looking for a package.json
+		// named @earendil-works/pi-coding-agent or @mariozechner/pi-coding-agent.
+		if (resolvePiPackageRoot() && isRunnableNodeScript(argvPath)) return argvPath;
 	}
 
 	// npm-global package dirs derived from `npm root -g` — placed BEFORE the

package/src/runtime/pipeline-runner.ts

@@ -1,9 +1,6 @@
-import type { AgentConfig } from "../agents/agent-config.ts";
 import { errors } from "../errors.ts";
 import { appendEventAsync, flushEventLogBuffer } from "../state/event-log.ts";
-import type { TeamTaskState } from "../state/types.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
+import type { WorkflowConfig } from "../workflows/workflow-config.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
 
 /**

package/src/runtime/post-checks.ts

@@ -5,7 +5,6 @@
  * Distilled from pi-autoresearch's post-check / backpressure pattern.
  */
 import { execFileSync } from "node:child_process";
-import * as path from "node:path";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
 import { resolveShellForScript } from "../utils/resolve-shell.ts";

package/src/runtime/retry-runner.ts

@@ -70,10 +70,10 @@ export interface TaskRunnerLike {
  */
 export class RetryRunner {
 	private _disposed = false;
-	private _handoffs: HandoffSummary[] = [];
 
 	private taskRunner: TaskRunnerLike;
 	private handoffManager: HandoffManager;
+	private _handoffs: HandoffSummary[] = [];
 
 	constructor(taskRunner: TaskRunnerLike, handoffManager: HandoffManager) {
 		this.taskRunner = taskRunner;