elanous 0.2.0 → 0.2.5

package/scripts/lib/front-route-measurement.ts

@@ -0,0 +1,131 @@
+import { classifyIntakeFrontRoute } from '../../src/intake-plane/front-route-classifier.js';
+import { INTAKE_FRONT_ROUTE_TRACKS, type IntakeFrontRouteDecision, type IntakeFrontRouteTrack } from '../../src/intake-plane/front-route-rules.js';
+import type { ResolveRoleProviderFn } from '../../src/intake-plane/runtime-callables.js';
+import { wilsonInterval, type WilsonInterval } from './nl-routing-measurement.js';
+
+export interface FrontRouteItem { id: string; text: string; expected: IntakeFrontRouteTrack }
+export interface FrontRouteCorpus { description: string; items: FrontRouteItem[] }
+export type FrontRouteConfusion = Record<IntakeFrontRouteTrack, Record<IntakeFrontRouteTrack, number>>;
+export interface FrontRouteProviderResult {
+  label: string;
+  runs: number;
+  agree: number;
+  agreement: number;
+  wilson: WilsonInterval | null;
+  askHuman: number;
+  confusion: FrontRouteConfusion;
+  meanLatencyMs: number;
+  perItem: { id: string; expected: IntakeFrontRouteTrack; got: IntakeFrontRouteTrack[] }[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isTrack(value: unknown): value is IntakeFrontRouteTrack {
+  return typeof value === 'string' && (INTAKE_FRONT_ROUTE_TRACKS as readonly string[]).includes(value);
+}
+
+export function loadFrontRouteCorpus(json: unknown): FrontRouteCorpus {
+  const parsed: unknown = typeof json === 'string' ? JSON.parse(json) : json;
+  if (!isRecord(parsed) || typeof parsed.description !== 'string' || !Array.isArray(parsed.items) || parsed.items.length === 0) {
+    throw new Error('Front-route corpus requires a description and nonempty items array');
+  }
+  const ids = new Set<string>();
+  const items: FrontRouteItem[] = parsed.items.map((raw: unknown, index: number) => {
+    if (!isRecord(raw) || typeof raw.id !== 'string' || !raw.id.trim() ||
+      typeof raw.text !== 'string' || !raw.text.trim() || !isTrack(raw.expected)) {
+      throw new Error(`Invalid front-route corpus item at index ${index} (id, text, expected track required)`);
+    }
+    if (ids.has(raw.id)) throw new Error(`Duplicate front-route corpus id at index ${index}`);
+    ids.add(raw.id);
+    return { id: raw.id, text: raw.text, expected: raw.expected };
+  });
+  return { description: parsed.description, items };
+}
+
+function emptyConfusion(): FrontRouteConfusion {
+  return Object.fromEntries(INTAKE_FRONT_ROUTE_TRACKS.map((expected) => [expected,
+    Object.fromEntries(INTAKE_FRONT_ROUTE_TRACKS.map((got) => [got, 0])),
+  ])) as FrontRouteConfusion;
+}
+
+export async function measureFrontRoute(
+  items: readonly FrontRouteItem[],
+  { providers, runs, classify = classifyIntakeFrontRoute, now = () => performance.now() }: {
+    providers: readonly { label: string; resolve: ResolveRoleProviderFn }[];
+    runs: number;
+    classify?: typeof classifyIntakeFrontRoute;
+    now?: () => number;
+  },
+): Promise<FrontRouteProviderResult[]> {
+  if (!Number.isSafeInteger(runs) || runs < 1) throw new Error('runs must be a positive integer');
+  if (!items.length || !providers.length) throw new Error('items and providers must not be empty');
+  if (new Set(providers.map(({ label }) => label)).size !== providers.length || providers.some(({ label }) => !label.trim())) {
+    throw new Error('provider labels must be unique and nonempty');
+  }
+  // An id can contain another item's text, too: sanitize against the whole corpus.
+  const texts = items.map(({ text }) => text);
+  const exposesText = (id: string) => texts.some((text) => id.includes(text));
+  const safeIds = new Set(items.filter(({ id }) => !exposesText(id)).map(({ id }) => id));
+  const reportIds = items.map(({ id }, index) => {
+    if (!exposesText(id)) return id;
+    let candidate = `item-${index + 1}`;
+    if (exposesText(candidate) || safeIds.has(candidate)) {
+      let codePoint = 0xe000;
+      while (texts.some((text) => text.includes(String.fromCodePoint(codePoint)))) codePoint++;
+      const unused = String.fromCodePoint(codePoint);
+      candidate = unused;
+      while (safeIds.has(candidate)) candidate += unused;
+    }
+    safeIds.add(candidate);
+    return candidate;
+  });
+  const results: FrontRouteProviderResult[] = [];
+  for (const { label, resolve } of providers) {
+    const confusion = emptyConfusion();
+    const perItem: FrontRouteProviderResult['perItem'] = [];
+    let agree = 0;
+    let askHuman = 0;
+    let latencyMs = 0;
+    for (const [index, item] of items.entries()) {
+      const got: IntakeFrontRouteTrack[] = [];
+      for (let repeat = 0; repeat < runs; repeat++) {
+        const started = now();
+        let decision: IntakeFrontRouteDecision;
+        try {
+          decision = await classify(item.text, { resolveRoleProvider: resolve });
+        } catch {
+          decision = { track: 'ask-human', confidence: 0, reason: 'classifier-failed:llm-error', decidedBy: 'classifier' };
+        } finally {
+          latencyMs += now() - started;
+        }
+        if (!isTrack(decision.track)) throw new Error(`Invalid classifier track for item ${reportIds[index]}`);
+        got.push(decision.track);
+        confusion[item.expected][decision.track]++;
+        if (decision.track === item.expected) agree++;
+        if (decision.track === 'ask-human' &&
+          (decision.reason.startsWith('classifier-low-confidence:') || decision.reason.startsWith('classifier-failed:'))) askHuman++;
+      }
+      perItem.push({ id: reportIds[index]!, expected: item.expected, got });
+    }
+    const total = items.length * runs;
+    results.push({ label, runs: total, agree, agreement: agree / total, wilson: wilsonInterval(agree, total), askHuman,
+      confusion, meanLatencyMs: latencyMs / total, perItem });
+  }
+  return results;
+}
+
+export function formatFrontRouteReport(result: readonly FrontRouteProviderResult[]): string {
+  const percent = (n: number) => `${(100 * n).toFixed(1)}%`;
+  const lines = ['Provider | Agreement | 95% Wilson | ask-human (low confidence/failure) | Mean latency ms'];
+  for (const provider of result) {
+    const interval = provider.wilson;
+    lines.push(`${provider.label} | ${provider.agree}/${provider.runs} (${percent(provider.agreement)}) | ${interval ? `${percent(interval.lower)}–${percent(interval.upper)}` : 'n/a'} | ${provider.askHuman} | ${provider.meanLatencyMs.toFixed(1)}`);
+    lines.push(`Confusion (${provider.label}): expected \\ got | ${INTAKE_FRONT_ROUTE_TRACKS.join(' | ')}`);
+    for (const expected of INTAKE_FRONT_ROUTE_TRACKS) {
+      lines.push(`${expected} | ${INTAKE_FRONT_ROUTE_TRACKS.map((got) => provider.confusion[expected][got]).join(' | ')}`);
+    }
+  }
+  return lines.join('\n');
+}

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}`;
+}