pi-better-model-select 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+## 0.3.1
+
+### Fixed
+
+- Included the README's showcase GIF in the npm package without shipping the other demo assets.
+- Restored the Ctrl+D set-default hint on the main model search screen, including at 80-column widths.
+- Accepting "Save and use anyway" now saves without asking for confirmation again. Default-save messages show the settings path and identify any startup override that remains.
+
+## 0.3.0
+
+### Added
+
+- `/bms-options` for direct access to result placement, write mode, and provider visibility.
+- Above-prompt result placement, with the best match nearest search. Below-prompt placement remains the default.
+- Ctrl+O Actions menu with access to model management, defaults, options, and usage reset.
+- Visible **Save configuration** and **Back** actions in forms, alongside Ctrl+S and Esc.
+
+### Changed
+
+- Replaced the model list with aligned MODEL, PROVIDER, CONTEXT, USES, and STATUS columns, a full-row selection highlight, and up to six visible results.
+- Moved search into a prompt-style field in Pi's editor area. Shortcut hints and the result count follow result placement.
+- Replaced model-edit questionnaires with draft forms. Changes are saved explicitly; leaving a modified form asks whether to discard them.
+- Organized Pi and subagent defaults into a table with model, effort, and source information.
+- Preserved search and selection across submenus. Returning from an Actions submenu restores the selected action.
+- Kept non-search menus top-to-bottom regardless of result placement.
+- Styled shortcut keys separately from action descriptions and omitted whole hints at narrow widths.
+- Made destructive confirmations cancel-first and explicit about write scope.
+
+### Fixed
+
+- Restored the same form draft and selection after closing a child dialog, without losing it when Pi restores its editor.
+
+## 0.2.0
+
+### Added
+
+- Default model and thinking effort configuration for Pi, the subagent fallback, and individual agent roles.
+- `/bms-defaults`, Ctrl+D for the Pi default, and Ctrl+G for the defaults menu.
+- User/project scope selection, effective-value sources, and warnings about higher-priority overrides.
+- Provider-reported effort capability hints, editable supported levels, and per-model preferred effort.
+- Active-model and saved-default markers in the picker.
+
+### Fixed
+
+- Discovery of pi-subagents roles with the newer bundled entry-point layout, checked against pi-subagents 0.82.1 after the original 0.79.0 integration.
+
+## 0.1.4
+
+- Added BMS options and provider filters.
+
+## 0.1.3
+
+- Renamed the package to `pi-better-model-select`.
+
+## 0.1.2
+
+- Persisted deletion of inherited models in the personal overlay.
+
+## 0.1.1
+
+- Added a personal model overlay so local edits can remain separate from Pi's model configuration.

package/README.md

@@ -10,12 +10,21 @@ pi install npm:pi-better-model-select
 
 Run `/bms`, type to filter by name, model ID, or provider, then press Enter to switch models for the current session.
 
+## Compact TUI
+
+![BMS model search, forms, defaults, and result placement](docs/demo/showcase.gif)
+
+The picker uses aligned model, provider, context, usage, and status columns. Type in the search field in Pi's editor area. Results appear below search by default, matching Pi command completion. Choose **Options → Result placement → Above prompt** for bottom-up results with the best match nearest the search line.
+
+Add and edit use one form. Review the fields, press Enter to change a value, then choose **Save configuration** or press Ctrl+S to save. Text and numeric fields currently open a Pi input dialog; choices use the compact table. Esc goes back; unsaved changes require a discard confirmation. Options also stay in a draft until saved.
+
 ## Commands and shortcuts
 
 | Command | Action |
 | --- | --- |
 | `/bms` | Open the model picker |
 | `/bms-add` | Add a model |
+| `/bms-options` | Open result placement, write mode, and provider options |
 | `/bms-defaults` | Configure Pi and subagent defaults |
 
 Inside `/bms`:
@@ -27,15 +36,15 @@ Inside `/bms`:
 | 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+O | Open actions, including options and defaults |
 | Ctrl+R | Reset usage ranking |
 | Esc | Close |
 
-The picker marks the active model with `[current]` and the saved startup model with `[default]`. Only Enter selections count toward usage ranking.
+The status column identifies the active model and saved default. Only Enter selections count toward usage ranking. Returning from a submenu preserves your search and selection. Plain menus always browse top-to-bottom; only searchable result lists reverse in above-prompt mode. Esc goes back one level, including back to Actions when that is where you entered a submenu.
 
 ## Default models and effort
 
-New in BMS `0.2.0`: save a model and thinking effort for Pi, a subagent fallback, or an individual agent role.
+Save a model and thinking effort for Pi, a subagent fallback, or an individual agent role.
 
 - 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.
@@ -55,7 +64,7 @@ pi install npm:pi-subagents
 
 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.
 
-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.
+If discovery fails, **Agent discovery details** shows the error. Pi defaults work without this integration. See the configuration reference for compatibility details.
 
 ### Supported effort levels
 
@@ -69,7 +78,7 @@ Add/update also lets you edit supported levels and set a per-model preferred eff
 
 ## Where changes are saved
 
-Ctrl+O selects the model write mode:
+Open Ctrl+O → Options to select the model write mode:
 
 | Mode | Behavior |
 | --- | --- |
@@ -82,8 +91,9 @@ Provider filters hide entries only in `/bms`, not Pi's `/model` picker. Default-
 
 ## Further documentation
 
-- [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.
+- [Changelog](CHANGELOG.md): changes by version.
+- [Configuration reference](docs/configuration.md): file paths, precedence, overlays, metadata, and integration limits.
+- [Development and testing](docs/development.md): local loading, isolated tests, checks, and publishing.
 
 ## License
 

package/docs/configuration.md

@@ -10,7 +10,7 @@ See the [README](../README.md) for installation and shortcuts.
 | --- | --- |
 | `<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-settings.json` | Write mode, result placement, 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 |
@@ -18,7 +18,7 @@ See the [README](../README.md) for installation and shortcuts.
 
 ## Model write modes
 
-Choose the write mode through Ctrl+O in `/bms`.
+Choose the write mode through Ctrl+O → Options in `/bms`, then Ctrl+S to save.
 
 - 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`.
@@ -35,6 +35,12 @@ Remove that entry from `models.bms.json` to restore the inherited model. Model f
 
 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.
 
+## Picker layout
+
+`bms-settings.json` accepts `resultPlacement: "below"` or `"above"`. Missing or invalid values use `"below"`, matching Pi command completion. In above mode the best match is the bottom row, immediately above search; arrow keys follow physical screen direction. Searchable assignment menus use the same preference. Forms retain their normal top-to-bottom field order.
+
+The search field is part of a temporary custom interaction in Pi's editor area. BMS does not replace the normal editor factory. Enter loads the selected model; Esc returns to the editor. Up to six results are shown at a time, with scrolling for the rest.
+
 ## Defaults and precedence
 
 Default settings are independent of the model write mode.

package/extensions/bms.ts

@@ -8,6 +8,7 @@ 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 { confirmAction, editForm, tableSelect } from "./lib/tui.ts";
 import { addFlow, deleteFlow, updateFlow, type FlowCtx } from "./lib/flows.ts";
 import { rankModels } from "./lib/picker.ts";
 import {
@@ -78,51 +79,50 @@ function syncLocalConfig(pi: ExtensionAPI, ctx: any): ModelsConfig | null {
   return effective;
 }
 
-/** Re-read model configuration from disk and switch the session to the given model. */
+/** Stage option changes until the user explicitly saves. */
 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);
-    }
-  }
+  const settings = loadSettings();
+  const providers = Object.keys(config.providers ?? {}).sort();
+  const writeLabel = () => settings.writeMode === "overlay" ? "BMS overlay (models.bms.json)" : "Pi config (models.json)";
+  await editForm(ctx, {
+    title: "Models / Options",
+    fields: [
+      { key: "placement", label: "Result placement", value: settings.resultPlacement === "above" ? "Above prompt" : "Below prompt",
+        description: "The best match stays nearest the search line. Arrow keys follow the displayed direction.",
+        edit: async () => {
+          const value = await tableSelect(ctx, { title: "Models / Options / Result placement", initialValue: settings.resultPlacement,
+            rows: [{ value: "below", label: "Below prompt", description: "Pi-style results. Down moves into the list." }, { value: "above", label: "Above prompt", description: "Results grow upward. Up moves into the list." }] });
+          if (!value) return;
+          settings.resultPlacement = value as "above" | "below";
+          return value === "above" ? "Above prompt" : "Below prompt";
+        } },
+      { key: "write", label: "Write mode", value: writeLabel(),
+        description: "Overlay keeps BMS edits separate from models.json. Direct mode edits Pi's model configuration.",
+        edit: async () => {
+          const value = await tableSelect(ctx, { title: "Models / Options / Write mode", initialValue: settings.writeMode,
+            rows: [{ value: "overlay", label: "BMS overlay", description: "models.bms.json" }, { value: "direct", label: "Pi config", description: "models.json" }] });
+          if (!value) return;
+          settings.writeMode = value as "overlay" | "direct";
+          return writeLabel();
+        } },
+      { key: "providers", label: "Providers", value: `${providers.filter(p => !settings.disabledProviders.includes(p)).length} enabled`,
+        description: "Choose a provider to toggle visibility. Esc returns to options; Ctrl+S saves the complete draft.",
+        edit: async () => {
+          let selected: string | undefined;
+          for (;;) {
+            selected = await tableSelect(ctx, { title: "Models / Options / Providers", initialValue: selected, search: true, placement: settings.resultPlacement,
+              rows: providers.map(provider => ({ value: provider, label: `${settings.disabledProviders.includes(provider) ? "[ ]" : "[x]"} ${provider}` })),
+              hint: "↑↓ move  Enter toggle  Esc back" });
+            if (!selected) break;
+            const disabled = new Set(settings.disabledProviders);
+            if (disabled.has(selected)) disabled.delete(selected); else disabled.add(selected);
+            settings.disabledProviders = [...disabled].sort();
+          }
+          return `${providers.filter(p => !settings.disabledProviders.includes(p)).length} enabled`;
+        } },
+    ],
+    onSave: async () => { saveSettings(settings); ctx.ui.notify("BMS options saved.", "info"); return true; },
+  });
 }
 
 async function loadModel(
@@ -173,6 +173,16 @@ export default function (pi: ExtensionAPI) {
   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-options", {
+    description: "Configure BMS result placement, write mode, and provider visibility",
+    handler: async (_args, ctx: any) => {
+      if (ctx.mode !== "tui") { ctx.ui.notify("/bms-options needs an interactive terminal.", "warning"); return; }
+      await report(ctx, async () => {
+        const config = syncLocalConfig(pi, ctx);
+        if (config) await optionsFlow(ctx, config);
+      });
+    },
+  });
   pi.registerCommand("bms-defaults", {
     description: "Configure Pi and subagent default models and effort levels",
     handler: async (_args, ctx: any) => {
@@ -192,7 +202,8 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      // Loop so the picker reappears after each add / update / delete.
+      // Preserve search and selection while opening submenus.
+      const pickerState: { query?: string; selectedValue?: string } = {};
       for (;;) {
         const config = syncLocalConfig(pi, ctx);
         if (!config) return;
@@ -230,7 +241,7 @@ export default function (pi: ExtensionAPI) {
             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);
+        const action = await pickerDialog(ctx, rows, "Models", false, { placement: settings.resultPlacement, state: pickerState });
 
         switch (action?.kind) {
           case "load":
@@ -265,10 +276,11 @@ export default function (pi: ExtensionAPI) {
             await optionsFlow(ctx, config);
             break;
           case "reset": {
-            const ok = await ctx.ui.confirm(
-              "Reset usage statistics?",
-              "Model ranking falls back to alphabetical order.",
-            );
+            const ok = await confirmAction(ctx, {
+              title: "Models / Reset usage",
+              lines: ["Clear all BMS model selection counts and last-used times.", "Ranking returns to alphabetical order. Models and defaults are unchanged."],
+              confirmLabel: "Reset usage",
+            });
             if (ok) {
               saveUsage({ version: 1, counts: {}, lastUsed: {} });
               ctx.ui.notify("Usage statistics cleared.", "info");

package/extensions/lib/defaults.ts

@@ -1,6 +1,6 @@
 import { discoverRoles, type AgentRole } from "./agents.ts";
 import { capabilities, isEffort, patchSettings, readSettings, roleField, setPiDefault, setRoleField, settingsPath, type Effort, type JsonObject, type Scope } from "./defaults-store.ts";
-import { pickerDialog } from "./picker-dialog.ts";
+import { tableSelect, editForm, confirmAction } from "./tui.ts";
 import { rankModelsForDefaults } from "./defaults-models.ts";
 import type { ModelsConfig } from "./store.ts";
 
@@ -8,7 +8,10 @@ export async function chooseEffort(ctx: any, key: string, model?: any, initial?:
   const capability = capabilities(key, model);
   const levels = [...capability.levels];
   if (isEffort(initial) && levels.includes(initial)) levels.splice(levels.indexOf(initial), 1), levels.unshift(initial);
-  return ctx.ui.select(`Effort for ${key}\n${capability.source}\nAutomatic removes this scope's preference. Pi/provider may clamp unsupported levels.`, ["automatic", ...levels]);
+  const title = `Effort for ${key}\n${capability.source}\nAutomatic removes this scope's preference. Pi/provider may clamp unsupported levels.`;
+  // Keep the public helper usable by RPC and legacy headless select mocks.
+  if (typeof ctx.ui.custom !== "function") return ctx.ui.select(title, ["automatic", ...levels]);
+  return await tableSelect(ctx, { title, initialValue: typeof initial === "string" ? initial : "automatic", rows: ["automatic", ...levels].map(value => ({ value, label: value })) }) as Effort | "automatic" | undefined;
 }
 export function piPreference(user: JsonObject, project: JsonObject): { provider?: string; model?: string; effort?: Effort; source: string } {
   const provider = project.defaultProvider ?? user.defaultProvider;
@@ -21,43 +24,58 @@ function trusted(pi: any, ctx: any): boolean {
   return typeof ctx.isProjectTrusted === "function" ? ctx.isProjectTrusted() : typeof pi.isProjectTrusted === "function" && pi.isProjectTrusted();
 }
 function projectSettings(pi: any, ctx: any, cwd: string): JsonObject { return trusted(pi, ctx) ? readSettings(settingsPath(cwd, "project")) : {}; }
+function confirmDefault(ctx: any, title: string, message: string, confirmLabel: string): Promise<boolean> {
+  return typeof ctx.ui.custom === "function"
+    ? confirmAction(ctx, { title, lines: message.split("\n"), confirmLabel })
+    : ctx.ui.confirm(title, message);
+}
 
 /** Switch first; never replace saved defaults when authentication/model selection fails. */
 export async function setMainDefault(pi: any, ctx: any, provider: string, modelId: string, scope: Scope = "user"): Promise<void> {
+  await applyMainDefault(pi, ctx, provider, modelId, scope);
+}
+async function applyMainDefault(pi: any, ctx: any, provider: string, modelId: string, scope: Scope, selectedEffort?: Effort | "automatic"): Promise<boolean> {
   if (scope === "project" && !trusted(pi, ctx)) throw new Error("Project is not trusted");
   await ctx.modelRegistry.refresh();
   const model = ctx.modelRegistry.find(provider, modelId);
   if (!model) throw new Error(`Model ${provider}/${modelId} is not in the active registry`);
   const user = readSettings(settingsPath(ctx.cwd, "user"));
   const project = projectSettings(pi, ctx, ctx.cwd);
-  const choice = await chooseEffort(ctx, `${provider}/${modelId}`, model, piPreference(user, project).effort);
-  if (choice === undefined) return;
+  const choice = selectedEffort ?? await chooseEffort(ctx, `${provider}/${modelId}`, model, piPreference(user, project).effort);
+  if (choice === undefined) return false;
   const effort = choice === "automatic" ? undefined : choice;
   const preview = structuredClone(scope === "user" ? user : project);
   setPiDefault(preview, provider, modelId, effort);
   const effective = piPreference(scope === "user" ? preview : user, scope === "project" ? preview : project);
   const shadowed = effective.provider !== provider || effective.model !== modelId || (effort !== undefined && effective.effort !== effort);
-  if (shadowed && !(await ctx.ui.confirm("Higher-priority settings", "Project or per-model settings override this preference at startup. Save and use your selection in this session anyway?"))) return;
-  if (!(await ctx.ui.confirm("Save and use Pi default?", `${provider}/${modelId}, effort ${choice}\nScope: ${scope}\n${settingsPath(ctx.cwd, scope)}`))) return;
+  const path = settingsPath(ctx.cwd, scope);
+  const key = `${provider}/${modelId}`;
+  const overridePath = settingsPath(ctx.cwd, effective.provider !== provider || effective.model !== modelId || project.modelThinkingLevels?.[key] !== undefined || (scope === "user" && project.defaultThinkingLevel !== undefined) ? "project" : "user");
+  const summary = `${provider}/${modelId}, effort ${choice}\nScope: ${scope}\nSave to: ${path}`;
+  if (shadowed) {
+    const message = `${summary}\nHigher-priority settings in ${overridePath} still apply at startup.\nSave this preference and use your selection in this session anyway?`;
+    if (!(await confirmDefault(ctx, "Higher-priority settings", message, "Save and use anyway"))) return false;
+  } else if (selectedEffort === undefined && !(await confirmDefault(ctx, "Save and use Pi default?", summary, "Save and use"))) return false;
   // Parse before changing session state. A malformed file must never be overwritten.
   readSettings(settingsPath(ctx.cwd, scope));
   const previousModel = ctx.model;
   const previousEffort = pi.getThinkingLevel();
   if (!(await pi.setModel(model))) {
     ctx.ui.notify("Could not switch model. Defaults were not changed.", "warning");
-    return;
+    return false;
   }
   const requested = effort ?? effective.effort ?? "medium";
   try {
     pi.setThinkingLevel(requested);
     const applied = pi.getThinkingLevel();
-    if (effort !== undefined && applied !== effort && !(await ctx.ui.confirm("Pi adjusted the effort", `Requested ${effort}; Pi uses ${applied}. Save ${applied} instead?`))) {
+    if (effort !== undefined && applied !== effort && !(await confirmDefault(ctx, "Pi adjusted the effort", `Requested ${effort}; Pi uses ${applied}. Save ${applied} instead?`, `Save ${applied}`))) {
       if (previousModel) await pi.setModel(previousModel);
       pi.setThinkingLevel(previousEffort);
-      return;
+      return false;
     }
     patchSettings(settingsPath(ctx.cwd, scope), data => setPiDefault(data, provider, modelId, effort === undefined ? undefined : applied));
-    ctx.ui.notify(`Using ${provider}/${modelId}, effort ${applied}. Saved ${scope} Pi default.${shadowed ? " Higher-priority startup settings still apply." : ""}`, "info");
+    ctx.ui.notify(`Using ${provider}/${modelId}, effort ${applied}. Saved ${scope} Pi default to ${path}.${shadowed ? ` Startup still uses ${effective.provider}/${effective.model}, effort ${effective.effort ?? "automatic"}, due to ${overridePath}. Edit the overriding preference to change startup behavior.` : ""}`, "info");
+    return true;
   } catch (error) {
     if (previousModel) await pi.setModel(previousModel);
     pi.setThinkingLevel(previousEffort);
@@ -73,11 +91,53 @@ function display(value: unknown): string {
 async function assignModel(ctx: any, config: ModelsConfig, title: string): Promise<{ provider: string; modelId: string } | undefined> {
   const rows = rankModelsForDefaults(config, ctx);
   if (!rows.length) { ctx.ui.notify("No models available to assign.", "warning"); return; }
-  const action = await pickerDialog(ctx, rows, title, true);
-  return action?.kind === "load" ? action : undefined;
+  const value = await tableSelect(ctx, { title, search: true, columns: [{ key: "model", label: "MODEL" }, { key: "provider", label: "PROVIDER" }], rows: rows.map((row, index) => ({ value: String(index), label: row.label, cells: { model: row.modelId, provider: row.provider } })) });
+  const row = value === undefined ? undefined : rows[Number(value)];
+  return row ? { provider: row.provider, modelId: row.modelId } : undefined;
+}
+async function editPiDefault(pi: any, ctx: any, config: ModelsConfig, scope: Scope, user: JsonObject, project: JsonObject): Promise<void> {
+  const current = piPreference(user, project);
+  let provider = current.provider, modelId = current.model;
+  let effort: Effort | "automatic" = current.effort ?? "automatic";
+  let reset = false;
+  const path = settingsPath(ctx.cwd, scope);
+  await editForm(ctx, {
+    title: "Pi session default",
+    hint: `Scope: ${scope}\n${path}\nSave switches the session after validating the model. Higher-priority settings still apply at startup.`,
+    fields: [
+      { key: "model", label: "Model", value: `${provider ?? "auto"}/${modelId ?? "auto"}`, edit: async () => {
+        const action = await tableSelect(ctx, { title: "Pi default model", rows: [{ value: "choose", label: "Choose model" }, { value: "reset", label: "Remove scope defaults", description: "Remove this scope's default model and global effort. Keep other per-model preferences." }] });
+        if (action === undefined) return;
+        if (action === "reset") {
+          if (!(await confirmAction(ctx, { title: "Reset Pi defaults?", lines: [`Scope: ${scope}`, path, "Remove defaultProvider, defaultModel and defaultThinkingLevel only. Session stays unchanged."], confirmLabel: "Reset scope defaults" }))) return;
+          reset = true; return "remove scope defaults";
+        }
+        const selected = await assignModel(ctx, config, "Choose Pi default model");
+        if (!selected) return;
+        provider = selected.provider; modelId = selected.modelId; reset = false;
+        return `${provider}/${modelId}`;
+      } },
+      { key: "effort", label: "Effort", value: effort, edit: async () => {
+        if (!provider || !modelId || reset) { ctx.ui.notify("Choose a model first.", "warning"); return; }
+        const selected = await chooseEffort(ctx, `${provider}/${modelId}`, ctx.modelRegistry.find(provider, modelId), effort);
+        if (selected === undefined) return;
+        effort = selected; return selected;
+      } },
+    ],
+    onSave: async () => {
+      if (scope === "project" && !trusted(pi, ctx)) throw new Error("Project is not trusted");
+      if (reset) {
+        patchSettings(path, data => { delete data.defaultProvider; delete data.defaultModel; delete data.defaultThinkingLevel; });
+        return true;
+      }
+      if (!provider || !modelId) { ctx.ui.notify("Choose a model first.", "warning"); return false; }
+      return applyMainDefault(pi, ctx, provider, modelId, scope, effort);
+    },
+  });
 }
 export async function defaultsFlow(pi: any, ctx: any, config: ModelsConfig): Promise<void> {
   let scope: Scope = "user";
+  const state = {};
   for (;;) {
     const discovery = await discoverRoles(ctx.cwd, pi, ctx.model?.provider, trusted(pi, ctx));
     const user = readSettings(settingsPath(ctx.cwd, "user"));
@@ -88,28 +148,33 @@ export async function defaultsFlow(pi: any, ctx: any, config: ModelsConfig): Pro
     const roles = discovery.roles;
     const modelFallback = roleField(agentUser, agentProject, ctx.model?.provider, undefined, "model");
     const thinkingFallback = roleField(agentUser, agentProject, ctx.model?.provider, undefined, "thinking");
-    const options = [
-      `Scope: ${scope} (select to change)`,
-      `Pi session: ${main.provider ?? "auto"}/${main.model ?? "auto"} | ${main.effort ?? "automatic"} [${main.source}]`,
-      `Subagent fallback: ${display(modelFallback.value)} | ${display(thinkingFallback.value)}`,
-      ...roles.map(role => {
-        const model = roleField(agentUser, agentProject, ctx.model?.provider, role.name, "model");
-        const effort = roleField(agentUser, agentProject, ctx.model?.provider, role.name, "thinking");
-        return `${role.name}: ${display(model.value ?? role.model)} | ${display(effort.value ?? role.thinking)} [${model.source}; ${effort.source}]${role.runner ? " [external runner]" : ""}`;
-      }),
-      ...(discovery.warning ? ["Agent discovery details"] : []),
-      "Done",
-    ];
-    const selected = await ctx.ui.select(`BMS defaults\nSaved settings, not running-child state. Agent changes require /reload.\n${scope === "user" ? settingsPath(ctx.cwd, scope) : "Pi: " + settingsPath(ctx.cwd, scope) + "\nAgents: " + settingsPath(discovery.projectRoot, scope)}`, options);
-    if (!selected || selected === "Done") return;
-    const index = options.indexOf(selected);
+    const selected = await tableSelect(ctx, {
+      title: "BMS defaults",
+      search: false,
+      state,
+      hint: `Scope: ${scope}. Saved settings, not running children. Agent changes require /reload.\nPi: ${settingsPath(ctx.cwd, scope)}\nAgents: ${settingsPath(discovery.projectRoot, scope)}`,
+      columns: [{ key: "target", label: "TARGET" }, { key: "model", label: "MODEL" }, { key: "effort", label: "EFFORT" }, { key: "source", label: "SOURCE" }],
+      rows: [
+        { value: "0", label: `Scope: ${scope}`, cells: { target: "Scope", model: scope, effort: "", source: "Select to change" } },
+        { value: "1", label: "Pi session", cells: { target: "Pi session", model: `${main.provider ?? "auto"}/${main.model ?? "auto"}`, effort: main.effort ?? "automatic", source: main.source } },
+        { value: "2", label: "Subagent fallback", cells: { target: "Subagent fallback", model: display(modelFallback.value), effort: display(thinkingFallback.value), source: `${modelFallback.source}; ${thinkingFallback.source}` } },
+        ...roles.map((role, index) => {
+          const model = roleField(agentUser, agentProject, ctx.model?.provider, role.name, "model");
+          const effort = roleField(agentUser, agentProject, ctx.model?.provider, role.name, "thinking");
+          return { value: String(index + 3), label: role.name, cells: { target: role.name, model: display(model.value ?? role.model), effort: display(effort.value ?? role.thinking), source: role.runner ? "External runner" : `${model.source}; ${effort.source}` } };
+        }),
+        ...(discovery.warning ? [{ value: "details", label: "Agent discovery details" }] : []),
+        { value: "done", label: "Done" },
+      ],
+    });
+    if (selected === undefined || selected === "done") return;
+    const index = Number(selected);
     if (index === 0) {
       if (!trusted(pi, ctx)) { ctx.ui.notify("Project defaults require a trusted project.", "warning"); continue; }
       scope = scope === "user" ? "project" : "user";
     } else if (index === 1) {
-      const model = await assignModel(ctx, config, "Choose Pi default model");
-      if (model) await setMainDefault(pi, ctx, model.provider, model.modelId, scope);
-    } else if (selected === "Agent discovery details") {
+      await editPiDefault(pi, ctx, config, scope, user, project);
+    } else if (selected === "details") {
       ctx.ui.notify(discovery.warning!, "warning");
     } else {
       const role = index === 2 ? undefined : roles[index - 3];
@@ -124,26 +189,55 @@ async function editRole(pi: any, ctx: any, config: ModelsConfig, scope: Scope, r
     ctx.ui.notify("External runner defaults are not editable with the Pi registry picker. Use the runner's own configuration.", "warning");
     return;
   }
-  const action = await ctx.ui.select(`${title}\nScope: ${scope}. Provider-specific and project overrides may take precedence.\n${path}`, ["Choose model", "Inherit parent model", "Remove model override", "Choose effort", "Remove effort override", "Back"]);
-  if (!action || action === "Back") return;
-  let field: "model" | "thinking" = "model";
-  let value: string | false | undefined;
-  if (action === "Choose model") {
-    const selected = await assignModel(ctx, config, `Choose model for ${title}`);
-    if (!selected) return;
-    value = `${selected.provider}/${selected.modelId}`;
-  } else if (action === "Inherit parent model") value = "inherit";
-  else if (action === "Choose effort") {
-    field = "thinking";
-    const selected = roleField(user, project, ctx.model?.provider, role?.name, "model").value ?? role?.model;
-    const ref = typeof selected === "string" && selected !== "inherit" ? selected.replace(/:(off|minimal|low|medium|high|xhigh|max)$/, "") : `${ctx.model?.provider}/${ctx.model?.id}`;
-    const split = ref.indexOf("/");
-    const model = split > 0 ? ctx.modelRegistry.find(ref.slice(0, split), ref.slice(split + 1)) : undefined;
-    const effort = await chooseEffort(ctx, ref, model);
-    if (effort === undefined) return;
-    value = effort === "automatic" ? undefined : effort;
-  } else if (action === "Remove effort override") field = "thinking";
-  if (!(await ctx.ui.confirm(`Save ${title}?`, `${field}: ${value ?? "remove override"}\n${path}\nReload Pi before relying on the new child defaults. Removing effort restores agent-defined/fallback behavior; it does not force parent inheritance.`))) return;
-  patchSettings(path, data => setRoleField(data, role?.name, field, value));
-  ctx.ui.notify(`Saved ${title} ${field}. Run /reload to refresh subagent defaults.`, "info");
+  const local = scope === "user" ? user : project;
+  const entry = role ? local.subagents?.agentOverrides?.[role.name] : undefined;
+  let model: string | undefined = role ? entry?.model : local.subagents?.defaultModel;
+  let effort: string | false | undefined = role ? entry?.thinking : local.subagents?.defaultThinking;
+  let modelChanged = false, effortChanged = false;
+  await editForm(ctx, {
+    title: `${title} defaults`,
+    hint: `Scope: ${scope}\n${path}\nProvider-specific and project overrides still take precedence. Removing effort restores agent-defined/fallback behavior, not parent inheritance.`,
+    fields: [
+      { key: "model", label: "Model", value: model ?? "remove override", edit: async () => {
+        const action = await tableSelect(ctx, { title: `Model for ${title}`, rows: [
+          { value: "choose", label: "Choose model" },
+          { value: "inherit", label: "Inherit parent model", description: "Explicitly use the parent session model." },
+          { value: "remove", label: "Remove model override", description: `Remove only the ${scope} ${title} model override.` },
+        ] });
+        if (action === undefined) return;
+        if (action === "choose") {
+          const selected = await assignModel(ctx, config, `Choose model for ${title}`);
+          if (!selected) return;
+          model = `${selected.provider}/${selected.modelId}`;
+        } else if (action === "inherit") model = "inherit";
+        else {
+          if (!(await confirmAction(ctx, { title: "Remove model override?", lines: [`Target: ${title}`, `Scope: ${scope}`, path], confirmLabel: "Remove override" }))) return;
+          model = undefined;
+        }
+        modelChanged = true;
+        return model ?? "remove override";
+      } },
+      { key: "effort", label: "Effort", value: display(effort), edit: async () => {
+        const effective = modelChanged ? model : roleField(user, project, ctx.model?.provider, role?.name, "model").value ?? role?.model;
+        const ref = typeof effective === "string" && effective !== "inherit" ? effective.replace(/:(off|minimal|low|medium|high|xhigh|max)$/, "") : `${ctx.model?.provider}/${ctx.model?.id}`;
+        const split = ref.indexOf("/");
+        const selected = await chooseEffort(ctx, ref, split > 0 ? ctx.modelRegistry.find(ref.slice(0, split), ref.slice(split + 1)) : undefined, effort);
+        if (selected === undefined) return;
+        if (selected === "automatic" && !(await confirmAction(ctx, { title: "Remove effort override?", lines: [`Target: ${title}`, `Scope: ${scope}`, path, "Restores agent-defined/fallback behavior."], confirmLabel: "Remove override" }))) return;
+        effort = selected === "automatic" ? undefined : selected;
+        effortChanged = true;
+        return effort ?? "remove override";
+      } },
+    ],
+    onSave: async () => {
+      if (scope === "project" && !trusted(pi, ctx)) throw new Error("Project is not trusted");
+      if (!modelChanged && !effortChanged) return true;
+      patchSettings(path, data => {
+        if (modelChanged) setRoleField(data, role?.name, "model", model);
+        if (effortChanged) setRoleField(data, role?.name, "thinking", effort);
+      });
+      ctx.ui.notify(`Saved ${title}. Run /reload to refresh subagent defaults.`, "info");
+      return true;
+    },
+  });
 }