pi-crew 0.1.45 → 0.1.49

package/src/runtime/task-runner/prompt-builder.ts

@@ -1,9 +1,24 @@
 import type { AgentConfig } from "../../agents/agent-config.ts";
-import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import type { TeamRunManifest, TeamTaskState, TaskOutputSchema } from "../../state/types.ts";
 import type { WorkflowStep } from "../../workflows/workflow-config.ts";
 import { buildMemoryBlock } from "../agent-memory.ts";
 import { permissionForRole } from "../role-permission.ts";
 import { renderTaskPacket } from "../task-packet.ts";
+import { buildWorkspaceTree } from "../workspace-tree.ts";
+
+/**
+ * When loadMode is "lean", emit a tool guidance block that tells the worker
+ * which tools to prefer.  This is a prompt-level hint only — actual tool
+ * filtering at the Pi level is a future optimisation (Phase 3.2+).
+ */
+export function toolGuidanceBlock(agent?: AgentConfig): string {
+	if (!agent || agent.loadMode !== "lean" || !agent.defaultTools?.length) return "";
+	return [
+		"# Tool Guidance",
+		`This role uses a focused tool set. Preferred tools: ${agent.defaultTools.join(", ")}.`,
+		"Other tools are available but should only be used when explicitly needed for the task.",
+	].join("\n");
+}
 
 function readOnlyRoleInstructions(role: string): string {
 	if (permissionForRole(role) !== "read_only") return "";
@@ -36,9 +51,45 @@ function inputDependencyContext(task: TeamTaskState): string {
 	return (task as TeamTaskState & { dependencyContextText?: string }).dependencyContextText ?? "";
 }
 
-export function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState, agent?: AgentConfig): string {
+export function renderOutputSchemaBlock(outputSchema: TaskOutputSchema): string {
+	const lines: string[] = ["## Expected Output Format"];
+	lines.push(`Your final output must be ${outputSchema.format}.`);
+	if (outputSchema.description) {
+		lines.push(outputSchema.description);
+	}
+	if (outputSchema.format === "json" && outputSchema.schema) {
+		lines.push("The output must match this schema:");
+		lines.push("```json");
+		lines.push(JSON.stringify(outputSchema.schema, null, 2));
+		lines.push("```");
+	}
+	if (outputSchema.example) {
+		lines.push("Example output:");
+		lines.push("```");
+		lines.push(outputSchema.example);
+		lines.push("```");
+	}
+	return lines.join("\n");
+}
+
+export interface RenderedTaskPrompt {
+	/** Stable sections that rarely change between tasks of the same role/cwd. */
+	stablePrefix: string;
+	/** Dynamic sections that change per-task (goal, task packet, skills, dependency context). */
+	dynamicSuffix: string;
+	/** Full rendered prompt (stablePrefix + dynamicSuffix). */
+	full: string;
+}
+
+export async function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState, agent?: AgentConfig, skillBlock = ""): Promise<RenderedTaskPrompt> {
 	const memoryBlock = agent?.memory ? buildMemoryBlock(agent.name, agent.memory, task.cwd, Boolean(agent.tools?.some((tool) => tool === "write" || tool === "edit"))) : "";
-	return [
+
+	// Build workspace tree for stable context
+	const tree = await buildWorkspaceTree(task.cwd);
+	const treeBlock = tree.rendered ? `# Workspace Structure\n${tree.rendered}` : "";
+
+	// Stable prefix: role instructions, coordination, workspace tree — rarely changes
+	const stablePrefix = [
 		"# pi-crew Worker Runtime Context",
 		`Run ID: ${manifest.runId}`,
 		`Team: ${manifest.team}`,
@@ -50,11 +101,6 @@ export function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep,
 		`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.",
@@ -65,11 +111,29 @@ export function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep,
 		"",
 		coordinationBridgeInstructions(task),
 		"",
+		treeBlock,
+		"",
+		toolGuidanceBlock(agent),
+	].filter(Boolean).join("\n");
+
+	// Dynamic suffix: goal, step, skills, task packet, dependency context, memory — changes per task
+	const dynamicSuffix = [
+		`Goal:\n${manifest.goal}`,
+		"",
+		`Step: ${step.id}`,
+		`Role: ${step.role}`,
+		"",
+		skillBlock,
+		"",
 		task.taskPacket ? renderTaskPacket(task.taskPacket) : "",
 		"",
 		(inputDependencyContext(task) || ""),
 		memoryBlock,
+		task.taskPacket?.outputSchema ? renderOutputSchemaBlock(task.taskPacket.outputSchema) : "",
 		"Task:",
 		step.task.replaceAll("{goal}", manifest.goal),
 	].join("\n");
+
+	const full = [stablePrefix, "", dynamicSuffix].join("\n");
+	return { stablePrefix, dynamicSuffix, full };
 }

package/src/runtime/task-runner/prompt-pipeline.ts

@@ -0,0 +1,64 @@
+import * as path from "node:path";
+import type { ArtifactDescriptor } from "../../state/types.ts";
+
+export type WorkerPromptPipelineStageName =
+	| "task-packet-built"
+	| "dependency-context-collected"
+	| "skills-rendered-or-disabled"
+	| "capability-inventory-recorded"
+	| "coordination-bridge-attached"
+	| "prompt-rendered"
+	| "prompt-artifact-written";
+
+export interface WorkerPromptPipelineStage {
+	name: WorkerPromptPipelineStageName;
+	references: string[];
+	details?: Record<string, string | number | boolean>;
+}
+
+export interface WorkerPromptPipelineArtifact {
+	schemaVersion: 1;
+	taskId: string;
+	stages: WorkerPromptPipelineStage[];
+}
+
+function artifactReference(artifactsRoot: string, artifact?: ArtifactDescriptor): string | undefined {
+	if (!artifact) return undefined;
+	const root = path.resolve(artifactsRoot);
+	const target = path.resolve(artifact.path);
+	const relative = path.relative(root, target);
+	if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return undefined;
+	return relative.replaceAll("\\", "/");
+}
+
+export interface BuildWorkerPromptPipelineInput {
+	artifactsRoot: string;
+	taskId: string;
+	promptArtifact: ArtifactDescriptor;
+	inputsArtifact: ArtifactDescriptor;
+	skillArtifact?: ArtifactDescriptor;
+	capabilityArtifact: ArtifactDescriptor;
+	coordinationArtifact: ArtifactDescriptor;
+	skillInstructionCount: number;
+	skillsDisabled: boolean;
+}
+
+export function buildWorkerPromptPipeline(input: BuildWorkerPromptPipelineInput): WorkerPromptPipelineArtifact {
+	return {
+		schemaVersion: 1,
+		taskId: input.taskId,
+		stages: [
+			{ name: "task-packet-built", references: [`metadata/${input.taskId}.task-packet.json`] },
+			{ name: "dependency-context-collected", references: [artifactReference(input.artifactsRoot, input.inputsArtifact) ?? `metadata/${input.taskId}.inputs.json`] },
+			{
+				name: "skills-rendered-or-disabled",
+				references: input.skillArtifact ? [artifactReference(input.artifactsRoot, input.skillArtifact) ?? `metadata/${input.taskId}.skills.md`] : [],
+				details: { disabled: input.skillsDisabled, skillInstructionCount: input.skillInstructionCount },
+			},
+			{ name: "capability-inventory-recorded", references: [artifactReference(input.artifactsRoot, input.capabilityArtifact) ?? `metadata/${input.taskId}.capabilities.json`] },
+			{ name: "coordination-bridge-attached", references: [artifactReference(input.artifactsRoot, input.coordinationArtifact) ?? `metadata/${input.taskId}.coordination-bridge.md`] },
+			{ name: "prompt-rendered", references: [] },
+			{ name: "prompt-artifact-written", references: [artifactReference(input.artifactsRoot, input.promptArtifact) ?? `prompts/${input.taskId}.md`] },
+		],
+	};
+}

package/src/runtime/task-runner/run-projection.ts

@@ -0,0 +1,104 @@
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import type { MailboxMessage } from "../../state/mailbox.ts";
+import type { ArtifactDescriptor } from "../../state/types.ts";
+
+export interface RunProjectionSource {
+	kind: "events" | "mailbox" | "artifacts" | "ui_metadata" | "runtime_metadata";
+	bounded: boolean;
+	reference?: string;
+}
+
+export interface RunProjectionResult {
+	sources: RunProjectionSource[];
+	summary: string;
+	injectedAsContext: boolean;
+}
+
+/**
+ * Transform run context before a worker starts.
+ * Builds a bounded projection of durable history that will be available
+ * to the worker as reference context, not as instructions.
+ *
+ * Rules:
+ * - Durable history retains events, mailbox, artifacts, UI/runtime metadata.
+ * - Worker prompt gets a bounded projection (truncated/summarized).
+ * - UI/runtime events are not prompt text unless explicitly selected.
+ */
+export function transformRunContextBeforeWorkerStart(input: {
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	pendingMailbox: MailboxMessage[];
+	artifacts: ArtifactDescriptor[];
+	maxEvents?: number;
+	maxMailboxMessages?: number;
+	maxArtifactRefs?: number;
+}): RunProjectionResult {
+	const maxEvents = input.maxEvents ?? 20;
+	const maxMailbox = input.maxMailboxMessages ?? 10;
+	const maxArtifacts = input.maxArtifactRefs ?? 15;
+
+	const sources: RunProjectionSource[] = [];
+	const lines: string[] = [];
+
+	// Project a bounded slice of task history
+	const completedTasks = input.tasks.filter((t) => t.status === "completed" || t.status === "failed");
+	if (completedTasks.length > 0) {
+		const tasks = completedTasks.slice(0, maxEvents);
+		sources.push({ kind: "events", bounded: true, reference: `tasks:${tasks.length}/${completedTasks.length}` });
+		lines.push(`Previous tasks (${tasks.length}/${completedTasks.length}):`);
+		for (const task of tasks) {
+			lines.push(`- ${task.id}: ${task.status}${task.error ? ` (${task.error})` : ""}`);
+		}
+	}
+
+	// Project pending mailbox that is relevant to this worker
+	if (input.pendingMailbox.length > 0) {
+		const messages = input.pendingMailbox.slice(0, maxMailbox);
+		sources.push({ kind: "mailbox", bounded: true, reference: `mailbox:${messages.length}/${input.pendingMailbox.length}` });
+		lines.push(`Pending messages (${messages.length}/${input.pendingMailbox.length}):`);
+		for (const msg of messages) {
+			lines.push(`- ${msg.kind ?? "message"}: ${msg.body.slice(0, 100)}`);
+		}
+	}
+
+	// Project artifact references (not content)
+	if (input.artifacts.length > 0) {
+		const artifacts = input.artifacts.slice(0, maxArtifacts);
+		sources.push({ kind: "artifacts", bounded: true, reference: `artifacts:${artifacts.length}/${input.artifacts.length}` });
+		lines.push(`Available artifacts (${artifacts.length}/${input.artifacts.length}):`);
+		for (const art of artifacts) {
+			lines.push(`- ${art.kind} (${art.producer})`);
+		}
+	}
+
+	// Metadata markers — not injected as prompt instructions
+	sources.push({ kind: "ui_metadata", bounded: false, reference: "excluded_from_prompt" });
+	sources.push({ kind: "runtime_metadata", bounded: false, reference: "excluded_from_prompt" });
+
+	return {
+		sources,
+		summary: lines.join("\n"),
+		injectedAsContext: true,
+	};
+}
+
+/**
+ * Convert run history to a bounded worker prompt section.
+ * Same logic as transformRunContextBeforeWorkerStart but returns
+ * the prompt text directly for embedding in the worker prompt.
+ */
+export function convertRunHistoryToWorkerPrompt(input: {
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	pendingMailbox: MailboxMessage[];
+	artifacts: ArtifactDescriptor[];
+}): string {
+	const projection = transformRunContextBeforeWorkerStart(input);
+	if (!projection.summary) return "";
+	return [
+		"## Run Context (bounded projection)",
+		projection.summary,
+		"",
+		`Projection sources: ${projection.sources.map((s) => s.kind).join(", ")}`,
+	].join("\n");
+}

package/src/runtime/task-runner.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
-import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
+import type { ArtifactDescriptor, OperationTerminalEvidence, TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
 import { saveRunManifest } from "../state/state-store.ts";
@@ -13,21 +13,33 @@ 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";
 import { coordinationBridgeInstructions, renderTaskPrompt } from "./task-runner/prompt-builder.ts";
+import { buildWorkerPromptPipeline } from "./task-runner/prompt-pipeline.ts";
+import { buildWorkerCapabilityInventory } from "./task-runner/capabilities.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";
 import { evaluateCompletionMutationGuard } from "./completion-guard.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;
@@ -43,14 +55,24 @@ export interface TaskRunnerInput {
 	parentModel?: unknown;
 	modelRegistry?: unknown;
 	modelOverride?: string;
+	teamRoleModel?: string;
+	teamRoleSkills?: string[] | false;
+	skillOverride?: string[] | false;
 	limits?: CrewLimitsConfig;
 	dependencyContextText?: string;
+	skillBlock?: string;
+	skillNames?: string[];
+	skillPaths?: string[];
 	/** Optional callback for JSON events from child Pi. Used for overflow recovery tracking. */
 	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 }
 
 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 });
@@ -67,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");
@@ -74,9 +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);
+	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`,
@@ -93,9 +125,17 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 	let parsedOutput: ParsedPiJsonOutput | undefined;
 	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);
+	const skillArtifact = skillBlock ? writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.skills.md`,
+		content: [`Selected skills: ${skillNames?.join(", ") ?? "(none)"}`, `Skill paths passed to child Pi: ${(skillPaths ?? []).length}`, "", skillBlock, ""].join("\n"),
+		producer: task.id,
+	}) : undefined;
 	const coordinationArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "metadata",
 		relativePath: `metadata/${task.id}.coordination-bridge.md`,
@@ -103,7 +143,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		producer: task.id,
 	});
 	if (runtimeKind === "child-process") {
-		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 modelRoutingPlan = buildConfiguredModelRouting({ overrideModel: input.modelOverride, stepModel: input.step.model, teamRoleModel: input.teamRoleModel, agentModel: input.agent.model, fallbackModels: input.agent.fallbackModels, parentModel: input.parentModel, modelRegistry: input.modelRegistry, cwd: task.cwd });
 		const candidates = modelRoutingPlan.candidates;
 		const attemptModels = candidates.length > 0 ? candidates : [undefined];
 		const logs: string[] = [];
@@ -151,6 +191,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				signal: input.signal,
 				transcriptPath,
 				maxDepth: input.limits?.maxTaskDepth,
+				skillPaths,
 				onSpawn: (pid) => {
 					({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));
 				},
@@ -165,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 {
@@ -181,6 +228,13 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 					persistChildProgress(event);
 				},
 			});
+			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") {
+				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;
@@ -238,7 +292,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		({ task, tasks } = checkpointTask(manifest, tasks, task, "artifact-written"));
 	} else if (runtimeKind === "live-session") {
 		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 });
+		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, modelOverride: input.modelOverride, teamRoleModel: input.teamRoleModel });
 		task = live.task;
 		tasks = live.tasks;
 		startupEvidence = live.startupEvidence;
@@ -262,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`,
@@ -295,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",
@@ -310,6 +394,8 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		resultArtifact,
 		claim: undefined,
 		heartbeat: touchWorkerHeartbeat(task.heartbeat ?? createWorkerHeartbeat(task.id), { alive: false }),
+		workerExitStatus: terminalEvidence.at(-1)?.exitStatus,
+		terminalEvidence: terminalEvidence.length ? [...(task.terminalEvidence ?? []), ...terminalEvidence] : task.terminalEvidence,
 		...(logArtifact ? { logArtifact } : {}),
 		...(transcriptArtifact ? { transcriptArtifact } : {}),
 	};
@@ -339,10 +425,34 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: `${JSON.stringify({ role: task.role, permissionMode }, null, 2)}\n`,
 		producer: task.id,
 	});
-	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, inputsArtifact, coordinationArtifact, packetArtifact, verificationArtifact, startupArtifact, permissionArtifact, ...(sharedOutputArtifact ? [sharedOutputArtifact] : []), ...(logArtifact ? [logArtifact] : []), ...(transcriptArtifact ? [transcriptArtifact] : []), ...(diffArtifact ? [diffArtifact] : []), ...(diffStatArtifact ? [diffStatArtifact] : [])] };
+	const capabilityArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.capabilities.json`,
+		content: `${JSON.stringify(buildWorkerCapabilityInventory({ taskId: task.id, role: task.role, agent: input.agent, runtime: runtimeKind, permissionMode, skillNames, skillPaths, skillsDisabled: input.skillOverride === false || input.teamRoleSkills === false, modelOverride: input.modelOverride, teamRoleModel: input.teamRoleModel, stepModel: input.step.model }), null, 2)}\n`,
+		producer: task.id,
+	});
+	const promptPipelineArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.prompt-pipeline.json`,
+		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,
+	});
+	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();
+	}
 }