infinity-harness 2.6.6 → 2.8.0

package/src/scheduler.ts

@@ -8,10 +8,12 @@
 
 import type { HarnessConfig, HandoffGranularity, Phase } from "./core/types.ts";
 import { loadFeatureList, tasksForPhase, type FlatTask, flattenTasks } from "./core/featureList.ts";
-import { loadRouterConfig } from "./modelRouter.ts";
+import { loadRouterConfig, resolveModel } from "./modelRouter.ts";
 import { spawnIsolatedWorker, type SpawnWorkerResult } from "./worker.ts";
 import { runIdFor } from "./runState.ts";
 import { loadConfig } from "./core/config.ts";
+import { loadRunState } from "./core/runState.ts";
+import { isCapExceeded } from "./daemon/budget.ts";
 
 /** Difficulty ranking — higher wins when collapsing a bucket to its hardest. */
 const DIFFICULTY_RANK: Record<string, number> = { easy: 1, moderate: 2, difficult: 3 };
@@ -20,10 +22,13 @@ function hardestDifficulty(tasks: Array<{ difficulty?: string }>): string | unde
   let best: string | undefined;
   let bestRank = -1;
   for (const t of tasks) {
-    const d = (t as { difficulty?: string }).difficulty;
+    const d = t.difficulty;
     if (!d) continue;
     const r = DIFFICULTY_RANK[d] ?? -1;
-    if (r > bestRank) { bestRank = r; best = d; }
+    if (r > bestRank) {
+      bestRank = r;
+      best = d;
+    }
   }
   return best;
 }
@@ -47,7 +52,6 @@ function goalIdForTask(task: FlatTask, list: import("./core/types.ts").FeatureLi
  *   - handoff phase  → all tasks in that phase share one model (hardest in phase)
  *   - handoff feature → tasks in feature share hardest in feature
  *   - handoff task   → subtasks share their parent task's model
- * Shown in wizard + dashboard so the user knows the trade-off.
  */
 export function effectiveDifficultyForTask(
   task: FlatTask,
@@ -56,16 +60,14 @@ export function effectiveDifficultyForTask(
 ): string | undefined {
   const own = (task as { difficulty?: string }).difficulty;
   if (handoff === "task" || handoff === "subtask" || handoff === "off") {
-    // task/subtask: subtasks are not separate tasks, so they inherit the task
-    // off: one session for whole run — hardest in whole plan (most conservative)
     if (handoff === "off") {
       const globalHardest = hardestDifficulty(flattenTasks(list) as unknown as Array<{ difficulty?: string }>);
       return globalHardest ?? own;
     }
     return own;
   }
-  let bucket: FlatTask[] = [];
   const all = flattenTasks(list);
+  let bucket: FlatTask[] = [];
   if (handoff === "phase") {
     const phase = (task as { effectivePhase?: string }).effectivePhase ?? "build";
     bucket = all.filter((t) => (t as { effectivePhase?: string }).effectivePhase === phase);
@@ -118,170 +120,142 @@ export type PickOpts = {
   exclude?: Set<string>;
 };
 
-/** Snapshot a worker's attempt dir for the widget/dashboard. */
-export type WorkerSnapshot = {
-  featureId: string;
-  taskId: string;
-  compositeKey: string;
-  attemptDir: string;
-  attempt: number;
-  state: "running" | "done" | "failed";
-  outputTail: string;
-  askedAt?: string;
-};
+// ── pick helpers ────────────────────────────────────────────────────────────
 
-/** Tail a worker attempt's output.log (best-effort, never throws). */
-export function tailWorkerOutput(attemptDir: string, bytes = 3000): string {
+function isBudgetFull(targetDir: string): boolean {
   try {
-    const { readFileSync, existsSync } = require("node:fs") as typeof import("node:fs");
-    const p = (require("node:path") as typeof import("node:path")).join(attemptDir, "output.log");
-    if (!existsSync(p)) return "";
-    const raw = readFileSync(p, "utf-8") as string;
-    return raw.slice(-bytes);
-  } catch { return ""; }
+    const rs = loadRunState(targetDir);
+    if (!rs?.budget) return false;
+    return isCapExceeded(rs.budget as never).exceeded;
+  } catch {
+    return false;
+  }
 }
 
-export function listWorkers(targetDir: string, runId?: string): WorkerSnapshot[] {
-  try {
-    const { readdirSync, existsSync } = require("node:fs") as typeof import("node:fs");
-    const path = require("node:path") as typeof import("node:path");
-    const root = path.resolve(targetDir, "tmp/infinity-harness", runId ?? "");
-    const roots: string[] = [];
-    if (runId) {
-      roots.push(path.resolve(targetDir, "tmp/infinity-harness", runId));
-    } else {
-      // all runs under tmp/infinity-harness
-      const base = path.resolve(targetDir, "tmp/infinity-harness");
-      if (existsSync(base)) for (const e of readdirSync(base,{ withFileTypes: true } as any)) if((e as any).isDirectory()) roots.push(path.join(base,(e as any).name));
-    }
-    const out: WorkerSnapshot[] = [];
-    for (const run of roots) {
-      if (!existsSync(run)) continue;
-      // run/feature/task/attempt-N as created by worker.ts
-      for (const f of readdirSync(run,{withFileTypes:true} as any) as any[]) {
-        if(!f.isDirectory()) continue;
-        const feat = path.join(run, f.name);
-        for (const t of readdirSync(feat,{withFileTypes:true} as any) as any[]) {
-          if(!t.isDirectory()) continue;
-          const taskRoot = path.join(feat, t.name);
-          const attempts = readdirSync(taskRoot,{withFileTypes:true} as any) as any[];
-          for (const a of attempts) {
-            if(!a.isDirectory() || !a.name.startsWith("attempt-")) continue;
-            const attemptDir = path.join(taskRoot, a.name);
-            const n = Number.parseInt(a.name.replace("attempt-",""),10) || 0;
-            const tail = tailWorkerOutput(attemptDir, 800);
-            out.push({
-              featureId: f.name,
-              taskId: t.name,
-              compositeKey: `${f.name}/${t.name}`,
-              attemptDir,
-              attempt: n,
-              state: "running",
-              outputTail: tail,
-            });
-          }
-        }
-      }
-    }
-    return out;
-  } catch { return []; }
+function hasSerializeTask(tasks: FlatTask[]): boolean {
+  return tasks.some(
+    (t) => (t as { serialize?: unknown }).serialize === true && (t.status === "pending" || t.status === "in_progress" || t.status === "rework"),
+  );
 }
 
-export function nextModelForTask(targetDir: string, difficulty?: string, taskId?: string, key?: string): { model?: string; thinking?: string } {
-  try {
-    const { resolveModel, resolveThinking } = require("./modelRouter.ts") as typeof import("./modelRouter.ts");
-    return {
-      model: resolveModel({ projectDir: targetDir, task: { difficulty: difficulty as any, id: taskId, key } }),
-      thinking: resolveThinking({ projectDir: targetDir, task: { difficulty: difficulty as any, id: taskId, key } }),
-    };
-  } catch { return {}; }
+function pickSerializeTask(tasks: FlatTask[], byKey: Map<string, FlatTask>, exclude?: Set<string>): FlatTask | null {
+  const serializeTask = tasks.find(
+    (t) =>
+      (t as { serialize?: unknown }).serialize === true &&
+      t.status === "pending" &&
+      (t.dependsOn ?? []).every((d) => {
+        const dep = byKey.get(d);
+        return dep !== undefined && dep.status === "complete";
+      }) &&
+      !exclude?.has(t.compositeKey) &&
+      !exclude?.has(t.id),
+  );
+  return serializeTask ?? null;
 }
 
-export function pickRunnableTasks(opts: PickOpts): FlatTask[] {
-  const { list } = loadFeatureList(opts.targetDir);
-  const phase = (opts.phase ?? null) as Phase | null;
-  // Phase-filtered pool when phase given, else all tasks across phases.
-  const all: FlatTask[] = phase ? tasksForPhase(list, phase) : (flattenTasks(list) as FlatTask[]); // imported above
-  // Build key map for dep check
-  const byKey = new Map<string, FlatTask>();
-  for (const t of all) {
-    byKey.set(t.compositeKey, t);
-    byKey.set(t.id, t);
-    if (t.key) byKey.set(t.key, t);
-  }
-  const eligible = all.filter((t) => {
+function isSerializeBlocked(tasks: FlatTask[]): boolean {
+  return tasks.some((t) => (t as { serialize?: unknown }).serialize === true && (t.status === "in_progress" || t.status === "rework"));
+}
+
+function eligibleTasks(tasks: FlatTask[], byKey: Map<string, FlatTask>, exclude?: Set<string>): FlatTask[] {
+  return tasks.filter((t) => {
     if (t.status !== "pending") return false;
-    if (opts.exclude?.has(t.compositeKey) || opts.exclude?.has(t.id)) return false;
+    if (exclude?.has(t.compositeKey) || exclude?.has(t.id)) return false;
     const deps = t.dependsOn ?? [];
     return deps.every((d) => {
       const dep = byKey.get(d);
-      return dep && dep.status === "complete";
+      return dep !== undefined && dep.status === "complete";
     });
   });
+}
 
-  // Group by granularity to enforce breadth limit.
-  const level = opts.parallelAt ?? "off";
-  if (level === "off" || level === "goal") {
-    // one task at a time (or one goal pipeline)
-    return eligible.slice(0, 1);
+function groupKeyFor(task: FlatTask, level: HandoffGranularity, list: import("./core/types.ts").FeatureList): string {
+  if (level === "task" || level === "subtask") return task.compositeKey;
+  if (level === "feature") return task.featureId;
+  if (level === "sprint") {
+    const feat = list.features.find((f) => f.id === task.featureId);
+    return (feat as { sprintId?: string } | undefined)?.sprintId ?? task.featureId;
   }
-  const keyFor = (t: FlatTask): string => {
-    // Resolve sprints/goals via feature list lookups when needed.
-    if (level === "task" || level === "subtask") return t.compositeKey;
-    if (level === "feature") return t.featureId;
-    if (level === "sprint") {
-      const feat = list.features.find((f) => f.id === t.featureId);
-      return (feat as { sprintId?: string } | undefined)?.sprintId ?? t.featureId;
-    }
-    if (level === "phase") return t.effectivePhase ?? "build";
-    return t.compositeKey;
-  };
-  const groups = new Map<string, FlatTask[]>();
-  for (const t of eligible) {
-    const k = keyFor(t);
-    if (!groups.has(k)) groups.set(k, []);
-    groups.get(k)!.push(t);
-  }
-  // Take one per group breadth-first, up to maxWorkers.
-  const max = Math.max(1, Math.min(16, opts.maxWorkers ?? 3));
+  if (level === "phase") return task.effectivePhase ?? "build";
+  return task.compositeKey;
+}
+
+function roundRobin(groups: Map<string, FlatTask[]>, max: number): FlatTask[] {
   const out: FlatTask[] = [];
-  const iters = groups.values();
-  // Round-robin one per group.
   const groupArrays = [...groups.values()];
   let idx = 0;
   while (out.length < max && groupArrays.some((g) => g.length > 0)) {
     const g = groupArrays[idx % groupArrays.length]!;
-    if (g.length > 0) {
-      const task = g.shift()!;
-      out.push(task);
-    }
+    if (g.length > 0) out.push(g.shift()!);
     idx++;
     if (idx > max * groupArrays.length + 10) break;
   }
   return out.slice(0, max);
 }
 
+export function pickRunnableTasks(opts: PickOpts): FlatTask[] {
+  const { list } = loadFeatureList(opts.targetDir);
+  const phase = (opts.phase ?? null) as Phase | null;
+  const all: FlatTask[] = phase ? tasksForPhase(list, phase) : (flattenTasks(list) as FlatTask[]);
+  const byKey = new Map<string, FlatTask>();
+  for (const t of all) {
+    byKey.set(t.compositeKey, t);
+    byKey.set(t.id, t);
+    if (t.key) byKey.set(t.key, t);
+  }
+
+  if (hasSerializeTask(all)) {
+    const serializeTask = pickSerializeTask(all, byKey, opts.exclude);
+    if (serializeTask) return [serializeTask];
+    if (isSerializeBlocked(all)) return [];
+  }
+
+  if (isBudgetFull(opts.targetDir)) return [];
+
+  const eligible = eligibleTasks(all, byKey, opts.exclude);
+  const level = opts.parallelAt ?? "off";
+  if (level === "off" || level === "goal") return eligible.slice(0, 1);
+
+  const groups = new Map<string, FlatTask[]>();
+  for (const t of eligible) {
+    const k = groupKeyFor(t, level, list);
+    if (!groups.has(k)) groups.set(k, []);
+    groups.get(k)!.push(t);
+  }
+  const max = Math.max(1, Math.min(16, opts.maxWorkers ?? 3));
+  return roundRobin(groups, max);
+}
+
 export async function spawnWorkers(
   targetDir: string,
   tasks: FlatTask[],
   opts: { runId?: string; promptFor: (t: FlatTask) => string; command?: string } = { promptFor: () => "" },
 ): Promise<SpawnWorkerResult[]> {
-  const { resolveModel } = await import("./modelRouter.ts");
   const runId = opts?.runId ?? runIdFor(targetDir, "sched");
-  // handoff bucket determines effective difficulty — read once
   let handoff: HandoffGranularity = "task";
-  try { handoff = (loadConfig(targetDir).config.session?.handoff as HandoffGranularity) ?? "task"; } catch {}
-  const allList = (()=>{ try{ return loadFeatureList(targetDir).list; }catch{ return null as unknown as import("./core/types.ts").FeatureList; } })();
+  try {
+    handoff = (loadConfig(targetDir).config.session?.handoff as HandoffGranularity) ?? "task";
+  } catch {}
+  let allList: import("./core/types.ts").FeatureList | null = null;
+  try {
+    allList = loadFeatureList(targetDir).list;
+  } catch {
+    allList = null;
+  }
   const results: SpawnWorkerResult[] = [];
   for (const t of tasks) {
     const prompt = opts.promptFor(t);
     const router = loadRouterConfig(targetDir);
     let modelHint: string | undefined;
-    if (router.enabled) {
+    if (router.enabled && allList) {
       try {
-        const effDiff = allList ? effectiveDifficultyForTask(t, handoff, allList) : (t as { difficulty?: string }).difficulty;
+        const effDiff = effectiveDifficultyForTask(t, handoff, allList);
         modelHint = resolveModel({ projectDir: targetDir, task: { difficulty: effDiff as string | undefined, id: t.id, key: t.compositeKey } });
       } catch {}
+    } else if (router.enabled) {
+      try {
+        modelHint = resolveModel({ projectDir: targetDir, task: { difficulty: (t as { difficulty?: string }).difficulty as string | undefined, id: t.id, key: t.compositeKey } });
+      } catch {}
     }
     const res = await spawnIsolatedWorker({
       projectDir: targetDir,
@@ -297,12 +271,18 @@ export async function spawnWorkers(
   return results;
 }
 
-export function executionPolicyOf(config: HarnessConfig): { parallelAt: HandoffGranularity; maxWorkers: number } {
-  const e = (config.execution ?? {}) as Partial<{ parallelAt: unknown; maxWorkers: unknown }>;
-  const at = typeof e.parallelAt === "string" && (["off","goal","phase","sprint","feature","task","subtask"] as const).includes(e.parallelAt as HandoffGranularity)
-    ? (e.parallelAt as HandoffGranularity)
-    : "task";
+export function executionPolicyOf(config: HarnessConfig): {
+  engine: import("./core/types.ts").ExecutionEngine;
+  parallelAt: HandoffGranularity;
+  maxWorkers: number;
+} {
+  const e = (config.execution ?? {}) as Partial<{ engine: unknown; parallelAt: unknown; maxWorkers: unknown }>;
+  const engine: import("./core/types.ts").ExecutionEngine = e.engine === "main-session" ? "main-session" : "background";
+  const at =
+    typeof e.parallelAt === "string" && (["off", "goal", "phase", "sprint", "feature", "task", "subtask"] as const).includes(e.parallelAt as HandoffGranularity)
+      ? (e.parallelAt as HandoffGranularity)
+      : "task";
   const raw = typeof e.maxWorkers === "number" ? e.maxWorkers : 3;
   const maxWorkers = Math.max(1, Math.min(16, Math.floor(raw)));
-  return { parallelAt: at, maxWorkers };
+  return { engine, parallelAt: at, maxWorkers };
 }