pi-crew 0.9.27 → 0.9.29

package/src/extension/crew-vibes/provider-usage.ts

@@ -68,6 +68,21 @@ export function loadZaiToken(): string | undefined {
 	}
 }
 
+/** Load the Minimax API key from env or auth.json. */
+export function loadMinimaxToken(): string | undefined {
+	const envKey = process.env.MINIMAX_API_KEY?.trim();
+	if (envKey) return envKey;
+	try {
+		const data = JSON.parse(readFileSync(piAuthPath(), "utf8")) as {
+			minimax?: { key?: string };
+		};
+		const key = data.minimax?.key;
+		return typeof key === "string" && key.length > 0 ? key : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 /** Copilot host entry keys used by the legacy GitHub Copilot CLI. */
 type CopilotHostEntry = {
 	oauth_token?: string;
@@ -262,69 +277,120 @@ export function clearProviderUsageCache(): void {
 	cachedAt = 0;
 }
 
+/** Minimax token plan remains response shape. */
+type MinimaxModelRemain = {
+	model_name?: string;
+	current_interval_remaining_percent?: number;
+	current_weekly_remaining_percent?: number;
+	end_time?: number;
+	weekly_end_time?: number;
+};
+type MinimaxUsageResponse = {
+	model_remains?: MinimaxModelRemain[];
+	base_resp?: { status_code?: number; status_msg?: string };
+};
+
+async function fetchMinimaxUsage(token: string): Promise<ProviderUsage> {
+	const data = await withTimeout(10000, async (signal) => {
+		const res = await fetch("https://www.minimax.io/v1/token_plan/remains", {
+			headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+			signal,
+		});
+		if (!res.ok) throw new Error(`minimax usage HTTP ${res.status}`);
+		return (await res.json()) as MinimaxUsageResponse;
+	});
+	if (data.base_resp?.status_code !== 0) throw new Error(data.base_resp?.status_msg || "minimax API error");
+
+	// Find the "general" model (text/chat). Fall back to first model.
+	const models = data.model_remains ?? [];
+	const general = models.find((m) => m.model_name === "general") ?? models[0];
+	if (!general) throw new Error("minimax: no model data");
+
+	// remaining_percent → used percent
+	const intervalUsed = 100 - (general.current_interval_remaining_percent ?? 100);
+	const weeklyUsed = 100 - (general.current_weekly_remaining_percent ?? 100);
+
+	const intervalReset = typeof general.end_time === "number" ? new Date(general.end_time).toISOString() : null;
+	const weeklyReset = typeof general.weekly_end_time === "number" ? new Date(general.weekly_end_time).toISOString() : null;
+
+	return {
+		providerName: "Minimax",
+		fiveHourPercent: intervalUsed,
+		fiveHourResetAt: intervalReset,
+		weeklyPercent: weeklyUsed,
+		weeklyResetAt: weeklyReset,
+	};
+}
+
+/** Providers that have a quota API. */
+const QUOTA_PROVIDERS = new Set(["anthropic", "minimax", "minimax-cn", "zai", "github-copilot"]);
+
+/** Check if a provider supports quota checking. */
+export function providerSupportsQuota(provider: string): boolean {
+	return QUOTA_PROVIDERS.has(provider);
+}
+
+/** Fetch usage for a SPECIFIC provider. Returns null if not supported. */
+async function fetchForProvider(provider: string): Promise<ProviderUsage | null> {
+	switch (provider) {
+		case "anthropic": {
+			const token = loadAnthropicToken();
+			if (!token) return null;
+			const base = await fetchAnthropicUsage(token);
+			return { providerName: "Claude", ...base };
+		}
+		case "minimax":
+		case "minimax-cn": {
+			const token = loadMinimaxToken();
+			if (!token) return null;
+			return await fetchMinimaxUsage(token);
+		}
+		case "zai": {
+			const token = loadZaiToken();
+			if (!token) return null;
+			const usage = await fetchZaiUsage(token);
+			usage.providerName = "z.ai";
+			return usage;
+		}
+		case "github-copilot": {
+			const token = loadCopilotToken();
+			if (!token) return null;
+			const pct = await fetchCopilotMonthlyPercent(token);
+			if (pct === undefined) return null;
+			return {
+				providerName: "Copilot",
+				fiveHourPercent: 0,
+				fiveHourResetAt: null,
+				weeklyPercent: pct,
+				weeklyResetAt: null,
+				copilotMonthlyPercent: pct,
+			};
+		}
+		default:
+			return null;
+	}
+}
+
 /**
- * Fetch provider rate-limit usage, caching the result for `maxAgeMs`.
- *
- * Tries providers in order: Anthropic → z.ai → Copilot.
- * Returns the first one that has credentials + responds successfully.
- * Returns `null` when no credentials exist or all fetches fail — never throws.
+ * Fetch provider rate-limit usage for the current model's provider.
+ * Returns `null` when provider has no quota API or no credentials.
  */
-export async function fetchProviderUsage(maxAgeMs = 300000): Promise<ProviderUsage | null> {
-	// Serve fresh-enough cache without hitting the network.
+export async function fetchProviderUsage(maxAgeMs = 300000, provider?: string): Promise<ProviderUsage | null> {
+	if (!provider || !QUOTA_PROVIDERS.has(provider)) {
+		cachedUsage = null;
+		return null;
+	}
 	if (cachedUsage !== null && Date.now() - cachedAt < maxAgeMs) {
 		return cachedUsage;
 	}
-
 	try {
-		// Try Anthropic first
-		const anthropicToken = loadAnthropicToken();
-		if (anthropicToken) {
-			const base = await fetchAnthropicUsage(anthropicToken);
-			const usage: ProviderUsage = {
-				providerName: "Claude",
-				fiveHourPercent: base.fiveHourPercent,
-				fiveHourResetAt: base.fiveHourResetAt,
-				weeklyPercent: base.weeklyPercent,
-				weeklyResetAt: base.weeklyResetAt,
-			};
+		const usage = await fetchForProvider(provider);
+		if (usage) {
 			cachedUsage = usage;
 			cachedAt = Date.now();
-			return usage;
 		}
-
-		// Try z.ai
-		const zaiToken = loadZaiToken();
-		if (zaiToken) {
-			const usage = await fetchZaiUsage(zaiToken);
-			usage.providerName = "z.ai";
-			cachedUsage = usage;
-			cachedAt = Date.now();
-			return usage;
-		}
-
-		// Try Copilot
-		const copilotToken = loadCopilotToken();
-		if (copilotToken) {
-			const monthlyPercent = await fetchCopilotMonthlyPercent(copilotToken);
-			if (monthlyPercent !== undefined) {
-				const usage: ProviderUsage = {
-					providerName: "Copilot",
-					fiveHourPercent: 0,
-					fiveHourResetAt: null,
-					weeklyPercent: monthlyPercent,
-					weeklyResetAt: null,
-					copilotMonthlyPercent: monthlyPercent,
-				};
-				cachedUsage = usage;
-				cachedAt = Date.now();
-				return usage;
-			}
-		}
-
-		// No credentials for any provider
-		return null;
+		return usage;
 	} catch {
-		// Network error / timeout / parse error — fail gracefully.
 		return null;
 	}
 }

package/src/extension/team-tool.ts

@@ -498,6 +498,17 @@ export function handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTe
 	}
 	task.pendingSteers.push(message);
 	saveRunTasks(loaded.manifest, loaded.tasks);
+	// Real-time steer delivery: write to steering file so child can read immediately
+	try {
+		const steeringDir = `${loaded.manifest.artifactsRoot}/steering`;
+		fs.mkdirSync(steeringDir, { recursive: true });
+		fs.appendFileSync(
+			`${steeringDir}/${taskId}.jsonl`,
+			JSON.stringify({ type: "steer", message, ts: new Date().toISOString() }) + "\n",
+		);
+	} catch {
+		// Best-effort: file write failure doesn't block the steer from pending array
+	}
 	appendEvent(loaded.manifest.eventsPath, {
 		type: "task.steer_queued",
 		runId,

package/src/prompt/prompt-runtime.ts

@@ -1,9 +1,12 @@
+import * as fs from "node:fs";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 export const PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV = "PI_TEAMS_INHERIT_PROJECT_CONTEXT";
 export const PI_TEAMS_INHERIT_SKILLS_ENV = "PI_TEAMS_INHERIT_SKILLS";
 export const PI_CREW_INHERIT_PROJECT_CONTEXT_ENV = "PI_CREW_INHERIT_PROJECT_CONTEXT";
 export const PI_CREW_INHERIT_SKILLS_ENV = "PI_CREW_INHERIT_SKILLS";
+const PI_CREW_MAX_OUTPUT_ENV = "PI_CREW_MAX_OUTPUT";
+const PI_CREW_STEERING_FILE_ENV = "PI_CREW_STEERING_FILE";
 
 const PROJECT_CONTEXT_HEADER = "\n\n# Project Context\n\nProject-specific instructions and guidelines:\n\n";
 const SKILLS_HEADER = "\n\nThe following skills provide specialized instructions for specific tasks.";
@@ -58,6 +61,68 @@ export function rewriteTeamWorkerPrompt(prompt: string, options: { inheritProjec
 }
 
 export default function registerPiTeamsPromptRuntime(pi: ExtensionAPI): void {
+	// ── Feature 1: maxTokens cap ──────────────────────────────────────────
+	// Cap output tokens per API call for background workers. Reads
+	// PI_CREW_MAX_OUTPUT_TOKENS env (set by pi-args.ts from agent.maxTokens).
+	const maxTokensEnv = process.env[PI_CREW_MAX_OUTPUT_ENV];
+	const maxTokensCap = maxTokensEnv ? Number.parseInt(maxTokensEnv, 10) : undefined;
+	if (maxTokensCap && maxTokensCap > 0) {
+		pi.on("before_provider_request", (event) => {
+			const payload = event.payload as Record<string, unknown> | undefined;
+			if (!payload || typeof payload !== "object") return;
+			// Cap both OpenAI-style max_tokens and Anthropic-style max_tokens
+			if (typeof payload.max_tokens === "number" && payload.max_tokens > maxTokensCap) {
+				payload.max_tokens = maxTokensCap;
+			}
+		});
+	}
+
+	// ── Feature 2: real-time steering ──────────────────────────────────────
+	// Poll the steering JSONL file for new steer messages. The parent (team
+	// tool) writes steers here in real-time; this reader injects them into
+	// the active session via pi.sendMessage with deliverAs:"steer".
+	const steeringFile = process.env[PI_CREW_STEERING_FILE_ENV];
+	if (steeringFile) {
+		let lastOffset = 0;
+		const pollSteering = (): void => {
+			try {
+				const stat = fs.statSync(steeringFile, { throwIfNoEntry: false });
+				if (!stat || stat.size <= lastOffset) return;
+				const fd = fs.openSync(steeringFile, "r");
+				try {
+					const buf = Buffer.alloc(stat.size - lastOffset);
+					fs.readSync(fd, buf, 0, buf.length, lastOffset);
+					lastOffset = stat.size;
+					const lines = buf.toString("utf8").split("\n").filter(Boolean);
+					for (const line of lines) {
+						try {
+							const entry = JSON.parse(line) as { type?: string; message?: string };
+							if (entry.type === "steer" && entry.message) {
+								pi.sendMessage(
+									{ customType: "crew-steer", content: entry.message, display: false },
+									{ deliverAs: "steer" },
+								);
+							}
+						} catch {
+							// Malformed line — skip
+						}
+					}
+				} finally {
+					try {
+						fs.closeSync(fd);
+					} catch {
+						/* already closed */
+					}
+				}
+			} catch {
+				// File doesn't exist yet or read error — will retry next tick
+			}
+		};
+		const timer = setInterval(pollSteering, 500);
+		timer.unref?.();
+	}
+
+	// ── Prompt rewriting (existing) ────────────────────────────────────────
 	pi.on("before_agent_start", (event) => {
 		const inheritProjectContext = readBooleanEnvAny(PI_CREW_INHERIT_PROJECT_CONTEXT_ENV, PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV);
 		const inheritSkills = readBooleanEnvAny(PI_CREW_INHERIT_SKILLS_ENV, PI_TEAMS_INHERIT_SKILLS_ENV);

package/src/runtime/child-pi.ts

@@ -80,6 +80,22 @@ function clearHardKillTimer(pid: number | undefined): void {
 	childHardKillTimers.delete(pid);
 }
 
+/**
+ * B6: spawn taskkill and attach an 'error' listener. spawn() emits ENOENT/EACCES
+ * asynchronously via the 'error' event (not as a throw), so an unlistened spawn
+ * can crash the parent as an uncaught exception. taskkill is a standard Windows
+ * binary so this is defensive, but the listener keeps failures bounded.
+ */
+function spawnTaskkillSafe(pid: number): void {
+	const taskkillChild = spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
+		stdio: "ignore",
+		windowsHide: true,
+	});
+	taskkillChild.on("error", (err) => {
+		logInternalError("child-pi.taskkill-spawn-error", err instanceof Error ? err : new Error(String(err)), `pid=${pid}`);
+	});
+}
+
 export function killProcessPid(pid: number): void {
 	if (!Number.isInteger(pid) || pid <= 0) return;
 	try {
@@ -87,10 +103,7 @@ export function killProcessPid(pid: number): void {
 			// 3.8: Windows path uses taskkill /T /F (force kill the entire tree).
 			// taskkill itself can silently fail (PID gone, permission denied, etc.)
 			// so verify after 2s and log a warning if the process is still alive.
-			spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
-				stdio: "ignore",
-				windowsHide: true,
-			});
+			spawnTaskkillSafe(pid);
 			const verifyTimer = setTimeout(() => {
 				try {
 					process.kill(pid, 0); // throws ESRCH when dead
@@ -101,10 +114,7 @@ export function killProcessPid(pid: number): void {
 						`pid=${pid}`,
 					);
 					try {
-						spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
-							stdio: "ignore",
-							windowsHide: true,
-						});
+						spawnTaskkillSafe(pid);
 					} catch {
 						/* best-effort */
 					}
@@ -238,6 +248,8 @@ export interface ChildPiRunInput {
 	excludeContextBash?: boolean;
 	/** pi session ID for session naming (aligns with pi-crew run ID) */
 	sessionId?: string;
+	/** Path to steering JSONL file for real-time steer injection. */
+	steeringFile?: string;
 	/** Run ID for cleanup tracking */
 	runId?: string;
 	/** Agent ID for cleanup tracking */
@@ -317,6 +329,8 @@ const BASE_ALLOWLIST: string[] = [
 	"PI_TEAMS_PI_BIN",
 	"PI_TEAMS_MOCK_CHILD_PI",
 	"PI_CREW_ALLOW_MOCK",
+	"PI_CREW_MAX_OUTPUT",
+	"PI_CREW_STEERING_FILE",
 ];
 
 export function buildChildPiSpawnOptions(cwd: string, env: NodeJS.ProcessEnv, model?: string): SpawnOptions {
@@ -888,6 +902,22 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 		skillPaths: input.skillPaths,
 		role: input.role,
 	});
+	// Pass steering file path to child for real-time steer injection
+	if (input.steeringFile) built.env.PI_CREW_STEERING_FILE = input.steeringFile;
+	// B5: if the parent already aborted before we spawn, do not start the child
+	// at all. Spawning a doomed process wastes resources, and the abort listener
+	// registered below will not re-fire for an already-aborted signal (so the
+	// child would only be killed later by the response-timeout path). Return a
+	// cancelled-style result immediately.
+	if (input.signal?.aborted) {
+		return {
+			exitCode: null,
+			stdout: "",
+			stderr: "",
+			error: "Aborted before spawn (parent AbortSignal already aborted)",
+			aborted: true,
+		};
+	}
 	const spawnSpec = getPiSpawnCommand(built.args);
 	try {
 		return await new Promise<ChildPiRunResult>((resolve) => {
@@ -1123,45 +1153,30 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 								turnCount += 1;
 								if (maxTurns !== undefined && !softLimitReached && turnCount >= maxTurns) {
 									softLimitReached = true;
-									// Inject steer via stdin to tell child to wrap up.
-									// Steer injection is ADVISORY: it asks the worker to wrap up. The real
-									// enforcement is the hard-abort at maxTurns + graceTurns (below). So a
-									// failed/non-writable stdin must NOT kill the worker — that destroys a
-									// valid answer already in stdout (Phase-0 root cause of the
-									// disableTools/maxTurns:1 exit-null bug). Just log + let the hard-abort
-									// path handle a genuinely runaway worker.
-									if (child.stdin?.writable) {
-										const steerPayload =
-											JSON.stringify({
-												type: "steer",
-												message:
-													"You have reached your turn limit. Wrap up immediately — provide your final answer now.",
-											}) + "\n";
-										const writeSucceeded = child.stdin.write(steerPayload);
-										if (!writeSucceeded) {
-											// Normal Node backpressure: the payload is buffered and will flush on
-											// 'drain'. NOT a failure — do NOT kill the worker. The steer is
-											// advisory; if the worker ignores it and runs past maxTurns +
-											// graceTurns, the hard-abort below terminates it.
+									// C8: deliver the "wrap up" advisory by appending to the steering JSONL
+									// file the child polls (PI_CREW_STEERING_FILE). The child is spawned with
+									// stdio:["ignore",...], so child.stdin is null and the old stdin branch was
+									// dead code that only spammed logs on every soft-limit hit. Advisory only —
+									// the hard-abort below at maxTurns + graceTurns is the real enforcement, so
+									// a failed write must NOT kill the worker.
+									if (input.steeringFile) {
+										try {
+											fs.appendFileSync(
+												input.steeringFile,
+												JSON.stringify({
+													type: "steer",
+													message:
+														"You have reached your turn limit. Wrap up immediately — provide your final answer now.",
+												}) + "\n",
+												"utf-8",
+											);
+										} catch (err) {
 											logInternalError(
-												"child-pi.steer-backpressure",
-												new Error(
-													"stdin write returned false (normal backpressure); steer buffered, worker NOT killed",
-												),
+												"child-pi.steer-write-failed",
+												err instanceof Error ? err : new Error(String(err)),
 												`pid=${child.pid}`,
 											);
 										}
-									} else {
-										// stdin closed (worker already finished) or otherwise unwritable.
-										// Also advisory — the worker is done or nearly done; let it exit
-										// naturally. Hard-abort remains the safety net for true runaways.
-										logInternalError(
-											"child-pi.steer-not-writable",
-											new Error(
-												"stdin not writable when attempting steer injection (worker may be done); worker NOT killed",
-											),
-											`pid=${child.pid}`,
-										);
 									}
 								} else if (maxTurns !== undefined && softLimitReached && turnCount >= maxTurns + (graceTurns ?? 5)) {
 									// Hard abort — terminate after grace turns

package/src/runtime/cross-extension-rpc.ts

@@ -1,5 +1,5 @@
 import * as crypto from "node:crypto";
-import { isHmacEnabled, extractSignaturePayload, verifyRpcSignature } from "../extension/rpc-hmac.ts";
+import { extractSignaturePayload, isHmacEnabled, verifyRpcSignature } from "../extension/rpc-hmac.ts";
 
 export interface EventBus {
 	on(event: string, handler: (data: unknown) => void): () => void;

package/src/runtime/pi-args.ts

@@ -360,6 +360,8 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 			PI_TEAMS_DEPTH: String(parentDepth + 1),
 			PI_TEAMS_MAX_DEPTH: String(maxDepth),
 			PI_TEAMS_ROLE: input.agent.name,
+			// maxTokens cap for background workers — prompt-runtime reads this to cap API output
+			...(input.agent.maxTokens ? { PI_CREW_MAX_OUTPUT: String(input.agent.maxTokens) } : {}),
 		},
 		tempDir,
 	};

package/src/runtime/post-exit-stdio-guard.ts

@@ -9,6 +9,9 @@ export interface ChildWithPipedStdio {
 	stdout: ChildProcess["stdout"];
 	stderr: ChildProcess["stderr"];
 	on: ChildProcess["on"];
+	/** Set by Node after the child exits. Used to detect a post-exit attach. */
+	exitCode?: number | null;
+	signalCode?: NodeJS.Signals | null;
 }
 
 export interface ChildWithKill {
@@ -72,13 +75,28 @@ export function attachPostExitStdioGuard(child: ChildWithPipedStdio, options: Po
 		stderrEnded = true;
 		if (stdoutEnded && stderrEnded) clearTimers();
 	});
-	child.on("exit", () => {
-		exited = true;
-		armIdleTimer();
+
+	const armHardTimer = (): void => {
 		if (hardTimer) return;
 		hardTimer = setTimeout(destroyUnendedStdio, hardMs);
 		hardTimer.unref();
-	});
+	};
+	const onExit = (): void => {
+		exited = true;
+		armIdleTimer();
+		armHardTimer();
+	};
+	// The guard is normally attached from INSIDE the child's 'exit' handler
+	// (child-pi.ts), i.e. AFTER the child has already exited. A listener
+	// registered with child.on('exit') during the in-flight 'exit' dispatch
+	// will NOT fire (Node clones the listener array before iterating), so
+	// relying on it alone makes this guard a no-op and can hang the run if a
+	// descendant process holds the stdio pipes open. When a prior exit is
+	// detectable (exitCode/signalCode already set by Node), arm immediately.
+	if (child.exitCode != null || child.signalCode != null) {
+		onExit();
+	}
+	child.on("exit", onExit);
 	child.on("close", clearTimers);
 	child.on("error", clearTimers);
 

package/src/runtime/stale-reconciler.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { errors } from "../errors.ts";
+import { atomicWriteJson } from "../state/atomic-write.ts";
 import { saveRunManifest } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { recordFromTask, upsertCrewAgent } from "./crew-agent-records.ts";
@@ -67,8 +68,12 @@ function checkResultFile(manifest: TeamRunManifest, tasks: TeamTaskState[]): { f
 		);
 	if (allTerminal) {
 		// All tasks are terminal but manifest status was not updated — repair it.
+		// Derive the run status from task outcomes instead of blindly marking
+		// "completed": a run where every task failed/cancelled is NOT a success.
+		const hasFailed = tasks.some((t) => t.status === "failed");
+		const onlyCancelledOrSkipped = tasks.every((t) => t.status === "cancelled" || t.status === "skipped");
+		manifest.status = hasFailed ? "failed" : onlyCancelledOrSkipped ? "cancelled" : "completed";
 		// Persist manifest status change immediately to make checkResultFile self-contained.
-		manifest.status = "completed";
 		saveRunManifest(manifest);
 		// Sync agent records even when tasks are already terminal
 		// (e.g., a previous reconcile fixed tasks but crashed before updating agents)
@@ -492,8 +497,8 @@ export function reconcileOrphanedTempWorkspaces(
 						const tasks: TeamTaskState[] = JSON.parse(fs.readFileSync(tasksPath, "utf-8"));
 						const result = reconcileStaleRun(manifest, tasks, now);
 						if (result.repaired && result.repairedTasks) {
-							// Persist repaired tasks
-							fs.writeFileSync(tasksPath, JSON.stringify(result.repairedTasks, null, 2));
+							// Persist repaired tasks (atomic — temp+rename to survive mid-write crash)
+							atomicWriteJson(tasksPath, result.repairedTasks);
 							// Update manifest status
 							const updated = {
 								...manifest,
@@ -501,7 +506,7 @@ export function reconcileOrphanedTempWorkspaces(
 								updatedAt: new Date(now).toISOString(),
 								summary: `Stale run reconciled: ${result.detail}`,
 							};
-							fs.writeFileSync(manifestPath, JSON.stringify(updated, null, 2));
+							atomicWriteJson(manifestPath, updated);
 							// Update agent records
 							for (const task of result.repairedTasks) {
 								try {

package/src/runtime/task-runner.ts

@@ -449,6 +449,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 					runId: manifest.runId,
 					agentId: task.id,
 					artifactsRoot: manifest.artifactsRoot,
+					steeringFile: `${manifest.artifactsRoot}/steering/${task.id}.jsonl`,
 					onSpawn: (pid) => {
 						try {
 							({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));

package/src/runtime/team-runner.ts

@@ -757,22 +757,17 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		stopTeamHeartbeat();
 		// P1: Catch unhandled errors — ensure manifest/tasks/agents are terminal so they don't stay "running" forever.
 		const message = error instanceof Error ? error.message : String(error);
-		// FIX (2026-07-02): drop withRunLock here entirely.
-		// Previously this catch path acquired withRunLock to reload manifest+tasks
-		// from disk (best-effort with in-memory fallback). But the closeout path at
-		// line ~1596 ALSO holds the same run lock for its final save — when a late
-		// failure fires during closeout (e.g. async hook error after run.completed),
-		// this catch path can hit `Run 'run.lock' is locked by another operation.`
-		// and the error propagates as "Unhandled error in team runner" after the
-		// run has actually completed. Lock acquisition here is unnecessary —
-		// the closeout writes through to disk before this catch fires (or after —
-		// either is fine), and the in-memory state already contains the latest
-		// post-completion manifest/tasks. We use in-memory state unconditionally.
-		// The stale-data concern is mitigated by the dispatcher having re-read disk
-		// state under lock at line ~1364 for each iteration; the manifest+task
-		// objects in the calling scope are already post-merge.
-		const freshManifest = manifest;
-		const freshTasks = refreshTaskGraphQueues(input.tasks);
+		// Re-read the latest persisted state from disk instead of trusting
+		// input.tasks (the ORIGINAL start snapshot, still all "queued" — it is never
+		// mutated by executeTeamRunCore). A late failure during closeout would
+		// otherwise map every task to "failed", overwriting tasks that already
+		// completed during the run. loadRunManifestById is the established
+		// fresh-read pattern in this file (see ~line 1269); it is best-effort with
+		// no lock, consistent with the lock-drop decision below. If the disk read
+		// fails, fall back to input.tasks so the run is still marked terminal.
+		const fresh = loadRunManifestById(manifest.cwd, manifest.runId);
+		const freshManifest = fresh?.manifest ?? manifest;
+		const freshTasks = refreshTaskGraphQueues(fresh?.tasks ?? input.tasks);
 		const failedAt = new Date().toISOString();
 		const tasks = freshTasks.map((task) =>
 			task.status === "running" || task.status === "queued" || task.status === "waiting"