pi-crew 0.1.46 → 0.1.49

package/src/runtime/task-runner/state-helpers.ts

@@ -1,22 +1,22 @@
-import type { TaskCheckpointState, TeamRunManifest, TeamTaskState } from "../../state/types.ts";
-import { loadRunManifestById, saveRunTasks } from "../../state/state-store.ts";
-import { recordFromTask, upsertCrewAgent } from "../crew-agent-records.ts";
-
-export function updateTask(tasks: TeamTaskState[], updated: TeamTaskState): TeamTaskState[] {
-	return tasks.map((task) => task.id === updated.id ? updated : task);
-}
-
-export 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;
-}
-
-export function checkpointTask(manifest: TeamRunManifest, tasks: TeamTaskState[], task: TeamTaskState, phase: TaskCheckpointState["phase"], childPid?: number): { task: TeamTaskState; tasks: TeamTaskState[] } {
-	const checkpoint: TaskCheckpointState = { phase, updatedAt: new Date().toISOString(), ...(childPid ? { childPid } : task.checkpoint?.childPid ? { childPid: task.checkpoint.childPid } : {}) };
-	const nextTask = { ...task, checkpoint };
-	const nextTasks = persistSingleTaskUpdate(manifest, updateTask(tasks, nextTask), nextTask);
-	upsertCrewAgent(manifest, recordFromTask(manifest, nextTask, "child-process"));
-	return { task: nextTask, tasks: nextTasks };
-}
+import type { TaskCheckpointState, TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import { loadRunManifestById, saveRunTasks } from "../../state/state-store.ts";
+import { recordFromTask, upsertCrewAgent } from "../crew-agent-records.ts";
+
+export function updateTask(tasks: TeamTaskState[], updated: TeamTaskState): TeamTaskState[] {
+	return tasks.map((task) => task.id === updated.id ? updated : task);
+}
+
+export 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;
+}
+
+export function checkpointTask(manifest: TeamRunManifest, tasks: TeamTaskState[], task: TeamTaskState, phase: TaskCheckpointState["phase"], childPid?: number): { task: TeamTaskState; tasks: TeamTaskState[] } {
+	const checkpoint: TaskCheckpointState = { phase, updatedAt: new Date().toISOString(), ...(childPid ? { childPid } : task.checkpoint?.childPid ? { childPid: task.checkpoint.childPid } : {}) };
+	const nextTask = { ...task, checkpoint };
+	const nextTasks = persistSingleTaskUpdate(manifest, updateTask(tasks, nextTask), nextTask);
+	upsertCrewAgent(manifest, recordFromTask(manifest, nextTask, "child-process"));
+	return { task: nextTask, tasks: nextTasks };
+}

package/src/runtime/task-runner.ts

@@ -13,11 +13,13 @@ import { buildConfiguredModelRouting, formatModelAttemptNote, isRetryableModelFa
 import { parsePiJsonOutput, type ParsedPiJsonOutput } from "./pi-json-output.ts";
 import { runChildPi } from "./child-pi.ts";
 import { buildTaskPacket } from "./task-packet.ts";
+import { executeHook, appendHookEvent } from "../hooks/registry.ts";
 import { createVerificationEvidence } from "./green-contract.ts";
 import { createStartupEvidence } from "./worker-startup.ts";
 import { permissionForRole } from "./role-permission.ts";
 import { collectDependencyOutputContext, renderDependencyOutputContext, writeTaskInputsArtifact, writeTaskSharedOutput } from "./task-output-context.ts";
 import { appendCrewAgentEvent, appendCrewAgentOutput, emptyCrewAgentProgress, recordFromTask, upsertCrewAgent } from "./crew-agent-records.ts";
+import { reserveControlChannel } from "./agent-control.ts";
 import { parseSessionUsage } from "./session-usage.ts";
 import type { CrewAgentProgress, CrewRuntimeKind } from "./crew-agent-runtime.ts";
 import { shouldAppendProgressEventUpdate, type ProgressEventSummary } from "./progress-event-coalescer.ts";
@@ -28,10 +30,16 @@ import { applyAgentProgressEvent, applyUsageToProgress, progressEventSummary, sh
 import { checkpointTask, persistSingleTaskUpdate, updateTask } from "./task-runner/state-helpers.ts";
 import { cleanResultText, isFinalChildEvent } from "./task-runner/result-utils.ts";
 import { evaluateCompletionMutationGuard } from "./completion-guard.ts";
-import { cancellationReasonFromSignal } from "./cancellation.ts";
+import { cancellationReasonFromSignal, buildSyntheticTerminalEvidence } from "./cancellation.ts";
 import { appendTaskAttentionEvent } from "./attention-events.ts";
 import { parseSupervisorContactFromLine, recordSupervisorContact } from "./supervisor-contact.ts";
+import { registerStreamBridge, bridgeEventFromJsonEvent } from "./event-stream-bridge.ts";
 import { renderSkillInstructions } from "./skill-instructions.ts";
+import { DEFAULT_YIELD_CONFIG, extractYieldResult, hasYieldInOutput, isYieldEvent, registerYieldTool, type YieldResult } from "./yield-handler.ts";
+import { validateWorkerOutput, type OutputValidationResult } from "./output-validator.ts";
+
+// Register the submit_result tool handler so subprocess events can extract yield data.
+registerYieldTool();
 
 export interface TaskRunnerInput {
 	manifest: TeamRunManifest;
@@ -61,6 +69,10 @@ export interface TaskRunnerInput {
 
 export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
 	let manifest = input.manifest;
+	// H4: registerStreamBridge inside try so dispose() in finally is safe
+	let streamBridge: ReturnType<typeof registerStreamBridge> | undefined;
+	try {
+	streamBridge = registerStreamBridge(manifest.runId);
 	const workspace = prepareTaskWorkspace(manifest, input.task);
 	const worktree = workspace.worktreePath && workspace.branch ? { path: workspace.worktreePath, branch: workspace.branch, reused: workspace.reused ?? false } : input.task.worktree;
 	const taskPacket = buildTaskPacket({ manifest, step: input.step, taskId: input.task.id, cwd: workspace.cwd, worktreePath: worktree?.path });
@@ -77,6 +89,8 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		heartbeat: createWorkerHeartbeat(input.task.id),
 		agentProgress: input.task.agentProgress ?? emptyCrewAgentProgress(),
 		...(dependencyContextText ? { dependencyContextText } : {}),
+		// Reserve control channel before spawn so cancel/steer can target this task immediately
+		controlReservation: reserveControlChannel(input.task.id, manifest.runId),
 	} as TeamTaskState;
 	let tasks = updateTask(input.tasks, task);
 	const runtimeKind = input.runtimeKind ?? (input.executeWorkers ? "child-process" : "scaffold");
@@ -84,13 +98,17 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 	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 } });
+	// Emit immediate UI notification so widget shows agent as "running" within ~100ms
+	// instead of waiting for child process first JSON event (2-5s delay).
+	streamBridge?.handler({ runId: manifest.runId, taskId: task.id, eventType: "task.started", timestamp: Date.now() });
 	const permissionMode = permissionForRole(task.role);
 	const renderedSkills = input.skillBlock === undefined ? renderSkillInstructions({ cwd: task.cwd, role: task.role, agent: input.agent, teamRole: { skills: input.teamRoleSkills }, step: input.step, override: input.skillOverride }) : undefined;
 	const skillBlock = input.skillBlock ?? renderedSkills?.block;
 	const skillNames = input.skillNames ?? renderedSkills?.names;
 	const skillPaths = input.skillPaths ?? renderedSkills?.paths;
 
-	const prompt = renderTaskPrompt(manifest, input.step, task, input.agent, skillBlock);
+	const promptResult = await renderTaskPrompt(manifest, input.step, task, input.agent, skillBlock);
+	const prompt = promptResult.full;
 	const promptArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "prompt",
 		relativePath: `prompts/${task.id}.md`,
@@ -108,6 +126,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 	let finalStdout = "";
 	let transcriptPath: string | undefined;
 	let terminalEvidence: OperationTerminalEvidence[] = [];
+	const collectedJsonEvents: Record<string, unknown>[] = [];
 
 	let startupEvidence = createStartupEvidence({ command: runtimeKind === "child-process" ? "pi" : runtimeKind === "live-session" ? "live-session" : "safe-scaffold", startedAt: new Date(task.startedAt ?? new Date().toISOString()), finishedAt: new Date(), promptSentAt: new Date(task.startedAt ?? new Date().toISOString()), promptAccepted: true, exitCode: 0 });
 	const inputsArtifact = writeTaskInputsArtifact(manifest, task, dependencyContext);
@@ -187,9 +206,15 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				},
 				onJsonEvent: (event) => {
 					appendCrewAgentEvent(manifest, task.id, event);
+					if (event && typeof event === "object" && !Array.isArray(event)) collectedJsonEvents.push(event as Record<string, unknown>);
 					persistHeartbeat();
 					task = { ...task, agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt) };
 					tasks = updateTask(tasks, task);
+					// Bridge event to UI event bus for near-instant updates
+					try {
+						const bridgeEvent = bridgeEventFromJsonEvent(manifest.runId, task.id, event);
+						if (bridgeEvent) streamBridge?.handler(bridgeEvent);
+					} catch { /* bridge errors should not affect task */ }
 					// Feed overflow recovery tracker
 					if (input.onJsonEvent) {
 						try {
@@ -205,7 +230,11 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 			});
 			const evidenceStatus = childResult.exitStatus?.cancelled ? "cancelled" : childResult.error || (childResult.exitCode && childResult.exitCode !== 0) ? "failed" : "completed";
 			terminalEvidence = [...terminalEvidence, { operation: "worker", status: evidenceStatus, startedAt: attemptStartedAt.toISOString(), finishedAt: new Date().toISOString(), ...(input.signal?.aborted ? { reason: cancellationReasonFromSignal(input.signal) } : {}), ...(childResult.exitStatus ? { exitStatus: childResult.exitStatus } : {}) }];
-			if (evidenceStatus === "cancelled") appendEvent(manifest.eventsPath, { type: "worker.cancelled", runId: manifest.runId, taskId: task.id, message: input.signal?.aborted ? cancellationReasonFromSignal(input.signal).message : "Worker cancelled.", data: { terminalEvidence: terminalEvidence.at(-1) } });
+			if (evidenceStatus === "cancelled") {
+				const cancelReason = input.signal?.aborted ? cancellationReasonFromSignal(input.signal) : { code: "caller_cancelled" as const, message: "Worker cancelled." };
+				terminalEvidence.push(buildSyntheticTerminalEvidence("tool", cancelReason, attemptStartedAt.toISOString()));
+				appendEvent(manifest.eventsPath, { type: "worker.cancelled", runId: manifest.runId, taskId: task.id, message: cancelReason.message, data: { terminalEvidence: terminalEvidence.at(-1) } });
+			}
 			startupEvidence = createStartupEvidence({ command: "pi", startedAt: attemptStartedAt, finishedAt: new Date(), promptSentAt: attemptStartedAt, promptAccepted: childResult.exitCode === 0 && !childResult.error, stderr: childResult.stderr, error: childResult.error, exitCode: childResult.exitCode });
 			exitCode = childResult.exitCode;
 			finalStdout = childResult.stdout;
@@ -287,6 +316,20 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		});
 	}
 
+	// --- Yield-based completion contract ---
+	let yieldResult: YieldResult | undefined;
+	const yieldEnabled = input.runtimeConfig?.yield?.enabled ?? DEFAULT_YIELD_CONFIG.enabled;
+	if (yieldEnabled && collectedJsonEvents.length > 0) {
+		if (hasYieldInOutput(collectedJsonEvents)) {
+			const yieldEvent = collectedJsonEvents.find((e) => isYieldEvent(e));
+			if (yieldEvent) {
+				yieldResult = extractYieldResult(yieldEvent);
+			}
+		} else if (!error) {
+			appendEvent(manifest.eventsPath, { type: "task.attention", runId: manifest.runId, taskId: task.id, message: "Worker completed without calling submit_result tool.", data: { activityState: "needs_attention", reason: "no_yield" } });
+		}
+	}
+
 	const diffArtifact = workspace.worktreePath ? writeArtifact(manifest.artifactsRoot, {
 		kind: "diff",
 		relativePath: `diffs/${task.id}.diff`,
@@ -320,6 +363,22 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		tasks = updateTask(tasks, task);
 	}
 
+	// --- Output format validation (caveman Phase 4) ---
+	// Validate worker output against the role's output contract.
+	// On failure: emit attention event but don't fail the task.
+	let outputValidation: OutputValidationResult | undefined;
+	if (!error) {
+		const outputText = parsedOutput?.finalText ?? finalStdout;
+		if (outputText) {
+			outputValidation = validateWorkerOutput(task.role, outputText);
+			if (!outputValidation.valid) {
+				appendEvent(manifest.eventsPath, { type: "task.output_validation", runId: manifest.runId, taskId: task.id, data: { valid: false, formatMatch: outputValidation.formatMatch, structurePreserved: outputValidation.structurePreserved, issues: outputValidation.issues } });
+				task = { ...task, agentProgress: { ...(task.agentProgress ?? emptyCrewAgentProgress()), activityState: "needs_attention" } };
+				tasks = updateTask(tasks, task);
+			}
+		}
+	}
+
 	task = {
 		...task,
 		status: error ? "failed" : "completed",
@@ -378,10 +437,22 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: `${JSON.stringify(buildWorkerPromptPipeline({ artifactsRoot: manifest.artifactsRoot, taskId: task.id, promptArtifact, inputsArtifact, skillArtifact, capabilityArtifact, coordinationArtifact, skillInstructionCount: skillNames?.length ?? 0, skillsDisabled: input.skillOverride === false || input.teamRoleSkills === false }), null, 2)}\n`,
 		producer: task.id,
 	});
-	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, inputsArtifact, coordinationArtifact, ...(skillArtifact ? [skillArtifact] : []), packetArtifact, verificationArtifact, startupArtifact, permissionArtifact, capabilityArtifact, promptPipelineArtifact, ...(sharedOutputArtifact ? [sharedOutputArtifact] : []), ...(logArtifact ? [logArtifact] : []), ...(transcriptArtifact ? [transcriptArtifact] : []), ...(diffArtifact ? [diffArtifact] : []), ...(diffStatArtifact ? [diffStatArtifact] : [])] };
+	const outputValidationArtifact = outputValidation ? writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.output-validation.json`,
+		content: `${JSON.stringify(outputValidation, null, 2)}\n`,
+		producer: task.id,
+	}) : undefined;
+	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, inputsArtifact, coordinationArtifact, ...(skillArtifact ? [skillArtifact] : []), packetArtifact, verificationArtifact, startupArtifact, permissionArtifact, capabilityArtifact, promptPipelineArtifact, ...(outputValidationArtifact ? [outputValidationArtifact] : []), ...(sharedOutputArtifact ? [sharedOutputArtifact] : []), ...(logArtifact ? [logArtifact] : []), ...(transcriptArtifact ? [transcriptArtifact] : []), ...(diffArtifact ? [diffArtifact] : []), ...(diffStatArtifact ? [diffStatArtifact] : [])] };
 	saveRunManifest(manifest);
 	tasks = persistSingleTaskUpdate(manifest, tasks, task);
 	upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
+	// Execute task_result hook before emitting terminal event
+	const hookReport = await executeHook("task_result", { runId: manifest.runId, taskId: task.id, cwd: manifest.cwd });
+	appendHookEvent(manifest, hookReport);
 	appendEvent(manifest.eventsPath, { type: error ? "task.failed" : "task.completed", runId: manifest.runId, taskId: task.id, message: error });
 	return { manifest, tasks };
+	} finally {
+		streamBridge?.dispose();
+	}
 }

package/src/runtime/team-runner.ts

@@ -3,6 +3,7 @@ import type { AgentConfig } from "../agents/agent-config.ts";
 import type { CrewLimitsConfig, CrewRuntimeConfig, CrewReliabilityConfig } from "../config/config.ts";
 import type { CrewRuntimeCapabilities } from "./runtime-resolver.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
+import { executeHook, appendHookEvent } from "../hooks/registry.ts";
 import { appendEvent } from "../state/event-log.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 import type { ArtifactDescriptor, PolicyDecision, TeamRunManifest, TaskAttemptState, TeamTaskState } from "../state/types.ts";
@@ -25,7 +26,7 @@ import { childCorrelation, withCorrelation } from "../observability/correlation.
 import { resolveBatchConcurrency } from "./concurrency.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
 import { permissionForRole } from "./role-permission.ts";
-import { CrewCancellationError, cancellationReasonFromSignal } from "./cancellation.ts";
+import { CrewCancellationError, buildSyntheticTerminalEvidence, cancellationReasonFromSignal } from "./cancellation.ts";
 import { effectivenessPolicyDecision, evaluateRunEffectiveness, formatRunEffectivenessLines } from "./effectiveness.ts";
 
 export interface ExecuteTeamRunInput {
@@ -506,6 +507,39 @@ function hasPendingMutatingAdaptiveTask(tasks: TeamTaskState[]): boolean {
 export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
 	let workflow = input.workflow;
 	let manifest = updateRunStatus(input.manifest, "running", input.executeWorkers ? "Executing team workflow." : "Creating workflow prompts and placeholder results.");
+
+	try {
+		return await executeTeamRunCore(input, manifest, workflow);
+	} catch (error) {
+		// P1: Catch unhandled errors — ensure manifest is set to "failed" so it doesn't stay "running" forever.
+		const message = error instanceof Error ? error.message : String(error);
+		try {
+			manifest = updateRunStatus(manifest, "failed", `Unhandled error in team runner: ${message}`);
+			await saveRunManifestAsync(manifest);
+		} catch {
+			// Best-effort — state write may also fail
+		}
+		const tasks = refreshTaskGraphQueues(input.tasks).map((task) =>
+			task.status === "running" || task.status === "queued" || task.status === "waiting"
+				? { ...task, status: "failed" as const, finishedAt: new Date().toISOString(), error: message }
+				: task,
+		);
+		return { manifest, tasks };
+	}
+}
+
+async function executeTeamRunCore(
+	input: ExecuteTeamRunInput,
+	manifest: TeamRunManifest,
+	workflow: WorkflowConfig,
+): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
+	// Execute before_run_start hook (non-blocking by default)
+	const beforeRunReport = await executeHook("before_run_start", { runId: manifest.runId, cwd: manifest.cwd });
+	appendHookEvent(manifest, beforeRunReport);
+	if (beforeRunReport.outcome === "block") {
+		manifest = updateRunStatus(manifest, "blocked", beforeRunReport.reason ?? "before_run_start hook blocked the run.");
+		return { manifest, tasks: input.tasks };
+	}
 	let tasks = refreshTaskGraphQueues(input.tasks);
 	let queueIndex = buildTaskGraphIndex(tasks);
 	const canInjectAdaptivePlan = workflow.name === "implementation";
@@ -552,7 +586,11 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 			tasks = tasks.map((task) => {
 				if (task.status !== "queued" && task.status !== "running" && task.status !== "waiting") return task;
 				cancelledTaskIds.push(task.id);
-				return { ...task, status: "cancelled", finishedAt: new Date().toISOString(), error: message };
+				const base = { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: message };
+				if (task.status === "running") {
+					return { ...base, terminalEvidence: [...(task.terminalEvidence ?? []), buildSyntheticTerminalEvidence("worker", cancelReason, task.startedAt)] };
+				}
+				return base;
 			});
 			await saveRunTasksAsync(manifest, tasks);
 			for (const taskId of cancelledTaskIds) appendEvent(manifest.eventsPath, { type: "task.cancelled", runId: manifest.runId, taskId, message, data: { reason: cancelReason.code } });
@@ -594,8 +632,18 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		}
 
 		appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, message: `Starting ready batch with ${readyBatch.length} task(s).`, data: { taskIds: readyBatch.map((task) => task.id), readyCount: snapshot.ready.length, blockedCount: snapshot.blocked.length, runningCount: snapshot.running.length, doneCount: snapshot.done.length, selectedCount: readyBatch.length, maxConcurrent: concurrency.maxConcurrent, defaultConcurrency: concurrency.defaultConcurrency, concurrencyReason: approvalPending ? `${concurrency.reason};plan-approval-read-only` : concurrency.reason } });
+		// Execute before_task_start hooks for the batch
+		for (const task of readyBatch) {
+			const taskReport = await executeHook("before_task_start", { runId: manifest.runId, taskId: task.id, cwd: manifest.cwd });
+			appendHookEvent(manifest, taskReport);
+			if (taskReport.outcome === "block") {
+				tasks = tasks.map((t) => t.id === task.id ? { ...t, status: "skipped" as const, error: taskReport.reason ?? "before_task_start hook blocked execution." } : t);
+				manifest = updateRunStatus(manifest, manifest.status, `Task '${task.id}' blocked by hook.`);
+			}
+		}
+		const batchTasks = readyBatch.filter((task) => tasks.find((t) => t.id === task.id && t.status !== "skipped"));
 		const results = await mapConcurrent(
-			readyBatch,
+			batchTasks,
 			concurrency.selectedCount,
 			async (task) => {
 				const step = findStep(workflow, task);
@@ -604,6 +652,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 				const baseInput = { manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, runtimeKind: input.runtime?.kind, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, modelOverride: input.modelOverride, teamRoleModel: teamRole?.model, teamRoleSkills: teamRole?.skills, skillOverride: input.skillOverride, limits: input.limits, onJsonEvent: input.onJsonEvent };
 				if (input.reliability?.autoRetry !== true) return withCorrelation(childCorrelation(manifest.runId, task.id), () => runTeamTask(baseInput));
 				let lastFailed: { manifest: TeamRunManifest; tasks: TeamTaskState[] } | undefined;
+				let lastAttemptId: string | undefined;
 				const attemptsSoFar: TaskAttemptState[] = [...(task.attempts ?? [])];
 				const policy = retryPolicyFromConfig(input.reliability);
 				try {
@@ -634,10 +683,12 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 						signal: input.signal,
 						attemptId: (attempt) => `${manifest.runId}:${task.id}:attempt-${attempt}`,
 						onAttemptFailed: (attempt, error, delayMs, info) => {
-							appendEvent(manifest.eventsPath, { type: "crew.task.retry_attempt", runId: manifest.runId, taskId: task.id, message: error.message, data: { attempt, attemptId: info.attemptId, delayMs } });
+							lastAttemptId = info.attemptId;
+							appendEvent(manifest.eventsPath, { type: "crew.task.retry_attempt", runId: manifest.runId, taskId: task.id, message: error.message, data: { attempt, attemptId: info.attemptId, delayMs }, metadata: { attemptId: info.attemptId } });
 							input.metricRegistry?.histogram("crew.task.retry_delay_ms", "Retry backoff delay, milliseconds").observe({ runId: manifest.runId, taskId: task.id }, delayMs);
 						},
 						onRetryGivenUp: (attempts, error, info) => {
+							lastAttemptId = info.attemptId;
 							appendDeadletter(manifest, { runId: manifest.runId, taskId: task.id, reason: "max-retries", attempts, attemptId: info.attemptId, lastError: error.message, timestamp: new Date().toISOString() });
 							input.metricRegistry?.counter("crew.task.deadletter_total", "Deadletter triggers by reason").inc({ reason: "max-retries" });
 							input.metricRegistry?.histogram("crew.task.retry_count", "Retries per task", [0, 1, 2, 3, 5, 10]).observe({ runId: manifest.runId, team: input.team.name }, Math.max(0, attempts - 1));
@@ -650,7 +701,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 						const freshManifest = fresh?.manifest ?? manifest;
 						const freshTasks = fresh?.tasks ?? tasks;
 						const cancelledTasks = freshTasks.map((item) => item.id === task.id && (item.status === "queued" || item.status === "running") ? { ...item, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: `${reason.message} (${reason.code})` } : item);
-						appendEvent(freshManifest.eventsPath, { type: "task.cancelled", runId: freshManifest.runId, taskId: task.id, message: reason.message, data: { reason, phase: "retry" } });
+						appendEvent(freshManifest.eventsPath, { type: "task.cancelled", runId: freshManifest.runId, taskId: task.id, message: reason.message, data: { reason, phase: "retry" }, metadata: lastAttemptId ? { attemptId: lastAttemptId } : undefined });
 						return { manifest: updateRunStatus(freshManifest, "cancelled", reason.message), tasks: cancelledTasks };
 					}
 					if (lastFailed) return lastFailed;
@@ -663,6 +714,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 				}
 			},
 		);
+		if (results.length === 0) break;
 		manifest = { ...results.at(-1)!.manifest, artifacts: mergeArtifacts([manifest.artifacts, ...results.map((item) => item.manifest.artifacts)].flat()) };
 		tasks = __test__mergeTaskUpdates(tasks, results);
 		const cancelledResult = results.find((item) => item.manifest.status === "cancelled");
@@ -701,14 +753,14 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		}
 		await saveRunTasksAsync(manifest, tasks);
 		saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
-		const completedBatch = readyBatch.map((task) => tasks.find((item) => item.id === task.id) ?? task);
+		const completedBatch = batchTasks.map((task) => tasks.find((item) => item.id === task.id) ?? task);
 		const batchArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "summary",
-			relativePath: `batches/${readyBatch.map((task) => task.id).join("+")}.md`,
+			relativePath: `batches/${batchTasks.map((task) => task.id).join("+")}.md`,
 			producer: "team-runner",
 			content: aggregateTaskOutputs(completedBatch, manifest),
 		});
-		const groupDelivery = deliverGroupJoin({ manifest, mode: resolveGroupJoinMode(input.runtimeConfig), batch: readyBatch, allTasks: tasks });
+		const groupDelivery = deliverGroupJoin({ manifest, mode: resolveGroupJoinMode(input.runtimeConfig), batch: batchTasks, allTasks: tasks });
 		manifest = { ...manifest, artifacts: mergeArtifacts([...manifest.artifacts, batchArtifact, ...(groupDelivery?.artifact ? [groupDelivery.artifact] : [])]) };
 		manifest = writeProgress(manifest, tasks, "team-runner", input.executeWorkers, input.runtimeConfig);
 		await saveRunManifestAsync(manifest);

package/src/runtime/worker-heartbeat.ts

@@ -1,21 +1,21 @@
-export interface WorkerHeartbeatState {
-	workerId: string;
-	pid?: number;
-	lastSeenAt: string;
-	lastStdoutAt?: string;
-	lastEventAt?: string;
-	turnCount?: number;
-	alive?: boolean;
-}
-
-export function createWorkerHeartbeat(workerId: string, pid?: number, now = new Date()): WorkerHeartbeatState {
-	return { workerId, pid, lastSeenAt: now.toISOString(), alive: true };
-}
-
-export function touchWorkerHeartbeat(heartbeat: WorkerHeartbeatState, updates: Partial<Omit<WorkerHeartbeatState, "workerId">> = {}, now = new Date()): WorkerHeartbeatState {
-	return { ...heartbeat, ...updates, lastSeenAt: now.toISOString() };
-}
-
-export function isWorkerHeartbeatStale(heartbeat: WorkerHeartbeatState, staleMs: number, now = new Date()): boolean {
-	return now.getTime() - Date.parse(heartbeat.lastSeenAt) > staleMs;
-}
+export interface WorkerHeartbeatState {
+	workerId: string;
+	pid?: number;
+	lastSeenAt: string;
+	lastStdoutAt?: string;
+	lastEventAt?: string;
+	turnCount?: number;
+	alive?: boolean;
+}
+
+export function createWorkerHeartbeat(workerId: string, pid?: number, now = new Date()): WorkerHeartbeatState {
+	return { workerId, pid, lastSeenAt: now.toISOString(), alive: true };
+}
+
+export function touchWorkerHeartbeat(heartbeat: WorkerHeartbeatState, updates: Partial<Omit<WorkerHeartbeatState, "workerId">> = {}, now = new Date()): WorkerHeartbeatState {
+	return { ...heartbeat, ...updates, lastSeenAt: now.toISOString() };
+}
+
+export function isWorkerHeartbeatStale(heartbeat: WorkerHeartbeatState, staleMs: number, now = new Date()): boolean {
+	return now.getTime() - Date.parse(heartbeat.lastSeenAt) > staleMs;
+}

package/src/runtime/worker-startup.ts

@@ -1,57 +1,57 @@
-export type WorkerLifecycleState = "spawning" | "trust_required" | "ready_for_prompt" | "running" | "finished" | "failed";
-export type StartupFailureClassification = "trust_required" | "prompt_misdelivery" | "prompt_acceptance_timeout" | "transport_dead" | "worker_crashed" | "unknown";
-
-export interface WorkerStartupEvidence {
-	lastLifecycleState: WorkerLifecycleState;
-	command: string;
-	promptSentAt?: string;
-	promptAccepted: boolean;
-	trustPromptDetected: boolean;
-	transportHealthy: boolean;
-	childProcessAlive: boolean;
-	elapsedMs: number;
-	classification: StartupFailureClassification;
-	stderrPreview?: string;
-}
-
-export function detectTrustPrompt(text: string): boolean {
-	const lowered = text.toLowerCase();
-	return lowered.includes("do you trust") || lowered.includes("trust this") || lowered.includes("untrusted") || lowered.includes("workspace trust") || lowered.includes("allow this folder");
-}
-
-export function classifyStartupFailure(evidence: Omit<WorkerStartupEvidence, "classification">): StartupFailureClassification {
-	if (!evidence.transportHealthy) return "transport_dead";
-	if (evidence.trustPromptDetected || evidence.lastLifecycleState === "trust_required") return "trust_required";
-	if (evidence.promptSentAt && !evidence.promptAccepted && evidence.childProcessAlive) return "prompt_acceptance_timeout";
-	if (evidence.promptSentAt && !evidence.promptAccepted && !evidence.childProcessAlive) return "worker_crashed";
-	if (evidence.stderrPreview?.toLowerCase().includes("command not found") || evidence.stderrPreview?.toLowerCase().includes("not recognized")) return "prompt_misdelivery";
-	if (!evidence.childProcessAlive && evidence.lastLifecycleState !== "finished") return "worker_crashed";
-	return "unknown";
-}
-
-export function createStartupEvidence(input: {
-	command: string;
-	startedAt: Date;
-	finishedAt?: Date;
-	promptSentAt?: Date;
-	promptAccepted?: boolean;
-	stderr?: string;
-	error?: string;
-	exitCode?: number | null;
-}): WorkerStartupEvidence {
-	const stderrPreview = (input.error || input.stderr || "").slice(0, 500) || undefined;
-	const trustPromptDetected = detectTrustPrompt(stderrPreview ?? "");
-	const childProcessAlive = input.exitCode === undefined || input.exitCode === null ? !input.finishedAt : false;
-	const base: Omit<WorkerStartupEvidence, "classification"> = {
-		lastLifecycleState: input.error || (input.exitCode !== undefined && input.exitCode !== null && input.exitCode !== 0) ? "failed" : input.finishedAt ? "finished" : "running",
-		command: input.command,
-		promptSentAt: input.promptSentAt?.toISOString(),
-		promptAccepted: input.promptAccepted ?? !input.error,
-		trustPromptDetected,
-		transportHealthy: !input.error || !/enoent|spawn|transport/i.test(input.error),
-		childProcessAlive,
-		elapsedMs: Math.max(0, (input.finishedAt ?? new Date()).getTime() - input.startedAt.getTime()),
-		stderrPreview,
-	};
-	return { ...base, classification: classifyStartupFailure(base) };
-}
+export type WorkerLifecycleState = "spawning" | "trust_required" | "ready_for_prompt" | "running" | "finished" | "failed";
+export type StartupFailureClassification = "trust_required" | "prompt_misdelivery" | "prompt_acceptance_timeout" | "transport_dead" | "worker_crashed" | "unknown";
+
+export interface WorkerStartupEvidence {
+	lastLifecycleState: WorkerLifecycleState;
+	command: string;
+	promptSentAt?: string;
+	promptAccepted: boolean;
+	trustPromptDetected: boolean;
+	transportHealthy: boolean;
+	childProcessAlive: boolean;
+	elapsedMs: number;
+	classification: StartupFailureClassification;
+	stderrPreview?: string;
+}
+
+export function detectTrustPrompt(text: string): boolean {
+	const lowered = text.toLowerCase();
+	return lowered.includes("do you trust") || lowered.includes("trust this") || lowered.includes("untrusted") || lowered.includes("workspace trust") || lowered.includes("allow this folder");
+}
+
+export function classifyStartupFailure(evidence: Omit<WorkerStartupEvidence, "classification">): StartupFailureClassification {
+	if (!evidence.transportHealthy) return "transport_dead";
+	if (evidence.trustPromptDetected || evidence.lastLifecycleState === "trust_required") return "trust_required";
+	if (evidence.promptSentAt && !evidence.promptAccepted && evidence.childProcessAlive) return "prompt_acceptance_timeout";
+	if (evidence.promptSentAt && !evidence.promptAccepted && !evidence.childProcessAlive) return "worker_crashed";
+	if (evidence.stderrPreview?.toLowerCase().includes("command not found") || evidence.stderrPreview?.toLowerCase().includes("not recognized")) return "prompt_misdelivery";
+	if (!evidence.childProcessAlive && evidence.lastLifecycleState !== "finished") return "worker_crashed";
+	return "unknown";
+}
+
+export function createStartupEvidence(input: {
+	command: string;
+	startedAt: Date;
+	finishedAt?: Date;
+	promptSentAt?: Date;
+	promptAccepted?: boolean;
+	stderr?: string;
+	error?: string;
+	exitCode?: number | null;
+}): WorkerStartupEvidence {
+	const stderrPreview = (input.error || input.stderr || "").slice(0, 500) || undefined;
+	const trustPromptDetected = detectTrustPrompt(stderrPreview ?? "");
+	const childProcessAlive = input.exitCode === undefined || input.exitCode === null ? !input.finishedAt : false;
+	const base: Omit<WorkerStartupEvidence, "classification"> = {
+		lastLifecycleState: input.error || (input.exitCode !== undefined && input.exitCode !== null && input.exitCode !== 0) ? "failed" : input.finishedAt ? "finished" : "running",
+		command: input.command,
+		promptSentAt: input.promptSentAt?.toISOString(),
+		promptAccepted: input.promptAccepted ?? !input.error,
+		trustPromptDetected,
+		transportHealthy: !input.error || !/enoent|spawn|transport/i.test(input.error),
+		childProcessAlive,
+		elapsedMs: Math.max(0, (input.finishedAt ?? new Date()).getTime() - input.startedAt.getTime()),
+		stderrPreview,
+	};
+	return { ...base, classification: classifyStartupFailure(base) };
+}