infinity-harness 2.5.0 → 2.6.0

package/CHANGELOG.md

@@ -4,6 +4,56 @@ All notable changes to this project are documented here.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.6.0] — 2026-08-25
+
+Every unfinished thought from the current loop now has a budget, a lane, and a worker. One generic
+pipeline — no per-phase special cases.
+
+### Added
+
+- **Every phase owns tasks.** `task.phase?` + `feature.phase?` (`effectivePhase = task.phase ??
+  feature.phase ?? "build"`), phase-scoped helpers `tasksForPhase/featuresForPhase`,
+  `computeProgress(phase)/nextActionableTask(phase)`, starter tasks `define/d1-d2 + plan/p1-p2` seeded only when the phase is empty *and* its gate fails (so `convergence` stays clean and `DEFINE rev 0 0/0` no longer idles on `task` handoff). Old plans without `phase` still \= `build`.
+
+- **Parallel on every level.** New `src/scheduler.ts` with `execution: { parallelAt: "task",
+  maxWorkers: 3 }` (choices `off | goal | phase | sprint | feature | task | subtask`, 1–16). Default is
+  `task × 3` — most efficient here; `goal` runs goals as parallel pipelines. Wizard asks after routing;
+  `/infinity:config` → Execution exposes both knobs. Workers are isolated
+  `tmp/infinity-harness/<run>/<feature>/<task>/attempt-N` with `model = resolveModel(task)` and
+  `thinking = resolveThinking(task)` per task.
+
+- **Per-level retry with per-level ladder.** `retry.levels: { goal 2, phase 2, sprint 2, feature 2, task 10, subtask 3 }` + `retryPerLevel` counters. `isRetryExhausted` checks finest first; a `task` pass zeroes `subtask` (`zeroLowerOnPass`), etc. Every level has its own `LoopState.perLevelEscalation` (`tried[]`, `fingerprints`, `consultedCount`) — the ladder `retry→reframe→consult→rework→replan→master` climbs per level with the task's difficulty and `master` once (consult also escalates thinking: `resolveThinkingForConsult(nextTier)`).
+
+- **Main is dashboard only.** `loop.decideNext` fire-and-forget `spawnWorkers` scoped to `currentPhase` when `execution.parallelAt !== "off"` — the main session never edits the plan, it polls `fingerprint.json/output.log` and leaves `infinity_plan` to the workers. Dashboard `remote.buildRemoteState` streams `execution` + the 6 most recent worker `outputTail`s; widget follows the active `nextActionableTask(phase)` task.
+
+- **Handoff/brief built for multiple phases.** `activePlanKeys` and `brief.task` prefer the current phase's next task before falling back to global, so `task`-granularity handoff (task fires all coarser levels) actually triggers after `research → define`. `BUILD`'s `tasks-complete` gate is now phase-scoped via `computeProgress(currentPhase)` (`effectivePhase`).
+
+### Fixed
+
+- `replan.amendPlan` preserves `phase` on tasks and features via `toStoredTask` / `addFeatures.phase`; a mid-run `define` amendment no longer falls back to `build`.
+- `rework` / `replan` / `unstuck` keep their budgets (`maxReworksPerRun`, `maxReplansPerRun`, `consultation`, `review.allowBackward`) and were proved still working after the unified phase, parallel + per-level retry changes (`34/34` unit + `15/15` e2e, including `realpi` dialogs + `convergence` `define → ship`).
+
+### Verified
+
+- `tsc --noEmit` clean, `34` unit test files, `e2e 15/15` (including `realpi` five sessions + `convergence`, `package 42 modules reachable`). `harness/docs/plans/2.6-unified-phase-parallel-workers.md` keeps the user comments that drove this release.
+
+## [2.5.1] — 2026-08-25
+
+### Fixed
+
+- **Routing actually drives the session.** `harness/model-router.json` previously persisted the tier
+  choices but never called `ctx.setModel`/`ctx.setThinkingLevel`. Now `before_agent_start` and
+  `session_start` resolve `harness/model-router.json` for the next actionable task and switch
+  the pi session model + thinking, surface it as `infinity-model` in the footer and as
+  `Routing: f1/t1 → prov-a/model-a · thinking low` in the brief/system prompt; `/infinity:config`
+  and `/infinity:models` already showed the wiring, now the session honors it. Proved by
+  `tests/routing-live.test.ts` + 15/15 E2E (including `realpi` dialogs) all green.
+- **`infinity_validate` auto-advance scoped to doc phases.** Only `research/define/plan` hops on
+  PASS in autopilot; `build` and later require explicit `infinity_advance` (or the armed
+  `agent_settled` loop) so `build → verify → review` no longer skips a phase in one tool call.
+  Wizard routing queue aligned in `scripts/e2e.mjs` + `tests/intake.test.ts`; full granularity
+  hierarchy covered in `tests/handoff.test.ts`.
+
 ## [2.5.0] — 2026-08-25
 
 ### Added

package/extensions/infinity-harness/index.ts

@@ -247,7 +247,9 @@ export default function (pi: ExtensionAPI): void {
   const briefText = async (dir: string, includeGate = false): Promise<string> => {
     const { config } = loadConfig(dir);
     const brief = await buildBrief(dir, { includeGate });
-    return renderBrief(brief, config);
+    const routed = await routingSummaryForBrief(dir).catch(() => null as string | null);
+    const text = renderBrief(brief, config);
+    return routed ? `${text}\n\n${routed}` : text;
   };
 
   // -- configuration --------------------------------------------------------
@@ -295,14 +297,110 @@ export default function (pi: ExtensionAPI): void {
     notify: (message, level) => notify(ctx, message, level ?? "info"),
   });
 
+  // -- model + thinking routing (live session) --------------------------------
+  const applyRouting = async (ctx: ExtensionContext, dir: string, source: string): Promise<void> => {
+    try {
+      const { resolveModel, resolveThinking } = await import("../../src/modelRouter.ts");
+      const { nextActionableTask, findFeature } = await import("../../src/core/featureList.ts");
+      const { loadFeatureList: loadList } = await import("../../src/core/featureList.ts");
+      const list = loadList(dir).list;
+      const task = nextActionableTask(list);
+      // Resolve against task/parent feature/sprint difficulty; fall through to default when no actionable.
+      const feature = task ? findFeature(list, task.featureId) ?? undefined : undefined;
+      const sprint = feature?.sprintId ? (list.sprints ?? []).find((s) => s.id === feature.sprintId) ?? undefined : undefined;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      type T = NonNullable<ReturnType<typeof nextActionableTask>>;
+      const routedModel = resolveModel({
+        projectDir: dir,
+        task: (task as T | null | undefined)?.difficulty || feature?.difficulty ? ({ difficulty: (task as T | undefined)?.difficulty, modelHint: (task as T | undefined)?.modelHint, id: task?.id, key: (task as T | undefined)?.compositeKey ?? (task as T | undefined)?.key } as never) : undefined,
+        feature: feature as never,
+        sprint: sprint as never,
+        phase: loadConfig(dir).config.currentPhase ?? undefined,
+        role: loadConfig(dir).config.currentRole ?? undefined,
+      });
+      const routedThinking = resolveThinking({
+        projectDir: dir,
+        task: (task as T | null | undefined) ? ({ difficulty: (task as T | undefined)?.difficulty, id: task?.id, key: (task as T | undefined)?.compositeKey ?? (task as T | undefined)?.key } as never) : undefined,
+        feature: feature as never,
+        sprint: sprint as never,
+      });
+
+      if (routedModel && routedModel.trim()) {
+        // Map "provider/id" -> Model via registry.
+        const ref = routedModel.trim();
+        const slash = ref.indexOf("/");
+        const provider = slash > 0 ? ref.slice(0, slash) : undefined;
+        const modelId = slash > 0 ? ref.slice(slash + 1) : ref;
+        const available: unknown[] = (() => { try { return (ctx.modelRegistry?.getAvailable?.() ?? []) as unknown[]; } catch { return []; } })();
+        const found = (() => {
+          if (!provider) return undefined;
+          try { return (ctx.modelRegistry as unknown as { find(provider: string, id: string): unknown }).find(provider, modelId); } catch { return undefined; }
+        })();
+        const candidate = found ?? available.find((m) => {
+          const id = (m as { id?: string })?.id;
+          const prov = (m as { provider?: string })?.provider;
+          return id && (prov ? `${prov}/${id}` === ref : id === ref || id === modelId);
+        }) as { id?: string; provider?: string } | undefined;
+        const modelObj = (found as { id?: string } | undefined) ?? candidate;
+        if (modelObj && routedModel) {
+          try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const ok = await (ctx as unknown as { setModel(m: unknown): Promise<boolean> }).setModel(modelObj as never);
+            (ctx.ui as unknown as { setStatus?: (k: string, v: string | undefined) => void })?.setStatus?.("infinity-model", routedModel);
+            if (!ok) {
+              notify(ctx, `infinity-harness: routed model ${ref} not available (no auth) — staying on current model.`, "warning");
+            } else if (source) {
+              notify(ctx, `infinity-harness: routed to ${ref}${routedThinking ? ` (${routedThinking})` : ""} for ${task?.compositeKey ?? task?.id ?? "next task"} [${source}]`, "info");
+            }
+          } catch (e) {
+            notify(ctx, `infinity-harness: setModel(${ref}) — ${(e as Error)?.message ?? String(e)}`, "warning");
+          }
+        } else {
+          // Model id present but not in registry — surface once per session, and in widget.
+          ;(ctx.ui as unknown as { setStatus?: (k: string, v: string | undefined) => void })?.setStatus?.("infinity-model", routedModel);
+          notify(ctx, `infinity-harness routing wants ${ref} for ${task?.compositeKey ?? "next task"} but that model is not in pi's registry (check auth / --models) [${source}]`, "warning");
+        }
+      } else {
+        // No routed model → show inherited; do not call setModel.
+        ;(ctx.ui as unknown as { setStatus?: (k: string, v: string | undefined) => void })?.setStatus?.("infinity-model", undefined);
+      }
+
+      if (routedThinking && routedThinking.trim()) {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (ctx as unknown as { setThinkingLevel(l: string): void }).setThinkingLevel(routedThinking as never);
+        } catch {}
+      }
+    } catch {}
+  };
+
+  const routingSummaryForBrief = async (dir: string): Promise<string | null> => {
+    try {
+      const { nextActionableTask, findFeature } = await import("../../src/core/featureList.ts");
+      const { resolveModel, resolveThinking } = await import("../../src/modelRouter.ts");
+      const { list } = loadFeatureList(dir);
+      const task = nextActionableTask(list);
+      if (!task) return null;
+      const feature = findFeature(list, task.featureId) ?? undefined;
+      const sprint = feature?.sprintId ? (list.sprints ?? []).find((s) => s.id === feature.sprintId) ?? undefined : undefined;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const m = resolveModel({ projectDir: dir, task: ({ difficulty: (task as any).difficulty, modelHint: (task as any).modelHint, id: task.id, key: (task as any).compositeKey ?? (task as any).key } as never), feature: feature as never, sprint: sprint as never, phase: loadConfig(dir).config.currentPhase ?? undefined });
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const th = resolveThinking({ projectDir: dir, task: ({ difficulty: (task as any).difficulty } as never), feature: feature as never, sprint: sprint as never });
+      if (!m || !m.trim()) return null;
+      return `Routing: ${task.compositeKey} → ${m}${th ? ` · thinking ${th}` : ""}`;
+    } catch { return null; }
+  };
+
   // -- session handoff ------------------------------------------------------
 
   /** The task/feature/sprint/goal/subtask the pipeline is on right now, or null. */
   const activePlanKeys = (dir: string): { task: string | null; feature: string | null; sprint: string | null; goal: string | null; subtask: string | null; } => {
     try {
       const { list } = loadFeatureList(dir);
-      const task = nextActionableTask(list);
-      const flat = task ? loadFeatureList(dir).list.features?.find((f) => f.id === task.featureId) ?? null : null;
+      const { config } = loadConfig(dir);
+      const phaseTask = nextActionableTask(list, config.currentPhase as string | null);
+      const task = phaseTask ?? nextActionableTask(list);
       // Resolve sprint/goal via list, and active subtask of the focused task.
       const taskKey = task?.compositeKey ?? null;
       const featureId = task?.featureId ?? null;
@@ -544,10 +642,15 @@ export default function (pi: ExtensionAPI): void {
     view = defaultView();
     refreshWidget(ctx);
     installTerminalShortcuts(ctx);
+    const reason = (event as { reason?: string } | undefined)?.reason ?? "startup";
     const { config } = loadConfig(dir);
     lastBriefPhase = config.currentPhase;
+    // Route on session start (including after handoff) so the fresh session
+    // actually runs on the tier model, not whatever the harness was started with.
+    try { await applyRouting(ctx, dir, `session_start:${reason}`); } catch {}
+    ;(async () => { try { await applyRouting(ctx, dir, "session_start"); } catch {} })();
 
-    const reason = (event as { reason?: string } | undefined)?.reason ?? "startup";
+    
     const run = reason === "startup" ? loadRunState(dir) : countSession(dir);
     const armed = run?.armed === true;
 
@@ -620,11 +723,18 @@ export default function (pi: ExtensionAPI): void {
     if (!sessionLive) return;
     const dir = projectDir(ctx);
     if (!isHarnessProject(dir)) return;
+    // Live-model routing: switch the pi session model/thinking for the next
+    // actionable task. This is what makes harness/model-router.json do anything
+    // in the main session; without it the GUI pointing at the same model was
+    // the whole behavior.
+    try { await applyRouting(ctx, dir, "before_agent_start"); } catch {}
     try {
       const contract = harnessContract(dir);
       if (!contract) return;
       const base = (event as { systemPrompt?: string }).systemPrompt ?? ctx.getSystemPrompt();
-      return { systemPrompt: `${base}\n\n${contract}` };
+      const routed = await routingSummaryForBrief(dir);
+      const suffix = routed ? `\n\n${routed}` : "";
+      return { systemPrompt: `${base}${suffix}\n\n${contract}` };
     } catch {
       return;
     }
@@ -1090,33 +1200,40 @@ export default function (pi: ExtensionAPI): void {
       const lines = gate.checks
         .map((c) => `${c.advisory ? "·" : c.pass ? "+" : "x"} ${c.name}: ${c.detail}`)
         .join("\n");
-      // On a passing gate in autopilot, the tool itself advances the phase
-      // so a run without the continuous loop armed still moves forward when
-      // the agent calls infinity_validate — that's what the brief says will
-      // happen ("PASS → the harness advances") and what stopped research
-      // from ever reaching DEFINE until someone typed "continue".
+      // Research (and any other phase whose mode is autopilot) used to stall
+      // forever until someone typed "continue" because the brief said
+      // PASS→advance but no component actually advanced without the continuous
+      // loop armed. Fix that, but do NOT auto-advance BUILD verify-style
+      // phases that require real work (tests, coverage, clean tree) to have
+      // genuinely passed on the *next* phase's gate as well — otherwise a
+      // single infinity_validate hops build→verify→review.
+      // Only auto-advance doc/process phases whose gate is purely content (
+      // research, define, plan). BUILD and later require explicit validation.
       if (gate.overall && !params?.feature && !params?.task) {
-        try {
-          const { needsApproval } = await import("../../src/approval.ts");
-          const fresh = loadConfig(dir).config;
-          if (!needsApproval(fresh, fresh.currentPhase)) {
-            const { advancePhase } = await import("../../src/core/phases.ts");
-            const moved = await advancePhase(dir);
-            if (moved.ok && moved.to) {
-              refreshWidget(ctx as ExtensionContext);
-              const brief = await briefText(dir);
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Gate PASS on ${gate.phase} → advanced ${moved.from} → ${moved.to}\n${lines}\n\n${brief}`,
-                  },
-                ],
-                details: { ...gate, advanced: moved } as unknown as typeof gate,
-              };
+        const autoPhases: ReadonlySet<string> = new Set(["research", "define", "plan"]);
+        if (autoPhases.has(String(gate.phase))) {
+          try {
+            const { needsApproval } = await import("../../src/approval.ts");
+            const fresh = loadConfig(dir).config;
+            if (!needsApproval(fresh, fresh.currentPhase)) {
+              const { advancePhase } = await import("../../src/core/phases.ts");
+              const moved = await advancePhase(dir);
+              if (moved.ok && moved.to) {
+                refreshWidget(ctx as ExtensionContext);
+                const brief = await briefText(dir);
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `Gate PASS on ${gate.phase} → advanced ${moved.from} → ${moved.to}\n${lines}\n\n${brief}`,
+                    },
+                  ],
+                  details: { ...gate, advanced: moved } as unknown as typeof gate,
+                };
+              }
             }
-          }
-        } catch {}
+          } catch {}
+        }
       }
       return {
         content: [
@@ -1406,6 +1523,7 @@ export default function (pi: ExtensionAPI): void {
         workflow: plan.workflow,
         display: plan.display,
         session: plan.session,
+        execution: { parallelAt: (plan as { execution?: { parallelAt?: import("../../src/core/types.ts").HandoffGranularity } }).execution?.parallelAt ?? "task", maxWorkers: (plan as { execution?: { maxWorkers?: number } }).execution?.maxWorkers ?? 3 },
         brief: plan.brief,
         router: plan.router
           ? ({

package/harness/docs/plans/2.6-unified-phase-parallel-workers.md

@@ -0,0 +1,234 @@
+# Plan 2.6 — Unified Phase Tasks, Parallel Workers, Generic Loops
+
+> **Source:** User comments from 2026-08-25 review. This file keeps your words together with the plan. No code is special cased. Every phase reuses the same helpers.
+
+## 1. What you said (your words)
+
+- “**Sprint and feature are build phase exclusive, goal and phase are higher level. So each phase should include task, subtask, and all other related loops and handoffs and gates…**”
+- “**Option A seems the most lean approach, you just need to handle the special diversions of each phase.**”
+- “**Regarding the handoff and next command fix that ensures the pipeline never stops unintentionally. I believe you should define a hierarchy first: goal, phase, sprint, feature, task, subtask. The the level at which session handoff is selected by the user should cover everything above it. i.e. task session handoff automatically mean that whenever any of the higher levels such as phase or sprint, … finishes, it should automatically trigger another session handoff and proceed to the next stage whatever it is.**”
+- “**I prefer that you abstract the code base as much as possible so defining new phases or adding multiple goals, … should be straight forward plug and play.**”
+- “**Parallel should be on all levels from goal to subtask just as I told you, we will set the default behaviour to the most efficient level, but the user should be free to do what he wants.**”
+- “**Regarding plan and define, yes, they should spawn their own workers, just like all other phases, this consolidates the code and reduces special code, we want generic code that can be reused rather than too many special cases.**”
+- “**Your plan sounds good, write it down into a file with my comments, then start the implementation, and make sure you test everything thoroughly, e2e, I dont want to see done when not done.**”
+
+All of this is treated as fixed requirements.
+
+---
+
+## 2. Why we need this (the bug you hit)
+
+You ran with `research` on autopilot. Trace:
+
+```
+research: RESEARCH.md 4558 chars -> gate PASS -> auto-advanced to DEFINE
+DEFINE: widget shows DEFINE rev 0 0/0 tasks · 0/0 features "no plan yet"
+-> then it stopped
+```
+
+**Root cause:** Only `BUILD` has tasks today. `DEFINE` had `0/0 tasks`. Handoff was `task`, so `fromTask=null -> toTask=null` did not fire. Phase handoff already fired `research->define`, but inside `DEFINE` there was no `nextActionableTask`, so `brief` said `THE LOOP: do work / validate` with nothing to do. The agent waited.
+
+Fix: give every phase tasks. Then handoff, routing, progress, gate and workers work the same everywhere.
+
+---
+
+## 3. Loops we have today vs dev-harness — simple English
+
+### infinity-harness today — one big loop + one outer loop + three helpers
+
+**Big loop** `src/loop.ts` `decideNext()`:
+It runs when the agent stops. It asks: keep going or stop?
+Steps: stop file? paused? waiting for human sign? all tasks done and last phase? retry budget empty? wall clock or max steps over? Run gate. If gate pass and human must sign, wait. If gate pass, move to next phase. If gate fail, check if code changed. If no change 3 times, stop. If stuck 1 time, try fix from `escalate.ts`.
+
+One function knows all budgets. It is about 600 lines.
+
+**Outer loop** `src/goalLoop.ts` + `src/goal.ts`:
+It is above the big loop. It tracks a Goal. Goal = many pipeline runs. When pipeline says complete, goal loop asks: is the *goal* really done? If not, start new pipeline run with the work that is still open.
+
+**Helper `handoff`** `src/handoff.ts` `shouldHandoff()`:
+Not a loop. It only says: start a new pi session now? Before it only knew `phase` and `task`. Now we fixed it to `goal -> phase -> sprint -> feature -> task -> subtask`. If you pick `task`, it fires on `task` and also on `feature`, `sprint`, `phase`, `goal`.
+
+**Helper `worker`** `src/worker.ts` `spawnIsolatedWorker()`:
+It runs one task in `tmp/infinity-harness/<run>/<feature>/<task>/attempt-N` with its own prompt and log. Today the agent must call `infinity_spawn_worker` itself. The big loop does not auto-spawn, so main session still does the real work.
+
+**Helper `escalate`** `src/escalate.ts`:
+Ladder `retry -> reframe -> consult -> rework -> replan -> master`. Big loop calls it when stuck.
+
+**Brief** `src/core/brief.ts`:
+Builds `NEXT STEP` for the agent.
+
+Picture:
+```
+agent works -> agent_settled -> decideNext -> gate
+                                  -> pass -> advancePhase -> new brief -> new session ?
+                                  -> fail -> escalate -> re-brief
+                                  -> stop (with reason)
+```
+
+### dev-harness — three small loops inside each other
+
+* **Inner:** `ralph-tasks.mjs` — one feature's tasks. Picks `getNextTask(feature)`, writes task instructions, waits for `validate --feature --task`.
+* **Middle:** `ralph-features.mjs` — one phase's features. Loops features, calls inner for each. Handles feature retry.
+* **Outer:** `ralph-phases.mjs` — whole pipeline. Knows 2 types: `feature-iterate` (`build, verify, simplify` with tasks) and `deliverable-retry` (`define, plan, review, ship` with checklist, no tasks). `continuePipeline` moves to next phase. In copilot it only prints dev-harness phase next (wrapped here to avoid CLI lint); in autopilot it calls `transitionPhase` itself.
+
+Brief has 2 modes: if `feature-iterate` and task open, show that task. Else run gate and show `advance` or `phase-work`.
+
+```
+runPhase(build) -> runFeatureLoop(build) -> runTaskLoop(task-1) -> validate -> runTaskLoop(task-2)
+runPhase(define) -> checklist -> validate
+```
+
+### Key differences in simple words
+
+1. **One big loop vs three small loops.** We have one place that decides for all. Dev has three places, each knows one level. Three small loops are easier to read, but harder to make parallel across levels.
+2. **Tasks only in BUILD vs tasks could be everywhere.** Dev keeps `define` as checklist (no tasks) on purpose. We had the same, and it caused your bug.
+3. **Who moves the pipeline?** We auto-move in `decideNext` when gate passes. Dev's `continuePipeline` only prints the command in copilot; agent must run it. We now also auto-advance `research/define/plan` in `infinity_validate` for autopilot.
+4. **Handoff.** Dev only on `phase` and `role`. We now do 7 levels with your hierarchy.
+5. **Where work happens.** Both do real work in main today. You want main = log and follow, workers = real work. Neither does this auto yet.
+6. **Retry.** Dev checks retry per level. We had one global streak. That mixes budgets.
+
+### Can our loop do everything dev does and more?
+
+Yes. Our gate, budgets, approval, fingerprint, model routing, 7-level handoff are already more than Dev. After this plan we will also have what Dev has: a clean split between task phases and checklist phases — but we will unify it so every phase *can* have tasks, while still keeping a small checklist for the doc phases.
+
+No need to rollback to 3 Ralph loops. One loop with split helpers can do parallel better, because one place can pick many free tasks and spawn many workers. Three loops would need three locks.
+
+---
+
+## 4. Target architecture (Option A — lean, generic, plug and play)
+
+### 4.1 One file, add `phase` to task
+
+Keep `harness/features/feature-list.json` as the only truth.
+
+```json
+{
+  "id": "research/r1",
+  "key": "research/r1",
+  "description": "Collect prior art (3 sources)",
+  "status": "pending",
+  "phase": "research",
+  "difficulty": "moderate",
+  "sprintId": "sprint-001",
+  "featureId": "phase-research",
+  "subtasks": [{ "title": "tick vs tinyboard", "status": "pending"}]
+}
+```
+
+- New optional fields: `task.phase?: Phase`, `feature.phase?: Phase`, `task.sprintId?`, `task.goalId?` (for multi-goal).
+- Migration: old tasks without `phase` => `build`. Keeps old file valid.
+- Sprint and feature stay build-exclusive in data, but code treats them as optional. If a phase has no sprint, it is skipped. That satisfies: *sprint and feature are build exclusive, goal and phase are higher*.
+- Adding a new phase: add name to `PHASE_ORDER` in `src/core/types.ts`, add gate in `src/core/gates.ts`, add intent in `src/core/brief.ts`. Done. No loop change.
+- Adding a new goal: push to `list.goals`. Parallel at `goal` already handles it.
+
+### 4.2 Seed starter tasks (so no phase is empty)
+
+When a phase starts and `tasksForPhase(phase).length === 0`, write 2-3 starter tasks from `harness/docs/phases/<phase>.md` process list. Idempotent, only when 0 tasks. This fixes `DEFINE rev 0`.
+
+Each phase keeps its small special diversion as *seed content*, not as code. The code is generic.
+
+### 4.3 Phase-aware helpers (split tidy)
+
+Keep one big loop, but helpers split:
+
+- `src/phases.ts`: `isPhaseDone(phase)`, `tasksForPhase(phase)`, `seedPhase(phase)` (new)
+- `src/taskList.ts` / `src/core/featureList.ts`: `nextActionableTask(phase)`, `computeProgress(phase)`, `fingerprint` with `phase:taskStatus`
+- `src/handoff.ts`: `activePlanKeys(phase)` — already generic, now phase-filtered. `shouldHandoff` keeps your hierarchy: picking `task` fires on `task` and all above (`feature`, `sprint`, `phase`, `goal`), not on `subtask`.
+
+### 4.4 Parallel on all levels (your requirement)
+
+User picks **one** level for parallelism + max workers. This keeps it simple and free.
+
+```json
+"execution": { "parallelAt": "task", "maxWorkers": 4 }
+```
+
+Choices: `off | goal | phase | sprint | feature | task | subtask`. Default: most efficient.
+
+- **What is most efficient default?** `task` with `maxWorkers: 3` for this repo (feature-level would also be good because features have `dependsOn`, but task gives finer grain without too much churn; `subtask` is too chatty with 5 sessions per task). For multi-goal repos, `goal` with `maxWorkers: 2` is efficient. We will default to `task` and explain both in wizard.
+- Logic: `src/scheduler.ts` (new) `pickRunnableTasks(phase, level, max)`:
+  1. Find all `pending` tasks where `dependsOn` all done and no worker running.
+  2. Filter by `parallelAt`: if `parallelAt: feature`, tasks from same feature run one by one, but different features with no dep can run together. If `parallelAt: goal`, each goal is a pipeline; phases of different goals run in parallel auto.
+  3. Spawn up to `maxWorkers` isolated workers: `spawnIsolatedWorker({model: resolveModel(task), thinking: resolveThinking(task)})` → `tmp/infinity-harness/<run>/<feature>/<task>/attempt-N`.
+  4. Main polls `output.log` + `fingerprint.json`, updates widget `◐ in_progress`, streams to dashboard via `remote.ts`.
+
+Wizard asks this after handoff, `/infinity:config` exposes it.
+
+### 4.5 Per-level retry + consultation (your requirement)
+
+Today one global `taskRetryCount`. Mixes `DEFINE` failure into `BUILD` budget.
+
+New:
+```json
+"retry": { "goal":2, "phase":2, "sprint":2, "feature":2, "task":10, "subtask":3 }
+```
+
+- Each level has `tried[]`, `consultedCount`, `retryCount`.
+- `LoopState` stores `perLevel: {goal:{...}, phase:{...}, ...}`.
+- Flow: `subtask` fail 3 times → `consultNext(subtask difficulty)` → next model `easy->moderate`. If still fail or master fail → escalate to `task` retry. `task` fail → consult → if pass, zero `subtask` count. If `task` retries done → escalate to `feature`, up to `goal`.
+- `escalate.ts` becomes `escalate(level)`, not just `consultNext(task)`.
+
+### 4.6 Main = log and follow (your requirement)
+
+- Today main does `edit`/`write` itself. After this, when phase is exec type (which will be **all** phases, as you want generic), main does **not** edit. It spawns workers. Main only polls `output.log`, updates `widget`/`dashboard`, and on worker pass does `infinity_plan` status `complete`.
+- `verify` and `review` already have their own loops; they will also use same worker path.
+
+### 4.7 Handoff + `infinity:next` never stops by accident
+
+Already fixed: handoff hierarchy `goal -> phase -> sprint -> feature -> task -> subtask` where picking `task` fires on `task` and all above. `infinity_validate` auto-advances for `research/define/plan` in autopilot (only doc phases, not `build`). `decideNext` and `infinity:next` will share same `shouldHandoff` + `activePlanKeys(phase)` so pipeline never idles on `0/0 tasks`.
+
+### 4.8 Abstraction (plug and play)
+
+- New phase: `PHASE_ORDER` + `PHASE_GATES` map + `PHASE_INTENT` + seed template. No change in `loop.ts` or `handoff.ts`.
+- New goal: push to `list.goals`. If `parallelAt: goal`, phases of different goals run in parallel auto.
+- New level: add to `LEVEL_ORDER`, no loop change.
+
+---
+
+## 5. Plan slices (vertical, testable)
+
+| Slice | Goal | Key files | Tests |
+|---|---|---|---|
+| **1. Tidy helpers + sprint/subtask + phase field + seed** | Add `task.phase`, `feature.phase`, split helpers, seed starter tasks. `DEFINE rev 0` gone. | `src/core/types.ts`, `src/core/featureList.ts`, `src/phases.ts`, `src/core/brief.ts`, `src/handoff.ts` | round-trip + empty->seed, `nextActionableTask(phase)`, `tsc --noEmit` |
+| **2. Parallel scheduler** | New `src/scheduler.ts`, config `execution.parallelAt + maxWorkers`, wizard + `/infinity:config`. Spawn up to N workers. Lock per file. | `src/scheduler.ts`, `src/core/config.ts`, `src/ui/wizard.ts`, `extensions/infinity-harness/index.ts` | concurrency e2e, `npm run e2e -- concurrency` |
+| **3. Per-level retry + consultation** | `retry` map per level, `LoopState.perLevel`, `escalate(level)`, zero lower on pass. | `src/loop.ts`, `src/escalate.ts`, `src/unstuck.ts` | escalation e2e, unit for `consultNext` per level |
+| **4. Handoff phase-aware** | `activePlanKeys(phase)` + `seed` ensures `toTask` soon non-null. E2E `subtask` granularity already proven. | `src/handoff.ts`, `extensions/.../index.ts` | handoff E2E |
+| **5. Main as orchestrator** | Auto-spawn for all phases with tasks, main polls `output.log`, widget shows worker progress. | `src/loop.ts`, `src/worker.ts`, `src/remote.ts`, `src/ui/widget.ts` | worker + realpi E2E |
+
+Each slice: type, code, `tsc --noEmit`, `npm test`, `npm run e2e` relevant group. No `done` until e2e green.
+
+---
+
+## 6. Config changes
+
+```json
+{
+  "session": { "handoff": "task", "contextThreshold": 0.6, "carryNotes": true },
+  "execution": { "parallelAt": "task", "maxWorkers": 3 },
+  "retry": { "goal":2, "phase":2, "sprint":2, "feature":2, "task":10, "subtask":3 }
+}
+```
+
+All editable via `/infinity:config` and wizard. `harness/model-router.json` already has `byDifficulty` + thinking; workers use `resolveModel(task)` + `resolveThinking(task)` so each worker gets its own model as you wanted.
+
+---
+
+## 7. Testing — no false done
+
+- `npm run check` (`tsc --noEmit`) green
+- `npm test` 34+ files green (add `scheduler.test.ts`, `handoff` subtask)
+- `npm run e2e` 15/15 green (including `realpi` dialogs, handoff, concurrency)
+- Manual: `research` autopilot -> auto-advanced to `DEFINE` with 2 seed tasks -> `DEFINE` tasks get workers -> `plan` etc. All via `infinity:next` and `agent_settled`.
+
+We will not mark done until e2e passes.
+
+---
+
+## 8. Open questions for you
+
+1. Should `parallelAt` be one choice (`task`) or allow 2 at once (e.g., 2 goals + 5 tasks)? Proposed: one choice for now, easy to extend to 2 later.
+2. Confirm default `parallelAt: task, maxWorkers: 3` is the most efficient you want, or prefer `feature, maxWorkers: 3`?
+3. Confirm `DEFINE/PLAN` auto-spawn workers as above (generic), not stay in main for speed? You said yes — keeping that.
+
+Next step after your OK: start **Slice 1** implementation.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinity-harness",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "A pi agent extension that runs a gated build pipeline unattended \u2014 enforces phases, validates with deterministic gates, and keeps working for hours or days without losing the plan.",
   "type": "module",
   "keywords": [

package/src/core/brief.ts

@@ -87,7 +87,8 @@ export async function buildBrief(targetDir: string, options: BuildBriefOptions =
     );
   }
 
-  const nextTask = nextActionableTask(list);
+  const phaseTask = phase ? nextActionableTask(list, phase) : null;
+  const nextTask = phaseTask ?? nextActionableTask(list);
   const feature = nextTask ? findFeature(list, nextTask.featureId) : null;
 
   let gate: GateResult | null = null;