pi-agent-browser-native 0.2.77 → 0.5.0

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

@@ -1,13 +1,8 @@
-/**
- * Purpose: Own file artifact detection, verification, manifest merging, and inline image attachment for tool presentation.
- * Responsibilities: Build artifact metadata, verification summaries, saved-file details, artifact retention notices, and safe image content.
- * Scope: Artifact and image presentation only.
- */
 import { readFile, stat } from "node:fs/promises";
 import { extname, resolve } from "node:path";
+import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
 import { isRecord, parsePositiveInteger } from "../../parsing.js";
-import { formatSessionArtifactRetentionSummary, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
-import { isPendingRecordingArtifact, isPendingRecordingCommand } from "../artifact-state.js";
+import { formatSessionArtifactRetentionSummary, getSessionArtifactManifestEntryKey, isPendingRecordingArtifact, isPendingRecordingCommand, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
 import { classifyAgentBrowserSuccessCategory } from "../categories.js";
 const IMAGE_EXTENSION_TO_MIME_TYPE = {
     ".gif": "image/gif",
@@ -18,6 +13,7 @@ const IMAGE_EXTENSION_TO_MIME_TYPE = {
 };
 const INLINE_IMAGE_MAX_BYTES_ENV = "PI_AGENT_BROWSER_INLINE_IMAGE_MAX_BYTES";
 const DEFAULT_INLINE_IMAGE_MAX_BYTES = 5 * 1_024 * 1_024;
+const ARTIFACT_MTIME_TOLERANCE_MS = 2_000;
 function getImageMimeType(filePath) {
     const extension = extname(filePath).toLowerCase();
     return IMAGE_EXTENSION_TO_MIME_TYPE[extension];
@@ -42,14 +38,11 @@ function appendPresentationNotice(presentation, message) {
 function shouldAppendArtifactRetentionNotice(entries) {
     return entries.some((entry) => entry.retentionState === "evicted" || entry.storageScope !== "explicit-path");
 }
-function getManifestEntryKey(entry) {
-    return entry.storageScope === "explicit-path" && entry.absolutePath ? `${entry.storageScope}:${entry.absolutePath}` : `${entry.storageScope}:${entry.path}`;
-}
 export function manifestHasNewNoticeWorthyEntries(base, current) {
     if (!current)
         return false;
-    const baseKeys = new Set((base?.entries ?? []).map(getManifestEntryKey));
-    return current.entries.some((entry) => !baseKeys.has(getManifestEntryKey(entry)) && (entry.retentionState === "evicted" || entry.storageScope !== "explicit-path"));
+    const baseKeys = new Set((base?.entries ?? []).map(getSessionArtifactManifestEntryKey));
+    return current.entries.some((entry) => !baseKeys.has(getSessionArtifactManifestEntryKey(entry)) && (entry.retentionState === "evicted" || entry.storageScope !== "explicit-path"));
 }
 export function applyArtifactManifest(presentation, baseManifest, entries) {
     if (entries.length === 0)
@@ -92,6 +85,9 @@ const ARTIFACT_EXTENSION_TO_MEDIA_TYPE = {
     ".zip": "application/zip",
     ...IMAGE_EXTENSION_TO_MIME_TYPE,
 };
+function isDownloadWaitSubcommand(subcommand) {
+    return subcommand === "--download" || subcommand === "-d";
+}
 function getArtifactKind(commandInfo) {
     if (commandInfo.command === "screenshot")
         return "image";
@@ -101,7 +97,7 @@ function getArtifactKind(commandInfo) {
         return "pdf";
     if (commandInfo.command === "download")
         return "download";
-    if (commandInfo.command === "wait" && commandInfo.subcommand === "--download")
+    if (commandInfo.command === "wait" && isDownloadWaitSubcommand(commandInfo.subcommand))
         return "download";
     if (commandInfo.command === "state" && commandInfo.subcommand === "save")
         return "file";
@@ -141,6 +137,11 @@ function extractPathStrings(data) {
     }
     return [...new Set(paths)];
 }
+function artifactMtimeIsOutsideCommandWindow(updatedAtMs, minUpdatedAtMs, maxUpdatedAtMs) {
+    return minUpdatedAtMs !== undefined
+        && (updatedAtMs < minUpdatedAtMs - ARTIFACT_MTIME_TOLERANCE_MS
+            || (maxUpdatedAtMs !== undefined && updatedAtMs > maxUpdatedAtMs + ARTIFACT_MTIME_TOLERANCE_MS));
+}
 async function buildFileArtifactMetadata(options) {
     const kind = getArtifactKind(options.commandInfo);
     if (!kind) {
@@ -152,11 +153,16 @@ async function buildFileArtifactMetadata(options) {
     const pendingRecording = isPendingRecordingCommand(options.commandInfo.command, options.commandInfo.subcommand, kind);
     let exists;
     let sizeBytes;
+    let stale = false;
+    let updatedAtMs;
     if (!pendingRecording) {
         try {
             const fileStats = await stat(absolutePath);
             exists = true;
             sizeBytes = fileStats.size;
+            updatedAtMs = fileStats.mtimeMs;
+            const commandCreatesArtifact = !(options.commandInfo.command === "wait" && isDownloadWaitSubcommand(options.commandInfo.subcommand));
+            stale = commandCreatesArtifact && artifactMtimeIsOutsideCommandWindow(updatedAtMs, options.artifactMinUpdatedAtMs, options.artifactMaxUpdatedAtMs);
         }
         catch {
             exists = false;
@@ -171,31 +177,33 @@ async function buildFileArtifactMetadata(options) {
         extension,
         kind,
         mediaType: extension ? ARTIFACT_EXTENSION_TO_MEDIA_TYPE[extension] : undefined,
+        namespace: options.namespace,
         path: displayPath,
         recordingState: pendingRecording ? "openRecording" : undefined,
         requestedPath: options.artifactRequest?.path,
         session: options.sessionName,
         sizeBytes,
-        status: options.artifactRequest?.status ?? (pendingRecording ? "pending" : exists === false ? "missing" : "saved"),
+        status: pendingRecording ? "pending" : exists === false ? "missing" : stale ? "stale" : options.artifactRequest?.status ?? "saved",
         subcommand: options.commandInfo.subcommand,
         tempPath: options.artifactRequest?.tempPath,
+        updatedAtMs,
         willExistOnStop: pendingRecording ? true : undefined,
     };
 }
 async function buildPreviousRestartRecordingArtifact(options) {
     if (options.commandInfo.command !== "record" || options.commandInfo.subcommand !== "restart")
         return undefined;
+    const sessionKey = options.sessionName ? getAgentBrowserSessionIdentityKey(options.sessionName, options.namespace) : undefined;
     const previousRecording = options.artifactManifest?.entries.find((entry) => (entry.command === "record" &&
         (entry.subcommand === "start" || entry.subcommand === "restart") &&
         entry.kind === "video" &&
-        (!options.sessionName || !entry.session || entry.session === options.sessionName) &&
-        !options.currentPaths.has(entry.path) &&
-        (!entry.absolutePath || !options.currentPaths.has(entry.absolutePath))));
+        (!sessionKey || (entry.session && getAgentBrowserSessionIdentityKey(entry.session, entry.namespace) === sessionKey))));
     if (!previousRecording)
         return undefined;
     const absolutePath = previousRecording.absolutePath ?? resolve(options.cwd, previousRecording.path);
     try {
         const fileStats = await stat(absolutePath);
+        const stale = artifactMtimeIsOutsideCommandWindow(fileStats.mtimeMs, options.artifactMinUpdatedAtMs, options.artifactMaxUpdatedAtMs);
         return {
             absolutePath,
             artifactType: "video",
@@ -205,23 +213,39 @@ async function buildPreviousRestartRecordingArtifact(options) {
             extension: previousRecording.extension ?? (extname(absolutePath).toLowerCase() || undefined),
             kind: "video",
             mediaType: previousRecording.mediaType,
+            namespace: previousRecording.namespace ?? options.namespace,
             path: previousRecording.path,
             requestedPath: previousRecording.requestedPath,
             session: previousRecording.session ?? options.sessionName,
             sizeBytes: fileStats.size,
-            status: "saved",
+            status: stale ? "stale" : "saved",
             subcommand: "restart-previous",
+            updatedAtMs: fileStats.mtimeMs,
         };
     }
     catch {
-        return undefined;
+        return {
+            absolutePath,
+            artifactType: "video",
+            command: "record",
+            cwd: previousRecording.cwd ?? options.cwd,
+            exists: false,
+            extension: previousRecording.extension ?? (extname(absolutePath).toLowerCase() || undefined),
+            kind: "video",
+            mediaType: previousRecording.mediaType,
+            namespace: previousRecording.namespace ?? options.namespace,
+            path: previousRecording.path,
+            requestedPath: previousRecording.requestedPath,
+            session: previousRecording.session ?? options.sessionName,
+            status: "missing",
+            subcommand: "restart-previous",
+        };
     }
 }
 export async function extractFileArtifacts(options) {
     const candidates = extractPathStrings(options.data);
     const currentArtifacts = (await Promise.all(candidates.map((path) => buildFileArtifactMetadata({ ...options, path })))).filter((artifact) => artifact !== undefined);
-    const currentPaths = new Set(currentArtifacts.flatMap((artifact) => [artifact.path, artifact.absolutePath]));
-    const previousRestartRecordingArtifact = await buildPreviousRestartRecordingArtifact({ artifactManifest: options.artifactManifest, commandInfo: options.commandInfo, currentPaths, cwd: options.cwd, sessionName: options.sessionName });
+    const previousRestartRecordingArtifact = await buildPreviousRestartRecordingArtifact({ artifactManifest: options.artifactManifest, artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs, artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs, commandInfo: options.commandInfo, cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName });
     return previousRestartRecordingArtifact ? [previousRestartRecordingArtifact, ...currentArtifacts] : currentArtifacts;
 }
 export function buildManifestEntriesForFileArtifacts(artifacts, nowMs = Date.now()) {
@@ -234,9 +258,10 @@ export function buildManifestEntriesForFileArtifacts(artifacts, nowMs = Date.now
         extension: artifact.extension,
         kind: artifact.kind,
         mediaType: artifact.mediaType,
+        namespace: artifact.namespace,
         path: artifact.path,
         requestedPath: artifact.requestedPath,
-        retentionState: artifact.exists === false ? "missing" : "live",
+        retentionState: artifact.exists === false || artifact.status === "stale" ? "missing" : "live",
         session: artifact.session,
         sizeBytes: artifact.sizeBytes,
         storageScope: "explicit-path",
@@ -244,6 +269,9 @@ export function buildManifestEntriesForFileArtifacts(artifacts, nowMs = Date.now
     }));
 }
 export function isManifestFileArtifact(artifact) {
+    if (artifact.status === "stale") {
+        return artifact.kind === "video" && artifact.command === "record" && artifact.subcommand === "restart-previous";
+    }
     return artifact.kind === "video" && artifact.command === "record" ? true : !isPendingRecordingArtifact(artifact);
 }
 function getArtifactVerificationEntry(artifact) {
@@ -265,20 +293,24 @@ function getArtifactVerificationEntry(artifact) {
             willExistOnStop: artifact.willExistOnStop ?? true,
         };
     }
-    const state = artifact.exists === true
-        ? "verified"
-        : artifact.exists === false
-            ? "missing"
-            : "unverified";
+    const state = artifact.status === "stale"
+        ? "unverified"
+        : artifact.exists === true
+            ? "verified"
+            : artifact.exists === false
+                ? "missing"
+                : "unverified";
     return {
         absolutePath: artifact.absolutePath,
         exists: artifact.exists,
         kind: artifact.kind,
-        limitation: state === "missing"
-            ? "The wrapper did not find the reported artifact at absolutePath. Treat the path as unverified until recovered or regenerated."
-            : state === "unverified"
-                ? "The wrapper could not prove local filesystem existence for this artifact."
-                : undefined,
+        limitation: artifact.status === "stale"
+            ? "The reported path's modification time fell outside this command's bounded artifact window. Treat the artifact as stale until regenerated."
+            : state === "missing"
+                ? "The wrapper did not find the reported artifact at absolutePath. Treat the path as unverified until recovered or regenerated."
+                : state === "unverified"
+                    ? "The wrapper could not prove local filesystem existence for this artifact."
+                    : undefined,
         mediaType: artifact.mediaType,
         path: artifact.path,
         requestedPath: artifact.requestedPath,
@@ -287,6 +319,7 @@ function getArtifactVerificationEntry(artifact) {
         state,
         status: artifact.status,
         storageScope: "explicit-path",
+        updatedAtMs: artifact.updatedAtMs,
     };
 }
 function getManifestVerificationEntry(entry) {
@@ -341,17 +374,19 @@ export function buildArtifactVerificationSummary(artifacts, manifest, manifestPa
     };
 }
 export function hasMissingFileArtifact(artifacts) {
-    return (artifacts ?? []).some((artifact) => !isPendingRecordingArtifact(artifact) && artifact.exists === false);
+    return (artifacts ?? []).some((artifact) => !isPendingRecordingArtifact(artifact) && (artifact.exists === false || artifact.status === "stale"));
 }
 export function formatMissingArtifactFailureText(artifacts) {
-    const missingArtifacts = (artifacts ?? []).filter((artifact) => !isPendingRecordingArtifact(artifact) && artifact.exists === false);
-    if (missingArtifacts.length === 0)
+    const failedArtifacts = (artifacts ?? []).filter((artifact) => !isPendingRecordingArtifact(artifact) && (artifact.exists === false || artifact.status === "stale"));
+    if (failedArtifacts.length === 0)
         return undefined;
-    if (missingArtifacts.length === 1) {
-        const artifact = missingArtifacts[0];
-        return `Artifact verification failed: requested ${artifact.kind} was not found at ${artifact.absolutePath}.`;
+    if (failedArtifacts.length === 1) {
+        const artifact = failedArtifacts[0];
+        return artifact.status === "stale"
+            ? `Artifact verification failed: requested ${artifact.kind} path ${artifact.absolutePath} has a modification time outside the current command window.`
+            : `Artifact verification failed: requested ${artifact.kind} was not found at ${artifact.absolutePath}.`;
     }
-    return `Artifact verification failed: ${missingArtifacts.length} requested artifacts were not found on disk.`;
+    return `Artifact verification failed: ${failedArtifacts.length} requested artifacts were missing or stale.`;
 }
 export function classifyPresentationSuccessCategory(options) {
     if ((options.artifactVerification?.missingCount ?? 0) > 0 || (options.artifactVerification?.unverifiedCount ?? 0) > 0) {
@@ -363,9 +398,9 @@ function formatArtifactLabel(artifact) {
     switch (artifact.kind) {
         case "download":
             if (artifact.exists !== true) {
-                return artifact.command === "wait" && artifact.subcommand === "--download" ? "Download event reported; file not verified" : "Download reported; file not verified";
+                return artifact.command === "wait" && isDownloadWaitSubcommand(artifact.subcommand) ? "Download event reported; file not verified" : "Download reported; file not verified";
             }
-            return artifact.command === "wait" && artifact.subcommand === "--download" ? "Download saved and verified" : "Downloaded file verified";
+            return artifact.command === "wait" && isDownloadWaitSubcommand(artifact.subcommand) ? "Download saved and verified" : "Downloaded file verified";
         case "file":
             return artifact.command === "state" ? "State file" : "Saved file";
         case "har":
@@ -381,11 +416,16 @@ function formatArtifactLabel(artifact) {
         case "trace":
             return "Saved trace";
         case "video":
-            if (artifact.command === "record" && artifact.subcommand === "restart-previous")
+            if (artifact.command === "record" && artifact.subcommand === "restart-previous") {
+                if (artifact.status === "stale")
+                    return "Previous recording stale";
+                if (artifact.exists === false)
+                    return "Previous recording missing";
                 return "Previous recording saved";
+            }
             if (!isPendingRecordingArtifact(artifact))
                 return "Saved recording";
-            return artifact.subcommand === "restart" ? "Recording restarted; output will be written on stop" : "Recording started; output will be written on stop";
+            return artifact.subcommand === "restart" ? "Recording restarted; output will be written on stop" : "Recording started in a fresh active page; output will be written on stop";
     }
 }
 export function formatArtifactSummary(artifacts) {
@@ -415,6 +455,7 @@ export function formatArtifactMetadataLines(artifacts) {
                 `Status: ${artifact.status ?? "pending"}`,
                 `Recording state: ${artifact.recordingState ?? "openRecording"}`,
                 `Will exist on stop: ${artifact.willExistOnStop !== false}`,
+                artifact.subcommand === "start" ? "Page state: record start uses a fresh active page for video capture; prior in-page DOM and JavaScript state does not carry over. Take a fresh snapshot before continuing." : undefined,
                 artifact.session ? `Session: ${artifact.session}` : undefined,
                 artifact.cwd ? `CWD: ${artifact.cwd}` : undefined,
                 `Machine data: details.artifacts[${index}]`,
@@ -439,7 +480,7 @@ export function formatArtifactMetadataLines(artifacts) {
     });
 }
 function isDownloadWaitCommand(commandInfo) {
-    return commandInfo.command === "wait" && commandInfo.subcommand === "--download";
+    return commandInfo.command === "wait" && isDownloadWaitSubcommand(commandInfo.subcommand);
 }
 function extractSavedFilePath(data) {
     return typeof data.path === "string" && data.path.trim().length > 0 ? data.path : undefined;

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

@@ -1,11 +1,13 @@
+import { isCloseCommand } from "../../command-taxonomy.js";
 import { isRecord } from "../../parsing.js";
-import { extractCommandTokens, parseCommandInfo, redactInvocationArgs, redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
+import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
+import { extractUpstreamCommandTokens, parseCommandInfo, redactInvocationArgs, redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { buildAgentBrowserNextActions } from "../action-recommendations.js";
-import { formatSessionArtifactRetentionSummary } from "../artifact-manifest.js";
+import { formatSessionArtifactRetentionSummary, isPendingRecordingArtifact } from "../artifact-manifest.js";
 import { classifyAgentBrowserFailureCategory } from "../categories.js";
 import { detectConfirmationRequired } from "../confirmation.js";
 import { applyNetworkRouteRecords, buildNetworkRouteDiagnostics } from "../network-routes.js";
-import { applyNamespaceToNextActions, withOptionalSessionArgs } from "../next-actions.js";
+import { appendUniqueAgentBrowserNextActions, applyNamespaceToNextActions, withOptionalSessionArgs } from "../next-actions.js";
 import { stringifyModelFacing } from "./common.js";
 import { buildArtifactVerificationSummary, classifyPresentationSuccessCategory, manifestHasNewNoticeWorthyEntries } from "./artifacts.js";
 import { formatBatchStepCommand, getPresentationImages, getPresentationPaths, getPresentationText, isStringArray } from "./content.js";
@@ -62,7 +64,7 @@ function hasModelFacingArgRedaction(args) {
 function getStatefulCommandSensitiveValues(command) {
     if (!command)
         return [];
-    const tokens = extractCommandTokens(command);
+    const tokens = extractUpstreamCommandTokens(command);
     const values = [];
     if (tokens[0] === "cookies" && tokens[1] === "set" && tokens[3])
         values.push(tokens[3]);
@@ -181,10 +183,11 @@ function formatBatchStepsText(steps) {
     return lines.join("\n\n");
 }
 async function buildBatchStepPresentation(options) {
-    const { artifactManifest, artifactRequest, buildNestedToolPresentation, cwd, index, item, namespace, networkRoutes, persistentArtifactStore, sessionName } = options;
+    const { artifactManifest, artifactMaxUpdatedAtMs, artifactMinUpdatedAtMs, artifactRequest, buildNestedToolPresentation, cwd, index, item, namespace, networkRoutes, persistentArtifactStore, sessionName } = options;
     const command = isStringArray(item.command) ? item.command : undefined;
     const redactedCommand = command ? redactInvocationArgs(command) : undefined;
     const commandText = formatBatchStepCommand(hasModelFacingArgRedaction(redactedCommand) ? redactedCommand : command, index);
+    const lifecycle = extractBatchStepLifecycle(item.result);
     if (item.success === false) {
         const redactedErrorData = command?.[0] === "clipboard"
             ? redactSensitiveValue(redactClipboardPermissionErrorValue({ command: "clipboard", subcommand: command[1] }, item.error, getClipboardWritePayloadCandidates(command)))
@@ -196,13 +199,14 @@ async function buildBatchStepPresentation(options) {
             errorText,
         });
         const confirmationRequired = detectConfirmationRequired(item.error);
-        const nextActions = applyNamespaceToNextActions(mergePresentationNextActions(buildAgentBrowserNextActions({
+        const nextActions = applyNamespaceToNextActions(mergePresentationNextActions(isWaitTextAssertionCommand(command) ? [buildWaitTextAssertionFailureNextAction(sessionName)] : undefined, buildAgentBrowserNextActions({
             args: command,
             command: command?.[0],
             confirmationId: confirmationRequired?.id,
             failureCategory,
             resultCategory: "failure",
-        }), isWaitTextAssertionCommand(command) ? [buildWaitTextAssertionFailureNextAction(sessionName)] : undefined), namespace);
+            sessionName,
+        })), namespace);
         const presentation = {
             content: [{ type: "text", text: errorText }],
             failureCategory,
@@ -219,6 +223,7 @@ async function buildBatchStepPresentation(options) {
                 data: redactedErrorData,
                 failureCategory,
                 index,
+                lifecycle,
                 nextActions,
                 resultCategory: "failure",
                 success: false,
@@ -235,12 +240,15 @@ async function buildBatchStepPresentation(options) {
         : undefined;
     const presentation = await buildNestedToolPresentation({
         artifactManifest,
+        artifactMaxUpdatedAtMs,
+        artifactMinUpdatedAtMs,
         artifactRequest,
         commandInfo: commandInfoWithTokens,
         cwd,
         args: command,
         envelope: { data: item.result, success: true },
         networkRouteDiagnostics,
+        namespace,
         persistentArtifactStore,
         sessionName,
     });
@@ -261,6 +269,7 @@ async function buildBatchStepPresentation(options) {
         failureCategory: presentation.failureCategory,
         resultCategory: stepSucceeded ? "success" : "failure",
         savedFilePath: presentation.savedFilePath,
+        sessionName,
         successCategory: presentation.successCategory,
     }), namespace);
     const pageChangeSummary = buildPageChangeSummary({
@@ -284,6 +293,7 @@ async function buildBatchStepPresentation(options) {
             imagePath: imagePaths[0],
             imagePaths: imagePaths.length > 0 ? imagePaths : undefined,
             index,
+            lifecycle,
             networkRouteDiagnostics: presentation.networkRouteDiagnostics,
             nextActions,
             pageChangeSummary,
@@ -298,6 +308,48 @@ async function buildBatchStepPresentation(options) {
         presentation,
     };
 }
+function extractBatchStepLifecycle(result) {
+    if (!isRecord(result) || !isRecord(result.lifecycle) || !isRecord(result.lifecycle.effectiveLaunch))
+        return undefined;
+    const browserLaunched = result.lifecycle.effectiveLaunch.browserLaunched;
+    return typeof browserLaunched === "boolean" ? { effectiveLaunch: { browserLaunched } } : undefined;
+}
+function abandonedRecordingArtifact(artifact) {
+    const { recordingState: _recordingState, willExistOnStop: _willExistOnStop, ...terminal } = artifact;
+    return { ...terminal, exists: false, status: "missing", subcommand: "close-abandoned" };
+}
+function coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace) {
+    const artifacts = [];
+    const pendingIndexesBySession = new Map();
+    const removedPendingIndexes = new Set();
+    for (const step of steps) {
+        for (const artifact of step.presentation.artifacts ?? []) {
+            const index = artifacts.push(artifact) - 1;
+            if (artifact.command !== "record" || artifact.kind !== "video")
+                continue;
+            const session = artifact.session ? getAgentBrowserSessionIdentityKey(artifact.session, artifact.namespace) : "";
+            if (isPendingRecordingArtifact(artifact)) {
+                const pendingIndexes = pendingIndexesBySession.get(session) ?? [];
+                pendingIndexes.push(index);
+                pendingIndexesBySession.set(session, pendingIndexes);
+                continue;
+            }
+            const pendingIndex = pendingIndexesBySession.get(session)?.pop();
+            if (pendingIndex !== undefined)
+                removedPendingIndexes.add(pendingIndex);
+        }
+        const command = step.details.command;
+        if (step.details.success !== true || !command || !isCloseCommand(extractUpstreamCommandTokens(command)[0]))
+            continue;
+        const session = sessionName ? getAgentBrowserSessionIdentityKey(sessionName, namespace) : "";
+        for (const pendingIndex of pendingIndexesBySession.get(session) ?? []) {
+            const pending = artifacts[pendingIndex];
+            if (pending && !removedPendingIndexes.has(pendingIndex))
+                artifacts[pendingIndex] = abandonedRecordingArtifact(pending);
+        }
+    }
+    return artifacts.filter((_, index) => !removedPendingIndexes.has(index));
+}
 export async function buildBatchPresentation(options) {
     const { artifactRequests, buildNestedToolPresentation, cwd, data, namespace, networkRoutes, persistentArtifactStore, sessionName, summary } = options;
     const steps = [];
@@ -307,6 +359,8 @@ export async function buildBatchPresentation(options) {
     for (const [index, item] of data.entries()) {
         const step = await buildBatchStepPresentation({
             artifactManifest: currentArtifactManifest,
+            artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs,
+            artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs,
             artifactRequest: artifactRequests?.[index],
             buildNestedToolPresentation,
             cwd,
@@ -319,7 +373,7 @@ export async function buildBatchPresentation(options) {
         });
         steps.push(step);
         currentArtifactManifest = step.presentation.artifactManifest ?? currentArtifactManifest;
-        currentNetworkRoutes = applyNetworkRouteRecords(currentNetworkRoutes, isStringArray(item.command) ? extractCommandTokens(item.command) : undefined, item.success !== false && step.details.success);
+        currentNetworkRoutes = applyNetworkRouteRecords(currentNetworkRoutes, isStringArray(item.command) ? extractUpstreamCommandTokens(item.command) : undefined, item.success !== false && step.details.success);
         protectedPersistentPaths.push(...getPresentationPaths({
             primaryPath: step.presentation.fullOutputPath,
             secondaryPaths: step.presentation.fullOutputPaths,
@@ -327,7 +381,7 @@ export async function buildBatchPresentation(options) {
     }
     const batchFailure = getBatchFailureDetails(steps);
     const images = steps.flatMap((step) => getPresentationImages(step.presentation));
-    const artifacts = steps.flatMap((step) => step.presentation.artifacts ?? []);
+    const artifacts = coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace);
     const artifactVerification = buildArtifactVerificationSummary(artifacts);
     const fullOutputPaths = steps.flatMap((step) => getPresentationPaths({
         primaryPath: step.presentation.fullOutputPath,
@@ -356,9 +410,10 @@ export async function buildBatchPresentation(options) {
     const contentText = artifactRetentionSummary && manifestHasNewNoticeWorthyEntries(options.artifactManifest, currentArtifactManifest)
         ? `${text}\n\n${artifactRetentionSummary}`
         : text;
+    const artifactLifecycleActions = applyNamespaceToNextActions(buildAgentBrowserNextActions({ artifacts, command: "batch", resultCategory: batchFailure ? "failure" : "success", sessionName }), namespace);
     const nextActions = batchFailure
-        ? batchFailure.failedStep.nextActions
-        : buildAgentBrowserNextActions({ artifacts, command: "batch", resultCategory: "success" });
+        ? appendUniqueAgentBrowserNextActions([...(batchFailure.failedStep.nextActions ?? [])], artifactLifecycleActions)
+        : artifactLifecycleActions;
     const changedSteps = steps.map((step) => step.details).filter((details) => details.pageChangeSummary !== undefined);
     const pageChangeSummary = artifacts.length > 0
         ? buildPageChangeSummary({

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Build browser profile/config recovery hints for launch/setup failures.
- * Responsibilities: Recognize local Chrome/profile setup errors, avoid self-loop diagnostics, and emit canonical next actions.
- * Scope: Error presentation only; upstream profile discovery and doctor execution remain normal agent_browser commands.
- */
 import { isOpenNavigationCommand } from "../../command-taxonomy.js";
 import { getStartupScopedFlags } from "../../runtime.js";
 import { buildNextToolAction } from "../next-actions.js";

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

@@ -1,11 +1,7 @@
-/**
- * Purpose: Share small presentation formatting and redaction helpers across result presentation modules.
- * Responsibilities: Normalize scalar fields, stringify model-facing values, and apply sensitive-text redaction.
- * Scope: Leaf helpers only; command-family formatting lives in sibling modules.
- */
 import { containsManagedSessionRestoreKey } from "../../managed-session-capabilities.js";
 import { redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { stringifyUnknown, truncateText } from "../text.js";
+const UNTITLED_PAGE_SUMMARY = "(untitled page)";
 export function stringifyModelFacing(value) {
     return stringifyUnknown(redactSensitiveValue(value));
 }
@@ -39,6 +35,23 @@ export function getStringField(data, key) {
     const value = data[key];
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
+// `lifecycle` is upstream launch/reuse bookkeeping, never page content, so it must not be the
+// answer an agent reads when a command has no dedicated presenter.
+export function omitUpstreamLifecycle(data) {
+    const { lifecycle: _lifecycle, ...rest } = data;
+    return rest;
+}
+export function getPageSummary(data) {
+    const title = typeof data.title === "string" ? data.title : undefined;
+    const url = typeof data.url === "string" ? data.url : undefined;
+    if (title === undefined && url === undefined)
+        return undefined;
+    if (title && url)
+        return `${title}\n${url}`;
+    if (url)
+        return url;
+    return title || UNTITLED_PAGE_SUMMARY;
+}
 export function formatCount(count, singular, plural = `${singular}s`) {
     return `${count} ${count === 1 ? singular : plural}`;
 }

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Share small ToolPresentation content helpers used by batch and compaction code.
- * Responsibilities: Extract text/image/path fields and format batch step command labels.
- * Scope: Pure ToolPresentation content helpers only.
- */
 export function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "string");
 }

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Render diagnostic command families and safe redacted diagnostic data.
- * Responsibilities: Format sessions, profiles, auth/cookies/storage, network diagnostics, console/errors, stream/dashboard/chat, and build network follow-up actions.
- * Scope: Diagnostic/result-state command presentation only; core orchestration stays in presentation.ts.
- */
 import { isRecord } from "../../parsing.js";
 import { isSensitiveFieldName, redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { classifyNetworkRequestFailure, isApiLikeNetworkRequest, isNetworkArtifactNoiseRequest, summarizeNetworkFailures } from "../network.js";
@@ -66,7 +61,9 @@ export function getTabSummary(data) {
                     ? String(tab.index)
                     : String(index);
         const labelText = label && label !== tabSelector ? ` label=${redactModelFacingText(label)}` : "";
-        return `${marker} [${tabSelector}]${labelText} ${title} — ${url}`;
+        const targetId = typeof tab.targetId === "string" && tab.targetId.trim().length > 0 ? tab.targetId.trim() : undefined;
+        const targetText = targetId && targetId !== tabSelector ? ` target=${redactModelFacingText(targetId)}` : "";
+        return `${marker} [${tabSelector}]${labelText}${targetText} ${title} — ${url}`;
     });
     return lines.join("\n");
 }
@@ -353,6 +350,8 @@ function formatNetworkRequestLine(item, index) {
 }
 function formatNetworkRequestsText(data, commandInfo) {
     const requests = getArrayField(data, "requests");
+    if (isClearDiagnosticCommand(commandInfo) && data.cleared === true && !requests)
+        return "Network request buffer cleared.";
     if (!requests)
         return undefined;
     if (isClearDiagnosticCommand(commandInfo)) {
@@ -598,6 +597,8 @@ export function buildStreamNextActions(commandInfo, data, sessionName) {
 }
 function formatConsoleText(data, commandInfo) {
     const messages = getArrayField(data, "messages");
+    if (isClearDiagnosticCommand(commandInfo) && data.cleared === true && !messages)
+        return "Console buffer cleared.";
     if (!messages)
         return undefined;
     if (isClearDiagnosticCommand(commandInfo)) {

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

@@ -189,11 +189,12 @@ export function buildErrorPresentation(options) {
     const nextActions = [
         ...(buildUnknownCommandSuggestionActions(unknownCommandSuggestions, sessionName) ?? []),
         ...(browserProfileConfigRecovery?.actions ?? []),
-        ...(buildAgentBrowserNextActions({
+        ...(browserProfileConfigRecovery ? [] : buildAgentBrowserNextActions({
             args,
             command: commandInfo.command,
             failureCategory: categoryDetails.failureCategory,
             resultCategory: "failure",
+            sessionName,
         }) ?? []),
     ];
     return {

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Compact oversized model-facing tool output into bounded previews and spill artifacts.
- * Responsibilities: Write full output to persistent/session temp storage, update artifact manifests, and preserve safe previews.
- * Scope: Large-output compaction only.
- */
 import { writePersistentSessionArtifactFile, writeSecureTempFile, } from "../../temp.js";
 import { buildEvictedSessionArtifactEntries } from "../artifact-manifest.js";
 import { countLines, truncateText } from "../text.js";

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Remove wrapper-owned managed session and state capabilities from caller-visible list results.
- * Responsibilities: Recognize managed list rows recursively and preserve the surrounding upstream result shape.
- * Scope: Presentation filtering only; command authorization lives in managed-session-state-policy.ts.
- */
 import { containsManagedSessionRestoreKey, isWrapperManagedSessionName } from "../../managed-session-capabilities.js";
 import { isRecord } from "../../parsing.js";
 function isWrapperManagedSessionListItem(item) {