pi-crew 0.9.15 → 0.9.17

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

@@ -17,9 +17,16 @@ export interface TaskGraphIndex {
 
 export function buildTaskGraphIndex(tasks: TeamTaskState[]): TaskGraphIndex {
 	return {
-		doneSteps: new Set(tasks.filter((task) => task.status === "completed").map((task) => task.stepId).filter((id): id is string => id !== undefined)),
+		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)),
+		stepToTaskId: new Map(
+			tasks.map((task) => [task.stepId, task.id]).filter((entry): entry is [string, string] => entry[0] !== undefined),
+		),
 	};
 }
 
@@ -27,7 +34,12 @@ 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 {
+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;
@@ -38,15 +50,27 @@ function dependencySatisfied(task: TeamTaskState, doneStepIds: Set<string>, idMa
 function withQueue(task: TeamTaskState, index: TaskGraphIndex): TeamTaskState {
 	if (task.status === "queued") {
 		const isReady = dependencySatisfied(task, index.doneSteps, index.idMap, index.stepToTaskId);
-		return { ...task, graph: task.graph ? { ...task.graph, queue: isReady ? "ready" : "blocked" } : task.graph };
+		return {
+			...task,
+			graph: task.graph ? { ...task.graph, queue: isReady ? "ready" : "blocked" } : task.graph,
+		};
 	}
 	if (task.status === "running") {
-		return { ...task, graph: task.graph ? { ...task.graph, queue: "running" } : task.graph };
+		return {
+			...task,
+			graph: task.graph ? { ...task.graph, queue: "running" } : task.graph,
+		};
 	}
 	if (task.status === "completed" || task.status === "skipped" || task.status === "needs_attention") {
-		return { ...task, graph: task.graph ? { ...task.graph, queue: "done" } : task.graph };
+		return {
+			...task,
+			graph: task.graph ? { ...task.graph, queue: "done" } : task.graph,
+		};
 	}
-	return { ...task, graph: task.graph ? { ...task.graph, queue: "blocked" } : task.graph };
+	return {
+		...task,
+		graph: task.graph ? { ...task.graph, queue: "blocked" } : task.graph,
+	};
 }
 
 function ensureIndex(tasks: TeamTaskState[], index?: TaskGraphIndex): TaskGraphIndex {
@@ -59,20 +83,49 @@ export function refreshTaskGraphQueues(tasks: TeamTaskState[], index?: TaskGraph
 }
 
 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));
+	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);
+	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);
+	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[] {
+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];
@@ -83,11 +136,18 @@ export function cancelTaskSubtree(tasks: TeamTaskState[], rootTaskId: string, re
 		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() };
-	}));
+	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[] {
@@ -102,11 +162,25 @@ export function failTaskAndBlockChildren(tasks: TeamTaskState[], rootTaskId: str
 		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;
-	}));
+	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 {

package/src/runtime/task-graph.ts

@@ -34,7 +34,7 @@ export interface ExecutionPlan {
  * - 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 {
@@ -50,7 +50,7 @@ export function buildExecutionPlan(tasks: TaskNode[]): ExecutionPlan {
 	}
 
 	const idSet = new Set<string>(tasks.map((t) => t.id));
-	const adjacency = new Map<string, Set<string>>();       // id -> ids that depend on it
+	const adjacency = new Map<string, Set<string>>(); // id -> ids that depend on it
 	const inDegree = new Map<string, number>();
 
 	for (const task of tasks) {
@@ -71,9 +71,7 @@ export function buildExecutionPlan(tasks: TaskNode[]): ExecutionPlan {
 	// 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 currentWaveIds = tasks.filter((t) => inDegree.get(t.id) === 0).map((t) => t.id);
 
 	let waveIndex = 0;
 	while (currentWaveIds.length > 0) {
@@ -98,9 +96,7 @@ export function buildExecutionPlan(tasks: TaskNode[]): ExecutionPlan {
 
 	// 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);
+		const cycleNodes = tasks.filter((t) => !assigned.has(t.id)).map((t) => t.id);
 		return {
 			waves,
 			hasCycle: true,
@@ -143,9 +139,7 @@ export function getReadyTasks(plan: ExecutionPlan, completedTaskIds: Set<string>
 
 	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)));
+		const priorWavesComplete = plan.waves.slice(0, wave.index).every((w) => w.taskIds.every((id) => completed.has(id)));
 
 		if (!priorWavesComplete) continue;
 

package/src/runtime/task-health.ts

@@ -1,76 +1,83 @@
 export type HealthGrade = "A" | "B" | "C" | "D" | "F";
 
 export interface HealthPenalty {
-  reason: string;
-  deduction: number;
+	reason: string;
+	deduction: number;
 }
 
 export interface HealthDelta {
-  metric: string;
-  delta: number;
-  trend: "improving" | "degrading" | "stable";
+	metric: string;
+	delta: number;
+	trend: "improving" | "degrading" | "stable";
 }
 
 export interface RunHealth {
-  score: number;
-  grade: HealthGrade;
-  penalties: HealthPenalty[];
-  deltas: HealthDelta[];
+	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";
+	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;
+	id: string;
+	status: string;
+	stalledSince?: number;
 }
 
 export interface ManifestSummary {
-  runId: string;
-  tasks: TaskSummary[];
-  createdAt: string;
+	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 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 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) });
-  }
+	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 (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)) });
-  }
+	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));
+	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: [],
-  };
-}
+	return {
+		score,
+		grade: scoreToGrade(score),
+		penalties,
+		deltas: [],
+	};
+}

package/src/runtime/task-id.ts

@@ -56,10 +56,7 @@ export function hashToBase36(content: string, length: number): string {
  * @param config - Adaptive configuration
  * @returns Recommended hash length
  */
-export function calculateAdaptiveLength(
-	existingCount: number,
-	config: AdaptiveIDConfig = DEFAULT_CONFIG,
-): number {
+export function calculateAdaptiveLength(existingCount: number, config: AdaptiveIDConfig = DEFAULT_CONFIG): number {
 	for (let length = config.minLength; length <= config.maxLength; length++) {
 		const totalPossibilities = Math.pow(36, length);
 		const probability = 1 - Math.exp(-(existingCount * existingCount) / (2 * totalPossibilities));
@@ -78,11 +75,7 @@ export function calculateAdaptiveLength(
  * @param existingCount - Number of existing IDs (for adaptive length)
  * @returns Hash-based ID like "pc-a1b2"
  */
-export function generateTaskHashId(
-	parts: string[],
-	prefix = DEFAULT_PREFIX,
-	existingCount = 0,
-): string {
+export function generateTaskHashId(parts: string[], prefix = DEFAULT_PREFIX, existingCount = 0): string {
 	const content = parts.join("|");
 	const length = calculateAdaptiveLength(existingCount);
 	const hash = hashToBase36(content, length);
@@ -137,15 +130,15 @@ export function childId(parentId: string, childNum: number): string {
  * Only "blocks" and "parent-child" affect execution ordering.
  */
 export type DependencyType =
-	| "blocks"              // A must complete before B starts
-	| "parent-child"        // Hierarchical relationship
-	| "conditional-blocks"  // B runs only if A fails
-	| "waits-for"           // Fanout gate: wait for dynamic children
-	| "related"             // Association only (no ordering)
-	| "supersedes"          // A replaces B
-	| "duplicates"          // A duplicates B
-	| "delegated-from"      // A was delegated from B
-	| "validates";          // A validates B's output
+	| "blocks" // A must complete before B starts
+	| "parent-child" // Hierarchical relationship
+	| "conditional-blocks" // B runs only if A fails
+	| "waits-for" // Fanout gate: wait for dynamic children
+	| "related" // Association only (no ordering)
+	| "supersedes" // A replaces B
+	| "duplicates" // A duplicates B
+	| "delegated-from" // A was delegated from B
+	| "validates"; // A validates B's output
 
 // ── Stable IDs (full hash, for cross-run references) ──────────────────────