pi-agent-browser-native 0.6.17 → 0.7.0

package/dist/extensions/agent-browser/lib/input-modes/script.js

@@ -1,15 +1,13 @@
 import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseArgvDescriptor } from "../argv-descriptor.js";
-import { getFlagName } from "../argv-grammar.js";
-import { isBrowserIndependentRead, needsManagedSession } from "../command-policy.js";
-import { isCloseCommand } from "../command-taxonomy.js";
-import { LAUNCH_SCOPED_FLAGS, MANAGED_RESTORE_INCOMPATIBLE_FLAGS } from "../launch-scoped-flags.js";
 import { isRecord } from "../parsing.js";
-import { validateToolArgs } from "../runtime.js";
+import { extractExplicitNamespace, extractExplicitSessionName, scanUpstreamGlobalFlagOccurrences } from "../argv-grammar.js";
+import { getUpstreamEffectiveBatchSteps } from "../orchestration/batch-stdin.js";
+import { extractUpstreamCommandTokens } from "../argv-descriptor.js";
+import { isCloseAllCommand } from "../command-taxonomy.js";
+import { redactSensitiveText, validateToolArgs } from "../runtime.js";
 export const AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES = 64 * 1_024;
 export const AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS = 120_000;
 export const AGENT_BROWSER_SCRIPT_NAMESPACE = "";
@@ -18,7 +16,6 @@ export const AGENT_BROWSER_SCRIPT_MAX_CALLS = 25;
 export const AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES = 64 * 1_024;
 export const AGENT_BROWSER_SCRIPT_IPC_MESSAGE_MAX_BYTES = 1 * 1_024 * 1_024;
 export const AGENT_BROWSER_SCRIPT_IPC_CUMULATIVE_MAX_BYTES = 8 * 1_024 * 1_024;
-export const AGENT_BROWSER_SCRIPT_SPILL_MAX_BYTES = 512 * 1_024;
 function findPackageRoot(startDir) {
     let currentDir = startDir;
     for (;;) {
@@ -37,25 +34,13 @@ function resolveScriptWorkerPath() {
     return workerPath;
 }
 const SCRIPT_SESSION_NAME_PATTERN = /^piab-script-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-const SCRIPT_ALLOWED_LAUNCH_FLAG = "--allowed-domains";
-const SCRIPT_FORBIDDEN_COMMANDS = new Set(["attach", "auth", "batch", "connect", "script", "session", "state"]);
-const SCRIPT_FORBIDDEN_FLAGS = new Set([
-    ...LAUNCH_SCOPED_FLAGS.filter((flag) => flag !== SCRIPT_ALLOWED_LAUNCH_FLAG),
-    ...MANAGED_RESTORE_INCOMPATIBLE_FLAGS.filter((flag) => flag !== SCRIPT_ALLOWED_LAUNCH_FLAG),
-    "--namespace",
-    "--session",
-    "--config",
-]);
-export function compileAgentBrowserScript(input) {
+export function validateAgentBrowserScriptSource(input) {
     if (typeof input !== "string")
         return { error: "script must be a string." };
     const bytes = Buffer.byteLength(input, "utf8");
     return bytes > AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES
         ? { error: `script must be ${AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES} bytes or less.` }
-        : { compiled: { code: input } };
-}
-export function createAgentBrowserScriptSessionName() {
-    return `piab-script-${randomUUID()}`;
+        : {};
 }
 export function createAgentBrowserScriptCloseArgs(sessionName) {
     return ["--namespace", AGENT_BROWSER_SCRIPT_NAMESPACE, "--session", sessionName, "close"];
@@ -63,25 +48,6 @@ export function createAgentBrowserScriptCloseArgs(sessionName) {
 export function isAgentBrowserScriptSessionName(value) {
     return typeof value === "string" && SCRIPT_SESSION_NAME_PATTERN.test(value);
 }
-function getScriptCallPolicyError(args) {
-    const descriptor = parseArgvDescriptor(args);
-    const command = descriptor.commandInfo.command;
-    if (!command)
-        return "script browser call args must contain an agent-browser command.";
-    if (isCloseCommand(command))
-        return "script browser calls cannot close, quit, or exit their isolated session.";
-    if (SCRIPT_FORBIDDEN_COMMANDS.has(command))
-        return `script browser calls cannot use ${command}.`;
-    if (!needsManagedSession(descriptor) && !isBrowserIndependentRead(descriptor.upstreamCommandTokens))
-        return `script browser calls cannot use sessionless/local command ${command}.`;
-    for (const token of args) {
-        const flag = getFlagName(token);
-        if (SCRIPT_FORBIDDEN_FLAGS.has(flag)) {
-            return `script browser calls cannot use ${flag}; the parent owns the isolated session identity and launch policy.`;
-        }
-    }
-    return undefined;
-}
 export function validateAgentBrowserScriptBrowserParams(input) {
     if (!isRecord(input))
         return { error: "script browser(params) requires an object." };
@@ -102,53 +68,51 @@ export function validateAgentBrowserScriptBrowserParams(input) {
         stdin: input.stdin,
         timeoutMs: input.timeoutMs,
     };
-    const policyError = getScriptCallPolicyError(params.args);
-    if (policyError)
-        return { error: policyError, policyBlocked: true };
     const validationError = validateToolArgs(params.args);
     return validationError ? { error: validationError } : { params };
 }
-function buildRejectedCallEnvelope(error, policyBlocked) {
+export function bindBrowserCodeCall(params, identity) {
+    const explicitSession = extractExplicitSessionName(params.args);
+    const namespaceFlags = scanUpstreamGlobalFlagOccurrences(params.args, "--namespace");
+    const explicitNamespace = extractExplicitNamespace(params.args);
+    if ((explicitSession !== undefined && explicitSession !== identity.sessionName)
+        || (namespaceFlags.length > 0 && (explicitNamespace || undefined) !== (identity.namespace || undefined))) {
+        throw new Error("A code call uses one browser identity. Set session/namespace on agent_browser_code to choose another browser.");
+    }
+    const tokens = extractUpstreamCommandTokens(params.args);
+    if (isCloseAllCommand(tokens) || getUpstreamEffectiveBatchSteps(tokens, params.stdin).some(isCloseAllCommand)) {
+        throw new Error("Run namespace-wide close --all directly with agent_browser, outside a session-scoped code call.");
+    }
+    return { ...params, args: [
+            ...(namespaceFlags.length === 0 ? ["--namespace", identity.namespace ?? ""] : []),
+            ...(explicitSession === undefined ? ["--session", identity.sessionName] : []),
+            ...params.args,
+        ] };
+}
+function buildRejectedCallEnvelope(error) {
     return {
         data: null,
-        details: { failureCategory: policyBlocked ? "policy-blocked" : "validation-error", resultCategory: "failure" },
         error,
-        failureCategory: policyBlocked ? "policy-blocked" : "validation-error",
-        ok: false,
+        failureCategory: "validation-error",
+        success: false,
         resultCategory: "failure",
         summary: error,
-        text: error,
     };
 }
 function normalizeBrowserEnvelope(value) {
-    if (!isRecord(value)
-        || typeof value.ok !== "boolean"
-        || typeof value.text !== "string"
-        || typeof value.summary !== "string"
-        || (value.resultCategory !== "success" && value.resultCategory !== "failure")) {
-        return buildRejectedCallEnvelope("The ordinary agent_browser executor returned an invalid script envelope.", false);
+    if (!isRecord(value) || typeof value.success !== "boolean" || (value.resultCategory !== "success" && value.resultCategory !== "failure")) {
+        return buildRejectedCallEnvelope("The browser executor returned an invalid code observation.");
     }
-    return {
-        data: value.data ?? null,
-        details: isRecord(value.details) ? value.details : undefined,
-        error: typeof value.error === "string" ? value.error : undefined,
-        failureCategory: value.failureCategory,
-        nextActions: Array.isArray(value.nextActions) ? value.nextActions : undefined,
-        ok: value.ok,
-        resultCategory: value.resultCategory,
-        successCategory: value.successCategory,
-        summary: value.summary,
-        text: value.text,
-    };
+    return value;
 }
 function buildStepSummary(index, envelope) {
     return {
         failureCategory: envelope.failureCategory,
         index,
-        ok: envelope.ok,
+        ok: envelope.success,
         resultCategory: envelope.resultCategory,
         successCategory: envelope.successCategory,
-        summary: envelope.summary,
+        summary: envelope.summary ?? (typeof envelope.error === "string" ? envelope.error : "Browser call completed."),
     };
 }
 function buildFailedRun(options) {
@@ -168,7 +132,7 @@ function isScriptChildMessage(value) {
         return true;
     if (value.type === "call")
         return typeof value.id === "number" && Number.isSafeInteger(value.id) && value.id > 0;
-    if (value.type === "emit")
+    if (value.type === "emit" || value.type === "image")
         return true;
     return value.type === "complete";
 }
@@ -206,7 +170,7 @@ function serializeFinalOutput(value) {
     return JSON.stringify(value);
 }
 export async function runAgentBrowserScript(options) {
-    const compiled = compileAgentBrowserScript(options.code);
+    const compiled = validateAgentBrowserScriptSource(options.code);
     if (compiled.error) {
         return buildFailedRun({ callCount: 0, emitCount: 0, error: compiled.error, failureCategory: "validation-error", rejectedCallCount: 0, steps: [] });
     }
@@ -241,12 +205,12 @@ export async function runAgentBrowserScript(options) {
     let cumulativeBytes = 0;
     let callCount = 0;
     let rejectedCallCount = 0;
-    let leaseStarted = false;
     let ready = false;
     let stopping = false;
     let activeCallController;
     const emissions = [];
     const steps = [];
+    const failures = [];
     const messages = [];
     let draining = false;
     let drainPromise = Promise.resolve();
@@ -275,10 +239,11 @@ export async function runAgentBrowserScript(options) {
         if (timeout)
             clearTimeout(timeout);
         options.signal?.removeEventListener("abort", abortListener);
-        activeCallController?.abort();
+        activeCallController?.abort(result.timedOut ? new DOMException("Browser code deadline exceeded.", "TimeoutError") : options.signal?.reason);
         killTimer = terminateChild(child);
+        // The caller holds the browser lease until dispatch actually settles.
         if (waitForDrain)
-            await settleWithin(drainPromise, 5_000);
+            await drainPromise.catch(() => undefined);
         await settleWithin(childExit, 1_000);
         clearTimeout(killTimer);
         resolveResult(result);
@@ -287,13 +252,16 @@ export async function runAgentBrowserScript(options) {
         ...flags,
         callCount,
         emitCount: emissions.length,
+        ...(emissions.length ? { data: emissions.length === 1 ? emissions[0] : emissions } : {}),
         error,
         failureCategory,
+        failures,
         rejectedCallCount,
         steps,
     }), waitForDrain);
     const abortListener = () => {
-        void fail("Script execution was aborted.", "aborted", { aborted: true }, true);
+        const timedOut = options.signal?.reason instanceof Error && options.signal.reason.name === "TimeoutError";
+        void fail(timedOut ? "Browser code deadline exceeded." : "Browser code was aborted.", timedOut ? "timeout" : "aborted", timedOut ? { timedOut: true } : { aborted: true }, true);
     };
     options.signal?.addEventListener("abort", abortListener, { once: true });
     timeout = setTimeout(() => {
@@ -333,6 +301,18 @@ export async function runAgentBrowserScript(options) {
                     emissions.push(message.value);
                     continue;
                 }
+                if (message.type === "image") {
+                    try {
+                        if (!options.emitImage)
+                            throw new Error("Image emission is unavailable.");
+                        await options.emitImage(message.value);
+                    }
+                    catch (error) {
+                        await fail(error instanceof Error ? error.message : "Invalid image handle.", "validation-error");
+                        return;
+                    }
+                    continue;
+                }
                 if (message.type === "complete") {
                     if (message.error) {
                         await fail(describeScriptError(message.error), "script-error");
@@ -353,7 +333,7 @@ export async function runAgentBrowserScript(options) {
                         await fail(`Final script output exceeds ${AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES} bytes.`, "validation-error");
                         return;
                     }
-                    await finish({ callCount, data, emitCount: emissions.length, ok: true, rejectedCallCount, steps }, false);
+                    await finish({ callCount, data, emitCount: emissions.length, failures, ok: true, rejectedCallCount, steps }, false);
                     return;
                 }
                 callCount += 1;
@@ -365,38 +345,30 @@ export async function runAgentBrowserScript(options) {
                 let envelope;
                 if (!validated.params) {
                     rejectedCallCount += 1;
-                    envelope = buildRejectedCallEnvelope(validated.error ?? "Invalid script browser call.", validated.policyBlocked === true);
+                    envelope = buildRejectedCallEnvelope(validated.error ?? "Invalid script browser call.");
                 }
                 else {
-                    if (!leaseStarted) {
-                        try {
-                            options.beforeFirstCall?.();
-                            leaseStarted = true;
-                        }
-                        catch {
-                            await fail("Unable to persist the isolated script session lease.", "upstream-error");
-                            return;
-                        }
-                    }
                     activeCallController = new AbortController();
                     try {
                         envelope = normalizeBrowserEnvelope(await options.dispatch(validated.params, activeCallController.signal));
                     }
-                    catch {
-                        envelope = buildRejectedCallEnvelope("The ordinary agent_browser executor failed while dispatching this call.", false);
+                    catch (error) {
+                        envelope = buildRejectedCallEnvelope(redactSensitiveText(error instanceof Error ? error.message : "The browser executor failed while dispatching this call."));
                     }
                     finally {
                         activeCallController = undefined;
                     }
-                    if (stopping)
-                        return;
                 }
                 steps.push(buildStepSummary(callCount - 1, envelope));
+                if (!envelope.success)
+                    failures.push({ ...envelope, index: callCount - 1 });
+                if (stopping)
+                    return;
                 try {
                     await sendParentMessage({ envelope, id: message.id, type: "response" });
                 }
                 catch {
-                    await fail("Unable to return a browser result to the script sandbox.", "upstream-error");
+                    await fail("Unable to return a browser result within the code IPC limit. Narrow the native extraction or use agent_browser with outputPath; already-dispatched effects are not rolled back.", "upstream-error");
                     return;
                 }
             }

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

@@ -1,12 +1,14 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
-import { lstat, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+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";
-import { canonicalizeAgentBrowserNamespace, getAgentBrowserSessionIdentityKey } from "./argv-grammar.js";
+import { canonicalizeAgentBrowserNamespace, foldAgentBrowserFilesystemIdentity } from "./argv-grammar.js";
+import { getAgentBrowserSocketDirValidationError, resolveAgentBrowserSocketDir } from "./process.js";
 import { processStartIdentitiesMatch, readProcessStartIdentity } from "./process-identity.js";
 const POLICY_LOCK_WAIT_MS = 1_000;
 const POLICY_LOCK_RETRY_MS = 10;
-const POLICY_LOCK_MAX_BYTES = 4_096;
+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";
 function getCoordinationDirectory(platform = process.platform) {
@@ -43,19 +45,133 @@ async function ensureCoordinationDirectory(path, platform) {
         return false;
     }
 }
-function getPolicyLockDigest(sessionName, namespace) {
-    const identity = getAgentBrowserSessionIdentityKey(sessionName, canonicalizeAgentBrowserNamespace(namespace));
-    return createHash("sha256").update(identity).digest("hex");
+export async function resolveBrowserExecutionIdentity(options) {
+    const socketDir = resolveAgentBrowserSocketDir(options);
+    const namespace = canonicalizeAgentBrowserNamespace(options.namespace);
+    let socketContext;
+    if (process.platform === "win32") {
+        // Native Windows can reach the same namespace/session TCP daemon from
+        // different storage roots. Do not split those callers into separate locks.
+        socketContext = `win32-native:${namespace ?? ""}`;
+    }
+    else {
+        if (socketDir === undefined)
+            throw new Error("Browser execution coordination requires the native socket directory.");
+        const error = await getAgentBrowserSocketDirValidationError(socketDir);
+        if (error)
+            throw new Error(`Browser execution coordination cannot use socket storage: ${error}.`);
+        const root = await realpath(socketDir);
+        socketContext = namespace ? join(root, "namespaces", namespace, "run") : root;
+    }
+    return {
+        socketContext: foldAgentBrowserFilesystemIdentity(socketContext, process.platform),
+        ...(options.sessionName !== undefined ? { sessionName: foldAgentBrowserFilesystemIdentity(options.sessionName, process.platform) } : {}),
+    };
+}
+export function getBrowserExecutionLockPath(identity) {
+    const digest = createHash("sha256").update(identity.socketContext).digest("hex");
+    return join(getCoordinationDirectory(), `.pi-agent-browser-policy-${digest}.lock-v4`);
+}
+function groupExecutionIdentities(identities) {
+    if (identities.length === 0)
+        throw new Error("Browser execution coordination requires at least one identity.");
+    const groups = new Map();
+    for (const { socketContext, sessionName } of identities) {
+        if (sessionName === undefined)
+            groups.set(socketContext, null);
+        else if (groups.get(socketContext) !== null) {
+            const sessions = groups.get(socketContext) ?? new Set();
+            sessions.add(sessionName);
+            groups.set(socketContext, sessions);
+        }
+    }
+    return [...groups.keys()].sort().map(socketContext => {
+        const sessions = groups.get(socketContext);
+        return { socketContext, sessionNames: sessions ? [...sessions].sort() : null };
+    });
+}
+const executionScope = new AsyncLocalStorage();
+function scopeCovers(outer, inner) {
+    return inner.every(identity => outer.some(held => held.socketContext === identity.socketContext
+        && (held.sessionNames === null || identity.sessionNames !== null && identity.sessionNames.every(session => held.sessionNames.includes(session)))));
+}
+/**
+ * Hold across every helper and action (or a complete code cell), not each CLI call.
+ * Nested siblings are serialized; recursive inner calls and managed policy checks borrow
+ * the claims. Declare every old/new identity up front for replacement or multi-browser cleanup;
+ * omit sessionName for close --all. Upgrading mid-operation would allow a lock-order cycle.
+ * Sessions sharing a socket context use ONE set-valued claim: acquiring them separately
+ * could deadlock against a namespace-wide claimant between the first and second session.
+ * Cancellation never releases a still-running callback. The callback must pass its signal
+ * to subprocesses and await their termination; finally drains started children before release.
+ */
+export async function withBrowserExecutionLocks(options, run) {
+    if (!Number.isFinite(options.deadline))
+        throw new Error("Browser execution coordination requires a finite deadline.");
+    const identities = groupExecutionIdentities(options.identities);
+    const parent = executionScope.getStore();
+    if (parent && !parent.active)
+        throw new Error("Browser execution scope has already finished.");
+    if (parent && !scopeCovers(parent.identities, identities))
+        throw new Error("Cannot change or upgrade browser identity inside an execution lock; acquire every required identity before starting.");
+    const controller = new AbortController();
+    const signals = [controller.signal, options.signal, parent?.signal].filter((signal) => signal !== undefined);
+    const signal = AbortSignal.any(signals);
+    const expire = () => controller.abort(new DOMException("Browser execution deadline exceeded.", "TimeoutError"));
+    const remaining = options.deadline - Date.now();
+    const timer = setTimeout(expire, Math.max(0, Math.min(remaining, 2_147_483_647)));
+    const checkBudget = () => {
+        if (Date.now() >= options.deadline)
+            expire();
+        signal.throwIfAborted();
+    };
+    const locks = [];
+    try {
+        checkBudget();
+        if (!parent) {
+            for (const identity of identities) {
+                const lock = await acquireExecutionClaim({ identity, deadline: options.deadline, signal });
+                if (lock)
+                    locks.push(lock);
+                checkBudget();
+                if (!lock)
+                    throw new Error("Browser execution coordination is unavailable or busy; no browser command was run.");
+            }
+        }
+        const execute = async () => {
+            checkBudget();
+            if (options.waitOnly)
+                clearTimeout(timer);
+            const scope = { identities: parent?.identities ?? identities, active: true, signal, children: Promise.resolve() };
+            try {
+                return await executionScope.run(scope, () => run(signal));
+            }
+            finally {
+                scope.active = false;
+                await scope.children;
+            }
+        };
+        if (!parent)
+            return await execute();
+        const result = parent.children.then(execute);
+        parent.children = result.then(() => undefined, () => undefined);
+        return await result;
+    }
+    finally {
+        clearTimeout(timer);
+        await Promise.all(locks.reverse().map(lock => lock.release()));
+    }
 }
-export function getManagedSessionPolicyLockPath(sessionName, namespace) {
-    return join(getCoordinationDirectory(), `.pi-agent-browser-policy-${getPolicyLockDigest(sessionName, namespace)}.lock-v3`);
+export function withBrowserExecutionLock(options, run) {
+    return withBrowserExecutionLocks({ identities: [options.identity], signal: options.signal, deadline: options.deadline, waitOnly: options.waitOnly }, run);
 }
 function parseOwner(content) {
     if (Buffer.byteLength(content) > POLICY_LOCK_MAX_BYTES)
         return undefined;
     try {
         const parsed = JSON.parse(content);
-        return parsed.version === 3
+        return parsed.version === 4
+            && (parsed.sessionNames === null || Array.isArray(parsed.sessionNames) && parsed.sessionNames.length > 0 && parsed.sessionNames.every(session => typeof session === "string"))
             && Number.isSafeInteger(parsed.pid) && (parsed.pid ?? 0) > 0
             && typeof parsed.startIdentity === "string" && parsed.startIdentity.length > 0
             && typeof parsed.token === "string" && parsed.token.length > 0
@@ -71,7 +187,7 @@ function parseTicket(content, token) {
         return undefined;
     try {
         const parsed = JSON.parse(content);
-        return parsed.version === 3
+        return parsed.version === 4
             && parsed.token === token
             && Number.isSafeInteger(parsed.ticket)
             && (parsed.ticket ?? 0) > 0
@@ -150,7 +266,7 @@ async function readClaims(basePath) {
     }
     return claims;
 }
-async function ownerAlive(owner) {
+async function ownerAlive(owner, budget) {
     try {
         process.kill(owner.pid, 0);
     }
@@ -161,7 +277,7 @@ async function ownerAlive(owner) {
         if (code !== "EPERM")
             return undefined;
     }
-    const current = await readProcessStartIdentity(owner.pid);
+    const current = await readProcessStartIdentity(owner.pid, process.platform, budget);
     return current === undefined ? undefined : processStartIdentitiesMatch(owner.startIdentity, current);
 }
 async function removeClaimOwnedBy(path, token, deadline = 0) {
@@ -199,7 +315,7 @@ async function removeClaimOwnedBy(path, token, deadline = 0) {
     await rm(movedPath, { force: true, recursive: true });
     return true;
 }
-async function cleanDeadPolicyArtifacts(directory) {
+async function cleanDeadPolicyArtifacts(directory, budget) {
     let names;
     try {
         names = await readdir(directory);
@@ -208,10 +324,12 @@ async function cleanDeadPolicyArtifacts(directory) {
         return;
     }
     for (const name of names.filter((candidate) => candidate.startsWith(".pi-agent-browser-policy-remove-")
-        || candidate.includes(".lock-v3.candidate-"))) {
+        || candidate.includes(".lock-v4.candidate-"))) {
+        if (budget.signal?.aborted || Date.now() >= (budget.deadline ?? Infinity))
+            return;
         const path = join(directory, name);
         const claim = await readClaim(path);
-        if (claim && await ownerAlive(claim.owner) === false)
+        if (claim && await ownerAlive(claim.owner, budget) === false)
             await rm(path, { force: true, recursive: true }).catch(() => undefined);
     }
 }
@@ -244,23 +362,48 @@ function waitForRetry(signal) {
 export async function acquireManagedSessionPolicyLock(options) {
     if (options.signal?.aborted)
         return undefined;
+    let identity;
+    try {
+        identity = await resolveBrowserExecutionIdentity({ ...options, ownedManagedSession: true });
+    }
+    catch {
+        return undefined;
+    }
+    const scope = executionScope.getStore();
+    if (scope) {
+        if (!scope.active || !scopeCovers(scope.identities, groupExecutionIdentities([identity])))
+            return undefined;
+        return { release: async () => undefined };
+    }
+    return acquireExecutionClaim({ identity: groupExecutionIdentities([identity])[0], signal: options.signal, timeoutMs: options.timeoutMs });
+}
+async function acquireExecutionClaim(options) {
+    if (options.signal?.aborted)
+        return undefined;
+    const deadline = options.deadline ?? Date.now() + (options.timeoutMs ?? POLICY_LOCK_WAIT_MS);
+    // timeoutMs: 0 retains the existing single-attempt policy probe contract.
+    const budget = { signal: options.signal, deadline: options.timeoutMs === 0 ? undefined : deadline };
     const platform = process.platform;
     const directory = getCoordinationDirectory(platform);
     if (!await ensureCoordinationDirectory(directory, platform))
         return undefined;
-    const basePath = getManagedSessionPolicyLockPath(options.sessionName, options.namespace);
+    const basePath = getBrowserExecutionLockPath(options.identity);
     const token = randomUUID();
-    const startIdentity = await readProcessStartIdentity(process.pid);
+    const startIdentity = await readProcessStartIdentity(process.pid, process.platform, budget);
     if (!startIdentity)
         return undefined;
-    const owner = { pid: process.pid, startIdentity, token, version: 3 };
+    const owner = { pid: process.pid, startIdentity, token, sessionNames: options.identity.sessionNames, version: 4 };
+    const ownerContent = JSON.stringify(owner);
+    // Never publish metadata our reader cannot validate and ownership-safely remove.
+    if (Buffer.byteLength(ownerContent) > POLICY_LOCK_MAX_BYTES)
+        return undefined;
     const candidatePath = `${basePath}.candidate-${token}`;
     const claimPath = `${basePath}.claim-${token}`;
     let claimPublished = false;
     let lockAcquired = false;
     try {
         await mkdir(candidatePath, { mode: 0o700 });
-        await writeFile(join(candidatePath, LOCK_OWNER_FILE), JSON.stringify(owner), { encoding: "utf8", flag: "wx", mode: 0o600 });
+        await writeFile(join(candidatePath, LOCK_OWNER_FILE), ownerContent, { encoding: "utf8", flag: "wx", mode: 0o600 });
         await rename(candidatePath, claimPath);
         claimPublished = true;
         const initialClaims = await readClaims(basePath);
@@ -269,11 +412,10 @@ export async function acquireManagedSessionPolicyLock(options) {
         const maxTicket = initialClaims.reduce((max, claim) => claim.ticket === null ? max : Math.max(max, claim.ticket), 0);
         if (!Number.isSafeInteger(maxTicket + 1))
             return undefined;
-        const ticket = { ticket: maxTicket + 1, token, version: 3 };
+        const ticket = { ticket: maxTicket + 1, token, version: 4 };
         const ticketCandidatePath = join(claimPath, `.ticket-${token}.tmp`);
         await writeFile(ticketCandidatePath, JSON.stringify(ticket), { encoding: "utf8", flag: "wx", mode: 0o600 });
         await rename(ticketCandidatePath, join(claimPath, LOCK_TICKET_FILE));
-        const deadline = Date.now() + (options.timeoutMs ?? POLICY_LOCK_WAIT_MS);
         while (!options.signal?.aborted) {
             const claims = await readClaims(basePath);
             if (!claims)
@@ -283,13 +425,15 @@ export async function acquireManagedSessionPolicyLock(options) {
                 return undefined;
             let blocked = false;
             for (const claim of claims) {
-                if (claim.owner.token === token || !claimPrecedes(claim, ownClaim))
+                const disjoint = owner.sessionNames !== null && claim.owner.sessionNames !== null
+                    && !owner.sessionNames.some(session => claim.owner.sessionNames.includes(session));
+                if (claim.owner.token === token || disjoint || !claimPrecedes(claim, ownClaim))
                     continue;
                 // Choosing is transient: a later published ticket must not make
                 // its predecessor wait on it using an earlier null snapshot.
                 if (await hasPublishedLaterTicket(claim, ownClaim))
                     continue;
-                const alive = await ownerAlive(claim.owner);
+                const alive = await ownerAlive(claim.owner, budget);
                 if (alive === false) {
                     await removeClaimOwnedBy(claim.path, claim.owner.token);
                     continue;
@@ -311,7 +455,9 @@ export async function acquireManagedSessionPolicyLock(options) {
                 break;
             }
             if (!blocked) {
-                await cleanDeadPolicyArtifacts(directory);
+                await cleanDeadPolicyArtifacts(directory, budget);
+                if (options.signal?.aborted || (budget.deadline !== undefined && Date.now() >= budget.deadline))
+                    return undefined;
                 lockAcquired = true;
                 return { release: async () => { await removeClaimOwnedBy(claimPath, token, Date.now() + POLICY_LOCK_WAIT_MS); } };
             }

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

@@ -432,7 +432,7 @@ export function buildSourceLookupElectronNextActions(sourceLookup) {
     if (sessionName)
         actions.push({ id: "snapshot-electron-session", params: { args: withOptionalSessionArgs(sessionName, ["snapshot", "-i"]) }, reason: "Refresh interactive refs in the attached Electron session before retrying source lookup with a narrower target.", safety: "Read-only snapshot; no app mutation.", tool: "agent_browser" });
     if (launchId)
-        actions.push({ id: "probe-electron-launch", params: { electron: { action: "probe", launchId } }, reason: "Collect bounded wrapper/session context for the packaged Electron launch after sourceLookup found no candidates.", safety: "Read-only probe of title, URL, focus, tabs, and compact snapshot metadata.", tool: "agent_browser" });
+        actions.push({ id: "probe-electron-launch", params: { action: "probe", launchId }, reason: "Collect bounded wrapper/session context for the packaged Electron launch after sourceLookup found no candidates.", safety: "Read-only probe of title, URL, focus, tabs, and compact snapshot metadata.", tool: "agent_browser_electron" });
     if (sessionName)
         actions.push({ id: "list-electron-tabs", params: { args: withOptionalSessionArgs(sessionName, ["tab", "list"]) }, reason: "Check current Electron tabs/targets before choosing a narrower selector or @ref.", safety: "Read-only tab listing.", tool: "agent_browser" });
     return actions;
@@ -901,6 +901,18 @@ function sanitizeCurrentPageUrlForTimeoutDiagnostic(url) {
         return redactSensitivePathSegmentsForDiagnostic(redactSensitiveText(url));
     }
 }
+export function redactTimeoutPartialProgress(progress) {
+    const redact = (value) => {
+        if (typeof value === "string")
+            return /^https?:\/\//i.test(value) ? sanitizeCurrentPageUrlForTimeoutDiagnostic(value) : redactSensitivePathSegmentsForDiagnostic(redactSensitiveText(value));
+        if (Array.isArray(value))
+            return value.map(redact);
+        if (isRecord(value))
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redact(item)]));
+        return value;
+    };
+    return redact(progress);
+}
 export function formatTimeoutPartialProgressText(progress, pageTargetUnknown = false) {
     const lines = [`Timeout partial progress: ${progress.summary}`];
     const currentPageTitle = progress.currentPage?.title ? redactSensitivePathSegmentsForDiagnostic(redactSensitiveText(progress.currentPage.title)) : undefined;