model-compare-opencode-plugin 0.5.0 → 0.6.0

package/src/opencode/aliases.ts

@@ -5,6 +5,7 @@
 // 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"
 
@@ -24,10 +25,17 @@ 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.
+//
+// `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`.
 export function planAlias(
   p: Priority,
   target: AliasTarget,
   model: ModelEntry | undefined,
+  displayModel?: ModelEntry,
 ): AliasPlan {
   if (target.id === null) {
     return {
@@ -45,13 +53,19 @@ 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)
   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)}${effort}${
+      target.fromFallback ? " (fallback)" : ""
+    }${alternative === "" ? "" : ` [alt ${sanitizeCatalogText(alternative)}]`}`,
     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,22 @@ 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. 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.
 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 .*\]$/, "")
+  // 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.
+  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

@@ -186,6 +186,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,
@@ -726,8 +728,15 @@ 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)
+      // 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".
+      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)
+      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
@@ -736,8 +745,11 @@ export default Plugin.define({
       // 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).
-      const fixed = 2 + qualW + 2 + priceW
-      const nameW = Math.max(8, Math.min(52 - fixed, Math.max(...labels.map((label) => label.length))))
+      // 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
       const headerLine =
@@ -746,6 +758,10 @@ export default Plugin.define({
         "  " +
         "qual".padStart(qualW) +
         "  " +
+        "effort".padStart(effortW) +
+        "  " +
+        "alt".padEnd(altW) +
+        "  " +
         "$ in/out".padEnd(priceW)
       const rows: ListRow[] = [{ label: "", headerLine }]
       for (const priority of PRIORITIES) {
@@ -759,6 +775,10 @@ export default Plugin.define({
               "  " +
               cell(entry.quality, qualW).padStart(qualW) +
               "  " +
+              cell(entry.effort || "-", effortW).padStart(effortW) +
+              "  " +
+              cell(entry.alternative || "-", altW).padEnd(altW) +
+              "  " +
               cell(entry.price, priceW).padEnd(priceW),
             // F-20 id split: the row DISPLAYS the sanitized id (in `label`)
             // but picks `value`, the raw catalog id switchToModel needs.

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"
 }