@ngockhoale/ukit 3.0.8 → 3.0.9

package/scripts/bench/decision-runtime-variant.mjs

@@ -0,0 +1,626 @@
+#!/usr/bin/env node
+// TASK-004 (C68 G6) — paired A/B variant runner (SPEC §2 G6-FR04/06, §4, §5).
+//
+// Replays the frozen docs/AI_HANDOFF/benchmark/corpus.yaml through the real
+// G2 supervisor with the G6 policies applied — caller-wait promotion
+// (selectWaitPolicy + DurationProfile) and the resource policy
+// (selectResourcePolicy on every supervisor event) — then compares against a
+// paired baseline report via computeGateComparison and emits a VariantReport:
+//   baseline report shape + { variantId, policy:{promotion,resource},
+//   comparison: GateComparison }.
+//
+// Both arms execute the corpus under the SAME supervisor on the same host so
+// the comparison is truly paired; the baseline arm applies no policies
+// (foreground wait, emit-all). A pre-existing baseline report may be supplied
+// via --baseline but only counts when env fields pair (SPEC §5 environment).
+//
+// Zero external model calls: every wake/token field is 'UNKNOWN' (metric-spec
+// §5 — no provider data source exists; chars/4 estimates are banned).
+// Smoke runs (--runs < 9) are recorded as non-comparable per metric-spec §3.
+//
+// Exit codes: 0 = ran to completion (the verdict is data — a 'non-inferior'
+// verdict means rollback stands, which is itself a valid gate outcome),
+// 2 = malformed corpus/args or harness crash.
+
+import { spawn, execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import yaml from 'yaml';
+
+import { createSupervisor } from '../../src/core/agentRuntime/supervisor.js';
+import { selectWaitPolicy } from '../../src/core/agentRuntime/promotion.js';
+import { selectResourcePolicy } from '../../src/core/agentRuntime/resourcePolicy.js';
+import { computeGateComparison } from '../../src/core/agentRuntime/evaluation.js';
+import {
+  UNKNOWN,
+  computeExternalWakeRate,
+  computeQualityScore,
+  summarizeRuns,
+} from './decision-runtime-metrics.mjs';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const DEFAULT_RUNS = 9;
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_CORPUS = path.join(REPO_ROOT, 'docs/AI_HANDOFF/benchmark/corpus.yaml');
+const ORACLE_TYPES = ['exit-code', 'output-match', 'file-exists'];
+const TERMINAL_TO = new Set(['completed', 'failed', 'cancelled']);
+
+// G6-FR02 DurationProfile — frozen config, thresholds are literal values
+// traceable to docs/AI_HANDOFF/inventory/baseline-report.json latency.p50
+// (reinject-context p50 = 29 ms is the cheapest measured known-transition
+// on this host; promoteAfterMs=29 ≈ the first real decision point where a
+// caller-visible wait can be promoted to a handle). Classes map 1:1 onto
+// corpus `class` fields: multi-step long-known promotes, everything else —
+// including ambiguous/false-completion classes — stays foreground.
+const DURATION_PROFILE = Object.freeze({
+  version: 1,
+  classes: Object.freeze({
+    'long-known': Object.freeze({ promoteAfterMs: 29 }),
+    'short-known': Object.freeze({ promoteAfterMs: null }),
+    'ambiguous-branch': Object.freeze({ promoteAfterMs: null }),
+    'false-completion': Object.freeze({ promoteAfterMs: null }),
+    'unsupported-host': Object.freeze({ promoteAfterMs: null }),
+    'crash-mid-operation': Object.freeze({ promoteAfterMs: null }),
+  }),
+  fallback: 'foreground',
+});
+
+const USAGE = `Usage: node scripts/bench/decision-runtime-variant.mjs [options]
+
+Replays the DR corpus through the supervisor with the G6 promotion/resource
+policies applied, pairs it against a baseline arm, and writes a VariantReport
+with a pre-registered GateComparison (pass | non-inferior | unknown).
+The verdict is data: a non-pass exit-0 report means the flags stay off.
+
+Options:
+  --runs <n>             Repetitions per scenario (default ${DEFAULT_RUNS}; <9 = smoke, non-comparable)
+  --corpus <file.yaml>   Corpus path (default ${DEFAULT_CORPUS})
+  --out <file.json>      Report output path (default docs/AI_HANDOFF/inventory/g6-variant-report.json)
+  --baseline <file.json> Pre-existing baseline report to pair against (must env-match, else a fresh baseline arm runs)
+  --pressure <level>     Injected cpuPressure for the resource policy: normal|elevated|critical (default normal)
+  --variant-id <id>      Variant identifier recorded in the report (default g6-promotion-resource)
+  --timeout <ms>         Per-operation terminal wait deadline (default ${DEFAULT_TIMEOUT_MS})
+  --help                 Show this help
+
+Exit codes: 0 = completed, 2 = malformed corpus/args or crash.`;
+
+// ---------- args ----------
+
+function parseArgs(argv) {
+  const opts = {
+    runs: DEFAULT_RUNS,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    corpus: DEFAULT_CORPUS,
+    out: path.join(REPO_ROOT, 'docs/AI_HANDOFF/inventory/g6-variant-report.json'),
+    baseline: null,
+    pressure: 'normal',
+    variantId: 'g6-promotion-resource',
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') return { help: true };
+    const takeValue = () => {
+      i += 1;
+      if (i >= argv.length) throw new Error(`Missing value for ${arg}`);
+      return argv[i];
+    };
+    if (arg === '--corpus') opts.corpus = takeValue();
+    else if (arg === '--out') opts.out = takeValue();
+    else if (arg === '--baseline') opts.baseline = takeValue();
+    else if (arg === '--runs') opts.runs = Number(takeValue());
+    else if (arg === '--timeout') opts.timeoutMs = Number(takeValue());
+    else if (arg === '--pressure') opts.pressure = takeValue();
+    else if (arg === '--variant-id') opts.variantId = takeValue();
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+  return opts;
+}
+
+// ---------- corpus loading + validation (same contract as the baseline runner) ----------
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim() !== '';
+}
+
+function isNonNegativeInt(value) {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+
+function validateCorpus(doc) {
+  const problems = [];
+  if (doc == null || typeof doc !== 'object') return ['document is not an object'];
+  if (doc.version !== 1) problems.push('version must be 1');
+  if (!Array.isArray(doc.scenarios) || doc.scenarios.length === 0) {
+    problems.push('scenarios must be a non-empty array');
+    return problems;
+  }
+  doc.scenarios.forEach((scenario, index) => {
+    const label = `scenarios[${index}]`;
+    if (!isNonEmptyString(scenario?.id)) problems.push(`${label}.id must be a non-empty string`);
+    if (!isNonEmptyString(scenario?.class)) problems.push(`${label}.class must be a non-empty string`);
+    if (!Array.isArray(scenario?.steps) || scenario.steps.length === 0) {
+      problems.push(`${label}.steps must be a non-empty array`);
+    } else {
+      scenario.steps.forEach((step, s) => {
+        if (!isNonEmptyString(step?.run)) problems.push(`${label}.steps[${s}].run must be a non-empty string`);
+        if (step?.expectExit !== undefined && !Number.isInteger(step.expectExit)) {
+          problems.push(`${label}.steps[${s}].expectExit must be an integer`);
+        }
+      });
+    }
+    if (!ORACLE_TYPES.includes(scenario?.oracle?.type)) {
+      problems.push(`${label}.oracle.type must be one of: ${ORACLE_TYPES.join(', ')}`);
+    }
+    if (!isNonNegativeInt(scenario?.eligibleTransitions)) {
+      problems.push(`${label}.eligibleTransitions must be a non-negative integer`);
+    }
+    if (!isNonNegativeInt(scenario?.expectedExternalWakes)) {
+      problems.push(`${label}.expectedExternalWakes must be a non-negative integer`);
+    }
+  });
+  return problems;
+}
+
+function loadCorpus(corpusPath) {
+  if (!fs.existsSync(corpusPath)) {
+    throw new Error(`corpus not found: ${corpusPath}`);
+  }
+  let doc;
+  try {
+    doc = yaml.parse(fs.readFileSync(corpusPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`corpus YAML parse error: ${error.message}`);
+  }
+  const problems = validateCorpus(doc);
+  if (problems.length > 0) {
+    throw new Error(`malformed corpus:\n  - ${problems.join('\n  - ')}`);
+  }
+  return doc;
+}
+
+// ---------- oracle (identical rules to the baseline runner) ----------
+
+function checkOracle(oracle, { lastExit, output, cwd }) {
+  switch (oracle.type) {
+    case 'exit-code':
+      return lastExit === oracle.expect;
+    case 'output-match':
+      return output.includes(oracle.pattern);
+    case 'file-exists':
+      return fs.existsSync(path.resolve(cwd, oracle.path));
+    default:
+      return false;
+  }
+}
+
+// ---------- supervised step replay ----------
+
+const SHELL = process.platform === 'win32'
+  ? { cmd: 'cmd.exe', args: ['/d', '/s', '/c'] }
+  : { cmd: '/bin/sh', args: ['-c'] };
+
+/**
+ * Run one corpus step as a supervised operation. Returns the process wall
+ * time and the caller-observed wait: under a promoted ('handle') wait policy
+ * the caller unblocks at promoteAfterMs while the operation finishes in the
+ * background — caller wall is the promoted threshold, never fabricated.
+ * Progress-class events flow through selectResourcePolicy; terminal/failure
+ * class events are always emitted (DR-FR09 — the policy itself enforces it).
+ */
+async function runStepSupervised(step, {
+  supervisor,
+  operationId,
+  cwd,
+  waitPolicy,
+  cpuPressure,
+  queueDepth,
+  timeoutMs,
+  events,
+}) {
+  const started = Date.now();
+  const spec = {
+    operationId,
+    attempt: 1,
+    argv: [SHELL.cmd, ...SHELL.args, step.run],
+    sideEffectClass: 'read_only',
+    cwd,
+    env: process.env,
+  };
+  const launched = await supervisor.start(spec);
+  if (launched.unsupported) {
+    return { exitCode: -1, durationMs: Date.now() - started, callerWaitMs: Date.now() - started, error: `launch:${launched.code}` };
+  }
+
+  // Poll the journal until the terminal transition lands or the deadline
+  // hits. observe() replays the journal as it exists right now — a snapshot,
+  // so liveness comes from re-polling, never from a live tail.
+  let exitCode = null;
+  let coalesced = 0;
+  const deadline = Date.now() + timeoutMs;
+  const seenSeq = new Set();
+
+  while (Date.now() <= deadline) {
+    for await (const event of supervisor.observe(operationId)) {
+      if (event?.seq == null || seenSeq.has(event.seq)) continue;
+      seenSeq.add(event.seq);
+      const isTransition = event?.eventType === 'operation.transition';
+      const eventClass = isTransition && TERMINAL_TO.has(event?.safePayload?.to)
+        ? 'terminal'
+        : 'progress';
+      const decision = selectResourcePolicy({
+        cpuPressure,
+        eventClass,
+        queueDepth: queueDepth + coalesced,
+      });
+      // Coalesced progress collapses into the pending receipt — bounded
+      // batching, never a drop. Deferred progress still lands as one event.
+      // Terminal/failure classes always emit via the policy itself (DR-FR09).
+      if (decision.action === 'emit' || eventClass === 'terminal') {
+        events.emitted += 1;
+      } else if (decision.action === 'coalesce') {
+        coalesced += 1;
+        events.coalesced += 1;
+      } else {
+        events.deferred += 1;
+        events.emitted += 1;
+      }
+      if (isTransition && TERMINAL_TO.has(event.safePayload?.to)) {
+        exitCode = event.safePayload?.exitCode ?? (event.safePayload?.to === 'completed' ? 0 : -1);
+      }
+    }
+    if (exitCode !== null) break;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+
+  const durationMs = Date.now() - started;
+  // Caller-wait semantics (DR-FR04): a promoted caller unblocks at
+  // promoteAfterMs; the process itself still runs to terminal above.
+  const callerWaitMs = waitPolicy.mode === 'handle'
+    ? Math.min(durationMs, waitPolicy.promoteAfterMs)
+    : durationMs;
+  return {
+    exitCode: exitCode ?? -1,
+    durationMs,
+    callerWaitMs,
+    error: exitCode === null ? 'terminal_timeout' : null,
+  };
+}
+
+function readOperationOutput(operationId, artifactDir) {
+  let output = '';
+  for (const stream of ['stdout', 'stderr']) {
+    const file = path.join(artifactDir, `${operationId}.${stream}.log`);
+    try {
+      output += fs.readFileSync(file, 'utf8');
+    } catch { /* absent stream — no output captured */ }
+  }
+  return output;
+}
+
+// ---------- scenario replay ----------
+
+async function replayScenario(scenario, { runs, workDir, arm, cpuPressure, timeoutMs, supervisorFactory }) {
+  const durations = [];
+  const callerWaits = [];
+  let oraclePasses = 0;
+  let forbiddenFailures = 0;
+  let reachedTransitions = 0;
+  let stepMismatches = 0;
+  let promotedRuns = 0;
+  const events = { emitted: 0, coalesced: 0, deferred: 0 };
+
+  for (let r = 0; r < runs; r += 1) {
+    const runDir = path.join(workDir, `run-${r}`);
+    const artifactDir = path.join(runDir, 'artifacts');
+    fs.mkdirSync(runDir, { recursive: true });
+    const runtimeDir = path.join(runDir, 'runtime');
+    fs.mkdirSync(runtimeDir, { recursive: true });
+    const supervisor = supervisorFactory(runtimeDir, artifactDir);
+
+    const started = Date.now();
+    let callerElapsed = 0;
+    let lastExit = -1;
+    let output = '';
+    let stepsOk = true;
+    let reached = 0;
+    let runPromoted = false;
+    const operationIds = [];
+
+    for (let s = 0; s < scenario.steps.length; s += 1) {
+      const step = scenario.steps[s];
+      const expected = step.expectExit ?? 0;
+      const waitPolicy = arm === 'variant'
+        ? selectWaitPolicy(DURATION_PROFILE, { class: scenario.class }, { pressure: cpuPressure })
+        : { mode: 'foreground', reason: 'baseline' };
+      const operationId = `${scenario.id}-r${r}-s${s}`;
+      operationIds.push(operationId);
+      const result = await runStepSupervised(step, {
+        supervisor,
+        operationId,
+        cwd: runDir,
+        waitPolicy: {
+          mode: waitPolicy.mode,
+          promoteAfterMs: waitPolicy.mode === 'handle'
+            ? DURATION_PROFILE.classes[scenario.class]?.promoteAfterMs ?? Infinity
+            : Infinity,
+        },
+        cpuPressure,
+        queueDepth: scenario.steps.length - s - 1,
+        timeoutMs,
+        events,
+      });
+      lastExit = result.exitCode;
+      callerElapsed += result.callerWaitMs;
+      if (waitPolicy.mode === 'handle') runPromoted = true;
+      if (result.exitCode !== expected || result.error) {
+        stepsOk = false;
+        stepMismatches += 1;
+        break;
+      }
+      reached += 1;
+    }
+
+    // Drain journals and close artifact streams before the oracle reads the
+    // captured output — artifact bytes flush at close().
+    await supervisor.close();
+    for (const operationId of operationIds) {
+      output += readOperationOutput(operationId, artifactDir);
+    }
+
+    durations.push(Date.now() - started);
+    callerWaits.push(callerElapsed);
+    if (runPromoted) promotedRuns += 1;
+    reachedTransitions += Math.min(reached, scenario.eligibleTransitions);
+
+    const oraclePass = checkOracle(scenario.oracle, { lastExit, output, cwd: runDir });
+    if (oraclePass) oraclePasses += 1;
+    if (stepsOk && !oraclePass) forbiddenFailures += 1;
+  }
+
+  const quality = computeQualityScore({
+    satisfied: oraclePasses,
+    eligible: runs,
+    forbiddenFailures,
+  });
+  const { p50, p95 } = summarizeRuns(callerWaits.length ? callerWaits : durations);
+  const wall = summarizeRuns(durations);
+  const coverageGap = Math.max(0, scenario.eligibleTransitions * runs - reachedTransitions);
+
+  return {
+    entry: {
+      id: scenario.id,
+      class: scenario.class,
+      verdict: quality.verdict,
+      wallMs: { n: runs, p50, p95 },
+      processWallMs: { n: wall.n, p50: wall.p50, p95: wall.p95 },
+      promotedRuns,
+      wakes: 0,
+      eligible: reachedTransitions,
+      coverageGap,
+      events,
+      quality: {
+        score: quality.score,
+        satisfied: oraclePasses,
+        eligible: runs,
+        forbiddenFailures,
+      },
+      tokens: UNKNOWN,
+      stepMismatches,
+    },
+  };
+}
+
+// ---------- env (same fields as the baseline runner, metric-spec §4) ----------
+
+function detectFsType(dir) {
+  try {
+    if (typeof fs.statfsSync === 'function') {
+      const stats = fs.statfsSync(dir);
+      if (stats && typeof stats.type === 'number') {
+        return `0x${stats.type.toString(16)}`;
+      }
+    }
+  } catch { /* fall through */ }
+  return 'local';
+}
+
+function collectEnv() {
+  const env = {
+    sha: 'unknown',
+    package: 'unknown',
+    node: process.version,
+    os: process.platform,
+    arch: process.arch,
+    fs: detectFsType(REPO_ROOT),
+  };
+  try {
+    env.sha = execSync('git rev-parse HEAD', { cwd: REPO_ROOT, encoding: 'utf8', timeout: 10_000 }).trim();
+  } catch { /* leave 'unknown' */ }
+  try {
+    env.package = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8')).version ?? 'unknown';
+  } catch { /* leave 'unknown' */ }
+  return env;
+}
+
+// ---------- arm orchestration ----------
+
+function buildReport({ corpus, corpusPath, scenarios, runs, extra }) {
+  const totals = scenarios.reduce((acc, sc) => ({
+    wakes: acc.wakes + sc.wakes,
+    eligible: acc.eligible + sc.eligible,
+    satisfied: acc.satisfied + sc.quality.satisfied,
+    qualityEligible: acc.qualityEligible + sc.quality.eligible,
+    forbiddenFailures: acc.forbiddenFailures + sc.quality.forbiddenFailures,
+  }), { wakes: 0, eligible: 0, satisfied: 0, qualityEligible: 0, forbiddenFailures: 0 });
+  const summaryQuality = computeQualityScore({
+    satisfied: totals.satisfied,
+    eligible: totals.qualityEligible,
+    forbiddenFailures: totals.forbiddenFailures,
+  });
+  const allP50 = scenarios.map((sc) => sc.wallMs.p50).filter((v) => typeof v === 'number');
+  const allP95 = scenarios.map((sc) => sc.wallMs.p95).filter((v) => typeof v === 'number');
+  return {
+    version: 1,
+    env: collectEnv(),
+    corpus: { path: path.resolve(corpusPath), version: corpus.version, scenarios: corpus.scenarios.length },
+    runs,
+    scenarios,
+    summary: {
+      externalWakeRate: computeExternalWakeRate({
+        externalWakes: totals.wakes,
+        eligibleTransitions: totals.eligible,
+      }),
+      qualityScore: summaryQuality.score,
+      qualityVerdict: summaryQuality.verdict,
+      forbiddenFailures: totals.forbiddenFailures,
+      p50: allP50.length ? summarizeRuns(allP50).p50 : UNKNOWN,
+      p95: allP95.length ? summarizeRuns(allP95).p95 : UNKNOWN,
+    },
+    ...extra,
+  };
+}
+
+async function runArm(corpus, { runs, arm, cpuPressure, timeoutMs, tmpRoot }) {
+  const supervisorFactory = (runtimeDir, artifactDir) => createSupervisor({
+    runtimeDir,
+    artifactDir,
+    config: { enabled: true },
+  });
+  const scenarios = [];
+  for (const scenario of corpus.scenarios) {
+    const workDir = path.join(tmpRoot, arm, scenario.id);
+    fs.mkdirSync(workDir, { recursive: true });
+    const { entry } = await replayScenario(scenario, {
+      runs,
+      workDir,
+      arm,
+      cpuPressure: arm === 'variant' ? cpuPressure : 'normal',
+      timeoutMs,
+      supervisorFactory,
+    });
+    scenarios.push(entry);
+  }
+  return scenarios;
+}
+
+function loadBaselineReport(file) {
+  try {
+    return JSON.parse(fs.readFileSync(path.resolve(file), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// ---------- main ----------
+
+async function main() {
+  let opts;
+  try {
+    opts = parseArgs(process.argv.slice(2));
+  } catch (error) {
+    console.error(`[decision-runtime-variant] ${error.message}\n\n${USAGE}`);
+    process.exit(2);
+  }
+  if (opts.help) {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  if (!Number.isInteger(opts.runs) || opts.runs < 1) {
+    console.error('[decision-runtime-variant] --runs must be a positive integer.');
+    process.exit(2);
+  }
+  if (!['normal', 'elevated', 'critical'].includes(opts.pressure)) {
+    console.error('[decision-runtime-variant] --pressure must be normal|elevated|critical.');
+    process.exit(2);
+  }
+
+  let corpus;
+  try {
+    corpus = loadCorpus(path.resolve(opts.corpus));
+  } catch (error) {
+    console.error(`[decision-runtime-variant] ${error.message}`);
+    process.exit(2);
+  }
+
+  const comparable = opts.runs >= 9;
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ukit-dr-variant-'));
+
+  // Baseline arm: supplied report if present (env pairing is enforced by the
+  // gate), otherwise a fresh same-host arm through the supervisor with no
+  // policies — foreground wait, emit-all resource behavior.
+  let baseline = opts.baseline ? loadBaselineReport(opts.baseline) : null;
+  if (baseline == null) {
+    const baselineScenarios = await runArm(corpus, {
+      runs: opts.runs,
+      arm: 'baseline',
+      cpuPressure: 'normal',
+      timeoutMs: opts.timeoutMs,
+      tmpRoot,
+    });
+    baseline = buildReport({
+      corpus,
+      corpusPath: opts.corpus,
+      scenarios: baselineScenarios,
+      runs: opts.runs,
+      extra: { arm: 'baseline', policy: null },
+    });
+  }
+
+  // Variant arm: same corpus, same supervisor, G6 policies applied.
+  const variantScenarios = await runArm(corpus, {
+    runs: opts.runs,
+    arm: 'variant',
+    cpuPressure: opts.pressure,
+    timeoutMs: opts.timeoutMs,
+    tmpRoot,
+  });
+
+  const variantReport = buildReport({
+    corpus,
+    corpusPath: opts.corpus,
+    scenarios: variantScenarios,
+    runs: opts.runs,
+    extra: {
+      arm: 'variant',
+      variantId: opts.variantId,
+      policy: {
+        promotion: {
+          enabled: true,
+          profile: DURATION_PROFILE,
+        },
+        resource: {
+          enabled: true,
+          cpuPressure: opts.pressure,
+        },
+      },
+      comparable,
+    },
+  });
+
+  variantReport.comparison = computeGateComparison({ baseline, variant: variantReport });
+  if (!comparable) {
+    variantReport.comparabilityNote = 'smoke run: --runs < 9 is dev-only and non-comparable (metric-spec §3)';
+  }
+
+  const outPath = path.resolve(opts.out);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs.writeFileSync(outPath, `${JSON.stringify(variantReport, null, 2)}\n`);
+
+  try {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  } catch { /* tmp cleanup is best-effort */ }
+
+  const c = variantReport.comparison;
+  console.log(`[decision-runtime-variant] report written: ${outPath}`);
+  console.log(`[decision-runtime-variant] scenarios=${variantScenarios.length} runs=${opts.runs} `
+    + `verdict=${c.verdict} comparable=${c.comparable} `
+    + `qualityDelta=${c.qualityDelta} wallP95Delta=${c.wallP95Delta}`);
+  process.exit(0);
+}
+
+main().catch((error) => {
+  console.error(`[decision-runtime-variant] harness crash: ${error?.stack ?? error}`);
+  process.exit(2);
+});