infinity-harness 2.8.9 → 2.8.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinity-harness",
-  "version": "2.8.9",
+  "version": "2.8.11",
   "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": [
@@ -19,6 +19,7 @@
   },
   "pi": {
     "extensions": [
+      "./dist/extensions",
       "./extensions"
     ],
     "skills": [
@@ -27,6 +28,7 @@
   },
   "files": [
     "extensions/",
+    "dist/",
     "src/",
     "types/",
     "harness/skills/",
@@ -51,7 +53,8 @@
   "scripts": {
     "test": "node scripts/run-tests.mjs",
     "check": "tsc --noEmit",
-    "build": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "prepare": "npm run build",
     "e2e": "node scripts/e2e.mjs"
   },
   "homepage": "https://github.com/bakr-bagaber/infinity-harness#readme",

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: {