infinity-harness 2.8.9 → 2.8.10

package/CHANGELOG.md

@@ -4,6 +4,16 @@ 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.10] — 2026-08-31
+
+Thinking levels from pi, not inventoried; locals inherit correctly.
+
+### Fixed
+
+- **Thinking menu was hard-coded, not model-aware.** Wizard now filters the thinking-level picker to exactly what pi reports for the picked model (“pi truth”): local reasoning-off models (lfm2.5/qwen3.8/granite) only offer “(inherit)” + “off”; reasoning locals offer off…high; full providers offer off…max. “/infinity:config” thinking settings do the same per-tier. Previously all 7 were always offered, so locals could be set to xhigh.
+- **Locals died on “inherit” even with thinking blank.** Worker forced “inherit” (“”) to “medium” before “createAgentSession”, so even blank B/C/D sent reasoning_effort → max_completion_tokens:1. Changed to leave “” as undefined so pi uses its per-model default then clamps via model.thinkingLevelMap (off for reasoning:false locals). Fixed in daemon/worker, daemon/index, and core/modelRouter clampThinkingForProvider (now model-aware with provider-string fallback).
+- **Provider-string clamp was model-blind.** ”lm-studio → medium” broke xhigh-capable locals and still sent medium to 2b QAD models. Replaced with pi-ai getSupportedThinkingLevels semantics: reasoning:false → only off; reasoning:true + empty map → off…high (no xhigh/max); map null → filtered. Config file stays on pi’s THINKING_LEVELS definition, nothing invented.
+
 ## [2.8.9] — 2026-08-31
 
 Locals no longer die on xhigh; DEFINE ladder re-consults.

package/extensions/infinity-harness/index.ts

@@ -540,6 +540,27 @@ export default function (pi: ExtensionAPI): void {
    * would produce a tier that fails at the first task rather than at setup.
    */
   const availableModels = (ctx: ExtensionContext): ModelChoice[] => {
+    // Helper: get pi-default thinking levels for a model (the truth — not our THINKING_LEVELS)
+    const supportedOf = (m: unknown): readonly string[] | null => {
+      try {
+        const mod = m as { reasoning?: boolean; thinkingLevelMap?: Record<string, string | null> };
+        if (!mod) return null;
+        // pi-ai getSupportedThinkingLevels: reasoning false => ["off"]
+        if (mod.reasoning === false) return ["off"] as const;
+        if (mod.reasoning === true) {
+          const map = mod.thinkingLevelMap ?? {};
+          const all: readonly string[] = ["off","minimal","low","medium","high","xhigh","max"];
+          const supported = all.filter(l => {
+            const v = (map as Record<string, string | null | undefined>)[l];
+            if (v === null) return false;
+            if ((l === "xhigh" || l === "max") && v === undefined) return false;
+            return true;
+          });
+          return supported.length ? supported : (["off"] as const);
+        }
+        return null;
+      } catch { return null; }
+    };
     try {
       const scoped = ctx.scopedModels ?? [];
       const models =
@@ -558,7 +579,8 @@ export default function (pi: ExtensionAPI): void {
         if (m.name && m.name !== m.id) bits.push(`· ${m.name}`);
         if (m.contextWindow) bits.push(`· ${Math.round(m.contextWindow / 1000)}k ctx`);
         if (m.reasoning) bits.push("· reasoning");
-        out.push({ ref, label: bits.join(" ") });
+        const levels = supportedOf(m);
+        out.push({ ref, label: bits.join(" "), ...(levels ? { supportedThinkingLevels: levels } : {}) } as unknown as ModelChoice & { supportedThinkingLevels?: readonly string[] });
       }
       out.sort((a, b) => a.ref.localeCompare(b.ref));
       return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinity-harness",
-  "version": "2.8.9",
+  "version": "2.8.10",
   "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/modelRouter.ts

@@ -13,8 +13,30 @@ 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 | "" {
+export function clampThinkingForProvider(provider: string, level: string | "" | undefined, modelForCheck?: unknown): string | "" {
   if (!level) return (level ?? "") as string | "";
+  // If we have the actual model, use pi-default truth (getSupportedThinkingLevels semantics)
+  try {
+    const m = modelForCheck as { reasoning?: boolean; thinkingLevelMap?: Record<string, string | null> } | null | undefined;
+    if (m && typeof m.reasoning === "boolean") {
+      if (m.reasoning === false) return level === "off" || level === "" ? (level as string | "") : "off";
+      const map = m.thinkingLevelMap ?? {};
+      const all = ["off","minimal","low","medium","high","xhigh","max"] as const;
+      const supported = all.filter(l => {
+        const v = (map as Record<string, string | null | undefined>)[l];
+        if (v === null) return false;
+        if ((l === "xhigh" || l === "max") && v === undefined) return false;
+        return true;
+      });
+      if (supported.includes(level as typeof all[number])) return level as string | "";
+      // clamp to nearest supported (prefer lower)
+      const idx = (all as readonly string[]).indexOf(level);
+      for (let i = idx; i >= 0; i--) if (supported.includes(all[i] as typeof all[number])) return all[i] as string | "";
+      for (let i = idx+1; i < all.length; i++) if (supported.includes(all[i] as typeof all[number])) return all[i] as string | "";
+      return supported[0] ?? "off";
+    }
+  } catch {}
+  // Fallback: old provider-string heuristic for when model not available (e.g. in config migration)
   const pp = String(provider || "").toLowerCase();
   const isLocal = pp === "lm-studio" || pp.startsWith("lm-studio/") || pp === "lmstudio";
   if (!isLocal) return level as string | "";

package/src/daemon/index.ts

@@ -275,7 +275,7 @@ async function runLoop(targetDir: string): Promise<void> {
         model: askedModel,
         askedModel,
         servedModel: null,
-        thinking: clampThinkingForProvider(routed.provider, ((tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel as unknown as string) ?? "medium") || "medium",
+        thinking: clampThinkingForProvider(routed.provider, ((tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel as unknown as string) ?? "") || undefined,
         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: clampThinkingForProvider(routed.provider, ((tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel as unknown as string) ?? "medium") || "medium" },
+        modelSpec: { provider: routed.provider, id: routed.id, thinkingLevel: clampThinkingForProvider(routed.provider, ((tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel as unknown as string) ?? "") || undefined },
         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: clampThinkingForProvider(routed.provider, ((tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel as unknown as string) ?? "medium") || "medium" },
+              modelSpec: { provider: routed.provider, id: routed.id, thinkingLevel: clampThinkingForProvider(routed.provider, ((tierSpec as { thinkingLevel?: string } | null)?.thinkingLevel as unknown as string) ?? "") || undefined },
               askedModel,
               sessionManagerDir: `harness/sessions/${workerLabel.replace(/[^a-z0-9._-]/gi, "-")}`,
               customTools: (await import("./isolation.ts")).harnessToolsForWorker() as unknown[],

package/src/daemon/worker.ts

@@ -110,12 +110,35 @@ export async function createWorker(opts: CreateWorkerOpts): Promise<{
     ? SessionManager.create(opts.cwd, opts.sessionManagerDir)
     : SessionManager.inMemory(opts.cwd);
 
-  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)
+  // inherit means inherit — don't force medium. Only clamp when explicitly set.
+  let thinkingLevel: string | undefined = (opts.thinkingLevel ?? opts.modelSpec.thinkingLevel ?? undefined) as unknown as string | undefined;
+  // capability-aware clamp: use pi-default supported levels for the actual model, not provider string
   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";
+    const mod = model as unknown as { reasoning?: boolean; thinkingLevelMap?: Record<string, string | null> } | null;
+    if (thinkingLevel) {
+      // inline getSupportedThinkingLevels semantics
+      if (mod && typeof mod.reasoning === "boolean" && mod.reasoning === false) {
+        if (thinkingLevel !== "off") thinkingLevel = "off";
+      } else if (mod && mod.reasoning === true) {
+        const map = mod.thinkingLevelMap ?? {};
+        const all = ["off","minimal","low","medium","high","xhigh","max"] as const;
+        const supported = all.filter(l => {
+          const v = (map as Record<string, string | null | undefined>)[l];
+          if (v === null) return false;
+          if ((l === "xhigh" || l === "max") && v === undefined) return false;
+          return true;
+        });
+        if (!supported.includes(thinkingLevel as typeof all[number])) {
+          const idx = (all as readonly string[]).indexOf(thinkingLevel);
+          let found: string | null = null;
+          for (let i = idx; i >= 0; i--) if (supported.includes(all[i] as typeof all[number])) { found = all[i] as string; break; }
+          if (!found) for (let i = idx+1; i < all.length; i++) if (supported.includes(all[i] as typeof all[number])) { found = all[i] as string; break; }
+          thinkingLevel = found ?? supported[0] ?? "off";
+        }
+      }
+    } else if (thinkingLevel === undefined) {
+      // inherit (undefined) — leave undefined so createAgentSession uses pi-default for that model
+    }
   } 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 {}

package/src/ui/config.ts

@@ -39,6 +39,8 @@ export type ModelChoice = {
   ref: string;
   /** What the user sees. */
   label: string;
+  /** Pi-default supported thinking levels for this model, or null if unknown. */
+  supportedThinkingLevels?: readonly string[];
 };
 
 export type ConfigMenuOptions = {
@@ -167,7 +169,29 @@ async function editSetting(setting: Setting, options: ConfigMenuOptions): Promis
       break;
     }
     case "thinking": {
-      const choices = ["(inherit)", "off", "minimal", "low", "medium", "high", "xhigh", "max"];
+      // capability-aware: if setting is tiers.X.thinkingLevel etc, filter to what the model actually supports
+      let choices: string[] = ["(inherit)", "off", "minimal", "low", "medium", "high", "xhigh", "max"];
+      try {
+        const m = setting.path.match(/^tiers.([A-Z]).(provider|id|thinkingLevel)/);
+        // For tiers.A/B/C/D/X thinkingLevel, look up that tier's model and its supported levels
+        const tierMatch = setting.path.match(/^tiers.([A-Z]).thinkingLevel/);
+        if (tierMatch) {
+          const tier = tierMatch[1]!;
+          const all = readAll(targetDir);
+          const tierSpec = (all.config as unknown as { tiers?: Record<string, { provider?: string; id?: string }> }).tiers?.[tier];
+          if (tierSpec?.provider && tierSpec?.id) {
+            const ref = tierSpec.provider + "/" + tierSpec.id;
+            const models = await options.models();
+            const found = models.find(x => x.ref === ref) as unknown as { supportedThinkingLevels?: readonly string[] } | undefined;
+            if (found?.supportedThinkingLevels?.length) {
+              choices = ["(inherit)", ...found.supportedThinkingLevels.filter(l => l !== "off")];
+              // ensure off is last fallback if model supports only off
+              if (!found.supportedThinkingLevels.includes("off")) choices = ["(inherit)", ...found.supportedThinkingLevels];
+              else if (choices.indexOf("off") === -1) choices.splice(1,0,"off");
+            }
+          }
+        }
+      } catch {}
       const picked = await prompt.select(`${setting.label} — ${setting.help}`, [...choices, BACK]);
       if (picked === undefined || picked === BACK) return false;
       raw = picked;

package/src/ui/wizard.ts

@@ -153,8 +153,9 @@ async function pickModelChoice(prompt: Prompter, title: string, models: ModelCho
   return model?.ref;
 }
 
-async function pickThinkingLevel(prompt: Prompter, title: string): Promise<ThinkingLevel | "" | undefined> {
-  const picked = await prompt.select(title, [THINK_INHERIT, ...THINKING_LEVELS]);
+async function pickThinkingLevel(prompt: Prompter, title: string, supported?: readonly string[] | null): Promise<ThinkingLevel | "" | undefined> {
+  const levels = Array.isArray(supported) && supported.length ? supported as ThinkingLevel[] : THINKING_LEVELS;
+  const picked = await prompt.select(title, [THINK_INHERIT, ...levels]);
   if (picked === undefined) return undefined;
   if (picked === THINK_INHERIT) return "";
   return picked as ThinkingLevel;
@@ -214,21 +215,25 @@ async function pickModelsStep(
   const tiers = ["easy", "moderate", "difficult"] as const;
   const byDifficulty: Record<string, string> = {};
   const thinkingByDifficulty: Partial<Record<string, ThinkingLevel | "">> = {};
+  const supportedFor = (ref: string): readonly string[] | null => {
+    const m = models.find(x => x.ref === ref) as unknown as { supportedThinkingLevels?: readonly string[] } | undefined;
+    return (m as { supportedThinkingLevels?: readonly string[] } | undefined)?.supportedThinkingLevels ?? null;
+  };
   for (const tier of tiers) {
     const model = await pickModelChoice(prompt, `${tier.toUpperCase()} tier — model`, models, "");
     if (model === undefined) return undefined;
     byDifficulty[tier] = model;
-    const thinking = await pickThinkingLevel(prompt, `${tier.toUpperCase()} tier — thinking level`);
+    const thinking = await pickThinkingLevel(prompt, `${tier.toUpperCase()} tier — thinking level`, model ? supportedFor(model) : null);
     if (thinking === undefined) return undefined;
     thinkingByDifficulty[tier] = thinking;
   }
   const masterModel = await pickModelChoice(prompt, "Consulting master — model (used only when the ladder is exhausted)", models, "");
   if (masterModel === undefined) return undefined;
-  const masterThinking = await pickThinkingLevel(prompt, "Consulting master — thinking level");
+  const masterThinking = await pickThinkingLevel(prompt, "Consulting master — thinking level", masterModel ? supportedFor(masterModel) : null);
   if (masterThinking === undefined) return undefined;
   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");
+  const defaultThinking = await pickThinkingLevel(prompt, "Default — thinking level fallback", defaultModel ? supportedFor(defaultModel) : null);
   if (defaultThinking === undefined) return undefined;
   return {
     router: {