infinity-harness 2.8.7 → 2.8.9

package/CHANGELOG.md

@@ -4,6 +4,28 @@ 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.9] — 2026-08-31
+
+Locals no longer die on xhigh; DEFINE ladder re-consults.
+
+### Fixed
+
+- **Locals cut off at 1 token on xhigh.** LM Studio (lm-studio/*) forwarded reasoning_effort xhigh/max as max_completion_tokens:1. Added provider-aware clamp: lm-studio tiers (B/C/D/X when local) never get xhigh/max/high — they are clamped to medium at the router, in daemon/index and in worker createWorker, with a [worker] trace in harness/daemon.log. master (muse-spark) still gets xhigh. Verified: no more length=1 on lfm/qwen/granite.
+
+- **DEFINE never re-consulted after RESEARCH spent the ladder.** perLevelEscalation[subtask] kept consultedCount/masterUsed across phase advance (research/r1 → define/d1), so consult/master appeared spent. decideNext now resets perLevelEscalation when retryLevel changes or when tree moves; escalation instruction for feature-criteria now explicitly says to use infinity_plan to add criteria.
+
+## [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.9",
+  "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/core/modelRouter.ts

@@ -13,6 +13,15 @@ import type { TierMap, TierSpec, HarnessConfig, FeatureList, Phase, Difficulty }
 export type ThinkingLevel = import("./types.ts").ThinkingLevel;
 export type TierId = import("./types.ts").TierId;
 
+export function clampThinkingForProvider(provider: string, level: string | "" | undefined): string | "" {
+  if (!level) return (level ?? "") as string | "";
+  const pp = String(provider || "").toLowerCase();
+  const isLocal = pp === "lm-studio" || pp.startsWith("lm-studio/") || pp === "lmstudio";
+  if (!isLocal) return level as string | "";
+  if (level === "xhigh" || level === "max" || level === "high") return "medium";
+  return level as string | "";
+}
+
 const DIFF_TO_TIER: Record<Difficulty, import("./types.ts").TierId> = {
   easy: "B",
   moderate: "C",

package/src/daemon/index.ts

@@ -26,7 +26,7 @@ import { saveSupervisor, appendActivity, type SupervisorWorker } from "./supervi
 import { runPreflight } from "./preflight.ts";
 import { addUsageForTier, isCapExceeded, hasXLeak, xLeakReason, type Tier } from "./budget.ts";
 import { createWorker, promptWorker, type TurnResult } from "./worker.ts";
-import { routeModel, effectiveDifficultyForTask as effectiveDifficulty } from "../core/modelRouter.ts";
+import { routeModel, effectiveDifficultyForTask as effectiveDifficulty, clampThinkingForProvider } from "../core/modelRouter.ts";
 import { dirname } from "node:path";
 import type { Server } from "node:http";
 
@@ -275,7 +275,7 @@ async function runLoop(targetDir: string): Promise<void> {
         model: askedModel,
         askedModel,
         servedModel: null,
-        thinking: (tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel ?? "medium",
+        thinking: clampThinkingForProvider(routed.provider, ((tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel as unknown as string) ?? "medium") || "medium",
         state: "starting",
         doing: "starting",
         startedAt: new Date().toISOString(),
@@ -298,7 +298,7 @@ async function runLoop(targetDir: string): Promise<void> {
       const workerFactory = await import("./worker.ts");
       workerHandle = await workerFactory.createWorker({
         cwd: targetDir,
-        modelSpec: { provider: routed.provider, id: routed.id, thinkingLevel: (tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel ?? "medium" },
+        modelSpec: { provider: routed.provider, id: routed.id, thinkingLevel: clampThinkingForProvider(routed.provider, ((tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel as unknown as string) ?? "medium") || "medium" },
         askedModel,
         sessionManagerDir: `harness/sessions/${workerLabel.replace(/[^a-z0-9._-]/gi, "-")}`,
         customTools: (await import("./isolation.ts")).harnessToolsForWorker() as unknown[],
@@ -317,7 +317,7 @@ async function runLoop(targetDir: string): Promise<void> {
           if (!workerHandle) {
             workerHandle = await workerFactory.createWorker({
               cwd: targetDir,
-              modelSpec: { provider: routed.provider, id: routed.id, thinkingLevel: (tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel ?? "medium" },
+              modelSpec: { provider: routed.provider, id: routed.id, thinkingLevel: clampThinkingForProvider(routed.provider, ((tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel as unknown as string) ?? "medium") || "medium" },
               askedModel,
               sessionManagerDir: `harness/sessions/${workerLabel.replace(/[^a-z0-9._-]/gi, "-")}`,
               customTools: (await import("./isolation.ts")).harnessToolsForWorker() as unknown[],

package/src/daemon/worker.ts

@@ -110,7 +110,15 @@ export async function createWorker(opts: CreateWorkerOpts): Promise<{
     ? SessionManager.create(opts.cwd, opts.sessionManagerDir)
     : SessionManager.inMemory(opts.cwd);
 
-  const thinkingLevel = (opts.thinkingLevel ?? opts.modelSpec.thinkingLevel ?? "medium") as unknown as string;
+  let thinkingLevel = (opts.thinkingLevel ?? opts.modelSpec.thinkingLevel ?? "medium") as unknown as string;
+  // A: clamp for lm-studio (xhigh/max not supported, caused max_completion_tokens:1)
+  try {
+    const p = String(opts.modelSpec.provider || "").toLowerCase();
+    const isLocal = p === "lm-studio" || p.startsWith("lm-studio/") || p === "lmstudio";
+    if (isLocal && (thinkingLevel === "xhigh" || thinkingLevel === "max" || thinkingLevel === "high")) thinkingLevel = "medium";
+  } catch {}
+  // B: debug trace of routed model/thinking (readable in harness/daemon.log)
+  try { console.log("[worker] model=" + opts.modelSpec.provider + "/" + opts.modelSpec.id + " thinking=" + thinkingLevel + " askedModel=" + opts.askedModel); } catch {}
 
   const agentTools = opts.customTools as unknown as import("@earendil-works/pi-coding-agent").ToolDefinition[] | undefined;
 

package/src/loop.ts

@@ -486,11 +486,18 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
     // budgets in rework.json and replan.json still bound the run across
     // stalls, but a rung spent on a problem that resolved should not be
     // missing when a different problem appears.
-    state.escalation = { ...state.escalation, tried: [] };
-    const lev = retryLevel
-      ? escalationStateForLevel(state, retryLevel)
-      : null;
-    if (lev) setEscalationForLevel(state, retryLevel, { ...lev, tried: [] });
+    // C: also reset per-level escalation when the active unit changes (define/d1 vs research/r1),
+    // otherwise consult/master stays marked spent across unrelated tasks.
+    const lastLev = state.escalations.length ? state.escalations[state.escalations.length-1]?.level as string | undefined : undefined;
+    if (lastLev && lastLev !== (retryLevel ?? "task")) {
+      setEscalationForLevel(state, retryLevel ?? "task", { consultedCount: 0, masterUsed: false, lastUnstuckAt: null, fingerprints: [], tried: [] } as unknown as import("./escalate.ts").EscalationState);
+    } else {
+      state.escalation = { ...state.escalation, tried: [] };
+      const lev = retryLevel
+        ? escalationStateForLevel(state, retryLevel)
+        : null;
+      if (lev) setEscalationForLevel(state, retryLevel, { ...lev, tried: [] });
+    }
   } else {
     state.noProgressStreak += 1;
   }
@@ -597,6 +604,13 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
   const task = nextActionableTask(list);
   const focus = task ? `\nCurrent task: ${task.compositeKey} — ${task.description}` : "";
 
+  // C: feature-criteria guard — when DEFINE stalls on feature-criteria, the plan is wrong, not the model.
+  if (escalation && escalation.strategy === "consult" && gate && (gate.failures as string[]).some((f: string) => String(f).toLowerCase().includes("feature-criteria"))) {
+    try {
+      const msg = "The " + phase.toUpperCase() + " gate is blocked on feature-criteria: every feature needs acceptance criteria. This is a plan gap — use infinity_plan to add criteria, not just a model switch. Escalating to " + (escalation.model ?? "master") + " for help writing them.";
+      escalation = { ...escalation, instruction: msg + "\n" + (escalation.instruction ?? "") } as unknown as typeof escalation;
+    } catch {}
+  }
   // An escalation replaces the standard "fix these" nudge, because repeating
   // that nudge is exactly what the ladder exists to interrupt.
   const head = standingRejection

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;