elanous 0.2.0 → 0.2.4

package/scripts/landing-heal/run-mission.ts

@@ -0,0 +1,101 @@
+#!/usr/bin/env bun
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { debug } from '../../src/debug/log.js';
+import { emitDecision } from '../../src/live/detail-switch.js';
+import { matchMustFix, type MustFixVerdict } from './must-fix-match.js';
+
+interface PullRequest {
+  number: number;
+  title: string;
+  state: string;
+  mergedAt: string | null;
+  headRefName: string;
+  files: Array<{ path: string }>;
+}
+interface Match { pr: number; text: string; verdict: MustFixVerdict }
+interface GraphContext { runId?: string; input?: { windowMinutes?: number; mustFixByPr?: Record<string, string[]> }; outputs?: Record<string, unknown> }
+export type RunCommand = (args: string[]) => string;
+const gh: RunCommand = (args) => {
+  const result = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+  if (result.error || result.status !== 0) throw new Error(`gh ${args.slice(0, 2).join(' ')} failed: ${result.stderr || String(result.error)}`);
+  return result.stdout;
+};
+
+function context(): GraphContext {
+  const path = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (!path) throw new Error('ELANOUS_GRAPH_CONTEXT required');
+  return JSON.parse(readFileSync(path, 'utf8')) as GraphContext;
+}
+
+function output(ctx: GraphContext, node: string): Record<string, unknown> {
+  const value = ctx.outputs?.[node];
+  if (value && typeof value === 'object' && !Array.isArray(value)) return value as Record<string, unknown>;
+  if (typeof value === 'string') {
+    const line = value.trim().split('\n').at(-1);
+    if (line) return JSON.parse(line) as Record<string, unknown>;
+  }
+  throw new Error(`missing ${node} output`);
+}
+
+function pullRequests(ctx: GraphContext): PullRequest[] {
+  const value = output(ctx, 'collect').prs;
+  if (!Array.isArray(value)) throw new Error('missing collected PRs');
+  return value as PullRequest[];
+}
+
+export function runMission(mission: string, ctx: GraphContext, run: RunCommand = gh, now = new Date()): Record<string, unknown> {
+  switch (mission) {
+    case 'collect': {
+      const minutes = ctx.input?.windowMinutes ?? 60;
+      if (!Number.isSafeInteger(minutes) || minutes < 1) throw new Error('windowMinutes must be a positive integer');
+      const since = new Date(now.getTime() - minutes * 60_000);
+      const rows = JSON.parse(run(['pr', 'list', '--state', 'all', '--search', `updated:>=${since.toISOString()}`, '--limit', '200', '--json', 'number,title,state,mergedAt,headRefName,files'])) as PullRequest[];
+      if (!Array.isArray(rows)) throw new Error('gh pr list did not return an array');
+      const prs = rows.filter((pr) => /^(?:self-impl\/|self-implement\/)/.test(pr.headRefName ?? '') &&
+        (pr.state === 'OPEN' || (pr.state === 'MERGED' && !!pr.mergedAt && Date.parse(pr.mergedAt) >= since.getTime())));
+      return { outcome: 'ok', prs, since: since.toISOString() };
+    }
+    case 'must-fix-match': {
+      const matches: Match[] = [];
+      for (const pr of pullRequests(ctx)) {
+        const details = JSON.parse(run(['pr', 'view', String(pr.number), '--json', 'reviews,comments'])) as {
+          reviews?: Array<{ body?: string }>;
+          comments?: Array<{ body?: string }>;
+        };
+        const pages = JSON.parse(run(['api', `repos/{owner}/{repo}/pulls/${pr.number}/comments`, '--paginate', '--slurp'])) as Array<Array<{ body?: string }>>;
+        if (!Array.isArray(pages) || !pages.every(Array.isArray)) throw new Error(`invalid review comments for PR #${pr.number}`);
+        const inline = pages.flat();
+        const mustFixes = [...(ctx.input?.mustFixByPr?.[String(pr.number)] ?? []),
+          ...[...(details.reviews ?? []), ...(details.comments ?? []), ...inline]
+            .flatMap((review) => review.body && /must[-\s]?fix/i.test(review.body) ? [review.body] : [])];
+        if (!mustFixes.length) continue;
+        const diff = run(['pr', 'diff', String(pr.number), '--patch']);
+        for (const text of mustFixes) matches.push({ pr: pr.number, text, verdict: matchMustFix(text, diff) });
+      }
+      return { outcome: 'ok', matches };
+    }
+    case 'verify-needed':
+      return { outcome: 'ok', verifyNeeded: pullRequests(ctx)
+        .filter((pr) => pr.state === 'MERGED' && pr.files.some((file) => file.path.startsWith('apps/pwa/') || file.path.startsWith('src/')))
+        .map((pr) => pr.number) };
+    case 'report': {
+      const prs = pullRequests(ctx).length;
+      const matches = output(ctx, 'must-fix-match').matches as Match[];
+      const mustFixUnresolved = matches.filter((item) => item.verdict === 'unresolved' || item.verdict === 'unknown').length;
+      const verifyNeeded = output(ctx, 'verify-needed').verifyNeeded as number[];
+      debug.log('landing-heal', 'tick', { prs, mustFixUnresolved, verifyNeeded });
+      emitDecision({ kind: 'VERIFY', what: `착지·치유 관측: PR ${prs}건`, reason: `must-fix 미해결/미상 ${mustFixUnresolved}건 · 착지 뒤 검증 필요 ${verifyNeeded.length}건`, purpose: '착지 후속 작업 관측', target: 'landing-heal', ...(ctx.runId ? { runId: ctx.runId } : {}) });
+      return { outcome: 'ok', prs, mustFixUnresolved, verifyNeeded };
+    }
+    default: throw new Error(`unknown landing-heal mission: ${mission}`);
+  }
+}
+
+if (import.meta.main) {
+  try { process.stdout.write(`${JSON.stringify(runMission(process.argv[2] ?? '', context()))}\n`); }
+  catch (error) {
+    process.stderr.write(`${String(error)}\n`);
+    process.exitCode = 1;
+  }
+}

package/scripts/lib/pwa-scenarios/acp-replay.ts

@@ -0,0 +1,79 @@
+type ReplaySocket = Pick<WebSocket, 'addEventListener' | 'send' | 'close'>;
+
+export function stripAnsi(text: string): string {
+  return text.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b\[[0-?]*[ -/]*[@-~]|\x1b[^\[\]]/g, '');
+}
+
+interface ReplayOptions {
+  baseUrl: string;
+  sessionId: string;
+  terminalId: string;
+  timeoutMs: number;
+}
+
+/** Connect as a separate ACP client; never open a socket in the browser page. */
+export async function readTerminalReplay(
+  { baseUrl, sessionId, terminalId, timeoutMs }: ReplayOptions,
+  connect: (url: string, origin: string) => ReplaySocket = (url, origin) => new WebSocket(url, { headers: { Origin: origin } } as unknown as string[]),
+): Promise<string> {
+  const origin = new URL(baseUrl).origin;
+  const url = new URL('/v1/acp', origin);
+  url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+  const socket = connect(url.href, origin);
+  return new Promise<string>((resolve, reject) => {
+    let done = false;
+    const finish = (error?: Error, text?: string) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      try { socket.close(); } catch { /* socket can already be closed */ }
+      if (error) reject(error);
+      else resolve(text!);
+    };
+    const timer = setTimeout(() => finish(new Error(`terminal replay timed out after ${timeoutMs}ms`)), timeoutMs);
+    const send = (request: Record<string, unknown>) => {
+      // 데몬 ACP 는 줄 단위 JSON(ndjson)이다 — 끝의 '\n' 이 없으면 서버가 프레임을 버퍼에 쥐고 처리하지 않는다
+      // (PWA `daemon-client.ts` sendRaw 와 같다 · 2026-09-27 실측: 없으면 initialize 응답 0).
+      if (!done) socket.send(`${JSON.stringify(request)}\n`);
+    };
+    socket.addEventListener('open', () => send({
+      jsonrpc: '2.0', id: 1, method: 'initialize',
+      params: { protocolVersion: 1, clientInfo: { name: 'pwa-scenarios', version: '1.0.0' }, clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false } },
+    }));
+    const decoder = new TextDecoder();
+    let buffered = '';
+    socket.addEventListener('message', (event: MessageEvent) => {
+      // 데몬은 바이트(Uint8Array/ArrayBuffer)로 보내고 한 프레임에 여러 줄이 올 수 있다.
+      const data = event.data as unknown;
+      buffered += typeof data === 'string' ? data
+        : data instanceof ArrayBuffer ? decoder.decode(new Uint8Array(data))
+        : ArrayBuffer.isView(data) ? decoder.decode(data as Uint8Array)
+        : String(data);
+      const lines = buffered.split('\n');
+      buffered = lines.pop() ?? '';
+      for (const line of lines) if (line.trim()) handleLine(line);
+    });
+    const handleLine = (line: string) => {
+      try {
+        const message = JSON.parse(line) as { id?: number; error?: { message?: string }; result?: Record<string, unknown> };
+        if (done || (message.id !== 1 && message.id !== 2 && message.id !== 3)) return;
+        if (message.error) throw new Error(`ACP ${message.id}: ${message.error.message ?? 'request failed'}`);
+        if (message.id === 1) {
+          // 페이지 세션을 `session/load` 로 불러오지 않는다 — 데몬을 새로 띄우면 그 세션을 몰라 Internal error 가 났다
+          // (2026-09-27 실물 3판 중 2판 T1b). 새 세션으로 붙어도 #20971 뒤로 같은 terminalId 의 살아 있는 셸에 attach 된다.
+          send({ jsonrpc: '2.0', id: 2, method: 'session/new', params: { cwd: '/', mcpServers: [] } });
+        } else if (message.id === 2) {
+          const replaySession = typeof message.result?.sessionId === 'string' ? message.result.sessionId : sessionId;
+          send({ jsonrpc: '2.0', id: 3, method: 'terminal/spawn', params: { sessionId: replaySession, terminalId, replay: true } });
+        } else {
+          if (message.result?.status !== 'attached' || typeof message.result.snapshot !== 'string') {
+            throw new Error(`terminal replay not attached: ${JSON.stringify(message.result)}`);
+          }
+          finish(undefined, stripAnsi(message.result.snapshot));
+        }
+      } catch (error) { finish(error instanceof Error ? error : new Error(String(error))); }
+    };
+    socket.addEventListener('error', () => finish(new Error('terminal replay WebSocket error')));
+    socket.addEventListener('close', () => finish(new Error('terminal replay WebSocket closed before response')));
+  });
+}

package/scripts/lib/pwa-scenarios/cdp-driver.ts

@@ -0,0 +1,67 @@
+import { createCdpClient, createCdpClientFromEndpoint, type CdpClient } from '../../../src/browser-cdp/client.js';
+import type { PageDriver } from './runner.js';
+
+export const VIEWPORT = { width: 1280, height: 800 } as const;
+
+/** Owns its Chrome process and an independent page target; never attaches to a user's browser. */
+export async function createCdpPageDriver(port: number, headed = false, baseUrl: string): Promise<PageDriver & { close(): Promise<void> }> {
+  const browser = await createCdpClient({ port, headless: !headed, url: 'about:blank' });
+  let page: CdpClient;
+  try {
+    // A page-level WebSocket is required for Runtime/Page/Input domains. The spawned
+    // browser's /json/version endpoint is browser-level, not page-level.
+    page = await createCdpClientFromEndpoint(port);
+  } catch (error) {
+    await browser.close();
+    throw error;
+  }
+  const send = async (method: string, params: Record<string, unknown>): Promise<void> => {
+    if (!page.send) throw new Error(`CDP ${method} is unavailable`);
+    await page.send(method, params);
+  };
+  // 헤드리스 기본 창(약 756×469)은 실제 기기보다 작아 터미널이 한 줄로 눌린다(2026-09-27 실측) — 데스크톱 크기로 고정한다.
+  await send('Emulation.setDeviceMetricsOverride', { width: VIEWPORT.width, height: VIEWPORT.height, deviceScaleFactor: 1, mobile: false });
+  return {
+    async llmCallCursor() {
+      // Same daemon's log store, not the runner's own or any federated store.
+      const url = `${baseUrl}/v1/logs?category=llm.stream&event=consume-start&limit=1`;
+      const response = await fetch(url, { headers: { Origin: baseUrl }, signal: AbortSignal.timeout(5_000) });
+      if (!response.ok) throw new Error(`LLM log cursor unavailable: HTTP ${response.status}`);
+      const body = await response.json() as { ok?: boolean; logs?: Array<{ id?: unknown }> };
+      if (body.ok !== true || !Array.isArray(body.logs)) throw new Error('LLM log cursor unavailable: invalid response');
+      const id = body.logs.length === 0 ? 0 : body.logs[0]?.id;
+      if (!Number.isSafeInteger(id) || Number(id) < 0) throw new Error('LLM log cursor unavailable: invalid ID');
+      return Number(id);
+    },
+    async goto(url) {
+      const result = await page.navigate(url);
+      if (result.errorText) throw new Error(`navigate ${url}: ${result.errorText}`);
+    },
+    evaluate: (expression) => page.evaluate(expression),
+    insertText: (text) => send('Input.insertText', { text }),
+    async press(key) {
+      if (key !== 'Enter') throw new Error(`unsupported key: ${key}`);
+      await send('Input.dispatchKeyEvent', { type: 'keyDown', key, code: 'Enter', windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 });
+      await send('Input.dispatchKeyEvent', { type: 'keyUp', key, code: 'Enter', windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 });
+    },
+    async click(selector) {
+      const point = await page.evaluate(`(() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return null;
+        el.scrollIntoView({ block: 'center', inline: 'center' });
+        const rect = el.getBoundingClientRect();
+        return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+      })()`) as { x: number; y: number } | null;
+      if (!point) throw new Error(`no-selector (${selector})`);
+      if (page.click) await page.click(point);
+      else {
+        await send('Input.dispatchMouseEvent', { type: 'mousePressed', ...point, button: 'left', clickCount: 1 });
+        await send('Input.dispatchMouseEvent', { type: 'mouseReleased', ...point, button: 'left', clickCount: 1 });
+      }
+    },
+    screenshot: () => page.screenshot({ format: 'png' }),
+    async close() {
+      try { await page.close(); } finally { await browser.close(); }
+    },
+  };
+}

package/scripts/lib/pwa-scenarios/runner.ts

@@ -0,0 +1,200 @@
+import type { Check, HostCheck, Scenario, Step, Surface } from './scenarios.js';
+
+export interface PageDriver {
+  goto(url: string): Promise<void>;
+  evaluate(expression: string): Promise<unknown>;
+  insertText(text: string): Promise<void>;
+  press(key: string): Promise<void>;
+  click(selector: string): Promise<void>;
+  screenshot(): Promise<Buffer>;
+  /** Latest daemon llm.stream/consume-start log ID; read failure must throw. */
+  llmCallCursor(): Promise<number>;
+}
+
+export interface CellResult {
+  id: string;
+  surface: Surface;
+  title: string;
+  pass: boolean;
+  ms: number;
+  chipMs?: number;
+  evidence: string[];
+  failure?: string;
+  blocked?: 'no-selector';
+}
+
+export type SaveShot = (id: string, image: Buffer) => Promise<string>;
+
+const describe = (value: unknown): string => {
+  try { return JSON.stringify(value) ?? String(value); } catch { return String(value); }
+};
+
+/** Evaluate at least once, then retry until true or the deadline. No unconditional sleep. */
+async function poll(driver: PageDriver, js: string, timeoutMs: number, intervalMs: number, onValue?: (value: unknown) => void): Promise<unknown> {
+  const deadline = Date.now() + timeoutMs;
+  let last: unknown;
+  do {
+    last = await driver.evaluate(js);
+    onValue?.(last);
+    if (last) return last;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    await new Promise<void>((resolve) => setTimeout(resolve, Math.min(intervalMs, remaining)));
+  } while (true);
+  return last;
+}
+
+/** 요소 또는 그 조상이 React 에 붙었는가(`__reactFiber$…`·`__reactProps$…` 키). xterm 처럼 React 밖 DOM 은 조상으로 판정한다. */
+export function hydratedJs(selector: string): string {
+  return `(() => { let el = document.querySelector(${JSON.stringify(selector)}); while (el) { if (Object.keys(el).some((k) => k.startsWith('__reactFiber') || k.startsWith('__reactProps'))) return true; el = el.parentElement; } return false; })()`;
+}
+
+class CellFailure extends Error {
+  constructor(message: string, readonly blocked = false) { super(message); }
+}
+
+async function runStep(driver: PageDriver, step: Step, url: string): Promise<unknown> {
+  switch (step.kind) {
+    case 'goto': return driver.goto(url);
+    case 'capture': {
+      const value = await poll(driver, step.js, step.timeoutMs, 100);
+      if (!value) throw new CellFailure(`timed out capturing ${step.key}; last=${describe(value)}`);
+      return value;
+    }
+    case 'waitFor': {
+      if (!step.selector && !step.jsPredicate) throw new CellFailure('no-selector', true);
+      const js = step.selector
+        ? `Boolean(document.querySelector(${JSON.stringify(step.selector)}))`
+        : step.jsPredicate!;
+      const last = await poll(driver, js, step.timeoutMs, step.intervalMs ?? 100);
+      if (!last) throw new CellFailure(`timed out${step.selector ? ` (${step.selector})` : ''}; last=${describe(last)}`);
+      return last;
+    }
+    case 'type': return driver.insertText(step.text);
+    case 'press': return driver.press(step.key);
+    case 'click': {
+      if (!step.selector) throw new CellFailure('no-selector', true);
+      const present = await driver.evaluate(`Boolean(document.querySelector(${JSON.stringify(step.selector)}))`);
+      if (!present) throw new CellFailure(`selector not rendered (${step.selector}); last=${describe(present)}`);
+      // 정적 export 는 React 가 넘겨받기(hydration) «전»에도 같은 DOM 을 보인다 — 그때 누르거나 친 글자는
+      // 상태에 안 닿는다(2026-09-27 실측: N5a 가 첫 창에서만 5초 시간 초과). 요소나 조상에 React 표식이 붙을 때까지 기다린다.
+      const hydrated = await poll(driver, hydratedJs(step.selector), 10_000, 100);
+      if (!hydrated) throw new CellFailure(`not hydrated (${step.selector}); last=${describe(hydrated)}`);
+      return driver.click(step.selector);
+    }
+  }
+}
+
+async function runCheck(driver: PageDriver, check: Check, onValue: (value: unknown) => void): Promise<unknown> {
+  return poll(driver, check.js, check.timeoutMs ?? 1_000, check.intervalMs ?? 100, onValue);
+}
+
+async function runHostCheck(driver: PageDriver, check: HostCheck, baseUrl: string, captured: Readonly<Record<string, unknown>>, onValue: (value: unknown) => void): Promise<boolean> {
+  const deadline = Date.now() + check.timeoutMs;
+  do {
+    const value = await driver.evaluate(check.js);
+    onValue(value);
+    if (await check.predicate(value, baseUrl, captured)) return true;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return false;
+    await new Promise<void>((resolve) => setTimeout(resolve, Math.min(check.intervalMs ?? 100, remaining)));
+  } while (true);
+}
+
+export async function runScenarios(driver: PageDriver, scenarios: readonly Scenario[], baseUrl: string, saveShot?: SaveShot): Promise<CellResult[]> {
+  const results: CellResult[] = [];
+  for (const scenario of scenarios) {
+    const start = Date.now();
+    const result: CellResult = { id: scenario.id, surface: scenario.surface, title: scenario.title, pass: false, ms: 0, evidence: [] };
+    try {
+      let llmBefore: number | undefined;
+      if (scenario.id === 'N6a') {
+        try {
+          llmBefore = await driver.llmCallCursor();
+          result.evidence.push(`LLM cursor before: ${llmBefore}`);
+        } catch (error) {
+          throw new CellFailure(`Check ${scenario.expect.length + 1} (LLM calls remain zero, baseline): ${String(error)}; last=unavailable`);
+        }
+      }
+      const url = new URL(scenario.path, `${baseUrl}/`).href;
+      let chipStart: number | undefined;
+      const captured: Record<string, unknown> = {};
+      for (const [index, step] of scenario.steps.entries()) {
+        try {
+          const boundedStep = step.kind === 'waitFor' && step.withinChipMs && chipStart !== undefined
+            ? { ...step, timeoutMs: Math.max(0, step.timeoutMs - (Date.now() - chipStart)) }
+            : step;
+          const value = await runStep(driver, boundedStep, url);
+          if (step.kind === 'capture') captured[step.key] = value;
+          if (scenario.id === 'N5a' && step.kind === 'type') chipStart = Date.now();
+          if (step.kind === 'waitFor' && step.measureChip && chipStart !== undefined) {
+            result.chipMs = Date.now() - chipStart;
+            result.evidence.push(`chipMs: ${result.chipMs}`);
+          }
+          if (step.kind === 'waitFor' && step.withinChipMs && chipStart !== undefined && Date.now() - chipStart > step.timeoutMs) {
+            throw new CellFailure(`absorb chip conditions exceeded ${step.timeoutMs}ms from insertion`);
+          }
+          result.evidence.push(`Step ${index + 1} (${step.kind}): ${step.kind === 'goto' ? url : describe(value)}`);
+        } catch (error) {
+          if (step.kind === 'waitFor' && step.measureChip && chipStart !== undefined) {
+            result.evidence.push(`chipMs: unavailable (chip not confirmed after ${Date.now() - chipStart}ms)`);
+          }
+          if (error instanceof CellFailure && error.blocked) result.blocked = 'no-selector';
+          const detail = error instanceof Error ? error.message : String(error);
+          result.evidence.push(`Step ${index + 1} (${step.kind}): ${detail}`);
+          throw new CellFailure(`Step ${index + 1} (${step.kind}): ${detail}`);
+        }
+      }
+      for (const [index, check] of scenario.expect.entries()) {
+        let last: unknown;
+        try {
+          last = await runCheck(driver, check, (value) => { last = value; });
+        } catch (error) {
+          result.evidence.push(`Check ${index + 1} (${check.expected}): last=${describe(last)}`);
+          throw new CellFailure(`Check ${index + 1} (${check.expected}): ${error instanceof Error ? error.message : String(error)}; last=${describe(last)}`);
+        }
+        result.evidence.push(`Check ${index + 1} (${check.expected}): last=${describe(last)}`);
+        if (!last) throw new CellFailure(`Check ${index + 1} (${check.expected}): last=${describe(last)}`);
+      }
+      for (const [index, check] of (scenario.hostCheck ?? []).entries()) {
+        let last: unknown;
+        let passed: boolean;
+        try {
+          passed = await runHostCheck(driver, check, baseUrl, captured, (value) => { last = value; });
+        } catch (error) {
+          const detail = error instanceof Error ? error.message : String(error);
+          result.evidence.push(`Host check ${index + 1} (${check.expected}): ${detail}; last=${describe(last)}`);
+          throw new CellFailure(`Host check ${index + 1} (${check.expected}): ${detail}; last=${describe(last)}`);
+        }
+        result.evidence.push(`Host check ${index + 1} (${check.expected}): last=${describe(last)}; pass=${passed}`);
+        if (!passed) throw new CellFailure(`Host check ${index + 1} (${check.expected}): last=${describe(last)}`);
+      }
+      if (llmBefore !== undefined) {
+        let llmAfter: number;
+        try { llmAfter = await driver.llmCallCursor(); }
+        catch (error) { throw new CellFailure(`Check ${scenario.expect.length + 1} (LLM calls remain zero): ${String(error)}; last=unavailable`); }
+        result.evidence.push(`LLM cursor after: ${llmAfter}; changed=${llmAfter !== llmBefore}`);
+        if (llmAfter !== llmBefore) throw new CellFailure(`Check ${scenario.expect.length + 1} (LLM calls remain zero): last=${llmBefore}→${llmAfter}`);
+        result.evidence.push(`Check ${scenario.expect.length + 1} (LLM calls remain zero): last=0`);
+      }
+      result.pass = true;
+    } catch (error) {
+      result.failure = error instanceof Error ? error.message : String(error);
+      if (saveShot) {
+        try {
+          const path = await saveShot(scenario.id, await driver.screenshot());
+          result.evidence.push(`screenshot: ${path}`);
+        } catch (shotError) {
+          result.evidence.push(`screenshot failed: ${String(shotError)}`);
+        }
+      }
+    }
+    result.ms = Date.now() - start;
+    results.push(result);
+  }
+  return results;
+}
+
+export function summarize(results: readonly CellResult[], baseUrl: string): string {
+  return `pwa-scenarios: pass ${results.filter((r) => r.pass).length} · fail ${results.filter((r) => !r.pass && !r.blocked).length} · blocked ${results.filter((r) => Boolean(r.blocked)).length} · base ${baseUrl}`;
+}

package/scripts/lib/pwa-scenarios/scenarios.ts

@@ -0,0 +1,202 @@
+import { randomBytes } from 'node:crypto';
+import { readTerminalReplay } from './acp-replay.js';
+
+export type Surface = 'terminal' | 'chat' | 'intake';
+export type Step =
+  | { kind: 'goto' }
+  | { kind: 'waitFor'; selector?: string; jsPredicate?: string; timeoutMs: number; intervalMs?: number; measureChip?: true; withinChipMs?: true }
+  | { kind: 'capture'; key: string; js: string; timeoutMs: number }
+  | { kind: 'type'; text: string }
+  | { kind: 'press'; key: string }
+  | { kind: 'click'; selector?: string };
+
+export interface Check {
+  /** Expression evaluated in the page; any truthy value passes. */
+  js: string;
+  expected: string;
+  timeoutMs?: number;
+  intervalMs?: number;
+}
+
+export interface HostCheck {
+  js: string;
+  expected: string;
+  timeoutMs: number;
+  intervalMs?: number;
+  predicate: (value: unknown, baseUrl: string, captured: Readonly<Record<string, unknown>>) => Promise<boolean>;
+}
+
+export interface Scenario {
+  id: string;
+  surface: Surface;
+  path: string;
+  title: string;
+  steps: Step[];
+  expect: Check[];
+  hostCheck?: HostCheck[];
+  /** Calls a real model (costs a turn). Runs only when named in `--only`. */
+  costly?: true;
+}
+
+const selector = (css: string): string => `Boolean(document.querySelector(${JSON.stringify(css)}))`;
+const tab = 'button[aria-label^="switch to "]';
+const terminal = '.xterm';
+const connected = '[aria-live="polite"]';
+// ChatInput 의 입력창(`apps/pwa/src/components/chat/ChatInput.tsx` placeholder) — testid 가 없어 placeholder 로 고른다.
+const chatInput = 'textarea[placeholder^="message"]';
+const intakeField = '[data-testid="intake-front-door-field"]';
+const terminalIdentity = `(() => { const sessionId = localStorage.getItem('elanous.daemon.sessionId'); const terminalId = Array.from(document.querySelectorAll('button[aria-label^="switch to "]')).find(node => node.title?.includes('지금 보는 터미널'))?.getAttribute('aria-label')?.slice('switch to '.length); return sessionId && terminalId ? { sessionId, terminalId } : null; })()`;
+const identity = (value: unknown): { sessionId: string; terminalId: string } | null => {
+  if (!value || typeof value !== 'object') return null;
+  const { sessionId, terminalId } = value as Record<string, unknown>;
+  return typeof sessionId === 'string' && sessionId.length > 0 && typeof terminalId === 'string' && terminalId.length > 0
+    ? { sessionId, terminalId } : null;
+};
+
+async function replayContains(value: unknown, baseUrl: string, text: string, count: number, readReplay: typeof readTerminalReplay): Promise<boolean> {
+  const ids = identity(value);
+  if (!ids) return false;
+  const snapshot = await readReplay({ baseUrl, ...ids, timeoutMs: 2_000 });
+  return snapshot.split(text).length - 1 >= count;
+}
+
+/** `--only` picks exactly those IDs; without it, every scenario except the costly ones (they call a real model). */
+export function selectScenarios(all: readonly Scenario[], only?: readonly string[]): { selected: Scenario[]; unknown: string[] } {
+  const requested = new Set(only ?? all.filter((s) => !s.costly).map((s) => s.id));
+  return {
+    selected: all.filter((s) => requested.has(s.id)),
+    unknown: [...requested].filter((id) => !all.some((s) => s.id === id)),
+  };
+}
+
+/** Fresh data per invocation: the terminal marker must not match earlier scrollback. */
+export function createScenarios(): Scenario[] {
+  return createScenariosWithReplay(readTerminalReplay);
+}
+
+/** Testable replay seam; production always uses the daemon-backed reader. */
+export function createScenariosWithReplay(readReplay: typeof readTerminalReplay): Scenario[] {
+  const marker = `pwa-scn-${randomBytes(8).toString('hex')}`;
+  const t1bMarker = `pwa-scn-${randomBytes(8).toString('hex')}`;
+  // C1 — the answer (n+1) never appears in the question, so finding it on the page means a model replied.
+  const c1Base = 1000 + (randomBytes(2).readUInt16BE(0) % 8000);
+  return [
+    {
+      id: 'T1', surface: 'terminal', path: '/app/term/', title: 'xterm and a tab',
+      steps: [{ kind: 'goto' }, { kind: 'waitFor', selector: terminal, timeoutMs: 20_000 }, { kind: 'waitFor', selector: tab, timeoutMs: 20_000 }],
+      expect: [
+        { js: selector(terminal), expected: 'xterm screen is mounted' },
+        { js: `document.querySelectorAll(${JSON.stringify(tab)}).length >= 1`, expected: 'at least one terminal tab' },
+      ],
+    },
+    {
+      id: 'T1b', surface: 'terminal', path: '/app/term/', title: 'no unknown terminal relationship',
+      steps: [
+        { kind: 'goto' }, { kind: 'waitFor', selector: terminal, timeoutMs: 20_000 },
+        { kind: 'waitFor', selector: tab, timeoutMs: 20_000 },
+        { kind: 'waitFor', jsPredicate: `Array.from(document.querySelectorAll(${JSON.stringify(connected)})).some(node => node.textContent?.includes('ACP: 연결됨'))`, timeoutMs: 20_000 },
+        { kind: 'click', selector: terminal }, { kind: 'type', text: `echo ${t1bMarker}` }, { kind: 'press', key: 'Enter' },
+      ],
+      expect: [],
+      hostCheck: [{
+        js: `(() => { const ids = ${terminalIdentity}; if (!ids) return null; return { ...ids, tabsClean: Array.from(document.querySelectorAll(${JSON.stringify(tab)})).every(node => !node.textContent?.includes('이 행에서는 알 수 없음')), paneClean: Array.from(document.querySelectorAll('[data-pane-relationship]')).every(node => !node.textContent?.includes('관계를 알 수 없어 배치하지 않았습니다')) }; })()`,
+        expected: 'two echo markers in replay, no unknown relationship message in terminal replay, pane or tab', timeoutMs: 20_000,
+        predicate: async (value, baseUrl) => {
+          const ids = identity(value);
+          if (!ids) return false;
+          const snapshot = await readReplay({ baseUrl, ...ids, timeoutMs: 2_000 });
+          return snapshot.split(t1bMarker).length - 1 >= 2
+            && !snapshot.includes('관계를 알 수 없어 배치하지 않았습니다')
+            && (value as { tabsClean?: unknown; paneClean?: unknown }).tabsClean === true
+            && (value as { paneClean?: unknown }).paneClean === true;
+        },
+      }],
+    },
+    {
+      id: 'T4a', surface: 'terminal', path: '/app/term/', title: 'terminal echo round-trip',
+      steps: [
+        { kind: 'goto' }, { kind: 'waitFor', selector: terminal, timeoutMs: 20_000 },
+        { kind: 'waitFor', selector: tab, timeoutMs: 20_000 },
+        { kind: 'waitFor', jsPredicate: `Array.from(document.querySelectorAll(${JSON.stringify(connected)})).some(node => node.textContent?.includes('ACP: 연결됨'))`, timeoutMs: 20_000 },
+        { kind: 'click', selector: terminal }, { kind: 'type', text: `echo ${marker}` }, { kind: 'press', key: 'Enter' },
+      ],
+      expect: [],
+      hostCheck: [{ js: terminalIdentity, expected: `replay contains ${marker} twice (input echo and output)`, timeoutMs: 20_000,
+        predicate: (value, baseUrl) => replayContains(value, baseUrl, marker, 2, readReplay) }],
+    },
+    {
+      id: 'T5', surface: 'terminal', path: '/app/term/', title: 'terminal reload keeps one shell',
+      steps: [{ kind: 'goto' }, { kind: 'waitFor', selector: tab, timeoutMs: 20_000 },
+        { kind: 'capture', key: 'first', js: terminalIdentity, timeoutMs: 20_000 },
+        { kind: 'goto' }, { kind: 'waitFor', selector: tab, timeoutMs: 20_000 },
+        { kind: 'capture', key: 'second', js: terminalIdentity, timeoutMs: 20_000 },
+        { kind: 'goto' }, { kind: 'waitFor', selector: tab, timeoutMs: 20_000 },
+        { kind: 'capture', key: 'third', js: terminalIdentity, timeoutMs: 20_000 }],
+      expect: [],
+      hostCheck: [{ js: terminalIdentity, expected: 'same tab ID on three opens and one web-registration row', timeoutMs: 10_000,
+        predicate: async (value, baseUrl, captured) => {
+          const ids = identity(value);
+          const first = identity(captured.first);
+          const second = identity(captured.second);
+          const third = identity(captured.third);
+          if (!ids || !first || !second || !third) return false;
+          if (first.terminalId !== second.terminalId || second.terminalId !== third.terminalId || third.terminalId !== ids.terminalId) return false;
+          const response = await fetch(`${baseUrl}/v1/terminals`, { headers: { Origin: baseUrl }, signal: AbortSignal.timeout(5_000) });
+          if (!response.ok) throw new Error(`terminal list HTTP ${response.status}`);
+          const body = await response.json() as { terminals?: Array<{ id?: string; producer?: string }> };
+          if (!Array.isArray(body.terminals)) throw new Error('invalid terminal list response');
+          return body.terminals.filter((row) => row.producer === 'web-registration' && row.id === ids.terminalId).length === 1;
+        } }],
+    },
+    {
+      id: 'C1', surface: 'chat', path: '/app/chat/', title: 'first message streams a model reply', costly: true,
+      steps: [{ kind: 'goto' }, { kind: 'waitFor', selector: chatInput, timeoutMs: 20_000 }, { kind: 'click', selector: chatInput }, { kind: 'type', text: `Reply with only the number that is one more than ${c1Base}.` }, { kind: 'press', key: 'Enter' }],
+      expect: [{ js: `document.body.innerText.includes(${JSON.stringify(String(c1Base + 1))})`, expected: `a model reply containing ${c1Base + 1} appears`, timeoutMs: 120_000, intervalMs: 1_000 }],
+    },
+    {
+      id: 'C2a', surface: 'chat', path: '/app/chat/', title: 'local meta command help',
+      steps: [{ kind: 'goto' }, { kind: 'waitFor', selector: chatInput, timeoutMs: 20_000 }, { kind: 'click', selector: chatInput }, { kind: 'type', text: ':help' }, { kind: 'press', key: 'Enter' }],
+      expect: [{ js: `Array.from(document.querySelectorAll('pre')).some(node => node.textContent?.includes('Meta commands'))`, expected: 'message list shows Meta commands', timeoutMs: 10_000 }],
+    },
+    {
+      id: 'C2b', surface: 'chat', path: '/app/chat/', title: 'slash help aliases local meta command',
+      steps: [{ kind: 'goto' }, { kind: 'waitFor', selector: chatInput, timeoutMs: 20_000 }, { kind: 'click', selector: chatInput }, { kind: 'type', text: '/help' }, { kind: 'press', key: 'Enter' }],
+      expect: [{ js: `Array.from(document.querySelectorAll('pre')).some(node => node.textContent?.includes('Meta commands'))`, expected: 'message list shows Meta commands for /help', timeoutMs: 10_000 }],
+    },
+    {
+      id: 'N1', surface: 'intake', path: '/app/intake/', title: 'empty field disables actions',
+      steps: [{ kind: 'goto' }, { kind: 'waitFor', selector: intakeField, timeoutMs: 20_000 },
+        ...['intake-absorb', 'intake-split', 'intake-graph'].map((id): Step => ({ kind: 'waitFor', selector: `[data-testid="${id}"]`, timeoutMs: 5_000 }))],
+      expect: [{ js: `['intake-absorb','intake-split','intake-graph'].every(id => document.querySelector('[data-testid="' + id + '"]')?.hasAttribute('disabled'))`, expected: 'all three action buttons disabled for empty input' }],
+    },
+    {
+      id: 'N5a', surface: 'intake', path: '/app/intake/', title: 'URL previews absorb without submitting',
+      steps: [{ kind: 'goto' }, { kind: 'waitFor', selector: intakeField, timeoutMs: 20_000 }, { kind: 'click', selector: intakeField }, { kind: 'type', text: 'https://example.com' },
+        { kind: 'waitFor', jsPredicate: `(() => { const chip = document.querySelector('[data-testid="intake-route-chip"]'); return Boolean(chip && chip.getClientRects().length); })()`, timeoutMs: 5_000, measureChip: true },
+        { kind: 'waitFor', jsPredicate: `(() => { const chip = document.querySelector('[data-testid="intake-route-chip"]'); return chip?.getAttribute('data-auto-submit') === '0' && chip.querySelector('[data-testid="intake-route-chip-label"]')?.textContent?.includes('흡수'); })()`, timeoutMs: 5_000, withinChipMs: true }],
+      expect: [{ js: `(() => { const chip = document.querySelector('[data-testid="intake-route-chip"]'); return chip?.getAttribute('data-auto-submit') === '0' && chip.querySelector('[data-testid="intake-route-chip-label"]')?.textContent?.includes('흡수'); })()`, expected: 'absorb chip within 5s and data-auto-submit=0', timeoutMs: 0 }],
+    },
+    {
+      id: 'N6a', surface: 'intake', path: '/app/intake/', title: 'unknown rule offers classification without invoking LLM',
+      steps: [{ kind: 'goto' }, { kind: 'waitFor', selector: intakeField, timeoutMs: 20_000 }, { kind: 'click', selector: intakeField }, { kind: 'type', text: '안녕' },
+        { kind: 'waitFor', selector: '[data-testid="intake-route-chip"]', timeoutMs: 5_000 }],
+      expect: [{ js: `(() => { const button = document.querySelector('[data-testid="intake-route-chip"] [data-testid="intake-route-classify"]'); return Boolean(button && button.getClientRects().length); })()`, expected: 'classification button visible; never clicked (no LLM call)', timeoutMs: 5_000 }],
+    },
+  ];
+}
+
+/** Return a canonical loopback origin; disallow credentials, paths and non-local hosts. */
+export function validateBaseUrl(input: string, allowPort = false): string {
+  const explicit = /^http:\/\/127\.0\.0\.1:(\d+)\/?$/.exec(input);
+  let url: URL;
+  try { url = new URL(input); } catch { throw new Error('base URL must be http://127.0.0.1:PORT'); }
+  const port = Number(explicit?.[1]);
+  if (!explicit || url.protocol !== 'http:' || url.hostname !== '127.0.0.1' || !Number.isInteger(port)
+      || port < 1 || port > 65535 || url.username || url.password || url.pathname !== '/' || url.search || url.hash) {
+    throw new Error('base URL must be http://127.0.0.1:PORT');
+  }
+  if (!allowPort && (port < 31450 || port > 31499 || [31415, 31420, 31421].includes(port))) {
+    throw new Error(`port ${port} refused: use isolated daemon port 31450–31499 (or --allow-port)`);
+  }
+  return `http://127.0.0.1:${port}`;
+}