pi-agent-browser-native 0.3.0 → 0.6.5

package/dist/extensions/agent-browser/lib/orchestration/browser-run/final-result.js

@@ -3,9 +3,10 @@ import { getCompiledSemanticActionCommandIndex, getCompiledSemanticActionSession
 import { redactNetworkSourceLookupSurface } from "../../input-modes/lookups.js";
 import { buildAgentBrowserNextActions } from "../../results/action-recommendations.js";
 import { buildAgentBrowserResultCategoryDetails } from "../../results/categories.js";
+import { extractAgentBrowserLifecycle } from "../../results/presentation/common.js";
 import { formatSessionArtifactRetentionSummary } from "../../results/artifact-manifest.js";
 import { alignPageChangeSummaryNextActionIds, appendUniqueAgentBrowserNextActions, applyNamespaceToNextActions, isStandaloneSnapshotNextAction, withOptionalSessionArgs, } from "../../results/next-actions.js";
-import { buildConnectedSessionNextActions, buildNoActivePageNextActions, buildSessionAwareStaleRefNextActions, buildSessionTabRecoveryNextActions, } from "../../results/recovery-next-actions.js";
+import { buildConnectedSessionNextActions, buildNoActivePageNextActions, buildPendingWebMcpNextActions, buildSessionAwareStaleRefNextActions, buildSessionTabRecoveryNextActions, } from "../../results/recovery-next-actions.js";
 import { buildRichInputRecoveryDiagnostic, buildRichInputRecoveryNextActions, buildVisibleRefFallbackNextActions, formatRichInputRecoveryText, formatVisibleRefFallbackText, sanitizeVisibleRefFallbackDiagnostic, } from "../../results/selector-recovery.js";
 import { buildNoActivePageRefSnapshotInvalidation, isNoActivePageSnapshotFailure, } from "../../session-page-state.js";
 import { extractExplicitSessionName } from "../../argv-grammar.js";
@@ -195,7 +196,7 @@ export async function prepareFinalResultRecoveryState(options) {
         }
     }
     const richInputRecoveryDiagnostic = buildRichInputRecoveryDiagnostic(visibleRefFallbackDiagnostic);
-    const noActivePageSnapshotFailure = categoryDetails.resultCategory === "failure" && (isNoActivePageSnapshotFailure(options.executionPlan.commandInfo.command, options.errorText ?? options.presentation.summary) || options.batchRefSnapshotState?.invalidation !== undefined);
+    const noActivePageSnapshotFailure = categoryDetails.resultCategory === "failure" && (isNoActivePageSnapshotFailure(options.executionPlan.commandInfo.command, options.errorText ?? options.presentation.summary) || options.batchRefSnapshotState?.invalidation?.reason === "no-active-page");
     const executionSessionKey = getSessionContextKey(options.executionPlan.sessionName, options.executionPlan.namespace);
     if (noActivePageSnapshotFailure && executionSessionKey) {
         const refUpdate = options.sessionPageState.applyRefSnapshotInvalidation({ invalidation: buildNoActivePageRefSnapshotInvalidation(), sessionName: executionSessionKey, update: options.sessionPageStateUpdate });
@@ -208,6 +209,18 @@ function buildTimeoutPartialProgressNextActions(options) {
     const retryArgs = options.timeoutPartialProgress?.retryStep?.retry?.args;
     const stepIndex = options.timeoutPartialProgress?.retryStep?.index;
     const freshSessionAbandoned = options.sessionMode === "fresh" && options.timeoutPartialProgress?.liveUrlRecovered !== true;
+    if (options.currentSessionTabTargetUnknown && !freshSessionAbandoned && options.executionPlan.sessionName) {
+        return [{
+                id: "verify-page-target-after-timeout",
+                params: {
+                    args: withOptionalSessionArgs(options.executionPlan.sessionName, ["batch", "--bail"]),
+                    stdin: JSON.stringify([["get", "url"], ["snapshot", "-i"]]),
+                },
+                reason: `Verify the current URL, then inspect the page after timeout${stepIndex === undefined ? "" : ` before resuming from incomplete step ${stepIndex}`}.`,
+                safety: "Fail-fast read-only recovery: snapshot runs only after get url succeeds, satisfying the wrapper page-target guard without trusting the planned URL.",
+                tool: "agent_browser",
+            }];
+    }
     if (retryArgs) {
         return [{
                 id: "retry-timeout-step",
@@ -267,6 +280,10 @@ function buildResultNextActions(options) {
     const appendUnique = (actions) => {
         appendUniqueAgentBrowserNextActions(nextActions, actions);
     };
+    if (options.unsettledWebMcpMutation && options.currentSessionTabTargetUnknown) {
+        nextActions = nextActions.filter((action) => !isStandaloneSnapshotNextAction(action));
+        appendUnique(buildPendingWebMcpNextActions(options.executionPlan.sessionName));
+    }
     if (options.categoryDetails.resultCategory === "success" && options.executionPlan.commandInfo.command === "connect" && !options.electronLaunchRecord)
         appendUnique(buildConnectedSessionNextActions(options.executionPlan.sessionName));
     if (options.noActivePageSnapshotFailure)
@@ -320,6 +337,8 @@ function buildResultNextActions(options) {
     if (options.managedSessionOutcome)
         appendUnique(buildManagedSessionFreshFailureNextActions(options.managedSessionOutcome));
     if (options.categoryDetails.failureCategory === "timeout" && options.processResult.timedOut) {
+        if (options.currentSessionTabTargetUnknown)
+            nextActions = nextActions.filter((action) => !isStandaloneSnapshotNextAction(action));
         appendUnique(buildTimeoutPartialProgressNextActions(options));
         appendUnique(buildDialogTimeoutNextActions({ command: options.executionPlan.commandInfo.command, sessionName: options.executionPlan.sessionName }));
     }
@@ -329,7 +348,45 @@ function buildResultNextActions(options) {
         append(buildAgentBrowserNextActions({ electron: { launchId: options.electronLaunchRecord.launchId, sessionName: options.electronLaunchRecord.sessionName, status: options.electronLaunchRecord.cleanupState }, failureCategory: options.categoryDetails.failureCategory, resultCategory: options.categoryDetails.resultCategory, successCategory: options.categoryDetails.successCategory }));
     return nextActions.length > 0 ? nextActions : undefined;
 }
+export function formatAgentBrowserNextActionsText(nextActions) {
+    if (!nextActions || nextActions.length === 0)
+        return undefined;
+    const lines = nextActions.slice(0, 6).map((action) => {
+        const params = action.params
+            ? { ...action.params, ...(action.params.stdin !== undefined && action.params.stdin.length > 500 ? { stdin: "[omitted; use details.nextActions]" } : {}) }
+            : undefined;
+        const payload = action.artifactPath ? { artifactPath: action.artifactPath } : params;
+        return `- ${action.id}${payload ? ` ${redactSensitiveText(JSON.stringify(payload))}` : ""}: ${redactSensitiveText(action.reason)}`;
+    });
+    return ["Next actions:", ...lines, "The same redacted payloads are available in details.nextActions."].join("\n");
+}
+function formatFailureNextActionsText(options, nextActions) {
+    return options.categoryDetails.resultCategory === "failure" ? formatAgentBrowserNextActionsText(nextActions) : undefined;
+}
+function getReadSource(options) {
+    return options.executionPlan.commandInfo.command === "read" && isRecord(options.presentationEnvelope?.data) && typeof options.presentationEnvelope.data.source === "string"
+        ? options.presentationEnvelope.data.source
+        : undefined;
+}
+function formatReadExecutionText(options, lifecycle) {
+    const source = getReadSource(options);
+    if (!source)
+        return undefined;
+    return `Read execution: source ${source}; CLI started: ${options.processResult.agentBrowserStarted ? "yes" : "no"}; managed browser lifecycle active: ${lifecycle?.effectiveLaunch.browserLaunched === true ? "yes" : "no"}; managed session outcome: ${options.managedSessionOutcome?.status ?? "not managed"}.`;
+}
+function buildBrowserWindowStatus(options, lifecycle) {
+    if (!options.headedLaunch || options.preserveAttachedBrowserSession || options.providerLaunch || !options.succeeded || lifecycle?.effectiveLaunch.browserLaunched !== true || !options.executionPlan.managedSessionName || !options.managedSessionOutcome || !["created", "replaced"].includes(options.managedSessionOutcome.status))
+        return undefined;
+    return { mode: "headed", ownership: "wrapper-managed", sessionName: options.executionPlan.managedSessionName, visibility: "unverified" };
+}
+function formatBrowserWindowText(browserWindow) {
+    if (!browserWindow)
+        return undefined;
+    return "Headed browser handoff: wrapper-managed headed window requested; desktop visibility unverified. If login is needed, ask the user to confirm they can see the window and finish signing in there, then continue with sessionMode auto.";
+}
 function buildAgentBrowserResultDetails(options, nextActions) {
+    const lifecycle = extractAgentBrowserLifecycle(options.presentationEnvelope?.data);
+    const browserWindow = buildBrowserWindowStatus(options, lifecycle);
     const publicVisibleRefFallbackDiagnostic = options.visibleRefFallbackDiagnostic ? sanitizeVisibleRefFallbackDiagnostic(options.visibleRefFallbackDiagnostic) : undefined;
     const rawPageChangeSummary = (options.scrollNoopDiagnostic || options.comboboxFocusDiagnostic) && options.presentation.pageChangeSummary ? { ...options.presentation.pageChangeSummary, nextActionIds: nextActions?.map((action) => action.id) } : options.presentation.pageChangeSummary;
     const pageChangeSummary = alignPageChangeSummaryNextActionIds(rawPageChangeSummary, nextActions);
@@ -357,6 +414,10 @@ function buildAgentBrowserResultDetails(options, nextActions) {
         navigationSummary: options.navigationSummary,
         electron: options.electronLaunchRecord ? { action: "launch", cleanup: options.electronFailedConnectCleanup, handoff: options.electronHandoff, identifiers: buildElectronIdentifiers(options.electronLaunchRecord), launch: options.electronLaunchRecord, profileIsolation: options.electronProfileIsolationDetails, status: options.succeeded ? "succeeded" : "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined,
         ...options.categoryDetails,
+        agentBrowserStarted: options.processResult.agentBrowserStarted,
+        browserWindow,
+        lifecycle,
+        readSource: getReadSource(options),
         aboutBlankSessionMismatch: options.aboutBlankSessionMismatch,
         electronPostCommandHealth: options.electronPostCommandHealth,
         electronRefFreshness: options.electronRefFreshnessDiagnostic,
@@ -416,6 +477,8 @@ function buildAgentBrowserResultDetails(options, nextActions) {
 }
 export function buildFinalAgentBrowserToolResult(options) {
     const nextActions = applyNamespaceToNextActions(buildResultNextActions(options), options.executionPlan.namespace);
+    const lifecycle = extractAgentBrowserLifecycle(options.presentationEnvelope?.data);
+    const browserWindow = buildBrowserWindowStatus(options, lifecycle);
     const details = buildAgentBrowserResultDetails(options, nextActions);
     const visibleRefFallbackText = formatVisibleRefFallbackText(options.visibleRefFallbackDiagnostic);
     const richInputRecoveryText = formatRichInputRecoveryText(options.richInputRecoveryDiagnostic);
@@ -432,9 +495,12 @@ export function buildFinalAgentBrowserToolResult(options) {
     const evalStdinHintText = formatEvalStdinHintText(options.evalStdinHint);
     const evalResultWarningText = formatEvalResultWarningText(options.evalResultWarning);
     const artifactCleanupText = formatArtifactCleanupGuidanceText(options.artifactCleanup);
-    const timeoutPartialProgressText = options.timeoutPartialProgress ? formatTimeoutPartialProgressText(options.timeoutPartialProgress) : undefined;
+    const timeoutPartialProgressText = options.timeoutPartialProgress ? formatTimeoutPartialProgressText(options.timeoutPartialProgress, options.currentSessionTabTargetUnknown === true && !(options.sessionMode === "fresh" && options.timeoutPartialProgress.liveUrlRecovered !== true)) : undefined;
     const managedSessionOutcomeText = formatManagedSessionOutcomeText(options.managedSessionOutcome);
-    const rawAppendedDiagnosticText = [visibleRefFallbackText, richInputRecoveryText, semanticActionCandidateText, clickDispatchText, overlayBlockerText, fillVerificationText, electronRefFreshnessText, selectorTextVisibilityText, electronBroadGetTextScopeText, scrollNoopDiagnosticText, comboboxFocusDiagnosticText, recordingDependencyWarningText, evalStdinHintText, evalResultWarningText, artifactCleanupText, timeoutPartialProgressText, managedSessionOutcomeText].filter((item) => item !== undefined).join("\n\n");
+    const readExecutionText = formatReadExecutionText(options, lifecycle);
+    const browserWindowText = formatBrowserWindowText(browserWindow);
+    const failureNextActionsText = formatFailureNextActionsText(options, nextActions);
+    const rawAppendedDiagnosticText = [visibleRefFallbackText, richInputRecoveryText, semanticActionCandidateText, clickDispatchText, overlayBlockerText, fillVerificationText, electronRefFreshnessText, selectorTextVisibilityText, electronBroadGetTextScopeText, scrollNoopDiagnosticText, comboboxFocusDiagnosticText, recordingDependencyWarningText, evalStdinHintText, evalResultWarningText, artifactCleanupText, timeoutPartialProgressText, managedSessionOutcomeText, readExecutionText, browserWindowText, failureNextActionsText].filter((item) => item !== undefined).join("\n\n");
     const appendedDiagnosticText = redactSensitiveText(redactExactSensitiveText(rawAppendedDiagnosticText, options.exactSensitiveValues));
     const shouldAppendDiagnosticText = appendedDiagnosticText.length > 0 && (!options.userRequestedJson || options.plainTextInspection);
     let content = shouldAppendDiagnosticText && options.redactedContent[0]?.type === "text" ? [{ ...options.redactedContent[0], text: `${options.redactedContent[0].text}\n\n${appendedDiagnosticText}` }, ...options.redactedContent.slice(1)] : options.redactedContent;
@@ -462,5 +528,5 @@ export async function buildMissingBinaryFailureResult(options) {
         missingBinaryElectronRecord = missingBinaryElectronCleanup.record;
     }
     const textParts = [errorText, managedSessionOutcomeText, missingBinaryElectronCleanup ? `Electron cleanup after failed attach: ${missingBinaryElectronCleanup.summary}` : undefined].filter((part) => part !== undefined && part.length > 0);
-    return { content: [{ type: "text", text: textParts.join("\n\n") }], details: { args: options.redactedArgs, compatibilityWorkaround: options.compatibilityWorkaround, effectiveArgs: options.redactedProcessArgs, electron: missingBinaryElectronRecord ? { action: "launch", cleanup: missingBinaryElectronCleanup, launch: missingBinaryElectronRecord, status: "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined, managedSessionOutcome, namespace: options.executionPlan.namespace, nextActions: managedSessionRecoveryNextActions.length > 0 ? managedSessionRecoveryNextActions : undefined, sessionMode: options.sessionMode, sessionTabCorrection: options.sessionTabCorrection, ...buildAgentBrowserResultCategoryDetails({ args: options.redactedProcessArgs, command: options.executionPlan.commandInfo.command, errorText, failureCategory: "missing-binary", spawnError, succeeded: false }), spawnError }, isError: true };
+    return { content: [{ type: "text", text: textParts.join("\n\n") }], details: { agentBrowserStarted: options.processResult.agentBrowserStarted, args: options.redactedArgs, compatibilityWorkaround: options.compatibilityWorkaround, effectiveArgs: options.redactedProcessArgs, electron: missingBinaryElectronRecord ? { action: "launch", cleanup: missingBinaryElectronCleanup, launch: missingBinaryElectronRecord, status: "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined, managedSessionOutcome, namespace: options.executionPlan.namespace, nextActions: managedSessionRecoveryNextActions.length > 0 ? managedSessionRecoveryNextActions : undefined, sessionMode: options.sessionMode, sessionTabCorrection: options.sessionTabCorrection, ...buildAgentBrowserResultCategoryDetails({ args: options.redactedProcessArgs, command: options.executionPlan.commandInfo.command, errorText, failureCategory: "missing-binary", spawnError, succeeded: false }), spawnError }, isError: true };
 }

package/dist/extensions/agent-browser/lib/orchestration/browser-run/index.js

@@ -20,6 +20,7 @@ async function runAgentBrowserToolInContext(options) {
     const ownedManagedSession = prepared.ownedManagedSessionContext;
     return await withOwnedManagedSessionContext(ownedManagedSession, async () => {
         try {
+            const artifactRunStartedAtMs = Date.now();
             const processResult = await runAgentBrowserProcess({
                 args: prepared.processArgs,
                 cwd: options.cwd,
@@ -51,7 +52,7 @@ async function runAgentBrowserToolInContext(options) {
             });
             if (missingBinaryResult)
                 return missingBinaryResult;
-            const output = await processBrowserOutput({ ...options, prepared, processResult });
+            const output = await processBrowserOutput({ ...options, artifactRunStartedAtMs, prepared, processResult });
             applyBrowserRunStatePatch(options.state, output.statePatch);
             return output.result;
         }

package/dist/extensions/agent-browser/lib/orchestration/browser-run/managed-session-daemon-policy.js

@@ -3,13 +3,14 @@ import { acquireManagedSessionPolicyLock } from "../../managed-session-policy-lo
 import { pruneOwnedManagedSessionRestoreSnapshots, resolveExplicitAutosaveInterval, } from "../../managed-session-restore.js";
 import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
 import { isRecord } from "../../parsing.js";
+import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
 import { runAgentBrowserProcess } from "../../process.js";
 import { getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { redactInvocationArgs } from "../../runtime.js";
 const MANAGED_SESSION_DAEMON_INSPECTION_TIMEOUT_MS = 35_000;
 const RUNNING_HEADED_AUTOSAVE_POLICY_CHANGE_ERROR = "AGENT_BROWSER_AUTOSAVE_INTERVAL_MS cannot change a running wrapper-owned headed session's launch-time periodic autosave interval. Close that session first, then retry with sessionMode: \"fresh\" so the new daemon starts with the requested interval.";
 export function getRunningHeadedAutosavePolicyChangeError(recordedInterval, closeCommand = false) {
-    const explicitInterval = resolveExplicitAutosaveInterval(process.env.AGENT_BROWSER_AUTOSAVE_INTERVAL_MS);
+    const explicitInterval = resolveExplicitAutosaveInterval(getAgentBrowserProcessEnvironment().AGENT_BROWSER_AUTOSAVE_INTERVAL_MS);
     return recordedInterval !== undefined && !closeCommand && explicitInterval !== undefined && explicitInterval !== recordedInterval
         ? RUNNING_HEADED_AUTOSAVE_POLICY_CHANGE_ERROR
         : undefined;
@@ -19,7 +20,6 @@ function getHeadedManagedAutosaveEnv(interval) {
 }
 export async function inspectManagedSessionDaemon(options) {
     const processResult = await runAgentBrowserProcess({
-        allowManagedSessionTarget: options.allowManagedSessionTarget,
         args: ["--json", "--namespace", options.namespace ?? "", "--session", options.sessionName, "session", "info"],
         cwd: options.cwd,
         env: getHeadedManagedAutosaveEnv(options.headedManagedAutosaveInterval),
@@ -67,7 +67,6 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
     }
     try {
         const daemon = await inspectManagedSessionDaemon({
-            allowManagedSessionTarget: true,
             cwd: context.cwd,
             headedManagedAutosaveInterval: context.headedManagedAutosaveInterval,
             namespace: context.namespace,
@@ -79,7 +78,7 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
         if (options.mode === "close") {
             if (daemon.status === "active")
                 context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
-            return { lock };
+            return { daemonStatus: daemon.status, lock };
         }
         const stickyDisabled = context.restoreState.isDisabled(context.sessionName, context.namespace);
         const hasKnownDaemonRestoreKey = context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace);
@@ -101,13 +100,14 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
             context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
         return !["inactive", "missing-binary"].includes(daemon.status) && !activePolicyMatches
             ? {
+                daemonStatus: daemon.status,
                 error: [
                     "This wrapper-owned session's live daemon does not match the requested managed-restore policy.",
                     "Close that session first, retry with sessionMode: \"fresh\", or use a distinct explicit --session.",
                 ].join(" "),
                 lock,
             }
-            : { lock };
+            : { daemonStatus: daemon.status, lock };
     }
     catch (error) {
         await lock.release();
@@ -118,7 +118,7 @@ export async function closeManagedSession(options) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), options.timeoutMs);
     let stdoutSpillPath;
-    const closeArgs = [...(options.namespace ? ["--namespace", options.namespace] : []), "--session", options.sessionName, "close"];
+    const closeArgs = [...(options.namespace !== undefined ? ["--namespace", options.namespace] : []), "--session", options.sessionName, "close"];
     const policyLock = options.policyLock ?? await acquireManagedSessionPolicyLock({
         namespace: options.namespace,
         sessionName: options.sessionName,
@@ -131,7 +131,6 @@ export async function closeManagedSession(options) {
     }
     try {
         const daemon = await inspectManagedSessionDaemon({
-            allowManagedSessionTarget: true,
             cwd: options.cwd,
             headedManagedAutosaveInterval: options.headedManagedAutosaveInterval,
             namespace: options.namespace,

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare/snapshot-filter.js

@@ -2,6 +2,7 @@ import { isRecord } from "../../../parsing.js";
 import { buildAgentBrowserResultCategoryDetails } from "../../../results/categories.js";
 import { buildSnapshotPresentation } from "../../../results/snapshot.js";
 import { extractRefSnapshotFromData } from "../../../session-page-state.js";
+import { redactSensitiveText } from "../../../runtime.js";
 import { collectScrollPositionSnapshot } from "../diagnostics.js";
 import { buildSessionDetailFields, runSessionCommandData } from "../session-state.js";
 function parseSnapshotFilterRequest(commandTokens) {
@@ -42,6 +43,116 @@ function parseSnapshotFilterRequest(commandTokens) {
         return undefined;
     return { cleanArgs, diff, role, search, viewport };
 }
+const RENDERED_TEXT_SEARCH_MAX_MATCHES = 8;
+function buildRenderedTextSearchEval(search) {
+    return `(() => {
+  const query = ${JSON.stringify(search.trim().toLowerCase())};
+  const limit = ${RENDERED_TEXT_SEARCH_MAX_MATCHES};
+  const normalize = (value) => String(value ?? "").replace(/\\s+/g, " ").trim();
+  const attributeTextOf = (element) => [element.getAttribute("aria-label"), element.getAttribute("title"), element.getAttribute("placeholder")].filter(Boolean).join(" ");
+  const searchableTextOf = (element) => normalize([attributeTextOf(element), element.textContent].filter(Boolean).join(" "));
+  const renderedTextOf = (element) => normalize([attributeTextOf(element), element instanceof HTMLElement ? element.innerText : element.textContent].filter(Boolean).join(" "));
+  const isRendered = (element) => {
+    if (!(element instanceof Element) || element.getClientRects().length === 0) return false;
+    const visibility = getComputedStyle(element).visibility;
+    if (visibility === "hidden" || visibility === "collapse") return false;
+    for (let current = element; current; current = current.parentElement) {
+      if (Number(getComputedStyle(current).opacity) === 0) return false;
+    }
+    return true;
+  };
+  const validationPattern = /(?:^|[-_\\s])(?:error|invalid|validation|warning)(?:$|[-_\\s])/i;
+  const validationAncestor = (element) => {
+    for (let current = element; current && current !== document.body; current = current.parentElement) {
+      const role = current.getAttribute("role");
+      const live = current.getAttribute("aria-live");
+      const descriptor = [current.id, current.className, current.getAttribute("data-testid")].map(normalize).join(" ");
+      if (["alert", "alertdialog", "status"].includes(role || "") || current.getAttribute("aria-invalid") === "true" || (live && live !== "off") || validationPattern.test(descriptor)) return current;
+    }
+    return null;
+  };
+  const candidates = Array.from(document.querySelectorAll("body *")).filter((element) => searchableTextOf(element).toLowerCase().includes(query));
+  const candidateSet = new Set(candidates);
+  const minimal = candidates.filter((element) => !Array.from(element.children).some((child) => candidateSet.has(child)));
+  const rendered = minimal.filter((element) => isRendered(element) && renderedTextOf(element).toLowerCase().includes(query));
+  const matches = rendered.map((element, index) => {
+    const semantic = validationAncestor(element);
+    const source = semantic || element;
+    const text = renderedTextOf(element);
+    const matchIndex = text.toLowerCase().indexOf(query);
+    const start = Math.max(0, matchIndex - 80);
+    const snippet = text.slice(start, start + 240);
+    const rect = element.getBoundingClientRect();
+    const name = normalize(element.getAttribute("aria-label") || element.getAttribute("title") || element.getAttribute("placeholder")) || undefined;
+    return {
+      index,
+      kind: semantic ? "validation" : "text",
+      name,
+      offscreen: rect.bottom < 0 || rect.right < 0 || rect.top > innerHeight || rect.left > innerWidth,
+      role: source.getAttribute("role") || undefined,
+      tagName: element.tagName.toLowerCase(),
+      text: snippet,
+    };
+  }).sort((left, right) => (left.kind === right.kind ? left.index - right.index : left.kind === "validation" ? -1 : 1));
+  const unique = [];
+  const seen = new Set();
+  for (const match of matches) {
+    const key = [match.kind, match.role, match.name, match.text].join("\\n");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const { index, ...visible } = match;
+    unique.push(visible);
+  }
+  return { matches: unique.slice(0, limit), totalMatches: unique.length, truncated: unique.length > limit };
+})()`;
+}
+function extractRenderedTextSearchResult(data) {
+    const result = isRecord(data) && isRecord(data.result) ? data.result : data;
+    if (!isRecord(result) || !Array.isArray(result.matches))
+        return undefined;
+    const matches = result.matches.flatMap((value) => {
+        if (!isRecord(value) || (value.kind !== "text" && value.kind !== "validation") || typeof value.offscreen !== "boolean" || typeof value.tagName !== "string" || typeof value.text !== "string")
+            return [];
+        return [{
+                kind: value.kind,
+                ...(typeof value.name === "string" ? { name: redactSensitiveText(value.name) } : {}),
+                offscreen: value.offscreen,
+                ...(typeof value.role === "string" ? { role: value.role } : {}),
+                tagName: value.tagName,
+                text: redactSensitiveText(value.text),
+            }];
+    }).slice(0, RENDERED_TEXT_SEARCH_MAX_MATCHES);
+    const totalMatches = typeof result.totalMatches === "number" && Number.isInteger(result.totalMatches) && result.totalMatches >= matches.length ? result.totalMatches : matches.length;
+    return { matches, totalMatches, truncated: result.truncated === true || totalMatches > matches.length };
+}
+function attachRenderedTextMatchRefs(matches, snapshotData) {
+    if (!isRecord(snapshotData) || !isRecord(snapshotData.refs))
+        return matches;
+    const refs = snapshotData.refs;
+    return matches.map((match) => {
+        if (!match.name)
+            return match;
+        const normalizedName = match.name.replace(/\s+/g, " ").trim().toLowerCase();
+        const candidates = Object.entries(refs).filter(([, value]) => {
+            if (!isRecord(value) || typeof value.name !== "string")
+                return false;
+            const nameMatches = value.name.replace(/\s+/g, " ").trim().toLowerCase() === normalizedName;
+            return nameMatches && (!match.role || typeof value.role !== "string" || value.role.toLowerCase() === match.role.toLowerCase());
+        });
+        return candidates.length === 1 ? { ...match, ref: candidates[0][0] } : match;
+    });
+}
+function formatRenderedTextSearchMatches(result) {
+    if (!result || result.matches.length === 0)
+        return undefined;
+    const lines = result.matches.map((match) => {
+        const context = [match.kind === "validation" ? "validation" : undefined, match.offscreen ? "outside viewport" : undefined, match.role, match.tagName, match.ref ? `@${match.ref}` : undefined].filter(Boolean).join(", ");
+        return `- ${JSON.stringify(match.text)}${context ? ` (${context})` : ""}`;
+    });
+    if (result.truncated)
+        lines.push(`- ... (${result.totalMatches - result.matches.length} additional rendered-text matches omitted)`);
+    return ["Rendered page text matches:", ...lines].join("\n");
+}
 function buildSnapshotDiff(previous, current) {
     if (!current)
         return undefined;
@@ -113,6 +224,11 @@ export async function trySnapshotFilter(options) {
     const filtered = request.role || request.search ? filterSnapshotData(snapshotData, request) : isRecord(snapshotData) ? { data: snapshotData, matchedRefs: isRecord(snapshotData.refs) ? Object.keys(snapshotData.refs).length : 0, totalLines: typeof snapshotData.snapshot === "string" ? snapshotData.snapshot.split(/\r?\n/).filter((line) => line.length > 0).length : 0, totalRefs: isRecord(snapshotData.refs) ? Object.keys(snapshotData.refs).length : 0, visibleLines: typeof snapshotData.snapshot === "string" ? snapshotData.snapshot.split(/\r?\n/).filter((line) => line.length > 0).length : 0 } : undefined;
     if (!filtered)
         return undefined;
+    const renderedTextSearch = request.search
+        ? extractRenderedTextSearchResult(await runSessionCommandData({ args: ["eval", "--stdin"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal, stdin: buildRenderedTextSearchEval(request.search) }))
+        : undefined;
+    if (renderedTextSearch)
+        renderedTextSearch.matches = attachRenderedTextMatchRefs(renderedTextSearch.matches, snapshotData);
     const viewport = request.viewport ? await collectScrollPositionSnapshot({ cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal }) : undefined;
     const fullSnapshot = extractRefSnapshotFromData(snapshotData);
     const diff = request.diff ? buildSnapshotDiff(options.previousRefSnapshot, fullSnapshot) : undefined;
@@ -126,7 +242,8 @@ export async function trySnapshotFilter(options) {
             : "Snapshot viewport metadata collected.";
     const viewportText = viewport ? `Viewport: ${viewport.innerWidth}×${viewport.innerHeight}, scroll ${viewport.scrollX},${viewport.scrollY}, document ${viewport.scrollWidth}×${viewport.scrollHeight}, sampled scroll containers ${viewport.containers.length}/${viewport.containerCount}.` : undefined;
     const diffText = diff && (request.role || request.search) ? diff.summary : undefined;
-    const prefix = [summary, diffText, viewportText].filter((line) => line !== undefined).join("\n");
+    const renderedTextSearchText = formatRenderedTextSearchMatches(renderedTextSearch);
+    const prefix = [summary, renderedTextSearchText, diffText, viewportText].filter((line) => line !== undefined).join("\n\n");
     if (presentation.content[0]?.type === "text")
         presentation.content[0] = { ...presentation.content[0], text: `${prefix}\n\n${presentation.content[0].text}` };
     return {
@@ -146,7 +263,7 @@ export async function trySnapshotFilter(options) {
                 refSnapshot: fullSnapshot,
                 sessionMode: options.sessionMode,
                 snapshotDiff: diff,
-                snapshotFilter: request.role || request.search ? { cleanArgs: request.cleanArgs, matchedRefs: filtered.matchedRefs, role: request.role, search: request.search, totalLines: filtered.totalLines, totalRefs: filtered.totalRefs, visibleLines: filtered.visibleLines } : undefined,
+                snapshotFilter: request.role || request.search ? { cleanArgs: request.cleanArgs, matchedRefs: filtered.matchedRefs, renderedTextMatches: renderedTextSearch?.matches, renderedTextTotalMatches: renderedTextSearch?.totalMatches, renderedTextTruncated: renderedTextSearch?.truncated, role: request.role, search: request.search, totalLines: filtered.totalLines, totalRefs: filtered.totalRefs, visibleLines: filtered.visibleLines } : undefined,
                 snapshotViewport: viewport,
                 ...buildAgentBrowserResultCategoryDetails({ args: options.effectiveArgs, command: "snapshot", succeeded: true }),
                 ...buildSessionDetailFields(options.sessionName, options.usedImplicitSession, options.namespace, options.managedSessionRestoreDisabled()),

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare/wait-timeouts.js

@@ -1,7 +1,7 @@
 import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS } from "../../../argv-grammar.js";
 import { isOpenNavigationCommand } from "../../../command-taxonomy.js";
 import { getAgentBrowserProcessTimeoutMs } from "../../../process.js";
-import { parseValidBatchStepEntries } from "../../batch-stdin.js";
+import { getUpstreamEffectiveBatchSteps } from "../../batch-stdin.js";
 const POSITIONAL_VALUE_FLAGS = new Set([...VALUE_FLAGS, "--llms"]);
 const COMMAND_PROCESS_TIMEOUT_GRACE_MS = 5_000;
 function parseMillisecondsToken(token) {
@@ -12,7 +12,8 @@ function parseMillisecondsToken(token) {
     return Number.isSafeInteger(parsed) ? parsed : undefined;
 }
 function findCommandTimeoutMs(commandTokens) {
-    if (commandTokens[0] !== "wait" && commandTokens[0] !== "read")
+    const [command, subcommand] = commandTokens;
+    if (command !== "wait" && command !== "read" && !(command === "webmcp" && ["invoke", "result"].includes(subcommand ?? "")))
         return undefined;
     for (let index = 1; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
@@ -73,11 +74,11 @@ function findCommandTimeoutBudgetMs(commandTokens, stdin, activePageUrl) {
     const directTimeout = commandTimeoutBudgetMs(commandTokens, activePageUrl);
     if (directTimeout !== undefined)
         return directTimeout;
-    if (commandTokens[0] !== "batch" || stdin === undefined)
+    if (commandTokens[0] !== "batch")
         return undefined;
     let batchTimeoutTotal = 0;
     let batchPageUrl = activePageUrl;
-    for (const { step } of parseValidBatchStepEntries(stdin)) {
+    for (const step of getUpstreamEffectiveBatchSteps(commandTokens, stdin)) {
         batchTimeoutTotal += commandTimeoutBudgetMs(step, batchPageUrl) ?? 0;
         if (isOpenNavigationCommand(step[0]))
             batchPageUrl = findFirstPositionalArgument(step);
@@ -87,10 +88,10 @@ function findCommandTimeoutBudgetMs(commandTokens, stdin, activePageUrl) {
 export function commandTimeoutNeedsActivePageUrl(commandTokens, stdin) {
     if (commandTokens[0] === "read")
         return findCommandTimeoutMs(commandTokens) !== undefined && readUsesActivePageUrl(commandTokens);
-    if (commandTokens[0] !== "batch" || stdin === undefined)
+    if (commandTokens[0] !== "batch")
         return false;
     let hasKnownPageUrl = false;
-    for (const { step } of parseValidBatchStepEntries(stdin)) {
+    for (const step of getUpstreamEffectiveBatchSteps(commandTokens, stdin)) {
         if (isOpenNavigationCommand(step[0]) && findFirstPositionalArgument(step))
             hasKnownPageUrl = true;
         if (!hasKnownPageUrl && findCommandTimeoutMs(step) !== undefined && step[0] === "read" && readUsesActivePageUrl(step))