pi-crew 0.9.16 → 0.9.18

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,12 +56,9 @@ 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 totalPossibilities = 36 ** length;
 		const probability = 1 - Math.exp(-(existingCount * existingCount) / (2 * totalPossibilities));
 		if (probability <= config.maxCollisionProbability) {
 			return length;
@@ -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) ──────────────────────