@benvargas/pi-model-sort 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -7,6 +7,34 @@ and this package adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.2] - 2026-09-11
+
+### Fixed
+- Scoped Ctrl+P / Ctrl+Shift+P cycling no longer fails with "Cannot read
+  properties of undefined (reading 'persist')" on pi 0.84.3 and later. pi
+  0.84.3 added a second `options` parameter to `AgentSession._cycleScopedModel`
+  and reads `options.persist` once a next model is selected; the patch
+  forwarded only the direction, so every cycle that actually changed model (two
+  or more available scoped models) threw after pi had already swapped the model
+  (no `model_select`, so last-used and thinking-level memory were not updated).
+  A single-model scope was unaffected (pi returns "Only one model in scope"
+  before reading the options). The patch now forwards every argument
+  untouched. Validated against pi 0.85.1, including a regression test that
+  drives pi's real `AgentSession` through the patched cycle.
+
+## [1.0.1] - 2026-09-02
+
+### Fixed
+- An explicit `--model` on the command line now wins over the MRU startup
+  override. Previously a fresh start such as `pi --model provider/id` (or
+  bb's Pi provider, which launches `pi --mode rpc --model provider/id` and
+  aborts the thread with "Pi did not start with model ..." when pi reports a
+  different model back) was silently switched to the most recently used
+  model. The explicitly requested model is recorded as last-used on startup,
+  since pi sets it during construction without emitting `model_select`.
+  Detection inspects `process.argv` for `--model <value>` / `--model=value`;
+  `--models` (scope) is not treated as a selection.
+
 ## [1.0.0] - 2026-08-28
 
 ### Added

package/README.md

@@ -5,6 +5,7 @@ Sorts pi's model picker by last usage and starts fresh sessions on your most rec
 - `/model` picker — both "Scope: all" and "Scope: scoped" views, including fuzzy-search results — is sorted by recency: current model first → most recently used → provider/id alphabetical
 - Ctrl+P / Ctrl+Shift+P **scoped** cycling follows last-used order (scoped models come from `enabledModels` or `--models`)
 - Fresh starts and `/new` begin on your most recently used model instead of `enabledModels[0]` or the hardcoded provider default
+- An explicit `--model` on the command line always wins over MRU (so `pi --model provider/id`, scripts, and bb's Pi provider get the model they asked for); that model is recorded as last-used
 - Continued sessions (`pi -c`, `--session`, `/resume`, forks) keep the model saved in the session file, and that restored model is recorded as last-used (fresh `/new` sessions and `/reload` are excluded from that recording)
 - Remembers the thinking level you last used on each model and restores it on every switch, clamped to what each model supports
 - No configuration needed — tracking starts on first use and degrades to the default alphabetical order with no history
@@ -31,6 +32,7 @@ The extension works automatically — there are no commands to learn.
 /model                    # Most recently used models appear at the top
 Ctrl+P / Ctrl+Shift+P     # Cycle through scoped models in last-used order
 pi                        # Fresh starts use MRU
+pi --model provider/id    # Explicit model wins over MRU
 pi -c                     # Continuations keep the session's model
 ```
 
@@ -38,7 +40,7 @@ pi -c                     # Continuations keep the session's model
 
 - Tracking uses pi's documented extension events: `/model` switches (`model_select`) and thinking-level changes (`thinking_level_select`) are timestamped into `~/.pi/agent/extensions/pi-model-sort.json`. Continued sessions restore their model during construction without emitting `model_select` (pi 0.84.3), so the extension records the restored model at `session_start` itself.
 - Sorting has no SDK hook, so the extension wraps (monkey-patches) internal methods: `ModelSelectorComponent.sortModels`, its scoped loader and `filterModels`, and `AgentSession._cycleScopedModel` for scoped cycling. All original methods are preserved and restored on shutdown/reload; the patches survive `modelRegistry.refresh()`.
-- The MRU startup override calls `pi.setModel()` on `session_start` for fresh starts and `/new` only. A continued session is detected by projecting its branch through pi's own context-message rules (`message`, `custom_message`, non-empty `branch_summary`, and `compaction` entries — exactly what `buildSessionContext()` counts) — pi seeds every new session with `model_change` + `thinking_level_change` entries before `session_start` fires, so raw branch length cannot distinguish fresh from continued.
+- The MRU startup override calls `pi.setModel()` on `session_start` for fresh starts and `/new` only, and never when the process was launched with `--model` (pi exposes no "model came from the CLI" signal to extensions, so the extension inspects `process.argv`). A continued session is detected by projecting its branch through pi's own context-message rules (`message`, `custom_message`, non-empty `branch_summary`, and `compaction` entries — exactly what `buildSessionContext()` counts) — pi seeds every new session with `model_change` + `thinking_level_change` entries before `session_start` fires, so raw branch length cannot distinguish fresh from continued.
 
 ### Known limitations on pi 0.84.x
 

package/extensions/index.ts

@@ -45,6 +45,7 @@ import {
 	findMruModel,
 	handleModelSelect,
 	hasContextMessages,
+	hasExplicitModelArg,
 	type ModelSortConfig,
 	parseConfig,
 	recordThinkingSelect,
@@ -315,18 +316,24 @@ function unpatchRegistry(registry: PatchedRegistry): void {
 // before cycling so Ctrl+P / Ctrl+Shift+P follows last-used order instead
 // of the configured order. Non-destructive: the session's stored order is
 // temporarily swapped and restored after the cycle lookup.
+//
+// Every argument is forwarded untouched: pi 0.84.3 added a second
+// `options: ModelMutationOptions` parameter and reads `options.persist` once
+// a next model is selected, so dropping it made every model-changing scoped
+// cycle (two or more available scoped models) throw. A single-model scope
+// returns early ("Only one model in scope") and never reached the crash.
 
 type ScopedModelEntry = { model: { provider: string; id: string }; thinkingLevel?: string };
 
-let origCycleScopedModel: ((direction: string) => Promise<unknown>) | null = null;
+let origCycleScopedModel: ((...args: unknown[]) => Promise<unknown>) | null = null;
 
 function patchCycleScopedModel(getLastUsed: () => Record<string, number>): void {
 	if (origCycleScopedModel !== null) return;
 
 	const proto = AgentSession.prototype as unknown as Record<string, unknown>;
-	origCycleScopedModel = proto._cycleScopedModel as (direction: string) => Promise<unknown>;
+	origCycleScopedModel = proto._cycleScopedModel as (...args: unknown[]) => Promise<unknown>;
 
-	proto._cycleScopedModel = async function (this: Record<string, unknown>, direction: string) {
+	proto._cycleScopedModel = async function (this: Record<string, unknown>, ...args: unknown[]) {
 		const orig = origCycleScopedModel;
 		if (!orig) return undefined;
 
@@ -334,7 +341,7 @@ function patchCycleScopedModel(getLastUsed: () => Record<string, number>): void
 		const origScoped = this._scopedModels as ScopedModelEntry[] | undefined;
 
 		if (!origScoped || origScoped.length <= 1) {
-			return orig.call(this, direction);
+			return orig.apply(this, args);
 		}
 
 		// Sort by last-used without mutating the session's stored order.
@@ -350,7 +357,7 @@ function patchCycleScopedModel(getLastUsed: () => Record<string, number>): void
 		// Temporarily swap for the cycle lookup, restore afterward.
 		this._scopedModels = sorted;
 		try {
-			return await orig.call(this, direction);
+			return await orig.apply(this, args);
 		} finally {
 			this._scopedModels = origScoped;
 		}
@@ -398,8 +405,21 @@ export default function (pi: ExtensionAPI) {
 		// branch_summary, compaction entries) — the same predicate pi core uses
 		// for its continuation check, not raw branch length and not literal
 		// message entries alone.
+		//
+		// An explicit `--model` on the command line always wins. Pi resolved
+		// that model during construction without emitting model_select, so on
+		// the initial startup record it as last-used instead of overriding it.
+		// This is what bb's Pi provider relies on: it launches
+		// `pi --mode rpc --model provider/id` and aborts the thread if pi
+		// reports a different model back.
 		const hasSessionMessages = hasContextMessages(ctx.sessionManager.buildContextEntries());
-		if (shouldApplyMruOverride(event.reason, hasSessionMessages) && Object.keys(lastUsed).length > 0) {
+		const explicitModel = hasExplicitModelArg(process.argv);
+		if (explicitModel && shouldApplyMruOverride(event.reason, hasSessionMessages)) {
+			if (event.reason === "startup" && ctx.model) {
+				lastUsed[buildModelKey(ctx.model.provider, ctx.model.id)] = Date.now();
+				writeConfig({ lastUsed, thinking: tracker.thinking });
+			}
+		} else if (shouldApplyMruOverride(event.reason, hasSessionMessages) && Object.keys(lastUsed).length > 0) {
 			const mruModel = findMruModel(lastUsed, ctx.modelRegistry);
 			const currentModel = ctx.model as { provider: string; id: string } | undefined;
 			if (

package/extensions/sort.ts

@@ -101,6 +101,36 @@ export function shouldApplyMruOverride(reason: SessionStartReason, hasSessionMes
 	return reason === "startup" || reason === "new";
 }
 
+/**
+ * Whether the process was launched with an explicit `--model` argument.
+ *
+ * Pi does not tell extensions whether the starting model came from the CLI,
+ * so this inspects the argv pi was started with. An explicit model must win
+ * over the MRU override: callers such as bb's Pi provider (`pi --mode rpc
+ * --model provider/id`), scripts, and anyone typing `pi --model ...` expect
+ * the model they asked for, and bb aborts the thread when the model pi
+ * reports back differs from the one it requested.
+ *
+ * Only pi's own spelling counts: `--model <value>` (pi 0.84.x has no `-m`
+ * alias). `--model=value` is accepted too in case pi adds it. `--models` is
+ * a scope list, not a selection, and is ignored. A trailing `--model` with no
+ * value is ignored.
+ *
+ * @param argv process arguments to inspect (normally `process.argv`)
+ */
+export function hasExplicitModelArg(argv: readonly string[]): boolean {
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--model") {
+			const value = argv[i + 1];
+			if (value !== undefined && value !== "" && !value.startsWith("-")) return true;
+			continue;
+		}
+		if (arg.startsWith("--model=") && arg.length > "--model=".length) return true;
+	}
+	return false;
+}
+
 /**
  * Whether the model pi restored for this session start should be recorded as
  * last-used. Pi 0.84.3 restores a continued session's model during

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benvargas/pi-model-sort",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Sort models in pi by last usage and start fresh sessions on the most recently used model",
   "keywords": [
     "pi",