pi-crew 0.1.45 → 0.1.49

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

@@ -1,127 +1,177 @@
-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 { resolveRealContainedPath } from "../utils/safe-paths.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 containedExists(filePath: string, baseDir?: string): boolean {
-	try {
-		const safePath = baseDir ? resolveRealContainedPath(baseDir, filePath) : filePath;
-		return fs.existsSync(safePath);
-	} catch {
-		return false;
-	}
-}
-
-function readIfSmall(filePath: string, maxBytes = 24_000, baseDir?: string): string | undefined {
-	try {
-		const safePath = baseDir ? resolveRealContainedPath(baseDir, filePath) : filePath;
-		const stat = fs.statSync(safePath);
-		if (stat.size > maxBytes) return `${fs.readFileSync(safePath, "utf-8").slice(0, maxBytes)}\n\n...(truncated ${stat.size - maxBytes} bytes)`;
-		return fs.readFileSync(safePath, "utf-8");
-	} catch {
-		return undefined;
-	}
-}
-
-function safeSharedName(name: string): string {
-	const normalized = name.replaceAll("\\", "/").replace(/^\.\/+/, "");
-	if (!normalized || normalized.split("/").some((segment) => segment === "..") || path.isAbsolute(normalized)) throw new Error(`Invalid shared artifact name: ${name}`);
-	return normalized;
-}
-
-export function sharedPath(manifest: TeamRunManifest, name: string): string {
-	const sharedRoot = path.resolve(manifest.artifactsRoot, "shared");
-	const resolved = path.resolve(sharedRoot, safeSharedName(name));
-	const relative = path.relative(sharedRoot, resolved);
-	if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Invalid shared artifact name: ${name}`);
-	return resolved;
-}
-
-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, 24_000, manifest.artifactsRoot) : undefined,
-	}));
-	const sharedReads = (step.reads === false ? [] : step.reads ?? []).map((name) => {
-		const filePath = sharedPath(manifest, name);
-		return { name, path: filePath, content: readIfSmall(filePath, 24_000, path.resolve(manifest.artifactsRoot, "shared")) ?? "" };
-	}).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 = safeSharedName(step.output || `${task.id}.md`);
-	const source = task.resultArtifact ? readIfSmall(task.resultArtifact.path, 80_000, manifest.artifactsRoot) : 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[], manifest?: TeamRunManifest): string {
-	return tasks.map((task, index) => {
-		const body = task.resultArtifact ? readIfSmall(task.resultArtifact.path, 40_000, manifest?.artifactsRoot) : undefined;
-		const hasBody = Boolean(body?.trim());
-		const expectedMissing = task.resultArtifact && !containedExists(task.resultArtifact.path, manifest?.artifactsRoot);
-		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");
-}
+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 { resolveRealContainedPath } from "../utils/safe-paths.ts";
+import type { WorkflowStep } from "../workflows/workflow-config.ts";
+
+export interface DependencyContextEntry {
+	taskId: string;
+	role: string;
+	status: string;
+	resultSummary: string;
+	resultPath?: string;
+	structuredResults?: Record<string, unknown>;
+	artifactsProduced?: string[];
+	usage?: { inputTokens: number; outputTokens: number; durationMs: number };
+}
+
+export interface DependencyOutputContext {
+	dependencies: DependencyContextEntry[];
+	sharedReads: Array<{ name: string; path: string; content: string }>;
+}
+
+function containedExists(filePath: string, baseDir?: string): boolean {
+	try {
+		const safePath = baseDir ? resolveRealContainedPath(baseDir, filePath) : filePath;
+		return fs.existsSync(safePath);
+	} catch {
+		return false;
+	}
+}
+
+function readIfSmall(filePath: string, maxBytes = 24_000, baseDir?: string): string | undefined {
+	try {
+		const safePath = baseDir ? resolveRealContainedPath(baseDir, filePath) : filePath;
+		const stat = fs.statSync(safePath);
+		if (stat.size > maxBytes) return `${fs.readFileSync(safePath, "utf-8").slice(0, maxBytes)}\n\n...(truncated ${stat.size - maxBytes} bytes)`;
+		return fs.readFileSync(safePath, "utf-8");
+	} catch {
+		return undefined;
+	}
+}
+
+function safeSharedName(name: string): string {
+	const normalized = name.replaceAll("\\", "/").replace(/^\.\/+/, "");
+	if (!normalized || normalized.split("/").some((segment) => segment === "..") || path.isAbsolute(normalized)) throw new Error(`Invalid shared artifact name: ${name}`);
+	return normalized;
+}
+
+export function sharedPath(manifest: TeamRunManifest, name: string): string {
+	const sharedRoot = path.resolve(manifest.artifactsRoot, "shared");
+	const resolved = path.resolve(sharedRoot, safeSharedName(name));
+	const relative = path.relative(sharedRoot, resolved);
+	if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Invalid shared artifact name: ${name}`);
+	return resolved;
+}
+
+function tryParseJson(text: string): Record<string, unknown> | undefined {
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed as Record<string, unknown>;
+	} catch {
+		// Not valid JSON object — return undefined.
+	}
+	return undefined;
+}
+
+function listTaskArtifacts(manifest: TeamRunManifest, taskId: string): string[] | undefined {
+	const produced = manifest.artifacts.filter((a) => a.producer === taskId);
+	if (produced.length === 0) return undefined;
+	return produced.map((a) => {
+		const relative = path.relative(manifest.artifactsRoot, a.path);
+		return relative.startsWith("..") ? a.path : relative;
+	});
+}
+
+function aggregateUsage(task: TeamTaskState): DependencyContextEntry["usage"] {
+	if (!task.usage) return undefined;
+	const inputTokens = task.usage.input ?? 0;
+	const outputTokens = task.usage.output ?? 0;
+	const started = task.startedAt ? new Date(task.startedAt).getTime() : 0;
+	const finished = task.finishedAt ? new Date(task.finishedAt).getTime() : 0;
+	const durationMs = started && finished ? finished - started : 0;
+	if (inputTokens === 0 && outputTokens === 0 && durationMs === 0) return undefined;
+	return { inputTokens, outputTokens, durationMs };
+}
+
+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) => {
+		const resultText = item.resultArtifact ? readIfSmall(item.resultArtifact.path, 24_000, manifest.artifactsRoot) : undefined;
+		return {
+			taskId: item.id,
+			role: item.role,
+			status: item.status,
+			resultSummary: resultText ?? "",
+			resultPath: item.resultArtifact?.path,
+			structuredResults: resultText ? tryParseJson(resultText) : undefined,
+			artifactsProduced: listTaskArtifacts(manifest, item.id),
+			usage: aggregateUsage(item),
+		};
+	});
+	const sharedReads = (step.reads === false ? [] : step.reads ?? []).map((name) => {
+		const filePath = sharedPath(manifest, name);
+		return { name, path: filePath, content: readIfSmall(filePath, 24_000, path.resolve(manifest.artifactsRoot, "shared")) ?? "" };
+	}).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.role})`, `Status: ${dep.status}`, dep.resultPath ? `Result artifact: ${dep.resultPath}` : "", "", dep.resultSummary?.trim() || "(no result output)", "");
+			if (dep.structuredResults) parts.push("Structured results:", JSON.stringify(dep.structuredResults, null, 2), "");
+			if (dep.artifactsProduced?.length) parts.push(`Artifacts produced: ${dep.artifactsProduced.join(", ")}`, "");
+			if (dep.usage) parts.push(`Usage: ${dep.usage.inputTokens} input tokens, ${dep.usage.outputTokens} output tokens, ${dep.usage.durationMs}ms`, "");
+		}
+	}
+	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 = safeSharedName(step.output || `${task.id}.md`);
+	const source = task.resultArtifact ? readIfSmall(task.resultArtifact.path, 80_000, manifest.artifactsRoot) : 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[], manifest?: TeamRunManifest): string {
+	return tasks.map((task, index) => {
+		const body = task.resultArtifact ? readIfSmall(task.resultArtifact.path, 40_000, manifest?.artifactsRoot) : undefined;
+		const hasBody = Boolean(body?.trim());
+		const expectedMissing = task.resultArtifact && !containedExists(task.resultArtifact.path, manifest?.artifactsRoot);
+		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/capabilities.ts

@@ -0,0 +1,78 @@
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import type { CrewRuntimeKind } from "../crew-agent-runtime.ts";
+
+export interface WorkerCapabilityInventory {
+	schemaVersion: 1;
+	taskId: string;
+	role: string;
+	agent: string;
+	runtime: CrewRuntimeKind;
+	permissionMode: string;
+	tools: string[];
+	extensions: string[];
+	skills: {
+		names: string[];
+		paths: string[];
+		disabled: boolean;
+	};
+	model: {
+		requested?: string;
+		agentDefault?: string;
+		fallbacks: string[];
+		teamRole?: string;
+		step?: string;
+	};
+	inheritance: {
+		projectContext: boolean;
+		skills: boolean;
+		systemPromptMode: "replace" | "append";
+	};
+}
+
+export interface BuildWorkerCapabilityInventoryInput {
+	taskId: string;
+	role: string;
+	agent: AgentConfig;
+	runtime: CrewRuntimeKind;
+	permissionMode: string;
+	skillNames?: string[];
+	skillPaths?: string[];
+	skillsDisabled: boolean;
+	modelOverride?: string;
+	teamRoleModel?: string;
+	stepModel?: string;
+}
+
+function uniqueSorted(values: readonly string[] | undefined): string[] {
+	return [...new Set((values ?? []).map((value) => value.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+
+export function buildWorkerCapabilityInventory(input: BuildWorkerCapabilityInventoryInput): WorkerCapabilityInventory {
+	return {
+		schemaVersion: 1,
+		taskId: input.taskId,
+		role: input.role,
+		agent: input.agent.name,
+		runtime: input.runtime,
+		permissionMode: input.permissionMode,
+		tools: uniqueSorted(input.agent.tools),
+		extensions: uniqueSorted(input.agent.extensions),
+		skills: {
+			names: uniqueSorted(input.skillNames),
+			paths: uniqueSorted(input.skillPaths),
+			disabled: input.skillsDisabled,
+		},
+		model: {
+			requested: input.modelOverride,
+			agentDefault: input.agent.model,
+			fallbacks: uniqueSorted(input.agent.fallbackModels),
+			teamRole: input.teamRoleModel,
+			step: input.stepModel,
+		},
+		inheritance: {
+			projectContext: input.agent.inheritProjectContext === true,
+			skills: input.agent.inheritSkills === true,
+			systemPromptMode: input.agent.systemPromptMode ?? "replace",
+		},
+	};
+}

package/src/runtime/task-runner/live-executor.ts

@@ -1,101 +1,107 @@
-import * as fs from "node:fs";
-import type { AgentConfig } from "../../agents/agent-config.ts";
-import type { CrewRuntimeConfig } from "../../config/config.ts";
-import { writeArtifact } from "../../state/artifact-store.ts";
-import { appendEvent } from "../../state/event-log.ts";
-import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../../state/types.ts";
-import type { WorkflowStep } from "../../workflows/workflow-config.ts";
-import { appendCrewAgentEvent, appendCrewAgentOutput, emptyCrewAgentProgress, recordFromTask, upsertCrewAgent } from "../crew-agent-records.ts";
-import { createStartupEvidence, type WorkerStartupEvidence } from "../worker-startup.ts";
-import { runLiveSessionTask } from "../live-session-runtime.ts";
-import { shouldAppendProgressEventUpdate, type ProgressEventSummary } from "../progress-event-coalescer.ts";
-import { applyAgentProgressEvent, applyUsageToProgress, progressEventSummary, shouldFlushProgressEvent } from "./progress.ts";
-import type { ParsedPiJsonOutput } from "../pi-json-output.ts";
-
-export interface RunLiveTaskInput {
-	manifest: TeamRunManifest;
-	tasks: TeamTaskState[];
-	task: TeamTaskState;
-	step: WorkflowStep;
-	agent: AgentConfig;
-	prompt: string;
-	signal?: AbortSignal;
-	runtimeConfig?: CrewRuntimeConfig;
-	parentContext?: string;
-	parentModel?: unknown;
-	modelRegistry?: unknown;
-	isCurrent?: () => boolean;
-}
-
-export interface RunLiveTaskOutput {
-	task: TeamTaskState;
-	tasks: TeamTaskState[];
-	startupEvidence: WorkerStartupEvidence;
-	exitCode: number | null;
-	error?: string;
-	parsedOutput?: ParsedPiJsonOutput;
-	resultArtifact: ArtifactDescriptor;
-	logArtifact?: ArtifactDescriptor;
-	transcriptArtifact?: ArtifactDescriptor;
-}
-
-function updateTask(tasks: TeamTaskState[], updated: TeamTaskState): TeamTaskState[] {
-	return tasks.map((task) => task.id === updated.id ? updated : task);
-}
-
-export async function runLiveTask(input: RunLiveTaskInput): Promise<RunLiveTaskOutput> {
-	const { manifest, step, agent, prompt } = input;
-	let task = input.task;
-	let tasks = input.tasks;
-	const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
-	let lastAgentRecordPersistedAt = 0;
-	let lastRunProgressPersistedAt = 0;
-	let lastRunProgressSummary: ProgressEventSummary | undefined;
-	const persistLiveProgress = (event: unknown, force = false): void => {
-		const now = Date.now();
-		if (force || shouldFlushProgressEvent(event) || now - lastAgentRecordPersistedAt >= 500) {
-			upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
-			lastAgentRecordPersistedAt = now;
-		}
-		const summary = progressEventSummary(task, event);
-		const decision = shouldAppendProgressEventUpdate({ previous: lastRunProgressSummary, next: summary, nowMs: now, lastAppendMs: lastRunProgressPersistedAt || undefined, minIntervalMs: 1000, force });
-		if (decision.shouldAppend) {
-			appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { ...summary, coalesceReason: decision.reason } });
-			lastRunProgressSummary = summary;
-			lastRunProgressPersistedAt = now;
-		}
-	};
-	const attemptStartedAt = new Date();
-	const isCurrent = input.isCurrent ?? (() => input.signal?.aborted !== true);
-	const liveResult = await runLiveSessionTask({
-		manifest,
-		task,
-		step,
-		agent,
-		prompt,
-		signal: input.signal,
-		transcriptPath,
-		runtimeConfig: input.runtimeConfig,
-		parentContext: input.parentContext,
-		parentModel: input.parentModel,
-		modelRegistry: input.modelRegistry,
-		isCurrent,
-		onOutput: (text) => appendCrewAgentOutput(manifest, task.id, text),
-		onEvent: (event) => {
-			appendCrewAgentEvent(manifest, task.id, event);
-			task = { ...task, agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt) };
-			tasks = updateTask(tasks, task);
-			persistLiveProgress(event);
-		},
-	});
-	const startupEvidence = createStartupEvidence({ command: "live-session", startedAt: attemptStartedAt, finishedAt: new Date(), promptSentAt: attemptStartedAt, promptAccepted: liveResult.exitCode === 0 && !liveResult.error, stderr: liveResult.stderr, error: liveResult.error, exitCode: liveResult.exitCode });
-	const exitCode = liveResult.exitCode;
-	const error = liveResult.error || (liveResult.exitCode && liveResult.exitCode !== 0 ? liveResult.stderr || `Live session exited with ${liveResult.exitCode}` : undefined);
-	const parsedOutput = { finalText: liveResult.stdout, textEvents: liveResult.stdout ? [liveResult.stdout] : [], jsonEvents: liveResult.jsonEvents, usage: liveResult.usage };
-	if (liveResult.usage) task = { ...task, usage: liveResult.usage, agentProgress: applyUsageToProgress(task.agentProgress, liveResult.usage) };
-	persistLiveProgress({ type: "attempt_finished" }, true);
-	const resultArtifact = writeArtifact(manifest.artifactsRoot, { kind: "result", relativePath: `results/${task.id}.txt`, content: liveResult.stdout || liveResult.stderr || "(no output)", producer: task.id });
-	const logArtifact = writeArtifact(manifest.artifactsRoot, { kind: "log", relativePath: `logs/${task.id}.log`, content: [`runtime=live-session`, `finalExitCode=${exitCode ?? "null"}`, `jsonEvents=${liveResult.jsonEvents}`, liveResult.usage ? `usage=${JSON.stringify(liveResult.usage)}` : "", "", "STDOUT:", liveResult.stdout, "", "STDERR:", liveResult.stderr].join("\n"), producer: task.id });
-	const transcriptArtifact = fs.existsSync(transcriptPath) ? writeArtifact(manifest.artifactsRoot, { kind: "log", relativePath: `transcripts/${task.id}.jsonl`, content: fs.readFileSync(transcriptPath, "utf-8"), producer: task.id }) : undefined;
-	return { task, tasks, startupEvidence, exitCode, error: error || undefined, parsedOutput, resultArtifact, logArtifact, transcriptArtifact };
-}
+import * as fs from "node:fs";
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import type { CrewRuntimeConfig } from "../../config/config.ts";
+import { writeArtifact } from "../../state/artifact-store.ts";
+import { appendEvent } from "../../state/event-log.ts";
+import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import type { WorkflowStep } from "../../workflows/workflow-config.ts";
+import { appendCrewAgentEvent, appendCrewAgentOutput, emptyCrewAgentProgress, recordFromTask, upsertCrewAgent } from "../crew-agent-records.ts";
+import { createStartupEvidence, type WorkerStartupEvidence } from "../worker-startup.ts";
+import { runLiveSessionTask } from "../live-session-runtime.ts";
+import { shouldAppendProgressEventUpdate, type ProgressEventSummary } from "../progress-event-coalescer.ts";
+import { applyAgentProgressEvent, applyUsageToProgress, progressEventSummary, shouldFlushProgressEvent } from "./progress.ts";
+import type { ParsedPiJsonOutput } from "../pi-json-output.ts";
+
+export interface RunLiveTaskInput {
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	task: TeamTaskState;
+	step: WorkflowStep;
+	agent: AgentConfig;
+	prompt: string;
+	signal?: AbortSignal;
+	runtimeConfig?: CrewRuntimeConfig;
+	parentContext?: string;
+	parentModel?: unknown;
+	modelRegistry?: unknown;
+	modelOverride?: string;
+	teamRoleModel?: string;
+	isCurrent?: () => boolean;
+}
+
+export interface RunLiveTaskOutput {
+	task: TeamTaskState;
+	tasks: TeamTaskState[];
+	startupEvidence: WorkerStartupEvidence;
+	exitCode: number | null;
+	error?: string;
+	parsedOutput?: ParsedPiJsonOutput;
+	resultArtifact: ArtifactDescriptor;
+	logArtifact?: ArtifactDescriptor;
+	transcriptArtifact?: ArtifactDescriptor;
+}
+
+function updateTask(tasks: TeamTaskState[], updated: TeamTaskState): TeamTaskState[] {
+	return tasks.map((task) => task.id === updated.id ? updated : task);
+}
+
+export async function runLiveTask(input: RunLiveTaskInput): Promise<RunLiveTaskOutput> {
+	const { manifest, step, agent, prompt } = input;
+	let task = input.task;
+	let tasks = input.tasks;
+	const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
+	let lastAgentRecordPersistedAt = 0;
+	let lastRunProgressPersistedAt = 0;
+	let lastRunProgressSummary: ProgressEventSummary | undefined;
+	const persistLiveProgress = (event: unknown, force = false): void => {
+		const now = Date.now();
+		if (force || shouldFlushProgressEvent(event) || now - lastAgentRecordPersistedAt >= 500) {
+			upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
+			lastAgentRecordPersistedAt = now;
+		}
+		const summary = progressEventSummary(task, event);
+		const decision = shouldAppendProgressEventUpdate({ previous: lastRunProgressSummary, next: summary, nowMs: now, lastAppendMs: lastRunProgressPersistedAt || undefined, minIntervalMs: 1000, force });
+		if (decision.shouldAppend) {
+			appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { ...summary, coalesceReason: decision.reason } });
+			lastRunProgressSummary = summary;
+			lastRunProgressPersistedAt = now;
+		}
+	};
+	const attemptStartedAt = new Date();
+	const isCurrent = input.isCurrent ?? (() => input.signal?.aborted !== true);
+	const liveResult = await runLiveSessionTask({
+		manifest,
+		task,
+		step,
+		agent,
+		prompt,
+		signal: input.signal,
+		transcriptPath,
+		runtimeConfig: input.runtimeConfig,
+		parentContext: input.parentContext,
+		parentModel: input.parentModel,
+		modelRegistry: input.modelRegistry,
+		modelOverride: input.modelOverride,
+		teamRoleModel: input.teamRoleModel,
+		isCurrent,
+		// Phase 2: Pass output schema for yield validation
+		outputSchema: undefined,
+		onOutput: (text) => appendCrewAgentOutput(manifest, task.id, text),
+		onEvent: (event) => {
+			appendCrewAgentEvent(manifest, task.id, event);
+			task = { ...task, agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt) };
+			tasks = updateTask(tasks, task);
+			persistLiveProgress(event);
+		},
+	});
+	const startupEvidence = createStartupEvidence({ command: "live-session", startedAt: attemptStartedAt, finishedAt: new Date(), promptSentAt: attemptStartedAt, promptAccepted: liveResult.exitCode === 0 && !liveResult.error, stderr: liveResult.stderr, error: liveResult.error, exitCode: liveResult.exitCode });
+	const exitCode = liveResult.exitCode;
+	const error = liveResult.error || (liveResult.exitCode && liveResult.exitCode !== 0 ? liveResult.stderr || `Live session exited with ${liveResult.exitCode}` : undefined);
+	const parsedOutput = { finalText: liveResult.stdout, textEvents: liveResult.stdout ? [liveResult.stdout] : [], jsonEvents: liveResult.jsonEvents, usage: liveResult.usage };
+	if (liveResult.usage) task = { ...task, usage: liveResult.usage, agentProgress: applyUsageToProgress(task.agentProgress, liveResult.usage) };
+	persistLiveProgress({ type: "attempt_finished" }, true);
+	const resultArtifact = writeArtifact(manifest.artifactsRoot, { kind: "result", relativePath: `results/${task.id}.txt`, content: liveResult.stdout || liveResult.stderr || "(no output)", producer: task.id });
+	const logArtifact = writeArtifact(manifest.artifactsRoot, { kind: "log", relativePath: `logs/${task.id}.log`, content: [`runtime=live-session`, `finalExitCode=${exitCode ?? "null"}`, `jsonEvents=${liveResult.jsonEvents}`, liveResult.usage ? `usage=${JSON.stringify(liveResult.usage)}` : "", "", "STDOUT:", liveResult.stdout, "", "STDERR:", liveResult.stderr].join("\n"), producer: task.id });
+	const transcriptArtifact = fs.existsSync(transcriptPath) ? writeArtifact(manifest.artifactsRoot, { kind: "log", relativePath: `transcripts/${task.id}.jsonl`, content: fs.readFileSync(transcriptPath, "utf-8"), producer: task.id }) : undefined;
+	return { task, tasks, startupEvidence, exitCode, error: error || undefined, parsedOutput, resultArtifact, logArtifact, transcriptArtifact };
+}