@pi-archimedes/session-name 2.10.4 → 2.11.1

package/README.md

@@ -41,7 +41,7 @@ After installing Pi, choose one installation command above, then `cd` into your
 | Setting | Type | Default | Description |
 |---------|------|---------|-------------|
 | `model` | string | _(current model)_ | Model used for title generation (e.g. `openai/gpt-4o-mini`). Canonical `provider/id`, bare IDs, and thinking-suffix forms are all resolved. Empty = current model. |
-| `reasoning` | string \| null | `minimal` | Thinking level for the title request: `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Set `null` to omit the option entirely — that's the fix for a provider that rejects thinking levels outright, which shows up as the naming warning plus a `400 Invalid request parameters` line in the log. Case and stray spaces are tolerated (`" Minimal "` works). Anything unrecognised is ignored in favour of the default and logged as `[archimedes] session-name: ignoring unrecognized reasoning <value>` — it is never sent to the provider, because what an unknown level *means* is provider-dependent: some read it as more thinking, some reject the request, and we'd rather not depend on which. |
+| `reasoning` | string \| null | `minimal` | Thinking level for the title request: `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `off`. Resolved to the nearest level the model supports (warns on change); the option is omitted only when that resolves to `"off"`. `off`/`null` therefore request no thinking but can still send a level on models that exclude it — use `"minimal"` for bounded-small everywhere. Case and stray spaces are tolerated (`" Minimal "` works). Anything unrecognised is ignored in favour of the default and logged. Only supported levels reach the provider: the setting resolves through pi's clamp to the nearest level the model supports. |
 
 `model` is also editable in the `/archimedes` panel (**Model for naming** — Enter to type, blank to go back to the current model); `reasoning` is JSON-only.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/session-name",
-  "version": "2.10.4",
+  "version": "2.11.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/danielcherubini/pi-archimedes.git"
@@ -18,7 +18,7 @@
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@pi-archimedes/core": "2.10.4"
+    "@pi-archimedes/core": "2.11.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.86.0",
@@ -26,9 +26,9 @@
     "@earendil-works/pi-tui": ">=0.86.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.87.0",
-    "@earendil-works/pi-coding-agent": "^0.87.0",
-    "@earendil-works/pi-tui": "^0.87.0",
+    "@earendil-works/pi-ai": "1.2.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
+    "@earendil-works/pi-tui": "1.2.0",
     "typescript": "^6.0.0"
   },
   "pi": {

package/src/index.test.ts

@@ -1,4 +1,5 @@
 import { loadConfig } from "@pi-archimedes/core/settings-io";
+import { diag } from "@pi-archimedes/core/log";
 import { describe, expect, it, vi } from "vitest";
 import { thinkingBudgetForLevel } from "@earendil-works/pi-ai/api/simple-options";
 import { generateTitle, registerSessionName, resolveTitleReasoning } from "./index.js";
@@ -39,7 +40,9 @@ function createMockCtx(options: {
     },
   ];
 
-  const defaultModel = { provider: "anthropic", id: "claude-3-5-sonnet" };
+  // Reasoning model without a level map: every named level passes clamp
+  // through, so existing assertions on forwarded levels keep holding.
+  const defaultModel = { provider: "anthropic", id: "claude-3-5-sonnet", reasoning: true };
 
   return {
     sessionManager: {
@@ -66,6 +69,16 @@ vi.mock("@pi-archimedes/core/settings-io", () => ({
   loadConfig: vi.fn((_namespace, defaults) => defaults),
 }));
 
+// Diagnostics never go to the console (see packages/core/src/log.ts): a write
+// there smears a fullscreen frame and is discarded inside a subagent child. So
+// every "it said something / it said nothing" assertion below watches `diag`.
+vi.mock("@pi-archimedes/core/log", async (importOriginal) => {
+  const real = await importOriginal<typeof import("@pi-archimedes/core/log")>();
+  return { ...real, diag: vi.fn() };
+});
+
+const clearDiag = () => vi.mocked(diag).mockClear();
+
 describe("generateTitle", () => {
   it("generates title, trims quotes and whitespace, and calls pi.setSessionName", async () => {
     const pi = createMockPi();
@@ -121,8 +134,10 @@ describe("generateTitle", () => {
   // anything. A non-level must never reach the provider — see the pin at the
   // end of this block for what that costs.
   describe("reasoning validation", () => {
-    it("passes every real thinking level through untouched", async () => {
-      for (const reasoning of ["minimal", "low", "medium", "high", "xhigh", "max"]) {
+    it("passes every supported thinking level through untouched", async () => {
+      // The mock model has no level map, like the real title model — so only
+      // minimal..high pass through; xhigh/max step down (covered below).
+      for (const reasoning of ["minimal", "low", "medium", "high"]) {
         vi.mocked(loadConfig).mockReturnValueOnce({ reasoning });
         const ctx = createMockCtx({});
         await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
@@ -132,54 +147,71 @@ describe("generateTitle", () => {
       }
     });
 
-    it.each(["Minimal", "  high  ", "MAX"])("tolerates casing and padding: %s", async (raw) => {
+    it.each([["xhigh", "high"], ["MAX", "high"]])("clamps %s to nearest supported %s, warning", async (raw, clamped) => {
       vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: raw });
       const ctx = createMockCtx({});
-      const log = vi.spyOn(console, "error").mockImplementation(() => {});
-      try {
-        await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
-        expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning).toBe(
-          raw.trim().toLowerCase(),
-        );
-        expect(log).not.toHaveBeenCalled();
-      } finally {
-        log.mockRestore();
-      }
+      clearDiag();
+      await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+      expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning).toBe(clamped);
+      expect(diag).toHaveBeenCalledWith(
+        "session-name",
+        expect.stringContaining(`using "${clamped}"`),
+      );
     });
 
-    it.each([["ultra"], ["off"], [""], [42], [true], [{}], [[]]])(
+    it.each(["Minimal", "  high  "])("tolerates casing and padding: %s", async (raw) => {
+      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: raw });
+      const ctx = createMockCtx({});
+      clearDiag();
+      await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+      expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning).toBe(
+        raw.trim().toLowerCase(),
+      );
+      expect(diag).not.toHaveBeenCalled();
+    });
+
+    it.each([["ultra"], [""], [42], [true], [{}], [[]]])(
       "never forwards a non-level: %s",
       async (raw) => {
         vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: raw });
         const ctx = createMockCtx({});
-        const log = vi.spyOn(console, "error").mockImplementation(() => {});
-        try {
-          await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
-
-          const sent = (ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning;
-          // Invalid config behaves like absent config: the documented default.
-          expect(sent).toBe("minimal");
-          expect(log).toHaveBeenCalledWith(
-            "[archimedes] session-name: ignoring unrecognized reasoning",
-            JSON.stringify(raw),
-          );
-        } finally {
-          log.mockRestore();
-        }
+        clearDiag();
+        await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+
+        const sent = (ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning;
+        // Invalid config behaves like absent config: the documented default.
+        expect(sent).toBe("minimal");
+        // The typo is invisible unless it is reported, and the report is the
+        // single log line naming the rejected value.
+        expect(diag).toHaveBeenCalledWith(
+          "session-name",
+          `[archimedes] session-name: ignoring unrecognized reasoning ${JSON.stringify(raw)}`,
+        );
       },
     );
 
-    it("sends no reasoning key when the value is null, and says nothing", async () => {
-      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: null });
+    it.each([["off"], [null]])("omits the key for %s on models that take it", async (reasoning) => {
+      // Default mock has no level map, so "off" is supported and omitted silently.
+      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning });
       const ctx = createMockCtx({});
-      const log = vi.spyOn(console, "error").mockImplementation(() => {});
-      try {
-        await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
-        expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2]).not.toHaveProperty("reasoning");
-        expect(log).not.toHaveBeenCalled();
-      } finally {
-        log.mockRestore();
-      }
+      clearDiag();
+      await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+      expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2]).not.toHaveProperty("reasoning");
+      expect(diag).not.toHaveBeenCalled();
+    });
+
+    it("clamps off to minimal with a warning where the model excludes it", async () => {
+      // Muse-spark shape: thinking model whose map excludes "off" (null).
+      const model = { provider: "op", id: "spark", reasoning: true, thinkingLevelMap: { off: null } };
+      vi.mocked(loadConfig).mockReturnValueOnce({ reasoning: "off" });
+      const ctx = createMockCtx({ model });
+      clearDiag();
+      await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+      expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning).toBe("minimal");
+      expect(diag).toHaveBeenCalledWith(
+        "session-name",
+        expect.stringContaining('using "minimal"'),
+      );
     });
 
     it("keeps the default when the setting is absent entirely, and says nothing", async () => {
@@ -187,26 +219,25 @@ describe("generateTitle", () => {
       // "minimal" — the common path must stay silent. A regression that warned
       // on every default-configured session would otherwise pass the suite.
       const ctx = createMockCtx({});
-      const log = vi.spyOn(console, "error").mockImplementation(() => {});
-      try {
-        await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
-        expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning).toBe("minimal");
-        expect(log).not.toHaveBeenCalled();
-      } finally {
-        log.mockRestore();
-      }
+      clearDiag();
+      await generateTitle(createMockPi() as any, ctx as any, vi.fn(), vi.fn());
+      expect((ctx.modelRegistry.streamSimple as any).mock.calls[0][2].reasoning).toBe("minimal");
+      expect(diag).not.toHaveBeenCalled();
     });
 
     it("treats undefined like absent config, without warning", () => {
       // Direct call: the generateTitle path can't produce this, since
       // loadConfig fills the default in, but the helper is exported.
-      const log = vi.spyOn(console, "error").mockImplementation(() => {});
-      try {
-        expect(resolveTitleReasoning(undefined)).toBe("minimal");
-        expect(log).not.toHaveBeenCalled();
-      } finally {
-        log.mockRestore();
-      }
+      clearDiag();
+      expect(resolveTitleReasoning(undefined)).toBe("minimal");
+      expect(diag).not.toHaveBeenCalled();
+    });
+
+    it("accepts off for the call site to clamp per model", () => {
+      clearDiag();
+      expect(resolveTitleReasoning("off")).toBe("off");
+      expect(resolveTitleReasoning(" Off ")).toBe("off");
+      expect(diag).not.toHaveBeenCalled();
     });
 
     // Pin the invariant against the arithmetic that makes this dangerous. Of
@@ -228,15 +259,18 @@ describe("generateTitle", () => {
       for (const level of levels) {
         expect(thinkingBudgetForLevel(level)).toBeTypeOf("number");
       }
-      const junk: unknown[] = ["ultra", "MINIMAL", "off", "", "Max ", 42, true, {}, []];
+      const junk: unknown[] = ["ultra", "MINIMAL", "", "Max ", 42, true, {}, []];
       for (const value of junk) {
         expect(thinkingBudgetForLevel(value as never)).toBeUndefined();
       }
 
-      // Whatever the setting holds, the value we forward is always safe to send.
+      // Whatever the setting holds, the value reaching clamp is a real level
+      // or "off" — never raw input. "off" is resolved per model at the call
+      // site (nearest supported, warn on change), never forwarded verbatim.
       for (const raw of [...levels, ...junk, null, undefined]) {
         const resolved = resolveTitleReasoning(raw);
         if (resolved === null) continue; // omitted → no level requested
+        if (resolved === "off") continue; // clamped per model at the call site
         expect(levels).toContain(resolved);
         expect(thinkingBudgetForLevel(resolved)).toBeTypeOf("number");
       }
@@ -270,16 +304,16 @@ describe("generateTitle", () => {
     pi.getSessionName.mockImplementation(() => { throw new Error(message); });
     const onSuccess = vi.fn();
     const onFailure = vi.fn();
-    const log = vi.spyOn(console, "error").mockImplementation(() => {});
-    try {
-      await generateTitle(pi as any, createMockCtx({}) as any, onSuccess, onFailure);
-      expect(onFailure).toHaveBeenCalledTimes(failures);
-      expect(log).toHaveBeenCalledTimes(failures);
-      expect(onSuccess).not.toHaveBeenCalled();
-      expect(pi.setSessionName).not.toHaveBeenCalled();
-    } finally {
-      log.mockRestore();
+    clearDiag();
+    await generateTitle(pi as any, createMockCtx({}) as any, onSuccess, onFailure);
+    expect(onFailure).toHaveBeenCalledTimes(failures);
+    // A swallowed failure is only acceptable if it left a trace.
+    expect(diag).toHaveBeenCalledTimes(failures);
+    if (failures === 1) {
+      expect(diag).toHaveBeenCalledWith("session-name", expect.stringContaining(message));
     }
+    expect(onSuccess).not.toHaveBeenCalled();
+    expect(pi.setSessionName).not.toHaveBeenCalled();
   });
 
   it("does not call onFailure when streamSimple returns stopReason === 'aborted'", async () => {
@@ -356,29 +390,28 @@ describe("registerSessionName", () => {
     const error = { stopReason: "error", content: [], errorMessage: "400 boom" };
     const notify = vi.fn();
     const ctx = { ...createMockCtx({ streamSimpleResult: error }), hasUI: scenario !== "no UI", ui: { notify } };
-    const log = vi.spyOn(console, "error").mockImplementation(() => {});
-    try {
-      await agentEnd({}, ctx);
-      await agentEnd({}, ctx);
-      let finish!: (response: any) => void;
-      const pending = new Promise((resolve) => { finish = resolve; });
-      ctx.modelRegistry.streamSimple.mockReturnValueOnce({ result: vi.fn(() => pending) });
-      await agentEnd({}, ctx);
-      // Change the session/UI while the third request is still pending.
-      if (scenario === "named") pi.setSessionName("Manual name");
-      if (scenario === "stale") pi.getSessionName.mockImplementation(() => { throw new Error("stale context"); });
-      if (scenario === "stale UI") Object.defineProperty(ctx, "hasUI", { get: () => { throw new Error("stale UI"); } });
-      if (scenario === "broken UI") notify.mockImplementation(() => { throw new Error("UI failed"); });
-      finish(error);
-      await pending;
-      await agentEnd({}, ctx);
-      expect(ctx.modelRegistry.streamSimple).toHaveBeenCalledTimes(3);
-      expect(log).toHaveBeenCalledTimes(3);
-      expect(log).toHaveBeenCalledWith("[archimedes] session-name failed:", "400 boom");
-      expect(notify).toHaveBeenCalledTimes(scenario === "UI" || scenario === "broken UI" ? 1 : 0);
-      if (scenario === "UI") expect(notify).toHaveBeenCalledWith(expect.stringContaining("/name"), "warning");
-    } finally {
-      log.mockRestore();
-    }
+    clearDiag();
+    await agentEnd({}, ctx);
+    await agentEnd({}, ctx);
+    let finish!: (response: any) => void;
+    const pending = new Promise((resolve) => { finish = resolve; });
+    ctx.modelRegistry.streamSimple.mockReturnValueOnce({ result: vi.fn(() => pending) });
+    await agentEnd({}, ctx);
+    // Change the session/UI while the third request is still pending.
+    if (scenario === "named") pi.setSessionName("Manual name");
+    if (scenario === "stale") pi.getSessionName.mockImplementation(() => { throw new Error("stale context"); });
+    if (scenario === "stale UI") Object.defineProperty(ctx, "hasUI", { get: () => { throw new Error("stale UI"); } });
+    if (scenario === "broken UI") notify.mockImplementation(() => { throw new Error("UI failed"); });
+    finish(error);
+    await pending;
+    await agentEnd({}, ctx);
+    expect(ctx.modelRegistry.streamSimple).toHaveBeenCalledTimes(3);
+    // Every attempt is diagnosable…
+    expect(diag).toHaveBeenCalledTimes(3);
+    expect(diag).toHaveBeenCalledWith("session-name", "[archimedes] session-name failed: 400 boom");
+    // …but the user is told once, at the retry-budget boundary: three lines of
+    // console noise (or three notifications) is not a report, it is spam.
+    expect(notify).toHaveBeenCalledTimes(scenario === "UI" || scenario === "broken UI" ? 1 : 0);
+    if (scenario === "UI") expect(notify).toHaveBeenCalledWith(expect.stringContaining("/name"), "warning");
   });
 });

package/src/index.ts

@@ -1,6 +1,8 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { ThinkingLevel } from "@earendil-works/pi-ai";
+import { clampThinkingLevel } from "@earendil-works/pi-ai";
+import type { ModelThinkingLevel, ThinkingLevel } from "@earendil-works/pi-ai";
 import { loadConfig } from "@pi-archimedes/core/settings-io";
+import { diag, describeError } from "@pi-archimedes/core/log";
 import type { SettingItem } from "@earendil-works/pi-tui";
 
 // ── Config ──────────────────────────────────────────────────────────────────
@@ -9,7 +11,7 @@ export interface SessionNameSettings {
   // suite-managed by meta's plugin gate (archimedes.sessionName.enabled — see ADR 0012); session-name never reads this
   enabled?: boolean | undefined;
   model?: string | undefined;
-  reasoning?: ThinkingLevel | null | undefined;
+  reasoning?: ThinkingLevel | "off" | null | undefined;
 }
 
 const DEFAULT_SESSION_NAME_CONFIG: SessionNameSettings = {
@@ -19,14 +21,16 @@ const DEFAULT_SESSION_NAME_CONFIG: SessionNameSettings = {
 
 const NAMESPACE = "archimedes.sessionName";
 
-/** The thinking levels we accept — pi-ai's set, minus `off` (see below). */
-const REASONING_LEVELS: readonly ThinkingLevel[] = [
+/** The thinking levels we accept — pi-ai's set, plus `off` (resolved per
+ * model at the call site: omitting is the only portable spelling of none). */
+const REASONING_LEVELS: readonly (ThinkingLevel | "off")[] = [
   "minimal",
   "low",
   "medium",
   "high",
   "xhigh",
   "max",
+  "off",
 ];
 
 /**
@@ -45,14 +49,15 @@ const REASONING_LEVELS: readonly ThinkingLevel[] = [
  * budget-based Claude it instead misses the four-key budget table, and the
  * resulting `undefined` reaches the provider as an invalid `max_tokens`.
  *
- * Outcomes: a real level (casing/padding tolerated) is forwarded; `null` means
- * omit the option entirely; anything else — including absent — is treated like
- * an absent setting and gets the default, with a log line so the user can find
- * the typo. `"off"` is deliberately not accepted: it would be a fourth
- * spelling of "unset" next to `null` and an absent key, and pi accepts `off` as
- * no-effort anyway wherever it maps one.
+ * Outcomes: a real level (casing/padding tolerated) is returned for the call
+ * site to resolve per model; `null` means omit the option entirely; anything
+ * else — including absent — is treated like an absent setting and gets the
+ * default, with a log line so the user can find the typo. `"off"` is
+ * accepted but never forwarded raw: it resolves through pi's
+ * `clampThinkingLevel` like every other level (nearest supported, warn on
+ * change), because unclamped providers map unknown levels to maximum effort.
  */
-export function resolveTitleReasoning(raw: unknown): ThinkingLevel | null {
+export function resolveTitleReasoning(raw: unknown): ThinkingLevel | "off" | null {
   if (raw === null) return null;
   if (typeof raw === "string") {
     const value = raw.trim().toLowerCase();
@@ -60,10 +65,10 @@ export function resolveTitleReasoning(raw: unknown): ThinkingLevel | null {
     if (match) return match;
   }
   if (raw !== undefined) {
-    console.error(
-      "[archimedes] session-name: ignoring unrecognized reasoning",
-      JSON.stringify(raw),
-    );
+    // A typo in a hand-edited settings.json is invisible unless reported, but
+    // the report is for whoever debugs the config — the log file, not the
+    // console (which smears a fullscreen frame and is discarded in a child).
+    diag("session-name", `[archimedes] session-name: ignoring unrecognized reasoning ${JSON.stringify(raw)}`);
   }
   return DEFAULT_SESSION_NAME_CONFIG.reasoning ?? null;
 }
@@ -205,8 +210,17 @@ export async function generateTitle(
     if (!ctx.modelRegistry.hasConfiguredAuth(model)) return;
 
     // 5. Stream simple with built-in auth resolution.
-    // Reasoning is resolved, not forwarded raw: see resolveTitleReasoning().
-    const reasoning = resolveTitleReasoning(settings.reasoning);
+    // Reasoning is resolved per model, not forwarded raw: see
+    // resolveTitleReasoning(). `clampThinkingLevel` maps to the nearest level
+    // the model supports (warn on change); only an `off` result omits the
+    // option, which is the single portable spelling of none.
+    const resolved = resolveTitleReasoning(settings.reasoning);
+    const requested: ModelThinkingLevel = resolved === null ? "off" : (resolved ?? "minimal");
+    const clamped = clampThinkingLevel(model, requested);
+    if (clamped !== requested) {
+      diag("session-name", `[archimedes] session-name: reasoning "${requested}" is not supported — using "${clamped}"`);
+    }
+    const reasoning = clamped === "off" ? undefined : clamped;
     const stream = ctx.modelRegistry.streamSimple(
       model,
       {
@@ -219,7 +233,7 @@ export async function generateTitle(
         ],
       },
       {
-        ...(reasoning !== null ? { reasoning } : {}),
+        ...(reasoning !== undefined ? { reasoning } : {}),
         cacheRetention: "none",
         sessionId: crypto.randomUUID(),
       },
@@ -231,7 +245,9 @@ export async function generateTitle(
       return;
     }
     if (response.stopReason === "error") {
-      console.error("[archimedes] session-name failed:", response.errorMessage ?? "title request failed");
+      // The user's notice is the single one at the retry-budget boundary (see
+      // registerSessionName); one line per attempt goes to the log.
+      diag("session-name", `[archimedes] session-name failed: ${response.errorMessage ?? "title request failed"}`);
       onFailure();
       return;
     }
@@ -260,7 +276,7 @@ export async function generateTitle(
   } catch (e) {
     // Session replacement or print-mode teardown makes an in-flight title irrelevant.
     if (e instanceof Error && e.message.includes("stale after session replacement")) return;
-    console.error("[archimedes] session-name failed:", e);
+    diag("session-name", `[archimedes] session-name failed: ${describeError(e)}`);
     onFailure();
   }
 }