pi-crew 0.1.28 → 0.1.30

package/src/runtime/task-runner.ts

@@ -4,15 +4,15 @@ import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
-import { loadRunManifestById, saveRunManifest, saveRunTasks } from "../state/state-store.ts";
+import { saveRunManifest } from "../state/state-store.ts";
 import { createTaskClaim } from "../state/task-claims.ts";
 import { createWorkerHeartbeat, touchWorkerHeartbeat } from "./worker-heartbeat.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
 import { captureWorktreeDiff, captureWorktreeDiffStat, prepareTaskWorkspace } from "../worktree/worktree-manager.ts";
-import { buildConfiguredModelCandidates, formatModelAttemptNote, isRetryableModelFailure, type ModelAttemptSummary } from "./model-fallback.ts";
+import { buildConfiguredModelRouting, formatModelAttemptNote, isRetryableModelFailure, type ModelAttemptSummary } from "./model-fallback.ts";
 import { parsePiJsonOutput, type ParsedPiJsonOutput } from "./pi-json-output.ts";
 import { runChildPi } from "./child-pi.ts";
-import { buildTaskPacket, renderTaskPacket } from "./task-packet.ts";
+import { buildTaskPacket } from "./task-packet.ts";
 import { createVerificationEvidence } from "./green-contract.ts";
 import { createStartupEvidence } from "./worker-startup.ts";
 import { permissionForRole } from "./role-permission.ts";
@@ -20,9 +20,11 @@ import { collectDependencyOutputContext, renderDependencyOutputContext, writeTas
 import { appendCrewAgentEvent, appendCrewAgentOutput, emptyCrewAgentProgress, recordFromTask, upsertCrewAgent } from "./crew-agent-records.ts";
 import { parseSessionUsage } from "./session-usage.ts";
 import type { CrewAgentProgress, CrewRuntimeKind } from "./crew-agent-runtime.ts";
-import { buildMemoryBlock } from "./agent-memory.ts";
-import { runLiveSessionTask } from "./live-session-runtime.ts";
 import { shouldAppendProgressEventUpdate, type ProgressEventSummary } from "./progress-event-coalescer.ts";
+import { coordinationBridgeInstructions, renderTaskPrompt } from "./task-runner/prompt-builder.ts";
+import { applyAgentProgressEvent, applyUsageToProgress, progressEventSummary, shouldFlushProgressEvent } from "./task-runner/progress.ts";
+import { checkpointTask, persistSingleTaskUpdate, updateTask } from "./task-runner/state-helpers.ts";
+import { cleanResultText, isFinalChildEvent } from "./task-runner/result-utils.ts";
 
 export interface TaskRunnerInput {
 	manifest: TeamRunManifest;
@@ -42,218 +44,6 @@ export interface TaskRunnerInput {
 	dependencyContextText?: string;
 }
 
-function readOnlyRoleInstructions(role: string): string {
-	if (permissionForRole(role) !== "read_only") return "";
-	return [
-		"# READ-ONLY ROLE CONTRACT",
-		"You are running in READ-ONLY mode for this task.",
-		"- Do not create, modify, delete, move, or copy files.",
-		"- Do not use shell redirects, heredocs, in-place edits, package installs, git commit/merge/rebase/reset/checkout, or other state-mutating commands.",
-		"- If implementation changes are needed, report exact recommendations instead of applying them.",
-		"- Prefer read/grep/find/listing tools and read-only git inspection commands.",
-	].join("\n");
-}
-
-function coordinationBridgeInstructions(task: TeamTaskState): string {
-	return [
-		"# Crew Coordination Channel",
-		`Mailbox target for this task: ${task.id}`,
-		"Use the run mailbox contract for coordination with the leader/orchestrator:",
-		"- If blocked or uncertain, report the blocker in your final result and, when mailbox tools/API are available, send an inbox/outbox message addressed to the leader.",
-		"- If nudged, answer with current status, blocker, or smallest next step.",
-		"- Treat inherited/dependency context as reference-only; do not continue the parent conversation directly.",
-		"- Completion handoff should include: DONE/FAILED, summary, changed/read files, verification evidence, and remaining risks.",
-	].join("\n");
-}
-
-function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState, agent?: AgentConfig): string {
-	const memoryBlock = agent?.memory ? buildMemoryBlock(agent.name, agent.memory, task.cwd, Boolean(agent.tools?.some((tool) => tool === "write" || tool === "edit"))) : "";
-	return [
-		"# pi-crew Worker Runtime Context",
-		`Run ID: ${manifest.runId}`,
-		`Team: ${manifest.team}`,
-		`Workflow: ${manifest.workflow ?? "(none)"}`,
-		`State root: ${manifest.stateRoot}`,
-		`Artifacts root: ${manifest.artifactsRoot}`,
-		`Events path: ${manifest.eventsPath}`,
-		`Task ID: ${task.id}`,
-		`Task cwd: ${task.cwd}`,
-		`Workspace mode: ${manifest.workspaceMode}`,
-		"",
-		`Goal:\n${manifest.goal}`,
-		"",
-		`Step: ${step.id}`,
-		`Role: ${step.role}`,
-		"",
-		"Protocol:",
-		"- Stay within the task scope unless the prompt explicitly says otherwise.",
-		"- Report blockers and verification evidence in the final result.",
-		"- Do not claim completion without evidence.",
-		"- Follow the Task Packet contract below; escalate if any contract field is impossible to satisfy.",
-		"",
-		readOnlyRoleInstructions(task.role),
-		"",
-		coordinationBridgeInstructions(task),
-		"",
-		task.taskPacket ? renderTaskPacket(task.taskPacket) : "",
-		"",
-		(inputDependencyContext(task) || ""),
-		memoryBlock,
-		"Task:",
-		step.task.replaceAll("{goal}", manifest.goal),
-	].join("\n");
-}
-
-function inputDependencyContext(task: TeamTaskState): string {
-	return (task as TeamTaskState & { dependencyContextText?: string }).dependencyContextText ?? "";
-}
-
-function updateTask(tasks: TeamTaskState[], updated: TeamTaskState): TeamTaskState[] {
-	return tasks.map((task) => task.id === updated.id ? updated : task);
-}
-
-function persistSingleTaskUpdate(manifest: TeamRunManifest, fallbackTasks: TeamTaskState[], updated: TeamTaskState): TeamTaskState[] {
-	const latest = loadRunManifestById(manifest.cwd, manifest.runId)?.tasks ?? fallbackTasks;
-	const merged = updateTask(latest, updated);
-	saveRunTasks(manifest, merged);
-	return merged;
-}
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-
-function textFromContent(content: unknown): string[] {
-	if (typeof content === "string") return [content];
-	if (!Array.isArray(content)) return [];
-	const text: string[] = [];
-	for (const part of content) {
-		const obj = asRecord(part);
-		if (!obj) continue;
-		if (obj.type === "text" && typeof obj.text === "string") text.push(obj.text);
-		else if (typeof obj.content === "string") text.push(obj.content);
-	}
-	return text;
-}
-
-function eventText(event: unknown): string[] {
-	const obj = asRecord(event);
-	if (!obj) return [];
-	const text: string[] = [];
-	if (typeof obj.text === "string") text.push(obj.text);
-	if (typeof obj.output === "string") text.push(obj.output);
-	text.push(...textFromContent(obj.content));
-	const message = asRecord(obj.message);
-	if (message) text.push(...textFromContent(message.content));
-	return text.filter((entry) => entry.trim());
-}
-
-function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
-	for (const key of keys) {
-		const value = obj[key];
-		if (typeof value === "number" && Number.isFinite(value)) return value;
-	}
-	return undefined;
-}
-
-function eventUsage(event: unknown): { input?: number; output?: number; turns?: number } | undefined {
-	const obj = asRecord(event);
-	if (!obj) return undefined;
-	const direct = {
-		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
-		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
-		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
-	};
-	if (Object.values(direct).some((value) => value !== undefined)) return direct;
-	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
-		const nested = eventUsage(obj[key]);
-		if (nested) return nested;
-	}
-	const message = asRecord(obj.message);
-	return message ? eventUsage(message.usage) : undefined;
-}
-
-function previewArgs(args: unknown): string | undefined {
-	if (!args) return undefined;
-	try {
-		const text = typeof args === "string" ? args : JSON.stringify(args);
-		return text.length > 240 ? `${text.slice(0, 240)}…` : text;
-	} catch {
-		return undefined;
-	}
-}
-
-function applyUsageToProgress(progress: CrewAgentProgress | undefined, usage: UsageState | undefined): CrewAgentProgress | undefined {
-	if (!usage) return progress;
-	const base = progress ?? emptyCrewAgentProgress();
-	return {
-		...base,
-		tokens: (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0),
-		turns: usage.turns ?? base.turns,
-	};
-}
-
-function shouldFlushProgressEvent(event: unknown): boolean {
-	const type = asRecord(event)?.type;
-	return type === "tool_execution_start" || type === "tool_execution_end" || type === "message_end" || type === "tool_result_end";
-}
-
-function cleanResultText(text: string | undefined): string | undefined {
-	const trimmed = text?.trim();
-	if (!trimmed) return undefined;
-	const doneIndex = trimmed.lastIndexOf("\nDONE\n");
-	if (doneIndex >= 0) return trimmed.slice(doneIndex + 1).trim();
-	if (trimmed === "DONE" || trimmed.startsWith("DONE\n")) return trimmed;
-	const fencedPromptIndex = trimmed.lastIndexOf("</file>");
-	if (fencedPromptIndex >= 0 && fencedPromptIndex < trimmed.length - 7) return trimmed.slice(fencedPromptIndex + 7).trim() || trimmed;
-	return trimmed;
-}
-
-function progressEventSummary(task: TeamTaskState, event: unknown): ProgressEventSummary {
-	const type = asRecord(event)?.type;
-	return {
-		eventType: typeof type === "string" ? type : "event",
-		currentTool: task.agentProgress?.currentTool,
-		toolCount: task.agentProgress?.toolCount,
-		tokens: task.agentProgress?.tokens,
-		turns: task.agentProgress?.turns,
-		activityState: task.agentProgress?.activityState,
-		lastActivityAt: task.agentProgress?.lastActivityAt,
-	};
-}
-
-function applyAgentProgressEvent(progress: CrewAgentProgress, event: unknown, startedAt: string | undefined): CrewAgentProgress {
-	const obj = asRecord(event);
-	const now = new Date().toISOString();
-	const next: CrewAgentProgress = { ...progress, recentTools: [...progress.recentTools], recentOutput: [...progress.recentOutput], lastActivityAt: now, activityState: "active" };
-	if (startedAt) next.durationMs = Date.now() - new Date(startedAt).getTime();
-	if (obj?.type === "tool_execution_start") {
-		next.toolCount += 1;
-		next.currentTool = typeof obj.toolName === "string" ? obj.toolName : typeof obj.name === "string" ? obj.name : "tool";
-		next.currentToolArgs = previewArgs(obj.args);
-		next.currentToolStartedAt = now;
-	}
-	if (obj?.type === "tool_execution_end") {
-		if (next.currentTool) next.recentTools.push({ tool: next.currentTool, args: next.currentToolArgs, endedAt: now });
-		next.currentTool = undefined;
-		next.currentToolArgs = undefined;
-		next.currentToolStartedAt = undefined;
-	}
-	if ((obj?.type === "tool_execution_error" || obj?.type === "tool_execution_failed") && next.currentTool) {
-		next.failedTool = next.currentTool;
-	}
-	const usage = eventUsage(event);
-	if (usage) {
-		next.tokens = (usage.input ?? 0) + (usage.output ?? 0);
-		next.turns = usage.turns ?? next.turns;
-	}
-	const text = eventText(event);
-	if (text.length > 0) next.recentOutput.push(...text.flatMap((entry) => entry.split(/\r?\n/)).filter(Boolean).slice(-10));
-	if (next.recentTools.length > 25) next.recentTools.splice(0, next.recentTools.length - 25);
-	if (next.recentOutput.length > 50) next.recentOutput.splice(0, next.recentOutput.length - 50);
-	return next;
-}
-
 export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
 	let manifest = input.manifest;
 	const workspace = prepareTaskWorkspace(manifest, input.task);
@@ -276,6 +66,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 	let tasks = updateTask(input.tasks, task);
 	const runtimeKind = input.runtimeKind ?? (input.executeWorkers ? "child-process" : "scaffold");
 	tasks = persistSingleTaskUpdate(manifest, tasks, task);
+	if (runtimeKind === "child-process") ({ task, tasks } = checkpointTask(manifest, tasks, task, "started"));
 	upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
 	appendEvent(manifest.eventsPath, { type: "task.started", runId: manifest.runId, taskId: task.id, data: { role: task.role, agent: task.agent, runtime: runtimeKind, cwd: task.cwd, worktreePath: workspace.worktreePath, worktreeBranch: workspace.branch, worktreeReused: workspace.reused } });
 	const permissionMode = permissionForRole(task.role);
@@ -305,13 +96,15 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		producer: task.id,
 	});
 	if (runtimeKind === "child-process") {
-		const candidates = buildConfiguredModelCandidates({ overrideModel: input.modelOverride, stepModel: input.step.model, agentModel: input.agent.model, fallbackModels: input.agent.fallbackModels, parentModel: input.parentModel, modelRegistry: input.modelRegistry, cwd: manifest.cwd });
+		const modelRoutingPlan = buildConfiguredModelRouting({ overrideModel: input.modelOverride, stepModel: input.step.model, agentModel: input.agent.model, fallbackModels: input.agent.fallbackModels, parentModel: input.parentModel, modelRegistry: input.modelRegistry, cwd: manifest.cwd });
+		const candidates = modelRoutingPlan.candidates;
 		const attemptModels = candidates.length > 0 ? candidates : [undefined];
 		const logs: string[] = [];
 		let finalStdout = "";
 		let finalStderr = "";
 		modelAttempts = [];
 		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
+		let finalCheckpointWritten = false;
 		let lastAgentRecordPersistedAt = 0;
 		let lastRunProgressPersistedAt = 0;
 		let lastRunProgressSummary: ProgressEventSummary | undefined;
@@ -344,11 +137,18 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				signal: input.signal,
 				transcriptPath,
 				maxDepth: input.limits?.maxTaskDepth,
+				onSpawn: (pid) => {
+					({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));
+				},
 				onStdoutLine: (line) => appendCrewAgentOutput(manifest, task.id, line),
 				onJsonEvent: (event) => {
 					appendCrewAgentEvent(manifest, task.id, event);
 					task = { ...task, agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt) };
 					tasks = updateTask(tasks, task);
+					if (!finalCheckpointWritten && isFinalChildEvent(event)) {
+						finalCheckpointWritten = true;
+						({ task, tasks } = checkpointTask(manifest, tasks, task, "child-stdout-final"));
+					}
 					persistChildProgress(event);
 				},
 			});
@@ -381,6 +181,12 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 			content: [...logs, `finalExitCode=${exitCode ?? "null"}`, `jsonEvents=${parsedOutput?.jsonEvents ?? 0}`, parsedOutput?.usage ? `usage=${JSON.stringify(parsedOutput.usage)}` : "", "", "STDOUT:", finalStdout, "", "STDERR:", finalStderr].join("\n"),
 			producer: task.id,
 		});
+		const successfulAttemptIndex = modelAttempts.findIndex((attempt) => attempt.success);
+		const usedAttempt = successfulAttemptIndex === -1 ? Math.max(0, modelAttempts.length - 1) : successfulAttemptIndex;
+		const resolvedModel = modelAttempts[usedAttempt]?.model ?? candidates[0] ?? "default";
+		const fallbackReason = usedAttempt > 0 ? modelAttempts[usedAttempt - 1]?.error : undefined;
+		task = { ...task, modelRouting: { requested: modelRoutingPlan.requested, resolved: resolvedModel, fallbackChain: candidates, reason: fallbackReason ?? modelRoutingPlan.reason, usedAttempt } };
+		tasks = updateTask(tasks, task);
 		const sessionUsage = parseSessionUsage(transcriptPath);
 		const effectiveUsage = parsedOutput?.usage ?? sessionUsage;
 		if (effectiveUsage) {
@@ -397,72 +203,21 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				producer: task.id,
 			});
 		}
+		task = { ...task, resultArtifact, ...(logArtifact ? { logArtifact } : {}), ...(transcriptArtifact ? { transcriptArtifact } : {}) };
+		tasks = updateTask(tasks, task);
+		({ task, tasks } = checkpointTask(manifest, tasks, task, "artifact-written"));
 	} else if (runtimeKind === "live-session") {
-		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
-		let lastAgentRecordPersistedAt = 0;
-		let lastRunProgressPersistedAt = 0;
-		let lastRunProgressSummary: ProgressEventSummary | undefined;
-		const persistLiveProgress = (event: unknown, force = false): void => {
-			const now = Date.now();
-			if (force || shouldFlushProgressEvent(event) || now - lastAgentRecordPersistedAt >= 500) {
-				upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
-				lastAgentRecordPersistedAt = now;
-			}
-			const summary = progressEventSummary(task, event);
-			const decision = shouldAppendProgressEventUpdate({ previous: lastRunProgressSummary, next: summary, nowMs: now, lastAppendMs: lastRunProgressPersistedAt || undefined, minIntervalMs: 1000, force });
-			if (decision.shouldAppend) {
-				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { ...summary, coalesceReason: decision.reason } });
-				lastRunProgressSummary = summary;
-				lastRunProgressPersistedAt = now;
-			}
-		};
-		const attemptStartedAt = new Date();
-		const liveResult = await runLiveSessionTask({
-			manifest,
-			task,
-			step: input.step,
-			agent: input.agent,
-			prompt,
-			signal: input.signal,
-			transcriptPath,
-			runtimeConfig: input.runtimeConfig,
-			parentContext: input.parentContext,
-			parentModel: input.parentModel,
-			modelRegistry: input.modelRegistry,
-			onOutput: (text) => appendCrewAgentOutput(manifest, task.id, text),
-			onEvent: (event) => {
-				appendCrewAgentEvent(manifest, task.id, event);
-				task = { ...task, agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt) };
-				tasks = updateTask(tasks, task);
-				persistLiveProgress(event);
-			},
-		});
-		startupEvidence = createStartupEvidence({ command: "live-session", startedAt: attemptStartedAt, finishedAt: new Date(), promptSentAt: attemptStartedAt, promptAccepted: liveResult.exitCode === 0 && !liveResult.error, stderr: liveResult.stderr, error: liveResult.error, exitCode: liveResult.exitCode });
-		exitCode = liveResult.exitCode;
-		error = liveResult.error || (liveResult.exitCode && liveResult.exitCode !== 0 ? liveResult.stderr || `Live session exited with ${liveResult.exitCode}` : undefined);
-		parsedOutput = { finalText: liveResult.stdout, textEvents: liveResult.stdout ? [liveResult.stdout] : [], jsonEvents: liveResult.jsonEvents, usage: liveResult.usage };
-		if (liveResult.usage) task = { ...task, usage: liveResult.usage, agentProgress: applyUsageToProgress(task.agentProgress, liveResult.usage) };
-		persistLiveProgress({ type: "attempt_finished" }, true);
-		resultArtifact = writeArtifact(manifest.artifactsRoot, {
-			kind: "result",
-			relativePath: `results/${task.id}.txt`,
-			content: liveResult.stdout || liveResult.stderr || "(no output)",
-			producer: task.id,
-		});
-		logArtifact = writeArtifact(manifest.artifactsRoot, {
-			kind: "log",
-			relativePath: `logs/${task.id}.log`,
-			content: [`runtime=live-session`, `finalExitCode=${exitCode ?? "null"}`, `jsonEvents=${liveResult.jsonEvents}`, liveResult.usage ? `usage=${JSON.stringify(liveResult.usage)}` : "", "", "STDOUT:", liveResult.stdout, "", "STDERR:", liveResult.stderr].join("\n"),
-			producer: task.id,
-		});
-		if (fs.existsSync(transcriptPath)) {
-			transcriptArtifact = writeArtifact(manifest.artifactsRoot, {
-				kind: "log",
-				relativePath: `transcripts/${task.id}.jsonl`,
-				content: fs.readFileSync(transcriptPath, "utf-8"),
-				producer: task.id,
-			});
-		}
+		const { runLiveTask } = await import("./task-runner/live-executor.ts");
+		const live = await runLiveTask({ manifest, tasks, task, step: input.step, agent: input.agent, prompt, signal: input.signal, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry });
+		task = live.task;
+		tasks = live.tasks;
+		startupEvidence = live.startupEvidence;
+		exitCode = live.exitCode;
+		error = live.error;
+		parsedOutput = live.parsedOutput;
+		resultArtifact = live.resultArtifact;
+		logArtifact = live.logArtifact;
+		transcriptArtifact = live.transcriptArtifact;
 	} else {
 		resultArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "result",

package/src/runtime/team-runner.ts

@@ -6,7 +6,7 @@ import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 import type { ArtifactDescriptor, PolicyDecision, TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { saveRunManifestAsync, saveRunTasksAsync, updateRunStatus } from "../state/state-store.ts";
+import { saveRunManifest, saveRunManifestAsync, saveRunTasksAsync, updateRunStatus } from "../state/state-store.ts";
 import { aggregateUsage, formatUsage } from "../state/usage.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
 import { evaluateCrewPolicy, summarizePolicyDecisions } from "./policy-engine.ts";
@@ -109,10 +109,14 @@ function slug(value: string): string {
 	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "task";
 }
 
-export function __test__parseAdaptivePlan(text: string, allowedRoles: string[]): AdaptivePlan | undefined {
+function extractAdaptivePlanJson(text: string): string | undefined {
 	const markerMatch = text.match(/ADAPTIVE_PLAN_JSON_START\s*([\s\S]*?)\s*ADAPTIVE_PLAN_JSON_END/);
 	const fencedMatch = markerMatch ? undefined : text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-	const raw = markerMatch?.[1] ?? fencedMatch?.[1];
+	return markerMatch?.[1] ?? fencedMatch?.[1];
+}
+
+export function __test__parseAdaptivePlan(text: string, allowedRoles: string[]): AdaptivePlan | undefined {
+	const raw = extractAdaptivePlanJson(text);
 	if (!raw) return undefined;
 	let parsed: unknown;
 	try { parsed = JSON.parse(raw); } catch { return undefined; }
@@ -141,6 +145,98 @@ export function __test__parseAdaptivePlan(text: string, allowedRoles: string[]):
 	return phases.length ? { phases } : undefined;
 }
 
+function closeUnbalancedJson(raw: string): string {
+	let result = raw.trim();
+	const stack: string[] = [];
+	let inString = false;
+	let escaped = false;
+	for (const char of result) {
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\" && inString) {
+			escaped = true;
+			continue;
+		}
+		if (char === '"') {
+			inString = !inString;
+			continue;
+		}
+		if (inString) continue;
+		if (char === "{") stack.push("}");
+		else if (char === "[") stack.push("]");
+		else if ((char === "}" || char === "]") && stack.at(-1) === char) stack.pop();
+	}
+	while (stack.length) result += stack.pop();
+	return result;
+}
+
+function adaptiveRoleAlias(role: string, allowed: Set<string>): string | undefined {
+	if (allowed.has(role)) return role;
+	const normalized = slug(role);
+	const aliases: Record<string, string[]> = {
+		reviewer: ["code-reviewer", "review", "code-review", "critic"],
+		"security-reviewer": ["security", "security-review", "sec-review"],
+		"test-engineer": ["tester", "qa", "test"],
+		executor: ["developer", "implementer", "coder", "engineer"],
+		explorer: ["researcher", "scout"],
+		analyst: ["analysis", "analyzer"],
+	};
+	for (const [target, names] of Object.entries(aliases)) if (allowed.has(target) && names.includes(normalized)) return target;
+	return undefined;
+}
+
+export function __test__repairAdaptivePlan(text: string, allowedRoles: string[]): { plan?: AdaptivePlan; repaired: boolean; reason?: string } {
+	const raw = extractAdaptivePlanJson(text);
+	if (!raw) return { repaired: false, reason: "missing-json" };
+	const candidates = [raw, closeUnbalancedJson(raw)];
+	let parsed: unknown;
+	for (const candidate of candidates) {
+		try {
+			parsed = JSON.parse(candidate);
+			break;
+		} catch {
+			// Try the next repair candidate.
+		}
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { repaired: false, reason: "invalid-json" };
+	const phasesRaw = Array.isArray((parsed as { phases?: unknown }).phases) ? (parsed as { phases: unknown[] }).phases : Array.isArray((parsed as { tasks?: unknown }).tasks) ? [{ name: "adaptive", tasks: (parsed as { tasks: unknown[] }).tasks }] : undefined;
+	if (!phasesRaw) return { repaired: false, reason: "missing-phases" };
+	const allowed = new Set(allowedRoles);
+	const phases: AdaptivePlanPhase[] = [];
+	let total = 0;
+	let repaired = raw !== closeUnbalancedJson(raw);
+	for (const [phaseIndex, phaseRaw] of phasesRaw.entries()) {
+		if (!phaseRaw || typeof phaseRaw !== "object" || Array.isArray(phaseRaw)) continue;
+		const phaseObj = phaseRaw as { name?: unknown; tasks?: unknown };
+		if (!Array.isArray(phaseObj.tasks)) continue;
+		const tasks: AdaptivePlanTask[] = [];
+		for (const taskRaw of phaseObj.tasks) {
+			if (total >= MAX_ADAPTIVE_TASKS) {
+				repaired = true;
+				break;
+			}
+			if (!taskRaw || typeof taskRaw !== "object" || Array.isArray(taskRaw)) {
+				repaired = true;
+				continue;
+			}
+			const taskObj = taskRaw as { role?: unknown; title?: unknown; task?: unknown };
+			const role = typeof taskObj.role === "string" ? adaptiveRoleAlias(taskObj.role, allowed) : undefined;
+			const taskText = typeof taskObj.task === "string" ? taskObj.task.trim() : "";
+			if (!role || !taskText) {
+				repaired = true;
+				continue;
+			}
+			tasks.push({ role, title: typeof taskObj.title === "string" ? taskObj.title : undefined, task: taskText });
+			total++;
+		}
+		if (tasks.length) phases.push({ name: typeof phaseObj.name === "string" && phaseObj.name.trim() ? phaseObj.name.trim() : `phase-${phaseIndex + 1}`, tasks });
+		if (total >= MAX_ADAPTIVE_TASKS) break;
+	}
+	return phases.length ? { plan: { phases }, repaired: true, reason: repaired ? "repaired" : "normalized" } : { repaired: false, reason: "empty-plan" };
+}
+
 function reconstructAdaptiveWorkflow(workflow: WorkflowConfig, tasks: TeamTaskState[]): WorkflowConfig {
 	const existing = new Set(workflow.steps.map((step) => step.id));
 	const steps: WorkflowStep[] = [];
@@ -167,10 +263,20 @@ function injectAdaptivePlanIfReady(input: { manifest: TeamRunManifest; tasks: Te
 		appendEvent(input.manifest.eventsPath, { type: "adaptive.plan_missing", runId: input.manifest.runId, taskId: assessTask.id, message: "Adaptive planner result artifact could not be read." });
 		return { tasks: input.tasks, workflow: input.workflow, injected: false, missingPlan: true };
 	}
-	const plan = __test__parseAdaptivePlan(text, input.team.roles.map((role) => role.name));
+	const allowedRoles = input.team.roles.map((role) => role.name);
+	let plan = __test__parseAdaptivePlan(text, allowedRoles);
 	if (!plan) {
-		appendEvent(input.manifest.eventsPath, { type: "adaptive.plan_missing", runId: input.manifest.runId, taskId: assessTask.id, message: "Adaptive planner did not produce a valid plan; no dynamic subagents were spawned." });
-		return { tasks: input.tasks, workflow: input.workflow, injected: false, missingPlan: true };
+		const repair = process.env.PI_CREW_ADAPTIVE_REPAIR === "0" || process.env.PI_TEAMS_ADAPTIVE_REPAIR === "0" ? { repaired: false, reason: "disabled" } : __test__repairAdaptivePlan(text, allowedRoles);
+		if (repair.plan) {
+			plan = repair.plan;
+			const repairArtifact = writeArtifact(input.manifest.artifactsRoot, { kind: "metadata", relativePath: "metadata/adaptive-repair.json", producer: assessTask.id, content: `${JSON.stringify({ reason: repair.reason, phases: repair.plan.phases.map((phase) => ({ name: phase.name, count: phase.tasks.length, roles: phase.tasks.map((task) => task.role) })) }, null, 2)}\n` });
+			saveRunManifest({ ...input.manifest, updatedAt: new Date().toISOString(), artifacts: [...input.manifest.artifacts, repairArtifact] });
+			appendEvent(input.manifest.eventsPath, { type: "adaptive.plan_repaired", runId: input.manifest.runId, taskId: assessTask.id, message: "Adaptive planner output was repaired before dynamic subagents were spawned.", data: { reason: repair.reason } });
+		} else {
+			appendEvent(input.manifest.eventsPath, { type: "adaptive.plan_repair_failed", runId: input.manifest.runId, taskId: assessTask.id, message: "Adaptive planner output could not be repaired.", data: { reason: repair.reason } });
+			appendEvent(input.manifest.eventsPath, { type: "adaptive.plan_missing", runId: input.manifest.runId, taskId: assessTask.id, message: "Adaptive planner did not produce a valid plan; no dynamic subagents were spawned." });
+			return { tasks: input.tasks, workflow: input.workflow, injected: false, missingPlan: true };
+		}
 	}
 	const steps: WorkflowStep[] = [];
 	const tasks: TeamTaskState[] = [];
@@ -327,7 +433,10 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 
 		const snapshot = taskGraphSnapshot(tasks, queueIndex);
 		const readyRoles = snapshot.ready.map((taskId) => tasks.find((task) => task.id === taskId)?.role).filter((role): role is string => Boolean(role));
-		const concurrency = resolveBatchConcurrency({ workflowName: workflow.name, workflowMaxConcurrency: workflow.maxConcurrency, teamMaxConcurrency: input.team.maxConcurrency, limitMaxConcurrentWorkers: input.limits?.maxConcurrentWorkers, readyCount: snapshot.ready.length, workspaceMode: manifest.workspaceMode, readyRoles });
+		const concurrency = resolveBatchConcurrency({ workflowName: workflow.name, workflowMaxConcurrency: workflow.maxConcurrency, teamMaxConcurrency: input.team.maxConcurrency, limitMaxConcurrentWorkers: input.limits?.maxConcurrentWorkers, allowUnboundedConcurrency: input.limits?.allowUnboundedConcurrency, readyCount: snapshot.ready.length, workspaceMode: manifest.workspaceMode, readyRoles });
+		if (concurrency.reason.includes(";unbounded:")) {
+			appendEvent(manifest.eventsPath, { type: "limits.unbounded", runId: manifest.runId, message: "Unbounded worker concurrency was explicitly enabled for this run.", data: { concurrencyReason: concurrency.reason, maxConcurrent: concurrency.maxConcurrent } });
+		}
 		const readyBatch = getReadyTasks(tasks, concurrency.selectedCount, queueIndex);
 		if (readyBatch.length === 0) {
 			tasks = markBlocked(tasks, "No ready queued task; dependency graph may be invalid.");

package/src/schema/config-schema.ts

@@ -18,6 +18,7 @@ export const PiTeamsAutonomousConfigSchema = Type.Object({
 
 export const PiTeamsLimitsConfigSchema = Type.Object({
 	maxConcurrentWorkers: Type.Optional(Type.Integer({ minimum: 1 })),
+	allowUnboundedConcurrency: Type.Optional(Type.Boolean()),
 	maxTaskDepth: Type.Optional(Type.Integer({ minimum: 1 })),
 	maxChildrenPerTask: Type.Optional(Type.Integer({ minimum: 1 })),
 	maxRunMinutes: Type.Optional(Type.Integer({ minimum: 1 })),

package/src/state/mailbox.ts

@@ -34,6 +34,11 @@ export interface MailboxValidationReport {
 	repaired: string[];
 }
 
+export interface MailboxReplayResult {
+	messages: MailboxMessage[];
+	updatedAt: string;
+}
+
 function mailboxDir(manifest: TeamRunManifest): string {
 	return path.join(manifest.stateRoot, "mailbox");
 }
@@ -110,6 +115,18 @@ export function readMailbox(manifest: TeamRunManifest, direction?: MailboxDirect
 	return directions.flatMap((item) => safeReadMailboxFile(mailboxPath(manifest, item, taskId), item)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
 
+function readAllInboxMessages(manifest: TeamRunManifest): MailboxMessage[] {
+	const messages = [...safeReadMailboxFile(mailboxPath(manifest, "inbox"), "inbox")];
+	const tasksDir = path.join(mailboxDir(manifest), "tasks");
+	if (fs.existsSync(tasksDir)) {
+		for (const entry of fs.readdirSync(tasksDir, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			messages.push(...safeReadMailboxFile(mailboxPath(manifest, "inbox", entry.name), "inbox"));
+		}
+	}
+	return messages.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+
 export function readDeliveryState(manifest: TeamRunManifest): MailboxDeliveryState {
 	ensureRunMailbox(manifest);
 	try {
@@ -163,6 +180,17 @@ export function acknowledgeMailboxMessage(manifest: TeamRunManifest, messageId:
 	return delivery;
 }
 
+export function replayPendingMailboxMessages(manifest: TeamRunManifest): MailboxReplayResult {
+	const delivery = readDeliveryState(manifest);
+	const pending = readAllInboxMessages(manifest).filter((message) => message.status !== "acknowledged" && delivery.messages[message.id] !== "acknowledged");
+	if (!pending.length) return { messages: [], updatedAt: delivery.updatedAt };
+	const updatedAt = new Date().toISOString();
+	for (const message of pending) delivery.messages[message.id] = "delivered";
+	delivery.updatedAt = updatedAt;
+	writeDeliveryState(manifest, delivery);
+	return { messages: pending, updatedAt };
+}
+
 export function validateMailbox(manifest: TeamRunManifest, options: { repair?: boolean } = {}): MailboxValidationReport {
 	ensureRunMailbox(manifest);
 	const issues: MailboxValidationIssue[] = [];

package/src/state/types.ts

@@ -118,12 +118,26 @@ export interface ModelAttemptState {
 	error?: string;
 }
 
+export interface ModelRoutingState {
+	requested?: string;
+	resolved: string;
+	fallbackChain: string[];
+	reason?: string;
+	usedAttempt: number;
+}
+
 export interface TaskWorktreeState {
 	path: string;
 	branch: string;
 	reused: boolean;
 }
 
+export interface TaskCheckpointState {
+	phase: "started" | "child-spawned" | "child-stdout-final" | "artifact-written";
+	updatedAt: string;
+	childPid?: number;
+}
+
 export interface TeamTaskState {
 	id: string;
 	runId: string;
@@ -144,12 +158,14 @@ export interface TeamTaskState {
 	exitCode?: number | null;
 	model?: string;
 	modelAttempts?: ModelAttemptState[];
+	modelRouting?: ModelRoutingState;
 	usage?: UsageState;
 	jsonEvents?: number;
 	agentProgress?: CrewAgentProgress;
 	error?: string;
 	claim?: TaskClaimState;
 	heartbeat?: WorkerHeartbeatState;
+	checkpoint?: TaskCheckpointState;
 	taskPacket?: TaskPacket;
 	verification?: VerificationEvidence;
 	graph?: TaskGraphNode;

package/src/subagents/async-entry.ts

@@ -0,0 +1 @@
+export * from "../runtime/async-runner.ts";

package/src/subagents/index.ts

@@ -0,0 +1,3 @@
+export * from "./spawn.ts";
+export * from "./manager.ts";
+export * from "./async-entry.ts";