testronaut 1.12.0 → 1.12.1

package/README.md

@@ -239,6 +239,34 @@ await runMissions({
 }, "Contact Form Flow");
 ```
 
+Control the order of an automatically discovered suite in
+`testronaut-config.json`:
+
+```json
+{
+  "missions": {
+    "include": ["**/*.mission.js"],
+    "order": [
+      "login.mission.js",
+      "account/**/*.mission.js",
+      "*",
+      "logout.mission.js"
+    ]
+  }
+}
+```
+
+Order entries are applied from top to bottom. Each pattern's matches remain
+alphabetical, `*` places missions not claimed by another entry, and unlisted
+missions are appended alphabetically. An exact filename that is not discovered
+produces a warning. Without `missions.order`, discovery remains alphabetical.
+Mission filenames supplied directly on the command line run in argument order.
+
+`maxTurns` counts working turns. If a mission spends the full budget without a
+verdict, Testronaut makes one additional tool-free closure request so the report
+ends with an explicit success or failure. JSON and HTML reports include elapsed
+milliseconds for each turn and mission plus the duration of the complete suite.
+
 ---
 
 ## 🧰 Developer Mode (Staging API)

package/bin/cli.js

@@ -951,7 +951,12 @@ if (args.includes('serve') || args.includes('view')) {
   await new Promise(() => {}); // ✅ never resolves; Ctrl+C will terminate
 }
 
-const { root: missionsRoot, files: discoveredMissions } = await discoverMissionFiles({ cwd: process.cwd() });
+const {
+  root: missionsRoot,
+  files: discoveredMissions,
+  warnings: missionDiscoveryWarnings = [],
+} = await discoverMissionFiles({ cwd: process.cwd() });
+for (const warning of missionDiscoveryWarnings) console.warn(`⚠️ ${warning}`);
 const tagConfig = await loadConfig(process.cwd());
 const optimizationPolicy = resolveOptimizationPolicy({ config: tagConfig });
 if (!optimizationPolicy.valid) {
@@ -1144,14 +1149,19 @@ const runFile = async (filePath) => {
 
     if (typeof missionsModule.executeMission === 'function') {
       if (!jsonOutput) terminalUi.phase('launch', path.relative(process.cwd(), modulePath) || filePath);
+      const missionFileStartTime = Date.now();
       const result = await missionsModule.executeMission();
+      const missionFileEndTime = Date.now();
       if (result == null) {
         console.error(`❌ Mission did not return a result: ${filePath}`);
         return false;
       }
       allResults.push({
         file: path.relative(process.cwd(), modulePath) || path.basename(modulePath),
-        result
+        result,
+        startTime: missionFileStartTime,
+        endTime: missionFileEndTime,
+        durationMs: Math.max(0, missionFileEndTime - missionFileStartTime),
       });
       const missionResults = Array.isArray(result) ? result : [result];
       return !missionResults.some(item => item?.status === 'failed');
@@ -1206,6 +1216,9 @@ const flatMissions = allResults.flatMap(entry => {
       ...m,
       steps,
       file: entry.file,
+      startTime: m.startTime ?? entry.startTime,
+      endTime: m.endTime ?? entry.endTime,
+      durationMs: m.durationMs ?? entry.durationMs,
     };
     const jevShadow = summarizeJevUsage(steps);
     return jevShadow.evaluations ? { ...mission, jevShadow } : mission;
@@ -1226,6 +1239,7 @@ const report = {
   cli: { version: CLI_VERSION },
   startTime: startTime.toISOString(),
   endTime: endTime.toISOString(),
+  durationMs: Math.max(0, endTime.getTime() - startTime.getTime()),
   llm: {
     provider: llmProvider,
     model: llmModel,
@@ -1283,7 +1297,7 @@ fs.writeFileSync(path.join(outputDir, `${runId}.json`), JSON.stringify(report, n
 const htmlReportPath = path.join(outputDir, `${runId}.html`);
 generateHtmlReport(report, htmlReportPath);
 if (jsonOutput) writeOutput(report);
-else terminalUi.summary({ ...report.summary, reportPath: path.relative(process.cwd(), htmlReportPath) });
+else terminalUi.summary({ ...report.summary, durationMs: report.durationMs, reportPath: path.relative(process.cwd(), htmlReportPath) });
 
   try {
     if (!process.env.TN_KEEP_TMP && fs.existsSync(TMP_DIR)) {

package/bin/terminalUi.js

@@ -9,6 +9,12 @@ const ANSI = {
   cream: '\u001b[38;5;230m',
 };
 
+export function formatDuration(durationMs) {
+  if (!Number.isFinite(durationMs)) return null;
+  const seconds = Math.max(0, durationMs) / 1000;
+  return seconds < 60 ? `${seconds.toFixed(2)}s` : `${Math.floor(seconds / 60)}m ${(seconds % 60).toFixed(1)}s`;
+}
+
 export function shouldUseColor(stream = process.stdout, env = process.env) {
   return Boolean(stream?.isTTY) && !('NO_COLOR' in env) && env.TERM !== 'dumb';
 }
@@ -38,13 +44,15 @@ export function createTerminalUi({
       const tagText = tags.length ? paint(ANSI.dim, `  ${tags.map(tag => `#${tag}`).join(' ')}`) : '';
       write(`   ${marker} ${file}${tagText}`);
     },
-    summary({ totalMissions = 0, passed = 0, failed = 0, reportPath }) {
+    summary({ totalMissions = 0, passed = 0, failed = 0, durationMs, reportPath }) {
       const status = failed === 0
         ? paint(`${ANSI.bold}${ANSI.teal}`, 'MISSION COMPLETE')
         : paint(`${ANSI.bold}${ANSI.red}`, 'MISSION NEEDS REVIEW');
       write('');
       write(`${label('COMPLETE')}${status}`);
       write(`   ${paint(ANSI.teal, `${passed} passed`)}  ${paint(failed ? ANSI.red : ANSI.dim, `${failed} failed`)}  ${paint(ANSI.dim, `${totalMissions} total`)}`);
+      const duration = formatDuration(durationMs);
+      if (duration) write(paint(ANSI.dim, `   Duration: ${duration}`));
       if (reportPath) write(paint(ANSI.dim, `   Report: ${reportPath}`));
     },
   };

package/core/agent.js

@@ -59,6 +59,7 @@ export async function runAgent(goals, missionName, maxTurns = 20, retryLimit, op
     const groundControl = createEmptyGroundControl();
 
     for (const goal of goals) {
+      const goalStartTime = Date.now();
       const telemetryStart = groundControl.telemetry.length;
       const steps = [];
       const stepsArchive = [];
@@ -114,6 +115,7 @@ export async function runAgent(goals, missionName, maxTurns = 20, retryLimit, op
             stepFile,
             startTime: now,
             endTime: now,
+            durationMs: 0,
             telemetry: [],
             launchProtocol: { id: protocol.id, status: 'reused', probe: 'passed' },
           });
@@ -289,6 +291,7 @@ Email invitation and magic links:
       }
 
       const compact = dedupeSteps(stepsArchive.length ? stepsArchive : steps);
+      const goalEndTime = Date.now();
 
       // Snapshot steps (avoid retaining references to mutable arrays)
       missionResults.push({
@@ -298,8 +301,9 @@ Email invitation and magic links:
         status: result?.success ? 'passed' : 'failed',
         steps: JSON.parse(JSON.stringify(compact)), // last 20 (by memory design)
         stepFile, // full history is in this JSONL (one step per line)
-        startTime: Date.now() - 1, // TODO: wire actual timings if needed
-        endTime: Date.now(),
+        startTime: goalStartTime,
+        endTime: goalEndTime,
+        durationMs: Math.max(0, goalEndTime - goalStartTime),
         telemetry: JSON.parse(JSON.stringify(groundControl.telemetry.slice(telemetryStart))),
         ...(protocolResult ? { launchProtocol: protocolResult } : {}),
       });

package/core/missionDiscovery.js

@@ -6,6 +6,54 @@ import { loadConfig } from './config.js';
 const DEFAULT_ROOT = 'missions';
 const DEFAULT_INCLUDE = ['**/*.mission.js', '**/*.mission.ts'];
 
+function orderMissionFiles(files, order, root) {
+  const alphabetical = [...files].sort();
+  if (!Array.isArray(order) || order.length === 0) {
+    return { files: alphabetical, warnings: [] };
+  }
+
+  const remaining = new Set(alphabetical);
+  const ordered = [];
+  const warnings = [];
+
+  for (let index = 0; index < order.length; index += 1) {
+    const rawPattern = order[index];
+    const pattern = String(rawPattern ?? '').trim();
+    if (!pattern) continue;
+
+    if (pattern === '*') {
+      const reserved = new Set(order.slice(index + 1).flatMap(laterPattern => {
+        const later = String(laterPattern ?? '').trim();
+        if (!later || later === '*') return [];
+        return fg.sync(later, { cwd: root, onlyFiles: true });
+      }));
+      for (const file of alphabetical) {
+        if (!reserved.has(file) && remaining.delete(file)) ordered.push(file);
+      }
+      continue;
+    }
+
+    const matches = fg.sync(pattern, { cwd: root, onlyFiles: true })
+      .filter(file => remaining.has(file))
+      .sort();
+    for (const file of matches) {
+      remaining.delete(file);
+      ordered.push(file);
+    }
+
+    if (!fg.isDynamicPattern(pattern) && !alphabetical.includes(pattern)) {
+      warnings.push(`Configured mission order entry was not discovered: ${pattern}`);
+    }
+  }
+
+  // A partial order only moves the named groups; all other missions retain
+  // deterministic legacy ordering after the configured entries.
+  for (const file of alphabetical) {
+    if (remaining.delete(file)) ordered.push(file);
+  }
+  return { files: ordered, warnings };
+}
+
 /**
  * Discover mission files based on testronaut-config.json.
  * - When no missions block exists, preserve legacy behavior:
@@ -14,7 +62,7 @@ const DEFAULT_INCLUDE = ['**/*.mission.js', '**/*.mission.ts'];
  *
  * @param {object} opts
  * @param {string} [opts.cwd=process.cwd()] - project root for config + resolution
- * @returns {Promise<{ root:string, files:string[] }>} root is absolute; files are relative to root
+ * @returns {Promise<{ root:string, files:string[], warnings:string[] }>} root is absolute; files are relative to root
  */
 export async function discoverMissionFiles({ cwd = process.cwd() } = {}) {
   const defaultRoot = path.resolve(cwd, DEFAULT_ROOT);
@@ -24,17 +72,17 @@ export async function discoverMissionFiles({ cwd = process.cwd() } = {}) {
   // Legacy behavior remains non-recursive, now with first-class TypeScript support.
   if (!missionsCfg) {
     if (!fs.existsSync(defaultRoot)) {
-      return { root: defaultRoot, files: [] };
+      return { root: defaultRoot, files: [], warnings: [] };
     }
     const files = fs.readdirSync(defaultRoot)
       .filter(f => f.endsWith('.mission.js') || f.endsWith('.mission.ts'))
       .sort();
-    return { root: defaultRoot, files };
+    return { root: defaultRoot, files, warnings: [] };
   }
 
   const root = path.resolve(cwd, missionsCfg.root || DEFAULT_ROOT);
   if (!fs.existsSync(root)) {
-    return { root, files: [] };
+    return { root, files: [], warnings: [] };
   }
 
   const include = Array.isArray(missionsCfg.include) && missionsCfg.include.length
@@ -49,7 +97,9 @@ export async function discoverMissionFiles({ cwd = process.cwd() } = {}) {
   });
 
   const unique = Array.from(new Set(matches));
-  unique.sort();
+  const ordered = orderMissionFiles(unique, missionsCfg.order, root);
 
-  return { root, files: unique };
+  return { root, ...ordered };
 }
+
+export const __test__ = { orderMissionFiles };

package/core/turnLoop.js

@@ -409,6 +409,8 @@ export const turnLoop = async (
   // Idempotent recorder – prevents accidental double-push
   const recordStep = (step) => {
     if (!step || step.__recorded) return;
+    step.endTime = Date.now();
+    step.durationMs = Math.max(0, step.endTime - (step.startTime ?? step.endTime));
     step._seq = stepSeq++;
     step.__recorded = true;
     try { steps.push(step); } catch {}
@@ -427,6 +429,7 @@ export const turnLoop = async (
     const attempt = turnRetries + 1;
     const step = {
       turn,
+      startTime: Date.now(),
       retryAttempt: attempt,
       retryLimit: retryLimitClamped, // number of retries allowed (excludes initial)
       events: [],
@@ -1061,7 +1064,61 @@ export const turnLoop = async (
     turnRetries = 0;
   }
 
-  return { success: false, steps: stepsArchive };
+  // The configured budget covers working turns. Once those are consumed, make
+  // one final tool-free request so every mission ends with an explicit verdict.
+  const closureStep = {
+    turn: maxTurns,
+    startTime: Date.now(),
+    isClosureTurn: true,
+    retryAttempt: 1,
+    retryLimit: 0,
+    events: ['⏱️ Working-turn budget exhausted; requesting final mission verdict.'],
+    result: '🟡 Awaiting Closure',
+    missionName,
+    provider: PROVIDER_ID,
+    model: MODEL_ID,
+  };
+  console.log(`\n🏁 Turn budget exhausted after ${maxTurns} working turn(s). Requesting closure.`);
+  messages.push({
+    role: 'user',
+    content: 'The working-turn budget is exhausted. Do not call tools or continue the task. Based only on the evidence already collected, respond with exactly SUCCESS: followed by a short reason if the goal was achieved, otherwise FAILURE: followed by a short reason.',
+  });
+
+  try {
+    const closureResponse = await llm.chat({ model: MODEL_ID, messages, tools: [] });
+    const msg = closureResponse?.message ?? { role: 'assistant', content: '' };
+    const usage = closureResponse?.usage;
+    if (usage) {
+      closureStep.tokensUsed = usage.total_tokens || 0;
+      closureStep.inputTokens = usage.input_tokens ?? usage.prompt_tokens ?? usage.providerRaw?.input_tokens ?? usage.providerRaw?.prompt_tokens;
+      closureStep.outputTokens = usage.output_tokens ?? usage.completion_tokens ?? usage.providerRaw?.output_tokens ?? usage.providerRaw?.completion_tokens;
+    }
+    closureStep.summary = summarizeTurnIntentFromMessage(msg, { emoji: true });
+    const finalResponse = finalResponseHandler(msg);
+    if (finalResponse) {
+      closureStep.events.push(finalResponse.finalMessage);
+      closureStep.result = finalResponse.success ? '✅ Mission Success' : '❌ Mission Failure';
+      recordStep(closureStep);
+      return {
+        success: finalResponse.success,
+        finalMessage: finalResponse.finalMessage,
+        steps: stepsArchive,
+        completedBy: 'budget_closure',
+      };
+    }
+    closureStep.events.push('FAILURE: The closure response did not provide an explicit SUCCESS or FAILURE verdict.');
+  } catch (error) {
+    closureStep.events.push(`FAILURE: Unable to obtain the closure verdict: ${error?.message || error}`);
+  }
+
+  closureStep.result = '❌ Mission Failure';
+  recordStep(closureStep);
+  return {
+    success: false,
+    finalMessage: closureStep.events.at(-1),
+    steps: stepsArchive,
+    completedBy: 'budget_closure',
+  };
 };
 
 // Expose small helper bundle for unit tests (no production use).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testronaut",
-  "version": "1.12.0",
+  "version": "1.12.1",
   "main": "./runner/testronaut.js",
   "bin": {
     "testronaut": "bin/cli.js"

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

@@ -98,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/missionDiscovery.test.js

@@ -78,4 +78,48 @@ describe('discoverMissionFiles', () => {
     const res = await discoverMissionFiles({ cwd: tmp });
     expect(res.files).toEqual(['keep.mission.js']);
   });
+
+  it('orders configured patterns and places remaining missions at the wildcard', async () => {
+    const tmp = makeTempDir();
+    temps.push(tmp);
+    const missionsDir = path.join(tmp, 'missions');
+    fs.mkdirSync(path.join(missionsDir, 'account'), { recursive: true });
+    for (const file of ['login.mission.js', 'logout.mission.js', 'search.mission.js']) {
+      fs.writeFileSync(path.join(missionsDir, file), '// ok');
+    }
+    fs.writeFileSync(path.join(missionsDir, 'account', 'profile.mission.js'), '// ok');
+
+    writeJson(path.join(tmp, 'testronaut-config.json'), {
+      missions: {
+        include: ['**/*.mission.js'],
+        order: ['login.mission.js', 'account/**/*.mission.js', '*', 'logout.mission.js'],
+      },
+    });
+
+    const res = await discoverMissionFiles({ cwd: tmp });
+    expect(res.files).toEqual([
+      'login.mission.js',
+      'account/profile.mission.js',
+      'search.mission.js',
+      'logout.mission.js',
+    ]);
+  });
+
+  it('warns about missing exact order entries while ignoring unmatched globs', async () => {
+    const tmp = makeTempDir();
+    temps.push(tmp);
+    fs.mkdirSync(path.join(tmp, 'missions'));
+    fs.writeFileSync(path.join(tmp, 'missions', 'actual.mission.js'), '// ok');
+    writeJson(path.join(tmp, 'testronaut-config.json'), {
+      missions: {
+        order: ['missing.mission.js', 'optional/**/*.mission.js', '*'],
+      },
+    });
+
+    const res = await discoverMissionFiles({ cwd: tmp });
+    expect(res.files).toEqual(['actual.mission.js']);
+    expect(res.warnings).toEqual([
+      'Configured mission order entry was not discovered: missing.mission.js',
+    ]);
+  });
 });

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;
     },
@@ -182,6 +182,52 @@ 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';

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',

package/tools/generateHtmlReport.js

@@ -30,8 +30,9 @@ import { summarizeJevUsage } from '../core/jevUsage.js';
 export function generateHtmlReport(report, outputPath) {
   const { runId, startTime, endTime, missions = [], summary = {}, llm = {}, cli = {}, optimization } = report;
   const reportTags = normalizeTags(report.tags ?? missions.flatMap(m => m.submissionType === 'mission' ? (m.tags ?? []) : []));
-  const durationSec =
-    (startTime && endTime)
+  const durationSec = Number.isFinite(report.durationMs)
+    ? (report.durationMs / 1000).toFixed(2)
+    : (startTime && endTime)
       ? ((new Date(endTime) - new Date(startTime)) / 1000).toFixed(2)
       : '—';
 
@@ -91,8 +92,9 @@ export function generateHtmlReport(report, outputPath) {
   const jevLogo = '<svg viewBox="0 0 24 24" role="img" aria-hidden="true"><rect width="24" height="24" rx="4" fill="#e547b5"/><g fill="none" stroke="#181a1b" stroke-width="2.25" stroke-linecap="square" stroke-linejoin="round"><path d="M12 2.5 6.1 6v10.1l3.2 1.9 2.7-1.6V9.6l3-1.8V4.3z"/><path d="m9.3 9.6 2.7 1.6 3-1.8 3 1.8v7L12 21.5l-3-1.8V13z"/><path d="m12 11.2 3 1.8 3-1.8M15 13v5.2l-6 3.3M9.3 9.6 12 8l3 1.8"/></g></svg>';
 
   const submissionBlock = (m) => {
-    const mDurationSec =
-      m.endTime && m.startTime
+    const mDurationSec = Number.isFinite(m.durationMs)
+      ? (m.durationMs / 1000).toFixed(2)
+      : m.endTime && m.startTime
         ? ((m.endTime - m.startTime) / 1000).toFixed(2)
         : (typeof m.durationSeconds === 'number' ? m.durationSeconds.toFixed(2) : '—');
 
@@ -129,6 +131,9 @@ export function generateHtmlReport(report, outputPath) {
         : step.modelRouting?.applied
           ? ' • routed by Jev'
           : '';
+      const stepDuration = Number.isFinite(step.durationMs)
+        ? ` • ${(step.durationMs / 1000).toFixed(2)}s`
+        : '';
 
       const plan = (typeof step.summary === 'string' && step.summary.trim())
         ? step.summary.trim()
@@ -140,7 +145,7 @@ export function generateHtmlReport(report, outputPath) {
       return `
         <details class="step" ${ok ? '' : 'open'}>
           <summary>
-            <span class="turn">Turn ${esc((step.turn ?? idx) + 1)}${esc(attemptLabel)}</span>
+            <span class="turn">${step.isClosureTurn ? 'Closure' : `Turn ${esc((step.turn ?? idx) + 1)}`}${esc(attemptLabel)}${stepDuration}</span>
             ${humanInput}
             ${planSpan}
             <span class="step-result ${ok ? 'ok' : 'bad'}" ${resultTooltip ? `title="${esc(resultTooltip)}"` : ''}>${esc(resultRaw)}</span>