Use when a RawTrace-controlled Chromium session is not running yet, or a known CDP endpoint or storage state must be opened before reproducing a browser issue. Preconditions: provide only profiles and systems you are authorized to inspect; storageState use also requires the raw-capture and credential acknowledgements. Next: navigate or inspect the selected page, then use browser_observe_action_result for one action or monitor_start for a multi-step reproduction. Sensitivity: launch options can expose an existing browser profile, CDP session, or credential-bearing storage state.

Use when an already-running Chromium instance contains the page that must be diagnosed and a tab needs to be selected by page ID, URL, title, or index. Preconditions: the CDP endpoint and target browser must be explicitly authorized and reachable. Next: confirm the selected page with browser_get_state, then observe one action or start a multi-step trace. Sensitivity: attaching exposes the live browser context and any data visible in the selected tab.

Use when the active page must open an exact URL as part of a reproduction, redirect investigation, authentication flow, or network-timing diagnosis. Preconditions: a browser must be active and the destination must be within the authorized development or test scope. Next: inspect state or begin the action sequence; use monitor_get_summary after stopping any active trace. Sensitivity: navigation contacts an external origin and may send cookies or other browser credentials.

Use when a reload is necessary to reproduce initialization races, cached-versus-fresh behavior, redirects, or intermittent requests. Preconditions: an active page is required; start monitor_start first when the whole reload sequence matters. Next: inspect the resulting state or stop the trace and read its summary. Sensitivity: reload can repeat writes or requests performed by the page and may transmit active credentials.

Use when history navigation is specifically needed to reproduce a redirect, back-button state bug, or single-page application history issue. Preconditions: an active page with a previous history entry is required. Next: inspect state and relevant network events after navigation. Sensitivity: history navigation can reissue requests and expose credential-bearing page state.

Use when forward history navigation is specifically required to reproduce a cached state, redirect, or single-page application history issue. Preconditions: an active page with a forward history entry is required. Next: inspect state and relevant network events after navigation. Sensitivity: history navigation can reissue requests and expose credential-bearing page state.

Use when the RawTrace browser context is no longer needed or must be reset before a clean reproduction. Preconditions: stop an active monitor first when its trace must be flushed and retained. Next: launch or attach again only if more browser work is required. Sensitivity: closing destroys the in-memory browser context and can discard unsaved page state.

Use when a full-profile workflow must discover the open pages before switching, closing, or selecting a CDP target. Preconditions: an active browser context is required. Next: use browser_switch_tab with the chosen page ID. Sensitivity: tab URLs and titles may reveal private application or account information.

Use when a full-profile reproduction genuinely requires a separate page rather than the existing active tab. Preconditions: an active browser context is required and any supplied URL must be authorized. Next: inspect or trace the new active tab, then close it when finished. Sensitivity: opening a URL contacts an external origin and may send context credentials.

Use when a full-profile workflow must make a previously discovered page the active target. Preconditions: obtain a valid page ID from browser_list_tabs or browser_attach_cdp. Next: confirm selection with browser_get_state before acting. Sensitivity: the selected tab may contain private content or an authenticated session.

Use when a full-profile workflow must remove an unneeded page or recover from a page-specific failure. Preconditions: identify the intended page and stop any trace that must retain its final events. Next: list tabs or inspect state to confirm which page remains active. Sensitivity: closing a tab discards its unsaved in-memory state.

Use when the current URL, title, frames, viewport, or focused element is needed to orient a browser diagnosis. Preconditions: an active page and acknowledgeRawCapture: true are required in an authorized environment. Next: use browser_snapshot for richer page context or choose the next targeted action. Sensitivity: state can expose URLs, frame metadata, and focused values from the live page.

Use when a compact combined view of page state, text, inputs, links, and interactive elements is more useful than separate inspection calls. Preconditions: an active page and acknowledgeRawCapture: true are required. Next: select a target for browser_observe_action_result or compare with a later snapshot. Sensitivity: snapshots may include DOM text, visible input values, links, and externalized raw artifacts.

Use when current HTML or text for a page region is needed to understand transient DOM state, hidden content, or selector behavior. Preconditions: an active page and acknowledgeRawCapture: true are required; narrow with a selector when possible. Next: use browser_get_elements for actionable targets or compare DOM mutations in a trace. Sensitivity: raw DOM and text may contain secrets, personal data, hidden form values, or externalized artifacts.

Use when stable selectors and concise metadata for clickable, editable, or otherwise interactive elements are needed before an action. Preconditions: an active page and acknowledgeRawCapture: true are required; filter by selector or text on large pages. Next: call browser_observe_action_result with the chosen selector for a single uncertain interaction. Sensitivity: element summaries can include visible text, attributes, values, and other raw page metadata.

Use when a full-profile workflow needs a shorter unique selector for a target that is already known. Preconditions: an active page, acknowledgeRawCapture: true, and a selector matching the intended element are required. Next: verify the returned selector with browser_get_elements before relying on it in automation. Sensitivity: candidate analysis reads DOM attributes and text that may be sensitive.

Use when visual evidence is necessary to understand layout, overlays, rendering, or the result of a browser interaction. Preconditions: an active page and acknowledgeRawCapture: true are required; select a region when the full page is unnecessary. Next: use the saved PNG as supporting evidence and continue with targeted DOM or trace inspection. Sensitivity: screenshots may capture personal data, secrets, account state, or other sensitive pixels and are written locally.

Use when a full-profile visual diagnosis needs temporary selector or coordinate annotations over the page. Preconditions: an active page and acknowledgeRawCapture: true are required; annotations must identify authorized content. Next: inspect the saved PNG and use normal DOM tools for machine-readable details. Sensitivity: the image and labels may expose sensitive page content and are written locally.

Use when recent request and response summaries are needed to explain a click with no request, wrong endpoint, status failure, redirect, or timing issue. Preconditions: a trace session must exist; filter by URL, method, status, or sequence when possible. Next: use monitor_search_events for cross-stream correlation or monitor_search_bodies only when body content is relevant. Sensitivity: network summaries can expose URLs, headers, status details, and references to sensitive bodies.

Use when a full-profile diagnosis specifically needs DOM-derived roles, names, states, or accessibility-oriented element summaries. Preconditions: an active page and acknowledgeRawCapture: true are required. Next: use the returned selector and role context in a targeted action or source fix. Sensitivity: accessible names and values are derived from raw DOM and may contain sensitive content.

Use when a full-profile diagnosis cannot be completed with safe DOM, action, wait, or trace tools and exact page-side JavaScript is essential. Preconditions: an active authorized page plus acknowledgeRawCapture: true and acknowledgeDangerousEval: true are required. Next: prefer a targeted inspection tool afterward and document why arbitrary evaluation was necessary. Sensitivity: arbitrary JavaScript can read or modify DOM, storage, page-visible credentials, and remote application state.

Use when a full-profile authentication or cookie-specific diagnosis explicitly requires raw cookie values. Preconditions: acknowledgeRawCapture: true and acknowledgeCredentialAccess: true are required on an authorized account. Next: inspect only the relevant cookie fields and avoid copying values into reports or code. Sensitivity: cookies are credentials and must be treated as secrets.

Use when a full-profile authorized test explicitly requires establishing or changing cookie state. Preconditions: acknowledgeRawCapture: true and acknowledgeCredentialAccess: true are required; use only intended test credentials. Next: verify the resulting flow without exposing cookie values and clear temporary state when appropriate. Sensitivity: this modifies credential state and raw cookie values are secrets.

Use when a full-profile test needs a deliberate logged-out or clean-cookie state. Preconditions: acknowledgeRawCapture: true and acknowledgeCredentialAccess: true are required; filters should be as narrow as possible. Next: reproduce the intended authentication or redirect behavior after clearing. Sensitivity: clearing cookies can sign out accounts and irreversibly remove session state from the active context.

Use when a full-profile authentication or application-state diagnosis explicitly requires localStorage or sessionStorage. Preconditions: acknowledgeRawCapture: true and acknowledgeCredentialAccess: true are required for an authorized origin. Next: inspect only relevant keys and avoid returning raw secrets in summaries. Sensitivity: web storage frequently contains tokens, identifiers, preferences, and personal data.

Use when a full-profile authorized test explicitly needs controlled localStorage or sessionStorage values. Preconditions: acknowledgeRawCapture: true and acknowledgeCredentialAccess: true are required; target the intended origin and keys. Next: reload or navigate as needed to observe the application's reaction. Sensitivity: this changes potentially credential-bearing application state.

Use when a full-profile authorized workflow explicitly needs a Playwright storageState file for reproduction or transfer. Preconditions: acknowledgeRawCapture: true and acknowledgeCredentialAccess: true are required and the output path must be protected. Next: use the file only for the intended test and remove it when no longer needed. Sensitivity: the exported file may contain reusable cookies, tokens, origins, and IndexedDB data.

Use when a full-profile authorized reproduction explicitly needs to replace active browser credential and origin state from a Playwright storageState file. Preconditions: raw-capture and credential acknowledgements are required; CDP or userDataDir contexts also require acknowledgeStorageStateOverwrite: true. Next: navigate or reload to verify the intended authenticated state. Sensitivity: import clears and replaces cookies, localStorage, and IndexedDB and can overwrite a real logged-in profile.

Use when a multi-step browser failure, transient DOM change, network race, WebSocket sequence, redirect, download, or authentication flow must be reproduced end to end. Preconditions: an authorized browser must be active and acknowledgeRawCapture: true is required; normally set captureCookies: false and captureBodies: false unless directly relevant. Next: perform the complete reproduction with RawTrace browser actions, then call monitor_stop before reading monitor_get_summary. Sensitivity: trace streams can capture raw DOM, headers, values, frames, console data, cookies, bodies, and WebSocket messages depending on options.

Use when the complete reproduction has finished and buffered trace events must be flushed before analysis. Preconditions: a monitor should be active; avoid extra unrelated browser actions before stopping. Next: call monitor_get_summary first, then targeted search tools, and read a raw artifact only when necessary. Sensitivity: the resulting trace directory is sensitive and must not be committed or broadly shared.

Use when a full-profile workflow must enumerate trace sessions created by the current MCP process. Preconditions: at least one trace session should exist. Next: select a session ID for manifest, summary, search, read, or export operations. Sensitivity: session paths and metadata may reveal local directories and sensitive investigation context.

Use when a full-profile workflow needs exact capture configuration, file inventory, schema, timing, or session metadata. Preconditions: a completed or active trace session must exist. Next: prefer monitor_get_summary for diagnosis and use manifest paths only to target later reads. Sensitivity: the manifest can expose local paths, target URLs, capture options, and trace metadata.

Use when a stopped multi-step trace needs the first compact AI-readable explanation of actions, DOM changes, requests, responses, WebSockets, console, and frames. Preconditions: complete the reproduction and call monitor_stop first whenever possible. Next: use monitor_search_events or monitor_search_bodies only for questions the summary does not answer. Sensitivity: summaries minimize volume but may still include sensitive URLs, text, values, and event details.

Use when a full-profile investigation needs paginated raw events after summary and search have identified the exact stream and range. Preconditions: a trace session and explicit stream are required; keep offset and limit narrow. Next: correlate the returned sequence with a targeted artifact only if necessary. Sensitivity: raw events may contain DOM text, headers, form values, cookie metadata, console output, and WebSocket payloads.

Use when a trace summary leaves a targeted question about an endpoint, DOM text, event type, sequence boundary, redirect, or WebSocket message. Preconditions: a trace session must exist; provide the narrowest useful stream and filters. Next: read only the matching artifact or small event range if more detail is needed. Sensitivity: matches may expose raw event fields, inline DOM content, URLs, headers, values, or payloads.

Use when authentication, API, GraphQL, request, or response content is directly relevant and body capture was enabled for the trace. Preconditions: acknowledgeRawCapture: true and a precise text query are required on an authorized session. Next: use monitor_read_artifact only for the specific matching body reference that answers the question. Sensitivity: request and response bodies can contain credentials, personal data, application secrets, and large raw payloads.

Use when summary and targeted search have identified one exact body, DOM, screenshot, eval, storage-state, or snapshot artifact needed to finish the diagnosis. Preconditions: acknowledgeRawCapture: true and a trace-contained path or reference are required; keep maxBytes bounded. Next: extract only the necessary finding and do not dump the artifact into source control or broad logs. Sensitivity: artifacts are raw and can contain reusable credentials, personal data, secrets, screenshots, or full application content.

Use when an authorized handoff or offline analysis explicitly requires a portable ZIP of a completed trace. Preconditions: a trace session must exist and the destination must be a protected local path. Next: share the bundle only through an approved sensitive-data channel and remove it when no longer needed. Sensitivity: the ZIP can contain every captured secret, body, cookie, DOM value, screenshot, and WebSocket frame.

Use when a known element must be clicked during a traced multi-step reproduction and before/after aggregation is not needed. Preconditions: an active page and a precise selector are required; prefer browser_observe_action_result when the outcome is uncertain. Next: continue the reproduction or inspect the resulting state and network events. Sensitivity: clicking can submit forms, mutate remote data, navigate, download files, or trigger other external effects.

Use when text must be entered into a known input during a reproduction. Preconditions: an active page and precise selector are required; use only data intended for the authorized target. Next: continue with the next action or observe the resulting request and DOM changes. Sensitivity: typed values may be captured in DOM, console, network, screenshots, or trace artifacts.

Use when a keyboard action such as Enter, Escape, Tab, or a shortcut is part of the browser reproduction. Preconditions: an active page is required and the optional selector must identify the intended focus target. Next: continue the sequence or inspect any resulting navigation, dialog, DOM, or network activity. Sensitivity: key presses can submit data, trigger shortcuts, navigate, or mutate remote state.

Use when hover-driven menus, tooltips, lazy content, or transient UI state must be reproduced. Preconditions: an active page and precise selector are required. Next: inspect the transient DOM promptly or continue the monitored sequence. Sensitivity: hover handlers can trigger network requests, analytics, or application state changes.

Use when lazy loading, infinite scroll, sticky layout, viewport-dependent behavior, or an off-screen target must be reproduced. Preconditions: an active page is required; provide a selector only when a specific scroll region matters. Next: wait for resulting activity or inspect DOM and network changes. Sensitivity: scroll listeners can trigger external requests, analytics, and dynamic content loading.

Use when one or more values must be selected in a native select control during a reproduction. Preconditions: an active page, precise selector, and intended value, label, or index are required. Next: continue the flow or inspect dependent DOM and network activity. Sensitivity: selection can submit forms, alter application state, or expose chosen values in traces.

Use when a checkbox or radio control must be checked or unchecked during a reproduction. Preconditions: an active page and precise selector are required. Next: continue the flow or inspect validation, DOM, and request changes. Sensitivity: changing a control can submit data, mutate remote state, or expose values in traces.

Use when one click, type, press, check, select, hover, scroll, reload, navigate, or authorized eval has an unclear outcome and a compact before/after diff is needed. Preconditions: an active page and acknowledgeRawCapture: true are required; eval actions also require acknowledgeDangerousEval: true. Next: use the returned DOM, state, network, and optional screenshot diff to decide whether a longer monitor_start reproduction is necessary. Sensitivity: before/after snapshots, values, screenshots, URLs, and network changes can contain sensitive raw page data.

Use when an action is expected to produce a response and timing or endpoint matching is the central question. Preconditions: start this wait before triggering the relevant action and provide narrow URL, method, or status filters. Next: correlate the matched response with the action or use the body variant only when content matters. Sensitivity: response metadata can expose private URLs, headers, status details, and timing information.

Use when an action is expected to produce one response whose raw or parsed body is directly required for an API, authentication, redirect, or payload diagnosis. Preconditions: start the wait before the action, use narrow filters, and pass acknowledgeRawCapture: true on an authorized system. Next: extract only the needed fields and prefer trace search for multi-request investigations. Sensitivity: response bodies may contain credentials, personal data, application secrets, or large binary content.

Use when a full-profile authorized test explicitly requires providing local files to a page file input. Preconditions: acknowledgeFileAccess: true, an exact selector, and intended local paths are required. Next: continue the upload flow and verify the resulting request or UI state. Sensitivity: this sends local file contents to the target site and can expose private data.

Use when a browser action should create a download and the saved file, filename, or timing must be verified. Preconditions: an active page is required; when triggerSelector is used it must identify the authorized download action, and raw capture requires acknowledgement. Next: inspect browser_get_downloads or the saved file through an appropriate local-file workflow. Sensitivity: downloaded files may contain sensitive application data and the optional trigger can cause external effects.

Use when saved downloads from the current runtime must be located or verified after a download flow. Preconditions: at least one download should have completed in this runtime. Next: use the relevant local file with an appropriate parser or test assertion. Sensitivity: download paths, filenames, URLs, and files can contain sensitive information.

Use when a full-profile reproduction explicitly depends on responsive breakpoints or viewport dimensions. Preconditions: an active page and intended positive width and height are required. Next: reload or inspect the affected layout and events. Sensitivity: viewport changes can trigger application reflow, lazy loading, analytics, and network requests.

Use when a full-profile authorized test explicitly requires browser permissions such as geolocation, notifications, camera, or microphone. Preconditions: acknowledgePermissionChange: true and the minimal intended permission list are required. Next: run the permission-dependent flow and avoid granting unrelated capabilities. Sensitivity: permissions expose device-like capabilities and can change what the target page may access.

Use when a full-profile authorized test explicitly depends on a controlled latitude, longitude, and accuracy. Preconditions: acknowledgeLocationAccess: true is required and only intended coordinates may be supplied. Next: reload or exercise the location-dependent behavior. Sensitivity: the coordinates are exposed to authorized pages that have geolocation permission.

Use when form structure, labels, controls, values, validation state, or submit targets are needed before reproducing a form issue. Preconditions: an active page and acknowledgeRawCapture: true are required; filter to the relevant form when possible. Next: use browser_fill_form for a multi-field reproduction or browser_observe_action_result for one uncertain control action. Sensitivity: form metadata can contain visible or hidden values, personal data, and credential fields.

Use when multiple form controls must be populated consistently and optionally submitted during a reproduction. Preconditions: an active page and unambiguous field selectors, names, labels, or placeholders are required; provide only intended test data. Next: observe validation, submission requests, redirects, and final state. Sensitivity: filled values may be captured in the DOM, requests, screenshots, traces, or remote application state.

Use when an alert, confirm, prompt, or beforeunload dialog blocks or changes the browser reproduction. Preconditions: configure the intended accept or dismiss behavior before the dialog appears. Next: trigger the dialog and inspect the resulting action, navigation, or state. Sensitivity: accepting prompts or confirmations can submit text, authorize actions, or mutate application state.

Use when the reproduction needs an explicit selector, URL, quiet-period, or bounded timeout wait instead of an arbitrary sleep. Preconditions: an active page is required and mode-specific selector or pattern inputs should be narrow. Next: perform the next action immediately after the expected condition is reached. Sensitivity: waiting observes live page and network state but does not itself redact any subsequently captured data.

Use when asynchronous DOM, URL, element value, or authentication signals must be sampled until one or all conditions match. Preconditions: an active page and acknowledgeRawCapture: true are required; use bounded timeout and interval values. Next: use the matched snapshot to continue the flow or explain the timing boundary. Sensitivity: poll snapshots can repeatedly capture raw text, values, URLs, authentication signals, and element metadata.