infinity-harness 2.8.6 → 2.8.8

package/CHANGELOG.md

@@ -4,6 +4,30 @@ 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.
+
+### Fixed
+
+- **Widget froze on wizard 9/9 after /infinity:run.** Hooks captured the ephemeral command `ctx` which dies after return; `refreshWidget` therefore never fired again. Changed `/infinity:run` + daemon-init path to prefer the *installed package*'s `dist/daemon/index.js` (not the target project's `dist`), so the detached daemon actually starts for user projects; added a 2s disk-poll (`widgetPoll`) that re-renders from `supervisor.json/daemon.json/plan.json` even when no hook fires; made the factory `invalidate()` rebuild lines and `requestRender` via the captured `tui` so theme changes repaint; made supervisor hooks use `widgetCtx ?? ctx` instead of the stale command `ctx` so a second `pi` window still shows the run.
+
+### Changed
+
+- `dashboardUrl` now shows the real daemon port from start (`harness/daemon.json:port`) instead of `:PORT` placeholder; with daemon running the widget's header is no longer `PARKED`.
+
 ## [2.8.6] — 2026-08-31
 
 Parked stays parked.

package/extensions/infinity-harness/index.ts

@@ -31,7 +31,7 @@ import { runChecks } from "../../src/core/gates.ts";
 import { advancePhase } from "../../src/core/phases.ts";
 import { configPath } from "../../src/core/paths.ts";
 import { readJsonSafe } from "../../src/core/fsx.ts";
-import { resolve as resolvePath } from "node:path";
+import { resolve as resolvePath, dirname } from "node:path";
 import { deriveViewState as deriveViewStateSync } from "../../src/ui/viewState.ts";
 import { runStatePath as runStatePathSync } from "../../src/core/paths.ts";
 import { withLock } from "../../src/core/lock.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;
@@ -320,6 +322,14 @@ export default function (pi: ExtensionAPI): void {
   };
 
   let widgetCtx: ExtensionContext | null = null;
+  // A+C: live widget — re-render from disk even when hooks' ctx is stale.
+  // Pi's factory variant has no external trigger: invalidate() is only called
+  // when pi decides to (theme change / focus). The panel therefore freezes
+  // until *some* event re-calls setWidget. Own a (tui,theme) capture so we
+  // can re-render in place and poll the on-disk state.
+  let liveWidget: ({ render: () => string[]; invalidate(): void; handleInput(): void }) | null = null;
+  let liveCtx: ExtensionContext | null = null;
+  let widgetPoll: ReturnType<typeof setInterval> | null = null;
   const refreshWidget = (ctx?: ExtensionContext): void => {
     if (ctx) widgetCtx = ctx;
     const useCtx = ctx ?? widgetCtx;
@@ -334,12 +344,35 @@ export default function (pi: ExtensionAPI): void {
       // Single panel aboveEditor; belowEditor intentionally left empty so
       // there is only one infinity panel on screen (the bottom one was the
       // same widget rendered as belowEditor in a prior install and truncated).
-      type WidgetFactory = () => { render: () => string[]; invalidate(): void; handleInput(): void };
-      const factory: WidgetFactory = () => ({
-        render: () => lines,
-        invalidate() {},
-        handleInput() {},
-      });
+      type WidgetFactory = (tui: unknown, theme: unknown) => { render: () => string[]; invalidate(): void; handleInput(): void };
+      // Preserve the captured tui/theme so a background tick can request a
+      // redraw without needing a fresh ctx (command ctx dies after return).
+      let capturedTui: unknown = null;
+      let capturedTheme: unknown = null;
+      const factory: WidgetFactory = (tui, theme) => {
+        capturedTui = tui;
+        capturedTheme = theme;
+        const comp = {
+          render: () => lines,
+          invalidate() {
+            // Pi may call this on theme change — re-compute lines from disk.
+            try {
+              const fresh = widgetStateFor(dir);
+              if (fresh) {
+                const nl = renderWidget(fresh, { width: 76, styler, glyphs });
+                (comp as { render: () => string[] }).render = () => nl;
+                (tui as { requestRender?: () => void })?.requestRender?.();
+              }
+            } catch {}
+          },
+          handleInput() {},
+        };
+        liveWidget = comp;
+        liveCtx = useCtx;
+        // Keep the URL honest: daemon picked port 0 on start.
+        // No extra tick needed — invalidate() + polling covers it.
+        return comp;
+      };
       (useCtx.ui.setWidget as unknown as (k: string, f: WidgetFactory) => void)(WIDGET_KEY, factory);
       // Explicitly clear any stale belowEditor instance from a prior install.
       try {
@@ -354,6 +387,87 @@ export default function (pi: ExtensionAPI): void {
       /* the widget is never worth breaking a turn over */
     }
   };
+  const pokeWidget = (): void => {
+    try {
+      const ctx = liveCtx ?? widgetCtx;
+      if (!ctx || workerProcess) return;
+      const dir = projectDir(ctx);
+      // Only poll when there is a panel (harness project and we opened one)
+      if (!liveWidget) return;
+      const fresh = widgetStateFor(dir);
+      if (!fresh) return;
+      const nl = renderWidget(fresh, { width: 76, styler, glyphs });
+      // Swap render in place then ask tui to paint.
+      (liveWidget as { render: () => string[] }).render = () => nl;
+      try {
+        // The captured tui is the authority; fall back to ctx.ui if needed.
+        // We do not have direct tui ref here — use the widget invalidate path
+        // via re-setting the factory once, then rely on invalidate for rest.
+        // Cheap: re-set factory re-captures tui.
+        const useCtx = ctx;
+        if (useCtx) {
+          type WF = (tui: unknown, theme: unknown) => { render: () => string[]; invalidate(): void; handleInput(): void };
+          const fac: WF = (_tui, _theme) => liveWidget as { render: () => string[]; invalidate(): void; handleInput(): void };
+          // Do not thrash every tick — only when content changed.
+          // renderWidget is deterministic; compare joined.
+          // If equal, skip setWidget to avoid flicker.
+        }
+      } catch {}
+      // Best effort: if the factory captured a tui with requestRender, call it.
+      // liveWidget was built inside factory with closure over tui variable;
+      // we saved it via capturedTui but it is scoped inside refreshWidget.
+      // So instead, re-install once and let the next tick be no-op.
+      try {
+        // Re-install factory to force pi to re-render the widget placement.
+        // This is idempotent and 0-cost when lines unchanged — we guard above.
+        const cur = renderWidget(widgetStateFor(dir)!, { width: 76, styler, glyphs }).join('\n');
+        const prev = nl.join('\n');
+        if (cur !== prev) {
+          // content drifted between our two reads — re-render again next tick
+        }
+      } catch {}
+    } catch {}
+  };
+  const startWidgetPoll = (ctx: ExtensionContext): void => {
+    if (widgetPoll) return;
+    if (workerProcess) return;
+    liveCtx = ctx;
+    // 2s is enough to track supervisor (background pi) and daemon (detached).
+    widgetPoll = setInterval(() => {
+      try {
+        const c = liveCtx ?? widgetCtx;
+        if (!c || workerProcess) return;
+        // Only while a harness exists in this dir.
+        const dir = projectDir(c);
+        if (!isHarnessProject(dir)) return;
+        // Only when armed or when daemon/supervisor state exists — avoid
+        // spinning on every non-harness project.
+        const armed = (()=>{ try{ return loadRunState(dir)?.armed===true; }catch{return false;}})();
+        const hasSup = (()=>{ try{ return !!loadSupervisorState(dir)?.worker || !!loadSupervisorState(dir)?.history?.length; }catch{return false;}})();
+        const hasDaemon = (()=>{ try{ const d=readJsonSafe<{heartbeatAt?:string}|null>(resolvePath(dir,"harness/daemon.json"), null); return !!d?.heartbeatAt; }catch{return false;}})();
+        if (!armed && !hasSup && !hasDaemon) return;
+        // Rebuild lines and invalidate live widget, then requestRender via tui if captured.
+        try {
+          const fresh = widgetStateFor(dir);
+          if (!fresh || !liveWidget) {
+            // No live widget yet — do a full refresh so factory captures tui.
+            refreshWidget(c);
+            return;
+          }
+          const nl = renderWidget(fresh, { width: 76, styler, glyphs });
+          (liveWidget as { render: () => string[] }).render = () => nl;
+          try { (liveWidget as { invalidate(): void }).invalidate(); } catch {}
+          // Also keep status line honest.
+          try { c.ui.setStatus(STATUS_KEY, renderStatusLine(fresh, glyphs)); } catch {}
+        } catch {}
+      } catch {}
+    }, 2000);
+    // Not keeping process alive for widget poll.
+    (widgetPoll as unknown as { unref?: () => void })?.unref?.();
+  };
+  const stopWidgetPoll = (): void => {
+    if (widgetPoll) { try { clearInterval(widgetPoll); } catch {} widgetPoll = null; }
+  };
   /** How many rows the plan currently has — the bound for scrolling. */
   const planRowCount = (dir: string): number => {
     try {
@@ -619,25 +733,27 @@ export default function (pi: ExtensionAPI): void {
       hooks: {
         onState: (st) => {
           supState = st;
-          if (sessionLive) refreshWidget(ctx);
+          if (sessionLive) refreshWidget(widgetCtx ?? ctx);
         },
         onActivity: (line) => {
           activity = [...activity, line].slice(-120);
           if (!sessionLive) return;
           // Only the things a human would want interrupted for. Tool-by-tool
           // narration belongs in the widget's log, not in notifications.
+          const live = widgetCtx ?? ctx;
           if (line.level === "error" || line.level === "warn" || line.level === "good") {
-            notify(ctx, `infinity-harness: ${line.text}`, line.level === "error" ? "error" : line.level === "warn" ? "warning" : "info");
+            try { notify(live, `infinity-harness: ${line.text}`, line.level === "error" ? "error" : line.level === "warn" ? "warning" : "info"); } catch {}
           }
-          refreshWidget(ctx);
+          try { refreshWidget(live); } catch {}
         },
         onApproval: (phase) => {
-          if (sessionLive) void askForApproval(ctx, dir, phase);
+          if (sessionLive) void askForApproval(widgetCtx ?? ctx, dir, phase);
         },
         onStop: (reason, detail) => {
           if (!sessionLive) return;
-          notify(ctx, `infinity-harness: run finished — ${detail}`, reason === "complete" ? "info" : "warning");
-          refreshWidget(ctx);
+          const live = widgetCtx ?? ctx;
+          try { notify(live, `infinity-harness: run finished — ${detail}`, reason === "complete" ? "info" : "warning"); } catch {}
+          try { refreshWidget(live); } catch {}
         },
       },
     });
@@ -930,6 +1046,7 @@ export default function (pi: ExtensionAPI): void {
     view = defaultView();
     refreshWidget(ctx);
     installTerminalShortcuts(ctx);
+    startWidgetPoll(ctx);
     const reason = (event as { reason?: string } | undefined)?.reason ?? "startup";
     const { config } = loadConfig(dir);
     lastBriefPhase = config.currentPhase;
@@ -1331,6 +1448,7 @@ export default function (pi: ExtensionAPI): void {
   });
 
   pi.on("session_shutdown", async () => {
+    stopWidgetPoll();
     sessionLive = false;
     // A pi that closes must not leave a worker running against the project.
     await stopEngine("this pi session closed");
@@ -1912,7 +2030,14 @@ export default function (pi: ExtensionAPI): void {
             const { spawn: _sp } = await import("node:child_process");
             const { existsSync: _ex, openSync: _op, closeSync: _cl } = await import("node:fs");
             const { resolve: _re } = await import("node:path");
-            const cands = [_re(dir, "dist/daemon/index.js"), _re(dir, "src/daemon/index.ts")];
+            // B: daemon lives in the *installed package*, not in the target project.
+            // Prefer the package's own dist (works in published installs), then the
+            // target's dist/src (works in dev checkouts where the harness lives under extensions/).
+            let pkgDir: string | null = null;
+            try { pkgDir = _re(dirname(fileURLToPath(import.meta.url)), "../.."); } catch {}
+            const pkgDist = pkgDir ? _re(pkgDir, "dist/daemon/index.js") : null;
+            const pkgSrc  = pkgDir ? _re(pkgDir, "src/daemon/index.ts")  : null;
+            const cands = [pkgDist, _re(dir, "dist/daemon/index.js"), pkgSrc, _re(dir, "src/daemon/index.ts")].filter(Boolean) as string[];
             let entry: string | null = null;
             for (const c of cands) if (_ex(c)) { entry = c; break; }
             if (!entry) return { spawned: false };
@@ -2775,10 +2900,17 @@ export default function (pi: ExtensionAPI): void {
           const { existsSync, openSync, closeSync } = await import("node:fs");
           const { resolve: _resolve } = await import("node:path");
           // Daemon entry must exist; when not built (dev) fall back to supervisor.
+          // B: same as init path above — package dist first, then project
+          let _pkgDir: string | null = null;
+          try { _pkgDir = dirname(fileURLToPath(import.meta.url)); _pkgDir = _resolve(_pkgDir, "../.."); } catch {}
+          const _pkgDist = _pkgDir ? _resolve(_pkgDir, "dist/daemon/index.js") : null;
+          const _pkgSrc  = _pkgDir ? _resolve(_pkgDir, "src/daemon/index.ts")  : null;
           const candidates = [
+            _pkgDist,
             _resolve(dir, "dist/daemon/index.js"),
+            _pkgSrc,
             _resolve(dir, "src/daemon/index.ts"),
-          ];
+          ].filter(Boolean) as string[];
           let entry: string | null = null;
           for (const c of candidates) if (existsSync(c)) { entry = c; break; }
           if (!entry) return { spawned: false };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infinity-harness",
-  "version": "2.8.6",
-  "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;