pi-agent-browser-native 0.9.3 → 0.9.5

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

@@ -0,0 +1,201 @@
+import { buildOutputStatePatch } from "./process-output-ownership.js";
+import { isRecordPageTransitionCommand } from "../../command-taxonomy.js";
+import { isRecord } from "../../parsing.js";
+import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
+import { buildAboutBlankWarning, formatElectronPostCommandHealthText, formatElectronSessionMismatchText, } from "./session-state.js";
+import { getArtifactCleanupGuidance } from "./diagnostics.js";
+import { buildFinalAgentBrowserToolResult, buildRedactedPresentationContent, prepareFinalResultRecoveryState, } from "./final-result.js";
+function recordingPageWarning(draft) {
+    const reached = draft.input.prepared.executionPlan.commandInfo.command === "batch"
+        ? draft.presentation.batchSteps?.some((step) => isRecordPageTransitionCommand(extractUpstreamCommandTokens(step.command ?? []))) === true
+        : isRecordPageTransitionCommand(draft.input.prepared.commandTokens);
+    if (!draft.input.processResult.agentBrowserStarted ||
+        draft.input.prepared.executionPlan.plainTextInspection ||
+        !reached) {
+        return;
+    }
+    return "Page state: this wrapper conservatively invalidates earlier refs after recording starts and URL-bearing restarts. Take a fresh snapshot before continuing; this does not prove the page changed.";
+}
+function sessionWarning(draft) {
+    if (draft.electronPostCommandHealth) {
+        return formatElectronPostCommandHealthText(draft.electronPostCommandHealth);
+    }
+    if (draft.electronSessionMismatch) {
+        return formatElectronSessionMismatchText(draft.electronSessionMismatch);
+    }
+    return draft.aboutBlankSessionMismatch
+        ? buildAboutBlankWarning(draft.aboutBlankSessionMismatch)
+        : undefined;
+}
+export async function collectPublicationWarnings(draft) {
+    draft.resultArtifactManifest = draft.presentation.artifactManifest ?? draft.artifactManifest;
+    draft.artifactCleanup = await getArtifactCleanupGuidance({
+        command: draft.input.prepared.executionPlan.commandInfo.command,
+        cwd: draft.input.cwd,
+        manifest: draft.resultArtifactManifest,
+        succeeded: draft.succeeded,
+    });
+    const warnings = [sessionWarning(draft), recordingPageWarning(draft)]
+        .filter((part) => part !== undefined && part.length > 0)
+        .join("\n\n");
+    draft.redactedContent =
+        draft.input.modelVisible === false
+            ? []
+            : buildRedactedPresentationContent({
+                exactSensitiveValues: draft.input.prepared.exactSensitiveValues,
+                plainTextInspection: draft.plainTextInspection,
+                presentation: draft.presentation,
+                presentationEnvelope: draft.presentationEnvelope,
+                succeeded: draft.succeeded,
+                userRequestedJson: draft.input.prepared.userRequestedJson,
+                warningText: warnings.length > 0 ? warnings : undefined,
+            });
+}
+export async function recoverFinalOutput(draft) {
+    const recovery = await prepareFinalResultRecoveryState({
+        aboutBlankSessionMismatch: draft.aboutBlankSessionMismatch,
+        batchRefSnapshotState: draft.batchRefSnapshotState,
+        commandTokens: draft.input.prepared.commandTokens,
+        compiledSemanticAction: draft.input.prepared.compiledSemanticAction,
+        currentRefSnapshot: draft.currentRefSnapshot,
+        currentRefSnapshotInvalidation: draft.currentRefSnapshotInvalidation,
+        currentSessionTabTarget: draft.currentSessionTabTarget,
+        cwd: draft.input.cwd,
+        electronPostCommandHealth: draft.electronPostCommandHealth,
+        errorText: draft.errorText,
+        executionPlan: draft.input.prepared.executionPlan,
+        parseError: draft.parseError,
+        plainTextInspection: draft.plainTextInspection,
+        presentation: draft.presentation,
+        processResult: draft.input.processResult,
+        redactedProcessArgs: draft.input.prepared.redactedProcessArgs,
+        runtimeToolArgs: draft.input.prepared.runtimeToolArgs,
+        sessionPageState: draft.input.state.sessionPageState,
+        sessionPageStateUpdate: draft.input.sessionPageStateUpdate,
+        sessionTabCorrection: draft.sessionTabCorrection,
+        signal: draft.input.signal,
+        succeeded: draft.succeeded,
+    });
+    draft.currentRefSnapshot = recovery.currentRefSnapshot;
+    draft.currentRefSnapshotInvalidation = recovery.currentRefSnapshotInvalidation;
+    return recovery;
+}
+export function buildOutputResult(sources, recovery) {
+    const { input, native, page, lifecycle, publication } = sources;
+    const result = buildFinalAgentBrowserToolResult({
+        modelVisible: input.modelVisible,
+        aboutBlankSessionMismatch: lifecycle.aboutBlankSessionMismatch,
+        artifactCleanup: publication.artifactCleanup,
+        categoryDetails: recovery.categoryDetails,
+        clickDispatchDiagnostic: page.clickDispatchDiagnostic,
+        commandTokens: input.prepared.commandTokens,
+        comboboxFocusDiagnostic: page.diagnostics.comboboxFocusDiagnostic,
+        compiledNetworkSourceLookup: input.prepared.compiledNetworkSourceLookup,
+        compiledSemanticAction: input.prepared.compiledSemanticAction,
+        compatibilityWorkaround: input.prepared.compatibilityWorkaround,
+        currentRefSnapshot: input.modelVisible === false ? undefined : publication.currentRefSnapshot,
+        currentRefSnapshotInvalidation: publication.currentRefSnapshotInvalidation,
+        currentSessionTabTarget: publication.currentSessionTabTarget,
+        currentSessionTabTargetUnknown: publication.currentSessionTabTargetUnknown,
+        ...electronResultEvidence(sources),
+        ...invocationResultEvidence(sources),
+        ...launchResultEvidence(sources),
+        errorText: lifecycle.errorText,
+        evalResultWarning: publication.evalResultWarning,
+        evalStdinHint: publication.evalStdinHint,
+        exactSensitiveValues: input.prepared.exactSensitiveValues,
+        executionPlan: input.prepared.executionPlan,
+        fillVerificationDiagnostic: page.diagnostics.fillVerificationDiagnostic,
+        inspectionText: native.inspectionText,
+        navigationSummary: page.navigationSummary,
+        networkSourceLookup: publication.networkSourceLookup,
+        noActivePageSnapshotFailure: recovery.noActivePageSnapshotFailure,
+        openResultTabCorrection: lifecycle.openResultTabCorrection,
+        overlayBlockerDiagnostic: page.diagnostics.overlayBlockerDiagnostic,
+        parseError: lifecycle.parseError,
+        parseFailureOutput: native.parseFailureOutput,
+        parseSucceeded: lifecycle.parseSucceeded,
+        plainTextInspection: lifecycle.plainTextInspection,
+        presentation: publication.presentation,
+        presentationEnvelope: publication.presentationEnvelope,
+        priorSessionTabTarget: input.prepared.priorSessionTabTarget,
+        processResult: input.processResult,
+        qaAttachedTarget: publication.qaAttachedTarget,
+        qaPreset: publication.qaPreset,
+        recordingDependencyWarning: page.diagnostics.recordingDependencyWarning,
+        resultArtifactManifest: publication.resultArtifactManifest,
+        richInputRecoveryDiagnostic: recovery.richInputRecoveryDiagnostic,
+        scrollNoopDiagnostic: page.diagnostics.scrollNoopDiagnostic,
+        selectorTextVisibilityDiagnostics: page.diagnostics.selectorTextVisibilityDiagnostics,
+        sessionMode: input.prepared.sessionMode,
+        sessionTabCorrection: lifecycle.sessionTabCorrection,
+        sourceLookup: publication.sourceLookup,
+        succeeded: publication.succeeded,
+        timeoutPartialProgress: lifecycle.timeoutPartialProgress,
+        unsettledWebMcpMutation: page.unsettledWebMcpMutation,
+        userRequestedJson: input.prepared.userRequestedJson,
+        visibleRefFallbackDiagnostic: recovery.visibleRefFallbackDiagnostic,
+        visibleRefFallbackSessionName: recovery.visibleRefFallbackSessionName,
+    });
+    const resultWithCloseAll = attachCloseAllReceipt(lifecycle, result);
+    const statePatch = buildOutputStatePatch({
+        ...lifecycle,
+        artifactManifest: publication.artifactManifest,
+        networkRoutesBySession: publication.networkRoutesBySession,
+    });
+    return { result: resultWithCloseAll, statePatch };
+}
+function launchResultEvidence(sources) {
+    const { input, lifecycle, publication } = sources;
+    return {
+        headedLaunch: input.prepared.headedLaunch,
+        preserveAttachedBrowserSession: input.preserveAttachedBrowserSession === true,
+        providerLaunch: input.prepared.providerLaunch,
+        managedSessionHeadedAutosaveDisabled: (!(input.prepared.ownedManagedSessionContext?.reuseOnly === true) &&
+            lifecycle.resultHeadedManagedAutosaveDisabled) ||
+            undefined,
+        managedSessionHeadedAutosaveInterval: input.prepared.ownedManagedSessionContext?.reuseOnly === true
+            ? undefined
+            : lifecycle.resultHeadedManagedAutosaveInterval,
+        managedSessionOutcome: publication.managedSessionOutcome,
+        managedSessionRestoreDisabled: input.state.managedSessionRestoreState.isDisabled(input.prepared.executionPlan.sessionName, input.prepared.executionPlan.namespace),
+    };
+}
+function electronResultEvidence(sources) {
+    const { input, page, lifecycle } = sources;
+    return {
+        electronBroadGetTextScopeDiagnostics: page.diagnostics.electronBroadGetTextScopeDiagnostics,
+        electronFailedConnectCleanup: lifecycle.electronFailedConnectCleanup,
+        electronHandoff: lifecycle.electronHandoff,
+        electronLaunch: input.prepared.electronLaunch,
+        electronLaunchRecord: lifecycle.electronLaunchRecord,
+        electronLaunchRecords: input.state.electronLaunchRecords,
+        electronPostCommandHealth: page.electronPostCommandHealth,
+        electronProfileIsolationDetails: input.electronProfileIsolationDetails,
+        electronRefFreshnessDiagnostic: page.diagnostics.electronRefFreshnessDiagnostic,
+        electronSessionMismatch: page.electronSessionMismatch,
+    };
+}
+function invocationResultEvidence(sources) {
+    const { input, publication } = sources;
+    return {
+        redactedArgs: input.prepared.redactedArgs,
+        redactedCompiledElectron: input.prepared.redactedCompiledElectron,
+        redactedCompiledJob: input.prepared.redactedCompiledJob,
+        redactedCompiledNetworkSourceLookup: input.prepared.redactedCompiledNetworkSourceLookup,
+        redactedCompiledQaPreset: input.prepared.redactedCompiledQaPreset,
+        redactedCompiledSemanticAction: input.prepared.redactedCompiledSemanticAction,
+        redactedCompiledSourceLookup: input.prepared.redactedCompiledSourceLookup,
+        redactedContent: publication.redactedContent,
+        redactedProcessArgs: input.prepared.redactedProcessArgs,
+        redactedRecoveryHint: input.prepared.redactedRecoveryHint,
+    };
+}
+function attachCloseAllReceipt(draft, result) {
+    return draft.closeAllApplied
+        ? {
+            ...result,
+            details: { ...(isRecord(result.details) ? result.details : {}), closeAllApplied: true },
+        }
+        : result;
+}

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

@@ -0,0 +1,183 @@
+import { buildOutputStatePatch } from "./process-output-ownership.js";
+import { isStringArray } from "../../results/presentation/content.js";
+import { extractAgentBrowserLifecycle } from "../../results/presentation/common.js";
+import { detectConfirmationRequired } from "../../results/confirmation.js";
+import { isSuccessfulNativeConfirmedClose } from "../../read-confirmation.js";
+import { extractRefSnapshotFromData } from "../../session-page-state.js";
+import { isRecord } from "../../parsing.js";
+import { redactInvocationArgs } from "../../runtime-redaction.js";
+import { inspectManagedSessionDaemon, } from "./managed-session-daemon-policy.js";
+import { applyBrowserRunStatePatch } from "./session-state.js";
+function observedBatchCommand(row) {
+    if (!isStringArray(row.command)) {
+        return;
+    }
+    return isSuccessfulNativeConfirmedClose(row.command, row.result)
+        ? ["close"]
+        : redactInvocationArgs(row.command);
+}
+function observedBatchSteps(draft) {
+    const data = draft.presentationEnvelope?.data;
+    if (!Array.isArray(data)) {
+        return;
+    }
+    return data.flatMap((row) => {
+        if (!isRecord(row)) {
+            return [];
+        }
+        return [
+            {
+                command: observedBatchCommand(row),
+                success: row.success === true && !detectConfirmationRequired(row.result),
+                lifecycle: extractAgentBrowserLifecycle(row.result),
+            },
+        ];
+    });
+}
+export function commitObservedLifecycle(draft) {
+    const { prepared, state, processResult } = draft.input;
+    // Native ownership must be committed before rendering or result export can fail.
+    applyBrowserRunStatePatch(state, buildOutputStatePatch(draft));
+    state.observedBrowserEffects = {
+        args: prepared.redactedArgs,
+        command: draft.directClose ? "close" : prepared.executionPlan.commandInfo.command,
+        subcommand: draft.directClose ? undefined : prepared.executionPlan.commandInfo.subcommand,
+        sessionName: prepared.executionPlan.sessionName,
+        namespace: prepared.executionPlan.namespace,
+        sessionMode: prepared.sessionMode,
+        usedImplicitSession: prepared.executionPlan.usedImplicitSession,
+        agentBrowserStarted: processResult.agentBrowserStarted,
+        nativeSucceeded: draft.succeeded,
+        managedSessionOutcome: draft.managedSessionOutcome,
+        managedSessionCwd: prepared.ownedManagedSessionContext?.cwd ?? draft.managedSessionCwd,
+        compatibilityWorkaround: prepared.compatibilityWorkaround,
+        managedSessionHeadedAutosaveDisabled: draft.resultHeadedManagedAutosaveDisabled,
+        managedSessionHeadedAutosaveInterval: draft.resultHeadedManagedAutosaveInterval,
+        managedSessionRestoreDisabled: state.managedSessionRestoreState.isDisabled(prepared.executionPlan.sessionName, prepared.executionPlan.namespace),
+        closeAllApplied: draft.closeAllApplied,
+        readConfirmation: draft.readConfirmationEvent ??
+            prepared.readConfirmation ??
+            state.observedBrowserEffects?.readConfirmation,
+        electron: draft.electronLaunchRecord
+            ? { launch: draft.electronLaunchRecord, cleanup: draft.electronFailedConnectCleanup }
+            : undefined,
+        batchSteps: observedBatchSteps(draft),
+    };
+}
+function managedLaunchRetained(draft) {
+    return (draft.succeeded ||
+        (draft.managedSessionOutcome?.activeAfter === true &&
+            draft.managedSessionOutcome.currentSessionName ===
+                draft.input.prepared.executionPlan.sessionName));
+}
+function needsDaemonReceipt(draft) {
+    const { prepared, state, processResult } = draft.input;
+    const owned = prepared.ownedManagedSessionContext;
+    return (owned !== undefined &&
+        owned.reuseOnly !== true &&
+        !draft.commandClosesSession &&
+        processResult.agentBrowserStarted &&
+        managedLaunchRetained(draft) &&
+        !state.managedSessionRestoreState.getDaemonReceipt(prepared.executionPlan.sessionName, prepared.executionPlan.namespace));
+}
+function bindDaemonEvidence(draft, daemon, sessionKey, newSnapshot) {
+    const { prepared, state } = draft.input;
+    if (newSnapshot) {
+        state.sessionPageState.bindSnapshotGeneration(sessionKey, daemon.status === "active" ? daemon.generation : undefined);
+        draft.currentRefSnapshot = state.sessionPageState.get(sessionKey).refSnapshot;
+    }
+    if (prepared.ownedManagedSessionContext &&
+        daemon.status === "active" &&
+        daemon.generation !== undefined &&
+        daemon.generation.length > 0) {
+        state.managedSessionRestoreState.recordDaemonRestoreKey(prepared.executionPlan.sessionName, prepared.executionPlan.namespace, daemon.restoreKey, daemon.generation);
+    }
+}
+function hasNewSnapshot(draft) {
+    const snapshot = draft.authoritativePageState?.refSnapshot;
+    return (snapshot !== undefined &&
+        snapshot.snapshotId !== draft.input.prepared.priorRefSnapshotState?.snapshotId);
+}
+function daemonReceiptIdentity(draft) {
+    const sessionKey = draft.sessionStateKey;
+    const sessionName = draft.input.prepared.executionPlan.sessionName;
+    if (sessionKey === undefined ||
+        sessionKey.length === 0 ||
+        sessionName === undefined ||
+        sessionName.length === 0) {
+        return;
+    }
+    return { sessionKey, sessionName };
+}
+function daemonAutosaveInterval(draft) {
+    const owned = draft.input.prepared.ownedManagedSessionContext;
+    return (owned?.headedManagedAutosaveInterval ??
+        (owned?.headedManagedAutosaveDisabled === true ? "0" : undefined));
+}
+export async function bindOutputDaemonReceipt(draft) {
+    const sessionKey = draft.sessionStateKey;
+    const { prepared, state, cwd, signal } = draft.input;
+    draft.authoritativePageState =
+        sessionKey !== undefined && sessionKey.length > 0
+            ? state.sessionPageState.get(sessionKey)
+            : undefined;
+    const newSnapshot = hasNewSnapshot(draft);
+    const receiptNeeded = needsDaemonReceipt(draft);
+    const identity = daemonReceiptIdentity(draft);
+    if (!identity || (!newSnapshot && !receiptNeeded)) {
+        return;
+    }
+    const { sessionKey: key, sessionName } = identity;
+    const daemon = await inspectManagedSessionDaemon({
+        cwd,
+        namespace: prepared.executionPlan.namespace,
+        sessionName,
+        signal,
+        includeGeneration: true,
+        headedManagedAutosaveInterval: daemonAutosaveInterval(draft),
+        timeoutMs: prepared.processTimeoutMs,
+    });
+    bindDaemonEvidence(draft, daemon, key, newSnapshot);
+}
+function confirmedSnapshotEvidenceComplete(draft) {
+    return (draft.sessionStateKey !== undefined &&
+        draft.sessionStateKey.length > 0 &&
+        draft.currentRefSnapshot !== undefined &&
+        draft.processSucceeded &&
+        draft.parseSucceeded &&
+        !draft.unobservedMutation);
+}
+function lastRowConfirmedSnapshot(draft) {
+    const data = draft.presentationEnvelope?.data;
+    const lastIndex = Array.isArray(data) ? data.length - 1 : 0;
+    return draft.confirmedEffects.some((effect) => effect.command === "snapshot" &&
+        effect.succeeded &&
+        effect.index === lastIndex &&
+        extractRefSnapshotFromData(effect.data) !== undefined);
+}
+function markFreshConfirmedSnapshot(draft) {
+    const confirmation = draft.readConfirmationEvent;
+    if (confirmation?.state !== "cleared" ||
+        confirmation.command !== "snapshot" ||
+        confirmation.action !== "snapshot") {
+        return;
+    }
+    if (!confirmedSnapshotEvidenceComplete(draft) || !lastRowConfirmedSnapshot(draft)) {
+        return;
+    }
+    draft.readConfirmationEvent = { ...confirmation, refSnapshotFresh: true };
+    draft.presentation.readConfirmation = draft.readConfirmationEvent;
+    draft.input.state.sessionPageState.applyReadConfirmation(draft.readConfirmationEvent, draft.input.sessionPageStateUpdate);
+    draft.input.state.observedBrowserEffects = {
+        ...draft.input.state.observedBrowserEffects,
+        readConfirmation: draft.readConfirmationEvent,
+    };
+}
+export function publishConfirmedSnapshot(draft) {
+    markFreshConfirmedSnapshot(draft);
+    if (draft.sessionStateKey !== undefined && draft.sessionStateKey.length > 0) {
+        draft.currentSessionTabTarget = draft.authoritativePageState?.tabTarget;
+    }
+    draft.currentSessionTabTargetUnknown =
+        draft.authoritativePageState?.tabTargetUnknown === true ? true : undefined;
+}

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

@@ -0,0 +1,200 @@
+import { buildPageTransitionRefSnapshotInvalidation, getCommandRefSnapshotInvalidation, extractLatestRefSnapshotStateFromBatchResults, extractRefSnapshotFromData, } from "../../session-page-state.js";
+import { isRecord } from "../../parsing.js";
+import { runSessionCommandData } from "./session-state.js";
+function batchSnapshotData(draft) {
+    const data = draft.presentationEnvelope?.data;
+    if (!Array.isArray(data)) {
+        return data;
+    }
+    const rows = [];
+    for (const [index, row] of data.entries()) {
+        const snapshot = draft.confirmedEffects.find((effect) => effect.index === index && effect.command === "snapshot");
+        if (snapshot && isRecord(row)) {
+            rows.push({
+                ...row,
+                command: ["snapshot"],
+                result: snapshot.data,
+                success: snapshot.succeeded,
+            });
+        }
+        else {
+            rows.push(row);
+        }
+    }
+    return rows;
+}
+function getTransitionInvalidation(draft) {
+    // Missing native rows can hide a recording swap or WebMCP mutation. Planned steps are conservative fallback evidence.
+    const direct = getCommandRefSnapshotInvalidation(draft.input.prepared.commandTokens);
+    const planned = !Array.isArray(draft.presentationEnvelope?.data)
+        ? draft.batchCommandSteps
+            .map(getCommandRefSnapshotInvalidation)
+            .find((value) => value !== undefined)
+        : undefined;
+    if (draft.unobservedMutation && !draft.failedTransitionReverification) {
+        return buildPageTransitionRefSnapshotInvalidation("A dispatched mutation was interrupted without a final outcome. Verify the current URL and take a fresh snapshot before deciding whether to retry.");
+    }
+    if (draft.unsettledWebMcpMutation) {
+        return buildPageTransitionRefSnapshotInvalidation("A detached WebMCP invocation is still pending or failed to settle and can mutate, rerender, or navigate the page, so prior snapshot refs remain invalid after URL verification. Run webmcp result or cancel, then take a fresh snapshot before using page-scoped refs.");
+    }
+    return observedTransitionInvalidation(draft, direct ?? planned);
+}
+function observedTransitionInvalidation(draft, commandInvalidation) {
+    if (draft.input.processResult.agentBrowserStarted &&
+        draft.nativeCommandMayHaveExecuted &&
+        commandInvalidation) {
+        return commandInvalidation;
+    }
+    if (draft.failedTransitionReverification) {
+        return buildPageTransitionRefSnapshotInvalidation("A failed page transition may still have changed the page, so the prior snapshot refs were invalidated. Run snapshot -i before using page-scoped refs.");
+    }
+    return draft.batchRefSnapshotState?.invalidation?.reason === "page-transition"
+        ? draft.batchRefSnapshotState.invalidation
+        : undefined;
+}
+function applyOutputTabTarget(draft, sessionName) {
+    const { state, sessionPageStateUpdate } = draft.input;
+    if (draft.currentSessionTabTarget) {
+        const tabUpdate = state.sessionPageState.applyTabTarget({
+            sessionName,
+            target: draft.currentSessionTabTarget,
+            update: sessionPageStateUpdate,
+        });
+        if (!tabUpdate.applied && draft.succeeded) {
+            state.sessionPageState.markPinning(sessionName, "drift");
+        }
+        return;
+    }
+    const { commandTokens } = draft.input.prepared;
+    const canHaveChanged = draft.unobservedMutation ||
+        draft.resultingPageState.pageUrlUnknown ||
+        draft.resultingPageState.pageTargetMayHaveChanged;
+    if (draft.input.processResult.agentBrowserStarted &&
+        canHaveChanged &&
+        !(commandTokens[0] === "session" && commandTokens[1] === "info")) {
+        state.sessionPageState.markTabTargetUnknown({ sessionName, update: sessionPageStateUpdate });
+    }
+}
+function outputSnapshot(draft) {
+    if (draft.unsettledWebMcpMutation || draft.unobservedMutation) {
+        return;
+    }
+    const { prepared } = draft.input;
+    if (prepared.executionPlan.commandInfo.command === "batch") {
+        return draft.batchRefSnapshotState?.snapshot;
+    }
+    if (!draft.succeeded) {
+        return;
+    }
+    return directOutputSnapshot(draft);
+}
+function snapshotRefreshArgs(draft, snapshot) {
+    if (draft.batchRefSnapshotState?.refreshArgs) {
+        return draft.batchRefSnapshotState.refreshArgs;
+    }
+    const { commandTokens } = draft.input.prepared;
+    const data = draft.presentationEnvelope?.data;
+    if (!draft.succeeded ||
+        commandTokens[0] !== "snapshot" ||
+        !isRecord(data) ||
+        !isRecord(data.snapshot) ||
+        snapshot) {
+        return;
+    }
+    return commandTokens.filter((token) => token !== "--delta" && token !== "--full");
+}
+async function refreshCompleteRefs(draft, sessionName, snapshot) {
+    const args = snapshotRefreshArgs(draft, snapshot);
+    if (!args ||
+        draft.readConfirmation?.state === "pending" ||
+        draft.unsettledWebMcpMutation ||
+        draft.unobservedMutation) {
+        return snapshot;
+    }
+    // Native owns delta baselines; read complete refs without advancing that baseline.
+    const refreshed = extractRefSnapshotFromData(await runSessionCommandData({
+        args,
+        cwd: draft.input.cwd,
+        namespace: draft.input.prepared.executionPlan.namespace,
+        sessionName: draft.input.prepared.executionPlan.sessionName,
+        signal: draft.input.signal,
+    }));
+    if (!refreshed) {
+        draft.input.state.sessionPageState.applyRefSnapshotInvalidation({
+            sessionName,
+            update: draft.input.sessionPageStateUpdate,
+            invalidation: buildPageTransitionRefSnapshotInvalidation("The native snapshot delta did not include complete refs and the full ref read failed. Run snapshot -i before using refs."),
+        });
+    }
+    return refreshed;
+}
+function applyOutputSnapshot(draft, sessionName, snapshot, invalidation) {
+    const { sessionPageState } = draft.input.state;
+    let view = sessionPageState.get(sessionName);
+    if (snapshot) {
+        view = sessionPageState.applyRefSnapshot({
+            sessionName,
+            snapshot,
+            fallbackTarget: draft.currentSessionTabTarget,
+            update: draft.input.sessionPageStateUpdate,
+        });
+    }
+    else if (invalidation) {
+        view = sessionPageState.applyRefSnapshotInvalidation({
+            sessionName,
+            invalidation,
+            update: draft.input.sessionPageStateUpdate,
+        });
+    }
+    draft.currentRefSnapshot = view.refSnapshot;
+    draft.currentRefSnapshotInvalidation = view.refSnapshotInvalidation;
+}
+export async function reconcileOutputRefs(draft) {
+    if (draft.input.prepared.executionPlan.commandInfo.command === "batch") {
+        draft.batchRefSnapshotState = extractLatestRefSnapshotStateFromBatchResults(batchSnapshotData(draft));
+    }
+    const sessionName = draft.sessionStateKey;
+    if (sessionName === undefined || sessionName.length === 0 || draft.browserIndependentRead) {
+        return;
+    }
+    if ((draft.directClose && draft.succeeded) || draft.nestedBatchClosed) {
+        retireOutputSession(draft, sessionName);
+        return;
+    }
+    const invalidation = getTransitionInvalidation(draft);
+    applyOutputTabTarget(draft, sessionName);
+    const snapshot = await refreshCompleteRefs(draft, sessionName, outputSnapshot(draft));
+    applyOutputSnapshot(draft, sessionName, snapshot, invalidation);
+}
+export function retireOutputSession(draft, sessionName) {
+    draft.input.state.attachedSessionKeys.delete(sessionName);
+    const routes = new Map(draft.networkRoutesBySession);
+    routes.delete(sessionName);
+    draft.networkRoutesBySession = routes;
+    draft.input.state.sessionPageState.clearSession(sessionName);
+    draft.input.state.closedManagedSessionNames.add(sessionName);
+}
+export function reconcileOutputPinning(draft) {
+    const sessionName = draft.sessionStateKey;
+    if (sessionName === undefined || sessionName.length === 0 || !draft.succeeded) {
+        return;
+    }
+    if (draft.openResultTabCorrection ||
+        draft.sessionTabCorrection ||
+        draft.aboutBlankSessionMismatch?.recoveryApplied === true) {
+        draft.input.state.sessionPageState.markPinning(sessionName, "drift");
+    }
+    else if (draft.input.prepared.sessionTabPinningReason === "restore" &&
+        draft.observedSessionTabTarget) {
+        draft.input.state.sessionPageState.clearRestorePinning(sessionName);
+    }
+}
+function directOutputSnapshot(draft) {
+    const { prepared } = draft.input;
+    if (prepared.executionPlan.commandInfo.command === "snapshot" ||
+        draft.confirmedCommand === "snapshot") {
+        return extractRefSnapshotFromData(draft.confirmedData ?? draft.presentationEnvelope?.data);
+    }
+    return (prepared.resolvedSemanticActionRefSnapshot ??
+        draft.diagnostics.overlayBlockerDiagnostic?.snapshot);
+}