pi-better-model-select 0.1.3 → 0.1.4

package/README.md

@@ -2,8 +2,8 @@
 
 A searchable, usage-ranked model picker for [pi](https://pi.dev).
 
-`/bms` opens the effective model list from `models.json` plus the optional
-`models.local.json` overlay, sorted by how often you pick each model. Start
+`/bms` opens the effective model list from `models.json` plus the optional BMS-owned
+`models.bms.json` overlay, sorted by how often you pick each model. Start
 typing to filter; press enter to switch the session to the highlighted model.
 Add, update and delete live on ctrl-chords so plain keystrokes always go to the
 search box.
@@ -38,9 +38,22 @@ pi install npm:pi-better-model-select
 | `ctrl+a`   | Add a model                                         |
 | `ctrl+u`   | Update the highlighted model                        |
 | `ctrl+x`   | Delete the highlighted model                        |
+| `ctrl+o`   | Open BMS options                                    |
 | `ctrl+r`   | Reset usage statistics                              |
 | `esc`      | Close                                               |
 
+## Options
+
+Press `ctrl+o` in `/bms` to configure:
+
+- **Write mode.** Overlay mode keeps Pi's `models.json` unchanged and stores
+  BMS edits in `models.bms.json`. Direct mode writes add, update and delete
+  operations to `models.json`.
+- **Provider filters.** Enable or disable providers in the `/bms` model list.
+  These filters do not change Pi's `/model` picker or either model file.
+
+BMS stores these choices in `<agent-dir>/bms-settings.json`.
+
 ## Ranking
 
 Every model loaded through `/bms` increments a counter in
@@ -66,9 +79,8 @@ cap, reasoning support and input modalities from, in order:
 
 Each step is best-effort. A plain OpenAI-compatible endpoint usually yields
 nothing from steps 1 and 2, and the flow falls back to name-based heuristics
-with editable defaults. Before a write, BMS asks you to choose
-`models.local.json` or `models.json`. The local file is listed first and acts as
-a personal BMS overlay. The selected file is re-read immediately before the
+with editable defaults. Choose the default write mode from `ctrl+o` in `/bms`. Overlay mode writes to
+`models.bms.json`; direct mode edits Pi's `models.json`. The selected file is re-read immediately before the
 write so a concurrent edit in another pi session is not clobbered.
 
 ## Paths
@@ -77,19 +89,20 @@ All files resolve through pi's `getAgentDir()`, so `PI_CODING_AGENT_DIR` and
 rebranded distributions work without special handling:
 
 - `<agent-dir>/models.json` is Pi's documented compatible-endpoint configuration.
-- `<agent-dir>/models.local.json` is an optional personal overlay managed by BMS.
+- `<agent-dir>/models.bms.json` is the optional overlay owned and loaded by BMS.
+- `<agent-dir>/bms-settings.json` stores the write mode and provider filters.
 - `<agent-dir>/bms-usage.json` stores selection counters.
 
-Pi does not currently document or load `models.local.json` itself. BMS merges it
-over `models.json` by provider and model id, then registers the merged providers
-through Pi's extension API at session start and whenever `/bms` opens. If the
-same model exists in both files, fields from `models.local.json` win.
+Pi does not load `models.bms.json` itself. In overlay mode, BMS merges it over
+`models.json` by provider and model id, then registers the merged providers
+through Pi's extension API. If the same model exists in both files, fields from
+`models.bms.json` win. Existing `models.local.json` overlays from BMS 0.1.x are
+renamed to `models.bms.json` automatically.
 
 Deleting a model that exists only in `models.json` leaves that file untouched.
-BMS writes `{ "id": "...", "bmsDeleted": true }` to the local overlay instead.
-This BMS-owned tombstone keeps generated or externally managed model entries
-hidden across restarts. Delete the tombstone from `models.local.json` to restore
-the inherited model.
+BMS writes `{ "id": "...", "bmsDeleted": true }` to the overlay instead.
+This tombstone keeps generated or externally managed model entries hidden across
+restarts. Delete it from `models.bms.json` to restore the inherited model.
 
 Writes are atomic using a temporary file and rename, so an interrupted write
 cannot truncate either configuration file.

package/extensions/bms.ts

@@ -11,8 +11,10 @@ import { ModelPicker, rankModels, type PickerAction } from "./lib/picker.ts";
 import {
   loadConfig,
   loadConfigFile,
+  loadSettings,
   pruneUsage,
   recordUsage,
+  saveSettings,
   saveUsage,
   type ModelEntry,
   type ModelsConfig,
@@ -47,11 +49,13 @@ function providerConfig(
 
 /** Apply the personal BMS overlay as extension providers. */
 function syncLocalConfig(pi: ExtensionAPI, ctx: any): ModelsConfig | null {
-  const local = loadConfigFile(ctx, "models.local.json", true);
+  const settings = loadSettings();
+  const overlay =
+    settings.writeMode === "overlay" ? loadConfigFile(ctx, "models.bms.json", true) : { providers: {} };
   const effective = loadConfig(ctx);
-  if (!local || !effective) return null;
+  if (!overlay || !effective) return null;
 
-  const next = new Set(Object.keys(local.providers ?? {}));
+  const next = new Set(Object.keys(overlay.providers ?? {}));
   for (const providerName of registeredLocalProviders) {
     if (!next.has(providerName)) pi.unregisterProvider(providerName);
   }
@@ -62,7 +66,7 @@ function syncLocalConfig(pi: ExtensionAPI, ctx: any): ModelsConfig | null {
     try {
       pi.registerProvider(providerName, providerConfig(ctx, providerName, provider) as any);
     } catch (e) {
-      ctx.ui.notify(`Cannot apply ${providerName} from models.local.json: ${e}`, "error");
+      ctx.ui.notify(`Cannot apply ${providerName} from models.bms.json: ${e}`, "error");
       return null;
     }
   }
@@ -73,6 +77,52 @@ function syncLocalConfig(pi: ExtensionAPI, ctx: any): ModelsConfig | null {
 }
 
 /** Re-read model configuration from disk and switch the session to the given model. */
+async function optionsFlow(ctx: any, config: ModelsConfig): Promise<void> {
+  for (;;) {
+    const settings = loadSettings();
+    const writeLabel =
+      settings.writeMode === "overlay" ? "BMS overlay (models.bms.json)" : "Pi config (models.json)";
+    const hidden = settings.disabledProviders.length;
+    const pick = await ctx.ui.select("BMS options", [
+      `Write mode: ${writeLabel}`,
+      `Provider filters: ${hidden} hidden`,
+      "Done",
+    ]);
+    if (!pick || pick === "Done") return;
+
+    if (pick.startsWith("Write mode:")) {
+      const mode = await ctx.ui.select("Where should BMS write model changes?", [
+        "BMS overlay (models.bms.json)",
+        "Pi config (models.json)",
+      ]);
+      if (!mode) continue;
+      settings.writeMode = mode.startsWith("BMS overlay") ? "overlay" : "direct";
+      saveSettings(settings);
+      ctx.ui.notify(`BMS write mode: ${settings.writeMode}.`, "info");
+      continue;
+    }
+
+    const providers = Object.keys(config.providers ?? {}).sort();
+    for (;;) {
+      const current = loadSettings();
+      const options = providers.map((provider) =>
+        `${current.disabledProviders.includes(provider) ? "[ ]" : "[x]"} ${provider}`,
+      );
+      const choice = await ctx.ui.select(
+        "Providers shown in /bms (select to toggle, ESC when done)",
+        options,
+      );
+      if (!choice) break;
+      const provider = choice.slice(4);
+      const disabled = new Set(current.disabledProviders);
+      if (disabled.has(provider)) disabled.delete(provider);
+      else disabled.add(provider);
+      current.disabledProviders = [...disabled].sort();
+      saveSettings(current);
+    }
+  }
+}
+
 async function loadModel(
   pi: ExtensionAPI,
   ctx: any,
@@ -129,8 +179,22 @@ export default function (pi: ExtensionAPI) {
         if (!config) return;
         pruneUsage(config);
 
-        const rows = rankModels(config);
+        const settings = loadSettings();
+        const rows = rankModels(config, settings.disabledProviders);
         if (rows.length === 0) {
+          const total = Object.values(config.providers ?? {}).reduce(
+            (sum, provider) => sum + (provider.models?.length ?? 0),
+            0,
+          );
+          if (total > 0) {
+            const open = await ctx.ui.confirm(
+              "No models visible",
+              "All providers are hidden by BMS filters. Open options?",
+            );
+            if (!open) return;
+            await optionsFlow(ctx, config);
+            continue;
+          }
           const add = await ctx.ui.confirm(
             "No models configured",
             "The effective model configuration has no models. Add one now?",
@@ -188,6 +252,9 @@ export default function (pi: ExtensionAPI) {
                 : undefined,
             );
             break;
+          case "options":
+            await optionsFlow(ctx, config);
+            break;
           case "reset": {
             const ok = await ctx.ui.confirm(
               "Reset usage statistics?",
@@ -208,7 +275,7 @@ export default function (pi: ExtensionAPI) {
 
   // Standalone add, kept for muscle memory and non-interactive convenience.
   pi.registerCommand("bms-add", {
-    description: "Add a model from a provider's endpoint to a selected config file",
+    description: "Add a model from a provider's endpoint using the configured write mode",
     handler: async (_args, ctx: any) => addFlow(ctx as FlowCtx),
   });
 }

package/extensions/lib/flows.ts

@@ -1,6 +1,6 @@
 // Add / update / delete flows against the effective model configuration.
 //
-// Each mutation asks which file to write, then re-reads that file immediately
+// Each mutation follows the saved write mode, then re-reads the target file
 // before saving so another pi session's edit is not silently clobbered.
 
 import {
@@ -17,9 +17,11 @@ import {
   configContainsModel,
   loadConfig,
   loadConfigFile,
+  loadSettings,
   saveConfig,
   tombstoneModel,
   upsertModel,
+  writeTarget,
   type ConfigTarget,
   type ModelEntry,
   type ModelsConfig,
@@ -37,20 +39,8 @@ export interface FlowCtx {
 
 const INPUT_OPTIONS: string[][] = [["text"], ["text", "image"]];
 
-const TARGET_LABELS = {
-  "models.local.json": "models.local.json (personal BMS overlay)",
-  "models.json": "models.json (Pi configuration)",
-} satisfies Record<ConfigTarget, string>;
-
-async function selectWriteTarget(
-  ctx: FlowCtx,
-  message = "Write changes to which file?",
-): Promise<ConfigTarget | undefined> {
-  const options = [TARGET_LABELS["models.local.json"], TARGET_LABELS["models.json"]];
-  const pick = await ctx.ui.select(message, options);
-  if (pick === TARGET_LABELS["models.local.json"]) return "models.local.json";
-  if (pick === TARGET_LABELS["models.json"]) return "models.json";
-  return undefined;
+function selectedWriteTarget(): ConfigTarget {
+  return writeTarget(loadSettings());
 }
 
 function providerOverlay(config: ModelsConfig, providerName: string): Record<string, unknown> {
@@ -187,11 +177,10 @@ export async function addFlow(ctx: FlowCtx): Promise<void> {
   if (input === undefined) return;
   crumbs.push(`Input: ${input.join("+")}`);
 
-  const writeTarget = await selectWriteTarget(ctx);
-  if (!writeTarget) return;
+  const targetFile = selectedWriteTarget();
   const ok = await ctx.ui.confirm(
     `${header()}Add this model to "${providerName}"?`,
-    `Write the entry to ${writeTarget}?`,
+    `Write the entry to ${targetFile}?`,
   );
   if (!ok) {
     ctx.ui.notify("Cancelled. Nothing written.", "info");
@@ -199,7 +188,7 @@ export async function addFlow(ctx: FlowCtx): Promise<void> {
   }
 
   const freshEffective = loadConfig(ctx);
-  const freshTarget = loadConfigFile(ctx, writeTarget, writeTarget === "models.local.json");
+  const freshTarget = loadConfigFile(ctx, targetFile, targetFile === "models.bms.json");
   if (!freshEffective || !freshTarget) return;
   if (!freshEffective.providers?.[providerName]) {
     ctx.ui.notify(`Provider "${providerName}" no longer exists.`, "error");
@@ -218,8 +207,8 @@ export async function addFlow(ctx: FlowCtx): Promise<void> {
     contextWindow,
     maxTokens,
   });
-  saveConfig(freshTarget, writeTarget);
-  ctx.ui.notify(`Added "${modelId}" to ${providerName} in ${writeTarget}.`, "info");
+  saveConfig(freshTarget, targetFile);
+  ctx.ui.notify(`Added "${modelId}" to ${providerName} in ${targetFile}.`, "info");
 }
 
 // ----- update --------------------------------------------------------------
@@ -381,11 +370,10 @@ export async function updateFlow(
     return;
   }
 
-  const writeTarget = await selectWriteTarget(ctx);
-  if (!writeTarget) return;
+  const targetFile = selectedWriteTarget();
   const ok = await ctx.ui.confirm(
     `Update ${existing.id}?`,
-    `Write ${[...changes.keys()].join(", ")} to "${providerName}" in ${writeTarget}?`,
+    `Write ${[...changes.keys()].join(", ")} to "${providerName}" in ${targetFile}?`,
   );
   if (!ok) {
     ctx.ui.notify("Cancelled. Nothing updated.", "info");
@@ -393,7 +381,7 @@ export async function updateFlow(
   }
 
   const freshEffective = loadConfig(ctx);
-  const freshTarget = loadConfigFile(ctx, writeTarget, writeTarget === "models.local.json");
+  const freshTarget = loadConfigFile(ctx, targetFile, targetFile === "models.bms.json");
   if (!freshEffective || !freshTarget) return;
   const modelEntry = completeModel(freshEffective, providerName, existing.id);
   if (!modelEntry) {
@@ -403,9 +391,9 @@ export async function updateFlow(
   Object.assign(modelEntry, Object.fromEntries(changes));
   ensureProviderSettings(freshTarget, freshEffective, providerName);
   upsertModel(freshTarget, providerName, modelEntry);
-  saveConfig(freshTarget, writeTarget);
+  saveConfig(freshTarget, targetFile);
   ctx.ui.notify(
-    `Updated "${existing.id}" in ${providerName} via ${writeTarget}: ${[...changes.entries()]
+    `Updated "${existing.id}" in ${providerName} via ${targetFile}: ${[...changes.entries()]
       .map(([k, v]) => `${k}=${Array.isArray(v) ? v.join("+") : String(v)}`)
       .join(", ")}.`,
     "info",
@@ -444,60 +432,66 @@ export async function deleteFlow(
     ({ provider, id } = map.get(label)!);
   }
 
+  const settings = loadSettings();
+  const targetFile = writeTarget(settings);
   const base = loadConfigFile(ctx, "models.json");
-  const local = loadConfigFile(ctx, "models.local.json", true);
-  if (!base || !local) return;
-
-  const candidates: ConfigTarget[] = [];
-  if (configContainsModel(local, provider, id)) candidates.push("models.local.json");
-  if (configContainsModel(base, provider, id)) candidates.push("models.json");
-  if (candidates.length === 0) {
-    ctx.ui.notify(`Model "${id}" is no longer present in either config file.`, "warning");
-    return;
-  }
+  if (!base) return;
+
+  if (settings.writeMode === "overlay") {
+    const overlay = loadConfigFile(ctx, "models.bms.json", true);
+    if (!overlay) return;
+    const inherited = configContainsModel(base, provider, id);
+    const local = configContainsModel(overlay, provider, id);
+    if (!inherited && !local) {
+      ctx.ui.notify(`Model "${id}" is no longer present in either config file.`, "warning");
+      return;
+    }
 
-  if (candidates.length === 1 && candidates[0] === "models.json") {
     const ok = await ctx.ui.confirm(
-      `Hide inherited model ${id}?`,
-      "Keep models.json unchanged and add a BMS tombstone to models.local.json?",
+      `${inherited && !local ? "Hide inherited model" : "Delete"} ${id}?`,
+      inherited && !local
+        ? "Keep models.json unchanged and add a BMS tombstone to models.bms.json?"
+        : `Remove it from "${provider}" in models.bms.json?`,
     );
     if (!ok) {
       ctx.ui.notify("Cancelled. Nothing deleted.", "info");
       return;
     }
 
-    const freshLocal = loadConfigFile(ctx, "models.local.json", true);
-    if (!freshLocal) return;
-    tombstoneModel(freshLocal, provider, id);
-    saveConfig(freshLocal, "models.local.json");
-    ctx.ui.notify(`Hidden inherited model "${id}" via models.local.json.`, "info");
+    if (inherited) tombstoneModel(overlay, provider, id);
+    else {
+      const target = overlay.providers?.[provider];
+      if (target?.models) target.models = target.models.filter((model) => model.id !== id);
+    }
+    saveConfig(overlay, "models.bms.json");
+    ctx.ui.notify(
+      inherited
+        ? `Hidden inherited model "${id}" via models.bms.json.`
+        : `Deleted "${id}" from ${provider} in models.bms.json.`,
+      "info",
+    );
     return;
   }
 
-  let writeTarget: ConfigTarget;
-  if (candidates.length === 1) {
-    writeTarget = candidates[0]!;
-  } else {
-    const selected = await selectWriteTarget(ctx, "Remove the model from which file?");
-    if (!selected) return;
-    writeTarget = selected;
+  if (!configContainsModel(base, provider, id)) {
+    ctx.ui.notify(`Model "${id}" is no longer present in models.json.`, "warning");
+    return;
   }
-
   const ok = await ctx.ui.confirm(
     `Delete ${id}?`,
-    `Remove it from "${provider}" in ${writeTarget}?`,
+    `Remove it from "${provider}" in ${targetFile}?`,
   );
   if (!ok) {
     ctx.ui.notify("Cancelled. Nothing deleted.", "info");
     return;
   }
 
-  const fresh = loadConfigFile(ctx, writeTarget, writeTarget === "models.local.json");
+  const fresh = loadConfigFile(ctx, targetFile, targetFile === "models.bms.json");
   if (!fresh) return;
   const target = fresh.providers?.[provider];
   if (target?.models) {
     target.models = target.models.filter((m) => m.id !== id);
-    saveConfig(fresh, writeTarget);
-    ctx.ui.notify(`Deleted "${id}" from ${provider} in ${writeTarget}.`, "info");
+    saveConfig(fresh, targetFile);
+    ctx.ui.notify(`Deleted "${id}" from ${provider} in ${targetFile}.`, "info");
   }
 }

package/extensions/lib/picker.ts

@@ -22,6 +22,7 @@ export type PickerAction =
   | { kind: "add" }
   | { kind: "update"; provider?: string; modelId?: string }
   | { kind: "delete"; provider?: string; modelId?: string }
+  | { kind: "options" }
   | { kind: "reset" }
   | { kind: "close" };
 
@@ -39,10 +40,15 @@ export interface RankedModel {
  * Rank models by usage: most-selected first, ties broken by most-recent, then
  * alphabetically so the order is stable for never-used models.
  */
-export function rankModels(config: ModelsConfig): RankedModel[] {
+export function rankModels(
+  config: ModelsConfig,
+  disabledProviders: readonly string[] = [],
+): RankedModel[] {
   const stats = loadUsage();
+  const disabled = new Set(disabledProviders);
   const rows: RankedModel[] = [];
   for (const [provider, entry] of Object.entries(config.providers ?? {})) {
+    if (disabled.has(provider)) continue;
     for (const m of entry.models ?? []) {
       const key = usageKey(provider, m.id);
       rows.push({
@@ -103,7 +109,7 @@ export function selectListTheme(theme: any): SelectListTheme {
 }
 
 const HINT =
-  "↑↓ move  •  enter load  •  ctrl+a add  •  ctrl+u update  •  ctrl+x delete  •  ctrl+r reset stats  •  esc close";
+  "↑↓ move  •  enter load  •  ctrl+a add  •  ctrl+u update  •  ctrl+x delete  •  ctrl+o options  •  ctrl+r reset  •  esc close";
 
 export class ModelPicker extends Container implements Focusable {
   private search: Input;
@@ -229,6 +235,7 @@ export class ModelPicker extends Container implements Focusable {
   handleInput(data: string): void {
     if (matchesKey(data, "escape")) return this.done({ kind: "close" });
     if (matchesKey(data, "ctrl+a")) return this.done({ kind: "add" });
+    if (matchesKey(data, "ctrl+o")) return this.done({ kind: "options" });
     if (matchesKey(data, "ctrl+r")) return this.done({ kind: "reset" });
 
     if (matchesKey(data, "ctrl+u")) {

package/extensions/lib/store.ts

@@ -1,19 +1,34 @@
 // Model configuration access + usage statistics store.
 //
-// Pi reads models.json itself. Better Model Select also supports an optional
-// models.local.json overlay for personal edits. The extension merges and
-// registers that overlay at runtime, so the local file remains private to BMS.
+// Pi reads models.json itself. Better Model Select can also use a BMS-owned
+// models.bms.json overlay. The extension merges and registers that overlay at
+// runtime, so Pi never needs to understand the extra file.
 
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-export type ConfigTarget = "models.json" | "models.local.json";
+export type ConfigTarget = "models.json" | "models.bms.json";
+export type WriteMode = "overlay" | "direct";
 
 export const MODELS_PATH = (): string => join(getAgentDir(), "models.json");
-export const LOCAL_MODELS_PATH = (): string => join(getAgentDir(), "models.local.json");
+export const BMS_MODELS_PATH = (): string => join(getAgentDir(), "models.bms.json");
+export const LEGACY_LOCAL_MODELS_PATH = (): string => join(getAgentDir(), "models.local.json");
+export const SETTINGS_PATH = (): string => join(getAgentDir(), "bms-settings.json");
 export const USAGE_PATH = (): string => join(getAgentDir(), "bms-usage.json");
 
+export interface BmsSettings {
+  version: 1;
+  writeMode: WriteMode;
+  disabledProviders: string[];
+}
+
+const DEFAULT_SETTINGS: BmsSettings = {
+  version: 1,
+  writeMode: "overlay",
+  disabledProviders: [],
+};
+
 export interface ModelEntry {
   id: string;
   /** BMS overlay tombstone. Hides an inherited model without editing models.json. */
@@ -41,7 +56,37 @@ export interface ModelsConfig {
 }
 
 export function configPath(target: ConfigTarget): string {
-  return target === "models.local.json" ? LOCAL_MODELS_PATH() : MODELS_PATH();
+  return target === "models.bms.json" ? BMS_MODELS_PATH() : MODELS_PATH();
+}
+
+/** Move the old BMS overlay name to the explicit BMS-owned filename. */
+export function migrateLegacyOverlay(): void {
+  if (!existsSync(BMS_MODELS_PATH()) && existsSync(LEGACY_LOCAL_MODELS_PATH())) {
+    renameSync(LEGACY_LOCAL_MODELS_PATH(), BMS_MODELS_PATH());
+  }
+}
+
+export function loadSettings(): BmsSettings {
+  try {
+    const raw = JSON.parse(readFileSync(SETTINGS_PATH(), "utf8")) as Partial<BmsSettings>;
+    return {
+      version: 1,
+      writeMode: raw.writeMode === "direct" ? "direct" : "overlay",
+      disabledProviders: Array.isArray(raw.disabledProviders)
+        ? raw.disabledProviders.filter((value): value is string => typeof value === "string")
+        : [],
+    };
+  } catch {
+    return structuredClone(DEFAULT_SETTINGS);
+  }
+}
+
+export function saveSettings(settings: BmsSettings): void {
+  writeJsonAtomic(SETTINGS_PATH(), settings);
+}
+
+export function writeTarget(settings = loadSettings()): ConfigTarget {
+  return settings.writeMode === "direct" ? "models.json" : "models.bms.json";
 }
 
 /** Write JSON atomically so a crash mid-write cannot truncate the target file. */
@@ -60,6 +105,7 @@ export function loadConfigFile(
   target: ConfigTarget,
   missingIsEmpty = false,
 ): ModelsConfig | null {
+  if (target === "models.bms.json") migrateLegacyOverlay();
   const path = configPath(target);
   if (missingIsEmpty && !existsSync(path)) return { providers: {} };
   try {
@@ -70,7 +116,7 @@ export function loadConfigFile(
   }
 }
 
-/** Merge models.local.json over models.json. Model entries merge by id. */
+/** Merge models.bms.json over models.json. Model entries merge by id. */
 export function mergeConfigs(base: ModelsConfig, local: ModelsConfig): ModelsConfig {
   const merged = structuredClone(base);
   merged.providers = merged.providers ?? {};
@@ -102,9 +148,11 @@ export function loadConfig(ctx: {
 }): ModelsConfig | null {
   const base = loadConfigFile(ctx, "models.json");
   if (!base) return null;
-  if (!existsSync(LOCAL_MODELS_PATH())) return base;
-  const local = loadConfigFile(ctx, "models.local.json");
-  return local ? mergeConfigs(base, local) : null;
+  if (loadSettings().writeMode === "direct") return base;
+  migrateLegacyOverlay();
+  if (!existsSync(BMS_MODELS_PATH())) return base;
+  const overlay = loadConfigFile(ctx, "models.bms.json");
+  return overlay ? mergeConfigs(base, overlay) : null;
 }
 
 export function saveConfig(config: ModelsConfig, target: ConfigTarget): void {
@@ -119,7 +167,7 @@ export function configContainsModel(
   return Boolean(config.providers?.[provider]?.models?.some((model) => model.id === modelId));
 }
 
-/** Hide an inherited model through the BMS local overlay. */
+/** Hide an inherited model through the BMS overlay. */
 export function tombstoneModel(config: ModelsConfig, provider: string, modelId: string): void {
   upsertModel(config, provider, { id: modelId, bmsDeleted: true });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-model-select",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "description": "Better model select for pi — /bms opens a searchable model picker sorted by how often you actually use each model, with inline add, update and delete.",
   "keywords": [