pi-better-model-select 0.1.3 → 0.2.0

package/extensions/lib/flows.ts

@@ -1,8 +1,9 @@
 // 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 { editModelEfforts, saveModelEfforts, type EffortDraft } from "./effort-editor.ts";
 import {
   DEFAULT_CONTEXT_WINDOW,
   DEFAULT_MAX_TOKENS,
@@ -17,9 +18,11 @@ import {
   configContainsModel,
   loadConfig,
   loadConfigFile,
+  loadSettings,
   saveConfig,
   tombstoneModel,
   upsertModel,
+  writeTarget,
   type ConfigTarget,
   type ModelEntry,
   type ModelsConfig,
@@ -27,6 +30,8 @@ import {
 
 // Minimal shape of the pi extension command context we rely on.
 export interface FlowCtx {
+  cwd?: string;
+  isProjectTrusted?: () => boolean;
   ui: {
     notify: (message: string, level: string) => void;
     select: (message: string, options: string[]) => Promise<string | undefined>;
@@ -37,20 +42,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> {
@@ -102,7 +95,7 @@ async function selectInput(
 
 // ----- add -----------------------------------------------------------------
 
-export async function addFlow(ctx: FlowCtx): Promise<void> {
+export async function addFlow(ctx: FlowCtx, onAdded?: (provider: string, modelId: string) => Promise<void>): Promise<void> {
   const config = loadConfig(ctx);
   if (!config) return;
   const providers = config.providers ?? {};
@@ -187,11 +180,13 @@ 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 effortDraft = await editModelEfforts(ctx, `${providerName}/${modelId}`, reasoning, meta.effortLevels);
+  if (!effortDraft) 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 +194,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");
@@ -209,6 +204,7 @@ export async function addFlow(ctx: FlowCtx): Promise<void> {
     ctx.ui.notify(`Model "${modelId}" is already configured in ${providerName}.`, "warning");
     return;
   }
+  if (!saveModelEfforts(ctx, `${providerName}/${modelId}`, effortDraft)) return;
   ensureProviderSettings(freshTarget, freshEffective, providerName);
   upsertModel(freshTarget, providerName, {
     id: modelId,
@@ -218,8 +214,9 @@ 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");
+  if (onAdded && await ctx.ui.confirm("Set as Pi default?", "Configure this model and effort as the default for new sessions?")) await onAdded(providerName, modelId);
 }
 
 // ----- update --------------------------------------------------------------
@@ -287,7 +284,20 @@ export async function updateFlow(
     );
   }
 
+  let effortDraft: EffortDraft | undefined;
   const fields: Field[] = [
+    {
+      key: "bmsEfforts",
+      label: "Available / preferred efforts",
+      current: "edit capability levels and Pi per-model preference",
+      suggest: meta.effortLevels?.join(", "),
+      edit: async () => {
+        const draft = await editModelEfforts(ctx, `${providerName}/${existing.id}`, Boolean(changes.get("reasoning") ?? existing.reasoning), meta.effortLevels);
+        if (!draft) return;
+        effortDraft = draft;
+        return `${draft.capability.levels.join(", ")}; preferred ${draft.preferred ?? "automatic"}`;
+      },
+    },
     {
       key: "name",
       label: "Display name",
@@ -374,6 +384,10 @@ export async function updateFlow(
     const value = await field.edit(() => `Model: ${existing.id} [${providerName}]\n`);
     if (value === undefined) continue; // ESC in the field editor — back to list
     changes.set(field.key, value);
+    if (field.key === "reasoning") {
+      effortDraft = undefined;
+      changes.delete("bmsEfforts");
+    }
   }
 
   if (changes.size === 0) {
@@ -381,11 +395,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,19 +406,24 @@ 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) {
     ctx.ui.notify(`Model "${existing.id}" no longer exists in ${providerName}.`, "error");
     return;
   }
-  Object.assign(modelEntry, Object.fromEntries(changes));
+  if (changes.has("reasoning") && !effortDraft) {
+    effortDraft = await editModelEfforts(ctx, `${providerName}/${existing.id}`, Boolean(changes.get("reasoning")), meta.effortLevels);
+    if (!effortDraft) return;
+  }
+  if (effortDraft && !saveModelEfforts(ctx, `${providerName}/${existing.id}`, effortDraft)) return;
+  Object.assign(modelEntry, Object.fromEntries([...changes].filter(([key]) => key !== "bmsEfforts")));
   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 +462,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/meta.ts

@@ -5,11 +5,20 @@
 // endpoint yields nothing and the caller falls back to explicit defaults.
 
 import type { ModelsConfig } from "./store.ts";
+import { normalizeEfforts, type Effort } from "./defaults-store.ts";
+
+/** Only explicit enumerations count. supported_parameters alone is not an effort list. */
+export function metadataEfforts(metadata: Record<string, any>): Effort[] | undefined {
+  return normalizeEfforts(metadata.supported_reasoning_efforts)
+    ?? normalizeEfforts(metadata.supported_thinking_levels)
+    ?? normalizeEfforts(metadata.reasoning_efforts);
+}
 
 export const DEFAULT_CONTEXT_WINDOW = 128000;
 export const DEFAULT_MAX_TOKENS = 32768;
 
 export interface ModelMeta {
+  effortLevels?: Effort[];
   contextWindow?: number;
   maxTokens?: number;
   reasoning?: boolean;
@@ -55,6 +64,7 @@ export async function fetchModelMeta(
   key: string,
   modelId: string,
 ): Promise<ModelMeta> {
+  let effortLevels: Effort[] | undefined;
   let metaContext: number | undefined;
   let metaMaxTokens: number | undefined;
   let metaReasoning: boolean | undefined;
@@ -87,6 +97,8 @@ export async function fetchModelMeta(
       );
       if (match?.model_info) {
         const mi = match.model_info as Record<string, any>;
+        effortLevels = metadataEfforts(mi);
+        if (typeof mi.supports_reasoning === "boolean") metaReasoning = mi.supports_reasoning;
         metaContext = mi.max_input_tokens ?? mi.max_tokens;
         // Only trust an explicit output cap — LiteLLM's generic `max_tokens`
         // is often a default (e.g. 4096/128000), not the model's real cap.
@@ -106,8 +118,8 @@ export async function fetchModelMeta(
     // Not a LiteLLM proxy or endpoint unavailable — ignore.
   }
 
-  // 2) OpenAI-style per-model GET
-  if (metaContext === undefined) {
+  // 2) OpenAI-style per-model GET, also used when token metadata lacks effort information.
+  if (metaContext === undefined || effortLevels === undefined) {
     try {
       const modelRes = await fetch(`${base}/models/${encodeURIComponent(modelId)}`, {
         headers: authHeaders,
@@ -117,9 +129,10 @@ export async function fetchModelMeta(
         const b = (await modelRes.json()) as Record<string, any>;
         // OpenAI /v1/models/{id} does not return token limits, but some proxies
         // add custom fields like max_context_length or max_model_tokens.
-        metaContext =
-          b.max_context_length ?? b.max_input_tokens ?? b.context_window ?? b.max_tokens;
-        metaMaxTokens = b.max_output_tokens ?? b.max_completion_tokens ?? metaContext;
+        effortLevels ??= metadataEfforts(b);
+        if (typeof b.reasoning === "boolean") metaReasoning ??= b.reasoning;
+        metaContext ??= b.max_context_length ?? b.max_input_tokens ?? b.context_window ?? b.max_tokens;
+        metaMaxTokens ??= b.max_output_tokens ?? b.max_completion_tokens;
       }
     } catch {
       // Endpoint not supported — ignore.
@@ -140,7 +153,7 @@ export async function fetchModelMeta(
           if (!entry) continue;
           metaContext = entry.max_input_tokens ?? entry.max_tokens;
           metaMaxTokens = entry.max_output_tokens ?? entry.max_tokens;
-          metaReasoning =
+          metaReasoning ??=
             entry.mode === "reasoning" || entry.reasoning === true || heuristicReasoning;
           if (entry.input_cost_per_token > 0 || entry.output_cost_per_token > 0) {
             metaInput = entry.supports_vision ? ["text", "image"] : ["text"];
@@ -165,7 +178,8 @@ export async function fetchModelMeta(
   return {
     contextWindow: metaContext,
     maxTokens: metaMaxTokens,
-    reasoning: metaReasoning,
+    reasoning: effortLevels?.some(level => level !== "off") ? true : metaReasoning,
+    effortLevels,
     input: metaInput,
   };
 }

package/extensions/lib/picker-dialog.ts

@@ -0,0 +1,21 @@
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { Container, Text } from "@earendil-works/pi-tui";
+import { ModelPicker, type PickerAction, type RankedModel } from "./picker.ts";
+
+export async function pickerDialog(ctx: any, rows: RankedModel[], title = "Better Model Select", assignment = false): Promise<PickerAction | undefined> {
+  return ctx.ui.custom((tui: any, theme: any, _kb: any, done: any) => {
+    const container = new Container();
+    const accent = (text: string) => typeof theme?.fg === "function" ? theme.fg("accent", text) : text;
+    container.addChild(new DynamicBorder(accent));
+    container.addChild(new Text(accent(title), 1, 0));
+    const picker = new ModelPicker(rows, theme, () => tui.requestRender(), done, assignment);
+    picker.focused = true;
+    container.addChild(picker);
+    container.addChild(new DynamicBorder(accent));
+    return {
+      render: (width: number) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data: string) => picker.handleInput(data),
+    };
+  });
+}

package/extensions/lib/picker.ts

@@ -19,9 +19,12 @@ import { loadUsage, usageKey, type ModelsConfig } from "./store.ts";
 
 export type PickerAction =
   | { kind: "load"; provider: string; modelId: string }
+  | { kind: "set-default"; provider: string; modelId: string }
+  | { kind: "defaults" }
   | { kind: "add" }
   | { kind: "update"; provider?: string; modelId?: string }
   | { kind: "delete"; provider?: string; modelId?: string }
+  | { kind: "options" }
   | { kind: "reset" }
   | { kind: "close" };
 
@@ -33,16 +36,23 @@ export interface RankedModel {
   lastUsed: number;
   contextWindow?: number;
   reasoning: boolean;
+  current?: boolean;
+  default?: boolean;
 }
 
 /**
  * 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({
@@ -71,6 +81,8 @@ function formatContext(n?: number): string {
 
 export function toSelectItem(row: RankedModel): SelectItem {
   const bits: string[] = [row.modelId, `[${row.provider}]`];
+  if (row.current) bits.push("[current]");
+  if (row.default) bits.push("[default]");
   const ctxLabel = formatContext(row.contextWindow);
   if (ctxLabel) bits.push(`ctx ${ctxLabel}`);
   if (row.reasoning) bits.push("reasoning");
@@ -103,7 +115,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+d default  •  ctrl+g agent defaults  •  ctrl+o options  •  ctrl+r reset  •  esc close";
 
 export class ModelPicker extends Container implements Focusable {
   private search: Input;
@@ -117,6 +129,7 @@ export class ModelPicker extends Container implements Focusable {
   private theme: any;
   private onChange: () => void;
   private done: (action: PickerAction) => void;
+  private assignment: boolean;
 
   private _focused = false;
   get focused(): boolean {
@@ -133,11 +146,13 @@ export class ModelPicker extends Container implements Focusable {
     theme: any,
     onChange: () => void,
     done: (action: PickerAction) => void,
+    assignment = false,
   ) {
     super();
     this.theme = theme;
     this.onChange = onChange;
     this.done = done;
+    this.assignment = assignment;
     this.rows = rows;
     this.filtered = rows;
 
@@ -157,7 +172,7 @@ export class ModelPicker extends Container implements Focusable {
     this.list = this.buildList(rows);
 
     this.countText = new Text(fg("dim", this.countLabel()), 1, 0);
-    this.hintText = new Text(fg("dim", HINT), 1, 0);
+    this.hintText = new Text(fg("dim", assignment ? "↑↓ move  •  enter assign  •  esc back" : HINT), 1, 0);
 
     this.addChild(this.search);
     this.addChild(this.list);
@@ -228,7 +243,15 @@ export class ModelPicker extends Container implements Focusable {
 
   handleInput(data: string): void {
     if (matchesKey(data, "escape")) return this.done({ kind: "close" });
+    if (!this.assignment && matchesKey(data, "ctrl+g")) return this.done({ kind: "defaults" });
+    if (!this.assignment && matchesKey(data, "ctrl+d")) {
+      const row = this.currentRow();
+      if (row) this.done({ kind: "set-default", provider: row.provider, modelId: row.modelId });
+      return;
+    }
+    if (this.assignment && ["ctrl+a", "ctrl+o", "ctrl+r", "ctrl+u", "ctrl+x", "ctrl+d", "ctrl+g"].some(key => matchesKey(data, key as any))) return;
     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 ?? {};
@@ -100,11 +146,13 @@ export function mergeConfigs(base: ModelsConfig, local: ModelsConfig): ModelsCon
 export function loadConfig(ctx: {
   ui: { notify: (m: string, l: string) => void };
 }): ModelsConfig | null {
-  const base = loadConfigFile(ctx, "models.json");
+  const base = loadConfigFile(ctx, "models.json", true);
   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,14 +1,17 @@
 {
   "name": "pi-better-model-select",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "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.",
+  "description": "Searchable, usage-ranked model picker for Pi with model management, default model and thinking effort selection, and per-role subagent defaults.",
   "keywords": [
     "pi-package",
     "pi-extension",
     "bms",
     "model-select",
     "model-manager",
+    "model-defaults",
+    "thinking-effort",
+    "subagents",
     "model-picker",
     "search",
     "fuzzy",
@@ -22,6 +25,8 @@
     "extensions/",
     "!extensions/**/*.test.ts",
     "README.md",
+    "docs/configuration.md",
+    "docs/development.md",
     "LICENSE"
   ],
   "pi": {
@@ -31,6 +36,7 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
+    "test:smoke": "python3 scripts/smoke-local.py",
     "test": "node --experimental-strip-types --test extensions/lib/*.test.ts",
     "check:pack": "npm pack --dry-run --ignore-scripts >/dev/null",
     "gate": "npm run typecheck && npm test && npm run check:pack"