infinity-harness 2.5.0 → 2.5.1

package/CHANGELOG.md

@@ -4,6 +4,23 @@ 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.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,6 +297,101 @@ 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. */
@@ -544,10 +641,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 +722,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 +1199,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: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinity-harness",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "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": [