pi-agent-browser-native 0.9.2 → 0.9.4

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

@@ -1,90 +1,127 @@
 import { isRecord } from "../../parsing.js";
 import { getStringField, redactModelFacingText, stringifyModelFacing } from "./common.js";
 function formatSkillsListText(skills) {
-    if (skills.length === 0)
+    if (skills.length === 0) {
         return "No agent-browser skills found.";
+    }
     return skills
         .map((item, index) => {
-        if (!isRecord(item))
+        if (!isRecord(item)) {
             return `${index + 1}. ${stringifyModelFacing(item)}`;
+        }
         const name = redactModelFacingText(getStringField(item, "name") ?? `(skill ${index + 1})`);
         const description = getStringField(item, "description");
-        return description ? `${index + 1}. ${name} — ${redactModelFacingText(description)}` : `${index + 1}. ${name}`;
+        return description !== undefined
+            ? `${index + 1}. ${name} — ${redactModelFacingText(description)}`
+            : `${index + 1}. ${name}`;
     })
         .join("\n");
 }
 function getSkillContent(data) {
-    if (typeof data === "string")
+    if (typeof data === "string") {
         return data;
-    if (isRecord(data) && typeof data.content === "string")
+    }
+    if (isRecord(data) && typeof data.content === "string") {
         return data.content;
-    if (!Array.isArray(data))
+    }
+    if (!Array.isArray(data)) {
         return undefined;
-    const content = data.flatMap((item) => (isRecord(item) && typeof item.content === "string" ? [item.content] : []));
+    }
+    const content = data.flatMap((item) => isRecord(item) && typeof item.content === "string" ? [item.content] : []);
     return content.length > 0 ? content.join("\n\n") : undefined;
 }
-function splitShellWords(input) {
-    const words = [];
-    let current = "";
-    let quote;
-    for (let index = 0; index < input.length; index += 1) {
-        const char = input[index];
-        if (quote === "single") {
-            if (char === "'")
-                quote = undefined;
-            else
-                current += char;
-            continue;
+class SkillShellWords {
+    words = [];
+    current = "";
+    quote;
+    index = 0;
+    input;
+    constructor(input) {
+        this.input = input;
+    }
+    flush() {
+        if (this.current.length > 0) {
+            this.words.push(this.current);
+            this.current = "";
         }
-        if (quote === "double") {
-            if (char === '"')
-                quote = undefined;
-            else if (char === "\\" && index + 1 < input.length) {
-                index += 1;
-                current += input[index];
-            }
-            else
-                current += char;
-            continue;
+    }
+    appendEscape() {
+        if (this.index + 1 < this.input.length) {
+            this.index += 1;
+            this.current += this.input[this.index];
         }
-        if (char === "'") {
-            quote = "single";
-            continue;
+        else {
+            this.current += "\\";
         }
-        if (char === '"') {
-            quote = "double";
-            continue;
+    }
+    consumeQuoted(char) {
+        const closing = this.quote === "single" ? "'" : '"';
+        if (char === closing) {
+            this.quote = undefined;
         }
-        if (char === "\\" && index + 1 < input.length) {
-            index += 1;
-            current += input[index];
-            continue;
+        else if (this.quote === "double" && char === "\\") {
+            this.appendEscape();
+        }
+        else {
+            this.current += char;
+        }
+    }
+    consumeUnquoted(char) {
+        if (char === "'" || char === '"') {
+            this.quote = char === "'" ? "single" : "double";
+        }
+        else if (char === "\\") {
+            this.appendEscape();
         }
-        if (char === "#" && current.length === 0) {
-            break;
+        else if (char === "#" && this.current.length === 0) {
+            return false;
         }
-        if (/\s/.test(char)) {
-            if (current.length > 0) {
-                words.push(current);
-                current = "";
+        else if (/\s/.test(char)) {
+            this.flush();
+        }
+        else {
+            this.current += char;
+        }
+        return true;
+    }
+    parse() {
+        for (; this.index < this.input.length; this.index += 1) {
+            const char = this.input[this.index];
+            if (this.quote !== undefined) {
+                this.consumeQuoted(char);
             }
-            continue;
+            else if (!this.consumeUnquoted(char)) {
+                break;
+            }
+        }
+        if (this.quote !== undefined) {
+            return undefined;
         }
-        current += char;
+        this.flush();
+        return this.words;
     }
-    if (quote)
-        return undefined;
-    if (current.length > 0)
-        words.push(current);
-    return words;
 }
 function formatNativeAgentBrowserCall(args, stdin) {
     return stdin === undefined
         ? `agent_browser { "args": ${JSON.stringify(args)} }`
         : `agent_browser { "args": ${JSON.stringify(args)}, "stdin": ${JSON.stringify(stdin)} }`;
 }
+function readSkillHeredoc(lines, startIndex, delimiter, stripsLeadingTabs) {
+    const stdinLines = [];
+    for (let cursor = startIndex; cursor < lines.length; cursor += 1) {
+        const candidate = stripsLeadingTabs ? lines[cursor].replace(/^\t+/, "") : lines[cursor];
+        if (candidate === delimiter) {
+            return { stdin: stdinLines.join("\n"), endIndex: cursor };
+        }
+        stdinLines.push(candidate);
+    }
+    return undefined;
+}
 function formatNativeSkillContent(content) {
-    const lines = content.replace(/^allowed-tools:.*agent-browser.*\n?/gim, "").replace(/^```bash\s*$/gim, "```text").split("\n");
+    const lines = content
+        .replace(/^allowed-tools:.*agent-browser.*\n?/gim, "")
+        .replace(/^```bash\s*$/gim, "```text")
+        .split("\n");
     const output = [];
     for (let index = 0; index < lines.length; index += 1) {
         const line = lines[index];
@@ -97,7 +134,7 @@ function formatNativeSkillContent(content) {
         const rawArgsText = commandMatch[2];
         const heredocMatch = /^(.*?)\s+(<<-?)['"]?([A-Za-z_][A-Za-z0-9_]*)['"]?\s*$/.exec(rawArgsText);
         const argsText = heredocMatch?.[1] ?? rawArgsText;
-        const args = splitShellWords(argsText);
+        const args = new SkillShellWords(argsText).parse();
         if (!args || args.length === 0) {
             output.push(line);
             continue;
@@ -106,42 +143,36 @@ function formatNativeSkillContent(content) {
             output.push(`${indent}${formatNativeAgentBrowserCall(args)}`);
             continue;
         }
-        const stripsLeadingTabs = heredocMatch[2] === "<<-";
-        const delimiter = heredocMatch[3];
-        const stdinLines = [];
-        let cursor = index + 1;
-        while (cursor < lines.length) {
-            const candidate = stripsLeadingTabs ? lines[cursor].replace(/^\t+/, "") : lines[cursor];
-            if (candidate === delimiter)
-                break;
-            stdinLines.push(candidate);
-            cursor += 1;
-        }
-        if (cursor >= lines.length) {
+        const heredoc = readSkillHeredoc(lines, index + 1, heredocMatch[3], heredocMatch[2] === "<<-");
+        if (!heredoc) {
             output.push(line);
             continue;
         }
-        output.push(`${indent}${formatNativeAgentBrowserCall(args, stdinLines.join("\n"))}`);
-        index = cursor;
+        output.push(`${indent}${formatNativeAgentBrowserCall(args, heredoc.stdin)}`);
+        index = heredoc.endIndex;
     }
     return output.join("\n");
 }
 export function formatSkillsText(commandInfo, data) {
-    if (commandInfo.command !== "skills")
+    if (commandInfo.command !== "skills") {
         return undefined;
-    if (commandInfo.subcommand === "path")
+    }
+    if (commandInfo.subcommand === "path") {
         return typeof data === "string" ? redactModelFacingText(data) : undefined;
-    if (commandInfo.subcommand === "list" && Array.isArray(data))
+    }
+    if (commandInfo.subcommand === "list" && Array.isArray(data)) {
         return formatSkillsListText(data);
+    }
     const content = getSkillContent(data);
-    if (content) {
+    if (content !== undefined && content.length > 0) {
         const note = [
             "Pi native-tool note: upstream skill text was adapted for this native tool.",
             "Use args for CLI tokens and stdin only for batch, eval --stdin, or auth save --password-stdin; do not pipe heredocs through bash unless the user explicitly asks for a bash workflow.",
         ].join("\n");
         return `${note}\n\n${redactModelFacingText(formatNativeSkillContent(content))}`;
     }
-    if (typeof data === "string")
+    if (typeof data === "string") {
         return redactModelFacingText(formatNativeSkillContent(data));
+    }
     return undefined;
 }

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

@@ -0,0 +1,109 @@
+import { extractUpstreamCommandTokens, parseCommandInfo, } from "../../argv-descriptor.js";
+import { isRecord } from "../../parsing.js";
+import { nextReadConfirmation } from "../../read-confirmation.js";
+import { redactInvocationArgs } from "../../runtime-redaction.js";
+import { detectConfirmationRequired } from "../confirmation.js";
+import { buildSnapshotPresentation } from "../snapshot.js";
+import { formatArtifactMetadataLines, formatArtifactSummary } from "./artifacts.js";
+import { buildBatchPresentation, isAgentBrowserBatchResultArray, redactBatchStepErrorData, } from "./batch.js";
+import { isStringArray } from "./content.js";
+import { enrichStreamStatusData, redactPresentationData } from "./diagnostics.js";
+import { formatPresentationContentText, formatPresentationSummary } from "./registry.js";
+import { resolvePresentationCommandInfo } from "./semantic-action.js";
+export function resolvePresentationCommands(options) {
+    const commandInfo = options.commandInfo.commandTokens || !options.args
+        ? options.commandInfo
+        : { ...options.commandInfo, commandTokens: extractUpstreamCommandTokens(options.args) };
+    return {
+        commandInfo,
+        presentationCommandInfo: resolvePresentationCommandInfo(commandInfo, options.compiledSemanticAction),
+    };
+}
+function redactBatchSpillData(data) {
+    return data.map((row) => {
+        const command = isStringArray(row.command) ? row.command : undefined;
+        return {
+            ...row,
+            command: command ? redactInvocationArgs(command) : row.command,
+            error: row.error === undefined ? undefined : redactBatchStepErrorData(command, row.error),
+            result: row.result === undefined
+                ? undefined
+                : redactPresentationData(parseCommandInfo(command ?? []), row.result),
+        };
+    });
+}
+export function buildPresentationSource(options, commands) {
+    const { commandInfo } = commands;
+    const data = enrichPresentationSource(options, commandInfo);
+    return {
+        ...commands,
+        data,
+        presentationData: commandInfo.command === "batch" && isAgentBrowserBatchResultArray(data)
+            ? redactBatchSpillData(data)
+            : redactPresentationData(commandInfo, data),
+        recordingCommand: commandInfo.command === "record",
+        recordingBatch: isRecordingBatch(commandInfo, data),
+        confirmationRequired: detectConfirmationRequired(data),
+        readConfirmation: nextReadConfirmation({
+            commandTokens: commandInfo.commandTokens ?? [],
+            data,
+            namespace: options.namespace,
+            sessionName: options.sessionName ?? "default",
+            succeeded: options.envelope?.success !== false,
+        }),
+    };
+}
+function enrichPresentationSource(options, commandInfo) {
+    const data = enrichStreamStatusData(commandInfo, options.envelope?.data);
+    return commandInfo.command === "session" && commandInfo.subcommand === "info" && isRecord(data)
+        ? { ...data, piCleanupOwnership: options.piCleanupOwnership ?? "unknown" }
+        : data;
+}
+function isRecordingBatch(command, data) {
+    return (command.command === "batch" &&
+        isAgentBrowserBatchResultArray(data) &&
+        data.some((row) => row.command?.[0] === "record"));
+}
+function buildNativeContent(options, source, artifacts) {
+    if (options.modelVisible === false) {
+        return [];
+    }
+    const text = artifacts.length > 0
+        ? formatArtifactMetadataLines(artifacts).join("\n")
+        : formatPresentationContentText(source.commandInfo, source.data, options.compiledSemanticAction);
+    return [{ type: "text", text }];
+}
+export async function buildSourcePresentation(options, source, artifacts, buildNestedToolPresentation) {
+    const summary = formatArtifactSummary(artifacts) ??
+        formatPresentationSummary(source.commandInfo, source.data, options.compiledSemanticAction);
+    if (source.commandInfo.command === "batch" && isAgentBrowserBatchResultArray(source.data)) {
+        return buildBatchPresentation({
+            artifactManifest: options.artifactManifest,
+            artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs,
+            artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs,
+            artifactRequests: options.batchArtifactRequests,
+            buildNestedToolPresentation,
+            modelVisible: options.modelVisible,
+            cwd: options.cwd,
+            data: source.data,
+            namespace: options.namespace,
+            networkRoutes: options.networkRoutes,
+            persistentArtifactStore: options.persistentArtifactStore,
+            piCleanupOwnership: options.piCleanupOwnership,
+            sessionName: options.sessionName,
+            summary,
+        });
+    }
+    if (options.modelVisible !== false &&
+        source.commandInfo.command === "snapshot" &&
+        isRecord(source.data) &&
+        !source.confirmationRequired) {
+        return buildSnapshotPresentation(source.data, options.persistentArtifactStore, options.artifactManifest);
+    }
+    return {
+        artifacts: artifacts.length > 0 ? artifacts : undefined,
+        content: buildNativeContent(options, source, artifacts),
+        data: source.presentationData,
+        summary,
+    };
+}

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

@@ -1,250 +1,19 @@
-import { getScreenshotCapture } from "../orchestration/browser-run/screenshot-observation.js";
-import { isRecord } from "../parsing.js";
-import { buildReadConfirmationNextActions, nextReadConfirmation } from "../read-confirmation.js";
-import { extractUpstreamCommandTokens, parseCommandInfo, redactInvocationArgs } from "../runtime.js";
-import { buildAgentBrowserNextActions } from "./action-recommendations.js";
-import { buildAgentBrowserResultCategoryDetails } from "./categories.js";
-import { detectConfirmationRequired } from "./confirmation.js";
-import { buildSnapshotPresentation } from "./snapshot.js";
-import { formatWebMcpCatalogUpdate, redactModelFacingText } from "./presentation/common.js";
-import { applyArtifactManifest, attachInlineImage, buildArtifactVerificationSummary, buildManifestEntriesForFileArtifacts, classifyPresentationSuccessCategory, extractFileArtifacts, extractImagePath, formatArtifactMetadataLines, formatArtifactSummary, formatMissingArtifactFailureText, getSavedFileDetails, hasMissingFileArtifact, isManifestFileArtifact, } from "./presentation/artifacts.js";
-import { buildBatchPresentation, isAgentBrowserBatchResultArray, redactBatchStepErrorData } from "./presentation/batch.js";
-import { getPresentationPaths, isStringArray } from "./presentation/content.js";
-import { buildNetworkRequestsNextActions, buildStreamNextActions, enrichStreamStatusData, formatNetworkRouteDiagnosticsText, redactPresentationData, } from "./presentation/diagnostics.js";
-import { buildErrorPresentation, isOverlayBlockedClickError } from "./presentation/errors.js";
-import { compactLargePresentationOutput } from "./presentation/large-output.js";
-import { buildPageChangeSummary } from "./presentation/navigation.js";
-import { formatPresentationContentText, formatPresentationSummary } from "./presentation/registry.js";
-import { resolvePresentationCommandInfo } from "./presentation/semantic-action.js";
-function sanitizeModelFacingPresentation(presentation) {
-    presentation.content = presentation.content.map((item) => {
-        if (item.type !== "text")
-            return item;
-        return { ...item, text: redactModelFacingText(item.text) };
-    });
-    presentation.summary = redactModelFacingText(presentation.summary);
-    return presentation;
-}
-function mergeNextActions(...groups) {
-    const merged = groups.flatMap((group) => group ?? []);
-    return merged.length > 0 ? merged : undefined;
-}
-function shouldAddAnnotatedScreenshotGuidance(commandInfo, args) {
-    return commandInfo.command === "screenshot" && (args?.includes("--annotate") ?? false);
-}
-function getKeyboardInsertTextWarning(commandInfo) {
-    if (commandInfo.command !== "keyboard" || commandInfo.subcommand !== "inserttext")
-        return undefined;
-    return "Input dispatch warning: keyboard inserttext skips key events. A DOM value change does not prove a framework-controlled editor accepted it; verify application state before saving, or use keyboard type when real key events are required.";
-}
-function redactBatchSpillData(data) {
-    return data.map((row) => {
-        const command = isStringArray(row.command) ? row.command : undefined;
-        const commandInfo = parseCommandInfo(command ?? []);
-        return {
-            ...row,
-            command: command ? redactInvocationArgs(command) : row.command,
-            error: row.error === undefined ? undefined : redactBatchStepErrorData(command, row.error),
-            result: row.result === undefined ? undefined : redactPresentationData(commandInfo, row.result),
-        };
-    });
-}
+import { completePresentationOutput, extractPresentationArtifacts, } from "./presentation/output-completion.js";
 export async function buildToolPresentation(options) {
-    const { args, artifactManifest, artifactRequest, commandInfo, compiledSemanticAction, cwd, envelope, errorText, namespace, networkRouteDiagnostics, networkRoutes, persistentArtifactStore, sessionName, } = options;
-    const commandInfoWithTokens = commandInfo.commandTokens || !args ? commandInfo : { ...commandInfo, commandTokens: extractUpstreamCommandTokens(args) };
-    const presentationCommandInfo = resolvePresentationCommandInfo(commandInfoWithTokens, compiledSemanticAction);
-    const recordingCommand = commandInfo.command === "record";
-    const recordingBatch = commandInfo.command === "batch" && isAgentBrowserBatchResultArray(envelope?.data)
-        && envelope.data.some((row) => row.command?.[0] === "record");
-    if (errorText && !recordingCommand && !recordingBatch) {
-        return { ...buildErrorPresentation({ args, commandInfo, errorText, presentationCommand: presentationCommandInfo.command, sessionName }),
-            data: redactPresentationData(commandInfoWithTokens, envelope?.data),
-        };
-    }
-    let data = enrichStreamStatusData(commandInfoWithTokens, envelope?.data);
-    if (commandInfo.command === "session" && commandInfo.subcommand === "info" && isRecord(data)) {
-        data = { ...data, piCleanupOwnership: options.piCleanupOwnership ?? "unknown" };
-    }
-    const readConfirmation = nextReadConfirmation({ commandTokens: commandInfoWithTokens.commandTokens ?? [], data, namespace, sessionName: sessionName ?? "default", succeeded: envelope?.success !== false });
-    const presentationData = commandInfo.command === "batch" && isAgentBrowserBatchResultArray(data)
-        ? redactBatchSpillData(data)
-        : redactPresentationData(commandInfoWithTokens, data);
-    const artifacts = await extractFileArtifacts({ artifactManifest, artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs, artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs, artifactRequest, commandInfo: presentationCommandInfo, cwd, data, namespace, recordingOutcome: recordingCommand ? envelope?.success : undefined, recordingPending: options.recordingPending, previousRecordingContactSheetPath: options.previousRecordingContactSheetPath, sessionName });
-    const artifactVerification = buildArtifactVerificationSummary(artifacts);
-    const artifactSummary = formatArtifactSummary(artifacts);
-    const summary = artifactSummary ?? formatPresentationSummary(commandInfoWithTokens, data, compiledSemanticAction);
-    const artifactText = artifacts.length > 0 ? formatArtifactMetadataLines(artifacts).join("\n") : undefined;
-    let presentation;
-    if (commandInfo.command === "batch" && isAgentBrowserBatchResultArray(data)) {
-        presentation = await buildBatchPresentation({
-            artifactManifest,
-            artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs,
-            artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs,
-            artifactRequests: options.batchArtifactRequests,
-            buildNestedToolPresentation: buildToolPresentation,
-            modelVisible: options.modelVisible,
-            cwd,
-            data,
-            namespace,
-            networkRoutes,
-            persistentArtifactStore,
-            piCleanupOwnership: options.piCleanupOwnership,
-            sessionName,
-            summary,
-        });
-    }
-    else if (options.modelVisible !== false && commandInfo.command === "snapshot" && isRecord(data)) {
-        presentation = await buildSnapshotPresentation(data, persistentArtifactStore, artifactManifest);
-    }
-    else {
-        presentation = {
-            artifactVerification,
-            artifacts: artifacts.length > 0 ? artifacts : undefined,
-            content: options.modelVisible === false ? [] : [{ type: "text", text: artifactText ?? formatPresentationContentText(commandInfoWithTokens, data, compiledSemanticAction) }],
-            data: presentationData,
-            summary,
-        };
-    }
-    if (errorText && (recordingCommand || recordingBatch)) {
-        const errorPresentation = buildErrorPresentation({ args, commandInfo, errorText, presentationCommand: presentationCommandInfo.command, sessionName });
-        presentation = { ...presentation, resultCategory: "failure", failureCategory: errorPresentation.failureCategory, summary: errorPresentation.summary,
-            content: [{ type: "text", text: `${errorPresentation.content[0]?.type === "text" ? errorPresentation.content[0].text : errorText}\n\n${presentation.content[0]?.type === "text" ? presentation.content[0].text : ""}` }],
-        };
-    }
-    if (networkRouteDiagnostics && networkRouteDiagnostics.length > 0 && presentation.content[0]?.type === "text") {
-        const diagnosticText = formatNetworkRouteDiagnosticsText(networkRouteDiagnostics);
-        if (diagnosticText)
-            presentation.content[0] = { ...presentation.content[0], text: `${diagnosticText}\n\n${presentation.content[0].text}` };
-        presentation.networkRouteDiagnostics = networkRouteDiagnostics;
-    }
-    if (artifacts.length > 0 && !presentation.artifacts) {
-        presentation.artifacts = artifacts;
-    }
-    presentation.artifactVerification = presentation.artifactVerification ?? artifactVerification;
-    if (isRecord(data)) {
-        const savedFile = getSavedFileDetails(commandInfo, data);
-        if (savedFile) {
-            presentation.savedFile = savedFile;
-            presentation.savedFilePath = savedFile.path;
-        }
-    }
-    if (isRecord(presentationData) && isRecord(presentationData.webmcp) && (Array.isArray(presentationData.webmcp.tools) || presentationData.webmcp.status === "unavailable") && presentation.content[0]?.type === "text") {
-        presentation.content[0] = { ...presentation.content[0], text: `${presentation.content[0].text}\n\n${formatWebMcpCatalogUpdate(presentationData.webmcp)}` };
-    }
-    if (shouldAddAnnotatedScreenshotGuidance(commandInfo, args) && presentation.content[0]?.type === "text") {
-        const guidance = "Annotated screenshot note: dense pages can produce overlapping labels. If the labels are noisy, capture a scoped element screenshot, take a non-annotated screenshot, or use snapshot -i high-value refs as the machine-readable map.";
-        presentation.content[0] = { ...presentation.content[0], text: `${presentation.content[0].text}\n\n${guidance}` };
-    }
-    const keyboardInsertTextWarning = getKeyboardInsertTextWarning(commandInfoWithTokens);
-    if (keyboardInsertTextWarning && presentation.content[0]?.type === "text") {
-        presentation.content[0] = { ...presentation.content[0], text: `${presentation.content[0].text}\n\n${keyboardInsertTextWarning}` };
-    }
-    const imagePath = artifactRequest?.absolutePath ?? extractImagePath(commandInfo, cwd, data)
-        ?? (recordingCommand ? artifacts.find((artifact) => artifact.kind === "image" && artifact.status === "saved")?.absolutePath : undefined);
-    const attachImage = imagePath && !(isRecord(data) && data.changed === false) && !artifacts.some(artifact => artifact.absolutePath === imagePath && ["missing", "stale", "failed"].includes(artifact.status ?? ""));
-    const presentationWithImage = attachImage ? await attachInlineImage(presentation, imagePath, options.modelVisible) : presentation;
-    if (commandInfo.command === "screenshot" && presentationWithImage.imageObservations) {
-        for (const image of presentationWithImage.imageObservations)
-            image.capture = getScreenshotCapture(commandInfoWithTokens.commandTokens ?? []).kind;
-    }
-    const compactedPresentation = options.modelVisible === false ? presentationWithImage : await compactLargePresentationOutput({
-        artifactManifest,
-        commandInfo,
-        data: presentationData,
-        persistentArtifactStore,
-        presentation: presentationWithImage,
-    });
-    const presentationWithManifest = applyArtifactManifest(compactedPresentation, compactedPresentation.artifactManifest ?? artifactManifest, buildManifestEntriesForFileArtifacts(artifacts.filter(isManifestFileArtifact)));
-    const currentSpillPaths = new Set(getPresentationPaths({
-        primaryPath: presentationWithManifest.fullOutputPath,
-        secondaryPaths: presentationWithManifest.fullOutputPaths,
-    }));
-    presentationWithManifest.artifactVerification = buildArtifactVerificationSummary(artifacts, presentationWithManifest.artifactManifest, currentSpillPaths) ?? presentationWithManifest.artifactVerification;
-    const confirmationRequired = detectConfirmationRequired(data);
-    const missingArtifactFailureText = formatMissingArtifactFailureText(presentationWithManifest.artifacts);
-    if (!errorText && missingArtifactFailureText && hasMissingFileArtifact(presentationWithManifest.artifacts)) {
-        presentationWithManifest.resultCategory = "failure";
-        presentationWithManifest.failureCategory = "artifact-missing";
-        presentationWithManifest.successCategory = undefined;
-        presentationWithManifest.summary = missingArtifactFailureText;
-        if (presentationWithManifest.content[0]?.type === "text") {
-            presentationWithManifest.content[0] = { ...presentationWithManifest.content[0], text: `${missingArtifactFailureText}\n\n${presentationWithManifest.content[0].text}` };
-        }
-        else {
-            presentationWithManifest.content.unshift({ type: "text", text: missingArtifactFailureText });
-        }
-    }
-    const failedRecording = presentationWithManifest.artifacts?.find((artifact) => artifact.recording?.success === false || artifact.recording?.output.encoderSucceeded === false);
-    if (failedRecording && !errorText) {
-        const failure = `Recording failed: ${failedRecording.recording?.error ?? "native capture/encoder failure"}`;
-        presentationWithManifest.resultCategory = "failure";
-        presentationWithManifest.failureCategory = "upstream-error";
-        presentationWithManifest.successCategory = undefined;
-        presentationWithManifest.summary = failure;
-        presentationWithManifest.content.unshift({ type: "text", text: failure });
-    }
-    if (readConfirmation?.state === "pending") {
-        presentationWithManifest.readConfirmation = readConfirmation;
-        presentationWithManifest.resultCategory = "failure";
-        presentationWithManifest.failureCategory = "confirmation-required";
-        presentationWithManifest.successCategory = undefined;
-    }
-    if (!presentationWithManifest.resultCategory) {
-        const categoryDetails = buildAgentBrowserResultCategoryDetails({
-            artifacts: presentationWithManifest.artifacts,
-            command: presentationCommandInfo.command,
-            confirmationRequired: confirmationRequired !== undefined,
-            errorText: envelope?.success === false ? presentationWithManifest.summary : undefined,
-            savedFile: presentationWithManifest.savedFile,
-            succeeded: envelope?.success !== false && confirmationRequired === undefined,
-        });
-        presentationWithManifest.resultCategory = categoryDetails.resultCategory;
-        presentationWithManifest.successCategory = categoryDetails.resultCategory === "success"
-            ? classifyPresentationSuccessCategory({
-                artifactVerification: presentationWithManifest.artifactVerification,
-                artifacts: presentationWithManifest.artifacts,
-                savedFile: presentationWithManifest.savedFile,
-            })
-            : categoryDetails.successCategory;
-        presentationWithManifest.failureCategory = categoryDetails.failureCategory;
-    }
-    if (presentationWithManifest.resultCategory === "success") {
-        presentationWithManifest.successCategory = classifyPresentationSuccessCategory({
-            artifactVerification: presentationWithManifest.artifactVerification,
-            artifacts: presentationWithManifest.artifacts,
-            savedFile: presentationWithManifest.savedFile,
-        });
-    }
-    const genericNextActions = presentationWithManifest.nextActions ? undefined : buildAgentBrowserNextActions({
-        artifacts: presentationWithManifest.artifacts,
-        args,
-        command: presentationCommandInfo.command,
-        confirmationId: confirmationRequired?.id,
-        failureCategory: presentationWithManifest.failureCategory,
-        overlayBlockedClick: isOverlayBlockedClickError(presentationCommandInfo.command, envelope?.success === false ? presentationWithManifest.summary : undefined, args ?? presentationCommandInfo.commandTokens),
-        resultCategory: presentationWithManifest.resultCategory ?? "success",
-        savedFilePath: presentationWithManifest.savedFilePath,
-        sessionName,
-        subcommand: presentationCommandInfo.subcommand,
-        successCategory: presentationWithManifest.successCategory,
-    });
-    const networkNextActions = commandInfoWithTokens.command === "network" && commandInfoWithTokens.subcommand === "requests" && presentationWithManifest.resultCategory === "success"
-        ? buildNetworkRequestsNextActions(data, sessionName, presentationWithManifest.networkRouteDiagnostics)
-        : undefined;
-    const streamNextActions = presentationWithManifest.resultCategory === "success" ? buildStreamNextActions(commandInfoWithTokens, data, sessionName) : undefined;
-    presentationWithManifest.nextActions = readConfirmation ? buildReadConfirmationNextActions(readConfirmation, true) : mergeNextActions(presentationWithManifest.nextActions, genericNextActions, networkNextActions, streamNextActions);
-    presentationWithManifest.pageChangeSummary = presentationWithManifest.pageChangeSummary ?? buildPageChangeSummary({
-        artifacts: presentationWithManifest.artifacts,
-        commandInfo: presentationCommandInfo,
-        data,
-        nextActions: presentationWithManifest.nextActions,
-        savedFilePath: presentationWithManifest.savedFilePath,
-        summary: presentationWithManifest.summary,
-    });
-    if (presentationWithManifest.pageChangeSummary?.observed === false && presentationCommandInfo.command !== "batch" && presentationWithManifest.content[0]?.type === "text") {
-        presentationWithManifest.content[0] = { ...presentationWithManifest.content[0], text: `${presentationWithManifest.content[0].text}\n\nAction dispatched; application change unverified. Verify the expected URL, text, state, or external receipt before relying on it.` };
-    }
-    if (options.modelVisible === false)
-        presentationWithManifest.content = [];
-    return sanitizeModelFacingPresentation(presentationWithManifest);
+    const { buildPresentationSource, buildSourcePresentation, resolvePresentationCommands } = await import("./presentation/source.js");
+    const { buildEarlyPresentation, sanitizeModelFacingPresentation } = await import("./presentation/early-result.js");
+    const { applyPresentationNotices } = await import("./presentation/notices.js");
+    const { applyPresentationOutcome } = await import("./presentation/outcomes.js");
+    const commands = resolvePresentationCommands(options);
+    const early = await buildEarlyPresentation(options, commands);
+    if (early) {
+        return early;
+    }
+    const source = buildPresentationSource(options, commands);
+    const artifacts = await extractPresentationArtifacts(options, source);
+    const draft = await buildSourcePresentation(options, source, artifacts, buildToolPresentation);
+    applyPresentationNotices(draft, options, source);
+    const completed = await completePresentationOutput(draft, options, source, artifacts);
+    applyPresentationOutcome(completed, options, source);
+    return sanitizeModelFacingPresentation(completed);
 }

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

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