pi-agent-browser-native 0.2.76 → 0.3.0

package/dist/extensions/agent-browser/lib/playbook.js

@@ -1,11 +1,4 @@
 import { LAUNCH_SCOPED_FLAG_LABEL } from "./launch-scoped-flags.js";
-/**
- * Purpose: Provide the canonical agent_browser operating playbook shared by runtime prompt metadata and generated documentation fragments.
- * Responsibilities: Define stable guidance bullets, native tool-call examples, and wrapper-behavior notes without importing runtime/browser process code.
- * Scope: Agent-facing documentation and prompt-guidance text only; command execution and wrapper state behavior live in runtime modules.
- * Usage: Imported by the extension entrypoint for promptGuidelines and by the documentation drift-check script for generated Markdown blocks.
- * Invariants/Assumptions: The native pi tool receives args after the agent-browser binary, stdin is only for batch/eval --stdin/auth save --password-stdin, and wrapper behavior documented here must match implemented behavior.
- */
 export const PROJECT_RULE_PROMPT = "Project rule: when browser automation is needed, prefer the native `agent_browser` tool. Do not run direct `agent-browser` bash commands unless the user explicitly asks for a bash-oriented workflow or browser-integration debugging.";
 export const TOOL_PROMPT_GUIDELINES_PREFIX = [
     "Use agent_browser for real browser or live web content.",
@@ -21,7 +14,7 @@ export const QUICK_START_GUIDELINES = [
     `Common advanced calls: { args: ["batch", "--bail"], stdin: "[[\"open\",\"https://example.com\"],[\"snapshot\",\"-i\"]]" }, { job: { steps: [{ action: "open", url: "https://example.com" }, { action: "assertText", text: "Example Domain" }, { action: "screenshot", path: ".dogfood/example.png" }] } }, { qa: { url: "https://example.com", expectedText: "Example Domain", screenshotPath: ".dogfood/qa-example.png" } } (example.com smoke only; elsewhere match exact visible text from snapshot -i), { electron: { action: "list", query: "code" } }, { electron: { action: "launch", appName: "Visual Studio Code", handoff: "snapshot" } }, { electron: { action: "probe" } }, { qa: { attached: true, expectedText: "Explorer" } }, { args: ["eval", "--stdin"], stdin: "document.title", outputPath: "logs/page-title.json" }, { args: ["auth", "save", "name", "--password-stdin"], stdin: "<password from user-approved secret source>" }, { args: ["--profile", "Default", "open", "https://example.com/account"], sessionMode: "fresh" }, and { args: ["open", "--enable", "react-devtools", "https://example.com"], sessionMode: "fresh" }. For app pages with a native dropdown, job steps can include { action: "select", selector: "#flavor", value: "chocolate" } before the dependent assertion; for locator-friendly pages, job click/fill steps can use semantic locator fields such as { action: "fill", locator: "role", role: "searchbox", name: "Search", text: "agent browser" }; for human-paced input, job type steps can use { action: "type", selector: "#prompt", text: "hello", delayMs: 20, press: "Enter" }; delayed typing is capped at 200 characters per step, and generated per-character rows are compacted in visible batch prose while full rows remain in details.batchSteps.`,
     "Constrained job navigation is explicit only: click (and select/submit flows that may navigate) does not prove the next page loaded; add assertUrl and/or assertText after navigation-prone steps before screenshot or later interactions. Keep jobs short around navigation, click, and rerender boundaries on dynamic React/product apps; avoid a whole checkout in one job. If a long job times out and details.timeoutPartialProgress shows a mutating incomplete step, inspect current page state and continue with a shorter job or single action instead of blindly retrying the mutating step. Example: { job: { steps: [{ action: \"open\", url: \"https://shop.example/checkout\" }, { action: \"fill\", selector: \"#email\", text: \"user@example.com\" }, { action: \"click\", selector: \"#continue\" }, { action: \"assertUrl\", url: \"**/shipping\" }, { action: \"assertText\", text: \"Shipping address\" }, { action: \"screenshot\", path: \".dogfood/shipping.png\" }] } }. Top-level click may add pageChangeSummary hints, but job never auto-inserts post-click asserts.",
     "High-value command reference: click <selector> --new-tab opens link-like targets in a new tab; select <selector> <value...> changes native dropdown values; wrapper-handled scroll <dir> [px|percent] and scroll to end/top target document scrolling before upstream fallback, while scroll <selector> <dir> [px|percent] targets nested scrollers; download <selector> <path> saves a file triggered by a click; read [url] returns agent-readable text (explicit URLs prefer markdown without launching Chrome; omit the URL for rendered active-tab DOM); get title/url need no selector; get text/html/value/count <selector> and get attr <selector> <name> read elements/page state (use body for whole-page text/html); screenshot [selector] [path] captures a page or element image; pdf <path> saves a PDF; tab list and tab <tab-id-or-label> inspect or recover the active tab; react tree, react inspect <fiberId>, react renders start/stop, and react suspense introspect React after --enable react-devtools; vitals [url] measures Core Web Vitals; pushstate <url> performs SPA navigation; tap <selector> and swipe <direction> [distance] support iOS/provider touch flows.",
-    "For artifact-producing commands, read the visible artifact block and details.artifactVerification before using files: check requested path, absolute path, existence, size bytes, artifact kind, optional mediaType, status, optional limitation, and verified/missing/pending/unverified counts. details.artifacts contains per-file metadata; record start rows are pending/openRecording until record stop writes the target. The wrapper creates parent directories for direct artifact paths and can save simple loopback HTTP(S) anchor downloads directly to the requested path before upstream download fallback. Browser close does not delete explicit saved files; if close reports details.artifactCleanup, use host file tools to remove paths listed in explicitArtifactPaths (when non-empty) after inspection. If close fails with details.promptGuard.reason=requested-artifacts-missing-before-close, save the exact required artifact path before closing. For annotated screenshots inside batch, put --annotate in top-level args (for example { args: [\"--annotate\", \"batch\"], stdin: \"[[\\\"screenshot\\\",\\\"/tmp/page.png\\\"]]\" }) rather than inside the screenshot step; if annotation labels crowd a dense page, use a scoped or non-annotated screenshot plus snapshot refs instead.",
+    "For artifact-producing commands, read the visible artifact block and details.artifactVerification before using files: check requested path, absolute path, existence, size bytes, artifact kind, optional mediaType, status, optional limitation, and verified/missing/pending/unverified counts. details.artifacts contains per-file metadata; record start rows are pending/openRecording until record stop writes the target. The wrapper creates parent directories for direct artifact paths and can save simple loopback HTTP(S) anchor downloads directly to the requested path before upstream download fallback. Browser close does not delete explicit saved files; if close reports details.artifactCleanup, use host file tools to remove paths listed in explicitArtifactPaths (when non-empty) after inspection. If close fails with details.promptGuard.reason=requested-artifacts-missing-before-close, save the exact required artifact path before closing. A bare inbound image/video path is not a requested output artifact and does not block close. For annotated screenshots inside batch, put --annotate in top-level args (for example { args: [\"--annotate\", \"batch\"], stdin: \"[[\\\"screenshot\\\",\\\"/tmp/page.png\\\"]]\" }) rather than inside the screenshot step; if annotation labels crowd a dense page, use a scoped or non-annotated screenshot plus snapshot refs instead.",
     "When details.nextActions is present, prefer those exact native agent_browser follow-up payloads over prose guidance; they may include args, stdin, sessionMode, networkSourceLookup, safety notes, or artifactPath for saved files.",
 ];
 export const WEB_SEARCH_PROMPT_GUIDELINE = "Use agent_browser_web_search for quick live search/URL discovery; prefer it over public search-engine forms that can hit anti-bot/CAPTCHA-gated pages. Use agent_browser after you have a target URL; one query, one follow-up max; stop on HTTP 429.";
@@ -37,13 +30,14 @@ export const SHARED_BROWSER_PLAYBOOK_GUIDELINES = [
     "Do not invent fixed explicit session names for routine tasks. Use the implicit session unless you truly need multiple isolated browser sessions in the same conversation.",
     `When using launch-scoped flags (${LAUNCH_SCOPED_FLAG_LABEL}), put them on the first command for that session. If you intentionally use an explicit --session, keep using that same explicit session for follow-ups.`,
     "Caller-owned explicit sessions are serialized per effective canonical namespace/session inside this extension while live URL checks, semantic-action snapshots, and the requested command run. For raw batches whose later content step depends on navigation, use exact batch --bail or split the calls; unsafe continue-after-navigation-failure shapes are rejected before the batch runs.",
+    "After a successful `connect`, `--cdp`, or enabled `--auto-connect` call, verify with get url and keep using the resulting session without repeating the attach flag. The wrapper remembers that attachment across active-branch reload/resume, omits local-launch-only `--args` / `--allow-file-access` defaults from follow-up and cleanup subprocesses so upstream keeps the existing CDP connection, and live-checks the URL before later page reads/interactions because an attached browser can drift externally; a successful close clears the marker. First-use attach plus content calls are blocked until the URL is verified.",
     `If you already used the implicit session and now need launch-scoped flags (${LAUNCH_SCOPED_FLAG_LABEL}), retry with top-level sessionMode set to fresh or pass an explicit --session for the new launch; never pass --session-mode inside args. After a successful unnamed fresh launch, later auto calls follow that new session.`,
     "For WebGPU pages, use args [\"--webgpu\", \"open\", \"<url>\"] on a fresh local browser launch; use doctor --webgpu (or --headed on Linux/Windows capture paths) to prove rendering before trusting a non-black screenshot. WebGPU cannot be combined with --cdp, --auto-connect, or provider launches unless --webgpu false overrides an enabled config/environment default.",
     "For --allowed-domains, use a fresh local Chrome context. Upstream rejects CDP/auto-connect, profiles, restore/state replay, direct-page providers, iOS/Safari, and startup/profile Chrome args because they cannot guarantee containment; Chromium also disables RTCPeerConnection while the allowlist is active.",
     "For React introspection, launch the page with --enable react-devtools before first navigation, then use react tree, react inspect <fiberId>, sourceLookup candidates for local UI source hints, react renders start/stop, or react suspense; sourceLookup is experimental and reports confidence/evidence instead of guaranteed DOM-to-file mappings. For failed fetches and APIs, networkSourceLookup (experimental) correlates failed network requests with initiator metadata and bounded workspace URL literals—candidates only, not definitive blame. Use vitals [url] for Core Web Vitals and hydration timing, and pushstate <url> for client-side SPA navigation.",
     "For first-navigation setup, use open without a URL plus network route --resource-type <csv>, cookies set --curl <file>, or --init-script/--enable before navigate/opening the target page.",
     "For stateful browser context work, prefer purpose-specific page actions before dumping browser data: use auth save --password-stdin with the tool stdin field for credentials, auth list/show/delete/remove for local auth-profile maintenance, auth login when you need the browser to fill a saved profile, state save/load for portable test state, state list/show/rename and targeted `state clear <caller-owned-name>` for saved-state lifecycle cleanup (the native wrapper blocks broad clear/clean and managed targets), cookies get/set/clear and storage local|session only when the task needs those values, and expect cookie/storage/auth/state summaries to redact credential-like fields while allowing benign primitive storage values when useful for local QA.",
-    "Upstream restore sessions periodically autosave cookies and localStorage while the browser stays open, including page-driven background changes; AGENT_BROWSER_AUTOSAVE_INTERVAL_MS controls the interval (30000 by default; 0 disables periodic saves but keeps save-on-close), while the never value for --restore-save disables automatic saves for that restore session.",
+    "Upstream restore sessions periodically autosave cookies and localStorage while the browser stays open, including page-driven background changes; AGENT_BROWSER_AUTOSAVE_INTERVAL_MS controls the interval (30000 by default; 0 disables periodic saves but keeps save-on-close), while the never value for --restore-save disables automatic saves for that restore session. For wrapper-owned headed launches, the wrapper defaults the interval to 0 because upstream 0.33.2 collects multi-origin storage through visible temporary tabs, then records and reapplies the effective launch-time value to helpers and follow-ups so daemon configuration remains stable. Native close still saves, but direct window close can lose newer state because upstream exempts headed browsers from idle shutdown; set AGENT_BROWSER_AUTOSAVE_INTERVAL_MS before launch when periodic preservation matters, because changing it on a running wrapper-owned headed session requires close plus a fresh launch.",
     "For batch chains that touch cookies, storage, auth, or other secret-bearing commands, use details.batchSteps for per-step artifacts, categories, spill paths, and full structured errors; top-level details.data on batch is only a compact redacted step matrix (success, argv-redacted command, redacted result or scrubbed error text) built from the same presentation rules as standalone calls.",
     "For non-core families, pass current upstream commands through the native tool directly: network requests, network route <url>, network har start/stop [path], diff snapshot, diff screenshot --baseline <file>, diff url <u1> <u2>, trace start, trace stop [path], profiler start, profiler stop [path], record start <path>, record stop, console/errors [--clear], highlight <selector>, inspect, clipboard read, clipboard write <text>, clipboard copy/paste, stream enable/disable/status, dashboard start/stop, device list for iOS simulator inventory, and chat <message>. For compact network requests output, prefer details.nextActions for request detail, route-mock diagnostics, actionable failed-request networkSourceLookup, filtering, clearing the aggregate buffer before repro, or HAR capture follow-ups instead of guessing request-id syntax. Artifact-producing commands report details.artifacts and verification state; long-running starts such as stream, dashboard, trace/profiler, and record should be paired with the matching stop/disable command when the task is done; stream enable already-enabled outcomes are treated as idempotent success with status/disable follow-ups.",
     "For Electron desktop apps, prefer top-level electron for wrapper-owned discovery, isolated launch, status, compact probe, and cleanup: list first, treat likely-sensitive annotations as hints rather than enforcement, launch with the default snapshot handoff unless handoff: \"tabs\" is the safer diagnostic starting point, use electron.probe or snapshot -i/qa.attached for current-session state, and always cleanup the returned launchId when done. electron.launch uses an isolated temporary profile; it does not reuse the app's normal signed-in profile or attach to an already-running authenticated app. For signed-in local app state, host-launch the normal app with --remote-debugging-port when appropriate, then use raw args connect <port|url>; after connect, run get url to verify the active target before page-content reads, inspect tab list, select the stable tab id such as tab t2, verify it again with get url, then run a condition wait or snapshot -i before using refs. close commands (`close`, `quit`, or `exit`) only close the browser/CDP session; leave manually launched app shutdown, profile cleanup, and explicit artifacts to the host owner.",
@@ -55,7 +49,7 @@ export const SHARED_BROWSER_PLAYBOOK_GUIDELINES = [
     "For downloads, prefer download <selector> <path> when an element click should save a file; simple loopback anchor downloads are saved to the requested path when the wrapper can resolve an HTTP(S) href. Do not rely on click alone when you need the downloaded file on disk.",
     "On dashboards with nested scroll containers, verify scroll with a screenshot or fresh snapshot -i; if the viewport did not move, details.data.scrolled may be false/noMovement true and you should prefer scrollintoview <@ref> or target the actual scrollable region with scroll <selector> <dir> [px|percent]. For native selects, use select <selector> <value...> (or semanticAction/job select) instead of clicking option refs; for custom comboboxes, a click/semanticAction may only focus the field, so re-snapshot and fall back to type, press Enter/arrow keys, or visible option refs.",
     "When using eval --stdin, scope checks and actions to the target element or route whenever possible instead of relying on broad page-wide text heuristics.",
-    "When using eval --stdin for extraction, pass the JavaScript through the native tool stdin field, not as an extra args token after --stdin, and return the value you want instead of relying on console.log as the primary result channel. Prefer plain expressions like ({ title: document.title }) or explicitly invoked functions like (() => ({ title: document.title }))(); use outputPath when the eval/get/snapshot data should be saved as a durable local file. If a function-shaped snippet returns {}, details.evalStdinHint may warn that the function was serialized instead of called. The native wrapper blocks follow-up inspection, scripting, and interaction on file:// pages to protect authenticated local browser state; use a reachable HTTP(S) fixture instead. If get text on a broad CSS selector surfaces details.selectorTextVisibility or selectorTextVisibilityAll, prefer a visible @ref, a more specific selector, or the inspect-visible-text-candidates nextAction over hidden tab content.",
+    "When using eval --stdin for extraction, pass the JavaScript through the native tool stdin field, not as an extra args token after --stdin, and return the value you want instead of relying on console.log as the primary result channel. Prefer plain expressions like ({ title: document.title }) or explicitly invoked functions like (() => ({ title: document.title }))(); use outputPath when the eval/get/snapshot data should be saved as a durable local file, but never reuse a screenshot, download, recording, or other browser artifact destination as outputPath. If a function-shaped snippet returns {}, details.evalStdinHint may warn that the function was serialized instead of called. The native wrapper blocks follow-up inspection, scripting, and interaction on file:// pages to protect authenticated local browser state; use a reachable HTTP(S) fixture instead. If get text on a broad CSS selector surfaces details.selectorTextVisibility or selectorTextVisibilityAll, prefer a visible @ref, a more specific selector, or the inspect-visible-text-candidates nextAction over hidden tab content.",
     "When details.pageChangeSummary is present, use changeType and summary as a compact signal for navigation, DOM mutation, confirmations, or artifacts; when nextActionIds is set, match those ids to entries in details.nextActions (or per-step nextActions inside batch) for concrete follow-up payloads instead of inferring from prose alone. If details.clickDispatch reports a click-dispatch miss, refresh/inspect/retry the real click first; for static local fixtures only, an explicit eval --stdin programmatic .click() can exercise app handlers, but treat it as an untrusted scripted workaround and never use it to bypass stop-before-submit/order/purchase boundaries. If a no-navigation click surfaces details.overlayBlockers, inspect the fresh snapshot evidence before using a close/dismiss candidate nextAction; ordinary page chrome without dialog/alertdialog evidence should not trigger this diagnostic.",
     "When commands save or spill files (screenshots, downloads, PDFs, traces, recordings, HAR, large snapshot spills), use the user's exact requested paths when given and treat paths as provisional until details.artifactVerification shows every row verified: branch on missingCount, pendingCount, unverifiedCount, per-entry state, and optional limitation before downstream file use or PASS/FAIL reporting.",
     "For evidence-only screenshots, QA captures, or other audit artifacts, save to an explicit path and branch on details.artifactVerification plus details.artifacts before reporting PASS/FAIL; do not require vision review of inline image attachments unless the user asked for visual inspection.",

package/dist/extensions/agent-browser/lib/process-identity.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Describe the native command used to read a process start identity for PID-reuse-safe ownership checks.
- * Responsibilities: Keep POSIX and native-Windows process identity probes aligned across policy locks and temp cleanup.
- * Scope: Command construction, output normalization, and cached async lookup for the current process.
- */
 import { execFile } from "node:child_process";
 import { win32 } from "node:path";
 const WINDOWS_PROCESS_START_IDENTITY_PREFIX = "win32-powershell-ticks-v1:";

package/dist/extensions/agent-browser/lib/process.js

@@ -1,10 +1,4 @@
-/**
- * Purpose: Execute the upstream agent-browser binary for the pi-agent-browser extension.
- * Responsibilities: Validate POSIX socket storage, spawn the agent-browser subprocess, forward parent environment variables plus wrapper overrides, stream optional stdin, bound in-memory output buffering, spill oversized stdout safely to a private temp file under a disk budget, and honor abort signals.
- * Scope: Process execution only; argument planning, output formatting, and pi tool registration live elsewhere.
- * Usage: Called by the extension tool after argument validation and session planning are complete.
- * Invariants/Assumptions: The binary name is always `agent-browser`; Windows routes through PowerShell to invoke npm launchers with escaped argv; callers handle semantic success/error interpretation.
- */
+import { AsyncLocalStorage } from "node:async_hooks";
 import { spawn } from "node:child_process";
 import { lstat, mkdir, readdir } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
@@ -32,6 +26,10 @@ const DEFAULT_AGENT_BROWSER_PROCESS_TIMEOUT_MS = 35_000;
 /** Grace period after `exit` before resolving when `close` is delayed by inherited stdio handles. */
 const EXIT_STDIO_GRACE_MS = 100;
 const WINDOWS_AGENT_BROWSER_MISSING_MARKER = "PI_AGENT_BROWSER_COMMAND_NOT_FOUND:agent-browser.cmd";
+const attachedBrowserSessionContext = new AsyncLocalStorage();
+export function withAttachedBrowserSessionContext(preserve, run) {
+    return attachedBrowserSessionContext.run(preserve || attachedBrowserSessionContext.getStore() === true, run);
+}
 function appendTail(text, addition, maxChars) {
     const combined = text + addition;
     return combined.length <= maxChars ? combined : combined.slice(combined.length - maxChars);
@@ -87,7 +85,7 @@ export function reorderWindowsLeadingGlobalArgs(args) {
     }
     return args;
 }
-export function pinAgentBrowserFileAccessDisabled(args, wrapperCompatibilityUserAgent) {
+export function pinAgentBrowserFileAccessDisabled(args, wrapperCompatibilityUserAgent, preserveAttachedBrowserSession = false) {
     const filtered = [];
     for (let index = 0; index < args.length; index += 1) {
         const token = args[index];
@@ -100,6 +98,9 @@ export function pinAgentBrowserFileAccessDisabled(args, wrapperCompatibilityUser
         }
         filtered.push(token);
     }
+    // These are launch-only controls. Sending them on an attached-session follow-up makes upstream replace the CDP connection with a local browser.
+    if (preserveAttachedBrowserSession)
+        return filtered;
     // Upstream's flag overrides only the active CDP target; the Chrome arg covers new tabs. Its --args parser splits commas/newlines.
     const browserArgs = wrapperCompatibilityUserAgent
         ? `--user-agent=${wrapperCompatibilityUserAgent.replaceAll(/[\r\n,]/g, "")}`
@@ -333,6 +334,7 @@ function getManagedPreSpawnPolicyError(options, effectiveEnv, allowManagedSessio
 }
 export async function runAgentBrowserProcess(options) {
     const { allowManagedSessionTarget, cwd, env, managedSessionRestoreState, managedStateCurrentPageUrl, managedStatePageUrlUnknown, signal, stdin, trustedFirstBatchTabSelection } = options;
+    const preserveAttachedBrowserSession = options.preserveAttachedBrowserSession === true || attachedBrowserSessionContext.getStore() === true;
     const ownedManagedSession = options.ownedManagedSession === true || isOwnedManagedSessionTarget(options.args);
     const args = canonicalizeOwnedManagedSessionCloseArgs({
         args: options.args,
@@ -390,6 +392,7 @@ export async function runAgentBrowserProcess(options) {
         ...getManagedSessionRestoreProtectedEnv(managedSessionRestoreOptions, managedSessionRestoreEnv),
         ...getOwnedManagedSessionNamespaceEnv(managedSessionRestoreOptions),
         ...ownedManagedSessionCompatibilityEnv,
+        AGENT_BROWSER_ALLOW_FILE_ACCESS: undefined,
         [AGENT_BROWSER_ARGS_ENV]: undefined,
     };
     const explicitSocketDir = processOverrides[AGENT_BROWSER_SOCKET_DIR_ENV];
@@ -524,7 +527,7 @@ export async function runAgentBrowserProcess(options) {
             resolve({ aborted: false, agentBrowserStarted: false, exitCode: 1, spawnError: new Error(spawnPolicyError), stderr: "", stdout: "", timedOut: false });
             return;
         }
-        const spawnCommand = buildAgentBrowserSpawnCommand(pinAgentBrowserFileAccessDisabled(args, ownedManagedSessionCompatibilityEnv.AGENT_BROWSER_USER_AGENT));
+        const spawnCommand = buildAgentBrowserSpawnCommand(pinAgentBrowserFileAccessDisabled(args, ownedManagedSessionCompatibilityEnv.AGENT_BROWSER_USER_AGENT, preserveAttachedBrowserSession));
         const child = spawn(spawnCommand.command, spawnCommand.args, {
             cwd,
             env: childEnv,

package/dist/extensions/agent-browser/lib/prompt-policy.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Derive operator prompt constraints for browser-run preflight guards and legacy bash policy.
- * Responsibilities: Parse the latest user message into requested artifact paths and legacy bash allowance.
- * Scope: Pure prompt-text policy; enforcement lives in orchestration prompt-guards and the extension entrypoint.
- */
 const BROWSER_PROMPT_PATTERNS = [
     /\b(?:agent[_ -]?browser|browser automation|eval\s+--stdin|screenshot|snapshot|tab\s+list)\b/i,
     /\b(?:react\s+(?:tree|inspect|renders|suspense)|web\s+vitals|core\s+web\s+vitals|pushstate)\b/i,
@@ -17,41 +12,190 @@ const LEGACY_BASH_ALLOW_PATTERNS = [
     /\bagent-browser\s+--(?:help|version)\b/i,
     /\bdebug(?:ging)?\b.*\b(?:agent[_ -]?browser|agent_browser|browser integration)\b/i,
 ];
-const PROMPT_ARTIFACT_PATH_PATTERN = /(?:^|[\s"'`(:])((?:\/[^\s"'`),;]+|[A-Za-z]:[\\/][^\s"'`),;]+|\.{1,2}[\\/][^\s"'`),;]+|[^\s"'`),;:\\/]+(?:[\\/][^\s"'`),;]+)+|[^\s"'`),;:\\/]+)\.(?:png|jpe?g|webp|gif|webm|mp4|har|pdf|trace|json))(?:[\s"'`),;.]|$)/gi;
-function inferPromptArtifactKind(line, path) {
+const PROMPT_ARTIFACT_PATH_PATTERN = /(?:^|[\s"'`(:])((?:\/[^\s"'`),;]+|[A-Za-z]:[\\/][^\s"'`),;]+|\.{1,2}[\\/][^\s"'`),;]+|[^\s"'`()[\],;:\\/]+(?:[\\/][^\s"'`()[\],;\\/]+)+|[^\s"'`()[\],;:\\/]+)\.(?:png|jpe?g|webp|gif|webm|mp4|har|pdf|trace|json))(?=[\s"'`),;.!?]|$)/gi;
+const PROMPT_ARTIFACT_COLON_OUTPUT_INTENT_PATTERN = /\b(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\s+(?:(?:a|an|another|the)\s+)?(?:short\s+)?(?:(?:full[- ]page|page|screen)\s+)?(?:image|page|recordings?|screenshots?|screen|video)\s*:\s*$/i;
+const PROMPT_ARTIFACT_OUTPUT_INTENT_PATTERN = /\b(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\s+(?:(?:a|an|another|the|this)\s+)?(?:short\s+)?(?:(?:full[- ]page|page|screen)\s+)?(?:image|page|recordings?|screenshots?|screen|video)\s+(?:directly\s+)?(?:\b(?:at|as|to)\b\s*[:=-]?|\bhere\b(?:\s+(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available)?\s*[:=-]?)\s*$|\b(?:export|output|save|write)\s+(?:it\s+)?(?:at|as|to)\s*[:=-]?\s*$/i;
+const PROMPT_ARTIFACT_UNSAFE_OUTPUT_PREFIX_PATTERN = /n['’]t\b|\b(?:cannot|disallowed|forbidden|maybe|needed|never|no|not|optional(?:ly)?|perhaps|prohibited|rather|refrain|unable|without)\b|\b(?:he|i|it|she|they|we|you)\s+(?:can|could|may|might)\b/i;
+const PROMPT_ARTIFACT_AFFIRMATIVE_PREFIX_PATTERN = /^(?:(?:and(?:\s+then)?|then)(?:\s+please)?|please|you|(?:be|make)\s+sure\s+to|(?:can|could|will|would)\s+you(?:\s+please)?|(?:i|we)\s+(?:need|want)\s+you\s+to|you\s+(?:must|should))$/i;
+const PROMPT_ARTIFACT_AFFIRMATIVE_LEAD_IN_PATTERN = /^(?:please\s+)?(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\b.*(?:[,\-:–—]|\b(?:and|then))\s*$/i;
+const PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN = /^[\s"'`()\[\]{},;:.*!?\/&+>-]*(?:(?:and|or)[\s"'`()\[\]{},;:.*!?\/&+>-]*)?$/i;
+const PROMPT_ARTIFACT_LIST_PREFIX_PATTERN = /^\s*(?:(?:[-*+]|\d+[.)])\s*)/;
+const PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN = /\b(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available\b/i;
+const PROMPT_ARTIFACT_STANDALONE_OPTIONAL_RECORDING_PATTERN = /^\s*(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available[.:;]?\s*$/i;
+const PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN = /\b(?:optionally|if\s+(?:convenient|desired|needed|possible|you\s+can|you\s+want\s+to)|when\s+(?:convenient|desired|needed|possible)|only\s+if\s+you\s+(?:can|want\s+to))\b/i;
+const PROMPT_ARTIFACT_REFERENCE_INTENT_PATTERN = /\btake\s+the\s+(?:image|recording|screenshot|video)\s+(?:at|from)\b/i;
+const PROMPT_ARTIFACT_CLAUSE_BOUNDARY_PATTERN = /(?:[;.!?](?:\s|$)|\b(?:but|instead)\b)/i;
+function getPromptArtifactKind(path) {
     const lowerPath = path.toLowerCase();
     if (/\.(?:webm|mp4)$/.test(lowerPath))
         return "recording";
     if (/\.(?:png|jpe?g|webp|gif)$/.test(lowerPath))
         return "screenshot";
-    const lowerLine = line.toLowerCase();
-    if (lowerLine.includes("screenshot"))
-        return "screenshot";
-    if (/\b(?:screen\s+recording|recording|webm|video)\b/.test(lowerLine))
-        return "recording";
     return undefined;
 }
+function getPromptArtifactIntentClause(context) {
+    return context.split(PROMPT_ARTIFACT_CLAUSE_BOUNDARY_PATTERN).at(-1) ?? context;
+}
+function getPromptArtifactTrailingClause(context) {
+    return context.split(PROMPT_ARTIFACT_CLAUSE_BOUNDARY_PATTERN)[0] ?? context;
+}
+function hasPromptArtifactOutputIntent(context) {
+    const clause = getPromptArtifactIntentClause(context)
+        .replace(/\[[^\]\r\n]*\]\(\s*$/, "")
+        .replace(/[([{\"'`]+\s*$/, "");
+    const intentMatch = clause.match(PROMPT_ARTIFACT_OUTPUT_INTENT_PATTERN) ?? clause.match(PROMPT_ARTIFACT_COLON_OUTPUT_INTENT_PATTERN);
+    if (!intentMatch)
+        return false;
+    const prefix = clause.slice(0, intentMatch.index ?? 0);
+    const governingPrefix = prefix.split(/\b(?:before|unless|until)\b/i).at(-1) ?? prefix;
+    if (PROMPT_ARTIFACT_UNSAFE_OUTPUT_PREFIX_PATTERN.test(governingPrefix))
+        return false;
+    const normalizedPrefix = governingPrefix.trim();
+    return normalizedPrefix.length === 0
+        || PROMPT_ARTIFACT_AFFIRMATIVE_PREFIX_PATTERN.test(normalizedPrefix)
+        || PROMPT_ARTIFACT_AFFIRMATIVE_LEAD_IN_PATTERN.test(governingPrefix);
+}
+function stripPromptArtifactListPrefix(context) {
+    return context.replace(PROMPT_ARTIFACT_LIST_PREFIX_PATTERN, "");
+}
+function normalizePromptArtifactPath(path) {
+    return path.replace(/^[([{]+/, "");
+}
+function isLikelyInboundPromptArtifact(path) {
+    return /(?:^|[\\/])pi-(?:attachment|clipboard|paste|upload)-/i.test(path);
+}
 function extractPromptRequestedArtifacts(prompt) {
     const artifacts = [];
-    const seen = new Set();
-    for (const line of prompt.split(/\r?\n/)) {
+    const seen = new Map();
+    const lines = prompt.split(/\r?\n/);
+    let inCodeFence = false;
+    let listArtifactIndexes = [];
+    let listContinuation;
+    let pendingRecordingAvailability = false;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        const line = lines[lineIndex] ?? "";
+        if (/^\s*(?:`{3,}|~{3,})/.test(line)) {
+            inCodeFence = !inCodeFence;
+            listArtifactIndexes = [];
+            listContinuation = undefined;
+            pendingRecordingAvailability = false;
+            continue;
+        }
+        if (inCodeFence)
+            continue;
         PROMPT_ARTIFACT_PATH_PATTERN.lastIndex = 0;
+        const pathMatches = [];
         for (const match of line.matchAll(PROMPT_ARTIFACT_PATH_PATTERN)) {
-            const path = match[1]?.trim();
-            if (!path)
-                continue;
-            const kind = inferPromptArtifactKind(line, path);
-            if (!kind)
+            const rawPath = match[1]?.trim();
+            const path = rawPath ? normalizePromptArtifactPath(rawPath) : undefined;
+            if (!path || !rawPath)
                 continue;
-            const key = `${kind}:${path}`;
-            if (seen.has(key))
+            const start = (match.index ?? 0) + match[0].indexOf(rawPath) + rawPath.indexOf(path);
+            pathMatches.push({ end: start + path.length, path, start });
+        }
+        if (pathMatches.length === 0 && PROMPT_ARTIFACT_STANDALONE_OPTIONAL_RECORDING_PATTERN.test(line)) {
+            if (listContinuation?.kind === "recording") {
+                for (const artifactIndex of listArtifactIndexes) {
+                    if (artifacts[artifactIndex]?.kind === "recording")
+                        artifacts[artifactIndex].required = false;
+                }
+                listContinuation = { ...listContinuation, required: false };
+            }
+            else {
+                pendingRecordingAvailability = true;
+            }
+            continue;
+        }
+        if (pathMatches.length === 0 && pendingRecordingAvailability && /\brecordings?\b/i.test(line) && hasPromptArtifactOutputIntent(line))
+            continue;
+        const pendingRecordingAvailabilityForLine = pathMatches.length > 0 && pendingRecordingAvailability;
+        pendingRecordingAvailability = false;
+        const pathlessLine = stripPromptArtifactListPrefix(line.replace(PROMPT_ARTIFACT_PATH_PATTERN, ""));
+        const remainder = pathlessLine.replace(/[\s"'`()\[\],;:.*!?>-]+/g, "").toLowerCase();
+        const listSyntax = pathlessLine
+            .replace(PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN, "")
+            .replace(PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN, "");
+        const isPathList = pathMatches.length > 0 && PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN.test(listSyntax);
+        const groupOptional = new Map();
+        const candidates = [];
+        let nextGroup = 0;
+        let previousGroup;
+        let previousKind;
+        let previousPathEnd = 0;
+        for (let matchIndex = 0; matchIndex < pathMatches.length; matchIndex += 1) {
+            const { end, path, start } = pathMatches[matchIndex];
+            const localContext = stripPromptArtifactListPrefix(line.slice(previousPathEnd, start));
+            const intentContext = matchIndex === 0 && (isPathList || !remainder || ["file", "output", "path"].includes(remainder))
+                ? `${lines[lineIndex - 1] ?? ""}\n${localContext}`
+                : localContext;
+            const kind = getPromptArtifactKind(path);
+            const directIntent = hasPromptArtifactOutputIntent(intentContext);
+            const sameLineContinuation = kind === previousKind && previousGroup !== undefined && PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN.test(localContext);
+            const priorLineContinuation = matchIndex === 0 && isPathList && kind === listContinuation?.kind && PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN.test(localContext);
+            let group;
+            if (directIntent) {
+                group = nextGroup++;
+                groupOptional.set(group, pendingRecordingAvailabilityForLine || PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN.test(getPromptArtifactIntentClause(intentContext)));
+            }
+            else if (sameLineContinuation) {
+                group = previousGroup;
+            }
+            else if (priorLineContinuation) {
+                group = nextGroup++;
+                groupOptional.set(group, listContinuation?.required === false);
+            }
+            const referenceReading = directIntent && PROMPT_ARTIFACT_REFERENCE_INTENT_PATTERN.test(getPromptArtifactIntentClause(intentContext));
+            const trailingContext = getPromptArtifactTrailingClause(line.slice(end, pathMatches[matchIndex + 1]?.start ?? line.length));
+            const explicitlyOptional = directIntent && (PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN.test(getPromptArtifactIntentClause(intentContext))
+                || PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN.test(trailingContext));
+            if (!kind || group === undefined || referenceReading || explicitlyOptional || isLikelyInboundPromptArtifact(path)) {
+                previousGroup = undefined;
+                previousKind = undefined;
+                previousPathEnd = end;
                 continue;
-            seen.add(key);
-            artifacts.push({
-                kind,
-                path,
-                required: kind === "screenshot" || !/\b(?:if|when)\s+(?:recording\s+)?(?:is\s+)?available\b/i.test(line),
-            });
+            }
+            candidates.push({ continuedFromPriorLine: priorLineContinuation && !directIntent, group, kind, matchIndex, path });
+            previousGroup = group;
+            previousKind = kind;
+            previousPathEnd = end;
+        }
+        for (const candidate of candidates) {
+            const match = pathMatches[candidate.matchIndex];
+            const nextStart = pathMatches[candidate.matchIndex + 1]?.start ?? line.length;
+            if (PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN.test(getPromptArtifactTrailingClause(line.slice(match.end, nextStart)))) {
+                groupOptional.set(candidate.group, true);
+            }
+        }
+        const lineArtifactIndexes = [];
+        for (const candidate of candidates) {
+            const required = candidate.kind === "screenshot" || groupOptional.get(candidate.group) !== true;
+            const key = `${candidate.kind}:${candidate.path}`;
+            let artifactIndex = seen.get(key);
+            if (artifactIndex === undefined) {
+                artifactIndex = artifacts.length;
+                seen.set(key, artifactIndex);
+                artifacts.push({ kind: candidate.kind, path: candidate.path, required });
+            }
+            else if (required) {
+                artifacts[artifactIndex].required = true;
+            }
+            lineArtifactIndexes.push(artifactIndex);
+        }
+        const lastCandidate = candidates.at(-1);
+        if (isPathList && lastCandidate?.matchIndex === pathMatches.length - 1) {
+            const lastArtifact = artifacts[lineArtifactIndexes.at(-1)];
+            listContinuation = { kind: lastArtifact.kind, required: lastArtifact.required };
+            if (candidates[0]?.continuedFromPriorLine) {
+                for (const artifactIndex of lineArtifactIndexes)
+                    listArtifactIndexes.push(artifactIndex);
+            }
+            else {
+                listArtifactIndexes = lineArtifactIndexes;
+            }
+        }
+        else {
+            listArtifactIndexes = [];
+            listContinuation = undefined;
         }
     }
     return artifacts;

package/dist/extensions/agent-browser/lib/results/action-recommendations.js

@@ -1,12 +1,5 @@
-/**
- * Purpose: Build generic nextAction recommendations from result categories, artifacts, Electron lifecycle state, and recovery context.
- * Responsibilities: Preserve stable action ids/order while keeping recommendation policy out of generic shared helpers.
- * Scope: Generic result-level recommendations only; feature-specific diagnostics append their own actions in the extension entrypoint.
- * Usage: Called by presentation and extension result assembly.
- * Invariants/Assumptions: Action ids are public machine-readable contracts; preserve first-observed order.
- */
 import { isOpenNavigationCommand, isPageMutationCommand } from "../command-taxonomy.js";
-import { isPendingRecordingArtifact } from "./artifact-state.js";
+import { isPendingRecordingArtifact } from "./artifact-manifest.js";
 import { buildNextToolAction } from "./next-actions.js";
 import { AGENT_BROWSER_RECOVERY_NEXT_ACTION_IDS, buildRecoveryNextActions, } from "./recovery-actions.js";
 function buildArtifactAction(path) {

package/dist/extensions/agent-browser/lib/results/artifact-manifest.js

@@ -1,11 +1,10 @@
-/**
- * Purpose: Own persistent session artifact manifest merge, retention, and validation logic.
- * Responsibilities: Parse manifest bounds, recognize manifest entries, merge new artifact rows, and format retention summaries.
- * Scope: Manifest accounting only; artifact detection and presentation live in presentation modules.
- * Usage: Imported by presentation and snapshot artifact persistence paths.
- * Invariants/Assumptions: Explicit-path artifacts are host-owned while persistent-session spill files are bounded by the manifest cap.
- */
 import { isRecord } from "../parsing.js";
+export function isPendingRecordingCommand(command, subcommand, kind) {
+    return command === "record" && (subcommand === "start" || subcommand === "restart") && kind === "video";
+}
+export function isPendingRecordingArtifact(artifact) {
+    return isPendingRecordingCommand(artifact.command, artifact.subcommand, artifact.kind);
+}
 export const SESSION_ARTIFACT_MANIFEST_VERSION = 1;
 export const SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES_ENV = "PI_AGENT_BROWSER_SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES";
 export const DEFAULT_SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES = 100;

package/dist/extensions/agent-browser/lib/results/categories.js

@@ -1,11 +1,4 @@
-/**
- * Purpose: Classify successful and failed agent-browser outcomes into stable result categories.
- * Responsibilities: Map artifacts, inspection calls, errors, refs, selectors, downloads, drift, and timeouts to small enums.
- * Scope: Category policy only; next-action recommendations and presentation formatting live elsewhere.
- * Usage: Called by presentation and extension result assembly before details are exposed to Pi.
- * Invariants/Assumptions: Category strings are public machine-readable contracts covered by tests and docs.
- */
-import { isPendingRecordingArtifact } from "./artifact-state.js";
+import { isPendingRecordingArtifact } from "./artifact-manifest.js";
 function hasUnverifiedFileArtifact(artifacts) {
     return (artifacts ?? []).some((artifact) => !isPendingRecordingArtifact(artifact) && artifact.exists !== true);
 }

package/dist/extensions/agent-browser/lib/results/confirmation.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Detect upstream guarded-action confirmation-needed result shapes without creating wrapper-owned confirmation state.
- * Responsibilities: Recognize confirmation-required markers, extract the pending upstream confirmation id, and optionally surface a short upstream action label.
- * Scope: Pure result-shape detection shared by presentation and error derivation; command execution, approval state, and redaction stay in their existing modules.
- * Usage: Imported by result presentation to render recovery commands and by envelope error handling to avoid hiding actionable confirmation payloads behind generic failure text.
- * Invariants/Assumptions: Detection must be conservative: a confirmation marker and a non-empty upstream id are both required before a result is treated as actionable.
- */
 import { isRecord } from "../parsing.js";
 const CONFIRMATION_REQUIRED_FIELD_NAMES = [
     "confirmation_required",

package/dist/extensions/agent-browser/lib/results/contracts.js

@@ -1,8 +1 @@
-/**
- * Purpose: Define stable result-rendering data contracts shared across focused result modules.
- * Responsibilities: Keep upstream envelope, presentation, artifact, category, and network shapes in one type-only surface.
- * Scope: Types only; runtime classifiers, manifests, network rules, and text helpers live in neighboring modules.
- * Usage: Imported with `import type` by result modules and re-exported by the public results facade.
- * Invariants/Assumptions: This file has no runtime policy so adding fields cannot hide behavior in a catch-all module.
- */
 export {};

package/dist/extensions/agent-browser/lib/results/editable-ref-evidence.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Detect whether upstream ref metadata or snapshot text proves an element is editable.
- * Responsibilities: Parse structured ref flags and snapshot-line contenteditable/editable markers into a conservative boolean/unknown signal.
- * Scope: Editable evidence only; callers decide how to rank controls or build recovery actions from the signal.
- * Usage: Imported by snapshot compaction and selector/fill recovery diagnostics.
- * Invariants/Assumptions: Explicit false evidence wins over positive hints; unknown remains undefined.
- */
 const EDITABLE_REF_EVIDENCE_KEYS = ["editable", "contentEditable", "contenteditable", "isContentEditable"];
 const EDITABLE_FALSE_TEXT_PATTERN = /\b(?:contenteditable|editable)\s*=\s*["']?(?:false|0)["']?/i;
 const EDITABLE_ASSIGNMENT_TEXT_PATTERN = /\b(contenteditable|editable)\s*=\s*("[^"]*"|'[^']*'|[^\s,\]]+)/gi;

package/dist/extensions/agent-browser/lib/results/envelope.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Parse upstream agent-browser output and turn failure envelopes into actionable error text.
- * Responsibilities: Read inline or spilled stdout, parse observed JSON envelope shapes, normalize batch arrays, and extract the most useful error text from nested upstream failures.
- * Scope: Envelope parsing and error derivation only; content rendering and snapshot compaction live in separate modules.
- * Usage: Imported by the public `lib/results.ts` facade and by tests through that facade.
- * Invariants/Assumptions: Upstream `agent-browser --json` responses follow the observed `{ success, data, error }` envelope shape or the array shape returned by `batch --json`.
- */
 import { readFile } from "node:fs/promises";
 import { isRecord } from "../parsing.js";
 import { detectConfirmationRequired } from "./confirmation.js";

package/dist/extensions/agent-browser/lib/results/network.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Classify failed network requests into actionable vs benign diagnostics.
- * Responsibilities: Recognize failed request rows, de-prioritize browser icon misses, and summarize failure counts.
- * Scope: Network diagnostic classification only.
- * Usage: QA preset analysis and presentation network summaries.
- * Invariants/Assumptions: Browser favicon/apple-touch icon misses are warnings; API/document/script failures are actionable.
- */
 import { isRecord } from "../parsing.js";
 export function getStringRecordField(value, key) {
     const field = value[key];

package/dist/extensions/agent-browser/lib/results/next-actions.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Own machine-readable agent_browser next-action contracts and merge policy.
- * Responsibilities: Define the stable nextAction shape, build basic argv follow-ups, and provide deterministic action-list collection helpers.
- * Scope: Result follow-up action mechanics only; command-specific recovery and artifact policies live in neighboring modules.
- * Usage: Imported by result presentation helpers and the extension entrypoint when attaching details.nextActions.
- * Invariants/Assumptions: Action ids are stable machine-readable contracts; dedupe preserves first occurrence order.
- */
 export function withOptionalNamespaceArgs(namespace, args) {
     return namespace && args[0] !== "--namespace" ? ["--namespace", namespace, ...args] : args;
 }
@@ -65,26 +58,3 @@ export function alignPageChangeSummaryNextActionIds(summary, nextActions) {
     const alignedIds = summary.nextActionIds.filter((id) => nextActionIds.has(id));
     return alignedIds.length > 0 ? { ...summary, nextActionIds: alignedIds } : { ...summary, nextActionIds: undefined };
 }
-export class AgentBrowserNextActionCollector {
-    actions;
-    constructor(initialActions = undefined) {
-        this.actions = initialActions ? [...initialActions] : [];
-    }
-    append(actions) {
-        if (!actions || actions.length === 0)
-            return;
-        this.actions.push(...actions);
-    }
-    appendUnique(actions) {
-        appendUniqueAgentBrowserNextActions(this.actions, actions);
-    }
-    replace(actions) {
-        this.actions = actions ? [...actions] : [];
-    }
-    removeWhere(predicate) {
-        this.actions = this.actions.filter((action) => !predicate(action));
-    }
-    toArray() {
-        return this.actions.length > 0 ? [...this.actions] : undefined;
-    }
-}

package/dist/extensions/agent-browser/lib/results/presentation/artifacts.js

@@ -1,13 +1,7 @@
-/**
- * Purpose: Own file artifact detection, verification, manifest merging, and inline image attachment for tool presentation.
- * Responsibilities: Build artifact metadata, verification summaries, saved-file details, artifact retention notices, and safe image content.
- * Scope: Artifact and image presentation only.
- */
 import { readFile, stat } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 import { isRecord, parsePositiveInteger } from "../../parsing.js";
-import { formatSessionArtifactRetentionSummary, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
-import { isPendingRecordingArtifact, isPendingRecordingCommand } from "../artifact-state.js";
+import { formatSessionArtifactRetentionSummary, isPendingRecordingArtifact, isPendingRecordingCommand, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
 import { classifyAgentBrowserSuccessCategory } from "../categories.js";
 const IMAGE_EXTENSION_TO_MIME_TYPE = {
     ".gif": "image/gif",

package/dist/extensions/agent-browser/lib/results/presentation/browser-profile-recovery.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Build browser profile/config recovery hints for launch/setup failures.
- * Responsibilities: Recognize local Chrome/profile setup errors, avoid self-loop diagnostics, and emit canonical next actions.
- * Scope: Error presentation only; upstream profile discovery and doctor execution remain normal agent_browser commands.
- */
 import { isOpenNavigationCommand } from "../../command-taxonomy.js";
 import { getStartupScopedFlags } from "../../runtime.js";
 import { buildNextToolAction } from "../next-actions.js";

package/dist/extensions/agent-browser/lib/results/presentation/common.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Share small presentation formatting and redaction helpers across result presentation modules.
- * Responsibilities: Normalize scalar fields, stringify model-facing values, and apply sensitive-text redaction.
- * Scope: Leaf helpers only; command-family formatting lives in sibling modules.
- */
 import { containsManagedSessionRestoreKey } from "../../managed-session-capabilities.js";
 import { redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { stringifyUnknown, truncateText } from "../text.js";

package/dist/extensions/agent-browser/lib/results/presentation/content.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Share small ToolPresentation content helpers used by batch and compaction code.
- * Responsibilities: Extract text/image/path fields and format batch step command labels.
- * Scope: Pure ToolPresentation content helpers only.
- */
 export function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "string");
 }

package/dist/extensions/agent-browser/lib/results/presentation/diagnostics.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Render diagnostic command families and safe redacted diagnostic data.
- * Responsibilities: Format sessions, profiles, auth/cookies/storage, network diagnostics, console/errors, stream/dashboard/chat, and build network follow-up actions.
- * Scope: Diagnostic/result-state command presentation only; core orchestration stays in presentation.ts.
- */
 import { isRecord } from "../../parsing.js";
 import { isSensitiveFieldName, redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { classifyNetworkRequestFailure, isApiLikeNetworkRequest, isNetworkArtifactNoiseRequest, summarizeNetworkFailures } from "../network.js";

package/dist/extensions/agent-browser/lib/results/presentation/large-output.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Compact oversized model-facing tool output into bounded previews and spill artifacts.
- * Responsibilities: Write full output to persistent/session temp storage, update artifact manifests, and preserve safe previews.
- * Scope: Large-output compaction only.
- */
 import { writePersistentSessionArtifactFile, writeSecureTempFile, } from "../../temp.js";
 import { buildEvictedSessionArtifactEntries } from "../artifact-manifest.js";
 import { countLines, truncateText } from "../text.js";

package/dist/extensions/agent-browser/lib/results/presentation/managed-list-filter.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Remove wrapper-owned managed session and state capabilities from caller-visible list results.
- * Responsibilities: Recognize managed list rows recursively and preserve the surrounding upstream result shape.
- * Scope: Presentation filtering only; command authorization lives in managed-session-state-policy.ts.
- */
 import { containsManagedSessionRestoreKey, isWrapperManagedSessionName } from "../../managed-session-capabilities.js";
 import { isRecord } from "../../parsing.js";
 function isWrapperManagedSessionListItem(item) {

package/dist/extensions/agent-browser/lib/results/presentation/navigation.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Format scalar extraction results, navigation summaries, and page-change summaries.
- * Responsibilities: Keep navigation/extraction presentation separate from core tool result orchestration.
- * Scope: Navigation and get/eval extraction formatting only.
- */
 import { isNavigationObservableCommandName, isPageChangeSummaryCommand } from "../../command-taxonomy.js";
 import { isRecord } from "../../parsing.js";
 import { detectConfirmationRequired } from "../confirmation.js";