bermudis-pi-goodies 0.5.3 → 0.5.4

package/README.md

@@ -1,104 +1,64 @@
 # bermudis-pi-goodies
 
 A bundle of small, frequently-used [Pi](https://github.com/earendil-works/pi)
-extensions. One entry point, ten independent features.
-
-| Feature | Command / hook | What it does |
-|---------|----------------|--------------|
-| `copy-with-model` | `/copy-with-model` | Copy last assistant message to the clipboard in a code fence tagged with the model name. |
-| `copy-trajectory` | `/copy-trajectory [thinking]` | Copy the whole conversation (user + assistant text, tool calls stripped) to the clipboard; `thinking` also includes assistant thinking blocks. |
-| `name-with-ai` | `/name-with-ai [name]` | Generate a short session name from the first user message (or set one manually). |
-| `zed` | `/z` | Open Zed editor on the current working directory. |
-| `prefer-tools` | hook (no command) | Nudge toward modern CLIs: `rg` over `grep`, `fd` over `find`, `uv` over bare `python`/`pip`/`pytest`/`mypy`. |
-| `model-thinking` | hook + `/model-thinking` | Apply provider/model thinking defaults and explicitly save per-model defaults. |
-| `fixed-defaults` | hook + `/fixed-defaults` | Keep the global startup provider and model fixed while allowing in-session model changes; `/fixed-defaults set` pins the current model. |
-| `kilo` | provider | Access Kilo Gateway models via `/login kilo` or `KILO_API_KEY`. |
-| `provider-balance` | footer (no command) | Show remaining Kilo or OpenRouter credits, z.ai token-plan quota, or OpenAI Codex quota on the right side of the working-directory footer line. |
-| `tps` | hook (no command) | Notify tokens/sec and in/out/cache token usage at the end of each agent turn. |
+extensions. One entry point, nine independent features.
+
+| Feature            | Command / hook                | What it does                                                                                                                                    |
+| ------------------ | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `copy-with-model`  | `/copy-with-model`            | Copy last assistant message to the clipboard in a code fence tagged with the model name.                                                        |
+| `copy-trajectory`  | `/copy-trajectory [thinking]` | Copy the whole conversation (user + assistant text, tool calls stripped) to the clipboard; `thinking` also includes assistant thinking blocks.  |
+| `name-with-ai`     | `/name-with-ai [name]`        | Generate a short session name from the first user message (or set one manually).                                                                |
+| `zed`              | `/z`                          | Open Zed editor on the current working directory.                                                                                               |
+| `prefer-tools`     | hook (no command)             | Nudge toward modern CLIs: `rg` over `grep`, `fd` over `find`, `uv` over bare `python`/`pip`/`pytest`/`mypy`.                                    |
+| `model-thinking`   | hook (no command)             | Apply native scoped-model thinking levels consistently when selecting a model through the full picker.                                          |
+| `kilo`             | provider                      | Access Kilo Gateway models via `/login kilo` or `KILO_API_KEY`.                                                                                 |
+| `provider-balance` | footer (no command)           | Show remaining Kilo or OpenRouter credits, z.ai token-plan quota, or OpenAI Codex quota on the right side of the working-directory footer line. |
+| `tps`              | hook (no command)             | Notify tokens/sec and in/out/cache token usage at the end of each agent turn.                                                                   |
 
 ## Install
 
 After publishing the package to npm:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.5.3
+pi install npm:bermudis-pi-goodies@0.5.4
 ```
 
 Remove any old `bermudis-pi-goodies.ts` symlink before reloading Pi. Each
 feature is independent — disabling one is a one-line edit in `index.ts`.
 Kilo's provider and its balance footer are bundled here.
 
-## Model-specific thinking
-
-This feature is deliberately opt-in: models not covered by the config retain
-Pi's native thinking-level behavior. Create `~/.pi/agent/model-thinking.json`
-with provider defaults, exact model defaults, or both:
-
-```json
-{
-  "providers": {
-    "anthropic": "high",
-    "openai-codex": "xhigh"
-  },
-  "models": {
-    "anthropic/claude-haiku-4-5": "low"
-  }
-}
-```
-
-Exact `provider/model-id` entries take precedence over provider defaults. Use
-`/model-thinking set` to explicitly save the current model's current thinking
-level as an exact-model entry; it also bootstraps models not yet covered by the
-config and overwrites an existing entry. Manual thinking-level changes in Pi do
-not modify this file. All current Pi levels are accepted:
-`off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`.
-`/model-thinking` shows the active resolution and config path;
-`/model-thinking reset` deletes the whole config. A malformed config is reported
-and ignored; `/model-thinking set` refuses to overwrite it until you repair the
-file or reset it.
-
-## Fixed startup model
+## Model selection and thinking
 
-Pi normally saves the last model and thinking level selected in the global
-settings file. `fixed-defaults` pins only the cross-session provider and model;
-`model-thinking` is the sole owner of model-specific thinking levels.
-
-Create `~/.pi/agent/fixed-defaults.json` to pin a startup model:
+Pi's native model settings are the single source of truth. Add models to
+`enabledModels` in `~/.pi/agent/settings.json` in cycle order. Add an optional
+thinking level after a colon:
 
 ```json
 {
-  "provider": "openai-codex",
-  "model": "gpt-5.6-luna"
+  "enabledModels": [
+    "opencode/hy3-free:high",
+    "zai/glm-5.2:high",
+    "openai-codex/gpt-5.6-terra:medium"
+  ]
 }
 ```
 
-Selecting a different model still changes the active session and its transcript;
-`fixed-defaults` restores the startup model after Pi persists a selection. Pi
-chooses the initial model before extensions receive `session_start`, so if you
-manually create or edit a pin for B while settings still name A, the current
-session remains on A and B starts with the next fresh session. Resuming an
-existing session restores that session's model instead.
-
-`/new` keeps the model and thinking level from the session you were just in,
-rather than switching to the pinned default and the settings thinking level.
-The level is re-applied after any per-model thinking policy, so a `/new`
-carries over a manual override. The pin still applies to a fresh `pi` launch.
-
-Older config files may contain `thinkingLevel`; that field is accepted for
-compatibility but ignored and should be managed in `model-thinking.json` instead.
-`fixed-defaults` logs a warning and shows the migration in its status when it
-finds the legacy field. The `/fixed-defaults set` command rewrites the file in
-the provider/model-only format.
-
-Manage the pin from Pi:
-
-- `/fixed-defaults set` — pin the currently active model as the startup model
-  (written to the override file and applied to `settings.json` immediately).
-- `/fixed-defaults` — show the active model, pinned startup model, and override
-  path.
-- `/fixed-defaults reset` — save the currently active model as Pi's last
-  selection, then delete the override file and stop pinning. With no active
-  model, it refuses to remove the pin.
+Pi applies those levels while cycling with Ctrl+P and Ctrl+Shift+P. This
+package fills the small consistency gaps: choosing a scoped model through the
+full model picker and starting with a plain explicit `--model` apply its
+configured level. Explicit `--thinking` and `--model ...:<level>` still win
+(unless the `:<level>` ending is the model's registered id, in which case the
+scoped level applies).
+One gap is inherent to Pi: it emits no selection event when you pick the
+model that is already active, so re-selecting it in the full picker leaves a
+manual thinking level in place — switch models (or cycle) to snap back.
+Resumed and forked sessions retain the level restored by Pi; `/new` carries the
+previous session's model and active thinking level into the new session.
+
+Use `/scoped-models` to search, enable, disable, and reorder the cycle list.
+Be aware that pi 0.84.2 currently writes bare model IDs when that screen is
+saved, so saving there removes any `:level` suffixes; restore them in
+`settings.json` afterward.
 
 ## Provider and balance details
 

package/index.ts

@@ -8,8 +8,7 @@
  *   - name-with-ai     /name-with-ai     generate a session name via the model
  *   - zed              /z                open Zed on cwd
  *   - prefer-tools     hook              block legacy tools (use trash/rg/fd/uv)
- *   - model-thinking   hook + command    remember thinking levels by provider/model
- *   - fixed-defaults   hook + command    keep startup provider/model stable; /fixed-defaults set pins the current model
+ *   - model-thinking   hook              apply native scoped-model thinking levels consistently
  *   - kilo             provider          access Kilo Gateway models
  *   - provider-balance footer            show Kilo credits or Codex quota in the footer
  *   - tps              hook              notify tokens/sec and usage at each agent turn end
@@ -17,7 +16,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import copyTrajectory from "./copy-trajectory.ts";
 import copyWithModel from "./copy-with-model.ts";
-import fixedDefaults from "./fixed-defaults.ts";
 import kilo from "./kilo.ts";
 import modelThinking from "./model-thinking.ts";
 import providerBalance from "./provider-balance.ts";
@@ -33,7 +31,6 @@ export default function bermudisPiGoodies(pi: ExtensionAPI): void {
   zed(pi);
   preferTools(pi);
   modelThinking(pi);
-  fixedDefaults(pi);
   providerBalance(pi);
   kilo(pi);
   tps(pi);

package/model-thinking.ts

@@ -1,18 +1,13 @@
-import {
-  getAgentDir,
-  type ExtensionAPI,
-  type ExtensionContext,
+import type {
+  ExtensionAPI,
+  ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import {
-  describeError,
-  unlinkIfPresent,
-  writeJsonFileAtomic,
-} from "./json-file.ts";
 
-const CONFIG_FILENAME = "model-thinking.json";
-const ALL_LEVELS = [
+type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
+type Model = NonNullable<ExtensionContext["model"]>;
+type ModelRef = Pick<Model, "provider" | "id">;
+
+const THINKING_LEVELS = new Set([
   "off",
   "minimal",
   "low",
@@ -20,304 +15,246 @@ const ALL_LEVELS = [
   "high",
   "xhigh",
   "max",
-] as const;
-
-type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
-
-interface ModelThinkingConfig {
-  models?: Record<string, ThinkingLevel>;
-  providers?: Record<string, ThinkingLevel>;
-}
+]);
 
-interface ModelRef {
+interface PreviousSessionState {
   provider: string;
   id: string;
+  thinkingLevel: ThinkingLevel;
 }
 
-interface ModelThinkingOptions {
-  /** Internal seam used by tests; normal callers use Pi's global agent dir. */
-  configPath?: string;
-}
+// The extension factory is recreated when Pi replaces a session. Keep this
+// snapshot at module scope so it survives that recreation.
+let previousSessionState: PreviousSessionState | null = null;
 
-function isThinkingLevel(value: unknown): value is ThinkingLevel {
-  return (
-    typeof value === "string" &&
-    (ALL_LEVELS as readonly string[]).includes(value)
-  );
+function sameModel(left: ModelRef, right: ModelRef): boolean {
+  return left.provider === right.provider && left.id === right.id;
 }
 
-function normalizeRecord(
-  value: unknown,
-  field: "models" | "providers",
-): Record<string, ThinkingLevel> | undefined {
-  if (value === undefined) return undefined;
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`\`${field}\` must be an object`);
+/**
+ * Pi resolves scoped thinking for its normal initial-model path, but an
+ * explicit plain `--model` takes a different path and falls back to the
+ * global level. There is no CLI-selection detail on session_start, so use
+ * argv only to distinguish that one case from Pi's already-resolved startup
+ * state. Explicit `--thinking` and `--model ...:<level>` remain authoritative.
+ *
+ * Mirrors Pi's parseArgs semantics for these two flags: the last --model
+ * wins, --thinking counts only when its value is a valid level (invalid
+ * values are dropped with a CLI warning), and a trailing flag without a
+ * value token sets nothing. Degenerate argv where another flag consumes a
+ * bare "--model"/"--thinking" as its value is not mirrored.
+ *
+ * Do not trust the presence of --model alone: an invalid CLI model leaves a
+ * restored session's model active. Before touching thinking, confirm that the
+ * active model could be Pi's resolution of the CLI pattern. This also mirrors
+ * Pi's important ordering for a trailing ":<level>": it fuzzy-matches the
+ * complete pattern before splitting a thinking suffix.
+ */
+function cliPatternMatchesActiveModel(
+  pattern: string,
+  provider: string | undefined,
+  activeModel: Model,
+): boolean {
+  const normalizedPattern = pattern.trim().toLowerCase();
+  if (!normalizedPattern) return false;
+
+  const normalizedProvider = provider?.trim().toLowerCase();
+  if (
+    normalizedProvider !== undefined &&
+    activeModel.provider.toLowerCase() !== normalizedProvider
+  ) {
+    return false;
   }
 
-  const result: Record<string, ThinkingLevel> = {};
-  for (const [key, level] of Object.entries(value)) {
-    if (!isThinkingLevel(level)) {
-      throw new Error(
-        `\`${field}.${key}\` must be one of: ${ALL_LEVELS.join(", ")}`,
-      );
-    }
-    result[key] = level;
+  let modelPattern = normalizedPattern;
+  const activeProviderPrefix = `${activeModel.provider}/`.toLowerCase();
+  if (modelPattern.startsWith(activeProviderPrefix)) {
+    modelPattern = modelPattern.slice(activeProviderPrefix.length);
+  } else if (
+    normalizedProvider === undefined &&
+    normalizedPattern.includes("/")
+  ) {
+    // Without the registry we cannot safely reinterpret an arbitrary slash as
+    // a provider separator: model IDs themselves may contain slashes.
+    return (
+      normalizedPattern ===
+      `${activeModel.provider}/${activeModel.id}`.toLowerCase()
+    );
   }
-  return Object.keys(result).length > 0 ? result : undefined;
+
+  const id = activeModel.id.toLowerCase();
+  const name = activeModel.name?.toLowerCase();
+  return (
+    modelPattern === id ||
+    id.includes(modelPattern) ||
+    name?.includes(modelPattern) === true
+  );
 }
 
-function parseConfig(value: unknown): ModelThinkingConfig {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("the top level must be an object");
+function plainCliModelNeedsScopedLevel(
+  activeModel: Model | undefined,
+): boolean {
+  const args = process.argv.slice(2);
+  let model: string | undefined;
+  let provider: string | undefined;
+  let thinking: string | undefined;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--model" && index + 1 < args.length) {
+      model = args[++index];
+    } else if (arg === "--provider" && index + 1 < args.length) {
+      provider = args[++index];
+    } else if (arg === "--thinking" && index + 1 < args.length) {
+      const level = args[++index];
+      if (THINKING_LEVELS.has(level)) thinking = level;
+    }
   }
+  if (thinking !== undefined) return false;
+  if (model === undefined || activeModel === undefined) return false;
 
-  const input = value as Record<string, unknown>;
-  const unknownKeys = Object.keys(input).filter(
-    (key) => key !== "models" && key !== "providers",
-  );
-  if (unknownKeys.length > 0) {
-    throw new Error(`unknown field(s): ${unknownKeys.join(", ")}`);
-  }
+  // Pi first attempts the complete pattern. This confirms both that --model
+  // actually selected the active model (rather than falling back to a
+  // restored session) and that a ":<level>" suffix belongs to its ID.
+  if (cliPatternMatchesActiveModel(model, provider, activeModel)) return true;
 
-  return {
-    models: normalizeRecord(input.models, "models"),
-    providers: normalizeRecord(input.providers, "providers"),
-  };
+  // Either the CLI model did not resolve, or Pi split a trailing valid
+  // ":<level>" and applied explicit thinking. Both cases must be left alone.
+  return false;
 }
 
-function fileStamp(path: string): string | undefined {
-  try {
-    const stat = statSync(path);
-    return `${stat.mtimeMs}:${stat.size}`;
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code;
-    if (code === "ENOENT") return undefined;
-    throw error;
-  }
-}
+/**
+ * Pi's scoped-models configuration is the source of truth for both the cycle
+ * list and per-model thinking levels. The native cycle path already applies
+ * those levels; this hook fills the two gaps in the native behavior:
+ *
+ * - selecting a model through the full picker should apply its scoped level;
+ *
+ * Pi emits model_select only when the model actually changes, so picking the
+ * already-active model in the full picker fires no event and its scoped
+ * level cannot be re-applied on that path; a manual level survives until a
+ * different model is selected.
+ *
+ * Pi applies the scoped level during normal startup selection. A plain
+ * explicit `--model` is the exception; the startup hook covers that case
+ * without overriding explicit CLI thinking choices.
+ *
+ * Resume and fork retain the model and level restored by Pi. /new is not a
+ * session restore in Pi: it starts from the saved default/scoped model, so we
+ * capture and restore the previous session explicitly.
+ */
+export default function modelThinking(pi: ExtensionAPI): void {
+  let restoringPreviousSession = false;
 
-interface ConfigLoadResult {
-  config: ModelThinkingConfig;
-  /** Non-null when the file exists but could not be read or validated. */
-  error: string | null;
-}
+  function applyScopedLevel(ctx: ExtensionContext, silent: boolean): void {
+    const model = ctx.model;
+    if (!model) return;
 
-class ConfigStore {
-  readonly path: string;
-  private initialized = false;
-  private cachedStamp: string | undefined;
-  private cachedResult: ConfigLoadResult = { config: {}, error: null };
+    const scoped = ctx.scopedModels.find((entry) =>
+      sameModel(entry.model, model),
+    );
+    const level = scoped?.thinkingLevel as ThinkingLevel | undefined;
+    if (level === undefined) return;
 
-  constructor(path: string) {
-    this.path = path;
-  }
+    const before = pi.getThinkingLevel();
+    pi.setThinkingLevel(level);
+    const after = pi.getThinkingLevel();
 
-  load(): ConfigLoadResult {
-    let stamp: string | undefined;
-    try {
-      stamp = fileStamp(this.path);
-    } catch (error) {
-      const message = describeError(error);
-      console.error(`[model-thinking] failed to stat ${this.path}:`, message);
-      return { config: {}, error: message };
+    if (after !== before && !silent) {
+      ctx.ui.notify(`Thinking: ${before} → ${after}`, "info");
     }
+  }
 
-    // Keep retrying a file that previously failed to load. A repair can leave
-    // its size and mtime unchanged, so an error result must not be cached by
-    // the same stamp as a successful read.
-    if (
-      this.initialized &&
-      stamp === this.cachedStamp &&
-      this.cachedResult.error === null
-    ) {
-      return this.cachedResult;
+  async function restorePreviousSession(
+    ctx: ExtensionContext,
+    previous: PreviousSessionState,
+  ): Promise<void> {
+    // Custom models supplied via --model may be synthesized for the current
+    // session and therefore not be present in the registry. If /new already
+    // selected that same model, the model itself is successfully restored;
+    // only the historical thinking level still needs to be applied.
+    if (ctx.model && sameModel(ctx.model, previous)) {
+      pi.setThinkingLevel(previous.thinkingLevel);
+      return;
     }
 
-    this.initialized = true;
-    this.cachedStamp = stamp;
-    if (stamp === undefined) {
-      this.cachedResult = { config: {}, error: null };
-      return this.cachedResult;
+    const model = ctx.modelRegistry.find(previous.provider, previous.id);
+    if (!model) {
+      console.error(
+        `[model-thinking] could not restore ${previous.provider}/${previous.id} after /new: model is unavailable`,
+      );
+      return;
     }
 
+    let applied = false;
     try {
-      this.cachedResult = {
-        config: parseConfig(
-          JSON.parse(readFileSync(this.path, "utf8")) as unknown,
-        ),
-        error: null,
-      };
+      restoringPreviousSession = true;
+      applied = await pi.setModel(model);
+      if (!applied) {
+        console.error(
+          `[model-thinking] could not restore ${previous.provider}/${previous.id} after /new: provider authentication is unavailable`,
+        );
+        return;
+      }
     } catch (error) {
-      const message = describeError(error);
       console.error(
-        `[model-thinking] invalid config at ${this.path}:`,
-        message,
+        `[model-thinking] failed to restore ${previous.provider}/${previous.id} after /new:`,
+        error,
       );
-      this.cachedResult = { config: {}, error: message };
+    } finally {
+      restoringPreviousSession = false;
     }
-    return this.cachedResult;
-  }
 
-  save(config: ModelThinkingConfig): void {
-    writeJsonFileAtomic(this.path, config);
-    this.cachedResult = { config, error: null };
-    this.cachedStamp = fileStamp(this.path);
-    this.initialized = true;
-  }
-
-  reset(): boolean {
-    const removed = unlinkIfPresent(this.path);
-    this.initialized = true;
-    this.cachedStamp = undefined;
-    this.cachedResult = { config: {}, error: null };
-    return removed;
-  }
-}
-
-function modelKey(model: ModelRef): string {
-  return `${model.provider}/${model.id}`;
-}
-
-function resolveThinkingLevel(
-  config: ModelThinkingConfig,
-  model: ModelRef | undefined,
-): ThinkingLevel | undefined {
-  if (!model) return undefined;
-  return config.models?.[modelKey(model)] ?? config.providers?.[model.provider];
-}
-
-/**
- * Opt-in per-model thinking policy. A provider or exact model must first be
- * present in model-thinking.json; unmanaged models retain Pi's native behavior.
- */
-export default function modelThinking(
-  pi: ExtensionAPI,
-  options: ModelThinkingOptions = {},
-): void {
-  const store = new ConfigStore(
-    options.configPath ?? join(getAgentDir(), CONFIG_FILENAME),
-  );
-  function apply(ctx: ExtensionContext, silent: boolean): void {
-    const model = ctx.model;
-    const loaded = store.load();
-    // Never treat a broken file as an empty policy: doing so would hide the
-    // error and make a later `/model-thinking set` overwrite it.
-    if (loaded.error || !model) return;
-
-    const level = resolveThinkingLevel(loaded.config, model);
-    if (level === undefined) return;
-
-    const before = pi.getThinkingLevel();
-    pi.setThinkingLevel(level);
-    const after = pi.getThinkingLevel();
-
-    if (after !== before && !silent) {
-      ctx.ui.notify(`Thinking: ${before} → ${after}`, "info");
+    if (applied) {
+      // setModel emits model_select, where the scoped policy may apply. The
+      // captured session level must have the final word for /new.
+      pi.setThinkingLevel(previous.thinkingLevel);
     }
   }
 
   pi.on("model_select", (event, ctx) => {
-    // When Pi restores a model from session history (e.g. resume/fork), keep
-    // the thinking level that was active in that session instead of
-    // overwriting it with the per-model default.
+    // A restored session owns its historical thinking level.
     if (event.source === "restore") return;
-    apply(ctx, false);
+    // Pi suppresses this event when the selected model equals the active
+    // one (see _emitModelSelect), which is why re-selecting the current
+    // model in the full picker does not re-apply its scoped level.
+    applyScopedLevel(ctx, restoringPreviousSession);
   });
 
   pi.on("session_start", (event, ctx) => {
-    if (!ctx.model) return;
-    // Resumed or forked sessions already carry their last thinking level
-    // (restored by Pi from the session's branch). Don't clobber it with
-    // the per-model default; the default only applies to fresh sessions.
-    if (event.reason === "resume" || event.reason === "fork") return;
-    apply(ctx, true);
-  });
-
-  pi.registerCommand("model-thinking", {
-    description: "Show, save, or reset model-specific thinking levels",
-    handler: async (args, ctx) => {
-      const command = args.trim();
+    if (event.reason === "new") {
+      const previous = previousSessionState;
+      previousSessionState = null;
+      if (previous) return restorePreviousSession(ctx, previous);
+      return;
+    }
 
-      if (command === "set") {
-        const model = ctx.model;
-        if (!model) {
-          ctx.ui.notify(
-            "Cannot save thinking level without an active model.",
-            "warning",
-          );
-          return;
-        }
+    // Pi restores these sessions' model and thinking level from the session.
+    // Startup is already resolved by Pi except for a plain explicit --model,
+    // which bypasses the enabledModels startup selection. Reload preserves
+    // the current session, so applying the scoped default there would clobber
+    // a manual change.
+    if (
+      event.reason === "reload" ||
+      event.reason === "resume" ||
+      event.reason === "fork"
+    ) {
+      return;
+    }
+    if (event.reason === "startup" && !plainCliModelNeedsScopedLevel(ctx.model))
+      return;
+    applyScopedLevel(ctx, true);
+  });
 
-        const key = modelKey(model);
-        const level = pi.getThinkingLevel();
-        try {
-          const loaded = store.load();
-          if (loaded.error) {
-            ctx.ui.notify(
-              `Cannot save model-thinking config: ${loaded.error}. Repair ${store.path} or run /model-thinking reset first.`,
-              "error",
-            );
-            return;
-          }
+  pi.on("session_before_switch", (event, ctx) => {
+    if (event.reason !== "new") return;
 
-          store.save({
-            ...loaded.config,
-            models: { ...loaded.config.models, [key]: level },
-          });
-          ctx.ui.notify(`Saved ${key}: ${level}`, "info");
-        } catch (error) {
-          console.error(
-            "[model-thinking] failed to save current model:",
-            error,
-          );
-          ctx.ui.notify("Failed to save model-thinking config.", "error");
-        }
-        return;
-      }
-
-      if (command === "reset") {
-        try {
-          const removed = store.reset();
-          ctx.ui.notify(
-            removed
-              ? "Model-thinking config cleared."
-              : "No model-thinking config file to clear.",
-            "info",
-          );
-        } catch (error) {
-          console.error("[model-thinking] failed to clear config:", error);
-          ctx.ui.notify("Failed to clear model-thinking config.", "error");
+    const model = ctx.model;
+    previousSessionState = model
+      ? {
+          provider: model.provider,
+          id: model.id,
+          thinkingLevel: pi.getThinkingLevel(),
         }
-        return;
-      }
-
-      if (command !== "") {
-        ctx.ui.notify("Usage: /model-thinking [set|reset]", "warning");
-        return;
-      }
-
-      const model = ctx.model;
-      const loaded = store.load();
-      const resolved = loaded.error
-        ? undefined
-        : resolveThinkingLevel(loaded.config, model);
-      const lines = [
-        `model: ${model ? modelKey(model) : "none"}`,
-        `managed: ${resolved === undefined ? "no" : "yes"}`,
-        `file: ${store.path}`,
-        `saved: ${resolved ?? "none — pi handles this model natively"}`,
-        `current: ${pi.getThinkingLevel()}`,
-        ...(loaded.error
-          ? [`⚠ config invalid — no policy applied: ${loaded.error}`]
-          : []),
-        "",
-        "run `/model-thinking set` to save this model and level; `/model-thinking reset` to clear all configured levels",
-      ];
-      const message = lines.join("\n");
-
-      if (ctx.hasUI) ctx.ui.notify(message, resolved ? "info" : "warning");
-      else console.log(message);
-    },
+      : null;
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bermudis-pi-goodies",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "private": false,
   "description": "A bundle of small, frequently-used Pi extensions.",
   "keywords": ["pi-package"],

package/fixed-defaults.ts

@@ -1,469 +0,0 @@
-import {
-  getAgentDir,
-  SettingsManager,
-  type ExtensionAPI,
-  type ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import {
-  describeError,
-  unlinkIfPresent,
-  writeJsonFileAtomic,
-} from "./json-file.ts";
-
-const CONFIG_FILENAME = "fixed-defaults.json";
-
-/**
- * Model and thinking level active in the session being replaced by `/new`,
- * captured during `session_before_switch`. The factory is re-invoked per
- * session, so this must live at module scope to survive the switch to the new
- * extension instance.
- */
-let previousModelForNewSession: PreviousSessionModel | null = null;
-
-/** Model + thinking level snapshot taken when `/new` replaces a session. */
-interface PreviousSessionModel {
-  provider: string;
-  id: string;
-  thinkingLevel: ThinkingLevel;
-}
-
-type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
-/**
- * Values read from the override file. `provider` and `model` are a coupled
- * pair — a model id is meaningless without its provider, so both must be
- * present if either is.
- *
- * `thinkingLevel` was accepted by older versions. It is deliberately ignored
- * for compatibility; model-thinking.ts is now the sole owner of thinking
- * policy.
- */
-interface FixedDefaultsOverride {
-  provider?: string;
-  model?: string;
-}
-
-interface FixedDefaultsOptions {
-  /** Internal seam used by tests; normal callers use Pi's global agent dir. */
-  agentDir?: string;
-  /** Internal seam used by tests; defaults to <agentDir>/fixed-defaults.json. */
-  configPath?: string;
-}
-
-function parseOverride(value: unknown): FixedDefaultsOverride {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("the top level must be an object");
-  }
-
-  const input = value as Record<string, unknown>;
-  const unknownKeys = Object.keys(input).filter(
-    (key) => key !== "provider" && key !== "model" && key !== "thinkingLevel",
-  );
-  if (unknownKeys.length > 0) {
-    throw new Error(`unknown field(s): ${unknownKeys.join(", ")}`);
-  }
-
-  const override: FixedDefaultsOverride = {};
-  if (input.provider !== undefined) {
-    if (typeof input.provider !== "string" || input.provider.length === 0) {
-      throw new Error("`provider` must be a non-empty string");
-    }
-    override.provider = input.provider;
-  }
-  if (input.model !== undefined) {
-    if (typeof input.model !== "string" || input.model.length === 0) {
-      throw new Error("`model` must be a non-empty string");
-    }
-    override.model = input.model;
-  }
-
-  // provider and model are a coupled pair — a model id is meaningless without
-  // its provider. Require both if either is present so a hand-edited partial
-  // file can't pin a broken default. The legacy thinkingLevel field is
-  // intentionally ignored; model-thinking.ts owns thinking policy.
-  if (
-    (override.provider !== undefined && override.model === undefined) ||
-    (override.model !== undefined && override.provider === undefined)
-  ) {
-    throw new Error(
-      "`provider` and `model` must be specified together — a model id is meaningless without its provider",
-    );
-  }
-
-  return override;
-}
-
-function hasLegacyThinkingLevel(value: unknown): boolean {
-  return (
-    value !== null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    Object.prototype.hasOwnProperty.call(value, "thinkingLevel")
-  );
-}
-
-/**
- * Read/write the override file. Reads are uncached (the file is tiny and the
- * events are rare), so hand edits are picked up without a reload. Writes are
- * atomic via temp file + rename.
- */
-class DefaultsStore {
-  readonly path: string;
-  private warnedLegacyThinkingLevel = false;
-
-  constructor(path: string) {
-    this.path = path;
-  }
-
-  /** Load the override; an absent file is a valid, inactive configuration. */
-  load(): LoadResult {
-    let raw: string;
-    try {
-      raw = readFileSync(this.path, "utf8");
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return {
-          present: false,
-          override: {},
-          error: null,
-          legacyThinkingLevel: false,
-        };
-      }
-      throw error;
-    }
-
-    try {
-      const value = JSON.parse(raw) as unknown;
-      const legacyThinkingLevel = hasLegacyThinkingLevel(value);
-      if (legacyThinkingLevel && !this.warnedLegacyThinkingLevel) {
-        console.warn(
-          `[fixed-defaults] legacy thinkingLevel found in ${this.path}; it is ignored. Add the policy to model-thinking.json instead.`,
-        );
-        this.warnedLegacyThinkingLevel = true;
-      }
-      return {
-        present: true,
-        override: parseOverride(value),
-        error: null,
-        legacyThinkingLevel,
-      };
-    } catch (error) {
-      const message = describeError(error);
-      console.error(
-        `[fixed-defaults] invalid config at ${this.path}:`,
-        message,
-      );
-      return {
-        present: true,
-        override: {},
-        error: message,
-        legacyThinkingLevel: false,
-      };
-    }
-  }
-
-  save(override: FixedDefaultsOverride): void {
-    writeJsonFileAtomic(this.path, override);
-    this.warnedLegacyThinkingLevel = false;
-  }
-
-  reset(): void {
-    // Deletion is intentionally idempotent: if another process removes the
-    // pin after it was loaded, reset has still reached the requested end state.
-    unlinkIfPresent(this.path);
-    this.warnedLegacyThinkingLevel = false;
-  }
-}
-
-/** Result of reading the override file: the parsed values plus any error. */
-interface LoadResult {
-  /** Whether the override file existed when it was read. */
-  present: boolean;
-  override: FixedDefaultsOverride;
-  /** Non-null when the file existed but failed to parse or validate. */
-  error: string | null;
-  /** True when an old, ignored thinkingLevel field should be migrated. */
-  legacyThinkingLevel: boolean;
-}
-
-/**
- * Keep Pi's cross-session provider/model defaults stable while still allowing
- * model changes in the current session. Pi intentionally saves the last
- * selected model, so this runs after model-selection notifications and restores
- * the configured startup model in the global settings file.
- *
- * The pin lives in `<agentDir>/fixed-defaults.json` and is the sole source of
- * truth — there are no built-in defaults, so with no override file the
- * extension is dormant and Pi's native last-selection behavior is preserved.
- * `provider` and `model` are a coupled pair. Thinking policy belongs to
- * model-thinking.ts. `/fixed-defaults set` pins the currently active model;
- * `/fixed-defaults reset` stops pinning; `/fixed-defaults` shows the active pin.
- */
-export default function fixedDefaults(
-  pi: ExtensionAPI,
-  options: FixedDefaultsOptions = {},
-): void {
-  const agentDir = options.agentDir ?? getAgentDir();
-  const store = new DefaultsStore(
-    options.configPath ?? join(agentDir, CONFIG_FILENAME),
-  );
-  let pending = Promise.resolve();
-
-  async function persistModel(
-    ctx: ExtensionContext,
-    provider: string,
-    modelId: string,
-  ): Promise<void> {
-    const settings = SettingsManager.create(ctx.cwd, agentDir, {
-      projectTrusted: ctx.isProjectTrusted(),
-    });
-    settings.setDefaultModelAndProvider(provider, modelId);
-    await settings.flush();
-
-    const errors = settings.drainErrors();
-    if (errors.length > 0) {
-      const details = errors
-        .map(({ scope, error }) => `${scope}: ${describeError(error)}`)
-        .join("; ");
-      throw new Error(`failed to persist fixed defaults (${details})`);
-    }
-  }
-
-  async function restorePinnedModel(ctx: ExtensionContext): Promise<void> {
-    const { override, error } = store.load();
-    // A broken or absent override means no pin: leave settings untouched so
-    // Pi's native last-selection behavior is preserved rather than guessed at.
-    if (error) return;
-    const hasModelPin =
-      override.provider !== undefined && override.model !== undefined;
-    if (!hasModelPin) return;
-
-    await persistModel(ctx, override.provider!, override.model!);
-  }
-
-  /**
-   * Restore the model and thinking level that were active before `/new`.
-   * Unlike the pin, this only applies to the session being created, so the
-   * next fresh `pi` still starts from the pin.
-   */
-  async function restorePreviousModel(
-    ctx: ExtensionContext,
-    previous: PreviousSessionModel | null,
-  ): Promise<void> {
-    if (!previous) return;
-    const model = ctx.modelRegistry.find(previous.provider, previous.id);
-    if (!model) return;
-    // setModel writes the restored model to settings.json, then its model_select
-    // notification re-applies the pin afterwards (see restorePinnedModel), so
-    // the active session keeps the previous model while the pin survives.
-    // That same notification can re-apply a per-model thinking policy
-    // (model-thinking.ts), so the captured level is only restored after
-    // setModel resolves — its emit is awaited, giving this the final word.
-    // setThinkingLevel clamps to the restored model's capabilities.
-    const applied = await pi.setModel(model);
-    if (!applied) return;
-    pi.setThinkingLevel(previous.thinkingLevel);
-  }
-
-  function enqueue<T>(
-    operation: () => Promise<T>,
-    failureMessage: string,
-  ): Promise<T> {
-    const queued = pending.then(operation);
-    // Log once at the queue boundary, then recover only the internal tail so a
-    // failed write does not prevent later operations. The returned promise
-    // still rejects, allowing commands to notify the user.
-    pending = queued.then(
-      () => undefined,
-      (error: unknown) => {
-        console.error(failureMessage, error);
-      },
-    );
-    return queued;
-  }
-
-  function schedule(
-    ctx: ExtensionContext,
-    failureMessage = "[fixed-defaults] failed to restore defaults:",
-  ): Promise<void> {
-    return enqueue(() => restorePinnedModel(ctx), failureMessage);
-  }
-
-  pi.on("session_start", (event, ctx) => {
-    // `/new` has already selected a model (the pinned default) by the time this
-    // fires, so restore the model and thinking level that were active before
-    // the switch here. The resulting model_select notification re-applies the
-    // pin in settings.json.
-    if (event.reason === "new") {
-      const previous = previousModelForNewSession;
-      previousModelForNewSession = null;
-      if (!previous) return;
-      // Run outside the shared queue: pi.setModel emits model_select, whose
-      // handler enqueues the pin restore. Enqueuing this operation too would
-      // deadlock that handler by making it wait on this operation to finish.
-      return restorePreviousModel(ctx, previous).catch((error: unknown) => {
-        console.error(
-          "[fixed-defaults] failed to restore the previous session model after /new:",
-          error,
-        );
-      });
-    }
-    return schedule(ctx);
-  });
-  pi.on("model_select", (_event, ctx) => schedule(ctx));
-
-  pi.on("session_before_switch", (event, ctx) => {
-    if (event.reason === "new") {
-      const model = ctx.model;
-      previousModelForNewSession = model
-        ? {
-            provider: model.provider,
-            id: model.id,
-            thinkingLevel: pi.getThinkingLevel(),
-          }
-        : null;
-    }
-  });
-
-  pi.registerCommand("fixed-defaults", {
-    description: "Show, set, or reset the pinned startup model",
-    handler: async (args, ctx) => {
-      const command = args.trim();
-
-      if (command === "set") {
-        const model = ctx.model;
-        if (!model) {
-          ctx.ui.notify(
-            "Cannot pin defaults without an active model.",
-            "warning",
-          );
-          return;
-        }
-
-        const override: FixedDefaultsOverride = {
-          provider: model.provider,
-          model: model.id,
-        };
-        try {
-          store.save(override);
-        } catch (error) {
-          console.error("[fixed-defaults] failed to save override:", error);
-          ctx.ui.notify("Failed to save the new fixed defaults.", "error");
-          return;
-        }
-
-        // The active model is already Pi's current selection. Do not rewrite
-        // settings here: that write is unnecessary and must not take ownership
-        // of Pi's native defaultThinkingLevel persistence.
-        ctx.ui.notify(
-          `Pinned ${model.provider}/${model.id} as the startup model`,
-          "info",
-        );
-        return;
-      }
-
-      if (command === "reset") {
-        type ResetResult =
-          | { status: "missing" }
-          | { status: "removed-inactive" }
-          | { status: "no-active-model" }
-          | {
-              status: "removed";
-              model: NonNullable<ExtensionContext["model"]>;
-            };
-
-        try {
-          const result = await enqueue<ResetResult>(async () => {
-            // Load and validate before touching settings. Invalid, legacy-only,
-            // and partial files are inactive, so remove them without replacing
-            // Pi's last selection with the currently active model.
-            const loaded = store.load();
-            if (!loaded.present) return { status: "missing" };
-
-            const hasModelPin =
-              loaded.error === null &&
-              loaded.override.provider !== undefined &&
-              loaded.override.model !== undefined;
-            if (!hasModelPin) {
-              store.reset();
-              return { status: "removed-inactive" };
-            }
-
-            const model = ctx.model;
-            if (!model) return { status: "no-active-model" };
-
-            // Save the active model before removing the valid pin. Otherwise
-            // the old pinned model remains in settings.json and wins at the
-            // next fresh start.
-            await persistModel(ctx, model.provider, model.id);
-            store.reset();
-            return { status: "removed", model };
-          }, "[fixed-defaults] failed to reset override:");
-
-          if (result.status === "missing") {
-            ctx.ui.notify("No fixed-defaults override file to reset.", "info");
-          } else if (result.status === "removed-inactive") {
-            ctx.ui.notify(
-              "Inactive or invalid fixed-defaults override removed; settings were left unchanged.",
-              "info",
-            );
-          } else if (result.status === "no-active-model") {
-            ctx.ui.notify(
-              "Cannot reset fixed defaults without an active model; the pin was left in place.",
-              "warning",
-            );
-          } else {
-            ctx.ui.notify(
-              `Fixed-defaults pin removed. Pi will use ${result.model.provider}/${result.model.id} as its last selection.`,
-              "info",
-            );
-          }
-        } catch {
-          ctx.ui.notify(
-            "Failed to reset fixed defaults. Pin removal could not be confirmed; settings may already reflect the active model.",
-            "error",
-          );
-        }
-        return;
-      }
-
-      if (command !== "") {
-        ctx.ui.notify("Usage: /fixed-defaults [set|reset]", "warning");
-        return;
-      }
-
-      const { override, error, legacyThinkingLevel } = store.load();
-      const model = ctx.model;
-      const lines = [
-        `model: ${model ? `${model.provider}/${model.id}` : "none"}`,
-        "",
-      ];
-      if (error) {
-        lines.push(`⚠ override file invalid — no pin active: ${error}`);
-      } else if (Object.keys(override).length === 0) {
-        lines.push("No pin active. Pi will use your last selection.");
-      } else {
-        if (override.provider !== undefined && override.model !== undefined) {
-          lines.push(`pinned provider: ${override.provider}`);
-          lines.push(`pinned model: ${override.model}`);
-        }
-      }
-      if (legacyThinkingLevel) {
-        lines.push(
-          "",
-          "⚠ legacy thinkingLevel is present but ignored; manage it with /model-thinking",
-        );
-      }
-      lines.push("", `override file: ${store.path}`);
-      lines.push(
-        "",
-        "run `/fixed-defaults set` to pin the current model; `/fixed-defaults reset` to stop pinning",
-      );
-      const message = lines.join("\n");
-
-      if (ctx.hasUI) ctx.ui.notify(message, "info");
-      else console.log(message);
-    },
-  });
-}