pi-agent-browser-native 0.6.6 → 0.6.7

package/dist/extensions/agent-browser/lib/command-taxonomy.js

@@ -143,7 +143,6 @@ const COMMAND_CAPABILITIES = [
         command: "keyboard",
         eligibleForElectronHealthProbe: true,
         eligibleForPageChangeSummary: true,
-        guardsPageRefs: true,
         invalidatesBatchRefs: true,
         triggersPostMutationSnapshot: true,
     },
@@ -157,7 +156,6 @@ const COMMAND_CAPABILITIES = [
     {
         command: "mouse",
         eligibleForElectronHealthProbe: true,
-        guardsPageRefs: true,
         invalidatesBatchRefs: true,
     },
     {
@@ -181,7 +179,6 @@ const COMMAND_CAPABILITIES = [
         command: "press",
         eligibleForElectronHealthProbe: true,
         eligibleForPageChangeSummary: true,
-        guardsPageRefs: true,
         invalidatesBatchRefs: true,
         triggersPostMutationSnapshot: true,
     },
@@ -330,8 +327,11 @@ export function isRecordPageTransitionCommand(tokens) {
 export function isWebMcpPageMutationCommand(tokens) {
     return isWebMcpPageMutation(tokens[0], tokens[1]);
 }
+export function isWindowOrDiffPageTransitionCommand(command, subcommand) {
+    return (command === "window" && subcommand === "new") || (command === "diff" && subcommand === "url");
+}
 export function isRefInvalidatingBatchCommand(step) {
-    return hasCommandCapability(step[0], "invalidatesBatchRefs") || isRecordPageTransitionCommand(step) || isWebMcpPageMutationCommand(step);
+    return hasCommandCapability(step[0], "invalidatesBatchRefs") || isRecordPageTransitionCommand(step) || isWebMcpPageMutationCommand(step) || isWindowOrDiffPageTransitionCommand(step[0], step[1]);
 }
 export function isRefGuardedCommand(command) {
     return hasCommandCapability(command, "guardsPageRefs");
@@ -343,12 +343,13 @@ function isWebMcpPageMutation(command, subcommand) {
     return command === "webmcp" && WEBMCP_PAGE_MUTATION_SUBCOMMANDS.has(subcommand ?? "");
 }
 export function isNavigationObservableCommandName(command, subcommand) {
-    return hasCommandCapability(command, "navigationObservable") || isWebMcpPageMutation(command, subcommand);
+    return hasCommandCapability(command, "navigationObservable") || isWebMcpPageMutation(command, subcommand) || isWindowOrDiffPageTransitionCommand(command, subcommand);
 }
 export function isUnverifiedPageTransitionCommand(command, subcommand) {
     return ["back", "connect", "eval", "forward", "reload"].includes(command ?? "")
         || (command === "state" && subcommand === "load")
         || (command === "tab" && subcommand !== undefined && !["list", "new"].includes(subcommand))
+        || isWindowOrDiffPageTransitionCommand(command, subcommand)
         || isWebMcpPageMutation(command, subcommand);
 }
 export function isPageMutationCommand(command, subcommand) {

package/dist/extensions/agent-browser/lib/electron/cleanup.js

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import { rm } from "node:fs/promises";
+import { lstat, rm } from "node:fs/promises";
 import { promisify } from "node:util";
 import { fetchCdpJson, parseCdpTargets, parseCdpVersion } from "./cdp.js";
 import { ELECTRON_PROFILE_DIR_PREFIX } from "./launch.js";
@@ -33,6 +33,14 @@ async function isPortAlive(port) {
 }
 export async function inspectElectronLaunchStatus(record) {
     const cdp = await isPortAlive(record.port);
+    let userDataDirState;
+    try {
+        await lstat(record.userDataDir);
+        userDataDirState = "present";
+    }
+    catch (error) {
+        userDataDirState = error.code === "ENOENT" ? "absent" : "unknown";
+    }
     return {
         cleanupState: record.cleanupState,
         launchId: record.launchId,
@@ -41,6 +49,7 @@ export async function inspectElectronLaunchStatus(record) {
         port: record.port,
         portAlive: cdp.version !== undefined,
         targets: cdp.targets,
+        userDataDirState,
         version: cdp.version,
     };
 }

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

@@ -11,7 +11,7 @@ export function createAgentBrowserParamsSchema(Type = JsonSchema, StringEnum = l
             maxLength: AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES,
         })),
         args: Type.Optional(Type.Array(Type.String(), {
-            description: "Raw agent-browser argv only: no binary, shell operators, or --json. Start with open → snapshot -i → act on current @refs; re-snapshot after page changes.",
+            description: "Raw agent-browser argv only: no binary, shell operators, or --json. Start with open → snapshot -i → act on current @refs; re-snapshot after page changes. Input: type <selector> <text>, or keyboard type <text> at current focus. Wait duration: wait <ms> (no --time). Artifacts: screenshot [selector] [path] [--full/-f]; record start <path> [url]; record restart <path> [url]; record stop. Paths are positional (no --path); use --full, not --full-page.",
             minItems: 1,
         })),
         semanticAction: Type.Optional(Type.Object({
@@ -21,10 +21,23 @@ export function createAgentBrowserParamsSchema(Type = JsonSchema, StringEnum = l
             values: Type.Optional(Type.Array(Type.String(), { description: "Select options; required for select by label.", minItems: 1 })),
             selector: Type.Optional(Type.String({ description: "Direct selector or @ref." })),
             text: Type.Optional(Type.String({ description: "Fill text." })),
-            role: Type.Optional(Type.String({ description: "Role locator; alternative to value." })),
+            role: Type.Optional(Type.String({ description: "Role for locator=role; select needs combobox or listbox." })),
             name: Type.Optional(Type.String({ description: "Accessible name." })),
             session: Type.Optional(Type.String({ description: "Upstream session name." })),
-        }, { additionalProperties: false, description: "Stable locator or direct-selector action." })),
+        }, {
+            additionalProperties: false,
+            // Pi normalizes optional nulls through properties, not union branches.
+            anyOf: [
+                Type.Object({
+                    action: StringEnum(["select"]),
+                    locator: Type.Optional(StringEnum(["role", "label"])),
+                }, { not: { required: ["text"] } }),
+                Type.Object({
+                    action: StringEnum(["check", "click", "fill"]),
+                }, { not: { required: ["values"] } }),
+            ],
+            description: "Stable locator or direct-selector action. values only with action=select.",
+        })),
         qa: Type.Optional(Type.Union([
             Type.Object({
                 attached: Type.Literal(true),
@@ -112,7 +125,7 @@ export function createAgentBrowserParamsSchema(Type = JsonSchema, StringEnum = l
                 locator: Type.Optional(StringEnum(AGENT_BROWSER_SEMANTIC_LOCATORS, { description: "Locator when selector is omitted." })),
                 role: Type.Optional(Type.String({ description: "Role locator." })),
                 name: Type.Optional(Type.String({ description: "Accessible name." })),
-                text: Type.Optional(Type.String({ description: "Fill text or assertText target." })),
+                text: Type.Optional(Type.String({ description: "Fill/type text; assertText uses only text, not selector/locator fields." })),
                 value: Type.Optional(Type.String({ description: "Select option or locator value." })),
                 values: Type.Optional(Type.Array(Type.String(), { description: "Select options.", minItems: 1 })),
                 path: Type.Optional(Type.String({ description: "Download or screenshot path." })),
@@ -120,10 +133,10 @@ export function createAgentBrowserParamsSchema(Type = JsonSchema, StringEnum = l
                 press: Type.Optional(Type.String({ description: "Key to press after typing." })),
                 milliseconds: Type.Optional(Type.Number({ description: "Wait duration in milliseconds." })),
             }, { additionalProperties: false }), { minItems: 1 }),
-        }, { additionalProperties: false, description: "Constrained multi-step batch." })),
-        stdin: Type.Optional(Type.String({ description: "Raw stdin for batch, eval --stdin, or auth save --password-stdin; unavailable with structured modes and electron." })),
+        }, { additionalProperties: false, description: "Constrained multi-step batch. Clicks can stale later refs; split and re-snapshot before using them." })),
+        stdin: Type.Optional(Type.String({ description: "For batch, a JSON array of token arrays, e.g. [[\"get\",\"title\"]]. Raw text only for eval --stdin or auth save --password-stdin; unavailable with structured modes and electron." })),
         outputPath: Type.Optional(Type.String({ description: "Workspace-relative or absolute result-data path; keep it distinct from screenshot, download, recording, and other browser artifact destinations.", minLength: 1 })),
-        timeoutMs: Type.Optional(Type.Integer({ description: "Wrapper timeout in ms; exceed explicit waits. Electron uses electron.timeoutMs.", minimum: 1 })),
+        timeoutMs: Type.Optional(Type.Integer({ description: "Wrapper timeout in ms; exceed explicit waits. electron.list has no configurable timeout; other Electron actions use electron.timeoutMs.", minimum: 1 })),
         sessionMode: Type.Optional(StringEnum(["auto", "fresh"], {
             description: "auto reuses the managed session; fresh starts one for launch-only flags, then makes it the managed session.",
             default: DEFAULT_SESSION_MODE,

package/dist/extensions/agent-browser/lib/launch-scoped-flags.js

@@ -150,7 +150,6 @@ export const MANAGED_RESTORE_INCOMPATIBLE_ENVS = [
     "AGENT_BROWSER_PROFILE",
     "AGENT_BROWSER_STATE",
     "AGENT_BROWSER_CDP",
-    "AGENT_BROWSER_NAMESPACE",
     "AGENT_BROWSER_SESSION_NAME",
     "AGENT_BROWSER_PROVIDER",
     "AGENT_BROWSER_EXECUTABLE_PATH",

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

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { extractUpstreamCommandTokens, parseCommandInfo } from "./argv-descriptor.js";
-import { canonicalizeAgentBrowserNamespace, extractExplicitNamespace, extractExplicitSessionName, extractRequestedRestoreKey, getAgentBrowserSessionIdentityKey, isUpstreamEnvFlagEnabled, scanUpstreamGlobalFlagOccurrences, } from "./argv-grammar.js";
+import { canonicalizeAgentBrowserNamespace, extractExplicitNamespace, extractExplicitSessionName, extractRequestedRestoreKey, getAgentBrowserSessionIdentityKey, isUpstreamEnvFlagEnabled, resolveAgentBrowserNamespace, scanUpstreamGlobalFlagOccurrences, } from "./argv-grammar.js";
 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";
@@ -11,7 +11,7 @@ const AGENT_BROWSER_CONFIG_ENV = "AGENT_BROWSER_CONFIG";
 const AGENT_BROWSER_RESTORE_ENV = "AGENT_BROWSER_RESTORE";
 const MANAGED_SESSION_RESTORE_ENV = "PI_AGENT_BROWSER_MANAGED_SESSION_RESTORE";
 export const MANAGED_SESSION_NAME_PREFIX = "piab-";
-const MANAGED_SESSION_RESTORE_SPAWN_PINNED_ENVS = new Set([AGENT_BROWSER_CONFIG_ENV, AGENT_BROWSER_RESTORE_ENV, "AGENT_BROWSER_NAMESPACE"]);
+const MANAGED_SESSION_RESTORE_SPAWN_PINNED_ENVS = new Set([AGENT_BROWSER_CONFIG_ENV, AGENT_BROWSER_RESTORE_ENV]);
 function isDisabledEnvFlag(value) {
     if (value === undefined)
         return false;
@@ -86,12 +86,13 @@ export function resolveOwnedManagedSessionContext(options) {
     }
     return undefined;
 }
-function ownedContextMatches(sessionName, namespace) {
+function ownedContextMatches(sessionName, args) {
     const owned = ownedManagedSessionStorage.getStore();
-    return owned && sessionName === owned.sessionName && canonicalizeAgentBrowserNamespace(namespace) === owned.namespace ? owned : undefined;
+    return owned && sessionName === owned.sessionName
+        && canonicalizeAgentBrowserNamespace(resolveAgentBrowserNamespace(args, owned.namespace)) === owned.namespace ? owned : undefined;
 }
 export function isOwnedManagedSessionTarget(args) {
-    return ownedContextMatches(extractExplicitSessionName(args), extractExplicitNamespace(args)) !== undefined;
+    return ownedContextMatches(extractExplicitSessionName(args), args) !== undefined;
 }
 function hasExplicitConfigArg(args) {
     return scanUpstreamGlobalFlagOccurrences(args, "--config").length > 0;
@@ -141,7 +142,7 @@ function managedSessionRestoreOptedOut(options) {
     const effectiveEnv = { ...(options.parentEnv ?? getAgentBrowserProcessEnvironment()), ...options.env };
     return isDisabledEnvFlag(effectiveEnv[MANAGED_SESSION_RESTORE_ENV]);
 }
-function isManagedSessionRestoreIncompatible(options) {
+function isManagedSessionRestoreIncompatible(options, namespace = extractExplicitNamespace(options.args)) {
     if (hasManagedSessionRestoreLaunchConflict(options))
         return true;
     if (managedSessionRestoreOptedOut(options))
@@ -152,13 +153,13 @@ function isManagedSessionRestoreIncompatible(options) {
         return true;
     if (options.cwd && agentBrowserConfigBlocksManagedRestore(options.cwd, effectiveEnv, args))
         return true;
-    return !ensureManagedSessionRestoreStorageIsSecure(effectiveEnv, process.platform, extractExplicitNamespace(args));
+    return !ensureManagedSessionRestoreStorageIsSecure(effectiveEnv, process.platform, namespace);
 }
 function resolveManagedSessionRestorePolicy(options) {
     const parentEnv = options.parentEnv ?? getAgentBrowserProcessEnvironment();
     const sessionName = extractExplicitSessionName(options.args);
-    const namespace = extractExplicitNamespace(options.args);
-    const ownedContext = ownedContextMatches(sessionName, namespace);
+    const ownedContext = ownedContextMatches(sessionName, options.args);
+    const namespace = ownedContext ? ownedContext.namespace : extractExplicitNamespace(options.args);
     const restoreState = ownedContext?.restoreState ?? options.restoreState;
     const owned = (options.ownedManagedSession || ownedContext !== undefined) && restoreState !== undefined;
     return { namespace, owned, ownedContext, parentEnv, restoreState, sessionName };
@@ -234,7 +235,7 @@ export function getManagedSessionRestoreEnv(options) {
         return { [AGENT_BROWSER_RESTORE_ENV]: ownedContext.restoreKey };
     }
     const policyOptions = { ...options, parentEnv };
-    if (managedSessionRestoreOptedOut(policyOptions) || ownedContext?.restoreSuppressed || isManagedSessionRestoreIncompatible(policyOptions))
+    if (managedSessionRestoreOptedOut(policyOptions) || ownedContext?.restoreSuppressed || isManagedSessionRestoreIncompatible(policyOptions, namespace))
         return {};
     if (restoreState.isDisabled(sessionName, namespace) || !sessionName)
         return {};
@@ -263,7 +264,7 @@ export function commitManagedSessionRestoreSuppression(options) {
         return;
     }
     const policyOptions = { ...options, parentEnv };
-    if (managedSessionRestoreOptedOut(policyOptions) || ownedContext?.restoreSuppressed || isManagedSessionRestoreIncompatible(policyOptions))
+    if (managedSessionRestoreOptedOut(policyOptions) || ownedContext?.restoreSuppressed || isManagedSessionRestoreIncompatible(policyOptions, namespace))
         restoreState.disable(sessionName, namespace);
 }
 export function buildOwnedManagedSessionRestoreContext(options) {
@@ -281,7 +282,7 @@ export function buildOwnedManagedSessionRestoreContext(options) {
     };
     const optedOut = managedSessionRestoreOptedOut(policyOptions);
     const projectIdentityAvailable = !optedOut && hasManagedSessionRestoreProjectIdentity(ownedCwd);
-    const incompatible = !optedOut && isManagedSessionRestoreIncompatible(policyOptions);
+    const incompatible = !optedOut && isManagedSessionRestoreIncompatible(policyOptions, owned.namespace);
     const enabled = !optedOut && !incompatible;
     const effectiveEnv = { ...(options.parentEnv ?? getAgentBrowserProcessEnvironment()), ...options.env };
     const restoreScope = getManagedSessionRestoreScope(owned.sessionName);

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

@@ -1,45 +1,28 @@
-import { isRecord } from "../../parsing.js";
+import { isRecord, parseRefId } from "../../parsing.js";
 import { redactSensitiveText } from "../../runtime.js";
 import { withOptionalSessionArgs } from "../../results/next-actions.js";
 import { runSessionCommandData } from "./session-state.js";
 const CLICK_DISPATCH_MARKER_PREFIX = "__piAgentBrowserClickDispatchProbe_";
 const CLICK_DISPATCH_CLEANUP_TIMEOUT_MS = 2_000;
 const ACCESSIBLE_REF_CLICK_DISPATCH_ROLES = new Set(["button", "checkbox", "menuitem", "radio", "switch", "tab"]);
-function parseClickRefId(selector) {
-    const trimmed = selector.trim();
-    const candidate = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed.startsWith("ref=") ? trimmed.slice(4) : trimmed;
-    return /^e\d+$/.test(candidate) ? candidate : undefined;
-}
 function normalizeAccessibleName(name) {
     return name.replace(/\s+/g, " ").trim().toLowerCase();
 }
-function getAccessibleRefDuplicateIndex(refSnapshot, refId, role, name) {
-    if (!refSnapshot?.refs)
-        return undefined;
-    const normalizedRole = role.toLowerCase();
-    const normalizedName = normalizeAccessibleName(name);
-    const matchingRefIds = refSnapshot.refIds.filter((candidateRefId) => {
-        const candidate = refSnapshot.refs?.[candidateRefId];
-        return candidate?.role.toLowerCase() === normalizedRole && normalizeAccessibleName(candidate.name) === normalizedName;
-    });
-    if (matchingRefIds.length <= 1)
-        return undefined;
-    const duplicateIndex = matchingRefIds.indexOf(refId);
-    return duplicateIndex >= 0 ? duplicateIndex : undefined;
-}
 function getClickDispatchProbeTarget(commandTokens, refSnapshot) {
     if (commandTokens[0] !== "click" || commandTokens.includes("--new-tab"))
         return undefined;
     const selector = commandTokens[1];
     if (!selector || selector.startsWith("-"))
         return undefined;
-    const refId = parseClickRefId(selector);
+    const refId = parseRefId(selector);
     if (refId) {
         const ref = refSnapshot?.refs?.[refId];
         if (!ref || !ACCESSIBLE_REF_CLICK_DISPATCH_ROLES.has(ref.role))
             return undefined;
-        const duplicateIndex = getAccessibleRefDuplicateIndex(refSnapshot, refId, ref.role, ref.name);
-        return { ...(duplicateIndex === undefined ? {} : { duplicateIndex }), kind: "accessible", name: ref.name, refId, role: ref.role };
+        const matchingRefs = Object.values(refSnapshot?.refs ?? {}).filter((candidate) => candidate.role.toLowerCase() === ref.role.toLowerCase() && normalizeAccessibleName(candidate.name) === normalizeAccessibleName(ref.name));
+        if (matchingRefs.length !== 1)
+            return undefined;
+        return { kind: "accessible", name: ref.name, refId, role: ref.role };
     }
     if (selector.startsWith("xpath="))
         return { kind: "xpath", selector: selector.slice("xpath=".length) };
@@ -58,7 +41,6 @@ function buildClickDispatchProbeInstallScript(probe) {
   const normalize = (value) => String(value ?? "").replace(/\\s+/g, " ").trim();
   const expectedRole = ${JSON.stringify(target.role)};
   const expectedName = normalize(${JSON.stringify(target.name)});
-  const duplicateIndex = ${JSON.stringify(target.duplicateIndex)};
   const inferRole = (element) => {
     const explicit = element.getAttribute("role");
     if (explicit) return explicit;
@@ -81,7 +63,6 @@ function buildClickDispatchProbeInstallScript(probe) {
     return element.getClientRects().length > 0;
   };
   const candidates = Array.from(document.querySelectorAll("button,a[href],input,select,textarea,summary,[role],[onclick],[tabindex]")).filter((element) => inferRole(element) === expectedRole && inferName(element) === expectedName && isVisible(element));
-  if (typeof duplicateIndex === "number") return candidates[duplicateIndex] || null;
   return candidates.length === 1 ? candidates[0] : null;
 })()`;
     return `(() => {

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

@@ -54,10 +54,9 @@ export function buildSemanticActionCandidateActions(compiled) {
     return [];
 }
 export function buildWrapperRecoveryHint(options) {
-    const wrapperManagedContexts = [options.sessionTabCorrection ? "session tab correction" : undefined, options.pinnedBatchUnwrapMode ? "pinned batch routing" : undefined].filter((item) => item !== undefined);
-    if (wrapperManagedContexts.length === 0)
+    if (!options.sessionTabCorrection)
         return undefined;
-    return `Wrapper recovery hint: this call used ${wrapperManagedContexts.join(" and ")}. Inspect details.effectiveArgs and details.sessionTabCorrection; if the selected tab looks wrong, run tab list for the same session before retrying.`;
+    return "Wrapper recovery hint: this call used session tab correction. Inspect details.effectiveArgs and details.sessionTabCorrection; if the selected tab looks wrong, run tab list for the same session before retrying.";
 }
 export function redactExactSensitiveText(text, sensitiveValues) {
     let redacted = text;

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

@@ -1,14 +1,22 @@
 import { runAgentBrowserProcess, withAttachedBrowserSessionContext } from "../../process.js";
+import { isRecord } from "../../parsing.js";
 import { withOwnedManagedSessionContext } from "../../managed-session-restore.js";
 import { cleanupClickDispatchProbe } from "./click-dispatch.js";
-import { applyBrowserRunStatePatch } from "./session-state.js";
+import { applyBrowserRunStatePatch, getSessionContextKey } from "./session-state.js";
 import { buildMissingBinaryFailureResult } from "./final-result.js";
 import { prepareBrowserRun } from "./prepare.js";
 import { processBrowserOutput } from "./process-output.js";
 export { closeManagedSession } from "./managed-session-daemon-policy.js";
 export { getSessionContextKey } from "./session-state.js";
 export async function runAgentBrowserTool(options) {
-    return await withAttachedBrowserSessionContext(options.preserveAttachedBrowserSession === true, () => runAgentBrowserToolInContext(options));
+    const result = await withAttachedBrowserSessionContext(options.preserveAttachedBrowserSession === true, () => runAgentBrowserToolInContext(options));
+    const details = isRecord(result.details) ? result.details : undefined;
+    const sessionKey = getSessionContextKey(typeof details?.sessionName === "string" ? details.sessionName : undefined, typeof details?.namespace === "string" ? details.namespace : undefined);
+    const page = options.state.sessionPageState.get(sessionKey);
+    return page.tabReopenPending === undefined ? result : {
+        ...result,
+        details: { ...details, sessionTabReopenPending: page.tabReopenPending, ...(page.refSnapshotInvalidation ? { refSnapshotInvalidation: page.refSnapshotInvalidation } : {}) },
+    };
 }
 async function runAgentBrowserToolInContext(options) {
     const preparedResult = await prepareBrowserRun(options);
@@ -34,7 +42,6 @@ async function runAgentBrowserToolInContext(options) {
                 signal: options.signal,
                 stdin: prepared.processStdin,
                 timeoutMs: prepared.processTimeoutMs,
-                trustedFirstBatchTabSelection: prepared.pinnedBatchUnwrapMode !== undefined,
             });
             const missingBinaryResult = await buildMissingBinaryFailureResult({
                 compatibilityWorkaround: prepared.compatibilityWorkaround,

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

@@ -100,6 +100,9 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
             context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
         return !["inactive", "missing-binary"].includes(daemon.status) && !activePolicyMatches
             ? {
+                cleanupOnlyReason: daemon.status === "active" && restoreDisabledPolicyNeedsProvenance && !hasKnownDaemonRestoreKey
+                    ? "restore-disabled-daemon-without-provenance"
+                    : undefined,
                 daemonStatus: daemon.status,
                 error: [
                     "This wrapper-owned session's live daemon does not match the requested managed-restore policy.",

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

@@ -25,7 +25,7 @@ function findCommandTimeoutMs(commandTokens) {
     const firstWaitArgument = commandTokens[0] === "wait" ? commandTokens[1] : undefined;
     return firstWaitArgument && !firstWaitArgument.startsWith("-") ? parseMillisecondsToken(firstWaitArgument) : undefined;
 }
-function findFirstPositionalArgument(commandTokens) {
+export function findFirstPositionalArgument(commandTokens) {
     for (let index = 1; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
         const flag = token.split("=", 1)[0];