pi-agent-browser-native 0.9.3 → 0.9.4

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

@@ -0,0 +1,142 @@
+import { observeHelperConfirmation } from "./process-output-confirmation.js";
+import { verifyClickDispatch, observeNavigationTarget, correctRestoredOpenTab, observeWebMcpTarget, resolveObservedPageTarget, } from "./process-output-navigation.js";
+import { recoverUnexpectedBlankTarget, pinPostCommandTarget, inspectElectronHealth, } from "./process-output-tabs.js";
+import { collectPageDiagnostics } from "./process-output-diagnostics.js";
+import { collectTimeoutPartialProgress } from "./diagnostics.js";
+import { normalizeSessionTabTarget } from "../../session-page-state.js";
+import { reconcileOutputRefs } from "./process-output-refs.js";
+async function recoverTimeoutPageTarget(view) {
+    const timeoutPartialProgress = view.input.processResult.timedOut &&
+        !view.recordingStopRecovery &&
+        !view.input.prepared.readConfirmation
+        ? await collectTimeoutPartialProgress({
+            commandTokens: view.input.prepared.commandTokens,
+            compiledJob: view.input.prepared.compiledJob,
+            cwd: view.input.cwd,
+            operationCwd: view.input.operationCwd,
+            namespace: view.input.prepared.executionPlan.namespace,
+            sessionName: view.input.prepared.executionPlan.sessionName,
+            stdin: view.input.prepared.runtimeToolStdin,
+        })
+        : undefined;
+    let currentSessionTabTarget = view.currentSessionTabTarget;
+    if (!currentSessionTabTarget && timeoutPartialProgress?.liveUrlRecovered === true) {
+        currentSessionTabTarget = normalizeSessionTabTarget(timeoutPartialProgress.currentPage);
+    }
+    return { timeoutPartialProgress, currentSessionTabTarget };
+}
+function createPageOutputPhase(input, native) {
+    return {
+        input,
+        aboutBlankSessionMismatch: undefined,
+        activeNetworkRoutes: undefined,
+        diagnostics: {
+            selectorTextVisibilityDiagnostics: [],
+            electronBroadGetTextScopeDiagnostics: [],
+        },
+        batchCommandSteps: native.batchCommandSteps,
+        batchRefSnapshotState: undefined,
+        browserIndependentRead: native.browserIndependentRead,
+        clickDispatchDiagnostic: undefined,
+        confirmationFromHelper: false,
+        confirmedCommand: native.confirmedCommand,
+        confirmedData: native.confirmedData,
+        confirmedEffects: native.confirmedEffects,
+        currentRefSnapshot: undefined,
+        currentRefSnapshotInvalidation: undefined,
+        currentSessionTabTarget: undefined,
+        destinationTransition: native.destinationTransition,
+        directClose: native.directClose,
+        dispatchedCommands: native.dispatchedCommands,
+        electronPostCommandHealth: undefined,
+        electronRecordForCommand: undefined,
+        electronSessionMismatch: undefined,
+        electronStatusAfterCommand: undefined,
+        failedTransitionReverification: false,
+        nativeCommandMayHaveExecuted: native.nativeCommandMayHaveExecuted,
+        navigationSummary: undefined,
+        nestedBatchClose: native.nestedBatchClose,
+        nestedBatchClosed: native.nestedBatchClosed,
+        networkRoutesBySession: native.networkRoutesBySession,
+        observedSessionTabTarget: undefined,
+        openResultTabCorrection: undefined,
+        presentationEnvelope: native.presentationEnvelope,
+        processSucceeded: native.processSucceeded,
+        readConfirmation: native.readConfirmation,
+        readConfirmationEvent: native.readConfirmationEvent,
+        recordingStopRecovery: native.recordingStopRecovery,
+        resultingPageState: { pageTargetMayHaveChanged: false, pageUrlUnknown: false },
+        sessionStateKey: native.sessionStateKey,
+        sessionTabCorrection: undefined,
+        succeeded: native.succeeded,
+        tabTransition: false,
+        textOutput: native.textOutput,
+        timeoutPartialProgress: undefined,
+        trustsReportedPageTarget: false,
+        unobservedMutation: native.unobservedMutation,
+        unsettledWebMcpMutation: false,
+    };
+}
+export async function observePageEffects(input, native) {
+    const draft = createPageOutputPhase(input, native);
+    await verifyClickDispatch(draft);
+    await observeNavigationTarget(draft);
+    await correctRestoredOpenTab(draft);
+    observeWebMcpTarget(draft);
+    observeHelperConfirmation(draft);
+    await resolveObservedPageTarget(draft);
+    await recoverUnexpectedBlankTarget(draft);
+    await pinPostCommandTarget(draft);
+    await inspectElectronHealth(draft);
+    const timeoutRecovery = await recoverTimeoutPageTarget(draft);
+    draft.timeoutPartialProgress = timeoutRecovery.timeoutPartialProgress;
+    draft.currentSessionTabTarget = timeoutRecovery.currentSessionTabTarget;
+    const collected = await collectPageDiagnostics({
+        input,
+        aboutBlankSessionMismatch: draft.aboutBlankSessionMismatch,
+        clickDispatchDiagnostic: draft.clickDispatchDiagnostic,
+        currentSessionTabTarget: draft.currentSessionTabTarget,
+        electronRecordForCommand: draft.electronRecordForCommand,
+        navigationSummary: draft.navigationSummary,
+        networkRoutesBySession: draft.networkRoutesBySession,
+        presentationEnvelope: draft.presentationEnvelope,
+        sessionStateKey: draft.sessionStateKey,
+        sessionTabCorrection: draft.sessionTabCorrection,
+        succeeded: draft.succeeded,
+    });
+    draft.diagnostics = collected.diagnostics;
+    draft.activeNetworkRoutes = collected.activeNetworkRoutes;
+    draft.networkRoutesBySession = collected.networkRoutesBySession;
+    await reconcileOutputRefs(draft);
+    return {
+        aboutBlankSessionMismatch: draft.aboutBlankSessionMismatch,
+        activeNetworkRoutes: draft.activeNetworkRoutes,
+        diagnostics: draft.diagnostics,
+        batchRefSnapshotState: draft.batchRefSnapshotState,
+        clickDispatchDiagnostic: draft.clickDispatchDiagnostic,
+        confirmationFromHelper: draft.confirmationFromHelper,
+        confirmedEffects: draft.confirmedEffects,
+        currentRefSnapshot: draft.currentRefSnapshot,
+        currentRefSnapshotInvalidation: draft.currentRefSnapshotInvalidation,
+        currentSessionTabTarget: draft.currentSessionTabTarget,
+        directClose: draft.directClose,
+        electronPostCommandHealth: draft.electronPostCommandHealth,
+        electronSessionMismatch: draft.electronSessionMismatch,
+        navigationSummary: draft.navigationSummary,
+        nestedBatchClosed: draft.nestedBatchClosed,
+        networkRoutesBySession: draft.networkRoutesBySession,
+        observedSessionTabTarget: draft.observedSessionTabTarget,
+        openResultTabCorrection: draft.openResultTabCorrection,
+        presentationEnvelope: draft.presentationEnvelope,
+        processSucceeded: draft.processSucceeded,
+        readConfirmationEvent: draft.readConfirmationEvent,
+        recordingStopRecovery: draft.recordingStopRecovery,
+        sessionStateKey: draft.sessionStateKey,
+        sessionTabCorrection: draft.sessionTabCorrection,
+        succeeded: draft.succeeded,
+        textOutput: draft.textOutput,
+        timeoutPartialProgress: draft.timeoutPartialProgress,
+        unobservedMutation: draft.unobservedMutation,
+        unsettledWebMcpMutation: draft.unsettledWebMcpMutation,
+    };
+}

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

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

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

@@ -0,0 +1,333 @@
+import { isStringArray } from "../../results/presentation/content.js";
+import { buildReadConfirmationNextActions, } from "../../read-confirmation.js";
+import { isCloseCommand } from "../../command-taxonomy.js";
+import { applyNetworkRouteRecords } from "../../results/network-routes.js";
+import { buildToolPresentation } from "../../results/presentation.js";
+import { compactLargePresentationOutput } from "../../results/presentation/large-output.js";
+import { extractEnvelopeErrorText, getAgentBrowserErrorText } from "../../results/envelope.js";
+import { detectConfirmationRequired } from "../../results/confirmation.js";
+import { omitUpstreamLifecycle } from "../../results/presentation/common.js";
+import { getClipboardWritePayloadCandidates, redactClipboardPermissionEcho, redactClipboardPermissionErrorValue, } from "../../results/presentation/errors.js";
+import { isRecord } from "../../parsing.js";
+import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
+import { getStaleRefArgs } from "./session-state.js";
+import { mergeRecordingRecoveryPresentation } from "./recording-recovery.js";
+import { buildWrapperRecoveryHint } from "./final-result.js";
+import { setNetworkRouteState } from "./process-output-diagnostics.js";
+export function resolveOutputError(draft) {
+    resolveNativeErrorText(draft);
+    applyErrorEnvelopeFallback(draft);
+    redactClipboardError(draft);
+    applyTextErrorEnvelope(draft);
+    observeResultLaunchPolicy(draft);
+}
+export async function renderNativePresentation(draft) {
+    draft.presentation = await buildNativePresentation(draft);
+    if (draft.recordingStopRecovery) {
+        draft.presentation = mergeRecordingRecoveryPresentation(draft.presentation, draft.recordingStopRecovery);
+    }
+    classifyMalformedNativeFailure(draft);
+    renderPresentationConfirmation(draft);
+    await renderUpgradeFailure(draft);
+    if (draft.electronHandoff?.error !== undefined &&
+        draft.electronHandoff.error.length > 0 &&
+        draft.electronHandoff.failureCategory !== undefined &&
+        draft.electronHandoff.failureCategory.length > 0) {
+        draft.presentation.failureCategory = draft.electronHandoff.failureCategory;
+    }
+}
+export function reclassifyPresentation(draft) {
+    applyBatchNetworkRouteState(draft);
+    if (draft.presentation.resultCategory === "failure" && draft.succeeded) {
+        draft.succeeded = false;
+        draft.presentationEnvelope = {
+            ...draft.presentationEnvelope,
+            error: draft.presentation.summary,
+            success: false,
+        };
+    }
+    reclassifyScrollNoop(draft);
+    renderParseFailureArtifacts(draft);
+}
+function resolveNativeErrorText(draft) {
+    draft.errorText =
+        draft.recordingStopRecovery?.recovery.healed === true
+            ? undefined
+            : getAgentBrowserErrorText({
+                aborted: draft.input.processResult.aborted,
+                command: draft.input.prepared.executionPlan.commandInfo.command,
+                effectiveArgs: draft.input.prepared.redactedProcessArgs,
+                envelope: draft.presentationEnvelope,
+                exitCode: draft.input.processResult.exitCode,
+                parseError: draft.parseError,
+                plainTextInspection: draft.plainTextInspection,
+                staleRefArgs: getStaleRefArgs(draft.input.prepared.commandTokens, draft.input.prepared.runtimeToolStdin),
+                spawnError: draft.input.processResult.spawnError,
+                stderr: draft.input.processResult.stderr,
+                timedOut: draft.input.processResult.timedOut,
+                timeoutMs: draft.input.processResult.timeoutMs,
+                wrapperRecoveryHint: buildWrapperRecoveryHint({
+                    sessionTabCorrection: draft.sessionTabCorrection,
+                }),
+            });
+}
+function applyErrorEnvelopeFallback(draft) {
+    if (draft.errorText !== undefined &&
+        draft.errorText.length > 0 &&
+        draft.presentationEnvelope?.success === false &&
+        extractEnvelopeErrorText(draft.presentationEnvelope.error) === undefined) {
+        draft.presentationEnvelope = { ...draft.presentationEnvelope, error: draft.errorText };
+    }
+}
+function redactClipboardError(draft) {
+    if (draft.errorText !== undefined && draft.errorText.length > 0) {
+        const clipboardWritePayloadCandidates = getClipboardWritePayloadCandidates(draft.input.prepared.commandTokens);
+        draft.errorText = redactClipboardPermissionEcho(draft.input.prepared.executionPlan.commandInfo, draft.errorText);
+        if (draft.presentationEnvelope?.error !== undefined) {
+            draft.presentationEnvelope = {
+                ...draft.presentationEnvelope,
+                error: redactClipboardPermissionErrorValue(draft.input.prepared.executionPlan.commandInfo, draft.presentationEnvelope.error, clipboardWritePayloadCandidates),
+            };
+        }
+    }
+}
+function applyTextErrorEnvelope(draft) {
+    if ((draft.plainTextUpgrade || draft.textOutput) &&
+        draft.errorText !== undefined &&
+        draft.errorText.length > 0) {
+        draft.presentationEnvelope = {
+            ...draft.presentationEnvelope,
+            success: false,
+            error: draft.errorText,
+        };
+    }
+}
+function observeResultLaunchPolicy(draft) {
+    const resultRetainsPreparedManagedSession = preparedSessionRetained(draft);
+    draft.resultHeadedManagedAutosaveDisabled =
+        draft.input.prepared.ownedManagedSessionContext?.headedManagedAutosaveDisabled === true &&
+            resultRetainsPreparedManagedSession &&
+            !(draft.commandClosesSession && draft.succeeded);
+    draft.resultHeadedManagedAutosaveInterval =
+        resultRetainsPreparedManagedSession && !(draft.commandClosesSession && draft.succeeded)
+            ? draft.input.prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval
+            : undefined;
+}
+function classifyMalformedNativeFailure(draft) {
+    if (draft.parseError !== undefined &&
+        draft.parseError.length > 0 &&
+        draft.input.processResult.exitCode !== 0 &&
+        draft.input.processResult.stderr.trim().length > 0 &&
+        !draft.input.processResult.timedOut &&
+        !draft.input.processResult.aborted &&
+        !draft.input.processResult.spawnError) {
+        draft.presentation.failureCategory = "upstream-error";
+    }
+}
+function renderPresentationConfirmation(draft) {
+    const confirmation = draft.readConfirmationEvent ?? draft.input.prepared.readConfirmation;
+    if (confirmation) {
+        draft.presentation.readConfirmation = confirmation;
+        renderPendingHelperConfirmation(draft, confirmation);
+        if (draft.readConfirmationEvent?.state === "pending") {
+            draft.presentation.resultCategory = "failure";
+            draft.presentation.failureCategory = "confirmation-required";
+            draft.presentation.successCategory = undefined;
+            if (draft.confirmationFromHelper) {
+                draft.presentation.content.unshift({
+                    type: "text",
+                    text: `Native helper ${confirmation.command ?? "read"} requires confirmation (${confirmation.action ?? "read"}, ${confirmation.id}). The requested command's result, if dispatched, is preserved below.`,
+                });
+            }
+        }
+    }
+}
+async function renderUpgradeFailure(draft) {
+    if (draft.plainTextUpgrade &&
+        !draft.textOutput &&
+        !draft.succeeded &&
+        typeof draft.presentationEnvelope?.data === "string") {
+        draft.presentation.data = draft.presentationEnvelope.data;
+        const errorContent = draft.presentation.content.at(0);
+        if (errorContent?.type === "text" && draft.presentationEnvelope.data.length > 0) {
+            errorContent.text += `\n\n${draft.presentationEnvelope.data}`;
+        }
+        if (draft.input.modelVisible !== false) {
+            draft.presentation = await compactLargePresentationOutput({
+                artifactManifest: draft.artifactManifest,
+                commandInfo: draft.input.prepared.executionPlan.commandInfo,
+                data: draft.presentation.data,
+                persistentArtifactStore: draft.persistentArtifactStore,
+                presentation: draft.presentation,
+            });
+        }
+    }
+}
+function reclassifyScrollNoop(draft) {
+    if (draft.diagnostics.scrollNoopDiagnostic) {
+        draft.succeeded = false;
+        draft.presentation.resultCategory = "failure";
+        draft.presentation.failureCategory = "upstream-error";
+        draft.presentationEnvelope = {
+            ...draft.presentationEnvelope,
+            error: "Scroll completed with no observed movement.",
+            success: false,
+        };
+        draft.presentation.summary = "Scroll completed with no observed movement.";
+        if (isRecord(draft.presentation.data)) {
+            draft.presentation.data = { ...draft.presentation.data, noMovement: true, scrolled: false };
+        }
+        if (draft.presentation.content[0]?.type === "text") {
+            const details = isRecord(draft.presentation.data)
+                ? JSON.stringify(omitUpstreamLifecycle(draft.presentation.data), null, 2)
+                : draft.presentation.content[0].text;
+            draft.presentation.content[0] = {
+                ...draft.presentation.content[0],
+                text: `Scroll completed with no observed movement.\n\n${details}`,
+            };
+        }
+        else {
+            draft.presentation.content.unshift({
+                type: "text",
+                text: "Scroll completed with no observed movement.",
+            });
+        }
+    }
+}
+function renderParseFailureArtifacts(draft) {
+    if (draft.parseFailureOutput.artifactManifest) {
+        draft.presentation.artifactManifest = draft.parseFailureOutput.artifactManifest;
+        draft.presentation.artifactRetentionSummary = draft.parseFailureOutput.artifactRetentionSummary;
+    }
+    renderParseFailureNotice(draft);
+    if (draft.presentation.artifactManifest) {
+        draft.artifactManifest = draft.presentation.artifactManifest;
+    }
+}
+function renderPendingHelperConfirmation(draft, confirmation) {
+    if (confirmation.state !== "cleared" ||
+        !detectConfirmationRequired(draft.presentationEnvelope?.data)) {
+        draft.presentation.nextActions = buildReadConfirmationNextActions(confirmation, draft.readConfirmationEvent?.state === "pending");
+    }
+}
+function inspectionPresentation(draft) {
+    return {
+        artifacts: undefined,
+        batchFailure: undefined,
+        batchSteps: undefined,
+        content: [{ type: "text", text: draft.inspectionText ?? "" }],
+        data: undefined,
+        fullOutputPath: undefined,
+        fullOutputPaths: undefined,
+        imagePath: undefined,
+        imagePaths: undefined,
+        savedFile: undefined,
+        savedFilePath: undefined,
+        summary: `${draft.input.prepared.redactedArgs.join(" ")} completed`,
+    };
+}
+function previousContactSheetPath(draft) {
+    const key = draft.sessionStateKey;
+    return key !== undefined && key.length > 0
+        ? draft.input.state.activeRecordingReservations?.get(key)?.contactSheetPath
+        : undefined;
+}
+function presentationCleanupOwnership(draft) {
+    const key = draft.sessionStateKey;
+    return key !== undefined &&
+        key.length > 0 &&
+        (draft.input.state.ownedManagedSessions.has(key) ||
+            draft.input.prepared.executionPlan.managedSessionName !== undefined)
+        ? "wrapper-managed"
+        : "caller-owned";
+}
+async function buildNativePresentation(draft) {
+    if (draft.plainTextInspection) {
+        return inspectionPresentation(draft);
+    }
+    if (draft.recordingStopRecovery && !draft.recordingStopRecovery.batch) {
+        return draft.recordingStopRecovery.presentation;
+    }
+    return buildToolPresentation({
+        textOutput: draft.textOutput,
+        stdin: draft.input.prepared.processStdin,
+        modelVisible: draft.input.modelVisible,
+        args: draft.input.prepared.redactedProcessArgs,
+        artifactManifest: draft.artifactManifest,
+        artifactMaxUpdatedAtMs: Date.now(),
+        artifactMinUpdatedAtMs: draft.input.artifactRunStartedAtMs,
+        artifactRequest: draft.screenshotArtifactRequest,
+        batchArtifactRequests: draft.batchScreenshotArtifactRequests,
+        commandInfo: {
+            ...draft.input.prepared.executionPlan.commandInfo,
+            commandTokens: draft.input.prepared.commandTokens,
+        },
+        compiledSemanticAction: draft.input.prepared.compiledSemanticAction,
+        cwd: draft.operationCwd,
+        envelope: draft.presentationEnvelope,
+        errorText: draft.errorText,
+        namespace: draft.input.prepared.executionPlan.namespace,
+        networkRouteDiagnostics: draft.diagnostics.networkRouteDiagnostics,
+        networkRoutes: draft.activeNetworkRoutes,
+        persistentArtifactStore: draft.persistentArtifactStore,
+        previousRecordingContactSheetPath: previousContactSheetPath(draft),
+        piCleanupOwnership: presentationCleanupOwnership(draft),
+        sessionName: draft.input.prepared.executionPlan.sessionName,
+    });
+}
+function preparedSessionRetained(draft) {
+    return (!draft.managedSessionOutcome ||
+        (draft.managedSessionOutcome.activeAfter &&
+            draft.managedSessionOutcome.attemptedSessionName ===
+                draft.managedSessionOutcome.currentSessionName));
+}
+function renderParseFailureNotice(draft) {
+    const path = draft.parseFailureOutput.fullOutputPath ?? "";
+    const unavailable = draft.parseFailureOutput.fullOutputUnavailable ?? "";
+    if (path.length === 0 && unavailable.length === 0) {
+        return;
+    }
+    const firstContent = draft.presentation.content.at(0);
+    const existingText = firstContent?.type === "text" ? firstContent.text : "";
+    const noticeLines = [
+        path.length > 0 ? `Full output path: ${path}` : `Full raw output unavailable: ${unavailable}`,
+        draft.parseFailureOutput.artifactRetentionSummary,
+    ].filter((item) => item !== undefined);
+    const notice = noticeLines.join("\n");
+    draft.presentation.content[0] = {
+        type: "text",
+        text: existingText.length > 0 ? `${existingText}\n\n${notice}` : notice,
+    };
+}
+function batchRouteEffect(item) {
+    if (!isRecord(item) || !isStringArray(item.command)) {
+        return;
+    }
+    return {
+        tokens: extractUpstreamCommandTokens(item.command),
+        succeeded: item.success !== false && !detectConfirmationRequired(item.result),
+    };
+}
+function applyBatchNetworkRouteState(draft) {
+    const key = draft.sessionStateKey;
+    const data = draft.presentationEnvelope?.data;
+    if (!draft.succeeded || key === undefined || key.length === 0 || !Array.isArray(data)) {
+        return;
+    }
+    let routes = draft.networkRoutesBySession.get(key);
+    for (const item of data) {
+        const effect = batchRouteEffect(item);
+        if (!effect) {
+            continue;
+        }
+        routes =
+            effect.succeeded && isCloseCommand(effect.tokens[0])
+                ? undefined
+                : applyNetworkRouteRecords(routes, effect.tokens, effect.succeeded);
+    }
+    draft.networkRoutesBySession = setNetworkRouteState({
+        routes,
+        routesBySession: draft.networkRoutesBySession,
+        sessionName: key,
+    });
+}

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

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

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

@@ -0,0 +1,71 @@
+import { renderNativePresentation, reclassifyPresentation } from "./process-output-presentation.js";
+import { bindOutputDaemonReceipt, publishConfirmedSnapshot } from "./process-output-receipts.js";
+import { analyzeOutputChecks, renderAttachedQaBanner, collectEvalGuidance, } from "./process-output-analysis.js";
+import { collectPublicationWarnings, recoverFinalOutput } from "./process-output-publication.js";
+function createPublicationOutputPhase(input, native, page, lifecycle) {
+    return {
+        input,
+        aboutBlankSessionMismatch: lifecycle.aboutBlankSessionMismatch,
+        activeNetworkRoutes: page.activeNetworkRoutes,
+        artifactCleanup: undefined,
+        artifactManifest: lifecycle.artifactManifest,
+        authoritativePageState: undefined,
+        batchRefSnapshotState: page.batchRefSnapshotState,
+        batchScreenshotArtifactRequests: native.batchScreenshotArtifactRequests,
+        commandClosesSession: lifecycle.commandClosesSession,
+        confirmationFromHelper: lifecycle.confirmationFromHelper,
+        confirmedEffects: page.confirmedEffects,
+        currentRefSnapshot: lifecycle.currentRefSnapshot,
+        currentRefSnapshotInvalidation: lifecycle.currentRefSnapshotInvalidation,
+        currentSessionTabTarget: lifecycle.currentSessionTabTarget,
+        currentSessionTabTargetUnknown: undefined,
+        electronHandoff: lifecycle.electronHandoff,
+        electronPostCommandHealth: page.electronPostCommandHealth,
+        electronSessionMismatch: page.electronSessionMismatch,
+        errorText: lifecycle.errorText,
+        evalResultWarning: undefined,
+        evalStdinHint: undefined,
+        inspectionText: native.inspectionText,
+        managedSessionOutcome: lifecycle.managedSessionOutcome,
+        navigationSummary: page.navigationSummary,
+        diagnostics: page.diagnostics,
+        networkRoutesBySession: lifecycle.networkRoutesBySession,
+        networkSourceLookup: undefined,
+        operationCwd: input.operationCwd ?? input.cwd,
+        parseError: lifecycle.parseError,
+        parseFailureOutput: native.parseFailureOutput,
+        parseSucceeded: lifecycle.parseSucceeded,
+        persistentArtifactStore: native.persistentArtifactStore,
+        plainTextInspection: lifecycle.plainTextInspection,
+        plainTextUpgrade: lifecycle.plainTextUpgrade,
+        presentation: { content: [], summary: "" },
+        presentationEnvelope: lifecycle.presentationEnvelope,
+        processSucceeded: lifecycle.processSucceeded,
+        qaAttachedTarget: undefined,
+        qaPreset: undefined,
+        readConfirmationEvent: lifecycle.readConfirmationEvent,
+        recordingStopRecovery: lifecycle.recordingStopRecovery,
+        redactedContent: [],
+        resultArtifactManifest: undefined,
+        screenshotArtifactRequest: native.screenshotArtifactRequest,
+        sessionStateKey: lifecycle.sessionStateKey,
+        sessionTabCorrection: lifecycle.sessionTabCorrection,
+        sourceLookup: undefined,
+        succeeded: lifecycle.succeeded,
+        textOutput: lifecycle.textOutput,
+        unobservedMutation: page.unobservedMutation,
+    };
+}
+export async function publishOutputEffects(input, native, page, lifecycle) {
+    const draft = createPublicationOutputPhase(input, native, page, lifecycle);
+    await renderNativePresentation(draft);
+    reclassifyPresentation(draft);
+    await analyzeOutputChecks(draft);
+    renderAttachedQaBanner(draft);
+    collectEvalGuidance(draft);
+    await collectPublicationWarnings(draft);
+    const recovery = await recoverFinalOutput(draft);
+    await bindOutputDaemonReceipt(draft);
+    publishConfirmedSnapshot(draft);
+    return { publication: draft, recovery };
+}