bermudis-pi-goodies 0.5.4 → 0.6.0

package/README.md

@@ -1,7 +1,7 @@
 # bermudis-pi-goodies
 
 A bundle of small, frequently-used [Pi](https://github.com/earendil-works/pi)
-extensions. One entry point, nine independent features.
+extensions. One entry point, ten independent features.
 
 | Feature            | Command / hook                | What it does                                                                                                                                    |
 | ------------------ | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -10,7 +10,8 @@ extensions. One entry point, nine independent features.
 | `name-with-ai`     | `/name-with-ai [name]`        | Generate a short session name from the first user message (or set one manually).                                                                |
 | `zed`              | `/z`                          | Open Zed editor on the current working directory.                                                                                               |
 | `prefer-tools`     | hook (no command)             | Nudge toward modern CLIs: `rg` over `grep`, `fd` over `find`, `uv` over bare `python`/`pip`/`pytest`/`mypy`.                                    |
-| `model-thinking`   | hook (no command)             | Apply native scoped-model thinking levels consistently when selecting a model through the full picker.                                          |
+| `keep-model-on-new` | hook (no command)            | Keep the active model when `/new` starts a fresh session instead of reverting to pi's saved default model.                                    |
+| `model-thinking`   | hook + `/levels`              | Per-model thinking levels stored in an extension sidecar (pi's /scoped-models rewrites `enabledModels` bare, wiping `:level` suffixes); `/levels` edits them, hooks apply them whenever a model becomes active. |
 | `kilo`             | provider                      | Access Kilo Gateway models via `/login kilo` or `KILO_API_KEY`.                                                                                 |
 | `provider-balance` | footer (no command)           | Show remaining Kilo or OpenRouter credits, z.ai token-plan quota, or OpenAI Codex quota on the right side of the working-directory footer line. |
 | `tps`              | hook (no command)             | Notify tokens/sec and in/out/cache token usage at the end of each agent turn.                                                                   |
@@ -20,7 +21,7 @@ extensions. One entry point, nine independent features.
 After publishing the package to npm:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.5.4
+pi install npm:bermudis-pi-goodies@0.6.0
 ```
 
 Remove any old `bermudis-pi-goodies.ts` symlink before reloading Pi. Each
@@ -29,36 +30,41 @@ Kilo's provider and its balance footer are bundled here.
 
 ## Model selection and thinking
 
-Pi's native model settings are the single source of truth. Add models to
-`enabledModels` in `~/.pi/agent/settings.json` in cycle order. Add an optional
-thinking level after a colon:
-
-```json
-{
-  "enabledModels": [
-    "opencode/hy3-free:high",
-    "zai/glm-5.2:high",
-    "openai-codex/gpt-5.6-terra:medium"
-  ]
-}
+Pi's native scoped-models config would put per-model thinking levels in
+`enabledModels` entries like `"zai/glm-5.3:high"`, but the `/scoped-models`
+screen (which maintains that list) rewrites it with bare model ids on every
+save, destroying any `:level` suffix. So this package stores levels in its
+own sidecar file:
+
+```
+~/.pi/agent/data/bermudis-pi-goodies/thinking-levels.json
 ```
 
-Pi applies those levels while cycling with Ctrl+P and Ctrl+Shift+P. This
-package fills the small consistency gaps: choosing a scoped model through the
-full model picker and starting with a plain explicit `--model` apply its
-configured level. Explicit `--thinking` and `--model ...:<level>` still win
-(unless the `:<level>` ending is the model's registered id, in which case the
-scoped level applies).
-One gap is inherent to Pi: it emits no selection event when you pick the
-model that is already active, so re-selecting it in the full picker leaves a
-manual thinking level in place — switch models (or cycle) to snap back.
-Resumed and forked sessions retain the level restored by Pi; `/new` carries the
-previous session's model and active thinking level into the new session.
-
-Use `/scoped-models` to search, enable, disable, and reorder the cycle list.
-Be aware that pi 0.84.2 currently writes bare model IDs when that screen is
-saved, so saving there removes any `:level` suffixes; restore them in
-`settings.json` afterward.
+The split of ownership is clean: `/scoped-models` owns which models are
+enabled and their Ctrl+P cycle order; `/levels` owns the per-model thinking
+level and can never be wiped by the other screen.
+
+Use `/levels` to edit: ↑↓ moves between scoped models, ←→ cycles each
+model's level through the ladder it actually supports plus `inherit`
+(which leaves pi's global default in charge), Enter saves atomically and
+applies to the active model immediately, Esc cancels.
+
+Hooks apply the stored level whenever a model becomes active: full-picker
+selection, Ctrl+P cycling, startup, and `/new` (where this package carries
+the previous session's active model forward). A native scoped level for the session — via
+`--models "x:high"` or a hand-suffixed enabledModels entry — always wins;
+the sidecar only fills in where pi itself has no level. Explicit
+`--thinking` or `--model ...:<level>` still
+wins for that launched session — a model whose registered id genuinely ends
+in `:<level>` is indistinguishable from that shorthand without the registry,
+so it opts out of its stored level for that startup; switch or cycle to
+re-apply. Resumed and forked sessions keep the level restored by pi.
+
+One gap is inherent to Pi: it emits no `model_select` when you pick the
+model that is already active, so re-selecting it in the full picker leaves
+a manual thinking level in place — switch models (or cycle) to snap back.
+Saving the `/scoped-models` screen in pi 0.84.2 writes bare model ids, which
+is now harmless: bare ids are exactly what this design expects.
 
 ## Provider and balance details
 

package/index.ts

@@ -8,7 +8,8 @@
  *   - name-with-ai     /name-with-ai     generate a session name via the model
  *   - zed              /z                open Zed on cwd
  *   - prefer-tools     hook              block legacy tools (use trash/rg/fd/uv)
- *   - model-thinking   hook              apply native scoped-model thinking levels consistently
+ *   - keep-model       hook              preserve the active model across /new
+ *   - model-thinking   hook              manage per-model thinking levels in an extension-owned sidecar
  *   - kilo             provider          access Kilo Gateway models
  *   - provider-balance footer            show Kilo credits or Codex quota in the footer
  *   - tps              hook              notify tokens/sec and usage at each agent turn end
@@ -17,6 +18,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import copyTrajectory from "./copy-trajectory.ts";
 import copyWithModel from "./copy-with-model.ts";
 import kilo from "./kilo.ts";
+import keepModelOnNew from "./keep-model-on-new.ts";
 import modelThinking from "./model-thinking.ts";
 import providerBalance from "./provider-balance.ts";
 import tps from "./tps.ts";
@@ -30,6 +32,9 @@ export default function bermudisPiGoodies(pi: ExtensionAPI): void {
   nameWithAi(pi);
   zed(pi);
   preferTools(pi);
+  // Register this before model-thinking so /new restores the model first and
+  // model-thinking then sees and configures the final active model.
+  keepModelOnNew(pi);
   modelThinking(pi);
   providerBalance(pi);
   kilo(pi);

package/keep-model-on-new.ts

@@ -0,0 +1,76 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+interface ModelIdentity {
+  provider: string;
+  id: string;
+}
+
+/**
+ * Extension modules are cached across Pi's session-runtime replacement, while
+ * their factories and handlers are recreated. This small handoff therefore
+ * survives /new without writing transient state to disk.
+ */
+const pendingModels = new Map<string, ModelIdentity>();
+
+function handoffKey(
+  sessionFile: string | undefined,
+  ctx: Pick<ExtensionContext, "cwd">,
+): string {
+  return sessionFile ?? `ephemeral:${ctx.cwd}`;
+}
+
+export interface KeepModelOnNewOptions {
+  /** Override the process-local handoff store (tests). */
+  pendingModels?: Map<string, ModelIdentity>;
+}
+
+export default function keepModelOnNew(
+  pi: ExtensionAPI,
+  options: KeepModelOnNewOptions = {},
+): void {
+  const handoffs = options.pendingModels ?? pendingModels;
+
+  pi.on("session_before_switch", (event, ctx) => {
+    if (event.reason !== "new" || !ctx.model) return;
+    handoffs.set(handoffKey(ctx.sessionManager.getSessionFile(), ctx), {
+      provider: ctx.model.provider,
+      id: ctx.model.id,
+    });
+  });
+
+  pi.on("session_start", async (event, ctx) => {
+    if (event.reason !== "new") return;
+
+    const key = handoffKey(event.previousSessionFile, ctx);
+    const previous = handoffs.get(key);
+    handoffs.delete(key);
+    if (!previous) return;
+    if (
+      ctx.model?.provider === previous.provider &&
+      ctx.model.id === previous.id
+    ) {
+      return;
+    }
+
+    const model = ctx.modelRegistry.find(previous.provider, previous.id);
+    if (!model) {
+      const message = `Could not keep model after /new: ${previous.provider}/${previous.id} is unavailable`;
+      console.warn(`[keep-model-on-new] ${message}`);
+      ctx.ui.notify(message, "warning");
+      return;
+    }
+
+    try {
+      await pi.setModel(model);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      console.warn(
+        `[keep-model-on-new] Failed to restore ${previous.provider}/${previous.id}: ${detail}`,
+      );
+      ctx.ui.notify(`Could not keep model after /new: ${detail}`, "warning");
+    }
+  });
+}