@joeytheman/gemini-mcp-tool 1.3.0 → 2.3.0

package/dist/__tests__/live-pass.test.js

@@ -0,0 +1,1249 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execFileSync } from 'child_process';
+vi.mock('../utils/logger.js', () => ({
+    Logger: { debug: vi.fn(), warn: vi.fn(), error: vi.fn(), log: vi.fn(), toolInvocation: vi.fn() },
+}));
+const mockExecuteAgyJson = vi.fn();
+vi.mock('../utils/agyExecutor.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, executeAgyJson: (...args) => mockExecuteAgyJson(...args) };
+});
+const cleanSnapshot = (root = '/repo') => ({
+    root,
+    lines: [],
+    hashes: new Map(),
+    truncated: false,
+});
+const mockSnapshotWorkingTree = vi.fn().mockReturnValue(cleanSnapshot());
+const mockCountAgyModelSteps = vi.fn(async (_conversationId) => null);
+vi.mock('../utils/agyModelSteps.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, countAgyModelSteps: (id) => mockCountAgyModelSteps(id) };
+});
+vi.mock('../utils/gitStatusGuard.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, snapshotWorkingTree: (...args) => mockSnapshotWorkingTree(...args) };
+});
+import { livePassTool, livePassArgsSchema, livePassResultSchema, LIVE_PASS_RESULT_JSON_SCHEMA, buildLivePassPrompt, frameFileName, prescribedFrameNames, prescribedTargetFiles, formatLayoutSection, readLayoutChecks, validateFrames, checkCoverage, deriveVerdict, runPublishCommand, writeCaptureScripts, } from '../tools/live-pass.tool.js';
+import { ERROR_MESSAGES, LAYOUT_CHECK_SNIPPET, LIVE_PASS, MODELS } from '../constants.js';
+import { readLayoutCheck } from '../utils/layoutCheck.js';
+import { buildCaptureScript, SCROLL_OVERFLOW_SNIPPET } from '../utils/captureScript.js';
+import { makeTempDir, cleanupTempDirs } from './utils/test-helpers.js';
+// ------------------------------------------------------------------ helpers
+const makeWorkDir = () => makeTempDir('live-pass');
+const PNG = fs.readFileSync(new URL('./fixtures/images/pixel.png', import.meta.url));
+const JPEG = fs.readFileSync(new URL('./fixtures/images/pixel.jpg', import.meta.url));
+const HOME_TARGET = {
+    screen: 'home',
+    state: 'default',
+    viewport: '390x844',
+    expected: "heading 'Hello'",
+};
+function makeFrame(overrides = {}) {
+    return {
+        file: '/tmp/frame.png',
+        screen: 'home',
+        state: 'default',
+        expected: "heading 'Hello'",
+        viewport: '390x844',
+        verdict: 'PASS',
+        observed: 'Shows the Hello heading above the list.',
+        ...overrides,
+    };
+}
+function makeResult(overrides = {}) {
+    return {
+        verdict: 'PASS',
+        summary: 'Everything rendered.',
+        served_branch_check: "footer reads 'BRANCH: smoke'",
+        frames: [makeFrame()],
+        findings: [],
+        regressions: [],
+        resolved: [],
+        changes: [],
+        skipped: [],
+        ...overrides,
+    };
+}
+const CLEAN_VALIDATION = { checks: [], okFiles: [], problems: [], notes: [], unreportedCaptures: [] };
+const CLEAN_COVERAGE = { uncovered: [], skipped: [], extraFrames: [] };
+function writeFrameFile(artifactDir, name, contents) {
+    fs.mkdirSync(artifactDir, { recursive: true });
+    const file = path.join(artifactDir, name);
+    fs.writeFileSync(file, contents ?? (/\.png$/i.test(name) ? PNG : /\.jpe?g$/i.test(name) ? JPEG : 'not an image'));
+    return file;
+}
+function writeManifest(artifactDir, frames) {
+    fs.writeFileSync(path.join(artifactDir, LIVE_PASS.MANIFEST_FILE), JSON.stringify({ run_started: new Date().toISOString(), driver: 'playwright', frames, skipped: [] }));
+}
+function makeLayoutReport(overrides = {}) {
+    return {
+        check: LIVE_PASS.LAYOUT_CHECK_ID,
+        viewport: { width: 390, height: 844 },
+        found: 0,
+        entries: [],
+        clamped: [],
+        ...overrides,
+    };
+}
+const SPILL_ENTRY = {
+    kind: 'text-spill',
+    text: 'Uploaded to the studio wins wall',
+    testID: 'label',
+    rect: { x: 0, y: 0, width: 320, height: 20 },
+};
+function writeLayoutFile(artifactDir, frameName, contents) {
+    fs.mkdirSync(artifactDir, { recursive: true });
+    const file = path.join(artifactDir, frameName.replace(/\.png$/, LIVE_PASS.LAYOUT_FILE_SUFFIX));
+    fs.writeFileSync(file, typeof contents === 'string' ? contents : JSON.stringify(contents, null, 2));
+    return file;
+}
+function envelope(structured, overrides = {}) {
+    return {
+        conversation_id: 'conv-abc',
+        status: 'SUCCESS',
+        response: '',
+        structured_output: structured,
+        num_turns: 3,
+        duration_seconds: 42,
+        usage: { input_tokens: 16000, output_tokens: 900, total_tokens: 16900 },
+        denied_actions: [],
+        ...overrides,
+    };
+}
+function run(args) {
+    return livePassTool.execute(args);
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockSnapshotWorkingTree.mockReturnValue(cleanSnapshot());
+});
+afterEach(cleanupTempDirs);
+// ------------------------------------------------------------------- schema
+describe('livePassArgsSchema', () => {
+    const minimal = {
+        targets: [HOME_TARGET],
+        brief: 'Base URL http://localhost:8123',
+        workingDirectory: '/tmp/project',
+        driver: 'playwright',
+    };
+    it('asks the caller\'s brief for the start URL and any link a user arrives by, with its source', () => {
+        expect(livePassArgsSchema.shape.brief.description).toContain("the app's start URL or app id, any link a user arrives by (an invite, email or share link) with where it comes from");
+        expect(livePassArgsSchema.shape.brief.description).not.toMatch(/entry url/i);
+    });
+    it('applies the documented defaults', () => {
+        const parsed = livePassArgsSchema.parse(minimal);
+        expect(parsed.yolo).toBe(true);
+        expect(parsed.printTimeout).toBe(LIVE_PASS.DEFAULT_PRINT_TIMEOUT);
+        expect(parsed.printTimeout).toBe('15m');
+        expect(parsed.model).toBe(MODELS.MEDIUM);
+        expect(parsed.model).toBe('Gemini 3.8 Flash (Medium)');
+    });
+    it('requires a driver and at least one target', () => {
+        expect(() => livePassArgsSchema.parse({ ...minimal, driver: undefined })).toThrow();
+        expect(() => livePassArgsSchema.parse({ ...minimal, targets: [] })).toThrow();
+    });
+    it('rejects a duplicate screen/state/viewport triple', () => {
+        expect(() => livePassArgsSchema.parse({
+            ...minimal,
+            targets: [HOME_TARGET, { ...HOME_TARGET, screen: ' Home ' }],
+        })).toThrow(/duplicate target/);
+    });
+    it('keeps two states of the same screen', () => {
+        const parsed = livePassArgsSchema.parse({
+            ...minimal,
+            targets: [HOME_TARGET, { ...HOME_TARGET, state: 'empty' }],
+        });
+        expect(parsed.targets).toHaveLength(2);
+    });
+    it('rejects a playwright target whose viewport is not WxH, and lets maestro name a form factor', () => {
+        const phone = { ...HOME_TARGET, viewport: 'iPhone 15' };
+        const web = livePassArgsSchema.safeParse({ ...minimal, targets: [HOME_TARGET, phone] });
+        const native = livePassArgsSchema.safeParse({ ...minimal, driver: 'maestro', targets: [phone] });
+        expect(web.success).toBe(false);
+        expect(web.error?.issues).toEqual([expect.objectContaining({
+                path: ['targets', 1, 'viewport'],
+                message: `${ERROR_MESSAGES.LIVE_PASS_WEB_VIEWPORT}. Received 'iPhone 15'.`,
+            })]);
+        expect(native.success).toBe(true);
+    });
+});
+describe('LIVE_PASS_RESULT_JSON_SCHEMA', () => {
+    it('has no $schema key and requires every result section', () => {
+        expect(LIVE_PASS_RESULT_JSON_SCHEMA).not.toHaveProperty('$schema');
+        expect(LIVE_PASS_RESULT_JSON_SCHEMA.required).toEqual(expect.arrayContaining([
+            'verdict', 'summary', 'served_branch_check', 'frames',
+            'findings', 'regressions', 'resolved', 'changes', 'skipped',
+        ]));
+    });
+    it('requires expected and observed on every frame', () => {
+        const frames = LIVE_PASS_RESULT_JSON_SCHEMA.properties.frames;
+        expect(frames.items.required).toEqual(expect.arrayContaining(['file', 'expected', 'observed', 'verdict']));
+    });
+    it('offers link_source on a frame without requiring it', () => {
+        const frames = LIVE_PASS_RESULT_JSON_SCHEMA.properties.frames;
+        expect(frames.items.properties.link_source.type).toBe('string');
+        expect(frames.items.required).not.toContain('link_source');
+    });
+});
+// ------------------------------------------------------------------- prompt
+describe('frameFileName', () => {
+    it('slugifies every segment so spaces and slashes cannot collide', () => {
+        expect(frameFileName({ screen: 'Settings/Profile', state: 'sheet open', viewport: '390x844' }))
+            .toBe('settings-profile-sheet-open-390x844.png');
+        expect(frameFileName({ screen: '  Order Detail  ', state: 'Empty!', viewport: '1280 x 800' }))
+            .toBe('order-detail-empty-1280-x-800.png');
+    });
+    it('suffixes a name two different targets would otherwise slugify onto', () => {
+        const names = prescribedFrameNames([
+            { screen: 'settings/profile', state: 'default', viewport: '390x844' },
+            { screen: 'settings-profile', state: 'default', viewport: '390x844' },
+        ]);
+        expect([...names.values()]).toEqual([
+            'settings-profile-default-390x844.png',
+            'settings-profile-default-390x844-2.png',
+        ]);
+    });
+    it('gives two viewports of the same screen and state different files', () => {
+        const mobile = frameFileName({ screen: 'home', state: 'default', viewport: '390x844' });
+        const desktop = frameFileName({ screen: 'home', state: 'default', viewport: '1280x800' });
+        expect(mobile).not.toBe(desktop);
+    });
+});
+describe('buildLivePassPrompt', () => {
+    const base = {
+        brief: 'Start URL http://localhost:8123; marker: footer BRANCH: feat/orders',
+        targets: [HOME_TARGET, { ...HOME_TARGET, state: 'offline', expected: 'offline notice plus Retry' }],
+        workingDirectory: '/work/tree',
+        artifactDir: '/work/tree/.live-pass/run1',
+        checkout: { branch: 'feat/orders', head: '0123456789abcdef0123456789abcdef01234567' },
+    };
+    it('renders the targets as a numbered list with their expected state', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright', resumed: false });
+        expect(prompt).toContain('1. screen: home | state: default | viewport: 390x844');
+        expect(prompt).toContain("expected: heading 'Hello'");
+        expect(prompt).toContain('2. screen: home | state: offline | viewport: 390x844');
+        expect(prompt).toContain('expected: offline notice plus Retry');
+    });
+    it('carries the playwright procedure and the evidence discipline', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright', resumed: false });
+        expect(prompt).toContain('Capture it: browser_run_code_unsafe with filename set to the exact absolute path printed as "capture:" for that target below. Never pass code, never write, edit or read a capture file');
+        expect(prompt).toContain('/work/tree/.live-pass/run1');
+        expect(prompt).toContain('If a capture returns an error, add the target to "skipped" with the error text. Never fall back to browser_take_screenshot.');
+        expect(prompt).toContain('The capture sets the target\'s viewport and grows a scrolling screen taller, a few times at most and up to 4000 px, until its scroll area fits; a screen that still scrolls after that is shot as it stands.');
+        expect(prompt).toContain('an added "; layout not measured: <error>" or "; viewport not restored: <error>" still saved the frame.');
+        expect(prompt).not.toContain('full height');
+        expect(prompt).not.toContain('browser_resize');
+        expect(prompt).not.toContain('fullPage');
+        expect(prompt).not.toContain('320x568');
+        expect(prompt).toContain('answer is ONLY the schema JSON');
+        expect(prompt).toContain('a spinner, blank page, skeleton, error, or the wrong screen is a FAIL');
+        expect(prompt).toContain('PASSES when it shows that state with everything "expected" names');
+        expect(prompt).toContain('Something "expected" does not ask for is at most a MINOR finding');
+        expect(prompt).toContain(LIVE_PASS.MANIFEST_FILE);
+        expect(prompt).not.toContain('list_devices');
+    });
+    it('prints one prescribed absolute file path per target, for both drivers', () => {
+        for (const driver of ['playwright', 'maestro']) {
+            const prompt = buildLivePassPrompt({ ...base, driver, resumed: false });
+            expect(prompt).toContain(`   file: /work/tree/.live-pass/run1/${frameFileName(base.targets[0])}`);
+            expect(prompt).toContain(`   file: /work/tree/.live-pass/run1/${frameFileName(base.targets[1])}`);
+            // The viewport is part of every prescribed name, so two viewports of one
+            // screen/state can never land in the same file.
+            expect(prompt).toContain('home-default-390x844.png');
+            expect(prompt).toContain('home-offline-390x844.png');
+            expect(prompt).toContain('a file that answers two targets is treated as no evidence at all');
+            expect(prompt).toContain('never reuse another target\'s file');
+        }
+    });
+    it('carries the maestro procedure instead for the maestro driver', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'maestro', resumed: false });
+        expect(prompt).toContain('list_devices');
+        expect(prompt).toContain('xcrun simctl io');
+        expect(prompt).toContain('Never use take_screenshot for evidence');
+        expect(prompt).not.toContain('browser_take_screenshot');
+        expect(prompt).not.toContain('browser_run_code_unsafe');
+    });
+    it('adds the delta paragraph only for a resumed pass', () => {
+        const fresh = buildLivePassPrompt({ ...base, driver: 'playwright', resumed: false });
+        const resumed = buildLivePassPrompt({ ...base, driver: 'playwright', resumed: true });
+        expect(fresh).not.toContain('Delta reporting');
+        expect(fresh).toContain('This is a fresh pass');
+        expect(resumed).toContain('Delta reporting');
+        expect(resumed).toContain('Never put an improvement in "findings" or "regressions"');
+    });
+});
+describe('buildLivePassPrompt: context Gemini used to dig for', () => {
+    const base = {
+        brief: 'Start URL http://localhost:8123; marker: footer BRANCH: feat/orders',
+        targets: [HOME_TARGET, { ...HOME_TARGET, state: 'offline', expected: 'offline notice plus Retry' }],
+        workingDirectory: '/work/tree',
+        artifactDir: '/work/tree/.live-pass/run1',
+        checkout: { branch: 'feat/orders', head: '0123456789abcdef0123456789abcdef01234567' },
+        resumed: false,
+    };
+    it('prints the branch and HEAD read in code, and forbids running git to find them', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright' });
+        expect(prompt).toContain('- Checkout under test: feat/orders at 0123456789abcdef0123456789abcdef01234567. Read for you, so never run git.');
+        expect(prompt).toContain('The checkout above is context. Set BLOCKED over it only when the marker names a branch or commit that contradicts it. A detached HEAD never contradicts a branch name, and a short commit hash matches the full one it begins.');
+    });
+    it('names a detached HEAD instead of a branch', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright', checkout: { branch: null, head: 'abc1234' } });
+        expect(prompt).toContain('- Checkout under test: a detached HEAD at abc1234.');
+    });
+    it('falls back to the brief marker when the working directory is not a git checkout', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright', checkout: null });
+        expect(prompt).toContain("- Checkout under test: not a git checkout with a commit, so rely on the brief's marker alone.");
+    });
+    it('carries a parameter cheat sheet for every playwright tool the procedure uses', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright' });
+        expect(prompt).toContain('## Tool cheat sheet (the installed parameters: never read tool schemas or Playwright source)');
+        for (const line of [
+            '- browser_navigate {url}',
+            '- browser_click {target, element?, doubleClick?, button?, modifiers?}',
+            '- browser_type {target, text, submit?, slowly?}',
+            '- browser_fill_form {fields: [{target, name, type: textbox | checkbox | radio | combobox | slider, value}]}',
+            '- browser_select_option {target, values: [...]}',
+            '- browser_press_key {key}',
+            '- browser_handle_dialog {accept, promptText?}',
+            '- browser_wait_for {text? | textGone? | time?}',
+            '- browser_find {text | regex}',
+            '- browser_snapshot {target?, depth?, boxes?}',
+            '- browser_run_code_unsafe {filename}: filename is absolute.',
+            '- browser_evaluate {function, filename}: the return value is written to filename as JSON instead of returned to you.',
+        ]) {
+            expect(prompt).toContain(line);
+        }
+        expect(prompt).not.toContain('- browser_take_screenshot');
+        expect(prompt).toContain('a unique selector such as [data-testid="save"]');
+        expect(prompt).not.toContain('- inspect_screen {device_id}');
+    });
+    it('carries the maestro tool cheat sheet for the maestro driver instead', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'maestro' });
+        for (const line of [
+            '- list_devices {}',
+            '- run {device_id, yaml, env?}',
+            '- inspect_screen {device_id}',
+            '- take_screenshot {device_id}: returns an image inline; never evidence.',
+            '- cheat_sheet {}',
+        ]) {
+            expect(prompt).toContain(line);
+        }
+        expect(prompt).not.toContain('- browser_click {');
+    });
+    it('tells a web pass to answer native dialogs right after the triggering click', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright' });
+        expect(prompt).toContain('Native dialogs such as window.confirm and window.alert block the page: accept or dismiss each with browser_handle_dialog right after the click that opened it.');
+    });
+    it.each(['playwright', 'maestro'])('forbids code, database and git reads for the %s driver', (driver) => {
+        const prompt = buildLivePassPrompt({ ...base, driver });
+        expect(prompt).toContain('Never read product source, tests, docs, config, tool schemas or tool source. Never query a database.');
+        expect(prompt).toContain("Never run a shell command except the capture command the procedure names and removing a stale file at a target's own \"file:\" path.");
+        expect(prompt).toContain('Never read code to work out why something failed. Report what you saw.');
+        expect(prompt).toContain('never run a git command.');
+        expect(prompt).toContain('It is only where you run: read, list and glob nothing outside the artifact directory.');
+        expect(prompt).not.toContain('Working directory (read-only)');
+    });
+    it.each(['playwright', 'maestro'])('opens the %s app once and reaches every other target by taps from the previous screen', (driver) => {
+        const prompt = buildLivePassPrompt({ ...base, driver });
+        expect(prompt).toContain('## User path\n- The pass opens the app once, at its start URL (or by launching it on a device), as the brief names it.');
+        expect(prompt).toContain('- Every other target is reached by taps from the previous screen: sign in through the sign-in form, tap through the navigation, and fill and submit forms. Any other URL or deep link in the brief is context, never a navigation target.');
+        expect(prompt).toContain('- A reload, only where the brief makes one part of the path, opens the URL the page is already on.');
+        expect(prompt).toContain('- No script that clicks, navigates, or sets storage, cookies or app state for you.');
+    });
+    it.each(['playwright', 'maestro'])('lets a %s target begin at its own link only when the brief names the link the user arrives by, and has the frame quote its source', (driver) => {
+        const prompt = buildLivePassPrompt({ ...base, driver });
+        expect(prompt).toContain('- A target may begin at a link of its own only when the brief says the user arrives by that link, such as an invite, email or share link, and names where the link comes from. Open it as following that link would, and quote the brief\'s words naming the source in that frame\'s "link_source".');
+    });
+    it.each(['playwright', 'maestro'])('leaves no per-target entry URL or URL jump anywhere in the %s prompt', (driver) => {
+        const prompt = buildLivePassPrompt({ ...base, driver });
+        expect(prompt).not.toMatch(/entry url/i);
+        expect(prompt).not.toContain('deeper URL');
+        expect(prompt).not.toContain('walk on from wherever');
+        expect(prompt).not.toContain('Never use openLink to skip a user step.');
+    });
+    it('sends a web pass\'s browser_navigate only where the user path allows, and keeps browser_evaluate and run_code to the printed save functions and capture files', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright' });
+        expect(prompt).not.toContain("browser_navigate to the target's route");
+        expect(prompt).toContain('browser_navigate opens only the URLs the "User path" section allows.\nFor each target, in order:\n- Reach it as the "User path" section says.');
+        expect(prompt).toContain('browser_evaluate runs only the "save layout:" functions and browser_run_code_unsafe only the "capture:" files. Neither is used to click, type, navigate, or set storage, cookies or app state.');
+    });
+    it('has a maestro pass launch the app only at the start and openLink only for a link arrival', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'maestro' });
+        expect(prompt).toContain('- Reach each state as the "User path" section says, with inline YAML flows: launchApp only to open the app at the start, then tapOn and inputText; openLink only for a link arrival that section allows.');
+    });
+    it('locates web controls by testID, then browser_find, then a scoped snapshot', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright' });
+        expect(prompt).toContain('Locate each control cheaply, in this order: a testID the brief names, as target [data-testid="<testID>"]; then browser_find with its visible label; then browser_snapshot with a target and a small depth scoped to that region. Never take a full-page snapshot just to look around');
+    });
+    it.each(['playwright', 'maestro'])('reports a %s dead end with the broken step, and a missing fact as skipped', (driver) => {
+        const prompt = buildLivePassPrompt({ ...base, driver });
+        expect(prompt).toContain('add it to "skipped" with the step where the path broke, such as "step 3: tapped Save, nothing happened". A dead end a user would hit is also a finding.');
+        expect(prompt).toContain('add the target to "skipped" with "brief missing: <the fact>". Never search the code for it.');
+    });
+    it('prints each web target its own capture file, layout file and save function, and neither page snippet', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'playwright' });
+        expect(prompt).toContain([
+            '   file: /work/tree/.live-pass/run1/home-default-390x844.png',
+            '   capture: /work/tree/.live-pass/run1/home-default-390x844.capture.js',
+            '   layout: /work/tree/.live-pass/run1/home-default-390x844.layout.json',
+            '   save layout: () => window.__livePassLayout?.["home-default-390x844.png"]',
+        ].join('\n'));
+        expect(prompt).toContain([
+            '   file: /work/tree/.live-pass/run1/home-offline-390x844.png',
+            '   capture: /work/tree/.live-pass/run1/home-offline-390x844.capture.js',
+            '   layout: /work/tree/.live-pass/run1/home-offline-390x844.layout.json',
+            '   save layout: () => window.__livePassLayout?.["home-offline-390x844.png"]',
+        ].join('\n'));
+        expect(prompt).toContain('browser_evaluate with function set to the "save layout:" function printed for that target, copied verbatim, and filename set to the exact absolute path printed as "layout:" for that target. Do not open that file or report on it');
+        expect(prompt).not.toContain(LAYOUT_CHECK_SNIPPET);
+        expect(prompt).not.toContain(SCROLL_OVERFLOW_SNIPPET);
+        expect(prompt).not.toContain('getBoundingClientRect');
+    });
+    it('asks a maestro pass for no capture file or layout check', () => {
+        const prompt = buildLivePassPrompt({ ...base, driver: 'maestro' });
+        expect(prompt).not.toContain('capture:');
+        expect(prompt).not.toContain('layout:');
+        expect(prompt).not.toContain(LAYOUT_CHECK_SNIPPET);
+        expect(prompt).not.toContain(SCROLL_OVERFLOW_SNIPPET);
+    });
+});
+describe('prescribedTargetFiles', () => {
+    it('puts each capture and layout file next to its frame, sharing the frame stem and its collision suffix', () => {
+        const targets = [
+            { ...HOME_TARGET, screen: 'settings/profile' },
+            { ...HOME_TARGET, screen: 'settings-profile' },
+        ];
+        const files = prescribedTargetFiles(targets, '/art');
+        expect([...files.values()]).toEqual([
+            {
+                frameName: 'settings-profile-default-390x844.png',
+                frame: '/art/settings-profile-default-390x844.png',
+                capture: '/art/settings-profile-default-390x844.capture.js',
+                layout: '/art/settings-profile-default-390x844.layout.json',
+            },
+            {
+                frameName: 'settings-profile-default-390x844-2.png',
+                frame: '/art/settings-profile-default-390x844-2.png',
+                capture: '/art/settings-profile-default-390x844-2.capture.js',
+                layout: '/art/settings-profile-default-390x844-2.layout.json',
+            },
+        ]);
+    });
+});
+// ------------------------------------------------------------ layout checks
+describe('readLayoutCheck', () => {
+    const frameName = frameFileName(HOME_TARGET);
+    it('accepts a fresh, schema-valid file inside the artifact directory', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const report = makeLayoutReport({ found: 1, entries: [SPILL_ENTRY] });
+        const file = writeLayoutFile(artifactDir, frameName, report);
+        const check = readLayoutCheck(file, artifactDir, Date.now());
+        expect(check).toEqual({ file, status: 'OK', report });
+    });
+    it('reports a file that was never written as MISSING', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        fs.mkdirSync(artifactDir, { recursive: true });
+        const file = path.join(artifactDir, 'home-default-390x844.layout.json');
+        expect(readLayoutCheck(file, artifactDir, Date.now())).toEqual({ file, status: 'MISSING', problem: 'not written' });
+    });
+    it('reports a file left over from an earlier run as STALE', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeLayoutFile(artifactDir, frameName, makeLayoutReport());
+        const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+        fs.utimesSync(file, yesterday, yesterday);
+        expect(readLayoutCheck(file, artifactDir, Date.now())).toEqual({ file, status: 'STALE', problem: 'predates this run' });
+    });
+    it('accepts a file written within the freshness tolerance before the run clock', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeLayoutFile(artifactDir, frameName, makeLayoutReport());
+        const runStartMs = fs.statSync(file).mtimeMs + LIVE_PASS.FRESHNESS_TOLERANCE_MS - 1;
+        expect(readLayoutCheck(file, artifactDir, runStartMs).status).toBe('OK');
+    });
+    it('reports a prescribed path symlinked out of the artifact directory as OUTSIDE', () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, 'frames');
+        fs.mkdirSync(artifactDir, { recursive: true });
+        const outside = writeLayoutFile(makeWorkDir(), frameName, makeLayoutReport());
+        const prescribed = path.join(artifactDir, path.basename(outside));
+        fs.symlinkSync(outside, prescribed);
+        expect(readLayoutCheck(prescribed, artifactDir, Date.now())).toEqual({
+            file: outside,
+            status: 'OUTSIDE',
+            problem: 'resolves outside the artifact directory',
+        });
+    });
+    it('reports an empty file as MALFORMED', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeLayoutFile(artifactDir, frameName, '');
+        expect(readLayoutCheck(file, artifactDir, Date.now())).toEqual({ file, status: 'MALFORMED', problem: 'empty' });
+    });
+    it('reports a result measured at another width than the frame as MISMATCHED', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeLayoutFile(artifactDir, frameName, makeLayoutReport({ viewport: { width: 1280, height: 800 } }));
+        expect(readLayoutCheck(file, artifactDir, Date.now(), 390)).toEqual({
+            file,
+            status: 'MISMATCHED',
+            problem: 'measured at width 1280, but the frame is 390 wide',
+        });
+    });
+    it('accepts a result measured at the frame width whatever the height, since a scrolling frame is resized taller', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const report = makeLayoutReport({ viewport: { width: 390, height: 2210 } });
+        const file = writeLayoutFile(artifactDir, frameName, report);
+        expect(readLayoutCheck(file, artifactDir, Date.now(), 390)).toEqual({ file, status: 'OK', report });
+    });
+    it('reports a file that is not JSON as MALFORMED', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeLayoutFile(artifactDir, frameName, 'undefined');
+        expect(readLayoutCheck(file, artifactDir, Date.now())).toEqual({ file, status: 'MALFORMED', problem: 'not valid JSON' });
+    });
+    it.each([
+        ['another check id', { ...makeLayoutReport(), check: 'layout-check/0' }, 'check'],
+        ['an unknown kind', makeLayoutReport({ found: 1, entries: [{ ...SPILL_ENTRY, kind: 'ugly' }] }), 'entries.0.kind'],
+        ['text longer than 80 characters', makeLayoutReport({ found: 1, entries: [{ ...SPILL_ENTRY, text: 'x'.repeat(81) }] }), 'entries.0.text'],
+        ['more than 50 entries', makeLayoutReport({ found: 51, entries: Array(51).fill(SPILL_ENTRY) }), 'entries'],
+        ['a defect kind in the clamped list', makeLayoutReport({ clamped: [SPILL_ENTRY] }), 'clamped.0.kind'],
+    ])('reports a result with %s as MALFORMED', (_label, contents, issuePath) => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeLayoutFile(artifactDir, frameName, contents);
+        const check = readLayoutCheck(file, artifactDir, Date.now());
+        expect(check.status).toBe('MALFORMED');
+        expect(check.report).toBeUndefined();
+        expect(check.problem).toContain(`not a ${LIVE_PASS.LAYOUT_CHECK_ID} result (${issuePath}:`);
+    });
+});
+describe('formatLayoutSection', () => {
+    it('lists each frame\'s entries, its intentional caps apart, a clean frame, and a frame never run', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const offline = { ...HOME_TARGET, state: 'offline' };
+        const empty = { ...HOME_TARGET, state: 'empty' };
+        writeLayoutFile(artifactDir, frameFileName(HOME_TARGET), makeLayoutReport({
+            found: 1,
+            entries: [SPILL_ENTRY],
+            clamped: [{ kind: 'text-clamped', text: 'Costume checklist', testID: null, rect: { x: 0, y: 40, width: 200, height: 40 } }],
+        }));
+        writeLayoutFile(artifactDir, frameFileName(offline), makeLayoutReport());
+        const section = formatLayoutSection(readLayoutChecks([HOME_TARGET, offline, empty], artifactDir, Date.now()));
+        expect(section).toBe([
+            '## Layout checks (measured in the page)',
+            '- home / default / 390x844: 1 entry',
+            '  - text-spill "Uploaded to the studio wins wall" testID=label at 0,0 320x20',
+            '  - capped (line clamp / ellipsis): text-clamped "Costume checklist" at 0,40 200x40',
+            '- home / offline / 390x844: clean',
+            `- home / empty / 390x844: not run (MISSING: ${path.join(artifactDir, 'home-empty-390x844.layout.json')} not written)`,
+        ].join('\n'));
+    });
+    it('shows a frame measured at the wrong width as not run, with both widths', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeLayoutFile(artifactDir, frameFileName(HOME_TARGET), makeLayoutReport({
+            viewport: { width: 1280, height: 800 }, found: 1, entries: [SPILL_ENTRY],
+        }));
+        const section = formatLayoutSection(readLayoutChecks([HOME_TARGET], artifactDir, Date.now()));
+        expect(section).toBe([
+            '## Layout checks (measured in the page)',
+            `- home / default / 390x844: not run (MISMATCHED: ${file} measured at width 1280, but the frame is 390 wide)`,
+        ].join('\n'));
+    });
+    it('marks a frame a framework dev overlay covered as polluted', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const overlay = { kind: 'dev-overlay', text: 'Uncaught Error', testID: null, rect: { x: 0, y: 0, width: 390, height: 844 } };
+        writeLayoutFile(artifactDir, frameFileName(HOME_TARGET), makeLayoutReport({ found: 1, entries: [overlay] }));
+        const section = formatLayoutSection(readLayoutChecks([HOME_TARGET], artifactDir, Date.now()));
+        expect(section).toBe([
+            '## Layout checks (measured in the page)',
+            '- home / default / 390x844: 1 entry (a framework dev overlay was on screen: this frame is polluted)',
+            '  - dev-overlay "Uncaught Error" at 0,0 390x844',
+        ].join('\n'));
+    });
+    it('says when the snippet found more entries than it listed', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        writeLayoutFile(artifactDir, frameFileName(HOME_TARGET), makeLayoutReport({ found: 73, entries: [SPILL_ENTRY] }));
+        const section = formatLayoutSection(readLayoutChecks([HOME_TARGET], artifactDir, Date.now()));
+        expect(section).toContain('- home / default / 390x844: 73 entries (73 found, first 1 listed)');
+    });
+});
+// --------------------------------------------------------------- validation
+describe('validateFrames', () => {
+    it('accepts a fresh, non-empty frame inside the artifact directory', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeFrameFile(artifactDir, 'home-default.png');
+        writeManifest(artifactDir, [{ file }]);
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file })] }), artifactDir, Date.now());
+        expect(validation.checks[0].status).toBe('OK');
+        expect(validation.okFiles).toEqual([file]);
+        expect(validation.problems).toEqual([]);
+    });
+    it.each(['jpg', 'jpeg'])('accepts a real .%s frame', extension => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeFrameFile(artifactDir, `home-default.${extension}`);
+        writeManifest(artifactDir, [{ file }]);
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file })] }), artifactDir, Date.now());
+        expect(validation.checks[0].status).toBe('OK');
+        expect(validation.okFiles).toEqual([file]);
+    });
+    it.each([
+        ['MISSING', (dir) => path.join(dir, 'never-written.png')],
+        ['EMPTY', (dir) => {
+                const file = path.join(dir, 'empty.png');
+                fs.writeFileSync(file, '');
+                return file;
+            }],
+        ['STALE', (dir) => {
+                const file = writeFrameFile(dir, 'stale.png');
+                const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+                fs.utimesSync(file, yesterday, yesterday);
+                return file;
+            }],
+    ])('flags a %s frame', (status, makeFile) => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        fs.mkdirSync(artifactDir, { recursive: true });
+        const file = makeFile(artifactDir);
+        writeManifest(artifactDir, [{ file }]);
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file })] }), artifactDir, Date.now());
+        expect(validation.checks[0].status).toBe(status);
+        expect(validation.okFiles).toEqual([]);
+        expect(validation.problems.join('\n')).toContain(status);
+    });
+    it('marks every frame after the first that reuses an evidence file as DUPLICATE', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeFrameFile(artifactDir, 'home-default-390x844.png');
+        writeManifest(artifactDir, [{ file }, { file }]);
+        const wide = { ...HOME_TARGET, viewport: '1280x800' };
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file }), makeFrame({ file, viewport: '1280x800' })] }), artifactDir, Date.now(), [HOME_TARGET, wide]);
+        expect(validation.checks.map(check => check.status)).toEqual(['OK', 'DUPLICATE']);
+        expect(validation.okFiles).toEqual([file]);
+        expect(validation.problems.join('\n')).toContain('reused evidence file');
+    });
+    it('notes a frame saved under a name other than the one prescribed, without failing it', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeFrameFile(artifactDir, 'whatever-i-felt-like.png');
+        writeManifest(artifactDir, [{ file }]);
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file })] }), artifactDir, Date.now(), [HOME_TARGET]);
+        expect(validation.checks[0].status).toBe('OK');
+        expect(validation.checks[0].misnamed).toBe(true);
+        expect(validation.problems).toEqual([]);
+        expect(validation.notes.join('\n')).toContain('MISNAMED');
+        expect(validation.notes.join('\n')).toContain(frameFileName(HOME_TARGET));
+    });
+    it.each([
+        ['a capture file', 'home-default-390x844.capture.js'],
+        ['a layout file', 'home-default-390x844.layout.json'],
+        ['text with a PNG extension', 'home-default-390x844.png'],
+        ['text with a JPEG extension', 'home-default-390x844.jpg'],
+    ])('rejects %s reported as a frame as NOT_IMAGE, and fails the pass', (_label, name) => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeFrameFile(artifactDir, name, 'not an image');
+        writeManifest(artifactDir, [{ file }]);
+        const result = makeResult({ frames: [makeFrame({ file })] });
+        const validation = validateFrames(result, artifactDir, Date.now(), [HOME_TARGET]);
+        const decision = deriveVerdict({ result, validation, coverage: CLEAN_COVERAGE, deniedActions: '' });
+        expect(validation.checks[0].status).toBe('NOT_IMAGE');
+        expect(validation.okFiles).toEqual([]);
+        expect(validation.problems).toEqual([`NOT_IMAGE: ${file} (home / default)`]);
+        expect(decision.verdict).toBe('FAIL');
+        expect(decision.reasons).toEqual([`NOT_IMAGE: ${file} (home / default)`]);
+    });
+    it('rejects JPEG bytes renamed to .png', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeFrameFile(artifactDir, 'home-default-390x844.png', JPEG);
+        writeManifest(artifactDir, [{ file }]);
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file })] }), artifactDir, Date.now());
+        expect(validation.checks[0].status).toBe('NOT_IMAGE');
+        expect(validation.okFiles).toEqual([]);
+    });
+    it('treats a directory reported as a frame as MISSING', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = path.join(artifactDir, 'home-default.png');
+        fs.mkdirSync(file, { recursive: true });
+        writeManifest(artifactDir, [{ file }]);
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file })] }), artifactDir, Date.now());
+        expect(validation.checks[0].status).toBe('MISSING');
+        expect(validation.okFiles).toEqual([]);
+    });
+    it('flags a frame written outside the artifact directory', () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, 'frames');
+        fs.mkdirSync(artifactDir, { recursive: true });
+        const outside = writeFrameFile(workDir, 'escaped.png');
+        writeManifest(artifactDir, [{ file: outside }]);
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file: outside })] }), artifactDir, Date.now());
+        expect(validation.checks[0].status).toBe('OUTSIDE');
+    });
+    it('reports a missing manifest and captures that were never reported', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const reported = writeFrameFile(artifactDir, 'home-default.png');
+        writeFrameFile(artifactDir, 'orphan.png');
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file: reported })] }), artifactDir, Date.now());
+        expect(validation.problems.join('\n')).toContain('was not written');
+        expect(validation.unreportedCaptures).toEqual([path.join(artifactDir, 'orphan.png')]);
+    });
+    it('rejects a manifest left over from an earlier run in a reused artifact directory', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeFrameFile(artifactDir, 'home-default-390x844.png');
+        writeManifest(artifactDir, [{ file }]);
+        const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+        fs.utimesSync(path.join(artifactDir, LIVE_PASS.MANIFEST_FILE), yesterday, yesterday);
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file })] }), artifactDir, Date.now(), [HOME_TARGET]);
+        expect(validation.problems.join('\n')).toContain('predates this run');
+    });
+    it('reports a manifest whose frame count disagrees with the answer', () => {
+        const artifactDir = path.join(makeWorkDir(), 'frames');
+        const file = writeFrameFile(artifactDir, 'home-default.png');
+        writeManifest(artifactDir, []);
+        const validation = validateFrames(makeResult({ frames: [makeFrame({ file })] }), artifactDir, Date.now());
+        expect(validation.problems.join('\n')).toContain('lists 0 frames');
+    });
+});
+describe('checkCoverage', () => {
+    it('matches a target to its frame exactly', () => {
+        const coverage = checkCoverage([HOME_TARGET], makeResult());
+        expect(coverage.uncovered).toEqual([]);
+        expect(coverage.extraFrames).toEqual([]);
+    });
+    it('matches despite case and whitespace differences', () => {
+        const result = makeResult({
+            frames: [makeFrame({ screen: ' HOME ', state: 'Default', viewport: '390 x 844' })],
+        });
+        expect(checkCoverage([HOME_TARGET], result).uncovered).toEqual([]);
+    });
+    it('reports a target with no frame as uncovered', () => {
+        const missing = { ...HOME_TARGET, screen: 'settings' };
+        const coverage = checkCoverage([HOME_TARGET, missing], makeResult());
+        expect(coverage.uncovered).toEqual([missing]);
+    });
+    it('reports a target only present in skipped as skipped', () => {
+        const missing = { ...HOME_TARGET, screen: 'settings' };
+        const result = makeResult({ skipped: [{ target: 'settings / default', reason: 'route 500s' }] });
+        const coverage = checkCoverage([HOME_TARGET, missing], result);
+        expect(coverage.uncovered).toEqual([]);
+        expect(coverage.skipped).toEqual([{ target: missing, reason: 'route 500s' }]);
+    });
+    it('keeps a frame that matches no requested target as an extra', () => {
+        const result = makeResult({
+            frames: [makeFrame(), makeFrame({ screen: 'bonus', file: '/tmp/bonus.png' })],
+        });
+        expect(checkCoverage([HOME_TARGET], result).extraFrames).toEqual(['/tmp/bonus.png']);
+    });
+});
+describe('deriveVerdict', () => {
+    it('downgrades a reported PASS when a frame failed', () => {
+        const result = makeResult({ frames: [makeFrame({ verdict: 'FAIL' })] });
+        const decision = deriveVerdict({ result, validation: CLEAN_VALIDATION, coverage: CLEAN_COVERAGE, deniedActions: '' });
+        expect(decision.verdict).toBe('FAIL');
+        expect(decision.reported).toBe('PASS');
+        expect(decision.reasons.join('\n')).toContain('frame FAIL: home / default');
+    });
+    it('downgrades a reported PASS when a target was never covered', () => {
+        const decision = deriveVerdict({
+            result: makeResult(),
+            validation: CLEAN_VALIDATION,
+            coverage: { ...CLEAN_COVERAGE, uncovered: [{ ...HOME_TARGET, screen: 'settings' }] },
+            deniedActions: '',
+        });
+        expect(decision.verdict).toBe('FAIL');
+        expect(decision.reasons.join('\n')).toContain('uncovered target: settings');
+    });
+    it('downgrades a reported PASS when a frame did not validate', () => {
+        const decision = deriveVerdict({
+            result: makeResult(),
+            validation: { ...CLEAN_VALIDATION, problems: ['STALE: /tmp/frame.png (home / default)'] },
+            coverage: CLEAN_COVERAGE,
+            deniedActions: '',
+        });
+        expect(decision.verdict).toBe('FAIL');
+    });
+    it.each([
+        ['BLOCKER', 'FAIL'],
+        ['MAJOR', 'FAIL'],
+        ['MINOR', 'PASS'],
+    ])('treats a %s finding as %s', (severity, expected) => {
+        const result = makeResult({ findings: [{ severity, screen: 'home', description: 'label clipped' }] });
+        const decision = deriveVerdict({ result, validation: CLEAN_VALIDATION, coverage: CLEAN_COVERAGE, deniedActions: '' });
+        expect(decision.verdict).toBe(expected);
+    });
+    it('fails a target Gemini skipped: a reason explains missing evidence, it does not excuse it', () => {
+        const decision = deriveVerdict({
+            result: makeResult(),
+            validation: CLEAN_VALIDATION,
+            coverage: {
+                ...CLEAN_COVERAGE,
+                skipped: [{ target: { ...HOME_TARGET, screen: 'settings' }, reason: 'simulator busy' }],
+            },
+            deniedActions: '',
+        });
+        expect(decision.verdict).toBe('FAIL');
+        expect(decision.reasons.join('\n')).toContain('skipped target: settings / default (simulator busy)');
+    });
+    it('is BLOCKED whenever Gemini reported BLOCKED', () => {
+        const result = makeResult({ verdict: 'BLOCKED', frames: [] });
+        const decision = deriveVerdict({ result, validation: CLEAN_VALIDATION, coverage: CLEAN_COVERAGE, deniedActions: '' });
+        expect(decision.verdict).toBe('BLOCKED');
+    });
+    it('is BLOCKED whenever an action was denied, whatever Gemini reported', () => {
+        const decision = deriveVerdict({
+            result: makeResult(),
+            validation: CLEAN_VALIDATION,
+            coverage: CLEAN_COVERAGE,
+            deniedActions: 'RunCommand (command)',
+        });
+        expect(decision.verdict).toBe('BLOCKED');
+        expect(decision.reasons.join('\n')).toContain('RunCommand (command)');
+    });
+    it('fails on a regression and passes on resolved or neutral changes', () => {
+        const regressed = deriveVerdict({
+            result: makeResult({ regressions: [{ severity: 'MAJOR', screen: 'home', description: 'Retry no longer works' }] }),
+            validation: CLEAN_VALIDATION,
+            coverage: CLEAN_COVERAGE,
+            deniedActions: '',
+        });
+        const improved = deriveVerdict({
+            result: makeResult({
+                resolved: [{ screen: 'home', description: 'clipped label now wraps' }],
+                changes: [{ screen: 'home', description: 'Retry moved below the message' }],
+            }),
+            validation: CLEAN_VALIDATION,
+            coverage: CLEAN_COVERAGE,
+            deniedActions: '',
+        });
+        expect(regressed.verdict).toBe('FAIL');
+        expect(improved.verdict).toBe('PASS');
+    });
+});
+// --------------------------------------------------------------- publishing
+describe('runPublishCommand', () => {
+    it('substitutes shell-quoted file paths', async () => {
+        const dir = makeWorkDir();
+        const file = writeFrameFile(dir, "it's here.png");
+        const result = await runPublishCommand('echo {files}', [file], dir);
+        expect(result.ran).toBe(true);
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toBe(file);
+    });
+    it('does not run without a command or without OK frames', async () => {
+        const dir = makeWorkDir();
+        expect((await runPublishCommand(undefined, ['/tmp/a.png'], dir)).ran).toBe(false);
+        const skipped = await runPublishCommand('echo {files}', [], dir);
+        expect(skipped.ran).toBe(false);
+        expect(skipped.skippedReason).toContain('no frames validated OK');
+    });
+    it('does not hang on a command that reads stdin', async () => {
+        const dir = makeWorkDir();
+        const result = await runPublishCommand('cat; echo done', ['/tmp/a.png'], dir);
+        expect(result.ran).toBe(true);
+        expect(result.stdout).toBe('done');
+    });
+    it('reports a non-zero exit instead of throwing', async () => {
+        const dir = makeWorkDir();
+        const result = await runPublishCommand('echo boom >&2; exit 3', ['/tmp/a.png'], dir);
+        expect(result.exitCode).toBe(3);
+        expect(result.stderr).toContain('boom');
+    });
+});
+// ------------------------------------------------------------------ execute
+describe('live-pass execute', () => {
+    it('rejects a working directory that is a root or does not exist', async () => {
+        const base = { targets: [HOME_TARGET], brief: 'b', driver: 'playwright' };
+        await expect(run({ ...base, workingDirectory: '/' })).rejects.toThrow(ERROR_MESSAGES.INVALID_WORKING_DIRECTORY);
+        await expect(run({ ...base, workingDirectory: '/no/such/dir/here' })).rejects.toThrow(ERROR_MESSAGES.INVALID_WORKING_DIRECTORY);
+        expect(mockExecuteAgyJson).not.toHaveBeenCalled();
+    });
+    it.each([
+        ['outside the working directory', (workDir) => path.join(path.dirname(workDir), 'elsewhere')],
+        ['equal to the working directory', (workDir) => workDir],
+        ['relative', () => '.live-pass/run1'],
+    ])('rejects an artifactDir that is %s', async (_label, makeDir) => {
+        const workDir = makeWorkDir();
+        await expect(run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright',
+            workingDirectory: workDir, artifactDir: makeDir(workDir),
+        })).rejects.toThrow(ERROR_MESSAGES.LIVE_PASS_ARTIFACT_DIR);
+        expect(mockExecuteAgyJson).not.toHaveBeenCalled();
+    });
+    it('accepts an artifactDir reached through a symlinked spelling of the worktree', async () => {
+        const workDir = makeWorkDir();
+        const link = path.join(makeWorkDir(), 'link');
+        fs.symlinkSync(workDir, link);
+        mockExecuteAgyJson.mockResolvedValue(envelope(makeResult()));
+        await run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright',
+            workingDirectory: link, artifactDir: path.join(link, '.live-pass', 'run1'),
+        });
+        const options = mockExecuteAgyJson.mock.calls[0][1];
+        expect(options.cwd).toBe(workDir);
+        expect(options.includeDirectories[1]).toBe(path.join(workDir, '.live-pass', 'run1'));
+    });
+    it('refuses the default artifact directory when .live-pass is a symlink out of the worktree', async () => {
+        const workDir = makeWorkDir();
+        const outside = makeWorkDir();
+        fs.symlinkSync(outside, path.join(workDir, LIVE_PASS.DEFAULT_ARTIFACT_SEGMENT));
+        await expect(run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir,
+        })).rejects.toThrow(ERROR_MESSAGES.LIVE_PASS_ARTIFACT_DIR);
+        expect(mockExecuteAgyJson).not.toHaveBeenCalled();
+    });
+    it('reports uninvited edits when the agy call itself fails', async () => {
+        const workDir = makeWorkDir();
+        mockSnapshotWorkingTree
+            .mockReturnValueOnce(cleanSnapshot(workDir))
+            .mockReturnValueOnce({
+            root: workDir,
+            lines: [' M src/app/index.tsx'],
+            hashes: new Map(),
+            truncated: false,
+        });
+        mockExecuteAgyJson.mockRejectedValue(new Error('Error: timed out waiting for response'));
+        await expect(run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir,
+        })).rejects.toThrow(/timed out[\s\S]*Working tree[\s\S]*src\/app\/index\.tsx/);
+    });
+    it('defaults the artifact directory to a timestamped folder under the worktree', async () => {
+        const workDir = makeWorkDir();
+        mockExecuteAgyJson.mockResolvedValue(envelope(makeResult()));
+        await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir });
+        const options = mockExecuteAgyJson.mock.calls[0][1];
+        const artifactDir = options.includeDirectories[1];
+        expect(artifactDir.startsWith(path.join(workDir, LIVE_PASS.DEFAULT_ARTIFACT_SEGMENT))).toBe(true);
+        expect(fs.existsSync(artifactDir)).toBe(true);
+    });
+    it('forwards the agy options the pass depends on', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        mockExecuteAgyJson.mockResolvedValue(envelope(makeResult()));
+        await run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright',
+            workingDirectory: workDir, artifactDir, conversationId: 'conv-abc',
+        });
+        const [prompt, options] = mockExecuteAgyJson.mock.calls[0];
+        expect(prompt).toContain('Delta reporting');
+        expect(options).toMatchObject({
+            cwd: workDir,
+            noCache: true,
+            conversationId: 'conv-abc',
+            yolo: true,
+            model: MODELS.MEDIUM,
+            printTimeout: LIVE_PASS.DEFAULT_PRINT_TIMEOUT,
+        });
+        expect(options.includeDirectories).toEqual([workDir, artifactDir]);
+        expect(JSON.parse(options.jsonSchema).properties).toHaveProperty('frames');
+    });
+    it('reports PASS with frames, PR markdown and no image data', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        let file = '';
+        mockExecuteAgyJson.mockImplementation(async () => {
+            file = writeFrameFile(artifactDir, 'home-default-390x844.png');
+            writeManifest(artifactDir, [{ file }]);
+            return envelope(makeResult({ frames: [makeFrame({ file })] }));
+        });
+        const report = await run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright',
+            workingDirectory: workDir, artifactDir, publishCommand: 'echo "![home]({files})"',
+        });
+        expect(report).toContain('[GEMINI_CONVERSATION_ID=conv-abc]');
+        expect(report).toContain('# Live pass: PASS');
+        expect(report).toContain(file);
+        expect(report).toContain('## PR markdown');
+        expect(report).toContain('![home](');
+        expect(report).not.toMatch(/data:image|base64/);
+        expect(report).not.toContain('WARNING');
+    });
+    it('fails two targets answered by one screenshot, even when Gemini reports PASS', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        const wide = { ...HOME_TARGET, viewport: '1280x800' };
+        mockExecuteAgyJson.mockImplementation(async () => {
+            const file = writeFrameFile(artifactDir, frameFileName(HOME_TARGET));
+            writeManifest(artifactDir, [{ file }, { file }]);
+            return envelope(makeResult({
+                frames: [makeFrame({ file }), makeFrame({ file, viewport: '1280x800' })],
+            }));
+        });
+        const report = await run({
+            targets: [HOME_TARGET, wide], brief: 'b', driver: 'playwright',
+            workingDirectory: workDir, artifactDir,
+        });
+        expect(report).toContain('# Live pass: FAIL (Gemini reported PASS)');
+        expect(report).toContain('reused evidence file');
+    });
+    it('passes the same two targets when each has its own screenshot', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        const wide = { ...HOME_TARGET, viewport: '1280x800' };
+        mockExecuteAgyJson.mockImplementation(async () => {
+            const mobile = writeFrameFile(artifactDir, frameFileName(HOME_TARGET));
+            const desktop = writeFrameFile(artifactDir, frameFileName(wide));
+            writeManifest(artifactDir, [{ file: mobile }, { file: desktop }]);
+            return envelope(makeResult({
+                frames: [makeFrame({ file: mobile }), makeFrame({ file: desktop, viewport: '1280x800' })],
+            }));
+        });
+        const report = await run({
+            targets: [HOME_TARGET, wide], brief: 'b', driver: 'playwright',
+            workingDirectory: workDir, artifactDir,
+        });
+        expect(report).toContain('# Live pass: PASS');
+        expect(report).not.toContain('reused evidence file');
+        expect(report).not.toContain('MISNAMED');
+    });
+    it('derives FAIL from an uncovered target even when Gemini reports PASS', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        mockExecuteAgyJson.mockImplementation(async () => {
+            const file = writeFrameFile(artifactDir, 'home-default-390x844.png');
+            writeManifest(artifactDir, [{ file }]);
+            return envelope(makeResult({ frames: [makeFrame({ file })] }));
+        });
+        const report = await run({
+            targets: [HOME_TARGET, { ...HOME_TARGET, screen: 'missing', state: 'not-found', expected: '404 text' }],
+            brief: 'b', driver: 'playwright', workingDirectory: workDir, artifactDir,
+        });
+        expect(report).toContain('# Live pass: FAIL (Gemini reported PASS)');
+        expect(report).toContain('uncovered target: missing / not-found');
+    });
+    it('passes a resumed re-pass whose only earlier defect is now fixed', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run2');
+        mockExecuteAgyJson.mockImplementation(async () => {
+            const file = writeFrameFile(artifactDir, 'home-default-390x844.png');
+            writeManifest(artifactDir, [{ file }]);
+            return envelope(makeResult({
+                frames: [makeFrame({ file })],
+                resolved: [{ screen: 'home', description: 'the clipped Retry label now wraps' }],
+            }));
+        });
+        const report = await run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright',
+            workingDirectory: workDir, artifactDir, conversationId: 'conv-abc',
+        });
+        expect(report).toContain('# Live pass: PASS');
+        expect(report).toContain('the clipped Retry label now wraps');
+    });
+    it('fails a resumed re-pass that reports a regression', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run2');
+        mockExecuteAgyJson.mockImplementation(async () => {
+            const file = writeFrameFile(artifactDir, 'home-default-390x844.png');
+            writeManifest(artifactDir, [{ file }]);
+            return envelope(makeResult({
+                frames: [makeFrame({ file })],
+                regressions: [{ severity: 'MAJOR', screen: 'home', description: 'Retry no longer reloads' }],
+            }));
+        });
+        const report = await run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright',
+            workingDirectory: workDir, artifactDir, conversationId: 'conv-abc',
+        });
+        expect(report).toContain('# Live pass: FAIL');
+        expect(report).toContain('Retry no longer reloads');
+    });
+    it('blocks and skips publishing when actions were denied', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        const marker = path.join(workDir, 'published.txt');
+        mockExecuteAgyJson.mockResolvedValue(envelope(makeResult({ verdict: 'BLOCKED', frames: [] }), {
+            denied_actions: [{ action: 'command', display_name: 'RunCommand' }],
+        }));
+        const report = await run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright',
+            workingDirectory: workDir, artifactDir, publishCommand: `touch ${marker}`,
+        });
+        expect(report).toContain('# Live pass: BLOCKED');
+        expect(report).toContain('RunCommand (command)');
+        expect(fs.existsSync(marker)).toBe(false);
+    });
+    it('blocks when the answer does not match the result schema', async () => {
+        const workDir = makeWorkDir();
+        mockExecuteAgyJson.mockResolvedValue(envelope({ verdict: 'MAYBE' }));
+        const report = await run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir,
+        });
+        expect(report).toContain('# Live pass: BLOCKED');
+        expect(report).toContain('Schema issues');
+        expect(report).toContain('Raw answer (truncated)');
+    });
+    it('still reports uninvited edits when the answer is off-schema', async () => {
+        const workDir = makeWorkDir();
+        mockSnapshotWorkingTree
+            .mockReturnValueOnce(cleanSnapshot(workDir))
+            .mockReturnValueOnce({ root: workDir, lines: [' M src/app/index.tsx'], hashes: new Map(), truncated: false });
+        mockExecuteAgyJson.mockResolvedValue(envelope({ verdict: 'MAYBE' }));
+        const report = await run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir,
+        });
+        expect(report).toContain('# Live pass: BLOCKED');
+        expect(report).toContain('## Working tree');
+        expect(report).toContain('src/app/index.tsx');
+    });
+    it('warns when the working tree changed during the pass', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        mockSnapshotWorkingTree
+            .mockReturnValueOnce(cleanSnapshot(workDir))
+            .mockReturnValueOnce({ root: workDir, lines: [' M src/app/index.tsx'], hashes: new Map(), truncated: false });
+        mockExecuteAgyJson.mockImplementation(async () => {
+            const file = writeFrameFile(artifactDir, 'home-default-390x844.png');
+            writeManifest(artifactDir, [{ file }]);
+            return envelope(makeResult({ frames: [makeFrame({ file })] }));
+        });
+        const report = await run({
+            targets: [HOME_TARGET], brief: 'b', driver: 'playwright',
+            workingDirectory: workDir, artifactDir,
+        });
+        expect(report).toContain('## Working tree');
+        expect(report).toContain('WARNING');
+        expect(report).toContain('src/app/index.tsx');
+    });
+});
+describe('live-pass execute: checkout, turns and layout checks', () => {
+    function passWithOneFrame(artifactDir, layout) {
+        mockExecuteAgyJson.mockImplementation(async () => {
+            const file = writeFrameFile(artifactDir, frameFileName(HOME_TARGET));
+            if (layout !== undefined)
+                writeLayoutFile(artifactDir, frameFileName(HOME_TARGET), layout);
+            writeManifest(artifactDir, [{ file }]);
+            return envelope(makeResult({ frames: [makeFrame({ file })] }), { num_turns: 9 });
+        });
+    }
+    it('reads the branch and HEAD of a git working directory into the prompt', async () => {
+        const workDir = makeWorkDir();
+        const git = (...args) => execFileSync('git', args, { cwd: workDir, encoding: 'utf-8' }).trim();
+        git('init', '--quiet', '--initial-branch', 'feat/served');
+        git('-c', 'user.email=t@example.com', '-c', 'user.name=t', 'commit', '--quiet', '--allow-empty', '-m', 'seed');
+        const head = git('rev-parse', 'HEAD');
+        mockExecuteAgyJson.mockResolvedValue(envelope(makeResult()));
+        await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir });
+        expect(mockExecuteAgyJson.mock.calls[0][0]).toContain(`- Checkout under test: feat/served at ${head}. Read for you, so never run git.`);
+    });
+    it('runs on a working directory that is not a git checkout', async () => {
+        const workDir = makeWorkDir();
+        mockExecuteAgyJson.mockResolvedValue(envelope(makeResult()));
+        await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir });
+        expect(mockExecuteAgyJson.mock.calls[0][0]).toContain("- Checkout under test: not a git checkout with a commit, so rely on the brief's marker alone.");
+    });
+    it("prints Gemini's model steps per frame, read from agy's store for this conversation, under the usage line", async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        passWithOneFrame(artifactDir);
+        mockCountAgyModelSteps.mockResolvedValueOnce(18);
+        const report = await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir, artifactDir });
+        expect(mockCountAgyModelSteps).toHaveBeenLastCalledWith('conv-abc');
+        expect(report).toMatch(/\nUsage: 9 turns [^\n]*\n\nGemini steps: 18 \(18 per frame, 1 frame\)\n/);
+    });
+    it('prints the quoted link source under a frame that began at a link the user arrives by', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        mockExecuteAgyJson.mockImplementation(async () => {
+            const file = writeFrameFile(artifactDir, frameFileName(HOME_TARGET));
+            writeManifest(artifactDir, [{ file }]);
+            return envelope(makeResult({ frames: [makeFrame({ file, link_source: 'the invite email the studio owner sends' })] }));
+        });
+        const report = await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir, artifactDir });
+        expect(report).toContain(`  file: ${path.join(artifactDir, frameFileName(HOME_TARGET))}\n  arrived by link: the invite email the studio owner sends\n  expected: heading 'Hello'`);
+    });
+    it('prints no link line under a frame reached by taps', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        passWithOneFrame(artifactDir);
+        const report = await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir, artifactDir });
+        expect(report).toContain(`  file: ${path.join(artifactDir, frameFileName(HOME_TARGET))}\n  expected: heading 'Hello'`);
+        expect(report).not.toContain('arrived by link');
+    });
+    it('reports layout defects for the caller to judge without changing a PASS', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        passWithOneFrame(artifactDir, makeLayoutReport({ found: 1, entries: [SPILL_ENTRY] }));
+        const report = await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir, artifactDir });
+        expect(report).toContain('# Live pass: PASS\n');
+        expect(report).toContain('## Why\n- none');
+        expect(report).toContain('## Layout checks (measured in the page)\n- home / default / 390x844: 1 entry\n  - text-spill "Uploaded to the studio wins wall" testID=label at 0,0 320x20');
+    });
+    it.each([
+        ['missing', undefined, 'MISSING'],
+        ['malformed', '{"check":', 'MALFORMED'],
+    ])('shows a %s layout file as not run, and still passes', async (_label, layout, status) => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        passWithOneFrame(artifactDir, layout);
+        const report = await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir, artifactDir });
+        expect(report).toContain('# Live pass: PASS\n');
+        expect(report).toContain(`- home / default / 390x844: not run (${status}: `);
+        expect(report).not.toContain('layout.json (home');
+    });
+    it('never feeds layout entries into the derived verdict', async () => {
+        const workDir = makeWorkDir();
+        const clean = path.join(workDir, '.live-pass', 'clean');
+        const defective = path.join(workDir, '.live-pass', 'defective');
+        passWithOneFrame(clean, makeLayoutReport());
+        const cleanReport = await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir, artifactDir: clean });
+        passWithOneFrame(defective, makeLayoutReport({ found: 50, entries: Array(50).fill(SPILL_ENTRY) }));
+        const defectiveReport = await run({ targets: [HOME_TARGET], brief: 'b', driver: 'playwright', workingDirectory: workDir, artifactDir: defective });
+        expect(defectiveReport).toContain('- home / default / 390x844: 50 entries');
+        expect(cleanReport).toContain('- home / default / 390x844: clean');
+        const verdictAndWhy = (report) => report.slice(report.indexOf('# Live pass'), report.indexOf('## Served-branch check'));
+        expect(verdictAndWhy(defectiveReport).replace(defective, clean)).toBe(verdictAndWhy(cleanReport));
+    });
+    it('writes one capture script per web target at its prescribed path before agy runs', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        const wide = { ...HOME_TARGET, viewport: '1280x800' };
+        let writtenBeforeAgy = [];
+        mockExecuteAgyJson.mockImplementation(async () => {
+            writtenBeforeAgy = fs.readdirSync(artifactDir).sort();
+            return envelope(makeResult());
+        });
+        await run({ targets: [HOME_TARGET, wide], brief: 'b', driver: 'playwright', workingDirectory: workDir, artifactDir });
+        expect(writtenBeforeAgy).toEqual(['home-default-1280x800.capture.js', 'home-default-390x844.capture.js']);
+        for (const [stem, viewport] of [['home-default-390x844', { width: 390, height: 844 }], ['home-default-1280x800', { width: 1280, height: 800 }]]) {
+            expect(fs.readFileSync(path.join(artifactDir, `${stem}.capture.js`), 'utf-8')).toBe(buildCaptureScript({
+                viewport, frameFile: path.join(artifactDir, `${stem}.png`), key: `${stem}.png`,
+            }));
+        }
+    });
+    it('replaces a symlink at a capture path with a regular file, leaving the link\'s target untouched', () => {
+        const artifactDir = makeWorkDir();
+        const outside = path.join(makeWorkDir(), 'victim.txt');
+        fs.writeFileSync(outside, 'keep me');
+        const capture = path.join(artifactDir, 'home-default-390x844.capture.js');
+        fs.symlinkSync(outside, capture);
+        writeCaptureScripts([HOME_TARGET], artifactDir);
+        expect(fs.readFileSync(outside, 'utf-8')).toBe('keep me');
+        expect(fs.lstatSync(capture).isFile()).toBe(true);
+    });
+    it('writes no capture script for a maestro pass', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        mockExecuteAgyJson.mockResolvedValue(envelope(makeResult()));
+        await run({ targets: [HOME_TARGET], brief: 'b', driver: 'maestro', workingDirectory: workDir, artifactDir });
+        expect(fs.readdirSync(artifactDir)).toEqual([]);
+    });
+    it('refuses to write a capture script for a viewport that is not WxH', () => {
+        const artifactDir = makeWorkDir();
+        expect(() => writeCaptureScripts([{ ...HOME_TARGET, viewport: 'iPhone 15' }], artifactDir))
+            .toThrow(`${ERROR_MESSAGES.LIVE_PASS_WEB_VIEWPORT}. Received 'iPhone 15'.`);
+        expect(fs.readdirSync(artifactDir)).toEqual([]);
+    });
+    it('adds no layout section to a maestro pass', async () => {
+        const workDir = makeWorkDir();
+        const artifactDir = path.join(workDir, '.live-pass', 'run1');
+        passWithOneFrame(artifactDir);
+        const report = await run({ targets: [HOME_TARGET], brief: 'b', driver: 'maestro', workingDirectory: workDir, artifactDir });
+        expect(report).not.toContain('Layout checks');
+    });
+});
+describe('livePassResultSchema', () => {
+    it('accepts a fresh pass with empty delta arrays', () => {
+        expect(livePassResultSchema.safeParse(makeResult()).success).toBe(true);
+    });
+    it('accepts a frame with a link_source and one without', () => {
+        const result = makeResult({ frames: [makeFrame(), makeFrame({ file: '/tmp/invite.png', link_source: 'the share link a teammate texts' })] });
+        expect(livePassResultSchema.safeParse(result).success).toBe(true);
+    });
+    it('rejects a frame verdict outside PASS/FAIL', () => {
+        const result = makeResult({ frames: [makeFrame({ verdict: 'BLOCKED' })] });
+        expect(livePassResultSchema.safeParse(result).success).toBe(false);
+    });
+});
+//# sourceMappingURL=live-pass.test.js.map