pi-crew 0.5.2 → 0.5.6

package/src/runtime/task-runner.ts

@@ -7,10 +7,11 @@ import type {
 	TeamRunManifest,
 	TeamTaskState,
 	UsageState,
+	VerificationEvidence,
 } from "../state/types.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent, appendEventFireAndForget } from "../state/event-log.ts";
+import { appendEvent, appendEventAsync, appendEventFireAndForget } from "../state/event-log.ts";
 import { saveRunManifest } from "../state/state-store.ts";
 import { createTaskClaim } from "../state/task-claims.ts";
 import {
@@ -38,6 +39,7 @@ import { runChildPi, type ChildPiLifecycleEvent } from "./child-pi.ts";
 import { buildTaskPacket } from "./task-packet.ts";
 import { executeHook, appendHookEvent } from "../hooks/registry.ts";
 import { createVerificationEvidence } from "./green-contract.ts";
+import { executeVerificationCommands, computeGreenLevelFromResults } from "./verification-gates.ts";
 import { createStartupEvidence } from "./worker-startup.ts";
 import { permissionForRole } from "./role-permission.ts";
 import { crewHooks } from "./crew-hooks.ts";
@@ -212,7 +214,7 @@ export async function runTeamTask(
 				"started",
 			));
 		upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
-		appendEvent(manifest.eventsPath, {
+		await appendEventAsync(manifest.eventsPath, {
 			type: "task.started",
 			runId: manifest.runId,
 			taskId: task.id,
@@ -244,6 +246,7 @@ export async function runTeamTask(
 						teamRole: { skills: input.teamRoleSkills },
 						step: input.step,
 						override: input.skillOverride,
+						runId: manifest.runId,  // ECC INSTINCT: Enable skill confidence tracking
 					})
 				: undefined;
 		const skillBlock = input.skillBlock ?? renderedSkills?.block;
@@ -420,6 +423,11 @@ export async function runTeamTask(
 					graceTurns: input.runtimeConfig?.graceTurns,
 					inheritContext: input.runtimeConfig?.inheritContext,
 					parentContext: input.parentContext,
+					excludeContextBash: input.runtimeConfig?.excludeContextBash,
+					sessionId: manifest.sessionId,
+					role: task.role,
+					runId: manifest.runId,
+					agentId: task.id,
 					onSpawn: (pid) => {
 						try {
 							({ task, tasks } = checkpointTask(
@@ -444,13 +452,13 @@ export async function runTeamTask(
 						}
 					},
 					onLifecycleEvent: (event: ChildPiLifecycleEvent) => {
-						appendEvent(manifest.eventsPath, {
+						void appendEventAsync(manifest.eventsPath, {
 							type: `worker.${event.type}` as const,
 							runId: manifest.runId,
 							taskId: task.id,
 							message: `Worker lifecycle: ${event.type}${event.error ? ` error=${event.error}` : ""}${event.exitCode != null ? ` exit=${event.exitCode}` : ""}`,
 							data: { ...event },
-						});
+						}).catch((error) => logInternalError("task-runner.lifecycle-event", error, `taskId=${task.id}, type=${event.type}`));
 					},
 					onStdoutLine: (line) => {
 						appendCrewAgentOutput(manifest, task.id, line);
@@ -590,7 +598,7 @@ export async function runTeamTask(
 							attemptStartedAt.toISOString(),
 						),
 					);
-					appendEvent(manifest.eventsPath, {
+					await appendEventAsync(manifest.eventsPath, {
 						type: "worker.cancelled",
 						runId: manifest.runId,
 						taskId: task.id,
@@ -863,7 +871,7 @@ export async function runTeamTask(
 				}
 			} else if (!error) {
 				noYield = true;
-				appendEvent(manifest.eventsPath, {
+				await appendEventAsync(manifest.eventsPath, {
 					type: "task.needs_attention",
 					runId: manifest.runId,
 					taskId: task.id,
@@ -896,6 +904,16 @@ export async function runTeamTask(
 				})
 			: undefined;
 
+		// Capture unified patches from edit tool results
+		const patchArtifact = parsedOutput?.patches?.length
+			? writeArtifact(manifest.artifactsRoot, {
+					kind: "patch",
+					relativePath: `patches/${task.id}.patch`,
+					content: parsedOutput.patches.join("\n---\n"),
+					producer: task.id,
+				})
+			: undefined;
+
 		const mutationGuardMode =
 			input.runtimeConfig?.completionMutationGuard ?? "warn";
 		const mutationGuard =
@@ -959,7 +977,7 @@ export async function runTeamTask(
 			if (outputText) {
 				outputValidation = validateWorkerOutput(task.role, outputText);
 				if (!outputValidation.valid) {
-					appendEvent(manifest.eventsPath, {
+					await appendEventAsync(manifest.eventsPath, {
 						type: "task.output_validation",
 						runId: manifest.runId,
 						taskId: task.id,
@@ -983,6 +1001,70 @@ export async function runTeamTask(
 			}
 		}
 
+		// --- ECC VERIFICATION_LOOP: Compute verification evidence before building task object ---
+		// Compute verification evidence (may be async if verification commands need to run)
+		const baseEvidence = createVerificationEvidence(
+			taskPacket.verification,
+			!error,
+			error
+				? `Task failed: ${error}`
+				: runtimeKind === "scaffold"
+					? "Safe scaffold mode; verification commands were not executed."
+					: `${runtimeKind} worker finished without reporting a verification failure.`,
+		);
+
+		// Only execute verification commands when:
+		// 1. Task completed successfully (no error)
+		// 2. Verification contract has commands
+		// 3. Not in scaffold mode (scaffold mode intentionally skips execution)
+		let verificationEvidence: VerificationEvidence = baseEvidence;
+		if (!error && runtimeKind !== "scaffold" && taskPacket.verification?.commands?.length) {
+			try {
+				const commandResults = await executeVerificationCommands(
+					taskPacket.verification,
+					task.cwd,
+					manifest.runId,
+					task.id,
+					manifest.artifactsRoot,
+					input.signal,
+				);
+
+				// Compute observed green level from results
+				const observedGreenLevel = computeGreenLevelFromResults(
+					commandResults,
+					taskPacket.verification.requiredGreenLevel,
+				);
+
+				// Determine satisfaction based on green level
+				const requiredLevel = taskPacket.verification.requiredGreenLevel;
+				const satisfied =
+					observedGreenLevel === "none" ? false :
+					observedGreenLevel === "targeted" ? requiredLevel === "targeted" :
+					observedGreenLevel === "package" ? ["targeted", "package"].includes(requiredLevel) :
+					observedGreenLevel === "workspace" ? ["targeted", "package", "workspace"].includes(requiredLevel) :
+					observedGreenLevel === "merge_ready";
+
+				const allPassed = commandResults.every(r => r.status === "passed");
+				const failedCount = commandResults.filter(r => r.status === "failed").length;
+
+				verificationEvidence = {
+					requiredGreenLevel: taskPacket.verification.requiredGreenLevel,
+					observedGreenLevel,
+					satisfied: satisfied && allPassed,
+					commands: commandResults,
+					notes: allPassed
+						? `${commandResults.length} verification commands passed`
+						: `${failedCount}/${commandResults.length} verification commands failed`,
+				};
+			} catch (execError) {
+				// On execution error, return base evidence with error note
+				verificationEvidence = {
+					...baseEvidence,
+					notes: `Verification execution failed: ${execError instanceof Error ? execError.message : String(execError)}`,
+				};
+			}
+		}
+
 		task = {
 			...task,
 			status: error ? "failed" : noYield ? "needs_attention" : "completed",
@@ -999,16 +1081,7 @@ export async function runTeamTask(
 						}
 					: task.agentProgress,
 			error,
-			verification: createVerificationEvidence(
-				taskPacket.verification,
-				!error,
-				error
-					? `Task failed: ${error}`
-					: runtimeKind === "scaffold"
-						? "Safe scaffold mode; verification commands were not executed."
-						: `${runtimeKind} worker finished without reporting a verification failure.`,
-			),
-			promptArtifact,
+			verification: verificationEvidence,
 			resultArtifact,
 			claim: undefined,
 			heartbeat: touchWorkerHeartbeat(
@@ -1105,6 +1178,7 @@ export async function runTeamTask(
 				...(transcriptArtifact ? [transcriptArtifact] : []),
 				...(diffArtifact ? [diffArtifact] : []),
 				...(diffStatArtifact ? [diffStatArtifact] : []),
+				...(patchArtifact ? [patchArtifact] : []),
 			],
 		};
 		saveRunManifest(manifest);
@@ -1117,7 +1191,7 @@ export async function runTeamTask(
 			cwd: manifest.cwd,
 		});
 		appendHookEvent(manifest, hookReport);
-		appendEvent(manifest.eventsPath, {
+		await appendEventAsync(manifest.eventsPath, {
 			type: error ? "task.failed" : noYield ? "task.needs_attention" : "task.completed",
 			runId: manifest.runId,
 			taskId: task.id,

package/src/runtime/team-runner.ts

@@ -6,7 +6,7 @@ import type { CrewRuntimeKind } from "./crew-agent-runtime.ts";
 import { resolveTaskRuntimeKind } from "./runtime-policy.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { executeHook, appendHookEvent } from "../hooks/registry.ts";
-import { appendEvent, appendEventFireAndForget } from "../state/event-log.ts";
+import { appendEvent, appendEventAsync, appendEventFireAndForget } from "../state/event-log.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 import type { ArtifactDescriptor, PolicyDecision, TeamRunManifest, TaskAttemptState, TeamTaskState } from "../state/types.ts";
 import { loadRunManifestById, saveRunManifest, saveRunManifestAsync, saveRunTasksAsync, updateRunStatus } from "../state/state-store.ts";
@@ -36,6 +36,7 @@ import { registerRunPromise, resolveRunPromise, rejectRunPromise } from "./run-t
 import { clearTrackedTaskUsage } from "./usage-tracker.ts";
 import { CrewCancellationError, buildSyntheticTerminalEvidence, cancellationReasonFromSignal } from "./cancellation.ts";
 import { effectivenessPolicyDecision, evaluateRunEffectiveness, formatRunEffectivenessLines } from "./effectiveness.ts";
+import { logInternalError } from "../utils/internal-error.ts";
 
 export interface ExecuteTeamRunInput {
 	manifest: TeamRunManifest;
@@ -279,7 +280,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		resolveRunPromise(manifest.runId, result);
 		cleanupUsage();
 		// Terminate live agents for this run — agents are done when the run ends.
-		void terminateLiveAgentsForRun(manifest.runId, "completed", appendEvent, manifest.eventsPath).catch(() => {});
+		void terminateLiveAgentsForRun(manifest.runId, "completed", appendEvent, manifest.eventsPath).catch((error) => logInternalError("team-runner.completed.terminate", error, `runId=${manifest.runId}`));
 
 		// Emit run completion hook (100% reliable, fire-and-forget)
 		crewHooks.emit({ type: "run_completed", timestamp: new Date().toISOString(), runId: manifest.runId, data: { status: result.manifest.status, taskCount: result.tasks.length } });
@@ -395,7 +396,7 @@ async function executeTeamRunCore(
 				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 } });
+			for (const taskId of cancelledTaskIds) await appendEventAsync(manifest.eventsPath, { type: "task.cancelled", runId: manifest.runId, taskId, message, data: { reason: cancelReason.code } });
 			manifest = updateRunStatus(manifest, "cancelled", message, { data: { reason: cancelReason.code, cancelledTaskIds } });
 			return { manifest, tasks };
 		}
@@ -429,7 +430,7 @@ async function executeTeamRunCore(
 			};
 			const preconditions = validatePhasePreconditions(wfMachine, wfContext);
 			if (!preconditions.ready) {
-				appendEvent(manifest.eventsPath, { type: "workflow.preconditions", runId: manifest.runId, message: `Workflow phase '${wfMachine.phases[wfMachine.currentPhaseIndex]?.name}' is missing inputs: ${preconditions.blocking.join(", ")}`, data: { phaseIndex: wfMachine.currentPhaseIndex, phaseName: wfMachine.phases[wfMachine.currentPhaseIndex]?.name, blocking: preconditions.blocking } });
+				await appendEventAsync(manifest.eventsPath, { type: "workflow.preconditions", runId: manifest.runId, message: `Workflow phase '${wfMachine.phases[wfMachine.currentPhaseIndex]?.name}' is missing inputs: ${preconditions.blocking.join(", ")}`, data: { phaseIndex: wfMachine.currentPhaseIndex, phaseName: wfMachine.phases[wfMachine.currentPhaseIndex]?.name, blocking: preconditions.blocking } });
 			} else {
 				// Advance the machine past completed phases.
 				while (wfMachine.currentPhaseIndex < wfMachine.phases.length && wfMachine.phases[wfMachine.currentPhaseIndex]?.status === "completed") {
@@ -441,7 +442,7 @@ async function executeTeamRunCore(
 		const readyRoles = effectiveReady.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, allowUnboundedConcurrency: input.limits?.allowUnboundedConcurrency, readyCount: effectiveReady.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 } });
+			await appendEventAsync(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 approvalPending = isPlanApprovalPending(manifest);
 		const readyIds = approvalPending ? effectiveReady : effectiveReady.slice(0, concurrency.selectedCount);
@@ -474,7 +475,7 @@ async function executeTeamRunCore(
 		}
 		const batchTasks = readyBatch.filter((task) => tasks.find((t) => t.id === task.id && t.status !== "skipped"));
 		if (batchTasks.length > 1) {
-			appendEvent(manifest.eventsPath, { type: "task.parallel_start", runId: manifest.runId, message: `Launching ${batchTasks.length} tasks in PARALLEL (concurrency=${concurrency.selectedCount}): ${batchTasks.map((t) => `${t.role}(${t.id})`).join(", ")}`, data: { taskIds: batchTasks.map((t) => t.id), roles: batchTasks.map((t) => t.role), concurrency: concurrency.selectedCount } });
+			await appendEventAsync(manifest.eventsPath, { type: "task.parallel_start", runId: manifest.runId, message: `Launching ${batchTasks.length} tasks in PARALLEL (concurrency=${concurrency.selectedCount}): ${batchTasks.map((t) => `${t.role}(${t.id})`).join(", ")}`, data: { taskIds: batchTasks.map((t) => t.id), roles: batchTasks.map((t) => t.role), concurrency: concurrency.selectedCount } });
 		}
 		const results = await mapConcurrent(
 			batchTasks,
@@ -519,7 +520,7 @@ async function executeTeamRunCore(
 						attemptId: (attempt) => `${manifest.runId}:${task.id}:attempt-${attempt}`,
 						onAttemptFailed: (attempt, error, delayMs, info) => {
 							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 } });
+							appendEventAsync(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 } }).catch((error) => logInternalError("team-runner.retry-attempt", error, `taskId=${task.id}`));
 							input.metricRegistry?.histogram("crew.task.retry_delay_ms", "Retry backoff delay, milliseconds").observe({ runId: manifest.runId, taskId: task.id }, delayMs);
 						},
 						onRetryGivenUp: (attempts, error, info) => {
@@ -536,7 +537,7 @@ async function executeTeamRunCore(
 						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" }, metadata: lastAttemptId ? { attemptId: lastAttemptId } : undefined });
+						appendEventAsync(freshManifest.eventsPath, { type: "task.cancelled", runId: freshManifest.runId, taskId: task.id, message: reason.message, data: { reason, phase: "retry" }, metadata: lastAttemptId ? { attemptId: lastAttemptId } : undefined }).catch((error) => logInternalError("team-runner.cancelled", error, `taskId=${task.id}`));
 						return { manifest: updateRunStatus(freshManifest, "cancelled", reason.message), tasks: cancelledTasks };
 					}
 					if (lastFailed) return lastFailed;
@@ -586,10 +587,10 @@ async function executeTeamRunCore(
 				const transition = transitionPhase(wfMachine, pi, phaseStatus, wfContext);
 				wfMachine = transition.machine;
 				if (transition.guardResult && !transition.guardResult.allowed) {
-					appendEvent(manifest.eventsPath, { type: "workflow.phase_guard_blocked", runId: manifest.runId, message: `Workflow phase '${phase.name}' guard blocked: ${transition.guardResult.reason ?? "unknown"}`, data: { phaseIndex: pi, phaseName: phase.name, reason: transition.guardResult.reason } });
+					await appendEventAsync(manifest.eventsPath, { type: "workflow.phase_guard_blocked", runId: manifest.runId, message: `Workflow phase '${phase.name}' guard blocked: ${transition.guardResult.reason ?? "unknown"}`, data: { phaseIndex: pi, phaseName: phase.name, reason: transition.guardResult.reason } });
 					break;
 				}
-				appendEvent(manifest.eventsPath, { type: phaseStatus === "failed" ? "workflow.phase_failed" : "workflow.phase_completed", runId: manifest.runId, message: `Workflow phase '${phase.name}' ${phaseStatus}.`, data: { phaseIndex: pi, phaseStatus } });
+				await appendEventAsync(manifest.eventsPath, { type: phaseStatus === "failed" ? "workflow.phase_failed" : "workflow.phase_completed", runId: manifest.runId, message: `Workflow phase '${phase.name}' ${phaseStatus}.`, data: { phaseIndex: pi, phaseStatus } });
 			}
 			wfMachine = { ...wfMachine, currentPhaseIndex: pi + 1 };
 		}
@@ -603,7 +604,7 @@ async function executeTeamRunCore(
 			await saveRunTasksAsync(manifest, tasks);
 			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
 			await saveRunManifestAsync(manifest);
-			appendEvent(manifest.eventsPath, { type: "run.cancelled", runId: manifest.runId, message, data: { reason, phase: "task-batch", cancelledResultRunId: cancelledResult?.manifest.runId } });
+			await appendEventAsync(manifest.eventsPath, { type: "run.cancelled", runId: manifest.runId, message, data: { reason, phase: "task-batch", cancelledResultRunId: cancelledResult?.manifest.runId } });
 			return { manifest, tasks };
 		}
 		queueIndex = buildTaskGraphIndex(tasks);
@@ -651,7 +652,7 @@ async function executeTeamRunCore(
 	const effectivenessDecision = effectivenessPolicyDecision(effectiveness);
 	if (effectivenessDecision) {
 		manifest = { ...manifest, policyDecisions: [...(manifest.policyDecisions ?? []), effectivenessDecision], updatedAt: new Date().toISOString() };
-		appendEvent(manifest.eventsPath, { type: "run.effectiveness", runId: manifest.runId, message: effectivenessDecision.message, data: { effectiveness, policyDecision: effectivenessDecision } });
+		await appendEventAsync(manifest.eventsPath, { type: "run.effectiveness", runId: manifest.runId, message: effectivenessDecision.message, data: { effectiveness, policyDecision: effectivenessDecision } });
 	}
 	const blockingDecision = manifest.policyDecisions?.find((item) => item.action === "block" || item.action === "escalate");
 	if (failed) {

package/src/runtime/tool-progress.ts

@@ -150,12 +150,18 @@ export interface ToolProgressDisplay {
  * Format tool progress for display
  */
 export function formatToolProgress(progress: CrewAgentProgress, maxContextTokens = 128000): ToolProgressDisplay {
-	const recentTools = progress.recentTools.map((t) => ({
+	const recentTools: Array<{
+		tool: string;
+		args?: string;
+		startedAt?: string;
+		endedAt?: string;
+		status: "running" | "done" | "error";
+	}> = progress.recentTools.map((t) => ({
 		tool: t.tool,
 		args: t.args,
 		startedAt: t.startedAt,
 		endedAt: t.endedAt,
-		status: t.endedAt ? "done" : "running" as const,
+		status: t.endedAt ? ("done" as const) : ("running" as const),
 	}));
 
 	// If there's a currentTool but no endedAt, it's still running
@@ -167,7 +173,8 @@ export function formatToolProgress(progress: CrewAgentProgress, maxContextTokens
 			tool: progress.currentTool,
 			args: progress.currentToolArgs,
 			startedAt: progress.currentToolStartedAt,
-			status: "running",
+			endedAt: undefined as string | undefined,
+			status: "running" as const,
 		});
 	}