pi-agent-browser-native 0.9.3 → 0.9.4

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

@@ -0,0 +1,70 @@
+import { isAgentBrowserBatchResultArray } from "./batch.js";
+import { redactModelFacingText } from "./common.js";
+import { redactPresentationData } from "./diagnostics.js";
+import { buildErrorPresentation } from "./errors.js";
+import { compactLargePresentationOutput } from "./large-output.js";
+import { stringifyUnknown } from "../text.js";
+function getNativeTextSummary(text) {
+    const first = text.split("\n", 1).at(0);
+    return first !== undefined && first.length > 0 ? first : "Native text command completed.";
+}
+export function sanitizeModelFacingPresentation(presentation) {
+    return {
+        ...presentation,
+        content: presentation.content.map((item) => item.type === "text" ? { ...item, text: redactModelFacingText(item.text) } : item),
+        summary: redactModelFacingText(presentation.summary),
+    };
+}
+async function buildNativeTextPresentation(options, commandInfo) {
+    const value = redactPresentationData(commandInfo, typeof options.envelope?.data === "string" ? options.envelope.data : "", options.stdin);
+    const text = typeof value === "string" ? value : stringifyUnknown(value);
+    const failure = options.errorText !== undefined && options.errorText.length > 0
+        ? buildErrorPresentation({
+            args: options.args,
+            commandInfo: options.commandInfo,
+            errorText: options.errorText,
+            sessionName: options.sessionName,
+        })
+        : undefined;
+    const presentation = {
+        ...failure,
+        content: options.modelVisible === false
+            ? []
+            : [{ type: "text", text: [options.errorText, text].filter(Boolean).join("\n\n") }],
+        data: text,
+        summary: failure?.summary ?? getNativeTextSummary(text),
+    };
+    return sanitizeModelFacingPresentation(options.modelVisible === false
+        ? presentation
+        : await compactLargePresentationOutput({
+            artifactManifest: options.artifactManifest,
+            commandInfo: options.commandInfo,
+            data: presentation.data,
+            persistentArtifactStore: options.persistentArtifactStore,
+            presentation,
+        }));
+}
+export async function buildEarlyPresentation(options, commands) {
+    if (options.textOutput === true) {
+        return buildNativeTextPresentation(options, commands.commandInfo);
+    }
+    const recordingBatch = options.commandInfo.command === "batch" &&
+        isAgentBrowserBatchResultArray(options.envelope?.data) &&
+        options.envelope.data.some((row) => row.command?.[0] === "record");
+    if (options.errorText !== undefined &&
+        options.errorText.length > 0 &&
+        options.commandInfo.command !== "record" &&
+        !recordingBatch) {
+        return {
+            ...buildErrorPresentation({
+                args: options.args,
+                commandInfo: options.commandInfo,
+                errorText: options.errorText,
+                presentationCommand: commands.presentationCommandInfo.command,
+                sessionName: options.sessionName,
+            }),
+            data: redactPresentationData(commands.commandInfo, options.envelope?.data),
+        };
+    }
+    return undefined;
+}

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

@@ -1,5 +1,7 @@
 import { isOpenNavigationCommand } from "../../command-taxonomy.js";
-import { extractUpstreamCommandTokens, redactSensitiveText } from "../../runtime.js";
+import { isRecord } from "../../parsing.js";
+import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
+import { redactSensitiveText } from "../../runtime-redaction.js";
 import { buildBrowserProfileConfigRecovery } from "./browser-profile-recovery.js";
 import { redactModelFacingText } from "./common.js";
 import { buildAgentBrowserNextActions } from "../action-recommendations.js";
@@ -23,13 +25,11 @@ const KEYBOARD_PRESS_ERROR_HINT = [
     "Agent-browser keyboard hint: upstream keyboard commands are `keyboard type <text>` and `keyboard inserttext <text>`; `keyboard press` is not a supported subcommand in the targeted upstream version.",
     'For Enter in text fields, use `keyboard type "\\n"` after focusing the intended control, then verify with a fresh snapshot, URL, or page-state check.',
 ].join(" ");
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
 function getSelectorRecoveryHint(errorText) {
     const normalized = errorText.trim();
-    if (normalized.length === 0)
+    if (normalized.length === 0) {
         return undefined;
+    }
     if (/\bUnknown ref\b|\bstale ref\b|\bref\b.*\b(?:not found|missing|expired)\b/i.test(normalized)) {
         return STALE_REF_ERROR_HINT;
     }
@@ -45,90 +45,143 @@ function getSelectorRecoveryHint(errorText) {
     return undefined;
 }
 function getClipboardPermissionHint(commandInfo, errorText) {
-    if (commandInfo.command !== "clipboard")
+    if (commandInfo.command !== "clipboard") {
         return undefined;
+    }
     if (!/\bNotAllowedError\b|\bclipboard\b.*\bpermission denied\b|\bpermission denied\b.*\bclipboard\b/i.test(errorText)) {
         return undefined;
     }
     return CLIPBOARD_PERMISSION_ERROR_HINT;
 }
 function getKeyboardPressHint(commandInfo, errorText) {
-    if (commandInfo.command !== "keyboard" || commandInfo.subcommand !== "press")
+    if (commandInfo.command !== "keyboard" || commandInfo.subcommand !== "press") {
         return undefined;
-    if (!/\bunknown\s+subcommand\b|\bvalid options?\b/i.test(errorText))
+    }
+    if (!/\bunknown\s+subcommand\b|\bvalid options?\b/i.test(errorText)) {
         return undefined;
+    }
     return KEYBOARD_PRESS_ERROR_HINT;
 }
 export function isOverlayBlockedClickError(command, errorText, args) {
     const tokens = args ? extractUpstreamCommandTokens(args) : [];
     const action = tokens[0] === "find"
-        ? tokens[tokens[1] === "nth" ? 4 : 3] ?? "click"
-        : tokens[0] ?? command;
-    return action === "click" && errorText !== undefined && /\bis covered by\b[\s\S]*\bat its click point\b/i.test(errorText);
+        ? (tokens[tokens[1] === "nth" ? 4 : 3] ?? "click")
+        : (tokens[0] ?? command);
+    return (action === "click" &&
+        errorText !== undefined &&
+        /\bis covered by\b[\s\S]*\bat its click point\b/i.test(errorText));
 }
 export function redactClipboardPermissionEcho(commandInfo, errorText) {
-    if (commandInfo.command !== "clipboard")
+    if (commandInfo.command !== "clipboard") {
         return errorText;
+    }
     return errorText
         .replace(/(\b(?:read|write)\s+permission denied\b(?:\s+for)?\s+)([\s\S]+)$/gi, "$1[REDACTED]")
         .replace(/(\bFailed to execute '[^']+' on 'Clipboard':\s*)([\s\S]+)$/gi, (match, prefix, suffix) => {
-        if (!/\bpermission denied\b/i.test(suffix))
+        if (!/\bpermission denied\b/i.test(suffix)) {
             return match;
+        }
         return `${prefix}${suffix.replace(/(\bpermission denied\b(?:\s+for)?\s+)([\s\S]+)$/i, "$1[REDACTED]")}`;
     });
 }
 export function getClipboardWritePayloadCandidates(commandTokens) {
-    if (commandTokens[0] !== "clipboard" || commandTokens[1] !== "write")
+    if (commandTokens[0] !== "clipboard" || commandTokens[1] !== "write") {
         return [];
+    }
     const payloadTokens = commandTokens.slice(2).filter((value) => value.length > 0);
-    return [...new Set([...payloadTokens, payloadTokens.join(" ")].filter((value) => value.length > 0))];
+    return [
+        ...new Set([...payloadTokens, payloadTokens.join(" ")].filter((value) => value.length > 0)),
+    ];
 }
 function shouldRedactClipboardPayloadField(key, value, payloadCandidates) {
     return payloadCandidates.some((candidate) => {
-        if (value === candidate)
+        if (value === candidate) {
             return true;
-        if (candidate.length < 8 || !/payload|clipboard|argument/i.test(key))
+        }
+        if (candidate.length < 8 || !/payload|clipboard|argument/i.test(key)) {
             return false;
+        }
         return value.includes(candidate);
     });
 }
 export function redactClipboardPermissionErrorValue(commandInfo, value, payloadCandidates = []) {
-    if (commandInfo.command !== "clipboard")
+    if (commandInfo.command !== "clipboard") {
         return value;
-    if (typeof value === "string")
-        return payloadCandidates.includes(value) ? "[REDACTED]" : redactClipboardPermissionEcho(commandInfo, value);
-    if (Array.isArray(value))
+    }
+    if (typeof value === "string") {
+        return payloadCandidates.includes(value)
+            ? "[REDACTED]"
+            : redactClipboardPermissionEcho(commandInfo, value);
+    }
+    if (Array.isArray(value)) {
         return value.map((item) => redactClipboardPermissionErrorValue(commandInfo, item, payloadCandidates));
-    if (!isRecord(value))
+    }
+    if (!isRecord(value)) {
         return value;
+    }
     return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
         key,
-        typeof entryValue === "string" && shouldRedactClipboardPayloadField(key, entryValue, payloadCandidates)
+        typeof entryValue === "string" &&
+            shouldRedactClipboardPayloadField(key, entryValue, payloadCandidates)
             ? "[REDACTED]"
             : redactClipboardPermissionErrorValue(commandInfo, entryValue, payloadCandidates),
     ]));
 }
 const UNKNOWN_COMMAND_SUGGESTIONS = {
-    attr: [{ description: "Use `get attr <selector> <name>` to read an attribute from a selector or current `@ref`." }],
+    attr: [
+        {
+            description: "Use `get attr <selector> <name>` to read an attribute from a selector or current `@ref`.",
+        },
+    ],
     count: [{ description: "Use `get count <selector>` to count matching elements." }],
-    html: [{ description: "Use `get html <selector>` to read element HTML from a selector or current `@ref`; use `get html body` when you need whole-page body HTML." }],
-    text: [{ description: "Use `get text <selector>` to read text from a selector or current `@ref`; run `snapshot -i` first when you need a safe `@ref`." }],
-    title: [{ args: ["get", "title"], description: "Use `get title` to read the current page title.", id: "use-get-title" }],
-    url: [{ args: ["get", "url"], description: "Use `get url` to read the current page URL.", id: "use-get-url" }],
-    value: [{ description: "Use `get value <selector>` to read form control value from a selector or current `@ref`." }],
+    html: [
+        {
+            description: "Use `get html <selector>` to read element HTML from a selector or current `@ref`; use `get html body` when you need whole-page body HTML.",
+        },
+    ],
+    text: [
+        {
+            description: "Use `get text <selector>` to read text from a selector or current `@ref`; run `snapshot -i` first when you need a safe `@ref`.",
+        },
+    ],
+    title: [
+        {
+            args: ["get", "title"],
+            description: "Use `get title` to read the current page title.",
+            id: "use-get-title",
+        },
+    ],
+    url: [
+        {
+            args: ["get", "url"],
+            description: "Use `get url` to read the current page URL.",
+            id: "use-get-url",
+        },
+    ],
+    value: [
+        {
+            description: "Use `get value <selector>` to read form control value from a selector or current `@ref`.",
+        },
+    ],
 };
 function getUnknownCommandSuggestions(command, errorText) {
-    if (!command)
+    if (command === undefined || command.length === 0) {
         return [];
+    }
     const normalizedCommand = command.trim().toLowerCase();
-    if (!/\bunknown\s+command\b|\bunknown\s+subcommand\b|\bunrecognized\s+command\b/i.test(errorText))
+    if (!/\bunknown\s+command\b|\bunknown\s+subcommand\b|\bunrecognized\s+command\b/i.test(errorText)) {
         return [];
+    }
     return UNKNOWN_COMMAND_SUGGESTIONS[normalizedCommand] ?? [];
 }
 function formatUnknownCommandSuggestionText(suggestions) {
-    if (suggestions.length === 0)
+    if (suggestions.length === 0) {
         return undefined;
-    return ["Agent-browser hint: This looks like a getter shortcut, but upstream getter commands are grouped under `get`.", ...suggestions.map((suggestion) => suggestion.description)].join(" ");
+    }
+    return [
+        "Agent-browser hint: This looks like a getter shortcut, but upstream getter commands are grouped under `get`.",
+        ...suggestions.map((suggestion) => suggestion.description),
+    ].join(" ");
 }
 function buildUnknownCommandSuggestionActions(suggestions, sessionName) {
     const actions = suggestions
@@ -143,10 +196,14 @@ function buildUnknownCommandSuggestionActions(suggestions, sessionName) {
     return actions.length > 0 ? actions : undefined;
 }
 function getLocalhostNavigationHint(commandInfo, errorText) {
-    if (!commandInfo.command || !isOpenNavigationCommand(commandInfo.command) || !commandInfo.subcommand)
+    if (!isOpenNavigationCommand(commandInfo.command) ||
+        commandInfo.subcommand === undefined ||
+        commandInfo.subcommand.length === 0) {
         return undefined;
-    if (!/\bnet::ERR_(?:EMPTY_RESPONSE|CONNECTION_REFUSED|ADDRESS_UNREACHABLE|TIMED_OUT|CONNECTION_RESET)\b/i.test(errorText))
+    }
+    if (!/\bnet::ERR_(?:EMPTY_RESPONSE|CONNECTION_REFUSED|ADDRESS_UNREACHABLE|TIMED_OUT|CONNECTION_RESET)\b/i.test(errorText)) {
         return undefined;
+    }
     let targetUrl;
     try {
         targetUrl = new URL(commandInfo.subcommand);
@@ -154,8 +211,9 @@ function getLocalhostNavigationHint(commandInfo, errorText) {
     catch {
         return undefined;
     }
-    if (!["localhost", "127.0.0.1", "::1", "[::1]"].includes(targetUrl.hostname.toLowerCase()))
+    if (!["localhost", "127.0.0.1", "::1", "[::1]"].includes(targetUrl.hostname.toLowerCase())) {
         return undefined;
+    }
     return [
         "Agent-browser local fixture hint: the browser process could not read a loopback URL from its own network namespace or browser host.",
         "Verify the server is still running and bound to an address the browser host can reach; if curl works from the shell but browser navigation fails, try the other loopback alias, add a proxy bypass for localhost/127.0.0.1 if a proxy is configured, or use a browser-host-reachable URL.",
@@ -164,29 +222,39 @@ function getLocalhostNavigationHint(commandInfo, errorText) {
 }
 export function appendSelectorRecoveryHint(errorText) {
     const hint = getSelectorRecoveryHint(errorText);
-    if (!hint || errorText.includes("Agent-browser hint:"))
+    if (hint === undefined || hint.length === 0 || errorText.includes("Agent-browser hint:")) {
         return errorText;
+    }
     return `${errorText}\n\n${hint}`;
 }
+function buildHintedErrorText(commandInfo, errorText, unknownSuggestion, profileHint) {
+    const selectorHinted = appendSelectorRecoveryHint(errorText);
+    return [
+        selectorHinted,
+        unknownSuggestion !== undefined &&
+            unknownSuggestion.length > 0 &&
+            !selectorHinted.includes("Agent-browser hint:")
+            ? unknownSuggestion
+            : undefined,
+        profileHint,
+        getLocalhostNavigationHint(commandInfo, errorText),
+        getClipboardPermissionHint(commandInfo, errorText),
+        getKeyboardPressHint(commandInfo, errorText),
+    ]
+        .filter((part) => part !== undefined && part.length > 0)
+        .join("\n\n");
+}
 export function buildErrorPresentation(options) {
     const { args, commandInfo, errorText, presentationCommand, sessionName } = options;
     const safeErrorText = redactModelFacingText(redactSensitiveText(redactClipboardPermissionEcho(commandInfo, errorText)));
-    const selectorHintedErrorText = appendSelectorRecoveryHint(safeErrorText);
     const unknownCommandSuggestions = getUnknownCommandSuggestions(commandInfo.command, safeErrorText);
     const unknownCommandSuggestionText = formatUnknownCommandSuggestionText(unknownCommandSuggestions);
-    const browserProfileConfigRecovery = buildBrowserProfileConfigRecovery({ args, commandInfo, errorText: safeErrorText });
-    const localhostNavigationHint = getLocalhostNavigationHint(commandInfo, safeErrorText);
-    const clipboardPermissionHint = getClipboardPermissionHint(commandInfo, safeErrorText);
-    const keyboardPressHint = getKeyboardPressHint(commandInfo, safeErrorText);
-    const hintedErrorParts = [
-        selectorHintedErrorText,
-        unknownCommandSuggestionText && !selectorHintedErrorText.includes("Agent-browser hint:") ? unknownCommandSuggestionText : undefined,
-        browserProfileConfigRecovery?.hint,
-        localhostNavigationHint,
-        clipboardPermissionHint,
-        keyboardPressHint,
-    ].filter((part) => Boolean(part));
-    const hintedErrorText = hintedErrorParts.join("\n\n");
+    const browserProfileConfigRecovery = buildBrowserProfileConfigRecovery({
+        args,
+        commandInfo,
+        errorText: safeErrorText,
+    });
+    const hintedErrorText = buildHintedErrorText(commandInfo, safeErrorText, unknownCommandSuggestionText, browserProfileConfigRecovery?.hint);
     const categoryDetails = buildAgentBrowserResultCategoryDetails({
         args: [commandInfo.command, commandInfo.subcommand].filter((item) => item !== undefined),
         command: commandInfo.command,
@@ -196,15 +264,17 @@ export function buildErrorPresentation(options) {
     const nextActions = [
         ...(buildUnknownCommandSuggestionActions(unknownCommandSuggestions, sessionName) ?? []),
         ...(browserProfileConfigRecovery?.actions ?? []),
-        ...(browserProfileConfigRecovery ? [] : buildAgentBrowserNextActions({
-            args,
-            command: commandInfo.command,
-            failureCategory: categoryDetails.failureCategory,
-            overlayBlockedClick: isOverlayBlockedClickError(presentationCommand ?? commandInfo.command, safeErrorText, args ?? commandInfo.commandTokens),
-            resultCategory: "failure",
-            sessionName,
-            subcommand: commandInfo.subcommand,
-        }) ?? []),
+        ...(browserProfileConfigRecovery
+            ? []
+            : (buildAgentBrowserNextActions({
+                args,
+                command: commandInfo.command,
+                failureCategory: categoryDetails.failureCategory,
+                overlayBlockedClick: isOverlayBlockedClickError(presentationCommand ?? commandInfo.command, safeErrorText, args ?? commandInfo.commandTokens),
+                resultCategory: "failure",
+                sessionName,
+                subcommand: commandInfo.subcommand,
+            }) ?? [])),
     ];
     return {
         ...categoryDetails,

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

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

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

@@ -1,29 +1,22 @@
-import { writePersistentSessionArtifactFile, writeSecureTempFile, } from "../../temp.js";
-import { buildEvictedSessionArtifactEntries } from "../artifact-manifest.js";
-import { countLines, truncateText } from "../text.js";
+import { countLines, stringifyUnknown, truncateText } from "../text.js";
 import { applyArtifactManifest } from "./artifacts.js";
-import { getPresentationText, projectAgentBrowserObservation, OBSERVATION_INLINE_MAX_CHARS } from "./content.js";
-import { redactModelFacingText, stringifyModelFacing } from "./common.js";
-const LARGE_OUTPUT_INLINE_MAX_CHARS = 8_000;
-const LARGE_OUTPUT_INLINE_MAX_LINES = 120;
-const LARGE_OUTPUT_PREVIEW_MAX_CHARS = 2_500;
-const LARGE_OUTPUT_PREVIEW_MAX_LINES = 40;
-const LARGE_OUTPUT_PREVIEW_MAX_LINE_CHARS = 240;
-const LARGE_OUTPUT_FAILURE_COMMAND_MAX_CHARS = 240;
-const LARGE_OUTPUT_FILE_PREFIX = "pi-agent-browser-output";
+import { getPresentationText } from "./content.js";
+import { buildSpillArtifactEntries, writeLargeOutputSpillFile, } from "./output-spill.js";
+export { OBSERVATION_INLINE_MAX_CHARS } from "./content.js";
+export { renderAgentBrowserObservation } from "./observation-rendering.js";
 function shouldCompactLargeOutput(text) {
-    return text.length > LARGE_OUTPUT_INLINE_MAX_CHARS || countLines(text) > LARGE_OUTPUT_INLINE_MAX_LINES;
+    return text.length > 8_000 || countLines(text) > 120;
 }
 function buildLargeOutputPreview(text) {
     const lines = text.split("\n");
     const previewLines = [];
     let previewChars = 0;
     for (const line of lines) {
-        if (previewLines.length >= LARGE_OUTPUT_PREVIEW_MAX_LINES || previewChars >= LARGE_OUTPUT_PREVIEW_MAX_CHARS) {
+        if (previewLines.length >= 40 || previewChars >= 2_500) {
             break;
         }
-        const remainingChars = LARGE_OUTPUT_PREVIEW_MAX_CHARS - previewChars;
-        const previewLine = truncateText(line, Math.min(Math.max(40, remainingChars), LARGE_OUTPUT_PREVIEW_MAX_LINE_CHARS));
+        const remainingChars = 2_500 - previewChars;
+        const previewLine = truncateText(line, Math.min(Math.max(40, remainingChars), 240));
         previewLines.push(previewLine);
         previewChars += previewLine.length + 1;
     }
@@ -34,132 +27,44 @@ function buildLargeOutputPreview(text) {
 }
 function buildLargeOutputFailureContext(presentation) {
     const failure = presentation.batchFailure;
-    if (!failure)
+    if (!failure) {
         return [];
+    }
     const failedStep = failure.failedStep;
-    const commandText = truncateText(failedStep.commandText, LARGE_OUTPUT_FAILURE_COMMAND_MAX_CHARS);
+    const commandText = truncateText(failedStep.commandText, 240);
     const lines = [
         "Failure context:",
         `- First failing step: ${failedStep.index + 1} — ${commandText}`,
         `- Batch result: ${failure.successCount}/${failure.totalCount} succeeded${failure.failureCount > 1 ? `; ${failure.failureCount} failed` : ""}`,
     ];
-    if (failedStep.failureCategory)
+    if (failedStep.failureCategory !== undefined) {
         lines.push(`- Failure category: ${failedStep.failureCategory}`);
-    const failureText = (failedStep.text || failedStep.summary).replace(/\s+/g, " ").trim();
-    if (failureText)
+    }
+    const failureText = (failedStep.text.length > 0 ? failedStep.text : failedStep.summary)
+        .replace(/\s+/g, " ")
+        .trim();
+    if (failureText.length > 0) {
         lines.push(`- Failure detail: ${truncateText(failureText, 700)}`);
+    }
     const stepPaths = [failedStep.fullOutputPath, ...(failedStep.fullOutputPaths ?? [])].filter((path, index, paths) => typeof path === "string" && path.length > 0 && paths.indexOf(path) === index);
-    if (stepPaths.length > 0)
+    if (stepPaths.length > 0) {
         lines.push(`- Failed-step spill path${stepPaths.length === 1 ? "" : "s"}: ${stepPaths.join(", ")}`);
-    return lines;
-}
-async function writeLargeOutputSpillFile(options) {
-    const payload = typeof options.data === "string"
-        ? redactModelFacingText(options.data)
-        : typeof options.data === "number" || typeof options.data === "boolean"
-            ? String(options.data)
-            : options.data === undefined
-                ? redactModelFacingText(options.text)
-                : stringifyModelFacing(options.data);
-    const isStructuredPayload = typeof options.data !== "string" && typeof options.data !== "number" && typeof options.data !== "boolean";
-    const fileOptions = {
-        content: payload,
-        prefix: LARGE_OUTPUT_FILE_PREFIX,
-        suffix: isStructuredPayload ? ".json" : ".txt",
-    };
-    if (options.persistentArtifactStore) {
-        const result = await writePersistentSessionArtifactFile({ ...fileOptions, store: options.persistentArtifactStore });
-        return { ...result, storageScope: "persistent-session" };
     }
-    return { evictedArtifacts: [], path: await writeSecureTempFile(fileOptions), storageScope: "process-temp" };
-}
-function buildSpillArtifactEntries(options) {
-    const nowMs = Date.now();
-    return [
-        {
-            command: options.commandInfo.command,
-            createdAtMs: nowMs,
-            kind: "spill",
-            path: options.path,
-            retentionState: options.storageScope === "persistent-session" ? "live" : "ephemeral",
-            storageScope: options.storageScope,
-            subcommand: options.commandInfo.subcommand,
-        },
-        ...buildEvictedSessionArtifactEntries(options.evictedArtifacts, nowMs),
-    ];
-}
-export { OBSERVATION_INLINE_MAX_CHARS } from "./content.js";
-/** Bound the final model-visible result, after recovery/diagnostic assembly. Never truncate executable actions. */
-export async function renderAgentBrowserObservation(options) {
-    const observation = projectAgentBrowserObservation(options.details, options.succeeded);
-    let structuredContent = observation;
-    const images = options.content.filter(part => part.type === "image");
-    const prose = options.content.filter(part => part.type === "text").map(part => part.text).join("\n\n");
-    const { data: _data, error: _error, summary: _summary, ...metadata } = observation;
-    let text = options.json ? JSON.stringify(observation, null, 2) : `${prose}\n\nObservation: ${JSON.stringify(metadata)}`;
-    let artifactManifest = options.details.artifactManifest;
-    if (text.length > OBSERVATION_INLINE_MAX_CHARS || JSON.stringify(observation).length > OBSERVATION_INLINE_MAX_CHARS) {
-        let spill;
-        let spillError;
-        try {
-            const write = () => writeLargeOutputSpillFile({ data: { ...observation, ...(!options.json ? { text: prose } : {}) }, persistentArtifactStore: options.persistentArtifactStore, text });
-            spill = await (options.withArtifactWrite ? options.withArtifactWrite(write) : write());
-            artifactManifest = applyArtifactManifest({ content: [], summary: "" }, artifactManifest, buildSpillArtifactEntries({
-                commandInfo: { command: typeof options.details.command === "string" ? options.details.command : undefined },
-                evictedArtifacts: spill.evictedArtifacts, path: spill.path, storageScope: spill.storageScope,
-            })).artifactManifest;
-        }
-        catch (error) {
-            spillError = error instanceof Error ? error.message : String(error);
-        }
-        const compact = {
-            success: options.succeeded, resultCategory: observation.resultCategory,
-            failureCategory: observation.failureCategory, successCategory: observation.successCategory,
-            summary: typeof observation.summary === "string" ? truncateText(observation.summary, 700)
-                : typeof observation.error === "string" ? truncateText(observation.error, 700) : undefined,
-            compacted: true,
-            ...(spill ? { observationPath: spill.path, retrieve: "Read observationPath for the complete redacted observation, including exact recovery actions and requested data." }
-                : { observationUnavailable: truncateText(redactModelFacingText(spillError ?? "Spill could not be written; request a smaller result."), 1_000) }),
-        };
-        for (const key of ["sessionName", "namespace", "codeRun", "error", "failures", "nextActions", "artifactVerification", "imageObservations", "data", "fullOutputPath", "fullOutputPaths"]) {
-            if (observation[key] !== undefined && JSON.stringify({ ...compact, [key]: observation[key] }, null, 2).length <= OBSERVATION_INLINE_MAX_CHARS - 500)
-                compact[key] = observation[key];
-        }
-        structuredContent = compact;
-        if (options.preserveContent)
-            text = prose;
-        else {
-            text = JSON.stringify(compact, null, 2);
-            if (!options.json)
-                text = `Browser observation compacted.\n${text}`;
-        }
-    }
-    return { content: [{ type: "text", text }, ...images], artifactManifest, structuredContent: JSON.parse(JSON.stringify(structuredContent)) };
+    return lines;
 }
-export async function compactLargePresentationOutput(options) {
-    const text = getPresentationText(options.presentation);
-    if (text.length === 0 || !shouldCompactLargeOutput(text)) {
-        return options.presentation;
-    }
-    let fullOutputPath;
-    let spill;
-    let spillErrorText;
+async function tryWritePresentationSpill(options) {
     try {
-        spill = await writeLargeOutputSpillFile({
-            data: options.data,
-            persistentArtifactStore: options.persistentArtifactStore,
-            text,
-        });
-        fullOutputPath = spill.path;
+        return { spill: await writeLargeOutputSpillFile(options) };
     }
     catch (error) {
-        spillErrorText = error instanceof Error ? error.message : String(error);
+        return { error: error instanceof Error ? error.message : stringifyUnknown(error) };
     }
+}
+function buildCompactedText(command, text, presentation, persisted) {
     const { omittedLineCount, previewText } = buildLargeOutputPreview(text);
-    const commandLabel = options.commandInfo.command ?? "agent-browser";
-    const failureContext = buildLargeOutputFailureContext(options.presentation);
+    const failureContext = buildLargeOutputFailureContext(presentation);
     const lines = [
-        `Large ${commandLabel} output compacted.`,
+        `Large ${command ?? "agent-browser"} output compacted.`,
         ...(failureContext.length > 0 ? ["", ...failureContext] : []),
         "",
         "Preview:",
@@ -168,35 +73,45 @@ export async function compactLargePresentationOutput(options) {
     if (omittedLineCount > 0) {
         lines.push(`- ... (${omittedLineCount} additional lines omitted)`);
     }
-    lines.push("", fullOutputPath
-        ? `Full output path: ${fullOutputPath}`
-        : `Full output unavailable: ${spillErrorText ?? "spill file could not be created."}`);
-    const firstTextIndex = options.presentation.content.findIndex((part) => part.type === "text");
-    const compactedText = lines.join("\n");
+    lines.push("", persisted.spill
+        ? `Full output path: ${persisted.spill.path}`
+        : `Full output unavailable: ${persisted.error ?? "spill file could not be created."}`);
+    return { compactedText: lines.join("\n"), previewText };
+}
+// The presentation owner supplies its mutable assembly draft; compaction preserves that identity.
+function applyCompactedPresentation(draft, text, rendered, persisted) {
+    const firstTextIndex = draft.content.findIndex((part) => part.type === "text");
     if (firstTextIndex >= 0) {
-        options.presentation.content[firstTextIndex] = { type: "text", text: compactedText };
+        draft.content[firstTextIndex] = { type: "text", text: rendered.compactedText };
     }
     else {
-        options.presentation.content.unshift({ type: "text", text: compactedText });
+        draft.content.unshift({ type: "text", text: rendered.compactedText });
     }
-    options.presentation.data = {
+    draft.data = {
         compacted: true,
-        fullOutputPath,
+        fullOutputPath: persisted.spill?.path,
         outputCharCount: text.length,
         outputLineCount: countLines(text),
-        previewCharCount: previewText.length,
-        previewLineCount: countLines(previewText),
-        spillError: spillErrorText,
+        previewCharCount: rendered.previewText.length,
+        previewLineCount: countLines(rendered.previewText),
+        spillError: persisted.error,
     };
-    options.presentation.fullOutputPath = fullOutputPath;
-    options.presentation.summary = `${options.presentation.summary} (compact)`;
-    if (fullOutputPath && spill) {
-        return applyArtifactManifest(options.presentation, options.presentation.artifactManifest ?? options.artifactManifest, buildSpillArtifactEntries({
-            commandInfo: options.commandInfo,
-            evictedArtifacts: spill.evictedArtifacts,
-            path: fullOutputPath,
-            storageScope: spill.storageScope,
-        }));
+    draft.fullOutputPath = persisted.spill?.path;
+    draft.summary = `${draft.summary} (compact)`;
+}
+export async function compactLargePresentationOutput(options) {
+    const text = getPresentationText(options.presentation);
+    if (text.length === 0 || !shouldCompactLargeOutput(text)) {
+        return options.presentation;
     }
-    return options.presentation;
+    const persisted = await tryWritePresentationSpill({
+        data: options.data,
+        persistentArtifactStore: options.persistentArtifactStore,
+        text,
+    });
+    const rendered = buildCompactedText(options.commandInfo.command, text, options.presentation, persisted);
+    applyCompactedPresentation(options.presentation, text, rendered, persisted);
+    return persisted.spill
+        ? applyArtifactManifest(options.presentation, options.presentation.artifactManifest ?? options.artifactManifest, buildSpillArtifactEntries({ ...persisted.spill, commandInfo: options.commandInfo }))
+        : options.presentation;
 }