model-compare-opencode-plugin 0.5.0 → 0.6.1

package/src/core/steering.ts

@@ -12,6 +12,7 @@
 // and the steeringFor cases here); a semantic change to one must be mirrored
 // in the other.
 
+import { gatewayEffort } from "./reasoning"
 import type { ModelEntry, Priority } from "./types"
 
 // A model reference as the hook event carries it (`event.model`), mirroring
@@ -75,6 +76,30 @@ export function steeringFor(
   return models.get(pick.id)?.steering ?? null
 }
 
+// The reasoning effort an alias request must pin, or null when it must not:
+// the same alias/body/pick/model gates as steeringFor, plus the explicit
+// variant rule. `#variant` is OpenCode's per-request selection (the event
+// carries it on `model.variant`); "default" is the no-selection sentinel
+// OpenCode stamps on `--model` refs (spike fact 1), so it does NOT count as an
+// explicit variant. The catalog's `quality_effort` is the effort the score was
+// measured at; the "reasoning" sentinel is a producer label and is never sent
+// to the gateway.
+export function reasoningEffortFor(
+  eventModel: ModelRef,
+  variant: string | undefined,
+  bodyModel: string | undefined,
+  picks: Partial<Record<Priority, AliasTarget>>,
+  models: Map<string, ModelEntry>,
+): string | null {
+  const p = aliasPriority(eventModel)
+  if (p === null) return null
+  if (variant !== undefined && variant !== "default") return null
+  const pick = picks[p]
+  if (pick === undefined || pick.id === null) return null
+  if (bodyModel !== undefined && bodyModel !== pick.id) return null
+  return gatewayEffort(models.get(pick.id)?.qualityEffort)
+}
+
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value)
 }
@@ -103,6 +128,17 @@ export function injectSteering(body: unknown, steering: Steering): unknown {
   }
 }
 
+// The body with `reasoning: { effort }` added — or the input untouched when
+// it already carries `reasoning` or the legacy `reasoning_effort` field (an
+// explicit #variant, user config or another plugin wins; the plugin never
+// clobbers a reasoning choice it did not make) or is not a JSON object.
+// Reference inequality is the wiring's "re-create the Request" signal.
+export function injectReasoning(body: unknown, effort: string): unknown {
+  if (!isPlainObject(body)) return body
+  if (Object.hasOwn(body, "reasoning") || Object.hasOwn(body, "reasoning_effort")) return body
+  return { ...body, reasoning: { effort } }
+}
+
 // normalize_provider (vendor/model_compare.py): casefold the name and strip
 // ALL non-alphanumeric characters — "Z.AI", "z-ai" and "z ai" all normalize
 // to "zai". JS toLowerCase stands in for Python's casefold (provider display

package/src/core/types.ts

@@ -6,6 +6,31 @@ export type Priority = "balanced" | "price" | "quality"
 
 export type Weights = { quality: number; price: number; context: number; age: number }
 
+// One measured reasoning effort (catalog v5): the AA intelligence index at
+// that effort, AA's reference-price benchmark cost per task (display-only,
+// never scored), and the record's provenance. `null` marks a missing value;
+// the record itself survives so the effort can still be offered as a variant.
+export type ReasoningDepth = {
+  effort: string
+  index: number | null
+  cost_per_task_usd: number | null
+  source: string | null
+  as_of: string | null
+}
+
+// The v5 per-model reasoning block. `supported_efforts` is what OpenRouter
+// accepts as a discrete effort (expanded upstream, never null); `depths` is
+// what some source measured (empty when nothing did). The raw flags are kept
+// for provenance and for the single-state/non-reasoning display rules.
+export type Reasoning = {
+  default_effort: string | null
+  supported_efforts: string[]
+  default_enabled: boolean | null
+  mandatory: boolean | null
+  supports_max_tokens: boolean | null
+  depths: ReasoningDepth[]
+}
+
 export type ModelEntry = {
   id: string
   name: string
@@ -20,6 +45,14 @@ export type ModelEntry = {
   }
   context: number
   quality: number | null
+  // The effort `quality` was measured at (catalog v5 `quality_effort`). The
+  // alias request pins exactly this effort; the sentinel "reasoning" is a
+  // catalog label, never a gateway value. Optional only for hand-built /
+  // legacy projected entries: validateCatalog always writes it (null or a
+  // string), and validateStoredCatalog requires it on cached records.
+  qualityEffort?: string | null
+  // Present when the raw block projects cleanly (absent stays absent).
+  reasoning?: Reasoning
   // The steering block (F-11/F-12): upstream records the provider's
   // endpoint-routing hints as { model, provider: { order, ignore,
   // quantizations?, allow_fallbacks } }; the projection unwraps the provider
@@ -47,7 +80,7 @@ export type Catalog = {
   models: ModelEntry[]
 }
 
-// Upstream.s PRIORITY_WEIGHTS at the pinned tag (v0.5.0; unchanged since v0.3.0). Used when a
+// Upstream's PRIORITY_WEIGHTS at the pinned tag (v0.6.0; unchanged since v0.3.0). Used when a
 // document carries no `parameters.weights` at all (design §5); individual
 // missing keys fall back to weight 0 instead.
 export const DEFAULT_WEIGHTS: Record<Priority, Weights> = {

package/src/index.ts

@@ -19,7 +19,13 @@ import { parseConfig } from "./config"
 import { pinKey, type Pin } from "./core/pins"
 import { effectiveWeights, rankModels } from "./core/rank"
 import type { Catalog, EndpointCapture, ModelEntry, Priority, Sourced } from "./core/types"
-import { captureEndpoint, injectSteering, steeringFor } from "./core/steering"
+import {
+  captureEndpoint,
+  injectReasoning,
+  injectSteering,
+  reasoningEffortFor,
+  steeringFor,
+} from "./core/steering"
 import { formatReport, humanizeAge, reportEntries, steeringNote } from "./opencode/commands"
 import { ModelCompare } from "./rpc"
 import { planAlias, type AliasTarget } from "./opencode/aliases"
@@ -329,6 +335,8 @@ 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 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) {
@@ -558,21 +566,36 @@ export async function wire(ctx: PluginCtx, deps: WireDeps = {}): Promise<() => v
         state.appliedSteering[event.sessionID] = null
         return
       }
-      const steering = steeringFor(
+      const byId = new Map(
+        state.sourced.doc.models.map((entry): [string, ModelEntry] => [entry.id, entry]),
+      )
+      const bodyModel = bodyModelOf(body)
+      const steering = steeringFor(event.model, bodyModel, state.picks, byId)
+      // Two independent injections share one re-created Request: the
+      // provider-routing block and the catalog's scored reasoning effort.
+      // Each helper preserves a value the body already sets, so an explicit
+      // #variant (either signalled by the event's variant or by the body's
+      // own reasoning field) wins without withholding the other block.
+      let modified: unknown = body
+      let providerApplied = false
+      if (steering !== null) {
+        const next = injectSteering(modified, steering)
+        if (next !== modified) {
+          modified = next
+          providerApplied = true
+        }
+      }
+      const effort = reasoningEffortFor(
         event.model,
-        bodyModelOf(body),
+        event.model.variant,
+        bodyModel,
         state.picks,
-        new Map(state.sourced.doc.models.map((entry): [string, ModelEntry] => [entry.id, entry])),
+        byId,
       )
-      if (steering === null) {
-        // No steering data for the pick: untouched, fail open.
-        state.appliedSteering[event.sessionID] = null
-        return
-      }
-      const modified = injectSteering(body, steering)
+      if (effort !== null) modified = injectReasoning(modified, effort)
       if (modified === body) {
-        // The body already carries a `provider` key (or is not an object):
-        // never clobber routing the user or a provider configured.
+        // Neither block had anything to add: no steering data, no scored
+        // effort, or the body already carries the corresponding field.
         state.appliedSteering[event.sessionID] = null
         return
       }
@@ -592,7 +615,9 @@ export async function wire(ctx: PluginCtx, deps: WireDeps = {}): Promise<() => v
       })
       // Record the order actually applied — the response hook reads it as
       // captureEndpoint's order (the `!` flag fires only on a non-empty one).
-      state.appliedSteering[event.sessionID] = steering.order
+      // A reasoning-only injection (or a body that already carried routing)
+      // applies no routing, so the record is null.
+      state.appliedSteering[event.sessionID] = providerApplied ? steering!.order : null
     } catch {
       // Fail open: any error leaves the original request proceeding
       // untouched, and records that nothing was injected.

package/src/opencode/aliases.ts

@@ -24,6 +24,11 @@ export type AliasPlan = {
 // §8 rule: a missing pick model DISABLES the alias with a warning — it is never
 // 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.
+//
+// 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,
@@ -45,13 +50,14 @@ export function planAlias(
       warnings: [`pick model ${target.id} missing from catalog for ${p}`],
     }
   }
+  // 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,
-    // The pick in the display name is flattened (F-20): `target.id` is
-    // catalog-derived and the name surfaces in the model picker, the TUI
-    // status line and dialogs. `modelID` stays RAW — switching needs the
-    // real id.
-    name: `Model Compare: ${p} → ${sanitizeCatalogText(target.id)}${target.fromFallback ? " (fallback)" : ""}`,
+    name: `Model Compare: ${p} → ${sanitizeCatalogText(target.id)}${
+      target.fromFallback ? " (fallback)" : ""
+    }`,
     enabled: true,
     warnings: [],
   }

package/src/opencode/commands.ts

@@ -8,6 +8,7 @@
 // not upstream's `generated_at`.
 
 import { effectiveWeights, overallScore } from "../core/rank"
+import { formatDepthAlternative } from "../core/reasoning"
 import type { Catalog, EndpointCapture, ModelEntry, Priority, Sourced, Weights } from "../core/types"
 import type { AliasTarget } from "./aliases"
 
@@ -141,6 +142,30 @@ function overrideInEffect(
   return eff.applied && !eff.zeroSum ? eff.weights : null
 }
 
+// Catalog v5 display suffixes: the effort the quality score was measured at
+// (` · high`) and the best measured selectable alternative (` · alt max 56.0`).
+// Both are catalog-derived, so they are flattened before joining the report
+// text / dialog (F-20). An absent effort/alternative adds nothing.
+function effortLabel(model: ModelEntry | undefined): string {
+  const effort = model?.qualityEffort
+  return effort == null ? "" : sanitizeCatalogText(effort)
+}
+
+function alternativeLabel(model: ModelEntry | undefined): string {
+  const alternative = formatDepthAlternative(model)
+  return alternative === "" ? "" : sanitizeCatalogText(alternative)
+}
+
+function reasoningSuffix(model: ModelEntry | undefined): string {
+  const label = effortLabel(model)
+  return label === "" ? "" : ` · ${label}`
+}
+
+function alternativeSuffix(model: ModelEntry | undefined): string {
+  const label = alternativeLabel(model)
+  return label === "" ? "" : ` · alt ${label}`
+}
+
 // §10: /model-compare's report. `ranks` arrives already ranked, top-first
 // (under the same overrides, see ReportContext), and only the top 5 per
 // priority are rendered; a ranked id absent from the catalog still takes its
@@ -175,18 +200,23 @@ export function formatReport(
         model === undefined ? null : weights ? overallScore(model, weights) : model.scores.overall[p]
       const score = value === null ? "-" : value.toFixed(3)
       const marker = pick?.id === id ? " ← current pick" : ""
-      lines.push(`${index + 1}. ${sanitizeCatalogText(id)} (${score})${marker}`)
+      lines.push(
+        `${index + 1}. ${sanitizeCatalogText(id)} (${score})${reasoningSuffix(model)}${alternativeSuffix(model)}${marker}`,
+      )
     }
     // A pick that is not visible in the list above needs its own line.
     if (pick !== undefined && (pick.id === null || !top.includes(pick.id))) {
+      const pickModel = pick.id === null ? undefined : byId.get(pick.id)
       if (pick.id === null) {
         lines.push("Current pick: none (alias disabled)")
       } else if (pick.fromFallback) {
-        lines.push(`Current pick: ${sanitizeCatalogText(pick.id)} (fallback)`)
+        lines.push(
+          `Current pick: ${sanitizeCatalogText(pick.id)} (fallback)${reasoningSuffix(pickModel)}${alternativeSuffix(pickModel)}`,
+        )
       } else {
         const rank = ranks[p].indexOf(pick.id)
         lines.push(
-          `Current pick: ${sanitizeCatalogText(pick.id)} (${rank === -1 ? "not in the ranking" : `rank ${rank + 1}`})`,
+          `Current pick: ${sanitizeCatalogText(pick.id)} (${rank === -1 ? "not in the ranking" : `rank ${rank + 1}`})${reasoningSuffix(pickModel)}${alternativeSuffix(pickModel)}`,
         )
       }
     }
@@ -225,6 +255,10 @@ export type ReportEntry = {
   value: string
   score: string
   quality: string
+  // The effort behind `quality` ("" when unknown) and the best selectable
+  // measured alternative as "<effort> <index>" ("" when there is none).
+  effort: string
+  alternative: string
   price: string
   current: boolean
   fromFallback: boolean
@@ -279,6 +313,8 @@ export function reportEntries(
         value: id,
         score: scoreValue === null ? "-" : scoreValue.toFixed(3),
         quality: fmtQuality(model),
+        effort: effortLabel(model),
+        alternative: alternativeLabel(model),
         price: fmtPrice(model),
         current,
         // A top-5 row that IS the current pick carries the pick's fallback
@@ -302,6 +338,8 @@ export function reportEntries(
         value: pick.id,
         score: "-",
         quality: fmtQuality(model),
+        effort: effortLabel(model),
+        alternative: alternativeLabel(model),
         price: fmtPrice(model),
         current: true,
         fromFallback: pick.fromFallback,

package/src/opencode/guard.ts

@@ -10,8 +10,10 @@
 
 import type { Priority } from "../core/types"
 
-// A model reference as configured on an agent (`agent.model`).
-export type ModelRef = { providerID: string; id: string }
+// A model reference (agent config, session selection or request event). The
+// optional `variant` is the `#variant` selection; alias identification stays
+// variant-blind (it is not stable across binding styles).
+export type ModelRef = { providerID: string; id: string; variant?: string }
 
 const ALIAS_PREFIX = "model-compare/"
 

package/src/opencode/usebest.ts

@@ -80,12 +80,23 @@ 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.
+// "Model Compare: <p> → <pick>[ (fallback)]" → "<pick>[ (fallback)]", or null
+// 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
-  return name.slice(arrow + 1).trim()
+  const rest = name.slice(arrow + 1).replace(/ \[alt .*\]$/, "")
+  // 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}`
 }
 
 // The pick an ENABLED alias view serves, or null when nothing observable is

package/src/rpc.ts

@@ -54,11 +54,25 @@ export const ModelCompare = Rpc.define({
                 value: { type: "string" },
                 score: { type: "string" },
                 quality: { type: "string" },
+                effort: { type: "string" },
+                alternative: { type: "string" },
                 price: { type: "string" },
                 current: { type: "boolean" },
                 fromFallback: { type: "boolean" },
               },
-              required: ["priority", "rank", "id", "value", "score", "quality", "price", "current", "fromFallback"],
+              required: [
+                "priority",
+                "rank",
+                "id",
+                "value",
+                "score",
+                "quality",
+                "effort",
+                "alternative",
+                "price",
+                "current",
+                "fromFallback",
+              ],
               additionalProperties: false,
             },
           },
@@ -88,11 +102,25 @@ export const ModelCompare = Rpc.define({
                 value: { type: "string" },
                 score: { type: "string" },
                 quality: { type: "string" },
+                effort: { type: "string" },
+                alternative: { type: "string" },
                 price: { type: "string" },
                 current: { type: "boolean" },
                 fromFallback: { type: "boolean" },
               },
-              required: ["priority", "rank", "id", "value", "score", "quality", "price", "current", "fromFallback"],
+              required: [
+                "priority",
+                "rank",
+                "id",
+                "value",
+                "score",
+                "quality",
+                "effort",
+                "alternative",
+                "price",
+                "current",
+                "fromFallback",
+              ],
               additionalProperties: false,
             },
           },

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
@@ -186,6 +240,8 @@ function toReportEntries(raw: unknown): ReportEntry[] {
         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,
@@ -643,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>
@@ -706,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}${
@@ -725,21 +790,57 @@ 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)))
-      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: string, width: number): string =>
-        value.length > width ? value.slice(0, width - 1) + "…" : value
+        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: 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+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: string): string =>
-        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: string): string => cell(label, nameW)
       const headerLine =
         "   " +
         " ".repeat(nameW) +
@@ -747,6 +848,16 @@ export default Plugin.define({
         "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: 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)
@@ -754,12 +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) +
+              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,

package/vendor/UPSTREAM.json

@@ -1,6 +1,6 @@
 {
   "repo": "canonical/model-compare",
-  "tag": "v0.5.0",
-  "commit": "2e0e0cbb0ebf1d1b3f03b2c1c949eb930730d8a4",
-  "sha256": "cebf2d100b020183c0236f1d127768933bca0e10ed615dd00ee549ebb86323b4"
+  "tag": "v0.6.0",
+  "commit": "2f39ed320ca87703b1a91a6a89b3ac796c5212ae",
+  "sha256": "94627727c2c5ef0e5d2f7b1753952aaa02d375a4fb2bd35c82124891a5b29830"
 }