pi-better-model-select 0.1.3 → 0.2.0

package/README.md

@@ -1,12 +1,6 @@
 # pi-better-model-select
 
-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
-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.
+A searchable model picker for [Pi](https://pi.dev). Switch models, edit model definitions, and save default models and thinking effort. Models you pick most often appear first.
 
 ## Install
 
@@ -14,108 +8,82 @@ search box.
 pi install npm:pi-better-model-select
 ```
 
-If you installed the package under its old name, migrate with:
+Run `/bms`, type to filter by name, model ID, or provider, then press Enter to switch models for the current session.
 
-```bash
-pi remove npm:@msenebald/better-model-select
-pi install npm:pi-better-model-select
-```
+## Commands and shortcuts
+
+| Command | Action |
+| --- | --- |
+| `/bms` | Open the model picker |
+| `/bms-add` | Add a model |
+| `/bms-defaults` | Configure Pi and subagent defaults |
 
-## Commands
+Inside `/bms`:
 
-| Command    | What it does                                        |
-| ---------- | --------------------------------------------------- |
-| `/bms`     | Open the searchable, usage-ranked picker            |
-| `/bms-add` | Jump straight to the add-a-model flow               |
+| Key | Action |
+| --- | --- |
+| ↑ / ↓ | Move through models |
+| Enter | Use the selected model for this session |
+| Ctrl+D | Choose effort, save as the Pi default, and use it now |
+| Ctrl+G | Open the defaults menu |
+| Ctrl+A / Ctrl+U / Ctrl+X | Add / update / delete a model |
+| Ctrl+O | Set write mode and provider filters |
+| Ctrl+R | Reset usage ranking |
+| Esc | Close |
 
-## Keys
+The picker marks the active model with `[current]` and the saved startup model with `[default]`. Only Enter selections count toward usage ranking.
 
-| Key        | Action                                              |
-| ---------- | --------------------------------------------------- |
-| `↑` `↓`    | Move through the list                               |
-| *type*     | Fuzzy filter by display name, model id or provider  |
-| `enter`    | Load the highlighted model                          |
-| `ctrl+a`   | Add a model                                         |
-| `ctrl+u`   | Update the highlighted model                        |
-| `ctrl+x`   | Delete the highlighted model                        |
-| `ctrl+r`   | Reset usage statistics                              |
-| `esc`      | Close                                               |
+## Default models and effort
 
-## Ranking
+New in BMS `0.2.0`: save a model and thinking effort for Pi, a subagent fallback, or an individual agent role.
 
-Every model loaded through `/bms` increments a counter in
-`<agent-dir>/bms-usage.json`. The list sorts by count, then by most recent use,
-then alphabetically — so an unused config starts in plain alphabetical order and
-drifts toward your habits.
+- Use Ctrl+D in `/bms` for the main Pi default.
+- Use `/bms-defaults` for all defaults. The menu starts in user scope; select the scope row to switch to a trusted project's settings.
+- Agent model and effort overrides are independent. You can inherit the parent model while choosing a different effort.
 
-Only `/bms` selections count. Switching via `/model`, `ctrl+p` cycling, or a
-session restore does not, which keeps the ranking a record of deliberate choices
-rather than of how often you restart pi.
+Removing an override restores the agent's own definition and fallback rules. Effort `off` is explicit, not inheritance. The menu shows saved settings and their sources, not running-child state.
 
-Stats for models that disappear from the effective configuration are pruned
-when the picker opens. `ctrl+r` clears everything.
+Run `/reload` after changing agent defaults or per-model effort preferences. Existing children stay unchanged. Test Pi startup defaults in a fresh session, since resumed sessions restore their recorded model and effort.
 
-## Metadata discovery
+### Optional pi-subagents integration
 
-When adding or updating, the extension tries to fill in context window, output
-cap, reasoning support and input modalities from, in order:
+[pi-subagents](https://github.com/nicobailon/pi-subagents) is a separate extension. Install it only if you want subagents:
 
-1. `GET {baseUrl}/model/info` — LiteLLM proxies
-2. `GET {baseUrl}/models/{id}` — OpenAI-style, plus proxy-specific fields
-3. The public LiteLLM model cost map on GitHub
+```bash
+pi install npm:pi-subagents
+```
 
-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
-write so a concurrent edit in another pi session is not clobbered.
+BMS discovers its agent roles and edits their saved model and effort defaults. It does not install `pi-subagents` automatically. External runner roles are read-only because their model settings belong to the runner.
 
-## Paths
+Discovery has now been checked with **pi-subagents `0.82.1`**, updated from the original `0.79.0` test. BMS handles the newer bundled entry-point layout. The adapter still uses internal modules, so future package changes may require an update. If discovery fails, **Agent discovery details** shows the error. Pi defaults work without this integration.
 
-All files resolve through pi's `getAgentDir()`, so `PI_CODING_AGENT_DIR` and
-rebranded distributions work without special handling:
+### Supported effort levels
 
-- `<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>/bms-usage.json` stores selection counters.
+BMS uses provider-reported effort lists when available and Pi's capability restrictions where supplied. Otherwise it offers Pi's standard levels, marked as provider support unverified:
 
-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.
+```text
+off · minimal · low · medium · high · xhigh · max
+```
 
-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.
+Add/update also lets you edit supported levels and set a per-model preferred effort. These hints do not change Pi's provider adapters. If Pi clamps an effort, BMS asks before saving the applied level. No paid model probes are made.
 
-Writes are atomic using a temporary file and rename, so an interrupted write
-cannot truncate either configuration file.
+## Where changes are saved
 
-## Development
+Ctrl+O selects the model write mode:
 
-```bash
-npm install
-npm run typecheck
-node --experimental-strip-types --test extensions/lib/picker.test.ts
-pi -e . -p "say OK"      # load the extension without installing it
-```
+| Mode | Behavior |
+| --- | --- |
+| Overlay, the default | Save model edits in `models.bms.json`; leave `models.json` unchanged |
+| Direct | Write model edits to Pi's `models.json` |
 
-## Publishing
+Defaults always go into native Pi `settings.json`, regardless of write mode. User files normally live in `~/.pi/agent`; project defaults use `.pi/settings.json`. BMS respects `PI_CODING_AGENT_DIR` and shows the selected settings paths.
 
-Set the new version in `package.json` and `package-lock.json`, then run:
+Provider filters hide entries only in `/bms`, not Pi's `/model` picker. Default-assignment menus also include authenticated Pi registry models.
 
-```bash
-make publish
-```
+## Further documentation
 
-The target runs the full package gate, checks npm authentication, opens npm's
-browser login when needed, skips the upload if that exact version already
-exists, publishes the public scoped package, and waits for npm to expose the
-new version. npm can take several minutes to process a package. If verification
-times out, rerun `make verify-publish`; do not publish the same version again.
+- [Configuration reference](https://g.han.zone/msenebald/pi-better-model-select/src/branch/main/docs/configuration.md): file paths, precedence, overlays, metadata, and integration limits.
+- [Development and testing](https://g.han.zone/msenebald/pi-better-model-select/src/branch/main/docs/development.md): local loading, isolated tests, checks, and publishing.
 
 ## License
 

package/docs/configuration.md

@@ -0,0 +1,105 @@
+# Configuration reference
+
+See the [README](../README.md) for installation and shortcuts.
+
+## Files
+
+`<agent-dir>` is normally `~/.pi/agent`. BMS uses Pi's `getAgentDir()`, so it respects `PI_CODING_AGENT_DIR`.
+
+| File | Contents |
+| --- | --- |
+| `<agent-dir>/models.json` | Pi model definitions |
+| `<agent-dir>/models.bms.json` | BMS model overlay |
+| `<agent-dir>/bms-settings.json` | Write mode and provider filters |
+| `<agent-dir>/bms-usage.json` | Selection counts and recency |
+| `<agent-dir>/bms-model-metadata.json` | Effort capability hints and their source |
+| `<agent-dir>/settings.json` | User defaults and per-model effort preferences |
+| `<project>/.pi/settings.json` | Project defaults |
+
+## Model write modes
+
+Choose the write mode through Ctrl+O in `/bms`.
+
+- Overlay mode, the default, leaves `models.json` unchanged and writes edits to `models.bms.json`.
+- Direct mode writes add, update, and delete operations to `models.json`.
+
+Pi does not load the overlay itself. BMS merges it over `models.json` by provider and model ID, then registers the merged providers through Pi's extension API. Overlay fields win for duplicate models. BMS automatically renames its old `models.local.json` overlay to `models.bms.json`.
+
+Deleting an inherited model in overlay mode writes a tombstone:
+
+```json
+{ "id": "model-id", "bmsDeleted": true }
+```
+
+Remove that entry from `models.bms.json` to restore the inherited model. Model files are re-read before writes and saved through a temporary file and rename. This does not provide a shared lock against other applications.
+
+Provider filters affect only `/bms`. They do not change Pi's `/model` picker or model definitions. Default-assignment menus ignore the filters and also include authenticated Pi registry models.
+
+## Defaults and precedence
+
+Default settings are independent of the model write mode.
+
+| Setting | Native Pi settings field |
+| --- | --- |
+| Pi model | `defaultProvider`, `defaultModel` |
+| Pi effort | `defaultThinkingLevel` |
+| Per-model preferred effort | `modelThinkingLevels["provider/model"]` |
+| Subagent fallback | `subagents.defaultModel`, `subagents.defaultThinking` |
+| Role override | `subagents.agentOverrides.<name>.model` and `.thinking` |
+
+The defaults menu starts in user scope. Project scope requires a trusted project. Pi defaults use the working directory's `.pi/settings.json`. Agent defaults use the project root resolved by `pi-subagents`, which may differ in nested repositories. The menu shows the paths.
+
+Project settings and provider-specific role overrides may take precedence. BMS shows override sources and warns when a saved Pi default would be shadowed. Saving a Pi default removes the selected model's per-model effort preference in the same scope, so it cannot override the new default.
+
+For agent roles:
+
+- **Inherit parent model** writes `model: "inherit"`.
+- **Remove model override** restores agent-definition and fallback rules.
+- **Automatic** or **Remove effort override** removes that scope's effort preference. It does not force parent effort inheritance. `pi-subagents` has no separate persistent setting for that.
+- **Off** is an explicit effort level, not inheritance.
+
+Changing the Pi default also switches the main session. Subagent assignments do not switch it or increment usage counts. Cancelled or failed model switches leave saved defaults unchanged. If Pi clamps an effort, BMS asks before saving the applied level.
+
+Run `/reload` after changing agent defaults or per-model effort preferences. Running children keep their existing configuration, and subagent model-scope policies still apply at launch. Resumed Pi sessions restore their recorded model and effort. Test startup defaults in a fresh session without CLI model or effort overrides.
+
+Settings writes preserve unrelated fields, reject malformed JSON, and use atomic rename. A `.bms-lock` file serializes BMS settings writers only. After a crash, remove a stale lock only after checking that no BMS writer is active. Updates across model definitions, settings, and capability metadata are not a multi-file transaction.
+
+## Effort levels and metadata
+
+BMS uses explicit provider effort lists when supplied, then native Pi capability restrictions where available. Otherwise it offers Pi's standard levels and labels provider support as unverified:
+
+```text
+off, minimal, low, medium, high, xhigh, max
+```
+
+The metadata adapter recognizes `supported_reasoning_efforts`, `supported_thinking_levels`, and `reasoning_efforts` containing Pi effort names. A generic reasoning flag or `supported_parameters: ["reasoning_effort"]` does not specify supported levels.
+
+Add/update lets you edit the available levels and choose an optional per-model preferred effort. Non-reasoning models offer only `off`; correct the reasoning flag first if the endpoint metadata is wrong. BMS makes no paid model probes.
+
+Capability hints guide menus. They do not change provider adapters or prove an endpoint honors a level. Pi may clamp effort or map it to a token budget. Provider errors remain visible rather than triggering a model fallback.
+
+BMS blocks capability edits that conflict with directly pinned defaults in the inspected user/project settings. Update those defaults first. This check does not audit every inherited agent definition or settings file elsewhere on disk.
+
+When adding or updating models, BMS tries these metadata sources in order:
+
+1. `GET {baseUrl}/model/info` for LiteLLM proxies.
+2. `GET {baseUrl}/models/{id}` for OpenAI-style and proxy-specific fields.
+3. The public LiteLLM model cost map on GitHub.
+
+These requests are best-effort. Missing metadata falls back to name-based heuristics and editable defaults for context window, output limit, reasoning support, and input types.
+
+## Optional pi-subagents integration
+
+[pi-subagents](https://github.com/nicobailon/pi-subagents) is a separate Pi extension. BMS configures its saved model and effort defaults; it does not install it or launch agents to discover roles.
+
+Discovery was originally tested with `0.79.0` and has now been checked against `0.82.1`. BMS supports both the older root entry point and the newer `bundle/index.js` package layout. Discovery still uses internal discovery/runtime modules because the public agents API does not expose role discovery. Future incompatible versions may need an adapter update.
+
+The package must be resolvable from BMS or `<agent-dir>/npm/node_modules`. Discovery includes built-in, package, user, project, and runtime roles when supported by the installed API. Untrusted project agents and settings are excluded. External runner roles are shown read-only; configure their models through the runner's own settings.
+
+If discovery fails, the menu offers **Agent discovery details** with the error. Main Pi defaults remain usable.
+
+## Usage ranking
+
+Only models loaded with Enter in `/bms` count toward ranking. BMS sorts by selection count, then recency, then alphabetically. Default assignments, `/model`, model cycling, and session restores do not count.
+
+BMS prunes statistics for models missing from the effective configuration when the picker opens. Ctrl+R clears all usage statistics.

package/docs/development.md

@@ -0,0 +1,104 @@
+# Development and testing
+
+Run these commands from the repository checkout:
+
+```bash
+npm ci
+npm run gate
+npm run test:smoke  # optional: installed Pi, Python 3 and a POSIX PTY required
+pi --no-extensions -e ./extensions/bms.ts  # temporary load; no install or publish
+```
+
+## Temporary local testing
+
+Use a fresh terminal in this checkout. The command above disables installed
+extensions to avoid loading two copies of BMS. It still uses your real Pi settings,
+so default changes persist. For an isolated test, use a scratch agent directory
+and project directory instead:
+
+```bash
+REPO="$PWD"
+SANDBOX="$(mktemp -d -t bms-local)"
+mkdir -p "$SANDBOX/agent" "$SANDBOX/project/.pi"
+printf '{}\n' > "$SANDBOX/project/.pi/settings.json"
+# Optional: copy your model definitions. Review literal credentials in this file.
+cp "${PI_CODING_AGENT_DIR:-$HOME/.pi/agent}/models.json" "$SANDBOX/agent/models.json"
+cd "$SANDBOX/project"
+PI_CODING_AGENT_DIR="$SANDBOX/agent" pi --no-extensions -e "$REPO/extensions/bms.ts"
+```
+
+Provider API-key environment variables remain available. The isolated directory
+has no login credentials; use `/login` there if needed. Do not commit credentials
+or scratch settings. To test agent roles, load your installed pi-subagents entry
+explicitly with another `-e` and make the package resolvable in the scratch agent's
+`npm/node_modules`, or use your real agent directory with backups. For the standard
+Pi npm install layout with pi-subagents 0.82.1, before launching:
+
+```bash
+REAL_AGENT="${PI_CODING_AGENT_DIR:-$HOME/.pi/agent}"
+ln -s "$REAL_AGENT/npm" "$SANDBOX/agent/npm"
+PI_CODING_AGENT_DIR="$SANDBOX/agent" pi --no-extensions \
+  -e "$REPO/extensions/bms.ts" -e "$REAL_AGENT/npm/node_modules/pi-subagents/bundle/index.js"
+```
+
+This symlinks installed package code, not your settings or auth files. Do not run
+package installation/update commands in this sandbox, since they would modify the
+shared package directory.
+
+The automated `npm run test:smoke` uses an unreachable dummy endpoint and
+throwaway settings. It checks command registration, the real TUI default-save
+flow, the defaults shortcut, and restoration in a fresh Pi process. No model
+prompts are sent. The regular test suite uses mocked provider metadata and UI.
+
+Manual checks:
+
+1. `/bms`: filter and use Enter. Only the current session should change.
+2. Reopen `/bms`, press Ctrl+D, choose effort and confirm. Check both markers,
+   the footer effort, and the scratch `agent/settings.json`.
+3. Cancel the effort dialog and confirmation. Neither should change defaults.
+4. `/bms-defaults`: select a Pi model, then select the same model again to change
+   only its default effort. Test user and trusted-project scope.
+5. Configure a subagent fallback and a role model/effort. Confirm the parent
+   session stays unchanged. Test explicit model inheritance and removal of each
+   override, then `/reload` and inspect `/subagents-models reviewer`.
+6. Add/update a model. Check provider-reported effort lists, the unverified Pi
+   fallback, manual levels, and the preferred effort. Try removing a level that
+   a directly pinned default uses; BMS should block the conflicting edit.
+7. Exit and start a fresh Pi session with the same scratch paths. Confirm startup
+   model and effort. Do not use `--continue`, `--resume`, or CLI model/effort overrides.
+8. Test a narrow terminal and verify the list, wrapped hints, and search still work.
+
+Quit Pi before deleting the sandbox with `rm -rf "$SANDBOX"`, then return to the
+checkout with `cd "$REPO"`. The test commands do not publish or install BMS.
+
+## Publishing
+
+Publish from `main` after the feature PR is reviewed and merged. Do not publish from the unmerged feature branch.
+
+For the current `0.2.0` release:
+
+```bash
+git switch main
+git pull --ff-only origin main
+npm ci
+npm run gate
+npm run test:smoke
+npm pack --dry-run
+```
+
+Check that the working tree is clean, both package manifests say `0.2.0`, and the package contains `README.md`, `docs/configuration.md`, and `docs/development.md`. Tests and the internal PR draft must not be included. The README links point to `main`, so merge the documentation before publishing.
+
+Then publish to the public npm registry:
+
+```bash
+make publish
+```
+
+For later releases, update both manifests with `npm version <version> --no-git-tag-version`, and include that change in a reviewed PR before publishing.
+
+The target runs the full package gate, checks npm authentication, opens npm's
+browser login when needed, skips the upload if that exact version already
+exists, publishes the public package, and waits for npm to expose the
+new version. npm can take several minutes to process a package. If verification
+times out, rerun `make verify-publish`; do not publish the same version again.
+

package/extensions/bms.ts

@@ -4,15 +4,19 @@
 // with add / update / delete wired to ctrl-chords so plain typing always goes
 // to the search box.
 
-import { DynamicBorder, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Container, Text } from "@earendil-works/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { defaultsFlow, piPreference, setMainDefault } from "./lib/defaults.ts";
+import { readSettings, settingsPath } from "./lib/defaults-store.ts";
+import { pickerDialog } from "./lib/picker-dialog.ts";
 import { addFlow, deleteFlow, updateFlow, type FlowCtx } from "./lib/flows.ts";
-import { ModelPicker, rankModels, type PickerAction } from "./lib/picker.ts";
+import { rankModels } from "./lib/picker.ts";
 import {
   loadConfig,
   loadConfigFile,
+  loadSettings,
   pruneUsage,
   recordUsage,
+  saveSettings,
   saveUsage,
   type ModelEntry,
   type ModelsConfig,
@@ -47,11 +51,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 +68,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 +79,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,
@@ -115,6 +167,23 @@ export default function (pi: ExtensionAPI) {
     syncLocalConfig(pi, ctx);
   });
 
+  const report = async (ctx: any, action: () => Promise<void>) => {
+    try { await action(); } catch (error) { ctx.ui.notify(`BMS: ${error}`, "error"); }
+  };
+  const addModel = async (ctx: any) => addFlow(ctx, async (provider, modelId) => {
+    if (syncLocalConfig(pi, ctx)) await report(ctx, () => setMainDefault(pi, ctx, provider, modelId));
+  });
+  pi.registerCommand("bms-defaults", {
+    description: "Configure Pi and subagent default models and effort levels",
+    handler: async (_args, ctx: any) => {
+      if (ctx.mode !== "tui") { ctx.ui.notify("/bms-defaults needs an interactive terminal.", "warning"); return; }
+      await report(ctx, async () => {
+        const config = syncLocalConfig(pi, ctx);
+        if (config) await defaultsFlow(pi, ctx, config);
+      });
+    },
+  });
+
   pi.registerCommand("bms", {
     description: "Better model select — searchable, usage-ranked model picker",
     handler: async (_args, ctx: any) => {
@@ -129,48 +198,52 @@ 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?",
           );
           if (!add) return;
-          await addFlow(ctx as FlowCtx);
+          await report(ctx, () => addModel(ctx));
           continue;
         }
 
-        const action: PickerAction | undefined = await ctx.ui.custom((tui: any, theme: any, _kb: any, done: any) => {
-          const container = new Container();
-          const accent = (s: string) =>
-            typeof theme?.fg === "function" ? theme.fg("accent", s) : s;
-
-          container.addChild(new DynamicBorder(accent));
-          container.addChild(new Text(accent("Better Model Select"), 1, 0));
-
-          const picker = new ModelPicker(
-            rows,
-            theme,
-            () => tui.requestRender(),
-            (a: PickerAction) => done(a),
-          );
-          picker.focused = true;
-          container.addChild(picker);
-          container.addChild(new DynamicBorder(accent));
-
-          return {
-            render: (w: number) => container.render(w),
-            invalidate: () => container.invalidate(),
-            handleInput: (data: string) => picker.handleInput(data),
-          };
-        });
+        try {
+          const preference = piPreference(readSettings(settingsPath(ctx.cwd, "user")), ctx.isProjectTrusted?.() ? readSettings(settingsPath(ctx.cwd, "project")) : {});
+          for (const row of rows) {
+            row.current = ctx.model?.provider === row.provider && ctx.model?.id === row.modelId;
+            row.default = preference.provider === row.provider && preference.model === row.modelId;
+          }
+        } catch (error) { ctx.ui.notify(`Cannot read defaults: ${error}`, "warning"); }
+        const action = await pickerDialog(ctx, rows);
 
         switch (action?.kind) {
           case "load":
             await loadModel(pi, ctx, action.provider, action.modelId);
             return;
+          case "set-default":
+            await report(ctx, () => setMainDefault(pi, ctx, action.provider, action.modelId));
+            break;
+          case "defaults":
+            await report(ctx, () => defaultsFlow(pi, ctx, config));
+            break;
           case "add":
-            await addFlow(ctx as FlowCtx);
+            await report(ctx, () => addModel(ctx));
             break;
           case "update":
             await updateFlow(
@@ -188,6 +261,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 +284,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",
-    handler: async (_args, ctx: any) => addFlow(ctx as FlowCtx),
+    description: "Add a model from a provider's endpoint using the configured write mode",
+    handler: async (_args, ctx: any) => report(ctx, () => addModel(ctx)),
   });
 }