pi-agent-browser-native 0.9.5 → 0.9.6

package/dist/extensions/agent-browser/lib/results/presentation/batch-redaction.js

@@ -1,68 +0,0 @@
-import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
-import { redactSensitiveText, redactSensitiveValue } from "../../runtime-redaction.js";
-import { isRecord } from "../../parsing.js";
-import { getClipboardWritePayloadCandidates, redactClipboardPermissionErrorValue, } from "./errors.js";
-export function hasModelFacingArgRedaction(args) {
-    return (args?.some((arg) => arg === "[REDACTED]" || arg.includes("%5BREDACTED%5D") || arg.includes("[REDACTED]")) === true);
-}
-function getPasswordValues(tokens) {
-    const values = [];
-    for (let index = 0; index < tokens.length; index += 1) {
-        const token = tokens[index];
-        const next = tokens.at(index + 1);
-        if (token === "--password" && next !== undefined && next.length > 0) {
-            values.push(next);
-        }
-        else if (token.startsWith("--password=")) {
-            values.push(token.slice("--password=".length));
-        }
-    }
-    return values;
-}
-function getStatefulValue(tokens) {
-    if (tokens[0] === "cookies" && tokens[1] === "set" && !tokens.slice(2).includes("--curl")) {
-        return tokens.at(3);
-    }
-    if (tokens[0] === "storage" &&
-        ["local", "session"].includes(tokens[1] ?? "") &&
-        tokens[2] === "set") {
-        return tokens.at(4);
-    }
-    return undefined;
-}
-function getStatefulCommandSensitiveValues(command) {
-    if (!command) {
-        return [];
-    }
-    const tokens = extractUpstreamCommandTokens(command);
-    const statefulValue = getStatefulValue(tokens);
-    const values = getPasswordValues(tokens);
-    if (statefulValue !== undefined) {
-        values.unshift(statefulValue);
-    }
-    return values.filter((value) => value.length > 0);
-}
-function redactExactValues(value, sensitiveValues) {
-    if (sensitiveValues.length === 0) {
-        return redactSensitiveValue(value);
-    }
-    if (typeof value === "string") {
-        let redacted = value;
-        for (const sensitive of sensitiveValues) {
-            redacted = redacted.split(sensitive).join("[REDACTED]");
-        }
-        return redactSensitiveText(redacted);
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => redactExactValues(item, sensitiveValues));
-    }
-    if (!isRecord(value)) {
-        return value;
-    }
-    return redactSensitiveValue(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactExactValues(item, sensitiveValues)])));
-}
-export function redactBatchStepErrorData(command, value) {
-    return command?.[0] === "clipboard"
-        ? redactSensitiveValue(redactClipboardPermissionErrorValue({ command: "clipboard", subcommand: command[1] }, value, getClipboardWritePayloadCandidates(command)))
-        : redactExactValues(value, getStatefulCommandSensitiveValues(command));
-}

package/dist/extensions/agent-browser/lib/results/presentation/batch-rendering.js

@@ -1,135 +0,0 @@
-import { getPresentationImages } from "./content.js";
-function getTypedTextLength(command) {
-    return command?.[0] === "keyboard" && command[1] === "type" && typeof command.at(2) === "string"
-        ? Array.from(command[2]).length
-        : undefined;
-}
-function getWaitDelayMs(command) {
-    const delay = command?.at(1);
-    return command?.[0] === "wait" && delay !== undefined && /^\d+$/.test(delay) ? delay : undefined;
-}
-function getTypingDelayBetween(steps, index) {
-    const delay = steps.at(index + 1)?.details;
-    const next = steps.at(index + 2)?.details;
-    if (!delay ||
-        !next ||
-        !delay.success ||
-        !next.success ||
-        getTypedTextLength(next.command) === undefined) {
-        return undefined;
-    }
-    return getWaitDelayMs(delay.command);
-}
-function getTypedPulse(steps, index) {
-    const step = steps.at(index)?.details;
-    if (!step || !step.success) {
-        return undefined;
-    }
-    const chars = getTypedTextLength(step.command);
-    if (chars === undefined) {
-        return undefined;
-    }
-    const delay = getTypingDelayBetween(steps, index);
-    return { chars, delay, nextIndex: index + (delay === undefined ? 1 : 2) };
-}
-function scanTypingRun(steps, start) {
-    let index = start;
-    let typedCharCount = 0;
-    let typedStepCount = 0;
-    let delayMs;
-    while (index < steps.length) {
-        const pulse = getTypedPulse(steps, index);
-        if (!pulse) {
-            break;
-        }
-        typedCharCount += pulse.chars;
-        typedStepCount += 1;
-        if (pulse.delay !== undefined) {
-            if (delayMs !== undefined && delayMs !== pulse.delay) {
-                return undefined;
-            }
-            delayMs = pulse.delay;
-        }
-        index = pulse.nextIndex;
-    }
-    return typedStepCount >= 2 ? { nextIndex: index, typedCharCount, delayMs } : undefined;
-}
-function getTypingStart(steps, index) {
-    const details = steps.at(index)?.details;
-    if (!details || !details.success) {
-        return undefined;
-    }
-    if (details.command?.[0] === "focus" && typeof details.command.at(1) === "string") {
-        return { firstIndex: details.index, typingIndex: index + 1, target: details.command[1] };
-    }
-    return { firstIndex: details.index, typingIndex: index };
-}
-function getPressAfterTyping(steps, index) {
-    const details = steps.at(index)?.details;
-    if (!details || !details.success || details.command?.[0] !== "press") {
-        return undefined;
-    }
-    return details.command.at(1);
-}
-function formatTypedSequenceSummary(steps, startIndex) {
-    const start = getTypingStart(steps, startIndex);
-    if (!start) {
-        return undefined;
-    }
-    const run = scanTypingRun(steps, start.typingIndex);
-    if (!run) {
-        return undefined;
-    }
-    const pressedKey = getPressAfterTyping(steps, run.nextIndex);
-    const nextIndex = run.nextIndex + (pressedKey !== undefined ? 1 : 0);
-    const firstStep = start.firstIndex + 1;
-    const lastIndex = steps.at(nextIndex - 1)?.details.index;
-    const lastStep = lastIndex === undefined ? undefined : lastIndex + 1;
-    const range = lastStep !== undefined && lastStep > firstStep ? `${firstStep}-${lastStep}` : String(firstStep);
-    return { nextIndex, text: formatTypingSummaryText(range, start.target, run, pressedKey) };
-}
-function formatTypingSummaryText(range, target, run, pressedKey) {
-    const label = target !== undefined && target.length > 0 ? `type ${target}` : "keyboard type";
-    const lines = [
-        `Step ${range} — ${label} (succeeded)`,
-        `Typed ${run.typedCharCount} char${run.typedCharCount === 1 ? "" : "s"}${run.delayMs !== undefined ? ` with delayMs=${run.delayMs}` : ""}.`,
-    ];
-    if (pressedKey !== undefined && pressedKey.length > 0) {
-        lines.push(`Pressed ${pressedKey}.`);
-    }
-    return lines.join("\n");
-}
-function formatBatchStepDetails(step) {
-    const details = step.details;
-    const images = getPresentationImages(step.presentation).length;
-    const lines = [
-        `Step ${details.index + 1} — ${details.commandText} (${details.success ? "succeeded" : "failed"})`,
-    ];
-    if (details.text.length > 0) {
-        lines.push(details.text);
-    }
-    if (images > 0) {
-        lines.push(`(${images} inline image attachment${images === 1 ? "" : "s"} below)`);
-    }
-    return lines.join("\n");
-}
-export function formatBatchStepsText(steps) {
-    if (steps.length === 0) {
-        return "(no batch steps)";
-    }
-    const lines = [];
-    for (let index = 0; index < steps.length;) {
-        const sequence = formatTypedSequenceSummary(steps, index);
-        if (sequence) {
-            lines.push(sequence.text);
-            index = sequence.nextIndex;
-            continue;
-        }
-        const step = steps.at(index);
-        if (step) {
-            lines.push(formatBatchStepDetails(step));
-        }
-        index += 1;
-    }
-    return lines.join("\n\n");
-}

package/dist/extensions/agent-browser/lib/results/presentation/batch-step.js

@@ -1,227 +0,0 @@
-import { parseCommandInfo } from "../../argv-descriptor.js";
-import { isRecord } from "../../parsing.js";
-import { redactInvocationArgs } from "../../runtime-redaction.js";
-import { buildAgentBrowserNextActions } from "../action-recommendations.js";
-import { buildPendingWebMcpNextActions } from "../recovery-next-actions.js";
-import { classifyAgentBrowserFailureCategory } from "../categories.js";
-import { detectConfirmationRequired } from "../confirmation.js";
-import { applyNamespaceToNextActions, withOptionalSessionArgs } from "../next-actions.js";
-import { buildNetworkRouteDiagnostics } from "../network-routes.js";
-import { extractAgentBrowserLifecycle, stringifyModelFacing } from "./common.js";
-import { classifyPresentationSuccessCategory } from "./artifacts.js";
-import { formatBatchStepCommand, getPresentationPaths, getPresentationText, isStringArray, } from "./content.js";
-import { buildPageChangeSummary } from "./navigation.js";
-import { appendSelectorRecoveryHint, isOverlayBlockedClickError } from "./errors.js";
-import { hasModelFacingArgRedaction, redactBatchStepErrorData } from "./batch-redaction.js";
-function createStepIdentity(item, index) {
-    const command = isStringArray(item.command) ? item.command : undefined;
-    const redactedCommand = command ? redactInvocationArgs(command) : undefined;
-    return {
-        command,
-        redactedCommand,
-        index,
-        commandText: formatBatchStepCommand(hasModelFacingArgRedaction(redactedCommand) ? redactedCommand : command, index),
-        lifecycle: extractAgentBrowserLifecycle(item.result),
-    };
-}
-function formatBatchStepError(error) {
-    const text = stringifyModelFacing(error).trim();
-    return appendSelectorRecoveryHint(text.length > 0 ? `Error: ${text}` : "Error: batch step failed.");
-}
-function buildWaitTextAssertionFailureAction(sessionName) {
-    return {
-        id: "inspect-after-text-assertion-failure",
-        params: { args: withOptionalSessionArgs(sessionName, ["snapshot", "-i"]) },
-        reason: "Inspect the current page after the text assertion failed before concluding the expected text is absent.",
-        safety: "Read-only snapshot; use current refs or visible text from this page before retrying the assertion.",
-        tool: "agent_browser",
-    };
-}
-function describeStepFailure(command, error) {
-    const data = redactBatchStepErrorData(command, error);
-    const text = formatBatchStepError(data);
-    return {
-        data,
-        text,
-        category: classifyAgentBrowserFailureCategory({
-            args: command,
-            command: command?.[0],
-            errorText: text,
-        }),
-        confirmationId: detectConfirmationRequired(error)?.id,
-        overlayBlocked: isOverlayBlockedClickError(command?.[0], text, command),
-    };
-}
-function buildFailedStepActions(command, failure, scope) {
-    const recovery = buildAgentBrowserNextActions({
-        args: command,
-        command: command?.[0],
-        confirmationId: failure.confirmationId,
-        failureCategory: failure.category,
-        overlayBlockedClick: failure.overlayBlocked,
-        resultCategory: "failure",
-        sessionName: scope.sessionName,
-        subcommand: command?.[1],
-    });
-    const waitAction = command?.[0] === "wait" && command.includes("--text")
-        ? [buildWaitTextAssertionFailureAction(scope.sessionName)]
-        : [];
-    const seen = new Set();
-    const actions = [...waitAction, ...(recovery ?? [])].filter((action) => {
-        if (seen.has(action.id)) {
-            return false;
-        }
-        seen.add(action.id);
-        return true;
-    });
-    return applyNamespaceToNextActions(actions.length > 0 ? actions : undefined, scope.namespace);
-}
-function buildFailedStep(item, identity, scope) {
-    const failure = describeStepFailure(identity.command, item.error);
-    const { data, text, category: failureCategory } = failure;
-    const nextActions = buildFailedStepActions(identity.command, failure, scope);
-    const presentation = {
-        content: [{ type: "text", text }],
-        failureCategory,
-        nextActions,
-        resultCategory: "failure",
-        summary: text,
-    };
-    return {
-        presentation,
-        details: {
-            artifactVerification: presentation.artifactVerification,
-            artifacts: presentation.artifacts,
-            command: identity.redactedCommand,
-            commandText: identity.commandText,
-            data,
-            failureCategory,
-            index: identity.index,
-            lifecycle: identity.lifecycle,
-            nextActions,
-            resultCategory: "failure",
-            success: false,
-            summary: text,
-            text,
-        },
-    };
-}
-function buildNestedRequest(options, command) {
-    const commandInfo = parseCommandInfo(command ?? []);
-    return {
-        modelVisible: options.modelVisible,
-        artifactManifest: options.artifactManifest,
-        artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs,
-        artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs,
-        artifactRequest: options.artifactRequest,
-        commandInfo: command ? { ...commandInfo, commandTokens: command } : commandInfo,
-        cwd: options.cwd,
-        args: command,
-        envelope: {
-            data: options.item.result,
-            success: options.item.success !== false,
-            error: options.item.error,
-        },
-        errorText: options.item.success === false
-            ? formatBatchStepError(redactBatchStepErrorData(command, options.item.error))
-            : undefined,
-        piCleanupOwnership: options.piCleanupOwnership,
-        networkRouteDiagnostics: commandInfo.command === "network" && commandInfo.subcommand === "requests"
-            ? buildNetworkRouteDiagnostics(options.item.result, options.networkRoutes)
-            : undefined,
-        namespace: options.namespace,
-        persistentArtifactStore: options.persistentArtifactStore,
-        sessionName: options.sessionName,
-    };
-}
-function isPendingWebMcpMutation(command, data) {
-    return (command.command === "webmcp" &&
-        ["invoke", "result"].includes(command.subcommand ?? "") &&
-        isRecord(data) &&
-        data.status === "pending");
-}
-function buildStandardStepActions(presentation, command, sessionName) {
-    return (presentation.nextActions ??
-        buildAgentBrowserNextActions({
-            artifacts: presentation.artifacts,
-            args: command,
-            command: command?.[0],
-            failureCategory: presentation.failureCategory,
-            resultCategory: presentation.resultCategory !== "failure" ? "success" : "failure",
-            savedFilePath: presentation.savedFilePath,
-            sessionName,
-            subcommand: command?.[1],
-            successCategory: presentation.successCategory,
-        }));
-}
-function getStepNextActions(presentation, commandInfo, command, scope) {
-    const actions = presentation.resultCategory !== "failure" &&
-        isPendingWebMcpMutation(commandInfo, presentation.data)
-        ? buildPendingWebMcpNextActions(scope.sessionName)
-        : buildStandardStepActions(presentation, command, scope.sessionName);
-    return applyNamespaceToNextActions(actions, scope.namespace);
-}
-function buildStepDetails(presentation, identity, command, scope) {
-    const fullOutputPaths = getPresentationPaths({
-        primaryPath: presentation.fullOutputPath,
-        secondaryPaths: presentation.fullOutputPaths,
-    });
-    const imagePaths = getPresentationPaths({
-        primaryPath: presentation.imagePath,
-        secondaryPaths: presentation.imagePaths,
-    });
-    const text = getPresentationText(presentation);
-    const succeeded = presentation.resultCategory !== "failure";
-    const nextActions = getStepNextActions(presentation, command, identity.command, scope);
-    return {
-        artifactVerification: presentation.artifactVerification,
-        artifacts: presentation.artifacts,
-        command: identity.redactedCommand,
-        commandText: identity.commandText,
-        data: presentation.data,
-        failureCategory: succeeded ? undefined : presentation.failureCategory,
-        fullOutputPath: fullOutputPaths.at(0),
-        fullOutputPaths: fullOutputPaths.length > 0 ? fullOutputPaths : undefined,
-        imagePath: imagePaths.at(0),
-        imagePaths: imagePaths.length > 0 ? imagePaths : undefined,
-        imageObservations: presentation.imageObservations,
-        index: identity.index,
-        lifecycle: identity.lifecycle,
-        networkRouteDiagnostics: presentation.networkRouteDiagnostics,
-        nextActions,
-        pageChangeSummary: buildPageChangeSummary({
-            artifacts: presentation.artifacts,
-            commandInfo: command,
-            data: presentation.data,
-            nextActions,
-            savedFilePath: presentation.savedFilePath,
-            summary: presentation.summary,
-        }),
-        resultCategory: succeeded ? "success" : "failure",
-        savedFile: presentation.savedFile,
-        savedFilePath: presentation.savedFilePath,
-        success: succeeded,
-        successCategory: succeeded
-            ? classifyPresentationSuccessCategory({
-                artifactVerification: presentation.artifactVerification,
-                artifacts: presentation.artifacts,
-                savedFile: presentation.savedFile,
-            })
-            : undefined,
-        summary: presentation.summary,
-        text: text.length > 0 ? text : presentation.summary,
-    };
-}
-export async function buildBatchStepPresentation(options) {
-    const identity = createStepIdentity(options.item, options.index);
-    const scope = { namespace: options.namespace, sessionName: options.sessionName };
-    if (options.item.success === false && identity.command?.[0] !== "record") {
-        return buildFailedStep(options.item, identity, scope);
-    }
-    const request = buildNestedRequest(options, identity.command);
-    const presentation = await options.buildNestedToolPresentation(request);
-    return {
-        details: buildStepDetails(presentation, identity, request.commandInfo, scope),
-        presentation,
-    };
-}

package/dist/extensions/agent-browser/lib/results/presentation/batch-summary.js

@@ -1,91 +0,0 @@
-import { formatBatchStepsText } from "./batch-rendering.js";
-import { buildPageChangeSummary } from "./navigation.js";
-function getBatchFailure(steps) {
-    const failed = steps.filter((step) => !step.details.success);
-    const first = failed.at(0);
-    return first
-        ? {
-            failedStep: first.details,
-            failureCount: failed.length,
-            successCount: steps.length - failed.length,
-            totalCount: steps.length,
-        }
-        : undefined;
-}
-function countUnverifiedMutations(steps) {
-    return steps.filter((step) => step.details.pageChangeSummary?.changeType === "mutation" &&
-        !step.details.pageChangeSummary.observed).length;
-}
-export function summarizeBatchStatus(steps, requestedSummary) {
-    const failure = getBatchFailure(steps);
-    const summary = failure
-        ? `Batch failed: ${failure.successCount}/${failure.totalCount} succeeded`
-        : requestedSummary;
-    const mutations = countUnverifiedMutations(steps);
-    return {
-        failure,
-        summary,
-        header: failure
-            ? [
-                summary,
-                `First failing step: ${failure.failedStep.index + 1} — ${failure.failedStep.commandText}`,
-                failure.failureCount > 1
-                    ? `${failure.failureCount} steps failed. See the per-step results below.`
-                    : "See the per-step results below.",
-            ].join("\n")
-            : undefined,
-        mutationEvidenceText: mutations > 0
-            ? `Mutation evidence: ${mutations} action result${mutations === 1 ? " proves" : "s prove"} dispatch only, not application state change. Use explicit later assertions or external receipts as postconditions; fixed waits are not postconditions.`
-            : undefined,
-    };
-}
-export function formatBatchStatusText(steps, status, modelVisible) {
-    return [
-        status.header,
-        status.mutationEvidenceText,
-        modelVisible === false ? "" : formatBatchStepsText(steps),
-    ]
-        .filter((line) => line !== undefined)
-        .join("\n\n");
-}
-export function serializeBatchData(steps) {
-    return steps.map(({ details }) => details.success
-        ? { command: details.command, result: details.data, success: true }
-        : {
-            command: details.command,
-            error: details.text,
-            ...(details.command?.[0] === "record" ? { result: details.data } : {}),
-            success: false,
-        });
-}
-function formatBatchChangeText(observed, unverified) {
-    if (observed === 0) {
-        return `batch → ${unverified} action${unverified === 1 ? "" : "s"} dispatched → application change unverified`;
-    }
-    return `batch → ${observed} observed change${observed === 1 ? "" : "s"}${unverified > 0 ? `; ${unverified} dispatched action${unverified === 1 ? "" : "s"} unverified` : ""}`;
-}
-export function buildBatchPageChangeSummary(steps, artifacts, nextActions, summary) {
-    if (artifacts.length > 0) {
-        return buildPageChangeSummary({
-            artifacts,
-            commandInfo: { command: "batch" },
-            data: serializeBatchData(steps),
-            nextActions,
-            summary,
-        });
-    }
-    const changed = steps
-        .map((step) => step.details)
-        .filter((details) => details.pageChangeSummary !== undefined);
-    if (changed.length === 0) {
-        return undefined;
-    }
-    const observed = changed.filter((details) => details.pageChangeSummary?.observed === true).length;
-    return {
-        changeType: "mutation",
-        command: "batch",
-        nextActionIds: nextActions?.map((action) => action.id),
-        observed: observed > 0,
-        summary: formatBatchChangeText(observed, countUnverifiedMutations(steps)),
-    };
-}

package/dist/extensions/agent-browser/lib/results/presentation/batch.js

@@ -1,123 +0,0 @@
-import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
-import { isRecord } from "../../parsing.js";
-import { buildAgentBrowserNextActions } from "../action-recommendations.js";
-import { formatSessionArtifactRetentionSummary } from "../artifact-manifest.js";
-import { applyNetworkRouteRecords } from "../network-routes.js";
-import { appendUniqueAgentBrowserNextActions, applyNamespaceToNextActions, } from "../next-actions.js";
-import { buildArtifactVerificationSummary, classifyPresentationSuccessCategory, manifestHasNewNoticeWorthyEntries, } from "./artifacts.js";
-import { getPresentationImages, getPresentationPaths, isStringArray } from "./content.js";
-import { buildBatchStepPresentation } from "./batch-step.js";
-import { coalesceTerminalBatchRecordingArtifacts } from "./batch-recording.js";
-import { buildBatchPageChangeSummary, formatBatchStatusText, serializeBatchData, summarizeBatchStatus, } from "./batch-summary.js";
-export { redactBatchStepErrorData } from "./batch-redaction.js";
-export function isAgentBrowserBatchResultArray(value) {
-    return (Array.isArray(value) &&
-        value.every((row) => isRecord(row) &&
-            (row.command === undefined || isStringArray(row.command)) &&
-            (row.success === undefined || typeof row.success === "boolean")));
-}
-async function collectPresentedSteps(options) {
-    const steps = [];
-    const protectedPaths = [];
-    let manifest = options.artifactManifest;
-    let routes = options.networkRoutes;
-    for (const [index, item] of options.data.entries()) {
-        // Each row updates artifact protection/manifest and route state required by the following row.
-        // oxlint-disable-next-line no-await-in-loop
-        const step = await buildBatchStepPresentation({
-            modelVisible: options.modelVisible,
-            artifactManifest: manifest,
-            artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs,
-            artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs,
-            artifactRequest: options.artifactRequests?.[index],
-            buildNestedToolPresentation: options.buildNestedToolPresentation,
-            cwd: options.cwd,
-            index,
-            item,
-            piCleanupOwnership: options.piCleanupOwnership,
-            namespace: options.namespace,
-            networkRoutes: routes,
-            persistentArtifactStore: options.persistentArtifactStore
-                ? { ...options.persistentArtifactStore, protectedPaths }
-                : undefined,
-            sessionName: options.sessionName,
-        });
-        steps.push(step);
-        manifest = step.presentation.artifactManifest ?? manifest;
-        routes = applyNetworkRouteRecords(routes, isStringArray(item.command) ? extractUpstreamCommandTokens(item.command) : undefined, item.success !== false && step.details.success);
-        protectedPaths.push(...getPresentationPaths({
-            primaryPath: step.presentation.fullOutputPath,
-            secondaryPaths: step.presentation.fullOutputPaths,
-        }));
-    }
-    return { steps, manifest };
-}
-export async function buildBatchPresentation(options) {
-    const { steps, manifest } = await collectPresentedSteps(options);
-    const status = summarizeBatchStatus(steps, options.summary);
-    const artifacts = await coalesceTerminalBatchRecordingArtifacts(steps, options.sessionName, options.namespace);
-    const artifactVerification = buildArtifactVerificationSummary(artifacts);
-    const paths = collectBatchOutputPaths(steps);
-    const text = formatBatchStatusText(steps, status, options.modelVisible);
-    const artifactRetentionSummary = manifest
-        ? formatSessionArtifactRetentionSummary(manifest)
-        : undefined;
-    const contentText = addRetentionNotice(text, artifactRetentionSummary, options.artifactManifest, manifest);
-    const lifecycleActions = applyNamespaceToNextActions(buildAgentBrowserNextActions({
-        artifacts,
-        command: "batch",
-        resultCategory: status.failure ? "failure" : "success",
-        sessionName: options.sessionName,
-    }), options.namespace);
-    const nextActions = status.failure
-        ? appendUniqueAgentBrowserNextActions([...(status.failure.failedStep.nextActions ?? [])], lifecycleActions)
-        : lifecycleActions;
-    return {
-        artifactManifest: manifest,
-        artifactRetentionSummary,
-        artifactVerification,
-        artifacts: artifacts.length > 0 ? artifacts : undefined,
-        batchFailure: status.failure,
-        batchSteps: steps.map((step) => step.details),
-        content: options.modelVisible === false
-            ? []
-            : [
-                { type: "text", text: contentText },
-                ...steps.flatMap((step) => getPresentationImages(step.presentation)),
-            ],
-        failureCategory: status.failure?.failedStep.failureCategory,
-        data: serializeBatchData(steps),
-        ...paths,
-        imageObservations: steps.flatMap((step) => step.presentation.imageObservations ?? []),
-        nextActions,
-        pageChangeSummary: buildBatchPageChangeSummary(steps, artifacts, nextActions, status.summary),
-        resultCategory: status.failure ? "failure" : "success",
-        successCategory: status.failure
-            ? undefined
-            : classifyPresentationSuccessCategory({ artifactVerification, artifacts }),
-        summary: status.summary,
-    };
-}
-function collectBatchOutputPaths(steps) {
-    const fullOutputPaths = steps.flatMap((step) => getPresentationPaths({
-        primaryPath: step.presentation.fullOutputPath,
-        secondaryPaths: step.presentation.fullOutputPaths,
-    }));
-    const imagePaths = steps.flatMap((step) => getPresentationPaths({
-        primaryPath: step.presentation.imagePath,
-        secondaryPaths: step.presentation.imagePaths,
-    }));
-    return {
-        fullOutputPath: fullOutputPaths.at(0),
-        fullOutputPaths: fullOutputPaths.length > 0 ? fullOutputPaths : undefined,
-        imagePath: imagePaths.at(0),
-        imagePaths: imagePaths.length > 0 ? imagePaths : undefined,
-    };
-}
-function addRetentionNotice(text, notice, original, current) {
-    return notice !== undefined &&
-        notice.length > 0 &&
-        manifestHasNewNoticeWorthyEntries(original, current)
-        ? `${text}\n\n${notice}`
-        : text;
-}