elanous 0.2.9 → 0.2.11

package/scripts/test-diet/node.ts

@@ -2,12 +2,14 @@
 // TD2 graph nodes: pick → measure → record. Shadow only — measures alone on a remote host and drafts a card.
 //   bun scripts/test-diet/node.ts pick|measure|audit|record (test-diet or nightly-audit graph)
 import { spawnSync } from 'node:child_process';
-import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
+import { CardStore } from '../../src/task-cards/card-store.js';
 import { GATE_NIGHTLY_AUDITS } from '../release-loop/gate-node.js';
-import { appendLedger, costTable, judge, lastLedgerLine, nightlyAuditLedgerPath, pickRange, writeCardDraft, type Measurement } from './lib.js';
+import { appendLedger, costTable, judge, lastLedgerLine, ledgerPath, nightlyAuditLedgerPath, pickRange, propose, td1Dispositions, writeCardDraft, type LedgerLine, type Measurement, type Td1Disposition } from './lib.js';
 
 type Context = { graphId?: string; input: Record<string, unknown>; outputs: Record<string, Record<string, unknown> | null> };
 function context(): Context {
@@ -52,7 +54,7 @@ function measure(ctx: Context, audit = false): number {
     'while IFS= read -r f; do',
     '  [ -n "$f" ] || continue',
     '  s=$(date +%s)',
-    '  if [ -n "$TO" ]; then /usr/bin/time -l "$TO" -k 10 300 bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; else /usr/bin/time -l bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; fi',
+    `  if [ -n "$TO" ]; then /usr/bin/time -l "$TO" -k 10 300 ${audit ? 'env ELANOUS_NIGHTLY_AUDIT=1 ' : ''}bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; else /usr/bin/time -l ${audit ? 'env ELANOUS_NIGHTLY_AUDIT=1 ' : ''}bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; fi`,
     '  rc=$?; e=$(( $(date +%s) - s ))',
     '  rss=$(awk \'/maximum resident set size/ {printf "%d", $1/1048576}\' "$T/err")',
     // bun test prints its summary on stderr — read both streams.
@@ -114,12 +116,13 @@ function recordNightlyAudit(ctx: Context): number {
   return emit({ outcome: failing ? 'fail' : 'ok', summary: `nightly audit ${results.length} · failing ${failing}${card ? ' · card draft' : ''}`, failing, ledger: path, ...(card ? { card } : {}) });
 }
 
-function record(ctx: Context): number {
+export function record(ctx: Context, deps: { createStore?: (root: string) => Pick<CardStore, 'createCard' | 'appendSection' | 'close'>; td1?: ReadonlyMap<string, Td1Disposition> } = {}): number {
   const p = ctx.outputs.pick;
   const m = ctx.outputs.measure;
   const measurements = (m?.measurements ?? []) as Measurement[];
   if (!p || measurements.length === 0) return emit({ outcome: 'fail', summary: 'nothing measured' });
-  const results = measurements.map((x) => judge(x, Number(git(['log', '--since=90.days', '--format=%s', '--', x.file]).split('\n').filter((s) => /^fix\b/i.test(s)).length)));
+  const td1 = deps.td1 ?? td1Dispositions(readFileSync(join(process.cwd(), 'docs/measurements/td1-top200-content-review-2026-10-01.tsv'), 'utf8'));
+  const results = measurements.map((x) => propose(judge(x, git(['log', '--since=90.days', '--format=%s', '--', x.file]).split('\n').filter((s) => /^fix\b/i.test(s)).length), td1));
   const line = {
     at: new Date().toISOString(), range: `#${p.start}~#${p.end}`, start: Number(p.start), end: Number(p.end), next: Number(p.next), total: Number(p.total),
     commit: String(m?.commit ?? '?'), budgetSecs: Number(p.budgetSecs), results,
@@ -127,17 +130,89 @@ function record(ctx: Context): number {
   const root = effectiveInstanceRoot();
   appendLedger(root, line);
   const card = writeCardDraft(root, line);
+  const proposals: Record<string, number> = {};
+  for (const result of results) {
+    if (!result.proposal) continue;
+    proposals[result.proposal] = (proposals[result.proposal] ?? 0) + 1;
+    let store: Pick<CardStore, 'createCard' | 'appendSection' | 'close'> | undefined;
+    try {
+      store = deps.createStore?.(root) ?? new CardStore(root);
+      const task = store.createCard({ goalId: `test-diet:${result.file}:${result.proposal}`, title: `시험 다이어트 제안 — ${result.file} · ${result.proposal}` });
+      const observation = { proposal: result.proposal, basis: result.basis, guards: td1.get(result.file)?.guards ?? '',
+        secs: result.secs, rssMb: result.rssMb, caught90: result.caught90, range: line.range };
+      const fingerprint = createHash('sha256').update(JSON.stringify(observation)).digest('hex');
+      const key = `test-diet:${line.commit}:${fingerprint}`;
+      if (!task.sections.some((section) => section.key === key)) store.appendSection(task.id, {
+        key, owner: 'test-diet', content: JSON.stringify({ ...observation, at: line.at }),
+      });
+    } catch (error) {
+      console.warn(`test-diet card failed: ${result.file}: ${String(error)}`);
+      debug.log('test-diet', 'card-failed', { file: result.file });
+    } finally {
+      try { store?.close(); } catch (error) {
+        console.warn(`test-diet card close failed: ${result.file}: ${String(error)}`);
+        debug.log('test-diet', 'card-failed', { file: result.file });
+      }
+    }
+  }
+  debug.log('test-diet', 'proposed', { range: line.range, proposals });
   const counts = { keep: results.filter((r) => r.verdict === 'keep').length, review: results.filter((r) => r.verdict === 'review').length, failing: results.filter((r) => r.verdict === 'failing').length };
   debug.log('test-diet', 'recorded', { range: line.range, ...counts, card: card !== null });
   return emit({ outcome: 'ok', summary: `test-diet ${line.range} · keep ${counts.keep} · review ${counts.review} · failing ${counts.failing}${card ? ' · card draft' : ''}`, range: line.range, ...counts, ...(card ? { card } : {}) });
 }
 
+function status(root: string, options: { json?: boolean; days?: number } = {}): number {
+  const path = ledgerPath(root);
+  const ledger = existsSync(path) ? readFileSync(path, 'utf8') : '';
+  if (!ledger.trim()) {
+    if (options.json) console.log(JSON.stringify({ error: '원장 없음 — 한 번도 안 돌았다' }));
+    else console.log('원장 없음 — 한 번도 안 돌았다');
+    return 1;
+  }
+  const latest = new Map<string, LedgerLine>();
+  for (const raw of ledger.split('\n').filter(Boolean)) {
+    const line = JSON.parse(raw) as LedgerLine;
+    const date = new Date(new Date(line.at).getTime() + 9 * 3600_000).toISOString().slice(0, 10);
+    if (!latest.has(date) || latest.get(date)!.at <= line.at) latest.set(date, line);
+  }
+  const days = options.days ?? 3;
+  const dates = [...latest.keys()].sort().reverse().slice(0, days);
+  let consecutive = 0;
+  for (const date of [...latest.keys()].sort().reverse()) {
+    const expected = new Date(Date.parse(`${dates[0]}T00:00:00Z`) - consecutive * 86_400_000).toISOString().slice(0, 10);
+    if (date !== expected) break;
+    consecutive++;
+  }
+  const rows = dates.map((date) => {
+    const line = latest.get(date)!;
+    return { date, range: line.range, measured: line.results.length, total: line.total,
+      keep: line.results.filter((r) => r.verdict === 'keep').length,
+      review: line.results.filter((r) => r.verdict === 'review').length,
+      failing: line.results.filter((r) => r.verdict === 'failing').length,
+      proposals: line.results.filter((r) => r.proposal != null).length };
+  });
+  if (options.json) console.log(JSON.stringify({ rows, consecutive, days }));
+  else {
+    for (const row of rows) console.log(`${row.date} · ${row.range} · ${row.measured}/${row.total} · keep ${row.keep}/review ${row.review}/failing ${row.failing} · 제안 ${row.proposals}`);
+    console.log(`연속 산출: ${consecutive}일 (기준 ${days})`);
+  }
+  return 0;
+}
+
 if (import.meta.main) {
   const step = process.argv[2];
   try {
-    const ctx = context();
-    process.exitCode = step === 'pick' ? pick(ctx) : step === 'measure' ? measure(ctx) : step === 'audit' ? measure(ctx, true)
-      : step === 'record' ? (ctx.graphId === 'nightly-audit' || Object.hasOwn(ctx.outputs, 'audit') ? recordNightlyAudit(ctx) : record(ctx)) : emit({ outcome: 'error', summary: `unknown step: ${step}` });
+    if (step === 'status') {
+      const args = process.argv.slice(3);
+      const daysAt = args.indexOf('--days');
+      const days = daysAt < 0 ? 3 : Number(args[daysAt + 1]);
+      if (!Number.isSafeInteger(days) || days < 1) throw new Error('--days needs a positive integer');
+      process.exitCode = status(effectiveInstanceRoot(), { json: args.includes('--json'), days });
+    } else {
+      const ctx = context();
+      process.exitCode = step === 'pick' ? pick(ctx) : step === 'measure' ? measure(ctx) : step === 'audit' ? measure(ctx, true)
+        : step === 'record' ? (ctx.graphId === 'nightly-audit' || Object.hasOwn(ctx.outputs, 'audit') ? recordNightlyAudit(ctx) : record(ctx)) : emit({ outcome: 'error', summary: `unknown step: ${step}` });
+    }
   } catch (error) {
     process.exitCode = emit({ outcome: 'error', summary: error instanceof Error ? error.message : String(error) });
   }

package/scripts/test-timeout-audit.ts

@@ -0,0 +1,114 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import ts from 'typescript';
+
+export type TimeoutStatus = '파일 기본' | '시험별 일부' | '없음';
+export type TimeoutFinding = { file: string; spawnLines: number; timeout: TimeoutStatus };
+
+const target = /\bbin\/elanous\.mjs\b|\bprocess\.execPath\b|["']bun["']|\bscripts\/[^\s"']+\.(?:ts|tsx|sh)\b/;
+const processCalls = new Set(['spawnSync', 'Bun.spawnSync', 'Bun.spawn', 'execFileSync', 'execSync']);
+
+function callName(node: ts.CallExpression): string {
+  return node.expression.getText();
+}
+
+/** Inspect the command and argv, not unrelated options, resolving local const aliases. */
+function commandText(node: ts.Expression, constants: ReadonlyMap<string, ts.Expression>, seen = new Set<string>()): string {
+  if (ts.isIdentifier(node) && constants.has(node.text)) {
+    if (seen.has(node.text)) return '';
+    seen.add(node.text);
+    return commandText(constants.get(node.text)!, constants, seen);
+  }
+  if (ts.isArrayLiteralExpression(node)) return node.elements.map((element) => commandText(element as ts.Expression, constants, new Set(seen))).join(' ');
+  if (ts.isObjectLiteralExpression(node)) return node.properties.map((property) =>
+    ts.isPropertyAssignment(property) ? commandText(property.initializer, constants, new Set(seen)) : '').join(' ');
+  if (ts.isStringLiteralLike(node)) return JSON.stringify(node.text);
+  if (ts.isPropertyAccessExpression(node) && node.getText() === 'process.execPath') return node.getText();
+  if (ts.isTemplateExpression(node)) return JSON.stringify(node.head.text) + node.templateSpans.map((span) => commandText(span.expression, constants, new Set(seen)) + JSON.stringify(span.literal.text)).join('');
+  if (ts.isParenthesizedExpression(node)) return commandText(node.expression, constants, seen);
+  if (ts.isCallExpression(node)) return node.arguments.map((arg) => commandText(arg, constants, new Set(seen))).join(' ');
+  if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) return commandText(node.left, constants, new Set(seen)) + commandText(node.right, constants, new Set(seen));
+  return '';
+}
+
+function hasNumericTimeout(node: ts.Expression | undefined): boolean {
+  return !!node && (ts.isNumericLiteral(node) || (ts.isObjectLiteralExpression(node) && node.properties.some((property) =>
+    ts.isPropertyAssignment(property) && property.name.getText() === 'timeout' && ts.isNumericLiteral(property.initializer))));
+}
+
+function testTimeout(call: ts.CallExpression): boolean {
+  const name = callName(call);
+  if (name === 'test' || name === 'it') return hasNumericTimeout(call.arguments[2]);
+  if (name === 'describe') return call.arguments.some((arg) => hasNumericTimeout(arg));
+  return false;
+}
+
+function withinTimedTest(node: ts.Node): boolean {
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (ts.isCallExpression(parent) && ['test', 'it', 'describe'].includes(callName(parent)) && testTimeout(parent)) return true;
+  }
+  return false;
+}
+
+/** Classify files that actually invoke a Bun/elanous/script subprocess. */
+export function classifyTimeouts(file: string, source: string): TimeoutFinding | null {
+  const tree = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, file.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const constants = new Map<string, ts.Expression>();
+  const collect = (node: ts.Node): void => {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isVariableDeclarationList(node.parent)
+      && (node.parent.flags & ts.NodeFlags.Const)) constants.set(node.name.text, node.initializer);
+    ts.forEachChild(node, collect);
+  };
+  collect(tree);
+  const lines = new Set<number>();
+  let fileDefault = false;
+  let uncovered = false;
+  const scan = (node: ts.Node): void => {
+    if (ts.isCallExpression(node)) {
+      const name = callName(node);
+      if (name === 'setDefaultTimeout' && node.arguments.length > 0) fileDefault = true;
+      if (processCalls.has(name)) {
+        const command = node.arguments.slice(0, name === 'execSync' || name.startsWith('Bun.') ? 1 : 2)
+          .map((arg) => commandText(arg, constants)).join(' ');
+        const executable = node.arguments[0] ? commandText(node.arguments[0], constants) : '';
+        if (target.test(command) && !/^\s*"git"/.test(executable)) {
+          lines.add(tree.getLineAndCharacterOfPosition(node.getStart(tree)).line + 1);
+          if (!withinTimedTest(node)) uncovered = true;
+        }
+      }
+    }
+    ts.forEachChild(node, scan);
+  };
+  scan(tree);
+  if (lines.size === 0) return null;
+  return { file, spawnLines: lines.size, timeout: fileDefault ? '파일 기본' : uncovered ? '없음' : '시험별 일부' };
+}
+
+export function auditTimeouts(root: string, paths: readonly string[]): TimeoutFinding[] {
+  return paths.map((file) => classifyTimeouts(file, readFileSync(join(root, file), 'utf8')))
+    .filter((finding): finding is TimeoutFinding => finding !== null)
+    .sort((a, b) => a.file.localeCompare(b.file));
+}
+
+export function renderTimeouts(findings: readonly TimeoutFinding[], json = false): string {
+  if (json) return JSON.stringify(findings, null, 2);
+  return ['파일 · 띄우는 줄 수 · 시한 상태', ...findings.map((f) => `${f.file} · ${f.spawnLines} · ${f.timeout}`)].join('\n');
+}
+
+export function main(root = process.cwd(), args = process.argv.slice(2)): number {
+  if (args.some((arg) => arg !== '--json')) {
+    console.error('Usage: bun scripts/test-timeout-audit.ts [--json]');
+    return 2;
+  }
+  const git = spawnSync('git', ['ls-files', '-z', '*.test.ts', '*.test.tsx'], { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  if (git.status !== 0 || git.error) {
+    console.error(git.error?.message ?? git.stderr ?? 'git ls-files failed');
+    return 2;
+  }
+  const findings = auditTimeouts(root, git.stdout.split('\0').filter(Boolean));
+  console.log(renderTimeouts(findings, args.includes('--json')));
+  return findings.some((f) => f.timeout === '없음') ? 1 : 0;
+}
+
+if (import.meta.main) process.exitCode = main();

package/scripts/tree-sync-alert.ts

@@ -20,6 +20,6 @@ export function renderTreeSyncAlert(tree: string, streak: number, decision: stri
 
 if (import.meta.main) {
   const [tree = '', streak = '0', decision = ''] = process.argv.slice(2);
-  const ok = sendOutbound(renderTreeSyncAlert(tree, Number(streak) || 0, decision), 'alert');
+  const ok = sendOutbound(renderTreeSyncAlert(tree, Number(streak) || 0, decision), 'ops-alert');
   process.exit(ok ? 0 : 1);
 }

package/scripts/tui-regress.ts

@@ -0,0 +1,71 @@
+// V1 — rerun the hand-measured TUI checks (scripts/lib/tui-regress-checks.ts) on a real PTY, every release.
+//
+//   bun scripts/tui-regress.ts [--only R2,R5] [--json]
+//
+// ⛔ Not under `bun test`: a real PTY of the real TUI is outside the test gate (NODE_ENV=test turns the PTY
+// manifest off, and the run takes ~1 minute). Each check gets a fresh temp config/state dir and its own PTY;
+// both are removed when the check ends, so the run leaves no process or folder behind.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { startPty } from '../src/pty-shell/registry.js';
+import { ERASE, TUI_REGRESS_CHECKS, type TuiCheck, type Verdict } from './lib/tui-regress-checks.js';
+
+const COLS = 160;
+const ROWS = 50;
+const BOOT_MS = 9_000;
+const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+async function runCheck(check: TuiCheck): Promise<Verdict> {
+  const dir = mkdtempSync(join(tmpdir(), `tui-regress-${check.id}-`));
+  const cli = join(import.meta.dir, '..', 'bin', 'elanous.mjs');
+  if (check.role && check.role !== 'owner') {
+    // A config written from scratch has onboarding unfinished → bare entry would take the first-run (web-first) path,
+    // not the TUI. Mark onboarding done so the check sees the same TUI as an existing user.
+    spawnSync(process.execPath, [cli, '--config-dir', dir, 'config', 'set', 'tui.role', check.role], { stdio: 'ignore' });
+    spawnSync(process.execPath, [cli, '--config-dir', dir, 'config', 'set', 'onboarding.completed', 'true'], { stdio: 'ignore' });
+  }
+  const handle = startPty({
+    cmd: process.execPath, args: [cli, '--config-dir', dir, '--test-state-dir', dir],
+    cols: COLS, rows: ROWS, workdir: join(import.meta.dir, '..'),
+    env: { ...process.env, ELANOUS_DRIVE_TUI: '1', ELANOUS_STATE_DIR: dir },
+  });
+  const snaps: Record<string, string> = {};
+  try {
+    await sleep(BOOT_MS);
+    for (const step of check.steps) {
+      if (step.kind === 'type') handle.write(step.text);
+      else if (step.kind === 'key') handle.write(step.data);
+      else if (step.kind === 'erase') handle.write(ERASE.repeat(step.count));
+      else if (step.kind === 'wait') await sleep(step.ms);
+      else snaps[step.as] = await handle.renderScreen();
+    }
+    // TUI_REGRESS_DUMP=<id> prints that check's screens (to see why a verdict failed).
+    if (!json && process.env.TUI_REGRESS_DUMP === check.id) for (const [k, v] of Object.entries(snaps)) console.log(`--- ${check.id}:${k}\n${v.split('\n').filter((l) => l.trim()).join('\n')}`);
+    return check.judge(snaps);
+  } catch (error) {
+    return { ok: false, reason: `실행 오류: ${String(error).slice(0, 120)}` };
+  } finally {
+    try { handle.kill('SIGKILL'); } catch { /* already gone */ }
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+const args = process.argv.slice(2);
+const onlyArg = args.indexOf('--only');
+const only = onlyArg >= 0 ? new Set((args[onlyArg + 1] ?? '').split(',').map((s) => s.trim()).filter(Boolean)) : null;
+const json = args.includes('--json');
+const checks = TUI_REGRESS_CHECKS.filter((check) => !only || only.has(check.id));
+if (checks.length === 0) { console.error('tui-regress: 고른 칸이 없다 (--only 확인)'); process.exit(2); }
+
+const results: { id: string; title: string; ok: boolean; reason: string }[] = [];
+for (const check of checks) {
+  const verdict = await runCheck(check);
+  results.push({ id: check.id, title: check.title, ...verdict });
+  if (!json) console.log(`${check.id} ${verdict.ok ? '✅' : '❌'} ${check.title} — ${verdict.reason}`);
+}
+const fail = results.filter((r) => !r.ok).length;
+if (json) console.log(JSON.stringify({ results, pass: results.length - fail, fail }));
+else console.log(`tui-regress: pass ${results.length - fail} · fail ${fail}`);
+process.exit(fail ? 1 : 0);

package/scripts/ux/demo-rehearsal.ts

@@ -0,0 +1,243 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import sharp from 'sharp';
+import { Frames, launch, PUBLIC_LEAK_CHECK, sleep } from './lib/cdp.js';
+import { failedApiResponse, judgeRun, judgeScene, worstSceneState, type SceneObservation, type SceneState } from './lib/rehearsal-verdict.js';
+
+const TITLES = ['문서 아키텍처', '라이브 트레이스', '루프 에이전트', '그래프 편집기', '마법사 → 마켓', 'PTY 인텔리전스'];
+
+type Args = { url: string; out: string; secs: number; width: number; height: number; demo: boolean; tokenStdin: boolean };
+
+export function parseArgs(argv: string[]): Args {
+  const values = new Map<string, string>();
+  let demo = true;
+  let tokenStdin = false;
+  for (let i = 0; i < argv.length; i++) {
+    const key = argv[i];
+    if (key === '--no-demo') { demo = false; continue; }
+    if (key === '--token-stdin') { tokenStdin = true; continue; }
+    if (!['--url', '--out', '--secs', '--size'].includes(key ?? '')) throw new Error(`알 수 없는 인자: ${key}`);
+    const value = argv[++i];
+    if (!value || value.startsWith('--')) throw new Error(`${key} 값이 필요합니다`);
+    values.set(key!, value);
+  }
+  const url = values.get('--url');
+  const out = values.get('--out');
+  if (!url || !out) throw new Error('--url <기반 URL> --out <폴더>가 필요합니다');
+  const base = new URL(url);
+  if (!['http:', 'https:'].includes(base.protocol) || base.username || base.password || base.search || base.hash) throw new Error('--url에는 인증정보·쿼리 없는 HTTP 기반 URL만 허용합니다');
+  const secsText = values.get('--secs') ?? '20';
+  const secs = Number(secsText);
+  if (!/^\d+(?:\.\d+)?$/.test(secsText) || !Number.isFinite(secs) || secs <= 0) throw new Error('--secs는 양의 초여야 합니다');
+  const size = /^(\d+)x(\d+)$/.exec(values.get('--size') ?? '1920x1080');
+  if (!size || +size[1]! < 1 || +size[2]! < 1 || !Number.isSafeInteger(+size[1]!) || !Number.isSafeInteger(+size[2]!)) throw new Error('--size는 양의 WxH여야 합니다');
+  return { url: base.origin, out, secs, width: +size[1]!, height: +size[2]!, demo, tokenStdin };
+}
+
+type FrameRect = { x: number; y: number; width: number; height: number };
+
+// Check the entire *visible scene*, not page chrome or the bottom margin of a valid scene.
+// An evenly blank scene is blank regardless of whether it is white, grey, or black.
+export async function isBlankFrame(jpeg: string, rect: FrameRect | null): Promise<boolean> {
+  if (!rect) return true;
+  const image = sharp(Buffer.from(jpeg, 'base64'));
+  const meta = await image.metadata();
+  const left = Math.max(0, Math.floor(rect.x));
+  const top = Math.max(0, Math.floor(rect.y));
+  const right = Math.min(meta.width, Math.ceil(rect.x + rect.width));
+  const bottom = Math.min(meta.height, Math.ceil(rect.y + rect.height));
+  if (right <= left || bottom <= top) return true;
+  const { data, info } = await image.extract({ left, top, width: right - left, height: bottom - top })
+    .resize({ width: 320, height: 180, fit: 'fill' })
+    .greyscale().raw().toBuffer({ resolveWithObject: true });
+  let edges = 0;
+  for (let y = 1; y < info.height; y++) {
+    for (let x = 1; x < info.width; x++) {
+      const i = y * info.width + x;
+      if (Math.abs(data[i]! - data[i - 1]!) > 20 ||
+          Math.abs(data[i]! - data[i - info.width]!) > 20) {
+        if (++edges >= 12) return false;
+      }
+    }
+  }
+  return true;
+}
+
+// The shared CDP client owns its socket; a second CDP session observes events without changing it.
+export async function observe(port: number) {
+  const pages = await (await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(5000) })).json() as Array<{ type: string; webSocketDebuggerUrl?: string }>;
+  const endpoint = pages.find((page) => page.type === 'page')?.webSocketDebuggerUrl;
+  if (!endpoint) throw new Error('CDP page missing');
+  const socket = new WebSocket(endpoint);
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('CDP observer connection timed out')), 5000);
+      socket.addEventListener('open', () => { clearTimeout(timer); resolve(); }, { once: true });
+      socket.addEventListener('error', () => { clearTimeout(timer); reject(new Error('CDP observer unavailable')); }, { once: true });
+      socket.addEventListener('close', () => { clearTimeout(timer); reject(new Error('CDP observer closed')); }, { once: true });
+    });
+  } catch (error) { socket.close(); throw error; }
+  let id = 0;
+  const pending = new Map<number, { resolve: (value: { error?: { message: string } }) => void; reject: (error: Error) => void; timer: ReturnType<typeof setTimeout> }>();
+  let closed = false;
+  const failPending = () => {
+    closed = true;
+    for (const [key, request] of pending) {
+      clearTimeout(request.timer);
+      request.reject(new Error('CDP observer disconnected'));
+      pending.delete(key);
+    }
+  };
+  socket.addEventListener('close', failPending);
+  socket.addEventListener('error', failPending);
+  const requests = new Map<string, string>();
+  let exceptions: string[] = [];
+  let failedRequests: string[] = [];
+  socket.addEventListener('message', (event) => {
+    const data = JSON.parse(String(event.data)) as { id?: number; error?: { message: string }; method?: string; params?: { requestId?: string; request?: { url: string }; response?: { url: string; status: number } } };
+    if (data.id !== undefined) {
+      const request = pending.get(data.id);
+      if (request) { clearTimeout(request.timer); pending.delete(data.id); request.resolve(data); }
+    }
+    if (data.method === 'Network.requestWillBeSent' && data.params?.requestId && data.params.request) {
+      // Preserve only the API classification; never persist a URL or a query containing a credential.
+      const path = new URL(data.params.request.url).pathname;
+      requests.set(data.params.requestId, /(?:^|\/)v1\//.test(path) ? '/v1/' : 'non-api request');
+    }
+    if (data.method === 'Network.responseReceived' && data.params?.response) {
+      const failed = failedApiResponse(data.params.response.url, data.params.response.status);
+      if (failed) failedRequests.push(failed);
+    }
+    if (data.method === 'Network.loadingFinished') requests.delete(data.params?.requestId ?? '');
+    if (data.method === 'Runtime.exceptionThrown') exceptions.push('Runtime.exceptionThrown');
+    if (data.method === 'Network.loadingFailed') {
+      const requestId = data.params?.requestId ?? '';
+      failedRequests.push(requests.get(requestId) ?? 'non-api request');
+      requests.delete(requestId);
+    }
+  });
+  const send = async (method: string) => {
+    if (closed || socket.readyState !== WebSocket.OPEN) throw new Error('CDP observer disconnected');
+    const response = await new Promise<{ error?: { message: string } }>((resolve, reject) => {
+      const next = ++id;
+      const timer = setTimeout(() => {
+        pending.delete(next);
+        reject(new Error(`CDP ${method} timed out`));
+      }, 5000);
+      pending.set(next, { resolve, reject, timer });
+      try { socket.send(JSON.stringify({ id: next, method })); }
+      catch { clearTimeout(timer); pending.delete(next); reject(new Error('CDP observer send failed')); }
+    });
+    if (response.error) throw new Error(`CDP ${method} failed`);
+  };
+  try { await send('Runtime.enable'); await send('Network.enable'); }
+  catch (error) { failPending(); socket.close(); throw error; }
+  return {
+    take: () => {
+      const result = { exceptions, failedRequests };
+      exceptions = []; failedRequests = [];
+      return result;
+    },
+    close: () => { failPending(); socket.close(); },
+  };
+}
+
+export async function run(args: Args): Promise<number> {
+  mkdirSync(args.out, { recursive: true });
+  const startedAt = new Date().toISOString();
+  const port = 9480 + Math.floor(Math.random() * 15);
+  const cdp = await launch({ port, timeoutMs: (args.secs * 6 + 180) * 1000, width: args.width, height: args.height });
+  let observer: Awaited<ReturnType<typeof observe>> | undefined;
+  try {
+    observer = await observe(port);
+    const target = new URL('/app/inside/', args.url);
+    target.searchParams.set('demo', args.demo ? '1' : '0');
+    target.searchParams.set('capture', 'public');
+    target.searchParams.set('scene', '1');
+    if (args.tokenStdin) {
+      const token = /elt_[A-Za-z0-9_-]{16,}/.exec(await Bun.stdin.text())?.[0];
+      if (token) {
+        await cdp.send('Page.navigate', { url: `${target.origin}/app/` });
+        await sleep(3000);
+        await cdp.ev(`localStorage.setItem('elanous.daemon.token', ${JSON.stringify(token)})`);
+      }
+    }
+    observer.take();
+    await cdp.send('Page.navigate', { url: target.toString() });
+    await sleep(8000);
+    const initialEvents = observer.take();
+    const scenes = [];
+    for (let scene = 1; scene <= 6; scene++) {
+      const hiddenByDemo = args.demo && scene === 5;
+      if (hiddenByDemo) {
+        const result = judgeScene({ scene, title: TITLES[scene - 1]!, hiddenByDemo, secs: 0, frames: 0, exceptions: [], failedRequests: [], textLength: 0, leaks: [], sectionsInDom: 0, visibleScene: null });
+        scenes.push(result);
+        console.log(`scene ${scene} ${result.verdict} 0s frames=0`);
+        continue;
+      }
+      if (scene !== 1) {
+        await cdp.ev<boolean>(`(()=>{const n=${scene}; const nav=document.querySelector('nav[aria-label="장면 선택"]'); const button=[...(nav?.querySelectorAll('button')??[])].find(b=>b.textContent?.trim().startsWith(n+' ')); button?.click(); return !!button})()`);
+        await sleep(300);
+      }
+      const frames = new Frames(join(args.out, `scene-${scene}`));
+      const states: SceneState[] = [];
+      const sceneRect = await cdp.ev<FrameRect | null>(`(()=>{const s=document.querySelector('[data-inside-scene="${scene}"]'); if (!s || s.hidden) return null; const r=s.getBoundingClientRect(); return {x:r.x,y:r.y,width:r.width,height:r.height}})()`);
+      let blankFrames = 0;
+      const inspect = async () => {
+        states.push(await cdp.ev<SceneState>(`(()=>{const sections=[...document.querySelectorAll('[data-inside-scene]')]; const visible=sections.filter(s=>!s.hidden && s.getClientRects().length>0); return {sectionsInDom:sections.length,visibleScene:visible.length===1?Number(visible[0].getAttribute('data-inside-scene')):null,textLength:visible.length===1?visible[0].innerText.length:0}})()`));
+      };
+      const until = Date.now() + args.secs * 1000;
+      await inspect();
+      do {
+        const screenshot = await cdp.send('Page.captureScreenshot', { format: 'jpeg', quality: 92 });
+        frames.add(screenshot.data);
+        if (await isBlankFrame(screenshot.data, sceneRect)) blankFrames++;
+        await inspect();
+      } while (Date.now() < until);
+      await cdp.png(join(args.out, `scene-${scene}.png`));
+      const { bad } = JSON.parse(await cdp.ev<string>(PUBLIC_LEAK_CHECK)) as { bad: string[] };
+      const dom = worstSceneState(scene, states);
+      const observed = observer.take();
+      const events = scene === 1 ? {
+        exceptions: [...initialEvents.exceptions, ...observed.exceptions],
+        failedRequests: [...initialEvents.failedRequests, ...observed.failedRequests],
+      } : observed;
+      frames.toMp4(join(args.out, `scene-${scene}.mp4`), args.width, args.height);
+      const obs: SceneObservation = { scene, title: TITLES[scene - 1]!, hiddenByDemo, secs: args.secs, frames: frames.list.length, ...events, ...dom, leaks: bad, blankFrames };
+      const result = judgeScene(obs);
+      scenes.push(result);
+      console.log(`scene ${scene} ${result.verdict} ${args.secs}s frames=${result.frames}`);
+    }
+    const result = judgeRun(scenes);
+    const report = { version: repoVersion(), startedAt, endedAt: new Date().toISOString(), ...result };
+    writeFileSync(join(args.out, 'rehearsal.json'), JSON.stringify(report, null, 2) + '\n');
+    writeFileSync(join(args.out, 'rehearsal.md'), [
+      '# DEMO-RUN 리허설',
+      '',
+      ...result.banner.map((line) => `> ⚠️ ${line}`),
+      ...(result.banner.length ? [''] : []),
+      `판: ${report.version} · 시작: ${startedAt} · 종료: ${report.endedAt} · 판정: ${report.verdict}`,
+      '',
+      '| 장면 | 판정 | 초 | 프레임 | 이유 |',
+      '|---|---|---:|---:|---|',
+      ...scenes.map((s) => `| ${s.scene} ${s.title} | ${s.verdict} | ${s.secs} | ${s.frames} | ${s.reasons.join('; ') || '없음'} |`),
+      '',
+      `ok ${result.ok} · broken ${result.broken} · 미검증 ${result.unverified}`,
+      '',
+    ].join('\n'));
+    for (const line of result.banner) console.log(`⚠️ ${line}`);
+    console.log(`rehearsal ${result.verdict} ok=${result.ok} broken=${result.broken} unverified=${result.unverified}`);
+    // 0 = all seen and ok · 1 = broken · 2 = nothing broken but a scene was not seen (not a pass).
+    return result.verdict === 'broken' ? 1 : result.verdict === 'unverified' ? 2 : 0;
+  } finally { observer?.close(); cdp.close(); }
+}
+
+function repoVersion(): string {
+  try { return String((JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')) as { version?: unknown }).version ?? 'unknown'); }
+  catch { return 'unknown'; }
+}
+
+if (import.meta.main) {
+  try { process.exitCode = await run(parseArgs(process.argv.slice(2))); }
+  catch { console.error('리허설 실행 실패'); process.exitCode = 1; }
+}

package/scripts/ux/lib/rehearsal-verdict.ts

@@ -0,0 +1,73 @@
+export type SceneObservation = {
+  scene: number;
+  title: string;
+  hiddenByDemo: boolean;
+  secs: number;
+  frames: number;
+  exceptions: string[];
+  failedRequests: string[];
+  textLength: number;
+  leaks: string[];
+  sectionsInDom: number;
+  visibleScene: number | null;
+  /** Number of captured JPEG frames with no discernible scene content. */
+  blankFrames?: number;
+};
+
+export type SceneState = Pick<SceneObservation, 'textLength' | 'sectionsInDom' | 'visibleScene'>;
+
+/** A recovered frame must not erase a blank or mismatched frame from the recording. */
+export function worstSceneState(scene: number, states: SceneState[]): SceneState {
+  return {
+    textLength: states.length ? Math.min(...states.map((state) => state.textLength)) : 0,
+    sectionsInDom: states.length ? Math.min(...states.map((state) => state.sectionsInDom)) : 0,
+    visibleScene: states.length && states.every((state) => state.visibleScene === scene) ? scene : null,
+  };
+}
+
+/** Keep the API path (so a broken scene says *which* call failed) and status, never the query string;
+ *  id-like segments (uuid · long hex · digits · run-…) collapse to `:id`. */
+export function failedApiResponse(url: string, status: number): string | null {
+  try {
+    const path = new URL(url).pathname;
+    if (!(status >= 400 && status <= 599 && /(?:^|\/)v1\//.test(path))) return null;
+    const shape = path.split('/').map((part) => (/^(?:run-)?[0-9a-f]{8,}(?:-[0-9a-f]{4,})*$/i.test(part) || /^\d+$/.test(part) ? ':id' : part)).join('/');
+    return `${shape} ${status}`;
+  } catch { return null; }
+}
+
+export type SceneResult = SceneObservation & { verdict: 'ok' | 'broken' | 'unverified'; reasons: string[] };
+
+/** A scene the demo hides is not a pass — it was not seen. OP 10-03: ⑤ (wizard → market) is the 10-08 highlight. */
+export const UNVERIFIED_REASON = '시연 모드에서 숨긴 장면 — WIZ1 착지 뒤 실물 필요';
+const CIRCLED = ['①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧', '⑨'];
+
+export function judgeScene(obs: SceneObservation): SceneResult {
+  if (obs.hiddenByDemo) return { ...obs, verdict: 'unverified', reasons: [UNVERIFIED_REASON] };
+  const reasons: string[] = [];
+  if (obs.exceptions.length) reasons.push(`실행 예외 ${obs.exceptions.length}건`);
+  const failed = obs.failedRequests.filter((request) => {
+    try {
+      const path = new URL(request, 'http://localhost').pathname;
+      return /(?:^|\/)v1\//.test(path) && !path.includes('/_next/static/') && !path.includes('favicon');
+    } catch { return false; }
+  });
+  if (failed.length) reasons.push(`API 요청 실패 ${failed.length}건`);
+  if (obs.textLength < 40) reasons.push(`빈 화면 (글자 ${obs.textLength}자)`);
+  if (obs.blankFrames) reasons.push(`녹화 프레임 빈 화면 ${obs.blankFrames}장`);
+  if (obs.sectionsInDom < 6) reasons.push(`장면 언마운트 (${obs.sectionsInDom}/6)`);
+  if (obs.visibleScene !== obs.scene) reasons.push(`보이는 장면 불일치 (기대 ${obs.scene}, 실제 ${obs.visibleScene ?? '없음'})`);
+  if (obs.leaks.length) reasons.push(`공개 화면 누설 ${obs.leaks.length}건`);
+  return { ...obs, verdict: reasons.length ? 'broken' : 'ok', reasons };
+}
+
+export function judgeRun(scenes: SceneResult[]) {
+  const ok = scenes.filter((scene) => scene.verdict === 'ok').length;
+  const broken = scenes.filter((scene) => scene.verdict === 'broken').length;
+  const unverified = scenes.filter((scene) => scene.verdict === 'unverified').length;
+  // broken wins; otherwise any unseen scene keeps the whole run from reading as a pass.
+  const verdict = broken ? 'broken' as const : unverified ? 'unverified' as const : 'ok' as const;
+  const banner = scenes.filter((scene) => scene.verdict === 'unverified')
+    .map((scene) => `${CIRCLED[scene.scene - 1] ?? scene.scene} 미검증 — WIZ1 착지 뒤 실물 필요`);
+  return { verdict, ok, broken, unverified, banner, scenes };
+}