@pro-vi/designer 0.3.9 → 0.3.11

package/dist/scripts/trace-analyze.js

@@ -0,0 +1,366 @@
+#!/usr/bin/env -S node --import tsx
+import fs from 'node:fs';
+import path from 'node:path';
+function asRec(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+function num(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+}
+function normalizeEndpoint(url) {
+    try {
+        const u = new URL(url);
+        const p = u.pathname.replace(/[0-9a-f]{8}-[0-9a-f-]{27,}/gi, ':id').replace(/\/\d{4,}/g, '/:n');
+        return u.origin + p;
+    }
+    catch {
+        return url.slice(0, 120);
+    }
+}
+function pct(sorted, p) {
+    if (sorted.length === 0)
+        return 0;
+    const idx = Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length));
+    return sorted[idx] ?? 0;
+}
+function ms(n) {
+    return `${Math.round(n)}ms`;
+}
+function main() {
+    const argPath = process.argv[2];
+    if (!argPath) {
+        console.error('Usage: trace-analyze.ts <traceDir | trace.jsonl>');
+        process.exit(1);
+    }
+    const dir = argPath.endsWith('.jsonl') ? path.dirname(argPath) : argPath;
+    const jsonlPath = argPath.endsWith('.jsonl') ? argPath : path.join(dir, 'trace.jsonl');
+    const manifestPath = path.join(dir, 'manifest.json');
+    let manifest = {};
+    if (fs.existsSync(manifestPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            manifest = asRec(parsed);
+        }
+        catch {
+            manifest = {};
+        }
+    }
+    const reqs = new Map();
+    const sockets = new Map();
+    const domSamples = [];
+    const markers = [];
+    let monoToWallOffset = null;
+    let firstTs = Infinity;
+    let lastTs = 0;
+    let totalLines = 0;
+    for (const line of fs.readFileSync(jsonlPath, 'utf8').split('\n')) {
+        if (!line.trim())
+            continue;
+        totalLines++;
+        let ev;
+        try {
+            const parsed = JSON.parse(line);
+            ev = asRec(parsed);
+        }
+        catch {
+            continue;
+        }
+        const ts = num(ev.ts) ?? 0;
+        if (ts) {
+            firstTs = Math.min(firstTs, ts);
+            lastTs = Math.max(lastTs, ts);
+        }
+        if (ev.kind === 'dom-sample') {
+            domSamples.push({ ts, sample: asRec(ev.sample) });
+            continue;
+        }
+        if (ev.kind === 'recorder') {
+            const detail = asRec(ev.detail);
+            if (ev.event === 'marker')
+                markers.push({ ts, name: String(detail.name || ''), detail });
+            continue;
+        }
+        if (ev.kind !== 'cdp')
+            continue;
+        const method = String(ev.method || '');
+        const p = asRec(ev.params);
+        const requestId = typeof p.requestId === 'string' ? p.requestId : null;
+        if (method === 'Network.requestWillBeSent' && requestId) {
+            const req = asRec(p.request);
+            const mono = num(p.timestamp);
+            const wall = num(p.wallTime);
+            if (mono !== null && wall !== null && monoToWallOffset === null)
+                monoToWallOffset = wall - mono;
+            reqs.set(requestId, {
+                requestId,
+                url: String(req.url || ''),
+                method: String(req.method || 'GET'),
+                resourceType: typeof p.type === 'string' ? p.type : null,
+                mimeType: null,
+                status: null,
+                hasContentLength: false,
+                sentMono: mono,
+                sentWall: wall,
+                responseMono: null,
+                finishedMono: null,
+                failed: null,
+                fromCache: false,
+                chunks: [],
+                sseMessages: 0
+            });
+        }
+        else if (requestId && reqs.has(requestId)) {
+            const r = reqs.get(requestId);
+            if (method === 'Network.responseReceived') {
+                const resp = asRec(p.response);
+                r.mimeType = typeof resp.mimeType === 'string' ? resp.mimeType : null;
+                r.status = num(resp.status);
+                r.responseMono = num(p.timestamp);
+                const headers = asRec(resp.headers);
+                r.hasContentLength = Object.keys(headers).some((k) => k.toLowerCase() === 'content-length');
+            }
+            else if (method === 'Network.dataReceived') {
+                r.chunks.push({
+                    mono: num(p.timestamp) ?? 0,
+                    bytes: num(p.dataLength) ?? 0,
+                    encodedBytes: num(p.encodedDataLength) ?? 0
+                });
+            }
+            else if (method === 'Network.loadingFinished') {
+                r.finishedMono = num(p.timestamp);
+            }
+            else if (method === 'Network.loadingFailed') {
+                r.failed = String(p.errorText || 'failed') + (p.canceled === true ? ' (canceled)' : '');
+                r.finishedMono = num(p.timestamp);
+            }
+            else if (method === 'Network.requestServedFromCache') {
+                r.fromCache = true;
+            }
+            else if (method === 'Network.eventSourceMessageReceived') {
+                r.sseMessages++;
+            }
+        }
+        if (method === 'Network.webSocketCreated' && requestId) {
+            sockets.set(requestId, {
+                requestId,
+                url: String(p.url || ''),
+                framesSent: 0,
+                framesReceived: 0,
+                bytesReceived: 0,
+                closed: false
+            });
+        }
+        else if (requestId && sockets.has(requestId)) {
+            const s = sockets.get(requestId);
+            if (method === 'Network.webSocketFrameSent')
+                s.framesSent++;
+            if (method === 'Network.webSocketFrameReceived') {
+                s.framesReceived++;
+                const resp = asRec(p.response);
+                s.bytesReceived += typeof resp.payloadData === 'string' ? resp.payloadData.length : num(resp.payloadBytes) ?? 0;
+            }
+            if (method === 'Network.webSocketClosed')
+                s.closed = true;
+        }
+    }
+    const monoToWall = (mono) => mono !== null && monoToWallOffset !== null ? (mono + monoToWallOffset) * 1000 : null;
+    const streamKind = (r) => {
+        if (r.sseMessages > 0 || r.mimeType === 'text/event-stream')
+            return 'sse';
+        const span = r.chunks.length >= 2 ? (r.chunks[r.chunks.length - 1]?.mono ?? 0) - (r.chunks[0]?.mono ?? 0) : 0;
+        if (r.chunks.length >= 3 && span > 1 && !r.hasContentLength)
+            return 'fetch-chunked';
+        return 'plain';
+    };
+    const endpoints = new Map();
+    for (const r of reqs.values()) {
+        const key = normalizeEndpoint(r.url);
+        const e = endpoints.get(key) || { hits: 0, methods: new Set(), kinds: new Set(), bytes: 0, sentWalls: [] };
+        e.hits++;
+        e.methods.add(r.method);
+        e.kinds.add(streamKind(r));
+        e.bytes += r.chunks.reduce((a, c) => a + c.encodedBytes, 0);
+        const w = monoToWall(r.sentMono);
+        if (w !== null)
+            e.sentWalls.push(w);
+        endpoints.set(key, e);
+    }
+    const iterStart = markers.find((m) => m.name === 'iterate-start')?.ts ?? null;
+    let main_ = null;
+    let mainScore = -1;
+    for (const r of reqs.values()) {
+        if (!/^https:\/\/claude\.ai\//.test(r.url))
+            continue;
+        if (r.method !== 'POST')
+            continue;
+        const span = r.responseMono !== null && r.finishedMono !== null ? r.finishedMono - r.responseMono : 0;
+        let score = span * 1000 + r.chunks.length;
+        const w = monoToWall(r.sentMono);
+        if (iterStart !== null && w !== null && w >= iterStart - 1000 && w <= iterStart + 5000)
+            score += 100_000;
+        if (score > mainScore) {
+            mainScore = score;
+            main_ = r;
+        }
+    }
+    const lines = [];
+    const out = (s = '') => {
+        lines.push(s);
+    };
+    const m = manifest;
+    out(`# Trace summary — ${m.scenario ?? path.basename(dir)}`);
+    out();
+    out(`- file: \`${jsonlPath}\``);
+    out(`- span: ${((lastTs - firstTs) / 1000).toFixed(1)}s | lines: ${totalLines} | requests: ${reqs.size} | sockets: ${sockets.size} | dom-samples: ${domSamples.length}`);
+    if (m.iterate)
+        out(`- iterate: failureMode=${m.iterate.failureMode} elapsed=${Math.round((m.iterate.elapsedMs ?? 0) / 1000)}s`);
+    for (const mk of markers)
+        out(`- marker \`${mk.name}\` @ +${((mk.ts - firstTs) / 1000).toFixed(1)}s`);
+    out();
+    out(`## Endpoints`);
+    out();
+    out(`| endpoint | hits | methods | kind | bytes | periodicity |`);
+    out(`|---|---|---|---|---|---|`);
+    const sortedEndpoints = [...endpoints.entries()].sort((a, b) => b[1].bytes - a[1].bytes || b[1].hits - a[1].hits);
+    for (const [ep, e] of sortedEndpoints) {
+        const walls = e.sentWalls.sort((x, y) => x - y);
+        const gaps = [];
+        for (let i = 1; i < walls.length; i++)
+            gaps.push((walls[i] ?? 0) - (walls[i - 1] ?? 0));
+        gaps.sort((x, y) => x - y);
+        const period = gaps.length >= 2 ? `~${(pct(gaps, 50) / 1000).toFixed(1)}s` : '';
+        out(`| ${ep.replace(/^https:\/\//, '')} | ${e.hits} | ${[...e.methods].join(',')} | ${[...e.kinds].join(',')} | ${e.bytes} | ${period} |`);
+    }
+    out();
+    if (main_) {
+        const kind = streamKind(main_);
+        out(`## Main generation request`);
+        out();
+        out(`**Verdict: generation streams via \`${kind}\` at \`${main_.method} ${normalizeEndpoint(main_.url)}\`** (status ${main_.status}, mime ${main_.mimeType})`);
+        out();
+        const t0 = main_.sentMono ?? 0;
+        out(`- request sent: t0${iterStart !== null && monoToWall(t0) !== null ? ` (+${((monoToWall(t0) - iterStart) / 1000).toFixed(1)}s after iterate-start)` : ''}`);
+        if (main_.responseMono !== null)
+            out(`- response headers: t0+${ms((main_.responseMono - t0) * 1000)}`);
+        if (main_.finishedMono !== null)
+            out(`- loading finished: t0+${((main_.finishedMono - t0)).toFixed(1)}s${main_.failed ? ` (FAILED: ${main_.failed})` : ''}`);
+        out(`- chunks: ${main_.chunks.length} | total encoded bytes: ${main_.chunks.reduce((a, c) => a + c.encodedBytes, 0)}`);
+        out();
+        const gaps = [];
+        for (let i = 1; i < main_.chunks.length; i++) {
+            gaps.push(((main_.chunks[i]?.mono ?? 0) - (main_.chunks[i - 1]?.mono ?? 0)) * 1000);
+        }
+        if (gaps.length) {
+            const sorted = [...gaps].sort((a, b) => a - b);
+            const mean = gaps.reduce((a, b) => a + b, 0) / gaps.length;
+            out(`### Inter-chunk gaps (candidate STALLED thresholds)`);
+            out();
+            out(`max ${ms(sorted[sorted.length - 1] ?? 0)} | p95 ${ms(pct(sorted, 95))} | p50 ${ms(pct(sorted, 50))} | mean ${ms(mean)}`);
+            out();
+            out(`→ a STALLED detector needs its no-chunk timeout comfortably above max (e.g. ${Math.ceil(((sorted[sorted.length - 1] ?? 0) * 3) / 1000)}s).`);
+            out();
+        }
+        const lastChunkWall = monoToWall(main_.chunks[main_.chunks.length - 1]?.mono ?? null);
+        const finishedWall = monoToWall(main_.finishedMono);
+        out(`### Network-quiet vs DOM-stable`);
+        out();
+        if (lastChunkWall !== null)
+            out(`- last chunk of main request: +${((lastChunkWall - firstTs) / 1000).toFixed(1)}s`);
+        if (finishedWall !== null)
+            out(`- main request finished: +${((finishedWall - firstTs) / 1000).toFixed(1)}s`);
+        let lastTurnChange = null;
+        let lastIframeChange = null;
+        let prevTurns = null;
+        let prevIframe = null;
+        for (const d of domSamples) {
+            if (d.sample.chatTurnCount !== prevTurns) {
+                if (prevTurns !== null)
+                    lastTurnChange = d.ts;
+                prevTurns = d.sample.chatTurnCount;
+            }
+            if (d.sample.iframeSrc !== prevIframe) {
+                if (prevIframe !== null)
+                    lastIframeChange = d.ts;
+                prevIframe = d.sample.iframeSrc;
+            }
+        }
+        if (lastTurnChange !== null)
+            out(`- last chatTurnCount change (dom): +${((lastTurnChange - firstTs) / 1000).toFixed(1)}s`);
+        if (lastIframeChange !== null)
+            out(`- last iframeSrc change (dom): +${((lastIframeChange - firstTs) / 1000).toFixed(1)}s`);
+        const stopSeen = domSamples.filter((d) => d.sample.stopProbe).length;
+        out(`- dom-samples with a visible stop/cancel button: ${stopSeen}/${domSamples.length}`);
+        const probes = domSamples.map((d) => d.sample.stopProbe).filter(Boolean);
+        if (probes.length)
+            out(`- stop-button probe: \`${JSON.stringify(probes[0]).slice(0, 300)}\``);
+        out();
+    }
+    else {
+        out(`## Main generation request`);
+        out();
+        out(`(none identified — expected for idle/quota traces)`);
+        out();
+    }
+    const byRpc = (name) => [...reqs.values()]
+        .filter((r) => r.url.includes(`OmeletteService/${name}`))
+        .sort((a, b) => (a.sentMono ?? 0) - (b.sentMono ?? 0));
+    const renews = byRpc('RenewTurn');
+    const releases = byRpc('ReleaseTurn');
+    const chats = byRpc('Chat');
+    if (renews.length || releases.length || chats.length) {
+        out(`## Turn lifecycle (OmeletteService)`);
+        out();
+        if (chats.length) {
+            out(`Chat segments: ${chats.length}`);
+            for (const c of chats.slice(0, 40)) {
+                const w = monoToWall(c.sentMono);
+                const dur = c.responseMono !== null && c.finishedMono !== null ? c.finishedMono - c.responseMono : 0;
+                out(`- +${w !== null ? ((w - firstTs) / 1000).toFixed(1) : '?'}s dur=${dur.toFixed(1)}s chunks=${c.chunks.length} bytes=${c.chunks.reduce((a, ch) => a + ch.encodedBytes, 0)}${c.failed ? ` FAILED: ${c.failed}` : ''}`);
+            }
+            out();
+        }
+        if (renews.length >= 2) {
+            const walls = renews.map((r) => monoToWall(r.sentMono)).filter((w) => w !== null);
+            const gaps = [];
+            for (let i = 1; i < walls.length; i++)
+                gaps.push((walls[i] ?? 0) - (walls[i - 1] ?? 0));
+            gaps.sort((a, b) => a - b);
+            const firstW = walls[0] ?? 0;
+            const lastW = walls[walls.length - 1] ?? 0;
+            out(`RenewTurn: ${renews.length} calls, median gap ${(pct(gaps, 50) / 1000).toFixed(1)}s, first +${((firstW - firstTs) / 1000).toFixed(1)}s, last +${((lastW - firstTs) / 1000).toFixed(1)}s`);
+        }
+        for (const rel of releases) {
+            const w = monoToWall(rel.sentMono);
+            out(`ReleaseTurn: +${w !== null ? ((w - firstTs) / 1000).toFixed(1) : '?'}s ← discrete FINISHED candidate`);
+        }
+        const iterDone = markers.find((mk) => mk.name === 'iterate-done')?.ts ?? null;
+        if (releases.length && iterDone !== null) {
+            const w = monoToWall(releases[releases.length - 1]?.sentMono ?? null);
+            if (w !== null)
+                out(`→ ReleaseTurn led the controller's HTML-stability verdict (iterate-done) by ${((iterDone - w) / 1000).toFixed(1)}s`);
+        }
+        out();
+    }
+    if (sockets.size) {
+        out(`## WebSockets`);
+        out();
+        for (const s of sockets.values()) {
+            out(`- ${s.url.slice(0, 100)} — frames sent ${s.framesSent} / recv ${s.framesReceived}, recv bytes ${s.bytesReceived}${s.closed ? ', closed' : ''}`);
+        }
+        out();
+    }
+    const failed = [...reqs.values()].filter((r) => r.failed);
+    if (failed.length) {
+        out(`## Failed requests`);
+        out();
+        for (const r of failed)
+            out(`- ${r.method} ${normalizeEndpoint(r.url)} — ${r.failed}`);
+        out();
+    }
+    const md = lines.join('\n');
+    const outPath = path.join(dir, 'summary.md');
+    fs.writeFileSync(outPath, md);
+    console.log(md);
+    console.log(`\n(written to ${outPath})`);
+}
+main();

package/dist/scripts/trace-spike.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env -S node --import tsx
+import fs from 'node:fs';
+import path from 'node:path';
+import { DesignerController } from "../designer-controller.js";
+import { CdpTraceRecorder } from "../cdp-trace.js";
+import { artifactsRoot } from "../artifact-store.js";
+import { getSession } from "../session-store.js";
+const USAGE = `Usage:
+  trace-spike.ts quota   [--seconds 60]                 capture quota banner + short idle trace
+  trace-spike.ts idle    [--minutes 3]                  baseline noise trace
+  trace-spike.ts success "<prompt>" [--key K] [--name N] [--fidelity highfi|wireframe] [--decisive] [--sample-ms 1500]
+  trace-spike.ts noop    ["<prompt>"] [--key K]         chat-only prompt (expects no file change)
+  trace-spike.ts watch   [--key K]                      record until Ctrl-C (opportunistic capture)
+
+Traces land in artifacts/trace/<scenario>-<ts>/{trace.jsonl,manifest.json}.`;
+function parseArgv(argv) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (!a)
+            continue;
+        if (a.startsWith('--')) {
+            const name = a.slice(2);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith('--')) {
+                flags[name] = next;
+                i++;
+            }
+            else {
+                flags[name] = true;
+            }
+        }
+        else {
+            positional.push(a);
+        }
+    }
+    return { positional, flags };
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+const NOOP_PROMPT = 'Answer in chat only — do not create, modify, or delete any files: briefly describe what the current design does.';
+function buildSampleJs(c) {
+    const sel = c.selectors;
+    return `(() => {
+    const q = (s) => { try { return document.querySelector(s); } catch { return null; } };
+    const vis = (el) => { if (!el) return false; const r = el.getBoundingClientRect(); return r.width > 0 && r.height > 0; };
+    const composer = q(${JSON.stringify(sel.composer.promptTextarea)});
+    const send = q(${JSON.stringify(sel.composer.sendButton)});
+    const iframe = q(${JSON.stringify(sel.preview.iframeOrContainer)});
+    const msgs = q(${JSON.stringify(sel.messages.chatMessagesContainer)});
+    let chatTurnCount = 0; let lastTurnRole = null;
+    if (msgs) {
+      const turns = msgs.querySelectorAll('[data-index]');
+      chatTurnCount = turns.length;
+      const last = turns[turns.length - 1];
+      if (last) {
+        const t = (last.innerText || '').trim();
+        lastTurnRole = t.startsWith('Claude') ? 'assistant' : t.startsWith('You') ? 'user' : 'unknown';
+      }
+    }
+    // selectors.json has composer.stopButton: null — probe generically so the
+    // trace doubles as selector discovery for the real stop button.
+    let stopProbe = null;
+    for (const b of Array.from(document.querySelectorAll('button'))) {
+      const label = ((b.getAttribute('aria-label') || '') + ' ' + (b.textContent || '')).trim();
+      if (/\\b(stop|cancel)\\b/i.test(label) && vis(b)) {
+        stopProbe = {
+          label: label.slice(0, 80),
+          testid: b.getAttribute('data-testid'),
+          outerHTML: b.outerHTML.slice(0, 400)
+        };
+        break;
+      }
+    }
+    return {
+      url: location.href,
+      iframeSrc: iframe && iframe.src ? iframe.src : null,
+      composerVisible: vis(composer),
+      sendVisible: vis(send),
+      sendDisabled: send ? (send.disabled === true || send.getAttribute('aria-disabled') === 'true') : null,
+      chatTurnCount,
+      lastTurnRole,
+      stopProbe
+    };
+  })()`;
+}
+const QUOTA_BANNER_JS = `(() => {
+  // Find the smallest element whose text mentions a percentage AND
+  // weekly-limit language — that's the usage banner.
+  const all = Array.from(document.querySelectorAll('div, section, aside'));
+  let best = null;
+  for (const el of all) {
+    const t = (el.innerText || '').trim();
+    if (!t || t.length > 600) continue;
+    if (!/\\d+\\s*%/.test(t)) continue;
+    if (!/week|usage|limit|resets/i.test(t)) continue;
+    if (!best || t.length < (best.innerText || '').trim().length) best = el;
+  }
+  if (!best) return { found: false, text: null, outerHTML: null };
+  return { found: true, text: (best.innerText || '').trim(), outerHTML: best.outerHTML.slice(0, 8000) };
+})()`;
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function main() {
+    const { positional, flags } = parseArgv(process.argv.slice(2));
+    const scenario = positional[0] || '';
+    if (!['quota', 'idle', 'success', 'noop', 'watch'].includes(scenario)) {
+        console.log(USAGE);
+        process.exit(scenario ? 1 : 0);
+    }
+    const key = String(flags.key || 'trace-spike');
+    const sampleMs = Number(flags['sample-ms'] || (scenario === 'idle' || scenario === 'watch' ? 5000 : 1500));
+    const controller = new DesignerController({ key });
+    const ready = await controller.ensureReady();
+    console.log(`ready: ${ready.url}`);
+    let prompt = null;
+    if (scenario === 'success' || scenario === 'noop') {
+        prompt = positional[1] || (scenario === 'noop' ? NOOP_PROMPT : null);
+        if (!prompt) {
+            console.error('success requires a prompt argument');
+            process.exit(1);
+        }
+        const stored = getSession(key);
+        if (stored?.designUrl) {
+            await controller.resumeSession();
+        }
+        else if (scenario === 'noop') {
+            console.error(`No stored session for key=${key} — run a success scenario first so noop has a design to ask about.`);
+            process.exit(1);
+        }
+        else {
+            const name = String(flags.name || 'aurora-trace');
+            const fidelity = flags.fidelity === 'wireframe' ? 'wireframe' : 'highfi';
+            const created = await controller.createSession(name, fidelity);
+            console.log(`created session: ${created.url}`);
+        }
+    }
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const outDir = path.join(artifactsRoot(), 'trace', `${scenario}-${stamp}`);
+    fs.mkdirSync(outDir, { recursive: true });
+    const targetUrlFlag = typeof flags['target-url'] === 'string' ? String(flags['target-url']) : null;
+    const recorder = await CdpTraceRecorder.attach({
+        outFile: path.join(outDir, 'trace.jsonl'),
+        preferUrlPrefix: getSession(key)?.designUrl?.split('?')[0] || null,
+        ...(targetUrlFlag ? { urlPattern: new RegExp('^' + escapeRegExp(targetUrlFlag)) } : {})
+    });
+    await recorder.start();
+    console.log(`recording → ${outDir}`);
+    const manifest = {
+        scenario,
+        key,
+        prompt,
+        startedAt: new Date().toISOString(),
+        endedAt: null,
+        aborted: false,
+        node: process.version,
+        cdp: recorder.targetInfo(),
+        iterate: null,
+        quota: null,
+        summary: null
+    };
+    const sampleJs = buildSampleJs(controller);
+    let samplerInFlight = false;
+    const sampler = setInterval(() => {
+        if (samplerInFlight)
+            return;
+        samplerInFlight = true;
+        controller.browser
+            .evalValue(sampleJs)
+            .then((sample) => recorder.record({ ts: Date.now(), kind: 'dom-sample', sample }))
+            .catch(() => null)
+            .finally(() => {
+            samplerInFlight = false;
+        });
+    }, sampleMs);
+    let finished = false;
+    const finalize = async (aborted) => {
+        if (finished)
+            return;
+        finished = true;
+        clearInterval(sampler);
+        manifest.aborted = aborted;
+        manifest.endedAt = new Date().toISOString();
+        manifest.summary = await recorder.stop();
+        fs.writeFileSync(path.join(outDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+        console.log(`\ntrace: ${path.join(outDir, 'trace.jsonl')}`);
+        console.log(`manifest: ${path.join(outDir, 'manifest.json')}`);
+        console.log(`events: ${manifest.summary.total} | bodies: ${manifest.summary.bodyCaptures} | reconnects: ${manifest.summary.reconnects}`);
+    };
+    process.on('SIGINT', () => {
+        void finalize(true).then(() => process.exit(130));
+    });
+    try {
+        if (scenario === 'quota') {
+            const screenshotPath = path.join(outDir, 'quota-banner.png');
+            await controller.browser.screenshot(screenshotPath, { full: true }).catch((e) => {
+                console.warn(`screenshot failed: ${e.message}`);
+                return '';
+            });
+            const banner = await controller.browser
+                .evalValue(QUOTA_BANNER_JS)
+                .catch(() => ({ found: false, text: null, outerHTML: null }));
+            let bannerHtmlPath = null;
+            if (banner.found && banner.outerHTML) {
+                bannerHtmlPath = path.join(outDir, 'quota-banner.html');
+                fs.writeFileSync(bannerHtmlPath, banner.outerHTML);
+            }
+            manifest.quota = {
+                bannerText: banner.text,
+                bannerHtmlPath,
+                screenshotPath: fs.existsSync(screenshotPath) ? screenshotPath : null
+            };
+            console.log(banner.found ? `banner: ${banner.text}` : 'banner: NOT FOUND (see screenshot)');
+            const seconds = Number(flags.seconds || 60);
+            recorder.marker('quota-idle-start', { seconds });
+            await sleep(seconds * 1000);
+            recorder.marker('quota-idle-end');
+        }
+        else if (scenario === 'idle') {
+            const minutes = Number(flags.minutes || 3);
+            recorder.marker('idle-start', { minutes });
+            await sleep(minutes * 60_000);
+            recorder.marker('idle-end');
+        }
+        else if (scenario === 'success' || scenario === 'noop') {
+            recorder.marker('iterate-start', { prompt, decisive: flags.decisive === true });
+            const result = await controller.iterate(prompt, { decisive: flags.decisive === true });
+            recorder.marker('iterate-done', {
+                failureMode: result.done.failureMode,
+                elapsedMs: result.done.elapsedMs,
+                changed: result.changed,
+                newFiles: result.newFiles
+            });
+            manifest.iterate = {
+                failureMode: result.done.failureMode,
+                ok: result.done.ok,
+                elapsedMs: result.done.elapsedMs,
+                changed: result.changed,
+                newFiles: result.newFiles,
+                removedFiles: result.removedFiles,
+                activeFile: result.activeFile,
+                htmlBytes: result.htmlBytes,
+                chatReplyBytes: result.chatReply ? result.chatReply.length : 0
+            };
+            console.log(`iterate: ok=${result.done.ok} failureMode=${result.done.failureMode} elapsed=${Math.round(result.done.elapsedMs / 1000)}s newFiles=[${result.newFiles.join(', ')}]`);
+            const banner = await controller.browser
+                .evalValue(QUOTA_BANNER_JS)
+                .catch(() => ({ found: false, text: null, outerHTML: null }));
+            if (banner.found && banner.outerHTML) {
+                const bannerHtmlPath = path.join(outDir, 'quota-banner.html');
+                fs.writeFileSync(bannerHtmlPath, banner.outerHTML);
+                manifest.quota = { bannerText: banner.text, bannerHtmlPath, screenshotPath: null };
+                console.log(`quota banner captured: ${banner.text}`);
+            }
+            await sleep(5000);
+        }
+        else if (scenario === 'watch') {
+            recorder.marker('watch-start');
+            console.log('watching — Ctrl-C to stop');
+            await new Promise(() => {
+            });
+        }
+    }
+    finally {
+        await finalize(false);
+    }
+}
+main().catch(async (e) => {
+    console.error(e.message);
+    process.exit(1);
+});