pi-agent-browser-native 0.2.77 → 0.5.0

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

@@ -1,8 +1,10 @@
 import { cleanupElectronLaunchResources } from "../../electron/cleanup.js";
-import { getCompiledSemanticActionCommandIndex, getCompiledSemanticActionSessionPrefix, isCompiledSemanticActionFindCommand, redactNetworkSourceLookupSurface, } from "../../input-modes.js";
-import { buildAgentBrowserNextActions, buildAgentBrowserResultCategoryDetails, } from "../../results.js";
+import { getCompiledSemanticActionCommandIndex, getCompiledSemanticActionSessionPrefix, isCompiledSemanticActionFindCommand } from "../../input-modes/semantic-action.js";
+import { redactNetworkSourceLookupSurface } from "../../input-modes/lookups.js";
+import { buildAgentBrowserNextActions } from "../../results/action-recommendations.js";
+import { buildAgentBrowserResultCategoryDetails } from "../../results/categories.js";
 import { formatSessionArtifactRetentionSummary } from "../../results/artifact-manifest.js";
-import { AgentBrowserNextActionCollector, alignPageChangeSummaryNextActionIds, applyNamespaceToNextActions, isStandaloneSnapshotNextAction, withOptionalSessionArgs, } from "../../results/next-actions.js";
+import { alignPageChangeSummaryNextActionIds, appendUniqueAgentBrowserNextActions, applyNamespaceToNextActions, isStandaloneSnapshotNextAction, withOptionalSessionArgs, } from "../../results/next-actions.js";
 import { buildConnectedSessionNextActions, buildNoActivePageNextActions, buildSessionAwareStaleRefNextActions, buildSessionTabRecoveryNextActions, } from "../../results/recovery-next-actions.js";
 import { buildRichInputRecoveryDiagnostic, buildRichInputRecoveryNextActions, buildVisibleRefFallbackNextActions, formatRichInputRecoveryText, formatVisibleRefFallbackText, sanitizeVisibleRefFallbackDiagnostic, } from "../../results/selector-recovery.js";
 import { buildNoActivePageRefSnapshotInvalidation, isNoActivePageSnapshotFailure, } from "../../session-page-state.js";
@@ -193,7 +195,7 @@ export async function prepareFinalResultRecoveryState(options) {
         }
     }
     const richInputRecoveryDiagnostic = buildRichInputRecoveryDiagnostic(visibleRefFallbackDiagnostic);
-    const noActivePageSnapshotFailure = categoryDetails.resultCategory === "failure" && (isNoActivePageSnapshotFailure(options.executionPlan.commandInfo.command, options.errorText ?? options.presentation.summary) || options.batchRefSnapshotState?.invalidation !== undefined);
+    const noActivePageSnapshotFailure = categoryDetails.resultCategory === "failure" && (isNoActivePageSnapshotFailure(options.executionPlan.commandInfo.command, options.errorText ?? options.presentation.summary) || options.batchRefSnapshotState?.invalidation?.reason === "no-active-page");
     const executionSessionKey = getSessionContextKey(options.executionPlan.sessionName, options.executionPlan.namespace);
     if (noActivePageSnapshotFailure && executionSessionKey) {
         const refUpdate = options.sessionPageState.applyRefSnapshotInvalidation({ invalidation: buildNoActivePageRefSnapshotInvalidation(), sessionName: executionSessionKey, update: options.sessionPageStateUpdate });
@@ -257,68 +259,87 @@ function buildDialogTimeoutNextActions(options) {
     ];
 }
 function buildResultNextActions(options) {
-    const nextActionCollector = new AgentBrowserNextActionCollector(options.presentation.nextActions);
+    let nextActions = options.presentation.nextActions ? [...options.presentation.nextActions] : [];
+    const append = (actions) => {
+        if (actions && actions.length > 0)
+            nextActions.push(...actions);
+    };
+    const appendUnique = (actions) => {
+        appendUniqueAgentBrowserNextActions(nextActions, actions);
+    };
     if (options.categoryDetails.resultCategory === "success" && options.executionPlan.commandInfo.command === "connect" && !options.electronLaunchRecord)
-        nextActionCollector.appendUnique(buildConnectedSessionNextActions(options.executionPlan.sessionName));
+        appendUnique(buildConnectedSessionNextActions(options.executionPlan.sessionName));
     if (options.noActivePageSnapshotFailure)
-        nextActionCollector.appendUnique(buildNoActivePageNextActions(options.executionPlan.sessionName));
+        appendUnique(buildNoActivePageNextActions(options.executionPlan.sessionName));
     if (options.aboutBlankSessionMismatch) {
-        nextActionCollector.appendUnique(buildSessionTabRecoveryNextActions({ kind: "about-blank", recoveryApplied: options.aboutBlankSessionMismatch.recoveryApplied, sessionName: options.executionPlan.sessionName, tabCorrection: options.aboutBlankSessionMismatch.recoveryApplied ? options.sessionTabCorrection : undefined, target: { title: options.aboutBlankSessionMismatch.targetTitle, url: options.aboutBlankSessionMismatch.targetUrl } }));
+        appendUnique(buildSessionTabRecoveryNextActions({ kind: "about-blank", recoveryApplied: options.aboutBlankSessionMismatch.recoveryApplied, sessionName: options.executionPlan.sessionName, tabCorrection: options.aboutBlankSessionMismatch.recoveryApplied ? options.sessionTabCorrection : undefined, target: { title: options.aboutBlankSessionMismatch.targetTitle, url: options.aboutBlankSessionMismatch.targetUrl } }));
         if (!options.aboutBlankSessionMismatch.recoveryApplied)
-            nextActionCollector.removeWhere(isStandaloneSnapshotNextAction);
+            nextActions = nextActions.filter((action) => !isStandaloneSnapshotNextAction(action));
     }
     else if (options.categoryDetails.resultCategory === "success" && (options.sessionTabCorrection || options.openResultTabCorrection))
-        nextActionCollector.appendUnique(buildSessionTabRecoveryNextActions({ kind: "tab-drift", recoveryApplied: true, sessionName: options.executionPlan.sessionName, tabCorrection: options.sessionTabCorrection ?? options.openResultTabCorrection, target: options.currentSessionTabTarget ?? options.priorSessionTabTarget }));
+        appendUnique(buildSessionTabRecoveryNextActions({ kind: "tab-drift", recoveryApplied: true, sessionName: options.executionPlan.sessionName, tabCorrection: options.sessionTabCorrection ?? options.openResultTabCorrection, target: options.currentSessionTabTarget ?? options.priorSessionTabTarget }));
     if (options.categoryDetails.failureCategory === "stale-ref")
-        nextActionCollector.replace(buildSessionAwareStaleRefNextActions(options.executionPlan.sessionName));
+        nextActions = [...buildSessionAwareStaleRefNextActions(options.executionPlan.sessionName)];
     if (options.visibleRefFallbackDiagnostic)
-        nextActionCollector.append(buildVisibleRefFallbackNextActions({ diagnostic: options.visibleRefFallbackDiagnostic, sessionName: options.visibleRefFallbackSessionName }));
+        append(buildVisibleRefFallbackNextActions({ diagnostic: options.visibleRefFallbackDiagnostic, sessionName: options.visibleRefFallbackSessionName }));
     if (options.richInputRecoveryDiagnostic)
-        nextActionCollector.append(buildRichInputRecoveryNextActions({ diagnostic: options.richInputRecoveryDiagnostic, sessionName: options.visibleRefFallbackSessionName }));
+        append(buildRichInputRecoveryNextActions({ diagnostic: options.richInputRecoveryDiagnostic, sessionName: options.visibleRefFallbackSessionName }));
     if (options.electronPostCommandHealth) {
         const electronRecord = options.electronLaunchRecords.get(options.electronPostCommandHealth.launchId);
         if (electronRecord)
-            nextActionCollector.appendUnique(buildElectronLifecycleNextActions(electronRecord));
+            appendUnique(buildElectronLifecycleNextActions(electronRecord));
     }
     if (options.electronSessionMismatch) {
         const electronRecord = options.electronLaunchRecords.get(options.electronSessionMismatch.launchId);
         if (electronRecord)
-            nextActionCollector.appendUnique(buildElectronMismatchNextActions(electronRecord, options.electronSessionMismatch.liveTarget));
+            appendUnique(buildElectronMismatchNextActions(electronRecord, options.electronSessionMismatch.liveTarget));
     }
     if (options.categoryDetails.failureCategory === "selector-not-found" && options.redactedCompiledSemanticAction) {
         const candidateActions = buildSemanticActionCandidateActions(options.redactedCompiledSemanticAction);
         if (candidateActions.length > 0)
-            nextActionCollector.append(candidateActions);
+            append(candidateActions);
     }
     if (options.overlayBlockerDiagnostic)
-        nextActionCollector.append(buildOverlayBlockerNextActions({ diagnostic: options.overlayBlockerDiagnostic, sessionName: options.executionPlan.sessionName }));
+        append(buildOverlayBlockerNextActions({ diagnostic: options.overlayBlockerDiagnostic, sessionName: options.executionPlan.sessionName }));
     if (options.fillVerificationDiagnostic)
-        nextActionCollector.appendUnique(buildFillVerificationNextActions(options.fillVerificationDiagnostic, options.executionPlan.sessionName));
+        appendUnique(buildFillVerificationNextActions(options.fillVerificationDiagnostic, options.executionPlan.sessionName));
     if (options.electronRefFreshnessDiagnostic)
-        nextActionCollector.appendUnique(buildElectronRefFreshnessNextActions(options.executionPlan.sessionName));
+        appendUnique(buildElectronRefFreshnessNextActions(options.executionPlan.sessionName));
     if (options.selectorTextVisibilityDiagnostics.length > 0)
-        nextActionCollector.append(buildSelectorTextVisibilityNextActions({ diagnostics: options.selectorTextVisibilityDiagnostics, sessionName: options.executionPlan.sessionName }));
+        append(buildSelectorTextVisibilityNextActions({ diagnostics: options.selectorTextVisibilityDiagnostics, sessionName: options.executionPlan.sessionName }));
     if (options.electronBroadGetTextScopeDiagnostics.length > 0)
-        nextActionCollector.append(buildElectronBroadGetTextScopeNextActions({ diagnostics: options.electronBroadGetTextScopeDiagnostics, sessionName: options.executionPlan.sessionName }));
+        append(buildElectronBroadGetTextScopeNextActions({ diagnostics: options.electronBroadGetTextScopeDiagnostics, sessionName: options.executionPlan.sessionName }));
     if (options.sourceLookup?.electronContext)
-        nextActionCollector.appendUnique(buildSourceLookupElectronNextActions(options.sourceLookup));
+        appendUnique(buildSourceLookupElectronNextActions(options.sourceLookup));
     if (options.clickDispatchDiagnostic)
-        nextActionCollector.append(buildClickDispatchNextActions({ commandTokens: options.commandTokens, diagnostic: options.clickDispatchDiagnostic, sessionName: options.executionPlan.sessionName }));
+        append(buildClickDispatchNextActions({ commandTokens: options.commandTokens, diagnostic: options.clickDispatchDiagnostic, sessionName: options.executionPlan.sessionName }));
     if (options.scrollNoopDiagnostic)
-        nextActionCollector.append(buildScrollNoopNextActions(options.executionPlan.sessionName));
+        append(buildScrollNoopNextActions(options.executionPlan.sessionName));
     if (options.comboboxFocusDiagnostic)
-        nextActionCollector.append(buildComboboxFocusNextActions(options.executionPlan.sessionName));
+        append(buildComboboxFocusNextActions(options.executionPlan.sessionName));
     if (options.managedSessionOutcome)
-        nextActionCollector.appendUnique(buildManagedSessionFreshFailureNextActions(options.managedSessionOutcome));
+        appendUnique(buildManagedSessionFreshFailureNextActions(options.managedSessionOutcome));
     if (options.categoryDetails.failureCategory === "timeout" && options.processResult.timedOut) {
-        nextActionCollector.appendUnique(buildTimeoutPartialProgressNextActions(options));
-        nextActionCollector.appendUnique(buildDialogTimeoutNextActions({ command: options.executionPlan.commandInfo.command, sessionName: options.executionPlan.sessionName }));
+        appendUnique(buildTimeoutPartialProgressNextActions(options));
+        appendUnique(buildDialogTimeoutNextActions({ command: options.executionPlan.commandInfo.command, sessionName: options.executionPlan.sessionName }));
     }
     if (options.categoryDetails.failureCategory === "stale-ref" && options.redactedCompiledSemanticAction && isCompiledSemanticActionFindCommand(options.compiledSemanticAction))
-        nextActionCollector.append([{ id: "retry-semantic-action-after-stale-ref", params: { args: options.redactedCompiledSemanticAction.args }, reason: "Retry the same semantic target via its compiled find command after the upstream stale-ref failure proves the prior action did not execute.", safety: "Use only for the same intended target; direct stale @refs still require a fresh snapshot or stable locator before retrying.", tool: "agent_browser" }]);
+        append([{ id: "retry-semantic-action-after-stale-ref", params: { args: options.redactedCompiledSemanticAction.args }, reason: "Retry the same semantic target via its compiled find command after the upstream stale-ref failure proves the prior action did not execute.", safety: "Use only for the same intended target; direct stale @refs still require a fresh snapshot or stable locator before retrying.", tool: "agent_browser" }]);
     if (options.electronLaunchRecord)
-        nextActionCollector.append(buildAgentBrowserNextActions({ electron: { launchId: options.electronLaunchRecord.launchId, sessionName: options.electronLaunchRecord.sessionName, status: options.electronLaunchRecord.cleanupState }, failureCategory: options.categoryDetails.failureCategory, resultCategory: options.categoryDetails.resultCategory, successCategory: options.categoryDetails.successCategory }));
-    return nextActionCollector.toArray();
+        append(buildAgentBrowserNextActions({ electron: { launchId: options.electronLaunchRecord.launchId, sessionName: options.electronLaunchRecord.sessionName, status: options.electronLaunchRecord.cleanupState }, failureCategory: options.categoryDetails.failureCategory, resultCategory: options.categoryDetails.resultCategory, successCategory: options.categoryDetails.successCategory }));
+    return nextActions.length > 0 ? nextActions : undefined;
+}
+function formatFailureNextActionsText(options, nextActions) {
+    if (options.categoryDetails.resultCategory !== "failure" || !nextActions || nextActions.length === 0)
+        return undefined;
+    const lines = nextActions.slice(0, 6).map((action) => {
+        const params = action.params
+            ? { ...action.params, ...(action.params.stdin === undefined ? {} : { stdin: "[omitted; use details.nextActions]" }) }
+            : undefined;
+        const payload = action.artifactPath ? { artifactPath: action.artifactPath } : params;
+        return `- ${action.id}${payload ? ` ${JSON.stringify(payload)}` : ""}: ${action.reason}`;
+    });
+    return ["Next actions:", ...lines, "Use the exact redacted payloads in details.nextActions when available."].join("\n");
 }
 function buildAgentBrowserResultDetails(options, nextActions) {
     const publicVisibleRefFallbackDiagnostic = options.visibleRefFallbackDiagnostic ? sanitizeVisibleRefFallbackDiagnostic(options.visibleRefFallbackDiagnostic) : undefined;
@@ -348,6 +369,7 @@ function buildAgentBrowserResultDetails(options, nextActions) {
         navigationSummary: options.navigationSummary,
         electron: options.electronLaunchRecord ? { action: "launch", cleanup: options.electronFailedConnectCleanup, handoff: options.electronHandoff, identifiers: buildElectronIdentifiers(options.electronLaunchRecord), launch: options.electronLaunchRecord, profileIsolation: options.electronProfileIsolationDetails, status: options.succeeded ? "succeeded" : "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined,
         ...options.categoryDetails,
+        agentBrowserStarted: options.processResult.agentBrowserStarted,
         aboutBlankSessionMismatch: options.aboutBlankSessionMismatch,
         electronPostCommandHealth: options.electronPostCommandHealth,
         electronRefFreshness: options.electronRefFreshnessDiagnostic,
@@ -358,6 +380,8 @@ function buildAgentBrowserResultDetails(options, nextActions) {
         fullOutputPath: options.parseFailureOutput.fullOutputPath ?? options.presentation.fullOutputPath,
         fullOutputPaths: options.presentation.fullOutputPaths,
         fullOutputUnavailable: options.parseFailureOutput.fullOutputUnavailable,
+        managedSessionHeadedAutosaveDisabled: options.managedSessionHeadedAutosaveDisabled,
+        managedSessionHeadedAutosaveInterval: options.managedSessionHeadedAutosaveInterval,
         managedSessionOutcome: options.managedSessionOutcome,
         imagePath: options.presentation.imagePath,
         imagePaths: options.presentation.imagePaths,
@@ -423,7 +447,8 @@ export function buildFinalAgentBrowserToolResult(options) {
     const artifactCleanupText = formatArtifactCleanupGuidanceText(options.artifactCleanup);
     const timeoutPartialProgressText = options.timeoutPartialProgress ? formatTimeoutPartialProgressText(options.timeoutPartialProgress) : undefined;
     const managedSessionOutcomeText = formatManagedSessionOutcomeText(options.managedSessionOutcome);
-    const rawAppendedDiagnosticText = [visibleRefFallbackText, richInputRecoveryText, semanticActionCandidateText, clickDispatchText, overlayBlockerText, fillVerificationText, electronRefFreshnessText, selectorTextVisibilityText, electronBroadGetTextScopeText, scrollNoopDiagnosticText, comboboxFocusDiagnosticText, recordingDependencyWarningText, evalStdinHintText, evalResultWarningText, artifactCleanupText, timeoutPartialProgressText, managedSessionOutcomeText].filter((item) => item !== undefined).join("\n\n");
+    const failureNextActionsText = formatFailureNextActionsText(options, nextActions);
+    const rawAppendedDiagnosticText = [visibleRefFallbackText, richInputRecoveryText, semanticActionCandidateText, clickDispatchText, overlayBlockerText, fillVerificationText, electronRefFreshnessText, selectorTextVisibilityText, electronBroadGetTextScopeText, scrollNoopDiagnosticText, comboboxFocusDiagnosticText, recordingDependencyWarningText, evalStdinHintText, evalResultWarningText, artifactCleanupText, timeoutPartialProgressText, managedSessionOutcomeText, failureNextActionsText].filter((item) => item !== undefined).join("\n\n");
     const appendedDiagnosticText = redactSensitiveText(redactExactSensitiveText(rawAppendedDiagnosticText, options.exactSensitiveValues));
     const shouldAppendDiagnosticText = appendedDiagnosticText.length > 0 && (!options.userRequestedJson || options.plainTextInspection);
     let content = shouldAppendDiagnosticText && options.redactedContent[0]?.type === "text" ? [{ ...options.redactedContent[0], text: `${options.redactedContent[0].text}\n\n${appendedDiagnosticText}` }, ...options.redactedContent.slice(1)] : options.redactedContent;
@@ -451,5 +476,5 @@ export async function buildMissingBinaryFailureResult(options) {
         missingBinaryElectronRecord = missingBinaryElectronCleanup.record;
     }
     const textParts = [errorText, managedSessionOutcomeText, missingBinaryElectronCleanup ? `Electron cleanup after failed attach: ${missingBinaryElectronCleanup.summary}` : undefined].filter((part) => part !== undefined && part.length > 0);
-    return { content: [{ type: "text", text: textParts.join("\n\n") }], details: { args: options.redactedArgs, compatibilityWorkaround: options.compatibilityWorkaround, effectiveArgs: options.redactedProcessArgs, electron: missingBinaryElectronRecord ? { action: "launch", cleanup: missingBinaryElectronCleanup, launch: missingBinaryElectronRecord, status: "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined, managedSessionOutcome, namespace: options.executionPlan.namespace, nextActions: managedSessionRecoveryNextActions.length > 0 ? managedSessionRecoveryNextActions : undefined, sessionMode: options.sessionMode, sessionTabCorrection: options.sessionTabCorrection, ...buildAgentBrowserResultCategoryDetails({ args: options.redactedProcessArgs, command: options.executionPlan.commandInfo.command, errorText, failureCategory: "missing-binary", spawnError, succeeded: false }), spawnError }, isError: true };
+    return { content: [{ type: "text", text: textParts.join("\n\n") }], details: { agentBrowserStarted: options.processResult.agentBrowserStarted, args: options.redactedArgs, compatibilityWorkaround: options.compatibilityWorkaround, effectiveArgs: options.redactedProcessArgs, electron: missingBinaryElectronRecord ? { action: "launch", cleanup: missingBinaryElectronCleanup, launch: missingBinaryElectronRecord, status: "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined, managedSessionOutcome, namespace: options.executionPlan.namespace, nextActions: managedSessionRecoveryNextActions.length > 0 ? managedSessionRecoveryNextActions : undefined, sessionMode: options.sessionMode, sessionTabCorrection: options.sessionTabCorrection, ...buildAgentBrowserResultCategoryDetails({ args: options.redactedProcessArgs, command: options.executionPlan.commandInfo.command, errorText, failureCategory: "missing-binary", spawnError, succeeded: false }), spawnError }, isError: true };
 }

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

@@ -20,6 +20,7 @@ async function runAgentBrowserToolInContext(options) {
     const ownedManagedSession = prepared.ownedManagedSessionContext;
     return await withOwnedManagedSessionContext(ownedManagedSession, async () => {
         try {
+            const artifactRunStartedAtMs = Date.now();
             const processResult = await runAgentBrowserProcess({
                 args: prepared.processArgs,
                 cwd: options.cwd,
@@ -51,7 +52,7 @@ async function runAgentBrowserToolInContext(options) {
             });
             if (missingBinaryResult)
                 return missingBinaryResult;
-            const output = await processBrowserOutput({ ...options, prepared, processResult });
+            const output = await processBrowserOutput({ ...options, artifactRunStartedAtMs, prepared, processResult });
             applyBrowserRunStatePatch(options.state, output.statePatch);
             return output.result;
         }

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

@@ -1,24 +1,29 @@
-/**
- * Purpose: Coordinate wrapper-owned managed-session daemon inspection, reuse, and cleanup policy.
- * Responsibilities: Serialize daemon policy decisions, verify live restore keys, and close owned sessions with snapshot cleanup.
- * Scope: Managed-session daemon policy only; page state and browser-result shaping live in sibling modules.
- * Usage: Called by browser-run preparation, Electron host probes, result handling, and extension shutdown cleanup.
- * Invariants/Assumptions: Every owned daemon decision holds the cross-process policy lock until its caller finishes the related operation.
- */
 import { rm } from "node:fs/promises";
 import { acquireManagedSessionPolicyLock } from "../../managed-session-policy-lock.js";
-import { pruneOwnedManagedSessionRestoreSnapshots, } from "../../managed-session-restore.js";
+import { pruneOwnedManagedSessionRestoreSnapshots, resolveExplicitAutosaveInterval, } 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 { getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results.js";
+import { getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { redactInvocationArgs } from "../../runtime.js";
-const MANAGED_SESSION_DAEMON_INSPECTION_TIMEOUT_MS = 5_000;
+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) {
+    const explicitInterval = resolveExplicitAutosaveInterval(getAgentBrowserProcessEnvironment().AGENT_BROWSER_AUTOSAVE_INTERVAL_MS);
+    return recordedInterval !== undefined && !closeCommand && explicitInterval !== undefined && explicitInterval !== recordedInterval
+        ? RUNNING_HEADED_AUTOSAVE_POLICY_CHANGE_ERROR
+        : undefined;
+}
+function getHeadedManagedAutosaveEnv(interval) {
+    return interval !== undefined ? { AGENT_BROWSER_AUTOSAVE_INTERVAL_MS: interval } : undefined;
+}
 export async function inspectManagedSessionDaemon(options) {
     const processResult = await runAgentBrowserProcess({
         allowManagedSessionTarget: options.allowManagedSessionTarget,
         args: ["--json", "--namespace", options.namespace ?? "", "--session", options.sessionName, "session", "info"],
         cwd: options.cwd,
+        env: getHeadedManagedAutosaveEnv(options.headedManagedAutosaveInterval),
         preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
         signal: options.signal,
         timeoutMs: options.timeoutMs ?? MANAGED_SESSION_DAEMON_INSPECTION_TIMEOUT_MS,
@@ -65,6 +70,7 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
         const daemon = await inspectManagedSessionDaemon({
             allowManagedSessionTarget: true,
             cwd: context.cwd,
+            headedManagedAutosaveInterval: context.headedManagedAutosaveInterval,
             namespace: context.namespace,
             sessionName: context.sessionName,
             signal,
@@ -74,7 +80,7 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
         if (options.mode === "close") {
             if (daemon.status === "active")
                 context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
-            return { lock };
+            return { daemonStatus: daemon.status, lock };
         }
         const stickyDisabled = context.restoreState.isDisabled(context.sessionName, context.namespace);
         const hasKnownDaemonRestoreKey = context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace);
@@ -96,13 +102,14 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
             context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
         return !["inactive", "missing-binary"].includes(daemon.status) && !activePolicyMatches
             ? {
+                daemonStatus: daemon.status,
                 error: [
                     "This wrapper-owned session's live daemon does not match the requested managed-restore policy.",
                     "Close that session first, retry with sessionMode: \"fresh\", or use a distinct explicit --session.",
                 ].join(" "),
                 lock,
             }
-            : { lock };
+            : { daemonStatus: daemon.status, lock };
     }
     catch (error) {
         await lock.release();
@@ -113,7 +120,7 @@ export async function closeManagedSession(options) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), options.timeoutMs);
     let stdoutSpillPath;
-    const closeArgs = [...(options.namespace ? ["--namespace", options.namespace] : []), "--session", options.sessionName, "close"];
+    const closeArgs = [...(options.namespace !== undefined ? ["--namespace", options.namespace] : []), "--session", options.sessionName, "close"];
     const policyLock = options.policyLock ?? await acquireManagedSessionPolicyLock({
         namespace: options.namespace,
         sessionName: options.sessionName,
@@ -128,6 +135,7 @@ export async function closeManagedSession(options) {
         const daemon = await inspectManagedSessionDaemon({
             allowManagedSessionTarget: true,
             cwd: options.cwd,
+            headedManagedAutosaveInterval: options.headedManagedAutosaveInterval,
             namespace: options.namespace,
             preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
             sessionName: options.sessionName,
@@ -142,7 +150,7 @@ export async function closeManagedSession(options) {
         const processResult = await runAgentBrowserProcess({
             args: closeArgs,
             cwd: options.cwd,
-            env: { AGENT_BROWSER_JSON: "1" },
+            env: { AGENT_BROWSER_JSON: "1", ...getHeadedManagedAutosaveEnv(options.headedManagedAutosaveInterval) },
             managedSessionRestoreState: options.restoreState,
             ownedManagedSession: true,
             preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,

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

@@ -1,7 +1,7 @@
 import { mkdir, stat, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { isRecord } from "../../../parsing.js";
-import { buildAgentBrowserResultCategoryDetails } from "../../../results.js";
+import { buildAgentBrowserResultCategoryDetails } from "../../../results/categories.js";
 import { formatSessionArtifactRetentionSummary, mergeSessionArtifactManifest } from "../../../results/artifact-manifest.js";
 import { redactSensitiveText } from "../../../runtime.js";
 import { buildSessionDetailFields, runSessionCommandData } from "../session-state.js";

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

@@ -1,5 +1,5 @@
 import { isRecord } from "../../../parsing.js";
-import { buildAgentBrowserResultCategoryDetails } from "../../../results.js";
+import { buildAgentBrowserResultCategoryDetails } from "../../../results/categories.js";
 import { redactSensitiveText } from "../../../runtime.js";
 import { buildSessionDetailFields, runSessionCommandData } from "../session-state.js";
 function parseNetworkRequestsPageFilterRequest(commandTokens) {

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

@@ -1,5 +1,5 @@
 import { isRecord } from "../../../parsing.js";
-import { buildAgentBrowserResultCategoryDetails } from "../../../results.js";
+import { buildAgentBrowserResultCategoryDetails } from "../../../results/categories.js";
 import { applyNamespaceToNextActions } from "../../../results/next-actions.js";
 import { buildScrollNoopNextActions } from "../diagnostics.js";
 import { buildSessionDetailFields, runSessionCommandData } from "../session-state.js";

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

@@ -1,5 +1,5 @@
 import { isRecord } from "../../../parsing.js";
-import { buildAgentBrowserResultCategoryDetails } from "../../../results.js";
+import { buildAgentBrowserResultCategoryDetails } from "../../../results/categories.js";
 import { buildSnapshotPresentation } from "../../../results/snapshot.js";
 import { extractRefSnapshotFromData } from "../../../session-page-state.js";
 import { collectScrollPositionSnapshot } from "../diagnostics.js";