ruvnet-brain 4.5.4 → 4.5.5

package/scripts/model-currency.mjs

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+// DISTINCT-FROM: scripts/model-router-catalog.mjs — per-user evidence currency, never candidate/default mutation.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { buildWeeklyAssessment } from './model-weekly-assessment.mjs';
+import { fileURLToPath } from 'node:url';
+import { WEEK_MS, digest, parseInventory, parseArtificialAnalysis, parseCodingAgentEvidence, currencyStatus } from './model-currency-evidence.mjs';
+
+export const DEFAULT_ROUTER_DIR = path.join(os.homedir(), '.claude', 'model-router');
+export const AA_URLS = [
+  'https://artificialanalysis.ai/models/comparisons',
+  'https://artificialanalysis.ai/models/comparisons/claude-fable-5-1-medium-vs-claude-opus-5-medium',
+  'https://artificialanalysis.ai/models/releases/comparisons/gpt-6-1-sol-vs-claude-sonnet-5-5',
+  'https://artificialanalysis.ai/models/releases/comparisons/gpt-6-luna-vs-gpt-6-astra',
+  'https://artificialanalysis.ai/models/releases/comparisons/claude-opus-5-5-vs-gpt-6-astra',
+];
+export const OFFICIAL_SOURCES = [
+  { provider: 'openai', url: 'https://developers.openai.com/api/docs/models' },
+  { provider: 'anthropic', url: 'https://platform.claude.com/docs/en/models/overview' },
+];
+export const AGENT_SOURCE_URLS = [
+  'https://artificialanalysis.ai/agents/coding-agents',
+  'https://artificialanalysis.ai/methodology/coding-agents-benchmarking',
+];
+export const CODING_BENCHMARK_SOURCES = [
+  { suite: 'vulcanbench', url: 'https://vulcanbench.com/' },
+  { suite: 'vulcanbench-swe-v4', url: 'https://vulcanbench.com/benchmarks/swe-v4-gpt61-sol-v318.html' },
+  { suite: 'terminal-bench', url: 'https://www.tbench.ai/' },
+  { suite: 'swe-bench', url: 'https://www.swebench.com/' },
+];
+const INVENTORY_URL = 'https://openrouter.ai/api/v1/models';
+const LOCK_MS = 10 * 60 * 1000;
+const RETRY_MS = 60 * 60 * 1000;
+const SELF = fileURLToPath(import.meta.url);
+function readRecord(routerDir) {
+  try {
+    const target = path.join(routerDir, 'currency.json');
+    if (fs.statSync(target).size > 8 * 1024 * 1024) return null;
+    return JSON.parse(fs.readFileSync(target, 'utf8'));
+  } catch { return null; }
+}
+export function readCurrencyStatus({ routerDir = DEFAULT_ROUTER_DIR, now = Date.now() } = {}) {
+  return currencyStatus(readRecord(routerDir), now);
+}
+function atomicWrite(target, bytes, beforeCommit = () => {}) {
+  fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+  const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    const fd = fs.openSync(tmp, 'wx', 0o600);
+    try { fs.writeFileSync(fd, bytes); fs.fsyncSync(fd); } finally { fs.closeSync(fd); }
+    beforeCommit();
+    fs.renameSync(tmp, target);
+  } finally { try { fs.unlinkSync(tmp); } catch { /* renamed */ } }
+}
+// This guard is held only for synchronous filesystem transactions, never during fetches.
+// Never reap it: a crash inside this tiny transaction must fail closed rather than overlap writers.
+function transaction(routerDir, operation) {
+  fs.mkdirSync(routerDir, { recursive: true, mode: 0o700 });
+  const guard = path.join(routerDir, 'currency-mutation.lock');
+  try { fs.mkdirSync(guard, { mode: 0o700 }); } catch (error) { if (error.code === 'EEXIST') return null; throw error; }
+  try { return operation(); } finally { fs.rmdirSync(guard); }
+}
+function ownerPath(routerDir) { return path.join(routerDir, 'currency-refresh-owner.json'); }
+function readOwner(routerDir) {
+  try { return JSON.parse(fs.readFileSync(ownerPath(routerDir), 'utf8')); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+}
+function claim(routerDir, now) {
+  return transaction(routerDir, () => {
+    const owner = readOwner(routerDir);
+    if (owner && (!Number.isFinite(owner.claimedAt) || now - owner.claimedAt <= LOCK_MS)) return null;
+    const next = { token: randomUUID(), claimedAt: now };
+    atomicWrite(ownerPath(routerDir), JSON.stringify(next));
+    return next.token;
+  });
+}
+function release(routerDir, token) {
+  return transaction(routerDir, () => {
+    if (readOwner(routerDir)?.token !== token) return false;
+    fs.unlinkSync(ownerPath(routerDir)); return true;
+  });
+}
+function fencedWrite(routerDir, token, target, bytes) {
+  const written = transaction(routerDir, () => {
+    if (readOwner(routerDir)?.token !== token) throw new Error('refresh superseded: ownership token changed');
+    atomicWrite(target, bytes, () => {
+      if (readOwner(routerDir)?.token !== token) throw new Error('refresh superseded before commit');
+    }); return true;
+  });
+  if (!written) throw new Error('refresh transaction busy; no write committed');
+}
+
+/** Prompt path: local bounded read and one detached worker; never await a network request. */
+export function maybeLaunchCurrencyRefresh({ routerDir = DEFAULT_ROUTER_DIR, now = Date.now(), launch = spawn } = {}) {
+  const record = readRecord(routerDir); const status = currencyStatus(record, now);
+  if (status.status === 'current') return { ...status, launched: false };
+  const attempted = Date.parse(record?.lastAttempt?.checkedAt);
+  if (Number.isFinite(attempted) && attempted <= now && now - attempted < RETRY_MS) return { ...status, launched: false, deferred: 'retry cooldown' };
+  const lock = claim(routerDir, now);
+  if (!lock) return { ...status, launched: false, deferred: fs.existsSync(path.join(routerDir, 'currency-mutation.lock'))
+    ? 'refresh transaction blocked; inspect mutation guard before recovery' : 'refresh already running' };
+  try {
+    const child = launch(process.execPath, [SELF, '--refresh', '--claim-token', lock, '--router-dir', routerDir], { detached: true, stdio: 'ignore' });
+    child.once?.('error', () => release(routerDir, lock));
+    child.unref();
+    return { ...status, launched: true };
+  } catch (error) { release(routerDir, lock); return { ...status, launched: false, errors: [error.message] }; }
+}
+
+export async function refreshModelCurrency({ routerDir = DEFAULT_ROUTER_DIR, now = Date.now(), fetchImpl = fetch,
+  identityBindings, aaUrls = AA_URLS, officialSources = OFFICIAL_SOURCES, agentSourceUrls = AGENT_SOURCE_URLS, codingBenchmarkSources = CODING_BENCHMARK_SOURCES, claimToken = null } = {}) {
+  const lock = claimToken ?? claim(routerDir, now);
+  if (!lock) return { action: 'busy', status: 'stale', reason: 'refresh ownership or transaction guard unavailable' };
+  try {
+    const prior = readRecord(routerDir) ?? { schemaVersion: 1 };
+    const checkedAt = new Date(now).toISOString(); const errors = [];
+    let bindings = identityBindings;
+    if (!bindings) {
+      try { bindings = JSON.parse(fs.readFileSync(path.join(routerDir, 'identity-bindings.json'), 'utf8')); }
+      catch { bindings = {}; }
+    }
+    const collect = async (url) => {
+      const response = await fetchImpl(url, { signal: AbortSignal.timeout(20_000) });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const bytes = await response.text();
+      if (bytes.length > 6 * 1024 * 1024) throw new Error('source exceeds 6 MiB limit');
+      const source = { url, checkedAt, sha256: digest(bytes) };
+      fencedWrite(routerDir, lock, path.join(routerDir, 'evidence', `${source.sha256}.${url === INVENTORY_URL ? 'json' : 'html'}`), bytes);
+      return { source, bytes };
+    };
+    const results = await Promise.allSettled([INVENTORY_URL, ...aaUrls, ...officialSources.map((s) => s.url), ...agentSourceUrls, ...codingBenchmarkSources.map((s) => s.url)].map(collect));
+    let inventory = prior.inventory; let evaluations = prior.evaluations;
+    if (results[0].status === 'fulfilled') {
+      try { inventory = parseInventory(results[0].value.bytes, results[0].value.source); }
+      catch (error) { errors.push(`inventory: ${error.message}`); }
+    } else errors.push(`inventory: ${results[0].reason.message}`);
+    const parsed = [];
+    for (let i = 1; i <= aaUrls.length; i++) {
+      const result = results[i];
+      try {
+        if (result.status !== 'fulfilled') throw result.reason;
+        parsed.push(parseArtificialAnalysis(result.value.bytes, { ...result.value.source, identityBindings: bindings }));
+      } catch (error) { errors.push(`evaluations ${aaUrls[i - 1]}: ${error.message}`); }
+    }
+    // All requested pages must parse before certifying a new matrix; partial pages are evidence only.
+    if (parsed.length === aaUrls.length && parsed.length > 0) {
+      const records = new Map();
+      for (const page of parsed) for (const record of page.records) records.set(record.sourceModelId, record);
+      evaluations = { checkedAt, sources: parsed.map((p) => p.source), records: [...records.values()],
+        selectionQualified: false, limitation: 'Independent benchmark evidence; native access and supported effort require separate verification. Arena is not collected.' };
+    }
+    let official = prior.officialSources;
+    const publicDocs = [];
+    for (let i = 0; i < officialSources.length; i++) {
+      const result = results[1 + aaUrls.length + i];
+      if (result.status === 'fulfilled') publicDocs.push({ ...result.value.source, provider: officialSources[i].provider,
+        scope: 'official public/API documentation; not native subscription access', semanticallyQualified: false });
+      else errors.push(`official ${officialSources[i].url}: ${result.reason.message}`);
+    }
+    if (publicDocs.length === officialSources.length) official = { checkedAt, sources: publicDocs };
+    let agents = prior.agentSources;
+    if (agentSourceUrls.length) {
+      const agentResults = results.slice(1 + aaUrls.length + officialSources.length, 1 + aaUrls.length + officialSources.length + agentSourceUrls.length);
+      try {
+        if (agentResults.length !== 2) throw new Error('coding-agent source and methodology pair required');
+        for (const result of agentResults) if (result.status !== 'fulfilled') throw result.reason;
+        const parsedAgents = parseCodingAgentEvidence(agentResults[0].value.bytes, agentResults[1].value.bytes,
+          { ...agentResults[0].value.source, identityBindings: bindings });
+        agents = { checkedAt, sources: agentResults.map((r) => r.value.source), ...parsedAgents };
+      } catch (error) { errors.push(`coding agents: ${error.message}`); }
+    }
+    const additional = [];
+    for (let i = 0; i < codingBenchmarkSources.length; i++) {
+      const result = results[1 + aaUrls.length + officialSources.length + agentSourceUrls.length + i];
+      if (result.status === 'fulfilled' && result.value.bytes.trim().length >= 100) {
+        additional.push({ ...result.value.source, suite: codingBenchmarkSources[i].suite,
+          scope: 'raw source archive; independent suite, score parsing and semantic qualification not implemented' });
+      } else errors.push(`coding benchmark ${codingBenchmarkSources[i].url}: ${result.status === 'rejected' ? result.reason.message : 'empty or truncated source'}`);
+    }
+    if (additional.length === codingBenchmarkSources.length && agents && agents !== prior.agentSources) agents = { ...agents, additionalSources: additional };
+    else if (additional.length !== codingBenchmarkSources.length) agents = prior.agentSources;
+    const instructionPath = path.join(routerDir, 'weekly-analyst-instruction.md');
+    let instruction; let instructionSource = 'packaged-fallback';
+    try {
+      const fd = fs.openSync(instructionPath, 'r');
+      try {
+        const buffer = Buffer.alloc(128 * 1024 + 1);
+        const size = fs.readSync(fd, buffer, 0, buffer.length, 0);
+        if (size > 128 * 1024) throw new Error('effective weekly instruction exceeds 128 KiB');
+        instruction = buffer.subarray(0, size).toString('utf8');
+        if (!instruction.trim()) throw new Error('effective weekly instruction is empty');
+        instructionSource = 'effective-per-user-file';
+      } finally { fs.closeSync(fd); }
+    } catch (error) {
+      if (error.code !== 'ENOENT') { errors.push(`instruction: ${error.message}`); instruction = undefined; instructionSource = 'fallback-after-read-error'; }
+    }
+    const next = { schemaVersion: 1, maxAgeMs: WEEK_MS, inventory, evaluations, officialSources: official, agentSources: agents,
+      lastAttempt: { checkedAt, status: errors.length ? (inventory === prior.inventory && evaluations === prior.evaluations ? 'failed' : 'partial') : 'complete', errors } };
+    let priorPolicyBytes = null; let policy = null;
+    try { priorPolicyBytes = fs.readFileSync(path.join(routerDir, 'routing-policy.json'), 'utf8'); policy = JSON.parse(priorPolicyBytes); }
+    catch { /* no policy: report missing allocation, never synthesize one */ }
+    const assessment = buildWeeklyAssessment({ currency: next, policy, priorPolicyBytes, now, previousAssessment: prior.assessment, instruction, instructionSource });
+    const assessmentDir = path.join(routerDir, 'assessments', `${checkedAt.replaceAll(':', '-')}-${lock}`);
+    for (const [name, bytes] of [['report.json', JSON.stringify(assessment.report, null, 2)],
+      ['proposal.json', JSON.stringify(assessment.proposal, null, 2)], ['report.md', assessment.markdown],
+      ['instruction.md', assessment.instruction], ['prior-policy.json', priorPolicyBytes ?? 'null']]) {
+      fencedWrite(routerDir, lock, path.join(assessmentDir, name), bytes);
+    }
+    if (!fs.existsSync(instructionPath)) fencedWrite(routerDir, lock, instructionPath, assessment.instruction);
+    next.assessment = { instructionPath, instructionSha256: assessment.report.instructionSha256, instructionSource, checkedAt, signature: assessment.report.signature, reportPath: path.join(assessmentDir, 'report.json'),
+      proposalPath: path.join(assessmentDir, 'proposal.json'), status: 'complete-unqualified', analystExecuted: false,
+      notification: assessment.report.notification };
+    fencedWrite(routerDir, lock, path.join(routerDir, 'currency.json'), `${JSON.stringify(next, null, 2)}\n`);
+    return { action: 'refreshed', ...currencyStatus(next, now), lastAttempt: next.lastAttempt };
+  } finally { release(routerDir, lock); }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === SELF) {
+  const dirIndex = process.argv.indexOf('--router-dir');
+  const routerDir = dirIndex >= 0 ? process.argv[dirIndex + 1] : DEFAULT_ROUTER_DIR;
+  if (!routerDir || !path.isAbsolute(routerDir)) throw new Error('--router-dir must be absolute');
+  if (process.argv.includes('--refresh')) {
+    refreshModelCurrency({ routerDir, claimToken: process.argv.includes('--claim-token') ? process.argv[process.argv.indexOf('--claim-token') + 1] : null }).then((result) => {
+      console.log(JSON.stringify(result)); if (result.status === 'stale') process.exitCode = 1;
+    }).catch((error) => { console.error(error.message); process.exitCode = 1; });
+  } else console.log(JSON.stringify(process.argv.includes('--catch-up') ? maybeLaunchCurrencyRefresh({ routerDir }) : readCurrencyStatus({ routerDir })));
+}

package/scripts/model-native-catalog.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// DISTINCT-FROM: model-router-catalog.mjs — fresh native subscription metadata, never model execution or policy promotion.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+const HOSTS = { codex: 'openai', 'claude-code': 'anthropic' };
+const EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+const read = (file, optional = false) => {
+  try { const bytes = fs.readFileSync(file); if (bytes.length > 1048576) throw new Error('Native catalog input exceeds limit'); return bytes; }
+  catch (error) { if (optional && error.code === 'ENOENT') return null; throw error; }
+};
+function stage(file, bytes) {
+  const temporary = `${file}.${randomUUID()}.tmp`; const fd = fs.openSync(temporary, 'wx', 0o600);
+  try { fs.writeFileSync(fd, bytes); fs.fsyncSync(fd); } catch (error) { fs.closeSync(fd); fs.unlinkSync(temporary); throw error; }
+  fs.closeSync(fd);
+  return temporary;
+}
+const equal = (a, b) => a === null ? b === null : b !== null && a.equals(b);
+export async function refreshNativeCatalog({ routerDir = path.join(os.homedir(), '.claude', 'model-router'),
+  deadline = Date.now() + 60000, inspect, now = Date.now() } = {}) {
+  const checkedAt = new Date(now).toISOString();
+  const failed = reason => ({ status: 'failed', checkedAt, newNativeModelIds: [], policyApplied: false, reason });
+  const paths = { profile: path.join(routerDir, 'profile.json'), catalog: path.join(routerDir, 'catalog.json'),
+    availability: path.join(routerDir, 'native-availability.json') };
+  let guard; let acquired = false; const temporary = [];
+  try {
+    if (!path.isAbsolute(routerDir) || !Number.isFinite(deadline) || deadline <= Date.now()) return failed('Invalid native metadata directory or deadline');
+    const before = Object.fromEntries(Object.entries(paths).map(([key, file]) => [key, read(file, key === 'availability')]));
+    const profile = JSON.parse(before.profile); const catalog = JSON.parse(before.catalog);
+    if (profile.automaticModelRoutingUpdates !== true) return failed('Automatic native model registration is not authorized by this profile');
+    if (!Array.isArray(catalog.candidates) || catalog.candidates.some(c => typeof c.id !== 'string')
+      || new Set(catalog.candidates.map(c => c.id)).size !== catalog.candidates.length) return failed('Existing model catalog is malformed');
+    const hosts = Object.keys(HOSTS).filter(host => profile.harnesses?.[host]?.available === true
+      && profile.harnesses[host].subscription === true && profile.harnesses[host].enabled !== false);
+    if (!hosts.length) return failed('No enabled native subscription host in this profile');
+    inspect ??= (await import('./model-native-qualification.mjs')).inspectNativeQualificationHost;
+    const observations = []; const eligibleIds = []; const nativeIds = []; const unknownEffortIds = []; const withheldIds = [];
+    const candidates = [...catalog.candidates];
+    for (const host of hosts) {
+      if (Date.now() >= deadline) return failed('Native metadata deadline expired');
+      const result = await inspect({ host, deadline });
+      if (result?.failure || result?.available !== true || result.nativeSubscription !== true || result.sourceReceipt?.host !== host
+        || result.sourceReceipt.allowance?.verified !== true || result.catalogStatus !== 'verified'
+        || !Array.isArray(result.models) || !result.models.length) return failed(`Verified native model list unavailable for ${host}`);
+      const models = [];
+      for (const model of result.models) {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]+$/.test(model.id ?? '')) return failed(`Exact native model identity unavailable for ${host}`);
+        const id = `${HOSTS[host]}/${model.id}`; nativeIds.push(id);
+        const nativeEfforts = Array.isArray(model.efforts) ? model.efforts.filter(e => typeof e === 'string' && /^[a-z][a-z0-9_-]{0,31}$/.test(e)) : [];
+        const efforts = [...new Set(nativeEfforts.filter(e => EFFORTS.has(e)))].sort();
+        const unrecognizedEfforts = [...new Set(nativeEfforts.filter(e => !EFFORTS.has(e)))].sort();
+        const knownEfforts = efforts.length > 0;
+        models.push({ id: model.id, efforts, effortSupport: knownEfforts ? 'verified' : 'unknown',
+          ...(unrecognizedEfforts.length ? { unrecognizedEfforts } : {}) });
+        if (!knownEfforts) { unknownEffortIds.push(id); continue; }
+        const existing = candidates.find(c => c.id === model.id);
+        if (existing) {
+          if (existing.provider !== HOSTS[host] || existing.disabled === true || existing.enabled === false
+            || !existing.harness?.includes(host) || !existing.subscription?.includes(host)) { withheldIds.push(id); continue; }
+        } else candidates.push({ id: model.id, provider: HOSTS[host], harness: [host], subscription: [host],
+          supportedEfforts: efforts, costPerMTok: null, verified: `${checkedAt} native subscription metadata; execution not tested`,
+          note: 'Native catalog availability is not role-quality qualification or active routing approval.' });
+        eligibleIds.push(id);
+      }
+      if (new Set(models.map(m => m.id)).size !== models.length) return failed(`Duplicate native model identity for ${host}`);
+      observations.push({ host, provider: HOSTS[host], checkedAt: result.checkedAt, harnessVersion: result.harnessVersion, allowanceVerified: true, models: models.sort((a, b) => a.id.localeCompare(b.id)) });
+    }
+    if (Date.now() >= deadline) return failed('Native metadata deadline expired');
+    const previous = before.availability ? JSON.parse(before.availability) : null;
+    if (previous && (previous.schemaVersion !== 1 || !Array.isArray(previous.nativeModelIds)
+      || previous.nativeModelIds.some(id => typeof id !== 'string'))) return failed('Previous native availability baseline is malformed');
+    const ids = [...new Set(eligibleIds)].sort(); const nativeModelIds = [...new Set(nativeIds)].sort();
+    const newNativeModelIds = previous ? nativeModelIds.filter(id => !previous.nativeModelIds.includes(id)) : [];
+    const snapshot = { schemaVersion: 1, status: 'current', checkedAt, hosts: observations,
+      nativeModelIds, eligibleModelIds: ids, unknownEffortModelIds: unknownEffortIds.sort(), withheldExistingModelIds: [...new Set(withheldIds)].sort(), inferenceRequests: 0, policyApplied: false };
+    const changedCatalog = candidates.length !== catalog.candidates.length;
+    const catalogBytes = changedCatalog ? Buffer.from(JSON.stringify({ ...catalog, candidates }, null, 2) + '\n') : before.catalog;
+    const snapshotBytes = Buffer.from(JSON.stringify(snapshot, null, 2) + '\n');
+    guard = path.join(routerDir, 'native-catalog-mutation.lock'); fs.mkdirSync(guard, { mode: 0o700 }); acquired = true;
+    for (const [key, file] of Object.entries(paths)) if (!equal(before[key], read(file, key === 'availability'))) throw new Error('Native catalog inputs changed');
+    const history = path.join(routerDir, 'native-catalog-history', `${now}-${randomUUID()}`); fs.mkdirSync(history, { recursive: true, mode: 0o700 });
+    for (const [name, bytes] of [['catalog.json', before.catalog], ['native-availability.json', before.availability]]) {
+      if (!bytes) continue; const target = path.join(history, name); const temp = stage(target, bytes); temporary.push(temp); fs.renameSync(temp, target);
+    }
+    const catalogTemp = changedCatalog ? stage(paths.catalog, catalogBytes) : null;
+    if (catalogTemp) temporary.push(catalogTemp);
+    const snapshotTemp = stage(paths.availability, snapshotBytes); temporary.push(snapshotTemp);
+    if (catalogTemp) fs.renameSync(catalogTemp, paths.catalog);
+    try { fs.renameSync(snapshotTemp, paths.availability); }
+    catch (error) {
+      if (catalogTemp && equal(catalogBytes, read(paths.catalog))) {
+        const restore = stage(paths.catalog, before.catalog); temporary.push(restore); fs.renameSync(restore, paths.catalog);
+      }
+      throw error;
+    }
+    return { status: 'current', checkedAt, newNativeModelIds, baseline: previous === null,
+      catalogAdded: candidates.length - catalog.candidates.length, unknownEffortModelIds: snapshot.unknownEffortModelIds, withheldExistingModelIds: snapshot.withheldExistingModelIds,
+      inferenceRequests: 0, policyApplied: false };
+  } catch { return failed('Native catalog refresh refused; previous availability and owner catalog retained where unchanged'); }
+  finally {
+    for (const file of temporary) { try { fs.unlinkSync(file); } catch { /* renamed */ } }
+    if (acquired) { try { fs.rmdirSync(guard); } catch { /* not acquired */ } }
+  }
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const option = name => { const at = process.argv.indexOf(name); return at < 0 ? undefined : process.argv[at + 1]; };
+  refreshNativeCatalog({ routerDir: option('--router-dir'), deadline: option('--deadline') === undefined ? undefined : Number(option('--deadline')) })
+    .then(result => { console.log(JSON.stringify(result)); if (result.status !== 'current') process.exitCode = 1; });
+}

package/scripts/model-native-qualification.mjs

@@ -0,0 +1,251 @@
+// Native subscription qualification: fixed plaintext tasks, never candidate code execution.
+// Protocol sequence derives from the source-bound native gateway acceptance probe.
+// Configuration identity is observable; provider/backend identity is never proved here.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawn, execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { StringDecoder } from 'node:string_decoder';
+import { assertSubscriptionAuth, subscriptionEnvironment } from './model-router-dispatch.mjs';
+import { discoverNativeCodex } from './model-routing-launchers.mjs';
+
+const SELF = fileURLToPath(import.meta.url);
+const digest = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');
+const EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+const ID = /^[a-z][a-z0-9]*(?:[-.][a-z0-9]+)*$/;
+const redact = (key, value) => /^(?:email|account_id|access_token|refresh_token|id_token|api_key|authorization|credentials)$/i.test(key) ? '[redacted]' : value;
+
+function binaryFor(host) {
+  const extensions = path.join(os.homedir(), '.vscode-server/extensions');
+  if (host === 'codex') return discoverNativeCodex(extensions);
+  const entries = JSON.parse(fs.readFileSync(path.join(extensions, 'extensions.json')));
+  const entry = entries.find((e) => e.identifier?.id === 'anthropic.claude-code');
+  if (!entry) throw new Error('Native Claude extension unavailable');
+  return path.join(entry.location.path, 'resources/native-binary', process.platform === 'win32' ? 'claude.exe' : 'claude');
+}
+
+export function verifyClaudeAllowance(usage, model) {
+  // Native 2.1.289 get_usage is explicitly experimental. Unknown shapes fail closed.
+  if (usage?.rate_limits_available !== true || usage.rate_limits?.extra_usage?.is_enabled !== false) throw new Error('Native Claude allowance unknown or extra usage enabled');
+  const limits = usage.rate_limits;
+  for (const key of ['five_hour', 'seven_day']) {
+    const window = limits[key];
+    if (!window || !Number.isFinite(window.utilization) || window.utilization < 0 || window.utilization >= 100 || window.locked_reason !== null) throw new Error('Native Claude ordinary allowance unavailable');
+  }
+  for (const scoped of limits.model_scoped || []) {
+    if (!Number.isFinite(scoped.utilization) || scoped.utilization < 0 || scoped.utilization >= 100 || scoped.locked_reason != null) throw new Error('Native Claude scoped allowance unavailable or unmapped');
+  }
+  for (const limit of limits.limits || []) {
+    if (!Number.isFinite(limit.percent) || limit.percent < 0 || limit.percent >= 100 || !['normal', 'warning'].includes(limit.severity)) throw new Error('Native Claude allowance unavailable or unknown');
+  }
+  return { verified: true, basis: 'native-get_usage-2.1.289', checkedAt: new Date().toISOString(), reservation: false, raceSafe: false, model };
+}
+
+class Transport {
+  constructor(child, host, fail, transcript, signal) {
+    this.child = child; this.host = host; this.fail = fail; this.transcript = transcript;
+    this.pending = new Map(); this.events = []; this.waiters = []; this.serial = 0; this.buffer = ''; this.bytes = 0; this.decoder = new StringDecoder('utf8');
+    child.stderr.on('data', () => {}); child.stdin.on('error', () => fail(new Error('Native input transport failed')));
+    child.once('error', () => fail(new Error('Native executable unavailable')));
+    child.once('exit', () => { if (!signal.aborted) fail(new Error('Native host exited before qualification')); });
+    child.stdout.on('data', (chunk) => {
+      this.bytes += chunk.length; if (this.bytes > 512 * 1024) return fail(new Error('Native transcript exceeded bound'));
+      this.buffer += this.decoder.write(chunk);
+      let at;
+      while ((at = this.buffer.indexOf('\n')) >= 0) {
+        const line = this.buffer.slice(0, at); this.buffer = this.buffer.slice(at + 1);
+        let message; try { message = JSON.parse(line); } catch { return fail(new Error('Malformed native protocol output')); }
+        transcript.push({ direction: 'native', packet: message });
+        const id = host === 'codex' ? message.id : message.type === 'control_response' ? message.response?.request_id : null;
+        const pending = this.pending.get(id);
+        if (pending) {
+          this.pending.delete(id);
+          if (message.error || (host === 'claude-code' && message.response.subtype !== 'success')) pending.reject(new Error('Native request refused'));
+          else pending.resolve(host === 'codex' ? message.result : message.response.response);
+        } else {
+          // No native tool/approval request is ever serviced by this adapter.
+          const tool = host === 'codex' ? Object.hasOwn(message, 'id') && Boolean(message.method)
+            : message.type === 'control_request' || message.message?.content?.some((p) => p.type === 'tool_use');
+          const item = message.params?.item;
+          if (tool || (item?.type && !['agentMessage', 'reasoning', 'userMessage'].includes(item.type))) return fail(new Error('Native tool inference refused'));
+          this.events.push(message);
+          for (const waiter of [...this.waiters]) if (waiter.predicate(message)) { this.waiters.splice(this.waiters.indexOf(waiter), 1); waiter.resolve(message); }
+        }
+      }
+    });
+  }
+  send(packet) { this.transcript.push({ direction: 'client', packet }); this.child.stdin.write(`${JSON.stringify(packet)}\n`); }
+  request(method, params = {}) {
+    const id = `qualification-${++this.serial}`;
+    const promise = new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
+    this.send(this.host === 'codex' ? { id, method, params } : { type: 'control_request', request_id: id, request: { subtype: method, ...params } });
+    return promise;
+  }
+  wait(predicate, start = 0) {
+    const existing = this.events.slice(start).find(predicate); if (existing) return Promise.resolve(existing);
+    return new Promise((resolve) => this.waiters.push({ predicate, resolve }));
+  }
+}
+
+async function run(options, inspectOnly) {
+  const { host, model, effort, prompt, cwd, env = process.env, deadline = Date.now() + 60000,
+    spawnHost = spawn, versionProbe = execFileSync, authCheck = assertSubscriptionAuth, now = Date.now } = options;
+  const started = now(); const transcript = []; let child, transport;
+  const result = { completed: false, output: '', nativeModel: null, nativeEffort: null, identityBasis: null,
+    backendIdentityProved: false, nativeSubscription: false, available: false, supported: false, models: [],
+    harnessVersion: null, elapsedMs: 0, nativeSessionId: null, nativeTurnId: null, sourceReceipt: {
+      schemaVersion: 1, kind: 'native-model-qualification', host, backendIdentityProved: false,
+      adapterSha256: digest(fs.readFileSync(SELF)), nativeSettings: {}, nativeTurn: null,
+      request: inspectOnly ? null : { model, effort, promptSha256: digest(String(prompt)) }, transcriptRedactions: ['account/auth identifying fields'],
+    } };
+  const controller = new AbortController(); let abortError;
+  const fail = (error) => { if (!controller.signal.aborted) { abortError = error; controller.abort(); } };
+  const remaining = () => { const ms = deadline - now(); if (ms <= 0) throw new Error('Shared native qualification deadline exhausted'); return ms; };
+  const bounded = (promise) => new Promise((resolve, reject) => {
+    if (controller.signal.aborted) return reject(abortError);
+    const stop = () => reject(abortError); controller.signal.addEventListener('abort', stop, { once: true });
+    Promise.resolve(promise).then(resolve, reject).finally(() => controller.signal.removeEventListener('abort', stop));
+  });
+  let timer;
+  try {
+    if (!['codex', 'claude-code'].includes(host) || !Number.isFinite(deadline)) throw new Error('Supported native host and absolute deadline required');
+    remaining(); timer = setTimeout(() => fail(new Error('Shared native qualification deadline exhausted')), remaining());
+    if (!inspectOnly && (!ID.test(model || '') || !EFFORTS.has(effort) || typeof prompt !== 'string' || !prompt.trim() || Buffer.byteLength(prompt) > 16384 || !path.isAbsolute(cwd || ''))) throw new Error('Static model/effort, bounded plaintext prompt and absolute sandbox cwd required');
+    const binary = fs.realpathSync(options.binary || binaryFor(host));
+    result.sourceReceipt.binary = binary;
+    // Exact native executable bytes, without retaining executable or credentials in the receipt.
+    const hash = crypto.createHash('sha256'); const stream = fs.createReadStream(binary);
+    const stopHash = () => stream.destroy(abortError);
+    controller.signal.addEventListener('abort', stopHash, { once: true });
+    try { await bounded(new Promise((resolve, reject) => { stream.on('data', (bytes) => { try { remaining(); hash.update(bytes); } catch (e) { stream.destroy(e); } }); stream.once('error', reject); stream.once('end', resolve); })); }
+    finally { controller.signal.removeEventListener('abort', stopHash); }
+    result.sourceReceipt.nativeBinarySha256 = hash.digest('hex');
+    const clean = subscriptionEnvironment(env);
+    result.harnessVersion = String(versionProbe(binary, ['--version'], { env: clean, encoding: 'utf8', timeout: remaining(), stdio: ['ignore', 'pipe', 'pipe'] })).trim().slice(0, 128);
+    await bounded(authCheck(host, { env: clean, probe: (_command, args, opts) => versionProbe(binary, args, { ...opts, timeout: remaining() }) }));
+    result.nativeSubscription = true;
+    const args = host === 'codex' ? ['app-server', '--strict-config', '-c', 'model_provider="openai"', '-c', 'service_tier="default"', '-c', 'features.fast_mode=false',
+      '-c', 'features.shell_tool=false', '-c', 'features.unified_exec=false', '-c', 'features.code_mode=false', '-c', 'features.code_mode_host=false', '-c', 'features.multi_agent=false', '-c', 'features.plugins=false', '-c', 'web_search="disabled"', '-c', 'mcp_servers={}']
+      : ['--print', '--verbose', '--input-format', 'stream-json', '--output-format', 'stream-json', '--include-partial-messages', '--tools', '', '--mcp-config', '{"mcpServers":{}}', '--strict-mcp-config', '--no-session-persistence'];
+    remaining(); child = spawnHost(binary, args, { env: clean, cwd: cwd || os.tmpdir(), shell: false, stdio: ['pipe', 'pipe', 'pipe'] });
+    transport = new Transport(child, host, fail, transcript, controller.signal);
+    const metadata = (promise) => {
+      const timeout = setTimeout(() => fail(new Error(`Native metadata timeout: ${result.sourceReceipt.stage}`)), Math.min(10000, remaining()));
+      return bounded(promise).finally(() => clearTimeout(timeout));
+    };
+    const request = (...params) => { result.sourceReceipt.stage = params[0]; return metadata(transport.request(...params)); };
+    if (host === 'codex') {
+      await request('initialize', { clientInfo: { name: 'native_model_qualification', version: '1' }, capabilities: { experimentalApi: true } }); transport.send({ method: 'initialized' });
+      const account = await request('account/read', { refreshToken: false });
+      if (account?.account?.type !== 'chatgpt') throw new Error('Native same-process subscription account unavailable');
+      const allowance = await request('account/rateLimits/read', { excludeResetCreditDetails: true, supportsLunaReserve: false });
+      if (allowance?.ordinaryUsageAllowed !== true) throw new Error('Native ordinary subscription allowance unavailable');
+      result.sourceReceipt.allowance = { verified: true, basis: 'native-account/rateLimits/read', reservation: false, raceSafe: false };
+      let cursor;
+      do {
+        const catalog = await request('model/list', { ...(cursor ? { cursor } : {}), includeHidden: true });
+        if (!Array.isArray(catalog?.data)) throw new Error('Native model catalog unavailable');
+        result.models.push(...catalog.data.map((m) => ({ id: m.model, efforts: (m.supportedReasoningEfforts || []).map((e) => e.reasoningEffort), inputModalities: m.inputModalities })));
+        cursor = catalog.nextCursor;
+        if (result.models.length > 1000) throw new Error('Native catalog exceeded bound');
+      } while (cursor);
+      result.available = true; result.catalogStatus = 'verified';
+      if (!inspectOnly) {
+        if (!result.models.some((m) => m.id === model && m.efforts.includes(effort))) throw new Error('Native model/effort unsupported');
+        result.supported = true;
+        const thread = await request('thread/start', { cwd, model, modelProvider: 'openai', serviceTier: 'default', sandbox: 'read-only', approvalPolicy: 'untrusted', ephemeral: true, environments: [], dynamicTools: [],
+          developerInstructions: 'Qualification: plaintext answer only. Never use tools, read files, execute code, or delegate.' });
+        const threadId = thread?.thread?.id; if (!threadId) throw new Error('Native thread identity missing');
+        result.nativeSessionId = threadId;
+        const settings = async (params) => {
+          const start = transport.events.length;
+          await request('thread/settings/update', { threadId, ...params });
+          result.sourceReceipt.stage = 'thread/settings/updated';
+          const event = await metadata(transport.wait((m) => m.method === 'thread/settings/updated' && m.params?.threadId === threadId, start));
+          const s = event.params.threadSettings;
+          if (s?.model !== model || s.effort !== effort || s.modelProvider !== 'openai' || s.serviceTier !== 'default') throw new Error('Native configured model/effort/provider mismatch');
+          return { model: s.model, effort: s.effort, provider: s.modelProvider, serviceTier: s.serviceTier, threadId };
+        };
+        result.sourceReceipt.nativeSettings.before = await settings({ model, effort, serviceTier: 'default' });
+        const accepted = await request('turn/start', { threadId, model, effort, serviceTier: 'default', input: [{ type: 'text', text: prompt }] });
+        const turnId = accepted?.turn?.id; if (!turnId) throw new Error('Native turn identity missing');
+        result.sourceReceipt.stage = 'turn/completed';
+        const end = await bounded(transport.wait((m) => m.method === 'turn/completed' && m.params?.threadId === threadId && m.params?.turn?.id === turnId));
+        if (end.params.turn.status !== 'completed') throw new Error('Native turn did not complete');
+        const items = transport.events.filter((m) => m.method === 'item/completed' && m.params?.threadId === threadId && m.params?.turnId === turnId);
+        result.output = items.filter((m) => m.params.item?.type === 'agentMessage').map((m) => m.params.item.text || '').join('\n');
+        result.nativeTurnId = turnId;
+        // Native same-value updates emit no notification. Read actual live thread
+        // metadata after completion; never infer settings from a no-op acknowledgment.
+        const observed = (await request('thread/read', { threadId, includeTurns: false }))?.thread;
+        if (observed?.id !== threadId || observed.model !== model || observed.reasoningEffort !== effort || observed.modelProvider !== 'openai') throw new Error('Native completed thread model/effort/provider mismatch');
+        result.sourceReceipt.nativeSettings.after = { model: observed.model, effort: observed.reasoningEffort, provider: observed.modelProvider, threadId, basis: 'native-thread/read' };
+        if (Object.hasOwn(observed, 'serviceTier')) {
+          if (observed.serviceTier !== 'default') throw new Error('Native completed thread service tier mismatch');
+          result.sourceReceipt.nativeSettings.after.serviceTier = observed.serviceTier;
+          result.sourceReceipt.nativeSettings.after.serviceTierBasis = 'native-thread/read';
+        } else result.sourceReceipt.nativeSettings.after.serviceTierBasis = 'pre-turn-native-settings-and-fixed-host-configuration';
+      }
+    } else {
+      if (!/^2\.1\.289 \(Claude Code\)$/.test(result.harnessVersion)) throw new Error('Experimental Claude allowance contract version unsupported');
+      const initialized = await request('initialize');
+      if (initialized?.session_state !== 'idle') throw new Error('Native Claude session not idle');
+      result.sourceReceipt.allowance = verifyClaudeAllowance(await request('get_usage', { skip_behaviors: true }), model);
+      // Native initialize.models is the extension's supportedModels() source.
+      result.catalogStatus = Array.isArray(initialized.models) ? 'verified' : 'unknown';
+      for (const m of initialized.models || []) {
+        if (typeof m.resolvedModel !== 'string') throw new Error('Native Claude model catalog malformed');
+        if (!result.models.some((entry) => entry.id === m.resolvedModel)) result.models.push({ id: m.resolvedModel,
+          efforts: m.supportsEffort === true && Array.isArray(m.supportedEffortLevels) ? m.supportedEffortLevels.filter((e) => EFFORTS.has(e)) : [] });
+      }
+      result.available = true;
+      if (!inspectOnly) {
+        if (!result.models.some((m) => m.id === model && m.efforts.includes(effort))) throw new Error('Native Claude model/effort unsupported or unknown');
+        await request('apply_flag_settings', { settings: { model, effortLevel: effort } });
+        const settings = async () => {
+          const observed = (await request('get_settings'))?.applied;
+          if (observed?.model !== model || observed.effort !== effort) throw new Error('Native Claude configured model/effort mismatch');
+          return { model: observed.model, effort: observed.effort };
+        };
+        result.sourceReceipt.nativeSettings.before = await settings(); result.supported = true;
+        transport.send({ type: 'user', uuid: crypto.randomUUID(), session_id: '', message: { role: 'user', content: [{ type: 'text', text: prompt }] }, parent_tool_use_id: null });
+        result.sourceReceipt.stage = 'result';
+        const completion = await bounded(transport.wait((m) => m.type === 'result'));
+        if (completion.is_error || completion.subtype !== 'success' || !completion.uuid || !completion.session_id || !completion.usage || !(completion.duration_api_ms > 0) || !(completion.num_turns > 0)) throw new Error('Native Claude completion identity/usage unavailable');
+        result.output = completion.result || ''; result.nativeSessionId = completion.session_id; result.nativeTurnId = completion.uuid;
+        result.sourceReceipt.nativeSettings.after = await settings();
+      }
+    }
+    if (!inspectOnly) {
+      if (typeof result.output !== 'string' || !result.output.trim() || Buffer.byteLength(result.output) > 32768) throw new Error('Native plaintext output missing or exceeded bound');
+      result.completed = true; result.nativeModel = result.sourceReceipt.nativeSettings.after.model; result.nativeEffort = result.sourceReceipt.nativeSettings.after.effort; result.identityBasis = 'native-host-confirmed-configuration';
+      result.sourceReceipt.nativeTurn = { threadId: result.nativeSessionId, turnId: result.nativeTurnId, status: 'completed', toolEvents: [],
+        turnIdBasis: host === 'codex' ? 'native-turn.id' : 'native-result.uuid' };
+      result.sourceReceipt.stage = 'completed';
+    }
+  } catch (error) { result.failure = error.message; result.completed = false; result.output = ''; }
+  finally {
+    clearTimeout(timer); controller.abort();
+    if (child) {
+      await new Promise((resolve) => {
+        const grace = setTimeout(() => { child.kill('SIGKILL'); resolve(); }, Math.max(0, Math.min(100, deadline - now())));
+        child.once('close', () => { clearTimeout(grace); resolve(); });
+        child.stdin.end(); child.kill('SIGTERM');
+      });
+    }
+    result.elapsedMs = Math.max(0, now() - started); result.checkedAt = new Date().toISOString();
+    result.transcript = transcript.map((frame) => JSON.stringify(frame, redact)).join('\n');
+    if (Buffer.byteLength(result.transcript) > 1024 * 1024) {
+      result.completed = false; result.output = ''; result.failure = 'Archived native transcript exceeded bound';
+      result.transcript = ''; result.sourceReceipt.nativeTurn = null;
+    }
+    result.transcriptSha256 = digest(result.transcript); result.sourceReceipt.transcriptSha256 = result.transcriptSha256;
+    result.sourceReceipt.harnessVersion = result.harnessVersion;
+  }
+  return result;
+}
+
+export const runNativeQualification = (options) => run(options, false);
+export const inspectNativeQualificationHost = (options) => run(options, true);