chore(metadata): resync jawcode bundle, re-block hy3-preview, add a drift guard

The committed generated file had drifted 95 models from its source — 148 price
fields, 45 maxTokens, 36 context windows, 36 new models — because nothing ever
checked it. That made any regeneration a blind bulk change, so this lands the
resync with each class of delta accounted for.

Price movements, classified rather than trusted:
- x1.1 exactly on the amazon-bedrock `eu.*` rows — the AWS EU regional premium
  (1 -> 1.1, 5 -> 5.5, 25 -> 27.5), plus one row moving the other way.
- ~x1.0-1.3 across ~40 openrouter rows; that bundle tracks live marketplace
  pricing, so drift there is the expected steady state.
- The two outliers are aliases, not repricing: `gemini-flash-latest` (x5) and
  `gemini-flash-lite-latest` (x2.5) were repointed from 2.5-flash to 3.5-flash.
  Confirmed the new values are byte-identical to the `gemini-3.5-flash` row,
  which is what a `-latest` alias is supposed to do.

MiniMax-M3 picks up `video` here as the clean one-row delta it was always meant
to be (jawcode `762549f`), with its cost row untouched.

**`hy3-preview` is re-blocked, and this is the important part.** Upstream
re-added `tencent/hy3-preview`, so the regeneration resurrected
`opencode-go/hy3-preview` — the model from lidge-jun#82 that returns
`Provider error 400 … model_not_supported` because it is not on the Zen Go lite
list. lidge-jun#82 was only ever "fixed" by upstream absence; there was no filter. There
is one now (`EXCLUDED_MODELS`), so a future re-add cannot hand users that 400
again. `hy3` itself stays selectable.

Two stale expectations updated with their reasons:
- `claude-opus-5` now has a real `anthropic` jawcode row at the *same*
  5/25/0.5/6.25 the maintainer derived, so its provenance moved
  `expected/verified-derived` -> `jawcode/verified` for that provider only.
  cursor and kiro still resolve through the overlay, so the overlay stays.
- `opencode-go` contexts follow upstream: `qwen3.5-plus` to 1M,
  `minimax-m3` down to the 512K tier that matches MiniMax's own ≤512K band.

The new guard regenerates into a temp file and byte-compares, so it cannot
clobber the committed output. It skips when the jawcode checkout is absent —
the generator throws without it, so asserting unconditionally would redden every
contributor and CI run, and drift can only be introduced by someone who has the
source anyway. Verified both directions: passes in sync, fails on a one-field
perturbation. (`JAWCODE_METADATA_OUT` exists to make that safe.)

Gates: tsc clean; sync-guard + codex-catalog + usage-cost + parity + slug-codec
+ minimax-reasoning-split 203 pass / 1 skip / 0 fail; privacy scan passed.

Author: lidge-jun

scripts/generate-jawcode-metadata.ts

@@ -22,7 +22,11 @@ type RawModel = {
 const sourcePath = process.env.JAWCODE_MODELS_JSON
   ? resolve(process.env.JAWCODE_MODELS_JSON)
   : resolve(process.cwd(), "../jawcode/packages/ai/src/models.json");
-const outPath = resolve(process.cwd(), "src/generated/jawcode-model-metadata.ts");
+// `JAWCODE_METADATA_OUT` lets the sync guard regenerate into a temp file and byte-compare without
+// any risk of clobbering the committed output (tests/jawcode-metadata-sync.test.ts).
+const outPath = process.env.JAWCODE_METADATA_OUT
+  ? resolve(process.env.JAWCODE_METADATA_OUT)
+  : resolve(process.cwd(), "src/generated/jawcode-model-metadata.ts");
 const CONTEXT_WINDOW_OVERRIDES: Record<string, number> = {
   "anthropic/claude-sonnet-4-6": 200_000,
   "anthropic/claude-sonnet-4-6[1m]": 200_000,
@@ -45,6 +49,15 @@ const COST_VENDOR_BUNDLES = [
 const allowedProviders = Array.from(
   new Set([...Object.values(PROVIDER_ALIASES), ...COST_VENDOR_BUNDLES]),
 ).sort();
+
+// Models the upstream catalogue lists but the provider rejects at request time. Issue #82:
+// `opencode-go/hy3-preview` returns `Provider error 400 ... model_not_supported` because it is not
+// on the Zen Go lite model list, yet upstream keeps re-adding `tencent/hy3-preview`. Without this
+// block, every regeneration resurrects it as a selectable model and users hit that 400 again.
+// Keyed as `<bundle>/<modelId>`; `tests/codex-catalog.test.ts` asserts the slug stays absent.
+const EXCLUDED_MODELS = new Set<string>([
+  "opencode-go/hy3-preview",
+]);
 const lines: string[] = [];
 
 function compactRow(values: unknown[]): unknown[] {
@@ -74,6 +87,7 @@ lines.push("const DATA: Record<string, readonly Row[]> = {");
 for (const provider of allowedProviders) {
   const models = registry[provider] ?? {};
   const rows = Object.entries(models)
+    .filter(([id]) => !EXCLUDED_MODELS.has(`${provider}/${id}`))
     .sort(([a], [b]) => a.localeCompare(b))
     .map(([id, model]) => compactRow([
       id,

src/generated/jawcode-model-metadata.ts

@@ -2071,9 +2071,11 @@ describe("Codex catalog routed normalization", () => {
   test("opencode-go high-risk models use official jawcode metadata in the Codex catalog", () => {
     const cases = [
       { id: "glm-5.2", context: 1_000_000, auto: 900_000, input: ["text"] },
-      { id: "qwen3.5-plus", context: 262_144, auto: 235_929, input: ["text", "image"] },
+      // Upstream raised qwen3.5-plus to a 1M window and cut minimax-m3 to the 512K tier that
+      // matches MiniMax's own <=512K pricing band; both are catalogue refreshes, not overrides.
+      { id: "qwen3.5-plus", context: 1_000_000, auto: 900_000, input: ["text", "image"] },
       { id: "kimi-k2.7-code", context: 262_144, auto: 235_929, input: ["text", "image"] },
-      { id: "minimax-m3", context: 1_000_000, auto: 900_000, input: ["text", "image"] },
+      { id: "minimax-m3", context: 512_000, auto: 460_800, input: ["text", "image"] },
       { id: "qwen3.7-max", context: 1_000_000, auto: 900_000, input: ["text"] },
     ] as const;
     const entries = buildCatalogEntries(nativeTemplate(), [], cases.map(({ id }) => ({ provider: "opencode-go", id })));

tests/codex-catalog.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+/**
+ * `src/generated/jawcode-model-metadata.ts` is generated from the jawcode `models.json`, and until
+ * now nothing checked that the committed file still matched its source. It drifted by 95 models —
+ * 148 price fields, 36 context windows, 45 maxTokens, and 36 entirely new models — which meant a
+ * routine regeneration would sweep all of that into cost accounting alongside whatever the author
+ * actually intended to change.
+ *
+ * This guard closes that. It regenerates into a temp directory and byte-compares, so it can never
+ * clobber the committed file.
+ *
+ * It SKIPS when the jawcode checkout is absent, which is the normal case for contributors and for
+ * CI: `scripts/generate-jawcode-metadata.ts` throws without it, so asserting unconditionally would
+ * turn every external run red. The drift can only be introduced by someone who has the source, so
+ * that is exactly where the check needs to fire.
+ */
+const GENERATED = resolve(import.meta.dir, "../src/generated/jawcode-model-metadata.ts");
+// Resolve the default exactly the way the generator does — relative to cwd, not to this file — so a
+// git worktree does not silently point at a sibling that happens to share the parent directory.
+const SOURCE = process.env.JAWCODE_MODELS_JSON
+  ? resolve(process.env.JAWCODE_MODELS_JSON)
+  : resolve(process.cwd(), "../jawcode/packages/ai/src/models.json");
+
+describe("generated jawcode metadata stays in sync with its source", () => {
+  test.skipIf(!existsSync(SOURCE))(
+    "regenerating reproduces the committed file byte for byte",
+    async () => {
+      const outDir = mkdtempSync(join(tmpdir(), "jawcode-sync-"));
+      const outPath = join(outDir, "jawcode-model-metadata.ts");
+
+      const proc = Bun.spawn(
+        ["bun", resolve(import.meta.dir, "../scripts/generate-jawcode-metadata.ts")],
+        {
+          cwd: resolve(import.meta.dir, ".."),
+          env: { ...process.env, JAWCODE_MODELS_JSON: SOURCE, JAWCODE_METADATA_OUT: outPath },
+          stdout: "pipe",
+          stderr: "pipe",
+        },
+      );
+      const exitCode = await proc.exited;
+      expect(exitCode, await new Response(proc.stderr).text()).toBe(0);
+
+      expect(readFileSync(outPath, "utf-8")).toBe(readFileSync(GENERATED, "utf-8"));
+    },
+    30_000,
+  );
+});

tests/jawcode-metadata-sync.test.ts

@@ -103,18 +103,35 @@ describe("normalizeCostTokens", () => {
 });
 
 describe("resolveMatchedPrice", () => {
-  // WP7: claude-opus-5 is exposed by three providers but missing from the jawcode
+  // WP7: claude-opus-5 is exposed by three providers but was missing from the jawcode
   // bundle, so it resolved to null and Logs rendered an em dash instead of a cost.
   // The model-level vendor fallback only searches jawcode metadata, never overlays,
-  // so each exposing provider needs its own row.
-  test("claude-opus-5 resolves to the user-derived Opus 4.6 price on every exposing provider", () => {
-    for (const provider of ["anthropic", "cursor", "kiro"]) {
+  // so each exposing provider needed its own row.
+  //
+  // Upstream has since published an `anthropic/claude-opus-5` row at the SAME numbers the
+  // maintainer derived (5 / 25 / 0.5 / 6.25), so that provider is now sourced from jawcode
+  // and reads `verified` instead of `verified-derived`. cursor and kiro have no jawcode row
+  // of their own and still come from the overlay, which is why the overlay must stay.
+  // The price is identical either way — only the provenance moved, and it moved forward.
+  test("claude-opus-5 resolves to the Opus 4.6 price on every exposing provider", () => {
+    const COST4 = { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 };
+
+    const anthropic = resolveMatchedPrice("anthropic", "claude-opus-5");
+    expect(anthropic).toMatchObject({
+      provider: "anthropic",
+      modelId: "claude-opus-5",
+      cost4: COST4,
+      source: "jawcode",
+      status: "verified",
+    });
+
+    for (const provider of ["cursor", "kiro"]) {
       const price = resolveMatchedPrice(provider, "claude-opus-5");
       expect(price).not.toBeNull();
       expect(price).toMatchObject({
         provider,
         modelId: "claude-opus-5",
-        cost4: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+        cost4: COST4,
         source: "expected",
         status: "verified-derived",
       });