elanous 0.2.42 → 0.2.44

package/src/ux-sim/mock-scenario-catalog.ts

@@ -9,6 +9,10 @@ export interface MockScenarioDevice {
   target: string;
   inputs: string[];
   observations: string[];
+  entryCommands: string[];
+  logsRecorded: 'yes' | 'no' | 'conditional' | 'runner-dependent';
+  eventNames: string[];
+  recentUse: { observedAt: string; runId: string; event: string; scenarioId: string; command: string } | null;
 }
 
 export interface MockScenarioEntry {
@@ -23,8 +27,19 @@ export interface MockScenarioEntry {
   expected: string;
 }
 
+export interface MockScenarioCandidate {
+  path: string;
+  disposition: 'device' | 'scenario' | 'already-indexed' | 'excluded';
+  entryCommand: string;
+  logsRecorded: 'yes' | 'no' | 'conditional' | 'runner-dependent';
+  logsDetail: string;
+  deviceId?: string;
+  scenarioIds?: string[];
+  excludeReason?: string;
+}
+
 export interface MockScenarioCatalog {
-  version: 1;
+  version: 2;
   runEvidence: {
     scope: string;
     runId: string;
@@ -34,6 +49,16 @@ export interface MockScenarioCatalog {
   };
   devices: MockScenarioDevice[];
   scenarios: MockScenarioEntry[];
+  candidateAudit: {
+    source: string;
+    baseCommit: string;
+    sourceRows: number;
+    existingPaths: number;
+    excludedPaths: number;
+    sourceExclusions: Array<{ path: string; reason: string }>;
+    omissionCheck: { requiredPaths: string[]; missingPaths: string[] };
+    candidates: MockScenarioCandidate[];
+  };
   discovery: { trackedRoot: string; candidateRoots: string[]; limits: string };
 }
 
@@ -66,7 +91,7 @@ function uniqueIds(rows: unknown[], path: string): Set<string> {
 
 /** Validate the checked-in index before CLI output or scenario metadata is consumed. */
 export function parseMockScenarioCatalog(value: unknown): MockScenarioCatalog {
-  if (!isRecord(value) || value.version !== 1) throw new Error('mock scenario catalog must declare version: 1');
+  if (!isRecord(value) || value.version !== 2) throw new Error('mock scenario catalog must declare version: 2');
   if (!Array.isArray(value.devices) || !Array.isArray(value.scenarios)) throw new Error('mock scenario catalog requires devices and scenarios arrays');
   const deviceIds = uniqueIds(value.devices, 'devices');
   uniqueIds(value.scenarios, 'scenarios');
@@ -81,6 +106,10 @@ export function parseMockScenarioCatalog(value: unknown): MockScenarioCatalog {
       target: requireString(row.target, `devices[${index}].target`),
       inputs: requireStringArray(row.inputs, `devices[${index}].inputs`),
       observations: requireStringArray(row.observations, `devices[${index}].observations`),
+      entryCommands: requireStringArray(row.entryCommands, `devices[${index}].entryCommands`),
+      logsRecorded: parseLogsRecorded(row.logsRecorded, `devices[${index}].logsRecorded`),
+      eventNames: requireStringArray(row.eventNames, `devices[${index}].eventNames`, true),
+      recentUse: parseRecentUse(row.recentUse, `devices[${index}].recentUse`),
     };
   });
   const scenarios = value.scenarios.map((row, index): MockScenarioEntry => {
@@ -99,15 +128,122 @@ export function parseMockScenarioCatalog(value: unknown): MockScenarioCatalog {
       expected: requireString(row.expected, `scenarios[${index}].expected`),
     };
   });
-  if (!isRecord(value.runEvidence) || !isRecord(value.runEvidence.event)) throw new Error('runEvidence and runEvidence.event are required');
-  if (!isRecord(value.discovery)) throw new Error('discovery is required');
+  if (!isRecord(value.candidateAudit) || !Array.isArray(value.candidateAudit.candidates) || !Array.isArray(value.candidateAudit.sourceExclusions)) {
+    throw new Error('candidateAudit and candidateAudit.candidates are required');
+  }
+  const knownScenarioIds = new Set(scenarios.map((scenario) => scenario.id));
+  const scenarioById = new Map(scenarios.map((scenario) => [scenario.id, scenario]));
+  const deviceById = new Map(devices.map((device) => [device.id, device]));
+  const candidatePaths = new Set<string>();
+  const sourceExclusions = value.candidateAudit.sourceExclusions.map((row, index) => {
+    if (!isRecord(row)) throw new Error(`candidateAudit.sourceExclusions[${index}] must be an object`);
+    const path = requireString(row.path, `candidateAudit.sourceExclusions[${index}].path`);
+    if (candidatePaths.has(path)) throw new Error(`candidateAudit.sourceExclusions contains duplicate path: ${path}`);
+    candidatePaths.add(path);
+    return { path, reason: requireString(row.reason, `candidateAudit.sourceExclusions[${index}].reason`) };
+  });
+  const candidates = value.candidateAudit.candidates.map((row, index): MockScenarioCandidate => {
+    if (!isRecord(row)) throw new Error(`candidateAudit.candidates[${index}] must be an object`);
+    const path = requireString(row.path, `candidateAudit.candidates[${index}].path`);
+    if (candidatePaths.has(path)) throw new Error(`candidateAudit.candidates contains duplicate path: ${path}`);
+    candidatePaths.add(path);
+    const disposition = requireString(row.disposition, `candidateAudit.candidates[${index}].disposition`);
+    if (!['device', 'scenario', 'already-indexed', 'excluded'].includes(disposition)) {
+      throw new Error(`candidateAudit.candidates[${index}].disposition is unknown: ${disposition}`);
+    }
+    const logsRecorded = requireString(row.logsRecorded, `candidateAudit.candidates[${index}].logsRecorded`);
+    if (!['yes', 'no', 'conditional', 'runner-dependent'].includes(logsRecorded)) {
+      throw new Error(`candidateAudit.candidates[${index}].logsRecorded is unknown: ${logsRecorded}`);
+    }
+    const deviceId = row.deviceId === undefined ? undefined : requireString(row.deviceId, `candidateAudit.candidates[${index}].deviceId`);
+    if (deviceId && !deviceIds.has(deviceId)) throw new Error(`candidateAudit.candidates[${index}] references unknown device: ${deviceId}`);
+    const scenarioIds = row.scenarioIds === undefined ? undefined : requireStringArray(row.scenarioIds, `candidateAudit.candidates[${index}].scenarioIds`);
+    for (const scenarioId of scenarioIds ?? []) {
+      if (!knownScenarioIds.has(scenarioId)) throw new Error(`candidateAudit.candidates[${index}] references unknown scenario: ${scenarioId}`);
+    }
+    const excludeReason = row.excludeReason === undefined ? undefined : requireString(row.excludeReason, `candidateAudit.candidates[${index}].excludeReason`);
+    if (disposition === 'excluded' && !excludeReason) throw new Error(`candidateAudit.candidates[${index}] excluded entries require excludeReason`);
+    if (disposition === 'excluded' && (deviceId || scenarioIds?.length)) {
+      throw new Error(`candidateAudit.candidates[${index}] excluded entries cannot have catalog links`);
+    }
+    if (disposition === 'device' && (!deviceId || !scenarioIds?.length)) {
+      throw new Error(`candidateAudit.candidates[${index}] device entries require deviceId and scenarioIds`);
+    }
+    if (disposition === 'scenario' && (!deviceId || !scenarioIds?.length)) {
+      throw new Error(`candidateAudit.candidates[${index}] scenario entries require deviceId and scenarioIds`);
+    }
+    if (disposition === 'already-indexed' && !deviceId && !scenarioIds?.length) {
+      throw new Error(`candidateAudit.candidates[${index}] already-indexed entries require a catalog link`);
+    }
+    if (scenarioIds?.length && !deviceId) {
+      throw new Error(`candidateAudit.candidates[${index}] scenarioIds require a deviceId`);
+    }
+    if (deviceId) {
+      const device = deviceById.get(deviceId)!;
+      if (![...device.implementation, ...device.tests].includes(path)) {
+        throw new Error(`candidateAudit.candidates[${index}] path is not registered by device ${deviceId}: ${path}`);
+      }
+    }
+    for (const scenarioId of scenarioIds ?? []) {
+      const scenario = scenarioById.get(scenarioId)!;
+      if (scenario.device !== deviceId) {
+        throw new Error(`candidateAudit.candidates[${index}] deviceId does not own scenario ${scenarioId}`);
+      }
+      if (![...scenario.implementation, ...scenario.tests].includes(path)) {
+        throw new Error(`candidateAudit.candidates[${index}] path is not registered by scenario ${scenarioId}: ${path}`);
+      }
+    }
+    return {
+      path,
+      disposition: disposition as MockScenarioCandidate['disposition'],
+      entryCommand: requireString(row.entryCommand, `candidateAudit.candidates[${index}].entryCommand`),
+      logsRecorded: logsRecorded as MockScenarioCandidate['logsRecorded'],
+      logsDetail: requireString(row.logsDetail, `candidateAudit.candidates[${index}].logsDetail`),
+      ...(deviceId ? { deviceId } : {}),
+      ...(scenarioIds ? { scenarioIds } : {}),
+      ...(excludeReason ? { excludeReason } : {}),
+    };
+  });
+  const omissionCheck = value.candidateAudit.omissionCheck;
+  if (!isRecord(omissionCheck)) throw new Error('candidateAudit.omissionCheck is required');
+  const requiredPaths = requireStringArray(omissionCheck.requiredPaths, 'candidateAudit.omissionCheck.requiredPaths');
+  const missingPaths = requireStringArray(omissionCheck.missingPaths, 'candidateAudit.omissionCheck.missingPaths', true);
+  const indexedCandidatePaths = new Set([...candidates, ...sourceExclusions].map((row) => row.path));
+  for (const path of requiredPaths) {
+    if (!indexedCandidatePaths.has(path)) throw new Error(`candidateAudit.omissionCheck path is not accounted for: ${path}`);
+  }
+  if (missingPaths.some((path) => !requiredPaths.includes(path))) throw new Error('candidateAudit.omissionCheck.missingPaths must be required paths');
+  const candidateAudit = value.candidateAudit;
+  const sourceRows = candidateAudit.sourceRows;
+  const baseCommit = candidateAudit.baseCommit;
+  const existingPaths = candidateAudit.existingPaths;
+  const excludedPaths = candidateAudit.excludedPaths;
+  if (![sourceRows, existingPaths, excludedPaths].every((n) => Number.isInteger(n) && Number(n) >= 0)) {
+    throw new Error('candidateAudit counts must be non-negative integers');
+  }
+  if (sourceRows !== candidates.length + sourceExclusions.length || excludedPaths !== candidates.filter((candidate) => candidate.disposition === 'excluded').length) {
+    throw new Error('candidateAudit counts do not match the candidate rows');
+  }
+  if (Number(existingPaths) !== candidates.length) throw new Error('candidateAudit.existingPaths must equal the current candidate count');
   const runEvidence = value.runEvidence;
+  if (!isRecord(runEvidence) || !isRecord(runEvidence.event)) throw new Error('runEvidence and runEvidence.event are required');
+  if (!isRecord(value.discovery)) throw new Error('discovery is required');
   const event = runEvidence.event;
   const discovery = value.discovery;
   return {
-    version: 1,
+    version: 2,
     devices,
     scenarios,
+    candidateAudit: {
+      source: requireString(candidateAudit.source, 'candidateAudit.source'),
+      baseCommit: requireString(baseCommit, 'candidateAudit.baseCommit'),
+      sourceRows: Number(sourceRows),
+      existingPaths: Number(existingPaths),
+      excludedPaths: Number(excludedPaths),
+      sourceExclusions,
+      omissionCheck: { requiredPaths, missingPaths },
+      candidates,
+    },
     runEvidence: {
       scope: requireString(runEvidence.scope, 'runEvidence.scope'),
       runId: requireString(runEvidence.runId, 'runEvidence.runId'),
@@ -133,6 +269,7 @@ export function renderMockScenarioList(catalog: MockScenarioCatalog): string[] {
     'Mock scenario catalog · reusable devices and scenario references',
     ...catalog.scenarios.map((scenario) => `${scenario.id}\t${scenario.kind}\t${scenario.name}`),
     `장치 ${catalog.devices.length} · 시나리오 ${catalog.scenarios.length} · 자세히: bun scripts/ux-sim.ts show <MS-id>`,
+    `후보 감사 ${catalog.candidateAudit.existingPaths}/${catalog.candidateAudit.sourceRows} 경로 확인 · 제외 ${catalog.candidateAudit.excludedPaths} · entry/logs 근거는 mock-scenario-catalog.json`,
   ];
 }
 
@@ -154,3 +291,36 @@ export function renderMockScenarioDetails(catalog: MockScenarioCatalog, id: stri
     `ScenarioV0 실행 증거: ${catalog.runEvidence.scope} · runId → ${catalog.runEvidence.event.category}/${catalog.runEvidence.event.name} → test logs.db · ${catalog.runEvidence.artifact}`,
   ];
 }
+
+/** Read-only device inventory; it reports stored evidence metadata and never runs a device. */
+export function renderMockScenarioDevices(catalog: MockScenarioCatalog): string[] {
+  return [
+    'Mock device registry · read-only',
+    ...catalog.devices.map((device) => [
+      `${device.id}\t${device.name}`,
+      `entry=${device.entryCommands.join(' ⊕ ')}`,
+      `logs=${device.logsRecorded}`,
+      `events=${device.eventNames.length ? device.eventNames.join(',') : '(none recorded)'}`,
+      `recent=${device.recentUse ? `${device.recentUse.observedAt} runId=${device.recentUse.runId} event=${device.recentUse.event} scenario=${device.recentUse.scenarioId} cmd=${device.recentUse.command}` : '(not recorded)'}`,
+    ].join('\t')),
+    `omission check: required=${catalog.candidateAudit.omissionCheck.requiredPaths.length} missing=${catalog.candidateAudit.omissionCheck.missingPaths.length}`,
+  ];
+}
+
+function parseLogsRecorded(value: unknown, path: string): MockScenarioDevice['logsRecorded'] {
+  const result = requireString(value, path);
+  if (!['yes', 'no', 'conditional', 'runner-dependent'].includes(result)) throw new Error(`${path} is unknown: ${result}`);
+  return result as MockScenarioDevice['logsRecorded'];
+}
+
+function parseRecentUse(value: unknown, path: string): MockScenarioDevice['recentUse'] {
+  if (value === null) return null;
+  if (!isRecord(value)) throw new Error(`${path} must be an object or null`);
+  return {
+    observedAt: requireString(value.observedAt, `${path}.observedAt`),
+    runId: requireString(value.runId, `${path}.runId`),
+    event: requireString(value.event, `${path}.event`),
+    scenarioId: requireString(value.scenarioId, `${path}.scenarioId`),
+    command: requireString(value.command, `${path}.command`),
+  };
+}

package/src/ux-sim/onboarding-first-run-device.ts

@@ -1,14 +1,13 @@
-// ux-sim device: the PRODUCTION first-run menu, driven under a real util-linux PTY.
+// ux-sim device: the PRODUCTION fresh-install setup menu, driven under a real util-linux PTY.
 //
-// Why this exists: the menu re-ask loop of `src/onboarding/first-run.ts`
-// (`promptProviderMenu` → `parseMenuAnswer`) is only reachable when
+// Why this exists: the fresh-install setup menu is only reachable when
 // `process.stdin.isTTY` is true. A plain pipe makes the CLI take the non-TTY
 // `needs-llm` shortcut instead, so the board (how many times the menu comes
 // back, which phrase ends the run, whether `onboarding.ready` is written) is
 // unmeasurable without a TTY. This device allocates one the same way the live
 // seat does — util-linux `script -q -e -c` — so the production entrypoint
 // `bin/elanous.mjs --test` runs its real `src/index.ts` → `runFirstRun` →
-// `promptProviderMenu` path.
+// `runFirstRunProviderSetup` path.
 //
 // Isolation (K-MK-03): HOME/XDG/claude dirs are a fresh temp tree and the CLI
 // is spawned with `--test --config-dir <temp>`, so the run cannot touch a real
@@ -19,26 +18,30 @@ import { spawn } from 'node:child_process';
 import { mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
-import { formatProviderMenu, orderProviderChoices } from '../onboarding/first-run.js';
+import { FIRST_RUN_PROVIDER_MENU_PROMPT, formatProviderMenu, orderProviderChoices } from '../onboarding/first-run.js';
+import {
+  FIRST_RUN_PROVIDER_SETUP_MENU_CHOICES,
+  FIRST_RUN_PROVIDER_SETUP_MENU_HEADING,
+  FIRST_RUN_PROVIDER_SETUP_MENU_MAX_MISSES,
+} from '../cli/setup-keys.js';
 import { spawnElanousSync } from '../instance/spawn-elanous.js';
 import { createFakeBins, utilLinuxScript, type FakeBinCall } from './fake-bin.js';
-/**
- * Text `promptProviderMenu` prints before every re-ask — one occurrence per render.
- * Every assertion on the re-ask count uses this marker, so it has one source.
- */
-export const FIRST_RUN_MENU_MARKER = 'Choose LLM';
-/**
- * Fixed choice line of the first-run menu, taken from the production renderer
- * itself (`formatProviderMenu` over the default choice order) rather than retyped.
- * Every assertion that the menu printed the expected wording — here and in
- * `src/onboarding/first-run.test.ts` — reads this, so production wording drift
- * turns into a failure instead of a stale expectation.
- */
+/** English provider chooser and Korean fresh-install chooser headings. */
+export const FIRST_RUN_MENU_MARKERS = [FIRST_RUN_PROVIDER_MENU_PROMPT, FIRST_RUN_PROVIDER_SETUP_MENU_HEADING] as const;
+
+/** Count menu renders independently of the selected user-facing locale. */
+export function countFirstRunMenuRenders(output: string): number {
+  const markerCounts = FIRST_RUN_MENU_MARKERS.map((marker) => output.split(marker).length - 1);
+  // A process keeps one locale; max also avoids counting one bilingual render twice.
+  return Math.max(...markerCounts);
+}
+/** Fixed provider-chooser choice line, taken from the production renderer. */
 export const FIRST_RUN_MENU_CHOICES = formatProviderMenu(orderProviderChoices());
+export const FIRST_RUN_MENU_CHOICE_MARKERS = [FIRST_RUN_MENU_CHOICES, FIRST_RUN_PROVIDER_SETUP_MENU_CHOICES] as const;
 /** Line `runFirstRun` prints before a fresh install has to pick a provider. */
 export const FIRST_RUN_SETUP_HINT = 'eln setup llm 으로 고르세요';
-/** Misses the parser must reject and re-ask: out of range, exponent, full-width, then 1. */
-export const FIRST_RUN_MENU_ANSWERS = ['4', '1e0', '１', '1'] as const;
+/** Misses the parser must reject: out of range, exponent, and full-width digits. */
+export const FIRST_RUN_MENU_ANSWERS = ['4', '1e0', '１'] as const;
 
 const repoRoot = resolve(import.meta.dir, '../..');
 const cliEntry = join(repoRoot, 'bin', 'elanous.mjs');
@@ -196,6 +199,7 @@ export async function driveFirstRunMenu(
     let stdout = '';
     let stderr = '';
     let seen = 0;
+    let keyPasteAnswered = false;
     const answersSent: string[] = [];
     let closed = false;
     let timedOut = false;
@@ -209,13 +213,19 @@ export async function driveFirstRunMenu(
 
     child.stdout.on('data', (chunk: Buffer) => {
       stdout += chunk.toString('utf8');
-      const count = stdout.split(FIRST_RUN_MENU_MARKER).length - 1;
+      const count = countFirstRunMenuRenders(stdout);
       while (seen < count) {
         seen += 1;
         setTimeout(() => {
           if (!closed) writeNext();
         }, answerDelayMs);
       }
+      if (!keyPasteAnswered && stdout.includes('.env 형식 키를 붙여 넣고 빈 줄로 끝내세요')) {
+        keyPasteAnswered = true;
+        setTimeout(() => {
+          if (!closed) child.stdin.write('\n');
+        }, answerDelayMs);
+      }
     });
     child.stderr.on('data', (chunk: Buffer) => {
       stderr += chunk.toString('utf8');
@@ -253,7 +263,7 @@ export async function driveFirstRunMenu(
       stderr,
       status,
       timedOut,
-      menuRenderCount: Math.min(seen, stdout.split(FIRST_RUN_MENU_MARKER).length - 1),
+      menuRenderCount: Math.min(seen, countFirstRunMenuRenders(stdout)),
       answersSent,
       finalPhrase: stdout.includes(FIRST_RUN_SETUP_HINT) ? FIRST_RUN_SETUP_HINT : null,
       readyRecorded,

package/src/ux-sim/release-sim-rig.ts

@@ -13,7 +13,8 @@ export interface ReleaseSimRigCase {
   id: string;
   mode?: 'baseline' | 'cut-tip-moved-after-resume';
   fault?: { node: string; outcome: 'fail' | 'error' | 'timeout'; evidence?: Record<string, unknown> };
-  expect: { status: 'done' | 'failed' | 'resume-refused'; mustVisit: string[]; mustNotVisit: string[] };
+  nodeOutcomes?: Record<string, { outcome: 'ok' | 'fail' | 'error'; delayMs?: number }>;
+  expect: { status: 'done' | 'failed' | 'resume-refused'; mustVisit: string[]; mustNotVisit: string[]; overlap?: [string, string]; refusalIncludes?: string };
 }
 
 export interface ReleaseSimRigScenario {
@@ -32,7 +33,9 @@ export interface ReleaseSimRigCaseResult {
   path: string[];
   dispatchedNodes: string[];
   unexpectedEdges: Array<{ from: string; to: string; outcome: string; expectedTo?: string }>;
-  checks: { status: boolean; mustVisit: boolean; mustNotVisit: boolean; ledgerEvents: boolean };
+  checks: { status: boolean; mustVisit: boolean; mustNotVisit: boolean; overlap: boolean; ledgerEvents: boolean };
+  fanOuts?: GraphRunState['fanOuts'];
+  nodeTimings?: Record<string, { startedAtMs: number; endedAtMs: number }>;
   injectedEvidence: Record<string, unknown>;
   ledgerEvents: Array<Record<string, unknown>>;
   statePath: string;
@@ -46,6 +49,7 @@ function unexpectedEdges(path: string[], state: GraphRunState, edges: Map<string
     const from = path[index]!;
     const to = path[index + 1]!;
     const edge = edges.get(from);
+    if (edge?.branches && edge.join === to) continue; // The runner records a fan-out's barrier as the parent-path successor.
     const output = nodes.get(from)?.output;
     let parsed: Record<string, unknown> = {};
     if (typeof output === 'string') {
@@ -100,8 +104,10 @@ function releaseGraphShape(): { nodeIds: Set<string>; edges: Map<string, Record<
   const edges = new Map<string, Record<string, unknown>>();
   for (const raw of graph.edges) {
     const edge = record(raw, 'release edge');
-    if (typeof edge.from !== 'string' || edge.on !== 'outcome' || !edge.map || typeof edge.map !== 'object') {
-      throw new Error('release simulation requires outcome edges with explicit maps');
+    const mapped = !!edge.map && typeof edge.map === 'object';
+    const branched = !!edge.branches && typeof edge.branches === 'object' && typeof edge.join === 'string';
+    if (typeof edge.from !== 'string' || edge.on !== 'outcome' || (!mapped && !branched)) {
+      throw new Error('release simulation requires outcome edges with explicit maps or fan-out joins');
     }
     if (edges.has(edge.from)) throw new Error(`release graph has multiple outcome edges from ${edge.from}`);
     edges.set(edge.from, edge);
@@ -128,7 +134,7 @@ export function parseReleaseSimRigScenario(source: string): ReleaseSimRigScenari
   const ids = new Set<string>();
   const cases = rawCases.map((raw, index): ReleaseSimRigCase => {
     const row = record(raw, `scenario.cases[${index}]`);
-    exactKeys(row, ['id', 'mode', 'fault', 'expect'], `scenario.cases[${index}]`);
+    exactKeys(row, ['id', 'mode', 'fault', 'nodeOutcomes', 'expect'], `scenario.cases[${index}]`);
     if (typeof row.id !== 'string' || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(row.id) || ids.has(row.id)) throw new Error(`scenario.cases[${index}].id must be unique lowercase text`);
     ids.add(row.id);
     let mode: ReleaseSimRigCase['mode'];
@@ -145,14 +151,35 @@ export function parseReleaseSimRigScenario(source: string): ReleaseSimRigScenari
       fault = { node: parsed.node, outcome: parsed.outcome, ...(parsed.evidence === undefined ? {} : { evidence: record(parsed.evidence, `scenario.cases[${index}].fault.evidence`) }) };
     }
     if ((mode === undefined) === (fault === undefined)) throw new Error(`scenario.cases[${index}] requires exactly one of mode or fault`);
+    const nodeOutcomes: ReleaseSimRigCase['nodeOutcomes'] = {};
+    if (row.nodeOutcomes !== undefined) {
+      const rawOutcomes = record(row.nodeOutcomes, `scenario.cases[${index}].nodeOutcomes`);
+      for (const [node, value] of Object.entries(rawOutcomes)) {
+        if (!nodeIds.has(node)) throw new Error(`scenario.cases[${index}].nodeOutcomes names unknown release node ${node}`);
+        const injection = record(value, `scenario.cases[${index}].nodeOutcomes.${node}`);
+        exactKeys(injection, ['outcome', 'delayMs'], `scenario.cases[${index}].nodeOutcomes.${node}`);
+        if (injection.outcome !== 'ok' && injection.outcome !== 'fail' && injection.outcome !== 'error') throw new Error(`scenario.cases[${index}].nodeOutcomes.${node}.outcome is invalid`);
+        if (injection.delayMs !== undefined && (!Number.isSafeInteger(injection.delayMs) || (injection.delayMs as number) < 0 || (injection.delayMs as number) > 60_000)) throw new Error(`scenario.cases[${index}].nodeOutcomes.${node}.delayMs must be 0–60000`);
+        nodeOutcomes[node] = { outcome: injection.outcome, ...(injection.delayMs === undefined ? {} : { delayMs: injection.delayMs as number }) };
+      }
+    }
     const expected = record(row.expect, `scenario.cases[${index}].expect`);
-    exactKeys(expected, ['status', 'mustVisit', 'mustNotVisit'], `scenario.cases[${index}].expect`);
+    exactKeys(expected, ['status', 'mustVisit', 'mustNotVisit', 'overlap', 'refusalIncludes'], `scenario.cases[${index}].expect`);
     if (expected.status !== 'done' && expected.status !== 'failed' && expected.status !== 'resume-refused') throw new Error(`scenario.cases[${index}].expect.status is invalid`);
     const mustVisit = stringList(expected.mustVisit, `scenario.cases[${index}].expect.mustVisit`);
     const mustNotVisit = stringList(expected.mustNotVisit, `scenario.cases[${index}].expect.mustNotVisit`);
+    const refusalIncludes = expected.refusalIncludes;
+    if (refusalIncludes !== undefined && (typeof refusalIncludes !== 'string' || !refusalIncludes.trim())) throw new Error(`scenario.cases[${index}].expect.refusalIncludes must be nonempty text`);
+    let overlap: [string, string] | undefined;
+    if (expected.overlap !== undefined) {
+      const pair = stringList(expected.overlap, `scenario.cases[${index}].expect.overlap`);
+      if (pair.length !== 2 || pair[0] === pair[1] || pair.some((id) => !nodeIds.has(id))) throw new Error(`scenario.cases[${index}].expect.overlap must name two different release nodes`);
+      overlap = [pair[0]!, pair[1]!];
+    }
     for (const id of [...mustVisit, ...mustNotVisit]) if (!nodeIds.has(id)) throw new Error(`scenario.cases[${index}] names unknown release node ${id}`);
     if (mustVisit.some((id) => mustNotVisit.includes(id))) throw new Error(`scenario.cases[${index}] visits and excludes the same node`);
-    return { id: row.id, ...(mode ? { mode } : {}), ...(fault ? { fault } : {}), expect: { status: expected.status, mustVisit, mustNotVisit } };
+    return { id: row.id, ...(mode ? { mode } : {}), ...(fault ? { fault } : {}), ...(Object.keys(nodeOutcomes).length ? { nodeOutcomes } : {}),
+      expect: { status: expected.status, mustVisit, mustNotVisit, ...(overlap ? { overlap } : {}), ...(typeof refusalIncludes === 'string' ? { refusalIncludes } : {}) } };
   });
   return { version: 1, kind: 'release-graph', id: root.id, isolation: 'test',
     input: { version: input.version, previousVersion: input.previousVersion }, cases };
@@ -182,11 +209,18 @@ async function runCase(scenario: ReleaseSimRigScenario, item: ReleaseSimRigCase,
   const runId = `release-sim-${scenario.id}-${item.id}`;
   const ledgerEvents: Array<Record<string, unknown>> = [];
   const dispatchedNodes: string[] = [];
+  const nodeTimings: NonNullable<ReleaseSimRigCaseResult['nodeTimings']> = {};
   const runBash = async (command: string, options: { env?: NodeJS.ProcessEnv }) => {
     const { nodeId } = parseContext(options.env ?? {});
     if (!command.trim()) throw new Error(`empty command at simulated node ${nodeId}`);
     dispatchedNodes.push(nodeId);
-    const result = resultForNode(nodeId, item.fault, scenario.input.version);
+    const startedAtMs = performance.now();
+    const injection = item.nodeOutcomes?.[nodeId];
+    const result = injection ? resultForNode(nodeId, injection.outcome === 'ok' ? undefined : {
+      node: nodeId, outcome: injection.outcome, evidence: {},
+    }, scenario.input.version) : resultForNode(nodeId, item.fault, scenario.input.version);
+    if (injection?.delayMs) await new Promise((resolve) => setTimeout(resolve, injection.delayMs));
+    nodeTimings[nodeId] = { startedAtMs, endedAtMs: performance.now() };
     return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
   };
   const capture = (event: string, data: Record<string, unknown>) => ledgerEvents.push({ event, ...data });
@@ -209,15 +243,20 @@ async function runCase(scenario: ReleaseSimRigScenario, item: ReleaseSimRigCase,
     const interrupted = listGraphRuns(root).runs.find((run) => run.runId === runId);
     const stateFile = interrupted?.statePath ?? '';
     const path = interrupted?.path ?? [];
+    const visited = new Set([...path, ...Object.values(interrupted?.fanOuts ?? {}).flatMap((fanout) => Object.keys(fanout.branches))]);
     recordObservedEdges(path, ledgerEvents);
     const edgeIssues = interrupted ? unexpectedEdges(path, interrupted, edges) : [];
-    const statusOk = item.expect.status === 'resume-refused' && refusal.includes('release command source differs from the saved cut tip');
-    const visitOk = item.expect.mustVisit.every((id) => path.includes(id));
-    const notVisitOk = item.expect.mustNotVisit.every((id) => !path.includes(id));
+    const statusOk = item.expect.status === 'resume-refused' && refusal.includes(item.expect.refusalIncludes ?? 'release command source differs from the saved cut tip');
+    const visitOk = item.expect.mustVisit.every((id) => visited.has(id));
+    const notVisitOk = item.expect.mustNotVisit.every((id) => !visited.has(id));
+    const overlapPair = item.expect.overlap;
+    const overlapOk = !overlapPair || (!!nodeTimings[overlapPair[0]] && !!nodeTimings[overlapPair[1]] &&
+      nodeTimings[overlapPair[0]]!.startedAtMs < nodeTimings[overlapPair[1]]!.endedAtMs &&
+      nodeTimings[overlapPair[1]]!.startedAtMs < nodeTimings[overlapPair[0]]!.endedAtMs);
     const ledgerOk = ledgerEvents.some((row) => row.event === 'node-end')
       && ledgerEvents.filter((row) => row.event === 'edge-observed').length === Math.max(0, path.length - 1);
-    return { id: item.id, pass: statusOk && visitOk && notVisitOk && ledgerOk && edgeIssues.length === 0, status: statusOk ? 'resume-refused' : interrupted?.status ?? 'missing',
-      path, dispatchedNodes, unexpectedEdges: edgeIssues, checks: { status: statusOk, mustVisit: visitOk, mustNotVisit: notVisitOk, ledgerEvents: ledgerOk }, injectedEvidence: {}, ledgerEvents,
+    return { id: item.id, pass: statusOk && visitOk && notVisitOk && overlapOk && ledgerOk && edgeIssues.length === 0, status: statusOk ? 'resume-refused' : interrupted?.status ?? 'missing',
+      path, dispatchedNodes, unexpectedEdges: edgeIssues, checks: { status: statusOk, mustVisit: visitOk, mustNotVisit: notVisitOk, overlap: overlapOk, ledgerEvents: ledgerOk }, injectedEvidence: {}, ledgerEvents,
       statePath: stateFile, ...(refusal ? { refusal } : {}) };
   }
 
@@ -225,17 +264,22 @@ async function runCase(scenario: ReleaseSimRigScenario, item: ReleaseSimRigCase,
   const state = await runGraph(RELEASE_GRAPH, { runId, input: scenario.input, pinChildUniverse: true, quiet: true,
     deps: { root, runBash, log: capture } });
   const path = state.path;
+  const visited = new Set([...path, ...Object.values(state.fanOuts ?? {}).flatMap((fanout) => Object.keys(fanout.branches))]);
   recordObservedEdges(path, ledgerEvents);
   const edgeIssues = unexpectedEdges(path, state, edges);
   const statusOk = state.status === item.expect.status;
-  const visitOk = item.expect.mustVisit.every((id) => path.includes(id));
-  const notVisitOk = item.expect.mustNotVisit.every((id) => !path.includes(id));
+  const visitOk = item.expect.mustVisit.every((id) => visited.has(id));
+  const notVisitOk = item.expect.mustNotVisit.every((id) => !visited.has(id));
+  const overlapPair = item.expect.overlap;
+  const overlapOk = !overlapPair || (!!nodeTimings[overlapPair[0]] && !!nodeTimings[overlapPair[1]] &&
+    nodeTimings[overlapPair[0]]!.startedAtMs < nodeTimings[overlapPair[1]]!.endedAtMs &&
+    nodeTimings[overlapPair[1]]!.startedAtMs < nodeTimings[overlapPair[0]]!.endedAtMs);
   const ledgerOk = ledgerEvents.some((row) => row.event === 'node-start') && ledgerEvents.some((row) => row.event === 'node-end')
     && ledgerEvents.filter((row) => row.event === 'edge-observed').length === Math.max(0, path.length - 1);
   const injectedEvidence = item.fault ? item.fault.evidence ?? {} : {};
-  return { id: item.id, pass: statusOk && visitOk && notVisitOk && ledgerOk && edgeIssues.length === 0, status: state.status, path, dispatchedNodes, unexpectedEdges: edgeIssues,
-    checks: { status: statusOk, mustVisit: visitOk, mustNotVisit: notVisitOk, ledgerEvents: ledgerOk }, injectedEvidence,
-    ledgerEvents, statePath: state.statePath };
+  return { id: item.id, pass: statusOk && visitOk && notVisitOk && overlapOk && ledgerOk && edgeIssues.length === 0, status: state.status, path, dispatchedNodes, unexpectedEdges: edgeIssues,
+    checks: { status: statusOk, mustVisit: visitOk, mustNotVisit: notVisitOk, overlap: overlapOk, ledgerEvents: ledgerOk }, injectedEvidence,
+    fanOuts: state.fanOuts, nodeTimings, ledgerEvents, statePath: state.statePath };
 }
 
 export async function runReleaseSimRigScenario(source: string): Promise<ReleaseSimRigResult> {