pi-agent-browser-native 0.6.10 → 0.6.11

package/dist/extensions/agent-browser/lib/process.js

@@ -286,10 +286,12 @@ export function buildAgentBrowserProcessEnv(baseEnv = processEnv, overrides = un
     clampUpstreamDefaultTimeout(childEnv);
     return childEnv;
 }
-function getManagedPreSpawnPolicyError(options, currentPageUrl, pageUrlUnknown = false) {
+function getManagedPreSpawnPolicyError(options, currentPageUrl, pageUrlUnknown = false, browserIndependentReadConfirmation = false) {
     if (!validateManagedSessionRestoreContextForSpawn(options)) {
         return "Managed session restore policy, storage, or checkout identity changed after planning; refusing to start agent-browser.";
     }
+    if (browserIndependentReadConfirmation)
+        return undefined;
     return getPageTargetValidationError({
         args: options.args,
         currentPageUrl,
@@ -316,7 +318,7 @@ export async function runAgentBrowserProcess(options) {
         restoreState: managedSessionRestoreState,
         stdin,
     };
-    const planningPolicyError = getManagedPreSpawnPolicyError(managedSessionRestoreOptions, managedStateCurrentPageUrl, managedStatePageUrlUnknown);
+    const planningPolicyError = getManagedPreSpawnPolicyError(managedSessionRestoreOptions, managedStateCurrentPageUrl, managedStatePageUrlUnknown, options.browserIndependentReadConfirmation);
     if (planningPolicyError) {
         return {
             aborted: false,
@@ -331,7 +333,7 @@ export async function runAgentBrowserProcess(options) {
     const managedSessionRestoreEnv = getManagedSessionRestoreEnv(managedSessionRestoreOptions);
     const ownedManagedSessionCompatibilityEnv = getOwnedManagedSessionCompatibilityEnv(managedSessionRestoreOptions);
     const processOverrides = {
-        [AGENT_BROWSER_IDLE_TIMEOUT_ENV]: String(getImplicitSessionIdleTimeoutMs()),
+        ...(ownedManagedSession ? { [AGENT_BROWSER_IDLE_TIMEOUT_ENV]: String(getImplicitSessionIdleTimeoutMs()) } : {}),
         ...managedSessionRestoreEnv,
         ...env,
         ...getManagedSessionRestoreProtectedEnv(managedSessionRestoreOptions, managedSessionRestoreEnv),
@@ -340,7 +342,8 @@ export async function runAgentBrowserProcess(options) {
     };
     const explicitSocketDir = processOverrides[AGENT_BROWSER_SOCKET_DIR_ENV];
     let effectiveEnv = explicitSocketDir === undefined ? { ...processOverrides, [AGENT_BROWSER_SOCKET_DIR_ENV]: undefined } : processOverrides;
-    const requestedSocketDir = explicitSocketDir ?? parentEnv[PI_AGENT_BROWSER_SOCKET_DIR_ENV] ?? getAgentBrowserSocketDir();
+    const requestedSocketDir = explicitSocketDir ?? parentEnv[PI_AGENT_BROWSER_SOCKET_DIR_ENV]
+        ?? (!ownedManagedSession ? parentEnv[AGENT_BROWSER_SOCKET_DIR_ENV] : undefined) ?? getAgentBrowserSocketDir();
     if (requestedSocketDir !== undefined) {
         const socketDirError = requestedSocketDir.length > 0
             ? await getAgentBrowserSocketDirValidationError(requestedSocketDir)
@@ -463,7 +466,7 @@ export async function runAgentBrowserProcess(options) {
             });
         };
         const childEnv = buildAgentBrowserProcessEnv(parentEnv, effectiveEnv);
-        const spawnPolicyError = getManagedPreSpawnPolicyError(managedSessionRestoreOptions, managedStateCurrentPageUrl, managedStatePageUrlUnknown);
+        const spawnPolicyError = getManagedPreSpawnPolicyError(managedSessionRestoreOptions, managedStateCurrentPageUrl, managedStatePageUrlUnknown, options.browserIndependentReadConfirmation);
         if (spawnPolicyError) {
             resolve({ aborted: false, agentBrowserStarted: false, exitCode: 1, spawnError: new Error(spawnPolicyError), stderr: "", stdout: "", timedOut: false });
             return;

package/dist/extensions/agent-browser/lib/read-confirmation.js

@@ -0,0 +1,59 @@
+import { extractUpstreamCommandTokens } from "./argv-descriptor.js";
+import { extractExplicitSessionName, getAgentBrowserSessionIdentityKey, resolveAgentBrowserNamespace, scanUpstreamGlobalFlagOccurrences } from "./argv-grammar.js";
+import { getExplicitReadUrl } from "./command-policy.js";
+import { isCloseCommand } from "./command-taxonomy.js";
+import { isRecord } from "./parsing.js";
+export function parseReadConfirmation(value) {
+    if (!isRecord(value) || value.source !== "native-explicit-url-read" || (value.state !== "pending" && value.state !== "cleared"))
+        return undefined;
+    if (typeof value.id !== "string" || !value.id || typeof value.sessionName !== "string" || !value.sessionName || (value.namespace !== undefined && typeof value.namespace !== "string"))
+        return undefined;
+    return { ...(isRecord(value.capabilities) && value.capabilities.readRequiresConfirmation === true ? { capabilities: { readRequiresConfirmation: true } } : {}), id: value.id, sessionName: value.sessionName, namespace: value.namespace, source: "native-explicit-url-read", state: value.state };
+}
+export function findReadConfirmation(args, confirmations, namespace) {
+    const tokens = extractUpstreamCommandTokens(args);
+    if (tokens.length !== 2 || !["confirm", "deny"].includes(tokens[0]))
+        return undefined;
+    const sessionName = extractExplicitSessionName(args);
+    const effectiveNamespace = resolveAgentBrowserNamespace(args, namespace);
+    const matches = [...confirmations].filter(value => value.state === "pending" && value.id === tokens[1]
+        && (sessionName === undefined || getAgentBrowserSessionIdentityKey(sessionName, value.namespace) === getAgentBrowserSessionIdentityKey(value.sessionName, value.namespace))
+        && (effectiveNamespace === undefined || getAgentBrowserSessionIdentityKey(value.sessionName, effectiveNamespace) === getAgentBrowserSessionIdentityKey(value.sessionName, value.namespace)));
+    return matches.length === 1 ? matches[0] : undefined;
+}
+export function scopeReadConfirmationArgs(args, confirmation) {
+    return [
+        ...(scanUpstreamGlobalFlagOccurrences(args, "--namespace").length === 0 ? ["--namespace", confirmation.namespace ?? ""] : []),
+        ...(extractExplicitSessionName(args) === undefined ? ["--session", confirmation.sessionName] : []),
+        ...args,
+    ];
+}
+export function nextReadConfirmation(options) {
+    const { commandTokens: tokens, current } = options;
+    const settlesRead = current?.state === "pending" && tokens.length === 2 && ["confirm", "deny"].includes(tokens[0]) && tokens[1] === current.id;
+    const confirmedResult = settlesRead && tokens[0] === "confirm" && isRecord(options.data) && options.data.confirmed === true && options.data.action === "read" && isRecord(options.data.result)
+        ? options.data.result.data : options.data;
+    // Native control fields only. Never parse response content, snapshot text or nested page JSON as provenance.
+    if (isRecord(confirmedResult) && confirmedResult.confirmation_required === true && typeof confirmedResult.confirmation_id === "string" && confirmedResult.confirmation_id && !("content" in confirmedResult)) {
+        if (confirmedResult.action === "read" && (typeof getExplicitReadUrl(tokens) === "string" || settlesRead)) {
+            return { ...(isRecord(confirmedResult.capabilities) && confirmedResult.capabilities.readRequiresConfirmation === true ? { capabilities: { readRequiresConfirmation: true } } : {}), id: confirmedResult.confirmation_id, namespace: options.namespace, sessionName: options.sessionName, source: "native-explicit-url-read", state: "pending" };
+        }
+        if (current?.state === "pending")
+            return { ...current, state: "cleared" };
+    }
+    return options.succeeded && current?.state === "pending" && (settlesRead || isCloseCommand(tokens[0])) ? { ...current, state: "cleared" } : undefined;
+}
+export function buildReadConfirmationNextActions(confirmation, pendingResponse) {
+    if (confirmation.state === "cleared")
+        return [];
+    const prefix = ["--namespace", confirmation.namespace ?? "", "--session", confirmation.sessionName];
+    if (!pendingResponse)
+        return [{ id: "inspect-read-confirmation-session", tool: "agent_browser", params: { args: [...prefix, "session", "info"] }, reason: "Inspect the exact native session after the read confirmation failed; rerun the original URL read if its ID expired.", safety: "Read-only status, without browser launch or tab changes. Do not substitute a different pending confirmation ID." }];
+    return ["confirm", "deny"].map(command => ({
+        id: command === "confirm" ? "approve-confirmation" : "deny-confirmation", tool: "agent_browser", params: { args: [...prefix, command, confirmation.id] },
+        reason: `${command === "confirm" ? "Approve" : "Deny"} the native confirmation for this explicit URL read.`,
+        safety: confirmation.capabilities?.readRequiresConfirmation === true
+            ? "Review the requested read first. The native capability proves ID matching; no DOM confirmation is implied."
+            : "Native ID matching/browser independence is unproven. The exact native session is preserved, but this confirmation retains normal page checks.",
+    }));
+}

package/dist/extensions/agent-browser/lib/recording-reservations.js

@@ -14,6 +14,8 @@ function getArtifactReservation(artifact) {
         cwd: artifact.cwd ?? process.cwd(),
         namespace: artifact.namespace,
         path: artifact.path,
+        ...(artifact.recording?.recordingId ? { recordingId: artifact.recording.recordingId } : {}),
+        ...(artifact.recordingStartedAtMs !== undefined ? { startedAtMs: artifact.recordingStartedAtMs } : {}),
         sessionName: artifact.session,
     };
 }
@@ -43,7 +45,7 @@ export function applyRecordingArtifactsToReservations(reservations, artifacts) {
     for (const [key, pending] of pendingBySession) {
         const existing = reservations.get(key);
         reservations.set(key, pending);
-        if (!existing || existing.absolutePath !== pending.absolutePath || existing.cwd !== pending.cwd) {
+        if (!existing || existing.absolutePath !== pending.absolutePath || existing.cwd !== pending.cwd || existing.recordingId !== pending.recordingId || existing.startedAtMs !== pending.startedAtMs) {
             transitions.push({ reservation: pending, state: "active" });
         }
     }
@@ -63,6 +65,8 @@ export function appendRecordingReservationTransition(pi, transition) {
         cwd: state === "active" ? reservation.cwd : undefined,
         namespace: reservation.namespace,
         path: state === "active" ? reservation.path : undefined,
+        recordingId: state === "active" ? reservation.recordingId : undefined,
+        startedAtMs: state === "active" ? reservation.startedAtMs : undefined,
         sessionName: reservation.sessionName,
         state,
         version: 1,
@@ -81,6 +85,10 @@ function parseReservationTransition(data) {
             state: "closed",
         };
     }
+    if (data.recordingId !== undefined && (typeof data.recordingId !== "string" || !data.recordingId))
+        return undefined;
+    if (data.startedAtMs !== undefined && (typeof data.startedAtMs !== "number" || !Number.isFinite(data.startedAtMs)))
+        return undefined;
     if (typeof data.absolutePath !== "string" || !isAbsolute(data.absolutePath)
         || typeof data.cwd !== "string" || !isAbsolute(data.cwd) || typeof data.path !== "string")
         return undefined;
@@ -90,6 +98,8 @@ function parseReservationTransition(data) {
             cwd: data.cwd,
             namespace: data.namespace,
             path: data.path,
+            ...(typeof data.recordingId === "string" ? { recordingId: data.recordingId } : {}),
+            ...(typeof data.startedAtMs === "number" ? { startedAtMs: data.startedAtMs } : {}),
             sessionName: data.sessionName,
         },
         state: "active",

package/dist/extensions/agent-browser/lib/results/action-recommendations.js

@@ -197,6 +197,14 @@ export function buildAgentBrowserNextActions(options) {
                 break;
             case "timeout":
                 {
+                    if (options.command === "session" && options.subcommand === "info") {
+                        actions.push(buildNextToolAction({
+                            args: ["session", "info"],
+                            id: "retry-session-info",
+                            reason: "Retry the same session status check without opening a browser or inspecting its page.",
+                        }));
+                        break;
+                    }
                     const textAssertion = options.command === "wait" && options.args?.includes("--text") === true;
                     const urlAssertion = options.command === "wait" && options.args?.includes("--url") === true;
                     actions.push(buildNextToolAction({

package/dist/extensions/agent-browser/lib/results/artifact-manifest.js

@@ -4,7 +4,8 @@ export function isPendingRecordingCommand(command, subcommand, kind) {
     return command === "record" && (subcommand === "start" || subcommand === "restart") && kind === "video";
 }
 export function isPendingRecordingArtifact(artifact) {
-    return isPendingRecordingCommand(artifact.command, artifact.subcommand, artifact.kind);
+    return artifact.recordingState === "openRecording" || artifact.status === "pending"
+        || (artifact.status === undefined && isPendingRecordingCommand(artifact.command, artifact.subcommand, artifact.kind));
 }
 export const SESSION_ARTIFACT_MANIFEST_VERSION = 1;
 export const SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES_ENV = "PI_AGENT_BROWSER_SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES";
@@ -98,10 +99,10 @@ export function retirePendingRecordingManifestEntries(manifest, sessionName, nam
             || !entry.session
             || getAgentBrowserSessionIdentityKey(entry.session, entry.namespace) !== sessionKey
             || entry.kind !== "video"
-            || !isPendingRecordingCommand(entry.command, entry.subcommand, entry.kind))
+            || !isPendingRecordingArtifact(entry))
             return entry;
         changed = true;
-        return { ...entry, retentionState: "missing", subcommand: "close-abandoned" };
+        return { ...entry, recordingState: undefined, status: "unverified", subcommand: "close-abandoned" };
     });
     if (!changed)
         return manifest;
@@ -135,7 +136,7 @@ export function mergeSessionArtifactManifest(options) {
                 if (candidateKey !== key
                     && sameRecordingSession
                     && candidate.kind === "video"
-                    && isPendingRecordingCommand(candidate.command, candidate.subcommand, candidate.kind)) {
+                    && isPendingRecordingArtifact(candidate)) {
                     byPath.delete(candidateKey);
                 }
             }
@@ -155,7 +156,7 @@ export function mergeSessionArtifactManifest(options) {
         const leftTime = left.evictedAtMs ?? left.createdAtMs;
         const rightTime = right.evictedAtMs ?? right.createdAtMs;
         return rightTime - leftTime
-            || Number(isPendingRecordingCommand(right.command, right.subcommand, right.kind)) - Number(isPendingRecordingCommand(left.command, left.subcommand, left.kind))
+            || Number(isPendingRecordingArtifact(right)) - Number(isPendingRecordingArtifact(left))
             || left.path.localeCompare(right.path);
     })
         .slice(0, maxEntries);

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

@@ -1,14 +1,16 @@
 import { isPendingRecordingArtifact } from "./artifact-manifest.js";
 function hasUnverifiedFileArtifact(artifacts) {
-    return (artifacts ?? []).some((artifact) => !isPendingRecordingArtifact(artifact) && artifact.exists !== true);
+    return (artifacts ?? []).some((artifact) => !isPendingRecordingArtifact(artifact) && (artifact.exists !== true || ["failed", "stale", "unverified"].includes(artifact.status ?? "")));
 }
 export function classifyAgentBrowserSuccessCategory(options) {
     if (options.inspection)
         return "inspection";
+    if (hasUnverifiedFileArtifact(options.artifacts))
+        return "artifact-unverified";
     if ((options.artifacts ?? []).some(isPendingRecordingArtifact))
         return "artifact-pending";
     if ((options.artifacts ?? []).length > 0)
-        return hasUnverifiedFileArtifact(options.artifacts) ? "artifact-unverified" : "artifact-saved";
+        return "artifact-saved";
     if (options.savedFile)
         return "artifact-saved";
     return "completed";

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

@@ -5,6 +5,7 @@ import { getExplicitArtifactDestination } from "../../orchestration/browser-run/
 import { isRecord, parsePositiveInteger } from "../../parsing.js";
 import { formatSessionArtifactRetentionSummary, getSessionArtifactManifestEntryKey, isPendingRecordingArtifact, isPendingRecordingCommand, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
 import { classifyAgentBrowserSuccessCategory } from "../categories.js";
+import { formatRecordingReceipt, getRecordingReceipt } from "../recording.js";
 const PNG_HEADER = Buffer.from("89504e470d0a1a0a0000000d49484452", "hex");
 const INLINE_IMAGE_MAX_BYTES_ENV = "PI_AGENT_BROWSER_INLINE_IMAGE_MAX_BYTES";
 const DEFAULT_INLINE_IMAGE_MAX_BYTES = 5 * 1_024 * 1_024;
@@ -159,24 +160,26 @@ async function buildFileArtifactMetadata(options) {
     const absolutePath = options.artifactRequest?.absolutePath ?? resolve(options.cwd, options.path);
     const displayPath = options.artifactRequest?.path ?? options.path;
     const extension = extname(absolutePath || options.path).toLowerCase() || undefined;
-    const pendingRecording = isPendingRecordingCommand(options.commandInfo.command, options.commandInfo.subcommand, kind);
+    const pendingRecording = options.recordingPending === true || (isPendingRecordingCommand(options.commandInfo.command, options.commandInfo.subcommand, kind) && options.recordingOutcome !== false && options.recording?.success !== false);
+    const captureStartedAtMs = options.recording?.capture.startedAt ? Date.parse(options.recording.capture.startedAt) : NaN;
+    const recordingStartedAtMs = Number.isFinite(captureStartedAtMs) ? captureStartedAtMs : options.artifactMinUpdatedAtMs;
     let exists;
     let sizeBytes;
     let mediaType;
     let stale = false;
     let updatedAtMs;
-    if (!pendingRecording) {
+    if (!pendingRecording || options.commandInfo.subcommand === "stop") {
         try {
             const fileStats = await stat(absolutePath);
-            exists = true;
+            exists = fileStats.isFile();
             sizeBytes = fileStats.size;
             updatedAtMs = fileStats.mtimeMs;
             mediaType = fileStats.isFile() ? await getFileImageMimeType(absolutePath) : undefined;
             const commandCreatesArtifact = !(options.commandInfo.command === "wait" && isDownloadWaitSubcommand(options.commandInfo.subcommand));
-            stale = commandCreatesArtifact && artifactMtimeIsOutsideCommandWindow(updatedAtMs, options.artifactMinUpdatedAtMs, options.artifactMaxUpdatedAtMs);
+            stale = commandCreatesArtifact && artifactMtimeIsOutsideCommandWindow(updatedAtMs, kind === "video" ? recordingStartedAtMs : options.artifactMinUpdatedAtMs, options.artifactMaxUpdatedAtMs);
         }
-        catch {
-            exists = false;
+        catch (error) {
+            exists = ["ENOENT", "ENOTDIR"].includes(error.code ?? "") ? false : undefined;
         }
     }
     return {
@@ -190,11 +193,17 @@ async function buildFileArtifactMetadata(options) {
         mediaType,
         namespace: options.namespace,
         path: displayPath,
+        recording: options.recording,
+        recordingStartedAtMs: kind === "video" ? recordingStartedAtMs : undefined,
         recordingState: pendingRecording ? "openRecording" : undefined,
         requestedPath: options.artifactRequest?.path ?? getExplicitArtifactDestination(options.commandInfo.commandTokens ?? []),
         session: options.sessionName,
         sizeBytes,
-        status: pendingRecording ? "pending" : exists === false ? "missing" : stale ? "stale" : options.artifactRequest?.status ?? "saved",
+        status: pendingRecording ? "pending" : exists !== true ? exists === false ? "missing" : "unverified" : stale ? "stale"
+            : kind === "video" && (options.recording?.success === false || options.recording?.output.encoderSucceeded === false || (options.recordingOutcome === false && options.recording?.success !== null)) ? "failed"
+                : kind === "video" && ((options.recording?.success !== true && options.recordingOutcome !== true)
+                    || (options.recording?.file.sizeBytes != null && options.recording.file.sizeBytes !== sizeBytes)) ? "unverified"
+                    : options.artifactRequest?.status ?? "saved",
         subcommand: options.commandInfo.subcommand,
         tempPath: options.artifactRequest?.tempPath,
         updatedAtMs,
@@ -204,6 +213,10 @@ async function buildFileArtifactMetadata(options) {
 async function buildPreviousRestartRecordingArtifact(options) {
     if (options.commandInfo.command !== "record" || options.commandInfo.subcommand !== "restart")
         return undefined;
+    if (isRecord(options.data) && "previousRecording" in options.data) {
+        const recording = getRecordingReceipt(options.data.previousRecording);
+        return recording ? buildFileArtifactMetadata({ ...options, commandInfo: { command: "record", subcommand: "restart-previous" }, path: recording.path, recording }) : 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") &&
@@ -233,18 +246,21 @@ async function buildPreviousRestartRecordingArtifact(options) {
             exists: true,
             mediaType: fileStats.isFile() ? await getFileImageMimeType(absolutePath) : undefined,
             sizeBytes: fileStats.size,
-            status: stale ? "stale" : "saved",
+            status: stale ? "stale" : "unverified",
             updatedAtMs: fileStats.mtimeMs,
         };
     }
-    catch {
-        return { ...base, exists: false, status: "missing" };
+    catch (error) {
+        const missing = ["ENOENT", "ENOTDIR"].includes(error.code ?? "");
+        return { ...base, exists: missing ? false : undefined, status: missing ? "missing" : "unverified" };
     }
 }
 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 previousRestartRecordingArtifact = await buildPreviousRestartRecordingArtifact({ artifactManifest: options.artifactManifest, artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs, artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs, commandInfo: options.commandInfo, cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName });
+    const recording = options.commandInfo.command === "record" ? getRecordingReceipt(options.data, options.commandInfo.subcommand === "stop" ? options.recordingOutcome : undefined) : undefined;
+    const recordingPending = options.recordingPending ?? (recording?.success === null && isRecord(options.data) && isRecord(options.data.capture) && recording.capture.endedAt === null);
+    const currentArtifacts = (await Promise.all(candidates.map((path) => buildFileArtifactMetadata({ ...options, path, recording, recordingPending })))).filter((artifact) => artifact !== undefined);
+    const previousRestartRecordingArtifact = await buildPreviousRestartRecordingArtifact(options);
     return previousRestartRecordingArtifact ? [previousRestartRecordingArtifact, ...currentArtifacts] : currentArtifacts;
 }
 export function buildManifestEntriesForFileArtifacts(artifacts, nowMs = Date.now()) {
@@ -259,6 +275,10 @@ export function buildManifestEntriesForFileArtifacts(artifacts, nowMs = Date.now
         mediaType: artifact.mediaType,
         namespace: artifact.namespace,
         path: artifact.path,
+        recording: artifact.recording,
+        recordingStartedAtMs: artifact.recordingStartedAtMs,
+        recordingState: artifact.recordingState,
+        status: artifact.status,
         requestedPath: artifact.requestedPath,
         retentionState: artifact.exists === false || artifact.status === "stale" ? "missing" : "live",
         session: artifact.session,
@@ -268,10 +288,7 @@ 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);
+    return artifact.kind === "video" && artifact.command === "record" ? true : artifact.status !== "stale" && !isPendingRecordingArtifact(artifact);
 }
 function getArtifactVerificationEntry(artifact) {
     if (isPendingRecordingArtifact(artifact)) {
@@ -279,7 +296,9 @@ function getArtifactVerificationEntry(artifact) {
             absolutePath: artifact.absolutePath,
             exists: artifact.exists,
             kind: artifact.kind,
-            limitation: "Recording output is pending until record stop completes.",
+            limitation: "Recording output is pending until native finalization succeeds and the file is verified.",
+            recording: artifact.recording,
+            recordingStartedAtMs: artifact.recordingStartedAtMs,
             mediaType: artifact.mediaType,
             path: artifact.path,
             recordingState: artifact.recordingState ?? "openRecording",
@@ -292,7 +311,7 @@ function getArtifactVerificationEntry(artifact) {
             willExistOnStop: artifact.willExistOnStop ?? true,
         };
     }
-    const state = artifact.status === "stale"
+    const state = ["failed", "stale", "unverified"].includes(artifact.status ?? "")
         ? "unverified"
         : artifact.exists === true
             ? "verified"
@@ -303,13 +322,17 @@ function getArtifactVerificationEntry(artifact) {
         absolutePath: artifact.absolutePath,
         exists: artifact.exists,
         kind: artifact.kind,
-        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,
+        recording: artifact.recording,
+        recordingStartedAtMs: artifact.recordingStartedAtMs,
+        limitation: artifact.status === "failed" || artifact.status === "unverified"
+            ? "File presence does not prove successful native recording finalization or encoding. Inspect the receipt and original failure."
+            : 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,
@@ -415,6 +438,10 @@ function formatArtifactLabel(artifact) {
         case "trace":
             return "Saved trace";
         case "video":
+            if (artifact.status === "failed")
+                return artifact.subcommand === "restart-previous" ? "Previous recording failed" : "Recording failed";
+            if (artifact.status === "unverified")
+                return artifact.subcommand === "restart-previous" ? "Previous recording unverified" : "Recording unverified";
             if (artifact.command === "record" && artifact.subcommand === "restart-previous") {
                 if (artifact.status === "stale")
                     return "Previous recording stale";
@@ -423,7 +450,9 @@ function formatArtifactLabel(artifact) {
                 return "Previous recording saved";
             }
             if (!isPendingRecordingArtifact(artifact))
-                return "Saved recording";
+                return artifact.status === "saved" ? "Saved recording" : "Recording reported; file not verified";
+            if (artifact.subcommand === "stop")
+                return "Recording finalization pending";
             return artifact.subcommand === "restart" ? "Recording restarted; output will be written on stop" : "Recording started; output will be written on stop";
     }
 }
@@ -440,7 +469,7 @@ export function formatArtifactSummary(artifacts) {
     if (restartArtifact && previousRecordingArtifacts.length > 0) {
         return [...previousRecordingArtifacts, restartArtifact].map((artifact) => `${formatArtifactLabel(artifact)}: ${artifact.path}`).join("\n");
     }
-    return `Saved ${artifacts.length} artifacts: ${artifacts.map((artifact) => `${artifact.kind} ${artifact.path}`).join(", ")}`;
+    return `${artifacts.every((artifact) => artifact.status === "saved") ? "Saved" : "Reported"} ${artifacts.length} artifacts: ${artifacts.map((artifact) => `${artifact.kind} ${artifact.path}`).join(", ")}`;
 }
 export function formatArtifactMetadataLines(artifacts) {
     return artifacts.map((artifact, index) => {
@@ -450,12 +479,13 @@ export function formatArtifactMetadataLines(artifacts) {
                 `Artifact type: ${artifact.kind}`,
                 artifact.requestedPath ? `Requested path: ${artifact.requestedPath}` : undefined,
                 `Absolute path: ${artifact.absolutePath}`,
-                "Exists: pending until record stop",
+                `Exists: ${artifact.exists ?? "pending until record stop"}`,
                 `Status: ${artifact.status ?? "pending"}`,
                 `Recording state: ${artifact.recordingState ?? "openRecording"}`,
                 `Will exist on stop: ${artifact.willExistOnStop !== false}`,
                 artifact.session ? `Session: ${artifact.session}` : undefined,
                 artifact.cwd ? `CWD: ${artifact.cwd}` : undefined,
+                artifact.recording ? formatRecordingReceipt(artifact.recording) : undefined,
                 `Machine data: details.artifacts[${index}]`,
             ].filter((item) => item !== undefined).join("\n");
         }
@@ -464,7 +494,7 @@ export function formatArtifactMetadataLines(artifacts) {
             `Artifact type: ${artifact.kind}`,
             artifact.requestedPath ? `Requested path: ${artifact.requestedPath}` : undefined,
             `Absolute path: ${artifact.absolutePath}`,
-            `Exists: ${artifact.exists === true}`,
+            `Exists: ${artifact.exists ?? "unknown"}`,
             artifact.exists === false ? "not found on disk" : undefined,
             typeof artifact.sizeBytes === "number" ? `Size: ${formatByteCount(artifact.sizeBytes)}` : undefined,
             typeof artifact.sizeBytes === "number" ? `Size bytes: ${artifact.sizeBytes}` : undefined,
@@ -473,6 +503,7 @@ export function formatArtifactMetadataLines(artifacts) {
             artifact.mediaType ? `Media type: ${artifact.mediaType}` : undefined,
             artifact.session ? `Session: ${artifact.session}` : undefined,
             artifact.cwd ? `CWD: ${artifact.cwd}` : undefined,
+            artifact.recording ? formatRecordingReceipt(artifact.recording) : undefined,
             `Machine data: details.artifacts[${index}]`,
         ].filter((item) => item !== undefined).join("\n");
     });

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

@@ -1,3 +1,4 @@
+import { stat } from "node:fs/promises";
 import { isCloseCommand } from "../../command-taxonomy.js";
 import { isRecord } from "../../parsing.js";
 import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
@@ -194,7 +195,7 @@ async function buildBatchStepPresentation(options) {
     const redactedCommand = command ? redactInvocationArgs(command) : undefined;
     const commandText = formatBatchStepCommand(hasModelFacingArgRedaction(redactedCommand) ? redactedCommand : command, index);
     const lifecycle = extractAgentBrowserLifecycle(item.result);
-    if (item.success === false) {
+    if (item.success === false && command?.[0] !== "record") {
         const redactedErrorData = redactBatchStepErrorData(command, item.error);
         const errorText = formatBatchStepError(redactedErrorData);
         const failureCategory = classifyAgentBrowserFailureCategory({
@@ -252,7 +253,9 @@ async function buildBatchStepPresentation(options) {
         commandInfo: commandInfoWithTokens,
         cwd,
         args: command,
-        envelope: { data: item.result, success: true },
+        envelope: { data: item.result, success: item.success !== false, error: item.error },
+        errorText: item.success === false ? formatBatchStepError(redactBatchStepErrorData(command, item.error)) : undefined,
+        piCleanupOwnership: options.piCleanupOwnership,
         networkRouteDiagnostics,
         namespace,
         persistentArtifactStore,
@@ -320,11 +323,18 @@ async function buildBatchStepPresentation(options) {
         presentation,
     };
 }
-function abandonedRecordingArtifact(artifact) {
+async function abandonedRecordingArtifact(artifact) {
     const { recordingState: _recordingState, willExistOnStop: _willExistOnStop, ...terminal } = artifact;
-    return { ...terminal, exists: false, status: "missing", subcommand: "close-abandoned" };
+    try {
+        const file = await stat(artifact.absolutePath);
+        return { ...terminal, exists: file.isFile(), sizeBytes: file.size, status: file.isFile() ? "unverified" : "missing", subcommand: "close-abandoned" };
+    }
+    catch (error) {
+        const missing = error.code === "ENOENT";
+        return { ...terminal, exists: missing ? false : undefined, status: missing ? "missing" : "unverified", subcommand: "close-abandoned" };
+    }
 }
-function coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace) {
+async function coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace) {
     const artifacts = [];
     const pendingIndexesBySession = new Map();
     const removedPendingIndexes = new Set();
@@ -351,7 +361,7 @@ function coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace)
         for (const pendingIndex of pendingIndexesBySession.get(session) ?? []) {
             const pending = artifacts[pendingIndex];
             if (pending && !removedPendingIndexes.has(pendingIndex))
-                artifacts[pendingIndex] = abandonedRecordingArtifact(pending);
+                artifacts[pendingIndex] = await abandonedRecordingArtifact(pending);
         }
     }
     return artifacts.filter((_, index) => !removedPendingIndexes.has(index));
@@ -372,6 +382,7 @@ export async function buildBatchPresentation(options) {
             cwd,
             index,
             item,
+            piCleanupOwnership: options.piCleanupOwnership,
             namespace,
             networkRoutes: currentNetworkRoutes,
             persistentArtifactStore: persistentArtifactStore ? { ...persistentArtifactStore, protectedPaths: protectedPersistentPaths } : undefined,
@@ -387,7 +398,7 @@ export async function buildBatchPresentation(options) {
     }
     const batchFailure = getBatchFailureDetails(steps);
     const images = steps.flatMap((step) => getPresentationImages(step.presentation));
-    const artifacts = coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace);
+    const artifacts = await coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace);
     const artifactVerification = buildArtifactVerificationSummary(artifacts);
     const fullOutputPaths = steps.flatMap((step) => getPresentationPaths({
         primaryPath: step.presentation.fullOutputPath,
@@ -399,7 +410,7 @@ export async function buildBatchPresentation(options) {
     }));
     const redactedBatchData = steps.map(({ details }) => (details.success
         ? { command: details.command, result: details.data, success: true }
-        : { command: details.command, error: details.text, success: false }));
+        : { command: details.command, error: details.text, ...(details.command?.[0] === "record" ? { result: details.data } : {}), success: false }));
     const unverifiedMutationCount = steps.filter((step) => step.details.pageChangeSummary?.changeType === "mutation" && step.details.pageChangeSummary.observed === false).length;
     const mutationEvidenceText = unverifiedMutationCount > 0
         ? `Mutation evidence: ${unverifiedMutationCount} action result${unverifiedMutationCount === 1 ? " proves" : "s prove"} dispatch only, not application state change. Use explicit later assertions or external receipts as postconditions; fixed waits are not postconditions.`

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

@@ -5,29 +5,9 @@ const UNTITLED_PAGE_SUMMARY = "(untitled page)";
 export function stringifyModelFacing(value) {
     return stringifyUnknown(redactSensitiveValue(value));
 }
-export function parseJsonPreviewString(value) {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
-        return value;
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return value;
-    }
-}
 export function redactModelFacingText(text) {
-    const parsed = parseJsonPreviewString(text);
-    if (parsed !== text) {
-        return stringifyModelFacing(parsed);
-    }
     return redactSensitiveText(text);
 }
-export function redactModelFacingTextIfSensitive(text) {
-    return /(?:@|\b(?:access[_-]?key|api[_-]?key|auth|authorization|basic|bearer|connection[_-]?string|cookie|database[_-]?url|db[_-]?url|mongo(?:db)?[_-]?uri|pass(?:word)?|private[_-]?key|redis[_-]?url|secret|session[_-]?id|token)\b)/i.test(text)
-        ? redactModelFacingText(text)
-        : text;
-}
 export function getArrayField(data, key) {
     return Array.isArray(data[key]) ? data[key] : undefined;
 }