@bacnh85/pi-advisor 0.2.4 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.3.0 (2026-09-13)
+
+### Added
+
+- **Per-slot thinking levels.** A trailing `:level`
+  (`minimal|low|medium|high|xhigh|max`) on a `pi-advisor.models` entry pins
+  that candidate's thinking; it rides into the stream call as
+  `SimpleStreamOptions.reasoning`. Entries without a suffix (and `:off`)
+  keep the provider default, so each fallback in the chain can carry its own
+  level. Strict trailing match — openrouter `:free` ids stay intact.
+  `/advisor models` gains a thinking row per slot (blank = model default);
+  the chain canonicalizer preserves pinned levels on save.
+
+### Fixed
+
+- Evidence sizing now strips a trailing `:level` before the registry lookup —
+  previously a pinned entry failed `parseModelRef` and the transcript budget
+  silently fell back to the 32k default (over-sizing for small-context
+  fallback models, whose context errors count toward the 3-strike pause).
+
 ## 0.2.4 (2026-09-12)
 
 ### Removed

package/README.md

@@ -44,7 +44,7 @@ npm install -g @bacnh85/pi-advisor
 
 ```bash
 /advisor <provider/model[, …]>  # set the chain (one model or comma-separated fallbacks)
-/advisor models             # edit the full model chain (TUI panel; non-TUI prints it)
+/advisor models             # edit the chain + per-slot thinking rows (TUI panel; non-TUI prints it)
 /advisor status             # model chain, watch state, counters
 /advisor on                 # enable watch for this session (also clears a pause)
 /advisor watch-off          # disable background watch for this session
@@ -57,18 +57,22 @@ Settings live in `~/.pi/agent/settings.json` (global) and `.pi/settings.json`
 ```json
 {
   "pi-advisor": {
-    "models": ["zai-coding-cn/glm-5.3", "opencode-go/deepseek-v4-pro"],
+    "models": ["zai-coding-cn/glm-5.3:high", "opencode-go/deepseek-v4-pro"],
     "watch": { "enabled": true, "minToolCalls": 3, "immuneTurns": 3 }
   }
 }
 ```
 
 - `models` — ordered fallback chain, first entry is primary. Accepts an array
-  or a comma-separated string (`"a/b, c/d"`). Legacy single `model` string is
-  still honored. If the primary is rate-limited or unavailable at review/consult
-  time, the next candidate serves automatically; a whole-chain failure counts
-  as one review failure (the 3-strike pause still applies). The advisor never
-  falls back to the primary model — it must never review its own turns.
+  or a comma-separated string (`"a/b, c/d"`). A trailing `:level`
+  (`minimal|low|medium|high|xhigh|max`) on an entry pins that candidate's
+  thinking; entries without one use the model's provider default, so each
+  fallback can carry its own level (`:high` on a strong primary, none on a
+  flash fallback). Legacy single `model` string is still honored. If the
+  primary is rate-limited or unavailable at review/consult time, the next
+  candidate serves automatically; a whole-chain failure counts as one review
+  failure (the 3-strike pause still applies). The advisor never falls back to
+  the primary model — it must never review its own turns.
 - `watch.enabled` (default `true`) — turn-end reviewing on session start (TUI only — print/rpc/json runs skip the watch; the on-demand advisor tool still works)
 - `watch.minToolCalls` (default `3`, `0` = every turn) — skip trivial turns
 - `watch.immuneTurns` (default `3`) — review window during which the same

package/extensions/commands/advisor.ts

@@ -2,7 +2,7 @@ import { buildSessionContext, type ExtensionAPI, type ExtensionContext } from "@
 import { fuzzyFilter } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { runIsolatedChain } from "../lib/isolated-model";
-import { chooseModel, exactModel, firstAvailable, modelRef, modelSearchText } from "../lib/model-picker";
+import { canonicalEntry, chooseModel, exactModel, firstAvailable, modelRef, modelSearchText } from "../lib/model-picker";
 import { buildEvidence } from "../lib/watcher";
 import type { WatcherRuntime } from "../lib/watcher";
 
@@ -153,6 +153,7 @@ export function registerAdvisor(pi: ExtensionAPI, state: AdvisorState): void {
         "Advisor models (ordered fallback, first = primary):",
         ...(models.length > 0 ? models.map((m, i) => `  #${i + 1}  ${m}`) : ["  (none — advisor inactive)"]),
         "",
+        `Append :level (minimal…max) to an entry to pin thinking per slot.`,
         `Edit ~/.pi/agent/settings.json → pi-advisor.models, or run /advisor models in a TUI.`,
       ];
       pi.sendMessage({ customType: "pi-advisor", content: lines.join("\n"), display: true });
@@ -160,10 +161,10 @@ export function registerAdvisor(pi: ExtensionAPI, state: AdvisorState): void {
     }
     const working = panel.buildModelsPanelCfg(models);
     const actions: Record<string, { label: string; run: (prompt: (label: string, onDone: (value: string | undefined) => void) => void) => Promise<void> | void }> = {
-      addModel: { label: "+ Add model slot", run: () => { working.models.push(""); } },
+      addModel: { label: "+ Add model slot", run: () => { working.models.push({ ref: "", thinking: "" }); } },
       removeLast: { label: "− Remove last slot", run: () => {
         const popped = working.models.pop();
-        if (popped) ctx.ui.notify(`Removed slot #${working.models.length + 1} ("${popped}" discarded).`, "warning");
+        if (popped?.ref) ctx.ui.notify(`Removed slot #${working.models.length + 1} ("${popped.ref}" discarded).`, "warning");
       } },
     };
     const panelOptions = { models: () => (registry?.getAvailable() ?? []).map((m) => modelRef(m)) };
@@ -174,6 +175,8 @@ export function registerAdvisor(pi: ExtensionAPI, state: AdvisorState): void {
       title: "Advisor models (ordered fallback)",
       onSave: (saved) => {
         if (!saved) return;
+        const invalid = panel.invalidThinkingSlots(working);
+        if (invalid.length > 0) ctx.ui.notify(`Dropped invalid thinking in slot(s): ${invalid.map((i) => `#${i + 1}`).join(", ")} (valid: minimal…max).`, "warning");
         // set() persists, updates the runtime, syncs tool availability, and
         // notifies; surface unexpected rejections instead of dropping them.
         set(panel.cfgToModels(working), ctx).catch((error) => ctx.ui.notify(`Advisor update failed: ${String(error)}`, "error"));
@@ -229,13 +232,10 @@ export function registerAdvisor(pi: ExtensionAPI, state: AdvisorState): void {
         // chain runner and availability gate skip dead entries at call time).
         // Dedupe here too: two raw spellings can resolve to the same provider/id.
         const available = ctx.modelRegistry.getAvailable();
-        return await set([...new Set(chain.map((entry) => {
-          const match = exactModel(available, entry);
-          return match ? modelRef(match) : entry;
-        }))], ctx);
+        return await set([...new Set(chain.map((entry) => canonicalEntry(available, entry)))], ctx);
       }
       const match = chain.length === 1 ? exactModel(ctx.modelRegistry.getAvailable(), chain[0]) : undefined;
-      if (match) return await set([modelRef(match)], ctx);
+      if (match) return await set([canonicalEntry(ctx.modelRegistry.getAvailable(), chain[0])], ctx);
       if (ctx.mode !== "tui") throw new Error("Usage: /advisor <provider/model[, …]|models|on|off|status>");
       const choice = await chooseModel(ctx, firstAvailable(ctx, state.getModels()), args.trim() || undefined);
       if (!choice) return;

package/extensions/lib/config.ts

@@ -108,6 +108,20 @@ export function parseModel(value: string): { provider: string; id: string } | un
   return { provider: value.slice(0, slash), id: value.slice(slash + 1) };
 }
 
+/** Thinking levels accepted as a trailing `:level` on a chain entry.
+ *  `off` maps to "no explicit level" (SimpleStreamOptions.reasoning has no off). */
+export const THINKING_LEVELS: readonly string[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+
+/** Split a trailing `:thinking` suffix. Strict trailing match only — openrouter
+ *  ids like `model:free` stay intact. */
+export function splitThinkingSuffix(entry: string): { name: string; thinking?: string } {
+  const idx = entry.lastIndexOf(":");
+  if (idx <= 0 || idx >= entry.length - 1) return { name: entry };
+  const suffix = entry.slice(idx + 1);
+  if (!THINKING_LEVELS.includes(suffix)) return { name: entry };
+  return { name: entry.slice(0, idx), thinking: suffix };
+}
+
 /**
  * One-shot legacy migration: if pi-advisor.model is unset, adopt the old
  * pi-plan advisorModel preference so existing users keep their advisor.

package/extensions/lib/isolated-model.ts

@@ -1,6 +1,6 @@
 import { streamSimple } from "@earendil-works/pi-ai/compat";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { parseModel } from "./config";
+import { parseModel, splitThinkingSuffix } from "./config";
 
 export interface IsolatedContext {
   systemPrompt: string;
@@ -21,14 +21,19 @@ export async function runIsolated(
   /** Progress hook — every stream event (incl. non-text deltas) resets the caller's idle deadline. */
   onEvent?: () => void,
 ): Promise<string> {
-  const parsed = modelId ? parseModel(modelId) : undefined;
+  // A trailing `:level` on the chain entry pins thinking for this candidate;
+  // `:off` and no suffix fall back to the chain-wide reasoning (or the
+  // provider default when that is unset too).
+  const { name, thinking } = modelId ? splitThinkingSuffix(modelId) : { name: modelId, thinking: undefined };
+  const effectiveReasoning = thinking && thinking !== "off" ? thinking : reasoning;
+  const parsed = name ? parseModel(name) : undefined;
   if (modelId && !parsed) throw new Error(`Invalid model: ${modelId}`);
   const model = parsed ? ctx.modelRegistry.find(parsed.provider, parsed.id) : ctx.model;
   if (!model) throw new Error(`Model unavailable: ${modelId ?? "active"}`);
   const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
   if (!auth.ok) throw new Error(auth.error);
   const provider = ctx.modelRegistry.getRegisteredProviderConfig(model.provider);
-  const options: Record<string, unknown> = { apiKey: auth.apiKey, headers: auth.headers, env: auth.env, signal, reasoning };
+  const options: Record<string, unknown> = { apiKey: auth.apiKey, headers: auth.headers, env: auth.env, signal, reasoning: effectiveReasoning };
   // ponytail: providers accept SimpleStreamOptions which expects ThinkingLevel for reasoning
   const streamOptions = options as any;
   const response = provider?.streamSimple

package/extensions/lib/model-picker.ts

@@ -1,4 +1,5 @@
 import { ModelSelectorComponent, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { splitThinkingSuffix } from "./config";
 
 export type Model = ReturnType<ExtensionContext["modelRegistry"]["getAvailable"]>[number];
 
@@ -6,9 +7,11 @@ export function modelRef(model: Pick<Model, "provider" | "id">): string {
   return `${model.provider}/${model.id}`;
 }
 
-/** Resolve a `provider/model` (or unambiguous bare id) reference against available models. */
+/** Resolve a `provider/model` (or unambiguous bare id) reference against available models.
+ *  A trailing `:level` thinking suffix is ignored for matching. */
 export function exactModel(models: Model[], reference: string): Model | undefined {
-  const value = reference.trim().toLowerCase();
+  const { name } = splitThinkingSuffix(reference.trim());
+  const value = name.toLowerCase();
   if (!value) return undefined;
   const canonical = models.filter((model) => modelRef(model).toLowerCase() === value);
   if (canonical.length === 1) return canonical[0];
@@ -21,6 +24,15 @@ export function modelAvailable(ctx: ExtensionContext, modelId: string | undefine
   return !!modelId && !!exactModel(ctx.modelRegistry.getAvailable(), modelId);
 }
 
+/** Canonicalize a chain entry: resolve the ref (ignoring a trailing `:level`),
+ *  re-attach the level so a pinned thinking level survives the save. */
+export function canonicalEntry(models: Model[], entry: string): string {
+  const { name, thinking } = splitThinkingSuffix(entry.trim());
+  const match = exactModel(models, name);
+  if (!match) return entry;
+  return thinking ? `${modelRef(match)}:${thinking}` : modelRef(match);
+}
+
 /** First registry-available ref in the chain, or undefined when none resolve. */
 export function firstAvailable(ctx: ExtensionContext, models: readonly string[]): string | undefined {
   return models.find((model) => modelAvailable(ctx, model));

package/extensions/lib/models-panel.ts

@@ -1,14 +1,17 @@
 /**
  * `/advisor models` panel (kernel lives in @bacnh85/pi-config-panel).
  *
- * One string row per model slot (ordered fallback chain, blank = remove
- * slot), plus "Add model slot" / "Remove last" action rows. Saving writes
- * the chain to the GLOBAL `~/.pi/agent/settings.json` under
- * `pi-advisor.models` (merge + atomic rename via saveModels).
+ * Per slot: a model-ref row plus a thinking row (blank = provider default).
+ * A pinned level serializes into the chain entry as `provider/id:level`
+ * (strict trailing match; openrouter `:free` ids stay intact), so the saved
+ * `pi-advisor.models` shape stays a plain string array. Plus "Add model slot"
+ * / "Remove last" action rows. Saving writes to the GLOBAL
+ * `~/.pi/agent/settings.json` via saveModels (merge + atomic rename).
  */
 
 import { row } from "@bacnh85/pi-config-panel";
 import type { PanelGroup, PanelAction } from "@bacnh85/pi-config-panel";
+import { splitThinkingSuffix, THINKING_LEVELS } from "./config";
 
 /** Completion sources for the panel's model rows (lazy — resolved per keypress). */
 export interface ModelsPanelOptions {
@@ -17,37 +20,61 @@ export interface ModelsPanelOptions {
 }
 
 export interface ModelsPanelCfg {
-  /** Working copy: ordered chain; blank row = removed slot. */
-  models: string[];
+  /** Working copy: ordered slots; blank ref = removed slot. */
+  models: { ref: string; thinking: string }[];
 }
 
-/** Seed a working config from the current effective chain. */
+/** Seed a working config from the current effective chain (`ref:level` entries parsed). */
 export function buildModelsPanelCfg(models: readonly string[]): ModelsPanelCfg {
-  return { models: [...models] };
+  return {
+    models: models.map((entry) => {
+      const { name, thinking } = splitThinkingSuffix(String(entry ?? "").trim());
+      return { ref: name, thinking: thinking ?? "" };
+    }),
+  };
 }
 
-/** Build panel groups: one row per slot + add/remove actions.
+/** Build panel groups: per-slot model + thinking rows + add/remove actions.
  *  `options` adds inline model completions (optional so unit tests and
  *  non-TUI callers stay unchanged). */
 export function buildRows(cfg: ModelsPanelCfg, options?: ModelsPanelOptions, actions: Record<string, PanelAction> = {}): PanelGroup[] {
   const modelItems = (): { value: string }[] =>
     (options?.models() ?? []).sort().map((ref) => ({ value: ref }));
   const withCompletions = options ? { completions: modelItems } : {};
-  const slotRows = cfg.models.map((value, index) =>
-    row(`model.${index}`, `#${index + 1}${index === 0 ? " (primary)" : ""}`, "string", value, (v) => {
-      cfg.models[index] = String(v ?? "").trim();
-    }, withCompletions),
-  );
+  const levelItems = () => THINKING_LEVELS.filter((l) => l !== "off").map((level) => ({ value: level }));
+  const rows = cfg.models.flatMap((slot, index) => {
+    const modelRow = row(`model.${index}`, `#${index + 1}${index === 0 ? " (primary)" : ""}`, "string", slot.ref, (v) => {
+      slot.ref = String(v ?? "").trim();
+    }, withCompletions);
+    const thinkingRow = row(`model.${index}.thinking`, `#${index + 1} thinking (blank = model default)`, "string", slot.thinking, (v) => {
+      slot.thinking = String(v ?? "").trim();
+    }, { completions: levelItems } as unknown as { mask?: boolean });
+    return [modelRow, thinkingRow];
+  });
   const actionRows = Object.entries(actions).map(([key, action]) => ({ key, label: action.label, kind: "action" as const, value: "", set: action.run as unknown as (v: unknown) => void }));
-  return [{ key: "models", label: "Model chain (ordered fallback, first = primary)", rows: [...slotRows, ...actionRows] }];
+  return [{ key: "models", label: "Model chain (ordered fallback, first = primary)", rows: [...rows, ...actionRows] }];
 }
 
-/** Convert a working config back to the saved chain (blanks removed). */
+/** Slot indexes whose thinking value is non-blank but not a valid level
+ *  (typo guard — cfgToModels drops them). Empty when all values are OK. */
+export function invalidThinkingSlots(cfg: ModelsPanelCfg): number[] {
+  const out: number[] = [];
+  cfg.models.forEach((slot, index) => {
+    const t = slot.thinking.trim();
+    if (t && !THINKING_LEVELS.includes(t)) out.push(index);
+  });
+  return out;
+}
+
+/** Convert a working config back to the saved chain: `ref:level` when a valid
+ *  level is pinned; blank refs and invalid levels dropped. */
 export function cfgToModels(cfg: ModelsPanelCfg): string[] {
   const out: string[] = [];
-  for (const entry of cfg.models) {
-    const trimmed = String(entry ?? "").trim();
-    if (trimmed) out.push(trimmed);
+  for (const slot of cfg.models) {
+    const ref = slot.ref.trim();
+    if (!ref) continue;
+    const thinking = slot.thinking.trim();
+    out.push(thinking && THINKING_LEVELS.includes(thinking) && thinking !== "off" ? `${ref}:${thinking}` : ref);
   }
   return out;
 }

package/extensions/lib/watcher.ts

@@ -1,7 +1,7 @@
 import { buildSessionContext, convertToLlm, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { runIsolatedChain } from "./isolated-model";
 import { createGuard, guardCheck, nextCycle, parseReviewOutput, type GuardState, type Severity } from "./emission-guard";
-import type { AdvisorConfig } from "./config";
+import { splitThinkingSuffix, type AdvisorConfig } from "./config";
 
 export const REVIEW_ENTRY = "pi-advisor";
 export type { Severity };
@@ -103,9 +103,10 @@ export function buildEvidence(ctx: ExtensionContext, modelId: string | readonly
 }
 
 function parseModelRef(value: string): { provider: string; id: string } | undefined {
-  const slash = value.indexOf("/");
-  if (slash <= 0 || slash === value.length - 1) return undefined;
-  return { provider: value.slice(0, slash), id: value.slice(slash + 1) };
+  const { name } = splitThinkingSuffix(value);
+  const slash = name.indexOf("/");
+  if (slash <= 0 || slash === name.length - 1) return undefined;
+  return { provider: name.slice(0, slash), id: name.slice(slash + 1) };
 }
 
 function toolCallCount(entries: any[], sinceId: string | undefined): number {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-advisor",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Pi extension for an automatic advisor: a second model that reviews each settled turn and injects severity-routed notes, plus an on-demand consult tool.",
   "type": "module",
   "license": "MIT",