model-compare-opencode-plugin 0.6.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). 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> · <effort> [alt <effort> <index>]`, with `(fallback)` while the fallback is serving, `(unavailable)` when the alias is disabled, and the `alt` part naming the best measured effort above the current one that OpenRouter can actually select.
+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; 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 `effort` and `alt` columns.
+- `/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). The picker's alias name carries the effort and alternative; 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.
+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
@@ -201,11 +203,13 @@ 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.

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
@@ -629,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);
@@ -696,43 +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 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: "minimal" (effort), "minimal 100.0" (alt), "10.00/100.00".
+      // values: "10.00/100.00" (price).
       const qualW = colW(data.entries.map(entry => entry.quality), "qual".length, 5);
-      // Catalog v5: the effort the quality was measured at and the best
-      // selectable measured alternative ("max 56.0"). A missing value is "-".
-      const effortW = colW(data.entries.map(entry => entry.effort || "-"), "effort".length, 7);
-      const altW = colW(data.entries.map(entry => entry.alternative || "-"), "alt".length, 13);
+      // 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.
-      const cell = (value, width) => value.length > width ? value.slice(0, width - 1) + "…" : value;
+      // 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+7+13+13 plus
-      // the four 2-char paddings and the 2-char row indent = 46, leaving the
-      // name floor of 6 (the name column shrinks first for real content).
-      const fixed = 2 + qualW + 2 + effortW + 2 + altW + 2 + priceW;
-      const nameW = Math.max(6, Math.min(52 - fixed, Math.max(...labels.map(label => label.length))));
-      const trim = label => label.length > nameW ? label.slice(0, nameW - 1) + "…" : label;
-      const headerLine = "   " + " ".repeat(nameW) + "  " + "qual".padStart(qualW) + "  " + "effort".padStart(effortW) + "  " + "alt".padEnd(altW) + "  " + "$ in/out".padEnd(priceW);
+      // 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(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
@@ -746,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.effort || "-", effortW).padStart(effortW) + "  " + cell(entry.alternative || "-", altW).padEnd(altW) + "  " + 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.6.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/index.ts

@@ -335,11 +335,9 @@ function applyAliases(state: WireState, editor: AliasEditor): void {
     // plan: planAlias only checks for undefined (it never reads model
     // internals — the applier does, below).
     const source = target.id === null ? undefined : editor.get(ALIAS_PROVIDER, target.id)
-    // The concrete editor model proves presence; the catalog entry supplies
-    // the v5 effort/alternative labels (the editor model has no ranking data).
-    const catalogModel =
-      target.id === null ? undefined : state.sourced?.doc.models.find((entry) => entry.id === target.id)
-    const plan = planAlias(p, target, source as unknown as ModelEntry | undefined, catalogModel)
+    // The concrete editor model is the presence proof; the display name
+    // carries only the pick (OpenCode renders the selected variant itself).
+    const plan = planAlias(p, target, source as unknown as ModelEntry | undefined)
 
     if (plan.enabled && plan.modelID !== null && source !== undefined) {
       editor.update(ALIAS_PROVIDER, aliasId(p), (model) => {

package/src/opencode/aliases.ts

@@ -5,7 +5,6 @@
 // is the applier's job (it reads them through editor.get), so this module never
 // touches model internals.
 
-import { formatDepthAlternative } from "../core/reasoning"
 import type { ModelEntry, Priority } from "../core/types"
 import { sanitizeCatalogText } from "./commands"
 
@@ -26,16 +25,14 @@ export type AliasPlan = {
 // silently skipped. `model` is undefined when the pick's model was removed by
 // another plugin, or when there is no catalog to look it up in.
 //
-// `displayModel` is the CATALOG entry for the same pick: the applier's
-// presence proof is the editor's concrete model (which carries no ranking
-// metadata), so the effort/alternative label reads the catalog entry instead.
-// Absent (a fallback pick with no catalog, or a caller that has only the
-// editor model) falls back to `model`.
+// The display name carries ONLY the pick (plus the fallback marker). OpenCode
+// shows the selected variant beside the model itself, so baking the catalog's
+// scored effort/alternative into the name would show a stale depth that does
+// not follow the user's `#variant` selection.
 export function planAlias(
   p: Priority,
   target: AliasTarget,
   model: ModelEntry | undefined,
-  displayModel?: ModelEntry,
 ): AliasPlan {
   if (target.id === null) {
     return {
@@ -53,19 +50,14 @@ export function planAlias(
       warnings: [`pick model ${target.id} missing from catalog for ${p}`],
     }
   }
-  // The effort the pick's score represents, followed by the best measured
-  // selectable alternative (catalog v5). Both are catalog-derived and
-  // flattened (F-20) for the model picker, the TUI status line and dialogs;
-  // `modelID` stays RAW — switching needs the real id.
-  const shown = displayModel ?? model
-  const effort =
-    shown.qualityEffort == null ? "" : ` · ${sanitizeCatalogText(shown.qualityEffort)}`
-  const alternative = formatDepthAlternative(shown)
+  // The pick is catalog-derived, so it is flattened (F-20) for the model
+  // picker and the TUI status line; `modelID` stays RAW — switching needs the
+  // real id.
   return {
     modelID: target.id,
-    name: `Model Compare: ${p} → ${sanitizeCatalogText(target.id)}${effort}${
+    name: `Model Compare: ${p} → ${sanitizeCatalogText(target.id)}${
       target.fromFallback ? " (fallback)" : ""
-    }${alternative === "" ? "" : ` [alt ${sanitizeCatalogText(alternative)}]`}`,
+    }`,
     enabled: true,
     warnings: [],
   }

package/src/opencode/usebest.ts

@@ -81,18 +81,19 @@ export function readAliasViews(
 
 // The pick shown in an alias's display name:
 // "Model Compare: <p> → <pick>[ (fallback)]" → "<pick>[ (fallback)]", or null
-// for the "(unavailable)" placeholder names. A v5 name appends the scored
-// effort and the best alternative (" · high [alt max 56.0]") AFTER the pick
-// (the fallback marker stays between them); those annotations are stripped so
-// the status line and toasts still name the served model, not its depth.
+// for the "(unavailable)" placeholder names. Older v5 names appended the
+// scored effort and the best alternative (" · high [alt max 56.0]") after the
+// pick; those annotations are no longer written, but remain stripped so a
+// registry entry left by an older plugin still names the served model.
 export function pickFromName(name: string): string | null {
   const arrow = name.indexOf("→")
   if (arrow === -1) return null
   const rest = name.slice(arrow + 1).replace(/ \[alt .*\]$/, "")
-  // Our name builder separates the pick from its v5 annotations with " · ";
-  // OpenRouter ids contain no spaces, so the first segment is the pick. The
-  // fallback marker lives in the annotation segment (or already after a pick
-  // with no annotations), so carry it over exactly once.
+  // Legacy v5 names (no longer written — see above) separated the pick from
+  // its annotations with " · "; OpenRouter ids contain no spaces, so the
+  // first segment is the pick. The fallback marker lives in the annotation
+  // segment (or already after a pick with no annotations), so carry it over
+  // exactly once.
   const [pick, ...annotations] = rest.split(" · ")
   const fallback = annotations.join(" ").includes("(fallback)") ? " (fallback)" : ""
   return `${pick.trim()}${fallback}`

package/src/tui.tsx

@@ -117,6 +117,10 @@ type ListRow = {
   // Trailing dim right-justified columns (the report table); when
   // present, label renders in its own span so the two tones can differ.
   columns?: string
+  // The cursor-following status line (the report table's variant and best
+  // higher variant): the dialog renders this row's status below the list and
+  // swaps it as the cursor moves.
+  status?: string
   selected?: string
   value?: string
   dim?: boolean
@@ -162,6 +166,56 @@ export function cappedRowsHeight(contentLines: number, terminalHeight: number):
   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: number): number {
+  // 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: string): number {
+  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
@@ -645,6 +699,14 @@ export default Plugin.define({
                 })
               })()}
             </scrollbox>
+            {(() => {
+              const row = selectable[cursor()]
+              return row.status === undefined ? null : (
+                <box paddingLeft={4}>
+                  <text fg={muted}>{row.status}</text>
+                </box>
+              )
+            })()}
             {footerLines.map((line) => (
               <box paddingLeft={4}>
                 <text fg={muted}>{line}</text>
@@ -708,17 +770,18 @@ 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}${
@@ -727,42 +790,74 @@ export default Plugin.define({
       )
       const labelOf = new Map(data.entries.map((entry, index) => [entry, labels[index]]))
       const colW = (values: string[], floor: number, cap: number): number =>
-        Math.min(cap, Math.max(floor, ...values.map((value) => value.length)))
+        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: "minimal" (effort), "minimal 100.0" (alt), "10.00/100.00".
+      // values: "10.00/100.00" (price).
       const qualW = colW(data.entries.map((entry) => entry.quality), "qual".length, 5)
-      // Catalog v5: the effort the quality was measured at and the best
-      // selectable measured alternative ("max 56.0"). A missing value is "-".
-      const effortW = colW(data.entries.map((entry) => entry.effort || "-"), "effort".length, 7)
-      const altW = colW(data.entries.map((entry) => entry.alternative || "-"), "alt".length, 13)
+      // 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.
-      const cell = (value: string, width: number): string =>
-        value.length > width ? value.slice(0, width - 1) + "…" : value
+      // 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: string, width: number): string => {
+        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: string, width: number): string =>
+        value + " ".repeat(Math.max(0, width - strWidth(value)))
+      const padStartW = (value: string, width: number): string =>
+        " ".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+7+13+13 plus
-      // the four 2-char paddings and the 2-char row indent = 46, leaving the
-      // name floor of 6 (the name column shrinks first for real content).
-      const fixed = 2 + qualW + 2 + effortW + 2 + altW + 2 + priceW
-      const nameW = Math.max(6, Math.min(52 - fixed, Math.max(...labels.map((label) => label.length))))
-      const trim = (label: string): string =>
-        label.length > nameW ? label.slice(0, nameW - 1) + "…" : label
+      // 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(6, Math.min(52 - fixed, Math.max(...labels.map(strWidth))))
+      const trim = (label: string): string => cell(label, nameW)
       const headerLine =
         "   " +
         " ".repeat(nameW) +
         "  " +
         "qual".padStart(qualW) +
         "  " +
-        "effort".padStart(effortW) +
-        "  " +
-        "alt".padEnd(altW) +
-        "  " +
         "$ 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: ReportEntry): string =>
+        `variant: ${cell(entry.effort || "-", effortW)} · best higher variant: ${cell(
+          entry.alternative || "-",
+          altW,
+        )}`
       const rows: ListRow[] = [{ label: "", headerLine }]
       for (const priority of PRIORITIES) {
         const section = data.entries.filter((entry) => entry.priority === priority)
@@ -770,16 +865,13 @@ export default Plugin.define({
         rows.push({ heading: priority, label: "" })
         for (const entry of section) {
           rows.push({
-            label: trim(labelOf.get(entry) ?? "").padEnd(nameW),
+            label: padEndW(trim(labelOf.get(entry) ?? ""), nameW),
             columns:
               "  " +
-              cell(entry.quality, qualW).padStart(qualW) +
-              "  " +
-              cell(entry.effort || "-", effortW).padStart(effortW) +
-              "  " +
-              cell(entry.alternative || "-", altW).padEnd(altW) +
+              padStartW(cell(entry.quality, qualW), qualW) +
               "  " +
-              cell(entry.price, priceW).padEnd(priceW),
+              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,