elanous 0.2.40 → 0.2.41

package/src/user-config.ts

@@ -1156,6 +1156,8 @@ export interface HarnessBudgetGateConfig {
 }
 
 export interface SelfImplementToolConfig {
+  /** Explicit opt-in for the needs-human reason-specific automatic repair goal. Defaults off. */
+  supervisor?: { reasonRepair?: boolean };
   /** Absolute root that holds per-repository child worktree directories. */
   worktreeRoot: string;
   /** Self-implement children receive a derived isolated universe by default; `inherit` keeps the parent's universe. */
@@ -1292,7 +1294,7 @@ const TOOLS_DEFAULTS: ToolsConfig = {
   selfOrchestrate: {},
   nativeStructure: { enabled: false },
   // 대표 결정(2026-07-26): 오토 선호 — 기본 ON.
-  selfImplement: { worktreeRoot: join(homedir(), '.elanous', 'worktrees'), childInstanceMode: 'isolated', prApprovalDelivery: 'terminal' as const, observeOnly: false, goalRecordInDoc: true, fabricDecompose: false, fabricDecomposeAutoPathThreshold: 5, autoOpenPr: true, autoStop: { enabled: true, minRung: 2 }, autoAssist: { enabled: true, minRung: 2 }, screenStallTermination: { enabled: true, minRung: 2 }, reworkBudget: { shadowStop: false, maxRounds: 3 }, decompositionShadow: { enabled: false }, clarificationEscalation: { enabled: false } },
+  selfImplement: { worktreeRoot: join(homedir(), '.elanous', 'worktrees'), childInstanceMode: 'isolated', prApprovalDelivery: 'terminal' as const, observeOnly: false, goalRecordInDoc: true, fabricDecompose: false, fabricDecomposeAutoPathThreshold: 5, autoOpenPr: true, supervisor: { reasonRepair: false }, autoStop: { enabled: true, minRung: 2 }, autoAssist: { enabled: true, minRung: 2 }, screenStallTermination: { enabled: true, minRung: 2 }, reworkBudget: { shadowStop: false, maxRounds: 3 }, decompositionShadow: { enabled: false }, clarificationEscalation: { enabled: false } },
 };
 
 // ── Debug ────────────────────────────────────────────────────────────
@@ -2649,6 +2651,10 @@ function parseToolsConfig(raw: unknown): ToolsConfig {
   const selfImplRaw = (root.selfImplement && typeof root.selfImplement === 'object' && !Array.isArray(root.selfImplement))
     ? root.selfImplement as Record<string, unknown>
     : {};
+  const supervisorRaw = selfImplRaw.supervisor && typeof selfImplRaw.supervisor === 'object' && !Array.isArray(selfImplRaw.supervisor)
+    ? selfImplRaw.supervisor as Record<string, unknown>
+    : {};
+  const supervisor = { reasonRepair: supervisorRaw.reasonRepair === true };
   const observeOnly = typeof selfImplRaw.observeOnly === 'boolean'
     ? selfImplRaw.observeOnly
     : TOOLS_DEFAULTS.selfImplement.observeOnly;
@@ -2807,7 +2813,7 @@ function parseToolsConfig(raw: unknown): ToolsConfig {
     runDevHarness,
     selfOrchestrate,
     nativeStructure,
-    selfImplement: { worktreeRoot, childInstanceMode, prApprovalDelivery, observeOnly, goalRecordInDoc, goalAuthorPersistentGrounding, fabricDecompose, fabricDecomposeAutoPathThreshold, autoOpenPr, draftOnStop, salvageRetention, autoStop, autoAssist, screenStallTermination, reworkBudget, decompositionShadow, clarificationEscalation, ...(childLlm ? { childLlm } : {}), ...(escalateChild && Object.keys(escalateChild).length ? { escalateChild } : {}), ...(selfImplRaw.podChildDefault !== undefined ? { podChildDefault: selfImplRaw.podChildDefault } : {}), ...(runTtlHours !== undefined ? { runTtlHours } : {}), ...(draftSweepCloseCap !== undefined ? { draftSweepCloseCap } : {}), ...(runTtl ? { runTtl } : {}), ...(autoheal ? { autoheal } : {}) },
+    selfImplement: { worktreeRoot, childInstanceMode, prApprovalDelivery, observeOnly, goalRecordInDoc, goalAuthorPersistentGrounding, fabricDecompose, fabricDecomposeAutoPathThreshold, autoOpenPr, supervisor, draftOnStop, salvageRetention, autoStop, autoAssist, screenStallTermination, reworkBudget, decompositionShadow, clarificationEscalation, ...(childLlm ? { childLlm } : {}), ...(escalateChild && Object.keys(escalateChild).length ? { escalateChild } : {}), ...(selfImplRaw.podChildDefault !== undefined ? { podChildDefault: selfImplRaw.podChildDefault } : {}), ...(runTtlHours !== undefined ? { runTtlHours } : {}), ...(draftSweepCloseCap !== undefined ? { draftSweepCloseCap } : {}), ...(runTtl ? { runTtl } : {}), ...(autoheal ? { autoheal } : {}) },
   };
 }
 
@@ -6344,11 +6350,11 @@ export const PROVIDER_DEFAULT_MODEL: Record<LLMProviderName, string> = {
   //   ⛔ openai(API 키)는 gpt-4o 그대로 — `gpt-6-*` 는 openai-codex 계열이라 openai 로 부르면 호환 판정이 거부한다(09-23 대표 · 같은 날 되돌림).
   anthropic: 'claude-opus-5-5',
   openai: 'gpt-4o',
-  // ⛔ 2026-09-23: `gpt-5.5` 는 ***두 세대 낡았다***. 운영 기본은 `gpt-6-sol` 이고
-  //    (대표 2026-09-23 · `llm.ts` `CODEX_DEFAULT_MODEL`), 이 표만 안 따라왔다.
+  // 2026-10-28: GPT-6.1 Terra is the current recommended Codex default.
+  //    `llm.ts` avoids importing this UI-facing module, so keep its local default aligned here.
   //    ⚠️ `llm.ts` 에서 import 하지 «않는다» — 이 파일은 UI 소비자가 CLI 표면을 안 끌어오게
   //    «일부러» 독립돼 있다(이 상수의 머리말). ⇒ 값을 맞추고 «자»로 묶는다.
-  'openai-codex': 'gpt-6-sol',
+  'openai-codex': 'gpt-6.1-terra',
   // ⛔ 2026-08-18: 'grok-4-1-fast' 는 «200 OK 로 응답하지만 실제로는 grok-4.3 이 도는»
   //    레거시 별칭이었다(xAI 실호출 대조). 실물 flagship 으로 고친다.
   grok: 'grok-4.7',

package/src/ux-sim/fault-needs-human-reason-repair.ts

@@ -0,0 +1,107 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { superviseRun, type SupervisorJobResult, type SupervisorStopReason } from '../self-dev/run-supervisor.js';
+
+const CASES = [
+  { reason: 'missing-path', runId: 'run-a4117f90-20261028-0000-4000-8000-000000000001',
+    piece: { taskId: 'missing-path-piece', feature: 'missing path piece', status: 'failed', stage: 'error',
+      targetPaths: ['src/gone.ts'],
+      error: { code: 'ENOENT', message: "ENOENT: no such file or directory, open 'src/gone.ts'" } }, goalText: '없는 경로를 다시 접지한다' },
+  { reason: 'scope-expansion', runId: 'run-b2aa6c1e-20261028-0000-4000-8000-000000000002',
+    piece: { taskId: 'scope-expansion-piece', feature: 'scope expansion piece', status: 'failed', stage: 'error',
+      error: { code: 'SCOPE_OUTSIDE', message: 'changed files outside the goal target paths' },
+      changedFiles: ['src/other/expanded.ts'], targetPaths: ['src/self-dev/run-supervisor.ts'] }, goalText: '범위 확장을 좁힌다' },
+  { reason: 'step-timeout', runId: 'run-c928719f-20261028-0000-4000-8000-000000000003',
+    piece: { taskId: 'step-timeout-piece', feature: 'step timeout piece', status: 'failed', stage: 'timed-out',
+      targetPaths: ['src/self-dev/run-supervisor.ts'],
+      error: { code: 'ETIMEDOUT', message: 'review step exceeded its budget' } }, goalText: '좁은 시험' },
+  { reason: 'no-piece', runId: 'run-d31870a2-20261028-0000-4000-8000-000000000004',
+    piece: { taskId: 'no-piece-piece', feature: 'no piece piece', status: 'failed', stage: 'error',
+      targetPaths: ['src/self-dev/run-supervisor.ts'],
+      error: { code: 'BOOM', message: 'TypeError: undefined is not a function' } }, goalText: '조각 없이 실패했다' },
+] as const;
+
+export interface NeedsHumanReasonRepairSimulationCase {
+  reason: typeof CASES[number]['reason'];
+  runId: string;
+  taskId: string;
+  goalText: string;
+  reruns: number;
+  repairGoal?: string;
+  stopReason?: SupervisorStopReason;
+  why?: string;
+  events: Array<{ event: string; data: Record<string, unknown> }>;
+}
+
+/** Runs the production supervisor with one injected failure per repair reason. */
+export async function simulateNeedsHumanReasonRepair(): Promise<NeedsHumanReasonRepairSimulationCase[]> {
+  const outcomes: NeedsHumanReasonRepairSimulationCase[] = [];
+  const previousStateDir = process.env.ELANOUS_STATE_DIR;
+  process.env.ELANOUS_STATE_DIR = join(process.cwd(), '.elanous-test');
+  let logStore: import('../mss/logging/log-store.js').LogStore | null = null;
+  let logSink: import('../mss/logging/log-store.js').StoreSink | null = null;
+  let unregisterLogSink: (() => void) | null = null;
+  if (process.env.NODE_ENV === 'test') {
+    const storeModule = await import('../mss/logging/log-store.js');
+    logStore = new storeModule.LogStore();
+    logSink = new storeModule.StoreSink(logStore, 'self-dev.supervisor', { installExitHandlers: false });
+    unregisterLogSink = debug.registerSink(logSink);
+  } else {
+    const { registerStandaloneLogSink } = await import('../domains/standalone-log-sink.js');
+    await registerStandaloneLogSink('self-dev.supervisor');
+  }
+  try {
+    for (const fixture of CASES) {
+      const operatorDir = mkdtempSync(join(tmpdir(), 'needs-human-reason-repair-sim-'));
+      const events: NeedsHumanReasonRepairSimulationCase['events'] = [];
+      const decisions: Array<{ action: string; stopReason?: SupervisorStopReason; why: string }> = [];
+      let repairGoal: string | undefined;
+      let reruns = 0;
+      try {
+        await superviseRun({
+          initial: [fixture.piece as unknown as SupervisorJobResult],
+          repairGoalExecution: true,
+          needsHumanReasonRepairExecution: true,
+          runStore: { runId: fixture.runId, operatorDir },
+          rerun: async (_previous, invocation) => {
+            reruns++;
+            repairGoal = invocation.repairGoals?.[fixture.piece.taskId];
+            return [fixture.piece as unknown as SupervisorJobResult];
+          },
+          onDecision: (decision) => decisions.push(decision),
+          observe: (event, data) => {
+            events.push({ event, data });
+            // Mirror the production single-run observer in self-implement-cli.ts.
+            try { debug.log('self-dev.supervisor', event, { ...data, surface: 'single' }); } catch { /* fail-open */ }
+          },
+          sweepPendingMerges: async () => ({ pending: 0, merged: 0 }),
+          taskAgentShadow: false,
+          taskAgentRejudge: false,
+        });
+        const terminal = decisions.at(-1);
+        outcomes.push({
+          reason: fixture.reason,
+          runId: fixture.runId,
+          taskId: fixture.piece.taskId,
+          goalText: fixture.goalText,
+          reruns,
+          ...(repairGoal === undefined ? {} : { repairGoal }),
+          ...(terminal?.stopReason === undefined ? {} : { stopReason: terminal.stopReason }),
+          ...(terminal === undefined ? {} : { why: terminal.why }),
+          events,
+        });
+      } finally {
+        rmSync(operatorDir, { recursive: true, force: true });
+      }
+    }
+  } finally {
+    logSink?.close();
+    unregisterLogSink?.();
+    logStore?.close();
+    if (previousStateDir === undefined) delete process.env.ELANOUS_STATE_DIR;
+    else process.env.ELANOUS_STATE_DIR = previousStateDir;
+  }
+  return outcomes;
+}

package/src/ux-sim/fault-pod-child-result.ts

@@ -0,0 +1,42 @@
+import { classifyPodTerminal } from '../self-dev/draft-residue.js';
+import { podChildEvidenceLedgerRow, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
+
+export interface PodChildResultScenario {
+  firstAttempt: Record<string, unknown>;
+  harvestAttempt: Record<string, unknown>;
+}
+
+/** Replays a successful Kubernetes Job carrying a failed/partial child result. */
+export function podChildResultScenario(): PodChildResultScenario {
+  const podTermination: PodTermination = {
+    job: 'si-task-report-deficit', path: 'result-marker', observedAt: '2026-10-28T09:35:13Z',
+    jobLookup: 'ok', jobUid: 'job-uid-1', jobConditionReason: 'CompletionsReached',
+    activeDeadlineSeconds: 14400, deadlineExceeded: false, podLookup: 'terminated',
+    containerReason: 'Completed', exitCode: 0, finishedAt: '2026-10-28T09:35:13Z', oomKilled: false,
+  };
+  const firstAttempt = podChildEvidenceLedgerRow({
+    job: podTermination.job, childRunId: 'run-first-report-deficit', state: 'complete',
+    result: {
+      stage: 'aborted', ok: false, failureClassification: 'report-deficit',
+      completionDisposition: 'partial', childEvidence: { error: 'report-deficit: missing child result summary' },
+    },
+    noResultDiagnostic: null, noResultLogEvidence: null, podTermination,
+  });
+  const harvestAttempt = classifyPodTerminal({
+    childRunId: 'run-second-harvest', state: 'complete', env: { ELANOUS_HARNESS_SEAT: 'UX' },
+    disposition: { stage: 'pr-opened', ok: true, prNumber: 32614,
+      prUrl: 'https://github.com/ElanvitalAI/elanous/pull/32614', branch: 'self-impl/coord-entrance-fold' },
+    at: '2026-10-28T09:35:29Z',
+  });
+  return { firstAttempt: firstAttempt ?? {}, harvestAttempt };
+}
+
+export function renderPodChildResult(scenario: PodChildResultScenario): string[] {
+  const first = scenario.firstAttempt as { childResult?: Record<string, unknown>; podTermination?: PodTermination };
+  return [
+    `pod-child-result · child completion=${String(first.childResult?.completionDisposition ?? 'unknown')}`,
+    `  first: child=${String(first.childResult?.ok)} · stage=${String(first.childResult?.stage)} · failure=${String(first.childResult?.failureClassification)}`,
+    `  pod: ${String(first.podTermination?.containerReason)} · exit=${String(first.podTermination?.exitCode)} · childRunId=${String(scenario.firstAttempt.childRunId)}`,
+    `  harvest: PR #${String(scenario.harvestAttempt.prNumber)} · ${String(scenario.harvestAttempt.terminalClass)}`,
+  ];
+}

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

@@ -0,0 +1,262 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { getTestStateRoot } from '../nexus/paths.js';
+import { listGraphRuns, runGraph, type GraphRunState } from '../graph-runner/runner.js';
+import { resolveScenarioFilePath } from './scenario.js';
+
+const REPOSITORY_ROOT = join(import.meta.dir, '../..');
+const RELEASE_GRAPH = join(REPOSITORY_ROOT, 'graphs/release/release-loop.yaml');
+const CUT_TIP = 'a'.repeat(40);
+
+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[] };
+}
+
+export interface ReleaseSimRigScenario {
+  version: 1;
+  kind: 'release-graph';
+  id: string;
+  isolation: 'test';
+  input: { version: string; previousVersion: string };
+  cases: ReleaseSimRigCase[];
+}
+
+export interface ReleaseSimRigCaseResult {
+  id: string;
+  pass: boolean;
+  status: string;
+  path: string[];
+  dispatchedNodes: string[];
+  unexpectedEdges: Array<{ from: string; to: string; outcome: string; expectedTo?: string }>;
+  checks: { status: boolean; mustVisit: boolean; mustNotVisit: boolean; ledgerEvents: boolean };
+  injectedEvidence: Record<string, unknown>;
+  ledgerEvents: Array<Record<string, unknown>>;
+  statePath: string;
+  refusal?: string;
+}
+
+function unexpectedEdges(path: string[], state: GraphRunState, edges: Map<string, Record<string, unknown>>): ReleaseSimRigCaseResult['unexpectedEdges'] {
+  const nodes = new Map(state.nodes.map((node) => [node.nodeId, node]));
+  const issues: ReleaseSimRigCaseResult['unexpectedEdges'] = [];
+  for (let index = 0; index + 1 < path.length; index++) {
+    const from = path[index]!;
+    const to = path[index + 1]!;
+    const edge = edges.get(from);
+    const output = nodes.get(from)?.output;
+    let parsed: Record<string, unknown> = {};
+    if (typeof output === 'string') {
+      try { parsed = record(JSON.parse(output.trim().split('\n').at(-1) ?? ''), `${from} output`); } catch { /* use runner fallback below */ }
+    } else if (output && typeof output === 'object' && !Array.isArray(output)) parsed = output as Record<string, unknown>;
+    const named = typeof parsed.outcome === 'string' ? parsed.outcome : nodes.get(from)?.ok ? 'ok' : 'fail';
+    const map = edge?.map && typeof edge.map === 'object' ? edge.map as Record<string, unknown> : {};
+    const expectedTo = typeof map[named] === 'string' ? map[named] as string : typeof map[named === 'ok' ? 'ok' : 'fail'] === 'string'
+      ? map[named === 'ok' ? 'ok' : 'fail'] as string : undefined;
+    if (expectedTo !== to) issues.push({ from, to, outcome: named, ...(expectedTo ? { expectedTo } : {}) });
+  }
+  return issues;
+}
+
+function recordObservedEdges(path: string[], events: Array<Record<string, unknown>>): void {
+  for (let index = 0; index + 1 < path.length; index++) {
+    events.push({ event: 'edge-observed', from: path[index], to: path[index + 1], source: 'release-run-path' });
+  }
+}
+
+export interface ReleaseSimRigResult {
+  id: string;
+  pass: boolean;
+  universe: string;
+  cases: ReleaseSimRigCaseResult[];
+  table: Array<{ scenario: string; path: string; status: string; unexpectedEdges: string }>;
+  artifactPath: string;
+}
+
+function record(value: unknown, where: string): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${where} must be an object`);
+  return value as Record<string, unknown>;
+}
+
+function exactKeys(value: Record<string, unknown>, allowed: readonly string[], where: string): void {
+  const extra = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (extra.length) throw new Error(`${where} has unsupported key(s): ${extra.join(', ')}`);
+}
+
+function stringList(value: unknown, where: string): string[] {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string' || item.trim() === '')) {
+    throw new Error(`${where} must be an array of non-empty strings`);
+  }
+  return value as string[];
+}
+
+function releaseGraphShape(): { nodeIds: Set<string>; edges: Map<string, Record<string, unknown>> } {
+  const graph = record(parseYaml(readFileSync(RELEASE_GRAPH, 'utf8')), 'release graph');
+  if (!Array.isArray(graph.nodes) || !Array.isArray(graph.edges)) throw new Error('release graph nodes or edges missing');
+  const nodeIds = new Set(graph.nodes.map((value) => record(value, 'release graph node').node_id)
+    .filter((id): id is string => typeof id === 'string'));
+  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');
+    }
+    if (edges.has(edge.from)) throw new Error(`release graph has multiple outcome edges from ${edge.from}`);
+    edges.set(edge.from, edge);
+  }
+  return { nodeIds, edges };
+}
+
+export function parseReleaseSimRigScenario(source: string): ReleaseSimRigScenario {
+  const root = record(parseYaml(source), 'release simulation scenario');
+  exactKeys(root, ['version', 'kind', 'id', 'isolation', 'input', 'cases'], 'release simulation scenario');
+  if (root.version !== 1 || root.kind !== 'release-graph' || root.isolation !== 'test') {
+    throw new Error('release simulation scenario requires version: 1, kind: release-graph, isolation: test');
+  }
+  if (typeof root.id !== 'string' || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(root.id)) throw new Error('scenario.id must be lowercase letters, digits, and hyphens');
+  const input = record(root.input, 'scenario.input');
+  exactKeys(input, ['version', 'previousVersion'], 'scenario.input');
+  if (typeof input.version !== 'string' || !/^\d+\.\d+\.\d+$/.test(input.version)
+    || typeof input.previousVersion !== 'string' || !/^\d+\.\d+\.\d+$/.test(input.previousVersion)) {
+    throw new Error('scenario.input requires release version and previousVersion');
+  }
+  const rawCases = root.cases;
+  if (!Array.isArray(rawCases) || rawCases.length === 0 || rawCases.length > 32) throw new Error('scenario.cases must contain 1–32 cases');
+  const { nodeIds } = releaseGraphShape();
+  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}]`);
+    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'];
+    if (row.mode !== undefined) {
+      if (row.mode !== 'baseline' && row.mode !== 'cut-tip-moved-after-resume') throw new Error(`scenario.cases[${index}].mode is unregistered`);
+      mode = row.mode;
+    }
+    let fault: ReleaseSimRigCase['fault'];
+    if (row.fault !== undefined) {
+      const parsed = record(row.fault, `scenario.cases[${index}].fault`);
+      exactKeys(parsed, ['node', 'outcome', 'evidence'], `scenario.cases[${index}].fault`);
+      if (typeof parsed.node !== 'string' || !nodeIds.has(parsed.node)) throw new Error(`scenario.cases[${index}].fault.node is not in the release graph`);
+      if (parsed.outcome !== 'fail' && parsed.outcome !== 'error' && parsed.outcome !== 'timeout') throw new Error(`scenario.cases[${index}].fault.outcome is unregistered`);
+      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 expected = record(row.expect, `scenario.cases[${index}].expect`);
+    exactKeys(expected, ['status', 'mustVisit', 'mustNotVisit'], `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`);
+    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 { version: 1, kind: 'release-graph', id: root.id, isolation: 'test',
+    input: { version: input.version, previousVersion: input.previousVersion }, cases };
+}
+
+function parseContext(env: NodeJS.ProcessEnv): { nodeId: string } {
+  const location = env.ELANOUS_GRAPH_CONTEXT;
+  if (!location) throw new Error('ELANOUS_GRAPH_CONTEXT missing in release simulation');
+  const context = record(JSON.parse(readFileSync(location, 'utf8')), 'release graph context');
+  if (typeof context.nodeId !== 'string') throw new Error('release graph context nodeId missing');
+  return { nodeId: context.nodeId };
+}
+
+function resultForNode(nodeId: string, fault: ReleaseSimRigCase['fault'], version: string): { exitCode: number; stdout: string; stderr: string; evidence: Record<string, unknown> } {
+  const triggeredFault = fault?.node === nodeId ? fault : undefined;
+  const outcome = triggeredFault ? triggeredFault.outcome === 'timeout' ? 'error' : triggeredFault.outcome : 'ok';
+  const evidence = triggeredFault?.evidence ?? {};
+  const commit = nodeId === 'version-release' ? { commit: CUT_TIP, tag: `v${version}` } : {};
+  const payload = { outcome, verdict: outcome === 'ok' ? 'pass' : 'fail', summary: triggeredFault ? `simulated ${triggeredFault.outcome}` : `simulated ${nodeId} success`, ...commit,
+    simulation: { injected: triggeredFault !== undefined, node: nodeId, evidence } };
+  return { exitCode: !triggeredFault ? 0 : triggeredFault.outcome === 'fail' ? 1 : triggeredFault.outcome === 'timeout' ? 124 : 2,
+    stdout: `${JSON.stringify(payload)}\n`, stderr: triggeredFault ? `SIMULATED_${triggeredFault.outcome.toUpperCase()}` : '', evidence };
+}
+
+async function runCase(scenario: ReleaseSimRigScenario, item: ReleaseSimRigCase, root: string,
+  edges: Map<string, Record<string, unknown>>): Promise<ReleaseSimRigCaseResult> {
+  const runId = `release-sim-${scenario.id}-${item.id}`;
+  const ledgerEvents: Array<Record<string, unknown>> = [];
+  const dispatchedNodes: string[] = [];
+  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);
+    return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
+  };
+  const capture = (event: string, data: Record<string, unknown>) => ledgerEvents.push({ event, ...data });
+
+  if (item.mode === 'cut-tip-moved-after-resume') {
+    let beforeNode = 0;
+    const simulatedStop = new Error('simulated runner stop after cut');
+    try {
+      await runGraph(RELEASE_GRAPH, { runId, input: scenario.input, pinChildUniverse: true, quiet: true,
+        deps: { root, runBash, log: capture, beforeNode: () => { if (++beforeNode === 2) throw simulatedStop; } } });
+    } catch (error) {
+      if (error !== simulatedStop) throw error;
+    }
+    let refusal = '';
+    try {
+      await runGraph(RELEASE_GRAPH, { resumeRunId: runId, pinChildUniverse: true, quiet: true,
+        releaseCommandSource: { root: REPOSITORY_ROOT, cutTip: 'b'.repeat(40), git: () => { throw new Error('git must not be consulted after the saved tip differs'); } },
+        deps: { root, runBash, log: capture } });
+    } catch (error) { refusal = error instanceof Error ? error.message : String(error); }
+    const interrupted = listGraphRuns(root).runs.find((run) => run.runId === runId);
+    const stateFile = interrupted?.statePath ?? '';
+    const path = interrupted?.path ?? [];
+    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 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,
+      statePath: stateFile, ...(refusal ? { refusal } : {}) };
+  }
+
+  // Initial runs have no releaseCommandSource (the runner only accepts it on resume); all node shell work is intercepted here.
+  const state = await runGraph(RELEASE_GRAPH, { runId, input: scenario.input, pinChildUniverse: true, quiet: true,
+    deps: { root, runBash, log: capture } });
+  const path = state.path;
+  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 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 };
+}
+
+export async function runReleaseSimRigScenario(source: string): Promise<ReleaseSimRigResult> {
+  const scenario = parseReleaseSimRigScenario(source);
+  const root = getTestStateRoot();
+  if (!root) throw new Error('release simulation rig requires --test isolated mode');
+  const { edges } = releaseGraphShape();
+  const cases = [];
+  for (const item of scenario.cases) cases.push(await runCase(scenario, item, root, edges));
+  const result: ReleaseSimRigResult = { id: scenario.id, pass: cases.every((item) => item.pass), universe: root, cases,
+    table: cases.map((item) => ({ scenario: item.id, path: item.path.join(' → '), status: item.status,
+      unexpectedEdges: item.unexpectedEdges.length ? JSON.stringify(item.unexpectedEdges) : 'none' })),
+    artifactPath: join(root, 'ux-sim', 'evidence', `${scenario.id}.json`) };
+  mkdirSync(join(root, 'ux-sim', 'evidence'), { recursive: true });
+  writeFileSync(result.artifactPath, `${JSON.stringify(result, null, 2)}\n`, { mode: 0o600 });
+  return result;
+}
+
+export async function runReleaseSimRigIfFile(filePath: string): Promise<ReleaseSimRigResult | null> {
+  const source = readFileSync(resolveScenarioFilePath(filePath), 'utf8');
+  if (record(parseYaml(source), 'scenario').kind !== 'release-graph') return null;
+  if (!getTestStateRoot()) throw new Error('release simulation rig requires --test isolated mode');
+  return runReleaseSimRigScenario(source);
+}

package/src/ux-sim/seminar-rehearsal.ts

@@ -0,0 +1,109 @@
+/**
+ * Simulate the 40-minute, seven-scene seminar rehearsal protocol.
+ *
+ * This checks timing, evidence completeness, fallback, and disclosure guards
+ * with injected records. It never claims that a real rehearsal or device run
+ * took place.
+ */
+// Targets mirror RUNBOOK-1027-seminar-smart-wizard-demo-2026-10-24.md; the test
+// parses that table so edits to the runbook cannot silently drift from this rig.
+export const SEMINAR_SCENES = [
+  { id: 1, name: 'hook', targetMinutes: 3 },
+  { id: 2, name: 'problem', targetMinutes: 5 },
+  { id: 3, name: 'AI executive', targetMinutes: 8 },
+  { id: 4, name: 'development demo', targetMinutes: 8 },
+  { id: 5, name: 'two phones', targetMinutes: 8 },
+  { id: 6, name: 'transit demo', targetMinutes: 4 },
+  { id: 7, name: 'close', targetMinutes: 4 },
+] as const;
+
+export type SeminarSceneId = (typeof SEMINAR_SCENES)[number]['id'];
+export type SeminarOutcome = 'pass' | 'fail' | 'unknown';
+
+export interface SeminarSceneRecord {
+  readonly scene: SeminarSceneId;
+  readonly elapsedMinutes: number | null;
+  readonly medium: string | null;
+  readonly evidenceId: string | null;
+  readonly outcome: SeminarOutcome;
+  readonly publicSafe: boolean | null;
+  readonly fallbackUsed: boolean | null;
+  readonly offlineFallbackPlayed: boolean | null;
+}
+
+export interface SeminarRehearsalResult {
+  readonly simulated: true;
+  readonly totalTargetMinutes: number;
+  readonly scenes: ReadonlyArray<{
+    scene: SeminarSceneId;
+    name: string;
+    targetMinutes: number;
+    observedMinutes: number | null;
+    verdict: 'pass' | 'fail' | 'unknown';
+    reason: string;
+  }>;
+  readonly verdict: 'pass' | 'fail' | 'unknown';
+}
+
+export function simSeminarRehearsal(records: readonly SeminarSceneRecord[]): SeminarRehearsalResult {
+  const byScene = new Map<SeminarSceneId, SeminarSceneRecord>();
+  for (const record of records) {
+    if (!SEMINAR_SCENES.some((scene) => scene.id === record.scene)) throw new Error(`unknown scene record: ${String(record.scene)}`);
+    if (byScene.has(record.scene)) throw new Error(`duplicate scene record: ${record.scene}`);
+    byScene.set(record.scene, record);
+  }
+
+  const scenes = SEMINAR_SCENES.map((scene) => {
+    const record = byScene.get(scene.id);
+    if (!record || record.elapsedMinutes === null || !record.medium || !record.evidenceId || record.outcome === 'unknown' || record.publicSafe === null || record.fallbackUsed === null || (record.fallbackUsed && record.offlineFallbackPlayed === null)) {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record?.elapsedMinutes ?? null, verdict: 'unknown' as const, reason: '실행 기록의 시간·매체·증거·결과·공개 안전 중 미확인 값이 있음' };
+    }
+    if (record.outcome === 'fail') {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'fail' as const, reason: '주입된 장면 결과가 fail' };
+    }
+    if (Math.abs(record.elapsedMinutes - scene.targetMinutes) > 1) {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'fail' as const, reason: `목표 ${scene.targetMinutes}분에서 ±1분 초과` };
+    }
+    if (!record.publicSafe) {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'fail' as const, reason: '공개 안전 확인 실패' };
+    }
+    if (record.fallbackUsed && !record.offlineFallbackPlayed) {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'fail' as const, reason: '대체 경로를 선택했으나 오프라인 매체 재생을 확인하지 못함' };
+    }
+    return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'pass' as const, reason: record.fallbackUsed ? '오프라인 대체 매체 재생 확인' : '주입된 시나리오 통과' };
+  });
+
+  const verdict = scenes.some((scene) => scene.verdict === 'unknown')
+    ? 'unknown'
+    : scenes.some((scene) => scene.verdict === 'fail')
+      ? 'fail'
+      : 'pass';
+
+  return {
+    simulated: true,
+    totalTargetMinutes: SEMINAR_SCENES.reduce((sum, scene) => sum + scene.targetMinutes, 0),
+    scenes,
+    verdict,
+  };
+}
+
+export function seminarRehearsalSweep(): SeminarRehearsalResult {
+  const records: SeminarSceneRecord[] = SEMINAR_SCENES.map((scene) => ({
+    scene: scene.id,
+    elapsedMinutes: scene.targetMinutes,
+    medium: scene.id === 5 ? 'simulated iPhone + Fold8' : scene.id === 4 ? 'simulated offline video' : 'simulated stage screen',
+    evidenceId: `sim-scene-${scene.id}`,
+    outcome: 'pass',
+    publicSafe: true,
+    fallbackUsed: scene.id === 5,
+    offlineFallbackPlayed: scene.id === 5 ? true : null,
+  }));
+  return simSeminarRehearsal(records);
+}
+
+export function renderSeminarRehearsal(result: SeminarRehearsalResult): string[] {
+  return [
+    `세미나 리허설 · ${result.totalTargetMinutes}분 · ${result.verdict} · sim only (실제 행사 실행 증거 아님)`,
+    ...result.scenes.map((scene) => `  S${scene.scene} ${scene.name.padEnd(18)} ${scene.observedMinutes === null ? '미확인' : `${scene.observedMinutes}분`.padEnd(5)} / 목표 ${scene.targetMinutes}분 · ${scene.verdict} · ${scene.reason}`),
+  ];
+}

package/src/ux-sim/subagent-tools-device.ts

@@ -1,5 +1,5 @@
 // N03 장치 — SUBAGENT-TOOLS-EMPTY (0.2.36 · 2026-10-22 · 대표 P0).
-// 진짜 classic TUI(bare `elanous`) ⊕ fake LLM 이 Agent 도구를 «틀린 이름» tool_filter 로 부른다
+// 진짜 classic TUI(`--legacy`) ⊕ fake LLM 이 Agent 도구를 «틀린 이름» tool_filter 로 부른다
 // (10-22 운영 실물: allow 5~12개를 줘도 49→0 · «0 tools · Blocked»). 판정은 같은 바이너리의 `logs --json`:
 //   mismatch  — allow 가 모르는 이름뿐 → tool-filter allowIgnored ⊕ dispatch noTools=false(도구 상속)
 //   deny-all  — 모든 도구를 deny → no-tools-refused(발사 거부 · 빈손 실행 0)
@@ -33,7 +33,7 @@ export async function runSubagentToolsDevice(spec: SubagentToolsSpec): Promise<S
     : { allow: ['Read'], deny: ['Read'] };
   const run = await mockSeatPtySequence({
     executable: spec.executable,
-    args: [spec.entry, '--config-dir', '{root}', '--test-state-dir', '{root}'],
+    args: [spec.entry, '--legacy', '--config-dir', '{root}', '--test-state-dir', '{root}'],
     root,
     rows: 30,
     cols: 100,

package/src/version/packed-revision.json

@@ -1 +1 @@
-{"commit":"0a06cc36728ac7d147fe4988e2fd43d5f5eb8ec8"}
+{"commit":"479072f6639b631e74d2a88a4e2f982193e00f89"}