npm - pi-agent-browser-native - Versions diffs - 0.8.2 → 0.8.3 - Mend

pi-agent-browser-native 0.8.2 → 0.8.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/dist/extensions/agent-browser/lib/input-modes/params.js CHANGED Viewed

@@ -79,41 +79,38 @@ export function createAgentBrowserQaParamsSchema(Type = JsonSchema, StringEnum =
 export function createAgentBrowserElectronParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
     const common = { outputPath: outputProperties(Type).outputPath };
     const timeoutMs = Type.Optional(Type.Integer({ minimum: 1 }));
-    return Type.Unsafe(Type.Union([
-        Type.Object({
-            action: StringEnum(["list"]),
-            query: Type.Optional(Type.String({ description: "Case-insensitive app filter.", minLength: 1 })),
-            maxResults: Type.Optional(Type.Integer({ description: `Result cap; default ${ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS}, clamped to ${ELECTRON_DISCOVERY_MAX_RESULTS}.`, minimum: 1 })),
-            ...common,
-        }, { additionalProperties: false }),
-        Type.Object({
-            action: StringEnum(["launch"]),
-            appPath: Type.Optional(Type.String({ description: "macOS .app path.", minLength: 1 })),
-            appName: Type.Optional(Type.String({ description: "Name from agent_browser_electron list.", minLength: 1 })),
-            bundleId: Type.Optional(Type.String({ minLength: 1 })),
-            executablePath: Type.Optional(Type.String({ minLength: 1 })),
-            appArgs: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-            handoff: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_HANDOFFS)),
-            targetType: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_TARGET_TYPES)),
-            timeoutMs,
-            allow: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-            deny: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-            ...common,
-        }, { additionalProperties: false }),
-        Type.Object({
-            action: StringEnum(["status", "cleanup"]),
-            launchId: Type.Optional(Type.String({ minLength: 1 })),
-            all: Type.Optional(Type.Literal(true)),
-            timeoutMs,
-            ...common,
-        }, { additionalProperties: false, not: { required: ["launchId", "all"] } }),
-        Type.Object({
-            action: StringEnum(["probe"]),
-            launchId: Type.Optional(Type.String({ minLength: 1 })),
-            timeoutMs,
-            ...common,
-        }, { additionalProperties: false }),
-    ]));
+    const list = {
+        query: Type.Optional(Type.String({ description: "Case-insensitive app filter.", minLength: 1 })),
+        maxResults: Type.Optional(Type.Integer({ description: `Result cap; default ${ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS}, clamped to ${ELECTRON_DISCOVERY_MAX_RESULTS}.`, minimum: 1 })),
+    };
+    const launch = {
+        appPath: Type.Optional(Type.String({ description: "macOS .app path.", minLength: 1 })),
+        appName: Type.Optional(Type.String({ description: "Name from agent_browser_electron list.", minLength: 1 })),
+        bundleId: Type.Optional(Type.String({ minLength: 1 })),
+        executablePath: Type.Optional(Type.String({ minLength: 1 })),
+        appArgs: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+        handoff: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_HANDOFFS)),
+        targetType: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_TARGET_TYPES)),
+        timeoutMs,
+        allow: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+        deny: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    };
+    const probe = { launchId: Type.Optional(Type.String({ minLength: 1 })), timeoutMs };
+    const lifecycle = { ...probe, all: Type.Optional(Type.Literal(true)) };
+    // Strict providers need an object root; Pi needs root properties to normalize optional nulls.
+    // Each branch retains its original action-specific field boundary.
+    return Type.Unsafe(Type.Object({
+        action: StringEnum(["list", "launch", "status", "cleanup", "probe"]),
+        ...list, ...launch, ...lifecycle, ...common,
+    }, {
+        additionalProperties: false,
+        anyOf: [
+            Type.Object({ action: StringEnum(["list"]), ...list, ...common }, { additionalProperties: false }),
+            Type.Object({ action: StringEnum(["launch"]), ...launch, ...common }, { additionalProperties: false }),
+            Type.Object({ action: StringEnum(["status", "cleanup"]), ...lifecycle, ...common }, { additionalProperties: false, not: { required: ["launchId", "all"] } }),
+            Type.Object({ action: StringEnum(["probe"]), ...probe, ...common }, { additionalProperties: false }),
+        ],
+    }));
 }
 export function createAgentBrowserSourceParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
     return Type.Unsafe(Type.Object({

package/dist/extensions/agent-browser/lib/managed-session-policy-lock.js CHANGED Viewed

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash, randomInt, randomUUID } from "node:crypto";
 import { lstat, mkdir, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
@@ -11,6 +11,9 @@ const POLICY_LOCK_RETRY_MS = 10;
 const POLICY_LOCK_MAX_BYTES = 1_048_576; // One claim may cover an entire owned-browser cleanup set.
 const LOCK_OWNER_FILE = "owner.json";
 const LOCK_TICKET_FILE = "ticket.json";
+const STALE_CLAIM_MIN_AGE_MS = 30 * 60 * 1_000;
+const POLICY_GC_BATCH_SIZE = 8;
+let lastPolicyGcName;
 function getCoordinationDirectory(platform = process.platform) {
     if (platform !== "win32") {
         const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
@@ -175,6 +178,7 @@ function parseOwner(content) {
             && Number.isSafeInteger(parsed.pid) && (parsed.pid ?? 0) > 0
             && typeof parsed.startIdentity === "string" && parsed.startIdentity.length > 0
             && typeof parsed.token === "string" && parsed.token.length > 0
+            && !parsed.token.includes("/") && !parsed.token.includes("\\") && !parsed.token.includes("\0")
             ? parsed
             : undefined;
     }
@@ -323,14 +327,30 @@ async function cleanDeadPolicyArtifacts(directory, budget) {
     catch {
         return;
     }
-    for (const name of names.filter((candidate) => candidate.startsWith(".pi-agent-browser-policy-remove-")
-        || candidate.includes(".lock-v4.candidate-"))) {
+    // ponytail: list/sort all names; stream directories if enumeration becomes the bottleneck.
+    const candidates = names.filter((name) => name.startsWith(".pi-agent-browser-policy-remove-")
+        || /^\.pi-agent-browser-policy-[a-f0-9]{64}\.lock-v4\.(?:candidate|claim)-/.test(name)).sort();
+    if (candidates.length === 0)
+        return;
+    const start = lastPolicyGcName === undefined ? randomInt(candidates.length)
+        : Math.max(0, candidates.findIndex((name) => name > lastPolicyGcName));
+    const batch = Array.from({ length: Math.min(POLICY_GC_BATCH_SIZE, candidates.length) }, (_, offset) => candidates[(start + offset) % candidates.length]);
+    lastPolicyGcName = batch.at(-1);
+    for (const name of batch) {
         if (budget.signal?.aborted || Date.now() >= (budget.deadline ?? Infinity))
             return;
         const path = join(directory, name);
+        const published = name.includes(".lock-v4.claim-");
+        if (published) {
+            const entry = await lstat(path).catch(() => undefined);
+            if (!entry || entry.mtimeMs >= Date.now() - STALE_CLAIM_MIN_AGE_MS)
+                continue;
+        }
         const claim = await readClaim(path);
-        if (claim && await ownerAlive(claim.owner, budget) === false)
-            await rm(path, { force: true, recursive: true }).catch(() => undefined);
+        if (!claim || (published && !name.endsWith(`.claim-${claim.owner.token}`)))
+            continue;
+        if (await ownerAlive(claim.owner, budget) === false)
+            await removeClaimOwnedBy(path, claim.owner.token).catch(() => false);
     }
 }
 function claimPrecedes(left, right) {

package/dist/extensions/agent-browser/lib/managed-session-restore.js CHANGED Viewed

@@ -4,6 +4,7 @@ import { canonicalizeAgentBrowserNamespace, extractExplicitNamespace, extractExp
 import { hasLaunchScopedFlagToken, MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS, MANAGED_RESTORE_INCOMPATIBLE_ENVS, MANAGED_RESTORE_INCOMPATIBLE_FLAGS, } from "./launch-scoped-flags.js";
 import { createManagedSessionRestoreKey, ensureManagedSessionRestoreStorageIsSecure, getManagedSessionRestoreScope, getManagedSessionRestoreProtectedStorageEnv, hasManagedSessionRestoreProjectIdentity, resolveManagedSessionRestoreHome, } from "./managed-session-storage.js";
 import { parseUserBatchStdin } from "./orchestration/batch-stdin.js";
+import { isRecord } from "./parsing.js";
 import { getAgentBrowserProcessEnvironment } from "./process-environment.js";
 export { createManagedSessionRestoreKey, ensureManagedSessionRestoreStorageIsSecure, getManagedSessionRestoreScope } from "./managed-session-storage.js";
 export { pruneOwnedManagedSessionRestoreSnapshots } from "./managed-session-snapshots.js";
@@ -39,10 +40,11 @@ export class ManagedSessionRestoreState {
             this.#disabled.add(getAgentBrowserSessionIdentityKey(sessionName, namespace));
     }
     getDaemonRestoreKey(sessionName, namespace) {
-        return typeof sessionName === "string" ? this.#daemonRestoreKeys.get(getAgentBrowserSessionIdentityKey(sessionName, namespace)) : undefined;
+        return typeof sessionName === "string" ? this.#daemonRestoreKeys.get(getAgentBrowserSessionIdentityKey(sessionName, namespace))?.restoreKey : undefined;
     }
     hasDaemonRestoreKey(sessionName, namespace) {
-        return typeof sessionName === "string" && this.#daemonRestoreKeys.has(getAgentBrowserSessionIdentityKey(sessionName, namespace));
+        return typeof sessionName === "string" && this.#daemonRestoreKeys.get(getAgentBrowserSessionIdentityKey(sessionName, namespace))?.restored !== true
+            && this.#daemonRestoreKeys.has(getAgentBrowserSessionIdentityKey(sessionName, namespace));
     }
     forgetDaemonRestoreKey(sessionName, namespace) {
         if (sessionName)
@@ -51,9 +53,22 @@ export class ManagedSessionRestoreState {
     isDisabled(sessionName, namespace) {
         return typeof sessionName === "string" && this.#disabled.has(getAgentBrowserSessionIdentityKey(sessionName, namespace));
     }
-    recordDaemonRestoreKey(sessionName, namespace, restoreKey) {
-        if (sessionName)
-            this.#daemonRestoreKeys.set(getAgentBrowserSessionIdentityKey(sessionName, namespace), restoreKey);
+    recordDaemonRestoreKey(sessionName, namespace, restoreKey, generation) {
+        if (sessionName) {
+            const key = getAgentBrowserSessionIdentityKey(sessionName, namespace);
+            const previous = this.#daemonRestoreKeys.get(key);
+            this.#daemonRestoreKeys.set(key, { restoreKey, generation: generation ?? (previous?.restoreKey === restoreKey ? previous.generation : undefined) });
+        }
+    }
+    getDaemonReceipt(sessionName, namespace) {
+        const receipt = sessionName ? this.#daemonRestoreKeys.get(getAgentBrowserSessionIdentityKey(sessionName, namespace)) : undefined;
+        return receipt?.generation ? { restoreKey: receipt.restoreKey, generation: receipt.generation } : undefined;
+    }
+    restoreDaemonReceipt(sessionName, namespace, receipt) {
+        if (isRecord(receipt) && typeof receipt.generation === "string" && receipt.generation.length > 0
+            && (receipt.restoreKey === null || typeof receipt.restoreKey === "string")) {
+            this.#daemonRestoreKeys.set(getAgentBrowserSessionIdentityKey(sessionName, namespace), { restoreKey: receipt.restoreKey, generation: receipt.generation, restored: true });
+        }
     }
     replace(identities = [], options = {}) {
         if (!options.preserveDaemonRestoreKeys)

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

@@ -5,7 +5,8 @@ import { acquireManagedSessionPolicyLock } from "../../managed-session-policy-lo
 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 { readProcessStartIdentity } from "../../process-identity.js";
+import { getAgentBrowserProcessEnvironment, withAgentBrowserProcessEnvironment } from "../../process-environment.js";
 import { runAgentBrowserProcess, withAttachedBrowserSessionContext } from "../../process.js";
 import { getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { redactInvocationArgs } from "../../runtime.js";
@@ -43,9 +44,16 @@ export async function inspectManagedSessionDaemon(options) {
             return { status: "inactive" };
         if (!isRecord(data.runtime))
             return { status: "unknown" };
+        let generation;
+        if (options.includeGeneration && Number.isSafeInteger(data.runtime.backgroundPid) && Number(data.runtime.backgroundPid) > 0
+            && typeof data.runtime.socketDir === "string" && data.runtime.browserLaunched !== false) {
+            const start = await readProcessStartIdentity(Number(data.runtime.backgroundPid), process.platform, { signal: options.signal, deadline: Date.now() + (options.timeoutMs ?? 5_000) });
+            if (start)
+                generation = JSON.stringify({ pid: data.runtime.backgroundPid, start, socketDir: data.runtime.socketDir });
+        }
         if (typeof data.runtime.restoreKey === "string" && data.runtime.restoreKey.length > 0)
-            return { restoreKey: data.runtime.restoreKey, status: "active" };
-        return data.runtime.restoreKey === null ? { restoreKey: null, status: "active" } : { status: "unknown" };
+            return { restoreKey: data.runtime.restoreKey, status: "active", generation };
+        return data.runtime.restoreKey === null ? { restoreKey: null, status: "active", generation } : { status: "unknown" };
     }
     finally {
         if (processResult.stdoutSpillPath)
@@ -86,8 +94,10 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
             };
     }
     try {
+        const receipt = context.restoreState.getDaemonReceipt(context.sessionName, context.namespace);
         const daemon = await inspectManagedSessionDaemon({
             cwd: context.cwd,
+            includeGeneration: receipt !== undefined && !context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace),
             headedManagedAutosaveInterval: context.headedManagedAutosaveInterval,
             namespace: context.namespace,
             sessionName: context.sessionName,
@@ -95,6 +105,13 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
         });
         if (daemon.status === "inactive")
             context.restoreState.forgetDaemonRestoreKey(context.sessionName, context.namespace);
+        if (daemon.status === "active" && receipt && !context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace)) {
+            if (daemon.generation === receipt.generation && daemon.restoreKey === receipt.restoreKey) {
+                context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey, daemon.generation);
+            }
+            else
+                context.restoreState.forgetDaemonRestoreKey(context.sessionName, context.namespace);
+        }
         if (options.mode === "close") {
             if (daemon.status === "active")
                 context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
@@ -141,87 +158,89 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
     }
 }
 export async function closeManagedSession(options) {
-    const controller = new AbortController();
-    let phase = "policy coordination";
-    let phaseStartedAt = Date.now();
-    let timeoutError;
-    const timer = setTimeout(() => {
-        timeoutError = `Managed-session cleanup timed out after ${options.timeoutMs} ms during ${phase} (${Date.now() - phaseStartedAt} ms in this phase).`;
-        controller.abort();
-    }, options.timeoutMs);
-    let stdoutSpillPath;
-    const closeArgs = [...(options.namespace !== undefined ? ["--namespace", options.namespace] : []), "--session", options.sessionName, "close"];
-    const policyLock = options.policyLock ?? await acquireManagedSessionPolicyLock({
-        namespace: options.namespace,
-        sessionName: options.sessionName,
-        signal: controller.signal,
-        timeoutMs: Math.min(options.timeoutMs, 1_000),
-    });
-    if (!policyLock) {
-        clearTimeout(timer);
-        return timeoutError ?? "Managed-session policy coordination is unavailable or busy; cleanup did not run. Retry after the current operation finishes or repair the private policy-lock directory.";
-    }
-    try {
-        phase = "daemon inspection";
-        phaseStartedAt = Date.now();
-        const daemon = await inspectManagedSessionDaemon({
-            cwd: options.cwd,
-            headedManagedAutosaveInterval: options.headedManagedAutosaveInterval,
+    return withAgentBrowserProcessEnvironment(options.socketDir ? { PI_AGENT_BROWSER_SOCKET_DIR: options.socketDir } : {}, async () => {
+        const controller = new AbortController();
+        let phase = "policy coordination";
+        let phaseStartedAt = Date.now();
+        let timeoutError;
+        const timer = setTimeout(() => {
+            timeoutError = `Managed-session cleanup timed out after ${options.timeoutMs} ms during ${phase} (${Date.now() - phaseStartedAt} ms in this phase).`;
+            controller.abort();
+        }, options.timeoutMs);
+        let stdoutSpillPath;
+        const closeArgs = [...(options.namespace !== undefined ? ["--namespace", options.namespace] : []), "--session", options.sessionName, "close"];
+        const policyLock = options.policyLock ?? await acquireManagedSessionPolicyLock({
             namespace: options.namespace,
-            preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
             sessionName: options.sessionName,
             signal: controller.signal,
-            timeoutMs: Math.min(options.timeoutMs, 2_000),
-        });
-        if (daemon.status === "active")
-            options.restoreState.recordDaemonRestoreKey(options.sessionName, options.namespace, daemon.restoreKey);
-        const daemonRestoreKey = options.restoreState.getDaemonRestoreKey(options.sessionName, options.namespace);
-        const ownedRestoreKey = !options.restoreState.isDisabled(options.sessionName, options.namespace)
-            && isManagedSessionRestoreKey(daemonRestoreKey) ? daemonRestoreKey : null;
-        phase = "native close";
-        phaseStartedAt = Date.now();
-        const processResult = await runAgentBrowserProcess({
-            args: closeArgs,
-            cwd: options.cwd,
-            env: { AGENT_BROWSER_JSON: "1", ...getHeadedManagedAutosaveEnv(options.headedManagedAutosaveInterval) },
-            managedSessionRestoreState: options.restoreState,
-            ownedManagedSession: true,
-            preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
-            signal: controller.signal,
+            timeoutMs: Math.min(options.timeoutMs, 1_000),
         });
-        clearTimeout(timer);
-        stdoutSpillPath = processResult.stdoutSpillPath;
-        if (!processResult.aborted && !processResult.spawnError && processResult.exitCode === 0) {
-            const parsed = await parseAgentBrowserEnvelope({ stdout: processResult.stdout, stdoutPath: processResult.stdoutSpillPath });
-            const data = parsed.envelope?.success === true && isRecord(parsed.envelope.data) ? parsed.envelope.data : undefined;
-            options.restoreState.clear(options.sessionName, options.namespace);
-            pruneOwnedManagedSessionRestoreSnapshots({
+        if (!policyLock) {
+            clearTimeout(timer);
+            return timeoutError ?? "Managed-session policy coordination is unavailable or busy; cleanup did not run. Retry after the current operation finishes or repair the private policy-lock directory.";
+        }
+        try {
+            phase = "daemon inspection";
+            phaseStartedAt = Date.now();
+            const daemon = await inspectManagedSessionDaemon({
                 cwd: options.cwd,
+                headedManagedAutosaveInterval: options.headedManagedAutosaveInterval,
                 namespace: options.namespace,
-                restoreKey: ownedRestoreKey,
-                statePath: typeof data?.statePath === "string" ? data.statePath : undefined,
+                preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
+                sessionName: options.sessionName,
+                signal: controller.signal,
+                timeoutMs: Math.min(options.timeoutMs, 2_000),
+            });
+            if (daemon.status === "active")
+                options.restoreState.recordDaemonRestoreKey(options.sessionName, options.namespace, daemon.restoreKey);
+            const daemonRestoreKey = options.restoreState.getDaemonRestoreKey(options.sessionName, options.namespace);
+            const ownedRestoreKey = !options.restoreState.isDisabled(options.sessionName, options.namespace)
+                && isManagedSessionRestoreKey(daemonRestoreKey) ? daemonRestoreKey : null;
+            phase = "native close";
+            phaseStartedAt = Date.now();
+            const processResult = await runAgentBrowserProcess({
+                args: closeArgs,
+                cwd: options.cwd,
+                env: { AGENT_BROWSER_JSON: "1", ...getHeadedManagedAutosaveEnv(options.headedManagedAutosaveInterval) },
+                managedSessionRestoreState: options.restoreState,
+                ownedManagedSession: true,
+                preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            stdoutSpillPath = processResult.stdoutSpillPath;
+            if (!processResult.aborted && !processResult.spawnError && processResult.exitCode === 0) {
+                const parsed = await parseAgentBrowserEnvelope({ stdout: processResult.stdout, stdoutPath: processResult.stdoutSpillPath });
+                const data = parsed.envelope?.success === true && isRecord(parsed.envelope.data) ? parsed.envelope.data : undefined;
+                options.restoreState.clear(options.sessionName, options.namespace);
+                pruneOwnedManagedSessionRestoreSnapshots({
+                    cwd: options.cwd,
+                    namespace: options.namespace,
+                    restoreKey: ownedRestoreKey,
+                    statePath: typeof data?.statePath === "string" ? data.statePath : undefined,
+                });
+            }
+            return timeoutError ?? getAgentBrowserErrorText({
+                aborted: processResult.aborted,
+                command: "close",
+                effectiveArgs: redactInvocationArgs(closeArgs),
+                exitCode: processResult.exitCode,
+                plainTextInspection: false,
+                spawnError: processResult.spawnError,
+                stderr: processResult.stderr,
+                timedOut: processResult.timedOut,
+                timeoutMs: processResult.timeoutMs,
             });
         }
-        return timeoutError ?? getAgentBrowserErrorText({
-            aborted: processResult.aborted,
-            command: "close",
-            effectiveArgs: redactInvocationArgs(closeArgs),
-            exitCode: processResult.exitCode,
-            plainTextInspection: false,
-            spawnError: processResult.spawnError,
-            stderr: processResult.stderr,
-            timedOut: processResult.timedOut,
-            timeoutMs: processResult.timeoutMs,
-        });
-    }
-    catch (error) {
-        return timeoutError ?? (error instanceof Error ? error.message : String(error));
-    }
-    finally {
-        clearTimeout(timer);
-        if (stdoutSpillPath)
-            await rm(stdoutSpillPath, { force: true }).catch(() => undefined);
-        if (!options.policyLock)
-            await policyLock.release();
-    }
+        catch (error) {
+            return timeoutError ?? (error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            clearTimeout(timer);
+            if (stdoutSpillPath)
+                await rm(stdoutSpillPath, { force: true }).catch(() => undefined);
+            if (!options.policyLock)
+                await policyLock.release();
+        }
+    });
 }

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

@@ -392,6 +392,7 @@ export async function prepareBrowserRun(options) {
                 }) };
         }
         electronLaunch = launchResult.value;
+        electronLaunch.record.ownerSessionId = options.ctx.sessionManager.getSessionId();
         runtimeToolArgs = ["connect", electronLaunch.connectArg];
         runtimeToolStdin = undefined;
     }
@@ -570,7 +571,18 @@ export async function prepareBrowserRun(options) {
             const sessionTabPinningReason = priorSessionPageState.pinningReason;
             let priorRefSnapshotState = priorSessionPageState.refSnapshot;
             let priorRefSnapshotInvalidation = priorSessionPageState.refSnapshotInvalidation;
-            const coldManagedSession = !browserIndependent && (managedSessionDaemonInactive || priorSessionPageState.tabReopenPending === true)
+            let nativeGenerationChanged = false;
+            if (!browserIndependent && !isCloseCommand(executionPlan.commandInfo.command) && priorRefSnapshotState?.refIds.length && sessionStateKey && executionPlan.sessionName) {
+                const daemon = await inspectManagedSessionDaemon({ cwd, namespace: executionPlan.namespace, sessionName: executionPlan.sessionName, signal, includeGeneration: true, headedManagedAutosaveInterval: ownedManagedSession?.headedManagedAutosaveInterval ?? (ownedManagedSession?.headedManagedAutosaveDisabled ? "0" : undefined), timeoutMs: params.timeoutMs });
+                sessionPageState.bindSnapshotGeneration(sessionStateKey, daemon.status === "active" ? daemon.generation : undefined);
+                if (daemon.status !== "active" || daemon.generation === undefined || priorRefSnapshotState.generation !== daemon.generation) {
+                    nativeGenerationChanged = daemon.status === "active" && daemon.generation !== undefined && priorRefSnapshotState.generation !== undefined && priorRefSnapshotState.generation !== daemon.generation;
+                    priorRefSnapshotState = undefined;
+                    priorRefSnapshotInvalidation = buildPageTransitionRefSnapshotInvalidation("The native browser generation changed or could not be verified. Take a new complete snapshot before using refs, even when the URL is unchanged.");
+                    sessionPageState.applyRefSnapshotInvalidation({ invalidation: priorRefSnapshotInvalidation, sessionName: sessionStateKey, update: options.sessionPageStateUpdate });
+                }
+            }
+            const coldManagedSession = !browserIndependent && (managedSessionDaemonInactive || nativeGenerationChanged || priorSessionPageState.tabReopenPending === true)
                 && recordedOwnedSession !== undefined
                 && sessionTabPinningReason === "restore"
                 && ownedManagedSession?.restoreDecision === "enabled"
@@ -960,8 +972,17 @@ export async function prepareBrowserRun(options) {
                 signal,
                 usedImplicitSession: executionPlan.usedImplicitSession,
             });
-            if (snapshotFilter)
+            if (snapshotFilter) {
+                if (sessionStateKey && executionPlan.sessionName) {
+                    const daemon = await inspectManagedSessionDaemon({ cwd, namespace: executionPlan.namespace, sessionName: executionPlan.sessionName, signal, includeGeneration: true, headedManagedAutosaveInterval: ownedManagedSession?.headedManagedAutosaveInterval ?? (ownedManagedSession?.headedManagedAutosaveDisabled ? "0" : undefined), timeoutMs: params.timeoutMs });
+                    sessionPageState.bindSnapshotGeneration(sessionStateKey, daemon.status === "active" ? daemon.generation : undefined);
+                    if (ownedManagedSession && daemon.status === "active" && daemon.generation)
+                        state.managedSessionRestoreState.recordDaemonRestoreKey(executionPlan.sessionName, executionPlan.namespace, daemon.restoreKey, daemon.generation);
+                    if (isRecord(snapshotFilter.result.details))
+                        snapshotFilter.result.details.refSnapshot = sessionPageState.get(sessionStateKey).refSnapshot;
+                }
                 return { kind: "early-result", statePatch: { ...statePatch, artifactManifest: snapshotFilter.artifactManifest ?? statePatch.artifactManifest }, result: snapshotFilter.result };
+            }
             const networkRequestsPageFilter = await tryNetworkRequestsPageFilter({
                 commandTokens,
                 compatibilityWorkaround,

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

@@ -15,7 +15,7 @@ import { buildToolPresentation } from "../../results/presentation.js";
 import { compactLargePresentationOutput } from "../../results/presentation/large-output.js";
 import { extractEnvelopeErrorText, getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { detectConfirmationRequired } from "../../results/confirmation.js";
-import { omitUpstreamLifecycle } from "../../results/presentation/common.js";
+import { extractAgentBrowserLifecycle, omitUpstreamLifecycle } from "../../results/presentation/common.js";
 import { getClipboardWritePayloadCandidates, redactClipboardPermissionEcho, redactClipboardPermissionErrorValue } from "../../results/presentation/errors.js";
 import { shouldCaptureSemanticActionNavigationSummary } from "../../results/presentation/semantic-action.js";
 import { buildPageTransitionRefSnapshotInvalidation, commandExplicitlyTargetsAboutBlank, getCommandRefSnapshotInvalidation, deriveSessionTabTarget, extractLatestRefSnapshotStateFromBatchResults, extractRefSnapshotFromData, extractSessionTabTargetFromBatchResults, extractSessionTabTargetFromCommandData, isAboutBlankSessionTabTarget, normalizeSessionTabTarget, } from "../../session-page-state.js";
@@ -23,10 +23,10 @@ import { isRecord } from "../../parsing.js";
 import { buildReadConfirmationNextActions, nextReadConfirmation } from "../../read-confirmation.js";
 import { pruneOwnedManagedSessionRestoreSnapshots } from "../../managed-session-restore.js";
 import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
-import { createFreshSessionName, extractUpstreamCommandTokens, resolveManagedSessionState } from "../../runtime.js";
+import { createFreshSessionName, extractUpstreamCommandTokens, redactInvocationArgs, resolveManagedSessionState } from "../../runtime.js";
 import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
 import { closeManagedSession, inspectManagedSessionDaemon } from "./managed-session-daemon-policy.js";
-import { applyOpenResultTabCorrection, buildAboutBlankRecoveryHint, buildAboutBlankWarning, buildElectronPostCommandHealthDiagnostic, buildElectronRefFreshnessDiagnostic, buildElectronSessionMismatch, buildManagedSessionOutcome, collectOpenResultTabCorrection, collectSessionTabSelection, collectSessionTabTarget, commandChoosesSessionTabTarget, extractNavigationSummaryFromData, extractStringResultField, findElectronLaunchRecordForSession, formatElectronPostCommandHealthText, formatElectronSessionMismatchText, getSessionContextKey, getStaleRefArgs, mergeNavigationSummaryIntoData, runSessionCommandData, shouldCaptureNavigationSummary, shouldCorrectSessionTabAfterCommand, shouldInspectElectronPostCommandHealth, updateTraceOwnerState, } from "./session-state.js";
+import { applyOpenResultTabCorrection, applyBrowserRunStatePatch, buildAboutBlankRecoveryHint, buildAboutBlankWarning, buildElectronPostCommandHealthDiagnostic, buildElectronRefFreshnessDiagnostic, buildElectronSessionMismatch, buildManagedSessionOutcome, collectOpenResultTabCorrection, collectSessionTabSelection, collectSessionTabTarget, commandChoosesSessionTabTarget, extractNavigationSummaryFromData, extractStringResultField, findElectronLaunchRecordForSession, formatElectronPostCommandHealthText, formatElectronSessionMismatchText, getSessionContextKey, getStaleRefArgs, mergeNavigationSummaryIntoData, runSessionCommandData, shouldCaptureNavigationSummary, shouldCorrectSessionTabAfterCommand, shouldInspectElectronPostCommandHealth, updateTraceOwnerState, } from "./session-state.js";
 import { collectClickDispatchDiagnostic } from "./click-dispatch.js";
 import { buildScrollNoopDiagnostic, collectComboboxFocusDiagnostic, collectElectronBroadGetTextScopeDiagnostics, collectElectronHandoff, collectFillVerificationDiagnostic, collectNavigationSummary, collectOverlayBlockerDiagnostic, collectQaAttachedTarget, collectSnapshotOverlayBlockerDiagnostic, collectRecordingDependencyWarning, collectScrollPositionSnapshot, collectSelectorTextVisibilityDiagnostics, collectTimeoutPartialProgress, sleepMs, formatQaAttachedTargetText, getArtifactCleanupGuidance, getEvalResultWarning, getEvalStdinHint, getSourceLookupElectronContext, } from "./diagnostics.js";
 import { repairScreenshotData } from "./prepare.js";
@@ -617,7 +617,7 @@ export async function processBrowserOutput(input) {
             networkRoutesBySession.delete(replacedSessionStateKey ?? replacedManagedSessionName);
             sessionPageState.clearSession(replacedSessionStateKey ?? replacedManagedSessionName);
             const replacedSessionKey = replacedSessionStateKey ?? replacedManagedSessionName;
-            const replacedCloseError = await closeManagedSession({ cwd: priorManagedSessionCwd, headedManagedAutosaveInterval: priorManagedSessionHeadedAutosaveInterval, namespace: priorManagedSessionNamespace, preserveAttachedBrowserSession: state.attachedSessionKeys.has(replacedSessionKey), restoreState: state.managedSessionRestoreState, sessionName: replacedManagedSessionName, timeoutMs: implicitSessionCloseTimeoutMs });
+            const replacedCloseError = await closeManagedSession({ cwd: priorManagedSessionCwd, headedManagedAutosaveInterval: priorManagedSessionHeadedAutosaveInterval, namespace: priorManagedSessionNamespace, preserveAttachedBrowserSession: state.attachedSessionKeys.has(replacedSessionKey), restoreState: state.managedSessionRestoreState, sessionName: replacedManagedSessionName, socketDir: state.ownedManagedSessions.get(replacedSessionKey)?.socketDir, timeoutMs: implicitSessionCloseTimeoutMs });
             if (managedSessionOutcome) {
                 managedSessionOutcome = {
                     ...managedSessionOutcome,
@@ -709,6 +709,30 @@ export async function processBrowserOutput(input) {
         }
         if (plainTextUpgrade && errorText)
             presentationEnvelope = { ...presentationEnvelope, success: false, error: errorText };
+        const resultRetainsPreparedManagedSession = !managedSessionOutcome || (managedSessionOutcome.activeAfter
+            && managedSessionOutcome.attemptedSessionName === managedSessionOutcome.currentSessionName);
+        const resultHeadedManagedAutosaveDisabled = prepared.ownedManagedSessionContext?.headedManagedAutosaveDisabled === true
+            && resultRetainsPreparedManagedSession
+            && !(commandClosesSession && succeeded);
+        const resultHeadedManagedAutosaveInterval = resultRetainsPreparedManagedSession && !(commandClosesSession && succeeded)
+            ? prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval
+            : undefined;
+        // Commit native lifecycle facts to the execution state before rendering/export can fail.
+        applyBrowserRunStatePatch(state, { artifactManifest, freshSessionOrdinal, managedSessionActive, managedSessionCompatibilityWorkaround, managedSessionHeadedAutosaveDisabled, managedSessionHeadedAutosaveInterval, managedSessionCwd, managedSessionName, managedSessionNamespace, networkRoutesBySession });
+        state.observedBrowserEffects = {
+            args: prepared.redactedArgs, command: prepared.executionPlan.commandInfo.command, subcommand: prepared.executionPlan.commandInfo.subcommand,
+            sessionName: prepared.executionPlan.sessionName, namespace: prepared.executionPlan.namespace, sessionMode: prepared.sessionMode,
+            usedImplicitSession: prepared.executionPlan.usedImplicitSession, agentBrowserStarted: processResult.agentBrowserStarted,
+            nativeSucceeded: succeeded, managedSessionOutcome, managedSessionCwd: prepared.ownedManagedSessionContext?.cwd ?? managedSessionCwd, compatibilityWorkaround: prepared.compatibilityWorkaround,
+            managedSessionHeadedAutosaveDisabled: resultHeadedManagedAutosaveDisabled, managedSessionHeadedAutosaveInterval: resultHeadedManagedAutosaveInterval,
+            managedSessionRestoreDisabled: state.managedSessionRestoreState.isDisabled(prepared.executionPlan.sessionName, prepared.executionPlan.namespace),
+            closeAllApplied, readConfirmation: readConfirmationEvent ?? prepared.readConfirmation,
+            electron: electronLaunchRecord ? { launch: electronLaunchRecord, cleanup: electronFailedConnectCleanup } : undefined,
+            batchSteps: Array.isArray(presentationEnvelope?.data) ? presentationEnvelope.data.filter(isRecord).map(row => ({
+                command: Array.isArray(row.command) && row.command.every(token => typeof token === "string") ? redactInvocationArgs(row.command) : undefined,
+                success: row.success, lifecycle: extractAgentBrowserLifecycle(row.result),
+            })) : undefined,
+        };
         let presentation = plainTextInspection ? { artifacts: undefined, batchFailure: undefined, batchSteps: undefined, content: [{ type: "text", text: inspectionText ?? "" }], data: undefined, fullOutputPath: undefined, fullOutputPaths: undefined, imagePath: undefined, imagePaths: undefined, savedFile: undefined, savedFilePath: undefined, summary: `${prepared.redactedArgs.join(" ")} completed` } : recordingStopRecovery && !recordingStopRecovery.batch ? recordingStopRecovery.presentation : await buildToolPresentation({ modelVisible: input.modelVisible, args: prepared.redactedProcessArgs, artifactManifest, artifactMaxUpdatedAtMs: Date.now(), artifactMinUpdatedAtMs: input.artifactRunStartedAtMs, artifactRequest: screenshotArtifactRequest, batchArtifactRequests: batchScreenshotArtifactRequests, commandInfo: prepared.executionPlan.commandInfo, compiledSemanticAction: prepared.compiledSemanticAction, cwd: operationCwd, envelope: presentationEnvelope, errorText, namespace: prepared.executionPlan.namespace, networkRouteDiagnostics, networkRoutes: activeNetworkRoutes, persistentArtifactStore, previousRecordingContactSheetPath: sessionStateKey ? state.activeRecordingReservations?.get(sessionStateKey)?.contactSheetPath : undefined, piCleanupOwnership: sessionStateKey && (state.ownedManagedSessions.has(sessionStateKey) || prepared.executionPlan.managedSessionName !== undefined) ? "wrapper-managed" : "caller-owned", sessionName: prepared.executionPlan.sessionName });
         if (recordingStopRecovery)
             presentation = mergeRecordingRecoveryPresentation(presentation, recordingStopRecovery);
@@ -794,13 +818,14 @@ export async function processBrowserOutput(input) {
             presentation.failureCategory = "qa-failure";
             presentation.summary = qaPreset.summary;
             const compactText = buildQaCompactFailureText({
-                batchStepCount: presentation.batchSteps?.length ?? prepared.compiledQaPreset.steps.length,
-                checks: prepared.compiledQaPreset.checks,
+                causalError: presentation.batchFailure?.failedStep.text,
+                executedStepCount: presentation.batchSteps?.length,
                 page: extractQaPageContext({
                     attachedTarget: qaAttachedTarget,
                     batchData: presentationEnvelope?.data,
                     compiled: prepared.compiledQaPreset,
                 }),
+                plannedStepCount: prepared.compiledQaPreset.steps.length,
                 qaPreset,
             });
             const nonTextContent = presentation.content.filter((item) => item.type !== "text");
@@ -829,7 +854,12 @@ export async function processBrowserOutput(input) {
         const qaAttachedBannerText = [qaAttachedTargetText, qaAttachedDiagnosticsText].filter((part) => typeof part === "string" && part.length > 0).join("\n");
         const skipAttachedTargetBanner = qaPreset?.passed && prepared.compiledQaPreset?.checks.attached;
         if (!skipAttachedTargetBanner && qaAttachedBannerText && presentation.content[0]?.type === "text")
-            presentation.content[0] = { ...presentation.content[0], text: `${qaAttachedBannerText}\n\n${presentation.content[0].text}` };
+            presentation.content[0] = {
+                ...presentation.content[0],
+                text: qaPreset?.passed === false
+                    ? `${presentation.content[0].text}\n\n${qaAttachedBannerText}`
+                    : `${qaAttachedBannerText}\n\n${presentation.content[0].text}`,
+            };
         else if (!skipAttachedTargetBanner && qaAttachedBannerText)
             presentation.content.unshift({ type: "text", text: qaAttachedBannerText });
         if (managedSessionOutcome && managedSessionOutcome.succeeded !== succeeded)
@@ -856,19 +886,24 @@ export async function processBrowserOutput(input) {
         currentRefSnapshot = finalRecoveryState.currentRefSnapshot;
         currentRefSnapshotInvalidation = finalRecoveryState.currentRefSnapshotInvalidation;
         const authoritativePageState = sessionStateKey ? sessionPageState.get(sessionStateKey) : undefined;
+        const newSnapshot = authoritativePageState?.refSnapshot && authoritativePageState.refSnapshot.snapshotId !== prepared.priorRefSnapshotState?.snapshotId;
+        const needsDaemonReceipt = prepared.ownedManagedSessionContext && !prepared.ownedManagedSessionContext.reuseOnly && !commandClosesSession && processResult.agentBrowserStarted
+            && (succeeded || managedSessionOutcome?.activeAfter === true && managedSessionOutcome.currentSessionName === prepared.executionPlan.sessionName)
+            && !state.managedSessionRestoreState.getDaemonReceipt(prepared.executionPlan.sessionName, prepared.executionPlan.namespace);
+        if (sessionStateKey && prepared.executionPlan.sessionName && (newSnapshot || needsDaemonReceipt)) {
+            const daemon = await inspectManagedSessionDaemon({ cwd, namespace: prepared.executionPlan.namespace, sessionName: prepared.executionPlan.sessionName, signal, includeGeneration: true, headedManagedAutosaveInterval: prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval ?? (prepared.ownedManagedSessionContext?.headedManagedAutosaveDisabled ? "0" : undefined), timeoutMs: prepared.processTimeoutMs });
+            if (newSnapshot) {
+                sessionPageState.bindSnapshotGeneration(sessionStateKey, daemon.status === "active" ? daemon.generation : undefined);
+                currentRefSnapshot = sessionPageState.get(sessionStateKey).refSnapshot;
+            }
+            if (prepared.ownedManagedSessionContext && daemon.status === "active" && daemon.generation) {
+                state.managedSessionRestoreState.recordDaemonRestoreKey(prepared.executionPlan.sessionName, prepared.executionPlan.namespace, daemon.restoreKey, daemon.generation);
+            }
+        }
         if (sessionStateKey)
             currentSessionTabTarget = authoritativePageState?.tabTarget;
         const currentSessionTabTargetUnknown = authoritativePageState?.tabTargetUnknown === true ? true : undefined;
-        const resultRetainsPreparedManagedSession = !managedSessionOutcome || (managedSessionOutcome.activeAfter
-            && managedSessionOutcome.attemptedSessionName === managedSessionOutcome.currentSessionName);
-        const resultHeadedManagedAutosaveDisabled = prepared.ownedManagedSessionContext?.headedManagedAutosaveDisabled === true
-            && !prepared.ownedManagedSessionContext.reuseOnly
-            && resultRetainsPreparedManagedSession
-            && !(commandClosesSession && succeeded);
-        const resultHeadedManagedAutosaveInterval = resultRetainsPreparedManagedSession && !prepared.ownedManagedSessionContext?.reuseOnly && !(commandClosesSession && succeeded)
-            ? prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval
-            : undefined;
-        const result = buildFinalAgentBrowserToolResult({ modelVisible: input.modelVisible, aboutBlankSessionMismatch, artifactCleanup, categoryDetails: finalRecoveryState.categoryDetails, clickDispatchDiagnostic, commandTokens: prepared.commandTokens, comboboxFocusDiagnostic, compiledNetworkSourceLookup: prepared.compiledNetworkSourceLookup, compiledSemanticAction: prepared.compiledSemanticAction, compatibilityWorkaround: prepared.compatibilityWorkaround, currentRefSnapshot, currentRefSnapshotInvalidation, currentSessionTabTarget, currentSessionTabTargetUnknown, electronBroadGetTextScopeDiagnostics, electronFailedConnectCleanup, electronHandoff, electronLaunch: prepared.electronLaunch, electronLaunchRecord, electronLaunchRecords, electronPostCommandHealth, electronProfileIsolationDetails: input.electronProfileIsolationDetails, electronRefFreshnessDiagnostic, electronSessionMismatch, errorText, evalResultWarning, evalStdinHint, exactSensitiveValues: prepared.exactSensitiveValues, executionPlan: prepared.executionPlan, fillVerificationDiagnostic, headedLaunch: prepared.headedLaunch, inspectionText, preserveAttachedBrowserSession: input.preserveAttachedBrowserSession === true, providerLaunch: prepared.providerLaunch, managedSessionHeadedAutosaveDisabled: resultHeadedManagedAutosaveDisabled || undefined, managedSessionHeadedAutosaveInterval: resultHeadedManagedAutosaveInterval, managedSessionOutcome, managedSessionRestoreDisabled: state.managedSessionRestoreState.isDisabled(prepared.executionPlan.sessionName, prepared.executionPlan.namespace), navigationSummary, networkSourceLookup, noActivePageSnapshotFailure: finalRecoveryState.noActivePageSnapshotFailure, openResultTabCorrection, overlayBlockerDiagnostic, parseError, parseFailureOutput, parseSucceeded, plainTextInspection, presentation, presentationEnvelope, priorSessionTabTarget: prepared.priorSessionTabTarget, processResult, qaAttachedTarget, qaPreset, recordingDependencyWarning, redactedArgs: prepared.redactedArgs, redactedCompiledElectron: prepared.redactedCompiledElectron, redactedCompiledJob: prepared.redactedCompiledJob, redactedCompiledNetworkSourceLookup: prepared.redactedCompiledNetworkSourceLookup, redactedCompiledQaPreset: prepared.redactedCompiledQaPreset, redactedCompiledSemanticAction: prepared.redactedCompiledSemanticAction, redactedCompiledSourceLookup: prepared.redactedCompiledSourceLookup, redactedContent, redactedProcessArgs: prepared.redactedProcessArgs, redactedRecoveryHint: prepared.redactedRecoveryHint, resultArtifactManifest, richInputRecoveryDiagnostic: finalRecoveryState.richInputRecoveryDiagnostic, scrollNoopDiagnostic, selectorTextVisibilityDiagnostics, sessionMode: prepared.sessionMode, sessionTabCorrection, sourceLookup, succeeded, timeoutPartialProgress, unsettledWebMcpMutation, userRequestedJson: prepared.userRequestedJson, visibleRefFallbackDiagnostic: finalRecoveryState.visibleRefFallbackDiagnostic, visibleRefFallbackSessionName: finalRecoveryState.visibleRefFallbackSessionName });
+        const result = buildFinalAgentBrowserToolResult({ modelVisible: input.modelVisible, aboutBlankSessionMismatch, artifactCleanup, categoryDetails: finalRecoveryState.categoryDetails, clickDispatchDiagnostic, commandTokens: prepared.commandTokens, comboboxFocusDiagnostic, compiledNetworkSourceLookup: prepared.compiledNetworkSourceLookup, compiledSemanticAction: prepared.compiledSemanticAction, compatibilityWorkaround: prepared.compatibilityWorkaround, currentRefSnapshot, currentRefSnapshotInvalidation, currentSessionTabTarget, currentSessionTabTargetUnknown, electronBroadGetTextScopeDiagnostics, electronFailedConnectCleanup, electronHandoff, electronLaunch: prepared.electronLaunch, electronLaunchRecord, electronLaunchRecords, electronPostCommandHealth, electronProfileIsolationDetails: input.electronProfileIsolationDetails, electronRefFreshnessDiagnostic, electronSessionMismatch, errorText, evalResultWarning, evalStdinHint, exactSensitiveValues: prepared.exactSensitiveValues, executionPlan: prepared.executionPlan, fillVerificationDiagnostic, headedLaunch: prepared.headedLaunch, inspectionText, preserveAttachedBrowserSession: input.preserveAttachedBrowserSession === true, providerLaunch: prepared.providerLaunch, managedSessionHeadedAutosaveDisabled: !prepared.ownedManagedSessionContext?.reuseOnly && resultHeadedManagedAutosaveDisabled || undefined, managedSessionHeadedAutosaveInterval: prepared.ownedManagedSessionContext?.reuseOnly ? undefined : resultHeadedManagedAutosaveInterval, managedSessionOutcome, managedSessionRestoreDisabled: state.managedSessionRestoreState.isDisabled(prepared.executionPlan.sessionName, prepared.executionPlan.namespace), navigationSummary, networkSourceLookup, noActivePageSnapshotFailure: finalRecoveryState.noActivePageSnapshotFailure, openResultTabCorrection, overlayBlockerDiagnostic, parseError, parseFailureOutput, parseSucceeded, plainTextInspection, presentation, presentationEnvelope, priorSessionTabTarget: prepared.priorSessionTabTarget, processResult, qaAttachedTarget, qaPreset, recordingDependencyWarning, redactedArgs: prepared.redactedArgs, redactedCompiledElectron: prepared.redactedCompiledElectron, redactedCompiledJob: prepared.redactedCompiledJob, redactedCompiledNetworkSourceLookup: prepared.redactedCompiledNetworkSourceLookup, redactedCompiledQaPreset: prepared.redactedCompiledQaPreset, redactedCompiledSemanticAction: prepared.redactedCompiledSemanticAction, redactedCompiledSourceLookup: prepared.redactedCompiledSourceLookup, redactedContent, redactedProcessArgs: prepared.redactedProcessArgs, redactedRecoveryHint: prepared.redactedRecoveryHint, resultArtifactManifest, richInputRecoveryDiagnostic: finalRecoveryState.richInputRecoveryDiagnostic, scrollNoopDiagnostic, selectorTextVisibilityDiagnostics, sessionMode: prepared.sessionMode, sessionTabCorrection, sourceLookup, succeeded, timeoutPartialProgress, unsettledWebMcpMutation, userRequestedJson: prepared.userRequestedJson, visibleRefFallbackDiagnostic: finalRecoveryState.visibleRefFallbackDiagnostic, visibleRefFallbackSessionName: finalRecoveryState.visibleRefFallbackSessionName });
         const resultWithCloseAll = closeAllApplied
             ? { ...result, details: { ...(isRecord(result.details) ? result.details : {}), closeAllApplied: true } }
             : result;

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

@@ -603,7 +603,7 @@ export async function cleanupTrackedElectronHostLaunches(options) {
         const sessionKey = getSessionPageStateKey(record.sessionName, record.namespace) ?? record.sessionName;
         const managedSessionOwner = sessionKey ? options.ownedManagedSessions.get(sessionKey) : undefined;
         const managedSessionCloseError = record.sessionName
-            ? await closeManagedSession({ cwd: options.cwd, headedManagedAutosaveInterval: managedSessionOwner?.headedManagedAutosaveInterval, namespace: record.namespace, preserveAttachedBrowserSession: options.attachedSessionKeys.has(sessionKey ?? record.sessionName), restoreState: options.managedSessionRestoreState, sessionName: record.sessionName, timeoutMs: options.timeoutMs })
+            ? await closeManagedSession({ cwd: options.cwd, headedManagedAutosaveInterval: managedSessionOwner?.headedManagedAutosaveInterval, namespace: record.namespace, preserveAttachedBrowserSession: options.attachedSessionKeys.has(sessionKey ?? record.sessionName), restoreState: options.managedSessionRestoreState, sessionName: record.sessionName, socketDir: managedSessionOwner?.socketDir, timeoutMs: options.timeoutMs })
             : undefined;
         const managedSessionStep = record.sessionName
             ? managedSessionCloseError