pi-crew 0.9.55 → 0.9.57

package/src/runtime/{run-coalesced-task-group.ts → scheduling/run-coalesced-task-group.ts}

@@ -1,18 +1,20 @@
-import type { AgentConfig } from "../agents/agent-config.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEventAsync } from "../state/event-log.ts";
-import { saveRunTasksAsync, updateRunStatus } from "../state/state-store.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import type { WorkflowStep } from "../workflows/workflow-config.ts";
-import { DEFAULT_RETRY_POLICY, executeWithRetry } from "./retry-executor.ts";
-import { permissionForRole } from "./role-permission.ts";
-import { runWorker } from "./run-worker.ts";
-import type { CrewRuntimeMode } from "./runtime-resolver.ts";
-import { sanitizeTaskText } from "./task-packet.ts";
-import { splitCoalescedOutput } from "./task-runner/output-splitter.ts";
-import { mergeArtifacts } from "./team-runner-artifacts.ts";
-import { createWorkerHeartbeat, touchWorkerHeartbeat } from "./worker-heartbeat.ts";
-import { buildWorkspaceTree } from "./workspace-tree.ts";
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import type { CrewReliabilityConfig, CrewRuntimeConfig } from "../../config/types.ts";
+import { appendEventAsync } from "../../state/event-log/event-log.ts";
+import { writeArtifact } from "../../state/stores/artifact-store.ts";
+import { saveRunTasksAsync, updateRunStatus } from "../../state/stores/state-store.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import type { WorkflowStep } from "../../workflows/workflow-config.ts";
+import { createWorkerHeartbeat, touchWorkerHeartbeat } from "../heartbeat/worker-heartbeat.ts";
+import type { CrewRuntimeMode } from "../model/runtime-resolver.ts";
+import type { RetryPolicy } from "../recovery/retry-executor.ts";
+import { DEFAULT_RETRY_POLICY, executeWithRetry } from "../recovery/retry-executor.ts";
+import { permissionForRole } from "../role-permission.ts";
+import { runWorker } from "../run-worker.ts";
+import { sanitizeTaskText } from "../task-packet.ts";
+import { splitCoalescedOutput } from "../task-runner/output-splitter.ts";
+import { mergeArtifacts } from "../team-runner-artifacts.ts";
+import { buildWorkspaceTree } from "../workspace-tree.ts";
 
 export interface CoalescedTaskGroupInput {
 	manifest: TeamRunManifest;
@@ -27,6 +29,10 @@ export interface CoalescedTaskGroupInput {
 	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 	teamRole?: unknown;
 	perTaskRuntime?: CrewRuntimeMode;
+	/** RT-5: runtime config for maxTurns, graceTurns, taskTimeoutMs (mirror singleton). */
+	runtimeConfig?: CrewRuntimeConfig;
+	/** RT-5: reliability config for autoRetry + retryPolicy (mirror singleton). */
+	reliability?: CrewReliabilityConfig;
 }
 
 export interface CoalescedTaskGroupResult {
@@ -80,6 +86,9 @@ export async function runCoalescedTaskGroup(input: CoalescedTaskGroupInput): Pro
 
 	let rawOutput = "";
 	let success = false;
+	// RT-5 #1: track cancellation separately from failure so the status
+	// mapping can branch cancel → "cancelled" (not "failed").
+	let cancelled = false;
 	// FIND-06: serialize heartbeat saves and retain the active save so terminal
 	// results can drain it before their final write.
 	let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
@@ -110,7 +119,7 @@ export async function runCoalescedTaskGroup(input: CoalescedTaskGroupInput): Pro
 						if (!taskIds.includes(t.id)) return t;
 						// FIND-06 belt-and-suspenders: never replace terminal state or its
 						// resultArtifact with a heartbeat-only snapshot.
-						if (t.status === "completed" || t.status === "failed") return t;
+						if (t.status === "completed" || t.status === "failed" || t.status === "cancelled") return t;
 						return {
 							...t,
 							heartbeat: touchWorkerHeartbeat(t.heartbeat ?? createWorkerHeartbeat(t.id), { alive: true }),
@@ -135,26 +144,76 @@ export async function runCoalescedTaskGroup(input: CoalescedTaskGroupInput): Pro
 				}
 			})();
 		}, 15_000);
+		// RT-5 #3/#4/#5: compute maxTurns, wall-clock timeout, and retry policy
+		// from config instead of hardcoding — mirrors the singleton path
+		// (team-runner.ts:1548-1578 + child-executor.ts:395-430).
+		const taskTimeoutMs = input.runtimeConfig?.taskTimeoutMs ?? 0;
+		const useRetry = input.reliability?.autoRetry !== false;
+		const policy: RetryPolicy = {
+			...DEFAULT_RETRY_POLICY,
+			...(input.reliability?.retryPolicy ?? {}),
+		};
+		// RT-5 #3: pass maxTurns from config instead of hardcoded 5.
+		// RT-5 #4: arm a per-attempt wall-clock timeout mirroring the singleton's
+		// AbortController+setTimeout pattern (child-executor.ts:395-430). The
+		// timeoutController is linked to the run-level signal so an external
+		// abort also aborts the worker. Its signal is passed to runWorker; the
+		// existing SIGTERM→SIGKILL escalation in child-pi.ts handles cleanup.
+		const runOnce = async () => {
+			const timeoutController = new AbortController();
+			let externalAbortListener: (() => void) | undefined;
+			if (signal) {
+				if (signal.aborted) {
+					timeoutController.abort(signal.reason);
+				} else {
+					externalAbortListener = () => timeoutController.abort(signal!.reason);
+					signal.addEventListener("abort", externalAbortListener, { once: true });
+				}
+			}
+			let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+			if (taskTimeoutMs > 0 && !timeoutController.signal.aborted) {
+				timeoutHandle = setTimeout(() => {
+					if (!timeoutController.signal.aborted) {
+						timeoutController.abort(new Error(`Task exceeded wall-clock timeout of ${taskTimeoutMs}ms`));
+					}
+				}, taskTimeoutMs);
+				timeoutHandle.unref?.();
+			}
+			try {
+				return await runWorker({
+					cwd: firstTask.cwd,
+					task: combinedPrompt,
+					agent,
+					signal: timeoutController.signal,
+					excludeContextBash: true,
+					maxTurns: input.runtimeConfig?.maxTurns,
+					graceTurns: input.runtimeConfig?.graceTurns,
+					onJsonEvent: (e) => input.onJsonEvent?.(firstTask.id, manifest.runId, e),
+				});
+			} finally {
+				if (timeoutHandle) clearTimeout(timeoutHandle);
+				if (externalAbortListener && signal) {
+					signal.removeEventListener("abort", externalAbortListener);
+				}
+			}
+		};
 		try {
-			const result = await executeWithRetry(
-				async () => {
-					return await runWorker({
-						cwd: firstTask.cwd,
-						task: combinedPrompt,
-						agent,
-						signal,
-						excludeContextBash: true,
-						maxTurns: 5,
-						onJsonEvent: (e) => input.onJsonEvent?.(firstTask.id, manifest.runId, e),
-					});
-				},
-				DEFAULT_RETRY_POLICY,
-				{ signal },
-			);
+			const result = useRetry ? await executeWithRetry(runOnce, policy, { signal }) : await runOnce();
 			rawOutput = result.rawFinalText ?? result.stdout ?? "";
-			success = result.exitStatus?.exitCode === 0;
+			// RT-5 #1/#2: distinguish cancel from failure. Cancel = run-level
+			// signal aborted OR the child reports cooperative cancellation.
+			// success requires exitCode===0 AND no error AND not cancelled
+			// (previously success = exitCode===0 only, which misreported
+			// depth-guard exitCode:1 and ignored the error field).
+			cancelled = signal?.aborted === true || result.exitStatus?.cancelled === true;
+			success = !cancelled && result.exitCode === 0 && !result.error;
 		} catch (err) {
-			rawOutput = `Worker dispatch failed: ${err instanceof Error ? err.message : String(err)}`;
+			// RT-5 #1: detect cancel in the throw path (e.g. executeWithRetry's
+			// throwIfCancelled when the run-level signal is already aborted).
+			cancelled = signal?.aborted === true;
+			rawOutput = cancelled
+				? `Worker dispatch cancelled: ${err instanceof Error ? err.message : String(err)}`
+				: `Worker dispatch failed: ${err instanceof Error ? err.message : String(err)}`;
 			success = false;
 		} finally {
 			if (heartbeatTimer !== null) clearInterval(heartbeatTimer);
@@ -186,7 +245,7 @@ export async function runCoalescedTaskGroup(input: CoalescedTaskGroupInput): Pro
 		newArtifacts.push(resultArtifact);
 		return {
 			...t,
-			status: ok ? ("completed" as const) : ("failed" as const),
+			status: ok ? ("completed" as const) : cancelled ? ("cancelled" as const) : ("failed" as const),
 			finishedAt,
 			result: {
 				text,
@@ -232,8 +291,8 @@ export async function runCoalescedTaskGroup(input: CoalescedTaskGroupInput): Pro
 	await appendEventAsync(updatedManifest.eventsPath, {
 		type: "task.coalesced_dispatch_end",
 		runId: manifest.runId,
-		message: `Coalesced dispatch ${success ? "completed" : "failed"} (${taskIds.length} tasks, ${split[0]?.strategy ?? "broadcast"} split)`,
-		data: { groupId, taskIds, success, strategy: split[0]?.strategy },
+		message: `Coalesced dispatch ${success ? "completed" : cancelled ? "cancelled" : "failed"} (${taskIds.length} tasks, ${split[0]?.strategy ?? "broadcast"} split)`,
+		data: { groupId, taskIds, success, cancelled, strategy: split[0]?.strategy },
 	});
 
 	return { manifest: updatedManifest, tasks: updatedTasks, taskIds, rawOutput, success };

package/src/runtime/{semaphore.ts → scheduling/semaphore.ts}

@@ -33,7 +33,10 @@ export class Semaphore {
 		// implementation let #queue grow without bound, risking memory
 		// exhaustion under sustained high concurrency with slow releases.
 		if (this.#queue.length >= Semaphore.MAX_QUEUE) {
-			throw new Error(`Semaphore queue full: ${this.#queue.length} waiters (max ${Semaphore.MAX_QUEUE}); cannot acquire slot`);
+			// P1-7: reject (don't throw) so callers can backpressure instead of crashing.
+			return Promise.reject(
+				new Error(`Semaphore queue full: ${this.#queue.length} waiters (max ${Semaphore.MAX_QUEUE}); cannot acquire slot`),
+			);
 		}
 		const { promise, resolve } = (() => {
 			let res: () => void;

package/src/runtime/{task-graph-scheduler.ts → scheduling/task-graph-scheduler.ts}

@@ -1,4 +1,4 @@
-import type { TeamTaskState } from "../state/types.ts";
+import type { TeamTaskState } from "../../state/types.ts";
 
 export interface TaskGraphSchedulerSnapshot {
 	ready: string[];

package/src/runtime/session-resources.ts

@@ -12,7 +12,7 @@ export function tryRegisterSessionCleanup(pi: ExtensionAPI, cleanup: () => void)
 	const registerFn = api.registerSessionResourceCleanup;
 	if (typeof registerFn === "function") {
 		try {
-			const unregister = (registerFn as (fn: () => void) => (() => void) | void)(cleanup);
+			const unregister = (registerFn as (fn: () => void) => (() => void) | undefined)(cleanup);
 			if (typeof unregister === "function") return unregister;
 			// API returned void — cleanup is registered but cannot be unregistered
 			return undefined;

package/src/runtime/settings-store.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import { homedir } from "node:os";
 import * as path from "node:path";
 import { atomicWriteJson } from "../state/atomic-write.ts";
-import { withFileLockSync } from "../state/locks.ts";
+import { withFileLockSync } from "../state/coordination/locks.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import type { JoinMode } from "./group-join.ts";
 

package/src/runtime/single-agent-compose.ts

@@ -72,6 +72,7 @@ export function composeSingleAgentPrompt(workflow: WorkflowConfig, goal: string)
 		if (step.output) {
 			lines.push(`Output: write your result to \`${step.output}\``);
 		}
+		// biome-ignore lint/complexity/useOptionalChain: reads is `string[] | false | undefined` — optional chain doesn't narrow out `false` (no .length on boolean)
 		if (step.reads && step.reads.length) {
 			lines.push(`Read first: ${step.reads.join(", ")}`);
 		}

package/src/runtime/stale-reconciler.ts

@@ -3,7 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { errors } from "../errors.ts";
 import { atomicWriteFile, atomicWriteJson } from "../state/atomic-write.ts";
-import { saveRunManifest } from "../state/state-store.ts";
+import { saveRunManifest } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { recordFromTask, upsertCrewAgent } from "./crew-agent-records.ts";
 import { checkProcessLiveness } from "./process-status.ts";

package/src/runtime/subagent-manager.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_PATHS, DEFAULT_SUBAGENT } from "../config/defaults.ts";
 import type { PiTeamsToolResult } from "../extension/tool-result.ts";
-import { loadRunManifestById } from "../state/state-store.ts";
+import { loadRunManifestById } from "../state/stores/state-store.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { projectCrewRoot } from "../utils/paths.ts";
 import { redactSecrets } from "../utils/redaction.ts";

package/src/runtime/supervisor-contact.ts

@@ -1,4 +1,4 @@
-import { appendEvent } from "../state/event-log.ts";
+import { appendEvent } from "../state/event-log/event-log.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 
@@ -37,22 +37,21 @@ export function recordSupervisorContact(manifest: TeamRunManifest, payload: Omit
  * Parse a supervisor contact request from child Pi stdout.
  * Detects structured JSON lines with type "supervisor_contact".
  */
-export function parseSupervisorContactFromLine(line: string): Omit<SupervisorContactPayload, "timestamp" | "runId"> | undefined {
-	if (!line.trim()) return undefined;
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(line);
-	} catch {
-		return undefined;
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
-	const record = parsed as Record<string, unknown>;
+const SUPERVISOR_CONTACT_REASONS = ["decision_needed", "clarification", "approval", "error_escalation", "custom"] as const;
+
+/**
+ * Validate a parsed event object as a supervisor-contact payload. Shared by the
+ * event-based (current) and line-based (deprecated) entry points. Returns the
+ * normalized payload, or undefined if the event is not a supervisor contact.
+ */
+export function supervisorContactFromEvent(event: unknown): Omit<SupervisorContactPayload, "timestamp" | "runId"> | undefined {
+	if (!event || typeof event !== "object" || Array.isArray(event)) return undefined;
+	const record = event as Record<string, unknown>;
 	if (record.type !== "supervisor_contact" && record.type !== "crew_supervisor_contact") return undefined;
 	return {
 		taskId: typeof record.taskId === "string" ? record.taskId : "",
 		reason:
-			typeof record.reason === "string" &&
-			["decision_needed", "clarification", "approval", "error_escalation", "custom"].includes(record.reason)
+			typeof record.reason === "string" && (SUPERVISOR_CONTACT_REASONS as readonly string[]).includes(record.reason)
 				? (record.reason as SupervisorContactPayload["reason"])
 				: "custom",
 		message: typeof record.message === "string" ? record.message : String(record.message ?? ""),
@@ -62,3 +61,19 @@ export function parseSupervisorContactFromLine(line: string): Omit<SupervisorCon
 				: undefined,
 	};
 }
+
+/**
+ * @deprecated The compact pipeline now passes `supervisor_contact` events through
+ * to `onJsonEvent` with their full payload (P2-25 fix). Prefer
+ * `supervisorContactFromEvent` on the parsed event. Kept for backward compat.
+ */
+export function parseSupervisorContactFromLine(line: string): Omit<SupervisorContactPayload, "timestamp" | "runId"> | undefined {
+	if (!line.trim()) return undefined;
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(line);
+	} catch {
+		return undefined;
+	}
+	return supervisorContactFromEvent(parsed);
+}

package/src/runtime/task-output-context.ts

@@ -1,14 +1,14 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_OUTPUT_CONTEXT } from "../config/defaults.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
 import { atomicWriteFile } from "../state/atomic-write.ts";
+import { writeArtifact } from "../state/stores/artifact-store.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
-import { applyCompactPipeline } from "./compact-pipeline.ts";
-import { ANSI_STRIP_STAGE, BLANK_COLLAPSE_STAGE, TruncationStage } from "./compact-stages/index.ts";
-import { DEFAULT_PRUNE_CONFIG, type FileEditEvent, pruneToolOutputs, type ToolResultEntry } from "./tool-output-pruner.ts";
+import { applyCompactPipeline } from "./compaction/compact-pipeline.ts";
+import { ANSI_STRIP_STAGE, BLANK_COLLAPSE_STAGE, TruncationStage } from "./compaction/compact-stages/index.ts";
+import { DEFAULT_PRUNE_CONFIG, type FileEditEvent, pruneToolOutputs, type ToolResultEntry } from "./compaction/tool-output-pruner.ts";
 
 export interface DependencyContextEntry {
 	taskId: string;
@@ -410,7 +410,9 @@ export function collectDependencyOutputContext(
 	// (used for recency sort in the trim step). Both are looked up against
 	// `task.dependsOn` (the declared order) and `tasks` (finished timestamps).
 	const declaredOrder = new Map<string, number>();
-	task.dependsOn.forEach((depId, index) => declaredOrder.set(depId, index));
+	task.dependsOn.forEach((depId, index) => {
+		declaredOrder.set(depId, index);
+	});
 	const recencyByTaskId = new Map<string, number>();
 	for (const item of tasks) {
 		if (!item.finishedAt) continue;

package/src/runtime/task-runner/child-executor.ts

@@ -29,13 +29,12 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadConfig } from "../../config/config.ts";
 import { errors } from "../../errors.ts";
-import { writeArtifact } from "../../state/artifact-store.ts";
-import { appendEventAsync, appendEventBuffered } from "../../state/event-log.ts";
+import { appendEventAsync, appendEventBuffered } from "../../state/event-log/event-log.ts";
+import { writeArtifact } from "../../state/stores/artifact-store.ts";
 import type { ArtifactDescriptor, OperationTerminalEvidence, TeamRunManifest } from "../../state/types.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
-import { buildSyntheticTerminalEvidence, cancellationReasonFromSignal } from "../cancellation.ts";
-import type { ChildPiLifecycleEvent } from "../child-pi.ts";
+import type { ChildPiLifecycleEvent, ChildPiRunResult } from "../child-pi/child-pi.ts";
 import {
 	appendCrewAgentEvent,
 	appendCrewAgentOutput,
@@ -45,21 +44,22 @@ import {
 } from "../crew-agent-records.ts";
 import { crewHooks } from "../crew-hooks.ts";
 import { bridgeEventFromJsonEvent } from "../event-stream-bridge.ts";
+import { createWorkerHeartbeat, touchWorkerHeartbeat } from "../heartbeat/worker-heartbeat.ts";
+import { createStartupEvidence } from "../heartbeat/worker-startup.ts";
 import {
 	buildConfiguredModelRouting,
 	formatModelAttemptNote,
 	isRetryableModelFailure,
 	type ModelAttemptSummary,
-} from "../model-fallback.ts";
-import { readEnabledModelsPatterns } from "../model-scope.ts";
-import { type ParsedPiJsonOutput, parsePiJsonOutput } from "../pi-json-output.ts";
-import { type ProgressEventSummary, shouldAppendProgressEventUpdate } from "../progress-event-coalescer.ts";
-import { DEFAULT_RETRY_POLICY } from "../retry-executor.ts";
+} from "../model/model-fallback.ts";
+import { readEnabledModelsPatterns } from "../model/model-scope.ts";
+import { type ParsedPiJsonOutput, parsePiJsonOutput } from "../output/pi-json-output.ts";
+import { type ProgressEventSummary, shouldAppendProgressEventUpdate } from "../output/progress-event-coalescer.ts";
+import { buildSyntheticTerminalEvidence, cancellationReasonFromSignal } from "../process/cancellation.ts";
+import { DEFAULT_RETRY_POLICY } from "../recovery/retry-executor.ts";
 import { runWorker } from "../run-worker.ts";
 import { parseSessionUsage } from "../session-usage.ts";
-import { parseSupervisorContactFromLine, recordSupervisorContact } from "../supervisor-contact.ts";
-import { createWorkerHeartbeat, touchWorkerHeartbeat } from "../worker-heartbeat.ts";
-import { createStartupEvidence } from "../worker-startup.ts";
+import { recordSupervisorContact, supervisorContactFromEvent } from "../supervisor-contact.ts";
 import type { TaskExecutionResult } from "./post-execution.ts";
 import type { StreamBridgeHandle, TaskExecutionContext } from "./pre-execution.ts";
 import { applyAgentProgressEvent, applyUsageToProgress, progressEventSummary, shouldFlushProgressEvent } from "./progress.ts";
@@ -115,6 +115,35 @@ async function resolveTaskScopeModelsPatterns(cwd: string): Promise<string[]> {
 	return readEnabledModelsPatterns(cwd);
 }
 
+/**
+ * RT-6: resolve the configured retry policy's maxAttempts from the project
+ * reliability config (`reliability.retryPolicy.maxAttempts`), falling back to
+ * {@link DEFAULT_RETRY_POLICY}.maxAttempts when config is unavailable or the
+ * field is unset. Mirrors `retryPolicyFromConfig` in team-runner.ts so the
+ * spawn-budget math and the actual retry loop (executeWithRetry) agree on the
+ * same ceiling. Best-effort: any config read failure silently falls back to
+ * the default so a misconfiguration never blocks the spawn.
+ */
+export function resolveConfiguredMaxAttempts(cwd: string): number {
+	try {
+		return loadConfig(cwd).config.reliability?.retryPolicy?.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts;
+	} catch {
+		return DEFAULT_RETRY_POLICY.maxAttempts;
+	}
+}
+
+/**
+ * RT-6: pure spawn-budget max formula. `attemptModelsCount × (maxAttempts + 1)`
+ * — always ≥ 1 full attempt above the theoretical max of
+ * `maxAttempts × attemptModelsCount`. Exported for direct unit testing so the
+ * configured-vs-default maxAttempts distinction is locked independently of
+ * the retry loop (previously hard-coded DEFAULT_RETRY_POLICY.maxAttempts = 3,
+ * silently halving retries when a higher maxAttempts — up to 10 — was set).
+ */
+export function computeSpawnBudgetMax(attemptModelsCount: number, configuredMaxAttempts: number): number {
+	return attemptModelsCount * (configuredMaxAttempts + 1);
+}
+
 /**
  * 429/rate-limit detection (PI_CREW_TOOLING_429_NOTE.md).
  *
@@ -215,8 +244,6 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 	const collectedJsonEvents = ctx.collectedJsonEvents;
 	const streamBridge: StreamBridgeHandle | undefined = ctx.streamBridge;
 
-	let resultArtifact: ArtifactDescriptor;
-	let logArtifact: ArtifactDescriptor | undefined;
 	let transcriptArtifact: ArtifactDescriptor | undefined;
 	let exitCode: number | null = 0;
 	let error: string | undefined;
@@ -246,8 +273,13 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 	// Budget = attemptModels.length × (maxAttempts + 1) — always one
 	// full attempt-worth above the theoretical maximum of
 	// maxAttempts × attemptModels.length. Only computes once (max=0 guard).
+	// RT-6: use the configured retry policy's maxAttempts (from project
+	// reliability config), NOT DEFAULT_RETRY_POLICY (3). The retry loop in
+	// team-runner.ts wraps runTeamTask in executeWithRetry with the same
+	// configured maxAttempts (up to 10); hard-coding the default here silently
+	// halved the spawn budget relative to the real retry ceiling.
 	if (input.spawnBudget && input.spawnBudget.max === 0) {
-		input.spawnBudget.max = attemptModels.length * (DEFAULT_RETRY_POLICY.maxAttempts + 1);
+		input.spawnBudget.max = computeSpawnBudgetMax(attemptModels.length, resolveConfiguredMaxAttempts(task.cwd));
 	}
 	const logs: string[] = [];
 	let finalStderr = "";
@@ -390,7 +422,7 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			}, taskTimeoutMs);
 			timeoutHandle.unref?.();
 		}
-		let childResult;
+		let childResult: ChildPiRunResult;
 		try {
 			childResult = await runWorker({
 				cwd: task.cwd,
@@ -419,7 +451,10 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 							const steeringDir = `${manifest.artifactsRoot}/steering`;
 							// Fire-and-forget async write for steering events
 							void appendSteeringAsync(steeringDir, task.id, task.pendingSteers);
-							task.pendingSteers = [];
+							// RT-8: spread before clearing pendingSteers instead of mutating
+							// in place — preserves the immutable-snapshot invariant (the same
+							// object may already be referenced by the tasks array / snapshots).
+							task = { ...task, pendingSteers: [] };
 							tasks = persistSingleTaskUpdate(manifest, tasks, task);
 						}
 					} catch (err) {
@@ -438,19 +473,15 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 				onStdoutLine: (line) => {
 					appendCrewAgentOutput(manifest, task.id, line);
 					persistHeartbeat();
-					// Check for supervisor contact requests from child Pi
-					const contact = parseSupervisorContactFromLine(line);
-					if (contact) {
-						recordSupervisorContact(manifest, {
-							runId: manifest.runId,
-							...contact,
-						});
-					}
 				},
 				onJsonEvent: (event) => {
 					// Top-level error boundary: prevent any single event from crashing the task.
 					// Errors are logged but processing continues so subsequent events still update state.
 					try {
+						// P2-25: handle supervisor_contact here (compact pipeline now passes
+						// the full payload through); was dead on the old displayLine path.
+						const contact = supervisorContactFromEvent(event);
+						if (contact) recordSupervisorContact(manifest, { runId: manifest.runId, ...contact });
 						appendCrewAgentEvent(manifest, task.id, event);
 						if (collectedJsonEvents && event && typeof event === "object" && !Array.isArray(event))
 							collectedJsonEvents.push(event as Record<string, unknown>);
@@ -463,10 +494,15 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 							if (msg?.role === "assistant") {
 								const usage = msg.usage as Record<string, number> | undefined;
 								if (usage) {
-									task.lifetimeUsage = {
-										input: (task.lifetimeUsage?.input ?? 0) + (usage.input ?? 0),
-										output: (task.lifetimeUsage?.output ?? 0) + (usage.output ?? 0),
-										cacheWrite: (task.lifetimeUsage?.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
+									// RT-8: spread before accumulating lifetimeUsage instead of
+									// mutating in place — preserves the immutable-snapshot invariant.
+									task = {
+										...task,
+										lifetimeUsage: {
+											input: (task.lifetimeUsage?.input ?? 0) + (usage.input ?? 0),
+											output: (task.lifetimeUsage?.output ?? 0) + (usage.output ?? 0),
+											cacheWrite: (task.lifetimeUsage?.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
+										},
 									};
 								}
 							}
@@ -680,7 +716,7 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			});
 		}
 	}
-	resultArtifact = writeArtifact(manifest.artifactsRoot, {
+	const resultArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "result",
 		relativePath: `results/${task.id}.txt`,
 		content:
@@ -699,7 +735,7 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			"(no output)",
 		producer: task.id,
 	});
-	logArtifact = writeArtifact(manifest.artifactsRoot, {
+	const logArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "log",
 		relativePath: `logs/${task.id}.log`,
 		content: [

package/src/runtime/task-runner/live-executor.ts

@@ -1,9 +1,9 @@
 import * as fs from "node:fs";
 import type { AgentConfig } from "../../agents/agent-config.ts";
 import type { CrewRuntimeConfig } from "../../config/config.ts";
-import { writeArtifact } from "../../state/artifact-store.ts";
-import { appendEventFireAndForget } from "../../state/event-log.ts";
-import { loadRunManifestById } from "../../state/state-store.ts";
+import { appendEventFireAndForget } from "../../state/event-log/event-log.ts";
+import { writeArtifact } from "../../state/stores/artifact-store.ts";
+import { loadRunManifestById } from "../../state/stores/state-store.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import type { WorkflowStep } from "../../workflows/workflow-config.ts";
 import {
@@ -13,11 +13,11 @@ import {
 	recordFromTask,
 	upsertCrewAgent,
 } from "../crew-agent-records.ts";
-import { runLiveSessionTask } from "../live-session-runtime.ts";
-import type { ParsedPiJsonOutput } from "../pi-json-output.ts";
-import { type ProgressEventSummary, shouldAppendProgressEventUpdate } from "../progress-event-coalescer.ts";
-import { createWorkerHeartbeat, touchWorkerHeartbeat } from "../worker-heartbeat.ts";
-import { createStartupEvidence, type WorkerStartupEvidence } from "../worker-startup.ts";
+import { createWorkerHeartbeat, touchWorkerHeartbeat } from "../heartbeat/worker-heartbeat.ts";
+import { createStartupEvidence, type WorkerStartupEvidence } from "../heartbeat/worker-startup.ts";
+import { runLiveSessionTask } from "../live-session/live-session-runtime.ts";
+import type { ParsedPiJsonOutput } from "../output/pi-json-output.ts";
+import { type ProgressEventSummary, shouldAppendProgressEventUpdate } from "../output/progress-event-coalescer.ts";
 import { applyAgentProgressEvent, applyUsageToProgress, progressEventSummary, shouldFlushProgressEvent } from "./progress.ts";
 import { persistSingleTaskUpdate } from "./state-helpers.ts";
 

package/src/runtime/task-runner/post-execution.ts

@@ -15,10 +15,10 @@
  * exactly (char scenarios 5-7, 9, 10 cover them).
  */
 import { appendHookEvent, executeHook } from "../../hooks/registry.ts";
-import { writeArtifact } from "../../state/artifact-store.ts";
-import { appendEventAsync } from "../../state/event-log.ts";
-import { withRunLock } from "../../state/locks.ts";
-import { saveRunManifestAsync } from "../../state/state-store.ts";
+import { withRunLock } from "../../state/coordination/locks.ts";
+import { appendEventAsync } from "../../state/event-log/event-log.ts";
+import { writeArtifact } from "../../state/stores/artifact-store.ts";
+import { saveRunManifestAsync } from "../../state/stores/state-store.ts";
 import type {
 	ArtifactDescriptor,
 	OperationTerminalEvidence,
@@ -29,16 +29,16 @@ import type {
 import { captureWorktreeDiffAsync, captureWorktreeDiffStatAsync } from "../../worktree/worktree-manager.ts";
 import { appendTaskAttentionEvent } from "../attention-events.ts";
 import { extractCommandTrace } from "../command-trace.ts";
-import { evaluateCompletionMutationGuard } from "../completion-guard.ts";
 import { emptyCrewAgentProgress, recordFromTask, upsertCrewAgent } from "../crew-agent-records.ts";
 import { crewHooks } from "../crew-hooks.ts";
-import { createVerificationEvidence } from "../green-contract.ts";
-import type { ModelAttemptSummary } from "../model-fallback.ts";
-import { type OutputValidationResult, validateWorkerOutput } from "../output-validator.ts";
-import type { ParsedPiJsonOutput } from "../pi-json-output.ts";
+import { createWorkerHeartbeat, touchWorkerHeartbeat } from "../heartbeat/worker-heartbeat.ts";
+import type { ModelAttemptSummary } from "../model/model-fallback.ts";
+import { type OutputValidationResult, validateWorkerOutput } from "../output/output-validator.ts";
+import type { ParsedPiJsonOutput } from "../output/pi-json-output.ts";
 import { writeTaskSharedOutput } from "../task-output-context.ts";
-import { computeGreenLevelFromResults, executeVerificationCommands } from "../verification-gates.ts";
-import { createWorkerHeartbeat, touchWorkerHeartbeat } from "../worker-heartbeat.ts";
+import { evaluateCompletionMutationGuard } from "../verification/completion-guard.ts";
+import { createVerificationEvidence } from "../verification/green-contract.ts";
+import { computeGreenLevelFromResults, executeVerificationCommands } from "../verification/verification-gates.ts";
 import { extractYieldResult, hasYieldInOutput, isYieldEvent, type YieldResult } from "../yield-handler.ts";
 import { buildWorkerCapabilityInventory } from "./capabilities.ts";
 import type { TaskExecutionContext } from "./pre-execution.ts";
@@ -64,7 +64,7 @@ export interface TaskExecutionResult {
 	finalStdout: string;
 	transcriptPath: string | undefined;
 	terminalEvidence: OperationTerminalEvidence[];
-	startupEvidence: import("../worker-startup.ts").WorkerStartupEvidence;
+	startupEvidence: import("../heartbeat/worker-startup.ts").WorkerStartupEvidence;
 }
 
 /** Final persisted task state returned by finalizeTaskResult. */