pi-crew 0.9.41 → 0.9.42

package/src/observability/event-bus.ts

@@ -14,6 +14,7 @@ export interface CrewEvent {
 type CrewEventListener = (event: CrewEvent) => void;
 
 class EventBus {
+	private static readonly MAX_LISTENERS_PER_EVENT = 100;
 	private listeners = new Map<CrewEventType, Set<CrewEventListener>>();
 	private static _instance?: EventBus;
 
@@ -54,7 +55,15 @@ class EventBus {
 		if (!this.listeners.has(type)) {
 			this.listeners.set(type, new Set());
 		}
-		this.listeners.get(type)!.add(listener);
+		const set = this.listeners.get(type)!;
+		if (set.size >= EventBus.MAX_LISTENERS_PER_EVENT) {
+			logInternalError(
+				"event-bus.listener-cap",
+				new Error(`Max ${EventBus.MAX_LISTENERS_PER_EVENT} listeners reached for event type '${type}'`),
+				`type=${type} currentCount=${set.size}`,
+			);
+		}
+		set.add(listener);
 
 		return () => {
 			this.listeners.get(type)?.delete(listener);

package/src/observability/event-to-metric.ts

@@ -37,7 +37,7 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 	const taskCount = registry.counter("crew.task.count", "Total tasks by status");
 	const subagentCount = registry.counter("crew.subagent.count", "Total subagent records by status");
 	const mailboxCount = registry.counter("crew.mailbox.count", "Total mailbox messages by direction");
-	const retryAttemptCount = registry.counter("crew.task.retry_attempt_total", "Retry attempts by run and task");
+	const retryAttemptCount = registry.counter("crew.task.retry_attempt_total", "Total retry attempts");
 	const deadletterCount = registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason");
 	const overflowCount = registry.counter("crew.task.overflow_phase_total", "Overflow recovery phase transitions");
 	const supervisorContactCount = registry.counter("crew.task.supervisor_contact_total", "Supervisor contact requests by reason");
@@ -89,12 +89,12 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 		[
 			"crew.task.retry_attempt",
 			(data) => {
-				const item = recordValue(data);
 				taskCount.inc({ status: "retry" });
-				retryAttemptCount.inc({
-					runId: stringValue(item.runId, "unknown"),
-					taskId: stringValue(item.taskId, "unknown"),
-				});
+				// Per-run/task detail lives in the event log (crew.task.retry_attempt).
+				// Using runId/taskId as METRIC labels would blow up cardinality (each unique
+				// run+task pair = a new series, silently LRU-evicted at MAX_LABEL_COMBINATIONS
+				// = 10_000), making the counter unreliable for aggregation.
+				retryAttemptCount.inc({});
 			},
 		],
 		[
@@ -121,8 +121,9 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 			(data) => {
 				const item = recordValue(data);
 				supervisorContactCount.inc({
+					// reason is low-cardinality; taskId is NOT (unique per task) — dropped to
+					// avoid cardinality blowup (OBS-1). Per-task detail is in the event log.
 					reason: stringValue(item.reason, "unknown"),
-					taskId: stringValue(item.taskId, "unknown"),
 				});
 			},
 		],

package/src/observability/exporters/adapter.ts

@@ -3,7 +3,7 @@ import type { MetricSnapshot } from "../metrics-primitives.ts";
 export interface MetricExporter {
 	name: string;
 	push(snapshots: MetricSnapshot[]): Promise<void>;
-	dispose(): void;
+	dispose(): Promise<void>;
 }
 
 export class CompositeExporter implements MetricExporter {
@@ -18,13 +18,10 @@ export class CompositeExporter implements MetricExporter {
 		await Promise.allSettled(this.exporters.map((exporter) => exporter.push(snapshots)));
 	}
 
-	dispose(): void {
-		for (const exporter of this.exporters) {
-			try {
-				exporter.dispose();
-			} catch {
-				// Best-effort cleanup; one exporter failing shouldn't prevent others.
-			}
-		}
+	async dispose(): Promise<void> {
+		// OBS-3: await allSettled so an async exporter cleanup (e.g. OTLPExporter awaiting
+		// an in-flight HTTP push) isn't cut short. Interface contract changed from `void`
+		// to `Promise<void>` because exporters may have async teardown.
+		await Promise.allSettled(this.exporters.map((exporter) => exporter.dispose()));
 	}
 }

package/src/observability/exporters/otlp-exporter.ts

@@ -1,3 +1,4 @@
+import { lookup } from "node:dns/promises";
 import { promisify } from "node:util";
 import { gzip } from "node:zlib";
 import { logInternalError } from "../../utils/internal-error.ts";
@@ -100,6 +101,76 @@ export function validateEndpoint(endpoint: string): void {
 	}
 }
 
+/**
+ * CFG-6: classify a single IP address (IPv4 or IPv6) as private / reserved /
+ * loopback / link-local. Used by the runtime DNS-rebinding guard below to
+ * verify the addresses the endpoint hostname resolves to. Returns true for
+ * addresses that must never receive a metrics push. The full literal checks
+ * in `validateEndpoint` use the same predicates for direct IP targets.
+ */
+export function isPrivateIpAddress(address: string): boolean {
+	const lower = address.toLowerCase();
+	// IPv4 literal
+	const ipv4 = lower.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+	if (ipv4) {
+		const o0 = Number(ipv4[1]);
+		const o1 = Number(ipv4[2]);
+		if (o0 === 127 || o0 === 0) return true;
+		if (o0 === 10) return true;
+		if (o0 === 172 && o1 >= 16 && o1 <= 31) return true;
+		if (o0 === 192 && o1 === 168) return true;
+		if (o0 === 169 && o1 === 254) return true;
+		return false;
+	}
+	// IPv6 (without surrounding brackets, as `dns.lookup` returns them)
+	if (lower === "::1" || lower === "::") return true;
+	if (lower.startsWith("fd") || lower.startsWith("fc")) return true;
+	if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb")) return true;
+	if (lower.startsWith("fec") || lower.startsWith("fed") || lower.startsWith("fee") || lower.startsWith("fef")) return true;
+	if (lower.startsWith("ff")) return true;
+	if (lower.startsWith("::ffff:")) return true;
+	return false;
+}
+
+/**
+ * CFG-6: DNS-rebinding guard. `validateEndpoint` runs once at exporter
+ * construction and only inspects the literal hostname; an attacker who
+ * controls the DNS for a public hostname can rebind it to a private IP
+ * (e.g. 169.254.169.254 cloud metadata) between construction and the actual
+ * fetch. Re-resolve the hostname at push time and reject if any returned
+ * address falls into a private/reserved range. Resolution failures are
+ * allowed to fall through so the underlying `fetch` surfaces the error.
+ */
+export async function assertResolvedAddressSafe(endpoint: string): Promise<void> {
+	let url: URL;
+	try {
+		url = new URL(endpoint);
+	} catch {
+		return;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return;
+	const hostname = url.hostname.toLowerCase();
+	if (!hostname) return;
+	// Locals and literal IPs are covered by `validateEndpoint`; skip the DNS
+	// round-trip so we don't double-report errors the sync check already
+	// produces.
+	if (hostname === "localhost" || hostname.endsWith(".localhost")) return;
+	if (hostname.startsWith("[")) return;
+	if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) return;
+	let addresses: { address: string }[];
+	try {
+		addresses = await lookup(hostname, { all: true, verbatim: true });
+	} catch {
+		// Let the fetch fail with a clearer error from the network layer.
+		return;
+	}
+	for (const { address } of addresses) {
+		if (isPrivateIpAddress(address)) {
+			throw new Error(`OTLP endpoint resolves to private/reserved address ${address} (DNS rebinding blocked): ${endpoint}`);
+		}
+	}
+}
+
 // FIX (Round 15): Cap the number of snapshots per push to prevent OOM when
 // the metric registry has grown large. The OTLP HTTP spec allows many metrics
 // in one payload, but a single push > 10_000 metrics would balloon the
@@ -210,6 +281,16 @@ export class OTLPExporter implements MetricExporter {
 
 	async push(snapshots: MetricSnapshot[]): Promise<void> {
 		try {
+			// CFG-6: re-validate the endpoint after DNS resolution to block
+			// rebinding from a public hostname to a private/metadata IP
+			// between construction time and the actual fetch. Failures are
+			// logged and the push is skipped — no metrics reach the bad host.
+			try {
+				await assertResolvedAddressSafe(this.opts.endpoint);
+			} catch (error) {
+				logInternalError("otlp-export-ssrf", error);
+				return;
+			}
 			// FIX (Round 15): Cap snapshots to a safe size to avoid OOM and
 			// oversized HTTP payloads. Log a warning if we are truncating.
 			let toSend = snapshots;

package/src/observability/metric-retention.ts

@@ -29,6 +29,10 @@ export class TimeWindowedCounter {
 		this.prune();
 	}
 
+	// PERF (OBS-5): This method is O(N) per call because it linearly scans
+	// all events and calls labelKey() (which uses JSON.stringify) on each.
+	// A more efficient aggregation (e.g., pre-aggregated label buckets or a
+	// sliding-window histogram) is planned to replace this hot path.
 	count(labels: MetricLabels = {}, durationMs = this.windowMs): number {
 		const now = this.now();
 		this.pruneAt(now);

package/src/observability/metric-sink.ts

@@ -6,7 +6,7 @@ import type { MetricRegistry } from "./metric-registry.ts";
 import type { MetricSnapshot } from "./metrics-primitives.ts";
 
 export interface MetricSink {
-	writeSnapshot(snapshots: MetricSnapshot[]): void;
+	writeSnapshot(snapshots: MetricSnapshot[]): void | Promise<void>;
 	dispose(): void;
 }
 
@@ -54,19 +54,29 @@ export function createMetricFileSink(opts: MetricFileSinkOptions): MetricSink {
 		fdDate = date;
 		return fd;
 	};
-	const writeSnapshot = (snapshots: MetricSnapshot[]): void => {
+	const writeSnapshot = (snapshots: MetricSnapshot[]): Promise<void> => {
 		try {
 			const now = new Date();
 			const date = now.toISOString().slice(0, 10);
 			const redacted = redactSecrets(snapshots);
 			if (!Array.isArray(redacted)) {
 				logInternalError("metric-sink.type", new Error("redactSecrets did not return an array"), `got=${typeof redacted}`);
-				return;
+				return Promise.resolve();
 			}
 			const target = ensureFd(date);
-			fs.writeSync(target, `${JSON.stringify({ exportedAt: now.toISOString(), snapshots: redacted as MetricSnapshot[] })}\n`);
+			const line = `${JSON.stringify({ exportedAt: now.toISOString(), snapshots: redacted as MetricSnapshot[] })}\n`;
+			// Async write to avoid blocking the main thread on the 60s tick.
+			// Return a promise that resolves once the write callback fires so
+			// tests (and any callers awaiting) can synchronize on completion.
+			return new Promise<void>((resolve) => {
+				fs.write(target, line, (err) => {
+					if (err) logInternalError("metric-sink.asyncWrite", err);
+					resolve();
+				});
+			});
 		} catch (error) {
 			logInternalError("metric-sink.write", error);
+			return Promise.resolve();
 		}
 	};
 	const timer = setInterval(() => writeSnapshot(opts.registry.snapshot()), opts.intervalMs ?? 60_000);

package/src/runtime/adaptive-plan.ts

@@ -21,7 +21,7 @@ import { saveRunManifestAsync } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
-import { getPlanTemplate, listPlanTemplates, renderPlanTemplate } from "./plan-templates.ts";
+import { getPlanTemplate, renderPlanTemplate } from "./plan-templates.ts";
 import { refreshTaskGraphQueues } from "./task-graph-scheduler.ts";
 
 export interface AdaptivePlanTask {

package/src/runtime/async-runner.ts

@@ -1,9 +1,9 @@
-import { type SpawnOptions, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { appendEvent, appendEventAsync } from "../state/event-log.ts";
+import { appendEventAsync } from "../state/event-log.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
@@ -356,8 +356,17 @@ export async function spawnBackgroundTeamRun(manifest: TeamRunManifest): Promise
 		);
 		// Best-effort: unregister when child exits. Background-runner writes
 		// the marker file before it dies, so we unregister on the next
-		// cleanup tick. But the child "exit" event won't fire because we
-		// unref'd and the stdio is piped + ignored.
+		// cleanup tick. The child "exit" event may fire after unref() when
+		// stdio is piped; register handler defensively.
+		if (child.pid) {
+			child.on("exit", () => {
+				try {
+					unregisterWorker(child.pid!);
+				} catch {
+					/* best-effort */
+				}
+			});
+		}
 	}
 
 	return { pid: child.pid, logPath };

package/src/runtime/background-runner.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
 import { loadConfig } from "../config/config.ts";
+import { atomicWriteFile } from "../state/atomic-write.ts";
 import { appendEvent } from "../state/event-log.ts";
 import { withRunLockSync } from "../state/locks.ts";
 import { createRunPaths, loadRunManifestById, saveRunManifestAsync, updateRunStatus } from "../state/state-store.ts";
@@ -70,7 +71,7 @@ function startHeartbeat(stateRoot: string, eventsPath: string, runId: string): (
 	const writeHeartbeat = (): void => {
 		try {
 			const mem = process.memoryUsage();
-			fs.writeFileSync(
+			atomicWriteFile(
 				heartbeatPath,
 				JSON.stringify({
 					pid: process.pid,
@@ -81,7 +82,6 @@ function startHeartbeat(stateRoot: string, eventsPath: string, runId: string): (
 						rssMb: Math.round(mem.rss / 1024 / 1024),
 					},
 				}),
-				"utf-8",
 			);
 		} catch {
 			/* ignore — best-effort */
@@ -454,27 +454,36 @@ async function main(): Promise<void> {
 		}
 	}
 	// Hook Node.js abort — if process.exit is called with code 1 (uncaught exception, assert failure)
-	// we log it before exiting so it appears in background.log
-	const origExit = process.exit.bind(process);
-	// Intercept all exit(code) calls to log them as async.exit events before exiting.
-	// This surfaces uncaught exceptions / early exits that would otherwise vanish silently.
-	process.exit = ((code?: number | string): never => {
-		const runId2 = argValue("--run-id");
-		const codeStr = code === undefined ? "<none>" : String(code);
-		if (runId2 && manifest.eventsPath) {
-			try {
-				appendEvent(manifest.eventsPath, {
-					type: "async.exit",
-					runId: runId2,
-					message: `Background runner exit(${codeStr}) pid=${process.pid}`,
-					data: { code, pid: process.pid },
-				});
-			} catch {
-				/* best-effort */
+	// we log it before exiting so it appears in background.log.
+	// NOTE: process.exit is monkey-patched here (not using process.on('exit')) because
+	// we need the log write to happen synchronously before the process actually exits.
+	// process.on('exit') handlers run too late for I/O to complete reliably.
+	// Wrapped in try/catch to guard against failures in the patch itself.
+	try {
+		const origExit = process.exit.bind(process);
+		// Intercept all exit(code) calls to log them as async.exit events before exiting.
+		// This surfaces uncaught exceptions / early exits that would otherwise vanish silently.
+		process.exit = ((code?: number | string): never => {
+			const runId2 = argValue("--run-id");
+			const codeStr = code === undefined ? "<none>" : String(code);
+			if (runId2 && manifest.eventsPath) {
+				try {
+					appendEvent(manifest.eventsPath, {
+						type: "async.exit",
+						runId: runId2,
+						message: `Background runner exit(${codeStr}) pid=${process.pid}`,
+						data: { code, pid: process.pid },
+					});
+				} catch {
+					/* best-effort */
+				}
 			}
-		}
-		return origExit(code);
-	}) as typeof process.exit;
+			return origExit(code);
+		}) as typeof process.exit;
+	} catch {
+		// If patching process.exit fails (e.g. frozen process object), continue
+		// without the exit log — the run will still proceed normally.
+	}
 
 	// Setup unhandled rejection guard FIRST — must be before any async operations
 	// that might produce unhandled rejections during cleanup. Without this, any unhandled
@@ -632,7 +641,7 @@ async function main(): Promise<void> {
 				// LAZY: defer dynamic import of ../workflows/discover-workflows.ts to its call site.
 				const { allWorkflows, discoverWorkflows } = await import("../workflows/discover-workflows.ts");
 				const wf = allWorkflows(discoverWorkflows(manifest.cwd)).find((w) => w.name === manifest.workflow);
-				if (!wf || wf.runtime !== "dynamic" || !wf.dynamicScript)
+				if (wf?.runtime !== "dynamic" || !wf.dynamicScript)
 					throw new Error(
 						`runKind="dynamic-workflow" but workflow '${manifest.workflow}' is not dynamic (runId=${manifest.runId})`,
 					);

package/src/runtime/capability-inventory.ts

@@ -1,4 +1,4 @@
-import type { AgentConfig, ResourceSource } from "../agents/agent-config.ts";
+import type { AgentConfig } from "../agents/agent-config.ts";
 import { discoverAgents } from "../agents/discover-agents.ts";
 import type { PiTeamsConfig } from "../config/config.ts";
 import { discoverSkills, getLastDiscoveryDiagnostics } from "../skills/discover-skills.ts";

package/src/runtime/chain-runner.ts

@@ -301,16 +301,16 @@ export class ChainRunner {
 		};
 
 		// Set step type based on matching pattern with type safety
-		if (teamMatch && teamMatch[1]) {
+		if (teamMatch?.[1]) {
 			parsed.team = this.sanitizeIdentifier(teamMatch[1]);
 		}
-		if (workflowMatch && workflowMatch[1]) {
+		if (workflowMatch?.[1]) {
 			parsed.workflow = this.sanitizeIdentifier(workflowMatch[1]);
 		}
-		if (templateMatch && templateMatch[1]) {
+		if (templateMatch?.[1]) {
 			parsed.template = this.sanitizeIdentifier(templateMatch[1]);
 		}
-		if (inlineMatch && inlineMatch[1]) {
+		if (inlineMatch?.[1]) {
 			parsed.inlineGoal = this.sanitizeInlineGoal(inlineMatch[1]);
 		}
 
@@ -334,7 +334,7 @@ export class ChainRunner {
 		const timeoutStr = this.extractFlag(step, "timeout");
 		if (timeoutStr) {
 			const timeoutMs = parseInt(timeoutStr, 10);
-			if (!isNaN(timeoutMs) && timeoutMs > 0 && timeoutMs <= 86400000) {
+			if (!Number.isNaN(timeoutMs) && timeoutMs > 0 && timeoutMs <= 86400000) {
 				parsed.timeout = timeoutMs * 1000; // Convert seconds to ms
 			}
 		}

package/src/runtime/checkpoint.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { atomicWriteFile } from "../state/atomic-write.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { projectCrewRoot } from "../utils/paths.ts";
 import { assertSafePathId } from "../utils/safe-paths.ts";
@@ -73,22 +74,11 @@ export class FileCheckpointStore implements CheckpointStore {
 		// other's data (silent corruption) and the second rename hits ENOENT
 		// (silent data loss). Including taskId + pid + timestamp guarantees
 		// uniqueness across processes and across tasks.
-		const tmp = path.join(
-			this.checkpointDir(),
-			`.tmp.${checkpoint.taskId}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`,
-		);
-		fs.writeFileSync(tmp, JSON.stringify(checkpoint, null, 2), "utf-8");
-		fs.renameSync(tmp, p);
-		// fsync parent directory to ensure the rename is durable
-		const dirFd = fs.openSync(this.checkpointDir(), "r");
-		try {
-			fs.fsyncSync(dirFd);
-		} catch {
-			// EPERM on Windows: opening a directory and fsync-ing it is not supported
-			// on all Windows configurations. Best-effort — the rename is still atomic.
-		} finally {
-			fs.closeSync(dirFd);
-		}
+		// atomicWriteFile handles temp + write + fsync(data) + rename + fsync(parent)
+		// with a UUID-based unique temp name (cross-process safe). The previous
+		// hand-rolled version missed data-fsync (ST-5), risking empty/stale content
+		// after power loss.
+		atomicWriteFile(p, JSON.stringify(checkpoint, null, 2));
 	}
 
 	load(runId: string, taskId: string): Checkpoint | null {

package/src/runtime/child-pi.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
 import { registerChildProcess, unregisterChildProcess } from "../extension/crew-cleanup.ts";
+import { atomicWriteFile } from "../state/atomic-write.ts";
 import type { WorkerExitStatus } from "../state/types.ts";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { buildScopedAllowList, sanitizeEnvSecrets } from "../utils/env-filter.ts";
@@ -31,6 +32,11 @@ const MAX_COMPACT_CONTENT_CHARS = DEFAULT_CHILD_PI.maxCompactContentChars;
 const activeChildProcesses = new Map<number, ChildProcess>();
 const childHardKillTimers = new Map<number, NodeJS.Timeout>();
 
+/** Maximum size (bytes) for the ChildPiLineObserver's line accumulation buffer.
+ * When exceeded, the buffer is force-flushed to prevent unbounded memory growth
+ * from chatty child processes that produce output without newlines. */
+const MAX_LINE_BUFFER_BYTES = 1024 * 1024; // 1 MB
+
 // Periodic cleanup of dead child process entries to prevent memory leaks.
 // If a child process never emits exit/close (zombie), the entry would leak.
 setInterval(() => {
@@ -749,6 +755,20 @@ export class ChildPiLineObserver {
 
 	observe(text: string): void {
 		this.buffer += text;
+		// Cap the buffer to prevent unbounded memory growth when a child process
+		// produces output without newlines (RT-F8). When exceeded, force-flush
+		// the buffer as a single line and log a warning.
+		if (this.buffer.length > MAX_LINE_BUFFER_BYTES) {
+			logInternalError(
+				"child-pi.buffer-overflow",
+				new Error(`Line buffer exceeded ${MAX_LINE_BUFFER_BYTES} bytes; force-flushing`),
+				`bufferLen=${this.buffer.length}`,
+			);
+			const line = this.buffer;
+			this.buffer = "";
+			this.emitLine(line);
+			return;
+		}
 		const lines = this.buffer.split(/\r?\n/);
 		this.buffer = lines.pop() ?? "";
 		for (const line of lines) this.emitLine(line);
@@ -869,7 +889,7 @@ function asRecord(value: unknown): Record<string, unknown> | undefined {
 
 function isFinalAssistantEvent(event: unknown): boolean {
 	const obj = asRecord(event);
-	if (!obj || obj.type !== "message_end") return false;
+	if (obj?.type !== "message_end") return false;
 	const message = asRecord(obj.message);
 	const role = message?.role;
 	if (role !== undefined && role !== "assistant") return false;
@@ -1002,7 +1022,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			}
 			count += 1;
 			try {
-				fs.writeFileSync(counterFile, String(count));
+				atomicWriteFile(counterFile, String(count));
 			} catch (error) {
 				logInternalError("child-pi.mock-counter-write", error as Error, `file=${counterFile}`);
 			}

package/src/runtime/coalesce-tasks.ts

@@ -78,7 +78,7 @@ export function planCoalescedGroups(
 	const buckets = new Map<string, TeamTaskState[]>();
 	for (const taskId of readyTaskIds) {
 		const task = taskById.get(taskId);
-		if (!task || !task.stepId) continue;
+		if (!task?.stepId) continue;
 		const step = stepById.get(task.stepId);
 		if (!step) continue;
 

package/src/runtime/crash-recovery.ts

@@ -397,31 +397,43 @@ export function purgeStaleActiveRunIndex(staleThresholdMs = 300_000, now = Date.
 		if (manifest?.status === "running" && manifest.async?.pid !== undefined) {
 			const pidAlive = checkProcessLiveness(manifest.async.pid).alive;
 			if (!pidAlive && !hasRecentLifeEvidence(entry, manifest.updatedAt, now, staleThresholdMs)) {
-				// Dead PID + no recent life evidence → cancel the manifest and unregister
+				// Dead PID + no recent life evidence → cancel the manifest and unregister.
+				// RT-F5: wrap load+modify+save in withRunLockSync so concurrent writers
+				// (e.g. team-runner final saveRunTasks) cannot interleave between the
+				// repaired-tasks write and the manifest-status flip. terminateLiveAgentsForRun
+				// is fire-and-forget so it stays OUTSIDE the lock to avoid blocking the
+				// critical section on async IPC.
 				try {
-					const fullLoaded = loadRunManifestById(entry.cwd, entry.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
+					const fullLoaded = loadRunManifestById(entry.cwd, entry.runId);
 					if (fullLoaded) {
-						const now_iso = new Date(now).toISOString();
-						const repairedTasks = fullLoaded.tasks.map((task) => {
-							if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
-								return {
-									...task,
-									status: "cancelled" as const,
-									finishedAt: now_iso,
-									error: "Orphaned run: worker process dead and no recent activity",
-								};
+						withRunLockSync(fullLoaded.manifest, () => {
+							// Re-read under lock so the stale-best-effort load above
+							// can't cause us to clobber a fresh status flip.
+							const fresh = loadRunManifestById(entry.cwd, entry.runId);
+							if (!fresh) return;
+							if (fresh.manifest.status !== "running") return;
+							const now_iso = new Date(now).toISOString();
+							const repairedTasks = fresh.tasks.map((task) => {
+								if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
+									return {
+										...task,
+										status: "cancelled" as const,
+										finishedAt: now_iso,
+										error: "Orphaned run: worker process dead and no recent activity",
+									};
+								}
+								return task;
+							});
+							saveRunTasks(fresh.manifest, repairedTasks);
+							for (const task of repairedTasks) {
+								try {
+									upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
+								} catch {
+									/* non-critical */
+								}
 							}
-							return task;
+							updateRunStatus(fresh.manifest, "cancelled", "Orphaned run: worker process dead and no recent activity");
 						});
-						saveRunTasks(fullLoaded.manifest, repairedTasks);
-						for (const task of repairedTasks) {
-							try {
-								upsertCrewAgent(fullLoaded.manifest, recordFromTask(fullLoaded.manifest, task, "scaffold"));
-							} catch {
-								/* non-critical */
-							}
-						}
-						updateRunStatus(fullLoaded.manifest, "cancelled", "Orphaned run: worker process dead and no recent activity");
 						void terminateLiveAgentsForRun(
 							fullLoaded.manifest.runId,
 							"cancelled",
@@ -447,35 +459,39 @@ export function purgeStaleActiveRunIndex(staleThresholdMs = 300_000, now = Date.
 		if (manifest?.status === "running" && manifest.async === undefined) {
 			if (!hasRecentLifeEvidence(entry, manifest.updatedAt, now, staleThresholdMs)) {
 				try {
-					const fullLoaded = loadRunManifestById(entry.cwd, entry.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
+					const fullLoaded = loadRunManifestById(entry.cwd, entry.runId);
 					if (fullLoaded && fullLoaded.manifest.status === "running") {
-						const now_iso = new Date(now).toISOString();
-						const repairedTasks = fullLoaded.tasks.map((task) => {
-							if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
-								return {
-									...task,
-									status: "cancelled" as const,
-									finishedAt: now_iso,
-									error: "Orphaned run: workflow completed but manifest never updated to terminal status",
-								};
+						withRunLockSync(fullLoaded.manifest, () => {
+							const fresh = loadRunManifestById(entry.cwd, entry.runId);
+							if (fresh?.manifest.status !== "running") return;
+							const now_iso = new Date(now).toISOString();
+							const repairedTasks = fresh.tasks.map((task) => {
+								if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
+									return {
+										...task,
+										status: "cancelled" as const,
+										finishedAt: now_iso,
+										error: "Orphaned run: workflow completed but manifest never updated to terminal status",
+									};
+								}
+								return task;
+							});
+							saveRunTasks(fresh.manifest, repairedTasks);
+							for (const task of repairedTasks) {
+								try {
+									upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
+								} catch {
+									/* non-critical */
+								}
 							}
-							return task;
+							updateRunStatus(
+								fresh.manifest,
+								"cancelled",
+								"Orphaned run: no async worker and no manifest update in over " +
+									Math.round(staleThresholdMs / 60000) +
+									" minutes",
+							);
 						});
-						saveRunTasks(fullLoaded.manifest, repairedTasks);
-						for (const task of repairedTasks) {
-							try {
-								upsertCrewAgent(fullLoaded.manifest, recordFromTask(fullLoaded.manifest, task, "scaffold"));
-							} catch {
-								/* non-critical */
-							}
-						}
-						updateRunStatus(
-							fullLoaded.manifest,
-							"cancelled",
-							"Orphaned run: no async worker and no manifest update in over " +
-								Math.round(staleThresholdMs / 60000) +
-								" minutes",
-						);
 						void terminateLiveAgentsForRun(
 							fullLoaded.manifest.runId,
 							"cancelled",