openzoo 0.49.18 → 0.50.0

package/lib/worktree.mjs

@@ -1,424 +0,0 @@
-// Desktop grokui SPAWN isolation — Claude Code worktrees + UltraCode
-// spawn_agent_worktree. Not ported to iOS/Android/Seeker/PSG1 (no local FS).
-//
-// Git goes through dugite's bundled binary, never PATH `git`.
-import { execFileSync } from 'node:child_process';
-import {
-  appendFileSync, cpSync, existsSync, mkdirSync, readdirSync,
-  readFileSync, rmSync,
-} from 'node:fs';
-import { homedir } from 'node:os';
-import path from 'node:path';
-import { setupEnvironment } from 'dugite';
-
-const FETCH_MS = 8000;
-const GIT_MS = 15000;
-
-export function agentSlug(name) {
-  const pr = parsePrRef(name);
-  if (pr) return `pr-${pr.n}`;
-  const s = String(name || 'agent').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64);
-  return s || 'agent';
-}
-
-/** #123, GitHub PR URL, GitLab MR URL, or a generic /pull/N. */
-export function parsePrRef(text) {
-  const s = String(text || '').trim();
-  if (!s) return null;
-  const hash = /^#(\d+)\b/.exec(s);
-  if (hash) return { n: Number(hash[1]) };
-  const gh = /github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)/i.exec(s);
-  if (gh) return { n: Number(gh[1]), host: 'github.com' };
-  const gl = /gitlab\.com\/\S+\/-\/merge_requests\/(\d+)/i.exec(s);
-  if (gl) return { n: Number(gl[1]), host: 'gitlab.com' };
-  const pull = /\/pull\/(\d+)\b/i.exec(s);
-  if (pull) return { n: Number(pull[1]) };
-  return null;
-}
-
-export function extractPrFromSpawn(name, spec) {
-  const fromName = parsePrRef(name);
-  if (fromName) return fromName;
-  const body = String(spec || '').trim();
-  if (!body) return null;
-  const first = body.split(/\s+/)[0];
-  return parsePrRef(first) || parsePrRef(body.split('|')[0].trim()) || parsePrRef(body);
-}
-
-/** github.com → pull/N/head; gitlab.com → merge-requests/N/head; else pull first. */
-export function fetchSpecsForOrigin(originUrl, n) {
-  const url = String(originUrl || '');
-  if (/github\.com/i.test(url)) return [`pull/${n}/head`];
-  if (/gitlab\.com/i.test(url)) return [`merge-requests/${n}/head`];
-  return [`pull/${n}/head`, `merge-requests/${n}/head`];
-}
-
-/** Absolute dugite binary, or '' if the embed is missing. Never PATH `git`. */
-export function bundledGitPath() {
-  try {
-    const { gitLocation } = setupEnvironment({});
-    return gitLocation && existsSync(gitLocation) ? gitLocation : '';
-  } catch {
-    return '';
-  }
-}
-
-function resolveGitRunner() {
-  let gitLocation = '';
-  let env = {};
-  try {
-    const setup = setupEnvironment({
-      GIT_TERMINAL_PROMPT: '0',
-      GIT_CONFIG_NOSYSTEM: '1',
-    });
-    gitLocation = setup.gitLocation;
-    env = setup.env;
-  } catch { /* setup failed */ }
-  if (!gitLocation || !existsSync(gitLocation)) {
-    throw new Error('dugite embedded git is missing — SPAWN will not call PATH git');
-  }
-  return { bin: gitLocation, env, bundled: true };
-}
-
-let lastGitBinary = '';
-export function gitBinary() { return lastGitBinary; }
-
-/** Dugite bundled git only. Never exec `git` from PATH. */
-export function git(args, cwd, { allowFail = false, timeout = GIT_MS } = {}) {
-  let bin, env;
-  try {
-    ({ bin, env } = resolveGitRunner());
-  } catch (e) {
-    if (allowFail) return '';
-    throw e;
-  }
-  lastGitBinary = bin;
-  try {
-    return execFileSync(bin, ['-c', 'safe.directory=*', ...args], {
-      cwd,
-      env,
-      encoding: 'utf8',
-      timeout,
-      maxBuffer: 8 * 1024 * 1024,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    }).trim();
-  } catch (e) {
-    if (allowFail) return '';
-    const err = new Error((e.stderr || e.message || '').toString().trim() || 'git failed');
-    err.code = e.status;
-    throw err;
-  }
-}
-
-export function githubRepoFromOrigin(originUrl) {
-  const m = /github\.com[:/]([^/]+)\/([^/.]+)/i.exec(String(originUrl || ''));
-  return m ? { owner: m[1], repo: m[2] } : null;
-}
-
-export function githubPullApiUrl(originUrl, n) {
-  const r = githubRepoFromOrigin(originUrl);
-  return r ? `https://api.github.com/repos/${r.owner}/${r.repo}/pulls/${n}` : null;
-}
-
-export function gitlabProjectFromOrigin(originUrl) {
-  const m = /gitlab\.com[:/](.+?)(?:\.git)?$/i.exec(String(originUrl || '').replace(/\/+$/, ''));
-  return m ? m[1].replace(/\.git$/i, '') : null;
-}
-
-export function gitlabMrApiUrl(originUrl, n) {
-  const project = gitlabProjectFromOrigin(originUrl);
-  return project
-    ? `https://gitlab.com/api/v4/projects/${encodeURIComponent(project)}/merge_requests/${n}`
-    : null;
-}
-
-function httpGetJsonSync(url) {
-  const src = `
-    const r = await fetch(${JSON.stringify(url)}, {
-      headers: { 'user-agent': 'openzoo-grokui', accept: 'application/json' },
-    });
-    if (!r.ok) process.exit(1);
-    process.stdout.write(await r.text());
-  `;
-  const body = execFileSync(process.execPath, ['--input-type=module', '-e', src], {
-    encoding: 'utf8',
-    timeout: FETCH_MS,
-    maxBuffer: 2 * 1024 * 1024,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-  return JSON.parse(body);
-}
-
-/** GitHub/GitLab API → commit SHA when `git fetch pull/N/head` cannot. */
-export function fetchPrHeadShaViaApi(originUrl, n) {
-  const gh = githubPullApiUrl(originUrl, n);
-  if (gh) {
-    try {
-      const j = httpGetJsonSync(gh);
-      if (j?.head?.sha) return String(j.head.sha);
-    } catch { /* */ }
-  }
-  const gl = gitlabMrApiUrl(originUrl, n);
-  if (gl) {
-    try {
-      const j = httpGetJsonSync(gl);
-      if (j?.sha) return String(j.sha);
-    } catch { /* */ }
-  }
-  return '';
-}
-
-export function isolatedWorktreesHome(home = homedir()) {
-  return path.join(home, '.openzoo', 'grokui-worktrees');
-}
-
-export function isGitRepo(dir) {
-  if (!dir || !existsSync(dir)) return false;
-  return git(['rev-parse', '--is-inside-work-tree'], dir, { allowFail: true }) === 'true';
-}
-
-export function mainRepoRoot(dir) {
-  if (!isGitRepo(dir)) return null;
-  let common = git(['rev-parse', '--path-format=absolute', '--git-common-dir'], dir, { allowFail: true });
-  if (!common) {
-    const rel = git(['rev-parse', '--git-common-dir'], dir, { allowFail: true });
-    common = rel ? path.resolve(dir, rel) : '';
-  }
-  if (!common) return null;
-  if (common.endsWith('.git')) return path.dirname(common);
-  return common;
-}
-
-export function originUrl(repo) {
-  return git(['remote', 'get-url', 'origin'], repo, { allowFail: true });
-}
-
-export function freshBaseRef(repo) {
-  const sym = git(['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD'], repo, { allowFail: true });
-  if (sym) return sym.replace(/^refs\/remotes\//, '');
-  for (const cand of ['origin/main', 'origin/master', 'main', 'master']) {
-    if (git(['rev-parse', '--verify', cand], repo, { allowFail: true })) return cand;
-  }
-  return 'HEAD';
-}
-
-function ensureExclude(repo) {
-  const common = git(['rev-parse', '--path-format=absolute', '--git-common-dir'], repo, { allowFail: true })
-    || path.join(repo, '.git');
-  const exclude = path.join(common, 'info', 'exclude');
-  try { mkdirSync(path.dirname(exclude), { recursive: true }); } catch { /* */ }
-  let cur = '';
-  try { cur = readFileSync(exclude, 'utf8'); } catch { /* */ }
-  if (!cur.includes('.openzoo/worktrees')) {
-    appendFileSync(exclude, (cur.endsWith('\n') || !cur ? '' : '\n') + '.openzoo/worktrees/\n');
-  }
-}
-
-function worktreeListed(repo, dest) {
-  const list = git(['worktree', 'list', '--porcelain'], repo, { allowFail: true });
-  const want = path.resolve(dest);
-  for (const block of list.split('\n\n')) {
-    const line = block.split('\n').find((l) => l.startsWith('worktree '));
-    if (line && path.resolve(line.slice(9).trim()) === want) return true;
-  }
-  return false;
-}
-
-function simpleGlobMatch(pattern, rel) {
-  const p = String(pattern || '').replace(/\\/g, '/').replace(/\/+$/, '');
-  const r = String(rel || '').replace(/\\/g, '/');
-  if (!p) return false;
-  if (!p.includes('*') && !p.includes('?')) {
-    return r === p || r.endsWith('/' + p) || path.basename(r) === p;
-  }
-  const re = new RegExp('^' + p.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
-  return re.test(r) || re.test(path.basename(r));
-}
-
-/** Claude .worktreeinclude — copy matching gitignored files. Optional, never blocks. */
-export function copyWorktreeIncludes(repo, dest) {
-  const spec = path.join(repo, '.worktreeinclude');
-  if (!existsSync(spec) || !existsSync(dest)) return 0;
-  const patterns = readFileSync(spec, 'utf8').split(/\r?\n/)
-    .map((l) => l.trim()).filter((l) => l && !l.startsWith('#'));
-  if (!patterns.length) return 0;
-  const ignored = git(['ls-files', '-oi', '--exclude-standard', '-z'], repo, { allowFail: true })
-    .split('\0').filter(Boolean);
-  let n = 0;
-  for (const rel of ignored) {
-    if (!patterns.some((p) => simpleGlobMatch(p, rel))) continue;
-    const from = path.join(repo, rel);
-    const to = path.join(dest, rel);
-    try {
-      if (!existsSync(from)) continue;
-      mkdirSync(path.dirname(to), { recursive: true });
-      cpSync(from, to);
-      n += 1;
-    } catch { /* optional */ }
-  }
-  return n;
-}
-
-export function worktreePath(repo, slug) {
-  return path.join(repo, '.openzoo', 'worktrees', slug);
-}
-
-export function worktreeBranch(slug) {
-  return `worktree-${slug}`;
-}
-
-function addWorktree(repo, slug, { pr = null } = {}) {
-  const dest = worktreePath(repo, slug);
-  const branch = worktreeBranch(slug);
-  mkdirSync(path.dirname(dest), { recursive: true });
-  ensureExclude(repo);
-
-  if (existsSync(dest) && worktreeListed(repo, dest)) {
-    return {
-      path: dest, branch, repo, reused: true,
-      fetchRef: pr?.n ? fetchSpecsForOrigin(originUrl(repo), pr.n)[0] : '',
-    };
-  }
-  if (existsSync(dest)) {
-    try { rmSync(dest, { recursive: true, force: true }); } catch { /* */ }
-  }
-
-  let base = freshBaseRef(repo);
-  let fetchRef = '';
-  if (pr?.n) {
-    const origin = originUrl(repo);
-    const specs = fetchSpecsForOrigin(origin, pr.n);
-    for (const spec of specs) {
-      try {
-        git(['fetch', '--no-tags', 'origin', spec], repo, { timeout: FETCH_MS });
-        if (git(['rev-parse', '--verify', 'FETCH_HEAD'], repo, { allowFail: true })) {
-          fetchRef = spec;
-          base = 'FETCH_HEAD';
-          break;
-        }
-      } catch { /* next spec */ }
-    }
-    if (!fetchRef && origin) {
-      const sha = fetchPrHeadShaViaApi(origin, pr.n);
-      if (sha) {
-        try {
-          git(['fetch', '--no-tags', 'origin', sha], repo, { timeout: FETCH_MS });
-          if (git(['rev-parse', '--verify', sha], repo, { allowFail: true })) {
-            fetchRef = specs[0];
-            base = sha;
-          }
-        } catch { /* isolated fallback */ }
-      }
-    }
-  }
-
-  const hasBranch = Boolean(git(['rev-parse', '--verify', `refs/heads/${branch}`], repo, { allowFail: true }));
-  try {
-    if (hasBranch) git(['worktree', 'add', dest, branch], repo);
-    else git(['worktree', 'add', '-b', branch, dest, base], repo);
-  } catch (e) {
-    if (!existsSync(dest)) throw e;
-  }
-  try { copyWorktreeIncludes(repo, dest); } catch { /* optional */ }
-  return {
-    path: dest, branch, repo, reused: hasBranch, baseRef: base,
-    ...(fetchRef ? { fetchRef } : {}),
-    ...(pr?.n ? { pr: pr.n } : {}),
-  };
-}
-
-function isolatedChildDir(parentDir, slug) {
-  let dest = path.join(isolatedWorktreesHome(), slug);
-  const parent = path.resolve(parentDir);
-  if (dest === parent || dest.startsWith(parent + path.sep)) {
-    dest = path.join(homedir(), '.openzoo', 'grokui-worktrees-out', slug);
-  }
-  if (dest === parent) throw new Error('refusing to isolate a child into the parent cwd');
-  mkdirSync(dest, { recursive: true });
-  return { path: dest, branch: null, kind: 'isolated' };
-}
-
-/**
- * Isolated cwd for a SPAWNed grokui thread (same Node process; shell cwd = t.dir).
- * Git parent → <repo>/.openzoo/worktrees/<slug> on worktree-<slug>.
- * Non-git → ~/.openzoo/grokui-worktrees/<slug>, never the parent dir.
- */
-export function prepareChildDir(parent, name, spec) {
-  const parentDir = path.resolve(parent?.dir || process.env.OZ_WORKSPACE_DIR
-    || path.join(homedir(), '.openzoo', 'grokui-workspace'));
-  const pr = extractPrFromSpawn(name, spec);
-  const slug = pr && parsePrRef(name) ? `pr-${pr.n}` : agentSlug(name);
-  const repo = mainRepoRoot(parentDir);
-  if (repo) {
-    try {
-      const ws = addWorktree(repo, slug, { pr });
-      return {
-        path: ws.path,
-        branch: ws.branch,
-        parentDir,
-        kind: 'worktree',
-        repo,
-        fetchRef: ws.fetchRef || '',
-        baseRef: ws.baseRef,
-      };
-    } catch { /* fall back to isolated, still not parent cwd */ }
-  }
-  return { ...isolatedChildDir(parentDir, slug), parentDir };
-}
-
-export function worktreeHasWork(wt) {
-  if (!wt?.path || !existsSync(wt.path)) return false;
-  if (wt.kind === 'isolated' || !wt.branch) {
-    try { return readdirSync(wt.path).length > 0; } catch { return false; }
-  }
-  if (git(['status', '--porcelain'], wt.path, { allowFail: true })) return true;
-  const base = wt.baseRef && wt.baseRef !== 'FETCH_HEAD' && wt.baseRef !== 'HEAD'
-    ? wt.baseRef
-    : (wt.repo ? freshBaseRef(wt.repo) : 'HEAD');
-  if (Number(git(['rev-list', '--count', `${base}..HEAD`], wt.path, { allowFail: true })) > 0) return true;
-  const unpushed = git(['rev-list', '--count', '@{upstream}..HEAD'], wt.path, { allowFail: true });
-  return Boolean(unpushed && Number(unpushed) > 0);
-}
-
-export function lockWorktree(wtOrThread) {
-  const wt = wtOrThread?.worktree || wtOrThread;
-  if (!wt?.path || !wt.branch || !existsSync(wt.path)) return false;
-  git(['worktree', 'lock', '--reason', 'openzoo spawn', wt.path], wt.repo || wt.path, { allowFail: true });
-  wt.locked = true;
-  return true;
-}
-
-export function unlockWorktree(wtOrThread) {
-  const wt = wtOrThread?.worktree || wtOrThread;
-  if (!wt?.path || !wt.branch) return false;
-  git(['worktree', 'unlock', wt.path], wt.repo || wt.path, { allowFail: true });
-  wt.locked = false;
-  return true;
-}
-
-/** Clean worktree → remove + delete the branch we created. Dirty → keep. */
-export function finishChildDir(wtOrThread) {
-  const thread = wtOrThread && wtOrThread.worktree ? wtOrThread : null;
-  const wt = thread?.worktree || wtOrThread;
-  if (!wt?.path) return { skipped: true };
-  unlockWorktree(wt);
-  if (worktreeHasWork(wt)) return { kept: true, path: wt.path, branch: wt.branch };
-  if (wt.kind === 'worktree' && wt.repo && wt.branch) {
-    git(['worktree', 'remove', '--force', wt.path], wt.repo, { allowFail: true });
-    git(['branch', '-D', wt.branch], wt.repo, { allowFail: true });
-  }
-  try { if (existsSync(wt.path)) rmSync(wt.path, { recursive: true, force: true }); } catch { /* */ }
-  if (thread) delete thread.worktree;
-  return { removed: true, path: wt.path, branch: wt.branch };
-}
-
-export function isWorktreeLocked(repo, dest) {
-  const list = git(['worktree', 'list', '--porcelain'], repo, { allowFail: true });
-  const want = path.resolve(dest);
-  let current = '';
-  for (const line of list.split('\n')) {
-    if (line.startsWith('worktree ')) current = path.resolve(line.slice(9).trim());
-    if ((line === 'locked' || line.startsWith('locked ')) && current === want) return true;
-  }
-  return false;
-}

package/vendor/modelroute/CURRENT_STATE.md

@@ -1,132 +0,0 @@
-# modelroute — current state
-
-_Snapshot: 2026-08-20. Read `HANDOFF.md` for how to integrate; this file is what is true, what is
-guessed, and what is unfinished._
-
----
-
-## Status at a glance
-
-| part | state |
-|---|---|
-| Router runtime (`route()`) | **working**, 22 contract tests + module selftest green |
-| Catalogue (414 gateway-callable models) | **working**, rebuilt from the gateway, 11 KB |
-| Task classifier (10 classes) | **working**, 0.642 held-out / 0.772 5-fold, 40 KB |
-| End-to-end CLI (`ask.py`) | **working** — routes, calls openzoo, records outcome |
-| `P_success` measured on real models | **in progress** — hard-suite run ~20% done |
-| Base-suite outcomes | **discarded** (saturated, low-n) — kept at `outcomes.base.json.bak` |
-| Vision / creative / advice classes | **never measured** — no objective grader, prior only |
-
-The router works today on priors. It works *better* the moment the hard-suite run lands and every
-time you record a real outcome.
-
----
-
-## What is measured vs. what is authored
-
-This distinction is the whole point of the design. Do not blur it.
-
-### MEASURED (evidence)
-
-- **Classifier accuracy.** 0.642 on a register-shifted held-out split, against a bag-of-words
-  baseline at 0.333 and majority at 0.100. Ablated: ridge head +0.12 over perceptron, hashed IDF
-  +0.09, anchor gazetteer +0.075. Caveat: anchors were written *after* inspecting held-out errors,
-  so 0.642 is optimistically biased. The 5-fold number (0.772) is clean.
-- **Routing regret.** 5.0% of held-out requests route below the bar their true class demands, at a
-  median 1.12× the oracle route's cost. The top-2 hedge causes that: hedge off gives 13.3% under-bar
-  at 1.00× cost. Ability bought with money, as the objective asks.
-- **Model success rates.** In progress. See below.
-
-### AUTHORED (policy, not evidence — argue with these)
-
-- **`_BAR`** — the required `P_success` per (class, difficulty). The single most important knob.
-- **`_OUT_TOKENS`** — expected completion length per class. Cost is linear in it.
-- **`_CLASS_CATEGORIES`** — which OpenRouter leaderboards count as evidence for which task class.
-  `vision` uses `technology` as an explicit *proxy* (there is no vision leaderboard); `bulk` maps to
-  nothing on purpose, so its objective degenerates to "cheapest feasible", which is correct for it.
-- **`P_TOP/P_BOT/P_UNKNOWN`** — how a leaderboard rank becomes a probability, and what an unranked
-  model is assumed to be worth (0.45, deliberately below every bar except bulk/chat).
-- **`BIND_ABOVE_TOKENS` (60k), `BIND_SLICE_TOKENS` (8k)** — when to bind instead of buying context.
-- **`difficulty()`** — a 3-signal heuristic (rigour cues, long input, low classifier margin). There
-  are no difficulty labels in the corpus, so a trained head here would be a guess in a lab coat.
-
----
-
-## The measurement run
-
-**Hard suite** (`suite_hard.py`): 64 tasks, every answer key **computed by the generator** and
-verified before spending — a reference answer must pass the real grader and a wrong answer must fail
-it. 5 classes: reasoning (24), agentic (12), longctx (10), bulk (10), code (8).
-
-It discriminates, which the base suite did not:
-
-| class | pass rate across models so far |
-|---|---|
-| agentic | 0.96 |
-| longctx | 0.88 |
-| code | 0.79 |
-| reasoning | 0.67 |
-| bulk | 0.54 |
-
-Model spread so far runs 0.60 → 0.95 (vs. the base suite, where 30 of 124 models tied at a perfect
-1.00 and it could not rank anything above the floor).
-
-**Run state:** ~1,200 of 6,336 calls, 20 of 99 models, ~$5 spent, ~4 calls/s, ETA well under an hour.
-Restart with the same command and `--resume` — it skips completed calls and *retries* errored ones.
-
-### Why 99 models, not 414
-
-409 models is not 409 pieces of information. `gpt-5.6-luna/sol/terra` scored identically; so did the
-`deepseek-v4-flash` and `gemini-3.x-flash` families. A fixed budget is models × tasks, and redundant
-variants buy nothing while every per-class estimate stays at n≈4 — a 95% CI **0.5 wide**, wider than
-the entire range the router cares about. `--per-provider 2` takes each provider's flagship (by
-leaderboard placement, then capability) plus its cheapest option. Same money, 10× the depth.
-
-### Statistical power, plainly
-
-| tasks per model | 95% CI width at p≈0.9 |
-|---|---|
-| 5 | 0.59 |
-| 10 | 0.39 |
-| 30 | 0.22 |
-| 64 (hard suite) | ~0.18 overall, but only ~n=10–24 *per class* |
-
-**Per-class estimates are still thin.** Overall model quality is now solidly measured; a
-per-(class, model) number at n=10 still leans on the prior. If you need per-class confidence, add
-tasks to that class in `suite_hard.py` — the generators make that cheap and key-safe.
-
----
-
-## Known weaknesses (ranked by how much they should bother you)
-
-1. **Three classes are never measured.** `creative`, `advice` and `vision` have no objective grader
-   (`vision` also needs image fixtures). They run on the leaderboard prior and always will until
-   someone decides what "good" means for them. An LLM judge was rejected: it is a second opinion, not
-   a measurement, and it would poison the same table the benchmark fills with real results.
-2. **`code` is the worst classifier class** (0.25 on the register-shifted held-out split). Requests
-   like "the linter hates everything I write" share no vocabulary with the training split. The
-   anchor gazetteer helps; more real examples would help more.
-3. **The corpus is one person's idea of what requests look like** — 400 authored sentences. Your
-   actual traffic is the real distribution. Drop a JSONL at
-   `lecore_data/modelroute/eval_real.jsonl` (`{"text":…, "label":…}`) and `train_router.py` will
-   report against it automatically.
-4. **21% of gateway calls return 429.** It is a per-account limit, not a concurrency problem —
-   dropping from 48 to 16 workers made it *worse*. The shared throttle handles it; it costs
-   wall-clock, not money or correctness.
-5. **Real prompts are fragments.** In a live agent session most turns are "fix it" / "did this
-   work?", which carry no routable task alone. Pass the conversation as `context=`; the router will
-   otherwise hedge (correctly) and route as if the task were hard, which costs money.
-
----
-
-## What I would build next, in order
-
-1. **Wire outcome recording into the openzoo call path.** Everything else exists. This is the step
-   that makes `P_success` yours instead of borrowed.
-2. **Grow `suite_hard.py` per class** until per-class n ≥ 30, using the generators (keys stay
-   correct by construction).
-3. **Decide what "good" means for creative/advice**, or accept them as prior-only forever and say so
-   in the UI.
-4. **Thompson sampling for exploration.** Right now the cheapest clearing model always wins, so the
-   alternatives never get observed and the table can only improve where you already route. A small
-   exploration budget would fix that; the Beta posteriors needed for it are already there.

package/vendor/modelroute/FOR_MOOSE.md

@@ -1,110 +0,0 @@
-# The auto-router, for Moose
-
-*How `openzoo/auto` picks a model — a VSA classifier trained closed-form, 40KB,
-no torch, no embeddings, no pretrained anything. Your math, our objective.*
-
-## The objective (this is the part that isn't a classifier)
-
-Routing is not "what topic is this" and not "what's the best model":
-
-```
-pick  argmin  cost(m, task)   subject to   P_success(m | task) >= bar(task)
-       m ∈ feasible(task)
-```
-
-If nothing clears the bar, say so and return the highest-P option **labelled as
-such** — never silently pretend the cheapest one was fine. Four terms, four
-sources:
-
-- **feasible()** — hard metadata facts only (image input, tool calling, strict
-  JSON, context length). A model without an image modality can't read a
-  screenshot at any price. Never guessed.
-- **cost()** — `price_in × est. prompt tokens + price_out × est. completion
-  tokens`, divided by the cheapest feasible candidate's, so ranking is
-  scale-free.
-- **bar()** — an authored policy knob per (class, difficulty). Stated, not
-  hidden, not measured.
-- **P_success()** — the interesting one, below.
-
-**A trap we deliberately walked around:** price is tempting as a capability
-proxy (expensive ≈ stronger). It is NOT used that way, because cost is the
-thing being minimised — letting price raise P_success would make the objective
-partly cancel itself and quietly re-rank toward expensive models for no
-measured reason. Price appears in cost(), nowhere else.
-
-## The classifier — random indexing, two gradient-free heads
-
-Text → hypervector by **Kanerva random indexing**: each token deterministically
-hashes (sha256, never Python's salted `hash()` — deterministic under any
-`PYTHONHASHSEED`) to k sparse ±1 positions in d=4096. A request is the bundle
-of its token atoms over **three separately-normalised channels** — words, word
-bigrams, char 4-grams — so a misspelling degrades a vector instead of erasing a
-word. Channel atoms are weighted by a hashed IDF table (16KB).
-
-Two heads produce the **same artifact shape** (K×d matrix, K=10 classes:
-code / reasoning / longctx / vision / bulk / creative / translate / agentic /
-chat / advice):
-
-- **ridge (shipped)** — closed-form one-vs-rest least squares in the dual:
-  `W = Xᵀ(XXᵀ + λI)⁻¹Y`. One 535×535 solve. No epochs, no learning rate, no
-  shuffling, no lucky seed.
-- **adapthd (kept)** — perceptron prototypes; the reference the ridge head is
-  checked against.
-
-Shipped artifact: **40KB int8 matrix + 16KB IDF**. Inference is a dot product.
-`router.json` carries `{classes, q_b64 (int8), q_shape [10,4096], scale, idf}`.
-
-## Measured, with ablations (train_router.py --ablate)
-
-10 classes, 400 authored requests + anchors, held-out split written in a
-deliberately different register:
-
-| configuration | held-out | 5-fold |
-|---|---|---|
-| ridge + IDF + anchors | **0.642** | **0.772** |
-| bag-of-words nearest centroid | 0.333 | — |
-| majority class | 0.100 | — |
-
-Each of the three choices (ridge, IDF, anchors) was ablated separately and each
-earns its place.
-
-**But class accuracy is not the headline.** `routing_regret.py` measures the
-classifier in dollars and failures instead: **5.0% of held-out requests route
-below the bar their true class would have demanded, at a median 1.12× the
-oracle route's cost.** A misclassification that lands on an adequate cheaper
-model is not an error that matters.
-
-## P_success — a prior that becomes a measurement
-
-No API reports "model m completes class c with probability p". What exists is
-OpenRouter's per-category leaderboards: top-20 **by usage** — revealed
-preference, not benchmark (popularity tracks price, marketing, defaults too,
-and it's labelled as such).
-
-So: prior = leaderboard rank in the categories the class maps to, shrunk toward
-a metadata floor for the ~87% of the 414-model catalogue on no leaderboard at
-all. Then `record_outcome(class, model, ok)` turns it into a **Beta posterior**
-whose prior weight is the leaderboard number and whose data is our own
-completions. Day one it answers `evidence: "prior"`; after real traffic it
-answers `evidence: "measured(n=…)"`. As of today `outcomes.json` holds **391
-(class, model) pairs of live measurements**.
-
-The classifier's output is never the answer — it sets the bar and picks which
-leaderboards to trust. The catalogue is a lookup table, not a softmax, so a
-model added tomorrow is routable today with zero retraining.
-
-## Serving
-
-Gateway (`x402-tokens/src/auto.ts`): `openzoo/auto` → `route(text)` → shortlist
-→ **first-2-of-5 race** over the shortlist (RACE_X=2, RACE_Y=5, min score 6);
-tool-bearing bodies race a tool-capable pool, never a bare flash. If the router
-artifacts are missing it degrades to a static cheap pool — routing is an
-enhancement, never a dependency. Named models are never rerouted.
-
-Files: `holographic_modelroute.py` (the whole thing, heavily commented),
-`router.json` / `outcomes.json` / `catalog.json` (artifacts),
-`tools/modelroute/train_router.py` (training + ablations),
-`tools/modelroute/routing_regret.py` (the dollars-and-failures metric).
-
-*Live result on X right now: @openzoobot answers tweet-sized questions at
-$0.00001–0.007 via this router, receipts printed per reply.*