pi-crew 0.1.37 → 0.1.39

package/src/runtime/role-permission.ts

@@ -1,39 +1,39 @@
-export type RolePermissionMode = "read_only" | "workspace_write" | "danger_full_access" | "explicit_confirm";
-
-const READ_ONLY_ROLES = new Set(["explorer", "reviewer", "security-reviewer", "verifier", "analyst", "critic", "planner", "writer"]);
-const WRITE_ROLES = new Set(["executor", "test-engineer"]);
-const READ_ONLY_COMMANDS = new Set(["cat", "head", "tail", "less", "more", "wc", "ls", "find", "grep", "rg", "awk", "sed", "echo", "printf", "which", "where", "whoami", "pwd", "env", "printenv", "date", "df", "du", "uname", "file", "stat", "diff", "sort", "uniq", "tr", "cut", "paste", "test", "true", "false", "type", "readlink", "realpath", "basename", "dirname", "sha256sum", "md5sum", "xxd", "hexdump", "od", "strings", "tree", "jq", "git", "gh"]);
-
-export interface PermissionCheckResult {
-	allowed: boolean;
-	mode: RolePermissionMode;
-	reason?: string;
-}
-
-export function permissionForRole(role: string): RolePermissionMode {
-	if (READ_ONLY_ROLES.has(role)) return "read_only";
-	if (WRITE_ROLES.has(role)) return "workspace_write";
-	return "workspace_write";
-}
-
-export function isReadOnlyCommand(command: string): boolean {
-	const first = command.trim().split(/\s+/)[0]?.split(/[\\/]/).pop() ?? "";
-	return READ_ONLY_COMMANDS.has(first) && !/\s(-i|--in-place)\b|\s>{1,2}\s|\brm\b|\bmv\b|\bcp\b|\bnpm\s+install\b|\bgit\s+(commit|push|merge|rebase|reset|checkout)\b/.test(command);
-}
-
-export function checkRolePermission(role: string, command: string): PermissionCheckResult {
-	const mode = permissionForRole(role);
-	if (mode === "read_only" && !isReadOnlyCommand(command)) return { allowed: false, mode, reason: `Role '${role}' is read-only and command may modify state.` };
-	return { allowed: true, mode };
-}
-
-export function currentCrewRole(env: NodeJS.ProcessEnv = process.env): string | undefined {
-	return env.PI_CREW_ROLE?.trim() || env.PI_TEAMS_ROLE?.trim() || undefined;
-}
-
-export function checkSubagentSpawnPermission(role: string | undefined): PermissionCheckResult {
-	if (!role) return { allowed: true, mode: "workspace_write" };
-	const mode = permissionForRole(role);
-	if (mode === "read_only") return { allowed: false, mode, reason: `Role '${role}' is read-only and cannot spawn additional subagents.` };
-	return { allowed: true, mode };
-}
+export type RolePermissionMode = "read_only" | "workspace_write" | "danger_full_access" | "explicit_confirm";
+
+const READ_ONLY_ROLES = new Set(["explorer", "reviewer", "security-reviewer", "verifier", "analyst", "critic", "planner", "writer"]);
+const WRITE_ROLES = new Set(["executor", "test-engineer"]);
+const READ_ONLY_COMMANDS = new Set(["cat", "head", "tail", "less", "more", "wc", "ls", "find", "grep", "rg", "awk", "sed", "echo", "printf", "which", "where", "whoami", "pwd", "env", "printenv", "date", "df", "du", "uname", "file", "stat", "diff", "sort", "uniq", "tr", "cut", "paste", "test", "true", "false", "type", "readlink", "realpath", "basename", "dirname", "sha256sum", "md5sum", "xxd", "hexdump", "od", "strings", "tree", "jq", "git", "gh"]);
+
+export interface PermissionCheckResult {
+	allowed: boolean;
+	mode: RolePermissionMode;
+	reason?: string;
+}
+
+export function permissionForRole(role: string): RolePermissionMode {
+	if (READ_ONLY_ROLES.has(role)) return "read_only";
+	if (WRITE_ROLES.has(role)) return "workspace_write";
+	return "workspace_write";
+}
+
+export function isReadOnlyCommand(command: string): boolean {
+	const first = command.trim().split(/\s+/)[0]?.split(/[\\/]/).pop() ?? "";
+	return READ_ONLY_COMMANDS.has(first) && !/\s(-i|--in-place)\b|\s>{1,2}\s|\brm\b|\bmv\b|\bcp\b|\bnpm\s+install\b|\bgit\s+(commit|push|merge|rebase|reset|checkout)\b/.test(command);
+}
+
+export function checkRolePermission(role: string, command: string): PermissionCheckResult {
+	const mode = permissionForRole(role);
+	if (mode === "read_only" && !isReadOnlyCommand(command)) return { allowed: false, mode, reason: `Role '${role}' is read-only and command may modify state.` };
+	return { allowed: true, mode };
+}
+
+export function currentCrewRole(env: NodeJS.ProcessEnv = process.env): string | undefined {
+	return env.PI_CREW_ROLE?.trim() || env.PI_TEAMS_ROLE?.trim() || undefined;
+}
+
+export function checkSubagentSpawnPermission(role: string | undefined): PermissionCheckResult {
+	if (!role) return { allowed: true, mode: "workspace_write" };
+	const mode = permissionForRole(role);
+	if (mode === "read_only") return { allowed: false, mode, reason: `Role '${role}' is read-only and cannot spawn additional subagents.` };
+	return { allowed: true, mode };
+}

package/src/runtime/session-usage.ts

@@ -1,79 +1,79 @@
-import * as fs from "node:fs";
-import type { UsageState } from "../state/types.ts";
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-
-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 usageFromValue(value: unknown): UsageState | undefined {
-	const obj = asRecord(value);
-	if (!obj) return undefined;
-	const direct: UsageState = {
-		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
-		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
-		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
-		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
-		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
-		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
-	};
-	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
-	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
-		const nested = usageFromValue(obj[key]);
-		if (nested) return nested;
-	}
-	const message = asRecord(obj.message);
-	return message ? usageFromValue(message.usage) : undefined;
-}
-
-function addUsage(total: UsageState, usage: UsageState): UsageState {
-	return {
-		input: (total.input ?? 0) + (usage.input ?? 0),
-		output: (total.output ?? 0) + (usage.output ?? 0),
-		cacheRead: (total.cacheRead ?? 0) + (usage.cacheRead ?? 0),
-		cacheWrite: (total.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
-		cost: (total.cost ?? 0) + (usage.cost ?? 0),
-		turns: (total.turns ?? 0) + (usage.turns ?? 0),
-	};
-}
-
-function compactUsage(total: UsageState, foundKeys: Set<keyof UsageState>): UsageState | undefined {
-	if (foundKeys.size === 0) return undefined;
-	const compact: UsageState = {};
-	for (const key of foundKeys) compact[key] = total[key];
-	return compact;
-}
-
-export function parseSessionUsageFromJsonlText(text: string): UsageState | undefined {
-	let total: UsageState = {};
-	const foundKeys = new Set<keyof UsageState>();
-	for (const line of text.split(/\r?\n/)) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		try {
-			const usage = usageFromValue(JSON.parse(trimmed) as unknown);
-			if (!usage) continue;
-			for (const key of Object.keys(usage) as Array<keyof UsageState>) foundKeys.add(key);
-			total = addUsage(total, usage);
-		} catch {
-			// Session JSONL can contain partial/corrupt lines after interrupted workers.
-		}
-	}
-	return compactUsage(total, foundKeys);
-}
-
-export function parseSessionUsage(filePath: string): UsageState | undefined {
-	try {
-		if (!fs.existsSync(filePath)) return undefined;
-		return parseSessionUsageFromJsonlText(fs.readFileSync(filePath, "utf-8"));
-	} catch {
-		return undefined;
-	}
-}
+import * as fs from "node:fs";
+import type { UsageState } from "../state/types.ts";
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+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 usageFromValue(value: unknown): UsageState | undefined {
+	const obj = asRecord(value);
+	if (!obj) return undefined;
+	const direct: UsageState = {
+		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
+		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
+		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
+		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
+		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
+		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
+	};
+	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
+	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
+		const nested = usageFromValue(obj[key]);
+		if (nested) return nested;
+	}
+	const message = asRecord(obj.message);
+	return message ? usageFromValue(message.usage) : undefined;
+}
+
+function addUsage(total: UsageState, usage: UsageState): UsageState {
+	return {
+		input: (total.input ?? 0) + (usage.input ?? 0),
+		output: (total.output ?? 0) + (usage.output ?? 0),
+		cacheRead: (total.cacheRead ?? 0) + (usage.cacheRead ?? 0),
+		cacheWrite: (total.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
+		cost: (total.cost ?? 0) + (usage.cost ?? 0),
+		turns: (total.turns ?? 0) + (usage.turns ?? 0),
+	};
+}
+
+function compactUsage(total: UsageState, foundKeys: Set<keyof UsageState>): UsageState | undefined {
+	if (foundKeys.size === 0) return undefined;
+	const compact: UsageState = {};
+	for (const key of foundKeys) compact[key] = total[key];
+	return compact;
+}
+
+export function parseSessionUsageFromJsonlText(text: string): UsageState | undefined {
+	let total: UsageState = {};
+	const foundKeys = new Set<keyof UsageState>();
+	for (const line of text.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const usage = usageFromValue(JSON.parse(trimmed) as unknown);
+			if (!usage) continue;
+			for (const key of Object.keys(usage) as Array<keyof UsageState>) foundKeys.add(key);
+			total = addUsage(total, usage);
+		} catch {
+			// Session JSONL can contain partial/corrupt lines after interrupted workers.
+		}
+	}
+	return compactUsage(total, foundKeys);
+}
+
+export function parseSessionUsage(filePath: string): UsageState | undefined {
+	try {
+		if (!fs.existsSync(filePath)) return undefined;
+		return parseSessionUsageFromJsonlText(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		return undefined;
+	}
+}

package/src/runtime/sidechain-output.ts

@@ -1,28 +1,28 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export interface SidechainEntry {
-	isSidechain: true;
-	agentId: string;
-	type: string;
-	message: unknown;
-	timestamp: string;
-	cwd: string;
-}
-
-export function writeSidechainEntry(filePath: string, entry: Omit<SidechainEntry, "isSidechain" | "timestamp">): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	fs.appendFileSync(filePath, `${JSON.stringify({ isSidechain: true, timestamp: new Date().toISOString(), ...entry })}\n`, "utf-8");
-}
-
-export function sidechainOutputPath(stateRoot: string, taskId: string): string {
-	return path.join(stateRoot, "agents", taskId, "sidechain.output.jsonl");
-}
-
-export function eventToSidechainType(event: unknown): string | undefined {
-	if (!event || typeof event !== "object" || Array.isArray(event)) return undefined;
-	const type = (event as { type?: unknown }).type;
-	if (type === "message_start" || type === "message_update" || type === "message_end") return "message";
-	if (type === "tool_execution_start" || type === "tool_execution_update" || type === "tool_execution_end") return "tool";
-	return typeof type === "string" ? type : undefined;
-}
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface SidechainEntry {
+	isSidechain: true;
+	agentId: string;
+	type: string;
+	message: unknown;
+	timestamp: string;
+	cwd: string;
+}
+
+export function writeSidechainEntry(filePath: string, entry: Omit<SidechainEntry, "isSidechain" | "timestamp">): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.appendFileSync(filePath, `${JSON.stringify({ isSidechain: true, timestamp: new Date().toISOString(), ...entry })}\n`, "utf-8");
+}
+
+export function sidechainOutputPath(stateRoot: string, taskId: string): string {
+	return path.join(stateRoot, "agents", taskId, "sidechain.output.jsonl");
+}
+
+export function eventToSidechainType(event: unknown): string | undefined {
+	if (!event || typeof event !== "object" || Array.isArray(event)) return undefined;
+	const type = (event as { type?: unknown }).type;
+	if (type === "message_start" || type === "message_update" || type === "message_end") return "message";
+	if (type === "tool_execution_start" || type === "tool_execution_update" || type === "tool_execution_end") return "tool";
+	return typeof type === "string" ? type : undefined;
+}

package/src/runtime/subagent-manager.ts

@@ -108,6 +108,9 @@ function totalRunTurns(cwd: string, runId: string | undefined): number | undefin
 
 export class SubagentManager {
 	private readonly records = new Map<string, SubagentRecord>();
+	private readonly cwdByRecord = new Map<string, string>();
+	private readonly controllers = new Map<string, AbortController>();
+	private readonly controllerCleanup = new Map<string, () => void>();
 	private queue: QueuedSpawn[] = [];
 	private runningBackground = 0;
 	private counter = 0;
@@ -135,6 +138,7 @@ export class SubagentManager {
 			background: options.background,
 		};
 		this.records.set(record.id, record);
+		this.cwdByRecord.set(record.id, options.cwd);
 		savePersistedSubagentRecord(options.cwd, record);
 		if (record.status === "queued") {
 			this.queue.push({ record, options, runner, signal });
@@ -157,28 +161,26 @@ export class SubagentManager {
 		if (!record) return false;
 		if (record.status === "queued") {
 			this.queue = this.queue.filter((entry) => entry.record.id !== id);
-			record.status = "stopped";
-			record.completedAt = Date.now();
+			this.markStopped(record);
 			return true;
 		}
 		if (record.status !== "running" && record.status !== "blocked") return false;
-		record.status = "stopped";
-		record.completedAt = Date.now();
+		this.controllers.get(id)?.abort();
+		this.markStopped(record);
 		return true;
 	}
 
 	abortAll(): number {
 		let count = 0;
 		for (const entry of this.queue) {
-			entry.record.status = "stopped";
-			entry.record.completedAt = Date.now();
+			this.markStopped(entry.record);
 			count++;
 		}
 		this.queue = [];
 		for (const record of this.records.values()) {
 			if (record.status === "running" || record.status === "blocked") {
-				record.status = "stopped";
-				record.completedAt = Date.now();
+				this.controllers.get(record.id)?.abort();
+				this.markStopped(record);
 				count++;
 			}
 		}
@@ -188,7 +190,7 @@ export class SubagentManager {
 	async waitForAll(): Promise<void> {
 		while (true) {
 			this.drainQueue();
-			const pending = this.listAgents().filter((record) => record.status === "running" || record.status === "blocked" || record.status === "queued").map((record) => record.promise).filter((promise): promise is Promise<void> => Boolean(promise));
+			const pending = this.listAgents().filter((record) => record.status === "running" || record.status === "queued").map((record) => record.promise).filter((promise): promise is Promise<void> => Boolean(promise));
 			if (!pending.length) break;
 			await Promise.allSettled(pending);
 		}
@@ -198,7 +200,7 @@ export class SubagentManager {
 		while (true) {
 			const record = this.records.get(id);
 			if (!record) return undefined;
-			if (record.status !== "running" && record.status !== "blocked" && record.status !== "queued") return record;
+			if (record.status !== "running" && record.status !== "queued") return record;
 			if (record.promise) await record.promise;
 			else await new Promise((resolve) => setTimeout(resolve, 100));
 		}
@@ -213,10 +215,13 @@ export class SubagentManager {
 		if (options.background) this.runningBackground++;
 		record.status = "running";
 		record.startedAt = Date.now();
+		record.completedAt = undefined;
+		const runSignal = this.createRunSignal(record.id, signal);
 		savePersistedSubagentRecord(options.cwd, record);
 		record.promise = (async () => {
 			try {
-				const result = await runner(options, signal);
+				const result = await runner(options, runSignal);
+				if (record.status === "stopped") return;
 				record.runId = detailsRunId(result);
 				record.result = resultText(result);
 				savePersistedSubagentRecord(options.cwd, record);
@@ -228,11 +233,16 @@ export class SubagentManager {
 				if (record.runId) await this.pollRunToTerminal(options.cwd, record);
 				else record.status = "completed";
 			} catch (error) {
+				if (record.status === "stopped" || runSignal.aborted) {
+					record.status = "stopped";
+					return;
+				}
 				record.status = "error";
 				record.error = error instanceof Error ? error.message : String(error);
 			} finally {
+				this.cleanupRunSignal(record.id);
 				if (options.background) this.runningBackground = Math.max(0, this.runningBackground - 1);
-				record.completedAt = record.completedAt ?? Date.now();
+				if (record.status !== "blocked") record.completedAt = record.completedAt ?? Date.now();
 				savePersistedSubagentRecord(options.cwd, record);
 				if (record.status === "completed" || record.status === "failed" || record.status === "cancelled" || record.status === "error" || record.status === "stopped") {
 					// Phase 1.6: Populate telemetry fields
@@ -246,6 +256,34 @@ export class SubagentManager {
 		})();
 	}
 
+	private markStopped(record: SubagentRecord): void {
+		record.status = "stopped";
+		record.completedAt = Date.now();
+		const cwd = this.cwdByRecord.get(record.id);
+		if (cwd) savePersistedSubagentRecord(cwd, record);
+	}
+
+	private createRunSignal(id: string, signal?: AbortSignal): AbortSignal {
+		const controller = new AbortController();
+		this.controllers.set(id, controller);
+		if (signal?.aborted) {
+			controller.abort();
+			return controller.signal;
+		}
+		if (signal) {
+			const abort = (): void => controller.abort();
+			signal.addEventListener("abort", abort, { once: true });
+			this.controllerCleanup.set(id, () => signal.removeEventListener("abort", abort));
+		}
+		return controller.signal;
+	}
+
+	private cleanupRunSignal(id: string): void {
+		this.controllerCleanup.get(id)?.();
+		this.controllerCleanup.delete(id);
+		this.controllers.delete(id);
+	}
+
 	private drainQueue(): void {
 		while (this.queue.length > 0 && this.runningBackground < this.maxConcurrent) {
 			const next = this.queue.shift();
@@ -286,6 +324,7 @@ export class SubagentManager {
 					record.completedAt = undefined;
 					this.onComplete?.(record);
 					this.scheduleStuckBlockedNotify(cwd, record);
+					this.scheduleBlockedTerminalPoll(cwd, record);
 				}
 				savePersistedSubagentRecord(cwd, record);
 				return;
@@ -294,6 +333,35 @@ export class SubagentManager {
 		}
 	}
 
+	private scheduleBlockedTerminalPoll(cwd: string, record: SubagentRecord): void {
+		const poll = (): void => {
+			const current = this.records.get(record.id);
+			if (!current || current.status !== "blocked" || !current.runId) return;
+			const loaded = loadRunManifestById(cwd, current.runId);
+			if (!loaded || loaded.manifest.status === "blocked" || loaded.manifest.status === "running" || loaded.manifest.status === "planning" || loaded.manifest.status === "queued") {
+				const timer = setTimeout(poll, this.pollIntervalMs);
+				timer.unref?.();
+				return;
+			}
+			const persisted = readPersistedSubagentRecord(cwd, current.id);
+			current.resultConsumed = current.resultConsumed || persisted?.resultConsumed;
+			if (loaded.manifest.status === "completed") {
+				current.status = "completed";
+				current.error = undefined;
+			} else if (loaded.manifest.status === "failed" || loaded.manifest.status === "cancelled") {
+				current.status = loaded.manifest.status;
+				current.error = loaded.manifest.summary;
+			} else return;
+			current.completedAt = Date.now();
+			current.turnCount = current.turnCount ?? totalRunTurns(cwd, current.runId);
+			current.durationMs = Math.max(0, current.completedAt - current.startedAt);
+			savePersistedSubagentRecord(cwd, current);
+			this.onComplete?.(current);
+		};
+		const timer = setTimeout(poll, this.pollIntervalMs);
+		timer.unref?.();
+	}
+
 	private scheduleStuckBlockedNotify(cwd: string, record: SubagentRecord): void {
 		const threshold = DEFAULT_SUBAGENT.stuckBlockedNotifyMs;
 		const fire = (): void => {

package/src/runtime/task-display.ts

@@ -1,38 +1,38 @@
-import type { TeamTaskState } from "../state/types.ts";
-import type { CrewAgentRecord, CrewRuntimeKind } from "./crew-agent-runtime.ts";
-import { recordFromTask } from "./crew-agent-records.ts";
-import type { TeamRunManifest } from "../state/types.ts";
-
-export function shouldMaterializeAgent(task: TeamTaskState): boolean {
-	return task.status !== "queued" && task.status !== "skipped";
-}
-
-export function recordsForMaterializedTasks(manifest: TeamRunManifest, tasks: TeamTaskState[], runtime: CrewRuntimeKind): CrewAgentRecord[] {
-	return tasks.filter(shouldMaterializeAgent).map((task) => recordFromTask(manifest, task, runtime));
-}
-
-export function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
-	const map = new Map<string, TeamTaskState>();
-	for (const task of tasks) {
-		map.set(task.id, task);
-		if (task.stepId) map.set(task.stepId, task);
-	}
-	return map;
-}
-
-export function waitingReason(task: TeamTaskState, tasks: TeamTaskState[]): string | undefined {
-	if (task.status !== "queued") return undefined;
-	const byId = taskById(tasks);
-	const waiting = task.dependsOn.map((id) => byId.get(id)?.id ?? id).filter((id) => byId.get(id)?.status !== "completed");
-	if (waiting.length === 0) return "ready";
-	return `waiting for ${waiting.join(", ")}`;
-}
-
-export function formatTaskGraphLines(tasks: TeamTaskState[]): string[] {
-	if (tasks.length === 0) return ["- (none)"];
-	return tasks.map((task) => {
-		const icon = task.status === "completed" ? "✓" : task.status === "running" ? "⠋" : task.status === "failed" ? "✗" : task.status === "cancelled" || task.status === "skipped" ? "■" : "◦";
-		const wait = waitingReason(task, tasks);
-		return `- ${icon} ${task.id} [${task.status}] ${task.role}->${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
-	});
-}
+import type { TeamTaskState } from "../state/types.ts";
+import type { CrewAgentRecord, CrewRuntimeKind } from "./crew-agent-runtime.ts";
+import { recordFromTask } from "./crew-agent-records.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+
+export function shouldMaterializeAgent(task: TeamTaskState): boolean {
+	return task.status !== "queued" && task.status !== "skipped";
+}
+
+export function recordsForMaterializedTasks(manifest: TeamRunManifest, tasks: TeamTaskState[], runtime: CrewRuntimeKind): CrewAgentRecord[] {
+	return tasks.filter(shouldMaterializeAgent).map((task) => recordFromTask(manifest, task, runtime));
+}
+
+export function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
+	const map = new Map<string, TeamTaskState>();
+	for (const task of tasks) {
+		map.set(task.id, task);
+		if (task.stepId) map.set(task.stepId, task);
+	}
+	return map;
+}
+
+export function waitingReason(task: TeamTaskState, tasks: TeamTaskState[]): string | undefined {
+	if (task.status !== "queued") return undefined;
+	const byId = taskById(tasks);
+	const waiting = task.dependsOn.map((id) => byId.get(id)?.id ?? id).filter((id) => byId.get(id)?.status !== "completed");
+	if (waiting.length === 0) return "ready";
+	return `waiting for ${waiting.join(", ")}`;
+}
+
+export function formatTaskGraphLines(tasks: TeamTaskState[]): string[] {
+	if (tasks.length === 0) return ["- (none)"];
+	return tasks.map((task) => {
+		const icon = task.status === "completed" ? "✓" : task.status === "running" ? "⠋" : task.status === "failed" ? "✗" : task.status === "cancelled" || task.status === "skipped" ? "■" : "◦";
+		const wait = waitingReason(task, tasks);
+		return `- ${icon} ${task.id} [${task.status}] ${task.role}->${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
+	});
+}