testronaut 1.11.0 → 1.12.1

package/experiments/optimizationBenchmark.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const DEFAULT_CLI = path.resolve(HERE, '../bin/cli.js');
+const DEFAULT_REPOS = {
+  openai: '/home/shane/workspace/testronaut-examples',
+  gemini: '/home/shane/workspace/e2e-testing-collegium',
+};
+
+export const BENCHMARK_TARGETS = {
+  openai: {
+    provider: 'openai',
+    repo: DEFAULT_REPOS.openai,
+    missions: [
+      'missions/login.mission.js',
+      'missions/removeTask.mission.js',
+      'missions/fileTransfer.mission.js',
+    ],
+    conditions: [
+      { id: 'l1_terra_control', level: 1, primary: 'gpt-5.6-terra', objective: 'off', mode: 'off' },
+      { id: 'l2_terra_guarded', level: 2, primary: 'gpt-5.6-terra', objective: 'tokens', mode: 'live' },
+      { id: 'l2_luna_guarded', level: 2, primary: 'gpt-5.6-luna', objective: 'tokens', mode: 'live' },
+      { id: 'l2_gpt55_guarded', level: 2, primary: 'gpt-5.5', objective: 'tokens', mode: 'live' },
+      { id: 'l3_terra_luna', level: 3, primary: 'gpt-5.6-terra', secondary: 'gpt-5.6-luna', objective: 'cost', mode: 'live' },
+      { id: 'l4_terra_gpt55', level: 4, primary: 'gpt-5.6-terra', secondary: 'gpt-5.5', objective: 'cost', mode: 'live' },
+      { id: 'l4_terra_gpt54', level: 4, primary: 'gpt-5.6-terra', secondary: 'gpt-5.4', objective: 'cost', mode: 'live' },
+    ],
+  },
+  gemini: {
+    provider: 'gemini',
+    repo: DEFAULT_REPOS.gemini,
+    missions: [
+      'missions/profileNavigation.mission.js',
+      'missions/projectsDashboard.mission.js',
+      'missions/projectWorkspaceNavigation.mission.js',
+    ],
+    conditions: [
+      { id: 'l1_gemini38_control', level: 1, primary: 'gemini-3.8-flash', objective: 'off', mode: 'off' },
+      { id: 'l2_gemini38_guarded', level: 2, primary: 'gemini-3.8-flash', objective: 'tokens', mode: 'live' },
+      { id: 'l2_gemini36_guarded', level: 2, primary: 'gemini-3.6-flash', objective: 'tokens', mode: 'live' },
+      { id: 'l2_gemini35lite_guarded', level: 2, primary: 'gemini-3.5-flash-lite', objective: 'tokens', mode: 'live' },
+      { id: 'l3_gemini38_gemini37', level: 3, primary: 'gemini-3.8-flash', secondary: 'gemini-3.7-flash', objective: 'cost', mode: 'live' },
+      { id: 'l4_gemini38_gemini36', level: 4, primary: 'gemini-3.8-flash', secondary: 'gemini-3.6-flash', objective: 'cost', mode: 'live' },
+      { id: 'l4_gemini38_gemini35lite', level: 4, primary: 'gemini-3.8-flash', secondary: 'gemini-3.5-flash-lite', objective: 'cost', mode: 'live' },
+    ],
+  },
+};
+
+function hashSeed(value) {
+  let hash = 2166136261;
+  for (const char of String(value)) {
+    hash ^= char.charCodeAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function seededRandom(seed) {
+  let value = seed || 1;
+  return () => {
+    value += 0x6D2B79F5;
+    let next = value;
+    next = Math.imul(next ^ (next >>> 15), next | 1);
+    next ^= next + Math.imul(next ^ (next >>> 7), next | 61);
+    return ((next ^ (next >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function shuffled(values, seed) {
+  const result = [...values];
+  const random = seededRandom(hashSeed(seed));
+  for (let index = result.length - 1; index > 0; index -= 1) {
+    const swap = Math.floor(random() * (index + 1));
+    [result[index], result[swap]] = [result[swap], result[index]];
+  }
+  return result;
+}
+
+export function buildBenchmarkSchedule({ repetitions = 5, targets = ['openai', 'gemini'], seed = 'optimization-pilot-v1' } = {}) {
+  const schedule = [];
+  for (let block = 1; block <= repetitions; block += 1) {
+    for (const targetName of targets) {
+      const target = BENCHMARK_TARGETS[targetName];
+      if (!target) throw new Error(`Unknown benchmark target: ${targetName}`);
+      for (const condition of shuffled(target.conditions, `${seed}:${targetName}:${block}`)) {
+        schedule.push({
+          key: `${targetName}:b${block}:${condition.id}`,
+          target: targetName,
+          block,
+          provider: target.provider,
+          repo: target.repo,
+          missions: target.missions,
+          ...condition,
+        });
+      }
+    }
+  }
+  return schedule;
+}
+
+export function commandForRun(run, cliPath = DEFAULT_CLI) {
+  return {
+    command: process.execPath,
+    args: [
+      cliPath,
+      `--provider=${run.provider}`,
+      `--model=${run.primary}`,
+      `--optimize=${run.objective}`,
+      `--optimization-mode=${run.mode}`,
+      ...run.missions,
+    ],
+    env: {
+      TESTRONAUT_JEV_ROUTING_THRESHOLD: '0.4',
+      ...(run.secondary ? { TESTRONAUT_BETA_MODEL_ROUTING: '1' } : {}),
+      ...(run.secondary ? { TESTRONAUT_JEV_FAST_MODEL: run.secondary } : {}),
+    },
+  };
+}
+
+function parseArgs(argv) {
+  const read = (name, fallback) => argv.find(arg => arg.startsWith(`--${name}=`))?.slice(name.length + 3) ?? fallback;
+  const target = read('target', 'both');
+  return {
+    dryRun: argv.includes('--dry-run'),
+    repetitions: Math.max(1, Number.parseInt(read('repetitions', '5'), 10) || 5),
+    targets: target === 'both' ? ['openai', 'gemini'] : target.split(',').filter(Boolean),
+    seed: read('seed', 'optimization-pilot-v1'),
+    experimentId: read('experiment-id', 'optimization-pilot-v1'),
+    cliPath: path.resolve(read('cli', DEFAULT_CLI)),
+  };
+}
+
+function reportFiles(repo) {
+  const directory = path.join(repo, 'missions/mission_reports');
+  if (!fs.existsSync(directory)) return new Set();
+  return new Set(fs.readdirSync(directory).filter(file => /^run_\d+\.json$/.test(file)));
+}
+
+function findNewReport(repo, before) {
+  const directory = path.join(repo, 'missions/mission_reports');
+  if (!fs.existsSync(directory)) return null;
+  const candidates = fs.readdirSync(directory)
+    .filter(file => /^run_\d+\.json$/.test(file) && !before.has(file))
+    .map(file => ({ file, time: fs.statSync(path.join(directory, file)).mtimeMs }))
+    .sort((a, b) => b.time - a.time);
+  return candidates[0] ? path.join(directory, candidates[0].file) : null;
+}
+
+function existingExperimentReports(repo, experimentId) {
+  const directory = path.join(repo, 'missions/mission_reports');
+  const reports = new Map();
+  if (!fs.existsSync(directory)) return reports;
+  for (const file of fs.readdirSync(directory).filter(name => /^run_\d+\.json$/.test(name))) {
+    const reportPath = path.join(directory, file);
+    try {
+      const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+      if (report.experiment?.id !== experimentId) continue;
+      reports.set(`${report.experiment.condition}:${report.experiment.block}`, reportPath);
+    } catch { /* ignore incomplete or unrelated reports */ }
+  }
+  return reports;
+}
+
+function loadState(file, metadata) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return { ...metadata, runs: {} }; }
+}
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function writeSummaryCsv(file, state) {
+  const columns = [
+    'key', 'target', 'block', 'level', 'condition', 'primary', 'secondary', 'objective',
+    'status', 'runId', 'passed', 'failed', 'turns', 'tokens', 'routedTurns',
+    'forcedPrimaryRetries', 'completionGates', 'jevInputTokens', 'jevOutputTokens',
+  ];
+  const escape = value => {
+    const text = String(value ?? '');
+    return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+  };
+  const rows = Object.entries(state.runs).map(([key, run]) => {
+    const metrics = run.metrics || {};
+    return [
+      key, run.target, run.block, run.level, run.id, run.primary, run.secondary, run.objective,
+      run.status, metrics.runId, metrics.passed, metrics.failed, metrics.turns, metrics.tokens,
+      metrics.routedTurns, metrics.forcedPrimaryRetries, metrics.completionGates,
+      metrics.jevInputTokens, metrics.jevOutputTokens,
+    ].map(escape).join(',');
+  });
+  fs.writeFileSync(file, `${columns.join(',')}\n${rows.join('\n')}\n`);
+}
+
+function summarizeReport(reportPath) {
+  if (!reportPath) return null;
+  try {
+    const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+    const steps = report.missions?.flatMap(mission => mission.steps || []) || [];
+    const models = {};
+    for (const step of steps) {
+      const model = step.model || report.llm?.model || 'unknown';
+      models[model] ||= { turns: 0, tokens: 0 };
+      models[model].turns += 1;
+      models[model].tokens += Number(step.tokensUsed || 0);
+    }
+    return {
+      runId: report.runId,
+      passed: report.summary?.passed || 0,
+      failed: report.summary?.failed || 0,
+      turns: steps.length,
+      tokens: steps.reduce((sum, step) => sum + Number(step.tokensUsed || 0), 0),
+      routedTurns: steps.filter(step => step.modelRouting?.applied).length,
+      forcedPrimaryRetries: steps.filter(step => step.modelRouting?.forcedPrimaryRetry).length,
+      jevInputTokens: Number(report.jevShadow?.inputTokens || 0),
+      jevOutputTokens: Number(report.jevShadow?.outputTokens || 0),
+      completionGates: Number(report.jevShadow?.triggeredCompletions || 0),
+      models,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function runBenchmark(options) {
+  const schedule = buildBenchmarkSchedule(options);
+  if (options.dryRun) return { schedule, completed: 0, skipped: 0 };
+
+  const stateRoot = path.resolve(HERE, 'results', options.experimentId);
+  const legacyStateFile = path.join(stateRoot, 'state.json');
+  const legacyState = loadState(legacyStateFile, { runs: {} });
+  const states = {};
+  const stateFiles = {};
+  for (const target of options.targets) {
+    const stateFile = path.join(stateRoot, `state-${target}.json`);
+    const legacyRuns = Object.fromEntries(
+      Object.entries(legacyState.runs || {}).filter(([, run]) => run.target === target),
+    );
+    const state = loadState(stateFile, {
+      experimentId: options.experimentId,
+      seed: options.seed,
+      repetitions: options.repetitions,
+      targets: [target],
+      createdAt: new Date().toISOString(),
+      runs: legacyRuns,
+    });
+    const targetSchedule = schedule.filter(run => run.target === target);
+    const existing = existingExperimentReports(targetSchedule[0]?.repo, options.experimentId);
+    for (const run of targetSchedule) {
+      if (state.runs[run.key]?.status === 'completed') continue;
+      const reportPath = existing.get(`${run.id}:${run.block}`);
+      if (!reportPath) continue;
+      state.runs[run.key] = {
+        ...run,
+        status: 'completed',
+        exitCode: null,
+        recoveredFromReport: true,
+        reportPath,
+        metrics: summarizeReport(reportPath),
+      };
+    }
+    states[target] = state;
+    stateFiles[target] = stateFile;
+    writeJson(stateFile, state);
+    writeSummaryCsv(path.join(stateRoot, `runs-${target}.csv`), state);
+  }
+  let completed = 0;
+  let skipped = 0;
+
+  for (const run of schedule) {
+    const state = states[run.target];
+    const stateFile = stateFiles[run.target];
+    if (state.runs[run.key]?.status === 'completed') {
+      skipped += 1;
+      continue;
+    }
+    const invocation = commandForRun(run, options.cliPath);
+    console.log(`\n[${run.key}] ${run.primary}${run.secondary ? ` -> ${run.secondary}` : ''} (${run.objective}/${run.mode})`);
+    const before = reportFiles(run.repo);
+    const logFile = path.join(stateRoot, 'logs', `${run.key.replaceAll(':', '_')}.log`);
+    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+    const startedAt = new Date().toISOString();
+    const env = { ...process.env, ...invocation.env };
+    if (!run.secondary) delete env.TESTRONAUT_JEV_FAST_MODEL;
+    Object.assign(env, {
+      TESTRONAUT_EXPERIMENT_ID: options.experimentId,
+      TESTRONAUT_EXPERIMENT_CONDITION: run.id,
+      TESTRONAUT_EXPERIMENT_BLOCK: String(run.block),
+    });
+    const result = spawnSync(invocation.command, invocation.args, {
+      cwd: run.repo,
+      env,
+      encoding: 'utf8',
+      stdio: ['inherit', 'pipe', 'pipe'],
+      maxBuffer: 50 * 1024 * 1024,
+    });
+    fs.writeFileSync(logFile, `${result.stdout || ''}${result.stderr || ''}`);
+    const reportPath = findNewReport(run.repo, before);
+    const status = reportPath ? 'completed' : 'no_report';
+    state.runs[run.key] = {
+      ...run,
+      status,
+      exitCode: result.status,
+      signal: result.signal,
+      startedAt,
+      endedAt: new Date().toISOString(),
+      reportPath,
+      logFile,
+      metrics: summarizeReport(reportPath),
+    };
+    writeJson(stateFile, state);
+    writeSummaryCsv(path.join(stateRoot, `runs-${run.target}.csv`), state);
+    console.log(`[${run.key}] ${status}; exit=${result.status}; report=${reportPath || 'none'}`);
+    if (status === 'completed') completed += 1;
+  }
+  return { schedule, completed, skipped, stateFiles };
+}
+
+function printSchedule(schedule) {
+  console.log(`Optimization benchmark schedule: ${schedule.length} runs`);
+  for (const run of schedule) {
+    const secondary = run.secondary ? ` -> ${run.secondary}` : '';
+    console.log(`${run.key} | L${run.level} | ${run.primary}${secondary} | ${run.objective}/${run.mode} | ${run.missions.length} missions`);
+  }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const options = parseArgs(process.argv.slice(2));
+  const result = runBenchmark(options);
+  if (options.dryRun) printSchedule(result.schedule);
+  else console.log(`Benchmark progress saved to ${Object.values(result.stateFiles).join(', ')}. Completed ${result.completed}; resumed/skipped ${result.skipped}.`);
+}
+
+export const __benchmarkInternals = { hashSeed, seededRandom, shuffled, parseArgs, summarizeReport };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testronaut",
-  "version": "1.11.0",
+  "version": "1.12.1",
   "main": "./runner/testronaut.js",
   "bin": {
     "testronaut": "bin/cli.js"
@@ -12,6 +12,10 @@
   },
   "type": "module",
   "scripts": {
+    "benchmark:optimization": "node ./experiments/optimizationBenchmark.js",
+    "benchmark:cross-provider": "node ./experiments/crossProviderBenchmark.js",
+    "benchmark:package": "node ./experiments/buildOptimizationDataPackage.js",
+    "benchmark:publish-package": "node ./experiments/buildExperimentPublicationPackage.js",
     "test": "vitest run",
     "test:watch": "vitest",
     "start": "node ./bin/cli.js"

package/tests/binTests/cli.helpers.test.js

@@ -108,6 +108,7 @@ describe('cli helpers', () => {
     }, '/tmp/project');
     expect(effective.outputDir).toEqual({ value: '/tmp/project/artifacts', source: 'config' });
     expect(effective.authenticated).toBe(true);
+    expect(effective.guardrails).toMatchObject({ enabled: false, failOpen: true, credentialConfigured: false });
     expect(JSON.stringify(effective)).not.toContain('secret');
   });
 
@@ -128,6 +129,21 @@ describe('cli helpers', () => {
     expect(res.invalid).toBe(false);
   });
 
+  it('parses optimization objective and execution mode flags', () => {
+    expect(__test__.parseOptimizationArgs([
+      '--optimize=balanced', '--optimization-mode', 'live', '--beta-model-routing', 'login.mission.js',
+    ])).toMatchObject({
+      objective: 'balanced', mode: 'live', betaModelRouting: true, args: ['login.mission.js'], invalid: false,
+    });
+    expect(__test__.parseOptimizationArgs(['--optimize=unknown'])).toMatchObject({ invalid: true });
+    expect(__test__.parseOptimizationArgs(['--guardrails', 'login.mission.js'])).toMatchObject({
+      objective: 'tokens', mode: 'live', guardrailsMode: 'live', args: ['login.mission.js'], invalid: false,
+    });
+    expect(__test__.parseOptimizationArgs(['--guardrails=shadow', 'login.mission.js'])).toMatchObject({
+      objective: 'tokens', mode: 'shadow', args: ['login.mission.js'], invalid: false,
+    });
+  });
+
   it('parses vercel bypass value from next arg', () => {
     const { parseVercelBypassArgs } = __test__;
     const res = parseVercelBypassArgs(['--vercel_bypass', 'abc', 'login']);

package/tests/binTests/cli.integration.test.js

@@ -62,6 +62,20 @@ describe('CLI inspection commands', () => {
     expect(result.stdout).not.toContain('private');
   });
 
+  it('reports opt-in guardrail readiness without exposing the Jev key', () => {
+    const cwd = makeProject();
+    fs.writeFileSync(path.join(cwd, 'testronaut-config.json'), JSON.stringify({
+      provider: 'openai', model: 'gpt-5.6', guardrails: { enabled: true, completionProbability: 0.85 },
+    }));
+    const result = spawnSync(process.execPath, [cliPath, 'config', '--json'], {
+      cwd, encoding: 'utf8', env: { ...process.env, TESTRONAUT_JEV_API_KEY: 'private-jev-key' },
+    });
+    expect(result.status).toBe(0);
+    const output = JSON.parse(result.stdout);
+    expect(output.guardrails).toMatchObject({ enabled: true, mode: 'live', completionProbability: 0.85, credentialConfigured: true, credentialSource: 'TESTRONAUT_JEV_API_KEY' });
+    expect(result.stdout).not.toContain('private-jev-key');
+  });
+
   it('suggests a close mission name and exits nonzero during dry-run', () => {
     const result = run(makeProject(), ['logn.mission.js', '--dry-run', '--json']);
     expect(result.status).toBe(1);
@@ -84,7 +98,10 @@ describe('CLI inspection commands', () => {
     const result = run(cwd, ['--tags', 'authentication', '--json', '--quiet']);
 
     expect(result.status).toBe(0);
-    expect(JSON.parse(result.stdout).missions[0].missionName).toBe('https://example.test');
+    const report = JSON.parse(result.stdout);
+    expect(report.missions[0].missionName).toBe('https://example.test');
+    expect(report.durationMs).toEqual(expect.any(Number));
+    expect(report.missions[0].durationMs).toEqual(expect.any(Number));
   });
 
   it('records shared-auth session mode in the report', () => {

package/tests/binTests/terminalUi.test.js

@@ -17,12 +17,13 @@ describe('terminal UI', () => {
     ui.banner({ version: '1.2.3', provider: 'openai', model: 'gpt-test', session: 'isolated' });
     ui.phase('launch', 'login.mission.js');
     ui.mission(true, 'login.mission.js', ['smoke']);
-    ui.summary({ totalMissions: 1, passed: 1, failed: 0, reportPath: 'reports/run.html' });
+    ui.summary({ totalMissions: 1, passed: 1, failed: 0, durationMs: 1234, reportPath: 'reports/run.html' });
 
     expect(target.read()).toContain('🧑‍🚀 TESTRONAUT  /  MISSION RUNNER');
     expect(target.read()).toContain('LAUNCH    login.mission.js');
     expect(target.read()).toContain('#smoke');
     expect(target.read()).toContain('MISSION COMPLETE');
+    expect(target.read()).toContain('Duration: 1.23s');
     expect(target.read()).not.toContain('\u001b[');
   });
 

package/tests/coreTests/agent.test.js

@@ -61,6 +61,8 @@ describe('core/agent.runAgent', () => {
     expect(res).toHaveLength(2);
     expect(res[0].status).toBe('passed');
     expect(res[1].status).toBe('passed');
+    expect(res[0].durationMs).toEqual(expect.any(Number));
+    expect(res[0].endTime).toBeGreaterThanOrEqual(res[0].startTime);
   });
 
   it('stops early on first failure and returns partial results', async () => {

package/tests/coreTests/browserEvidence.test.js

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import { buildBrowserEvidence, mergeBrowserControlState } from '../../core/browserEvidence.js';
+
+describe('browser evidence', () => {
+  it('extracts bounded structure without field values or URL secrets', () => {
+    const evidence = buildBrowserEvidence(`
+      <html><head><title>Mission Dashboard</title></head><body>
+        <main><h1>Mission Tasks</h1><form><label for="access">Access code</label>
+          <input id="access" name="access" type="password" value="super-secret" />
+          <button>Sign in</button>
+        </form></main>
+        <a href="https://example.test/tasks?token=secret#private">Tasks</a>
+        <p>private body content</p>
+      </body></html>
+    `, { url: 'https://example.test/dashboard?token=secret#private' });
+
+    expect(evidence).toMatchObject({
+      url: 'https://example.test/dashboard',
+      title: 'Mission Dashboard',
+      headings: ['Mission Tasks'],
+      counts: { headings: 1, forms: 1, buttons: 1, links: 1, inputs: 1 },
+    });
+    expect(JSON.stringify(evidence)).not.toContain('super-secret');
+    expect(JSON.stringify(evidence)).not.toContain('private body content');
+    expect(JSON.stringify(evidence)).not.toContain('token=secret');
+    expect(evidence.regions).toEqual(expect.arrayContaining([
+      expect.objectContaining({ kind: 'main', headings: ['Mission Tasks'] }),
+      expect.objectContaining({ kind: 'form', controls: ['Access code', 'Sign in'] }),
+    ]));
+  });
+
+  it('tracks route changes and clears stale page structure', () => {
+    const previous = buildBrowserEvidence('<title>Login</title><h1>Sign in</h1>', {
+      url: 'https://example.test/login',
+    });
+    const evidence = buildBrowserEvidence(null, {
+      url: 'https://example.test/dashboard',
+      previous,
+    });
+
+    expect(evidence).toEqual({
+      url: 'https://example.test/dashboard',
+      previousUrl: 'https://example.test/login',
+      routeChanged: true,
+    });
+  });
+
+  it('merges only boolean live state without exposing field contents', () => {
+    const evidence = { controls: [{ tag: 'input', id: 'password' }] };
+    const merged = mergeBrowserControlState(evidence, [{
+      hasValue: true,
+      checked: false,
+      disabled: false,
+      readOnly: true,
+      visible: true,
+      value: 'must-not-copy',
+    }]);
+
+    expect(merged.controls[0]).toEqual({
+      tag: 'input',
+      id: 'password',
+      hasValue: true,
+      checked: false,
+      disabled: false,
+      readOnly: true,
+      visible: true,
+    });
+    expect(JSON.stringify(merged)).not.toContain('must-not-copy');
+  });
+});

package/tests/coreTests/jevRouting.test.js

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { chooseJevTurnModel, resolveJevRoutingConfig } from '../../core/jevRouting.js';
+
+const safeFastRoute = {
+  modelRoute: { choice: 'fast_model', confidence: 0.22, probabilities: { fast_model: 0.52 } },
+  missionStage: { choice: 'interact' },
+  recovery: { choice: 'continue' },
+};
+
+describe('Jev dynamic routing', () => {
+  it('defaults OpenAI experiments to Luna without enabling routing', () => {
+    expect(resolveJevRoutingConfig({}, {
+      provider: 'openai', primaryModel: 'gpt-5.6-terra',
+    })).toMatchObject({ mode: 'off', fastModel: 'gpt-5.6-luna', confidenceThreshold: 0.4 });
+  });
+
+  it.each([
+    ['gemini', 'gemini-3.8-flash', 'gemini-3.5-flash-lite'],
+    ['anthropic', 'claude-sonnet-5', 'claude-haiku-4-5'],
+  ])('keeps the default fast model within the %s family', (provider, primaryModel, fastModel) => {
+    expect(resolveJevRoutingConfig({}, { provider, primaryModel })).toMatchObject({ fastModel });
+  });
+
+  it('records an eligible route without applying it in shadow mode', () => {
+    const result = chooseJevTurnModel(safeFastRoute, {
+      mode: 'shadow', fastModel: 'gpt-5.6-luna', confidenceThreshold: 0.4,
+    }, { provider: 'openai', primaryModel: 'gpt-5.6-terra' });
+    expect(result).toMatchObject({ eligible: true, applied: false, selectedModel: 'gpt-5.6-terra', reason: 'shadow_only' });
+  });
+
+  it('applies a high-confidence fast route for one live turn', () => {
+    const result = chooseJevTurnModel(safeFastRoute, {
+      mode: 'live', fastModel: 'gpt-5.6-luna', confidenceThreshold: 0.4,
+    }, { provider: 'openai', primaryModel: 'gpt-5.6-terra' });
+    expect(result).toMatchObject({ eligible: true, applied: true, selectedModel: 'gpt-5.6-luna', reason: 'jev_fast_model', score: 0.52, confidence: 0.22 });
+  });
+
+  it.each([
+    [{ ...safeFastRoute, missionStage: { choice: 'authenticate' } }, 'stage_authenticate'],
+    [{ ...safeFastRoute, recovery: { choice: 'reobserve' } }, 'recovery_reobserve'],
+    [{ ...safeFastRoute, modelRoute: { choice: 'fast_model', confidence: 0.5, probabilities: { fast_model: 0.39 } } }, 'low_probability'],
+  ])('keeps sensitive or uncertain turns on the primary model', (strategy, reason) => {
+    expect(chooseJevTurnModel(strategy, {
+      mode: 'live', fastModel: 'gpt-5.6-luna', confidenceThreshold: 0.4,
+    }, { provider: 'openai', primaryModel: 'gpt-5.6-terra' })).toMatchObject({ applied: false, reason });
+  });
+
+  it('rejects a configured model from another provider family', () => {
+    expect(chooseJevTurnModel(safeFastRoute, {
+      mode: 'live', fastModel: 'gpt-5.6-luna', confidenceThreshold: 0.4,
+    }, { provider: 'gemini', primaryModel: 'gemini-3.8-flash' })).toMatchObject({
+      applied: false,
+      reason: 'fast_model_provider_mismatch',
+      selectedModel: 'gemini-3.8-flash',
+    });
+  });
+});