pi-agent-browser-native 0.6.8 → 0.6.10

package/dist/extensions/agent-browser/lib/orchestration/browser-run/artifact-paths.js

@@ -2,8 +2,7 @@ import { lstatSync, readlinkSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { foldAgentBrowserFilesystemIdentity } from "../../argv-grammar.js";
 import { parseWaitCommandTokens } from "../../argv-descriptor.js";
-const SCREENSHOT_BOOLEAN_FLAGS = new Set(["--annotate", "--full", "-f"]);
-const SCREENSHOT_VALUE_FLAGS = new Set(["--screenshot-dir", "--screenshot-format", "--screenshot-quality"]);
+import { getRecordCommandOperands } from "../../command-taxonomy.js";
 const SCREENSHOT_IMAGE_EXTENSIONS = [".jpeg", ".jpg", ".png", ".webp"];
 function isSingleScreenshotPathToken(token) {
     const explicitlyRelative = token.startsWith("./") || token.startsWith("../");
@@ -17,11 +16,7 @@ function getScreenshotPositionalIndices(commandTokens) {
     const positionalIndices = [];
     for (let index = 1; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
-        if (SCREENSHOT_VALUE_FLAGS.has(token)) {
-            index += 1;
-            continue;
-        }
-        if (SCREENSHOT_BOOLEAN_FLAGS.has(token))
+        if (token === "--full" || token === "-f")
             continue;
         positionalIndices.push(index);
     }
@@ -54,9 +49,6 @@ function getDiffScreenshotOutputPath(commandTokens) {
     }
     return outputPath;
 }
-function foldArtifactPath(path, platform) {
-    return foldAgentBrowserFilesystemIdentity(path, platform);
-}
 function canonicalizeArtifactPath(absolutePath, platform, seenSymlinks) {
     let cursor = absolutePath;
     const suffix = [];
@@ -71,7 +63,7 @@ function canonicalizeArtifactPath(absolutePath, platform, seenSymlinks) {
             catch {
                 // The destination does not exist yet; canonical ancestry still catches aliases.
             }
-            return foldArtifactPath(canonicalPath, platform);
+            return foldAgentBrowserFilesystemIdentity(canonicalPath, platform);
         }
         catch {
             let symlinkTarget;
@@ -90,7 +82,7 @@ function canonicalizeArtifactPath(absolutePath, platform, seenSymlinks) {
             }
             const parent = dirname(cursor);
             if (parent === cursor)
-                return foldArtifactPath(absolutePath, platform);
+                return foldAgentBrowserFilesystemIdentity(absolutePath, platform);
             suffix.unshift(basename(cursor));
             cursor = parent;
         }
@@ -120,7 +112,7 @@ export function getExplicitArtifactDestination(commandTokens) {
         return commandTokens[3];
     if ((command === "trace" || command === "profiler") && subcommand === "stop")
         return commandTokens[2];
-    if (command === "record" && (subcommand === "start" || subcommand === "restart"))
-        return commandTokens[2];
+    if (command === "record")
+        return getRecordCommandOperands(commandTokens).path;
     return undefined;
 }

package/dist/extensions/agent-browser/lib/orchestration/browser-run/diagnostics.js

@@ -7,11 +7,11 @@ import { formatSessionArtifactRetentionSummary } from "../../results/artifact-ma
 import { buildInspectOverlayStateAction, buildNextToolAction, withOptionalSessionArgs } from "../../results/next-actions.js";
 import { buildVisibleRefFallbackDiagnosticFromSnapshot, getVisibleRefFallbackTarget } from "../../results/selector-recovery.js";
 import { extractRefSnapshotFromData, isAboutBlankUrl, normalizeComparableUrl } from "../../session-page-state.js";
-import { extractUpstreamCommandTokens, parseWaitCommandTokens, redactInvocationArgs, redactSensitiveText } from "../../runtime.js";
+import { redactInvocationArgs, redactSensitiveText } from "../../runtime.js";
 import { isRecord } from "../../parsing.js";
 import { extractBatchResultCommand, extractNavigationSummaryFromData, extractStringResultField, findElectronLaunchRecordForSession, runSessionCommandData, } from "./session-state.js";
-import { parseValidBatchStepEntries } from "../batch-stdin.js";
-import { getScreenshotPathTokenIndex } from "./artifact-paths.js";
+import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
+import { getExplicitArtifactDestination } from "./artifact-paths.js";
 const ELECTRON_FILL_VERIFICATION_TIMEOUT_MS = 2_000;
 export function sleepMs(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -227,7 +227,7 @@ export async function collectRecordingDependencyWarning(options) {
         return undefined;
     if (await executableExistsOnPath("ffmpeg"))
         return undefined;
-    return { command: recordCommand, dependency: "ffmpeg", message: `${recordCommand} can begin recording, but record stop needs ffmpeg on PATH to encode the WebM output.`, reason: "ffmpeg-missing-for-recording", recommendations: ["Install ffmpeg before relying on this recording workflow; on macOS with Homebrew, brew install ffmpeg or brew install ffmpeg-full.", "If ffmpeg was just installed, restart pi or ensure the PATH visible to pi includes the ffmpeg binary before running record stop."] };
+    return { command: recordCommand, dependency: "ffmpeg", message: `${recordCommand} reported a pending recording, but ffmpeg is not on PATH. Its output is unverified; install ffmpeg before starting a new recording.`, reason: "ffmpeg-missing-for-recording", recommendations: ["Install ffmpeg before recording; on macOS with Homebrew, brew install ffmpeg or brew install ffmpeg-full.", "Stop this recording, check the result, and start a new recording after ensuring Pi can find ffmpeg on PATH."] };
 }
 export function formatRecordingDependencyWarningText(warning) {
     if (!warning)
@@ -711,12 +711,10 @@ export async function collectElectronHandoff(options) {
     }
     return { handoff: "snapshot", refSnapshot, snapshot, ...(snapshotRetryCount > 0 ? { snapshotRetryCount } : {}), tabs };
 }
-function getTimeoutProgressSteps(compiledJob, command, stdin) {
+function getTimeoutProgressSteps(compiledJob, commandTokens, stdin) {
     if (compiledJob)
         return compiledJob.steps.map((step, index) => ({ args: step.args, generatedFrom: step.generatedFrom, index: index + 1 }));
-    if (command !== "batch" || !stdin)
-        return [];
-    return parseValidBatchStepEntries(stdin).map(({ index, step }) => ({ args: step, index: index + 1 }));
+    return getUpstreamEffectiveBatchSteps(commandTokens, stdin).map((args, index) => ({ args, index: index + 1 }));
 }
 function getLastPositionalToken(args, startIndex = 1) {
     for (let index = args.length - 1; index >= startIndex; index -= 1) {
@@ -726,20 +724,8 @@ function getLastPositionalToken(args, startIndex = 1) {
     }
     return undefined;
 }
-function getTimeoutStepArtifactPath(args) {
-    const commandArgs = extractUpstreamCommandTokens(args);
-    const [command] = commandArgs;
-    if (command === "screenshot") {
-        const index = getScreenshotPathTokenIndex(commandArgs);
-        return index === undefined ? undefined : commandArgs[index];
-    }
-    if (command === "pdf")
-        return getLastPositionalToken(commandArgs);
-    if (command === "download")
-        return getLastPositionalToken(commandArgs, 2);
-    if (command === "wait")
-        return parseWaitCommandTokens(commandArgs).downloadPath;
-    return undefined;
+function getTimeoutStepArtifactPath(commandTokens) {
+    return ["screenshot", "pdf", "download", "wait"].includes(commandTokens[0]) ? getExplicitArtifactDestination(commandTokens) : undefined;
 }
 async function statTimeoutArtifactPath(absolutePath) {
     for (let attempt = 0; attempt < 3; attempt += 1) {
@@ -795,7 +781,7 @@ const TIMEOUT_RETRYABLE_COMMANDS = new Set([
 ]);
 function getTimeoutStepRetry(step) {
     const command = step.args[0];
-    return command && TIMEOUT_RETRYABLE_COMMANDS.has(command) ? { args: step.args } : undefined;
+    return command && TIMEOUT_RETRYABLE_COMMANDS.has(command) ? { args: ["batch"], stdin: JSON.stringify([step.args]) } : undefined;
 }
 function normalizeUrlForTimeoutComparison(url) {
     if (!url)
@@ -873,7 +859,7 @@ function buildTimeoutProgressSteps(options) {
     };
 }
 export async function collectTimeoutPartialProgress(options) {
-    const rawSteps = getTimeoutProgressSteps(options.compiledJob, options.command, options.stdin);
+    const rawSteps = getTimeoutProgressSteps(options.compiledJob, options.commandTokens, options.stdin);
     const artifacts = await collectTimeoutArtifactEvidence(options.cwd, rawSteps);
     const urlData = await runSessionCommandData({ args: ["get", "url"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName });
     const recoveredUrl = extractStringResultField(urlData, "result") ?? extractStringResultField(urlData, "url");
@@ -930,7 +916,7 @@ export function formatTimeoutPartialProgressText(progress, pageTargetUnknown = f
             lines.push(`- ... ${progress.steps.length - shownSteps.length} more step${progress.steps.length - shownSteps.length === 1 ? "" : "s"} omitted`);
     }
     if (progress.retryStep?.retry?.args) {
-        const payload = JSON.stringify({ args: redactInvocationArgs(progress.retryStep.retry.args) });
+        const payload = JSON.stringify({ ...progress.retryStep.retry, stdin: JSON.stringify([redactInvocationArgs(progress.retryStep.args)]) });
         lines.push(pageTargetUnknown
             ? `Retry candidate for step ${progress.retryStep.index}: ${payload}. Verify the current URL before running it.`
             : `Retry failed step: ${payload}`);

package/dist/extensions/agent-browser/lib/orchestration/browser-run/final-result.js

@@ -205,7 +205,7 @@ export async function prepareFinalResultRecoveryState(options) {
     return { categoryDetails, currentRefSnapshot, currentRefSnapshotInvalidation, noActivePageSnapshotFailure, richInputRecoveryDiagnostic, visibleRefFallbackDiagnostic, visibleRefFallbackSessionName };
 }
 function buildTimeoutPartialProgressNextActions(options) {
-    const retryArgs = options.timeoutPartialProgress?.retryStep?.retry?.args;
+    const retry = options.timeoutPartialProgress?.retryStep?.retry;
     const stepIndex = options.timeoutPartialProgress?.retryStep?.index;
     const freshSessionAbandoned = options.sessionMode === "fresh" && options.timeoutPartialProgress?.liveUrlRecovered !== true;
     if (options.currentSessionTabTargetUnknown && !freshSessionAbandoned && options.executionPlan.sessionName) {
@@ -220,12 +220,12 @@ function buildTimeoutPartialProgressNextActions(options) {
                 tool: "agent_browser",
             }];
     }
-    if (retryArgs) {
+    if (retry) {
         return [{
                 id: "retry-timeout-step",
                 params: freshSessionAbandoned
-                    ? { args: retryArgs, sessionMode: "fresh" }
-                    : { args: withOptionalSessionArgs(options.executionPlan.sessionName, retryArgs) },
+                    ? { ...retry, sessionMode: "fresh" }
+                    : { ...retry, args: withOptionalSessionArgs(options.executionPlan.sessionName, retry.args) },
                 reason: freshSessionAbandoned
                     ? `Retry the first incomplete timed-out step${stepIndex === undefined ? "" : ` ${stepIndex}`} in a fresh browser session because the timed-out fresh session was not proven live.`
                     : `Retry the first incomplete timed-out step${stepIndex === undefined ? "" : ` ${stepIndex}`} against the current browser session.`,

package/dist/extensions/agent-browser/lib/orchestration/browser-run/managed-session-daemon-policy.js

@@ -1,12 +1,15 @@
 import { rm } from "node:fs/promises";
+import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
+import { inspectElectronLaunchStatus } from "../../electron/cleanup.js";
 import { acquireManagedSessionPolicyLock } from "../../managed-session-policy-lock.js";
-import { pruneOwnedManagedSessionRestoreSnapshots, resolveExplicitAutosaveInterval, } from "../../managed-session-restore.js";
+import { pruneOwnedManagedSessionRestoreSnapshots, resolveExplicitAutosaveInterval, withOwnedManagedSessionContext, } from "../../managed-session-restore.js";
 import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
 import { isRecord } from "../../parsing.js";
 import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
-import { runAgentBrowserProcess } from "../../process.js";
+import { runAgentBrowserProcess, withAttachedBrowserSessionContext } from "../../process.js";
 import { getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { redactInvocationArgs } from "../../runtime.js";
+import { runSessionCommandData } from "./session-state.js";
 const MANAGED_SESSION_DAEMON_INSPECTION_TIMEOUT_MS = 35_000;
 const RUNNING_HEADED_AUTOSAVE_POLICY_CHANGE_ERROR = "AGENT_BROWSER_AUTOSAVE_INTERVAL_MS cannot change a running wrapper-owned headed session's launch-time periodic autosave interval. Close that session first, then retry with sessionMode: \"fresh\" so the new daemon starts with the requested interval.";
 export function getRunningHeadedAutosavePolicyChangeError(recordedInterval, closeCommand = false) {
@@ -49,6 +52,23 @@ export async function inspectManagedSessionDaemon(options) {
             await rm(processResult.stdoutSpillPath, { force: true }).catch(() => undefined);
     }
 }
+async function verifyRestoredElectronAttachment(context, record, signal, timeoutMs) {
+    const cwd = context.cwd;
+    if (!cwd || !record?.webSocketDebuggerUrl || !record.sessionName || record.cleanupState === "cleaned"
+        || getAgentBrowserSessionIdentityKey(record.sessionName, record.namespace) !== getAgentBrowserSessionIdentityKey(context.sessionName, context.namespace))
+        return false;
+    const status = await inspectElectronLaunchStatus(record, signal);
+    if (signal?.aborted || status.pidAlive !== true || status.userDataDirState !== "present"
+        || status.version?.webSocketDebuggerUrl !== record.webSocketDebuggerUrl)
+        return false;
+    // This metadata probe must not grant daemon provenance just by spawning.
+    const connection = await withAttachedBrowserSessionContext(true, () => withOwnedManagedSessionContext(undefined, () => runSessionCommandData({
+        args: ["get", "cdp-url"], cwd, env: getHeadedManagedAutosaveEnv(context.headedManagedAutosaveInterval), namespace: context.namespace, pinNamespace: true,
+        sessionName: context.sessionName, signal, timeoutMs,
+    })));
+    return !signal?.aborted && isRecord(connection) && typeof connection.cdpUrl === "string"
+        && (connection.cdpUrl === record.webSocketDebuggerUrl || status.targets.some((target) => target.webSocketDebuggerUrl === connection.cdpUrl));
+}
 export async function acquireOwnedManagedSessionDaemonPolicy(options) {
     const { context, signal } = options;
     if (!context.cwd)
@@ -81,7 +101,7 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
             return { daemonStatus: daemon.status, lock };
         }
         const stickyDisabled = context.restoreState.isDisabled(context.sessionName, context.namespace);
-        const hasKnownDaemonRestoreKey = context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace);
+        let hasKnownDaemonRestoreKey = context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace);
         const knownDaemonRestoreKey = context.restoreState.getDaemonRestoreKey(context.sessionName, context.namespace);
         const requestedDaemonRestoreKey = context.restoreDecision === "enabled" && stickyDisabled
             ? knownDaemonRestoreKey ?? null
@@ -93,6 +113,9 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
             };
         }
         const restoreDisabledPolicyNeedsProvenance = stickyDisabled || context.restoreDecision !== "enabled";
+        if (daemon.status === "active" && restoreDisabledPolicyNeedsProvenance && !hasKnownDaemonRestoreKey && daemon.restoreKey === requestedDaemonRestoreKey) {
+            hasKnownDaemonRestoreKey = await verifyRestoredElectronAttachment(context, options.electronLaunchRecord, signal, options.electronVerificationTimeoutMs);
+        }
         const activePolicyMatches = daemon.status === "active"
             && (!restoreDisabledPolicyNeedsProvenance || hasKnownDaemonRestoreKey)
             && daemon.restoreKey === requestedDaemonRestoreKey;

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare.js

@@ -22,7 +22,7 @@ import { buildOwnedManagedSessionRestoreContext, resolveExplicitAutosaveInterval
 import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
 import { getExplicitSessionPageVerificationRequirement, getPageTargetValidationError, } from "../../page-target-validation.js";
 import { acquireOwnedManagedSessionDaemonPolicy, getRunningHeadedAutosavePolicyChangeError } from "./managed-session-daemon-policy.js";
-import { buildManagedSessionOutcome, buildSessionDetailFields, buildStaleRefPreflight, getSessionContextKey, extractStringResultField, ensureSessionTabTarget, getGuardedRefUsage, getTraceOwnerGuardMessage, runSessionCommandData, shouldPinSessionTabForCommand, } from "./session-state.js";
+import { buildManagedSessionOutcome, buildSessionDetailFields, buildStaleRefPreflight, getSessionContextKey, findElectronLaunchRecordForSession, extractStringResultField, ensureSessionTabTarget, getGuardedRefUsage, getTraceOwnerGuardMessage, runSessionCommandData, shouldPinSessionTabForCommand, } from "./session-state.js";
 import { getUpstreamEffectiveBatchSteps, parseBatchStdinJsonArray } from "../batch-stdin.js";
 import { buildElectronHostFailureResult, formatAgentBrowserNextActionsText, getElectronLaunchFailureCategory, redactRecoveryHint } from "./final-result.js";
 import { prepareClickDispatchProbe } from "./click-dispatch.js";
@@ -73,21 +73,19 @@ async function ensureArtifactParentDirectory(commandTokens, cwd) {
         return;
     await mkdir(dirname(resolve(cwd, requestedPath)), { recursive: true });
 }
-async function normalizeScreenshotPathInTokens(commandTokens, cwd) {
-    const scopedCommandTokens = extractCommandTokens(commandTokens);
-    const projection = projectUpstreamGlobalFlags(scopedCommandTokens);
-    const projectedPathTokenIndex = getScreenshotPathTokenIndex(projection.tokens);
-    const scopedPathTokenIndex = projectedPathTokenIndex === undefined ? undefined : projection.indices[projectedPathTokenIndex];
-    if (scopedPathTokenIndex === undefined) {
+async function normalizeScreenshotPathInTokens(commandTokens, cwd, batchStep = false) {
+    // Native batch rows skip outer CLI global-flag cleanup.
+    const projection = batchStep ? undefined : projectUpstreamGlobalFlags(commandTokens);
+    const pathIndex = getScreenshotPathTokenIndex(projection?.tokens ?? commandTokens);
+    const screenshotPathTokenIndex = pathIndex === undefined ? undefined : projection ? projection.indices[pathIndex] : pathIndex;
+    if (screenshotPathTokenIndex === undefined)
         return { tokens: commandTokens };
-    }
-    const screenshotPathTokenIndex = commandTokens.length - scopedCommandTokens.length + scopedPathTokenIndex;
     const requestedPath = commandTokens[screenshotPathTokenIndex];
     const absolutePath = resolve(cwd, requestedPath);
     await mkdir(dirname(absolutePath), { recursive: true });
     const tokens = [...commandTokens];
     tokens[screenshotPathTokenIndex] = absolutePath;
-    const terminatorIndex = tokens.indexOf("--");
+    const terminatorIndex = batchStep ? -1 : tokens.indexOf("--");
     if (terminatorIndex >= 0) {
         tokens.splice(terminatorIndex, 1);
     }
@@ -110,13 +108,12 @@ async function prepareBatchScreenshotPaths(args, stdin, cwd) {
         // prepare parent directories for the rows that will run and skip stdin
         // preparation (no directories for never-executed rows).
         for (const step of argumentSteps) {
-            const stepTokens = extractUpstreamCommandTokens(step);
-            await ensureArtifactParentDirectory(stepTokens, cwd);
-            if (stepTokens[0] === "screenshot") {
+            await ensureArtifactParentDirectory(step, cwd);
+            if (step[0] === "screenshot") {
                 // Reuse the screenshot path resolution for its parent-directory side
                 // effect only: raw strings are never rewritten, so the normalized
                 // tokens and path request are deliberately discarded.
-                await normalizeScreenshotPathInTokens(step, cwd);
+                await normalizeScreenshotPathInTokens(step, cwd, true);
             }
         }
         return undefined;
@@ -134,12 +131,11 @@ async function prepareBatchScreenshotPaths(args, stdin, cwd) {
         if (!Array.isArray(step) || !step.every((item) => typeof item === "string")) {
             return step;
         }
-        const upstreamStep = extractUpstreamCommandTokens(step);
-        await ensureArtifactParentDirectory(upstreamStep, cwd);
-        if (upstreamStep[0] !== "screenshot") {
+        await ensureArtifactParentDirectory(step, cwd);
+        if (step[0] !== "screenshot") {
             return step;
         }
-        const normalized = await normalizeScreenshotPathInTokens(step, cwd);
+        const normalized = await normalizeScreenshotPathInTokens(step, cwd, true);
         batchScreenshotPathRequests[index] = normalized.request;
         if (normalized.request) {
             changed = true;
@@ -508,6 +504,8 @@ export async function prepareBrowserRun(options) {
             const closeCommand = isCloseCommand(executionPlan.commandInfo.command);
             const policy = await acquireOwnedManagedSessionDaemonPolicy({
                 context: ownedManagedSession,
+                electronLaunchRecord: findElectronLaunchRecordForSession(executionPlan.sessionName, state.electronLaunchRecords, executionPlan.namespace),
+                electronVerificationTimeoutMs: params.timeoutMs,
                 mode: closeCommand ? "close" : "reuse",
                 signal,
             });

package/dist/extensions/agent-browser/lib/orchestration/browser-run/process-output.js

@@ -1,7 +1,7 @@
 import { rm } from "node:fs/promises";
 import { parseArgvDescriptor } from "../../argv-descriptor.js";
 import { needsManagedSession } from "../../command-policy.js";
-import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace } from "../../argv-grammar.js";
+import { deleteIdentityKeysInNamespace, getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace } from "../../argv-grammar.js";
 import { batchHasSuccessfulCloseAll, getSuccessfulBatchCloseLifecycle } from "../../batch-lifecycle.js";
 import { isCloseAllCommand, isCloseCommand, isOpenNavigationCommand, isRecordPageTransitionCommand, isUnverifiedPageTransitionCommand, isWindowOrDiffPageTransitionCommand } from "../../command-taxonomy.js";
 import { OPEN_RESULT_TAB_CORRECTION_FLAGS } from "../../launch-scoped-flags.js";
@@ -108,12 +108,6 @@ function batchStartedManagedBrowser(data) {
 function withoutNamespaceEntries(entries, namespace) {
     return new Map([...entries].filter(([key]) => !isAgentBrowserSessionIdentityKeyInNamespace(key, namespace)));
 }
-function deleteNamespaceEntries(entries, namespace) {
-    for (const key of entries.keys()) {
-        if (isAgentBrowserSessionIdentityKeyInNamespace(key, namespace))
-            entries.delete(key);
-    }
-}
 function setNetworkRouteState(options) {
     if (!options.sessionName)
         return options.routesBySession;
@@ -223,8 +217,8 @@ export async function processBrowserOutput(input) {
         }
         if (closeAllApplied) {
             networkRoutesBySession = withoutNamespaceEntries(networkRoutesBySession, prepared.executionPlan.namespace);
-            deleteNamespaceEntries(state.attachedSessionKeys, prepared.executionPlan.namespace);
-            deleteNamespaceEntries(traceOwners, prepared.executionPlan.namespace);
+            deleteIdentityKeysInNamespace(state.attachedSessionKeys, prepared.executionPlan.namespace);
+            deleteIdentityKeysInNamespace(traceOwners, prepared.executionPlan.namespace);
             sessionPageState.clearNamespace(prepared.executionPlan.namespace);
             const retainedSessionKey = nestedBatchRemainsActive ? sessionStateKey : undefined;
             for (const [key, owner] of state.ownedManagedSessions) {
@@ -370,7 +364,7 @@ export async function processBrowserOutput(input) {
         let fillVerificationDiagnostic;
         let selectorTextVisibilityDiagnostics = [];
         let electronBroadGetTextScopeDiagnostics = [];
-        const timeoutPartialProgress = processResult.timedOut ? await collectTimeoutPartialProgress({ command: prepared.executionPlan.commandInfo.command, compiledJob: prepared.compiledJob, cwd, namespace: prepared.executionPlan.namespace, sessionName: prepared.executionPlan.sessionName, stdin: prepared.runtimeToolStdin }) : undefined;
+        const timeoutPartialProgress = processResult.timedOut ? await collectTimeoutPartialProgress({ commandTokens: prepared.commandTokens, compiledJob: prepared.compiledJob, cwd, namespace: prepared.executionPlan.namespace, sessionName: prepared.executionPlan.sessionName, stdin: prepared.runtimeToolStdin }) : undefined;
         if (!currentSessionTabTarget && timeoutPartialProgress?.currentPage?.source === "live") {
             currentSessionTabTarget = normalizeSessionTabTarget(timeoutPartialProgress.currentPage);
         }
@@ -763,7 +757,7 @@ export async function processBrowserOutput(input) {
             ? presentation.batchSteps?.some((step) => isRecordPageTransitionCommand(extractUpstreamCommandTokens(step.command ?? [])))
             : isRecordPageTransitionCommand(prepared.commandTokens);
         const recordingPageWarning = processResult.agentBrowserStarted && !prepared.executionPlan.plainTextInspection && recordingTransitionReached
-            ? "Page state: this recording command can replace or navigate the active page, even on failure; prior in-page DOM and JavaScript state may not carry over. Take a fresh snapshot before continuing with page-scoped refs."
+            ? "Page state: this wrapper conservatively invalidates earlier refs after recording starts and URL-bearing restarts. Take a fresh snapshot before continuing; this does not prove the page changed."
             : undefined;
         const sessionWarning = electronPostCommandHealth ? formatElectronPostCommandHealthText(electronPostCommandHealth) : electronSessionMismatch ? formatElectronSessionMismatchText(electronSessionMismatch) : aboutBlankSessionMismatch ? buildAboutBlankWarning(aboutBlankSessionMismatch) : undefined;
         const warningText = [sessionWarning, recordingPageWarning].filter(Boolean).join("\n\n") || undefined;

package/dist/extensions/agent-browser/lib/orchestration/browser-run/session-state.js

@@ -7,7 +7,7 @@ import { buildAgentBrowserNextActions } from "../../results/action-recommendatio
 import { parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { buildNextToolAction, withOptionalNamespaceArgs, withOptionalSessionArgs } from "../../results/next-actions.js";
 import { getSessionPageStateKey, isAboutBlankUrl, normalizeComparableUrl, targetsMatch, } from "../../session-page-state.js";
-import { isCloseCommand, isElectronPostCommandHealthCommand, isNavigationObservableCommandName, isOpenNavigationCommand, isRefGuardedCommand, isRefInvalidatingBatchCommand, isRecordPageTransitionCommand, isSessionTabPinningExcludedCommand, isSessionTabPostCommandCorrectionExcludedCommand, isWindowOrDiffPageTransitionCommand, } from "../../command-taxonomy.js";
+import { getRecordCommandOperands, isCloseCommand, isElectronPostCommandHealthCommand, isNavigationObservableCommandName, isOpenNavigationCommand, isRefGuardedCommand, isRefInvalidatingBatchCommand, isSessionTabPinningExcludedCommand, isSessionTabPostCommandCorrectionExcludedCommand, isWindowOrDiffPageTransitionCommand, } from "../../command-taxonomy.js";
 import { chooseOpenResultTabCorrection } from "../../runtime.js";
 import { isRecord, parseRefId } from "../../parsing.js";
 import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
@@ -424,7 +424,7 @@ export function commandChoosesSessionTabTarget(args) {
         || isWindowOrDiffPageTransitionCommand(command, subcommand)
         || (command === "a11y" && findFirstPositionalArgument(tokens) !== undefined)
         || (["vitals", "web-vitals"].includes(command) && tokens.slice(1).some((token) => !token.startsWith("--")))
-        || (isRecordPageTransitionCommand(tokens) && tokens[3] !== undefined);
+        || getRecordCommandOperands(tokens).url !== undefined;
 }
 export function shouldPinSessionTabForCommand(options) {
     if (!options.pinningRequired || !options.sessionName || !options.command)
@@ -483,12 +483,13 @@ function selectAnySessionTargetTab(options) {
     return selection ? { ...selection, ...(targetTitle ? { targetTitle } : {}), targetUrl } : undefined;
 }
 export async function runSessionCommandData(options) {
-    const { args, cwd, namespace, pinNamespace, sessionName, signal, stdin, throwOnFailure, timeoutMs } = options;
+    const { args, cwd, env, namespace, pinNamespace, sessionName, signal, stdin, throwOnFailure, timeoutMs } = options;
     if (!sessionName)
         return undefined;
     const processResult = await runAgentBrowserProcess({
         args: ["--json", ...(namespace !== undefined || pinNamespace ? ["--namespace", namespace ?? ""] : []), "--session", sessionName, ...args],
         cwd,
+        env,
         signal,
         stdin,
         timeoutMs,

package/dist/extensions/agent-browser/lib/orchestration/electron-host/index.js

@@ -414,7 +414,7 @@ async function withOwnedElectronManagedSessionPolicy(options, run) {
         throw new ElectronManagedSessionPolicyError("Electron helper could not establish wrapper ownership for its managed session.");
     let policy;
     try {
-        policy = await acquireOwnedManagedSessionDaemonPolicy({ context, signal: options.signal });
+        policy = await acquireOwnedManagedSessionDaemonPolicy({ context, electronLaunchRecord: options.electronLaunchRecord, electronVerificationTimeoutMs: options.timeoutMs, signal: options.signal });
     }
     catch (error) {
         throw new ElectronManagedSessionPolicyError(error instanceof Error ? error.message : String(error), { cause: error });
@@ -675,6 +675,7 @@ async function handleElectronHostInputInContext(options) {
             const sessionKey = getSessionPageStateKey(record.sessionName, record.namespace) ?? record.sessionName;
             return collectOwnedElectronManagedSessionTarget({
                 cwd,
+                electronLaunchRecord: record,
                 headedManagedAutosaveDisabled: ownedManagedSessions.get(sessionKey)?.headedManagedAutosaveDisabled,
                 headedManagedAutosaveInterval: ownedManagedSessions.get(sessionKey)?.headedManagedAutosaveInterval,
                 namespace: record.namespace,
@@ -750,12 +751,14 @@ async function handleElectronHostInputInContext(options) {
             const probe = await withOwnedElectronManagedSessionPolicy({
                 args: ["snapshot", "-i"],
                 cwd,
+                electronLaunchRecord: launchRecord,
                 headedManagedAutosaveDisabled,
                 headedManagedAutosaveInterval,
                 namespace: probeNamespace,
                 restoreState: managedSessionRestoreState,
                 sessionName: probeSessionName,
                 signal,
+                timeoutMs: compiledElectron.timeoutMs,
             }, async () => await collectElectronProbe({ cwd, namespace: probeNamespace, sessionName: probeSessionName, signal, timeoutMs: compiledElectron.timeoutMs }));
             const managedSession = {
                 sessionName: probe.sessionName,

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

@@ -15,7 +15,7 @@ export const QUICK_START_GUIDELINES = [
     `Common advanced calls: { args: ["batch", "--bail"], stdin: "[[\"open\",\"https://example.com\"],[\"snapshot\",\"-i\"]]" }, { job: { steps: [{ action: "open", url: "https://example.com" }, { action: "assertText", text: "Example Domain" }, { action: "screenshot", path: ".dogfood/example.png" }] } }, { qa: { url: "https://example.com", expectedText: "Example Domain", screenshotPath: ".dogfood/qa-example.png" } } (example.com smoke only; elsewhere match exact visible text from snapshot -i), { electron: { action: "list", query: "code" } }, { electron: { action: "launch", appName: "Visual Studio Code", handoff: "snapshot" } }, { electron: { action: "probe" } }, { qa: { attached: true, expectedText: "Explorer" } }, { args: ["eval", "--stdin"], stdin: "document.title", outputPath: "logs/page-title.json" }, { args: ["auth", "save", "name", "--password-stdin"], stdin: "<password from user-approved secret source>" }, { args: ["--profile", "Default", "open", "https://example.com/account"], sessionMode: "fresh" }, and { args: ["open", "--enable", "react-devtools", "https://example.com"], sessionMode: "fresh" }. For app pages with a native dropdown, job steps can include { action: "select", selector: "#flavor", value: "chocolate" } before the dependent assertion; for locator-friendly pages, job click/fill steps can use semantic locator fields such as { action: "fill", locator: "role", role: "searchbox", name: "Search", text: "agent browser" }; for human-paced input, job type steps can use { action: "type", selector: "#prompt", text: "hello", delayMs: 20, press: "Enter" }; delayed typing is capped at 200 characters per step, and generated per-character rows are compacted in visible batch prose while full rows remain in details.batchSteps.`,
     "Constrained job navigation is explicit only: click (and select/submit flows that may navigate) does not prove the next page loaded; add an assertUrl that does not already match the starting page and/or assertText for new page state after navigation-prone steps before screenshot or later interactions. assertText takes only text, not selector or locator fields. Clicks can stale subsequent @refs: split the job and re-snapshot before using those refs. Keep jobs short around navigation, click, and rerender boundaries on dynamic React/product apps; avoid a whole checkout in one job. If a long job times out and details.timeoutPartialProgress shows a mutating incomplete step, inspect current page state and continue with a shorter job or single action instead of blindly retrying the mutating step. Example: { job: { steps: [{ action: \"open\", url: \"https://shop.example/checkout\" }, { action: \"fill\", selector: \"#email\", text: \"user@example.com\" }, { action: \"click\", selector: \"#continue\" }, { action: \"assertUrl\", url: \"**/shipping\" }, { action: \"assertText\", text: \"Shipping address\" }, { action: \"screenshot\", path: \".dogfood/shipping.png\" }] } }. Top-level click may add pageChangeSummary hints, but job never auto-inserts post-click asserts.",
     "High-value command reference: click <selector> --new-tab opens link-like targets in a new tab; select <selector> <value...> changes native dropdown values; wrapper-handled scroll <dir> [px|percent] and scroll to end/top target document scrolling before upstream fallback, while scroll <selector> <dir> [px|percent] targets nested scrollers; download <selector> <path> saves a file triggered by a click; read [url] returns agent-readable text (explicit URLs prefer markdown without requiring a Chrome page; omit the URL for rendered active-tab DOM); get title/url need no selector; get text/html/value/count <selector> and get attr <selector> <name> read elements/page state (use body for whole-page text/html); screenshot [selector] [path] captures a page or element image; pdf <path> saves a PDF; tab list and tab <tab-id-or-label> inspect or recover the active tab; react tree, react inspect <fiberId>, react renders start/stop, and react suspense introspect React after --enable react-devtools; vitals [url] measures Core Web Vitals; pushstate <url> performs SPA navigation; tap <selector> and swipe <direction> [distance] support iOS/provider touch flows.",
-    "For artifact-producing commands, read the visible artifact block and details.artifactVerification before using files: check requested path, absolute path, existence, size bytes, artifact kind, optional mediaType, status, optional limitation, and verified/missing/pending/unverified counts. details.artifacts contains per-file metadata; record start rows are pending/openRecording until record stop writes the target. Upstream record start uses a fresh active page for video capture, so prior in-page DOM and JavaScript state does not carry over; the wrapper blocks prior @e… refs as stale-ref even when the start fails as already-active, and record restart with a URL navigates and invalidates the same way (plain record restart keeps the page), so take a fresh snapshot before continuing. The wrapper creates parent directories for direct artifact paths and can save simple loopback HTTP(S) anchor downloads directly to the requested path before upstream download fallback. Browser close does not delete explicit saved files; if close reports details.artifactCleanup, use host file tools to remove paths listed in explicitArtifactPaths (when non-empty) after inspection. If close fails with details.promptGuard.reason=requested-artifacts-missing-before-close, save the exact required artifact path before closing. A bare inbound image/video path is not a requested output artifact and does not block close. For annotated screenshots inside batch, put --annotate in top-level args (for example { args: [\"--annotate\", \"batch\"], stdin: \"[[\\\"screenshot\\\",\\\"/tmp/page.png\\\"]]\" }) rather than inside the screenshot step; if annotation labels crowd a dense page, use a scoped or non-annotated screenshot plus snapshot refs instead.",
+    "For artifact-producing commands, read the visible artifact block and details.artifactVerification before using files: check requested path, absolute path, existence, size bytes, artifact kind, optional mediaType, status, optional limitation, and verified/missing/pending/unverified counts. details.artifacts contains per-file metadata; record start rows are pending/openRecording until record stop writes the target. Current upstream records the active page unless a URL is supplied. To support older natives, the wrapper conservatively blocks prior @e… refs after every dispatched start attempt and URL-bearing restart, even on failure; this does not prove the page changed. Take a fresh snapshot before continuing. A restart with only --fps keeps the page and refs; --fps <n> selects 1–60 fps (default 30). The wrapper creates parent directories for direct artifact paths and can save simple loopback HTTP(S) anchor downloads directly to the requested path before upstream download fallback. Browser close does not delete explicit saved files; if close reports details.artifactCleanup, use host file tools to remove paths listed in explicitArtifactPaths (when non-empty) after inspection. If close fails with details.promptGuard.reason=requested-artifacts-missing-before-close, save the exact required artifact path before closing. A bare inbound image/video path is not a requested output artifact and does not block close. For annotated screenshots inside batch, put --annotate in top-level args (for example { args: [\"--annotate\", \"batch\"], stdin: \"[[\\\"screenshot\\\",\\\"/tmp/page.png\\\"]]\" }) rather than inside the screenshot step; if annotation labels crowd a dense page, use a scoped or non-annotated screenshot plus snapshot refs instead.",
     "When failure output shows Next actions, prefer those exact native agent_browser follow-up payloads over guessed commands. The same actions are available in details.nextActions to callers that expose structured details; short stdin is shown inline, while long stdin stays details-only.",
 ];
 export const WEB_SEARCH_PROMPT_GUIDELINE = "Prefer agent_browser_web_search for current or external web facts and URL discovery over public search-engine forms that can hit anti-bot/CAPTCHA-gated pages. For research before implementation, pass searchType: deep-lite unless webSearch.defaultSearchType already does; omit it for everyday lookups so config/auto wins. Provider rank is not proof of authority: when correctness or version matters, prefer the vendor or project's primary current docs, inspect page-date and version clues, and constrain one follow-up after discovering the official domain (Exa includeDomains; Brave site: in query). Do not count URL aliases as independent sources. Use agent_browser after you have a target URL that needs interaction, screenshots, or DOM inspection.";
@@ -35,7 +35,7 @@ export const SHARED_BROWSER_PLAYBOOK_GUIDELINES = [
     "After a successful `connect`, `--cdp`, or enabled `--auto-connect` call, verify with get url and keep using the resulting session without repeating the attach flag. The wrapper remembers that attachment across active-branch reload/resume and live-checks the URL before later page reads/interactions because an attached browser can drift externally; caller config, file access, launch arguments, and environment pass through unchanged. A successful close clears the marker. When several named sessions share one Chrome, pass --pin-tab once (AGENT_BROWSER_PIN_TAB) so a closed bound tab fails as tab_gone instead of acting on a neighbor; recover with tab new or tab list. --no-pin-tab turns the sticky pin off. tab list includes each tab's CDP targetId, accepted as a tab ref.",
     `If you already used the implicit session and now need launch-scoped flags (${LAUNCH_SCOPED_FLAG_LABEL}), retry with top-level sessionMode set to fresh or pass an explicit --session for the new launch; never pass --session-mode inside args. After a successful unnamed fresh launch, later auto calls follow that new session.`,
     "For WebGPU pages, use args [\"--webgpu\", \"open\", \"<url>\"] on a fresh local browser launch; use doctor --webgpu (or --headed on Linux/Windows capture paths) to prove rendering before trusting a non-black screenshot. WebGPU cannot be combined with --cdp, --auto-connect, or provider launches unless --webgpu false overrides an enabled config/environment default.",
-    "For experimental WebMCP page tools, use webmcp list, then webmcp invoke <tool> with --params and optional --frame/--detach/--timeout; use webmcp result or cancel for detached calls. Locally managed Chrome enables WebMCP by default. --no-webmcp is launch-scoped and requires a fresh session; invoke/result/cancel can mutate or navigate, so refresh snapshot refs afterward.",
+    "For experimental WebMCP page tools, use webmcp list, then webmcp invoke <tool> with --params and optional --frame/--detach/--timeout; use webmcp result or cancel for detached calls. Locally managed Chrome enables WebMCP by default; a positive navigation hint means the page has tools to list. --no-webmcp is launch-scoped and requires a fresh session; invoke/result/cancel can mutate or navigate, so refresh snapshot refs afterward.",
     "For --allowed-domains, use a fresh local Chrome context. Upstream rejects CDP/auto-connect, profiles, restore/state replay, direct-page providers, iOS/Safari, and startup/profile Chrome args because they cannot guarantee containment; Chromium also disables RTCPeerConnection while the allowlist is active.",
     "For React introspection, launch the page with --enable react-devtools before first navigation, then use react tree, react inspect <fiberId>, sourceLookup candidates for local UI source hints, react renders start/stop, or react suspense; sourceLookup is experimental and reports confidence/evidence instead of guaranteed DOM-to-file mappings. For failed fetches and APIs, networkSourceLookup (experimental) correlates failed network requests with initiator metadata and bounded workspace URL literals—candidates only, not definitive blame. Use vitals [url] for Core Web Vitals and hydration timing, and pushstate <url> for client-side SPA navigation.",
     "For first-navigation setup, use open without a URL plus network route --resource-type <csv>, cookies set --curl <file>, or --init-script/--enable before navigate/opening the target page.",
@@ -57,7 +57,7 @@ export const SHARED_BROWSER_PLAYBOOK_GUIDELINES = [
     "When commands save or spill files (screenshots, downloads, PDFs, traces, recordings, HAR, large snapshot spills), use the user's exact requested paths when given and treat paths as provisional until details.artifactVerification shows every row verified: branch on missingCount, pendingCount, unverifiedCount, per-entry state, and optional limitation before downstream file use or PASS/FAIL reporting.",
     "For evidence-only screenshots, QA captures, or other audit artifacts, save to an explicit path and branch on details.artifactVerification plus details.artifacts before reporting PASS/FAIL; do not require vision review of inline image attachments unless the user asked for visual inspection.",
     "Respect explicit user stop boundaries yourself. When the surrounding authenticated employee or automation context is explicitly unattended/auto-approved, ordinary non-destructive form submissions within the requested flow may proceed without separate confirmation. Still require explicit authorization for purchases, production-control actions, destructive or irreversible actions, and account, security, or privacy changes. The wrapper does not infer broad business intent from prompt text; details.promptGuard is reserved for concrete artifact-before-close checks.",
-    "Successful record stop needs ffmpeg on PATH; the wrapper may warn after record start when ffmpeg is missing.",
+    "Recording needs ffmpeg on PATH before start. Current upstream checks it at startup; older natives may defer failure. A pending recording is not verified output.",
     "Do not call --help or other exploratory inspection commands unless the user explicitly asks for them or debugging the browser integration is necessary.",
 ];
 export const TOOL_PROMPT_GUIDELINES_SUFFIX = [
@@ -80,7 +80,7 @@ export const RUNTIME_PROMPT_GUIDELINES = [
     "Use agent_browser with one input mode: script, args, semanticAction, job, qa, sourceLookup/networkSourceLookup, or electron. stdin: batch/eval/auth/wrapper batch only; electron rejects it; never pass --json.",
     "For agent_browser, use open → snapshot -i → @refs; re-snapshot after changes. In authenticated unattended/auto-approved employee flows, ordinary requested non-destructive submissions may proceed. Honor explicit stops; require explicit authorization for purchases, production-control, destructive/irreversible, or account/security/privacy changes.",
     "Use agent_browser sessionMode=fresh for launch flags. Use requested/configured profiles only; run profiles/doctor on failure. --allowed-domains cannot restore; macOS profile copies may omit encrypted cookies. Verify auth; use a user-approved headed login if needed. Profile content is model-visible.",
-    "agent_browser: exact user paths; verify artifactVerification/artifacts before success claims. Save promptGuard-required files before close; record stop needs ffmpeg; close keeps files; waited:timeout proves nothing.",
+    "agent_browser: exact user paths; verify artifactVerification/artifacts before success claims. Save promptGuard-required files before close; ffmpeg before recording; close keeps files; waited:timeout proves nothing.",
     "When agent_browser details.nextActions exists, use them. Check Omitted high-value controls in dense snapshots. Dashboards: verify scroll via screenshot/snapshot.",
     "agent_browser: read <url> for docs/text or active DOM; get title/url; get text/html/value/count <selector>; get attr <selector> <name>. Batch 3+ getters; heed visibility warnings.",
 ];

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

@@ -3,7 +3,6 @@ import { extname, resolve } from "node:path";
 import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
 import { getExplicitArtifactDestination } from "../../orchestration/browser-run/artifact-paths.js";
 import { isRecord, parsePositiveInteger } from "../../parsing.js";
-import { extractUpstreamCommandTokens } from "../../runtime.js";
 import { formatSessionArtifactRetentionSummary, getSessionArtifactManifestEntryKey, isPendingRecordingArtifact, isPendingRecordingCommand, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
 import { classifyAgentBrowserSuccessCategory } from "../categories.js";
 const PNG_HEADER = Buffer.from("89504e470d0a1a0a0000000d49484452", "hex");
@@ -192,7 +191,7 @@ async function buildFileArtifactMetadata(options) {
         namespace: options.namespace,
         path: displayPath,
         recordingState: pendingRecording ? "openRecording" : undefined,
-        requestedPath: options.artifactRequest?.path ?? getExplicitArtifactDestination(extractUpstreamCommandTokens(options.commandInfo.commandTokens ?? [])),
+        requestedPath: options.artifactRequest?.path ?? getExplicitArtifactDestination(options.commandInfo.commandTokens ?? []),
         session: options.sessionName,
         sizeBytes,
         status: pendingRecording ? "pending" : exists === false ? "missing" : stale ? "stale" : options.artifactRequest?.status ?? "saved",
@@ -213,44 +212,33 @@ async function buildPreviousRestartRecordingArtifact(options) {
     if (!previousRecording)
         return undefined;
     const absolutePath = previousRecording.absolutePath ?? resolve(options.cwd, previousRecording.path);
+    const base = {
+        absolutePath,
+        artifactType: "video",
+        command: "record",
+        cwd: previousRecording.cwd ?? options.cwd,
+        extension: previousRecording.extension ?? (extname(absolutePath).toLowerCase() || undefined),
+        kind: "video",
+        namespace: previousRecording.namespace ?? options.namespace,
+        path: previousRecording.path,
+        requestedPath: previousRecording.requestedPath,
+        session: previousRecording.session ?? options.sessionName,
+        subcommand: "restart-previous",
+    };
     try {
         const fileStats = await stat(absolutePath);
         const stale = artifactMtimeIsOutsideCommandWindow(fileStats.mtimeMs, options.artifactMinUpdatedAtMs, options.artifactMaxUpdatedAtMs);
         return {
-            absolutePath,
-            artifactType: "video",
-            command: "record",
-            cwd: previousRecording.cwd ?? options.cwd,
+            ...base,
             exists: true,
-            extension: previousRecording.extension ?? (extname(absolutePath).toLowerCase() || undefined),
-            kind: "video",
             mediaType: fileStats.isFile() ? await getFileImageMimeType(absolutePath) : undefined,
-            namespace: previousRecording.namespace ?? options.namespace,
-            path: previousRecording.path,
-            requestedPath: previousRecording.requestedPath,
-            session: previousRecording.session ?? options.sessionName,
             sizeBytes: fileStats.size,
             status: stale ? "stale" : "saved",
-            subcommand: "restart-previous",
             updatedAtMs: fileStats.mtimeMs,
         };
     }
     catch {
-        return {
-            absolutePath,
-            artifactType: "video",
-            command: "record",
-            cwd: previousRecording.cwd ?? options.cwd,
-            exists: false,
-            extension: previousRecording.extension ?? (extname(absolutePath).toLowerCase() || undefined),
-            kind: "video",
-            namespace: previousRecording.namespace ?? options.namespace,
-            path: previousRecording.path,
-            requestedPath: previousRecording.requestedPath,
-            session: previousRecording.session ?? options.sessionName,
-            status: "missing",
-            subcommand: "restart-previous",
-        };
+        return { ...base, exists: false, status: "missing" };
     }
 }
 export async function extractFileArtifacts(options) {
@@ -436,7 +424,7 @@ function formatArtifactLabel(artifact) {
             }
             if (!isPendingRecordingArtifact(artifact))
                 return "Saved recording";
-            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";
+            return artifact.subcommand === "restart" ? "Recording restarted; output will be written on stop" : "Recording started; output will be written on stop";
     }
 }
 export function formatArtifactSummary(artifacts) {

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

@@ -64,11 +64,11 @@ export function getPageSummary(data) {
     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;
+    const summary = title && url ? `${title}\n${url}` : url || title || UNTITLED_PAGE_SUMMARY;
+    const webmcp = isRecord(data.webmcp) ? data.webmcp : undefined;
+    return webmcp?.available === true && typeof webmcp.toolCount === "number" && Number.isInteger(webmcp.toolCount) && webmcp.toolCount > 0
+        ? `${summary}\n\nWebMCP tools are available on this page (experimental). Run webmcp list to view them.`
+        : summary;
 }
 export function formatCount(count, singular, plural = `${singular}s`) {
     return `${count} ${count === 1 ? singular : plural}`;

package/dist/extensions/agent-browser/lib/session-page-state.js

@@ -212,7 +212,7 @@ export function buildNoActivePageRefSnapshotInvalidation() {
 export function buildPageTransitionRefSnapshotInvalidation(summary) {
     return {
         reason: "page-transition",
-        summary: summary ?? "A recording command (record start, or record restart with a URL) replaced or navigated the active page and invalidated the prior snapshot. Run snapshot -i before using page-scoped refs.",
+        summary: summary ?? "Recording starts and URL-bearing restarts conservatively invalidate earlier page-scoped refs. Run snapshot -i before using refs; this is not evidence of a page change.",
     };
 }
 export function getCommandRefSnapshotInvalidation(commandTokens) {