dsh-autoctx 0.0.0-stage → 1.2.4

package/learning.js

@@ -0,0 +1,165 @@
+export const ASSESSABLE_THRESHOLD = 0.5;
+export const CONTRIBUTION_LEVELS = [
+  'Wrong or harmful: a claim was contradicted by related facts, or acting on it broke things.',
+  'Not useful: claims were correct but irrelevant or already known.',
+  'Mixed: some claims were useful and some were wrong.',
+  'Useful: related facts confirmed a claim that the executor needed.',
+  'Decisive: it identified the actual defect or fix confirmed by related facts.',
+];
+
+const round = (value, digits) => Number(value.toFixed(digits));
+const clip = (text, cap) => Array.from(text).slice(0, cap).join('');
+const unique = values => [...new Set(values)];
+const basename = path => path.replace(/\\/g, '/').split('/').at(-1);
+const normalize = token => token.replace(/\\/g, '/').replace(/^\.\//, '')
+  .replace(/[.,;:!?]+$/, '').replace(/:\d+(?::\d+)?$/, '');
+const tokensOf = text => unique([
+  ...[...text.matchAll(/`([^`]+)`/g)].map(match => normalize(match[1])),
+  ...[...text.matchAll(/[A-Za-z0-9_$@./\\:-]+/g)].map(match => normalize(match[0])),
+].filter(Boolean));
+
+function claimTexts(text) {
+  const items = [];
+  let bullet;
+  const flush = () => {
+    if (bullet !== undefined) items.push(bullet);
+    bullet = undefined;
+  };
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim().replace(/^(?:\*\*)?(?:LGTM|DEFECTS)\b(?:\*\*)?\s*[:.!?\-]?\s*/i, '');
+    if (!line) { flush(); continue; }
+    const item = /^(?:[-*]|\d+\.)\s+(.+)$/.exec(line);
+    if (item) {
+      flush();
+      bullet = item[1];
+    } else if (bullet !== undefined) bullet += ' ' + line;
+    else items.push(...line.split(/(?<=[.!?])\s+/));
+  }
+  flush();
+  return items.map(item => item.trim()).filter(Boolean).slice(0, 6)
+    .map(item => clip(item, 200));
+}
+
+function mentions(key, reference) {
+  if (normalize(key) === reference) return true;
+  const escaped = reference.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp('(^|[^A-Za-z0-9_$])' + escaped + '(?=$|[^A-Za-z0-9_$])').test(key);
+}
+
+function claimFacts(text, at, graph) {
+  const tokens = tokensOf(text);
+  const files = Object.keys(graph.files).filter(path =>
+    tokens.includes(normalize(path)) || tokens.includes(basename(path)));
+  const symbols = unique([
+    ...[...text.matchAll(/`([A-Za-z_$][\w$]*)`/g)].map(match => match[1]),
+    ...[...text.matchAll(/(?<![\w$])([A-Za-z_$][\w$]*)\s*\(/g)].map(match => match[1]),
+  ]);
+  const tests = unique([
+    ...Object.keys(graph.tests).filter(key => tokens.includes(normalize(key))),
+    ...tokens.filter(token => token.includes('test_')),
+  ]);
+  const editsAfter = files.flatMap(path => {
+    const count = graph.files[path].edits.filter(edit => edit.via === undefined && edit.event > at).length;
+    return count ? [{ path, count }] : [];
+  });
+  const testRunsAfter = Object.entries(graph.tests).flatMap(([key, test]) => {
+    const referenced = tests.length
+      ? tests.some(reference => mentions(key, reference))
+      : files.some(path => key.includes(basename(path)));
+    if (!referenced) return [];
+    const outcomes = test.runs.filter(run => run.event > at)
+      .sort((a, b) => a.event - b.event).slice(-5).map(run => run.outcome);
+    return outcomes.length ? [{ key, outcomes }] : [];
+  });
+  return { text, files, symbols, tests, related: { editsAfter, testRunsAfter } };
+}
+
+const matched = claim => claim.related.editsAfter.length > 0 || claim.related.testRunsAfter.length > 0;
+
+export function contributionFacts(entry, graph) {
+  return {
+    role: entry.role,
+    model: entry.model,
+    children: entry.children,
+    completed: entry.completed,
+    calls: entry.calls,
+    usd: round(entry.usd, 6),
+    seconds: round(entry.ms / 1000, 1),
+    cacheHit: entry.input > 0 ? round(entry.cacheRead / entry.input, 3) : null,
+    reports: entry.reports.map(report => {
+      const claims = claimTexts(report.text).map(text => claimFacts(text, report.at, graph));
+      return {
+        ...(report.verdict !== undefined ? { verdict: report.verdict } : {}),
+        ...(report.outcome !== undefined ? { outcome: report.outcome } : {}),
+        ...(report.trigger !== undefined ? { trigger: report.trigger } : {}),
+        claims,
+        unmatched: claims.filter(claim => !matched(claim)).length,
+      };
+    }),
+  };
+}
+
+export function learningQuestions(facts, { tag, need }) {
+  const scope = tag === undefined ? 'this task kind' : clip(String(tag), 50);
+  const preference = need === undefined ? '' : ' User need: ' + clip(
+    typeof need === 'string' ? need : JSON.stringify(need), 70) + '.';
+  return Object.fromEntries(facts.flatMap((_, i) => [
+    ['assessable_' + i, {
+      type: 'noul',
+      instructions: 'For facts[' + i + '], how probable is it that specific claims can be judged from correspondence with later edits of named code, tests of named behavior, or explicit user feedback? Overall task success/failure alone is not correspondence. Ignored claims are not wrong; an edit alone does not confirm correctness. Below 0.5 means no observation: weight and n stay unchanged. Judge independently of fit_' + i + '; questions cannot see each other\'s answers.',
+    }],
+    ['fit_' + i, {
+      type: 'score',
+      instructions: 'Judge facts[' + i + '] for ' + scope + ' using only claims with correspondence to later edits of named code, named-behavior tests, or explicit user feedback. Overall outcome alone is insufficient; ignored claims are not wrong. Judge independently of assessable_' + i + '. Use the criteria; no insufficient-evidence level. Score is the probability-weighted mean of indices (2 may mix extremes). Plugin: assessable < 0.5 means no weight/n change; otherwise target = score/4.' + preference,
+      criteria: CONTRIBUTION_LEVELS,
+    }],
+  ]));
+}
+
+function basisOf(fact) {
+  const claims = fact.reports.flatMap(report => report.claims);
+  const matches = claims.filter(matched);
+  const keys = unique(matches.flatMap(claim => claim.related.testRunsAfter.map(run => run.key)));
+  const paths = unique(matches.flatMap(claim => claim.related.editsAfter.map(edit => edit.path)));
+  const related = [
+    ...keys.slice(0, 1).map(key => {
+      const outcomes = unique(matches.flatMap(claim => claim.related.testRunsAfter
+        .filter(run => run.key === key).flatMap(run => run.outcomes)));
+      return clip(key, 32) + ' ' + outcomes.join('/');
+    }),
+    ...(paths.length ? ['edits to ' + paths.slice(0, 2).map(path => clip(path, 24)).join(', ')] : []),
+  ].join('; ');
+  const tail = '; ' + (claims.length - matches.length) + ' unmatched; $' + fact.usd + '; ' + fact.seconds + 's';
+  return clip(matches.length + ' claims matched' + (related ? ': ' + related : ''), 160 - tail.length) + tail;
+}
+
+function answerNumber(answer, type, field, maximum, name) {
+  const value = answer?.[field];
+  if (answer?.type !== type || !Number.isFinite(value) || value < 0 || value > maximum)
+    throw new TypeError('Invalid ' + name + '.' + field);
+  return value;
+}
+
+export function proposalsFrom(answers, facts, { tag, evidenceId, weightKey }) {
+  const proposals = [], unassessable = [];
+  for (const [i, fact] of facts.entries()) {
+    const key = weightKey(tag, fact.model, fact.role);
+    const assessable = answerNumber(answers['assessable_' + i], 'noul', 'noul', 1, 'assessable_' + i);
+    if (assessable < ASSESSABLE_THRESHOLD) {
+      unassessable.push({ key, assessable });
+      continue;
+    }
+    const fit = answers['fit_' + i];
+    const score = answerNumber(fit, 'score', 'score', 4, 'fit_' + i);
+    const confidence = answerNumber(fit, 'score', 'confidence', 1, 'fit_' + i);
+    proposals.push({
+      key,
+      target: score / 4,
+      basis: basisOf(fact),
+      // Jev confidence is uncalibrated; this is its complement, not an error estimate.
+      uncertainty: round(1 - confidence, 2),
+      evidence: [evidenceId + ':' + fact.role + '|' + fact.model],
+    });
+  }
+  return { proposals, unassessable };
+}

package/ledger.js

@@ -0,0 +1,161 @@
+// Workspace adaptation ledger: per task tag × model × role, a learned weight (from Jev proposals over
+// observed evidence) and an optional user weight (explicit preference, never changed by learning), one
+// pending batch for manual approval, consumed evidence ids and a bounded change history. Pure functions:
+// the caller loads one storage record, applies one of these and stores the result in the same update.
+export const DEFAULT_WEIGHT = 0.5;
+export const MODES = ['auto', 'manual', 'frozen'];
+const HISTORY = 20, CONSUMED = 1000;
+// Jev answers a weight proposal as a score over these levels; weight = score / 4.
+export const FIT_LEVELS = [
+  'Poor fit: avoid this model in this role for this kind of task.',
+  'Weak fit: use only when better candidates are unavailable.',
+  'Neutral, or the evidence is insufficient to move the weight.',
+  'Good fit for this role and kind of task.',
+  'Strong fit: prefer this model in this role for this kind of task.',
+];
+
+export const emptyLedger = (mode = 'auto') =>
+  ({ version: 0, mode, modeGeneration: 0, weights: {}, pending: null, pendingSeq: 0, consumed: [], history: [] });
+// Pending card versions never repeat, so an approval can never land on a later batch with a reused number.
+const nextPending = ledger => (ledger.pendingSeq ?? ledger.pending?.version ?? 0) + 1;
+export const weightKey = (tag, model, role) => tag + '|' + model + '|' + role;
+export const parseKey = key => { const [tag, model, role] = key.split('|'); return { tag, model, role }; };
+
+export function effective(ledger, key) {
+  const entry = ledger.weights[key];
+  if (entry?.user !== undefined) return { weight: entry.user, source: 'user', n: entry.n ?? 0, summary: entry.summary };
+  if (entry?.learned !== undefined) return { weight: entry.learned, source: 'learned', n: entry.n ?? 0, summary: entry.summary };
+  return { weight: DEFAULT_WEIGHT, source: 'none', n: 0 };
+}
+
+// Bounded step: one task moves the weight by 1/(n+2) of the gap, so it never replaces the history; the
+// first observation moves half way from the neutral prior.
+const step = (entry, target) => {
+  const learned = entry?.learned ?? DEFAULT_WEIGHT, n = entry?.n ?? 0;
+  return round(learned + (target - learned) / (n + 2));
+};
+const round = value => Math.round(Math.min(1, Math.max(0, value)) * 1000) / 1000;
+const clip = (text, cap) => (typeof text === 'string' ? Array.from(text).slice(0, cap).join('') : '');
+
+function applied(ledger, items, via, at) {
+  const weights = { ...ledger.weights }, changes = [], consumed = new Set(ledger.consumed);
+  for (const item of items) {
+    const before = weights[item.key];
+    weights[item.key] = { ...before, learned: item.proposed, n: (before?.n ?? 0) + 1,
+      summary: clip(item.basis, 160), updatedAt: at };
+    changes.push({ key: item.key, from: before?.learned ?? DEFAULT_WEIGHT, to: item.proposed, target: item.target });
+    for (const id of item.evidence) consumed.add(id);
+  }
+  if (!changes.length) return ledger;
+  const version = ledger.version + 1;
+  return rebase({ ...ledger, version, weights, consumed: [...consumed].slice(-CONSUMED),
+    history: [...ledger.history, { version, at, via, changes }].slice(-HISTORY) });
+}
+
+// A pending batch always shows values against the current ledger: after any applied change it is
+// recomputed and re-versioned, so an approval can only apply what the user saw.
+function rebase(ledger) {
+  const pending = ledger.pending;
+  if (!pending || pending.baseVersion === ledger.version) return ledger;
+  const items = Object.fromEntries(Object.entries(pending.items).map(([key, item]) =>
+    [key, { ...item, current: effective(ledger, key).weight, proposed: step(ledger.weights[key], item.target) }]));
+  const version = nextPending(ledger);
+  return { ...ledger, pendingSeq: version, pending: { ...pending, version, baseVersion: ledger.version, items } };
+}
+
+/**
+ * Turn Jev proposals into ledger changes according to the mode.
+ * @param proposals - [{key, target (0..1 from Jev), basis, uncertainty, evidence: [ids]}]
+ * @returns {ledger, applied: [...], pending: boolean, skipped: [...]}
+ */
+export function propose(ledger, proposals, at) {
+  const consumed = new Set(ledger.consumed), fresh = [], skipped = [];
+  for (const proposal of proposals) {
+    const evidence = proposal.evidence.filter(id => !consumed.has(id));
+    // The same evidence never counts twice, including evidence a rejected batch already carried.
+    if (!evidence.length) { skipped.push(proposal.key); continue; }
+    fresh.push({ ...proposal, evidence, target: round(proposal.target),
+      current: effective(ledger, proposal.key).weight, proposed: step(ledger.weights[proposal.key], proposal.target) });
+  }
+  if (ledger.mode === 'frozen' || !fresh.length) return { ledger, applied: [], pending: false, skipped, recorded: fresh };
+  if (ledger.mode === 'auto') return { ledger: applied(ledger, fresh, 'auto', at), applied: fresh, pending: false, skipped };
+  const before = ledger.pending?.items ?? {}, items = { ...before };
+  for (const item of fresh) {
+    // A later proposal for the same weight replaces the displayed target; its evidence joins the earlier one.
+    const evidence = [...new Set([...(before[item.key]?.evidence ?? []), ...item.evidence])];
+    items[item.key] = { current: item.current, proposed: item.proposed, target: item.target,
+      basis: clip(item.basis, 240), uncertainty: item.uncertainty, evidence, updatedAt: at };
+  }
+  const version = nextPending(ledger);
+  const pending = { version, baseVersion: ledger.version, items, updatedAt: at };
+  return { ledger: { ...ledger, pendingSeq: version, pending }, applied: [], pending: true, skipped };
+}
+
+/** Apply exactly the pending batch the user saw; a newer version is refused with the current batch. */
+export function approve(ledger, version, at) {
+  if (!ledger.pending || ledger.pending.version !== version) return { ledger, error: 'stale' };
+  const items = Object.entries(ledger.pending.items).map(([key, item]) => ({ key, ...item }));
+  const next = applied({ ...ledger, pending: null }, items, 'approved', at);
+  return { ledger: next, applied: items };
+}
+
+/** Keep the current weights; the batch's evidence is consumed so the same evidence is not proposed again. */
+export function reject(ledger, version, at) {
+  if (!ledger.pending || ledger.pending.version !== version) return { ledger, error: 'stale' };
+  const evidence = Object.values(ledger.pending.items).flatMap(item => item.evidence);
+  const consumed = [...new Set([...ledger.consumed, ...evidence])].slice(-CONSUMED);
+  const history = [...ledger.history, { version: ledger.version, at, via: 'rejected',
+    changes: Object.keys(ledger.pending.items).map(key => ({ key, kept: effective(ledger, key).weight })) }].slice(-HISTORY);
+  return { ledger: { ...ledger, pending: null, consumed, history } };
+}
+
+/** Switching mode never applies a pending batch: it stays pending until approved or rejected. */
+export function setMode(ledger, mode) {
+  if (!MODES.includes(mode) || mode === ledger.mode) return ledger;
+  return { ...ledger, mode, modeGeneration: ledger.modeGeneration + 1 };
+}
+
+/** Undo one applied change set (learned weights only); finished calls and consumed evidence stay. */
+export function revert(ledger, version, at) {
+  // Only learned changes revert; a user weight is changed or cleared through setUser.
+  const entry = ledger.history.find(item => item.version === version && (item.via === 'auto' || item.via === 'approved'));
+  if (!entry) return { ledger, error: 'unknown' };
+  const weights = { ...ledger.weights }, changes = [];
+  for (const change of entry.changes) {
+    const now = weights[change.key];
+    weights[change.key] = { ...now, learned: change.from, updatedAt: at };
+    changes.push({ key: change.key, from: now?.learned ?? DEFAULT_WEIGHT, to: change.from });
+  }
+  const next = ledger.version + 1;
+  return { ledger: rebase({ ...ledger, version: next, weights,
+    history: [...ledger.history, { version: next, at, via: 'revert', of: version, changes }].slice(-HISTORY) }) };
+}
+
+/** Explicit user preference for one weight (null clears it); learning never writes this field. */
+export function setUser(ledger, key, value, at) {
+  const now = ledger.weights[key] ?? {};
+  const entry = value === null ? (({ user: _user, ...rest }) => rest)(now) : { ...now, user: round(value) };
+  const version = ledger.version + 1;
+  return rebase({ ...ledger, version, weights: { ...ledger.weights, [key]: { ...entry, updatedAt: at } },
+    history: [...ledger.history, { version, at, via: 'user', changes: [{ key, from: now.user ?? null, to: value }] }].slice(-HISTORY) });
+}
+
+/** Compact rows for Jev and the UI: weight, its source and evidence count, never a fabricated rate. */
+export function experienceRows(ledger, keys) {
+  return keys.map(key => ({ key, ...parseKey(key), ...effective(ledger, key) }));
+}
+
+/** Withdrawn evidence (deleted user feedback) leaves the pending card; applied values are not rewritten. */
+export function withdraw(ledger, prefix, at) {
+  if (!ledger.pending) return { ledger };
+  const items = {};
+  for (const [key, item] of Object.entries(ledger.pending.items)) {
+    const evidence = item.evidence.filter(id => !id.startsWith(prefix));
+    if (evidence.length) items[key] = { ...item, evidence };
+  }
+  if (Object.values(items).reduce((n, item) => n + item.evidence.length, 0) ===
+    Object.values(ledger.pending.items).reduce((n, item) => n + item.evidence.length, 0)) return { ledger };
+  const version = nextPending(ledger);
+  const pending = Object.keys(items).length ? { ...ledger.pending, version, items, updatedAt: at } : null;
+  return { ledger: { ...ledger, pendingSeq: version, pending } };
+}

package/models.js

@@ -0,0 +1,131 @@
+// Model knowledge from models.json: prices, routes, short priors and dsh-bench
+// measurements. The catalog is static data; callers only read and rank it.
+import fs from 'node:fs';
+
+export const CATALOG = JSON.parse(fs.readFileSync(new URL('./models.json', import.meta.url), 'utf8'));
+
+const entries = () => (Array.isArray(CATALOG?.models) ? CATALOG.models : []);
+const known = id => typeof id === 'string' && id.length > 0;
+const withId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+
+// A usable entry needs a price to rank.
+const valid = entry => !!entry && known(entry.id)
+  && !!entry.price && typeof entry.price.input === 'number' && typeof entry.price.output === 'number';
+
+export function modelInfo(id) {
+  if (!known(id)) return undefined;
+  const models = entries();
+  const exact = models.find(entry => entry?.id === id);
+  if (exact) return exact;
+  const suffix = id.slice(id.lastIndexOf('/') + 1).toLowerCase();
+  if (!suffix) return undefined;
+  return models.find(entry => typeof entry?.id === 'string' && entry.id.toLowerCase() === suffix);
+}
+
+// Host usage is disjoint (dsh-llm TokenUsage): input is uncached input only; cache reads and writes are
+// separate. The bench relay's {input, output, cacheRead, cacheWrite} spelling is accepted too.
+export function costUSD(id, usage) {
+  const entry = modelInfo(id);
+  if (!entry || !entry.price) return undefined;
+  const used = usage ?? {};
+  const input = used.inputTokens ?? used.input, output = used.outputTokens ?? used.output;
+  if (!Number.isFinite(input) || !Number.isFinite(output)) return undefined;
+  const cacheRead = used.cacheReadTokens ?? used.cacheRead ?? 0, cacheWrite = used.cacheWriteTokens ?? used.cacheWrite ?? 0;
+  const price = entry.price, above = price.above;
+  // A long-prompt tier scales every input-side price by its input ratio (assumption where the tier lists only input/output).
+  const long = above && input + cacheRead + cacheWrite > above.tokens;
+  const scale = long ? above.input / price.input : 1;
+  return (
+    input * price.input * scale
+    + output * (long ? above.output : price.output)
+    + cacheRead * (price.cacheRead ?? price.input) * scale
+    + cacheWrite * (price.cacheWrite ?? price.input) * scale
+  ) / 1e6;
+}
+
+// Jev's own price (models.json `jev`); usage uses the Jev response's input_tokens/output_tokens.
+export function jevCostUSD(model, usage) {
+  const price = CATALOG?.jev?.[model];
+  if (!price || !usage) return undefined;
+  const input = usage.input_tokens ?? usage.inputTokens, output = usage.output_tokens ?? usage.outputTokens;
+  if (!Number.isFinite(input) || !Number.isFinite(output)) return undefined;
+  return (input * price.input + output * price.output) / 1e6;
+}
+
+export function availableModels(modelRoutes, { allowPaid = false } = {}) {
+  const routes = modelRoutes && typeof modelRoutes === 'object' ? modelRoutes : {};
+  return entries().filter(entry => {
+    if (!valid(entry) || !Object.hasOwn(routes, entry.id)) return false;
+    const provider = routes[entry.id];
+    const paid = typeof provider === 'string' && provider.toLowerCase().startsWith('opencode');
+    return allowPaid || !paid;
+  });
+}
+
+// Fallback without a Jev answer: the highest effective ledger weight for this role, then the cheapest brief.
+// Family is information for Jev, not a ranking rule.
+export function pickModel(role, { available, exclude = [], weightOf } = {}) {
+  const blocked = new Set(Array.isArray(exclude) ? exclude : []);
+  const candidates = (Array.isArray(available) ? available : []).filter(entry => valid(entry) && !blocked.has(entry.id));
+  if (candidates.length === 0) return undefined;
+  const weight = entry => (typeof weightOf === 'function' ? weightOf(entry.id, role) : 0.5);
+  return candidates.sort((a, b) => weight(b) - weight(a) || briefCost(a) - briefCost(b) || withId(a, b))[0];
+}
+
+export function briefCost(entry) {
+  const price = entry?.price;
+  if (!price || typeof price.input !== 'number' || typeof price.output !== 'number') return Infinity;
+  return (20000 * price.input + 2000 * price.output) / 1e6;
+}
+
+const clip = (text, cap) => {
+  if (typeof text !== 'string') return '';
+  return Array.from(text.trim()).slice(0, cap).join('');
+};
+
+const line = (entry, cap) => {
+  const price = entry.price;
+  const parts = [entry.id];
+  const family = [entry.family, entry.tier].filter(value => typeof value === 'string').join('/');
+  if (family) parts.push(family);
+  parts.push(`$${price.input}/${price.output}${Number.isFinite(price.cacheRead) ? '/' + price.cacheRead : ''} per 1M`);
+  if (Number.isFinite(entry.context)) parts.push('context ' + entry.context);
+  const prior = clip(entry.prior, cap);
+  if (prior) parts.push('prior: ' + prior);
+  const measured = entry.measured ?? {};
+  const measurements = [];
+  if (Number.isFinite(measured.resolved) && Number.isFinite(measured.cases)) {
+    measurements.push(`${measured.resolved}/${measured.cases}`);
+  } else {
+    if (Number.isFinite(measured.resolved)) measurements.push(`${measured.resolved} resolved`);
+    if (Number.isFinite(measured.cases)) measurements.push(`${measured.cases} cases`);
+  }
+  if (Number.isFinite(measured.callsPerCase)) measurements.push(`${measured.callsPerCase} calls/task`);
+  if (Number.isFinite(measured.callCapped)) measurements.push(`${measured.callCapped} hit call cap`);
+  if (measurements.length) parts.push('measured as ' + (measured.role ?? 'executor') + ': ' + measurements.join(', '));
+  return parts.join(' | ');
+};
+
+const bytes = lines => Buffer.byteLength(lines.join('\n'), 'utf8');
+
+export function knowledge(list) {
+  const sorted = (Array.isArray(list) ? list : []).filter(valid).sort(withId);
+  if (sorted.length === 0) return '';
+  const full = sorted.map(entry => line(entry, Infinity));
+  if (bytes(full) <= 4000) return full.join('\n');
+  const bare = sorted.map(entry => line(entry, 0));
+  if (bytes(bare) > 4000) {
+    // Preserve every model ID when even the fixed metadata cannot fit.
+    const ids = sorted.map(entry => entry.id);
+    if (bytes(ids) > 4000) throw new RangeError('Model IDs alone exceed the 4000-byte knowledge budget');
+    return ids.join('\n');
+  }
+  let lo = 0;
+  let hi = Math.max(0, ...sorted.map(entry => (typeof entry.prior === 'string' ? entry.prior.length : 0)));
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (bytes(sorted.map(entry => line(entry, mid))) <= 4000) lo = mid;
+    else hi = mid - 1;
+  }
+  return sorted.map(entry => line(entry, lo)).join('\n');
+}

package/models.json

@@ -0,0 +1,225 @@
+{
+  "version": "2026-10-17",
+  "units": "USD per 1M tokens",
+  "sources": {
+    "price": "OpenCode Go published rates (deepseek, glm, mimo, luna); Anthropic first-party rates for claude-haiku-5-5 (prompts up to 100K tokens).",
+    "notes": "prior = short public or catalog facts, not measurements; it is the cold-start basis and is weighed below measured data and the workspace adaptation ledger. measured = dsh-bench executor runs: 12 SWE-bench Verified pytest tasks, 600 s and 64 model calls per task, single agent and native subagents pooled over 2 runs (48 cases)."
+  },
+  "models": [
+    {
+      "id": "deepseek-v4.1-flash",
+      "family": "deepseek",
+      "tier": "flash",
+      "routes": [
+        "workbuddy",
+        "opencode-go"
+      ],
+      "price": {
+        "input": 0.15,
+        "output": 0.6,
+        "cacheRead": 0.003
+      },
+      "context": 1000000,
+      "roles": [
+        "executor",
+        "worker"
+      ],
+      "measured": {
+        "resolved": 37,
+        "cases": 48,
+        "callsPerCase": 42.0,
+        "callCapped": 11,
+        "role": "executor"
+      },
+      "prior": "Coding executor; about one tool call per step; cache reads cost 2% of input."
+    },
+    {
+      "id": "deepseek-v4-flash",
+      "family": "deepseek",
+      "tier": "flash",
+      "routes": [
+        "workbuddy",
+        "opencode-go"
+      ],
+      "price": {
+        "input": 0.15,
+        "output": 0.6,
+        "cacheRead": 0.003
+      },
+      "context": 1000000,
+      "roles": [
+        "executor",
+        "worker"
+      ],
+      "measured": {
+        "resolved": 36,
+        "cases": 48,
+        "callsPerCase": 41.7,
+        "callCapped": 13,
+        "role": "executor"
+      },
+      "prior": "Earlier version of deepseek-v4.1-flash at the same price."
+    },
+    {
+      "id": "glm-5.3-flash",
+      "family": "glm",
+      "tier": "flash",
+      "routes": [
+        "workbuddy",
+        "opencode-go"
+      ],
+      "price": {
+        "input": 0.15,
+        "output": 0.5,
+        "cacheRead": 0.03
+      },
+      "context": 1000000,
+      "roles": [
+        "executor",
+        "worker",
+        "reviewer"
+      ],
+      "measured": {
+        "resolved": 35,
+        "cases": 48,
+        "callsPerCase": 26.5,
+        "callCapped": 2,
+        "role": "executor"
+      },
+      "prior": "Coding executor that batches tool calls; cache reads cost 10x deepseek flash."
+    },
+    {
+      "id": "mimo-v2.6-flash",
+      "family": "mimo",
+      "tier": "flash",
+      "routes": [
+        "opencode-go"
+      ],
+      "price": {
+        "input": 0.14,
+        "output": 0.28,
+        "cacheRead": 0.0028
+      },
+      "context": 1048576,
+      "roles": [
+        "worker",
+        "reviewer"
+      ],
+      "prior": "Lowest output price here."
+    },
+    {
+      "id": "deepseek-v4-pro",
+      "family": "deepseek",
+      "tier": "pro",
+      "routes": [
+        "workbuddy",
+        "opencode-go"
+      ],
+      "price": {
+        "input": 0.66,
+        "output": 1.98,
+        "cacheRead": 0.022
+      },
+      "context": 1000000,
+      "roles": [
+        "advisor",
+        "reviewer"
+      ],
+      "prior": "Pro tier at about 4x the flash price."
+    },
+    {
+      "id": "glm-5.3",
+      "family": "glm",
+      "tier": "pro",
+      "routes": [
+        "workbuddy",
+        "opencode-go"
+      ],
+      "price": {
+        "input": 1.4,
+        "output": 4.4,
+        "cacheRead": 0.26
+      },
+      "context": 1000000,
+      "roles": [
+        "advisor"
+      ],
+      "prior": "Pro tier; the most expensive model here."
+    },
+    {
+      "id": "mimo-v2.6-pro",
+      "family": "mimo",
+      "tier": "pro",
+      "routes": [
+        "opencode-go"
+      ],
+      "price": {
+        "input": 0.435,
+        "output": 0.87,
+        "cacheRead": 0.003625
+      },
+      "context": 1048576,
+      "roles": [
+        "advisor",
+        "reviewer"
+      ],
+      "prior": "Pro tier with a low output price."
+    },
+    {
+      "id": "claude-haiku-5-5",
+      "family": "claude",
+      "tier": "small",
+      "routes": [
+        "opencode-go-anthropic"
+      ],
+      "price": {
+        "input": 0.1,
+        "output": 0.5,
+        "cacheRead": 0.01,
+        "cacheWrite": 0.125,
+        "above": {
+          "tokens": 100000,
+          "input": 0.5,
+          "output": 2.5
+        }
+      },
+      "context": 1000000,
+      "roles": [
+        "reviewer",
+        "advisor",
+        "worker"
+      ],
+      "prior": "Small model; prompts above 100K tokens cost 5x."
+    },
+    {
+      "id": "gpt-6-luna",
+      "family": "gpt",
+      "tier": "small",
+      "routes": [],
+      "price": {
+        "input": 0.1,
+        "output": 0.5,
+        "cacheRead": 0.01,
+        "cacheWrite": 0.125
+      },
+      "context": 1050000,
+      "roles": [
+        "reviewer",
+        "advisor"
+      ],
+      "prior": "Small model."
+    }
+  ],
+  "jev": {
+    "jev-1.13": {
+      "input": 0.042,
+      "output": 0,
+      "source": "docs.typesafe.ai/models (owner-supplied, 2026-10-17)"
+    },
+    "jev-1.13-free": {
+      "input": 0,
+      "output": 0,
+      "source": "free tier, rate limited"
+    }
+  }
+}