@saifymatteo/pi-extensions 0.0.0-stage → 0.1.0

package/packages/pi-model-go/README.md

@@ -0,0 +1,33 @@
+# pi-model-go
+
+Cost-aware model picker showing registry prices/context, OpenCode Go credit multipliers and stencil.so intelligence scores. Source describes it as a port of rizal72/oc-models-pro.
+
+## Running locally
+
+From the monorepo root:
+
+```sh
+pi -e ./packages/pi-model-go
+```
+
+**Warning:** this extension uses your existing Pi resources and settings unless you load it in an isolated home (see the root README). Do not load two copies of the same extension (for example an older standalone file alongside this package): commands and hooks can duplicate. The package never installs or relocates personal settings.
+
+## Commands and shortcuts
+
+- `/model-go [query]` — opens the picker; Enter switches the selected model.
+- Up/Down or PageUp/PageDown to move; Ctrl+O cycles sort; Ctrl+S cycles Go/with-key/all scopes; Ctrl+U clears search.
+- Escape clears a nonempty search, then closes; Ctrl+C closes immediately.
+
+## Settings and storage
+
+Uses Pi's model registry and existing credentials (`OPENCODE_API_KEY` or `/login` for OpenCode Go). Caches data in `<agent-dir>/state/model-go/{go-plan,bench}.json`; `<agent-dir>` is `PI_CODING_AGENT_DIR` or `~/.pi/agent`. Go data is cached for one day, benchmark data for six hours; stale data can be used with warnings.
+
+## Privacy and operations
+
+On command, fetches `https://opencode.ai/v2/docs/console/go/` and `https://catalog.stencil.so/models.json` with 20-second request timeouts and writes cache files. These fetches request public data, not conversation content. Picking changes the active model; later prompts may have different cost/provider privacy. No model completion is requested by the picker.
+
+## Compatibility
+
+Node.js >=24 for development checks; run extensions through Pi's TypeScript loader. Host imports are wildcard peers, not bundled runtime copies. Interactive TUI only; other modes are told to use `/model`. Remote HTML/catalog formats and intelligence/price matching may change; figures are estimates, not billing guarantees. No token-per-second metric is supplied. Source helper retains its optional offline/live self-check; no live check is run by tests.
+
+See [NOTICE.md](NOTICE.md) for provenance. Tests use the monorepo's TypeScript dev dependency and VM loader; they do not contact services or write to user-home resources.

package/packages/pi-model-go/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@saifymatteo/pi-model-go",
+  "version": "0.1.0",
+  "license": "AGPL-3.0-only",
+  "type": "module",
+  "keywords": [
+    "pi-package"
+  ],
+  "files": [
+    "src",
+    "README.md",
+    "NOTICE.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "description": "/model-go: cost-aware model picker with Go-plan pricing and intelligence scores.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/saifymatteo/pi-extensions.git",
+    "directory": "packages/pi-model-go"
+  }
+}

package/packages/pi-model-go/src/index.ts

@@ -0,0 +1,171 @@
+// /model-go: a cost-aware alternative to the built-in /model, ported from rizal72/oc-models-pro.
+// Rows come from Pi's own model registry (prices, context); the Go plan credit multiplier and the
+// stencil.so intelligence score are decoration (lib/model-go.ts). Enter switches via pi.setModel.
+// tok/s is not ported: Pi session entries carry no first/last streamed-token timestamps.
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth, type Component, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { DIALOG_OVERLAY, dialogRows, wheelAsArrows } from "./lib/dialog.ts";
+import { GO_PROVIDER, SORTS, compare, effective, loadBench, loadGoCredits, matches, toRow, type Row, type SortKey } from "./lib/model-go.ts";
+
+type Scope = "go" | "ready" | "all";
+const SCOPES: Scope[] = ["go", "ready", "all"];
+const SCOPE_LABEL: Record<Scope, string> = { go: "OpenCode Go", ready: "with key", all: "all" };
+const SORT_LABEL: Record<SortKey, string> = { effective: "effective ↑", input: "input ↑", output: "output ↑", context: "context ↓", int: "intelligence ↓", name: "name" };
+const PAD_X = 2; // spaces between the border and the content
+const GAP = 2; // spaces between columns
+// Explicit bright white, bold: headers stand out on any dark theme.
+const header = (s: string) => `\x1b[1m\x1b[97m${s}\x1b[39m\x1b[22m`;
+
+const price = (n?: number) => (n === undefined ? "—" : n === 0 ? "free" : n < 10 ? n.toFixed(2) : n.toFixed(1));
+const ctxText = (n?: number) => (n === undefined ? "—" : n >= 1e6 ? `${+(n / 1e6).toFixed(1)}M` : `${Math.round(n / 1e3)}K`);
+const pad = (s: string, w: number, right = false) => {
+	const t = truncateToWidth(s, w, "…");
+	const gap = " ".repeat(Math.max(0, w - visibleWidth(t)));
+	return right ? gap + t : t + gap;
+};
+
+class Picker implements Component {
+	private query = "";
+	private scope: Scope;
+	private sort: SortKey = "effective";
+	private selected = 0;
+	private offset = 0;
+	private pageSize = 10;
+
+	private tui: any;
+	private theme: any;
+	private all: Row[];
+	private current: string | undefined;
+	private notes: string[];
+	private done: (row: Row | null) => void;
+
+	constructor(tui: any, theme: any, all: Row[], current: string | undefined, notes: string[], done: (row: Row | null) => void, query: string) {
+		this.tui = tui;
+		this.theme = theme;
+		this.all = all;
+		this.current = current;
+		this.notes = notes;
+		this.done = done;
+		this.query = query;
+		this.scope = all.some((r) => r.provider === GO_PROVIDER) ? "go" : "all";
+	}
+
+	private list(): Row[] {
+		return this.all
+			.filter((r) => (this.scope === "go" ? r.provider === GO_PROVIDER : this.scope === "ready" ? r.hasAuth : true))
+			.filter((r) => matches(r, this.query))
+			.sort((a, b) => compare(this.sort, a, b));
+	}
+
+	render(width: number): string[] {
+		const t = this.theme;
+		const border = (s: string) => t.fg("border", s);
+		const inner = Math.max(20, width - 2);
+		const body = inner - 2 * PAD_X;
+		const line = (s: string) => border("┃") + " ".repeat(PAD_X) + pad(s, body) + " ".repeat(PAD_X) + border("┃");
+		const rows = this.list();
+		// Everything except the table rows: 2 borders, 4 blank padding lines, search, header, detail, hint, notes.
+		const chrome = 10 + (this.notes.length ? 1 : 0);
+		this.pageSize = dialogRows(this.tui, chrome, 5);
+		this.selected = Math.min(this.selected, Math.max(0, rows.length - 1));
+		this.offset = Math.max(0, Math.min(this.offset, this.selected, rows.length - this.pageSize));
+		if (this.selected >= this.offset + this.pageSize) this.offset = this.selected - this.pageSize + 1;
+
+		// Fixed numeric columns; the name takes what is left and the widest-but-least-useful columns drop first.
+		const cols = [
+			{ key: "EFFECTIVE", w: 9, get: (r: Row) => price(effective(r)) },
+			{ key: "INPUT", w: 6, get: (r: Row) => price(r.input) },
+			{ key: "OUTPUT", w: 6, get: (r: Row) => price(r.output) },
+			{ key: "CONTEXT", w: 7, get: (r: Row) => ctxText(r.context) },
+			{ key: "INTELLIGENCE", w: 12, get: (r: Row) => (r.int === undefined ? "—" : r.int.toFixed(0)) },
+			{ key: "CREDIT", w: 9, get: (r: Row) => (r.provider !== GO_PROVIDER ? "" : `${r.credit}x${r.promo ? "↑" : ""}${r.peak ? " pk" : ""}`) },
+		];
+		const nameMin = 22;
+		const dropOrder = ["OUTPUT", "CREDIT", "INPUT", "CONTEXT", "INTELLIGENCE"];
+		let shown = cols;
+		const used = () => shown.reduce((s, c) => s + c.w + GAP, 0);
+		for (const k of dropOrder) if (body - 2 - used() < nameMin) shown = shown.filter((c) => c.key !== k);
+		const nameW = Math.max(8, body - 2 - used());
+		const fmt = (mark: string, name: string, cells: string[]) => mark + " " + pad(name, nameW) + cells.map((c, i) => " ".repeat(GAP) + pad(c, shown[i].w, true)).join("");
+
+		const title = ` /model-go · ${SCOPE_LABEL[this.scope]} · sorted by ${SORT_LABEL[this.sort]} · ${rows.length} models `;
+		const out = [border(`┏${pad(title, inner).replace(/ +$/, (s) => "━".repeat(s.length))}┓`)];
+		out.push(line(""));
+		out.push(line(t.fg("warning", `Search: ${this.query}▏`)));
+		out.push(line(""));
+		out.push(line(header(fmt(" ", "MODEL", shown.map((c) => c.key)))));
+		const page = rows.slice(this.offset, this.offset + this.pageSize);
+		for (let i = 0; i < this.pageSize; i++) {
+			const r = page[i];
+			if (!r) { out.push(line("")); continue; }
+			const id = `${r.provider}/${r.id}`;
+			const isSel = this.offset + i === this.selected;
+			const isCur = id === this.current;
+			const label = r.provider === GO_PROVIDER && this.scope === "go" ? r.id : id;
+			const text = fmt(isSel ? "▶" : isCur ? "●" : " ", label, shown.map((c) => c.get(r)));
+			out.push(line(isSel ? t.fg("accent", text) : !r.hasAuth ? t.fg("dim", text) : isCur ? t.fg("success", text) : t.fg("text", text)));
+		}
+		const sel = rows[this.selected];
+		out.push(line(""));
+		const detail = sel && sel.provider === GO_PROVIDER
+			? `${sel.name}: ${sel.credit}x plan credit${sel.promo ? ` (promo ${sel.promo}x)` : ""}${sel.peak ? `, peak price ${sel.peak}x` : ""}${sel.hasAuth ? "" : " · set OPENCODE_API_KEY to use"}`
+			: sel ? `${sel.name}${sel.hasAuth ? "" : " · no API key configured"}` : "no match";
+		out.push(line(t.fg("muted", detail)));
+		if (this.notes.length) out.push(line(t.fg("warning", "⚠ " + this.notes.join(" · "))));
+		out.push(line(t.fg("dim", "↑↓ move · Enter switch · ^O sort · ^S scope · ^U clear · Esc close · $/M tokens, effective = input ÷ credit")));
+		out.push(line(""));
+		out.push(border(`┗${"━".repeat(inner)}┛`));
+		return out.map((l) => truncateToWidth(l, width));
+	}
+
+	handleMouse(event: TuiMouseEvent) { return wheelAsArrows(event, (key) => this.handleInput(key)); }
+
+	handleInput(data: string): void {
+		const rows = this.list();
+		if (matchesKey(data, "escape")) {
+			if (!this.query) return this.done(null);
+			this.query = "";
+		} else if (matchesKey(data, "ctrl+c")) return this.done(null);
+		else if (matchesKey(data, "enter")) return rows[this.selected] ? this.done(rows[this.selected]) : undefined;
+		else if (matchesKey(data, "up")) this.selected = Math.max(0, this.selected - 1);
+		else if (matchesKey(data, "down")) this.selected = Math.min(rows.length - 1, this.selected + 1);
+		else if (matchesKey(data, "pageUp")) this.selected = Math.max(0, this.selected - this.pageSize);
+		else if (matchesKey(data, "pageDown")) this.selected = Math.min(rows.length - 1, this.selected + this.pageSize);
+		else if (matchesKey(data, "ctrl+o")) this.sort = SORTS[(SORTS.indexOf(this.sort) + 1) % SORTS.length];
+		else if (matchesKey(data, "ctrl+s")) { this.scope = SCOPES[(SCOPES.indexOf(this.scope) + 1) % SCOPES.length]; this.selected = 0; }
+		else if (matchesKey(data, "ctrl+u")) { this.query = ""; this.selected = 0; }
+		else if (matchesKey(data, "backspace")) { this.query = this.query.slice(0, -1); this.selected = 0; }
+		else if (!/[\x00-\x1f\x7f]/.test(data)) { this.query += data; this.selected = 0; }
+		this.tui.requestRender();
+	}
+
+	invalidate(): void {}
+}
+
+export default function (pi: ExtensionAPI): void {
+	pi.registerCommand("model-go", {
+		description: "Model picker with price, context, intelligence and OpenCode Go plan credits",
+		handler: async (args, ctx) => {
+			if (ctx.mode !== "tui") return ctx.ui.notify("/model-go needs the interactive TUI; use /model", "warning");
+			const [go, bench] = await Promise.all([loadGoCredits(), loadBench()]);
+			const registry = ctx.modelRegistry;
+			const rows = registry.getAll()
+				.filter((m: any) => !m.type || m.type === "chat")
+				.map((m) => toRow(m, registry.hasConfiguredAuth(m), go.credits, bench.bench));
+			const notes = [go.error, bench.error].filter((e): e is string => !!e);
+			if (!rows.some((r) => r.provider === GO_PROVIDER))
+				notes.unshift("no opencode-go models in the registry: set OPENCODE_API_KEY (or /login) to list them");
+			const current = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
+			const picked = await ctx.ui.custom<Row | null>(
+				(tui, theme, _kb, done) => new Picker(tui, theme, rows, current, notes, done, (args ?? "").trim()),
+				DIALOG_OVERLAY,
+			);
+			if (!picked) return;
+			const model = registry.find(picked.provider, picked.id);
+			if (!model) return ctx.ui.notify(`Model ${picked.provider}/${picked.id} not found`, "error");
+			if (!(await pi.setModel(model)))
+				return ctx.ui.notify(`No API key for ${picked.provider}${picked.provider === GO_PROVIDER ? ": set OPENCODE_API_KEY or /login" : ""}`, "warning");
+			ctx.ui.notify(`Model: ${picked.provider}/${picked.id}`, "info");
+		},
+	});
+}

package/packages/pi-model-go/src/lib/dialog.ts

@@ -0,0 +1,31 @@
+// One size for every overlay dialog in this package. Change DIALOG_HEIGHT here and every dialog follows:
+// the overlay is capped at that share of the terminal and each dialog pads its list to fill it.
+
+/** Share of the terminal height every dialog fills. */
+export const DIALOG_HEIGHT = 0.8
+
+/** `ctx.ui.custom(factory, DIALOG_OVERLAY)`: centered, 92% wide, DIALOG_HEIGHT tall. */
+export const DIALOG_OVERLAY = {
+  overlay: true,
+  overlayOptions: { anchor: 'center', width: '92%', maxHeight: `${DIALOG_HEIGHT * 100}%`, margin: 1 },
+} as const
+
+/**
+ * Scrolling rows that fit once `chrome` fixed lines (borders, search, header, footer) are drawn.
+ * Same floor as the overlay's own percentage, so dialog and overlay agree; read it in render() so a
+ * resize takes effect on the next frame.
+ */
+export const dialogRows = (tui: { terminal?: { rows: number } }, chrome: number, min = 1): number =>
+  Math.max(min, Math.floor((tui.terminal?.rows ?? 24) * DIALOG_HEIGHT) - chrome)
+
+/**
+ * Mouse wheel → ↑/↓ key presses, so a dialog reuses its own keyboard handling (clamping, render).
+ * Use as `handleMouse(e) { return wheelAsArrows(e, (k) => this.handleInput(k)) }`. Fullscreen mode only:
+ * regular mode leaves the mouse to the terminal. Handling the wheel also stops it scrolling the transcript behind.
+ */
+export function wheelAsArrows(event: { type: string; wheelDelta?: number }, handleInput: (data: string) => void): { handled: true } | undefined {
+  if (event.type !== 'wheel' || !event.wheelDelta) return undefined
+  const key = event.wheelDelta < 0 ? '\x1b[A' : '\x1b[B'
+  for (let i = 0; i < Math.min(Math.abs(event.wheelDelta), 20); i++) handleInput(key)
+  return { handled: true }
+}

package/packages/pi-model-go/src/lib/model-go.ts

@@ -0,0 +1,239 @@
+// Data half of /model-go (port of rizal72/oc-models-pro): OpenCode Go plan credits and
+// stencil.so intelligence, matched onto Pi's own model catalogue. No Pi imports, so it runs bare:
+//   node pi/extensions/lib/model-go.ts --self-check        (offline: parsing, matching, sorting)
+//   node pi/extensions/lib/model-go.ts --self-check --live (plus both live fetches)
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+export const GO_PROVIDER = 'opencode-go'
+export const GO_PAGE = 'https://opencode.ai/v2/docs/console/go/'
+export const CATALOG = 'https://catalog.stencil.so/models.json'
+const CACHE_DIR = join(process.env.PI_CODING_AGENT_DIR || join(homedir(), '.pi', 'agent'), 'state', 'model-go')
+const DAY_MS = 86_400_000
+const SIX_HOURS_MS = 6 * 60 * 60 * 1000
+
+// ---------- Go plan page ----------
+
+export interface GoLimit { name: string; input?: number; limit?: number; base?: number }
+export interface GoPlan { price: number; limits: GoLimit[] }
+/** credit = monthly limit ÷ plan price; promo = limit ÷ struck-through base; peak = peak ÷ off-peak input. */
+export interface Credits { credit: number; promo?: number; peak?: number }
+
+const text = (html: string) => html.replace(/<br\s*\/?>/gi, ' ').replace(/<[^>]+>/g, ' ').replace(/&nbsp;/g, ' ')
+  .replace(/&amp;/g, '&').replace(/&#39;|&rsquo;/g, "'").replace(/&quot;/g, '"').replace(/\s+/g, ' ').trim()
+const money = (html: string): number | undefined => {
+  const plain = text(html)
+  if (/free/i.test(plain)) return 0
+  const found = plain.match(/\$([\d.]+)/)
+  return found ? Number(found[1]) : undefined
+}
+
+/** Server-rendered table: model | input | output | cache read | cache write | monthly limit. Repeats per plan; first wins. */
+export function parseGoTable(html: string): GoLimit[] {
+  const limits: GoLimit[] = []
+  const seen = new Set<string>()
+  for (const raw of html.split(/<tr[\s>]/i).slice(1)) {
+    const cells = raw.split(/<\/tr>/i)[0].match(/<td[^>]*>[\s\S]*?<\/td>/gi) ?? []
+    if (cells.length < 6) continue
+    const name = text(cells[0])
+    if (!name || /^model$/i.test(name) || seen.has(name)) continue
+    seen.add(name)
+    const monthly = cells[5]
+    const promoted = monthly.match(/<strong[^>]*>([\s\S]*?)<\/strong>/i)
+    const struck = monthly.match(/<del[^>]*>([\s\S]*?)<\/del>/i)
+    limits.push({ name, input: money(cells[1]), limit: money(promoted ? promoted[1] : monthly), base: struck ? money(struck[1]) : undefined })
+  }
+  return limits
+}
+
+export const parsePlanPrice = (html: string): number | undefined => {
+  const found = text(html).match(/\$\s?([\d.]+)\s*\/\s*month/i)
+  return found ? Number(found[1]) : undefined
+}
+
+/** "GLM-5.3-Flash", "glm-5.3-flash" and "DeepSeek V4.1 Flash (Peak)" meet here. */
+export const goKey = (name: string) => name.replace(/\s*\((?:off-?peak|peak)\)\s*$/i, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '')
+
+export function credits(plan: GoPlan): Map<string, Credits> {
+  const grouped = new Map<string, GoLimit[]>()
+  for (const row of plan.limits) grouped.set(goKey(row.name), [...(grouped.get(goKey(row.name)) ?? []), row])
+  const out = new Map<string, Credits>()
+  const r1 = (n: number) => Math.round(n * 10) / 10
+  for (const [id, rows] of grouped) {
+    const off = rows.find((r) => /off-?peak/i.test(r.name)) ?? rows[0]
+    const peak = rows.find((r) => /\(peak\)/i.test(r.name))
+    if (!off.limit || !plan.price) continue
+    out.set(id, {
+      credit: r1(off.limit / plan.price),
+      ...(off.base ? { promo: r1(off.limit / off.base) } : {}),
+      ...(peak?.input && off.input ? { peak: r1(peak.input / off.input) } : {}),
+    })
+  }
+  return out
+}
+
+// ---------- stencil.so intelligence ----------
+
+/** "DeepSeek V4.1 Flash 1017" and `deepseek-v4.1-flash` meet here: labels and snapshot stamps come off. */
+export function benchKey(name: string): string {
+  let key = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+  for (let round = 0; round < 2; round++) {
+    key = key.replace(/-(?:latest|contributor|free|preview|exp|thinking)$/g, '')
+    key = key.replace(/-\d{4,6}$/, (stamp) => (key.length - stamp.length >= 4 ? '' : stamp))
+  }
+  return key.replace(/^-|-$/g, '')
+}
+
+export function buildBenchIndex(catalog: Record<string, any>): Map<string, number> {
+  const index = new Map<string, number>()
+  for (const provider of Object.values(catalog ?? {}))
+    for (const [id, meta] of Object.entries((provider as any)?.models ?? {})) {
+      const int = (meta as any)?.int
+      const key = benchKey(String(id).split('/').pop() ?? '')
+      if (typeof int === 'number' && key && !index.has(key)) index.set(key, int)
+    }
+  return index
+}
+
+// ---------- cached fetch ----------
+
+async function cachedFetch<T>(file: string, maxAgeMs: number, load: () => Promise<T>): Promise<{ value?: T; error?: string }> {
+  const path = join(CACHE_DIR, file)
+  let previous: { fetched: number; value: T } | undefined
+  try { previous = JSON.parse(await readFile(path, 'utf8')) } catch {}
+  if (previous && Date.now() - previous.fetched < maxAgeMs) return { value: previous.value }
+  try {
+    const value = await load()
+    await mkdir(dirname(path), { recursive: true })
+    await writeFile(path + '.tmp', JSON.stringify({ fetched: Date.now(), value }))
+    await rename(path + '.tmp', path)
+    return { value }
+  } catch (error) {
+    // A stale copy beats an empty column; the error is still reported.
+    return { value: previous?.value, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+const get = async (url: string) => {
+  const response = await fetch(url, { headers: { 'user-agent': 'pi-model-go' }, signal: AbortSignal.timeout(20_000) })
+  if (!response.ok) throw new Error(`HTTP ${response.status}`)
+  return response
+}
+
+export async function loadGoCredits(): Promise<{ credits?: Map<string, Credits>; error?: string }> {
+  const { value, error } = await cachedFetch<GoPlan>('go-plan.json', DAY_MS, async () => {
+    const html = await (await get(GO_PAGE)).text()
+    const plan = { price: parsePlanPrice(html) ?? 0, limits: parseGoTable(html) }
+    if (!plan.price || !plan.limits.length) throw new Error('Go page shape changed')
+    return plan
+  })
+  return { credits: value ? credits(value) : undefined, error: error && `Go plan: ${error}` }
+}
+
+export async function loadBench(): Promise<{ bench?: Map<string, number>; error?: string }> {
+  const { value, error } = await cachedFetch<Record<string, number>>('bench.json', SIX_HOURS_MS, async () => {
+    const index = buildBenchIndex(await (await get(CATALOG)).json())
+    if (!index.size) throw new Error('catalog shape changed')
+    return Object.fromEntries(index)
+  })
+  return { bench: value ? new Map(Object.entries(value)) : undefined, error: error && `stencil: ${error}` }
+}
+
+// ---------- rows ----------
+
+export interface Row {
+  provider: string
+  id: string
+  name: string
+  /** $/M tokens; undefined = unknown, not free. */
+  input?: number
+  output?: number
+  context?: number
+  int?: number
+  /** Go plan multiplier; 1 off the Go plan. */
+  credit: number
+  promo?: number
+  peak?: number
+  hasAuth: boolean
+}
+
+export function toRow(model: { provider: string; id: string; name?: string; cost?: { input?: number; output?: number }; contextWindow?: number },
+  hasAuth: boolean, goCredits?: Map<string, Credits>, bench?: Map<string, number>): Row {
+  const name = model.name || model.id
+  const plan = model.provider === GO_PROVIDER ? (goCredits?.get(goKey(name)) ?? goCredits?.get(goKey(model.id))) : undefined
+  const int = bench?.get(benchKey(name)) ?? bench?.get(benchKey(model.id))
+  const num = (n: unknown) => (typeof n === 'number' && Number.isFinite(n) ? n : undefined)
+  return {
+    provider: model.provider, id: model.id, name,
+    input: num(model.cost?.input), output: num(model.cost?.output), context: num(model.contextWindow),
+    ...(int !== undefined ? { int } : {}),
+    credit: plan?.credit ?? 1,
+    ...(plan?.promo ? { promo: plan.promo } : {}),
+    ...(plan?.peak ? { peak: plan.peak } : {}),
+    hasAuth,
+  }
+}
+
+/** What the Go plan makes a request cost: list input price ÷ credit multiplier. */
+export const effective = (row: Row) => (row.input === undefined ? undefined : row.input / (row.credit || 1))
+
+export type SortKey = 'effective' | 'input' | 'output' | 'context' | 'int' | 'name'
+export const SORTS: SortKey[] = ['effective', 'input', 'output', 'context', 'int', 'name']
+const VALUE: Record<Exclude<SortKey, 'name'>, [(r: Row) => number | undefined, 1 | -1]> = {
+  effective: [effective, 1],
+  input: [(r) => r.input, 1],
+  output: [(r) => r.output, 1],
+  context: [(r) => r.context, -1],
+  int: [(r) => r.int, -1],
+}
+
+/** Unknown figures sort last in either direction; ties fall back to name so the list never reshuffles. */
+export function compare(key: SortKey, a: Row, b: Row): number {
+  const byName = a.name.localeCompare(b.name) || a.provider.localeCompare(b.provider)
+  if (key === 'name') return byName
+  const [value, sign] = VALUE[key]
+  const left = value(a), right = value(b)
+  if (left === undefined || right === undefined) return left === right ? byName : left === undefined ? 1 : -1
+  return left === right ? byName : (left < right ? -1 : 1) * sign
+}
+
+export const matches = (row: Row, query: string) =>
+  query.toLowerCase().split(/\s+/).filter(Boolean).every((word) => `${row.provider}/${row.id} ${row.name}`.toLowerCase().includes(word))
+
+// ---------- self-check ----------
+
+if (process.argv[2] === '--self-check') {
+  const check = (ok: boolean, message: string) => { if (!ok) throw new Error('self-check: ' + message) }
+  const html = `<h2>Go $10/month</h2><table><tr><th>Model</th></tr>
+    <tr><td>DeepSeek V4.1 Flash (Off-Peak)</td><td>$0.15</td><td>$0.60</td><td>$0.01</td><td>-</td><td><del>$20</del> <strong>$80</strong> 4x</td></tr>
+    <tr><td>DeepSeek V4.1 Flash (Peak)</td><td>$0.30</td><td>$1.20</td><td>$0.02</td><td>-</td><td>$80</td></tr>
+    <tr><td>GLM-5.3</td><td>$1.40</td><td>$4.40</td><td>$0.26</td><td>-</td><td>$15</td></tr>
+    <tr><td>GLM-5.3</td><td>$9</td><td>$9</td><td>$9</td><td>-</td><td>$99</td></tr></table>`
+  const plan = { price: parsePlanPrice(html)!, limits: parseGoTable(html) }
+  check(plan.price === 10, 'plan price')
+  check(plan.limits.length === 3, 'repeated plan table: first occurrence wins')
+  const table = credits(plan)
+  const ds = table.get('deepseek-v4-1-flash')
+  check(ds?.credit === 8 && ds.promo === 4 && ds.peak === 2, 'DeepSeek credit/promo/peak: ' + JSON.stringify(ds))
+  check(table.get('glm-5-3')?.credit === 1.5, 'GLM credit')
+  check(benchKey('DeepSeek V4.1 Flash 1017') === 'deepseek-v4-1-flash', 'bench key strips stamp')
+  check(benchKey('Muse Spark 1.3 Contributor') === benchKey('muse-spark-1.3'), 'bench key strips label')
+  const bench = buildBenchIndex({ a: { models: { 'x/deepseek-v4.1-flash': { int: 40 } } } })
+  const go = toRow({ provider: GO_PROVIDER, id: 'deepseek-v4.1-flash', name: 'DeepSeek V4.1 Flash', cost: { input: 0.15, output: 0.6 }, contextWindow: 1e6 }, false, table, bench)
+  check(go.credit === 8 && go.int === 40 && effective(go) === 0.15 / 8, 'Go row: ' + JSON.stringify(go))
+  const other = toRow({ provider: 'deepseek', id: 'deepseek-v4.1-flash', cost: { input: 0.15 } }, true, table, bench)
+  check(other.credit === 1, 'credits apply to opencode-go only')
+  const unknown = toRow({ provider: 'p', id: 'mystery' }, true)
+  const sorted = (k: SortKey) => [unknown, other, go].sort((a, b) => compare(k, a, b))
+  check(sorted('effective')[0] === go && sorted('effective')[2] === unknown, 'effective: cheapest first, unknown last')
+  check(sorted('int')[2] === unknown, 'int: missing score last')
+  check(matches(go, 'opencode-go flash') && !matches(go, 'glm'), 'search')
+  if (process.argv[3] !== '--live') console.log('self-check ok (offline)')
+  else {
+    const [g, b] = await Promise.all([loadGoCredits(), loadBench()])
+    check(!!g.credits && g.credits.size >= 10, 'live Go plan: ' + (g.error ?? g.credits?.size))
+    check(!!b.bench && b.bench.size >= 20, 'live stencil: ' + (b.error ?? b.bench?.size))
+    console.log(`self-check ok (live): ${g.credits!.size} Go models credited, ${b.bench!.size} benchmarked`)
+  }
+}

package/packages/pi-model-go/test/behavior.test.mjs

@@ -0,0 +1,17 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { credits, parseGoTable, parsePlanPrice, toRow, effective, compare, matches, GO_PROVIDER } from '../src/lib/model-go.ts';
+test('Go multipliers apply only to Go models and unknown prices sort last', () => {
+  const html = '<h2>$10/month</h2><table><tr><td>Example</td><td>$2</td><td>$3</td><td>0</td><td>0</td><td><del>$20</del><strong>$80</strong></td></tr></table>';
+  const data = credits({ price: parsePlanPrice(html), limits: parseGoTable(html) });
+  const go = toRow({ provider: GO_PROVIDER, id: 'example', cost: { input: 2 } }, true, data);
+  const other = toRow({ provider: 'other', id: 'example', cost: { input: 2 } }, true, data);
+  const unknown = toRow({ provider: 'other', id: 'unknown' }, false);
+  assert.equal(go.credit, 8);
+  assert.equal(go.promo, 4);
+  assert.equal(other.credit, 1);
+  assert.equal(effective(go), 0.25);
+  assert.equal([unknown, other, go].sort((a, b) => compare('effective', a, b))[0], go);
+  assert.ok(compare('input', unknown, other) > 0);
+  assert.ok(matches(go, 'opencode-go EXAMPLE'));
+});