pi-agent-browser-native 0.9.3 → 0.9.4

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-native-phase.js

@@ -0,0 +1,93 @@
+import { parseNativeOutput, repairOutputScreenshots, resolveDispatchedCommands, } from "./process-output-native.js";
+import { foldReadConfirmations } from "./process-output-confirmation.js";
+import { observeCloseLifecycle, redactNativeEnvelope, classifyNativeExecution, observeInterruptedMutation, applyCloseAndTraceLifecycle, } from "./process-output-lifecycle.js";
+function createNativeOutputPhase(input, ownership) {
+    return {
+        input,
+        artifactManifest: ownership.artifactManifest,
+        batchCommandSteps: [],
+        batchScreenshotArtifactRequests: undefined,
+        browserIndependentRead: false,
+        closeAllApplied: false,
+        confirmedCommand: undefined,
+        confirmedData: undefined,
+        confirmedEffects: [],
+        destinationTransition: false,
+        directClose: false,
+        directCloseAllRequested: false,
+        dispatchedCommands: [],
+        inspectionText: undefined,
+        nativeCommandMayHaveExecuted: false,
+        nestedBatchClose: undefined,
+        nestedBatchClosed: false,
+        nestedBatchClosesAll: false,
+        nestedBatchRemainsActive: false,
+        networkRoutesBySession: ownership.networkRoutesBySession,
+        parseError: undefined,
+        parseFailureOutput: {},
+        parseSucceeded: false,
+        parsed: {},
+        persistentArtifactStore: undefined,
+        plainTextInspection: false,
+        plainTextUpgrade: false,
+        presentationEnvelope: undefined,
+        processSucceeded: false,
+        rawCloseStatePath: undefined,
+        readConfirmation: undefined,
+        readConfirmationEvent: undefined,
+        recordingStopRecovery: undefined,
+        screenshotArtifactRequest: undefined,
+        sessionStateKey: undefined,
+        succeeded: false,
+        textOutput: false,
+        unobservedMutation: false,
+    };
+}
+export async function observeNativeEffects(input, ownership) {
+    const draft = createNativeOutputPhase(input, ownership);
+    await parseNativeOutput(draft);
+    await repairOutputScreenshots(draft);
+    resolveDispatchedCommands(draft);
+    foldReadConfirmations(draft);
+    observeCloseLifecycle(draft);
+    redactNativeEnvelope(draft);
+    classifyNativeExecution(draft);
+    observeInterruptedMutation(draft);
+    applyCloseAndTraceLifecycle(draft);
+    return {
+        artifactManifest: draft.artifactManifest,
+        batchCommandSteps: draft.batchCommandSteps,
+        batchScreenshotArtifactRequests: draft.batchScreenshotArtifactRequests,
+        browserIndependentRead: draft.browserIndependentRead,
+        closeAllApplied: draft.closeAllApplied,
+        confirmedCommand: draft.confirmedCommand,
+        confirmedData: draft.confirmedData,
+        confirmedEffects: draft.confirmedEffects,
+        destinationTransition: draft.destinationTransition,
+        directClose: draft.directClose,
+        dispatchedCommands: draft.dispatchedCommands,
+        inspectionText: draft.inspectionText,
+        nativeCommandMayHaveExecuted: draft.nativeCommandMayHaveExecuted,
+        nestedBatchClose: draft.nestedBatchClose,
+        nestedBatchClosed: draft.nestedBatchClosed,
+        nestedBatchRemainsActive: draft.nestedBatchRemainsActive,
+        networkRoutesBySession: draft.networkRoutesBySession,
+        parseError: draft.parseError,
+        parseFailureOutput: draft.parseFailureOutput,
+        parseSucceeded: draft.parseSucceeded,
+        persistentArtifactStore: draft.persistentArtifactStore,
+        plainTextInspection: draft.plainTextInspection,
+        plainTextUpgrade: draft.plainTextUpgrade,
+        presentationEnvelope: draft.presentationEnvelope,
+        processSucceeded: draft.processSucceeded,
+        rawCloseStatePath: draft.rawCloseStatePath,
+        readConfirmation: draft.readConfirmation,
+        readConfirmationEvent: draft.readConfirmationEvent,
+        recordingStopRecovery: draft.recordingStopRecovery,
+        screenshotArtifactRequest: draft.screenshotArtifactRequest,
+        sessionStateKey: draft.sessionStateKey,
+        succeeded: draft.succeeded,
+        textOutput: draft.textOutput,
+        unobservedMutation: draft.unobservedMutation,
+    };
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-native.js

@@ -0,0 +1,113 @@
+import { observeNativeWebMcp } from "../../webmcp-observation.js";
+import { parseArgvDescriptor } from "../../argv-descriptor.js";
+import { needsManagedSession } from "../../command-policy.js";
+import { getAgentBrowserSessionIdentityKey, getBooleanFlagValue } from "../../argv-grammar.js";
+import { parseAgentBrowserEnvelope } from "../../results/envelope.js";
+import { isRecord } from "../../parsing.js";
+import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
+import { getPersistentSessionArtifactStore } from "./session-state.js";
+import { repairScreenshotData } from "./prepare.js";
+import { recoverRecordingStop } from "./recording-recovery.js";
+import { isStringArray } from "../../results/presentation/content.js";
+export async function parseNativeOutput(draft) {
+    draft.persistentArtifactStore = getPersistentSessionArtifactStore(draft.input.ctx);
+    draft.plainTextUpgrade =
+        !draft.input.prepared.executionPlan.plainTextInspection &&
+            draft.input.prepared.executionPlan.commandInfo.command === "upgrade" &&
+            !needsManagedSession(parseArgvDescriptor(draft.input.prepared.runtimeToolArgs));
+    draft.textOutput = getBooleanFlagValue(draft.input.prepared.processArgs, "--json") === false;
+    draft.parsed = await parseAgentBrowserEnvelope({
+        stdout: draft.input.processResult.stdout,
+        stdoutPath: draft.input.processResult.stdoutSpillPath,
+        plainText: draft.plainTextUpgrade,
+        textOutput: draft.textOutput,
+    });
+    observeNativeWebMcp(draft.parsed.envelope?.data);
+    draft.parseError = draft.parsed.parseError;
+    draft.recordingStopRecovery = await recoverRecordingStop({
+        modelVisible: draft.input.modelVisible,
+        artifactManifest: draft.artifactManifest,
+        artifactRunStartedAtMs: draft.input.artifactRunStartedAtMs,
+        commandTokens: draft.input.prepared.commandTokens,
+        cwd: draft.input.cwd,
+        envelope: draft.parsed.envelope,
+        namespace: draft.input.prepared.executionPlan.namespace,
+        parseError: draft.parseError,
+        processResult: draft.input.processResult,
+        reservation: draft.input.prepared.executionPlan.sessionName !== undefined &&
+            draft.input.prepared.executionPlan.sessionName.length > 0
+            ? draft.input.state.activeRecordingReservations?.get(getAgentBrowserSessionIdentityKey(draft.input.prepared.executionPlan.sessionName, draft.input.prepared.executionPlan.namespace))
+            : undefined,
+        sessionName: draft.input.prepared.executionPlan.sessionName,
+        signal: draft.input.signal,
+        stdin: draft.input.prepared.runtimeToolStdin,
+    });
+    draft.presentationEnvelope = draft.recordingStopRecovery?.envelope ?? draft.parsed.envelope;
+}
+export async function repairOutputScreenshots(draft) {
+    const repairedScreenshot = await repairScreenshotArtifact({
+        cwd: draft.input.cwd,
+        envelope: draft.presentationEnvelope,
+        request: draft.input.prepared.preparedArgs.screenshotPathRequest,
+    });
+    draft.presentationEnvelope = repairedScreenshot.envelope;
+    const repairedBatchScreenshots = await repairBatchScreenshotArtifacts({
+        cwd: draft.input.cwd,
+        envelope: draft.presentationEnvelope,
+        requests: draft.input.prepared.preparedArgs.batchScreenshotPathRequests,
+    });
+    draft.presentationEnvelope = repairedBatchScreenshots.envelope;
+    draft.screenshotArtifactRequest = repairedScreenshot.request;
+    draft.batchScreenshotArtifactRequests = repairedBatchScreenshots.requests;
+}
+export function resolveDispatchedCommands(draft) {
+    draft.batchCommandSteps =
+        draft.input.prepared.executionPlan.commandInfo.command === "batch"
+            ? getUpstreamEffectiveBatchSteps(draft.input.prepared.commandTokens, draft.input.prepared.runtimeToolStdin)
+            : [];
+    if (draft.input.prepared.executionPlan.commandInfo.command !== "batch") {
+        draft.dispatchedCommands = [draft.input.prepared.commandTokens];
+        return;
+    }
+    const data = draft.presentationEnvelope?.data;
+    if (!Array.isArray(data)) {
+        draft.dispatchedCommands = draft.batchCommandSteps;
+        return;
+    }
+    draft.dispatchedCommands = data.flatMap((row, index) => {
+        if (!isRecord(row)) {
+            return [];
+        }
+        const command = isStringArray(row.command)
+            ? row.command
+            : (draft.batchCommandSteps[index] ?? []);
+        return [command];
+    });
+}
+async function repairScreenshotArtifact(options) {
+    const { cwd, envelope, request } = options;
+    if (!request || !envelope || !isRecord(envelope.data)) {
+        return { envelope, request };
+    }
+    const repaired = await repairScreenshotData({ cwd, data: envelope.data, request });
+    return { envelope: { ...envelope, data: repaired.data }, request: repaired.request };
+}
+async function repairBatchScreenshotArtifacts(options) {
+    const { cwd, envelope, requests } = options;
+    if (!envelope ||
+        !Array.isArray(envelope.data) ||
+        !(requests?.some((request) => request !== undefined) === true)) {
+        return { envelope, requests };
+    }
+    const repairedRequests = [];
+    const repairedData = await Promise.all(envelope.data.map(async (item, index) => {
+        const request = requests[index];
+        if (!request || !isRecord(item) || !isRecord(item.result)) {
+            return item;
+        }
+        const repaired = await repairScreenshotData({ cwd, data: item.result, request });
+        repairedRequests[index] = repaired.request;
+        return { ...item, result: repaired.data };
+    }));
+    return { envelope: { ...envelope, data: repairedData }, requests: repairedRequests };
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-navigation-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-navigation.js

@@ -0,0 +1,316 @@
+import { isStringArray } from "../../results/presentation/content.js";
+import { isNavigationObservableCommandName, isOpenNavigationCommand, isUnverifiedPageTransitionCommand, } from "../../command-taxonomy.js";
+import { OPEN_RESULT_TAB_CORRECTION_FLAGS } from "../../launch-scoped-flags.js";
+import { getResultingPageTargetState, commandRequiresLivePageVerification, } from "../../page-target-validation.js";
+import { detectConfirmationRequired } from "../../results/confirmation.js";
+import { shouldCaptureSemanticActionNavigationSummary } from "../../results/presentation/semantic-action.js";
+import { commandExplicitlyTargetsAboutBlank, deriveSessionTabTarget, extractSessionTabTargetFromBatchResults, extractSessionTabTargetFromCommandData, normalizeSessionTabTarget, } from "../../session-page-state.js";
+import { isRecord } from "../../parsing.js";
+import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
+import { applyOpenResultTabCorrection, collectOpenResultTabCorrection, collectSessionTabTarget, extractStringResultField, mergeNavigationSummaryIntoData, shouldCaptureNavigationSummary, } from "./session-state.js";
+import { collectClickDispatchDiagnostic } from "./click-dispatch.js";
+import { collectNavigationSummary } from "./diagnostics.js";
+export async function verifyClickDispatch(draft) {
+    if (!draft.succeeded || !draft.input.prepared.clickDispatchProbe) {
+        return;
+    }
+    draft.clickDispatchDiagnostic = await collectClickDispatchDiagnostic({
+        cwd: draft.input.cwd,
+        namespace: draft.input.prepared.executionPlan.namespace,
+        probe: draft.input.prepared.clickDispatchProbe,
+        sessionName: draft.input.prepared.executionPlan.sessionName,
+        signal: draft.input.signal,
+    });
+    if (draft.clickDispatchDiagnostic) {
+        draft.succeeded = false;
+        draft.presentationEnvelope = {
+            ...draft.presentationEnvelope,
+            error: draft.clickDispatchDiagnostic.summary,
+            success: false,
+        };
+    }
+}
+function resolveResultingPageState(draft) {
+    const { prepared, state } = draft.input;
+    draft.tabTransition =
+        draft.confirmedEffects.some((effect) => effect.command === "tab") ||
+            draft.dispatchedCommands.some((step) => {
+                const tokens = extractUpstreamCommandTokens(step);
+                const command = tokens[0];
+                const subcommand = tokens.at(1);
+                return command === "tab" && subcommand !== undefined && subcommand !== "list";
+            });
+    const preservePriorTarget = !draft.nativeCommandMayHaveExecuted ||
+        detectConfirmationRequired(draft.presentationEnvelope?.data) !== undefined ||
+        state.sessionPageState.get(draft.sessionStateKey).tabReopenPending === true;
+    draft.resultingPageState = preservePriorTarget
+        ? {
+            currentPageUrl: prepared.priorSessionTabTarget?.url,
+            pageTargetMayHaveChanged: false,
+            pageUrlUnknown: prepared.priorSessionTabTargetUnknown === true,
+        }
+        : getResultingPageTargetState({
+            args: prepared.executionPlan.effectiveArgs,
+            executedBatchSteps: draft.dispatchedCommands,
+            batchResults: draft.presentationEnvelope?.data,
+            currentPageUrl: prepared.priorSessionTabTarget?.url,
+            pageUrlUnknown: prepared.priorSessionTabTargetUnknown === true,
+        });
+}
+function hasNativeNavigationEvidence(draft) {
+    const { commandInfo } = draft.input.prepared.executionPlan;
+    return (draft.confirmedEffects.some((effect) => shouldCaptureNavigationSummary(effect.command, effect.data)) ||
+        shouldCaptureNavigationSummary(commandInfo.command, draft.presentationEnvelope?.data, commandInfo.subcommand) ||
+        (commandInfo.command === "batch" &&
+            draft.dispatchedCommands.some(([command, subcommand]) => isNavigationObservableCommandName(command, subcommand))));
+}
+function navigationObservationRequested(draft) {
+    const { prepared } = draft.input;
+    return (hasNativeNavigationEvidence(draft) ||
+        shouldCaptureSemanticActionNavigationSummary(prepared.compiledSemanticAction, draft.presentationEnvelope?.data) ||
+        commandRequiresLivePageVerification(prepared.executionPlan.effectiveArgs, prepared.runtimeToolStdin) ||
+        draft.destinationTransition ||
+        draft.tabTransition);
+}
+function canObserveSuccessfulNavigation(draft) {
+    const observedSuccess = draft.succeeded ||
+        (draft.processSucceeded && draft.confirmedEffects.some((effect) => effect.succeeded));
+    return (observedSuccess &&
+        draft.readConfirmation?.state !== "pending" &&
+        !draft.nestedBatchClosed &&
+        !draft.directClose);
+}
+function hasFailedPageTransition(draft) {
+    return (draft.confirmedEffects.some((effect) => isUnverifiedPageTransitionCommand(effect.command)) ||
+        draft.dispatchedCommands.some((step) => {
+            const [command, subcommand] = extractUpstreamCommandTokens(step);
+            return ((draft.input.prepared.executionPlan.commandInfo.command === "batch" &&
+                isOpenNavigationCommand(command)) ||
+                isUnverifiedPageTransitionCommand(command, subcommand));
+        }));
+}
+function canReverifyFailedNavigation(draft) {
+    if (draft.succeeded ||
+        draft.navigationSummary !== undefined ||
+        draft.readConfirmation?.state === "pending") {
+        return false;
+    }
+    if (processCannotVerifyPage(draft)) {
+        return false;
+    }
+    return !draft.nestedBatchClosed && !draft.directClose && hasFailedPageTransition(draft);
+}
+function mergeObservedNavigation(draft) {
+    if (draft.textOutput || !draft.navigationSummary || !draft.presentationEnvelope) {
+        return;
+    }
+    if (draft.input.prepared.executionPlan.commandInfo.command === "eval" ||
+        Array.isArray(draft.presentationEnvelope.data)) {
+        return;
+    }
+    draft.presentationEnvelope = {
+        ...draft.presentationEnvelope,
+        data: mergeNavigationSummaryIntoData(draft.presentationEnvelope.data, draft.navigationSummary),
+    };
+}
+export async function observeNavigationTarget(draft) {
+    resolveResultingPageState(draft);
+    const { prepared, cwd, signal } = draft.input;
+    if (canObserveSuccessfulNavigation(draft) && navigationObservationRequested(draft)) {
+        draft.navigationSummary = await collectNavigationSummary({
+            cwd,
+            namespace: prepared.executionPlan.namespace,
+            priorTarget: prepared.priorSessionTabTarget,
+            reusePriorTitle: !draft.tabTransition,
+            sessionName: prepared.executionPlan.sessionName,
+            signal,
+        });
+    }
+    // A failed transition may have changed the page. Its live URL cannot make prior refs valid.
+    if (canReverifyFailedNavigation(draft)) {
+        draft.navigationSummary = await collectNavigationSummary({
+            cwd,
+            namespace: prepared.executionPlan.namespace,
+            priorTarget: prepared.priorSessionTabTarget,
+            sessionName: prepared.executionPlan.sessionName,
+            signal,
+        });
+        draft.failedTransitionReverification = draft.navigationSummary !== undefined;
+    }
+    mergeObservedNavigation(draft);
+}
+export async function correctRestoredOpenTab(draft) {
+    const { prepared, cwd, signal } = draft.input;
+    const sessionName = prepared.executionPlan.sessionName;
+    if (!draft.succeeded || sessionName === undefined || sessionName.length === 0) {
+        return;
+    }
+    if (!prepared.executionPlan.startupScopedFlags.some((flag) => OPEN_RESULT_TAB_CORRECTION_FLAGS.has(flag)) ||
+        !isOpenNavigationCommand(prepared.executionPlan.commandInfo.command) ||
+        commandExplicitlyTargetsAboutBlank(prepared.commandTokens)) {
+        return;
+    }
+    const correction = await collectOpenResultTabCorrection({
+        cwd,
+        namespace: prepared.executionPlan.namespace,
+        sessionName,
+        signal,
+        targetTitle: extractStringResultField(draft.presentationEnvelope?.data, "title"),
+        targetUrl: extractStringResultField(draft.presentationEnvelope?.data, "url"),
+    });
+    if (correction) {
+        draft.openResultTabCorrection = await applyOpenResultTabCorrection({
+            correction,
+            cwd,
+            namespace: prepared.executionPlan.namespace,
+            sessionName,
+            signal,
+        });
+    }
+}
+function verifiesCurrentUrl(draft) {
+    const { prepared } = draft.input;
+    const { commandInfo } = prepared.executionPlan;
+    return ((commandInfo.command === "get" && commandInfo.subcommand === "url") ||
+        (draft.readConfirmationEvent?.state === "cleared" &&
+            prepared.readConfirmation?.source === "native-guarded-action" &&
+            extractSessionTabTargetFromCommandData(prepared.commandTokens, draft.presentationEnvelope?.data) !== undefined));
+}
+function hasFailedWebMcpSettlement(draft) {
+    const { prepared } = draft.input;
+    const { commandInfo } = prepared.executionPlan;
+    return (prepared.priorSessionTabTargetUnknown === true &&
+        ((!draft.succeeded && isWebMcpSettlementCommand(commandInfo.command, commandInfo.subcommand)) ||
+            (commandInfo.command === "batch" &&
+                batchHasFailedWebMcpSettlement(draft.presentationEnvelope?.data))));
+}
+export function observeWebMcpTarget(draft) {
+    draft.trustsReportedPageTarget =
+        !draft.resultingPageState.pageUrlUnknown || verifiesCurrentUrl(draft);
+    const { commandInfo } = draft.input.prepared.executionPlan;
+    const pending = isPendingWebMcpMutation(commandInfo.command, commandInfo.subcommand, draft.presentationEnvelope?.data) ||
+        (commandInfo.command === "batch" &&
+            batchHasPendingWebMcpMutation(draft.presentationEnvelope?.data));
+    draft.unsettledWebMcpMutation = pending || hasFailedWebMcpSettlement(draft);
+}
+function observedPageTarget(draft, data) {
+    if (draft.unsettledWebMcpMutation ||
+        (draft.unobservedMutation && !draft.failedTransitionReverification)) {
+        return;
+    }
+    const navigation = normalizeSessionTabTarget(draft.navigationSummary);
+    if (navigation) {
+        return navigation;
+    }
+    if (!draft.trustsReportedPageTarget) {
+        return;
+    }
+    const batchTarget = extractSessionTabTargetFromBatchResults(data);
+    if (batchTarget) {
+        return batchTarget;
+    }
+    return draft.succeeded
+        ? extractSessionTabTargetFromCommandData(draft.input.prepared.commandTokens, data)
+        : undefined;
+}
+function reportedPageTarget(draft, data) {
+    const { prepared } = draft.input;
+    if (prepared.executionPlan.commandInfo.command === "batch") {
+        return extractSessionTabTargetFromBatchResults(data);
+    }
+    if (prepared.commandTokens[0] === "tab" && prepared.commandTokens[1] === "close") {
+        return;
+    }
+    return extractSessionTabTargetFromCommandData(prepared.commandTokens, data);
+}
+async function resolveObservedTargetIdentity(draft, data) {
+    if (!draft.observedSessionTabTarget ||
+        draft.readConfirmation?.state === "pending" ||
+        draft.browserIndependentRead ||
+        draft.nestedBatchClosed ||
+        draft.directClose) {
+        return;
+    }
+    const reported = reportedPageTarget(draft, data);
+    if (reported?.targetId !== undefined && reported.targetId.length > 0) {
+        draft.observedSessionTabTarget = {
+            ...draft.observedSessionTabTarget,
+            targetId: reported.targetId,
+        };
+        return;
+    }
+    draft.observedSessionTabTarget = await collectSessionTabTarget({
+        cwd: draft.input.cwd,
+        namespace: draft.input.prepared.executionPlan.namespace,
+        sessionName: draft.input.prepared.executionPlan.sessionName,
+        signal: draft.input.signal,
+        target: draft.observedSessionTabTarget,
+    });
+}
+function fallbackPageTarget(draft, data) {
+    // Window/diff URL2 is intent, not redirect evidence.
+    if (draft.resultingPageState.pageTargetMayHaveChanged) {
+        return draft.succeeded && !draft.destinationTransition
+            ? normalizeSessionTabTarget({ url: draft.resultingPageState.currentPageUrl })
+            : undefined;
+    }
+    const { prepared } = draft.input;
+    return deriveSessionTabTarget({
+        command: draft.directClose ? "close" : prepared.executionPlan.commandInfo.command,
+        data,
+        navigationSummary: draft.navigationSummary,
+        previousTarget: prepared.priorSessionTabTarget,
+        subcommand: prepared.executionPlan.commandInfo.subcommand,
+    });
+}
+export async function resolveObservedPageTarget(draft) {
+    const data = draft.textOutput ? undefined : draft.presentationEnvelope?.data;
+    draft.observedSessionTabTarget = observedPageTarget(draft, data);
+    await resolveObservedTargetIdentity(draft, data);
+    draft.currentSessionTabTarget = draft.observedSessionTabTarget;
+    if (!draft.currentSessionTabTarget &&
+        draft.nestedBatchClose === undefined &&
+        !draft.unobservedMutation) {
+        draft.currentSessionTabTarget = fallbackPageTarget(draft, data);
+    }
+}
+function isPendingWebMcpMutation(command, subcommand, data) {
+    return (command === "webmcp" &&
+        ["invoke", "result"].includes(subcommand ?? "") &&
+        isRecord(data) &&
+        data.status === "pending");
+}
+function isWebMcpSettlementCommand(command, subcommand) {
+    return command === "webmcp" && ["result", "cancel"].includes(subcommand ?? "");
+}
+function batchHasPendingWebMcpMutation(data) {
+    if (!Array.isArray(data)) {
+        return false;
+    }
+    return data.some((row) => {
+        if (!isRecord(row) || row.success === false || !isStringArray(row.command)) {
+            return false;
+        }
+        const [command, subcommand] = extractUpstreamCommandTokens(row.command);
+        return isPendingWebMcpMutation(command, subcommand, row.result);
+    });
+}
+function batchHasFailedWebMcpSettlement(data) {
+    if (!Array.isArray(data)) {
+        return false;
+    }
+    return data.some((row) => {
+        if (!isRecord(row) || row.success !== false || !isStringArray(row.command)) {
+            return false;
+        }
+        const [command, subcommand] = extractUpstreamCommandTokens(row.command);
+        return isWebMcpSettlementCommand(command, subcommand);
+    });
+}
+function processCannotVerifyPage(draft) {
+    const { processResult } = draft.input;
+    return (!processResult.agentBrowserStarted ||
+        !draft.nativeCommandMayHaveExecuted ||
+        processResult.aborted ||
+        processResult.timedOut);
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-ownership.js

@@ -0,0 +1,28 @@
+export function captureBrowserOutputOwnership(input) {
+    return {
+        artifactManifest: input.state.artifactManifest,
+        freshSessionOrdinal: input.state.freshSessionOrdinal,
+        managedSessionActive: input.state.managedSessionActive,
+        managedSessionCompatibilityWorkaround: input.state.managedSessionCompatibilityWorkaround,
+        managedSessionHeadedAutosaveDisabled: input.state.managedSessionHeadedAutosaveDisabled === true,
+        managedSessionHeadedAutosaveInterval: input.state.managedSessionHeadedAutosaveInterval,
+        managedSessionCwd: input.state.managedSessionCwd,
+        managedSessionName: input.state.managedSessionName,
+        managedSessionNamespace: input.state.managedSessionNamespace,
+        networkRoutesBySession: input.state.networkRoutesBySession,
+    };
+}
+export function buildOutputStatePatch(draft) {
+    return {
+        artifactManifest: draft.artifactManifest,
+        freshSessionOrdinal: draft.freshSessionOrdinal,
+        managedSessionActive: draft.managedSessionActive,
+        managedSessionCompatibilityWorkaround: draft.managedSessionCompatibilityWorkaround,
+        managedSessionHeadedAutosaveDisabled: draft.managedSessionHeadedAutosaveDisabled,
+        managedSessionHeadedAutosaveInterval: draft.managedSessionHeadedAutosaveInterval,
+        managedSessionCwd: draft.managedSessionCwd,
+        managedSessionName: draft.managedSessionName,
+        managedSessionNamespace: draft.managedSessionNamespace,
+        networkRoutesBySession: draft.networkRoutesBySession,
+    };
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output-page-phase-contracts.js

@@ -0,0 +1 @@
+export {};