@browserbridge/bbx 1.7.7 → 1.8.0

package/PRIVACY.md

@@ -0,0 +1,111 @@
+# Browser Bridge (BBX) Privacy Policy
+
+Last updated: 2026-07-22
+
+## Overview
+
+Browser Bridge is a developer tool that lets a user-approved local agent inspect and interact with web pages in an explicitly enabled Chrome window. This policy describes how Browser Bridge handles data.
+
+## What Browser Bridge can access
+
+When you enable Browser Bridge for a Chrome window, Browser Bridge can access page data from tabs in that window as needed to fulfill your requests. Depending on the action you or your connected agent triggers, this can include:
+
+- Page metadata such as URL, title, viewport, and scroll position
+- DOM structure, element attributes, visible text, and layout information
+- Computed styles, class/inline-style context, and semantic accessibility-tree data
+- Console messages and uncaught page errors
+- Network request metadata captured from page `fetch` and `XMLHttpRequest` activity, such as URL, method, status, timing, type, timestamp, and size
+- Optional Chrome DevTools Protocol metadata for broader resource activity, including request ID, redacted URL, method, resource type, status, MIME type, protocol, cache indicators, redirects, failure reason, duration, and timestamp
+- Current JavaScript dialog information when observable and explicitly requested, including dialog type, bounded message text, and bounded default prompt text
+- `localStorage` and `sessionStorage` values when explicitly requested
+- Screenshots or cropped image captures when explicitly requested
+- User-triggered interaction data and results such as clicks, native pointer movement/drag, DOM or native text dispatch, key presses, selection changes, dialog decisions, and navigation actions
+- Bounded semantic descriptors for optional stale-element recovery, represented in memory with normalized hashes and structural context rather than page text values or attributes written into the application DOM
+
+All-resource network inspection excludes request and response bodies, cookies,
+authorization values, and complete headers. It removes URL credentials and
+fragments, replaces query parameter values with a redaction marker, and
+summarizes data/blob URLs before returning them. Browser Bridge does not expose
+these excluded values through that feature.
+
+Browser Bridge is designed for local debugging and automation of the browser state you intentionally expose to it.
+
+## How Browser Bridge uses data
+
+Browser Bridge uses this data only to provide its user-facing purpose: letting you inspect, test, and patch the currently enabled browser window from a connected developer tool or agent.
+
+The normal local path sends request and response data through:
+
+1. The Browser Bridge Chrome extension
+2. The Browser Bridge native messaging host running on your machine
+3. The agent client or IDE that you intentionally connect
+
+The extension/native-host segment remains on the browser machine. If you explicitly configure an authenticated remote destination, the daemon can send bridge results over your own SSH tunnel or network route to that selected client. Browser Bridge does not operate a Browser Bridge cloud service and does not send extension data to developer-operated remote servers. Raw remote TCP is not presented as encrypted.
+
+## Sharing and downstream processing
+
+Browser Bridge shares page data only with the companion components and client you choose to connect. The normal path is local. If you explicitly configure Browser Bridge's authenticated remote proxy and your own tunnel or network route, the selected remote client can receive bridge results through that user-configured path; Browser Bridge does not provide or operate that network service.
+
+Important:
+
+- Browser Bridge itself does not sell your data.
+- Browser Bridge itself does not use your data for advertising.
+- Browser Bridge itself does not transfer page data to Browser Bridge-operated remote infrastructure.
+- Your connected agent or IDE may, depending on its own configuration and provider, forward prompts, tool calls, or tool results to remote services. That downstream handling is controlled by the connected product, not by Browser Bridge.
+
+You should review the privacy and retention practices of any connected agent, IDE, or model provider you use with Browser Bridge.
+
+## Data retention
+
+Browser Bridge keeps data only as long as needed for the current local session and feature behavior.
+
+- Window enablement state is stored in session storage and cleared when disabled or when the browser session ends.
+- Action log entries are stored for the current browser session only.
+- Console and fetch/XHR network buffers are bounded in memory and cleared when disabled or when the page state is reset.
+- Optional CDP network capture is bounded in memory, explicitly started/stopped, expires after a safety interval, and is cleared on relevant debugger, tab, or access teardown.
+- Dialog message/default prompt text is returned to the requesting caller when inspected but is excluded from persisted action-log summaries and size diagnostics.
+- Patch rollback records and remembered element references live in the current document. Browser Bridge attempts patch rollback when access is disabled or switched, while page replacement/navigation removes document-local state.
+- Hashed semantic descriptors used for optional stale recovery are bounded in memory with the element registry and do not survive the document/registry lifecycle.
+
+Browser Bridge does not provide Browser Bridge-hosted accounts, sync, or long-term server-side storage.
+
+## User control
+
+You control when Browser Bridge can access browser data.
+
+- Access is off by default.
+- You explicitly enable Browser Bridge for a Chrome window.
+- You can disable it at any time.
+- Restricted Chrome pages are not scriptable through Browser Bridge.
+
+## Remote code and runtime evaluation
+
+Browser Bridge does not load remotely hosted extension code.
+
+Browser Bridge can, when you explicitly invoke features such as page evaluation, execute user-requested expressions in the inspected page context through Chrome's documented Debugger API. That execution affects only the currently enabled browser window and is part of Browser Bridge's developer-tool functionality.
+
+The same existing Debugger API permission is used only when requested for
+native pointer/text dispatch, JavaScript dialog observation and explicit
+handling, accessibility reads, screenshots, performance/CDP reads, interception,
+and optional all-resource network capture. Browser Bridge does not silently
+accept/dismiss dialogs and does not claim that accepted browser input proves an
+application-level outcome.
+
+## Security
+
+- Extension code is packaged with the extension; Browser Bridge does not fetch and execute remote extension scripts.
+- Communication with the companion host uses Chrome Native Messaging.
+- Access is limited to the explicitly enabled browser window.
+- The extension includes bounded buffers and document-local rollback records for temporary page patches, with rollback attempted when enabled-window access ends or switches.
+
+## Chrome Web Store Limited Use statement
+
+The use of information received from Google APIs will adhere to the Chrome Web Store User Data Policy, including the Limited Use requirements.
+
+## Changes
+
+If Browser Bridge's data practices change, this policy will be updated before those changes are released.
+
+## Contact
+
+- GitHub Issues: https://github.com/koltyakov/browser-bridge/issues

package/README.md

@@ -4,7 +4,7 @@
 
 > **Chrome Web Store:** Install `Browser Bridge (BBX)` from the [Chrome Web Store](https://chromewebstore.google.com/detail/browser-bridge/jjjkmmcdkpcgamlopogicbnnhdgebhie). For local or custom builds, use the unpacked install flow in [docs/unpacked-extension.md](https://github.com/koltyakov/browser-bridge/blob/main/docs/unpacked-extension.md).
 
-A local bridge between your coding agent and a real Chrome tab. Browser Bridge gives the agent structured access to DOM, styles, layout, console, network, and reversible patches - starting from the actual tab you already have open, with all its real state intact.
+A local bridge between your coding agent and a real Chrome tab. Browser Bridge gives the agent structured access to DOM, styles, layout, console, network, accessibility data, reliable browser input, explicit JavaScript dialog handling, and reversible patches - starting from the actual tab you already have open, with all its real state intact.
 
 See [Quickstart](https://github.com/koltyakov/browser-bridge/blob/main/docs/quickstart.md) to get started in another repo, or browse the rest of the guides in [docs/index.md](https://github.com/koltyakov/browser-bridge/blob/main/docs/index.md).
 
@@ -101,7 +101,7 @@ Managed installs support OpenAI Codex, Claude Code, Cursor, GitHub Copilot, Open
 
 Most adjacent tools optimize for different goals. [Playwright](https://playwright.dev/) and headless automation stacks are excellent for deterministic tests and CI - but they start from a clean browser context by design. [Claude in Chrome](https://support.claude.com/en/articles/12012173-get-started-with-claude-in-chrome) is great for integrated Claude workflows, and the [Codex extension](https://chromewebstore.google.com/detail/codex/hehggadaopoacecdllhhajmbjkdcmajg) is a great option if you use Codex, but both are vendor-specific. Generic MCP browser servers offer broad control without the developer-focused depth.
 
-Browser Bridge is optimized for the opposite starting point: **inspect the state that already exists** in a real tab - logged-in sessions, feature flags, seeded storage, SPA state - use structured reads to understand it, test a patch in place, then fix the source. It's open-source, agent-agnostic, and scoped to explicit tab sessions rather than ambient browser control.
+Browser Bridge is optimized for the opposite starting point: **inspect the state that already exists** in a real tab - logged-in sessions, feature flags, seeded storage, SPA state - use structured reads to understand it, test a patch in place, then fix the source. It's open-source, agent-agnostic, and scoped to one explicitly enabled browser window rather than ambient browser control.
 
 ## Setup
 
@@ -120,9 +120,13 @@ MCP mode is self-contained: the server exposes tools and startup instructions, s
 
 - The extension is scoped to one explicitly enabled Chrome window at a time - no ambient browser access
 - Requests default to the active tab in that window unless a tab is targeted explicitly
-- Sessions are tab and origin scoped, auto-refreshed when possible
-- All patch operations are reversible and session-scoped
+- Targeted input actions reject hidden, disabled, ambiguous, stale, or obscured targets instead of silently guessing; their responses report the resolution and DOM/CDP execution path (`cdp_press_key` and `scroll_into_view` use separate contracts)
+- Native pointer/text input, dialog handling, all-resource network capture, accessibility trees, screenshots, and raw CDP reads use the existing debugger permission only when requested
+- Element references are document-local and strict by default; stale input recovery is opt-in, same-document, requires one strong unique semantic match, and fails safely when its bounded scan cannot prove uniqueness
+- Patches keep per-document rollback history and Browser Bridge attempts best-effort rollback when window access is disabled or switched; committing the patch baseline keeps current changes but discards their rollback history
+- URL waits observe full navigation and same-document SPA changes, and report the final URL and observed navigation kind
 - Structured DOM/style/layout reads are the primary transport; screenshots are a fallback
+- Browser input dispatch does not prove the application accepted the intended change, so agents should verify with a wait or structured read
 - Open-ended investigation should start with structured reads on a smaller, lower-cost subagent when the client supports delegation
 - The native host daemon auto-starts on demand
 
@@ -139,10 +143,14 @@ MCP mode is self-contained: the server exposes tools and startup instructions, s
 
 ## Privacy
 
-Browser Bridge itself routes extension data locally through the Chrome extension, native host, and the local client you choose to connect. Browser Bridge does not operate a Browser Bridge cloud service.
+The extension and native host communicate on the browser machine, and local clients connect to that daemon by default. If you explicitly configure an authenticated remote destination, bridge results can travel over your user-provided SSH tunnel or network route to the selected client. Browser Bridge does not operate a Browser Bridge cloud service, and raw remote TCP is not presented as encrypted.
 
 Your connected agent or IDE may still forward tool calls or tool results to remote services under that product's own settings and privacy policy. See [PRIVACY.md](https://github.com/koltyakov/browser-bridge/blob/main/PRIVACY.md) for the Browser Bridge policy.
 
+## Responsible Use
+
+Browser Bridge is intended for local development, debugging, and testing of web resources you own, control, or are explicitly authorized to test. Do not use it for web scraping, unauthorized data collection, or impersonating or acting as another user. You are responsible for the agents you connect, the actions they perform, and compliance with applicable laws, permissions, website terms, and third-party rights. See the [Responsible Use Agreement](https://github.com/koltyakov/browser-bridge/blob/main/RESPONSIBLE_USE.md).
+
 ## License
 
 MIT. See [LICENSE](https://github.com/koltyakov/browser-bridge/blob/main/LICENSE).

package/RESPONSIBLE_USE.md

@@ -0,0 +1,16 @@
+# Browser Bridge (BBX) Responsible Use Agreement
+
+Last updated: 2026-07-22
+
+Browser Bridge is intended for local development, debugging, and testing of websites, applications, and other web resources that you own, control, or have explicit permission to test.
+
+By using Browser Bridge, you agree that you will not use it to:
+
+- Scrape websites or perform bulk, automated, or unauthorized data collection.
+- Impersonate another user or act through another person's identity, credentials, account, or authenticated session without their explicit authorization.
+- Access systems or data without authorization, bypass access controls, violate privacy, or perform deceptive, fraudulent, abusive, or harmful actions.
+- Violate applicable laws, regulations, contractual obligations, website terms, or third-party rights.
+
+You are responsible for the browser windows you enable, the agents and services you connect, the instructions and actions they perform, the data they access or transmit, and any resulting impact. You must obtain all necessary permissions and consent and review the privacy and security practices of connected agents, IDEs, and model providers.
+
+Use Browser Bridge fairly, lawfully, and only within an authorized scope. This agreement does not modify the project's [MIT License](./LICENSE).

package/SECURITY.md

@@ -0,0 +1,52 @@
+# Security Policy
+
+Browser Bridge gives coding agents structured access to a real browser profile. The daemon,
+native messaging host, Chrome extension, CLI, and MCP server are all part of the trusted
+path between an agent and the user's browser, so security reports are taken seriously.
+
+## Supported Versions
+
+Only the latest version published to npm (`@browserbridge/bbx`) and the Chrome Web Store
+receives security fixes. Older versions are not patched retroactively; upgrade to the
+latest release before reporting.
+
+## Reporting a Vulnerability
+
+Please do **not** open a public GitHub issue for security vulnerabilities.
+
+Report privately via GitHub's security advisory form:
+<https://github.com/koltyakov/browser-bridge/security/advisories/new>
+
+Include the affected component (daemon, native host, extension, CLI, MCP server), a
+reproduction, and the impact you believe it has. Reports are acknowledged as quickly as
+possible; fixes for confirmed vulnerabilities are prioritized over regular development.
+
+## Scope
+
+In scope:
+
+- The bridge daemon: transport auth (socket permissions, TCP auth token), request routing,
+  and the opt-in proxy/remote mode.
+- The native messaging host and its manifest installation.
+- The Chrome extension (MV3 service worker, content scripts, CDP usage).
+- The `bbx` CLI and MCP server, including config/skill installation paths.
+
+Out of scope:
+
+- Vulnerabilities in Chrome, Node.js, or other dependencies (report upstream).
+- Issues requiring an already-compromised machine or browser profile.
+- The inherent capability of the tool itself: an agent authorized to use Browser Bridge
+  can, by design, read and manipulate pages in the connected browser profile. See
+  [PRIVACY.md](https://github.com/koltyakov/browser-bridge/blob/main/PRIVACY.md) and
+  [docs/agent-permissions.md](https://github.com/koltyakov/browser-bridge/blob/main/docs/agent-permissions.md)
+  for the intended trust model.
+
+## Design Notes
+
+- By default the daemon listens on a user-owned Unix socket (mode `0700` directory) or,
+  on Windows, a named pipe / localhost TCP.
+- Any TCP listener requires a random 256-bit auth token stored with mode `0600`;
+  registration without it is rejected and the comparison is constant-time.
+- Proxy mode (LAN exposure) is opt-in via `bbx proxy enable` and always provisions a
+  token; an invalid `bindHost` in the config rejects the config rather than widening
+  the bind address.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbridge/bbx",
-  "version": "1.7.7",
+  "version": "1.8.0",
   "private": false,
   "keywords": [
     "agent-tools",
@@ -33,7 +33,10 @@
   },
   "files": [
     "LICENSE",
+    "PRIVACY.md",
+    "RESPONSIBLE_USE.md",
     "README.md",
+    "SECURITY.md",
     "packages/agent-client/src",
     "packages/mcp-server/src",
     "packages/native-host/bin",
@@ -52,8 +55,9 @@
     "lint": "oxlint . && oxfmt --check .",
     "format": "oxfmt .",
     "format:check": "oxfmt --check .",
-    "test:runtime": "node --test",
-    "test": "c8 node --test",
+    "fixture:browser": "node tests/fixtures/browser-reliability/server.mjs",
+    "test:runtime": "node --import tsx --test packages/*/test/*.test.ts packages/integration-tests/*.test.ts tests/fixtures/*/*.test.ts",
+    "test": "c8 node --import tsx --test packages/*/test/*.test.ts packages/integration-tests/*.test.ts tests/fixtures/*/*.test.ts",
     "coverage": "c8 report --reporter=text --reporter=text-summary",
     "coverage:review": "c8 report --reporter=json-summary && node scripts/review-coverage.mjs",
     "coverage:check": "c8 check-coverage --lines 92 --branches 83",
@@ -70,15 +74,17 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@mozilla/readability": "^0.6.0",
+    "linkedom": "^0.18.13",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/chrome": "^0.2.2",
     "@types/node": "^26.1.1",
     "c8": "^12.0.0",
-    "linkedom": "^0.18.13",
-    "oxfmt": "^0.59.0",
-    "oxlint": "^1.74.0",
+    "oxfmt": "^0.60.0",
+    "oxlint": "^1.75.0",
+    "tsx": "^4.23.1",
     "typescript": "^7.0.2"
   },
   "engines": {

package/packages/agent-client/src/cli-args.js

@@ -60,6 +60,30 @@ export function extractTabFlag(args) {
   return { tabId, rest };
 }
 
+/**
+ * @param {string[]} args
+ * @returns {{ format: 'png' | 'jpeg' | 'webp', quality: number | undefined, rest: string[] }}
+ */
+export function extractScreenshotFlags(args) {
+  const rest = [...args];
+  const formatIndex = rest.indexOf('--format');
+  const rawFormat = formatIndex === -1 ? 'png' : rest[formatIndex + 1];
+  if (rawFormat !== 'png' && rawFormat !== 'jpeg' && rawFormat !== 'webp') {
+    throw new Error('--format must be png, jpeg, or webp.');
+  }
+  if (formatIndex !== -1) rest.splice(formatIndex, 2);
+  const qualityIndex = rest.indexOf('--quality');
+  let quality;
+  if (qualityIndex !== -1) {
+    quality = Number(rest[qualityIndex + 1]);
+    if (!Number.isInteger(quality) || quality < 0 || quality > 100) {
+      throw new Error('--quality must be an integer from 0 to 100.');
+    }
+    rest.splice(qualityIndex, 2);
+  }
+  return { format: rawFormat, quality, rest };
+}
+
 /**
  * @param {string[]} args
  * @returns {Promise<{ tabId: number | null, method: BridgeMethod, params: Record<string, unknown> }>}

package/packages/agent-client/src/cli.js

@@ -16,6 +16,7 @@ import {
 import { startBridgeMcpServer } from '../../mcp-server/src/server.js';
 import {
   extractRemoteFlag,
+  extractScreenshotFlags,
   extractTabFlag,
   parseCallCommand,
   parseInterceptAddArgs,
@@ -197,10 +198,10 @@ async function runLocalCommand(run) {
  */
 async function createCliClient() {
   try {
-    return await createBridgeClientForDestination(
-      remoteDestinationId,
-      clientTimeoutMs ? { defaultTimeoutMs: clientTimeoutMs } : {}
-    );
+    return await createBridgeClientForDestination(remoteDestinationId, {
+      checkProtocolOnConnect: false,
+      ...(clientTimeoutMs ? { defaultTimeoutMs: clientTimeoutMs } : {}),
+    });
   } catch (error) {
     printJson({
       ok: false,
@@ -362,62 +363,31 @@ async function main() {
 
     const shortcutCmd = SHORTCUT_COMMANDS[command];
     if (shortcutCmd) {
-      // Allow `bbx <shortcut> --tab <id> ...` to target a specific tab.
-      // Without this, --tab gets eaten as a positional argument and the
-      // request hits whatever tab the bridge route happens to be pointing
-      // at (typically the active tab). For element-resolving shortcuts
-      // the ref must be resolved against the SAME tab the action targets,
-      // so we pass tabId to both resolveRef and the subsequent request.
       const { tabId, rest: shortcutArgs } = extractTabFlag(rest);
-      const selectorInput = shortcutCmd.resolve ? shortcutArgs[0] : null;
-      if (shortcutCmd.resolve && !selectorInput) {
-        throw new Error(`Usage: ${command} <ref|selector>`);
-      }
-
-      // Retry-on-stale: if the action fails with ELEMENT_STALE and the
-      // original input was a selector (not an el_xxx ref), re-resolve the
-      // selector and retry once. This handles the common case where the
-      // agent resolved an element, then the page re-rendered (React
-      // reconciliation, SPA navigation) before the action was dispatched.
-      const canRetry = typeof selectorInput === 'string' && !selectorInput.startsWith('el_');
-      const maxAttempts = canRetry ? 2 : 1;
-      /** @type {import('./runtime.js').BridgeResponse | undefined} */
-      let response;
-      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        let elementRef;
-        if (shortcutCmd.resolve && selectorInput) {
-          elementRef = await resolveRef(client, selectorInput, tabId, REQUEST_SOURCE);
-        }
-        response = await requestBridge(
-          client,
-          shortcutCmd.method,
-          shortcutCmd.build(shortcutArgs, elementRef),
-          { source: REQUEST_SOURCE, tabId }
-        );
-        const isStale = !response.ok && response.error?.code === 'ELEMENT_STALE';
-        if (isStale && attempt < maxAttempts) {
-          process.stderr.write(
-            `bbx: ELEMENT_STALE on "${selectorInput}", re-resolving and retrying...\n`
-          );
-        }
-        if (!isStale || attempt >= maxAttempts) break;
-      }
-      if (response) await printSummary(response, shortcutCmd.printMethod);
+      const response = await requestBridge(
+        client,
+        shortcutCmd.method,
+        shortcutCmd.build(shortcutArgs),
+        { source: REQUEST_SOURCE, tabId }
+      );
+      await printSummary(response, shortcutCmd.printMethod);
       return;
     }
 
     if (command === 'press-key') {
       const [key, refOrSelector] = rest;
       if (!key) throw new Error('Usage: press-key <key> [ref|selector]');
-      const elementRef = refOrSelector
-        ? await resolveRef(client, refOrSelector, null, REQUEST_SOURCE)
+      const target = refOrSelector
+        ? refOrSelector.startsWith('el_')
+          ? { elementRef: refOrSelector }
+          : { selector: refOrSelector }
         : undefined;
       const response = await requestBridge(
         client,
         'input.press_key',
         {
           key,
-          target: elementRef ? { elementRef } : undefined,
+          target,
         },
         { source: REQUEST_SOURCE }
       );
@@ -447,15 +417,20 @@ async function main() {
 
     if (command === 'screenshot') {
       const parsed = extractTabFlag(rest);
-      const [refOrSelector, outputPath] = parsed.rest;
+      const screenshotOptions = extractScreenshotFlags(parsed.rest);
+      const [refOrSelector, outputPath] = screenshotOptions.rest;
       if (!refOrSelector)
-        throw new Error('Usage: screenshot [--tab <tabId>] <ref|selector> [path]');
+        throw new Error(
+          'Usage: screenshot [--tab <tabId>] [--format png|jpeg|webp] [--quality 0-100] <ref|selector> [path]'
+        );
       const elementRef = await resolveRef(client, refOrSelector, parsed.tabId, REQUEST_SOURCE);
       const response = await requestBridge(
         client,
         'screenshot.capture_element',
         {
           elementRef,
+          format: screenshotOptions.format,
+          quality: screenshotOptions.quality,
         },
         { tabId: parsed.tabId, source: REQUEST_SOURCE }
       );
@@ -464,13 +439,32 @@ async function main() {
         return;
       }
       const screenshotResult = /** @type {ScreenshotResult} */ (response.result);
-      const filePath = outputPath || path.join(os.tmpdir(), `bbx-${Date.now()}.png`);
-      const data = screenshotResult.image.replace(/^data:image\/png;base64,/, '');
+      const extension = screenshotOptions.format === 'jpeg' ? 'jpg' : screenshotOptions.format;
+      const acceptedExtensions =
+        screenshotOptions.format === 'jpeg'
+          ? new Set(['.jpg', '.jpeg'])
+          : new Set([`.${extension}`]);
+      let filePath = outputPath || path.join(os.tmpdir(), `bbx-${Date.now()}.${extension}`);
+      if (outputPath && !path.extname(outputPath)) filePath = `${outputPath}.${extension}`;
+      if (
+        outputPath &&
+        path.extname(outputPath) &&
+        !acceptedExtensions.has(path.extname(outputPath))
+      ) {
+        throw new Error(`Screenshot path extension must match ${screenshotOptions.format} format.`);
+      }
+      const data = screenshotResult.image.replace(/^data:image\/(?:png|jpeg|webp);base64,/, '');
       await fs.promises.writeFile(filePath, Buffer.from(data, 'base64'));
       printJson({
         ok: true,
         summary: `Screenshot saved to ${filePath}.`,
-        evidence: { savedTo: filePath, rect: screenshotResult.rect },
+        evidence: {
+          savedTo: filePath,
+          rect: screenshotResult.rect,
+          format: screenshotResult.format,
+          complete: screenshotResult.complete,
+          clipped: screenshotResult.clipped,
+        },
       });
       return;
     }