pi-agent-browser-native 0.9.2 → 0.9.4

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

@@ -0,0 +1,115 @@
+import { observeFinalHelperConfirmation } from "./process-output-confirmation.js";
+import { reconcileOutputPinning } from "./process-output-refs.js";
+import { resolveManagedCloseTarget, inspectFailedFreshLaunch, applyManagedTransition, retireReplacedSession, } from "./process-output-managed.js";
+import { reconcileElectronHandoff } from "./process-output-electron.js";
+import { resolveOutputError } from "./process-output-presentation.js";
+import { commitObservedLifecycle } from "./process-output-receipts.js";
+function createLifecycleOutputPhase(input, native, page, ownership) {
+    return {
+        input,
+        aboutBlankSessionMismatch: page.aboutBlankSessionMismatch,
+        artifactManifest: native.artifactManifest,
+        closeAllApplied: native.closeAllApplied,
+        closeCommandSucceeded: false,
+        commandClosesSession: false,
+        confirmationFromHelper: page.confirmationFromHelper,
+        currentRefSnapshot: page.currentRefSnapshot,
+        currentRefSnapshotInvalidation: page.currentRefSnapshotInvalidation,
+        currentSessionTabTarget: page.currentSessionTabTarget,
+        directClose: page.directClose,
+        electronFailedConnectCleanup: undefined,
+        electronHandoff: undefined,
+        electronLaunchRecord: undefined,
+        errorText: undefined,
+        freshSessionOrdinal: ownership.freshSessionOrdinal,
+        managedCloseSessionName: undefined,
+        managedSessionActive: ownership.managedSessionActive,
+        managedSessionCompatibilityWorkaround: ownership.managedSessionCompatibilityWorkaround,
+        managedSessionCwd: ownership.managedSessionCwd,
+        managedSessionHeadedAutosaveDisabled: ownership.managedSessionHeadedAutosaveDisabled,
+        managedSessionHeadedAutosaveInterval: ownership.managedSessionHeadedAutosaveInterval,
+        managedSessionName: ownership.managedSessionName,
+        managedSessionNamespace: ownership.managedSessionNamespace,
+        managedSessionOutcome: undefined,
+        managedTransitionSucceeded: false,
+        nestedBatchClosed: page.nestedBatchClosed,
+        nestedBatchRemainsActive: native.nestedBatchRemainsActive,
+        networkRoutesBySession: page.networkRoutesBySession,
+        observedSessionTabTarget: page.observedSessionTabTarget,
+        openResultTabCorrection: page.openResultTabCorrection,
+        parseError: native.parseError,
+        parseSucceeded: native.parseSucceeded,
+        plainTextInspection: native.plainTextInspection,
+        plainTextUpgrade: native.plainTextUpgrade,
+        presentationEnvelope: page.presentationEnvelope,
+        priorManagedSessionActive: false,
+        priorManagedSessionCwd: "",
+        priorManagedSessionHeadedAutosaveInterval: undefined,
+        priorManagedSessionName: "",
+        priorManagedSessionNamespace: undefined,
+        processSucceeded: page.processSucceeded,
+        rawCloseStatePath: native.rawCloseStatePath,
+        readConfirmationEvent: page.readConfirmationEvent,
+        recordingStopRecovery: page.recordingStopRecovery,
+        replacedManagedSessionName: undefined,
+        resultHeadedManagedAutosaveDisabled: false,
+        resultHeadedManagedAutosaveInterval: undefined,
+        sessionStateKey: page.sessionStateKey,
+        sessionTabCorrection: page.sessionTabCorrection,
+        succeeded: page.succeeded,
+        textOutput: page.textOutput,
+        timeoutPartialProgress: page.timeoutPartialProgress,
+    };
+}
+export async function commitLifecycleEffects(input, native, page, ownership) {
+    const draft = createLifecycleOutputPhase(input, native, page, ownership);
+    resolveManagedCloseTarget(draft);
+    await inspectFailedFreshLaunch(draft);
+    applyManagedTransition(draft);
+    reconcileOutputPinning(draft);
+    await retireReplacedSession(draft);
+    await reconcileElectronHandoff(draft);
+    resolveOutputError(draft);
+    observeFinalHelperConfirmation(draft);
+    commitObservedLifecycle(draft);
+    return {
+        aboutBlankSessionMismatch: draft.aboutBlankSessionMismatch,
+        artifactManifest: draft.artifactManifest,
+        closeAllApplied: draft.closeAllApplied,
+        commandClosesSession: draft.commandClosesSession,
+        confirmationFromHelper: draft.confirmationFromHelper,
+        currentRefSnapshot: draft.currentRefSnapshot,
+        currentRefSnapshotInvalidation: draft.currentRefSnapshotInvalidation,
+        currentSessionTabTarget: draft.currentSessionTabTarget,
+        electronFailedConnectCleanup: draft.electronFailedConnectCleanup,
+        electronHandoff: draft.electronHandoff,
+        electronLaunchRecord: draft.electronLaunchRecord,
+        errorText: draft.errorText,
+        freshSessionOrdinal: draft.freshSessionOrdinal,
+        managedSessionActive: draft.managedSessionActive,
+        managedSessionCompatibilityWorkaround: draft.managedSessionCompatibilityWorkaround,
+        managedSessionCwd: draft.managedSessionCwd,
+        managedSessionHeadedAutosaveDisabled: draft.managedSessionHeadedAutosaveDisabled,
+        managedSessionHeadedAutosaveInterval: draft.managedSessionHeadedAutosaveInterval,
+        managedSessionName: draft.managedSessionName,
+        managedSessionNamespace: draft.managedSessionNamespace,
+        managedSessionOutcome: draft.managedSessionOutcome,
+        networkRoutesBySession: draft.networkRoutesBySession,
+        openResultTabCorrection: draft.openResultTabCorrection,
+        parseError: draft.parseError,
+        parseSucceeded: draft.parseSucceeded,
+        plainTextInspection: draft.plainTextInspection,
+        plainTextUpgrade: draft.plainTextUpgrade,
+        presentationEnvelope: draft.presentationEnvelope,
+        processSucceeded: draft.processSucceeded,
+        readConfirmationEvent: draft.readConfirmationEvent,
+        recordingStopRecovery: draft.recordingStopRecovery,
+        resultHeadedManagedAutosaveDisabled: draft.resultHeadedManagedAutosaveDisabled,
+        resultHeadedManagedAutosaveInterval: draft.resultHeadedManagedAutosaveInterval,
+        sessionStateKey: draft.sessionStateKey,
+        sessionTabCorrection: draft.sessionTabCorrection,
+        succeeded: draft.succeeded,
+        textOutput: draft.textOutput,
+        timeoutPartialProgress: draft.timeoutPartialProgress,
+    };
+}

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

@@ -0,0 +1,256 @@
+import { isStringArray } from "../../results/presentation/content.js";
+import { isBrowserIndependentRead } from "../../command-policy.js";
+import { deleteIdentityKeysInNamespace, isAgentBrowserSessionIdentityKeyInNamespace, } from "../../argv-grammar.js";
+import { batchHasSuccessfulCloseAll, getSuccessfulBatchCloseLifecycle, } from "../../batch-lifecycle.js";
+import { isCloseAllCommand, isPageMutationCommand, isWindowOrDiffPageTransitionCommand, } from "../../command-taxonomy.js";
+import { detectConfirmationRequired } from "../../results/confirmation.js";
+import { isRecord } from "../../parsing.js";
+import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
+import { isBrowserIndependentConfirmation } from "../../read-confirmation.js";
+import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
+import { commandChoosesSessionTabTarget, getSessionContextKey, updateTraceOwnerState, nativePolicyDefinitelyUnestablished, } from "./session-state.js";
+import { redactExactSensitiveValue } from "./final-result.js";
+export function observeCloseLifecycle(draft) {
+    draft.destinationTransition = draft.dispatchedCommands.some((step) => {
+        const [command, subcommand] = extractUpstreamCommandTokens(step);
+        return isWindowOrDiffPageTransitionCommand(command, subcommand);
+    });
+    draft.nestedBatchClose =
+        draft.input.prepared.executionPlan.commandInfo.command === "batch"
+            ? getSuccessfulBatchCloseLifecycle(draft.presentationEnvelope?.data, draft.batchCommandSteps)
+            : undefined;
+    draft.nestedBatchClosed = draft.nestedBatchClose?.endsClosed === true;
+    draft.nestedBatchRemainsActive = draft.nestedBatchClose?.endsClosed === false;
+    draft.nestedBatchClosesAll =
+        draft.input.prepared.executionPlan.commandInfo.command === "batch" &&
+            batchHasSuccessfulCloseAll(draft.presentationEnvelope?.data, draft.batchCommandSteps);
+    draft.directCloseAllRequested = isCloseAllCommand(extractUpstreamCommandTokens(draft.input.prepared.commandTokens));
+    observeCloseStatePath(draft);
+}
+export function redactNativeEnvelope(draft) {
+    if (draft.presentationEnvelope && draft.input.prepared.exactSensitiveValues.length > 0) {
+        const redacted = redactExactSensitiveValue(draft.presentationEnvelope, draft.input.prepared.exactSensitiveValues);
+        if (!isRecord(redacted) || typeof redacted.success !== "boolean") {
+            throw new Error("Native envelope redaction did not preserve its success field.");
+        }
+        draft.presentationEnvelope = { ...redacted, success: redacted.success };
+    }
+    draft.parseFailureOutput =
+        draft.parseError !== undefined &&
+            draft.parseError.length > 0 &&
+            draft.input.processResult.stdoutSpillPath !== undefined &&
+            draft.input.processResult.stdoutSpillPath.length > 0
+            ? {
+                fullOutputUnavailable: "Malformed upstream output was discarded because it may contain sensitive browser data.",
+            }
+            : {};
+}
+export function classifyNativeExecution(draft) {
+    observeNativePolicyExecution(draft);
+    classifyNativeEnvelope(draft);
+}
+export function observeInterruptedMutation(draft) {
+    draft.unobservedMutation =
+        draft.input.processResult.agentBrowserStarted &&
+            !draft.plainTextInspection &&
+            (draft.input.processResult.aborted ||
+                draft.input.processResult.timedOut ||
+                !draft.parseSucceeded ||
+                draft.presentationEnvelope === undefined) &&
+            (draft.input.prepared.executionPlan.commandInfo.command === "batch"
+                ? draft.batchCommandSteps
+                : [draft.input.prepared.commandTokens]).some((step) => {
+                const action = step[0] === "find" ? (step[step[1] === "nth" ? 4 : 3] ?? "click") : step[0];
+                return isPageMutationCommand(action, step[1]);
+            });
+    draft.sessionStateKey = getSessionContextKey(draft.input.prepared.executionPlan.sessionName, draft.input.prepared.executionPlan.namespace);
+    draft.closeAllApplied =
+        draft.nestedBatchClosesAll || (draft.directCloseAllRequested && draft.succeeded);
+}
+export function applyCloseAndTraceLifecycle(draft) {
+    clearReopenedTabLatch(draft);
+    applyOutputCloseScope(draft);
+    restoreConfirmActionsAfterRelaunch(draft);
+    foldTraceOwnership(draft);
+}
+function nativePrimitiveErrorMessage(error) {
+    if (typeof error === "number") {
+        return error !== 0 && !Number.isNaN(error) ? String(error) : undefined;
+    }
+    return error === true ? "true" : undefined;
+}
+function getEnvelopeErrorString(envelope) {
+    if (!envelope) {
+        return;
+    }
+    const error = envelope.error;
+    if (typeof error === "string") {
+        return error.length > 0 ? error : undefined;
+    }
+    if (isRecord(error) && typeof error.message === "string") {
+        return error.message;
+    }
+    // Arbitrary browser error objects may contain credentials and have no useful public message.
+    return nativePrimitiveErrorMessage(error);
+}
+function isStreamEnableAlreadyEnabledNoop(options) {
+    if (!options.processSucceeded ||
+        options.command !== "stream" ||
+        options.subcommand !== "enable" ||
+        options.envelope?.success !== false) {
+        return false;
+    }
+    const message = (getEnvelopeErrorString(options.envelope) ?? "")
+        .trim()
+        .replace(/[.!]+$/, "")
+        .toLowerCase();
+    return (message === "streaming is already enabled for this session" ||
+        message === "streaming is already enabled" ||
+        message === "stream already enabled");
+}
+function observeCloseStatePath(draft) {
+    const directCloseData = draft.confirmedData ?? draft.presentationEnvelope?.data;
+    draft.rawCloseStatePath =
+        draft.directClose && isRecord(directCloseData) && typeof directCloseData.statePath === "string"
+            ? directCloseData.statePath
+            : draft.nestedBatchClose?.statePath;
+}
+function classifyNativeEnvelope(draft) {
+    observeNativeConfirmationPolicy(draft);
+    draft.processSucceeded =
+        !draft.input.processResult.timedOut &&
+            !draft.input.processResult.aborted &&
+            !draft.input.processResult.spawnError &&
+            draft.input.processResult.exitCode === 0;
+    draft.plainTextInspection =
+        draft.input.prepared.executionPlan.plainTextInspection && draft.processSucceeded;
+    draft.parseSucceeded = draft.plainTextInspection || draft.parseError === undefined;
+    normalizeStreamEnableNoop(draft);
+    resolveEnvelopeSuccess(draft);
+    draft.inspectionText = draft.plainTextInspection
+        ? draft.input.processResult.stdout.trim()
+        : undefined;
+}
+function observeNativePolicyExecution(draft) {
+    draft.browserIndependentRead =
+        isBrowserIndependentConfirmation(draft.input.prepared.readConfirmation) ||
+            isBrowserIndependentRead(draft.input.prepared.commandTokens, draft.input.prepared.runtimeToolStdin);
+    draft.nativeCommandMayHaveExecuted = !nativePolicyDefinitelyUnestablished(draft.input.processResult, draft.parsed.envelope, draft.input.prepared.commandTokens);
+}
+function observeNativeConfirmationPolicy(draft) {
+    if (draft.input.state.confirmationPolicyMayBeEstablished !== true) {
+        draft.input.state.confirmationPolicyMayBeEstablished = draft.nativeCommandMayHaveExecuted;
+    }
+}
+function normalizeStreamEnableNoop(draft) {
+    if (isStreamEnableAlreadyEnabledNoop({
+        command: draft.input.prepared.executionPlan.commandInfo.command,
+        envelope: draft.presentationEnvelope,
+        processSucceeded: draft.processSucceeded,
+        subcommand: draft.input.prepared.executionPlan.commandInfo.subcommand,
+    })) {
+        draft.presentationEnvelope = {
+            success: true,
+            data: {
+                alreadyEnabled: true,
+                enabled: true,
+                message: getEnvelopeErrorString(draft.presentationEnvelope) ?? "Stream already enabled",
+            },
+        };
+    }
+}
+function clearReopenedTabLatch(draft) {
+    if (draft.sessionStateKey !== undefined &&
+        draft.sessionStateKey.length > 0 &&
+        draft.input.processResult.agentBrowserStarted &&
+        draft.input.state.sessionPageState.get(draft.sessionStateKey).tabReopenPending === true) {
+        if (draft.dispatchedCommands.some(commandChoosesSessionTabTarget)) {
+            draft.input.state.sessionPageState.setTabReopenPending({
+                pending: false,
+                sessionName: draft.sessionStateKey,
+                update: draft.input.sessionPageStateUpdate,
+            });
+        }
+    }
+}
+function applyOutputCloseScope(draft) {
+    if (draft.closeAllApplied) {
+        pruneNamespaceNetworkRoutes(draft);
+        deleteIdentityKeysInNamespace(draft.input.state.attachedSessionKeys, draft.input.prepared.executionPlan.namespace);
+        deleteIdentityKeysInNamespace(draft.input.state.traceOwners, draft.input.prepared.executionPlan.namespace);
+        draft.input.state.sessionPageState.clearNamespace(draft.input.prepared.executionPlan.namespace);
+        const retainedSessionKey = draft.nestedBatchRemainsActive ? draft.sessionStateKey : undefined;
+        for (const [key, owner] of draft.input.state.ownedManagedSessions) {
+            if (!isAgentBrowserSessionIdentityKeyInNamespace(key, draft.input.prepared.executionPlan.namespace) ||
+                key === retainedSessionKey) {
+                continue;
+            }
+            draft.input.state.closedManagedSessionNames.add(key);
+            draft.input.state.managedSessionRestoreState.clear(owner.sessionName, owner.namespace);
+        }
+    }
+    else if (draft.nestedBatchClose &&
+        draft.sessionStateKey !== undefined &&
+        draft.sessionStateKey.length > 0) {
+        const routes = new Map(draft.networkRoutesBySession);
+        routes.delete(draft.sessionStateKey);
+        draft.networkRoutesBySession = routes;
+        draft.input.state.sessionPageState.clearSession(draft.sessionStateKey);
+    }
+}
+function restoreConfirmActionsAfterRelaunch(draft) {
+    if (draft.sessionStateKey !== undefined &&
+        draft.sessionStateKey.length > 0 &&
+        draft.nestedBatchRemainsActive) {
+        const confirmActions = getAgentBrowserProcessEnvironment().AGENT_BROWSER_CONFIRM_ACTIONS;
+        if (confirmActions !== undefined) {
+            draft.input.state.sessionPageState.setConfirmActions(draft.sessionStateKey, confirmActions);
+        }
+    }
+}
+function foldTraceOwnership(draft) {
+    if (draft.input.prepared.executionPlan.commandInfo.command === "batch" &&
+        Array.isArray(draft.presentationEnvelope?.data)) {
+        for (const [index, row] of draft.presentationEnvelope.data.entries()) {
+            foldBatchTraceRow(draft, row, index);
+        }
+    }
+    else {
+        updateTraceOwnerState({
+            command: draft.directClose ? "close" : draft.input.prepared.executionPlan.commandInfo.command,
+            sessionName: draft.sessionStateKey,
+            subcommand: draft.input.prepared.executionPlan.commandInfo.subcommand,
+            succeeded: draft.succeeded,
+            traceOwners: draft.input.state.traceOwners,
+        });
+    }
+}
+function resolveEnvelopeSuccess(draft) {
+    const envelopeSuccess = draft.plainTextInspection
+        ? true
+        : draft.presentationEnvelope?.success !== false &&
+            !detectConfirmationRequired(draft.presentationEnvelope?.data);
+    draft.succeeded =
+        (draft.processSucceeded && draft.parseSucceeded && envelopeSuccess) ||
+            draft.recordingStopRecovery?.recovery.healed === true;
+}
+function foldBatchTraceRow(draft, row, index) {
+    if (!isRecord(row)) {
+        return;
+    }
+    const rowCommand = isStringArray(row.command) ? row.command : draft.batchCommandSteps.at(index);
+    if (!rowCommand) {
+        return;
+    }
+    const [command, subcommand] = extractUpstreamCommandTokens(rowCommand);
+    updateTraceOwnerState({
+        command,
+        sessionName: draft.sessionStateKey,
+        subcommand,
+        succeeded: row.success === true && !detectConfirmationRequired(row.result),
+        traceOwners: draft.input.state.traceOwners,
+    });
+}
+function pruneNamespaceNetworkRoutes(draft) {
+    draft.networkRoutesBySession = new Map([...draft.networkRoutesBySession].filter(([key]) => !isAgentBrowserSessionIdentityKeyInNamespace(key, draft.input.prepared.executionPlan.namespace)));
+}

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

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

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

@@ -0,0 +1,256 @@
+import { createFreshSessionName, resolveManagedSessionState, } from "../../runtime-session-identity.js";
+import { closeManagedSession, inspectManagedSessionDaemon, } from "./managed-session-daemon-policy.js";
+import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace, } from "../../argv-grammar.js";
+import { isOpenNavigationCommand } from "../../command-taxonomy.js";
+import { isRecord } from "../../parsing.js";
+import { pruneOwnedManagedSessionRestoreSnapshots } from "../../managed-session-restore.js";
+import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
+import { buildManagedSessionOutcome, getSessionContextKey } from "./session-state.js";
+function closeAllClosesManagedSession(draft) {
+    const priorKey = getSessionContextKey(draft.priorManagedSessionName, draft.priorManagedSessionNamespace) ??
+        draft.priorManagedSessionName;
+    const targetsPrior = draft.closeAllApplied &&
+        draft.priorManagedSessionActive &&
+        isAgentBrowserSessionIdentityKeyInNamespace(priorKey, draft.input.prepared.executionPlan.namespace);
+    const retainsPrior = targetsPrior && draft.nestedBatchRemainsActive && draft.sessionStateKey === priorKey;
+    return targetsPrior && !retainsPrior;
+}
+function managedCloseTarget(draft, closesPrior) {
+    if (closesPrior) {
+        return draft.priorManagedSessionName;
+    }
+    const { executionPlan } = draft.input.prepared;
+    if (draft.closeCommandSucceeded &&
+        executionPlan.sessionName === draft.priorManagedSessionName &&
+        executionPlan.namespace === draft.priorManagedSessionNamespace) {
+        return executionPlan.sessionName;
+    }
+    return executionPlan.managedSessionName;
+}
+export function resolveManagedCloseTarget(draft) {
+    draft.priorManagedSessionActive = draft.managedSessionActive;
+    draft.priorManagedSessionCwd = draft.managedSessionCwd;
+    draft.priorManagedSessionHeadedAutosaveInterval = draft.managedSessionHeadedAutosaveInterval;
+    draft.priorManagedSessionName = draft.managedSessionName;
+    draft.priorManagedSessionNamespace = draft.managedSessionNamespace;
+    const closesPrior = closeAllClosesManagedSession(draft);
+    draft.commandClosesSession = draft.directClose || draft.nestedBatchClosed || closesPrior;
+    draft.closeCommandSucceeded =
+        (draft.directClose && draft.succeeded) || draft.nestedBatchClosed || closesPrior;
+    draft.managedCloseSessionName = managedCloseTarget(draft, closesPrior);
+}
+function failedBatchEstablishedBrowser(draft) {
+    const { prepared } = draft.input;
+    return (!draft.succeeded &&
+        draft.processSucceeded &&
+        draft.parseSucceeded &&
+        prepared.sessionMode === "fresh" &&
+        prepared.executionPlan.commandInfo.command === "batch" &&
+        batchStartedManagedBrowser(draft.presentationEnvelope?.data));
+}
+function timedOutBatchEstablishedPage(draft) {
+    const { prepared, processResult } = draft.input;
+    return (!draft.succeeded &&
+        processResult.timedOut &&
+        prepared.sessionMode === "fresh" &&
+        prepared.executionPlan.commandInfo.command === "batch" &&
+        draft.timeoutPartialProgress?.liveUrlRecovered === true);
+}
+function failedFreshSessionMayHaveStarted(draft) {
+    const { prepared, processResult } = draft.input;
+    const spawnMayHaveRun = processResult.agentBrowserStarted ||
+        (!processResult.aborted && processResult.spawnError === undefined);
+    return (!draft.succeeded &&
+        spawnMayHaveRun &&
+        prepared.sessionMode === "fresh" &&
+        prepared.executionPlan.managedSessionName === prepared.executionPlan.sessionName);
+}
+async function inspectFailedFreshDaemon(draft) {
+    const { prepared, cwd, implicitSessionCloseTimeoutMs } = draft.input;
+    const sessionName = prepared.executionPlan.sessionName;
+    if (!failedFreshSessionMayHaveStarted(draft) ||
+        sessionName === undefined ||
+        sessionName.length === 0) {
+        return;
+    }
+    const daemon = await inspectManagedSessionDaemon({
+        cwd,
+        headedManagedAutosaveInterval: prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval,
+        namespace: prepared.executionPlan.namespace,
+        sessionName,
+        timeoutMs: Math.min(implicitSessionCloseTimeoutMs, 2_000),
+    });
+    if (daemon.status === "active") {
+        draft.input.state.managedSessionRestoreState.recordDaemonRestoreKey(prepared.executionPlan.sessionName, prepared.executionPlan.namespace, daemon.restoreKey);
+    }
+    return daemon;
+}
+export async function inspectFailedFreshLaunch(draft) {
+    const batchStarted = failedBatchEstablishedBrowser(draft);
+    const timeoutPage = timedOutBatchEstablishedPage(draft);
+    const daemon = await inspectFailedFreshDaemon(draft);
+    // Only an explicitly inactive daemon proves a started fresh command did not establish ownership.
+    const failedFreshStarted = daemon !== undefined && daemon.status !== "inactive";
+    draft.managedTransitionSucceeded =
+        draft.succeeded ||
+            draft.nestedBatchClosed ||
+            draft.nestedBatchRemainsActive ||
+            batchStarted ||
+            timeoutPage ||
+            failedFreshStarted;
+}
+function executionTargetsManagedSession(draft) {
+    const { executionPlan } = draft.input.prepared;
+    return (executionPlan.sessionName !== undefined &&
+        executionPlan.sessionName.length > 0 &&
+        getAgentBrowserSessionIdentityKey(executionPlan.sessionName, executionPlan.namespace) ===
+            getAgentBrowserSessionIdentityKey(draft.managedSessionName, draft.managedSessionNamespace));
+}
+function applyManagedLaunchPolicy(draft) {
+    if (!draft.managedSessionActive) {
+        draft.managedSessionCompatibilityWorkaround = undefined;
+        draft.managedSessionHeadedAutosaveDisabled = false;
+        draft.managedSessionHeadedAutosaveInterval = undefined;
+        return;
+    }
+    const { prepared } = draft.input;
+    const owned = prepared.ownedManagedSessionContext;
+    if (!draft.managedTransitionSucceeded ||
+        !executionTargetsManagedSession(draft) ||
+        !owned ||
+        owned.reuseOnly === true) {
+        return;
+    }
+    draft.managedSessionCompatibilityWorkaround = prepared.compatibilityWorkaround;
+    draft.managedSessionHeadedAutosaveDisabled = owned.headedManagedAutosaveDisabled === true;
+    draft.managedSessionHeadedAutosaveInterval = owned.headedManagedAutosaveInterval;
+}
+function retireManagedRestorePool(draft) {
+    if (!draft.closeCommandSucceeded ||
+        draft.managedCloseSessionName !== draft.priorManagedSessionName ||
+        draft.managedSessionActive) {
+        return;
+    }
+    const { managedSessionRestoreState } = draft.input.state;
+    const daemonKey = managedSessionRestoreState.getDaemonRestoreKey(draft.managedCloseSessionName, draft.priorManagedSessionNamespace);
+    const ownedKey = !managedSessionRestoreState.isDisabled(draft.managedCloseSessionName, draft.priorManagedSessionNamespace) && isManagedSessionRestoreKey(daemonKey)
+        ? daemonKey
+        : null;
+    managedSessionRestoreState.clear(draft.managedCloseSessionName, draft.priorManagedSessionNamespace);
+    pruneOwnedManagedSessionRestoreSnapshots({
+        cwd: draft.input.cwd,
+        namespace: draft.priorManagedSessionNamespace,
+        restoreKey: ownedKey,
+        statePath: draft.rawCloseStatePath,
+    });
+    draft.freshSessionOrdinal += 1;
+    draft.managedSessionName = createFreshSessionName(draft.input.state.managedSessionBaseName, draft.input.state.ephemeralSessionSeed, draft.freshSessionOrdinal);
+    draft.managedSessionNamespace = undefined;
+}
+function updateManagedLaunchDirectory(draft) {
+    const sessionName = draft.input.prepared.executionPlan.managedSessionName;
+    if (sessionName === undefined ||
+        sessionName.length === 0 ||
+        !draft.managedTransitionSucceeded ||
+        !draft.managedSessionActive) {
+        return;
+    }
+    if (!draft.priorManagedSessionActive ||
+        (draft.replacedManagedSessionName !== undefined && draft.replacedManagedSessionName.length > 0)) {
+        draft.managedSessionCwd = draft.input.cwd;
+    }
+    draft.managedSessionNamespace = draft.input.prepared.executionPlan.namespace;
+}
+export function applyManagedTransition(draft) {
+    const { prepared, state } = draft.input;
+    const command = draft.commandClosesSession ? "close" : prepared.executionPlan.commandInfo.command;
+    const next = resolveManagedSessionState({
+        command,
+        managedSessionName: draft.managedCloseSessionName,
+        managedSessionNamespace: prepared.executionPlan.namespace,
+        priorActive: draft.priorManagedSessionActive,
+        priorNamespace: draft.priorManagedSessionNamespace,
+        priorSessionName: draft.priorManagedSessionName,
+        succeeded: draft.managedTransitionSucceeded,
+    });
+    if (!draft.managedTransitionSucceeded &&
+        prepared.sessionMode === "fresh" &&
+        prepared.executionPlan.managedSessionName !== undefined &&
+        prepared.executionPlan.managedSessionName.length > 0) {
+        state.managedSessionRestoreState.clear(prepared.executionPlan.managedSessionName, prepared.executionPlan.namespace);
+    }
+    draft.replacedManagedSessionName = next.replacedSessionName;
+    draft.managedSessionActive = next.active;
+    draft.managedSessionName = next.sessionName;
+    draft.managedSessionNamespace = next.namespace;
+    applyManagedLaunchPolicy(draft);
+    retireManagedRestorePool(draft);
+    draft.managedSessionOutcome = buildManagedSessionOutcome({
+        activeAfter: draft.managedSessionActive,
+        activeBefore: draft.priorManagedSessionActive,
+        attemptedSessionName: draft.managedCloseSessionName,
+        command,
+        currentSessionName: draft.managedSessionName,
+        currentSessionNamespace: draft.managedSessionNamespace,
+        previousSessionName: draft.priorManagedSessionName,
+        replacedSessionName: draft.replacedManagedSessionName,
+        replacedSessionNamespace: draft.priorManagedSessionNamespace,
+        sessionMode: prepared.sessionMode,
+        succeeded: draft.managedTransitionSucceeded,
+    });
+    updateManagedLaunchDirectory(draft);
+}
+export async function retireReplacedSession(draft) {
+    const sessionName = draft.replacedManagedSessionName;
+    if (sessionName === undefined || sessionName.length === 0) {
+        return;
+    }
+    const sessionKey = getSessionContextKey(sessionName, draft.priorManagedSessionNamespace) ?? sessionName;
+    const { state } = draft.input;
+    const closeError = await closeManagedSession({
+        confirmActions: state.sessionPageState.get(sessionKey).confirmActions ??
+            process.env.AGENT_BROWSER_CONFIRM_ACTIONS,
+        cwd: draft.priorManagedSessionCwd,
+        headedManagedAutosaveInterval: draft.priorManagedSessionHeadedAutosaveInterval,
+        namespace: draft.priorManagedSessionNamespace,
+        preserveAttachedBrowserSession: state.attachedSessionKeys.has(sessionKey),
+        restoreState: state.managedSessionRestoreState,
+        sessionName,
+        socketDir: state.ownedManagedSessions.get(sessionKey)?.socketDir,
+        timeoutMs: draft.input.implicitSessionCloseTimeoutMs,
+    });
+    const closed = (closeError ?? "").length === 0;
+    if (draft.managedSessionOutcome) {
+        draft.managedSessionOutcome = {
+            ...draft.managedSessionOutcome,
+            replacedSessionClosed: closed,
+            summary: closed
+                ? draft.managedSessionOutcome.summary
+                : `${draft.managedSessionOutcome.summary} Previous session ${sessionName} remains wrapper-owned because automatic close failed; retry an explicit close.`,
+        };
+    }
+    if (!closed) {
+        return;
+    }
+    const routes = new Map(draft.networkRoutesBySession);
+    routes.delete(sessionKey);
+    draft.networkRoutesBySession = routes;
+    state.sessionPageState.clearSession(sessionKey);
+    state.attachedSessionKeys.delete(sessionKey);
+    state.closedManagedSessionNames.add(sessionKey);
+}
+function batchStartedManagedBrowser(data) {
+    if (!Array.isArray(data)) {
+        return false;
+    }
+    return data.some((entry) => {
+        if (!isRecord(entry) || entry.success !== true || !Array.isArray(entry.command)) {
+            return false;
+        }
+        const command = typeof entry.command[0] === "string" ? entry.command[0] : undefined;
+        return (command === "connect" ||
+            command === "goto" ||
+            command === "navigate" ||
+            isOpenNavigationCommand(command));
+    });
+}

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

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