pi-crew 0.1.5 → 0.1.7

package/src/runtime/task-graph-scheduler.ts

@@ -0,0 +1,107 @@
+import type { TaskGraphNode, TeamTaskState } from "../state/types.ts";
+
+export interface TaskGraphSchedulerSnapshot {
+	ready: string[];
+	blocked: string[];
+	running: string[];
+	done: string[];
+	failed: string[];
+	cancelled: string[];
+}
+
+function completedStepIds(tasks: TeamTaskState[]): Set<string> {
+	return new Set(tasks.filter((task) => task.status === "completed").map((task) => task.stepId).filter((id): id is string => id !== undefined));
+}
+
+function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
+	return new Map(tasks.map((task) => [task.id, task]));
+}
+
+function stepIdToTaskId(tasks: TeamTaskState[]): Map<string, string> {
+	return new Map(tasks.map((task) => [task.stepId, task.id]).filter((entry): entry is [string, string] => entry[0] !== undefined));
+}
+
+function dependencySatisfied(task: TeamTaskState, doneStepIds: Set<string>, idMap: Map<string, TeamTaskState>, stepMap: Map<string, string>): boolean {
+	return task.dependsOn.every((dependency) => {
+		if (doneStepIds.has(dependency)) return true;
+		const taskId = stepMap.get(dependency) ?? dependency;
+		return idMap.get(taskId)?.status === "completed";
+	});
+}
+
+function withQueue(task: TeamTaskState, queue: TaskGraphNode["queue"]): TeamTaskState {
+	return task.graph ? { ...task, graph: { ...task.graph, queue } } : task;
+}
+
+export function refreshTaskGraphQueues(tasks: TeamTaskState[]): TeamTaskState[] {
+	const doneSteps = completedStepIds(tasks);
+	const ids = taskById(tasks);
+	const steps = stepIdToTaskId(tasks);
+	return tasks.map((task) => {
+		if (task.status === "queued") return withQueue(task, dependencySatisfied(task, doneSteps, ids, steps) ? "ready" : "blocked");
+		if (task.status === "running") return withQueue(task, "running");
+		if (task.status === "completed" || task.status === "skipped") return withQueue(task, "done");
+		return withQueue(task, "blocked");
+	});
+}
+
+export function getReadyTasks(tasks: TeamTaskState[], maxCount = 1): TeamTaskState[] {
+	return refreshTaskGraphQueues(tasks).filter((task) => task.status === "queued" && task.graph?.queue === "ready").slice(0, Math.max(0, maxCount));
+}
+
+export function markTaskRunning(tasks: TeamTaskState[], taskId: string, now = new Date()): TeamTaskState[] {
+	return refreshTaskGraphQueues(tasks).map((task) => task.id === taskId ? withQueue({ ...task, status: "running", startedAt: task.startedAt ?? now.toISOString() }, "running") : task);
+}
+
+export function markTaskDone(tasks: TeamTaskState[], taskId: string, now = new Date()): TeamTaskState[] {
+	return refreshTaskGraphQueues(tasks.map((task) => task.id === taskId ? { ...task, status: "completed", finishedAt: task.finishedAt ?? now.toISOString() } : task));
+}
+
+export function cancelTaskSubtree(tasks: TeamTaskState[], rootTaskId: string, reason = "Cancelled by task graph scheduler.", now = new Date()): TeamTaskState[] {
+	const ids = taskById(tasks);
+	const toCancel = new Set<string>();
+	const stack = [rootTaskId];
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current || toCancel.has(current)) continue;
+		toCancel.add(current);
+		const task = ids.get(current);
+		for (const child of task?.graph?.children ?? []) stack.push(child);
+	}
+	return refreshTaskGraphQueues(tasks.map((task) => {
+		if (!toCancel.has(task.id)) return task;
+		if (task.status === "completed") return task;
+		return { ...task, status: "cancelled", error: reason, finishedAt: task.finishedAt ?? now.toISOString() };
+	}));
+}
+
+export function failTaskAndBlockChildren(tasks: TeamTaskState[], rootTaskId: string, reason: string, now = new Date()): TeamTaskState[] {
+	const ids = taskById(tasks);
+	const blocked = new Set<string>();
+	const root = ids.get(rootTaskId);
+	const stack = [...(root?.graph?.children ?? [])];
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current || blocked.has(current)) continue;
+		blocked.add(current);
+		const task = ids.get(current);
+		for (const child of task?.graph?.children ?? []) stack.push(child);
+	}
+	return refreshTaskGraphQueues(tasks.map((task) => {
+		if (task.id === rootTaskId) return { ...task, status: "failed", error: reason, finishedAt: task.finishedAt ?? now.toISOString() };
+		if (blocked.has(task.id) && task.status === "queued") return { ...task, status: "skipped", error: `Blocked by failed task '${rootTaskId}'.`, finishedAt: task.finishedAt ?? now.toISOString() };
+		return task;
+	}));
+}
+
+export function taskGraphSnapshot(tasks: TeamTaskState[]): TaskGraphSchedulerSnapshot {
+	const refreshed = refreshTaskGraphQueues(tasks);
+	return {
+		ready: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "ready").map((task) => task.id),
+		blocked: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "blocked").map((task) => task.id),
+		running: refreshed.filter((task) => task.status === "running").map((task) => task.id),
+		done: refreshed.filter((task) => task.status === "completed" || task.status === "skipped").map((task) => task.id),
+		failed: refreshed.filter((task) => task.status === "failed").map((task) => task.id),
+		cancelled: refreshed.filter((task) => task.status === "cancelled").map((task) => task.id),
+	};
+}

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

@@ -0,0 +1,106 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { writeArtifact } from "../state/artifact-store.ts";
+import type { WorkflowStep } from "../workflows/workflow-config.ts";
+
+export interface DependencyOutputContext {
+	dependencies: Array<{ taskId: string; title: string; status: string; result?: string; resultPath?: string }>;
+	sharedReads: Array<{ name: string; path: string; content: string }>;
+}
+
+function readIfSmall(filePath: string, maxBytes = 24_000): string | undefined {
+	try {
+		const stat = fs.statSync(filePath);
+		if (stat.size > maxBytes) return `${fs.readFileSync(filePath, "utf-8").slice(0, maxBytes)}\n\n...(truncated ${stat.size - maxBytes} bytes)`;
+		return fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return undefined;
+	}
+}
+
+export function sharedPath(manifest: TeamRunManifest, name: string): string {
+	return path.join(manifest.artifactsRoot, "shared", name);
+}
+
+export function collectDependencyOutputContext(manifest: TeamRunManifest, tasks: TeamTaskState[], task: TeamTaskState, step: WorkflowStep): DependencyOutputContext {
+	const byStep = new Map(tasks.map((item) => [item.stepId, item]).filter((entry): entry is [string, TeamTaskState] => Boolean(entry[0])));
+	const byId = new Map(tasks.map((item) => [item.id, item]));
+	const dependencies = task.dependsOn.map((dep) => byStep.get(dep) ?? byId.get(dep)).filter((item): item is TeamTaskState => Boolean(item)).map((item) => ({
+		taskId: item.id,
+		title: item.title,
+		status: item.status,
+		resultPath: item.resultArtifact?.path,
+		result: item.resultArtifact ? readIfSmall(item.resultArtifact.path) : undefined,
+	}));
+	const sharedReads = (step.reads === false ? [] : step.reads ?? []).map((name) => {
+		const filePath = sharedPath(manifest, name);
+		return { name, path: filePath, content: readIfSmall(filePath) ?? "" };
+	}).filter((item) => item.content.trim().length > 0);
+	return { dependencies, sharedReads };
+}
+
+export function renderDependencyOutputContext(context: DependencyOutputContext): string {
+	const parts: string[] = [];
+	if (context.dependencies.length) {
+		parts.push("# Dependency Outputs", "");
+		for (const dep of context.dependencies) {
+			parts.push(`## ${dep.taskId} (${dep.title})`, `Status: ${dep.status}`, dep.resultPath ? `Result artifact: ${dep.resultPath}` : "", "", dep.result?.trim() || "(no result output)", "");
+		}
+	}
+	if (context.sharedReads.length) {
+		parts.push("# Shared Run Context Reads", "");
+		for (const read of context.sharedReads) parts.push(`## shared/${read.name}`, `Path: ${read.path}`, "", read.content.trim(), "");
+	}
+	return parts.join("\n").trim();
+}
+
+export function writeTaskSharedOutput(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState): ArtifactDescriptor | undefined {
+	if (step.output === false) return undefined;
+	const name = step.output || `${task.id}.md`;
+	const source = task.resultArtifact ? readIfSmall(task.resultArtifact.path, 80_000) : undefined;
+	if (!source) return undefined;
+	return writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `shared/${name}`,
+		producer: task.id,
+		content: source.endsWith("\n") ? source : `${source}\n`,
+	});
+}
+
+export function writeTaskInputsArtifact(manifest: TeamRunManifest, task: TeamTaskState, context: DependencyOutputContext): ArtifactDescriptor {
+	return writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.inputs.json`,
+		producer: task.id,
+		content: `${JSON.stringify(context, null, 2)}\n`,
+	});
+}
+
+export function aggregateTaskOutputs(tasks: TeamTaskState[]): string {
+	return tasks.map((task, index) => {
+		const body = task.resultArtifact ? readIfSmall(task.resultArtifact.path, 40_000) : undefined;
+		const hasBody = Boolean(body?.trim());
+		const expectedMissing = task.resultArtifact && !fs.existsSync(task.resultArtifact.path);
+		const status = task.status === "skipped"
+			? "SKIPPED"
+			: task.status === "failed"
+				? `FAILED${task.exitCode !== undefined ? ` (exit code ${task.exitCode ?? "null"})` : ""}${task.error ? `: ${task.error}` : ""}`
+				: expectedMissing
+					? `EMPTY OUTPUT (expected result artifact missing: ${task.resultArtifact?.path})`
+					: !hasBody
+						? "EMPTY OUTPUT (no textual response returned)"
+						: task.status.toUpperCase();
+		return [
+			`=== Task ${index + 1}: ${task.id} (${task.agent}) ===`,
+			`Status: ${status}`,
+			task.role ? `Role: ${task.role}` : "",
+			task.resultArtifact?.path ? `Result artifact: ${task.resultArtifact.path}` : "",
+			task.logArtifact?.path ? `Log artifact: ${task.logArtifact.path}` : "",
+			task.transcriptArtifact?.path ? `Transcript: ${task.transcriptArtifact.path}` : "",
+			task.usage ? `Usage: ${JSON.stringify(task.usage)}` : "",
+			"",
+			hasBody ? body!.trim() : status,
+		].filter(Boolean).join("\n");
+	}).join("\n\n");
+}

package/src/runtime/task-runner.ts

@@ -1,5 +1,7 @@
+import * as fs from "node:fs";
 import type { AgentConfig } from "../agents/agent-config.ts";
-import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import type { CrewLimitsConfig } 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 { saveRunManifest, saveRunTasks } from "../state/state-store.ts";
@@ -12,6 +14,12 @@ import { parsePiJsonOutput, type ParsedPiJsonOutput } from "./pi-json-output.ts"
 import { runChildPi } from "./child-pi.ts";
 import { buildTaskPacket, renderTaskPacket } from "./task-packet.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 { parseSessionUsage } from "./session-usage.ts";
+import type { CrewAgentProgress } from "./crew-agent-runtime.ts";
 
 export interface TaskRunnerInput {
 	manifest: TeamRunManifest;
@@ -21,6 +29,32 @@ export interface TaskRunnerInput {
 	agent: AgentConfig;
 	signal?: AbortSignal;
 	executeWorkers: boolean;
+	limits?: CrewLimitsConfig;
+	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): string {
@@ -47,21 +81,139 @@ function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: T
 		"- 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) || ""),
 		"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 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 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);
 	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 });
+	const dependencyContext = collectDependencyOutputContext(manifest, input.tasks, input.task, input.step);
+	const dependencyContextText = input.dependencyContextText ?? renderDependencyOutputContext(dependencyContext);
 	let task: TeamTaskState = {
 		...input.task,
 		cwd: workspace.cwd,
@@ -71,10 +223,14 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		startedAt: new Date().toISOString(),
 		claim: createTaskClaim(`task-runner:${input.task.id}`),
 		heartbeat: createWorkerHeartbeat(input.task.id),
-	};
+		agentProgress: input.task.agentProgress ?? emptyCrewAgentProgress(),
+		...(dependencyContextText ? { dependencyContextText } : {}),
+	} as TeamTaskState;
 	let tasks = updateTask(input.tasks, task);
 	saveRunTasks(manifest, tasks);
+	upsertCrewAgent(manifest, recordFromTask(manifest, task, input.executeWorkers ? "child-process" : "scaffold"));
 	appendEvent(manifest.eventsPath, { type: "task.started", runId: manifest.runId, taskId: task.id, data: { role: task.role, agent: task.agent, cwd: task.cwd, worktreePath: workspace.worktreePath, worktreeBranch: workspace.branch, worktreeReused: workspace.reused } });
+	const permissionMode = permissionForRole(task.role);
 
 	const prompt = renderTaskPrompt(manifest, input.step, task);
 	const promptArtifact = writeArtifact(manifest.artifactsRoot, {
@@ -86,11 +242,20 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 
 	let resultArtifact: ArtifactDescriptor;
 	let logArtifact: ArtifactDescriptor | undefined;
+	let transcriptArtifact: ArtifactDescriptor | undefined;
 	let exitCode: number | null = 0;
 	let error: string | undefined;
 	let modelAttempts: ModelAttemptSummary[] | undefined;
 	let parsedOutput: ParsedPiJsonOutput | undefined;
 
+	let startupEvidence = createStartupEvidence({ command: input.executeWorkers ? "pi" : "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 coordinationArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.coordination-bridge.md`,
+		content: `${coordinationBridgeInstructions(task)}\n`,
+		producer: task.id,
+	});
 	if (input.executeWorkers) {
 		const candidates = buildModelCandidates(input.step.model ?? input.agent.model, input.agent.fallbackModels, undefined);
 		const attemptModels = candidates.length > 0 ? candidates : [input.step.model ?? input.agent.model];
@@ -98,9 +263,28 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		let finalStdout = "";
 		let finalStderr = "";
 		modelAttempts = [];
+		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
 		for (let i = 0; i < attemptModels.length; i++) {
 			const model = attemptModels[i];
-			const childResult = await runChildPi({ cwd: task.cwd, task: prompt, agent: input.agent, model, signal: input.signal });
+			const attemptStartedAt = new Date();
+			const childResult = await runChildPi({
+				cwd: task.cwd,
+				task: prompt,
+				agent: input.agent,
+				model,
+				signal: input.signal,
+				transcriptPath,
+				maxDepth: input.limits?.maxTaskDepth,
+				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);
+					upsertCrewAgent(manifest, recordFromTask(manifest, task, "child-process"));
+					appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { event } });
+				},
+			});
+			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;
 			finalStderr = childResult.stderr;
@@ -126,6 +310,22 @@ 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 sessionUsage = parseSessionUsage(transcriptPath);
+		const effectiveUsage = parsedOutput?.usage ?? sessionUsage;
+		if (effectiveUsage) {
+			parsedOutput = { ...(parsedOutput ?? { jsonEvents: 0, textEvents: [] }), usage: effectiveUsage };
+			task = { ...task, usage: effectiveUsage, agentProgress: applyUsageToProgress(task.agentProgress, effectiveUsage) };
+			tasks = updateTask(tasks, task);
+			upsertCrewAgent(manifest, recordFromTask(manifest, task, "child-process"));
+		}
+		if (fs.existsSync(transcriptPath)) {
+			transcriptArtifact = writeArtifact(manifest.artifactsRoot, {
+				kind: "log",
+				relativePath: `transcripts/${task.id}.jsonl`,
+				content: fs.readFileSync(transcriptPath, "utf-8"),
+				producer: task.id,
+			});
+		}
 	} else {
 		resultArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "result",
@@ -155,6 +355,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		modelAttempts,
 		usage: parsedOutput?.usage,
 		jsonEvents: parsedOutput?.jsonEvents,
+		agentProgress: error && task.agentProgress?.currentTool ? { ...task.agentProgress, failedTool: task.agentProgress.currentTool } : task.agentProgress,
 		error,
 		verification: createVerificationEvidence(taskPacket.verification, !error, error ? `Task failed: ${error}` : input.executeWorkers ? "Worker finished without reporting a verification failure." : "Safe scaffold mode; verification commands were not executed."),
 		promptArtifact,
@@ -162,6 +363,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		claim: undefined,
 		heartbeat: touchWorkerHeartbeat(task.heartbeat ?? createWorkerHeartbeat(task.id), { alive: false }),
 		...(logArtifact ? { logArtifact } : {}),
+		...(transcriptArtifact ? { transcriptArtifact } : {}),
 	};
 	tasks = updateTask(tasks, task);
 	const packetArtifact = writeArtifact(manifest.artifactsRoot, {
@@ -176,9 +378,23 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: `${JSON.stringify(task.verification, null, 2)}\n`,
 		producer: task.id,
 	});
-	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, packetArtifact, verificationArtifact, ...(logArtifact ? [logArtifact] : []), ...(diffArtifact ? [diffArtifact] : [])] };
+	const sharedOutputArtifact = writeTaskSharedOutput(manifest, input.step, task);
+	const startupArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.startup-evidence.json`,
+		content: `${JSON.stringify(startupEvidence, null, 2)}\n`,
+		producer: task.id,
+	});
+	const permissionArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.permission.json`,
+		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] : [])] };
 	saveRunManifest(manifest);
 	saveRunTasks(manifest, tasks);
+	upsertCrewAgent(manifest, recordFromTask(manifest, task, input.executeWorkers ? "child-process" : "scaffold"));
 	appendEvent(manifest.eventsPath, { type: error ? "task.failed" : "task.completed", runId: manifest.runId, taskId: task.id, message: error });
 	return { manifest, tasks };
 }