pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/packaged/lib/playbook.js

@@ -0,0 +1,694 @@
+// dist/extensions/agent-browser/lib/command-capabilities.js
+var ADDITIONAL_COMMAND_TOKENS = [
+  "a11y",
+  "auth",
+  "chat",
+  "clipboard",
+  "confirm",
+  "connect",
+  "dashboard",
+  "deny",
+  "device",
+  "dialog",
+  "diff",
+  "doctor",
+  "errors",
+  "eval",
+  "find",
+  "frame",
+  "get",
+  "highlight",
+  "inspect",
+  "install",
+  "is",
+  "mcp",
+  "plugin",
+  "plugins",
+  "profiles",
+  "profiler",
+  "react",
+  "record",
+  "removeinitscript",
+  "session",
+  "set",
+  "skills",
+  "snapshot",
+  "state",
+  "stream",
+  "trace",
+  "upgrade",
+  "vitals",
+  "wait",
+  "web-vitals",
+  "webmcp",
+  "window"
+];
+var COMMAND_CAPABILITIES = [
+  {
+    command: "back",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "batch",
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "check",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "click",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    aliases: ["quit", "exit"],
+    closesSession: true,
+    command: "close",
+    excludedFromPinning: true,
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "console",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "cookies",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "dblclick",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "dialog",
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "diff",
+    guardsPageRefs: true
+  },
+  {
+    command: "download",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true
+  },
+  {
+    command: "drag",
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true
+  },
+  {
+    command: "errors",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "eval",
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "fill",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "find",
+    eligibleForElectronHealthProbe: true
+  },
+  {
+    command: "frame",
+    guardsPageRefs: true
+  },
+  {
+    command: "focus",
+    guardsPageRefs: true
+  },
+  {
+    command: "forward",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "get",
+    guardsPageRefs: true
+  },
+  {
+    command: "highlight",
+    guardsPageRefs: true
+  },
+  {
+    command: "hover",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "is",
+    guardsPageRefs: true
+  },
+  {
+    command: "keydown",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "keyboard",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "keyup",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "mouse",
+    eligibleForElectronHealthProbe: true,
+    invalidatesBatchRefs: true
+  },
+  {
+    command: "network",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    aliases: ["goto", "navigate"],
+    command: "open",
+    eligibleForPageChangeSummary: true,
+    excludedFromPinning: true,
+    invalidatesBatchRefs: true,
+    openNavigation: true
+  },
+  {
+    command: "pdf",
+    eligibleForPageChangeSummary: true
+  },
+  {
+    aliases: ["key"],
+    command: "press",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "pushstate",
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "reload",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "read",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "screenshot",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true
+  },
+  {
+    command: "scroll",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    aliases: ["scrollinto"],
+    command: "scrollintoview",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "select",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "session",
+    excludedFromPinning: true,
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "storage",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "swipe",
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "tab",
+    excludedFromPinning: true,
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "tap",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "type",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "uncheck",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "upload",
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true
+  }
+];
+var COMMAND_CAPABILITY_BY_NAME = /* @__PURE__ */ new Map();
+for (const entry of COMMAND_CAPABILITIES) {
+  COMMAND_CAPABILITY_BY_NAME.set(entry.command, entry);
+  for (const alias of entry.aliases ?? []) {
+    COMMAND_CAPABILITY_BY_NAME.set(alias, entry);
+  }
+}
+var KNOWN_COMMAND_TOKENS = /* @__PURE__ */ new Set([
+  ...COMMAND_CAPABILITY_BY_NAME.keys(),
+  ...ADDITIONAL_COMMAND_TOKENS
+]);
+
+// dist/extensions/agent-browser/lib/argv-grammar.js
+var GLOBAL_VALUE_FLAGS = [
+  "--session",
+  "--namespace",
+  "--cdp",
+  "--config",
+  "--profile",
+  "--session-name",
+  "--restore-save",
+  "--restore-check-url",
+  "--restore-check-text",
+  "--restore-check-fn",
+  "--proxy",
+  "--proxy-bypass",
+  "--ca-cert",
+  "--headers",
+  "--executable-path",
+  "--extension",
+  "--init-script",
+  "--enable",
+  "--provider",
+  "-p",
+  "--engine",
+  "--state",
+  "--download-path",
+  "--screenshot-dir",
+  "--screenshot-format",
+  "--screenshot-quality",
+  "--color-scheme",
+  "--device",
+  "--args",
+  "--user-agent",
+  "--allowed-domains",
+  "--action-policy",
+  "--confirm-actions",
+  "--max-output",
+  "--model",
+  "--idle-timeout",
+  "--input-mode"
+];
+var COMMAND_VALUE_FLAGS = [
+  "--allowed-origins",
+  "--baseline",
+  "--body",
+  "--categories",
+  "--content",
+  "--curl",
+  "--depth",
+  "-d",
+  "--domain",
+  "--expires",
+  "--filter",
+  "--frame",
+  "--fn",
+  "--label",
+  "--load",
+  "--method",
+  "--name",
+  "--older-than",
+  "--output",
+  "--prefix",
+  "--path",
+  "--port",
+  "--params",
+  "--resource-type",
+  "--resource-types",
+  "--sameSite",
+  "--scope",
+  "--selector",
+  "-s",
+  "--status",
+  "--tags",
+  "--text",
+  "--threshold",
+  "--timeout",
+  "--type",
+  "--url",
+  "--username",
+  "--password",
+  "--wait-until"
+];
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  ...GLOBAL_VALUE_FLAGS,
+  ...COMMAND_VALUE_FLAGS
+]);
+var PREVALIDATED_VALUE_FLAGS = new Set(GLOBAL_VALUE_FLAGS);
+
+// dist/extensions/agent-browser/lib/launch-scoped-flags.js
+var LAUNCH_SCOPED_FLAG_DEFINITIONS = [
+  {
+    flag: "--auto-connect",
+    reason: "attaches to an already-running browser at launch time instead of reusing an existing named session"
+  },
+  {
+    flag: "--allowed-domains",
+    reason: "installs upstream network and WebRTC containment on a fresh controllable browser context"
+  },
+  {
+    flag: "--namespace",
+    reason: "selects the upstream daemon/socket and restore-state namespace before session lookup"
+  },
+  {
+    flag: "--cdp",
+    reason: "selects the browser/CDP endpoint used when an upstream session is launched"
+  },
+  {
+    flag: "--ca-cert",
+    reason: "selects isolated Chromium CA trust and may relaunch the browser"
+  },
+  {
+    flag: "--no-ca-cert",
+    reason: "clears retained isolated Chromium CA trust and may relaunch the browser"
+  },
+  {
+    flag: "--enable",
+    reason: "selects built-in page init scripts before the upstream browser session is launched"
+  },
+  {
+    flag: "--engine",
+    reason: "selects the browser engine used for the upstream launch"
+  },
+  {
+    flag: "--executable-path",
+    reason: "selects the browser executable used for the upstream launch"
+  },
+  {
+    flag: "--webgpu",
+    reason: "selects the platform-specific WebGPU browser launch preset"
+  },
+  {
+    flag: "--no-webmcp",
+    reason: "selects whether locally launched Chrome enables experimental WebMCP support"
+  },
+  {
+    flag: "--init-script",
+    reason: "registers page init scripts before the upstream browser session is launched"
+  },
+  {
+    flag: "--idle-timeout",
+    reason: "configures background browser lifecycle for the launched session"
+  },
+  {
+    flag: "--args",
+    reason: "selects raw Chrome arguments for the browser launch"
+  },
+  {
+    flag: "--user-agent",
+    reason: "selects the browser user agent at launch time"
+  },
+  {
+    flag: "--headed",
+    reason: "selects whether the launched browser has a visible window"
+  },
+  {
+    flag: "--device",
+    reason: "selects the provider device for the upstream launch"
+  },
+  {
+    flag: "--profile",
+    reason: "selects Chrome profile state for the upstream launch"
+  },
+  {
+    flag: "--provider",
+    reason: "selects the upstream browser provider for the launch"
+  },
+  {
+    flag: "-p",
+    reason: "selects the upstream browser provider for the launch"
+  },
+  {
+    flag: "--session-name",
+    reason: "selects upstream saved auth/session state for the launch"
+  },
+  {
+    flag: "--restore",
+    reason: "selects upstream saved auth/session restore state for the launch"
+  },
+  {
+    flag: "--restore-save",
+    reason: "configures upstream restore auto-save policy for the launched session"
+  },
+  {
+    flag: "--restore-check-url",
+    reason: "configures restore validation before the launched session can auto-save"
+  },
+  {
+    flag: "--restore-check-text",
+    reason: "configures restore validation before the launched session can auto-save"
+  },
+  {
+    flag: "--restore-check-fn",
+    reason: "configures restore validation before the launched session can auto-save"
+  },
+  {
+    flag: "--state",
+    reason: "loads persisted upstream browser/auth state at launch time"
+  }
+];
+var LAUNCH_SCOPED_FLAGS = LAUNCH_SCOPED_FLAG_DEFINITIONS.map((definition) => definition.flag);
+var LAUNCH_SCOPED_FLAG_LABEL = LAUNCH_SCOPED_FLAGS.join(", ");
+
+// dist/extensions/agent-browser/lib/playbook.js
+var 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.";
+var TOOL_PROMPT_GUIDELINES_PREFIX = [
+  "Use agent_browser for real browser or live web content."
+];
+function buildInstalledDocsGuideline(paths) {
+  return `For detailed agent_browser docs, read targeted sections: ${paths.readmePath} (setup), ${paths.commandReferencePath} (commands), ${paths.toolContractPath} (result/details). Do not load the full command reference unless needed.`;
+}
+var QUICK_START_GUIDELINES = [
+  "Choose agent_browser for one native command, native batch --bail with JSON-array stdin for a known fixed sequence, or agent_browser_code for loops, branches, and aggregation. Return to the model when a fresh observation needs judgment. Neither tool is a named recipe registry.",
+  'agent_browser takes args (argv after the binary), optional stdin, outputPath, timeoutMs, and sessionMode. Start with { args: ["open", "<url>"] }, then { args: ["snapshot", "-i"] }; act on current @refs and re-snapshot after navigation or DOM changes. Native commands, providers, plugins, profiles, auth, file access, and caller paths remain available through args.',
+  'Use { args: ["batch", "--bail"], stdin: "[[\\"fill\\",\\"@e1\\",\\"text\\"],[\\"click\\",\\"@e2\\"]]" } for same-snapshot form fields followed by submit. Split if a fill rerenders later fields. Add native condition waits after navigation-prone actions; a click alone does not prove the destination loaded. Avoid blind mutation retries after timeout.',
+  "agent_browser_code takes { code, session?, namespace?, timeoutMs?, outputPath? }. JavaScript globals are fresh for every call; the selected browser persists and is shared with agent_browser. Use await browser({ args, stdin?, timeoutMs? }), inspect result.success, and emit selected JSON instead of whole envelopes. Use emitImage(result.imageObservations[0]) only when image inspection is needed; image handles belong to the current code call. No imports or host filesystem/network/process APIs are exposed.",
+  `Example agent_browser_code: { code: 'const result = await browser({args:["get","title"]}); if (!result.success) { emit(result); } else { emit({title:result.data}); }' }. Native batch still avoids extra CLI processes for fixed segments inside code. Explicit session/namespace controls select the browser for this cell without changing the default browser.`,
+  'Call agent_browser_tools with no fields for inventory, or { enable: ["action", "qa", "electron", "source", "network"] } for advanced native tools. It adds agent_browser_action, agent_browser_qa, agent_browser_electron, agent_browser_source, and agent_browser_network_source without disabling other tools. The browser instructions cover these capabilities; activation reveals their selected tool declarations.',
+  "Use read <url> for readable web text; get title/url, get text/html/value/count <selector>, or get attr <selector> <name> for targeted state. For eval --stdin, put JavaScript in stdin and return the desired value. outputPath saves result data and must differ from screenshot/download/recording paths. Use --json only when JSON text is needed.",
+  "For artifacts, verify artifactVerification and artifacts before reporting success. A pending recording is not verified output; install ffmpeg before starting and pair start with stop. Native download owns the click and saves Blob/redirect downloads. Close keeps explicitly saved files. Save promptGuard-required paths before close. Screenshot pixels are not browser CSS coordinates: use imageObservations geometry (dimensions, viewport, crop/origin, scroll and DPR) before any visual-coordinate action; full-page and element captures are not current-viewport coordinates, and Pi resizing only maps sent pixels to original image pixels. Lightpanda images are text-rendered, not graphical layout; rendering:text never supports CSS/mouse-coordinate input.",
+  "Follow model-visible nextActions when present, including identity and stdin, instead of guessing commands. Treat native pending confirmations and unknown mutation outcomes as inspection boundaries. For dense snapshots, inspect Omitted high-value controls before reading a full spill."
+];
+var ADVANCED_TOOL_PROMPT_GUIDELINES = {
+  action: [
+    "agent_browser_action uses flat action/locator/value/role/name/text/selector fields. Use current @refs or stable visible labels. Select uses selector plus value/values, or role=combobox/listbox plus values, or locator=label with value=label text and values=options; it preserves unique accessible-target selection. Use native uncheck through agent_browser.",
+    "For agent_browser_action fill misses, follow nextActions/richInputRecovery to a current editable ref, then use agent_browser keyboard type for framework-controlled editors. keyboard inserttext may change only DOM state; verify application state. Do not submit unless the requested flow calls for it."
+  ],
+  qa: [
+    "agent_browser_qa returns a QA verdict from fail-fast native batch, visible-text/selector waits and actionable diagnostics. URL mode defaults console/errors/network checks on; attached:true preserves the current page and defaults those checks off to avoid attributing old errors. Set checks explicitly when needed. attached:true cannot use url or sessionMode:fresh.",
+    "agent_browser_qa defaults loadState to domcontentloaded; use networkidle only without long-lived requests. Use exact observed expectedText, not guessed copy. Verify screenshot artifacts; benign icon failures are warnings rather than failed checks. A timeout or partial mutation requires inspection before retry."
+  ],
+  electron: [
+    "agent_browser_electron uses flat action fields: list before launch; default handoff=snapshot and targetType=page. Launch owns an isolated temporary profile, not the app's existing signed-in profile. Use probe/status for readiness and always cleanup the returned launchId. Native browser close alone does not perform owned app/profile cleanup.",
+    "For a user-requested existing signed-in app, host-launch its normal profile with remote debugging when appropriate, then use agent_browser connect, get url, tab list/selection and a fresh snapshot. agent_browser_electron timeoutMs belongs to the host action; list has no timeout option. Caller-owned app shutdown remains with its owner."
+  ],
+  source: [
+    "agent_browser_source provides experimental DOM/React/workspace candidates, not proven DOM-to-file mappings. For React, launch with --enable react-devtools before navigation. componentName scans bounded local source files even when separate filesystem tools are absent; includeDomHints:false skips the HTML probe."
+  ],
+  network: [
+    "agent_browser_network_source correlates failed request IDs/filters/URLs with initiator evidence and bounded local URL literals. Results are experimental candidates, not definitive blame; preserve explicit session/namespace for the request being diagnosed."
+  ]
+};
+var WEB_SEARCH_PROMPT_GUIDELINE = "Prefer agent_browser_web_search for current or external web facts and URL discovery over public search-engine forms that can hit anti-bot/CAPTCHA-gated pages. For research before implementation, pass searchType: deep-lite unless webSearch.defaultSearchType already does; omit it for everyday lookups so config/auto wins. Provider rank is not proof of authority: when correctness or version matters, prefer the vendor or project's primary current docs, inspect page-date and version clues, and constrain one follow-up after discovering the official domain (Exa includeDomains; Brave site: in query). Do not count URL aliases as independent sources. Use agent_browser after you have a target URL that needs interaction, screenshots, or DOM inspection.";
+var WEB_SEARCH_TOOL_PROMPT_GUIDELINES = [
+  WEB_SEARCH_PROMPT_GUIDELINE,
+  "agent_browser_web_search chooses Exa or Brave from configured keys; when both are available, Exa is preferred by default unless webSearch.preferredProvider says otherwise. Use provider only when the user/config calls for a specific provider.",
+  "Use Exa deep only when deep-lite may miss angles, and deep-reasoning only for exhaustive or still-thin research. Do not run parallel agent_browser_web_search calls; make one high-signal query, inspect its results, then at most one follow-up.",
+  "If agent_browser_web_search returns HTTP 429, stop searching and tell the user the API plan/rate limit needs time or a plan change.",
+  "After using agent_browser_web_search, cite result URLs in the final answer when web evidence informed the answer."
+];
+var SHARED_BROWSER_PLAYBOOK_GUIDELINES = [
+  QUICK_START_GUIDELINES[0],
+  QUICK_START_GUIDELINES[3],
+  "Standard workflow: open the page, snapshot -i, interact using current @refs from that snapshot, and re-snapshot after navigation, scrolling, rerendering, or other major DOM changes because refs are page-scoped; the wrapper fails mutation-prone stale/recycled refs before upstream can silently target a different current-page element. On dense pages, use wrapper-side snapshot -i --search <text> or snapshot -i --filter role=<role> to render matching refs while preserving the full ref map in details.refSnapshot, add snapshot --viewport when scroll position or above/below-fold context matters, and add snapshot --diff when a quick before/after ref-map delta would prevent reading a full spill file.",
+  "For ordinary forms from one snapshot, batch multiple fill @refs before the submit/click step to avoid serial tool calls; if a fill may autosubmit, navigate, or rerender later fields, split the flow and refresh refs first.",
+  "Do not use browser automation to drive public search-engine forms such as Google for discovery; headless jobs that type a query and press Enter can be redirected to anti-bot or CAPTCHA pages. Prefer agent_browser_web_search for live discovery, then agent_browser on a target URL. Do not attempt CAPTCHA bypass.",
+  "Snapshot choice: prefer snapshot -i for routine clicks/fills (interactive @refs, main-content-first). Use snapshot --compact when you need a denser same-page tree without full spill; use full snapshot (no -i) only when you need the complete accessibility tree. Re-snapshot after navigation or major DOM changes. When snapshot -i compacts because the tree is oversized, scan visible output for Omitted high-value controls and optional details.data.highValueControlRefIds before opening the spill file: those list bounded searchboxes, textboxes, comboboxes, buttons, named action links, tabs, checkboxes, radios, options, and menuitems that did not fit the key/other ref previews.",
+  "When a visible text or accessible-name target should survive ref churn, prefer find locators such as role, text, label, placeholder, alt, title, or testid with the intended action instead of guessing a CSS selector.",
+  "For desktop or host-controlled rich inputs, if agent_browser_action fill misses, refresh refs and prefer a current editable @ref from details.richInputRecovery or the latest snapshot; focus or click that ref, then use keyboard type for framework-controlled editors that require real key events. keyboard inserttext is paste-like and can change a DOM value without updating application state, so use it only when later application-state evidence proves the edit was accepted. Do not auto-submit with Enter or a submit button unless the user flow explicitly calls for it.",
+  "Do not assume Playwright selector dialects such as text=Close or button:has-text('Close') are supported wrapper syntax unless current upstream agent-browser behavior has been verified.",
+  "For authenticated or user-specific content explicitly requested by the user, such as feeds, inboxes, account pages, or private dashboards, use a real profile only when the user/config asks for it or profiles have been inspected; do not assume --profile Default exists on every machine. Do not use a real profile for public pages just because they are dashboards. Treat visible page content from real profiles as model-visible transcript data. On macOS, copied Chrome profiles may omit encrypted cookies, so profile selection alone is not proof of authentication; verify the target page and use a user-approved headed login once when needed. Use --auto-connect only if profile-based reuse is unavailable or the task is specifically about attaching to a running debug-enabled browser. If profile/user-data-dir resolution fails, stop retrying opens, run profiles and/or doctor through agent_browser, then report what the user needs to configure.",
+  "Ordinary bare calls share one native browser within your root Pi parent/subagent group; unrelated roots browse independently. Coordinate multi-call navigation inside your group with existing subagent/intercom tools. Explicit native session defaults still win. Pi quit does not close group browsers; never close an unrelated browser.",
+  `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.`,
+  "Cooperating Pi processes serialize each complete browser operation and code cell by native socket context, namespace, and session, including target/ref helpers and state updates. Different identities remain concurrent; namespace-wide close waits for matching operations. All participating Pi instances must load this release; humans, third-party clients, and older extensions are outside that coordination. It is not a transaction or rollback. For raw batches whose later content depends on navigation, use exact batch --bail or split the calls.",
+  "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 and live-checks the URL before later page reads/interactions because an attached browser can drift externally; caller config, file access, launch arguments, and environment pass through unchanged. A successful close clears the marker. When several named sessions share one Chrome, pass --pin-tab once (AGENT_BROWSER_PIN_TAB) so a closed bound tab fails as tab_gone instead of acting on a neighbor; recover with tab new or tab list. --no-pin-tab turns the sticky pin off. tab list includes each tab's CDP targetId, accepted as a tab ref.",
+  `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.`,
+  "Chrome is the default. Use separately installed Lightpanda only when explicitly selected with --engine lightpanda, environment or native config; --engine is launch-scoped, so use sessionMode:fresh to change a managed browser. Lightpanda text-rendered screenshots do not prove graphical layout/visibility or mouse coordinates. Chrome profiles, headed mode, multi-tab, WebGPU and native WebMCP are not parity capabilities; choose Chrome explicitly when needed, never assume automatic fallback.",
+  '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 experimental WebMCP page tools, use webmcp list, then webmcp invoke <tool> with --params and optional --frame/--detach/--timeout; use webmcp result or cancel for detached calls. Locally managed Chrome enables WebMCP by default; a positive navigation hint means the page has tools to list. --no-webmcp is launch-scoped and requires a fresh session; invoke/result/cancel can mutate or navigate, so refresh snapshot refs afterward.",
+  "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>, agent_browser_source candidates for local UI source hints, react renders start/stop, or react suspense; agent_browser_source is experimental and reports confidence/evidence instead of guaranteed DOM-to-file mappings. For failed fetches and APIs, agent_browser_network_source (experimental) correlates failed network requests with initiator metadata and bounded workspace URL literals\u2014candidates 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, 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, and state save/load/list/show/rename/clear/clean for upstream saved-state lifecycle. State paths, restore identifiers, wrapper-prefixed sessions, and all upstream list rows remain available; credential values inside cookie/storage/auth payloads are still redacted from presentation.",
+  "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 agent_browser_network_source, 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, enable agent_browser_electron through agent_browser_tools 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 agent_browser_electron probe or snapshot -i/agent_browser_qa attached:true for current-session state, and always cleanup the returned launchId when done. agent_browser_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.',
+  "For provider or specialized app workflows, load version-matched upstream guidance with skills get agentcore|electron|slack|dogfood|vercel-sandbox|derive-client through the native tool; add --full when you need references/templates, and use skills get --all only for broad skill audits. Use derive-client when recording HAR traffic to generate a standalone API client; prefer network har start (text bodies by default) or network har start --content all|none before multi-step capture. For accessibility audits use a11y or a11y --tags wcag2a,wcag2aa (CDP browsers only). Hosted sandbox workflows should use upstream @agent-browser/sandbox helpers outside this wrapper. Provider launches such as -p ios, --provider browserbase/kernel/browseruse/browserless/agentcore, and iOS --device are upstream-owned setup paths; use sessionMode fresh when switching providers and expect external credentials or local Appium/Xcode setup to be required.",
+  "For dialogs and frames, use dialog status/accept/dismiss and frame <selector|main> through native args; dialog commands and eval snippets that look like alert/confirm/prompt/dialog triggers are shorter-bounded than normal browser calls, and timed-out dialog-like interactions may add inspect-dialog-after-timeout, dismiss-dialog-after-timeout, or recover-fresh-session-after-dialog-timeout nextActions. Set --confirm-actions on the session's first command; selected strings, including an explicit empty string, follow same-identity helpers and resumed follow-ups until successful close. Native unset keeps ordinary native defaults. Changing a running daemon's policy can discard pending confirmations. When it produces a pending confirmation, including a cold-reopen helper, follow the exact details.nextActions or confirm <id> / deny <id> calls without repeating the policy or inventing ids. Matching native guarded controls avoid page helpers that could replace the pending action; this is not native ID-validation proof or browser independence. In native batch, only a matching first effective decision gets that helper suppression; later page/ref checks remain. Nested decisions remain pending; failed inner actions fail, and completed browser actions reconcile their page state. A pending tab_new transport may show a validated after_confirmation open request and conditional guidance: follow it in the same session and new tab only after successful tab approval, never after denial. The extension does not execute that continuation. Confirmed full snapshots install returned refs; a final confirmed capture supplies the next same-identity call's freshness sample once, including semantic role click/check/fill and unique accessible select resolution, with target/membership/invalidation checks intact. On this one use, live verification compares the complete capture URL, including fragments, and rejects refs when it changes\u2014including wrapper-owned managed sessions and warm sessions without resume. Ordinary ref/tab URL comparisons remain fragment-insensitive. Pending snapshots display confirmation required, not an empty page. Intervening calls or later rows consume it; DOM-only renames on the same page after that sample are not resampled on this one use.",
+  'If a session lands on the wrong page or tab, an interaction changes origin unexpectedly, or an open call returns blocked, blank, or otherwise unexpected results, use tab list / tab <tab-id-or-label> / snapshot -i to recover state before retrying different URLs or fallback strategies. For headed demos, put --headed on the first launch with sessionMode=fresh and verify with screenshot/tab/get-url evidence because tool success cannot prove the OS window is visible to the user. For desktop readiness, prefer real conditions first: wait --text, wait --url, wait --fn, wait --load <state>, wait --download, or agent_browser_qa attached:true; for disappearance checks, use wait --fn predicates instead of stale upstream-help examples like wait <selector> --state hidden. Use agent_browser_electron probe/status for wrapper-owned launch health or target mismatch. Fixed waits are a last resort: their duration is positional (wait <ms>, not wait --time <ms>). Use explicit --timeout or top-level timeoutMs for legitimately slow waits, and treat a successful payload like "waited":"timeout" as elapsed time only\u2014verify completion with an observed condition, fresh snapshot, or screenshot.',
+  "For feed, timeline, or inbox reading tasks, focus on the main timeline/list region and read the first item there rather than unrelated composer or sidebar content.",
+  "For read-only browsing tasks, use read <url> for documentation or other unstructured text without requiring a Chrome page, or read with no URL for rendered active-tab DOM. Prefer the current snapshot, structured ref labels, getters, or scoped eval --stdin when you need interactive structure or targeted page state. Only click into media viewers, detail routes, or new pages when the current view does not contain the needed information.",
+  "For downloads, prefer download <selector> <path> when an element click should save a file; native download owns the click and download, including loopback links, generated Blob exports, and redirects. 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 agent_browser_action select) instead of clicking option refs; for custom comboboxes, a click/agent_browser_action may only focus the field, so re-snapshot and use keyboard type <text> for focused input, press ArrowDown or press Enter, or visible option refs. Raw type requires both <selector> and <text>.",
+  "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, 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. Local file pages and caller-selected output paths are supported when upstream allows them. 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. Optional click-dispatch probes are skipped when native confirmation settings guard evaluate, without bypassing native click policy. Otherwise probes require native get attr readback of a temporary marker on the candidate target; unproven ref or XPath identity leaves the native click unverified, not failed. 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 an upstream click failure says the target is covered by another element at the target's click point, use the inspect-overlay-state nextAction to refresh refs and inspect the blocker before deciding whether to retry; do not blindly repeat the blocked click. 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.",
+  "On upstream 0.38+, use snapshot --delta for native full/unchanged/changed revisions; --delta --full resets its baseline. Surviving DOM nodes keep refs, but refresh after navigation or replacement. Wrapper filters use full trees. screenshot --if-changed or --threshold 0.01 can return changed:false with no path or image; use ordinary screenshots when a file is required. --input-mode instant|smooth|human controls sticky pointer behavior; click/drag --human and mouse move --duration/--steps/--human/--seed pass through. record start/restart accept --cursor, --contact-sheet, and --contact-sheet-threshold; stop and verify both video and reported contact sheet. auth login <name> --no-navigate fills a prepared login page only after native origin checks. WebMCP catalog updates are untrusted page data; webmcp list supplies full schemas.",
+  "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.",
+  "Respect explicit user stop boundaries yourself. When the surrounding authenticated employee or automation context is explicitly unattended/auto-approved, ordinary non-destructive form submissions within the requested flow may proceed without separate confirmation. Still require explicit authorization for purchases, production-control actions, destructive or irreversible actions, and account, security, or privacy changes. The wrapper does not infer broad business intent from prompt text; details.promptGuard is reserved for concrete artifact-before-close checks.",
+  "Recording needs ffmpeg on PATH before start. Current upstream checks it at startup; older natives may defer failure. A pending recording is not verified output.",
+  "Do not call --help or other exploratory inspection commands unless the user explicitly asks for them or debugging the browser integration is necessary."
+];
+var TOOL_PROMPT_GUIDELINES_SUFFIX = [
+  "Prefer agent_browser over bash, osascript, AppleScript, or generic browser shell for sites, docs, clicks, fills, screenshots, eval, and batch."
+];
+var INSPECTION_TOOL_CALL_EXAMPLES = [
+  '{ "args": ["--help"] }',
+  '{ "args": ["--version"] }'
+];
+var WRAPPER_TAB_RECOVERY_BEHAVIOR = [
+  "After open/goto/navigate calls with --profile, --restore, --session-name, or --state, agent_browser best-effort re-selects the tab whose URL matches the returned page when restored tabs steal focus during launch or reconnect.",
+  "After confirmed shutdown of an automatically restored managed session, the wrapper retains its complete recorded URL, including the fragment, until the first current-page operation (including get url and reload). Non-page calls such as tab list may start a daemon without fulfilling that reopen; explicit URL reads leave the managed browser and pending reopen untouched. The wrapper uses native open once, verifies the observed tab, and discards old refs/frame scope; it does not restore unsaved forms, JavaScript memory, or history. Explicit navigation, caller-owned/attached sessions, and restore-disabled sessions are not auto-reopened.",
+  "For a still-live browser after tab drift or resume, the wrapper verifies/selects the intended tab before ref/semantic helpers and page commands; failed selection stops the call without navigating. Local commands, read <url>, URL a11y/vitals, diff url, window new, and explicit tab/navigation/connection/state recovery do not require the prior tab. Batch checks follow effective rows past non-page prefixes and stop at explicit context changes, preserving caller argv/stdin and continue-on-error behavior. Same-tab reselection is avoided because it clears refs. Use exact batch --bail for fail-fast, not --bail=<value>. Routine same-session calls skip tab-list preflights.",
+  "For sessions with observed tab-drift risk, after a successful command on a known target tab, agent_browser also best-effort restores that intended tab if a restored/background tab steals focus after the command completes. Routine same-session commands skip focus correction; observed pages without a native targetId use tab list to establish their identity.",
+  "If a known session target unexpectedly reports about:blank, agent_browser best-effort re-selects the prior intended target when it still exists; if recovery fails, it records the observed about:blank target and reports exact recovery guidance instead of treating the prior page as active.",
+  "If upstream reports tab_gone, the pinned bound tab is gone; use details.nextActions (tab list / tab new) instead of assuming another tab is yours."
+];
+var RUNTIME_PROMPT_GUIDELINES = [
+  "Use agent_browser for one native command; batch --bail with JSON-array stdin for fixed sequences; agent_browser_code for loops/branches/aggregation. Return to the model at judgment boundaries. Use agent_browser_tools to discover/enable action, qa, electron, source, or network tools.",
+  "agent_browser_code runs fresh JavaScript against the persistent browser: await browser({args, stdin?, timeoutMs?}), check result.success, emit(selected JSON), or emitImage(result.imageObservations[0]). No host APIs/imports; globals do not persist. Explicit session/namespace selects this cell's browser without changing the default.",
+  "For agent_browser, use open \u2192 snapshot -i \u2192 current @refs; re-snapshot after changes. Batch same-snapshot fills before submit; split on rerenders/navigation. Native args, profiles, auth, providers, paths, config and environment pass through. Use requested/configured profiles and verify authentication after restart.",
+  "agent_browser bare calls share a root Pi browser with descendants, not unrelated roots; coordinate navigation within the group. Native explicit sessions win. sessionMode:fresh intentionally launches a separate managed browser. Never close an unrelated browser.",
+  "For agent_browser and agent_browser_code, follow visible nextActions. Inspect unknown mutation outcomes before retry. Use exact user paths; verify artifactVerification/artifacts before success claims. Save promptGuard-required files before close; close keeps files; waited:timeout proves nothing.",
+  "For agent_browser screenshot coordinates, use imageObservations dimensions/viewport/crop/origin/scroll/DPR; full-page and element images are not viewport CSS coordinates. Pi image resizing maps sent pixels to original image pixels only. Lightpanda rendering:text images never establish CSS/mouse coordinates. Prefer refs; inspect screenshots only when the task needs vision.",
+  "In agent_browser workflows, ordinary requested non-destructive submissions may proceed in authenticated unattended/auto-approved flows. Honor explicit stops; require explicit authorization for purchases, production-control, destructive/irreversible, or account/security/privacy changes.",
+  "agent_browser: read <url> for text, get title/url, get text/html/value/count <selector>, get attr <selector> <name>; heed visibility warnings and Omitted high-value controls. Verify nested scrolling via snapshot/screenshot. Use --json only for JSON text; recording needs ffmpeg before start and a verified stop."
+];
+function buildBrowserExecutablePathGuideline(executablePath) {
+  if (executablePath === void 0 || executablePath.length === 0) {
+    return void 0;
+  }
+  return `agent_browser config sets browser.executablePath to ${JSON.stringify(executablePath)}. Global/override values bootstrap inactive automatic root Chrome browsers, not Lightpanda; bare calls preserve active native launch settings. Project-only values remain guidance for explicit --executable-path launches. Use sessionMode:fresh only for an intentionally separate managed browser, not routine root-group browsing. Upstream profiles lists Chrome profiles only; use a supported explicit profile path for other Chromium browsers.`;
+}
+function buildBrowserDefaultProfileGuideline(profile) {
+  if (!profile || profile.policy === "explicit-only") {
+    return void 0;
+  }
+  if (profile.policy === "always") {
+    return `agent_browser config sets browser.defaultProfile.name to ${JSON.stringify(profile.name)} with policy always. Global/override Chrome profile names bootstrap automatic root Chrome browsers, not Lightpanda, through independent native copies with per-root restore; bare calls and helpers preserve the active native launch settings without resending bootstrap options. Paths and project-only settings stay advisory. Explicit unrelated sessions are unchanged. Verify actual app auth after restart: native JSON restore omits new IndexedDB and memory-only credentials; use a supported per-root persistent profile if needed. Profile content is model-visible user data.`;
+  }
+  return `agent_browser config sets browser.defaultProfile.name to ${JSON.stringify(profile.name)}; for signed-in/account-specific browser tasks, reuse a configured native shared session with bare calls, otherwise start with --profile ${JSON.stringify(profile.name)} plus sessionMode:fresh unless the user asks for a different profile.`;
+}
+function buildToolPromptGuidelines(options) {
+  const browserDefaultProfileGuideline = buildBrowserDefaultProfileGuideline(options.browserDefaultProfile);
+  const browserExecutablePathGuideline = buildBrowserExecutablePathGuideline(options.browserExecutablePath);
+  return [
+    ...options.includeWebSearch ? ["Prefer agent_browser_web_search for facts; agent_browser for pages."] : TOOL_PROMPT_GUIDELINES_PREFIX,
+    ...options.docs ? [buildInstalledDocsGuideline(options.docs)] : [],
+    ...RUNTIME_PROMPT_GUIDELINES,
+    ...browserExecutablePathGuideline !== void 0 ? [browserExecutablePathGuideline] : [],
+    ...browserDefaultProfileGuideline !== void 0 ? [browserDefaultProfileGuideline] : [],
+    TOOL_PROMPT_GUIDELINES_SUFFIX[0]
+  ];
+}
+export {
+  ADVANCED_TOOL_PROMPT_GUIDELINES,
+  INSPECTION_TOOL_CALL_EXAMPLES,
+  PROJECT_RULE_PROMPT,
+  QUICK_START_GUIDELINES,
+  RUNTIME_PROMPT_GUIDELINES,
+  SHARED_BROWSER_PLAYBOOK_GUIDELINES,
+  TOOL_PROMPT_GUIDELINES_PREFIX,
+  TOOL_PROMPT_GUIDELINES_SUFFIX,
+  WEB_SEARCH_PROMPT_GUIDELINE,
+  WEB_SEARCH_TOOL_PROMPT_GUIDELINES,
+  WRAPPER_TAB_RECOVERY_BEHAVIOR,
+  buildBrowserDefaultProfileGuideline,
+  buildBrowserExecutablePathGuideline,
+  buildInstalledDocsGuideline,
+  buildToolPromptGuidelines
+};