@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/smoke-autofire-100-prompts.mjs

@@ -0,0 +1,481 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import {
+  ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+  ARIA_CODEX_UNIVERSAL_MAPPING_FLOOR,
+  ARIA_CODEX_UNIVERSAL_PRIMITIVE_FLOOR,
+  ARIA_CODEX_UNIVERSAL_RUNTIME_FLOOR,
+  inferSessionId,
+  loadTurnState,
+} from '../hooks/codex-native/lib/runtime-client.mjs';
+
+const repoRoot = process.cwd();
+const now = new Date();
+const runId = now.toISOString().replace(/[:.]/g, '-');
+const outputRoot = path.join(repoRoot, 'artifacts', 'autofire-smoke', runId);
+const screenshotDir = path.join(outputRoot, 'screenshots');
+const hookPath = process.env.ARIA_AUTOFIRE_SMOKE_HOOK || path.join(os.homedir(), '.codex', 'hooks', 'aria-userprompt-submit.mjs');
+const promptInstructionRx = /\b(?:fire|skill|skills|autofire|qiyas|tadabbur|runtime|runtimes|load|autoload|packet|hook)\b/i;
+const floor = {
+  prompts: 100,
+  skill: ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+  runtime: ARIA_CODEX_UNIVERSAL_RUNTIME_FLOOR,
+  primitive: ARIA_CODEX_UNIVERSAL_PRIMITIVE_FLOOR,
+  mapping: ARIA_CODEX_UNIVERSAL_MAPPING_FLOOR,
+  qiyas: 15,
+  tadabbur: 12,
+  noor: 14,
+};
+
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 0o755 });
+}
+
+function sha256(value) {
+  return createHash('sha256').update(typeof value === 'string' ? value : JSON.stringify(value)).digest('hex');
+}
+
+function percentile(values, p) {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
+  return sorted[index];
+}
+
+function safeJsonParse(raw) {
+  try {
+    return raw && raw.trim() ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function htmlEscape(value) {
+  return String(value ?? '')
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+function buildPrompts() {
+  const domains = [
+    'API handler review',
+    'deployment incident triage',
+    'owner status update',
+    'database migration review',
+    'queue worker diagnosis',
+    'security review',
+    'test plan design',
+    'product decision memo',
+    'research synthesis',
+    'connector design',
+    'documentation rewrite',
+    'observability review',
+    'release readiness note',
+    'customer support escalation',
+    'architecture comparison',
+    'billing workflow audit',
+    'onboarding flow critique',
+    'data pipeline diagnosis',
+    'error handling review',
+    'team execution review',
+  ];
+  const tasks = [
+    'Identify the safest next action and the evidence needed before claiming success.',
+    'Find the highest-risk failure mode and name a verification step.',
+    'Rewrite the response so an owner can understand status, evidence, and next action.',
+    'Compare two implementation paths and choose the lower-risk path with reasons.',
+    'List concrete checks that would catch a false success claim.',
+  ];
+  const prompts = [];
+  for (const domain of domains) {
+    for (const task of tasks) {
+      prompts.push(`${domain}: ${task}`);
+    }
+  }
+  if (prompts.length !== 100) throw new Error(`prompt fixture expected 100 prompts, got ${prompts.length}`);
+  const explicit = prompts.filter((prompt) => promptInstructionRx.test(prompt));
+  if (explicit.length) throw new Error(`prompt fixture contains explicit trigger terms: ${explicit.join(' | ')}`);
+  return prompts;
+}
+
+function turnStatePath(sessionId) {
+  const safe = String(sessionId || 'codex').replace(/[^a-zA-Z0-9._-]+/g, '_');
+  return path.join(os.homedir(), '.codex', 'tmp', 'aria-hook-turn-state', `${safe}.json`);
+}
+
+function packetPath(sessionId) {
+  const safe = String(sessionId || 'codex').replace(/[^a-zA-Z0-9._-]+/g, '_');
+  return path.join(os.homedir(), '.codex', 'tmp', 'aria-turn-substrate-packets', `${safe}.json`);
+}
+
+function extractCounts(state) {
+  const forced = state?.forcedSkillLoad || state?.readiness?.forcedSkillLoad || {};
+  const receipt = forced?.skillExecutionReceipt || {};
+  const fired = Array.isArray(receipt.executedSkillIds) && receipt.executedSkillIds.length
+    ? receipt.executedSkillIds
+    : Array.isArray(receipt.firedSkillIds) ? receipt.firedSkillIds : [];
+  const cognitive = forced?.cognitiveRuntimeReceipts || receipt?.cognitiveRuntimeReceipts || {};
+  return {
+    status: state?.readiness?.status || null,
+    currentPhase: state?.readiness?.currentPhase || null,
+    forcedSkillLoadEnforced: state?.forcedSkillLoadEnforced === true,
+    universalTurnPacket: state?.universalTurnPacket === true || forced?.universalTurnPacket === true,
+    skillExecutionMode: forced?.skillExecutionMode || receipt?.mode || null,
+    firedSkillCount: fired.length,
+    activeRuntimeCount: Array.isArray(forced?.activeRuntimes) ? forced.activeRuntimes.length : 0,
+    activePrimitiveCount: Array.isArray(forced?.activePrimitives) ? forced.activePrimitives.length : 0,
+    activeMappingCount: Array.isArray(forced?.activeMappings) ? forced.activeMappings.length : 0,
+    qaSkillCount: Array.isArray(forced?.qaSkills) ? forced.qaSkills.length : 0,
+    correctionSkillCount: Array.isArray(forced?.correctionSkills) ? forced.correctionSkills.length : 0,
+    qiyasPerspectiveCount: Number(cognitive?.qiyas?.perspectiveCount || 0),
+    tadabburStageCount: Number(cognitive?.tadabbur?.stageCount || 0),
+    noorSuiteCount: Number(cognitive?.noor?.noorSuiteCount || 0),
+    fullSkillBodiesInjected: forced?.fullSkillBodiesInjected === true,
+    promptChars: Number(forced?.promptChars || 0),
+    receiptHash: receipt?.receiptHash || null,
+    substrateExecutionHash: receipt?.substrateKernelExecution?.executionHash || forced?.substrateKernelExecution?.executionHash || null,
+    actionLedgerEventCount: Number(state?.actionLedger?.eventCount || 0),
+    actionLedgerLatestEventHash: state?.actionLedger?.latestEventHash || null,
+    statePath: null,
+    packetPath: null,
+  };
+}
+
+function promptPasses(row) {
+  const c = row.counts;
+  const failures = [];
+  if (row.exitCode !== 0) failures.push(`hook exit ${row.exitCode}`);
+  if (row.explicitTriggerInstruction) failures.push('prompt included explicit trigger wording');
+  if (c.status !== 'ready') failures.push(`readiness status ${c.status || 'missing'}`);
+  if (c.skillExecutionMode !== 'mechanical-receipt') failures.push(`mode ${c.skillExecutionMode || 'missing'}`);
+  if (c.firedSkillCount < floor.skill) failures.push(`skills ${c.firedSkillCount}/${floor.skill}`);
+  if (c.activeRuntimeCount < floor.runtime) failures.push(`runtimes ${c.activeRuntimeCount}/${floor.runtime}`);
+  if (c.activePrimitiveCount < floor.primitive) failures.push(`primitives ${c.activePrimitiveCount}/${floor.primitive}`);
+  if (c.activeMappingCount < floor.mapping) failures.push(`mappings ${c.activeMappingCount}/${floor.mapping}`);
+  if (c.qiyasPerspectiveCount < floor.qiyas) failures.push(`qiyas ${c.qiyasPerspectiveCount}/${floor.qiyas}`);
+  if (c.tadabburStageCount < floor.tadabbur) failures.push(`tadabbur ${c.tadabburStageCount}/${floor.tadabbur}`);
+  if (c.noorSuiteCount < floor.noor) failures.push(`noor ${c.noorSuiteCount}/${floor.noor}`);
+  if (c.fullSkillBodiesInjected) failures.push('full skill bodies entered provider context');
+  if (!existsSync(c.statePath || '')) failures.push('state file missing');
+  if (!existsSync(c.packetPath || '')) failures.push('turn substrate packet missing');
+  return failures;
+}
+
+function writeSvgCard(filePath, title, rows, status) {
+  const width = 1280;
+  const height = 720;
+  const accent = status === 'pass' ? '#0f766e' : status === 'partial' ? '#b45309' : '#b91c1c';
+  const rowText = rows.slice(0, 12).map((row, index) => {
+    const y = 170 + index * 38;
+    return `<text x="72" y="${y}" font-size="25" fill="#172033">${htmlEscape(row.label)}: <tspan font-weight="700">${htmlEscape(row.value)}</tspan></text>`;
+  }).join('\n');
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+  <rect width="1280" height="720" fill="#f8fafc"/>
+  <rect x="42" y="42" width="1196" height="636" rx="14" fill="#ffffff" stroke="#d8dee9"/>
+  <rect x="42" y="42" width="1196" height="18" fill="${accent}"/>
+  <text x="72" y="112" font-family="Inter, Arial, sans-serif" font-size="42" font-weight="800" fill="#0f172a">${htmlEscape(title)}</text>
+  <text x="72" y="148" font-family="Inter, Arial, sans-serif" font-size="20" fill="#475569">Generated from local smoke metrics, not illustrative sample data.</text>
+  <g font-family="Inter, Arial, sans-serif">${rowText}</g>
+  <text x="72" y="642" font-family="Inter, Arial, sans-serif" font-size="18" fill="#64748b">run_id=${htmlEscape(runId)}</text>
+</svg>`;
+  writeFileSync(filePath, svg);
+}
+
+function renderHtml(summary, promptRows, qaArtifact) {
+  const statusClass = summary.pass ? 'pass' : 'partial';
+  const rows = promptRows.slice(0, 100).map((row) => `<tr>
+    <td>${row.index}</td>
+    <td>${htmlEscape(row.prompt)}</td>
+    <td>${row.pass ? 'pass' : 'fail'}</td>
+    <td>${row.durationMs}</td>
+    <td>${row.counts.firedSkillCount}</td>
+    <td>${row.counts.activeRuntimeCount}</td>
+    <td>${row.counts.activePrimitiveCount}</td>
+    <td>${row.counts.activeMappingCount}</td>
+    <td>${htmlEscape(row.failures.join('; ') || 'none')}</td>
+  </tr>`).join('\n');
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Aria Autofire 100-Prompt Smoke ${htmlEscape(runId)}</title>
+  <style>
+    :root { color-scheme: light; font-family: Inter, Arial, sans-serif; }
+    body { margin: 0; background: #f8fafc; color: #0f172a; }
+    main { max-width: 1180px; margin: 0 auto; padding: 42px 28px; }
+    h1 { margin: 0 0 8px; font-size: 42px; letter-spacing: 0; }
+    .lede { color: #475569; margin: 0 0 28px; font-size: 18px; }
+    .status { display: inline-block; padding: 8px 12px; border-radius: 6px; color: #fff; background: ${summary.pass ? '#0f766e' : '#b45309'}; font-weight: 800; }
+    .grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; margin: 24px 0; }
+    .metric { border: 1px solid #d8dee9; border-radius: 8px; padding: 16px; background: white; }
+    .metric b { display: block; font-size: 30px; margin-bottom: 4px; }
+    .metric span { color: #475569; }
+    section { margin: 28px 0; }
+    table { width: 100%; border-collapse: collapse; background: white; border: 1px solid #d8dee9; font-size: 13px; }
+    th, td { text-align: left; padding: 8px 10px; border-bottom: 1px solid #e2e8f0; vertical-align: top; }
+    th { background: #eef2f7; font-size: 12px; text-transform: uppercase; color: #334155; }
+    code { background: #e2e8f0; padding: 2px 5px; border-radius: 4px; }
+    .note { border-left: 4px solid #0f766e; padding: 10px 14px; background: #ecfdf5; }
+  </style>
+</head>
+<body>
+<main>
+  <p class="status">${summary.pass ? 'PASS' : 'PARTIAL'}</p>
+  <h1>Mechanical Autofire Smoke: 100 Ordinary Prompts</h1>
+  <p class="lede">Run ${htmlEscape(runId)} called the live Codex UserPromptSubmit hook before provider execution. Prompt text did not instruct Aria to trigger cognition or load anything.</p>
+  <div class="grid">
+    <div class="metric"><b>${summary.totalPrompts}</b><span>prompts run</span></div>
+    <div class="metric"><b>${summary.passedPrompts}</b><span>passed all floors</span></div>
+    <div class="metric"><b>${summary.blockedPrompts}</b><span>blocked or failed</span></div>
+    <div class="metric"><b>${summary.promptInstructionClean}</b><span>without explicit trigger terms</span></div>
+    <div class="metric"><b>${summary.minFiredSkills}</b><span>minimum fired count</span></div>
+    <div class="metric"><b>${summary.minActiveRuntimes}</b><span>minimum active runtimes</span></div>
+    <div class="metric"><b>${summary.p95DurationMs}ms</b><span>p95 hook duration</span></div>
+    <div class="metric"><b>${summary.fullSkillBodyLeaks}</b><span>full-body prompt leaks</span></div>
+  </div>
+  <section class="note">
+    <strong>Evidence boundary:</strong> this proves mechanical pre-provider hook firing, state save, turn packet write, and floor enforcement. It does not measure final provider answer quality.
+  </section>
+  <section>
+    <h2>Substantive QA Artifact</h2>
+    <p>Artifact status: <code>${htmlEscape(qaArtifact.status)}</code>. Findings: <code>${qaArtifact.findings.length}</code>. Evidence hash: <code>${htmlEscape(qaArtifact.evidenceHash)}</code>.</p>
+  </section>
+  <section>
+    <h2>Prompt-Level Evidence</h2>
+    <table>
+      <thead><tr><th>#</th><th>Prompt</th><th>Status</th><th>ms</th><th>Skills</th><th>Runs</th><th>Prims</th><th>Maps</th><th>Failures</th></tr></thead>
+      <tbody>${rows}</tbody>
+    </table>
+  </section>
+</main>
+</body>
+</html>`;
+}
+
+function maybeScreenshot(htmlPath, pngPath) {
+  const browser = ['/home/hamzaibrahim1/.local/bin/chromium-browser', '/home/hamzaibrahim1/.local/bin/chromium', '/home/hamzaibrahim1/.local/bin/google-chrome']
+    .find((candidate) => existsSync(candidate));
+  if (!browser) return { ok: false, reason: 'chromium browser not found' };
+  const result = spawnSync(browser, [
+    '--headless=new',
+    '--no-sandbox',
+    '--disable-gpu',
+    '--window-size=1440,1600',
+    `--screenshot=${pngPath}`,
+    `file://${htmlPath}`,
+  ], { encoding: 'utf8' });
+  return {
+    ok: result.status === 0 && existsSync(pngPath),
+    browser,
+    exitCode: result.status,
+    stderr: result.stderr?.slice(0, 2000) || '',
+  };
+}
+
+async function main() {
+  if (!existsSync(hookPath)) throw new Error(`live hook not found: ${hookPath}`);
+  ensureDir(outputRoot);
+  ensureDir(screenshotDir);
+
+  const prompts = buildPrompts();
+  const rows = [];
+  const metricsJsonl = path.join(outputRoot, 'metrics.jsonl');
+
+  for (let i = 0; i < prompts.length; i += 1) {
+    const prompt = prompts[i];
+    const event = {
+      hook_event_name: 'UserPromptSubmit',
+      thread_id: `autofire-smoke-${runId}`,
+      turn_id: `prompt-${String(i + 1).padStart(3, '0')}`,
+      prompt,
+      cwd: repoRoot,
+    };
+    const sessionId = inferSessionId(event);
+    const started = Date.now();
+    const child = spawnSync(process.execPath, [hookPath], {
+      cwd: repoRoot,
+      input: JSON.stringify(event),
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        ARIA_REMOTE_COACH_ENABLED: '0',
+        ARIA_CODEX_TICKER_STDERR: '0',
+      },
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    const durationMs = Date.now() - started;
+    const state = loadTurnState(sessionId);
+    const counts = extractCounts(state);
+    counts.statePath = turnStatePath(sessionId);
+    counts.packetPath = packetPath(sessionId);
+    const parsedStdout = safeJsonParse(child.stdout);
+    const row = {
+      index: i + 1,
+      prompt,
+      promptSha256: sha256(prompt),
+      explicitTriggerInstruction: promptInstructionRx.test(prompt),
+      sessionId,
+      durationMs,
+      exitCode: child.status,
+      signal: child.signal || null,
+      stdoutJsonOk: parsedStdout !== null,
+      stdoutSha256: sha256(child.stdout || ''),
+      stderrSha256: sha256(child.stderr || ''),
+      stdoutPreview: (child.stdout || '').slice(0, 600),
+      stderrPreview: (child.stderr || '').slice(0, 600),
+      counts,
+      pass: false,
+      failures: [],
+    };
+    row.failures = promptPasses(row);
+    row.pass = row.failures.length === 0;
+    rows.push(row);
+    writeFileSync(metricsJsonl, JSON.stringify(row) + '\n', { flag: 'a', mode: 0o644 });
+    process.stdout.write(JSON.stringify({ index: row.index, pass: row.pass, durationMs, firedSkillCount: counts.firedSkillCount, runtimes: counts.activeRuntimeCount, failures: row.failures }) + '\n');
+  }
+
+  const durations = rows.map((row) => row.durationMs);
+  const summary = {
+    schema: 'aria.autofire_100_prompt_smoke.v1',
+    runId,
+    generatedAt: new Date().toISOString(),
+    hookPath,
+    evidenceBoundary: 'Mechanical pre-provider Codex UserPromptSubmit autofire smoke; provider answer quality is not measured by this artifact.',
+    floors: floor,
+    totalPrompts: rows.length,
+    passedPrompts: rows.filter((row) => row.pass).length,
+    blockedPrompts: rows.filter((row) => row.exitCode !== 0).length,
+    failedFloorPrompts: rows.filter((row) => row.exitCode === 0 && !row.pass).length,
+    promptInstructionClean: rows.filter((row) => !row.explicitTriggerInstruction).length,
+    promptInstructionViolations: rows.filter((row) => row.explicitTriggerInstruction).length,
+    fullSkillBodyLeaks: rows.filter((row) => row.counts.fullSkillBodiesInjected).length,
+    savedStateFiles: rows.filter((row) => existsSync(row.counts.statePath)).length,
+    savedTurnPackets: rows.filter((row) => existsSync(row.counts.packetPath)).length,
+    minFiredSkills: Math.min(...rows.map((row) => row.counts.firedSkillCount)),
+    minActiveRuntimes: Math.min(...rows.map((row) => row.counts.activeRuntimeCount)),
+    minActivePrimitives: Math.min(...rows.map((row) => row.counts.activePrimitiveCount)),
+    minActiveMappings: Math.min(...rows.map((row) => row.counts.activeMappingCount)),
+    minQiyasPerspectives: Math.min(...rows.map((row) => row.counts.qiyasPerspectiveCount)),
+    minTadabburStages: Math.min(...rows.map((row) => row.counts.tadabburStageCount)),
+    minNoorSuite: Math.min(...rows.map((row) => row.counts.noorSuiteCount)),
+    p50DurationMs: percentile(durations, 50),
+    p95DurationMs: percentile(durations, 95),
+    maxDurationMs: Math.max(...durations),
+    pass: false,
+  };
+  summary.pass = summary.totalPrompts === floor.prompts
+    && summary.passedPrompts === floor.prompts
+    && summary.promptInstructionClean === floor.prompts
+    && summary.fullSkillBodyLeaks === 0
+    && summary.savedStateFiles === floor.prompts
+    && summary.savedTurnPackets === floor.prompts;
+
+  const qaArtifact = {
+    schema: 'aria.autofire_smoke_substantive_qa.v1',
+    runId,
+    status: summary.pass ? 'pass' : 'partial',
+    requirement: 'Substantive QA artifact must bind aggregate verdict to per-prompt evidence, floor counts, saved state files, saved turn packets, and explicit boundary language.',
+    findings: [
+      `Mechanical autofire evidence is prompt-independent because ${summary.promptInstructionClean}/${summary.totalPrompts} prompts avoided trigger terms while the live hook still recorded mechanical receipt counts.`,
+      `State persistence evidence is concrete: ${summary.savedStateFiles}/${summary.totalPrompts} turn state files and ${summary.savedTurnPackets}/${summary.totalPrompts} turn substrate packets existed after hook execution.`,
+      `Floor evidence is numeric: minimum observed counts were skills=${summary.minFiredSkills}, runtimes=${summary.minActiveRuntimes}, primitives=${summary.minActivePrimitives}, mappings=${summary.minActiveMappings}, qiyas=${summary.minQiyasPerspectives}, tadabbur=${summary.minTadabburStages}, noor=${summary.minNoorSuite}.`,
+      `Marketing evidence is bounded to hook-level behavior with metrics, HTML, SVG, and browser screenshot artifacts; provider answer quality needs a separate live-answer evaluation.`,
+    ],
+    failures: rows.filter((row) => !row.pass).map((row) => ({ index: row.index, failures: row.failures, sessionId: row.sessionId })),
+    evidenceHash: sha256({ summary, rowHashes: rows.map((row) => sha256(row)) }),
+  };
+
+  const metricsPath = path.join(outputRoot, 'metrics.json');
+  const qaPath = path.join(outputRoot, 'substantive-qa-artifact.json');
+  const summaryPath = path.join(outputRoot, 'summary.md');
+  const htmlPath = path.join(outputRoot, 'marketing-report.html');
+  const overviewSvg = path.join(screenshotDir, 'overview.svg');
+  const failuresSvg = path.join(screenshotDir, 'failures.svg');
+  const pngPath = path.join(screenshotDir, 'marketing-report.png');
+
+  writeFileSync(metricsPath, JSON.stringify({ summary, rows }, null, 2) + '\n');
+  writeFileSync(qaPath, JSON.stringify(qaArtifact, null, 2) + '\n');
+  writeFileSync(summaryPath, [
+    `# Aria Autofire 100-Prompt Smoke`,
+    ``,
+    `- run_id: ${runId}`,
+    `- status: ${summary.pass ? 'pass' : 'partial'}`,
+    `- prompts: ${summary.passedPrompts}/${summary.totalPrompts} passed all floors`,
+    `- explicit trigger terms: ${summary.promptInstructionViolations}`,
+    `- saved state files: ${summary.savedStateFiles}/${summary.totalPrompts}`,
+    `- saved turn packets: ${summary.savedTurnPackets}/${summary.totalPrompts}`,
+    `- minimum fired skills: ${summary.minFiredSkills}/${floor.skill}`,
+    `- minimum active runtimes: ${summary.minActiveRuntimes}/${floor.runtime}`,
+    `- minimum active primitives: ${summary.minActivePrimitives}/${floor.primitive}`,
+    `- minimum active mappings: ${summary.minActiveMappings}/${floor.mapping}`,
+    `- p95 hook duration: ${summary.p95DurationMs}ms`,
+    `- evidence boundary: ${summary.evidenceBoundary}`,
+    ``,
+    `## Artifacts`,
+    ``,
+    `- metrics: ${metricsPath}`,
+    `- jsonl: ${metricsJsonl}`,
+    `- qa: ${qaPath}`,
+    `- html: ${htmlPath}`,
+    `- overview svg: ${overviewSvg}`,
+    `- failures svg: ${failuresSvg}`,
+    `- browser screenshot: ${pngPath}`,
+    ``,
+    `## Failures`,
+    ``,
+    qaArtifact.failures.length ? qaArtifact.failures.map((failure) => `- ${failure.index}: ${failure.failures.join('; ')}`).join('\n') : `- none`,
+    ``,
+  ].join('\n'));
+  writeFileSync(htmlPath, renderHtml(summary, rows, qaArtifact));
+  writeSvgCard(overviewSvg, 'Aria Autofire Smoke Evidence', [
+    { label: 'Prompts passed', value: `${summary.passedPrompts}/${summary.totalPrompts}` },
+    { label: 'Explicit trigger terms', value: summary.promptInstructionViolations },
+    { label: 'Minimum fired count', value: `${summary.minFiredSkills}/${floor.skill}` },
+    { label: 'Minimum active runs', value: `${summary.minActiveRuntimes}/${floor.runtime}` },
+    { label: 'Saved state files', value: `${summary.savedStateFiles}/${summary.totalPrompts}` },
+    { label: 'Saved turn packets', value: `${summary.savedTurnPackets}/${summary.totalPrompts}` },
+    { label: 'Full-body leaks', value: summary.fullSkillBodyLeaks },
+    { label: 'p95 hook duration', value: `${summary.p95DurationMs}ms` },
+  ], summary.pass ? 'pass' : 'partial');
+  writeSvgCard(failuresSvg, 'Autofire Smoke Failure Evidence', [
+    { label: 'Blocked or failed exits', value: summary.blockedPrompts },
+    { label: 'Floor failures after release', value: summary.failedFloorPrompts },
+    { label: 'First failure', value: qaArtifact.failures[0] ? `${qaArtifact.failures[0].index}: ${qaArtifact.failures[0].failures.join('; ')}` : 'none' },
+    { label: 'QA artifact', value: qaArtifact.status },
+    { label: 'Evidence hash', value: qaArtifact.evidenceHash.slice(0, 24) },
+  ], summary.pass ? 'pass' : 'partial');
+  const screenshot = maybeScreenshot(htmlPath, pngPath);
+  const finalReport = {
+    ok: summary.pass,
+    summary,
+    artifacts: {
+      outputRoot,
+      metricsPath,
+      metricsJsonl,
+      qaPath,
+      summaryPath,
+      htmlPath,
+      overviewSvg,
+      failuresSvg,
+      pngPath: screenshot.ok ? pngPath : null,
+    },
+    screenshot,
+    qaArtifact,
+  };
+  writeFileSync(path.join(outputRoot, 'run-report.json'), JSON.stringify(finalReport, null, 2) + '\n');
+  process.stdout.write(JSON.stringify(finalReport, null, 2) + '\n');
+  process.exit(summary.pass ? 0 : 1);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack : String(error));
+  process.exit(1);
+});