@azure-id/orc 0.55.0

package/bin/mockrun-catalog.js

@@ -0,0 +1,267 @@
+"use strict";
+/**
+ * mockrun-catalog.js — the catalogue of MOCKED RUNS that ship with ORC.
+ *
+ * A mocked run is a written walkthrough of ONE lane: what you type, what ORC
+ * prints back, what lands on disk. Nothing was executed to produce them — they
+ * are documentation — and that is exactly why they exist: a new user needs to
+ * know what a lane LOOKS like before paying tokens to find out.
+ *
+ * Two sources, one catalogue:
+ *   · `mock-run/*.md`                       the reader-facing walkthroughs
+ *   · `templates/skills/<skill>/examples/*`  the dense annotated examples that
+ *                                            already shipped with each skill
+ *
+ * DERIVED, never hand-listed. A new file in either place appears by itself:
+ * the title comes from the file's own `# ` heading, the lane from whether
+ * `templates/commands/<name>.md` exists, and the one-line summary from the
+ * `> ` blockquote the walkthroughs open with. The only hand-written table here
+ * is the READING ORDER (`GROUPS` + `GROUP_OF`) — an order is editorial and
+ * cannot be derived from a filename. A file nobody placed still shows up, in
+ * the `other` group, because a mocked run that exists and is invisible is the
+ * failure mode this module is meant to make impossible.
+ *
+ * This is package content, not project state: it is the same on every machine
+ * and needs no `.claude/`. `orc mock-run` reads it, and `orc ui` serves it the
+ * same way it serves the onboarding walkthrough — straight from the module,
+ * because spawning a subprocess to read files that ship in this package would
+ * be ceremony with a cost. It is NOT `orc mock`, which lists the runnable
+ * `mock-examples/<slug>/` folders a green verify left in YOUR project.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const ROOT = path.join(__dirname, "..");
+const WALKTHROUGH_DIR = path.join(ROOT, "mock-run");
+const SKILLS_DIR = path.join(ROOT, "templates", "skills");
+const COMMANDS_DIR = path.join(ROOT, "templates", "commands");
+
+// The reading order. Group titles are DATA (the panel prints them as written
+// and never translates them, exactly like a config key or a doctor message).
+const GROUPS = [
+  { id: "start", title: "Start here" },
+  { id: "build", title: "Build a change" },
+  { id: "decide", title: "Decide what to build" },
+  { id: "knowledge", title: "Teach ORC your project" },
+  { id: "check", title: "Check what happened" },
+  { id: "ship", title: "Ship and hand over" },
+  { id: "tools", title: "Panel and terminal" },
+  { id: "other", title: "More" },
+];
+
+// slug (or lane name) → group. Anything absent lands in `other`.
+const GROUP_OF = {
+  "the-example-project": "start",
+  "a-normal-day": "start",
+
+  orc: "build",
+  "orc-ultra": "build",
+  "orc-mini": "build",
+  "orc-fast": "build",
+  "orc-quick": "build",
+  "orc-diy": "build",
+
+  // v0.48.0. It sits with the deciding lanes rather than the knowledge ones: a
+  // /orc-doc document is derived from what you DECIDED, not from the code —
+  // which is exactly what separates it from /orc-wiki and /orc-learn.
+  "orc-doc": "decide",
+
+  "orc-brainstorm": "decide",
+  "orc-grill": "decide",
+  "orc-plan": "decide",
+  "orc-route": "decide",
+  "orc-explain": "decide",
+  "orc-analyze": "decide",
+  "orc-analyze-mini": "decide",
+  "context-combiner": "decide",
+  "orc-poly": "decide",
+
+  // v0.50.0. It sits with the TOOLS rather than the build lanes: `orc extra` is
+  // not a lane you invoke — it is a setting that changes where the lanes you
+  // already run send their work.
+  "orc-extra": "tools",
+  // v0.54.0. It sits beside `orc-extra` for the same reason: recovering a
+  // half-finished foreign dispatch is a thing you do at the terminal and in the
+  // panel, not a lane you invoke.
+  "extra-recovery": "tools",
+  // v0.55.0. Same shelf again: the four lanes that pin an agent instead of
+  // scoring a task are a routing decision, and routing is where `orc-extra`
+  // already lives.
+  "extra-slots": "tools",
+
+  "orc-wiki": "knowledge",
+  "orc-pattern": "knowledge",
+  "orc-learn": "knowledge",
+  "orc-claude": "knowledge",
+  "orc-export": "knowledge",
+
+  "orc-verify": "check",
+  "orc-challenge": "check",
+  // v0.49.1. It sits beside the lane it belongs to, and it is a SEPARATE
+  // walkthrough because the council is a decision the reader takes before the
+  // first review runs — not a detail of one.
+  "orc-challenge-council": "check",
+  "orc-pact": "check",
+  "orc-boundary": "check",
+  "orc-aftermath": "check",
+  "orc-budget": "check",
+  "orc-retro": "check",
+
+  "orc-pr-setup": "ship",
+  "orc-pr-driver": "ship",
+  "orc-handoff": "ship",
+
+  "orc-ui": "tools",
+  "orc-cli": "tools",
+};
+
+// A few docs lead their group because they are prerequisites for reading the
+// rest, which alphabetical order cannot know. Everything else sorts by title.
+const PINNED_FIRST = ["the-example-project", "orc", "orc-brainstorm", "orc-wiki-example", "orc-verify-example"];
+
+// Files in mock-run/ that are not themselves a mocked run.
+const NOT_A_DOC = new Set(["INDEX.md", "README.md"]);
+
+function readSafe(p) {
+  try {
+    return fs.readFileSync(p, "utf8");
+  } catch (_) {
+    return null;
+  }
+}
+
+function listSafe(dir) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_) {
+    return [];
+  }
+}
+
+// `# Mock run — \`/orc-pact\`` → `Mock run — /orc-pact`. Backticks are markup
+// for a reader, not part of the title.
+function titleOf(md, fallback) {
+  const m = String(md || "").match(/^#\s+(.+?)\s*$/m);
+  return m ? m[1].replace(/`/g, "").trim() : fallback;
+}
+
+// The walkthroughs open with a `> one line` blockquote under the title. The
+// older annotated examples do not, so the first real line stands in.
+function summaryOf(md) {
+  const lines = String(md || "").split(/\r?\n/);
+  let seenTitle = false;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("# ")) {
+      seenTitle = true;
+      continue;
+    }
+    if (!seenTitle) continue;
+    if (line.startsWith(">")) return clip(line.replace(/^>\s?/, ""));
+    if (line.startsWith("#") || line.startsWith("---")) continue;
+    return clip(line);
+  }
+  return "";
+}
+
+// A summary is read as one line of prose, so the markup that made it readable
+// in the file (`**bold**`, `` `code` ``) is noise here.
+function clip(s, max = 200) {
+  const t = String(s).replace(/\*\*/g, "").replace(/`/g, "").trim();
+  return t.length > max ? t.slice(0, max - 1).trimEnd() + "…" : t;
+}
+
+// A name is a lane only when the payload really ships that slash command. This
+// is what keeps `/orc-pact` a link and `a-normal-day` plain text, with no list
+// to maintain in two places.
+function laneOf(name) {
+  return fs.existsSync(path.join(COMMANDS_DIR, name + ".md")) ? "/" + name : null;
+}
+
+function entry(slug, file, kind, name, md) {
+  const stat = (() => {
+    try {
+      return fs.statSync(file);
+    } catch (_) {
+      return null;
+    }
+  })();
+  const body = md === null ? "" : md;
+  return {
+    slug,
+    title: titleOf(body, slug),
+    lane: laneOf(name),
+    kind, // "walkthrough" = written for a reader · "annotated" = the dense one
+    group: GROUP_OF[name] || GROUP_OF[slug] || "other",
+    summary: summaryOf(body),
+    path: path.relative(ROOT, file).split(path.sep).join("/"),
+    bytes: stat ? stat.size : body.length,
+    lines: body ? body.split(/\r?\n/).length : 0,
+  };
+}
+
+// Every mocked run that ships in this package, in reading order.
+function list() {
+  const out = [];
+
+  for (const e of listSafe(WALKTHROUGH_DIR)) {
+    if (!e.isFile() || !e.name.endsWith(".md") || NOT_A_DOC.has(e.name)) continue;
+    const name = e.name.replace(/\.md$/, "");
+    const file = path.join(WALKTHROUGH_DIR, e.name);
+    out.push(entry(name, file, "walkthrough", name, readSafe(file)));
+  }
+
+  for (const s of listSafe(SKILLS_DIR)) {
+    if (!s.isDirectory()) continue;
+    const exDir = path.join(SKILLS_DIR, s.name, "examples");
+    for (const f of listSafe(exDir)) {
+      if (!f.isFile() || !f.name.endsWith(".md")) continue;
+      const file = path.join(exDir, f.name);
+      // One example per skill is the shipped shape; a second one keeps its own
+      // file name so neither can hide the other.
+      const base = f.name.replace(/\.md$/, "");
+      const slug = `${s.name}-example`;
+      const taken = out.some((d) => d.slug === slug);
+      out.push(entry(taken ? `${s.name}-${base}` : slug, file, "annotated", s.name, readSafe(file)));
+    }
+  }
+
+  const rank = new Map(GROUPS.map((g, i) => [g.id, i]));
+  out.sort((a, b) => {
+    const g = (rank.get(a.group) ?? 99) - (rank.get(b.group) ?? 99);
+    if (g) return g;
+    // Inside a group: pinned docs first, then the reader-facing walkthrough
+    // before the dense annotated example, then by title.
+    const p = (d) => {
+      const i = PINNED_FIRST.indexOf(d.slug);
+      return i === -1 ? PINNED_FIRST.length : i;
+    };
+    const pin = p(a) - p(b);
+    if (pin) return pin;
+    if (a.kind !== b.kind) return a.kind === "walkthrough" ? -1 : 1;
+    return a.title.localeCompare(b.title);
+  });
+  return out;
+}
+
+// The catalogue, grouped, with the counts a header can print without counting.
+function catalogue() {
+  const docs = list();
+  const groups = GROUPS.map((g) => ({
+    ...g,
+    docs: docs.filter((d) => d.group === g.id),
+  })).filter((g) => g.docs.length);
+  return { root: path.relative(ROOT, WALKTHROUGH_DIR) || "mock-run", total: docs.length, groups, docs };
+}
+
+// One doc, with its body. Returns null when the slug is unknown — the caller
+// decides what a miss means (exit 1 in the CLI, a 404 in the panel).
+function get(slug) {
+  const hit = list().find((d) => d.slug === slug);
+  if (!hit) return null;
+  return { ...hit, body: readSafe(path.join(ROOT, hit.path)) || "" };
+}
+
+module.exports = { GROUPS, catalogue, list, get };

package/bin/onboarding-content.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * onboarding-content.js — the single source for `orc onboarding`. One ordered
+ * list of sections; the CLI renders a menu (TTY) or prints them all (piped).
+ * Keeping the content here (not inline in cli.js) means the help/init pointers
+ * to `orc onboarding` can't drift from the walkthrough itself.
+ *
+ * Each section: { id, title, lines: string[] } — `lines` is plain text; the CLI
+ * adds the styled header. `{cmd}` is styled by the renderer.
+ */
+
+const SECTIONS = [
+  {
+    id: "overview",
+    title: "① What ORC is",
+    lines: [
+      "ORC is a CONSTELLATION of Claude Code skills, slash commands, and",
+      "model-pinned subagents — NOT a runtime. The `orc` CLI only installs those",
+      "files into your project's .claude/ directory; Claude Code reads and follows",
+      "them to run a build pipeline:",
+      "",
+      "   intake → analyze → plan → score → parallel subagents → review → verify → ship",
+      "",
+      "Every unit of work is done by a spawned subagent whose model is scored to the",
+      "task. The main session orchestrates; it never implements.",
+    ],
+  },
+  {
+    id: "install",
+    title: "② Install & init",
+    lines: [
+      "  orc init                 install into ./.claude (this project)",
+      "  orc init --global        install into ~/.claude (all projects)",
+      "  orc where                show exactly where files land",
+      "",
+      "init merges two guards into .claude/settings.json (non-destructively):",
+      "  • a PreToolUse effort hard-block (keeps /orc on a capable tier)",
+      "  • a statusline model warning (❌ ORC WILL DEGRADE on the wrong tier)",
+      "Run your MAIN session on Opus 4.8 high (or Opus 5 / Fable 5 at medium+) —",
+      "subagents can't exceed it; the top [90,100] band needs an Opus 5 session.",
+    ],
+  },
+  {
+    id: "first-run",
+    title: "③ Your first run",
+    lines: [
+      "  /orc <request>       full pipeline: analyze · plan · score · review · verify · ship",
+      "  /orc-mini <request>  fast lane: one Sonnet 5 subagent, no review/verify",
+      "  /orc-fast <request>  fastest: needs a fresh wiki + cached pattern (else falls to mini)",
+      "  /orc-quick <request> fewest steps: look · ask once · do. Works for a fix, a",
+      "                       quick question, a defect hunt, or PR review comments.",
+      "                       ALWAYS asks which agent to dispatch; saves every request",
+      "                       to orc-quick/<slug>/quick-context.md. No config overrides it.",
+      "",
+      "Session-tier acceptance (the statusline verdict):",
+      "  ✔ ORC-ready     Opus 4.8 high            (the baseline)",
+      "  🚀 ORC-boosted  Opus 4.8 xhigh/max, or   Opus 5 / Fable 5 medium…max",
+      "  ✖ WILL DEGRADE  anything below           (wrong model or sub-baseline effort)",
+      "",
+      "Which one do I type? Start from what you HAVE, not from the lane names:",
+      "  a quick question, or a small fix        →  /orc-quick",
+      "  one clear change you can describe       →  /orc-mini",
+      "  a big or risky change                   →  /orc",
+      "  you have no idea what the options are   →  /orc-brainstorm (it proposes)",
+      "  one idea, but it is still vague         →  /orc-grill   (a conversation)",
+      "  a document to turn into requirements    →  /orc-analyze",
+      "  a plan already in hand                  →  /orc-route   (which lane builds it)",
+      "  something ORC said that did not land    →  /orc-explain",
+      "",
+      "Settings: `orc config recommend` reads this repo and suggests one profile;",
+      "`orc config profile <name>` applies it. Paused mid-run? `orc resume`.",
+    ],
+  },
+  {
+    id: "lanes",
+    title: "④ Lanes cheat-sheet (28 commands)",
+    lines: [
+      "  /orc           full orchestrated pipeline",
+      "  /orc-quick     ask for almost anything — 3 steps, always asks which agent",
+      "  /orc-brainstorm no idea yet? it generates the options, you pick",
+      "  /orc-grill     sharpen a vague idea by conversation (no scan, no build)",
+      "  /orc-route     you have a PLAN — which lane should build it? (refuses prose)",
+      "  /orc-explain   say the last ORC message again, with the background it assumed",
+      "  /orc-mini      lightweight single-subagent build",
+      "  /orc-fast      knowledge-gated single-executor build (wiki + pattern)",
+      "  /orc-ultra     max rigor: + advisor + 3 judgment gates",
+      "  /orc-diy       your own composed flow (configure via `orc diy`)",
+      "  /orc-analyze   turn a doc/requirement into a code-grounded spec",
+      "  /orc-plan      turn a spec/request into a grounded task plan",
+      "  /orc-poly      cross-repo PLANNER (host + peers; never builds)",
+      "  /orc-pr-setup  stacked-PR planner — where the PR cut lines go (plans only)",
+      "  /orc-pr-driver stacked-PR driver — layer branches, per-layer green gate, submit",
+      "  /orc-verify    verify the git-modified changes (read-only)",
+      "  /orc-challenge grade a FINISHED artifact, then stop — you fix it elsewhere",
+      "  /orc-pact      the promises this project makes, and which are in doubt",
+      "  /orc-boundary  what ORC should NOT try here, and what would change that",
+      "  /orc-handoff   what a non-developer can safely change, with the undo first",
+      "  /orc-budget    what a PLAN will cost, in the unit you are billed in",
+      "  /orc-aftermath did what we shipped hold up (read-only, no telemetry)",
+      "  /orc-export    compile the context into a portable AGENTS.md",
+      "  /orc-wiki      build/maintain the project knowledge base",
+      "  /orc-pattern   learn & cache your code conventions per language",
+      "  /orc-claude    build/refresh this repo's CLAUDE.md",
+      "  /orc-learn     per-feature onboarding docs (local, git-ignored)",
+      "  /orc-retro     mine behavior traces → calibration report",
+    ],
+  },
+  {
+    id: "config",
+    title: "⑤ Config (`orc config`)",
+    lines: [
+      "Config is a CLI concern (zero model tokens). Edit via the interactive menu",
+      "or `orc config set <key> <value>`; overrides live in .claude/orc.config.yaml",
+      "and survive every update/upgrade.",
+      "",
+      "Groups:",
+      "  Common   waves, pauses, scoring granularity, analysis depth, tests,",
+      "           pattern gate, security pass, stacked PRs (stacked_pr + thresholds)",
+      "  Fable 5  fable5_enabled / fable5_effort / fable5_roles — HARD-GATED role",
+      "           override: route analyze/plan/advisor/judge/review to Fable 5 agents",
+      "           (nothing happens unless fable5_enabled: true AND roles are selected)",
+      "  Advanced dirs, crosslink day-tiers, orchestrator model, log dir",
+    ],
+  },
+  {
+    id: "knowledge",
+    title: "⑥ Knowledge systems (paid vs free)",
+    lines: [
+      "  wiki      (/orc-wiki)     PAID scan → persistent knowledge base. Registration",
+      "                            (`orc wiki sync`) is FREE and derived from the docs.",
+      "  pattern   (/orc-pattern)  PAID scan → cached per-language conventions executors",
+      "                            match. Probe existence free: `orc pattern status <lang>`.",
+      "  crosslink (`orc crosslink`) FREE graph config → advisory cross-repo wiki hints;",
+      "                            never blocks, reads foreign WIKI only (never source).",
+      "",
+      "Precedence everywhere: code > fresh wiki > stale wiki (hints) > model priors.",
+    ],
+  },
+  {
+    id: "upgrade",
+    title: "⑦ Upgrade & after-upgrade",
+    lines: [
+      "  orc upgrade    fetch the latest package (network), THEN apply it. Tries the",
+      "                 last source that worked, then the tarball, then the github: spec.",
+      "  orc update     re-copy the already-installed templates (offline).",
+      "  orc doctor     read-only health report (version skew, orphans, settings wiring).",
+      "  orc doctor --fix   = update + prune + settings re-merge.",
+      "",
+      "PRUNE removes files ORC used to ship but no longer does — only ones a previous",
+      "install manifest proves ORC owned. Your files, patterns, wiki, configs are never",
+      "touched. Your .claude/orc.config.yaml overrides always survive.",
+    ],
+  },
+  {
+    id: "troubleshooting",
+    title: "⑧ Troubleshooting",
+    lines: [
+      "  \"/orc blocked — required effort not met\"",
+      "     → switch to high effort (or Opus 5 / Fable 5 at medium+). xhigh/max also pass.",
+      "  statusline says \"WILL DEGRADE\"",
+      "     → wrong model/effort, or a usage window ≥90%. Move to Opus 4.8 high or Opus 5.",
+      "  \"wiki: UNREGISTERED\"",
+      "     → docs exist but no manifest. Run `orc wiki sync` (instant, no re-scan).",
+      "  /orc-diy \"blocked — no compiled flow\"",
+      "     → run `orc diy init`, shape it, then `orc diy compile`.",
+      "  an agent ran on the wrong model",
+      "     → the main session's tier caps subagents; run it on Opus 4.8 (or Fable 5).",
+    ],
+  },
+];
+
+module.exports = { SECTIONS };

package/bin/pricing.json

@@ -0,0 +1,200 @@
+{
+  "_readme": [
+    "Dated price table for `orc budget`. Point `orc config set budget_price_table <path>`",
+    "at your own copy to override it. Rates are USD per MILLION tokens.",
+    "",
+    "Four rates per model, never one: cache reads are usually the LARGEST token",
+    "count in a run and the CHEAPEST per token, so a blended number hides",
+    "whichever component is about to bite you. cache_write/cache_read are the",
+    "multipliers this vendor publishes against `input` (1.25x / 0.1x) written out",
+    "as absolute rates so nothing has to remember the ratio.",
+    "",
+    "`as_of` is load-bearing: a table older than 90 days makes every dollar",
+    "figure print a staleness warning. Bump the date only when you have checked",
+    "the published rates.",
+    "",
+    "`providers` (v0.50.0) is the same four-rate shape for a NON-CLAUDE endpoint",
+    "reached through `orc extra`. Every `models` map SHIPS EMPTY, on purpose, and",
+    "that is not an oversight: between this package's cutoff and any release the",
+    "lineup moves (DeepSeek V3.2 -> V4, Kimi K2 -> K2.7, GLM 4.6 -> 5.2), several",
+    "of these vendors price by PEAK/OFF-PEAK window or by tier, one is",
+    "subscription-only, and one is a passthrough with a surcharge. A shipped",
+    "figure that is wrong by 2x is worse than no figure, because a wrong figure",
+    "gets believed. So ORC ships the MECHANISM and no dollar figure without a",
+    "rate you put there yourself.",
+    "",
+    "Fill one in with `orc extra rates` — it lists every provider/model pair your",
+    "own traces have actually used, prints the JSON to paste, and says which ones",
+    "it has no rate for. A pair with no rate reports `usd: null` forever, never a",
+    "guess and never a family fallback."
+  ],
+  "as_of": "2026-08-01",
+  "currency": "USD",
+  "unit": "per_million_tokens",
+  "server_tools": {
+    "web_search_requests": 0.01,
+    "web_fetch_requests": 0.0
+  },
+  "models": {
+    "claude-opus-5": {
+      "input": 15,
+      "cache_write": 18.75,
+      "cache_read": 1.5,
+      "output": 75
+    },
+    "claude-opus-4-8": {
+      "input": 15,
+      "cache_write": 18.75,
+      "cache_read": 1.5,
+      "output": 75
+    },
+    "claude-opus-4-7": {
+      "input": 15,
+      "cache_write": 18.75,
+      "cache_read": 1.5,
+      "output": 75
+    },
+    "claude-fable-5": {
+      "input": 15,
+      "cache_write": 18.75,
+      "cache_read": 1.5,
+      "output": 75
+    },
+    "claude-sonnet-5": {
+      "input": 3,
+      "cache_write": 3.75,
+      "cache_read": 0.3,
+      "output": 15
+    },
+    "claude-sonnet-4-6": {
+      "input": 3,
+      "cache_write": 3.75,
+      "cache_read": 0.3,
+      "output": 15
+    },
+    "claude-haiku-4-5": {
+      "input": 1,
+      "cache_write": 1.25,
+      "cache_read": 0.1,
+      "output": 5
+    }
+  },
+  "families": {
+    "opus": {
+      "input": 15,
+      "cache_write": 18.75,
+      "cache_read": 1.5,
+      "output": 75
+    },
+    "fable": {
+      "input": 15,
+      "cache_write": 18.75,
+      "cache_read": 1.5,
+      "output": 75
+    },
+    "sonnet": {
+      "input": 3,
+      "cache_write": 3.75,
+      "cache_read": 0.3,
+      "output": 15
+    },
+    "haiku": {
+      "input": 1,
+      "cache_write": 1.25,
+      "cache_read": 0.1,
+      "output": 5
+    }
+  },
+  "_plans_readme": [
+    "Quota view. A Pro/Max user does not pay per token — they burn a 5-hour",
+    "session window and a weekly ceiling. These are WEIGHTED-token capacities",
+    "(cache reads counted at their 0.1x weight), because that is the unit the",
+    "forecast can actually produce. They are approximations of a published",
+    "allowance, not a metered balance: the percentages are a magnitude, and the",
+    "renderer says so."
+  ],
+  "plans": {
+    "pro": {
+      "label": "Pro",
+      "window_weighted_tokens": 900000,
+      "weekly_weighted_tokens": 9000000
+    },
+    "max5": {
+      "label": "Max 5x",
+      "window_weighted_tokens": 4500000,
+      "weekly_weighted_tokens": 45000000
+    },
+    "max20": {
+      "label": "Max 20x",
+      "window_weighted_tokens": 18000000,
+      "weekly_weighted_tokens": 180000000
+    }
+  },
+  "context_windows": {
+    "claude-opus-5": 200000,
+    "claude-opus-4-8": 200000,
+    "claude-opus-4-7": 200000,
+    "claude-fable-5": 200000,
+    "claude-sonnet-5": 200000,
+    "claude-sonnet-4-6": 200000,
+    "claude-haiku-4-5": 200000
+  },
+  "providers": {
+    "_note": "Rates are USD per MILLION tokens, four per model, never one. `models` maps a provider's own model id EXACTLY as the endpoint reports it.",
+    "deepseek": {
+      "label": "DeepSeek",
+      "caveat": "Prices differ by PEAK and OFF-PEAK window, so one number cannot be right for both. Record the window you actually run in.",
+      "models": {}
+    },
+    "zai": {
+      "label": "Z.ai / GLM",
+      "caveat": "The current flagship is sold inside a Coding Plan subscription rather than per token, which a per-token table cannot express. Leave it empty and read your invoice.",
+      "models": {}
+    },
+    "moonshot": {
+      "label": "Moonshot / Kimi",
+      "caveat": null,
+      "models": {}
+    },
+    "minimax": {
+      "label": "MiniMax",
+      "caveat": null,
+      "models": {}
+    },
+    "qwen": {
+      "label": "Alibaba / Qwen",
+      "caveat": "Tiered by request size, so a single rate is an average rather than a price.",
+      "models": {}
+    },
+    "mimo": {
+      "label": "Xiaomi / MiMo",
+      "caveat": null,
+      "models": {}
+    },
+    "stepfun": {
+      "label": "StepFun",
+      "caveat": null,
+      "models": {}
+    },
+    "siliconflow": {
+      "label": "SiliconFlow",
+      "caveat": null,
+      "models": {}
+    },
+    "openrouter": {
+      "label": "OpenRouter",
+      "caveat": "A PASSTHROUGH: the rate is the upstream provider's, plus a surcharge on credit purchase. It also reroutes between providers by default while preserving the model id, so the model id alone does not identify who you paid.",
+      "models": {}
+    },
+    "ollama": {
+      "label": "Ollama (local)",
+      "caveat": "Local inference has no per-token price. Zero here would be true of the API bill and false of the electricity and the hardware, so it is left empty rather than asserted as free.",
+      "models": {}
+    },
+    "custom": {
+      "label": "Custom endpoint",
+      "caveat": null,
+      "models": {}
+    }
+  }
+}