model-compare-opencode-plugin 0.5.0 → 0.6.1

package/README.md

@@ -10,7 +10,9 @@ Each priority is a live alias inside the existing OpenRouter provider — no new
 | `openrouter/model-compare/price` | best price pick |
 | `openrouter/model-compare/quality` | best quality pick |
 
-The alias re-points at the current pick while OpenCode runs (refresh every 30 minutes, data cache 6 hours). OpenCode's model picker shows it as `Model Compare: <priority> → <pick>`, with `(fallback)` or `(unavailable)` when the fallback is serving or the alias is disabled.
+The alias re-points at the current pick while OpenCode runs (refresh every 30 minutes, data cache 6 hours). It also pins the catalog's scored reasoning effort on each request, so the model runs at the depth its `quality` score was measured at. OpenCode's model picker shows it as `Model Compare: <priority> → <pick>`, with `(fallback)` while the fallback is serving and `(unavailable)` when the alias is disabled. The alias name deliberately carries no catalog effort or alternative: OpenCode shows the selected variant itself, and a baked-in depth would not follow your `#variant` choice.
+
+**Effort vs variant.** The model-compare catalog and the request body call this reasoning level the *effort* (`quality_effort`, pinned as `reasoning.effort`); OpenCode calls the selectable model option a *variant* (`provider/model#variant`). The alias byline shows only the pick; the report dialog's status line uses “variant” and shows the highlighted model's variant and its best higher variant.
 
 
 ## Install
@@ -69,7 +71,7 @@ opencode run --model "openrouter/model-compare/price" "msg"
 Commands:
 
 - `/use-best [priority]` — switch the session to `openrouter/model-compare/<p>` (defaults to `defaultPriority`). Refuses a disabled alias.
-- `/model-compare` — top 5 per priority with scores and data age; priorities whose `weights` override actually takes effect are labelled `(custom weights)` with recomputed scores, and each alias's current pick is marked `← current pick`. The output is a synthetic message (`resume: false`): it costs no model turn and, in a headless session, surfaces in the transcript at the next turn. In the TUI it opens the report dialog instead.
+- `/model-compare` — top 5 per priority with scores and data age; each line also shows the reasoning effort behind `quality` (`· high`) and the best selectable measured alternative (`· alt max 56.0`). Priorities whose `weights` override actually takes effect are labelled `(custom weights)` with recomputed scores, and each alias's current pick is marked `← current pick`. The output is a synthetic message (`resume: false`): it costs no model turn and, in a headless session, surfaces in the transcript at the next turn. In the TUI it opens the report dialog instead, with model, quality and price columns and a status line that follows the cursor and shows the highlighted model's variant and its best higher variant.
 
 
 ### Keyboard shortcuts
@@ -78,14 +80,14 @@ Commands:
 |---|---|
 | `alt+m` | picks dialog — all three priorities with their current picks |
 | `alt+e` | toast the last response's served endpoint, alias responses only (`!` prefix flags a downgrade — not in the steering order) |
-| `alt+shift+m` | report dialog — the top-5 table; `return` switches the session to the highlighted model |
+| `alt+shift+m` | report dialog — the top-5 table with a cursor-following variant status line; `return` switches the session to the highlighted model |
 | `up` / `down` | move the dialog cursor |
 | `return` | select the highlighted row (picks dialog: switch to that priority) |
 | `esc` | close the dialog |
 
 Both dialogs open anywhere — including the opening screen, where no session exists yet. There, picking a row (a priority in the picks dialog, a model in the report) creates a new session already bound to that model and opens it; merely opening a dialog never creates a session. With a session open, a pick switches that session as before. The TUI has no `/use-best` keybinding: the slash command already covers switching.
 
-Status: the footer shows `MC: balanced → <pick>` (balanced only — `disabled`/`unavailable`/`(fallback)` as applicable; all three priorities live in the picks dialog). Toasts announce `/use-best` outcomes and pick changes (never for the first observation after load), the `alt+e` served endpoint, and the cannot-steer notice — see [Steering and served endpoints](#steering-and-served-endpoints). Headless, command feedback is synthetic transcript messages at the next turn; the steering toasts have no headless surface.
+Status: the footer shows `MC: balanced → <pick>` (balanced only — `disabled`/`unavailable`/`(fallback)` as applicable; all three priorities live in the picks dialog). The picker's alias name carries only the pick (plus the fallback marker); the report dialog's status line carries the variant and best higher variant. The footer stays a compact served-model line. Toasts announce `/use-best` outcomes and pick changes (never for the first observation after load), the `alt+e` served endpoint, and the cannot-steer notice — see [Steering and served endpoints](#steering-and-served-endpoints). Headless, command feedback is synthetic transcript messages at the next turn; the steering toasts have no headless surface.
 
 
 ## Configuration
@@ -155,18 +157,18 @@ The alt+e capture is best-effort by design, and alias-scoped: only a session who
 
 The last validated catalog is persisted, so ranking and `/model-compare` work offline after a restart. The cache is keyed by source (URL or script path), so changing the source never serves the previous source's data. Script exit code 2 means "no candidates" *or* an argparse usage error — never read it as "no candidates" alone.
 
-**Vendored pin:** `vendor/model_compare.py` is byte-identical to upstream `v0.5.0` (`vendor/UPSTREAM.json` records repo, tag, commit, sha256). The catalog is schema v4 (since upstream 0.5.0): v3's `pricing` tier/schedule structure and published ranking `parameters.weights` are unchanged, and v4 adds per-model quality provenance (`quality_as_of`, `quality_drift`) plus a reshaped `sources.aa` block — nothing `validateCatalog` reads changed shape. The plugin accepts schema v4 ONLY — `validateCatalog` rejects anything else — and releases are gated on the live remote serving v4 (the release-gate check pipes `https://model-compare.dev/catalog.json` through `scripts/canary-check.mjs`, which fails closed when the served document is not the expected schema). Effective-tier pricing semantics still apply: `pricing` scalars hold effective-tier values — the tier in effect at 1M-token prompts — so models with OpenRouter price overrides are ranked at what a long session actually pays.
+**Vendored pin:** `vendor/model_compare.py` is byte-identical to upstream `v0.6.0` (`vendor/UPSTREAM.json` records repo, tag, commit, sha256). The catalog is schema v5 (since upstream 0.6.0): `quality` is the AA intelligence index at the model's effective OpenRouter default reasoning effort, and every entry carries `quality_effort` plus a `reasoning` block (`default_effort`, the expanded `supported_efforts`, the raw flags, and the measured `depths` with AA `$/task`). The plugin accepts schema v5 ONLY — `validateCatalog` rejects anything else — and releases are gated on the live remote serving v5 (the release-gate check pipes `https://model-compare.dev/catalog.json` through `scripts/canary-check.mjs`, which fails closed when the served document is not the expected schema). Each alias request pins exactly the pick's `quality_effort` in its body (`reasoning: { effort }`), so the alias runs at the depth its score represents; an explicit `#variant` selection, or a body that already sets `reasoning`/`reasoning_effort`, wins and is never overwritten. The catalog's `reasoning` sentinel is display-only and never sent to the gateway. Effective-tier pricing semantics still apply: `pricing` scalars hold effective-tier values — the tier in effect at 1M-token prompts — so models with OpenRouter price overrides are ranked at what a long session actually pays.
 
-**Vendored 0.5.0 cold-cache network profile:** since 0.4.0 the vendored script performs per-model endpoint-pricing fetches when building a fresh catalog (74 candidates in the recorded run). Each fetch fails closed per model — after the script's internal retries, a failed endpoint fetch drops that model and the catalog shrinks silently (429-class responses raise without retry) — so a degraded network costs pool coverage, not pricing correctness. Since 0.5.0, unkeyed runs also hydrate quality from the published catalog (one fetch of `https://model-compare.dev/catalog.json`, cached under `published-catalog`; keyed runs consult the AA API — now the primary quality source — and never fetch the published catalog); every quality hydration fails closed to "no quality data" per model. A cold cache under a slow network can exceed the plugin's 60-second local budget, in which case the plugin warns and falls back (`auto` → remote, `local` → its cached document).
+**Vendored 0.6.0 cold-cache network profile:** since 0.4.0 the vendored script performs per-model endpoint-pricing fetches when building a fresh catalog (76 candidates in the recorded run). Each fetch fails closed per model — after the script's internal retries, a failed endpoint fetch drops that model and the catalog shrinks silently (429-class responses raise without retry) — so a degraded network costs pool coverage, not pricing correctness. Unkeyed runs hydrate quality from the published catalog (one fetch of `https://model-compare.dev/catalog.json`, cached under `published-catalog`; keyed runs consult the AA API — the primary quality source — and never fetch the published catalog); every quality hydration fails closed to "no quality data" per model, and a missing record at the selected effort shows `-` rather than borrowing another effort's score. A cold cache under a slow network can exceed the plugin's 60-second local budget, in which case the plugin warns and falls back (`auto` → remote, `local` → its cached document).
 
 **Upgrading the pin** — reviewed PRs only; nothing merges automatically:
 
 1. `node scripts/sync-vendor.mjs <tag>` — fetches the script at that commit, reports the sha256 change, re-pins `UPSTREAM.json`, prints the matching CHANGELOG section (`--check` verifies offline).
-2. Conformance tests check `--version`, schema v4, required fields, recomputed `overall` scores, and the standard-library-only import allowlist.
+2. Conformance tests check `--version`, schema v5, required fields, recomputed `overall` scores, and the standard-library-only import allowlist.
 3. The upgrade PR body lists script lines touching imports, URLs, environment variables, subprocess calls and file writes, for reviewer attention.
 4. Release with a changelog line naming the upstream tag; users run `opencode plugin update` (OpenCode checks but doesn't apply).
 
-A scheduled workflow opens a draft upgrade PR when upstream publishes a newer release (never a downgrade); a nightly canary exercises the vendored script against live upstream data and asserts the generated catalog is schema v4 (`scripts/canary-check.mjs` pins `EXPECTED_SCHEMA_VERSION = 4` and exits nonzero on any other version); releases additionally gate on the live remote itself (see the publishing gates below); a weekly drift check compares the vendored sha256 against upstream's pinned commit and the published rankings against the published scores.
+A scheduled workflow opens a draft upgrade PR when upstream publishes a newer release (never a downgrade); a nightly canary exercises the vendored script against live upstream data and asserts the generated catalog is schema v5 (`scripts/canary-check.mjs` pins `EXPECTED_SCHEMA_VERSION = 5` and exits nonzero on any other version); releases additionally gate on the live remote itself (see the publishing gates below); a weekly drift check compares the vendored sha256 against upstream's pinned commit and the published rankings against the published scores.
 
 
 ## Troubleshooting
@@ -201,16 +203,18 @@ Run a checkout instead of the npm package:
 OpenCode's local loader resolves a directory target strictly as `<dir>/index.*` — `exports` are ignored for local paths, and file targets are rejected. `src/` has the physical entry files (`src/index.ts`, `src/tui.tsx`); the plugin's imports resolve from the repo's `node_modules` (`npm ci` once at the repo root). The repo ships this setup as [`.test/`](.test/README.md). Two caveats: the watcher only watches package-style entries, so source edits need an OpenCode restart; and a bare package name is always npm-installed by OpenCode — it is not read from `node_modules` — so local testing must use the directory form.
 
 ```sh
+npm run dev                                           # launch the TUI against this checkout
 npm test                                              # unit + vendored-conformance suites (hermetic)
 npm run build                                         # regenerate dist/tui.js from src/tui.tsx
 MC_INTEGRATION=1 npx vitest run tests/integration/    # live-server suite (opt-in)
 ```
 
+- `npm run dev` writes a scratch project under `/tmp/opencode/model-compare-dev`, points its plugin entry at this checkout's `src/`, hides the global OpenCode config for the run (so an installed `model-compare-opencode-plugin` cannot shadow the local copy), and runs `opencode --standalone` there. The isolation is config-only: the scratch project shares your OpenCode data directory (auth, plugin state, sessions), so alias switches made in the dev session rewrite your live aliases. Pass extra flags after `--` (for example `npm run dev -- --auto`), or use `--print-config` to inspect the generated project config. `MC_DEV_DIR` overrides the scratch location. Source edits need an OpenCode restart.
 - Local development loads `src/` directly and needs no build; the *published* package does — OpenCode's Solid JSX transform skips `node_modules` paths, so the npm-installed raw TSX cannot load (see [Install](#install) and the troubleshooting entry). `npm run build` precompiles `src/tui.tsx` through the same Babel pipeline as the host's loader (taken from the pinned `@opentui/solid`) into `dist/tui.js`, rebasing relative imports from `src/`-relative to `dist/`-relative; `prepublishOnly` runs it, and CI builds before the packaging check. `dist/` is regenerated, never committed.
 - The integration files skip unless `MC_INTEGRATION=1`, so plain `npm test` stays hermetic. The suite drives a real `opencode serve` on 127.0.0.1:14721 and needs the `opencode` CLI and `python3` (skips cleanly when either is missing); one case needs network access and the `sqlite3` CLI.
 - `node scripts/pack-smoke.mjs` (also in CI, after `node scripts/build-tui.mjs`) packs the plugin and checks the tarball against the packaging list (files, `exports`, relative imports, and that the TUI artifact is precompiled — no react import). It does **not** load the package in OpenCode — install the tarball into a scratch project and confirm OpenCode loads it before publishing.
 - Publishing: cut a GitHub release tagged `vX.Y.Z` and `.github/workflows/release.yaml` stages the package on npm through trusted publishing (tokenless OIDC — no token secret; the npmjs.com trusted-publisher entry must name `release.yaml`, the `canonical/model-compare-opencode-plugin` repository and the `release` environment, with "Allow npm publish" and "Allow npm dist-tag" unchecked — stage-only, npm's recommended posture). Nothing goes live until a maintainer approves it with 2FA on npmjs.com (package page → Staged Packages) or via `npm stage approve`. The workflow fails closed when the tag does not match `package.json`'s version, and the gates (build, typecheck, tests, pack-smoke, live-remote canary) run before staging.
-- `fixtures/catalog-v0.5.0.json` is the sole contract fixture — a recorded schema-v4 catalog; `fixtures/catalog-no-quality.json` is derived from it by `scripts/make-no-quality-fixture.py` (the vendored script's own quality-blind weights, so its scores are internally consistent). No pre-v4 fixture exists; the v4-only gate rejects one. `node scripts/sync-vendor.mjs --check` verifies the pin's sha256 offline.
+- `fixtures/catalog-v0.6.0.json` is the sole contract fixture — a recorded schema-v5 catalog; `fixtures/catalog-no-quality.json` is derived from it by `scripts/make-no-quality-fixture.py` (the vendored script's own quality-blind weights, so its scores are internally consistent). No pre-v5 fixture exists; the v5-only gate rejects one. `node scripts/sync-vendor.mjs --check` verifies the pin's sha256 offline.
 - Repo layout: `src/core/` (pure ranking/pinning), `src/sources/` (local + remote acquisition), `src/opencode/` (aliases, guard, commands, storage, refresh), `dist/` (generated `tui.js` artifact, gitignored), `vendor/` (pinned upstream script), `tests/{unit,conformance,integration}`.
 
 

package/dist/tui.js

@@ -139,6 +139,68 @@ export function cappedRowsHeight(contentLines, terminalHeight) {
   return Math.min(contentLines, Math.max(1, Math.floor(terminalHeight / 2) - 6));
 }
 
+// The terminal display width of one code point, in columns: 2 for the ranges
+// terminals render double-width — East Asian Wide/Fullwidth (CJK, Hangul) and
+// the emoji/symbol planes — and 1 for everything else. Deliberately
+// CONSERVATIVE: it never undercounts the wide content the catalog can carry.
+// Blocks that are only partially wide are covered at BLOCK width — the
+// narrow tails inside the SMP symbol planes (alchemical symbols, chess)
+// count 2 anyway — and variation selector 16 (emoji presentation) counts 1
+// itself, so a base+VS16 sequence such as ☺️ always totals ≥ 2 even when the
+// base alone would not. Overcounting only makes a clamp cut
+// earlier; it can never let a line render wider than its budget. (Genuinely
+// East-Asian-Ambiguous characters OUTSIDE these ranges — ±, an en dash,
+// Greek — count 1; a terminal font that renders those wide is beyond the
+// clamp's scope. Catalog text is sanitized to a single line by
+// sanitizeCatalogText, so width is the only wrap risk left.)
+function charWidth(codePoint) {
+  // Variation selectors (VS1–VS16) are zero-width in reality. VS16 forces
+  // emoji presentation on the preceding base, so the pair renders 2 columns:
+  // counting the selector itself as 1 keeps any base+VS16 sequence at ≥ 2
+  // even when the base is NOT in a wide block (⌨️ = U+2328+VS16), while a
+  // wide base + VS16 overcounts by one — the safe direction.
+  if (codePoint >= 0xfe00 && codePoint <= 0xfe0f) return 1;
+  if (codePoint >= 0x1100 && codePoint <= 0x115f ||
+  // Hangul Jamo
+  codePoint >= 0x2e80 && codePoint <= 0xa4cf ||
+  // CJK radicals … Yi
+  codePoint >= 0xa960 && codePoint <= 0xa97f ||
+  // Hangul Jamo Ext. A
+  codePoint >= 0xac00 && codePoint <= 0xd7a3 ||
+  // Hangul syllables
+  codePoint >= 0xf900 && codePoint <= 0xfaff ||
+  // CJK compat ideographs
+  codePoint >= 0xfe10 && codePoint <= 0xfe19 ||
+  // vertical forms
+  codePoint >= 0xfe30 && codePoint <= 0xfe6f ||
+  // CJK compat forms
+  codePoint >= 0xff00 && codePoint <= 0xff60 ||
+  // fullwidth forms
+  codePoint >= 0xffe0 && codePoint <= 0xffe6 ||
+  // fullwidth signs
+  codePoint >= 0x2600 && codePoint <= 0x27bf ||
+  // misc symbols + dingbats (☺ ✨ ⚠ — ambiguous, commonly 2 under emoji presentation)
+  codePoint >= 0x2b00 && codePoint <= 0x2bff ||
+  // misc symbols and arrows (⭐)
+  codePoint >= 0x1f000 && codePoint <= 0x1faff ||
+  // the SMP symbol planes: mahjong/cards, enclosed ideographs, pictographs, transport (🚀), supplemental, symbols ext-A
+  codePoint >= 0x20000 && codePoint <= 0x2fffd ||
+  // CJK ext B+
+  codePoint >= 0x30000 && codePoint <= 0x3fffd // CJK ext G+
+  ) {
+    return 2;
+  }
+  return 1;
+}
+
+// A string's terminal display width (the sum of its code points' widths).
+// Exported for the unit rig, which asserts rendered lines against it.
+export function strWidth(value) {
+  let width = 0;
+  for (const char of value) width += charWidth(char.codePointAt(0));
+  return width;
+}
+
 // One report entry's defensive normalization, shared by the two paths that
 // carry report data across a trust boundary (the /model-compare command's
 // event and the TUI's direct RPC call): an entry missing any identity field
@@ -157,6 +219,8 @@ function toReportEntries(raw) {
       value: entry.value,
       score: typeof entry.score === "string" ? entry.score : "-",
       quality: typeof entry.quality === "string" ? entry.quality : "-",
+      effort: typeof entry.effort === "string" ? entry.effort : "",
+      alternative: typeof entry.alternative === "string" ? entry.alternative : "",
       price: typeof entry.price === "string" ? entry.price : "-",
       current: entry.current === true,
       fromFallback: entry.fromFallback === true
@@ -627,14 +691,26 @@ export default Plugin.define({
             })();
           });
         });
+        _$insert(_el$2, () => {
+          const row = selectable[cursor()];
+          return row.status === undefined ? null : (() => {
+            var _el$18 = _$createElement("box"),
+              _el$19 = _$createElement("text");
+            _$insertNode(_el$18, _el$19);
+            _$setProp(_el$18, "paddingLeft", 4);
+            _$setProp(_el$19, "fg", muted);
+            _$insert(_el$19, () => row.status);
+            return _el$18;
+          })();
+        }, _el$8);
         _$insert(_el$2, () => footerLines.map(line => (() => {
-          var _el$18 = _$createElement("box"),
-            _el$19 = _$createElement("text");
-          _$insertNode(_el$18, _el$19);
-          _$setProp(_el$18, "paddingLeft", 4);
-          _$setProp(_el$19, "fg", muted);
-          _$insert(_el$19, line);
-          return _el$18;
+          var _el$20 = _$createElement("box"),
+            _el$21 = _$createElement("text");
+          _$insertNode(_el$20, _el$21);
+          _$setProp(_el$20, "paddingLeft", 4);
+          _$setProp(_el$21, "fg", muted);
+          _$insert(_el$21, line);
+          return _el$20;
         })()), _el$8);
         _$insertNode(_el$8, _el$9);
         _$setProp(_el$8, "paddingLeft", 4);
@@ -694,33 +770,76 @@ export default Plugin.define({
         notify("no ranking data available yet", "error");
         return;
       }
-      // The approved table: one dim column header at the top (directly above
-      // the first section), section headings with a blank line above all but
-      // the first, and right-justified quality/price columns. No score
-      // column — the transcript's text report keeps it. Column widths are
-      // clamped (qual ≤ 8, $ in/out ≤ 16) and oversized cells are truncated
-      // to their clamped width, so with the name clamp below the row budget
-      // holds even for hostile/absurd column strings: what the clamp
-      // guarantees is that a row and the header stay within the dialog's
-      // fixed 52-char content width (hostile values get truncated rather
-      // than pushed into wrapping — the 40-char rankless fallback label did
-      // exactly that before the name clamp).
+      // The approved table now carries three columns: model name, quality
+      // and price. The scored variant (the catalog's effort) and the best
+      // higher variant moved into a cursor-following status line below the
+      // list (see ListRow.status), so the table stays readable. No score
+      // column — the transcript's text report keeps it. Column widths are clamped
+      // (qual ≤ 5, $ in/out ≤ 13) and oversized cells are truncated to their
+      // clamped width, so with the name clamp below the row budget holds
+      // even for hostile/absurd column strings: what the clamp guarantees is
+      // that a row and the header stay within the dialog's fixed 52-char
+      // content width (hostile values get truncated rather than pushed into
+      // wrapping — the 40-char rankless fallback label did exactly that
+      // before the name clamp).
       const labels = data.entries.map(entry => `${entry.rank === null ? "·" : entry.rank}. ${entry.id}${entry.fromFallback ? " (fallback)" : ""}`);
       const labelOf = new Map(data.entries.map((entry, index) => [entry, labels[index]]));
-      const colW = (values, floor, cap) => Math.min(cap, Math.max(floor, ...values.map(value => value.length)));
-      const qualW = colW(data.entries.map(entry => entry.quality), "qual".length, 8);
-      const priceW = colW(data.entries.map(entry => entry.price), "$ in/out".length, 16);
-      // A cell wider than its clamped column is truncated to fit.
-      const cell = (value, width) => value.length > width ? value.slice(0, width - 1) + "…" : value;
+      const colW = (values, floor, cap) => Math.min(cap, Math.max(floor, ...values.map(strWidth)));
+      // Quality is a one-decimal AA index (max "100.0"); the caps leave the
+      // 52-char row budget intact (see `fixed` below) while fitting real
+      // values: "10.00/100.00" (price).
+      const qualW = colW(data.entries.map(entry => entry.quality), "qual".length, 5);
+      // The status line's variant and best-higher-variant cells keep their
+      // old column caps: the status box is a direct child of the 60-wide
+      // dialog with only its own 4-char left inset, so one text line has 56
+      // columns — the worst case, 9 ("variant: ") + 7 + 24 (" · best higher
+      // variant: ") + 13 = 53, leaves 3 columns of slack. Clamping each cell
+      // (in display columns, see cell) keeps hostile catalog strings from
+      // wrapping.
+      const effortW = 7;
+      const altW = 13;
+      const priceW = colW(data.entries.map(entry => entry.price), "$ in/out".length, 13);
+      // A cell wider than its clamped column is truncated to fit — measured
+      // in terminal COLUMNS (strWidth), not string length: a 7-code-point
+      // CJK effort label renders 14 columns wide and would push the row
+      // past its budget if length were the measure.
+      const cell = (value, width) => {
+        if (strWidth(value) <= width) return value;
+        // Reserve one column for the ellipsis; walk whole code points so a
+        // wide char is never cut in half.
+        let used = 0;
+        let out = "";
+        for (const char of value) {
+          const w = charWidth(char.codePointAt(0));
+          if (used + w > width - 1) break;
+          out += char;
+          used += w;
+        }
+        return `${out}…`;
+      };
+      // The pads match cell's measure, so a truncated wide cell and its
+      // padding land on the same column arithmetic (padEnd keeps the
+      // prices' flush right edges — see below).
+      const padEndW = (value, width) => value + " ".repeat(Math.max(0, width - strWidth(value)));
+      const padStartW = (value, width) => " ".repeat(Math.max(0, width - strWidth(value))) + value;
       // Prices use padEnd (not padStart): padded to a common width the
       // right edges stay flush while the fixed 2-space gap between columns
       // stays exactly 2 (padStart pushed each value right by its slack).
       // The default dialog is 60 wide: 2 list insets + 6 row insets leave 52
       // for row content; the header shares that budget (plus its 3-indent).
+      // Column caps keep the budget even for hostile strings: 5+13 plus the
+      // two 2-char paddings and the 2-char row indent = 24, leaving plenty
+      // for the name (the name column shrinks first for real content).
       const fixed = 2 + qualW + 2 + priceW;
-      const nameW = Math.max(8, Math.min(52 - fixed, Math.max(...labels.map(label => label.length))));
-      const trim = label => label.length > nameW ? label.slice(0, nameW - 1) + "…" : label;
+      const nameW = Math.max(6, Math.min(52 - fixed, Math.max(...labels.map(strWidth))));
+      const trim = label => cell(label, nameW);
       const headerLine = "   " + " ".repeat(nameW) + "  " + "qual".padStart(qualW) + "  " + "$ in/out".padEnd(priceW);
+      // Catalog v5 calls this the effort the quality was measured at, and the
+      // best selectable measured alternative ("max 56.0"). OpenCode calls the
+      // selectable option a VARIANT, so the TUI uses "variant" throughout to
+      // match what the user sees in OpenCode's model picker. A missing value
+      // is "-", and "best higher variant" spells out what "alt" meant.
+      const statusOf = entry => `variant: ${cell(entry.effort || "-", effortW)} · best higher variant: ${cell(entry.alternative || "-", altW)}`;
       const rows = [{
         label: "",
         headerLine
@@ -734,8 +853,9 @@ export default Plugin.define({
         });
         for (const entry of section) {
           rows.push({
-            label: trim(labelOf.get(entry) ?? "").padEnd(nameW),
-            columns: "  " + cell(entry.quality, qualW).padStart(qualW) + "  " + cell(entry.price, priceW).padEnd(priceW),
+            label: padEndW(trim(labelOf.get(entry) ?? ""), nameW),
+            columns: "  " + padStartW(cell(entry.quality, qualW), qualW) + "  " + padEndW(cell(entry.price, priceW), priceW),
+            status: statusOf(entry),
             // F-20 id split: the row DISPLAYS the sanitized id (in `label`)
             // but picks `value`, the raw catalog id switchToModel needs.
             value: entry.value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "model-compare-opencode-plugin",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "OpenCode plugin that switches OpenRouter model aliases to the best value-for-money pick from canonical/model-compare's ranking (balanced, price, quality).",
   "keywords": [
     "opencode",
@@ -39,6 +39,7 @@
   },
   "scripts": {
     "build": "node scripts/build-tui.mjs",
+    "dev": "node scripts/dev-local.mjs",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build && npm run typecheck && npm test && node scripts/pack-smoke.mjs"

package/src/core/catalog.ts

@@ -1,9 +1,16 @@
 // src/core/catalog.ts
-// Catalog document validation (design §5). Accepts schema v4 documents (only) from
+// Catalog document validation (design §5). Accepts schema v5 documents (only) from
 // either source (vendored script or remote catalog) and projects them onto
 // the plugin's Catalog type. Validation only — ranking lives elsewhere.
 
-import type { Catalog, ModelEntry, Priority, Weights } from "./types"
+import type {
+  Catalog,
+  ModelEntry,
+  Priority,
+  Reasoning,
+  ReasoningDepth,
+  Weights,
+} from "./types"
 
 const PRIORITIES: readonly Priority[] = ["balanced", "price", "quality"]
 const SCORE_KEYS = ["quality", "price", "context", "age"] as const
@@ -44,18 +51,67 @@ function steer(raw: unknown): ModelEntry["steering"] {
   return steering
 }
 
+function finiteOrNull(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null
+}
+
+function stringOrNull(value: unknown): string | null {
+  return typeof value === "string" ? value : null
+}
+
+function boolOrNull(value: unknown): boolean | null {
+  return typeof value === "boolean" ? value : null
+}
+
+// The v5 reasoning block (display + request injection). Field-by-field
+// projection, never a spread of the raw object: a hostile catalogURL serves
+// arbitrary JSON here, and only the fields the plugin reads survive. A
+// non-object block reads as absent; a malformed field reads as its neutral
+// value (empty list / null) rather than rejecting the whole catalog — the
+// block is advisory metadata, not ranking input. Depth records without a
+// non-empty string effort are dropped; every other depth field is nullable.
+function projectReasoning(raw: unknown): Reasoning | undefined {
+  if (!isObject(raw)) return undefined
+  const supported =
+    Array.isArray(raw.supported_efforts) && raw.supported_efforts.every((effort) => typeof effort === "string")
+      ? [...(raw.supported_efforts as string[])]
+      : []
+  const depths: ReasoningDepth[] = []
+  if (Array.isArray(raw.depths)) {
+    for (const record of raw.depths) {
+      if (!isObject(record)) continue
+      if (typeof record.effort !== "string" || record.effort === "") continue
+      depths.push({
+        effort: record.effort,
+        index: finiteOrNull(record.index),
+        cost_per_task_usd: finiteOrNull(record.cost_per_task_usd),
+        source: stringOrNull(record.source),
+        as_of: stringOrNull(record.as_of),
+      })
+    }
+  }
+  return {
+    default_effort: stringOrNull(raw.default_effort),
+    supported_efforts: supported,
+    default_enabled: boolOrNull(raw.default_enabled),
+    mandatory: boolOrNull(raw.mandatory),
+    supports_max_tokens: boolOrNull(raw.supports_max_tokens),
+    depths,
+  }
+}
+
 export function validateCatalog(
   raw: unknown,
 ): { ok: true; catalog: Catalog } | { ok: false; reason: string } {
   if (!isObject(raw)) return { ok: false, reason: "catalog must be a JSON object" }
 
-  // Supported schema: v4 only — upstream's current contract (0.5.0's
-  // schema_version 4). The v4 changes are additive provenance (per-model
-  // quality_as_of/quality_drift, a reshaped sources.aa block) and change
-  // nothing this validator reads; every other version is rejected with the
-  // reason string the canary and the stored-document path rely on.
-  if (raw.schema_version !== 4) {
-    return { ok: false, reason: `schema_version must be 4, got ${JSON.stringify(raw.schema_version)}` }
+  // Supported schema: v5 only — upstream's current contract (0.6.0's
+  // schema_version 5). v5 changes the meaning of `quality` (the AA score at
+  // the selected/default reasoning effort) and adds per-model
+  // `quality_effort` and `reasoning`; every other version is rejected with
+  // the reason string the canary and the stored-document path rely on.
+  if (raw.schema_version !== 5) {
+    return { ok: false, reason: `schema_version must be 5, got ${JSON.stringify(raw.schema_version)}` }
   }
   if (typeof raw.generated_at !== "string") {
     return { ok: false, reason: "generated_at must be a string" }
@@ -160,12 +216,17 @@ export function validateCatalog(
     const input = pricing.input_per_1m
     const output = pricing.output_per_1m
     // The steering block projects (or reads as absent) per the steer() rules.
-    // The assignment sits AFTER the spread so it explicitly overrides the raw
-    // block that `...entry` would otherwise carry through verbatim — a
-    // hostile steering block must never survive onto the projected entry.
+    // The v5 quality_effort/reasoning fields project the same way: strip the
+    // raw keys before the spread so the camelCase projection is the only
+    // representation on the entry (a hostile block never survives verbatim).
+    const { steering: _rawSteering, quality_effort: _rawQualityEffort, reasoning: _rawReasoning, ...passthrough } =
+      entry
     const steering = steer(entry.steering)
+    const qualityEffort =
+      typeof entry.quality_effort === "string" && entry.quality_effort !== "" ? entry.quality_effort : null
+    const reasoning = projectReasoning(entry.reasoning)
     models.push({
-      ...entry,
+      ...passthrough,
       id: entry.id,
       name: entry.name,
       pricing: {
@@ -177,6 +238,8 @@ export function validateCatalog(
       context: entry.context,
       scores: { ...components, overall },
       quality,
+      qualityEffort,
+      reasoning,
       steering,
     })
   }
@@ -220,14 +283,33 @@ export function validateStoredCatalog(
   stored: unknown,
 ): { ok: true; catalog: Catalog } | { ok: false; reason: string } {
   if (!isObject(stored)) return { ok: false, reason: "stored catalog must be an object" }
+  // v5 projections always carry qualityEffort (null or a string). A record
+  // written by a pre-v5 plugin lacks it: accepting it would mix v4's max-row
+  // quality with v5's default-effort semantics, so it is a cache miss.
+  if (Array.isArray(stored.models)) {
+    for (const [i, entry] of stored.models.entries()) {
+      if (isObject(entry) && !Object.hasOwn(entry, "qualityEffort")) {
+        return { ok: false, reason: `models[${i}].qualityEffort is missing (not a v5 catalog)` }
+      }
+    }
+  }
   const models = Array.isArray(stored.models)
     ? stored.models.map((entry) => {
-        if (!isObject(entry) || entry.steering === undefined) return entry
-        return { ...entry, steering: { model: entry.id, provider: entry.steering } }
+        if (!isObject(entry)) return entry
+        // The projection renamed quality_effort to qualityEffort and unwrapped
+        // steering; rebuild the raw v5 shape. A hand-edited record re-projects
+        // (or reads as absent) exactly like a raw one would.
+        const raw: Record<string, unknown> = {
+          ...entry,
+          quality_effort: entry.qualityEffort ?? null,
+        }
+        if (entry.reasoning !== undefined) raw.reasoning = entry.reasoning
+        if (entry.steering !== undefined) raw.steering = { model: entry.id, provider: entry.steering }
+        return raw
       })
     : stored.models
   return validateCatalog({
-    schema_version: 4,
+    schema_version: 5,
     generated_at: stored.generatedAt,
     parameters: { weights: stored.weights },
     models,

package/src/core/reasoning.ts

@@ -0,0 +1,96 @@
+// src/core/reasoning.ts
+// Reasoning-depth helpers (catalog v5): gateway-effort validation, the
+// selectable-depth rule, and the best measured alternative to the effort a
+// model was scored at. Pure functions over a projected ModelEntry — no I/O,
+// no OpenCode imports.
+//
+// The selectable rule is upstream's site rule (web/site/app.js depthRows):
+// OpenRouter can select an effort only when the model's expanded
+// `supported_efforts` lists it (or the model is a single-state toggle that
+// exposes `#none`). An AA row for an unlisted effort is display-only and is
+// never advertised as an alternative. The catalog's `reasoning` sentinel is a
+// producer label for a single-state reasoning model, not a gateway value.
+
+import type { ModelEntry, Reasoning } from "./types"
+
+// What OpenRouter accepts as a discrete effort. Mirrors upstream's
+// REASONING_GATEWAY_EFFORTS. Deliberately excludes the catalog sentinels
+// "reasoning" and "default".
+export const GATEWAY_EFFORTS = ["max", "xhigh", "high", "medium", "low", "minimal", "none"] as const
+
+// Deepest-first display order, mirroring upstream's AA_EFFORT_ORDER.
+const EFFORT_ORDER: readonly string[] = [...GATEWAY_EFFORTS, "reasoning"]
+
+export function gatewayEffort(value: string | null | undefined): string | null {
+  return value !== null && value !== undefined && (GATEWAY_EFFORTS as readonly string[]).includes(value)
+    ? value
+    : null
+}
+
+function effortOrder(effort: string): number {
+  const index = EFFORT_ORDER.indexOf(effort)
+  return index === -1 ? EFFORT_ORDER.length : index
+}
+
+// Upstream's v5 non-reasoning rule (the producer's is_reasoning flag is not
+// published): no reasoning metadata at all, so the bare id is the only form.
+function isNonReasoningBlock(reasoning: Reasoning): boolean {
+  return (
+    reasoning.default_effort === "none" &&
+    reasoning.default_enabled !== false &&
+    reasoning.mandatory !== true &&
+    reasoning.supports_max_tokens !== true
+  )
+}
+
+// A single-state reasoning model with reasoning off by default exposes only
+// the "#none" toggle.
+function isSingleStateToggle(reasoning: Reasoning): boolean {
+  return reasoning.mandatory !== true && reasoning.default_enabled === false
+}
+
+export function isSelectableDepth(model: ModelEntry, effort: string): boolean {
+  if (effort === "reasoning") return false
+  const reasoning = model.reasoning
+  if (reasoning === undefined) return false
+  if (reasoning.supported_efforts.includes(effort)) return true
+  if (effort !== "none" || reasoning.supported_efforts.length > 0) return false
+  if (isNonReasoningBlock(reasoning)) return false
+  return isSingleStateToggle(reasoning)
+}
+
+export type DepthAlternative = {
+  effort: string
+  index: number
+  cost: number | null
+}
+
+// The best measured, selectable effort that scores strictly higher than the
+// effort `quality` already represents. Unselectable rows never qualify; ties
+// resolve to the deeper effort (the display order).
+export function bestDepthAlternative(model: ModelEntry): DepthAlternative | null {
+  const base = model.quality
+  const selected = model.qualityEffort
+  const reasoning = model.reasoning
+  if (base == null || selected == null || reasoning === undefined) return null
+
+  const depths = [...reasoning.depths].sort((a, b) => effortOrder(a.effort) - effortOrder(b.effort))
+  let best: DepthAlternative | null = null
+  for (const depth of depths) {
+    if (depth.index === null || depth.effort === selected) continue
+    if (!isSelectableDepth(model, depth.effort)) continue
+    if (depth.index <= base) continue
+    if (best === null || depth.index > best.index) {
+      best = { effort: depth.effort, index: depth.index, cost: depth.cost_per_task_usd }
+    }
+  }
+  return best
+}
+
+// The report's compact alternative label: "<effort> <index>" ("max 56.0"),
+// the same shape upstream's site shows under QUAL. Empty when there is none.
+export function formatDepthAlternative(model: ModelEntry | undefined): string {
+  if (model === undefined) return ""
+  const best = bestDepthAlternative(model)
+  return best === null ? "" : `${best.effort} ${best.index.toFixed(1)}`
+}