pi-crew 0.9.50 → 0.9.52

package/src/runtime/task-display.ts

@@ -1,52 +0,0 @@
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { recordFromTask } from "./crew-agent-records.ts";
-import type { CrewAgentRecord, CrewRuntimeKind } from "./crew-agent-runtime.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"
-							? "■"
-							: task.status === "needs_attention"
-								? "⚠"
-								: "◦";
-		const wait = waitingReason(task, tasks);
-		return `- ${icon} ${task.id} [${task.status}] ${task.role}->${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
-	});
-}

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

@@ -1,227 +0,0 @@
-import type { TeamTaskState } from "../state/types.ts";
-
-export interface TaskGraphSchedulerSnapshot {
-	ready: string[];
-	blocked: string[];
-	running: string[];
-	done: string[];
-	failed: string[];
-	cancelled: string[];
-}
-
-export interface TaskGraphIndex {
-	doneSteps: Set<string>;
-	idMap: Map<string, TeamTaskState>;
-	stepToTaskId: Map<string, string>;
-}
-
-/**
- * P14 (perf): identity-keyed memoization for `buildTaskGraphIndex`. The 3
- * data structures built here (doneSteps Set, idMap Map, stepToTaskId Map) are
- * a function of the task list alone — if the caller passes the SAME array
- * reference twice (e.g., across `refreshTaskGraphQueues` -> `getReadyTasks`
- * rounds within one main-loop iteration before any new tasks land), we can
- * reuse the cached index. The cache is invalidated naturally by a new array
- * reference (e.g., the result of `markTaskRunning` / `markTaskDone`).
- *
- * Memozation is a WeakMap so a stale reference is collected when the array
- * goes out of scope — no manual invalidation needed, no unbounded growth.
- */
-const taskGraphIndexCache = new WeakMap<TeamTaskState[], TaskGraphIndex>();
-
-export function buildTaskGraphIndex(tasks: TeamTaskState[]): TaskGraphIndex {
-	const cached = taskGraphIndexCache.get(tasks);
-	if (cached) return cached;
-	const fresh: TaskGraphIndex = {
-		doneSteps: new Set(
-			tasks
-				.filter((task) => task.status === "completed")
-				.map((task) => task.stepId)
-				.filter((id): id is string => id !== undefined),
-		),
-		idMap: new Map(tasks.map((task) => [task.id, task])),
-		stepToTaskId: new Map(
-			tasks.map((task) => [task.stepId, task.id]).filter((entry): entry is [string, string] => entry[0] !== undefined),
-		),
-	};
-	taskGraphIndexCache.set(tasks, fresh);
-	return fresh;
-}
-
-/** Test/diagnostic helper — invalidate the WeakMap-backed index cache. Not
- *  used by production code paths; the WeakMap self-invalidates when a tasks
- *  array goes out of scope. Provided for parity with `clearStablePrefixCache`. */
-export function clearTaskGraphIndexCache(): void {
-	// WeakMap has no `.clear()`; rely on GC. Exposed as a no-op stub so callers
-	// that import `clearStablePrefixCache` (also a no-op stub for symmetry) can
-	// adopt a parallel API if needed in the future. Documented as no-op rather
-	// than removed so the API stays discoverable.
-}
-
-function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
-	return new Map(tasks.map((task) => [task.id, task]));
-}
-
-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, index: TaskGraphIndex): TeamTaskState {
-	let resolvedQueue: "ready" | "blocked" | "running" | "done";
-	if (task.status === "queued") {
-		const isReady = dependencySatisfied(task, index.doneSteps, index.idMap, index.stepToTaskId);
-		resolvedQueue = isReady ? "ready" : "blocked";
-	} else if (task.status === "running") {
-		resolvedQueue = "running";
-	} else if (task.status === "completed" || task.status === "skipped" || task.status === "needs_attention") {
-		resolvedQueue = "done";
-	} else {
-		resolvedQueue = "blocked";
-	}
-
-	// FIX (incremental task graph refresh): return the SAME task reference when
-	// the computed queue already matches task.graph.queue. This eliminates the
-	// per-task per-call spread allocation that previously ran on every
-	// refreshTaskGraphQueues invocation. Common case (queue unchanged from the
-	// previous refresh) is now allocation-free; reference-stable tasks also let
-	// downstream selectors skip re-rendering when queues haven't moved.
-	if (task.graph && task.graph.queue === resolvedQueue) {
-		return task;
-	}
-
-	return {
-		...task,
-		graph: task.graph ? { ...task.graph, queue: resolvedQueue } : task.graph,
-	};
-}
-
-function ensureIndex(tasks: TeamTaskState[], index?: TaskGraphIndex): TaskGraphIndex {
-	return index ?? buildTaskGraphIndex(tasks);
-}
-
-export function refreshTaskGraphQueues(tasks: TeamTaskState[], index?: TaskGraphIndex): TeamTaskState[] {
-	const resolved = ensureIndex(tasks, index);
-	return tasks.map((task) => withQueue(task, resolved));
-}
-
-export function getReadyTasks(tasks: TeamTaskState[], maxCount = 1, index?: TaskGraphIndex): TeamTaskState[] {
-	return refreshTaskGraphQueues(tasks, index)
-		.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(), index?: TaskGraphIndex): TeamTaskState[] {
-	const resolved = ensureIndex(tasks, index);
-	return refreshTaskGraphQueues(tasks, resolved).map((task) =>
-		task.id === taskId
-			? withQueue(
-					{
-						...task,
-						status: "running",
-						startedAt: task.startedAt ?? now.toISOString(),
-					},
-					resolved,
-				)
-			: task,
-	);
-}
-
-export function markTaskDone(tasks: TeamTaskState[], taskId: string, now = new Date(), index?: TaskGraphIndex): TeamTaskState[] {
-	const resolved = ensureIndex(tasks, index);
-	return refreshTaskGraphQueues(
-		tasks.map((task) =>
-			task.id === taskId
-				? {
-						...task,
-						status: "completed",
-						finishedAt: task.finishedAt ?? now.toISOString(),
-					}
-				: task,
-		),
-		resolved,
-	);
-}
-
-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[], index?: TaskGraphIndex): TaskGraphSchedulerSnapshot {
-	const refreshed = refreshTaskGraphQueues(tasks, index);
-	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-graph.ts

@@ -1,290 +0,0 @@
-/**
- * DAG-based task execution order calculator.
- *
- * Uses Kahn's algorithm for topological sort and DFS for cycle detection.
- * Groups tasks into parallel "waves" where all tasks in wave N can run
- * concurrently and wave N+1 depends on at least one task in wave N.
- */
-
-/** A lightweight node representation for the execution DAG. */
-export interface TaskNode {
-	id: string;
-	dependsOn: string[];
-	phase?: string;
-}
-
-/** A group of tasks that can all run in parallel. */
-export interface ExecutionWave {
-	index: number;
-	taskIds: string[];
-	label?: string;
-}
-
-/** The full execution plan produced by topological sort. */
-export interface ExecutionPlan {
-	waves: ExecutionWave[];
-	hasCycle: boolean;
-	cycleNodes?: string[];
-}
-
-/**
- * Build an execution plan from a flat list of task nodes using Kahn's algorithm.
- *
- * - Tasks with empty `dependsOn` go into wave 0.
- * - Each subsequent wave contains tasks whose dependencies are all in earlier waves.
- * - If all tasks have empty `dependsOn`, they all go into wave 0 (backward compatible).
- * - If a cycle is detected, `hasCycle` is true and `cycleNodes` lists the involved IDs.
- *
- * @throws Error if a task depends on itself (self-dependency).
- */
-export function buildExecutionPlan(tasks: TaskNode[]): ExecutionPlan {
-	if (tasks.length === 0) {
-		return { waves: [], hasCycle: false };
-	}
-
-	// HIGH-9: Detect self-dependency
-	for (const task of tasks) {
-		if (task.dependsOn.includes(task.id)) {
-			throw new Error(`Task "${task.id}" has self-dependency (depends on itself)`);
-		}
-	}
-
-	const idSet = new Set<string>(tasks.map((t) => t.id));
-	const adjacency = new Map<string, Set<string>>(); // id -> ids that depend on it
-	const inDegree = new Map<string, number>();
-
-	for (const task of tasks) {
-		adjacency.set(task.id, new Set<string>());
-		inDegree.set(task.id, 0);
-	}
-
-	for (const task of tasks) {
-		let degree = 0;
-		for (const dep of task.dependsOn) {
-			if (!idSet.has(dep)) continue; // ignore unknown deps
-			adjacency.get(dep)!.add(task.id);
-			degree++;
-		}
-		inDegree.set(task.id, degree);
-	}
-
-	// Kahn's algorithm with wave grouping
-	const waves: ExecutionWave[] = [];
-	const assigned = new Set<string>();
-	let currentWaveIds = tasks.filter((t) => inDegree.get(t.id) === 0).map((t) => t.id);
-
-	let waveIndex = 0;
-	while (currentWaveIds.length > 0) {
-		for (const id of currentWaveIds) assigned.add(id);
-
-		const wave = buildWave(tasks, currentWaveIds, waveIndex);
-		waves.push(wave);
-
-		// Decrement in-degrees for dependents
-		const nextWaveCandidates = new Set<string>();
-		for (const id of currentWaveIds) {
-			for (const dependent of adjacency.get(id) ?? []) {
-				const current = inDegree.get(dependent)!;
-				inDegree.set(dependent, current - 1);
-				if (current - 1 === 0) nextWaveCandidates.add(dependent);
-			}
-		}
-
-		currentWaveIds = [...nextWaveCandidates];
-		waveIndex++;
-	}
-
-	// Detect cycle: if not all tasks were assigned, remaining ones form cycles
-	if (assigned.size < tasks.length) {
-		const cycleNodes = tasks.filter((t) => !assigned.has(t.id)).map((t) => t.id);
-		return {
-			waves,
-			hasCycle: true,
-			cycleNodes,
-		};
-	}
-
-	return { waves, hasCycle: false };
-}
-
-/**
- * Derive the phase label for a wave. If all tasks in the wave share the same
- * `phase` value, use it as the wave label; otherwise leave it undefined.
- */
-function buildWave(tasks: TaskNode[], ids: string[], index: number): ExecutionWave {
-	const taskMap = new Map(tasks.map((t) => [t.id, t]));
-	// MEDIUM-12: Filter out undefined values instead of using non-null assertion
-	const waveTasks = ids.map((id) => taskMap.get(id)).filter(Boolean) as TaskNode[];
-
-	let label: string | undefined;
-	if (waveTasks.length > 0 && waveTasks.every((t) => t.phase !== undefined)) {
-		const phases = new Set(waveTasks.map((t) => t.phase));
-		if (phases.size === 1) label = [...phases][0];
-	}
-
-	return { index, taskIds: ids, label };
-}
-
-/**
- * Return the IDs of tasks that are ready to run given a set of completed tasks.
- *
- * A task is "ready" when all its dependencies are in `completedTaskIds` AND
- * it has not already been completed itself. Returns tasks from the earliest
- * wave that still has uncompleted tasks.
- */
-export function getReadyTasks(plan: ExecutionPlan, completedTaskIds: Set<string>): string[] {
-	if (plan.hasCycle || plan.waves.length === 0) return [];
-
-	const completed = completedTaskIds;
-
-	for (const wave of plan.waves) {
-		// All tasks in prior waves must be completed for this wave to be ready
-		const priorWavesComplete = plan.waves.slice(0, wave.index).every((w) => w.taskIds.every((id) => completed.has(id)));
-
-		if (!priorWavesComplete) continue;
-
-		// Filter to tasks not already completed
-		const ready = wave.taskIds.filter((id) => !completed.has(id));
-		if (ready.length > 0) return ready;
-	}
-
-	return [];
-}
-
-/**
- * Detect all cycles in the task graph using DFS.
- *
- * Returns an array of cycles, where each cycle is represented as an array of
- * task IDs forming a path from a node back to itself.
- */
-export function detectCycles(tasks: TaskNode[]): string[][] {
-	if (tasks.length === 0) return [];
-
-	const idSet = new Set<string>(tasks.map((t) => t.id));
-	const adjacency = new Map<string, string[]>();
-	for (const task of tasks) {
-		adjacency.set(
-			task.id,
-			task.dependsOn.filter((dep) => idSet.has(dep)),
-		);
-	}
-
-	const WHITE = 0;
-	const GRAY = 1;
-	const BLACK = 2;
-
-	const color = new Map<string, number>();
-	for (const task of tasks) color.set(task.id, WHITE);
-
-	const cycles: string[][] = [];
-	const path: string[] = [];
-
-	function dfs(nodeId: string): void {
-		color.set(nodeId, GRAY);
-		path.push(nodeId);
-
-		const deps = adjacency.get(nodeId) ?? [];
-		for (const dep of deps) {
-			const depColor = color.get(dep);
-			if (depColor === GRAY) {
-				// Found a cycle: extract the path from dep to current node
-				const cycleStart = path.indexOf(dep);
-				if (cycleStart >= 0) {
-					cycles.push(path.slice(cycleStart));
-				}
-			} else if (depColor === WHITE) {
-				dfs(dep);
-			}
-		}
-
-		path.pop();
-		color.set(nodeId, BLACK);
-	}
-
-	for (const task of tasks) {
-		if (color.get(task.id) === WHITE) {
-			dfs(task.id);
-		}
-	}
-
-	return cycles;
-}
-
-/**
- * Find tasks that are blocked (not completed, have incomplete dependencies).
- *
- * Pattern origin: pi-blueprint dependency-graph.ts findBlockedTasks()
- *
- * @param tasks - All task nodes
- * @param completedIds - Set of completed task IDs
- * @returns Array of blocked task IDs
- */
-export function findBlockedTasks(tasks: TaskNode[], completedIds: Set<string>): string[] {
-	return tasks
-		.filter((t) => !completedIds.has(t.id))
-		.filter((t) => t.dependsOn.some((dep) => !completedIds.has(dep)))
-		.map((t) => t.id);
-}
-
-/**
- * Get specific incomplete dependencies blocking a task.
- *
- * Pattern origin: pi-blueprint dependency-graph.ts getBlockingTasks()
- *
- * @param tasks - All task nodes
- * @param taskId - The task to check
- * @param completedIds - Set of completed task IDs
- * @returns Array of blocking task IDs
- */
-export function getBlockingTasks(tasks: TaskNode[], taskId: string, completedIds: Set<string>): string[] {
-	const task = tasks.find((t) => t.id === taskId);
-	if (!task) return [];
-	return task.dependsOn.filter((dep) => !completedIds.has(dep));
-}
-
-/**
- * Topological sort using Kahn's BFS algorithm.
- *
- * Pattern origin: pi-blueprint dependency-graph.ts topologicalSort()
- *
- * @param tasks - All task nodes
- * @returns Ordered array of task IDs (dependencies first)
- */
-export function topologicalSort(tasks: TaskNode[]): string[] {
-	if (tasks.length === 0) return [];
-
-	const idSet = new Set(tasks.map((t) => t.id));
-	const inDegree = new Map<string, number>();
-	const adjacency = new Map<string, string[]>();
-
-	for (const task of tasks) {
-		inDegree.set(task.id, 0);
-		adjacency.set(task.id, []);
-	}
-
-	for (const task of tasks) {
-		for (const dep of task.dependsOn) {
-			if (!idSet.has(dep)) continue;
-			adjacency.get(dep)!.push(task.id);
-			inDegree.set(task.id, (inDegree.get(task.id) ?? 0) + 1);
-		}
-	}
-
-	const queue: string[] = [];
-	for (const [id, deg] of inDegree) {
-		if (deg === 0) queue.push(id);
-	}
-
-	const result: string[] = [];
-	while (queue.length > 0) {
-		const id = queue.shift()!;
-		result.push(id);
-		for (const dependent of adjacency.get(id) ?? []) {
-			const deg = inDegree.get(dependent)! - 1;
-			inDegree.set(dependent, deg);
-			if (deg === 0) queue.push(dependent);
-		}
-	}
-
-	return result;
-}

package/src/runtime/task-health.ts

@@ -1,83 +0,0 @@
-export type HealthGrade = "A" | "B" | "C" | "D" | "F";
-
-export interface HealthPenalty {
-	reason: string;
-	deduction: number;
-}
-
-export interface HealthDelta {
-	metric: string;
-	delta: number;
-	trend: "improving" | "degrading" | "stable";
-}
-
-export interface RunHealth {
-	score: number;
-	grade: HealthGrade;
-	penalties: HealthPenalty[];
-	deltas: HealthDelta[];
-}
-
-const STALLED_THRESHOLD_MS = 5 * 60 * 1000;
-
-export function scoreToGrade(score: number): HealthGrade {
-	if (score >= 90) return "A";
-	if (score >= 70) return "B";
-	if (score >= 50) return "C";
-	if (score >= 30) return "D";
-	return "F";
-}
-
-export interface TaskSummary {
-	id: string;
-	status: string;
-	stalledSince?: number;
-}
-
-export interface ManifestSummary {
-	runId: string;
-	tasks: TaskSummary[];
-	createdAt: string;
-}
-
-export function computeRunHealth(manifest: ManifestSummary): RunHealth {
-	const penalties: HealthPenalty[] = [];
-	const tasks = manifest.tasks;
-	const taskCount = tasks.length;
-	if (taskCount === 0) return { score: 100, grade: "A", penalties: [], deltas: [] };
-
-	const failedCount = tasks.filter((t) => t.status === "failed").length;
-	const stalledCount = tasks.filter((t) => t.stalledSince !== undefined && Date.now() - t.stalledSince > STALLED_THRESHOLD_MS).length;
-
-	const failureRate = failedCount / taskCount;
-	if (failureRate > 0.2) {
-		penalties.push({
-			reason: "high-failure-rate",
-			deduction: Math.round(failureRate * 50),
-		});
-	}
-
-	if (stalledCount > 0) {
-		penalties.push({
-			reason: "stalled-tasks",
-			deduction: Math.min(15, stalledCount * 5),
-		});
-	}
-
-	if (taskCount > 20) {
-		penalties.push({
-			reason: "large-task-count",
-			deduction: Math.min(10, Math.floor((taskCount - 20) / 10)),
-		});
-	}
-
-	const totalDeduction = penalties.reduce((sum, p) => sum + p.deduction, 0);
-	const score = Math.max(0, Math.min(100, 100 - totalDeduction));
-
-	return {
-		score,
-		grade: scoreToGrade(score),
-		penalties,
-		deltas: [],
-	};
-}