@monoes/monobrowse 1.0.11 → 1.0.13

package/dist/src/cli/commands.js

@@ -2,8 +2,8 @@
  * Browse Command — Native browser automation via Chrome DevTools Protocol
  * Provides ref-based element model and token-efficient accessibility snapshots
  */
-import { output } from './output.js';
 import { createActionCommand } from './action.js';
+import { output } from './output.js';
 import { createPlatformCommand } from './platform.js';
 // Runtime state (single session per CLI process)
 const DEFAULT_PORT = 9222;
@@ -50,7 +50,9 @@ function ensureSignalCleanupHandlers() {
                             try {
                                 process.kill(pid, 'SIGKILL');
                             }
-                            catch { /* already exited */ }
+                            catch {
+                                /* already exited */
+                            }
                         }
                     }
                 }
@@ -78,7 +80,9 @@ async function resolveDefaultPort(browser) {
         // user's debug port and silently swap which browser commands act on —
         // fail loudly instead.
         try {
-            await fetch(`http://127.0.0.1:${persisted.port}/json/version`, { signal: AbortSignal.timeout(1500) });
+            await fetch(`http://127.0.0.1:${persisted.port}/json/version`, {
+                signal: AbortSignal.timeout(1500),
+            });
         }
         catch {
             await browser.clearActivePort();
@@ -89,7 +93,7 @@ async function resolveDefaultPort(browser) {
 }
 async function ensureConnected(port, targetId) {
     const browser = await getBrowser();
-    if (!_client || !_client.isConnected()) {
+    if (!_client?.isConnected()) {
         if (_client && _sessionId) {
             browser.teardownRouteInterception(_sessionId);
             browser.stopRequestCapture(_sessionId);
@@ -146,20 +150,28 @@ async function detectAttentionNeeded(client, sessionId, url) {
     if (ATTENTION_URL_RE.test(url))
         return 'login';
     try {
-        const hasPassword = await client.send('Runtime.evaluate', {
+        const hasPassword = await client
+            .send('Runtime.evaluate', {
             expression: '!!document.querySelector("input[type=password]")',
             returnByValue: true,
-        }, sessionId).then(r => r.result?.value === true).catch(() => false);
+        }, sessionId)
+            .then((r) => r.result?.value === true)
+            .catch(() => false);
         if (hasPassword)
             return 'login';
-        const hasCaptcha = await client.send('Runtime.evaluate', {
+        const hasCaptcha = await client
+            .send('Runtime.evaluate', {
             expression: '!!(document.querySelector("iframe[src*=recaptcha]") || document.querySelector("iframe[src*=hcaptcha]") || document.querySelector(".g-recaptcha") || document.querySelector(".h-captcha") || document.querySelector("[data-sitekey]"))',
             returnByValue: true,
-        }, sessionId).then(r => r.result?.value === true).catch(() => false);
+        }, sessionId)
+            .then((r) => r.result?.value === true)
+            .catch(() => false);
         if (hasCaptcha)
             return 'captcha';
     }
-    catch { /* ignore CDP errors */ }
+    catch {
+        /* ignore CDP errors */
+    }
     return null;
 }
 function waitForEnter() {
@@ -167,12 +179,16 @@ function waitForEnter() {
         // Non-interactive context (MCP server, piped input, CI) — cannot safely read stdin.
         // Auto-continue after a short grace period so automation isn't blocked.
         output.printWarning('Non-interactive mode: auto-continuing in 30s. Switch to headed manually if needed.');
-        return new Promise(resolve => setTimeout(resolve, 30_000));
+        return new Promise((resolve) => setTimeout(resolve, 30_000));
     }
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
         process.stdin.resume();
         process.stdin.setEncoding('utf8');
-        const onData = () => { process.stdin.pause(); process.stdin.off('data', onData); resolve(); };
+        const onData = () => {
+            process.stdin.pause();
+            process.stdin.off('data', onData);
+            resolve();
+        };
         process.stdin.once('data', onData);
     });
 }
@@ -184,7 +200,9 @@ async function switchToHeaded(url, port) {
         try {
             savedCookies = await browser.getCookies(_client, _sessionId);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         browser.teardownRouteInterception(_sessionId);
         browser.stopRequestCapture(_sessionId);
         browser.teardownDialogHandling(_sessionId);
@@ -219,14 +237,18 @@ async function switchToHeaded(url, port) {
         try {
             await browser.setCookies(_client, _sessionId, savedCookies);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     await browser.openUrl(_client, _sessionId, url);
     output.printInfo('Browser window opened. Complete the required action (login / CAPTCHA), then press Enter to continue in headless mode...');
     await waitForEnter();
     // Capture post-auth cookies
     const authCookies = await browser.getCookies(_client, _sessionId).catch(() => []);
-    const authLocalStorage = await browser.getLocalStorage(_client, _sessionId).catch(() => ({}));
+    const authLocalStorage = await browser
+        .getLocalStorage(_client, _sessionId)
+        .catch(() => ({}));
     // Close headed session — actually terminate the underlying Chrome process
     // (Browser.close CDP command, PID-kill fallback), not just our CDP client
     // connection, so the visible authenticated window doesn't linger forever.
@@ -251,13 +273,17 @@ async function switchToHeaded(url, port) {
         try {
             await browser.setCookies(_client, _sessionId, authCookies);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     if (authLocalStorage && Object.keys(authLocalStorage).length) {
         try {
             await browser.setLocalStorage(_client, _sessionId, authLocalStorage);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
 }
 /**
@@ -272,7 +298,7 @@ function imageFormat(value, allowed, fallback) {
     return allowed.includes(value) ? value : fallback;
 }
 function print(msg) {
-    process.stdout.write(msg + '\n');
+    process.stdout.write(`${msg}\n`);
 }
 // ---------------------------------------------------------------------------
 // Sub-commands
@@ -282,7 +308,12 @@ const openCommand = {
     description: 'Open a URL in the browser. Usage: monomind browse open <url>',
     options: [
         { name: 'port', short: 'p', type: 'number', description: 'CDP port', default: 9222 },
-        { name: 'headed', type: 'boolean', description: 'Force visible browser window', default: false },
+        {
+            name: 'headed',
+            type: 'boolean',
+            description: 'Force visible browser window',
+            default: false,
+        },
         { name: 'session', short: 's', type: 'string', description: 'Session name to restore' },
         { name: 'state', type: 'string', description: 'State file to load' },
     ],
@@ -300,19 +331,25 @@ const openCommand = {
                 try {
                     await browser.stopHarRecording(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.getTraceStatus(prevSid)) {
                 try {
                     await browser.stopTrace(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.isProfilingActive(prevSid)) {
                 try {
                     await browser.stopCpuProfile(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             browser.teardownRouteInterception(prevSid);
             browser.stopRequestCapture(prevSid);
@@ -352,7 +389,10 @@ const openCommand = {
             // launched it) instead of overwriting with undefined.
             const existing = await browser.loadActivePortInfo();
             const preserved = existing && existing.port === _port ? existing : undefined;
-            await browser.saveActivePort(_port, { pid: preserved?.pid, userDataDir: preserved?.userDataDir });
+            await browser.saveActivePort(_port, {
+                pid: preserved?.pid,
+                userDataDir: preserved?.userDataDir,
+            });
         }
         ensureSignalCleanupHandlers();
         const conn = await browser.connectToTarget(_port);
@@ -395,15 +435,49 @@ const snapshotCommand = {
     name: 'snapshot',
     description: 'Capture accessibility snapshot with ref-based element handles (@e1, @e2, ...)',
     options: [
-        { name: 'interactive', short: 'i', type: 'boolean', description: 'Interactive elements only (93% token reduction)', default: false },
-        { name: 'compact', short: 'c', type: 'boolean', description: 'Compact output format', default: false },
+        {
+            name: 'interactive',
+            short: 'i',
+            type: 'boolean',
+            description: 'Interactive elements only (93% token reduction)',
+            default: false,
+        },
+        {
+            name: 'compact',
+            short: 'c',
+            type: 'boolean',
+            description: 'Compact output format',
+            default: false,
+        },
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
         { name: 'depth', short: 'd', type: 'number', description: 'Max depth of AX tree to show' },
-        { name: 'selector', short: 's', type: 'string', description: 'Scope snapshot to a CSS selector' },
-        { name: 'save', type: 'string', description: 'Save snapshot text to file (baseline for --diff)' },
-        { name: 'diff', type: 'string', description: 'Compare current snapshot against a saved baseline file' },
-        { name: 'content-boundaries', type: 'boolean', description: 'Wrap output in sentinel markers to prevent page-content injection attacks', default: false },
-        { name: 'max-output', type: 'number', description: 'Truncate output to N characters (prevents context window blowout on large pages)' },
+        {
+            name: 'selector',
+            short: 's',
+            type: 'string',
+            description: 'Scope snapshot to a CSS selector',
+        },
+        {
+            name: 'save',
+            type: 'string',
+            description: 'Save snapshot text to file (baseline for --diff)',
+        },
+        {
+            name: 'diff',
+            type: 'string',
+            description: 'Compare current snapshot against a saved baseline file',
+        },
+        {
+            name: 'content-boundaries',
+            type: 'boolean',
+            description: 'Wrap output in sentinel markers to prevent page-content injection attacks',
+            default: false,
+        },
+        {
+            name: 'max-output',
+            type: 'number',
+            description: 'Truncate output to N characters (prevents context window blowout on large pages)',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -427,8 +501,8 @@ const snapshotCommand = {
         };
         // --save: write snapshot text to baseline file
         if (ctx.flags.save) {
-            const { writeFile, mkdir } = await import('fs/promises');
-            const { dirname } = await import('path');
+            const { writeFile, mkdir } = await import('node:fs/promises');
+            const { dirname } = await import('node:path');
             const savePath = ctx.flags.save;
             await mkdir(dirname(savePath), { recursive: true }).catch(() => { });
             await writeFile(savePath, result.text, 'utf8');
@@ -437,7 +511,7 @@ const snapshotCommand = {
         }
         // --diff: compare against baseline file
         if (ctx.flags.diff) {
-            const { readFile } = await import('fs/promises');
+            const { readFile } = await import('node:fs/promises');
             const baselinePath = ctx.flags.diff;
             let baseline;
             try {
@@ -459,7 +533,13 @@ const snapshotCommand = {
                     removed.push(l);
             const changed = added.length > 0 || removed.length > 0;
             if (ctx.flags.json) {
-                print(JSON.stringify({ changed, additions: added.length, removals: removed.length, added, removed }));
+                print(JSON.stringify({
+                    changed,
+                    additions: added.length,
+                    removals: removed.length,
+                    added,
+                    removed,
+                }));
             }
             else {
                 if (!changed) {
@@ -473,11 +553,19 @@ const snapshotCommand = {
                         print(`\x1b[31m- ${l}\x1b[0m`);
                 }
             }
-            return { success: true, data: { changed, additions: added.length, removals: removed.length } };
+            return {
+                success: true,
+                data: { changed, additions: added.length, removals: removed.length },
+            };
         }
         if (ctx.flags.json) {
             const refsObj = Object.fromEntries([...result.refs.entries()].map(([k, v]) => [k, v]));
-            print(JSON.stringify({ url: result.url, title: result.title, refs: refsObj, snapshot: result.text }));
+            print(JSON.stringify({
+                url: result.url,
+                title: result.title,
+                refs: refsObj,
+                snapshot: result.text,
+            }));
         }
         else {
             print(`[${result.title}] ${result.url}\n`);
@@ -555,11 +643,19 @@ const waitCommand = {
         { name: 'text', type: 'string', description: 'Wait for text to appear in page' },
         { name: 'not-text', type: 'string', description: 'Wait for text to disappear from page' },
         { name: 'selector', type: 'string', description: 'Wait for CSS selector to appear' },
-        { name: 'load', type: 'string', description: 'Wait for load event: load|networkidle|domcontentloaded' },
+        {
+            name: 'load',
+            type: 'string',
+            description: 'Wait for load event: load|networkidle|domcontentloaded',
+        },
         { name: 'fn', type: 'string', description: 'Wait until JS expression returns truthy' },
         { name: 'ms', type: 'number', description: 'Wait N milliseconds' },
         { name: 'timeout', short: 't', type: 'number', description: 'Timeout in ms', default: 30000 },
-        { name: 'download', type: 'string', description: 'Wait for a file download to complete and save to path (monitors Browser.downloadProgress events)' },
+        {
+            name: 'download',
+            type: 'string',
+            description: 'Wait for a file download to complete and save to path (monitors Browser.downloadProgress events)',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -574,7 +670,9 @@ const waitCommand = {
         if (ctx.flags.fn) {
             const expr = ctx.flags.fn;
             const rawTimeout = ctx.flags.timeout ?? 30000;
-            const timeout = Number.isFinite(rawTimeout) ? Math.max(100, Math.min(rawTimeout, 300_000)) : 30000; // cap at 5min
+            const timeout = Number.isFinite(rawTimeout)
+                ? Math.max(100, Math.min(rawTimeout, 300_000))
+                : 30000; // cap at 5min
             const interval = 200;
             const deadline = Date.now() + timeout;
             while (Date.now() < deadline) {
@@ -593,7 +691,7 @@ const waitCommand = {
             const interval = 200;
             const deadline = Date.now() + timeout;
             while (Date.now() < deadline) {
-                const text = await browser.evaluateJs(client, sessionId, 'document.body?.innerText ?? ""');
+                const text = (await browser.evaluateJs(client, sessionId, 'document.body?.innerText ?? ""'));
                 if (!text.includes(target)) {
                     output.printSuccess('Text disappeared');
                     return { success: true };
@@ -604,26 +702,39 @@ const waitCommand = {
         }
         if (ctx.flags.download) {
             const savePath = ctx.flags.download;
-            const { mkdir } = await import('fs/promises');
-            const { dirname, join } = await import('path');
-            const { tmpdir } = await import('os');
+            const { mkdir } = await import('node:fs/promises');
+            const { dirname, join } = await import('node:path');
+            const { tmpdir } = await import('node:os');
             const downloadDir = join(tmpdir(), `mm-dl-wait-${Date.now()}`);
             await mkdir(downloadDir, { recursive: true });
-            await client.send('Browser.setDownloadBehavior', {
-                behavior: 'allow', downloadPath: downloadDir, eventsEnabled: true,
-            }, undefined).catch(() => client.send('Page.setDownloadBehavior', { behavior: 'allow', downloadPath: downloadDir }, sessionId).catch(() => { }));
+            await client
+                .send('Browser.setDownloadBehavior', {
+                behavior: 'allow',
+                downloadPath: downloadDir,
+                eventsEnabled: true,
+            }, undefined)
+                .catch(() => client
+                .send('Page.setDownloadBehavior', { behavior: 'allow', downloadPath: downloadDir }, sessionId)
+                .catch(() => { }));
             const MAX_DOWNLOAD_TIMEOUT = 5 * 60 * 1000; // I6: cap at 5 minutes
             const rawTimeout = Math.min(ctx.flags.timeout ?? 30000, MAX_DOWNLOAD_TIMEOUT);
             const finalPath = await new Promise((resolve, reject) => {
                 let guid = '';
                 let settled = false;
                 // C2: capture off() functions to avoid listener leaks
-                const offBegin = client.on('Browser.downloadWillBegin', (params) => { guid = params.guid; });
+                const offBegin = client.on('Browser.downloadWillBegin', (params) => {
+                    guid = params.guid;
+                });
                 let offProgress;
                 // cleanup defined before setTimeout so the timeout callback can call it
                 let tid;
                 let pollTid;
-                const cleanup = () => { clearTimeout(tid); clearInterval(pollTid); offBegin?.(); offProgress?.(); };
+                const cleanup = () => {
+                    clearTimeout(tid);
+                    clearInterval(pollTid);
+                    offBegin?.();
+                    offProgress?.();
+                };
                 const finish = (path) => {
                     if (settled)
                         return;
@@ -641,7 +752,7 @@ const waitCommand = {
                 tid = setTimeout(() => fail(new Error('Download timed out')), rawTimeout);
                 offProgress = client.on('Browser.downloadProgress', async (params) => {
                     if (params.guid === guid && params.state === 'completed') {
-                        const { readdir, rename, rmdir } = await import('fs/promises');
+                        const { readdir, rename, rmdir } = await import('node:fs/promises');
                         const files = await readdir(downloadDir);
                         if (files.length > 0) {
                             const src = join(downloadDir, files[0]);
@@ -671,7 +782,7 @@ const waitCommand = {
                     if (settled || guid)
                         return; // a real CDP event has taken over
                     try {
-                        const { stat } = await import('fs/promises');
+                        const { stat } = await import('node:fs/promises');
                         const st = await stat(savePath);
                         if (st.isFile() && st.size > 0 && st.size === lastSize) {
                             stableReads++;
@@ -709,8 +820,18 @@ const screenshotCommand = {
         { name: 'full', type: 'boolean', description: 'Full page screenshot', default: false },
         { name: 'format', type: 'string', description: 'Format: png|jpeg|webp', default: 'png' },
         { name: 'quality', type: 'number', description: 'Quality 0-100 for jpeg/webp', default: 80 },
-        { name: 'annotate', type: 'boolean', description: 'Overlay numbered labels keyed to @eN refs from last snapshot (viewport-only; do not combine with --full)', default: false },
-        { name: 'hide-scrollbars', type: 'boolean', description: 'Hide native scrollbars via CSS injection before capture', default: false },
+        {
+            name: 'annotate',
+            type: 'boolean',
+            description: 'Overlay numbered labels keyed to @eN refs from last snapshot (viewport-only; do not combine with --full)',
+            default: false,
+        },
+        {
+            name: 'hide-scrollbars',
+            type: 'boolean',
+            description: 'Hide native scrollbars via CSS injection before capture',
+            default: false,
+        },
         { name: 'json', type: 'boolean', description: 'Output JSON with path', default: false },
     ],
     action: async (ctx) => {
@@ -718,10 +839,12 @@ const screenshotCommand = {
         const browser = await getBrowser();
         const hideScrollbars = ctx.flags['hide-scrollbars'];
         if (hideScrollbars) {
-            await client.send('Runtime.evaluate', {
+            await client
+                .send('Runtime.evaluate', {
                 expression: `(function(){var s=document.getElementById('__mm_noscroll__');if(s)return;var el=document.createElement('style');el.id='__mm_noscroll__';el.textContent='*::-webkit-scrollbar{display:none!important}*{scrollbar-width:none!important;-ms-overflow-style:none!important}';document.head.appendChild(el);})()`,
                 returnByValue: false,
-            }, sessionId).catch(() => { });
+            }, sessionId)
+                .catch(() => { });
         }
         const annotate = ctx.flags.annotate;
         // eslint-disable-next-line prefer-const
@@ -738,10 +861,12 @@ const screenshotCommand = {
         }
         finally {
             if (hideScrollbars) {
-                await client.send('Runtime.evaluate', {
+                await client
+                    .send('Runtime.evaluate', {
                     expression: `(function(){var s=document.getElementById('__mm_noscroll__');if(s)s.remove();})()`,
                     returnByValue: false,
-                }, sessionId).catch(() => { });
+                }, sessionId)
+                    .catch(() => { });
             }
         }
         if (ctx.flags.json) {
@@ -756,9 +881,7 @@ const screenshotCommand = {
 const getCommand = {
     name: 'get',
     description: 'Get page info. Usage: monomind browse get url|title|text|html|value|attr|count|box|styles [@ref] [attrName]',
-    options: [
-        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
-    ],
+    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON', default: false }],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
@@ -811,7 +934,8 @@ const getCommand = {
                     throw new Error('Element not in DOM');
                 const r = await client.send('Runtime.callFunctionOn', {
                     functionDeclaration: 'function() { return this.value ?? null; }',
-                    objectId, returnByValue: true,
+                    objectId,
+                    returnByValue: true,
                 }, sessionId);
                 value = r.result?.value ?? null;
                 break;
@@ -830,7 +954,8 @@ const getCommand = {
                     throw new Error('Element not in DOM');
                 const r = await client.send('Runtime.callFunctionOn', {
                     functionDeclaration: `function() { return this.getAttribute(${JSON.stringify(attrName)}); }`,
-                    objectId, returnByValue: true,
+                    objectId,
+                    returnByValue: true,
                 }, sessionId);
                 value = r.result?.value ?? null;
                 break;
@@ -867,7 +992,8 @@ const getCommand = {
                     throw new Error('Element not in DOM');
                 const r = await client.send('Runtime.callFunctionOn', {
                     functionDeclaration: 'function() { const s = window.getComputedStyle(this); return JSON.stringify(Object.fromEntries([...s].map(k => [k, s.getPropertyValue(k)]))); }',
-                    objectId, returnByValue: true,
+                    objectId,
+                    returnByValue: true,
                 }, sessionId);
                 try {
                     value = JSON.parse(r.result?.value ?? '{}');
@@ -895,7 +1021,12 @@ const scrollCommand = {
     options: [
         { name: 'amount', short: 'a', type: 'number', description: 'Pixels to scroll', default: 300 },
         { name: 'ref', type: 'string', description: 'Element ref to scroll within' },
-        { name: 'selector', short: 's', type: 'string', description: 'CSS selector of element to scroll within' },
+        {
+            name: 'selector',
+            short: 's',
+            type: 'string',
+            description: 'CSS selector of element to scroll within',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -905,12 +1036,14 @@ const scrollCommand = {
             throw new Error('Usage: monomind browse scroll up|down|left|right [amount]');
         // Support positional amount: scroll down 300
         const positionalAmount = ctx.args[1] !== undefined ? parseInt(ctx.args[1], 10) : undefined;
-        const amount = (positionalAmount && Number.isFinite(positionalAmount)) ? positionalAmount : ctx.flags.amount ?? 300;
+        const amount = positionalAmount && Number.isFinite(positionalAmount)
+            ? positionalAmount
+            : (ctx.flags.amount ?? 300);
         if (ctx.flags.selector) {
             const sel = ctx.flags.selector;
             const dx = direction === 'right' ? amount : direction === 'left' ? -amount : 0;
             const dy = direction === 'down' ? amount : direction === 'up' ? -amount : 0;
-            const posJson = await browser.evaluateJs(client, sessionId, `(function(){var el=document.querySelector(${JSON.stringify(sel)});if(!el)return null;var r=el.getBoundingClientRect();return JSON.stringify({x:r.left+r.width/2,y:r.top+r.height/2});})()`);
+            const posJson = (await browser.evaluateJs(client, sessionId, `(function(){var el=document.querySelector(${JSON.stringify(sel)});if(!el)return null;var r=el.getBoundingClientRect();return JSON.stringify({x:r.left+r.width/2,y:r.top+r.height/2});})()`));
             if (!posJson)
                 throw new Error(`Selector not found: ${sel}`);
             const pos = JSON.parse(posJson);
@@ -958,7 +1091,9 @@ const navigateCommand = {
                     expression: direction === 'back' ? 'history.back()' : 'history.forward()',
                 }, sessionId);
                 let fallbackHandle;
-                const fallbackPromise = new Promise((r) => { fallbackHandle = setTimeout(r, 2000); });
+                const fallbackPromise = new Promise((r) => {
+                    fallbackHandle = setTimeout(r, 2000);
+                });
                 await Promise.race([frameStartedPromise, fallbackPromise]);
                 if (fallbackHandle !== undefined)
                     clearTimeout(fallbackHandle);
@@ -996,10 +1131,13 @@ const setCommand = {
                 const width = parseInt(ctx.args[1], 10);
                 const height = parseInt(ctx.args[2], 10);
                 const dpr = parseFloat(ctx.args[3]) || undefined;
-                if (isNaN(width) || isNaN(height))
+                if (Number.isNaN(width) || Number.isNaN(height))
                     throw new Error('Usage: set viewport <width> <height> [dpr]');
                 await client.send('Emulation.setDeviceMetricsOverride', {
-                    width, height, deviceScaleFactor: dpr ?? 1, mobile: false,
+                    width,
+                    height,
+                    deviceScaleFactor: dpr ?? 1,
+                    mobile: false,
                 }, sessionId);
                 output.printSuccess(`Viewport set to ${width}x${height}${dpr ? ` @${dpr}x` : ''}`);
                 break;
@@ -1016,7 +1154,7 @@ const setCommand = {
                 const lat = parseFloat(ctx.args[1]);
                 const lon = parseFloat(ctx.args[2]);
                 const acc = parseFloat(ctx.args[3]) || 100;
-                if (isNaN(lat) || isNaN(lon))
+                if (Number.isNaN(lat) || Number.isNaN(lon))
                     throw new Error('Usage: set geo <latitude> <longitude> [accuracy]');
                 await browser.setGeolocation(client, sessionId, lat, lon, acc);
                 output.printSuccess(`Geolocation set: ${lat}, ${lon}`);
@@ -1066,7 +1204,11 @@ const stateCommand = {
     name: 'state',
     description: 'Manage browser session state. Usage: monomind browse state save|load|list|rename|clean [name]',
     options: [
-        { name: 'older-than', type: 'number', description: 'For state clean: remove sessions older than N days' },
+        {
+            name: 'older-than',
+            type: 'number',
+            description: 'For state clean: remove sessions older than N days',
+        },
     ],
     action: async (ctx) => {
         const browser = await getBrowser();
@@ -1123,7 +1265,13 @@ const stateCommand = {
                 const title = await browser.getCurrentTitle(c, sid);
                 const cookies = await browser.getCookies(c, sid);
                 const ls = await browser.getAllLocalStorage(c, sid);
-                const info = { url, title, cookies: cookies.length, localStorage: Object.keys(ls).length, refs: _refs.size };
+                const info = {
+                    url,
+                    title,
+                    cookies: cookies.length,
+                    localStorage: Object.keys(ls).length,
+                    refs: _refs.size,
+                };
                 print(JSON.stringify(info, null, 2));
                 return { success: true, data: info };
             }
@@ -1146,14 +1294,14 @@ const stateCommand = {
                 if (!sessions.includes(oldName))
                     throw new Error(`Session not found: ${oldName}`);
                 // W1: validate newName to prevent path traversal
-                const { basename: basenameFn } = await import('path');
+                const { basename: basenameFn } = await import('node:path');
                 const safeName = basenameFn(newName);
                 if (safeName !== newName || safeName.startsWith('.') || safeName.includes('/')) {
                     throw new Error('Invalid session name — must not contain path separators or start with "."');
                 }
-                const { unlink: unlinkRename, readFile, writeFile, mkdir: mkdirRename } = await import('fs/promises');
-                const { join: joinR } = await import('path');
-                const { homedir } = await import('os');
+                const { unlink: unlinkRename, readFile, writeFile, mkdir: mkdirRename, } = await import('node:fs/promises');
+                const { join: joinR } = await import('node:path');
+                const { homedir } = await import('node:os');
                 const sessionDir = joinR(homedir(), '.monomind', 'browser-sessions');
                 const oldPath = joinR(sessionDir, `${oldName}.json`);
                 const newPath = joinR(sessionDir, `${newName}.json`);
@@ -1167,9 +1315,9 @@ const stateCommand = {
             }
             case 'clean': {
                 const days = ctx.flags['older-than'] ?? 7;
-                const { unlink, stat } = await import('fs/promises');
-                const { join: joinC } = await import('path');
-                const { homedir: homedirC } = await import('os');
+                const { unlink, stat } = await import('node:fs/promises');
+                const { join: joinC } = await import('node:path');
+                const { homedir: homedirC } = await import('node:os');
                 const sessionDir = joinC(homedirC(), '.monomind', 'browser-sessions');
                 const sessions = await browser.listSessions();
                 const cutoff = Date.now() - days * 86400 * 1000;
@@ -1200,10 +1348,26 @@ const networkCommand = {
         { name: 'status', type: 'number', description: 'HTTP status for fulfill', default: 200 },
         { name: 'headers', type: 'string', description: 'JSON headers object' },
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
-        { name: 'filter', type: 'string', description: 'Filter requests by URL substring (for network requests)' },
-        { name: 'method', type: 'string', description: 'Filter by HTTP method, e.g. GET, POST (for network requests)' },
-        { name: 'status-code', type: 'number', description: 'Filter by HTTP status code (for network requests)' },
-        { name: 'type', type: 'string', description: 'Filter by resource type: xhr|fetch|document|script|stylesheet|image (for network requests)' },
+        {
+            name: 'filter',
+            type: 'string',
+            description: 'Filter requests by URL substring (for network requests)',
+        },
+        {
+            name: 'method',
+            type: 'string',
+            description: 'Filter by HTTP method, e.g. GET, POST (for network requests)',
+        },
+        {
+            name: 'status-code',
+            type: 'number',
+            description: 'Filter by HTTP status code (for network requests)',
+        },
+        {
+            name: 'type',
+            type: 'string',
+            description: 'Filter by resource type: xhr|fetch|document|script|stylesheet|image (for network requests)',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -1216,15 +1380,19 @@ const networkCommand = {
                 const pattern = ctx.flags.pattern;
                 if (!pattern)
                     throw new Error('--pattern required for network route');
-                const routes = [{
+                const routes = [
+                    {
                         pattern,
                         action: ctx.flags.abort ? 'abort' : ctx.flags.fulfill ? 'fulfill' : 'continue',
-                        response: ctx.flags.fulfill ? {
-                            status: ctx.flags.status,
-                            body: ctx.flags.fulfill,
-                            headers: ctx.flags.headers ? JSON.parse(ctx.flags.headers) : {},
-                        } : undefined,
-                    }];
+                        response: ctx.flags.fulfill
+                            ? {
+                                status: ctx.flags.status,
+                                body: ctx.flags.fulfill,
+                                headers: ctx.flags.headers ? JSON.parse(ctx.flags.headers) : {},
+                            }
+                            : undefined,
+                    },
+                ];
                 await browser.setupRoutes(client, sessionId, routes);
                 output.printSuccess(`Network route set: ${pattern}`);
                 break;
@@ -1275,7 +1443,8 @@ const networkCommand = {
                 if (filterStatus)
                     reqs = reqs.filter((r) => r.status === filterStatus);
                 if (filterType)
-                    reqs = reqs.filter((r) => r.resourceType === filterType || r.type === filterType);
+                    reqs = reqs.filter((r) => r.resourceType === filterType ||
+                        r.type === filterType);
                 if (ctx.flags.json)
                     print(JSON.stringify({ data: reqs }));
                 else {
@@ -1293,7 +1462,8 @@ const networkCommand = {
                 if (!reqId)
                     throw new Error('Usage: monomind browse network request <requestId>');
                 const reqs = browser.getCapturedRequests(sessionId);
-                const req = reqs.find((r) => r.requestId === reqId || r.id === reqId);
+                const req = reqs.find((r) => r.requestId === reqId ||
+                    r.id === reqId);
                 if (!req) {
                     output.printWarning(`Request not found: ${reqId}`);
                     return { success: false };
@@ -1319,16 +1489,29 @@ const DEFAULT_EVAL_MAX_OUTPUT = 50_000;
 function truncateForOutput(text, maxOutput) {
     if (!(maxOutput > 0) || text.length <= maxOutput)
         return text;
-    return text.slice(0, maxOutput) + `\n[... truncated at ${maxOutput} chars]`;
+    return `${text.slice(0, maxOutput)}\n[... truncated at ${maxOutput} chars]`;
 }
 const evalCommand = {
     name: 'eval',
     description: 'Evaluate JavaScript in page context. Usage: monomind browse eval "document.title"',
     options: [
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
-        { name: 'stdin', type: 'boolean', description: 'Read JS expression from stdin (heredoc-friendly for multiline scripts)', default: false },
-        { name: 'max-output', type: 'number', description: `Truncate printed output to N characters (default ${DEFAULT_EVAL_MAX_OUTPUT}; 0 disables truncation)` },
-        { name: 'timeout', type: 'number', description: 'Max ms to wait for evaluation to settle (default 30000)' },
+        {
+            name: 'stdin',
+            type: 'boolean',
+            description: 'Read JS expression from stdin (heredoc-friendly for multiline scripts)',
+            default: false,
+        },
+        {
+            name: 'max-output',
+            type: 'number',
+            description: `Truncate printed output to N characters (default ${DEFAULT_EVAL_MAX_OUTPUT}; 0 disables truncation)`,
+        },
+        {
+            name: 'timeout',
+            type: 'number',
+            description: 'Max ms to wait for evaluation to settle (default 30000)',
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -1354,6 +1537,254 @@ const evalCommand = {
         return { success: true, data: { result } };
     },
 };
+const reportCommand = {
+    name: 'report',
+    description: 'Test a page and write one self-contained HTML report + sibling JSON. Usage: monomind browse report <url>',
+    options: [
+        { name: 'out', short: 'o', type: 'string', description: 'Output .html path, or a directory' },
+        {
+            name: 'budget',
+            short: 'b',
+            type: 'string',
+            description: 'Budget JSON file path, or inline JSON',
+        },
+        {
+            name: 'devices',
+            short: 'd',
+            type: 'string',
+            description: 'Comma-separated device names for the screenshot matrix',
+        },
+        {
+            name: 'wait',
+            short: 'w',
+            type: 'string',
+            description: 'Extra settle step: a CSS selector to wait for, or milliseconds',
+        },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+        {
+            name: 'full-page',
+            type: 'boolean',
+            description: 'Full-page screenshot (--no-full-page for viewport only)',
+            default: true,
+        },
+        {
+            name: 'vitals-wait',
+            type: 'number',
+            description: 'Milliseconds to let the web-vitals observers run',
+            default: 2500,
+        },
+        {
+            name: 'timeout',
+            type: 'number',
+            description: 'Milliseconds to wait for the page to go network-idle',
+            default: 20000,
+        },
+        {
+            name: 'keep-open',
+            type: 'boolean',
+            description: 'Leave the browser running after the report',
+            default: false,
+        },
+        {
+            name: 'repeat',
+            type: 'number',
+            description: 'Run the URL N times and report per-check flake rates (RIG-14)',
+        },
+        {
+            name: 'record',
+            type: 'boolean',
+            description: 'Record frames for the evidence timeline even when the run passes',
+            default: false,
+        },
+        {
+            name: 'history',
+            type: 'boolean',
+            description: 'Print the stored run history for this URL instead of running it',
+            default: false,
+        },
+        {
+            name: 'save',
+            type: 'boolean',
+            description: 'Save this run to the history store (--no-save to skip)',
+            default: true,
+        },
+        {
+            name: 'history-max',
+            type: 'number',
+            description: 'Runs kept per URL before the oldest are pruned (default 20)',
+        },
+        {
+            name: 'trend-window',
+            type: 'number',
+            description: 'Prior runs charted in the trend section (default 10)',
+        },
+    ],
+    examples: [
+        { command: 'monomind browse report https://example.com', description: 'Report with defaults' },
+        {
+            command: 'monomind browse report https://example.com --repeat 5',
+            description: 'Run five times and report flake rates',
+        },
+        {
+            command: 'monomind browse report https://example.com --history',
+            description: 'Show the stored run history for a URL',
+        },
+        {
+            command: 'monomind browse report https://example.com --record',
+            description: 'Attach a frame-by-frame evidence timeline',
+        },
+        {
+            command: 'monomind browse report https://example.com --out ./reports/home.html',
+            description: 'Choose the output path',
+        },
+        {
+            command: 'monomind browse report https://example.com --budget \'{"lcp":4000}\'',
+            description: 'Relax a budget inline',
+        },
+        {
+            command: 'monomind browse report https://example.com --devices "iPhone 14,iPad"',
+            description: 'Add a device screenshot matrix',
+        },
+    ],
+    action: async (ctx) => {
+        const url = ctx.args[0];
+        if (!url)
+            throw new Error('URL required. Usage: monomind browse report <url>');
+        // Imported lazily for the same reason getBrowser() is: this module loads
+        // on every CLI invocation, and nothing but `report` needs the renderer.
+        const { runReport, runReportRepeated, readHistory } = await import('../report/index.js');
+        // --history is a read of the store, so it deliberately never launches a
+        // browser — `report --history` must work offline and on a dead site.
+        if (ctx.flags.history) {
+            const { dir, runs } = await readHistory(url);
+            if (ctx.flags.json) {
+                print(JSON.stringify({ data: { dir, runs } }, null, 2));
+            }
+            else if (!runs.length) {
+                output.printWarning(`No stored runs for ${url}`);
+                print(`Looked in: ${dir}`);
+            }
+            else {
+                print(`${runs.length} run(s) for ${url}`);
+                print(`Stored in: ${dir}`);
+                for (const run of runs) {
+                    const lcp = run.vitals.lcp === undefined ? '—' : `${Math.round(run.vitals.lcp)}ms`;
+                    print(`  ${run.capturedAt}  ${run.verdict.toUpperCase().padEnd(4)}  ` +
+                        `LCP ${lcp.padStart(7)}  ${run.counts.consoleErrors} console errors  ` +
+                        `${run.counts.failedRequests} failed requests  ${run.counts.a11yErrors} a11y errors`);
+                }
+            }
+            return { success: true, data: { dir, runs } };
+        }
+        const repeatRaw = ctx.flags.repeat;
+        const repeat = typeof repeatRaw === 'number' && Number.isFinite(repeatRaw) && repeatRaw > 1
+            ? Math.floor(repeatRaw)
+            : undefined;
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const rawDevices = ctx.flags.devices;
+        const devices = typeof rawDevices === 'string'
+            ? rawDevices
+                .split(',')
+                .map((d) => d.trim())
+                .filter(Boolean)
+            : undefined;
+        const runOptions = {
+            url,
+            out: ctx.flags.out,
+            budget: ctx.flags.budget,
+            devices,
+            wait: ctx.flags.wait,
+            vitalsWaitMs: ctx.flags['vitals-wait'],
+            loadTimeoutMs: ctx.flags.timeout,
+            fullPage: ctx.flags['full-page'] !== false,
+            cwd: ctx.cwd,
+            // A failing run records its own evidence without being asked; --record
+            // is for when you want the timeline from a run that passes.
+            record: ctx.flags.record === true,
+            history: ctx.flags.save !== false,
+            historyMax: ctx.flags['history-max'],
+            trendWindow: ctx.flags['trend-window'],
+        };
+        let result;
+        try {
+            result = repeat
+                ? await runReportRepeated(client, sessionId, { ...runOptions, repeat })
+                : await runReport(client, sessionId, runOptions);
+        }
+        finally {
+            // A report is a one-shot command — CI should not be left with an
+            // orphan Chrome. Only close a browser THIS process launched: an
+            // attached one belongs to the user's own `open`/`connect` session.
+            if (!ctx.flags['keep-open'] && browser.getLaunchedPid(_port) !== undefined) {
+                browser.stopRequestCapture(sessionId);
+                browser.teardownConsoleCapture(sessionId);
+                try {
+                    await browser.closeBrowser(client, _port);
+                }
+                catch {
+                    /* best-effort */
+                }
+                _client = null;
+                _sessionId = '';
+                _targetId = '';
+                _refs = new Map();
+                await browser.clearActivePort();
+                await browser.clearRefCache();
+            }
+        }
+        const { report, htmlPath, jsonPath, summary, historyDir } = result;
+        const { flake } = result;
+        // With --repeat the flake verdict governs: a check that failed 2 of 5
+        // runs must not exit 0 just because the last run happened to be green.
+        const passed = flake ? flake.verdict === 'pass' : report.verdict === 'pass';
+        if (ctx.flags.json) {
+            const { toJsonReport } = await import('../report/index.js');
+            print(JSON.stringify({ data: { ...toJsonReport(report), flake, htmlPath, jsonPath, historyDir } }, null, 2));
+        }
+        else {
+            if (passed)
+                output.printSuccess(summary);
+            else
+                output.printError(summary);
+            if (flake) {
+                print(`    ${flake.confidenceNote}`);
+                for (const check of flake.checks.filter((c) => !c.stable)) {
+                    print(`    ${check.label}: failed ${check.failed} of ${check.runs} runs`);
+                }
+                for (const signal of flake.signals.slice(0, 5)) {
+                    print(`    ${signal.kind} "${signal.signature}" in ${signal.runs} of ${signal.total} runs`);
+                }
+            }
+            for (const failure of report.failures) {
+                print(`    ${failure.budget}: expected ${failure.expected}, got ${failure.actual}`);
+                if (failure.detail)
+                    print(`      ${failure.detail}`);
+            }
+            for (const headline of report.trend?.headlines ?? [])
+                output.printWarning(headline);
+            if (report.diff?.structure) {
+                const d = report.diff.structure;
+                print(`    vs previous run: ${d.gained.length} gained, ${d.lost.length} lost, ${d.renamed.length} renamed`);
+            }
+            if (report.diff?.pixels?.comparable) {
+                print(`    vs previous run: ${report.diff.pixels.changedPercent.toFixed(2)}% of pixels changed`);
+            }
+            for (const note of report.notes)
+                output.printWarning(note);
+            print(`Report: ${htmlPath}`);
+            print(`JSON:   ${jsonPath}`);
+            if (historyDir)
+                print(`History: ${historyDir}`);
+        }
+        // Non-zero exit is the point of RIG-06 — CI and agents gate on it.
+        return {
+            success: passed,
+            exitCode: passed ? 0 : 1,
+            data: { htmlPath, jsonPath, report, flake },
+        };
+    },
+};
 const closeCommand = {
     name: 'close',
     description: 'Close the active browser session',
@@ -1367,19 +1798,25 @@ const closeCommand = {
                 try {
                     await browser.stopHarRecording(client, sid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.getTraceStatus(sid)) {
                 try {
                     await browser.stopTrace(client, sid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.isProfilingActive(sid)) {
                 try {
                     await browser.stopCpuProfile(client, sid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             browser.teardownRouteInterception(sid);
             browser.stopRequestCapture(sid);
@@ -1418,7 +1855,9 @@ const closeCommand = {
                         try {
                             conn.client.close();
                         }
-                        catch { /* already gone */ }
+                        catch {
+                            /* already gone */
+                        }
                     }
                     // closeBrowser has no PID fallback in a fresh process (launchedPids
                     // is per-process) — re-probe so we report what actually happened.
@@ -1428,8 +1867,10 @@ const closeCommand = {
                     const probeDeadline = Date.now() + 3000;
                     while (stillUp && Date.now() < probeDeadline) {
                         try {
-                            await fetch(`http://127.0.0.1:${persisted.port}/json/version`, { signal: AbortSignal.timeout(800) });
-                            await new Promise(r => setTimeout(r, 300));
+                            await fetch(`http://127.0.0.1:${persisted.port}/json/version`, {
+                                signal: AbortSignal.timeout(800),
+                            });
+                            await new Promise((r) => setTimeout(r, 300));
                         }
                         catch {
                             stillUp = false;
@@ -1733,7 +2174,7 @@ const tapCommand = {
             y = Math.round(box.y);
         }
         else {
-            const posJson = await browser.evaluateJs(client, sessionId, `(function(){var el=document.querySelector(${JSON.stringify(arg)});if(!el)return null;var r=el.getBoundingClientRect();return JSON.stringify({x:r.left+r.width/2,y:r.top+r.height/2});})()`);
+            const posJson = (await browser.evaluateJs(client, sessionId, `(function(){var el=document.querySelector(${JSON.stringify(arg)});if(!el)return null;var r=el.getBoundingClientRect();return JSON.stringify({x:r.left+r.width/2,y:r.top+r.height/2});})()`));
             if (!posJson)
                 throw new Error(`Selector not found: ${arg}`);
             const pos = JSON.parse(posJson);
@@ -1750,9 +2191,25 @@ const swipeCommand = {
     name: 'swipe',
     description: 'Swipe gesture (mobile). Usage: monomind browse swipe up|down|left|right [distance] [--x N] [--y N]',
     options: [
-        { name: 'x', type: 'number', description: 'Start X coordinate (default: center)', default: 200 },
-        { name: 'y', type: 'number', description: 'Start Y coordinate (default: center)', default: 400 },
-        { name: 'distance', short: 'd', type: 'number', description: 'Swipe distance in pixels', default: 300 },
+        {
+            name: 'x',
+            type: 'number',
+            description: 'Start X coordinate (default: center)',
+            default: 200,
+        },
+        {
+            name: 'y',
+            type: 'number',
+            description: 'Start Y coordinate (default: center)',
+            default: 400,
+        },
+        {
+            name: 'distance',
+            short: 'd',
+            type: 'number',
+            description: 'Swipe distance in pixels',
+            default: 300,
+        },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -1763,14 +2220,16 @@ const swipeCommand = {
         const startX = ctx.flags.x ?? 200;
         const startY = ctx.flags.y ?? 400;
         const positionalDistance = ctx.args[1] !== undefined ? parseInt(ctx.args[1], 10) : undefined;
-        const distance = (positionalDistance && Number.isFinite(positionalDistance)) ? positionalDistance : ctx.flags.distance ?? 300;
+        const distance = positionalDistance && Number.isFinite(positionalDistance)
+            ? positionalDistance
+            : (ctx.flags.distance ?? 300);
         const dx = direction === 'right' ? distance : direction === 'left' ? -distance : 0;
         const dy = direction === 'down' ? distance : direction === 'up' ? -distance : 0;
         await client.send('Input.dispatchTouchEvent', { type: 'touchStart', touchPoints: [{ x: startX, y: startY }] }, sessionId);
         const steps = 10;
         for (let i = 1; i <= steps; i++) {
-            const x = Math.round(startX + dx * i / steps);
-            const y = Math.round(startY + dy * i / steps);
+            const x = Math.round(startX + (dx * i) / steps);
+            const y = Math.round(startY + (dy * i) / steps);
             await client.send('Input.dispatchTouchEvent', { type: 'touchMove', touchPoints: [{ x, y }] }, sessionId);
             await new Promise((r) => setTimeout(r, 16));
         }
@@ -1835,33 +2294,43 @@ const downloadCommand = {
     name: 'download',
     description: 'Click an element and capture the triggered file download. Usage: monomind browse download @e1 ./output.pdf',
     options: [
-        { name: 'timeout', short: 't', type: 'number', description: 'Max wait for download in ms', default: 30000 },
+        {
+            name: 'timeout',
+            short: 't',
+            type: 'number',
+            description: 'Max wait for download in ms',
+            default: 30000,
+        },
         { name: 'json', type: 'boolean', description: 'Output result as JSON', default: false },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
-        const browser = await getBrowser();
+        const _browser = await getBrowser();
         const refOrSel = ctx.args[0];
         const savePath = ctx.args[1];
         if (!refOrSel || !savePath)
             throw new Error('Usage: monomind browse download @e1|selector <save-path>');
-        const { mkdir } = await import('fs/promises');
-        const { dirname } = await import('path');
-        const { tmpdir } = await import('os');
-        const { join } = await import('path');
+        const { mkdir } = await import('node:fs/promises');
+        const { dirname } = await import('node:path');
+        const { tmpdir } = await import('node:os');
+        const { join } = await import('node:path');
         const downloadDir = join(tmpdir(), `mm-download-${Date.now()}`);
         await mkdir(downloadDir, { recursive: true });
         // Enable Page.downloadWillBegin / Page.downloadProgress events
-        await client.send('Browser.setDownloadBehavior', {
+        await client
+            .send('Browser.setDownloadBehavior', {
             behavior: 'allow',
             downloadPath: downloadDir,
             eventsEnabled: true,
-        }, undefined).catch(() => {
+        }, undefined)
+            .catch(() => {
             // Fallback: older Chrome API (session-scoped)
-            return client.send('Page.setDownloadBehavior', {
+            return client
+                .send('Page.setDownloadBehavior', {
                 behavior: 'allow',
                 downloadPath: downloadDir,
-            }, sessionId).catch(() => { });
+            }, sessionId)
+                .catch(() => { });
         });
         // Track when download completes
         const downloadPromise = new Promise((resolve, reject) => {
@@ -1873,13 +2342,20 @@ const downloadCommand = {
             let offProgress;
             // cleanup defined before setTimeout so the timeout callback can call it
             let timeout;
-            const cleanup = () => { clearTimeout(timeout); offBegin?.(); offProgress?.(); };
-            timeout = setTimeout(() => { cleanup(); reject(new Error('Download timed out')); }, ctx.flags.timeout);
+            const cleanup = () => {
+                clearTimeout(timeout);
+                offBegin?.();
+                offProgress?.();
+            };
+            timeout = setTimeout(() => {
+                cleanup();
+                reject(new Error('Download timed out'));
+            }, ctx.flags.timeout);
             offProgress = client.on('Browser.downloadProgress', async (params) => {
                 if (params.guid === guid && params.state === 'completed') {
                     cleanup();
                     // Find the downloaded file in downloadDir
-                    const { readdir, rename, rmdir } = await import('fs/promises');
+                    const { readdir, rename, rmdir } = await import('node:fs/promises');
                     const files = await readdir(downloadDir);
                     if (files.length > 0) {
                         const src = join(downloadDir, files[0]);
@@ -2071,9 +2547,7 @@ const frameCommand = {
 const tabCommand = {
     name: 'tab',
     description: 'Tab management. Usage: monomind browse tab list|new|close [url]',
-    options: [
-        { name: 'label', type: 'string', description: 'Label for new tab' },
-    ],
+    options: [{ name: 'label', type: 'string', description: 'Label for new tab' }],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
@@ -2102,19 +2576,25 @@ const tabCommand = {
                         try {
                             await browser.stopHarRecording(client, sid);
                         }
-                        catch { /* ignore */ }
+                        catch {
+                            /* ignore */
+                        }
                     }
                     if (browser.getTraceStatus(sid)) {
                         try {
                             await browser.stopTrace(client, sid);
                         }
-                        catch { /* ignore */ }
+                        catch {
+                            /* ignore */
+                        }
                     }
                     if (browser.isProfilingActive(sid)) {
                         try {
                             await browser.stopCpuProfile(client, sid);
                         }
-                        catch { /* ignore */ }
+                        catch {
+                            /* ignore */
+                        }
                     }
                     browser.teardownRouteInterception(sid);
                     browser.stopRequestCapture(sid);
@@ -2142,19 +2622,25 @@ const tabCommand = {
                     try {
                         await browser.stopHarRecording(client, oldSid);
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                 }
                 if (browser.getTraceStatus(oldSid)) {
                     try {
                         await browser.stopTrace(client, oldSid);
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                 }
                 if (browser.isProfilingActive(oldSid)) {
                     try {
                         await browser.stopCpuProfile(client, oldSid);
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                 }
                 await browser.disableInterception(client, oldSid).catch(() => { });
                 browser.stopRequestCapture(oldSid);
@@ -2192,19 +2678,25 @@ const windowCommand = {
                 try {
                     await browser.stopHarRecording(client, oldSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.getTraceStatus(oldSid)) {
                 try {
                     await browser.stopTrace(client, oldSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.isProfilingActive(oldSid)) {
                 try {
                     await browser.stopCpuProfile(client, oldSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             browser.teardownRouteInterception(oldSid);
             browser.stopRequestCapture(oldSid);
@@ -2366,11 +2858,13 @@ const cookiesCommand = {
                 if (!name || value === undefined) {
                     throw new Error('Usage: monomind browse cookies set <name> <value> [--domain <d>]');
                 }
-                await browser.setCookies(client, sessionId, [{
+                await browser.setCookies(client, sessionId, [
+                    {
                         name,
                         value,
                         domain: ctx.flags.domain,
-                    }]);
+                    },
+                ]);
                 output.printSuccess(`Cookie set: ${name}`);
                 break;
             }
@@ -2406,9 +2900,7 @@ const pdfCommand = {
 const isCommand = {
     name: 'is',
     description: 'Check element state. Usage: monomind browse is visible|enabled|checked @e1',
-    options: [
-        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
-    ],
+    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON', default: false }],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
@@ -2429,7 +2921,8 @@ const isCommand = {
             case 'checked':
                 result = await browser.isChecked(client, sessionId, ref);
                 break;
-            default: throw new Error(`Unknown check: ${check}. Use: visible|enabled|checked`);
+            default:
+                throw new Error(`Unknown check: ${check}. Use: visible|enabled|checked`);
         }
         if (ctx.flags.json) {
             print(JSON.stringify({ data: { [check]: result } }));
@@ -2467,7 +2960,7 @@ const findCommand = {
         if (locator === 'alttext') {
             // I2: use JS attribute comparison to avoid broken CSS selectors for values with spaces/quotes
             const valJson = JSON.stringify(value);
-            const found = await browser.evaluateJs(client, sessionId, `(function(v){var el=document.querySelector('img[alt]')||null;var all=document.querySelectorAll('[alt]');for(var i=0;i<all.length;i++){if(all[i].getAttribute('alt')===v){all[i].setAttribute('data-mm-located','true');return true;}}return false;})(${valJson})`);
+            const found = (await browser.evaluateJs(client, sessionId, `(function(v){var el=document.querySelector('img[alt]')||null;var all=document.querySelectorAll('[alt]');for(var i=0;i<all.length;i++){if(all[i].getAttribute('alt')===v){all[i].setAttribute('data-mm-located','true');return true;}}return false;})(${valJson})`));
             if (!found) {
                 output.printWarning(`alttext not found: ${value}`);
                 return { success: false };
@@ -2479,7 +2972,7 @@ const findCommand = {
         if (locator === 'title') {
             // I2: use JS attribute comparison to avoid broken CSS selectors for values with spaces/quotes
             const valJson = JSON.stringify(value);
-            const found = await browser.evaluateJs(client, sessionId, `(function(v){var all=document.querySelectorAll('[title]');for(var i=0;i<all.length;i++){if(all[i].getAttribute('title')===v){all[i].setAttribute('data-mm-located','true');return true;}}return false;})(${valJson})`);
+            const found = (await browser.evaluateJs(client, sessionId, `(function(v){var all=document.querySelectorAll('[title]');for(var i=0;i<all.length;i++){if(all[i].getAttribute('title')===v){all[i].setAttribute('data-mm-located','true');return true;}}return false;})(${valJson})`));
             if (!found) {
                 output.printWarning(`title not found: ${value}`);
                 return { success: false };
@@ -2585,7 +3078,13 @@ const diffCommand = {
     name: 'diff',
     description: 'Compare two URLs or snapshots. Usage: monomind browse diff url <url1> <url2> [--interactive] [--json]',
     options: [
-        { name: 'interactive', short: 'i', type: 'boolean', description: 'Snapshot interactive elements only', default: false },
+        {
+            name: 'interactive',
+            short: 'i',
+            type: 'boolean',
+            description: 'Snapshot interactive elements only',
+            default: false,
+        },
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
     ],
     action: async (ctx) => {
@@ -2600,11 +3099,15 @@ const diffCommand = {
             // Capture snapshot at url1
             await browser.openUrl(client, sessionId, url1);
             await browser.waitFor(client, sessionId, { load: 'load', timeout: 15000 });
-            const snap1 = await browser.captureSnapshot(client, sessionId, { interactiveOnly: ctx.flags.interactive });
+            const snap1 = await browser.captureSnapshot(client, sessionId, {
+                interactiveOnly: ctx.flags.interactive,
+            });
             // Capture snapshot at url2
             await browser.openUrl(client, sessionId, url2);
             await browser.waitFor(client, sessionId, { load: 'load', timeout: 15000 });
-            const snap2 = await browser.captureSnapshot(client, sessionId, { interactiveOnly: ctx.flags.interactive });
+            const snap2 = await browser.captureSnapshot(client, sessionId, {
+                interactiveOnly: ctx.flags.interactive,
+            });
             _refs = snap2.refs;
             await browser.saveRefCache(_targetId, snap2.url, _refs);
             // Text diff
@@ -2616,7 +3119,15 @@ const diffCommand = {
             const onlyIn2 = lines2.filter((l) => !set1.has(l));
             const changed = onlyIn1.length > 0 || onlyIn2.length > 0;
             if (ctx.flags.json) {
-                print(JSON.stringify({ changed, url1, url2, onlyIn1, onlyIn2, additions: onlyIn2.length, removals: onlyIn1.length }));
+                print(JSON.stringify({
+                    changed,
+                    url1,
+                    url2,
+                    onlyIn1,
+                    onlyIn2,
+                    additions: onlyIn2.length,
+                    removals: onlyIn1.length,
+                }));
             }
             else {
                 if (!changed) {
@@ -2630,7 +3141,10 @@ const diffCommand = {
                         print(`\x1b[32m+ ${l}\x1b[0m`);
                 }
             }
-            return { success: true, data: { changed, url1, url2, additions: onlyIn2.length, removals: onlyIn1.length } };
+            return {
+                success: true,
+                data: { changed, url1, url2, additions: onlyIn2.length, removals: onlyIn1.length },
+            };
         }
         throw new Error('Usage: monomind browse diff url <url1> <url2>');
     },
@@ -2744,7 +3258,6 @@ export function parseBatchCommandLine(cmdStr) {
             flags[boolFlag[1]] = true;
             rest = rest.slice(boolFlag[0].length);
             consumedAnother = true;
-            continue;
         }
     }
     return { subName: 'eval', subArgs: [rest], flags };
@@ -2803,7 +3316,9 @@ const batchCommand = {
                             parsedFlags[key] = true;
                         }
                     }
-                    else if (subArgs[i].startsWith('-') && subArgs[i].length === 2 && /[a-zA-Z]/.test(subArgs[i][1])) {
+                    else if (subArgs[i].startsWith('-') &&
+                        subArgs[i].length === 2 &&
+                        /[a-zA-Z]/.test(subArgs[i][1])) {
                         consumedIndices.add(i);
                         const shortKey = subArgs[i][1];
                         const optDef = subCmd.options?.find((o) => o.short === shortKey);
@@ -2835,7 +3350,11 @@ const batchCommand = {
                 };
                 const cmdResult = await subCmd.action(fakeCtx);
                 const succeeded = cmdResult?.success !== false;
-                results.push({ command: cmdStr, success: succeeded, error: succeeded ? undefined : 'Command returned failure' });
+                results.push({
+                    command: cmdStr,
+                    success: succeeded,
+                    error: succeeded ? undefined : 'Command returned failure',
+                });
                 if (!succeeded && ctx.flags.bail)
                     break;
             }
@@ -2886,7 +3405,12 @@ const connectCommand = {
     options: [
         { name: 'port', short: 'p', type: 'number', description: 'CDP port', default: 9222 },
         { name: 'target', type: 'string', description: 'Target ID to attach to' },
-        { name: 'auto-connect', type: 'boolean', description: 'Auto-discover running Chrome on ports 9222 and 9229', default: false },
+        {
+            name: 'auto-connect',
+            type: 'boolean',
+            description: 'Auto-discover running Chrome on ports 9222 and 9229',
+            default: false,
+        },
     ],
     action: async (ctx) => {
         let port = ctx.flags.port ?? 9222;
@@ -2902,7 +3426,9 @@ const connectCommand = {
                         break;
                     }
                 }
-                catch { /* port not open */ }
+                catch {
+                    /* port not open */
+                }
             }
             if (!found)
                 throw new Error('No running Chrome instance found. Launch Chrome with --remote-debugging-port or use --port.');
@@ -2915,19 +3441,25 @@ const connectCommand = {
                 try {
                     await browser.stopHarRecording(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.getTraceStatus(prevSid)) {
                 try {
                     await browser.stopTrace(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             if (browser.isProfilingActive(prevSid)) {
                 try {
                     await browser.stopCpuProfile(prevClient, prevSid);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
             browser.teardownRouteInterception(prevSid);
             browser.stopRequestCapture(prevSid);
@@ -3030,7 +3562,9 @@ const traceCommand = {
             throw new Error('Usage: monomind browse trace start|stop [path]');
         switch (action) {
             case 'start':
-                await browser.startTrace(client, sessionId, { screenshots: ctx.flags.screenshots });
+                await browser.startTrace(client, sessionId, {
+                    screenshots: ctx.flags.screenshots,
+                });
                 output.printSuccess('Trace started');
                 return { success: true };
             case 'stop': {
@@ -3064,7 +3598,9 @@ const profilerCommand = {
             throw new Error('Usage: monomind browse profiler start|stop|heap [path]');
         switch (action) {
             case 'start':
-                await browser.startCpuProfile(client, sessionId, { samplingInterval: ctx.flags.interval });
+                await browser.startCpuProfile(client, sessionId, {
+                    samplingInterval: ctx.flags.interval,
+                });
                 output.printSuccess('CPU profiler started');
                 return { success: true };
             case 'stop': {
@@ -3155,7 +3691,7 @@ const resizeCommand = {
         const browser = await getBrowser();
         const width = parseInt(ctx.args[0], 10);
         const height = parseInt(ctx.args[1], 10);
-        if (isNaN(width) || isNaN(height))
+        if (Number.isNaN(width) || Number.isNaN(height))
             throw new Error('Usage: monomind browse resize <width> <height>');
         await browser.setViewport(client, sessionId, width, height);
         output.printSuccess(`Resized to ${width}x${height}`);
@@ -3291,6 +3827,7 @@ const browseCommand = {
         traceCommand,
         profilerCommand,
         vitalsCommand,
+        reportCommand,
         harCommand,
         resizeCommand,
         closeCommand,
@@ -3303,7 +3840,10 @@ const browseCommand = {
     ],
     examples: [
         { command: 'monomind browse open https://example.com', description: 'Open a URL' },
-        { command: 'monomind browse snapshot -i', description: 'Interactive-only snapshot (93% token reduction)' },
+        {
+            command: 'monomind browse snapshot -i',
+            description: 'Interactive-only snapshot (93% token reduction)',
+        },
         { command: 'monomind browse click @e3', description: 'Click element by ref' },
         { command: 'monomind browse fill @e1 "user@example.com"', description: 'Fill an input' },
         { command: 'monomind browse press Enter', description: 'Press Enter key' },
@@ -3317,7 +3857,14 @@ const browseCommand = {
         { command: 'monomind browse state save my-session', description: 'Save session state' },
         { command: 'monomind browse navigate back', description: 'Navigate back' },
         { command: 'monomind browse eval "document.title"', description: 'Evaluate JavaScript' },
-        { command: 'monomind browse network route --pattern "https://api.*" --abort', description: 'Abort API calls' },
+        {
+            command: 'monomind browse network route --pattern "https://api.*" --abort',
+            description: 'Abort API calls',
+        },
+        {
+            command: 'monomind browse report https://example.com',
+            description: 'One-command page report with a pass/fail verdict',
+        },
         { command: 'monomind browse close', description: 'Close browser session' },
     ],
     action: async (_ctx) => {
@@ -3374,6 +3921,7 @@ const browseCommand = {
         output.printInfo('  batch          Execute multiple commands');
         output.printInfo('  addinitscript  Add script to run before page navigation');
         output.printInfo('  removeinitscript Remove a previously added init script');
+        output.printInfo('  report         Test a page and write an HTML report');
         output.printInfo('  close          Close the browser session');
         return { success: true };
     },