pi-crew 0.9.42 → 0.9.46

package/src/runtime/compact-stages/tail-capture-stage.ts

@@ -59,7 +59,7 @@ export class TailCaptureStage implements ICompactStage {
 			// never contains a partial multi-byte sequence.
 			if (Buffer.byteLength(text, "utf-8") <= this.maxBytes) return text;
 			let tail = text.slice(Math.max(0, text.length - this.maxBytes));
-			while (Buffer.byteLength(tail, "utf-8") > this.maxBytes) tail = tail.slice(1024);
+			while (Buffer.byteLength(tail, "utf-8") > this.maxBytes) tail = tail.slice(0, -1);
 			return this.marker ? `${this.marker}\n${tail}` : tail;
 		}
 		// Char cap mode.

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

@@ -28,6 +28,11 @@ export interface DwfCheckpointState {
 	logs: string[]; // capped copy (≤1000); the events log (dwf.log) is the durable source of truth
 	spent: number; // budget accumulator (round-14 P1-2)
 	agentCount: number;
+	/** PERS-1: per-agent-call idempotency cache. Maps a deterministic call ID to the
+	 *  cached result so a DWF resume skips already-completed agent calls (avoids
+	 *  duplicating artifacts/mailbox/tokens). Uses Record (not Map) for JSON
+	 *  serialization safety. */
+	completedAgentCalls?: Record<string, { text: string; usage?: { input: number; output: number } }>;
 	updatedAt: string;
 }
 

package/src/runtime/dynamic-workflow-context.ts

@@ -35,6 +35,7 @@ import { logInternalError } from "../utils/internal-error.ts";
 import { cleanupAgentWorktreeAsync, prepareAgentWorktreeAsync } from "../worktree/worktree-manager.ts";
 import { runChildPi } from "./child-pi.ts";
 import type { DwfCheckpointState } from "./dwf-state-store.ts";
+import { withWorkerSlot } from "./global-worker-cap.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
 import { parsePiJsonOutput } from "./pi-json-output.ts";
 import { renderPlanTemplate } from "./plan-templates.ts";
@@ -269,6 +270,11 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 		logs: opts.resumedState ? [...opts.resumedState.logs].slice(0, 1000) : [],
 		args: opts.args ?? {},
 	};
+	// PERS-1: per-agent-call idempotency cache. Hydrated from resumedState so a DWF
+	// resume skips already-completed agent calls (avoids duplicating artifacts/mailbox/tokens).
+	// Uses Record (not Map) for JSON serialization safety.
+	const completedAgentCalls: Record<string, { text: string; usage?: { input: number; output: number } }> =
+		opts.resumedState?.completedAgentCalls ?? {};
 	// round-14 P1-2: frozen budget surface. The closures read wfState.spent so the
 	// object stays live after Object.freeze(ctx). total is a snapshot primitive.
 	const budget = Object.freeze({
@@ -290,10 +296,35 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 			// regardless of which return/throw path is taken.
 			let worktreePath: string | undefined;
 			let worktreeBranch: string | undefined;
+			// BDG-2: declared before the try so the catch block can un-reserve on failure.
+			const ESTIMATE = 4096;
+			let reserved = false;
 			try {
-				// round-14 P1-2: budget check BEFORE spawning. When the per-workflow token
-				// budget is exhausted, reject the call without consuming a child worker.
-				if (budget.total !== null && budget.remaining() <= 0) {
+				// PERS-1: per-agent-call idempotency. Compute a deterministic call ID
+				// from the call arguments and check if this call was already completed
+				// (e.g. during a previous run before a crash). If so, return the cached
+				// result without re-spawning the agent.
+				const callId = JSON.stringify({
+					role: call.role,
+					agent: call.agent,
+					prompt: call.prompt,
+					model: call.model,
+					schema: call.schema ? "yes" : "no",
+				});
+				const cached = completedAgentCalls[callId];
+				if (cached) {
+					return {
+						ok: true,
+						text: cached.text,
+						usage: cached.usage,
+						durationMs: 0,
+					};
+				}
+
+				// BDG-2: reserve-then-adjust budget. Before spawning, estimate the cost and
+				// reserve it by adding to wfState.spent. This prevents N concurrent calls from
+				// all seeing the same remaining budget and overspending.
+				if (budget.total !== null && budget.remaining() < ESTIMATE) {
 					return {
 						ok: false,
 						text: "",
@@ -301,6 +332,10 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 						durationMs: 0,
 					};
 				}
+				// Reserve the estimate before spawning.
+				wfState.spent += ESTIMATE;
+				reserved = true;
+
 				const agentConfig = resolveAgentForRole(call.role, {
 					explicitAgent: call.agent,
 					team: opts.team,
@@ -353,20 +388,25 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					}
 				}
 
-				const childResult = await runChildPi({
-					cwd: agentCwd,
-					task,
-					agent: effectiveAgent,
-					model: call.model ?? opts.modelOverride ?? agentConfig.model,
-					skillPaths: undefined, // skills resolved via agent config + team-role plumbing
-					maxTurns: call.maxTurns,
-					graceTurns: call.graceTurns,
-					signal: opts.signal,
-					artifactsRoot: manifest.artifactsRoot,
-					runId: manifest.runId,
-					role: call.role ?? call.agent,
-				});
+				const childResult = await withWorkerSlot(() =>
+					runChildPi({
+						cwd: agentCwd,
+						task,
+						agent: effectiveAgent,
+						model: call.model ?? opts.modelOverride ?? agentConfig.model,
+						skillPaths: undefined, // skills resolved via agent config + team-role plumbing
+						maxTurns: call.maxTurns,
+						graceTurns: call.graceTurns,
+						signal: opts.signal,
+						artifactsRoot: manifest.artifactsRoot,
+						runId: manifest.runId,
+						role: call.role ?? call.agent,
+					}),
+				);
 				if (childResult.exitCode !== 0 || childResult.error) {
+					// BDG-2: un-reserve the estimate on spawn failure.
+					wfState.spent -= ESTIMATE;
+					reserved = false;
 					return {
 						ok: false,
 						text: "",
@@ -376,8 +416,10 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 				}
 				const parsed = parsePiJsonOutput(childResult.stdout);
 				// round-14 P1-2: accumulate this run's token usage into the workflow budget.
-				// Covers both the success and schema-mismatch paths (both report parsed.usage).
-				wfState.spent += (parsed.usage?.input ?? 0) + (parsed.usage?.output ?? 0);
+				// BDG-2: adjust the reserve — subtract the estimate, add the actual usage.
+				// This correctly reduces spent when actualUsage < ESTIMATE.
+				wfState.spent += (parsed.usage?.input ?? 0) + (parsed.usage?.output ?? 0) - ESTIMATE;
+				reserved = false;
 				let text = parsed.finalText ?? "";
 				// Round-11 test fix: parsePiJsonOutput only extracts text from pi event stream
 				// ({type:"message_end", message:{role:"assistant", content:[...]}}). When the
@@ -400,6 +442,7 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					producer: "dynamic-workflow",
 				});
 				if (call.schema !== undefined && !extracted.structured) {
+					// BDG-2: un-reserve was already done above (reserved = false after adjust).
 					return {
 						ok: false,
 						text,
@@ -409,6 +452,11 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 						durationMs: Date.now() - started,
 					};
 				}
+				// PERS-1: cache the successful result for idempotency on resume.
+				completedAgentCalls[callId] = {
+					text,
+					usage: { input: parsed.usage?.input ?? 0, output: parsed.usage?.output ?? 0 },
+				};
 				return {
 					ok: true,
 					text,
@@ -418,6 +466,8 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					durationMs: Date.now() - started,
 				};
 			} catch (error) {
+				// BDG-2: un-reserve the estimate on failure (only if still reserved).
+				if (reserved) wfState.spent -= ESTIMATE;
 				logInternalError("dynamic-workflow-context.agent", error, `runId=${manifest.runId}`);
 				return {
 					ok: false,
@@ -450,6 +500,7 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 							logs: wfState.logs.slice(0, 1000),
 							spent: wfState.spent,
 							agentCount,
+							completedAgentCalls,
 							updatedAt: new Date().toISOString(),
 						});
 					} catch (checkpointError) {
@@ -709,6 +760,12 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 		get: () => agentCount,
 		enumerable: false,
 	});
+	// PERS-1: completedAgentCalls is read-only from the runner; the agent() method
+	// is the only writer. Exposed so getWorkflowCheckpoint() can include it.
+	Object.defineProperty(ctx, "__completedAgentCalls", {
+		get: () => completedAgentCalls,
+		enumerable: false,
+	});
 	return ctx;
 }
 
@@ -757,6 +814,9 @@ export function getWorkflowCheckpoint(ctx: WorkflowCtx): DwfCheckpointState {
 		logs: logs ?? [],
 		spent: ctx.budget.spent(),
 		agentCount: (ctx as unknown as { __agentCount?: number }).__agentCount ?? 0,
+		completedAgentCalls:
+			(ctx as unknown as { __completedAgentCalls?: Record<string, { text: string; usage?: { input: number; output: number } }> })
+				.__completedAgentCalls ?? {},
 		updatedAt: new Date().toISOString(),
 	};
 }

package/src/runtime/dynamic-workflow-runner.ts

@@ -19,6 +19,7 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { transformSync } from "esbuild";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
@@ -113,7 +114,11 @@ async function loadWorkflowModule(scriptPath: string): Promise<DynamicWorkflowSc
 	// raw .dwf.ts file. This is the same source jiti will execute.
 	const scriptSource = readFileSync(scriptPath, "utf-8");
 	if (isDeterminismCheckEnabled()) {
-		assertDeterministicScript(scriptSource);
+		// DISC-1: acorn can only parse JavaScript, not TypeScript. Real .dwf.ts files
+		// contain type annotations/imports that cause a silent parse error, so the
+		// determinism check never runs. Transpile to JS via esbuild first.
+		const js = transformSync(scriptSource, { loader: "ts", format: "esm" }).code;
+		assertDeterministicScript(js);
 	}
 	// jiti is the same loader async-runner.ts uses (resolveTypeScriptLoader). We require it
 	// lazily so this module stays importable in environments without jiti (type-only consumers).
@@ -166,9 +171,16 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 		});
 	}
 
+	// ERR-1: Create a timeout AbortController so we can abort spawned children on script timeout.
+	// Combine the input signal with the timeout controller's signal so EITHER source
+	// (external abort OR our timeout) propagates to runChildPi via the ctx.
+	// AbortSignal.any is available since Node 20.3 — the project requires Node 20+.
+	const timeoutController = new AbortController();
+	const combinedSignal = AbortSignal.any([signal, timeoutController.signal]);
+
 	const ctx = makeWorkflowCtx(manifest, {
 		concurrency: input.concurrency ?? workflow.maxConcurrency ?? 4,
-		signal,
+		signal: combinedSignal,
 		team: input.team,
 		modelOverride: input.modelOverride,
 		tokenBudget: input.tokenBudget ?? workflow.maxTokenBudget,
@@ -200,6 +212,10 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 		let timeoutHandle: NodeJS.Timeout | undefined;
 		const timeoutPromise = new Promise<never>((_, reject) => {
 			timeoutHandle = setTimeout(() => {
+				// ERR-1: abort the timeout controller so the abort propagates to
+				// runChildPi (via the combined signal passed to makeWorkflowCtx),
+				// which kills spawned children instead of letting them run.
+				timeoutController.abort();
 				reject(
 					new Error(
 						`Dynamic workflow script timed out after ${SCRIPT_TIMEOUT_MS}ms. The script may have spawned a child process that did not exit. Check for spawn/exec calls without proper stdio handling.`,

package/src/runtime/goal-evaluator.ts

@@ -188,7 +188,9 @@ function tryParseDirectVerdict(stdout: string): { achieved: boolean; reason: str
  * Returns a GoalVerdict. On any failure (non-zero exit, non-JSON, invalid shape),
  * returns a `BLOCKED:`-prefixed verdict so the loop stops (§0c C6 fallback).
  */
-export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdict> {
+export async function evaluateGoal(
+	input: EvaluateGoalInput,
+): Promise<{ verdict: GoalVerdict; judgeUsage?: { totalTokens: number; inputTokens?: number; outputTokens?: number } }> {
 	const agent = synthesizeJudgeAgentConfig();
 	const task = buildJudgeTask(input);
 	const evaluatedAt = new Date().toISOString();
@@ -212,12 +214,15 @@ 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 {
+				verdict: blockedVerdict(
+					input.turn,
+					input.model,
+					evaluatedAt,
+					`judge spawn failed (exit=${result.exitCode}): ${result.error ?? result.stderr.slice(0, 200)}`,
+				),
+				judgeUsage: undefined,
+			};
 		}
 
 		const parsed = parsePiJsonOutput(result.stdout);
@@ -231,16 +236,22 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 		const direct = !finalText.trim() ? tryParseDirectVerdict(result.stdout) : undefined;
 		if (direct) {
 			return {
-				turn: input.turn,
-				achieved: direct.achieved,
-				reason: direct.reason,
-				evidenceRefs: direct.evidenceRefs,
-				evaluatorModel: input.model,
-				evaluatedAt,
+				verdict: {
+					turn: input.turn,
+					achieved: direct.achieved,
+					reason: direct.reason,
+					evidenceRefs: direct.evidenceRefs,
+					evaluatorModel: input.model,
+					evaluatedAt,
+				},
+				judgeUsage: undefined,
 			};
 		}
 		if (!finalText.trim()) {
-			return blockedVerdict(input.turn, input.model, evaluatedAt, "judge produced no output");
+			return {
+				verdict: blockedVerdict(input.turn, input.model, evaluatedAt, "judge produced no output"),
+				judgeUsage: undefined,
+			};
 		}
 
 		const extracted = extractStructuredResult(finalText);
@@ -252,27 +263,48 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 				})
 			: 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)}`);
+			return {
+				verdict: blockedVerdict(
+					input.turn,
+					input.model,
+					evaluatedAt,
+					`judge output not valid verdict JSON: ${truncate(finalText, 200)}`,
+				),
+				judgeUsage: undefined,
+			};
 		}
 		const evidenceRefs = Array.isArray(data.evidenceRefs)
 			? data.evidenceRefs.filter((r): r is string => typeof r === "string")
 			: undefined;
+		const judgeUsage = parsed.usage
+			? {
+					totalTokens: (parsed.usage.input ?? 0) + (parsed.usage.output ?? 0),
+					inputTokens: parsed.usage.input,
+					outputTokens: parsed.usage.output,
+				}
+			: undefined;
 		return {
-			turn: input.turn,
-			achieved: data.achieved,
-			reason: data.reason,
-			evidenceRefs,
-			evaluatorModel: input.model,
-			evaluatedAt,
+			verdict: {
+				turn: input.turn,
+				achieved: data.achieved,
+				reason: data.reason,
+				evidenceRefs,
+				evaluatorModel: input.model,
+				evaluatedAt,
+			},
+			judgeUsage,
 		};
 	} 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 {
+			verdict: blockedVerdict(
+				input.turn,
+				input.model,
+				evaluatedAt,
+				`judge threw: ${error instanceof Error ? error.message : String(error)}`,
+			),
+			judgeUsage: undefined,
+		};
 	}
 }
 

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

@@ -66,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.
@@ -94,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"
@@ -676,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/live-agent-manager.ts

@@ -268,6 +268,24 @@ export function evictStaleLiveAgentHandles(now = Date.now()): number {
 			// 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);

package/src/runtime/manifest-cache.ts

@@ -164,6 +164,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 			manifestIndex.clear();
 		}
 		listCache.clear();
+		invalidateListActive();
 	}
 
 	function scheduleListRefresh(): void {
@@ -174,12 +175,17 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 			const timer = listTimer;
 			listTimer = undefined;
 			listCache.clear();
+			invalidateListActive();
 			timer?.unref();
 		}, ttlMs);
 		// Unref immediately so the timer never blocks process exit (defense in
 		// depth: the in-callback unref above may not run if shutdown happens
 		// before the timer fires).
 		listTimer.unref();
+		// FIND-03: invalidate the listActive() cache eagerly on every watcher
+		// tick. The TTL is the fallback for missed events; the watcher-driven
+		// path gives the tightest possible invalidation.
+		invalidateListActive();
 	}
 
 	function loadManifest(runId: string, rootsToCheck: string[]): CachedManifest | undefined {
@@ -266,6 +272,18 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 		return undefined;
 	}
 
+	// FIND-03: short-TTL cache for listActive(). Mirrors the listCache pattern
+	// used by list(): we cache the un-capped running set and apply the caller's
+	// `limit` post-hoc on every return. Storing the full set (not a
+	// limit-sliced array) is what preserves the RT-F3 contract — callers with
+	// different `limit` values all see the same underlying "every running run"
+	// result, never a top-N createdAt-filtered view.
+	let listActiveCache: { result: TeamRunManifest[] | null; expiresAt: number } = { result: null, expiresAt: 0 };
+
+	function invalidateListActive(): void {
+		listActiveCache = { result: null, expiresAt: 0 };
+	}
+
 	/**
 	 * 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
@@ -277,9 +295,19 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 	 * 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().
+	 *
+	 * FIND-03 perf: the full scan is memoized behind a 500ms TTL (same TTL as
+	 * list()). fs.watch-driven scheduleListRefresh() invalidates the cache
+	 * immediately so the next call re-scans. The cap is applied AFTER the
+	 * cache lookup so a cached scan result can be sliced to ANY limit without
+	 * re-scanning.
 	 */
 	function listActive(limit: number): TeamRunManifest[] {
 		const cap = Math.max(0, limit);
+		const now = Date.now();
+		if (listActiveCache.result !== null && listActiveCache.expiresAt > now) {
+			return listActiveCache.result.slice(0, cap);
+		}
 		const parsedEntries = [
 			...roots.flatMap((root) => collectRoots(root)),
 			...activeRunEntries().map((entry) => ({
@@ -303,6 +331,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 			.filter((value): value is CachedManifest => value !== undefined)
 			.map((value) => value.manifest)
 			.filter((manifest) => manifest.status === "running");
+		listActiveCache = { result: running, expiresAt: now + ttlMs };
 		return running.slice(0, cap);
 	}
 
@@ -340,6 +369,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 			watchers = [];
 			manifestIndex.clear();
 			listCache.clear();
+			invalidateListActive();
 		},
 	};
 }

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;
 	}

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