infinity-harness 2.8.7 → 2.8.8

package/CHANGELOG.md

@@ -4,6 +4,18 @@ 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.8.8] — 2026-08-31
+
+Routing is one source; default honestly idle.
+
+### Changed
+
+- **Default (tier A) is now honest.** Wizard title is “Default (tier A) — general work + undifficult tasks — idle under task handoff when every task has difficulty” with the live “tierScopeNote(handoff)”. Widget appends “Default nemotron (idle — all tasks have B/C/D, task handoff) · Model per task …” when every lane has B/C/D under task/subtask handoff so “never called” reads as “idle by design”.
+
+### Fixed
+
+- **Single source of truth for model routing.** “harness/model-router.json” migrates into “harness/config.json:tiers” (“A=default, B=easy, C=moderate, D=difficult, X=master” + thinkingLevel) on first “loadConfig” when “tiers:{}” and as “initHarness” writes both files for new projects. Daemon and supervisor now agree: “supervisor.ts” prefers “core/modelRouter:routeModel” via “config.tiers” when present, falling back to legacy “src/modelRouter:resolveModel”. Existing projects like “bakr_test_2.8.6” auto-heal without hand-editing.
+
 ## [2.8.7] — 2026-08-31
 
 Widget stays live after /infinity:run; daemon found in installed package.

package/extensions/infinity-harness/index.ts

@@ -219,7 +219,7 @@ export default function (pi: ExtensionAPI): void {
 
   // -- widget ---------------------------------------------------------------
 
-  const handoffNoteFor = (h: import("../../src/core/types.ts").HandoffGranularity): string | null => {
+  const handoffNoteFor = (h: import("../../src/core/types.ts").HandoffGranularity, hasDefaultIdle?: boolean, defaultRef?: string | null): string | null => {
     const map: Record<string, string> = {
       off: "Model per run (off/goal) — the whole run shares its hardest model; finer per-task routing requires task/subtask handoff",
       goal: "Model per run (off/goal) — the whole run shares its hardest model; finer per-task routing requires task/subtask handoff",
@@ -236,7 +236,9 @@ export default function (pi: ExtensionAPI): void {
     try {
       const { list } = loadFeatureList(dir);
       const { config } = loadConfig(dir);
-      const handoffModelNote: string | null = handoffNoteFor((config.session?.handoff as import("../../src/core/types.ts").HandoffGranularity) ?? "task");
+      const _routerForWidget = (()=>{ try{ const {loadRouterConfig: _lrc} = require("../../src/modelRouter.ts"); return _lrc(dir); }catch{ return null as unknown as {default?: string; byDifficulty?: Record<string,string>}; }})() as {default?: string; byDifficulty?: Record<string,string>} | null;
+      const hasIdle = ((): boolean =>{ try{ if(!_routerForWidget?.default?.trim()) return false; const h=(config.session?.handoff as string) ?? "task"; if(h!=="task" && h!=="subtask") return false; let lanes: Array<{difficulty?: string}> = []; try{ lanes = flattenTasks(list) as unknown as Array<{difficulty?: string}>; }catch{ lanes = []; } if(!lanes.length) return false; return lanes.every(x=>{ const d=(x as {difficulty?: string}).difficulty; return d==="easy"||d==="moderate"||d==="difficult"; }); }catch{return false;} })();
+      const handoffModelNote: string | null = handoffNoteFor((config.session?.handoff as import("../../src/core/types.ts").HandoffGranularity) ?? "task", hasIdle, _routerForWidget?.default ?? null);
       const spent = escalationSummary(dir);
       // v3 viewState: widget must read daemon.json before rendering — deriveViewState is that check.
       let viewState: WidgetState["viewState"] = null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infinity-harness",
-  "version": "2.8.7",
-  "description": "A pi agent extension that runs a gated build pipeline unattended — enforces phases, validates with deterministic gates, and keeps working for hours or days without losing the plan.",
+  "version": "2.8.8",
+  "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": [
     "pi-package",

package/src/core/config.ts

@@ -10,7 +10,7 @@
 import type { HarnessConfig, GateHistoryEntry, Phase, Role } from "./types.ts";
 import { DEFAULT_ENABLED_PHASES, PHASE_ROLE } from "./types.ts";
 import { defaultDisplay, normalizeDisplay } from "../ui/display.ts";
-import { configPath } from "./paths.ts";
+import { configPath, modelRouterPath } from "./paths.ts";
 import { readJson, writeJsonAtomic, backupOnce, fileExists } from "./fsx.ts";
 import { existsSync, readFileSync } from "node:fs";
 
@@ -181,10 +181,17 @@ function migrate(config: HarnessConfig, stored: Partial<HarnessConfig>): Harness
     }
   }
   // tiers: validate + migrate from model-router.json if empty
+  // C: single source — config.tiers is truth; legacy file migrates in.
+  // When config.tiers is {} and harness/model-router.json exists with
+  // byDifficulty/master/default, populate A=default, B=easy, C=moderate, D=difficult, X=master.
   {
     const t = normalizeTiers((out as Record<string, unknown>).tiers);
-    if (t !== undefined) (out as Record<string, unknown>).tiers = t;
-    else (out as Record<string, unknown>).tiers = {};
+    if (t !== undefined && Object.keys(t).length > 0) {
+      (out as Record<string, unknown>).tiers = t;
+    } else {
+      // targetDir not available in migrate(); migration happens in loadConfig where targetDir is known.
+      (out as Record<string, unknown>).tiers = t ?? {};
+    }
   }
 
   // The signal is what the *file* had, not what the merge produced: defaults
@@ -255,7 +262,61 @@ export function loadConfig(targetDir: string): LoadResult {
     if (raw === null) {
       return { ok: false, config: defaultConfig(), error: "harness/config.json is empty", seeded: true };
     }
-    return { ok: true, config: migrate(deepMerge(defaultConfig(), raw), raw), error: null, seeded: false };
+    let cfg = migrate(deepMerge(defaultConfig(), raw), raw);
+    // C: migrate legacy harness/model-router.json -> config.tiers when empty.
+    // In-memory only until next saveConfig; legacy file kept for one release.
+    try {
+      const tiersNow = (cfg as unknown as { tiers?: Record<string, unknown> }).tiers ?? {};
+      if (Object.keys(tiersNow).length === 0) {
+
+        const mrPath = modelRouterPath(targetDir);
+        if (existsSync(mrPath)) {
+          const rawMr = JSON.parse(readFileSync(mrPath, "utf-8"));
+          if (typeof rawMr?.enabled === "boolean" && rawMr.enabled) {
+            const byDiff = (rawMr as { byDifficulty?: Record<string,string> }).byDifficulty ?? {};
+            const toTier = (ref: string | undefined): { provider: string; id: string } | null => {
+              if (!ref || !ref.trim()) return null;
+              const s = ref.trim();
+              const slash = s.indexOf("/");
+              if (slash <= 0 || slash === s.length-1) return null;
+              return { provider: s.slice(0, slash), id: s.slice(slash+1) };
+            };
+            const next: Record<string, { provider: string; id: string; thinkingLevel?: string }> = {};
+            const thinkByDiff = (rawMr as { thinkingByDifficulty?: Record<string,string> }).thinkingByDifficulty ?? {};
+            const tLvl = (k: string): string | undefined => {
+              const v = (thinkByDiff as Record<string,string>)[k];
+              return typeof v === "string" && v.trim() ? v.trim() : undefined;
+            };
+            // A = default
+            const a = toTier(rawMr.default as string | undefined);
+            if (a) next["A"] = { ...a, ...(tLvl("__default__") || (rawMr as { thinkingDefault?: string }).thinkingDefault ? { thinkingLevel: ((rawMr as { thinkingDefault?: string }).thinkingDefault || tLvl("__default__") || undefined) } : {}) };
+            // B/C/D from byDifficulty
+            const want: Array<[string,string]> = [["B","easy"],["C","moderate"],["D","difficult"]];
+            for (const [tier, diff] of want) {
+              const m = toTier(byDiff[diff]);
+              if (m) {
+                const tl = tLvl(diff) || undefined;
+                next[tier] = tl ? { ...m, thinkingLevel: tl as string } : m;
+              }
+            }
+            // X = master
+            const x = toTier(rawMr.master as string | undefined);
+            if (x) {
+              const masterTl = (rawMr as { thinkingMaster?: string }).thinkingMaster;
+              next["X"] = masterTl ? { ...x, thinkingLevel: masterTl } : x;
+            }
+            // also fill A thinkingDefault correctly (override above if needed)
+            if (next["A"] && (rawMr as { thinkingDefault?: string }).thinkingDefault) {
+              (next["A"] as { thinkingLevel?: string }).thinkingLevel = (rawMr as { thinkingDefault?: string }).thinkingDefault as string;
+            }
+            if (Object.keys(next).length > 0) {
+              (cfg as unknown as { tiers: unknown }).tiers = next;
+            }
+          }
+        }
+      }
+    } catch {}
+    return { ok: true, config: cfg, error: null, seeded: false };
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     return { ok: false, config: defaultConfig(), error: msg, seeded: false };

package/src/core/init.ts

@@ -264,6 +264,39 @@ export function initHarness(targetDir: string, options: InitOptions = {}): InitR
         merged.thinkingByDifficulty = { ...((existing.thinkingByDifficulty as Record<string,string>) ?? {}), ...(incoming.thinkingByDifficulty as Record<string,string>) };
       }
       writeFileSync(routerPath, JSON.stringify(merged, null, 2), "utf-8");
+      // C: also materialize config.tiers so daemon + supervisor share truth.
+      // Keep legacy file for one release (read fallback still honours it).
+      try {
+        const toTier = (ref: string | undefined): { provider: string; id: string } | null => {
+          if (!ref || !ref.trim()) return null;
+          const s = ref.trim(); const slash = s.indexOf("/");
+          if (slash <= 0 || slash === s.length-1) return null;
+          return { provider: s.slice(0, slash), id: s.slice(slash+1) };
+        };
+        const next: Record<string, { provider: string; id: string; thinkingLevel?: string }> = {};
+        const thinkByDiff = (incoming as { thinkingByDifficulty?: Record<string,string> }).thinkingByDifficulty ?? {};
+        const tLvl2 = (k: string): string | undefined => {
+          const v = (thinkByDiff as Record<string,string>)[k];
+          return typeof v === "string" && v.trim() ? v.trim() : undefined;
+        };
+        const a2 = toTier(incoming.default as string | undefined);
+        if (a2) {
+          const td = (incoming as { thinkingDefault?: string }).thinkingDefault;
+          next["A"] = td ? { ...a2, thinkingLevel: td } : a2;
+        }
+        for (const [tier, diff] of [["B","easy"],["C","moderate"],["D","difficult"]] as Array<[string,string]>) {
+          const m = toTier((incoming as Record<string,Record<string,string>>)?.byDifficulty?.[diff]);
+          if (m) { const tl = tLvl2(diff); next[tier] = tl ? { ...m, thinkingLevel: tl } : m; }
+        }
+        const x2 = toTier(incoming.master as string | undefined);
+        if (x2) {
+          const mt = (incoming as { thinkingMaster?: string }).thinkingMaster;
+          next["X"] = mt ? { ...x2, thinkingLevel: mt } : x2;
+        }
+        if (Object.keys(next).length > 0) {
+          (config as unknown as { tiers: unknown }).tiers = { ...((config as unknown as { tiers?: Record<string,unknown> })?.tiers ?? {}), ...next };
+        }
+      } catch {}
     } catch { /* best-effort */ }
   }
 

package/src/supervisor.ts

@@ -50,7 +50,8 @@ import { readJsonSafe, writeJsonAtomic, fileExists } from "./core/fsx.ts";
 import { decideNext, stopFilePath, type LoopDecision } from "./loop.ts";
 import { loadRunState, countSession, disarmRun } from "./runState.ts";
 import { effectiveDifficultyForTask } from "./scheduler.ts";
-import { resolveModel, resolveThinking, loadRouterConfig } from "./modelRouter.ts";
+import { resolveModel as legacyResolveModel, resolveThinking as legacyResolveThinking, loadRouterConfig } from "./modelRouter.ts";
+import { routeModel as coreRouteModel, effectiveDifficultyForTask as coreEffectiveDifficulty } from "./core/modelRouter.ts";
 import {
   WorkerSession,
   WORKER_DIRECTIVE,
@@ -371,7 +372,9 @@ export function currentUnit(targetDir: string, baseModel?: string | null): WorkU
   })();
   if (!identity) return null;
 
-  const routed = resolveModel({
+  // C: prefer config.tiers (core/modelRouter) — single source. Fallback to legacy model-router.json.
+  const useCore = (()=>{ try{ return Object.keys((config as unknown as { tiers?: Record<string,unknown> }).tiers ?? {}).length>0; }catch{return false;}})();
+  const routedLegacy = legacyResolveModel({
     projectDir: targetDir,
     task: task
       ? ({
@@ -386,12 +389,24 @@ export function currentUnit(targetDir: string, baseModel?: string | null): WorkU
     phase: phase ?? undefined,
     role: (config.currentRole ?? undefined) as string | undefined,
   });
-  const thinking = resolveThinking({
+  const thinkingLegacy = legacyResolveThinking({
     projectDir: targetDir,
     task: difficulty ? ({ difficulty } as never) : undefined,
     feature: (feature ?? undefined) as never,
     sprint: (sprint ?? undefined) as never,
   });
+  let routed = routedLegacy;
+  let thinking = thinkingLegacy;
+  if (useCore) {
+    try {
+      const mod = require("./runState.ts") as { loadRunState: (d:string)=>{ baseModel?: {provider:string;id:string}}|null };
+      const rs2 = mod.loadRunState(targetDir);
+      const coreRes = coreRouteModel({ difficulty: difficulty ?? undefined, config, runState: rs2 as unknown as { baseModel?: {provider:string;id:string}} | null });
+      routed = coreRes.provider + "/" + coreRes.id;
+      const tierThinking = (()=>{ try{ const tiers=(config as unknown as { tiers?: Record<string,{thinkingLevel?: string}> }).tiers ?? {}; const tk = ({easy:"B",moderate:"C",difficult:"D"} as Record<string,string>)[String(difficulty ?? "")] ?? "A"; const th = (tiers as Record<string,{thinkingLevel?: string}>)[tk]?.thinkingLevel; return typeof th==="string"&&th ? th : undefined; }catch{return undefined;}})();
+      if (tierThinking) thinking = tierThinking as unknown as typeof thinking;
+    } catch {}
+  }
 
   return {
     level,

package/src/ui/wizard.ts

@@ -226,7 +226,7 @@ async function pickModelsStep(
   if (masterModel === undefined) return undefined;
   const masterThinking = await pickThinkingLevel(prompt, "Consulting master — thinking level");
   if (masterThinking === undefined) return undefined;
-  const defaultModel = await pickModelChoice(prompt, "Default — fallback when nothing more specific matches", models, "");
+  const defaultModel = await pickModelChoice(prompt, "Default (tier A) — general work + undifficult tasks — idle under task handoff when every task has difficulty (" + tierScopeNote(handoff) + ")", models, "");
   if (defaultModel === undefined) return undefined;
   const defaultThinking = await pickThinkingLevel(prompt, "Default — thinking level fallback");
   if (defaultThinking === undefined) return undefined;