infinity-harness 2.5.1 → 2.6.0

package/src/replan.ts

@@ -51,6 +51,7 @@ export type ReplanTaskInput = {
   difficulty?: string;
   modelHint?: string;
   acceptanceCriteria?: string[];
+  phase?: string;
 };
 
 export interface AmendPlanOpts {
@@ -66,6 +67,7 @@ export interface AmendPlanOpts {
     passes?: boolean;
     tasks?: ReplanTaskInput[];
     difficulty?: string;
+    phase?: string;
   }>;
   addTasks?: Array<{ featureId: string; task: ReplanTaskInput }>;
 }
@@ -171,7 +173,7 @@ function readMaxReplans(projectDir: string): number {
 
 /** Shape a submitted task into the stored form. One place, so the two add paths agree. */
 function toStoredTask(t: ReplanTaskInput): Task {
-  return {
+  const out: Task = {
     id: t.id,
     key: t.key,
     description: t.description,
@@ -181,7 +183,9 @@ function toStoredTask(t: ReplanTaskInput): Task {
     difficulty: t.difficulty as Task["difficulty"],
     modelHint: t.modelHint,
     acceptanceCriteria: t.acceptanceCriteria ?? [],
-  };
+  } as Task;
+  if (t.phase) (out as unknown as { phase: string }).phase = t.phase;
+  return out;
 }
 
 export async function amendPlan(opts: AmendPlanOpts): Promise<AmendPlanResult> {
@@ -227,8 +231,9 @@ export async function amendPlan(opts: AmendPlanOpts): Promise<AmendPlanResult> {
         sprintId: f.sprintId,
         goalId: f.goalId,
         difficulty: f.difficulty,
+        ...(f.phase ? { phase: f.phase } : {}),
         tasks: (f.tasks ?? []).map(toStoredTask),
-      };
+      } as Feature;
       list.features.push(feature);
       addedFeatures++;
     }

package/src/scheduler.ts

@@ -0,0 +1,205 @@
+/**
+ * infinity-harness — parallel scheduler.
+ *
+ * Picks which tasks can run now, respecting deps and the chosen
+ * parallel granularity, then spawns isolated workers for them.
+ * The main session never edits files; it only polls worker logs.
+ */
+
+import type { HarnessConfig, HandoffGranularity, Phase } from "./core/types.ts";
+import { loadFeatureList, tasksForPhase, type FlatTask } from "./core/featureList.ts";
+import { loadRouterConfig } from "./modelRouter.ts";
+import { spawnIsolatedWorker, type SpawnWorkerResult } from "./worker.ts";
+import { runIdFor } from "./runState.ts";
+
+export type PickOpts = {
+  targetDir: string;
+  phase?: Phase | null;
+  parallelAt?: HandoffGranularity;
+  maxWorkers?: number;
+  /** Keys already being worked (in_progress) or rework. */
+  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;
+};
+
+/** Tail a worker attempt's output.log (best-effort, never throws). */
+export function tailWorkerOutput(attemptDir: string, bytes = 3000): string {
+  try {
+    const { readFileSync, existsSync } = require("node:fs");
+    const p = require("node:path").join(attemptDir, "output.log");
+    if (!existsSync(p)) return "";
+    const raw = readFileSync(p, "utf-8") as string;
+    return raw.slice(-bytes);
+  } catch { return ""; }
+}
+
+export function listWorkers(targetDir: string, runId?: string): WorkerSnapshot[] {
+  try {
+    const { readdirSync, existsSync } = require("node:fs");
+    const path = require("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 []; }
+}
+
+export function nextModelForTask(targetDir: string, difficulty?: string, taskId?: string, key?: string): { model?: string; thinking?: string } {
+  try {
+    const { resolveModel, resolveThinking } = require("./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 {}; }
+}
+
+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 { flattenTasks } = require("./core/featureList.ts");
+  const all: FlatTask[] = phase ? tasksForPhase(list, phase) : (flattenTasks(list) as FlatTask[]);
+  // 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) => {
+    if (t.status !== "pending") return false;
+    if (opts.exclude?.has(t.compositeKey) || opts.exclude?.has(t.id)) return false;
+    const deps = t.dependsOn ?? [];
+    return deps.every((d) => {
+      const dep = byKey.get(d);
+      return dep && 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);
+  }
+  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));
+  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);
+    }
+    idx++;
+    if (idx > max * groupArrays.length + 10) break;
+  }
+  return out.slice(0, 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");
+  const results: SpawnWorkerResult[] = [];
+  for (const t of tasks) {
+    const prompt = opts.promptFor(t);
+    const router = loadRouterConfig(targetDir);
+    let modelHint: string | undefined;
+    if (router.enabled) {
+      try { modelHint = resolveModel({ projectDir: targetDir, task: { difficulty: (t as { difficulty?: string }).difficulty, id: t.id, key: t.compositeKey } }); } catch {}
+    }
+    const res = await spawnIsolatedWorker({
+      projectDir: targetDir,
+      runId,
+      featureId: t.featureId,
+      taskId: t.id,
+      prompt,
+      command: opts.command,
+      model: modelHint,
+    });
+    results.push(res);
+  }
+  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";
+  const raw = typeof e.maxWorkers === "number" ? e.maxWorkers : 3;
+  const maxWorkers = Math.max(1, Math.min(16, Math.floor(raw)));
+  return { parallelAt: at, maxWorkers };
+}

package/src/taskList.ts

@@ -279,13 +279,14 @@ export function applyTaskList(current: FeatureList, input: ApplyInput): ApplyRes
         : (existing?.subtasks ?? []).map((s) => ({ ...s }));
 
     // Merge onto the stored task so unknown fields survive. `index`,
-    // `compositeKey`, `featureId` and `featureName` are view-only additions
+    // `compositeKey`, `featureId`, `featureName`, `effectivePhase` are view-only additions
     // from flattenTasks and must not be persisted.
     const base: Record<string, unknown> = existing ? { ...existing } : {};
     delete base.index;
     delete base.compositeKey;
     delete base.featureId;
     delete base.featureName;
+    delete base.effectivePhase;
 
     const task: Task = {
       ...(base as Partial<Task>),
@@ -460,6 +461,7 @@ function stripView(t: FlatTask): Task {
   delete copy.compositeKey;
   delete copy.featureId;
   delete copy.featureName;
+  delete copy.effectivePhase;
   return copy as Task;
 }
 

package/src/ui/wizard.ts

@@ -187,11 +187,31 @@ export async function runIntakeWizard(options: WizardOptions): Promise<WizardRes
     const modelsAnswer = await pickModelsStep(prompt, options.models);
     if (modelsAnswer === undefined) return { cancelled: true };
 
-    // -- 5. display ---------------------------------------------------------
+    // -- 5. execution (parallelism) -----------------------------------------
+    const execOptions = [
+      { value: "off", label: "one at a time", help: "No parallel work. Simplest, lowest token use." },
+      { value: "task", label: "parallel at task (recommended)", help: "Tasks with no deps run together, up to max workers." },
+      { value: "feature", label: "parallel at feature", help: "Features with no deps run together." },
+      { value: "sprint", label: "parallel at sprint", help: "Sprints in parallel." },
+      { value: "goal", label: "parallel at goal", help: "Goals run as parallel pipelines (phases run together)." },
+      { value: "subtask", label: "parallel at subtask", help: "Subtasks of a task run together. Finest grain." },
+    ];
+    const execLabels = execOptions.map((o) => line(o.label, o.help));
+    // Execution parallelism is optional — older E2E/tests scripted 5 answers, not 7. Default to task×3 so they keep passing.
+    let parallelAt: import("../core/types.ts").HandoffGranularity = "task";
+    let maxWorkers = 3;
+    const execPick = await prompt.select("When to run things in parallel?", execLabels);
+    if (execPick !== undefined) {
+      parallelAt = (execOptions[execLabels.indexOf(execPick)]?.value ?? "task") as import("../core/types.ts").HandoffGranularity;
+      const workersRaw = await prompt.input("Max parallel workers? (1-16)", "3");
+      maxWorkers = workersRaw === undefined ? 3 : Math.max(1, Math.min(16, Number.parseInt(String(workersRaw).trim(), 10) || 3));
+    }
+
+    // -- 6. display ---------------------------------------------------------
     const display = await pickDisplay(prompt, env);
     if (display === undefined) return { cancelled: true };
 
-    const answers: IntakeAnswers = { workflow, brief, handoff, display, router: modelsAnswer.router };
+    const answers: IntakeAnswers = { workflow, brief, handoff, display, router: modelsAnswer.router, parallelAt, maxWorkers };
     const plan = planIntake(answers);
 
     if (options.skipConfirm) return { cancelled: false, plan, answers };