testronaut 1.11.0 → 1.12.1

package/tests/coreTests/turnLoop.test.js

@@ -96,7 +96,7 @@ vi.mock('../../tools/turnLoopUtils.js', async () => {
     finalResponseHandler: (msg) => {
       const content = (msg?.content || '').toString();
       if (content.includes('FINAL')) {
-        return { finalMessage: 'Mission complete', success: true };
+        return { finalMessage: content, success: !content.includes('FAILURE') };
       }
       return null;
     },
@@ -112,6 +112,7 @@ vi.mock('../../core/turnIntent.js', () => ({
 vi.mock('../../core/redaction.js', () => ({
   maskPreview: (value) => `masked:${String(value ?? '').length}`,
   redactArgs: (name, args) => args,
+  redactPasswordInText: (value) => String(value ?? ''),
 }));
 
 // Import SUT after mocks
@@ -130,6 +131,13 @@ describe('turnLoop', () => {
 
   beforeEach(() => {
     delete process.env.TESTRONAUT_SCREENSHOTS;
+    delete process.env.TESTRONAUT_JEV_SHADOW;
+    delete process.env.TESTRONAUT_JEV_GATE;
+    delete process.env.TESTRONAUT_JEV_STRATEGIES;
+    delete process.env.TESTRONAUT_JEV_ROUTING;
+    delete process.env.TESTRONAUT_JEV_FAST_MODEL;
+    delete process.env.TESTRONAUT_JEV_ROUTING_THRESHOLD;
+    delete process.env.TESTRONAUT_JEV_API_KEY;
     browser = {};
     // reset spies and chat mock
     shared.chromeToolSpies.fill.mockClear();
@@ -174,6 +182,348 @@ describe('turnLoop', () => {
     expect(shared.chromeToolSpies.get_dom).not.toHaveBeenCalled();
   });
 
+  it('uses one tool-free closure turn after the working-turn budget is exhausted', async () => {
+    shared.chatMock
+      .mockResolvedValueOnce({
+        message: { role: 'assistant', content: 'Still investigating' },
+        usage: { total_tokens: 10 },
+        headers: {},
+      })
+      .mockResolvedValueOnce({
+        message: { role: 'assistant', content: 'FINAL: FAILURE: budget exhausted before completion' },
+        usage: { total_tokens: 4 },
+        headers: {},
+      });
+
+    const result = await turnLoop(browser, baseMessages(), 1, 0, 0, {}, {
+      steps: [], missionName: 'demo',
+    });
+
+    expect(result).toMatchObject({ success: false, completedBy: 'budget_closure' });
+    expect(shared.chatMock).toHaveBeenCalledTimes(2);
+    expect(shared.chatMock.mock.calls[1][0].tools).toEqual([]);
+    expect(shared.chatMock.mock.calls[1][0].messages.at(-1).content).toContain('working-turn budget is exhausted');
+    expect(result.steps.at(-1)).toMatchObject({
+      isClosureTurn: true,
+      result: '❌ Mission Failure',
+      tokensUsed: 4,
+    });
+  });
+
+  it('records elapsed milliseconds for normal and closure turns', async () => {
+    shared.chatMock
+      .mockResolvedValueOnce({ message: { role: 'assistant', content: 'Continue' }, usage: {} })
+      .mockResolvedValueOnce({ message: { role: 'assistant', content: 'FINAL: FAILURE: incomplete' }, usage: {} });
+
+    const result = await turnLoop(browser, baseMessages(), 1, 0, 0, {}, {
+      steps: [], missionName: 'timed',
+    });
+
+    expect(result.steps).toHaveLength(2);
+    for (const step of result.steps) {
+      expect(step.startTime).toEqual(expect.any(Number));
+      expect(step.endTime).toEqual(expect.any(Number));
+      expect(step.durationMs).toEqual(expect.any(Number));
+      expect(step.durationMs).toBeGreaterThanOrEqual(0);
+    }
+  });
+
+  it('records Jev shadow telemetry without changing the final result', async () => {
+    process.env.TESTRONAUT_JEV_SHADOW = '1';
+    process.env.TESTRONAUT_JEV_STRATEGIES = '1';
+    process.env.TESTRONAUT_JEV_API_KEY = 'test-key';
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        model: 'jev-test',
+        answers: {
+          missionComplete: { type: 'noul', noul: 0.95 },
+          modelRoute: { type: 'choice', choice: 'finish', confidence: 0.9, probabilities: { finish: 0.9 } },
+          postconditionSatisfied: { type: 'noul', noul: 0.9 },
+          recoveryRoute: { type: 'choice', choice: 'continue', confidence: 0.9, probabilities: { continue: 0.9 } },
+          missionStage: { type: 'choice', choice: 'complete', confidence: 0.9, probabilities: { complete: 0.9 } },
+          prerequisiteSatisfied: { type: 'noul', noul: 0.9 },
+        },
+        usage: { input_tokens: 75, output_tokens: 2 },
+      }),
+    }));
+    shared.chatMock.mockResolvedValueOnce({
+      message: { role: 'assistant', content: 'FINAL: success' },
+      usage: { total_tokens: 10 },
+      headers: {},
+    });
+
+    try {
+      const result = await turnLoop(browser, baseMessages(), 1, 0, 0, {}, {
+        steps: [],
+        missionName: 'demo',
+        goal: 'Complete the demo mission',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.steps[0].result).toMatch(/Success/);
+      expect(result.steps[0].jevShadow).toMatchObject({
+        status: 'ok',
+        model: 'jev-test',
+        usage: { input_tokens: 75, output_tokens: 2 },
+        strategies: { modelRoute: { choice: 'finish' } },
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+      delete process.env.TESTRONAUT_JEV_SHADOW;
+      delete process.env.TESTRONAUT_JEV_STRATEGIES;
+      delete process.env.TESTRONAUT_JEV_API_KEY;
+    }
+  });
+
+  it('routes the turn after a safe Jev fast-model recommendation', async () => {
+    process.env.TESTRONAUT_JEV_ROUTING = 'live';
+    process.env.TESTRONAUT_JEV_FAST_MODEL = 'stub-fast';
+    process.env.TESTRONAUT_JEV_API_KEY = 'test-key';
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        model: 'jev-test',
+        answers: {
+          modelRoute: { type: 'choice', choice: 'fast_model', confidence: 0.25, probabilities: { fast_model: 0.55 } },
+          missionStage: { type: 'choice', choice: 'interact', confidence: 0.9 },
+          recoveryRoute: { type: 'choice', choice: 'continue', confidence: 0.9 },
+        },
+        usage: { input_tokens: 50, output_tokens: 2 },
+      }),
+    }));
+    shared.chatMock
+      .mockResolvedValueOnce({
+        message: {
+          role: 'assistant', content: '',
+          tool_calls: [{ id: 'route_1', type: 'function', function: { name: 'click_text', arguments: '{"text":"Continue"}' } }],
+        },
+        usage: { total_tokens: 10 }, headers: {},
+      })
+      .mockResolvedValueOnce({
+        message: { role: 'assistant', content: 'FINAL: success' },
+        usage: { total_tokens: 5 }, headers: {},
+      });
+
+    try {
+      const result = await turnLoop(browser, baseMessages(), 2, 0, 0, {}, { steps: [], missionName: 'demo' });
+      expect(result.success).toBe(true);
+      expect(shared.chatMock.mock.calls.map(([request]) => request.model)).toEqual(['stub-model', 'stub-fast']);
+      expect(result.steps[1]).toMatchObject({
+        model: 'stub-fast',
+        modelRouting: { recommendation: 'fast_model', applied: true, reason: 'jev_fast_model' },
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('falls back to the primary model when a routed request fails', async () => {
+    process.env.TESTRONAUT_JEV_ROUTING = 'live';
+    process.env.TESTRONAUT_JEV_FAST_MODEL = 'stub-fast';
+    process.env.TESTRONAUT_JEV_API_KEY = 'test-key';
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        model: 'jev-test',
+        answers: {
+          modelRoute: { type: 'choice', choice: 'fast_model', confidence: 0.25, probabilities: { fast_model: 0.55 } },
+          missionStage: { type: 'choice', choice: 'interact', confidence: 0.9 },
+          recoveryRoute: { type: 'choice', choice: 'continue', confidence: 0.9 },
+        },
+        usage: { input_tokens: 50, output_tokens: 2 },
+      }),
+    }));
+    shared.chatMock
+      .mockResolvedValueOnce({
+        message: {
+          role: 'assistant', content: '',
+          tool_calls: [{ id: 'route_1', type: 'function', function: { name: 'click_text', arguments: '{"text":"Continue"}' } }],
+        },
+        usage: { total_tokens: 10 }, headers: {},
+      })
+      .mockRejectedValueOnce(new Error('fast model unavailable'))
+      .mockResolvedValueOnce({
+        message: { role: 'assistant', content: 'FINAL: success' },
+        usage: { total_tokens: 5 }, headers: {},
+      });
+
+    try {
+      const result = await turnLoop(browser, baseMessages(), 2, 0, 0, {}, { steps: [], missionName: 'demo' });
+      expect(shared.chatMock.mock.calls.map(([request]) => request.model)).toEqual(['stub-model', 'stub-fast', 'stub-model']);
+      expect(result.steps[1].modelRouting).toMatchObject({ fallback: true, selectedModel: 'stub-model' });
+      expect(result.steps[1].events).toContain('↩️ Jev route fallback to stub-model');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('forces a routed action retry back onto the primary model', async () => {
+    process.env.TESTRONAUT_JEV_ROUTING = 'live';
+    process.env.TESTRONAUT_JEV_FAST_MODEL = 'stub-fast';
+    process.env.TESTRONAUT_JEV_API_KEY = 'test-key';
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        model: 'jev-test',
+        answers: {
+          modelRoute: { type: 'choice', choice: 'fast_model', confidence: 0.2, probabilities: { fast_model: 0.55 } },
+          missionStage: { type: 'choice', choice: 'interact' },
+          recoveryRoute: { type: 'choice', choice: 'continue' },
+        },
+        usage: { input_tokens: 50, output_tokens: 2 },
+      }),
+    }));
+    shared.chromeToolSpies.click_text
+      .mockResolvedValueOnce(JSON.stringify({ ok: true }))
+      .mockRejectedValueOnce(new Error('temporary click failure'));
+    const toolResponse = id => ({
+      message: {
+        role: 'assistant', content: '',
+        tool_calls: [{ id, type: 'function', function: { name: 'click_text', arguments: '{"text":"Continue"}' } }],
+      },
+      usage: { total_tokens: 10 }, headers: {},
+    });
+    shared.chatMock
+      .mockResolvedValueOnce(toolResponse('primary_action'))
+      .mockResolvedValueOnce(toolResponse('fast_action'))
+      .mockResolvedValueOnce({
+        message: { role: 'assistant', content: 'FINAL: success' },
+        usage: { total_tokens: 5 }, headers: {},
+      });
+
+    try {
+      const result = await turnLoop(browser, baseMessages(), 3, 0, 0, {}, { steps: [], missionName: 'demo' });
+      expect(result.success).toBe(true);
+      expect(shared.chatMock.mock.calls.map(([request]) => request.model)).toEqual(['stub-model', 'stub-fast', 'stub-model']);
+      expect(result.steps[2].modelRouting).toMatchObject({
+        applied: false,
+        forcedPrimaryRetry: true,
+        reason: 'routed_retry_primary',
+        selectedModel: 'stub-model',
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('allows the opt-in Jev gate to finish after strong browser evidence', async () => {
+    process.env.TESTRONAUT_JEV_GATE = '1';
+    process.env.TESTRONAUT_JEV_API_KEY = 'test-key';
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        model: 'jev-test',
+        answers: {
+          missionComplete: { type: 'noul', noul: 0.91 },
+          progressState: { type: 'choice', choice: 'complete', confidence: 0.9, probabilities: { complete: 0.92 } },
+          nextCompute: { type: 'choice', choice: 'finish', confidence: 0.9, probabilities: { finish: 0.93 } },
+        },
+        usage: { input_tokens: 75, output_tokens: 2 },
+      }),
+    }));
+    shared.chromeToolSpies.get_dom.mockResolvedValueOnce('<html><title>Dashboard</title><h1>Mission complete</h1></html>');
+    shared.chromeToolSpies.screenshot.mockResolvedValueOnce('Screenshot saved at: ./screenshots/jev-gate.png');
+    shared.chatMock.mockResolvedValueOnce({
+      message: {
+        role: 'assistant',
+        content: '',
+        tool_calls: [{
+          id: 'tool_gate',
+          type: 'function',
+          function: { name: 'click_text', arguments: '{"text":"Sign in"}' },
+        }],
+      },
+      usage: { total_tokens: 10 },
+      headers: {},
+    });
+
+    try {
+      const result = await turnLoop(browser, baseMessages(), 5, 0, 0, {}, {
+        steps: [],
+        missionName: 'demo',
+        goal: 'Reach the dashboard',
+      });
+
+      expect(result).toMatchObject({ success: true, completedBy: 'jev_gate' });
+      expect(shared.chatMock).toHaveBeenCalledTimes(1);
+      expect(shared.chromeToolSpies.screenshot).toHaveBeenCalledTimes(1);
+      expect(result.steps[0]).toMatchObject({
+        result: '✅ Mission Success (Jev gate)',
+        screenshotPath: './screenshots/jev-gate.png',
+        jevGate: { triggered: true, candidate: true, threshold: 0.8 },
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+      delete process.env.TESTRONAUT_JEV_GATE;
+      delete process.env.TESTRONAUT_JEV_API_KEY;
+    }
+  });
+
+  it('fails open to the normal loop when gate finalization cannot capture a screenshot', async () => {
+    process.env.TESTRONAUT_JEV_GATE = '1';
+    process.env.TESTRONAUT_JEV_API_KEY = 'test-key';
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        model: 'jev-test',
+        answers: {
+          missionComplete: { type: 'noul', noul: 0.91 },
+          progressState: { type: 'choice', choice: 'complete', confidence: 0.9, probabilities: { complete: 0.92 } },
+          nextCompute: { type: 'choice', choice: 'finish', confidence: 0.9, probabilities: { finish: 0.93 } },
+        },
+        usage: { input_tokens: 75, output_tokens: 2 },
+      }),
+    }));
+    shared.chromeToolSpies.get_dom.mockResolvedValueOnce('<html><title>Dashboard</title><h1>Mission complete</h1></html>');
+    shared.chromeToolSpies.screenshot.mockRejectedValueOnce(new Error('disk unavailable'));
+    shared.chatMock
+      .mockResolvedValueOnce({
+        message: {
+          role: 'assistant',
+          content: '',
+          tool_calls: [{
+            id: 'tool_gate_fail_open',
+            type: 'function',
+            function: { name: 'click_text', arguments: '{"text":"Sign in"}' },
+          }],
+        },
+        usage: { total_tokens: 10 },
+        headers: {},
+      })
+      .mockResolvedValueOnce({
+        message: { role: 'assistant', content: 'FINAL: success' },
+        usage: { total_tokens: 10 },
+        headers: {},
+      });
+
+    try {
+      const result = await turnLoop(browser, baseMessages(), 5, 0, 0, {}, {
+        steps: [],
+        missionName: 'demo',
+        goal: 'Reach the dashboard',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.completedBy).toBeUndefined();
+      expect(shared.chatMock).toHaveBeenCalledTimes(2);
+      expect(result.steps[0].jevGate).toMatchObject({
+        triggered: false,
+        reason: 'screenshot_failed',
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+      delete process.env.TESTRONAUT_JEV_GATE;
+      delete process.env.TESTRONAUT_JEV_API_KEY;
+    }
+  });
+
   it('executes a tool call, injects DOM, then finishes on next turn', async () => {
     shared.chatMock.mockResolvedValueOnce({
       message: {

package/tests/experimentTests/buildOptimizationDataPackage.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { __dataPackageInternals } from '../../experiments/buildOptimizationDataPackage.js';
+
+describe('optimization data package statistics', () => {
+  it('calculates sample statistics', () => {
+    expect(__dataPackageInternals.mean([1, 2, 3])).toBe(2);
+    expect(__dataPackageInternals.sampleSd([1, 2, 3])).toBe(1);
+  });
+
+  it('calculates paired percentage deltas by block', () => {
+    const condition = [
+      { block: 1, tokens: 80 }, { block: 2, tokens: 160 },
+      { block: 3, tokens: 240 }, { block: 4, tokens: 320 }, { block: 5, tokens: 400 },
+    ];
+    const control = [
+      { block: 1, tokens: 100 }, { block: 2, tokens: 200 },
+      { block: 3, tokens: 300 }, { block: 4, tokens: 400 }, { block: 5, tokens: 500 },
+    ];
+    expect(__dataPackageInternals.pairedDelta(condition, control, 'tokens')).toEqual({
+      average: -20,
+      low: -20,
+      high: -20,
+    });
+  });
+});

package/tests/experimentTests/crossProviderBenchmark.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { CROSS_PROVIDER_CONDITIONS, buildCrossProviderSchedule, commandForCrossProviderRun, interpretSelection } from '../../experiments/crossProviderBenchmark.js';
+
+describe('cross-provider benchmark', () => {
+  it('builds 120 deterministic isolated mission executions', () => {
+    const first = buildCrossProviderSchedule();
+    const repeat = buildCrossProviderSchedule();
+    expect(first).toHaveLength(120);
+    expect(first.map(run => run.key)).toEqual(repeat.map(run => run.key));
+    for (let block = 1; block <= 5; block += 1) {
+      expect(first.filter(run => run.block === block)).toHaveLength(24);
+    }
+  });
+
+  it('limits portfolios to two models and crosses providers', () => {
+    for (const condition of CROSS_PROVIDER_CONDITIONS) expect(condition.candidates.length).toBeLessThanOrEqual(2);
+    for (const condition of CROSS_PROVIDER_CONDITIONS.filter(item => item.id.startsWith('x'))) {
+      expect(new Set(condition.candidates.map(item => item.provider)).size).toBe(2);
+    }
+  });
+
+  it('uses a sufficiently confident Jev selection and otherwise falls back', () => {
+    const candidates = CROSS_PROVIDER_CONDITIONS.find(item => item.id.startsWith('x')).candidates;
+    const chosen = interpretSelection({ status: 'ok', answers: { executionModel: { choice: 'model_2', probabilities: { model_2: 0.8 } } } }, candidates);
+    expect(chosen).toMatchObject({ selected: candidates[1], selectedBy: 'jev', score: 0.8 });
+    const fallback = interpretSelection({ status: 'ok', answers: { executionModel: { choice: 'model_2', probabilities: { model_2: 0.4 } } } }, candidates);
+    expect(fallback).toMatchObject({ selected: candidates[0], selectedBy: 'fallback' });
+  });
+
+  it('runs one mission with guardrails and no intra-mission fast model', () => {
+    const run = buildCrossProviderSchedule({ repetitions: 1 })[0];
+    const selection = { selected: run.candidates[0] };
+    const invocation = commandForCrossProviderRun(run, selection, '/cli.js');
+    expect(invocation.args).toEqual(['/cli.js', `--provider=${selection.selected.provider}`, `--model=${selection.selected.model}`, '--optimize=tokens', '--optimization-mode=live', run.mission]);
+    expect(invocation.args.filter(arg => arg.endsWith('.mission.js'))).toHaveLength(1);
+  });
+});

package/tests/experimentTests/optimizationBenchmark.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import { BENCHMARK_TARGETS, buildBenchmarkSchedule, commandForRun } from '../../experiments/optimizationBenchmark.js';
+
+describe('optimization benchmark matrix', () => {
+  it('builds seven conditions and five blocked repetitions per repository', () => {
+    const schedule = buildBenchmarkSchedule();
+    expect(schedule).toHaveLength(70);
+    expect(schedule.filter(run => run.target === 'openai')).toHaveLength(35);
+    expect(schedule.filter(run => run.target === 'gemini')).toHaveLength(35);
+    for (const target of ['openai', 'gemini']) {
+      for (let block = 1; block <= 5; block += 1) {
+        const runs = schedule.filter(run => run.target === target && run.block === block);
+        expect(runs).toHaveLength(7);
+        expect(new Set(runs.map(run => run.id)).size).toBe(7);
+      }
+    }
+  });
+
+  it('is deterministically randomized by seed', () => {
+    const first = buildBenchmarkSchedule({ repetitions: 2, seed: 'one' }).map(run => run.key);
+    const repeat = buildBenchmarkSchedule({ repetitions: 2, seed: 'one' }).map(run => run.key);
+    const other = buildBenchmarkSchedule({ repetitions: 2, seed: 'two' }).map(run => run.key);
+    expect(first).toEqual(repeat);
+    expect(first).not.toEqual(other);
+  });
+
+  it('keeps routed conditions to exactly two execution models', () => {
+    for (const target of Object.values(BENCHMARK_TARGETS)) {
+      for (const condition of target.conditions) {
+        expect([condition.primary, condition.secondary].filter(Boolean).length).toBeLessThanOrEqual(2);
+      }
+    }
+  });
+
+  it('constructs explicit, reproducible CLI arguments', () => {
+    const run = buildBenchmarkSchedule({ repetitions: 1, targets: ['openai'] })
+      .find(item => item.id === 'l4_terra_gpt55');
+    const invocation = commandForRun(run, '/cli/bin.js');
+    expect(invocation.args).toEqual(expect.arrayContaining([
+      '/cli/bin.js', '--provider=openai', '--model=gpt-5.6-terra',
+      '--optimize=cost', '--optimization-mode=live', 'missions/login.mission.js',
+    ]));
+    expect(invocation.env).toMatchObject({
+      TESTRONAUT_JEV_FAST_MODEL: 'gpt-5.5',
+      TESTRONAUT_JEV_ROUTING_THRESHOLD: '0.4',
+      TESTRONAUT_BETA_MODEL_ROUTING: '1',
+    });
+  });
+});

package/tests/toolsTests/generateHtmlReport.test.js

@@ -18,6 +18,26 @@ afterEach(() => {
 });
 
 describe('generateHtmlReport', () => {
+  it('renders explicit suite, mission, and turn durations', () => {
+    const report = {
+      runId: 'timed_run',
+      durationMs: 6500,
+      missions: [{
+        missionName: 'Timed Mission',
+        submissionType: 'mission',
+        status: 'passed',
+        durationMs: 2500,
+        steps: [{ turn: 0, result: '✅ Mission Success', durationMs: 1250 }],
+      }],
+    };
+    const outPath = path.join(tmpDir, 'timed.html');
+    generateHtmlReport(report, outPath);
+    const html = fs.readFileSync(outPath, 'utf8');
+    expect(html).toContain('<strong>Duration:</strong> 6.50s');
+    expect(html).toContain('duration: 2.50s');
+    expect(html).toContain('Turn 1 • 1.25s');
+  });
+
   it('writes an HTML report containing mission and retry metadata', () => {
     const report = {
       runId: 'run_test',
@@ -116,4 +136,84 @@ describe('generateHtmlReport', () => {
     expect(html).toContain('<strong>gpt-5.6</strong>');
     expect(html).not.toContain('<strong>LLM:</strong>');
   });
+
+  it('renders run, mission, and step Jev token spend', () => {
+    const steps = [{
+      turn: 0,
+      result: '✅ Mission Success (Jev gate)',
+      tokensUsed: 500,
+      inputTokens: 450,
+      outputTokens: 50,
+      events: [],
+      jevShadow: {
+        status: 'ok',
+        usage: { input_tokens: 1000, output_tokens: 25 },
+        latencyMs: 100,
+        completionGate: { candidate: true },
+      },
+      jevGate: { triggered: true },
+    }];
+    const outPath = path.join(tmpDir, 'jev.html');
+    generateHtmlReport({
+      runId: 'jev_run',
+      llm: { provider: 'openai', model: 'gpt-5.6-terra' },
+      summary: { totalMissions: 1, passed: 1, failed: 0 },
+      jevShadow: {
+        evaluations: 1,
+        completed: 1,
+        errors: 0,
+        skipped: 0,
+        inputTokens: 1000,
+        outputTokens: 25,
+        estimatedInputCostUsd: 0.000042,
+      },
+      missions: [{ missionName: 'Jev Mission', status: 'passed', steps }],
+    }, outPath);
+
+    const html = fs.readFileSync(outPath, 'utf8');
+    expect(html).toContain('<strong>gpt-5.6-terra</strong>');
+    expect(html).toContain('title="Jev"');
+    expect(html).toContain('<strong>Jev</strong>');
+    expect(html).toContain('Model tokens: 500 (450 in / 50 out)');
+    expect(html).toContain('Jev tokens: 1,000 in / 25 out');
+    expect(html).toContain('Jev: 1,000 in / 25 out');
+    expect(html).not.toContain('estimated spend');
+    expect(html).not.toContain('est. $');
+    expect(html).not.toContain('strategy eval');
+  });
+
+  it('breaks dynamically routed token usage down by model', () => {
+    const outPath = path.join(tmpDir, 'routed.html');
+    generateHtmlReport({
+      runId: 'routed_run',
+      llm: { provider: 'openai', model: 'gpt-5.6-terra' },
+      optimization: { configured: true, objective: 'cost', mode: 'live' },
+      missions: [{
+        missionName: 'Routed Mission', status: 'passed', steps: [
+          { turn: 0, model: 'gpt-5.6-terra', tokensUsed: 100, inputTokens: 90, outputTokens: 10, result: '✅ Passed' },
+          { turn: 1, model: 'gpt-5.6-luna', tokensUsed: 40, inputTokens: 35, outputTokens: 5, result: '✅ Passed', modelRouting: { applied: true } },
+        ],
+      }],
+    }, outPath);
+
+    const html = fs.readFileSync(outPath, 'utf8');
+    expect(html).toContain('<strong>gpt-5.6-terra + gpt-5.6-luna</strong>');
+    expect(html).toContain('gpt-5.6-terra tokens: 100 (90 in / 10 out)');
+    expect(html).toContain('gpt-5.6-luna tokens: 40 (35 in / 5 out)');
+    expect(html).toContain('By model: gpt-5.6-terra 100 / gpt-5.6-luna 40');
+    expect(html).toContain('routed by Jev');
+    expect(html).toContain('Optimization: cost (live)');
+  });
+
+  it('makes skipped Jev evaluations visible', () => {
+    const outPath = path.join(tmpDir, 'jev-skipped.html');
+    generateHtmlReport({
+      runId: 'jev_skipped',
+      jevShadow: { evaluations: 3, completed: 0, errors: 0, skipped: 3, inputTokens: 0, outputTokens: 0 },
+    }, outPath);
+
+    const html = fs.readFileSync(outPath, 'utf8');
+    expect(html).toContain('Jev skipped: 3');
+    expect(html).not.toContain('Jev estimated spend:');
+  });
 });