pi-crew 0.1.16 → 0.1.18

package/src/runtime/team-runner.ts

@@ -1,240 +1,242 @@
-import type { AgentConfig } from "../agents/agent-config.ts";
-import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
-import type { CrewRuntimeCapabilities } from "./runtime-resolver.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent } from "../state/event-log.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import type { ArtifactDescriptor, PolicyDecision, TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { saveRunManifest, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
-import { aggregateUsage, formatUsage } from "../state/usage.ts";
-import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
-import { evaluateCrewPolicy, summarizePolicyDecisions } from "./policy-engine.ts";
-import { buildRecoveryLedger } from "./recovery-recipes.ts";
-import { getReadyTasks, refreshTaskGraphQueues, taskGraphSnapshot } from "./task-graph-scheduler.ts";
-import { checkBranchFreshness } from "../worktree/branch-freshness.ts";
-import { aggregateTaskOutputs } from "./task-output-context.ts";
-import { recordFromTask, saveCrewAgents } from "./crew-agent-records.ts";
-import { deliverGroupJoin, resolveGroupJoinMode } from "./group-join.ts";
-import { runTeamTask } from "./task-runner.ts";
-
-export interface ExecuteTeamRunInput {
-	manifest: TeamRunManifest;
-	tasks: TeamTaskState[];
-	team: TeamConfig;
-	workflow: WorkflowConfig;
-	agents: AgentConfig[];
-	executeWorkers: boolean;
-	limits?: CrewLimitsConfig;
-	runtime?: CrewRuntimeCapabilities;
-	runtimeConfig?: CrewRuntimeConfig;
-	parentContext?: string;
-	parentModel?: unknown;
-	modelRegistry?: unknown;
-	modelOverride?: string;
-	signal?: AbortSignal;
-}
-
-function findReadyTask(tasks: TeamTaskState[]): TeamTaskState | undefined {
-	return getReadyTasks(tasks, 1)[0];
-}
-
-function findStep(workflow: WorkflowConfig, task: TeamTaskState): WorkflowStep {
-	const step = workflow.steps.find((candidate) => candidate.id === task.stepId);
-	if (!step) throw new Error(`Workflow step '${task.stepId}' not found for task '${task.id}'.`);
-	return step;
-}
-
-function findAgent(agents: AgentConfig[], task: TeamTaskState): AgentConfig {
-	const agent = agents.find((candidate) => candidate.name === task.agent);
-	if (!agent) throw new Error(`Agent '${task.agent}' not found for task '${task.id}'.`);
-	return agent;
-}
-
-function markBlocked(tasks: TeamTaskState[], reason: string): TeamTaskState[] {
-	return tasks.map((task) => task.status === "queued" ? { ...task, status: "skipped", error: reason, finishedAt: new Date().toISOString(), graph: task.graph ? { ...task.graph, queue: "blocked" } : undefined } : task);
-}
-
-function mergeArtifacts(items: ArtifactDescriptor[]): ArtifactDescriptor[] {
-	const byPath = new Map<string, ArtifactDescriptor>();
-	for (const item of items) byPath.set(item.path, item);
-	return [...byPath.values()];
-}
-
-function mergeTaskUpdates(base: TeamTaskState[], results: Array<{ tasks: TeamTaskState[] }>): TeamTaskState[] {
-	let merged = base;
-	for (const result of results) {
-		for (const updated of result.tasks) {
-			const current = merged.find((task) => task.id === updated.id);
-			if (!current) continue;
-			if (updated.status !== current.status || updated.finishedAt || updated.startedAt || updated.resultArtifact || updated.error) {
-				merged = merged.map((task) => task.id === updated.id ? updated : task);
-			}
-		}
-	}
-	return refreshTaskGraphQueues(merged);
-}
-
-function formatTaskProgress(task: TeamTaskState): string {
-	return `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.error ? ` - ${task.error}` : ""}`;
-}
-
-function writeProgress(manifest: TeamRunManifest, tasks: TeamTaskState[], producer: string): TeamRunManifest {
-	const counts = new Map<string, number>();
-	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
-	const queue = taskGraphSnapshot(tasks);
-	const progress = writeArtifact(manifest.artifactsRoot, {
-		kind: "progress",
-		relativePath: "progress.md",
-		producer,
-		content: [
-			`# pi-crew progress ${manifest.runId}`,
-			"",
-			`Status: ${manifest.status}`,
-			`Team: ${manifest.team}`,
-			`Workflow: ${manifest.workflow ?? "(none)"}`,
-			`Updated: ${new Date().toISOString()}`,
-			`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
-			`Queue: ready=${queue.ready.length}, blocked=${queue.blocked.length}, running=${queue.running.length}, done=${queue.done.length}, failed=${queue.failed.length}, cancelled=${queue.cancelled.length}`,
-			"",
-			"## Tasks",
-			...tasks.map(formatTaskProgress),
-			"",
-		].join("\n"),
-	});
-	return { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts.filter((artifact) => !(artifact.kind === "progress" && artifact.path === progress.path)), progress] };
-}
-
-function applyPolicy(manifest: TeamRunManifest, tasks: TeamTaskState[], limits?: CrewLimitsConfig): TeamRunManifest {
-	const branchFreshness = checkBranchFreshness(manifest.cwd);
-	const branchArtifact = writeArtifact(manifest.artifactsRoot, {
-		kind: "metadata",
-		relativePath: "metadata/branch-freshness.json",
-		producer: "branch-freshness",
-		content: `${JSON.stringify(branchFreshness, null, 2)}\n`,
-	});
-	let decisions: PolicyDecision[] = evaluateCrewPolicy({ manifest, tasks, limits });
-	if (branchFreshness.status === "stale" || branchFreshness.status === "diverged") {
-		const branchDecision: PolicyDecision = {
-			action: "notify",
-			reason: "branch_stale",
-			message: branchFreshness.message,
-			createdAt: new Date().toISOString(),
-		};
-		decisions = [...decisions, branchDecision];
-		appendEvent(manifest.eventsPath, { type: "branch.stale", runId: manifest.runId, message: branchFreshness.message, data: { branchFreshness } });
-	}
-	const policyArtifact = writeArtifact(manifest.artifactsRoot, {
-		kind: "metadata",
-		relativePath: "policy-decisions.json",
-		producer: "policy-engine",
-		content: `${JSON.stringify(decisions, null, 2)}\n`,
-	});
-	const recoveryLedger = buildRecoveryLedger(decisions);
-	const recoveryArtifact = writeArtifact(manifest.artifactsRoot, {
-		kind: "metadata",
-		relativePath: "recovery-ledger.json",
-		producer: "recovery-engine",
-		content: `${JSON.stringify(recoveryLedger, null, 2)}\n`,
-	});
-	for (const item of decisions) appendEvent(manifest.eventsPath, { type: item.action === "escalate" ? "policy.escalated" : "policy.action", runId: manifest.runId, taskId: item.taskId, message: item.message, data: { action: item.action, reason: item.reason } });
-	for (const item of recoveryLedger.entries) appendEvent(manifest.eventsPath, { type: item.state === "escalation_required" ? "recovery.escalated" : "recovery.attempted", runId: manifest.runId, taskId: item.taskId, message: item.message, data: { scenario: item.scenario, steps: item.steps, attempt: item.attempt, state: item.state } });
-	return { ...manifest, updatedAt: new Date().toISOString(), policyDecisions: decisions, artifacts: [...manifest.artifacts.filter((artifact) => !(artifact.kind === "metadata" && (artifact.path.endsWith("policy-decisions.json") || artifact.path.endsWith("recovery-ledger.json") || artifact.path.endsWith("branch-freshness.json")))), branchArtifact, policyArtifact, recoveryArtifact] };
-}
-
-export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
-	let manifest = updateRunStatus(input.manifest, "running", input.executeWorkers ? "Executing team workflow." : "Creating workflow prompts and placeholder results.");
-	let tasks = refreshTaskGraphQueues(input.tasks);
-	manifest = writeProgress(manifest, tasks, "team-runner");
-	saveRunManifest(manifest);
-	const runtimeKind = input.runtime?.kind ?? (input.executeWorkers ? "child-process" : "scaffold");
-	saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
-
-	while (tasks.some((task) => task.status === "queued")) {
-		if (input.signal?.aborted) {
-			tasks = tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled", finishedAt: new Date().toISOString(), error: "Run cancelled." } : task);
-			saveRunTasks(manifest, tasks);
-			manifest = updateRunStatus(manifest, "cancelled", "Run cancelled.");
-			return { manifest, tasks };
-		}
-
-		const failed = tasks.find((task) => task.status === "failed");
-		if (failed) {
-			tasks = markBlocked(tasks, `Blocked by failed task '${failed.id}'.`);
-			saveRunTasks(manifest, tasks);
-			saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
-			manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
-			return { manifest, tasks };
-		}
-
-		const maxConcurrent = Math.max(1, input.limits?.maxConcurrentWorkers ?? 1);
-		const readyBatch = getReadyTasks(tasks, maxConcurrent);
-		if (readyBatch.length === 0) {
-			tasks = markBlocked(tasks, "No ready queued task; dependency graph may be invalid.");
-			saveRunTasks(manifest, tasks);
-			saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
-			manifest = updateRunStatus(manifest, "blocked", "No ready queued task.");
-			return { manifest, tasks };
-		}
-
-		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), maxConcurrent } });
-		const results = await Promise.all(readyBatch.map((task) => {
-			const step = findStep(input.workflow, task);
-			const agent = findAgent(input.agents, task);
-			return runTeamTask({ 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, limits: input.limits });
-		}));
-		manifest = { ...results.at(-1)!.manifest, artifacts: mergeArtifacts([manifest.artifacts, ...results.map((item) => item.manifest.artifacts)].flat()) };
-		tasks = mergeTaskUpdates(tasks, results);
-		saveRunTasks(manifest, tasks);
-		saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
-		const completedBatch = readyBatch.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`,
-			producer: "team-runner",
-			content: aggregateTaskOutputs(completedBatch),
-		});
-		const groupDelivery = deliverGroupJoin({ manifest, mode: resolveGroupJoinMode(input.runtimeConfig), batch: readyBatch, allTasks: tasks });
-		manifest = { ...manifest, artifacts: mergeArtifacts([...manifest.artifacts, batchArtifact, ...(groupDelivery?.artifact ? [groupDelivery.artifact] : [])]) };
-		manifest = writeProgress(manifest, tasks, "team-runner");
-		saveRunManifest(manifest);
-	}
-
-	const failed = tasks.find((task) => task.status === "failed");
-	manifest = applyPolicy(manifest, tasks, input.limits);
-	const blockingDecision = manifest.policyDecisions?.find((item) => item.action === "block" || item.action === "escalate");
-	if (failed) {
-		manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
-	} else if (blockingDecision) {
-		manifest = updateRunStatus(manifest, "blocked", blockingDecision.message);
-	} else {
-		manifest = updateRunStatus(manifest, "completed", input.executeWorkers ? "Team workflow completed." : "Team workflow scaffold completed without launching child workers.");
-	}
-	manifest = writeProgress(manifest, tasks, "team-runner");
-	saveRunManifest(manifest);
-	const usage = aggregateUsage(tasks);
-	const summaryArtifact = writeArtifact(manifest.artifactsRoot, {
-		kind: "summary",
-		relativePath: "summary.md",
-		producer: "team-runner",
-		content: [
-			`# pi-crew run ${manifest.runId}`,
-			"",
-			`Status: ${manifest.status}`,
-			`Team: ${manifest.team}`,
-			`Workflow: ${manifest.workflow ?? "(none)"}`,
-			`Goal: ${manifest.goal}`,
-			`Usage: ${formatUsage(usage)}`,
-			"",
-			"## Tasks",
-			...tasks.map(formatTaskProgress),
-			"",
-			"## Policy decisions",
-			...(manifest.policyDecisions?.length ? summarizePolicyDecisions(manifest.policyDecisions) : ["- (none)"]),
-			"",
-		].join("\n"),
-	});
-	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, summaryArtifact] };
-	saveRunManifest(manifest);
-	saveRunTasks(manifest, tasks);
-	return { manifest, tasks };
-}
+import type { AgentConfig } from "../agents/agent-config.ts";
+import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
+import type { CrewRuntimeCapabilities } from "./runtime-resolver.ts";
+import { writeArtifact } from "../state/artifact-store.ts";
+import { appendEvent } from "../state/event-log.ts";
+import type { TeamConfig } from "../teams/team-config.ts";
+import type { ArtifactDescriptor, PolicyDecision, TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { saveRunManifest, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
+import { aggregateUsage, formatUsage } from "../state/usage.ts";
+import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
+import { evaluateCrewPolicy, summarizePolicyDecisions } from "./policy-engine.ts";
+import { buildRecoveryLedger } from "./recovery-recipes.ts";
+import { getReadyTasks, refreshTaskGraphQueues, taskGraphSnapshot } from "./task-graph-scheduler.ts";
+import { checkBranchFreshness } from "../worktree/branch-freshness.ts";
+import { aggregateTaskOutputs } from "./task-output-context.ts";
+import { saveCrewAgents } from "./crew-agent-records.ts";
+import { recordsForMaterializedTasks } from "./task-display.ts";
+import { deliverGroupJoin, resolveGroupJoinMode } from "./group-join.ts";
+import { runTeamTask } from "./task-runner.ts";
+
+export interface ExecuteTeamRunInput {
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	team: TeamConfig;
+	workflow: WorkflowConfig;
+	agents: AgentConfig[];
+	executeWorkers: boolean;
+	limits?: CrewLimitsConfig;
+	runtime?: CrewRuntimeCapabilities;
+	runtimeConfig?: CrewRuntimeConfig;
+	parentContext?: string;
+	parentModel?: unknown;
+	modelRegistry?: unknown;
+	modelOverride?: string;
+	signal?: AbortSignal;
+}
+
+function findReadyTask(tasks: TeamTaskState[]): TeamTaskState | undefined {
+	return getReadyTasks(tasks, 1)[0];
+}
+
+function findStep(workflow: WorkflowConfig, task: TeamTaskState): WorkflowStep {
+	const step = workflow.steps.find((candidate) => candidate.id === task.stepId);
+	if (!step) throw new Error(`Workflow step '${task.stepId}' not found for task '${task.id}'.`);
+	return step;
+}
+
+function findAgent(agents: AgentConfig[], task: TeamTaskState): AgentConfig {
+	const agent = agents.find((candidate) => candidate.name === task.agent);
+	if (!agent) throw new Error(`Agent '${task.agent}' not found for task '${task.id}'.`);
+	return agent;
+}
+
+function markBlocked(tasks: TeamTaskState[], reason: string): TeamTaskState[] {
+	return tasks.map((task) => task.status === "queued" ? { ...task, status: "skipped", error: reason, finishedAt: new Date().toISOString(), graph: task.graph ? { ...task.graph, queue: "blocked" } : undefined } : task);
+}
+
+function mergeArtifacts(items: ArtifactDescriptor[]): ArtifactDescriptor[] {
+	const byPath = new Map<string, ArtifactDescriptor>();
+	for (const item of items) byPath.set(item.path, item);
+	return [...byPath.values()];
+}
+
+function mergeTaskUpdates(base: TeamTaskState[], results: Array<{ tasks: TeamTaskState[] }>): TeamTaskState[] {
+	let merged = base;
+	for (const result of results) {
+		for (const updated of result.tasks) {
+			const current = merged.find((task) => task.id === updated.id);
+			if (!current) continue;
+			if (updated.status !== current.status || updated.finishedAt || updated.startedAt || updated.resultArtifact || updated.error) {
+				merged = merged.map((task) => task.id === updated.id ? updated : task);
+			}
+		}
+	}
+	return refreshTaskGraphQueues(merged);
+}
+
+function formatTaskProgress(task: TeamTaskState): string {
+	return `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.error ? ` - ${task.error}` : ""}`;
+}
+
+function writeProgress(manifest: TeamRunManifest, tasks: TeamTaskState[], producer: string): TeamRunManifest {
+	const counts = new Map<string, number>();
+	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
+	const queue = taskGraphSnapshot(tasks);
+	const progress = writeArtifact(manifest.artifactsRoot, {
+		kind: "progress",
+		relativePath: "progress.md",
+		producer,
+		content: [
+			`# pi-crew progress ${manifest.runId}`,
+			"",
+			`Status: ${manifest.status}`,
+			`Team: ${manifest.team}`,
+			`Workflow: ${manifest.workflow ?? "(none)"}`,
+			`Updated: ${new Date().toISOString()}`,
+			`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
+			`Queue: ready=${queue.ready.length}, blocked=${queue.blocked.length}, running=${queue.running.length}, done=${queue.done.length}, failed=${queue.failed.length}, cancelled=${queue.cancelled.length}`,
+			"",
+			"## Tasks",
+			...tasks.map(formatTaskProgress),
+			"",
+		].join("\n"),
+	});
+	return { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts.filter((artifact) => !(artifact.kind === "progress" && artifact.path === progress.path)), progress] };
+}
+
+function applyPolicy(manifest: TeamRunManifest, tasks: TeamTaskState[], limits?: CrewLimitsConfig): TeamRunManifest {
+	const branchFreshness = checkBranchFreshness(manifest.cwd);
+	const branchArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: "metadata/branch-freshness.json",
+		producer: "branch-freshness",
+		content: `${JSON.stringify(branchFreshness, null, 2)}\n`,
+	});
+	let decisions: PolicyDecision[] = evaluateCrewPolicy({ manifest, tasks, limits });
+	if (branchFreshness.status === "stale" || branchFreshness.status === "diverged") {
+		const branchDecision: PolicyDecision = {
+			action: "notify",
+			reason: "branch_stale",
+			message: branchFreshness.message,
+			createdAt: new Date().toISOString(),
+		};
+		decisions = [...decisions, branchDecision];
+		appendEvent(manifest.eventsPath, { type: "branch.stale", runId: manifest.runId, message: branchFreshness.message, data: { branchFreshness } });
+	}
+	const policyArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: "policy-decisions.json",
+		producer: "policy-engine",
+		content: `${JSON.stringify(decisions, null, 2)}\n`,
+	});
+	const recoveryLedger = buildRecoveryLedger(decisions);
+	const recoveryArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: "recovery-ledger.json",
+		producer: "recovery-engine",
+		content: `${JSON.stringify(recoveryLedger, null, 2)}\n`,
+	});
+	for (const item of decisions) appendEvent(manifest.eventsPath, { type: item.action === "escalate" ? "policy.escalated" : "policy.action", runId: manifest.runId, taskId: item.taskId, message: item.message, data: { action: item.action, reason: item.reason } });
+	for (const item of recoveryLedger.entries) appendEvent(manifest.eventsPath, { type: item.state === "escalation_required" ? "recovery.escalated" : "recovery.attempted", runId: manifest.runId, taskId: item.taskId, message: item.message, data: { scenario: item.scenario, steps: item.steps, attempt: item.attempt, state: item.state } });
+	return { ...manifest, updatedAt: new Date().toISOString(), policyDecisions: decisions, artifacts: [...manifest.artifacts.filter((artifact) => !(artifact.kind === "metadata" && (artifact.path.endsWith("policy-decisions.json") || artifact.path.endsWith("recovery-ledger.json") || artifact.path.endsWith("branch-freshness.json")))), branchArtifact, policyArtifact, recoveryArtifact] };
+}
+
+export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
+	let manifest = updateRunStatus(input.manifest, "running", input.executeWorkers ? "Executing team workflow." : "Creating workflow prompts and placeholder results.");
+	let tasks = refreshTaskGraphQueues(input.tasks);
+	manifest = writeProgress(manifest, tasks, "team-runner");
+	saveRunManifest(manifest);
+	const runtimeKind = input.runtime?.kind ?? (input.executeWorkers ? "child-process" : "scaffold");
+	saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+
+	while (tasks.some((task) => task.status === "queued")) {
+		if (input.signal?.aborted) {
+			tasks = tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled", finishedAt: new Date().toISOString(), error: "Run cancelled." } : task);
+			saveRunTasks(manifest, tasks);
+			manifest = updateRunStatus(manifest, "cancelled", "Run cancelled.");
+			return { manifest, tasks };
+		}
+
+		const failed = tasks.find((task) => task.status === "failed");
+		if (failed) {
+			tasks = markBlocked(tasks, `Blocked by failed task '${failed.id}'.`);
+			saveRunTasks(manifest, tasks);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
+			return { manifest, tasks };
+		}
+
+		const defaultConcurrency = input.workflow.name === "parallel-research" ? 4 : input.workflow.name === "research" ? 2 : input.workflow.name === "implementation" || input.workflow.name === "review" || input.workflow.name === "default" ? 2 : 1;
+		const maxConcurrent = Math.max(1, input.limits?.maxConcurrentWorkers ?? input.team.maxConcurrency ?? defaultConcurrency);
+		const readyBatch = getReadyTasks(tasks, maxConcurrent);
+		if (readyBatch.length === 0) {
+			tasks = markBlocked(tasks, "No ready queued task; dependency graph may be invalid.");
+			saveRunTasks(manifest, tasks);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "blocked", "No ready queued task.");
+			return { manifest, tasks };
+		}
+
+		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), maxConcurrent } });
+		const results = await Promise.all(readyBatch.map((task) => {
+			const step = findStep(input.workflow, task);
+			const agent = findAgent(input.agents, task);
+			return runTeamTask({ 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, limits: input.limits });
+		}));
+		manifest = { ...results.at(-1)!.manifest, artifacts: mergeArtifacts([manifest.artifacts, ...results.map((item) => item.manifest.artifacts)].flat()) };
+		tasks = mergeTaskUpdates(tasks, results);
+		saveRunTasks(manifest, tasks);
+		saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+		const completedBatch = readyBatch.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`,
+			producer: "team-runner",
+			content: aggregateTaskOutputs(completedBatch),
+		});
+		const groupDelivery = deliverGroupJoin({ manifest, mode: resolveGroupJoinMode(input.runtimeConfig), batch: readyBatch, allTasks: tasks });
+		manifest = { ...manifest, artifacts: mergeArtifacts([...manifest.artifacts, batchArtifact, ...(groupDelivery?.artifact ? [groupDelivery.artifact] : [])]) };
+		manifest = writeProgress(manifest, tasks, "team-runner");
+		saveRunManifest(manifest);
+	}
+
+	const failed = tasks.find((task) => task.status === "failed");
+	manifest = applyPolicy(manifest, tasks, input.limits);
+	const blockingDecision = manifest.policyDecisions?.find((item) => item.action === "block" || item.action === "escalate");
+	if (failed) {
+		manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
+	} else if (blockingDecision) {
+		manifest = updateRunStatus(manifest, "blocked", blockingDecision.message);
+	} else {
+		manifest = updateRunStatus(manifest, "completed", input.executeWorkers ? "Team workflow completed." : "Team workflow scaffold completed without launching child workers.");
+	}
+	manifest = writeProgress(manifest, tasks, "team-runner");
+	saveRunManifest(manifest);
+	const usage = aggregateUsage(tasks);
+	const summaryArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "summary",
+		relativePath: "summary.md",
+		producer: "team-runner",
+		content: [
+			`# pi-crew run ${manifest.runId}`,
+			"",
+			`Status: ${manifest.status}`,
+			`Team: ${manifest.team}`,
+			`Workflow: ${manifest.workflow ?? "(none)"}`,
+			`Goal: ${manifest.goal}`,
+			`Usage: ${formatUsage(usage)}`,
+			"",
+			"## Tasks",
+			...tasks.map(formatTaskProgress),
+			"",
+			"## Policy decisions",
+			...(manifest.policyDecisions?.length ? summarizePolicyDecisions(manifest.policyDecisions) : ["- (none)"]),
+			"",
+		].join("\n"),
+	});
+	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, summaryArtifact] };
+	saveRunManifest(manifest);
+	saveRunTasks(manifest, tasks);
+	return { manifest, tasks };
+}

package/src/ui/live-run-sidebar.ts

@@ -0,0 +1,95 @@
+import * as fs from "node:fs";
+import type { CrewUiConfig } from "../config/config.ts";
+import { readCrewAgents } from "../runtime/crew-agent-records.ts";
+import { applyAttentionState, resolveCrewControlConfig } from "../runtime/agent-control.ts";
+import { formatTaskGraphLines, waitingReason } from "../runtime/task-display.ts";
+import { loadRunManifestById } from "../state/state-store.ts";
+import { aggregateUsage, formatUsage } from "../state/usage.ts";
+import type { TeamTaskState } from "../state/types.ts";
+
+const ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+type ThemeLike = { fg?: (color: string, text: string) => string; bold?: (text: string) => string };
+type Done = (value: undefined) => void;
+
+function visibleLength(value: string): number { return value.replace(ANSI_PATTERN, "").length; }
+function truncate(value: string, width: number): string {
+	if (width <= 0) return "";
+	if (visibleLength(value) <= width) return value;
+	return `${value.slice(0, Math.max(0, width - 1))}…`;
+}
+function pad(value: string, width: number): string { return `${value}${" ".repeat(Math.max(0, width - visibleLength(value)))}`; }
+function line(text: string, width: number): string { return `│ ${pad(truncate(text, width - 4), width - 4)} │`; }
+function border(left: string, fill: string, right: string, width: number): string { return `${left}${fill.repeat(Math.max(0, width - 2))}${right}`; }
+function readTasks(path: string): TeamTaskState[] {
+	try { const parsed = JSON.parse(fs.readFileSync(path, "utf-8")); return Array.isArray(parsed) ? parsed as TeamTaskState[] : []; } catch { return []; }
+}
+function shortUsage(tasks: TeamTaskState[]): string {
+	const usage = aggregateUsage(tasks);
+	return usage ? formatUsage(usage) : "usage=(none)";
+}
+function glyph(status: string): string {
+	if (status === "running") return "⠋";
+	if (status === "completed") return "✓";
+	if (status === "failed") return "✗";
+	if (status === "cancelled" || status === "stopped") return "■";
+	return "◦";
+}
+
+export class LiveRunSidebar {
+	private readonly cwd: string;
+	private readonly runId: string;
+	private readonly done: Done;
+	private readonly theme: ThemeLike;
+	private readonly config: CrewUiConfig;
+
+	constructor(input: { cwd: string; runId: string; done: Done; theme?: unknown; config?: CrewUiConfig }) {
+		this.cwd = input.cwd;
+		this.runId = input.runId;
+		this.done = input.done;
+		this.theme = (input.theme ?? {}) as ThemeLike;
+		this.config = input.config ?? {};
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const fg = this.theme.fg?.bind(this.theme) ?? ((_color: string, text: string) => text);
+		const bold = this.theme.bold?.bind(this.theme) ?? ((text: string) => text);
+		const w = Math.max(36, width);
+		const loaded = loadRunManifestById(this.cwd, this.runId);
+		if (!loaded) return [border("╭", "─", "╮", w), line(`${bold("pi-crew live sidebar")} · run not found`, w), border("╰", "─", "╯", w)];
+		const tasks = readTasks(loaded.manifest.tasksPath);
+		const controlConfig = resolveCrewControlConfig({ ui: this.config });
+		const agents = readCrewAgents(loaded.manifest).map((agent) => applyAttentionState(loaded.manifest, agent, controlConfig));
+		const active = agents.filter((agent) => agent.status === "running");
+		const completed = agents.filter((agent) => agent.status !== "running").slice(-5);
+		const waiting = tasks.filter((task) => task.status === "queued");
+		const lines: string[] = [
+			border("╭", "─", "╮", w),
+			line(`${fg("accent", "▐")} ${bold("pi-crew live sidebar")} · right default`, w),
+			line(`run ${loaded.manifest.runId.slice(-12)} · ${loaded.manifest.status}`, w),
+			line(`${loaded.manifest.team}/${loaded.manifest.workflow ?? "none"} · ${shortUsage(tasks)}`, w),
+			border("├", "─", "┤", w),
+			line(`Active agents (${active.length})`, w),
+		];
+		for (const agent of active.slice(0, 8)) {
+			const usage = agent.usage ? formatUsage(agent.usage) : agent.progress?.tokens ? `tokens=${agent.progress.tokens}` : "usage=pending";
+			lines.push(line(`${glyph(agent.status)} ${agent.taskId} ${agent.role}->${agent.agent}`, w));
+			lines.push(line(`  ${agent.model ? `model ${agent.model}` : "model pending"}`, w));
+			lines.push(line(`  ${agent.progress?.currentTool ? `tool ${agent.progress.currentTool} · ` : ""}${agent.toolUses ?? 0} tools · ${usage}`, w));
+		}
+		if (active.length === 0) lines.push(line("- none", w));
+		lines.push(border("├", "─", "┤", w), line(`Waiting tasks (${waiting.length})`, w));
+		for (const task of waiting.slice(0, 8)) lines.push(line(`◦ ${task.id} ${waitingReason(task, tasks) ?? "waiting"}`, w));
+		if (waiting.length === 0) lines.push(line("- none", w));
+		lines.push(border("├", "─", "┤", w), line(`Completed agents (${completed.length})`, w));
+		for (const agent of completed) lines.push(line(`${glyph(agent.status)} ${agent.taskId} ${agent.model ? `· ${agent.model}` : ""}${agent.usage ? ` · ${formatUsage(agent.usage)}` : ""}`, w));
+		if (completed.length === 0) lines.push(line("- none", w));
+		lines.push(border("├", "─", "┤", w), ...formatTaskGraphLines(tasks).slice(0, 6).map((entry) => line(entry, w)), line("q close · /team-dashboard details", w), border("╰", "─", "╯", w));
+		return lines.map((entry) => truncate(entry, w));
+	}
+
+	handleInput(data: string): void {
+		if (data === "q" || data === "\u001b") this.done(undefined);
+	}
+}