@cydm/pie 2.7.1 → 2.7.3

package/dist/builtin/skills/computer-use-axi/computer-use-axi-broker.js

@@ -12,6 +12,14 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
 var __commonJS = (cb, mod) => function __require2() {
   try {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
@@ -19,6 +27,10 @@ var __commonJS = (cb, mod) => function __require2() {
     throw mod = 0, e;
   }
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -36,6 +48,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// vendor/computer-use-axi/src/platform/coerce.ts
+function toBoolean(value) {
+  return value === true || value === "true" || value === 1;
+}
+function toFiniteNumber(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+function toOptionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+var init_coerce = __esm({
+  "vendor/computer-use-axi/src/platform/coerce.ts"() {
+  }
+});
+
 // ../../node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
   "../../node_modules/ws/lib/constants.js"(exports, module) {
@@ -3719,188 +3751,746 @@ var require_websocket_server = __commonJS({
   }
 });
 
-// vendor/computer-use-axi/src/broker-server.ts
-import { createHash as createHash3, randomUUID as randomUUID8 } from "node:crypto";
-import { chmodSync as chmodSync2, lstatSync as lstatSync4, readFileSync as readFileSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import net3 from "node:net";
-import path14 from "node:path";
-
-// vendor/computer-use-axi/src/artifact-store.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
-import { closeSync, existsSync as existsSync2, lstatSync as lstatSync3, mkdirSync as mkdirSync4, openSync, readdirSync as readdirSync2, rmdirSync, unlinkSync as unlinkSync2, writeSync } from "node:fs";
-import path3 from "node:path";
-
-// vendor/computer-use-axi/src/broker-protocol.ts
-import { createHash, randomUUID } from "node:crypto";
-import { chmodSync, lstatSync as lstatSync2, mkdirSync as mkdirSync3 } from "node:fs";
-import path2 from "node:path";
-
-// vendor/computer-use-axi/src/persist.ts
-import { lstatSync, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "node:fs";
-import path from "node:path";
-
-// src/config.ts
-import { existsSync, mkdirSync, readFileSync, renameSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var isBunRuntime = !!process.versions.bun;
-function getPackageDir() {
-  const envDir = process.env.PIE_PACKAGE_DIR;
-  if (envDir) {
-    if (envDir === "~") return homedir();
-    if (envDir.startsWith("~/")) return homedir() + envDir.slice(1);
-    return envDir;
-  }
-  let dir = __dirname;
-  while (dir !== dirname(dir)) {
-    if (existsSync(join(dir, "package.json"))) {
-      return dir;
+// vendor/computer-use-axi/src/platform/macos/helper-path.mjs
+import { accessSync, constants as fsConstants, existsSync as existsSync4 } from "node:fs";
+import os from "node:os";
+import path7 from "node:path";
+function resolveMacosHelperAppPath(options = {}) {
+  const env = options.env ?? process.env;
+  const explicitPath = env.PIE_COMPUTER_USE_HELPER_APP_PATH?.trim();
+  if (explicitPath) return path7.resolve(explicitPath);
+  const homeDir = options.homeDir ?? os.homedir();
+  const configDir = options.configDir ?? resolvePieConfigDir(env, homeDir);
+  const systemHelperAppPath = options.systemHelperAppPath ?? SYSTEM_HELPER_APP_PATH;
+  const fileExists = options.fileExists ?? existsSync4;
+  const directoryIsWritable = options.directoryIsWritable ?? ((directoryPath) => {
+    try {
+      accessSync(directoryPath, fsConstants.W_OK);
+      return true;
+    } catch {
+      return false;
     }
-    dir = dirname(dir);
+  });
+  if (fileExists(systemHelperAppPath) && directoryIsWritable(path7.dirname(systemHelperAppPath))) {
+    return systemHelperAppPath;
   }
-  return __dirname;
-}
-function getPackageJsonPath() {
-  return join(getPackageDir(), "package.json");
+  return path7.join(configDir, "computer-use", HELPER_APP_NAME);
 }
-var pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
-var CONFIG_DIR_NAME = ".pie";
-var VERSION = pkg.version;
-var ENV_AGENT_DIR = "PIE_CODING_AGENT_DIR";
-function getConfigDir() {
-  const envDir = process.env[ENV_AGENT_DIR];
+function resolvePieConfigDir(env, homeDir) {
+  const envDir = env.PIE_CODING_AGENT_DIR;
   if (envDir) {
-    if (envDir === "~") return homedir();
-    if (envDir.startsWith("~/")) return homedir() + envDir.slice(1);
+    if (envDir === "~") return homeDir;
+    if (envDir.startsWith("~/")) return homeDir + envDir.slice(1);
     return envDir;
   }
-  return join(homedir(), CONFIG_DIR_NAME);
+  return path7.join(homeDir, ".pie");
 }
+var HELPER_APP_NAME, SYSTEM_HELPER_APP_PATH;
+var init_helper_path = __esm({
+  "vendor/computer-use-axi/src/platform/macos/helper-path.mjs"() {
+    HELPER_APP_NAME = "pie-computer-use.app";
+    SYSTEM_HELPER_APP_PATH = path7.join("/Applications", HELPER_APP_NAME);
+  }
+});
 
-// vendor/computer-use-axi/src/persist.ts
-function stateRootDir(env = process.env) {
-  const override = env.PIE_COMPUTER_USE_STATE_DIR?.trim();
-  if (override) return override;
-  return path.join(getConfigDir(), "computer-use");
-}
-function statesDir(env = process.env) {
-  return path.join(stateRootDir(env), "states");
-}
-function outputsDir(env = process.env) {
-  return path.join(stateRootDir(env), "outputs");
-}
-function runtimeStatePath(env = process.env) {
-  return path.join(stateRootDir(env), "runtime.json");
-}
-function brokerStateDir(env = process.env) {
-  return path.join(stateRootDir(env), "broker");
-}
-function brokerManifestPath(env = process.env) {
-  return path.join(brokerStateDir(env), "manifest.json");
-}
-function loadBrokerManifest(env = process.env) {
-  const manifest = readJsonFile(brokerManifestPath(env));
-  if (!manifest || typeof manifest.generation !== "string") return void 0;
-  return {
-    generation: manifest.generation,
-    helperGeneration: typeof manifest.helperGeneration === "string" ? manifest.helperGeneration : "",
-    stateIds: Array.isArray(manifest.stateIds) ? manifest.stateIds.filter((id) => typeof id === "string" && /^[A-Za-z0-9-]{1,128}$/.test(id)).slice(0, 256) : [],
-    updatedAt: Number.isFinite(manifest.updatedAt) ? manifest.updatedAt : 0
-  };
-}
-function saveBrokerManifest(manifest, env = process.env) {
-  mkdirSync2(brokerStateDir(env), { recursive: true, mode: 448 });
-  writeJsonAtomic(brokerManifestPath(env), { ...manifest, stateIds: manifest.stateIds.slice(0, 256) });
-}
-function brokerDrainMarkerPath(env = process.env) {
-  return path.join(brokerStateDir(env), "draining.json");
-}
-function loadDrainMarker(env = process.env) {
-  const marker = readJsonFile(brokerDrainMarkerPath(env));
-  if (!marker || typeof marker !== "object" || !Number.isFinite(marker.pid)) return void 0;
-  return {
-    pid: Math.trunc(marker.pid),
-    startedAt: Number.isFinite(marker.startedAt) ? marker.startedAt : 0,
-    deadlineAt: Number.isFinite(marker.deadlineAt) ? marker.deadlineAt : 0
-  };
-}
-function saveDrainMarker(marker, env = process.env) {
-  mkdirSync2(brokerStateDir(env), { recursive: true, mode: 448 });
-  writeJsonAtomic(brokerDrainMarkerPath(env), marker);
-}
-function clearDrainMarker(env = process.env) {
-  try {
-    const stats = lstatSync(brokerDrainMarkerPath(env));
-    if (stats.isFile() && !stats.isSymbolicLink()) unlinkSync(brokerDrainMarkerPath(env));
-  } catch {
+// vendor/computer-use-axi/src/platform/package-root.ts
+import { existsSync as existsSync5 } from "node:fs";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function resolveExtensionRoot(moduleUrl) {
+  const override = process.env.PIE_COMPUTER_USE_PACKAGE_ROOT?.trim();
+  if (override) return path8.resolve(override);
+  let dir = path8.dirname(fileURLToPath2(moduleUrl));
+  for (let depth = 0; depth < 12; depth += 1) {
+    if (existsSync5(path8.join(dir, "scripts", "setup-helper.mjs"))) return dir;
+    const parent = path8.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
+  throw new Error(`computer-use: could not locate extension root (scripts/setup-helper.mjs) above ${path8.dirname(fileURLToPath2(moduleUrl))}. Set PIE_COMPUTER_USE_PACKAGE_ROOT.`);
 }
-function cleanupLegacyBrokerCache(env = process.env) {
-  let runtimeFile = false;
-  let states = 0;
-  let outputs2 = 0;
-  const runtime = runtimeStatePath(env);
-  try {
-    const stats = lstatSync(runtime);
-    if (stats.isFile() && !stats.isSymbolicLink()) {
-      unlinkSync(runtime);
-      runtimeFile = true;
-    }
-  } catch {
-  }
-  const statesDirPath = statesDir(env);
-  try {
-    for (const name of readdirSync(statesDirPath).slice(0, 512)) {
-      if (!/^[A-Za-z0-9-]+\.json$/.test(name)) continue;
-      const target = path.join(statesDirPath, name);
-      try {
-        const stats = lstatSync(target);
-        if (!stats.isFile() || stats.isSymbolicLink()) continue;
-        unlinkSync(target);
-        states += 1;
-      } catch {
-      }
-    }
-  } catch {
-  }
-  const oldOutputs = outputsDir(env);
-  try {
-    for (const name of readdirSync(oldOutputs).slice(0, 512)) {
-      if (!/^o\d+\.(txt|meta\.json)$/.test(name)) continue;
-      const target = path.join(oldOutputs, name);
-      try {
-        const stats = lstatSync(target);
-        if (!stats.isFile() || stats.isSymbolicLink()) continue;
-        unlinkSync(target);
-        outputs2 += 1;
-      } catch {
-      }
-    }
-  } catch {
+var init_package_root = __esm({
+  "vendor/computer-use-axi/src/platform/package-root.ts"() {
   }
-  return { runtimeFile, states, outputs: outputs2 };
+});
+
+// vendor/computer-use-axi/src/platform/macos/helper.ts
+import { spawn } from "node:child_process";
+import { constants as fsConstants2 } from "node:fs";
+import { access, mkdir, realpath } from "node:fs/promises";
+import net from "node:net";
+import os2 from "node:os";
+import path9 from "node:path";
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw new Error("Operation aborted.");
 }
-function writeJsonAtomic(filePath, value) {
-  mkdirSync2(path.dirname(filePath), { recursive: true });
-  const temp = `${filePath}.${process.pid}.tmp`;
-  writeFileSync(temp, JSON.stringify(value), "utf8");
-  renameSync2(temp, filePath);
+async function sleep(ms, signal) {
+  throwIfAborted(signal);
+  await new Promise((resolve2, reject) => {
+    const timer = setTimeout(resolve2, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("Operation aborted."));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  }).finally(() => signal?.throwIfAborted?.());
 }
-function readJsonFile(filePath) {
+async function isExecutable(filePath) {
   try {
-    return JSON.parse(readFileSync2(filePath, "utf8"));
+    await access(filePath, fsConstants2.X_OK);
+    return true;
   } catch {
-    return void 0;
+    return false;
   }
 }
-
-// src/runtime/computer-use-owner.ts
-var COMPUTER_USE_STANDALONE_OWNER = "standalone";
-var OWNER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@-]{0,255}$/;
-function normalizeComputerUseOwner(value) {
+async function isResolvedHelperExecutable(filePath) {
+  if (!filePath) return true;
+  const [actualPath, expectedPath] = await Promise.all([
+    realpath(filePath).catch(() => path9.resolve(filePath)),
+    realpath(HELPER_APP_EXECUTABLE_PATH).catch(() => path9.resolve(HELPER_APP_EXECUTABLE_PATH))
+  ]);
+  return actualPath === expectedPath;
+}
+async function runProcess(command, args, timeoutMs, signal, env) {
+  throwIfAborted(signal);
+  await new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env
+    });
+    let stderr = "";
+    let stdout = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      cleanup();
+      reject(new Error(`Command timed out after ${timeoutMs}ms: ${command} ${args.join(" ")}`));
+    }, timeoutMs);
+    const onAbort = () => {
+      child.kill("SIGTERM");
+      cleanup();
+      reject(new Error("Operation aborted."));
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      cleanup();
+      reject(error);
+    });
+    child.on("close", (code) => {
+      cleanup();
+      if (code === 0) {
+        resolve2();
+        return;
+      }
+      const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+      reject(new Error(`Command failed (${code}): ${command} ${args.join(" ")}
+${output}`.trim()));
+    });
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var COMMAND_TIMEOUT_MS2, HELPER_PROTOCOL_VERSION, HELPER_SETUP_TIMEOUT_MS, HELPER_APP_PATH, HELPER_APP_EXECUTABLE_PATH, DEFAULT_HELPER_SOCKET_PATH, HELPER_SOCKET_PATH, usingExternalHelperSocket, PACKAGE_ROOT, SETUP_HELPER_SCRIPT, HelperTransportError, HelperCommandError, MacosHelperClient, macosHelper;
+var init_helper = __esm({
+  "vendor/computer-use-axi/src/platform/macos/helper.ts"() {
+    init_coerce();
+    init_helper_path();
+    init_package_root();
+    COMMAND_TIMEOUT_MS2 = 15e3;
+    HELPER_PROTOCOL_VERSION = 6;
+    HELPER_SETUP_TIMEOUT_MS = 6e4;
+    HELPER_APP_PATH = resolveMacosHelperAppPath();
+    HELPER_APP_EXECUTABLE_PATH = path9.join(HELPER_APP_PATH, "Contents", "MacOS", "pie-computer-use");
+    DEFAULT_HELPER_SOCKET_PATH = path9.join(os2.homedir(), "Library", "Caches", "pie-computer-use", "bridge.sock");
+    HELPER_SOCKET_PATH = process.env.PIE_COMPUTER_USE_SOCKET_PATH ?? DEFAULT_HELPER_SOCKET_PATH;
+    usingExternalHelperSocket = HELPER_SOCKET_PATH !== DEFAULT_HELPER_SOCKET_PATH;
+    PACKAGE_ROOT = resolveExtensionRoot(import.meta.url);
+    SETUP_HELPER_SCRIPT = path9.join(PACKAGE_ROOT, "scripts", "setup-helper.mjs");
+    HelperTransportError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "HelperTransportError";
+      }
+    };
+    HelperCommandError = class extends Error {
+      code;
+      constructor(message, code) {
+        super(message);
+        this.name = "HelperCommandError";
+        this.code = code;
+      }
+    };
+    MacosHelperClient = class {
+      daemonAvailable = false;
+      requestSequence = 0;
+      diagnosticsCache;
+      get diagnostics() {
+        return this.diagnosticsCache;
+      }
+      async ensureInstalled(signal) {
+        if (usingExternalHelperSocket) return;
+        if (await isExecutable(HELPER_APP_EXECUTABLE_PATH)) {
+          return;
+        }
+        await runProcess(process.execPath, [SETUP_HELPER_SCRIPT, "--runtime"], HELPER_SETUP_TIMEOUT_MS, signal, {
+          ...process.env,
+          ELECTRON_RUN_AS_NODE: "1",
+          BUN_BE_BUN: "1"
+        });
+        if (!await isExecutable(HELPER_APP_EXECUTABLE_PATH)) {
+          throw new Error(`Failed to install pie-computer-use helper app at ${HELPER_APP_PATH}.`);
+        }
+      }
+      async launchDaemon(signal) {
+        if (usingExternalHelperSocket) throw new HelperTransportError(`External helper socket is unavailable at ${HELPER_SOCKET_PATH}.`);
+        await mkdir(path9.dirname(HELPER_SOCKET_PATH), { recursive: true });
+        await runProcess("open", ["-n", "-g", HELPER_APP_PATH, "--args", "serve", "--socket", HELPER_SOCKET_PATH], COMMAND_TIMEOUT_MS2, signal);
+      }
+      async daemonCommand(cmd, args, timeoutMs, signal) {
+        return await new Promise((resolve2, reject) => {
+          const id = `req_${++this.requestSequence}`;
+          const socket = net.createConnection(HELPER_SOCKET_PATH);
+          let buffer = "";
+          const timer = setTimeout(() => {
+            socket.destroy();
+            reject(new HelperTransportError(`Daemon command '${cmd}' timed out after ${timeoutMs}ms.`));
+          }, timeoutMs);
+          const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+          };
+          const onAbort = () => {
+            socket.destroy();
+            cleanup();
+            reject(new Error("Operation aborted."));
+          };
+          signal?.addEventListener("abort", onAbort, { once: true });
+          socket.setEncoding("utf8");
+          socket.on("connect", () => socket.write(`${JSON.stringify({ id, cmd, ...args })}
+`));
+          socket.on("data", (chunk) => {
+            buffer += chunk;
+            const newline = buffer.indexOf("\n");
+            if (newline < 0) return;
+            cleanup();
+            socket.end();
+            try {
+              const parsed = JSON.parse(buffer.slice(0, newline));
+              if (parsed.ok === true) resolve2(parsed.result);
+              else reject(new HelperCommandError(parsed?.error?.message ?? `Daemon command '${cmd}' failed.`, parsed?.error?.code));
+            } catch (error) {
+              reject(error);
+            }
+          });
+          socket.on("error", (error) => {
+            cleanup();
+            reject(new HelperTransportError(error.message));
+          });
+        });
+      }
+      async ensureDaemon(signal) {
+        if (this.daemonAvailable) return true;
+        try {
+          await this.daemonCommand("diagnostics", {}, 1e3, signal);
+          this.daemonAvailable = true;
+          return true;
+        } catch {
+        }
+        await this.launchDaemon(signal).catch(() => void 0);
+        for (let index = 0; index < 30; index += 1) {
+          try {
+            await this.daemonCommand("diagnostics", {}, 1e3, signal);
+            this.daemonAvailable = true;
+            return true;
+          } catch {
+            await sleep(100, signal);
+          }
+        }
+        return false;
+      }
+      async command(cmd, args = {}, options) {
+        const timeoutMs = options?.timeoutMs ?? COMMAND_TIMEOUT_MS2;
+        if (!await this.ensureDaemon(options?.signal)) {
+          throw new HelperTransportError(`pie-computer-use helper app daemon is unavailable at ${HELPER_APP_PATH}.`);
+        }
+        try {
+          return await this.daemonCommand(cmd, args, timeoutMs, options?.signal);
+        } catch (error) {
+          this.daemonAvailable = false;
+          throw error instanceof Error ? error : new Error(String(error));
+        }
+      }
+      async restart(signal) {
+        await this.command("shutdown", {}, { signal, timeoutMs: 2e3 }).catch(() => void 0);
+        this.daemonAvailable = false;
+        await sleep(400, signal);
+        if (!await this.ensureDaemon(signal)) {
+          throw new Error(`pie-computer-use helper did not come back after restart. Helper app: ${HELPER_APP_PATH}`);
+        }
+      }
+      async diagnosticsCommand(signal) {
+        const result = await this.command("diagnostics", {}, { signal });
+        const diagnostics = {
+          protocolVersion: Math.trunc(toFiniteNumber(result?.protocolVersion, 0)),
+          architectureVersion: Math.trunc(toFiniteNumber(result?.architectureVersion, 0)),
+          invariants: Array.isArray(result?.invariants) ? result.invariants.filter((value) => typeof value === "string") : [],
+          pid: Math.trunc(toFiniteNumber(result?.pid, 0)),
+          parentPid: Math.trunc(toFiniteNumber(result?.parentPid, 0)) || void 0,
+          parentAppName: toOptionalString(result?.parentAppName),
+          parentBundleId: toOptionalString(result?.parentBundleId),
+          parentPath: toOptionalString(result?.parentPath),
+          executablePath: toOptionalString(result?.executablePath),
+          os: toOptionalString(result?.macOS),
+          arch: toOptionalString(result?.arch),
+          accessibility: toBoolean(result?.accessibility),
+          screenRecording: toBoolean(result?.screenRecording)
+        };
+        this.diagnosticsCache = diagnostics;
+        return diagnostics;
+      }
+      async ensureProtocol(signal) {
+        let diagnostics = await this.diagnosticsCommand(signal);
+        const executableMatches = await isResolvedHelperExecutable(diagnostics.executablePath);
+        if (diagnostics.protocolVersion === HELPER_PROTOCOL_VERSION && executableMatches) return diagnostics;
+        await this.restart(signal);
+        diagnostics = await this.diagnosticsCommand(signal);
+        const relaunchedExecutableMatches = await isResolvedHelperExecutable(diagnostics.executablePath);
+        if (diagnostics.protocolVersion !== HELPER_PROTOCOL_VERSION || !relaunchedExecutableMatches) {
+          this.daemonAvailable = false;
+          throw new Error(
+            `pie-computer-use helper mismatch after relaunch: expected protocol ${HELPER_PROTOCOL_VERSION} and executable ${HELPER_APP_EXECUTABLE_PATH}; got protocol ${diagnostics.protocolVersion} and executable ${diagnostics.executablePath ?? "unknown"}. Reinstall or rebuild the helper app at ${HELPER_APP_PATH}.`
+          );
+        }
+        return diagnostics;
+      }
+    };
+    macosHelper = new MacosHelperClient();
+  }
+});
+
+// vendor/computer-use-axi/src/permissions.ts
+async function runPermissionSetup(bridge, mode, signal) {
+  throwIfAborted2(signal);
+  if (mode === "recheck") await bridge.restartHelper(signal);
+  let status = await bridge.checkPermissions(signal);
+  if (mode === "setup" && !allGranted(status, bridge.kinds)) {
+    await bridge.registerPermissions(signal);
+    for (const kind of missingKinds(status, bridge.kinds)) {
+      throwIfAborted2(signal);
+      await bridge.openPermissionPane(kind, signal);
+    }
+    status = await bridge.checkPermissions(signal);
+  }
+  return status;
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted) throw new Error("Operation aborted.");
+}
+function granted(status, kind) {
+  return status[kind] === true;
+}
+function allGranted(status, kinds) {
+  return kinds.every(({ kind }) => granted(status, kind));
+}
+function missingKinds(status, kinds) {
+  return kinds.flatMap(({ kind }) => granted(status, kind) ? [] : [kind]);
+}
+function permissionStatusSuggestsHelperRestart(status) {
+  return status.screenRecordingPreflight === true && status.screenRecording === false;
+}
+async function ensurePermissions(ctx, bridge, helperPath, signal) {
+  let status = await bridge.checkPermissions(signal);
+  if (allGranted(status, bridge.kinds)) return status;
+  if (!ctx.hasUI) throw new Error(bridge.copy.nonInteractiveError(helperPath));
+  await bridge.registerPermissions(signal).catch(() => void 0);
+  while (!allGranted(status, bridge.kinds)) {
+    throwIfAborted2(signal);
+    const missing = missingKinds(status, bridge.kinds);
+    const options = bridge.kinds.filter(({ kind }) => missing.includes(kind)).map(({ openOption }) => openOption);
+    options.push("Recheck (restarts helper)", "Cancel");
+    const choice = await ctx.ui.select(bridge.copy.prompt(status, helperPath, bridge.permissionHint), options, { signal });
+    if (!choice || choice === "Cancel") throw new Error(bridge.copy.incompleteError(helperPath));
+    const selected = bridge.kinds.find(({ openOption }) => choice === openOption);
+    if (selected) await bridge.openPermissionPane(selected.kind, signal);
+    if (choice.startsWith("Recheck")) {
+      await bridge.restartHelper(signal);
+      status = await bridge.checkPermissions(signal);
+      if (allGranted(status, bridge.kinds)) {
+        ctx.ui.notify(bridge.copy.readyMessage, "info");
+      } else {
+        ctx.ui.notify(bridge.copy.stillMissing(missingKinds(status, bridge.kinds)), "warning");
+      }
+    }
+  }
+  return status;
+}
+var init_permissions = __esm({
+  "vendor/computer-use-axi/src/permissions.ts"() {
+  }
+});
+
+// vendor/computer-use-axi/src/platform/architecture.ts
+function assertPlatformArchitecture(platform, diagnostics) {
+  if (diagnostics.architectureVersion !== PLATFORM_ARCHITECTURE_VERSION) {
+    throw new Error(`${platform} helper architecture mismatch: expected ${PLATFORM_ARCHITECTURE_VERSION}, got ${diagnostics.architectureVersion ?? "unknown"}. Rebuild and restart the helper.`);
+  }
+  const reported = new Set(diagnostics.invariants ?? []);
+  const missing = REQUIRED_PLATFORM_INVARIANTS.filter((invariant) => !reported.has(invariant));
+  if (missing.length > 0) {
+    throw new Error(`${platform} helper does not satisfy the shared computer-use contract: ${missing.join(", ")}.`);
+  }
+}
+var PLATFORM_ARCHITECTURE_VERSION, REQUIRED_PLATFORM_INVARIANTS;
+var init_architecture = __esm({
+  "vendor/computer-use-axi/src/platform/architecture.ts"() {
+    PLATFORM_ARCHITECTURE_VERSION = 1;
+    REQUIRED_PLATFORM_INVARIANTS = [
+      "state-scoped-observations",
+      "bounded-observation-history",
+      "multi-root-forest",
+      "progressive-disclosure",
+      "atomic-physical-input",
+      "concurrent-requests",
+      "transactional-batching"
+    ];
+  }
+});
+
+// vendor/computer-use-axi/src/platform/macos/permissions.ts
+var permissions_exports = {};
+__export(permissions_exports, {
+  ensureMacosReady: () => ensureMacosReady,
+  setupMacosPermissions: () => setupMacosPermissions
+});
+function permissionStatusSummary(status) {
+  const lines = [
+    `Accessibility: ${status.accessibility ? "granted" : "missing"}`,
+    `Screen Recording: ${status.screenRecording ? "granted" : "missing"}`
+  ];
+  if (status.screenRecordingPreflight && !status.screenRecording) {
+    lines.push(
+      "(Screen Recording reads granted in the TCC database but a live capture probe failed \u2014 the grant likely belongs to a different app identity, or the helper needs a restart.)"
+    );
+  }
+  return lines.join("; ");
+}
+function permissionPrompt(status, helperPath, hint) {
+  return [
+    "pie-computer-use needs macOS permissions for its helper app.",
+    permissionStatusSummary(status),
+    "",
+    `Helper: pie-computer-use.app (${helperPath})`,
+    hint,
+    "",
+    `Important: ${SIGNING_MIGRATION_WARNING}`,
+    "",
+    "pie-computer-use.app is already listed in the pane(s) \u2014 enable its toggle, then choose Recheck."
+  ].filter(Boolean).join("\n");
+}
+function missingPermissionMessage(kinds) {
+  return `Still missing after restart: ${kinds.join(" and ")}. ${SIGNING_MIGRATION_WARNING} Then choose Recheck again.`;
+}
+async function checkPermissions(signal) {
+  const result = await macosHelper.command("checkPermissions", {}, { signal });
+  const rawSource = result?.source;
+  return {
+    accessibility: toBoolean(result?.accessibility),
+    // Authoritative: the helper's live ScreenCaptureKit probe.
+    screenRecording: toBoolean(result?.screenRecordingCapturable),
+    // Keep the preflight value separate: disagreement means stale per-process
+    // TCC cache or a grant row belonging to another app identity.
+    screenRecordingPreflight: toBoolean(result?.screenRecordingPreflight),
+    source: rawSource && typeof rawSource === "object" ? {
+      // macOS attributes Accessibility / Screen Recording grants to the
+      // responsible process at the top of the launch chain. "helper-app"
+      // is the canonical installed app via LaunchServices; "caller" means
+      // grants would attach to the launching app instead.
+      attribution: rawSource.attribution === "helper-app" ? "helper-app" : "caller",
+      pid: Math.trunc(toFiniteNumber(rawSource.pid, 0)) || void 0,
+      parentPid: Math.trunc(toFiniteNumber(rawSource.parentPid, 0)) || void 0,
+      executablePath: toOptionalString(rawSource.executablePath),
+      parentPath: toOptionalString(rawSource.parentPath),
+      parentBundleId: toOptionalString(rawSource.parentBundleId),
+      os: toOptionalString(rawSource.macOS)
+    } : void 0
+  };
+}
+async function registerPermissions(signal) {
+  const helperPid = macosHelper.diagnostics?.pid;
+  if (helperPid !== void 0 && helperPid === registeredForHelperPid) return;
+  await macosHelper.command("registerPermissions", {}, { signal, timeoutMs: 15e3 });
+  registeredForHelperPid = helperPid;
+}
+async function setupMacosPermissions(mode) {
+  await macosHelper.ensureInstalled();
+  if (!await macosHelper.ensureDaemon()) throw new Error(`Helper daemon unavailable: ${HELPER_APP_PATH}`);
+  assertPlatformArchitecture("macOS", await macosHelper.ensureProtocol());
+  return await runPermissionSetup({
+    kinds: macosPermissionKinds,
+    checkPermissions,
+    registerPermissions,
+    openPermissionPane: async (kind, signal) => {
+      await macosHelper.command("openPermissionPane", { kind }, { signal });
+    },
+    restartHelper: (signal) => macosHelper.restart(signal)
+  }, mode);
+}
+async function ensureMacosReady(ctx, state, signal) {
+  await macosHelper.ensureInstalled(signal);
+  if (!await macosHelper.ensureDaemon(signal)) {
+    throw new Error(`pie-computer-use helper app daemon did not start. Helper app: ${HELPER_APP_PATH}`);
+  }
+  const helperDiagnostics = await macosHelper.ensureProtocol(signal);
+  assertPlatformArchitecture("macOS", helperDiagnostics);
+  const now = Date.now();
+  const cachedStatus = state.permissionStatus;
+  const canUseCachedPermissions = cachedStatus?.accessibility && cachedStatus.screenRecording && now - state.lastPermissionCheckAt < 2e3;
+  if (canUseCachedPermissions) {
+    return { ...state, helperDiagnostics };
+  }
+  let permissionStatus = await checkPermissions(signal);
+  let lastPermissionCheckAt = now;
+  if (!autoRestartAttempted && permissionStatusSuggestsHelperRestart(permissionStatus)) {
+    autoRestartAttempted = true;
+    await macosHelper.restart(signal).catch(() => void 0);
+    permissionStatus = await checkPermissions(signal);
+    lastPermissionCheckAt = Date.now();
+  }
+  if (!permissionStatus.accessibility || !permissionStatus.screenRecording) {
+    const attributionHint = permissionStatus.source?.attribution === "caller" ? `Warning: the helper is not running as the installed pie-computer-use.app (executable: ${permissionStatus.source?.executablePath ?? "unknown"}). Grants made now would attach to the launching app instead. Restart Pie so the canonical helper is used.` : void 0;
+    permissionStatus = await ensurePermissions(
+      ctx,
+      {
+        kinds: macosPermissionKinds,
+        copy: {
+          nonInteractiveError: (helperPath) => `Run 'computer-use-axi permissions setup' to register the helper and open Settings, grant both permissions, then run 'computer-use-axi permissions recheck'. ${GRANT_INSTRUCTIONS}
+Helper path: ${helperPath}`,
+          prompt: permissionPrompt,
+          incompleteError: (helperPath) => `pie-computer-use setup is incomplete. ${GRANT_INSTRUCTIONS} Helper path: ${helperPath}`,
+          readyMessage: "pie-computer-use is ready.",
+          stillMissing: missingPermissionMessage
+        },
+        checkPermissions: (permissionSignal) => checkPermissions(permissionSignal ?? signal),
+        registerPermissions: (permissionSignal) => registerPermissions(permissionSignal ?? signal),
+        openPermissionPane: async (kind, permissionSignal) => {
+          await macosHelper.command("openPermissionPane", { kind }, { signal: permissionSignal ?? signal });
+        },
+        restartHelper: (permissionSignal) => macosHelper.restart(permissionSignal ?? signal),
+        permissionHint: attributionHint
+      },
+      HELPER_APP_PATH,
+      signal
+    );
+    lastPermissionCheckAt = Date.now();
+  }
+  return { permissionStatus, lastPermissionCheckAt, helperDiagnostics };
+}
+var GRANT_INSTRUCTIONS, SIGNING_MIGRATION_WARNING, macosPermissionKinds, registeredForHelperPid, autoRestartAttempted;
+var init_permissions2 = __esm({
+  "vendor/computer-use-axi/src/platform/macos/permissions.ts"() {
+    init_permissions();
+    init_coerce();
+    init_helper();
+    init_architecture();
+    GRANT_INSTRUCTIONS = "Grant Accessibility and Screen Recording to pie-computer-use.app in System Settings \u2192 Privacy & Security. Screen Recording lets the agent see the window; Accessibility lets it interact with the window.";
+    SIGNING_MIGRATION_WARNING = "If these permissions were enabled before this install/update, macOS invalidated the old grants because pie-computer-use.app was re-signed. Re-enable both toggles for the newly signed helper. If a toggle is already on, switch it off and on again.";
+    macosPermissionKinds = [
+      { kind: "accessibility", openOption: "Open Accessibility Settings (missing)" },
+      { kind: "screenRecording", openOption: "Open Screen Recording Settings (missing)" }
+    ];
+    autoRestartAttempted = false;
+  }
+});
+
+// vendor/computer-use-axi/src/broker-server.ts
+import { createHash as createHash3, randomUUID as randomUUID8 } from "node:crypto";
+import { chmodSync as chmodSync2, lstatSync as lstatSync4, readFileSync as readFileSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import net3 from "node:net";
+import path14 from "node:path";
+
+// vendor/computer-use-axi/src/artifact-store.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { closeSync, existsSync as existsSync2, lstatSync as lstatSync3, mkdirSync as mkdirSync4, openSync, readdirSync as readdirSync2, rmdirSync, unlinkSync as unlinkSync2, writeSync } from "node:fs";
+import path3 from "node:path";
+
+// vendor/computer-use-axi/src/broker-protocol.ts
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, lstatSync as lstatSync2, mkdirSync as mkdirSync3 } from "node:fs";
+import path2 from "node:path";
+
+// vendor/computer-use-axi/src/persist.ts
+import { lstatSync, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, renameSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var isBunRuntime = !!process.versions.bun;
+function getPackageDir() {
+  const envDir = process.env.PIE_PACKAGE_DIR;
+  if (envDir) {
+    if (envDir === "~") return homedir();
+    if (envDir.startsWith("~/")) return homedir() + envDir.slice(1);
+    return envDir;
+  }
+  let dir = __dirname;
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return __dirname;
+}
+function getPackageJsonPath() {
+  return join(getPackageDir(), "package.json");
+}
+var pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
+var CONFIG_DIR_NAME = ".pie";
+var VERSION = pkg.version;
+var ENV_AGENT_DIR = "PIE_CODING_AGENT_DIR";
+function getConfigDir() {
+  const envDir = process.env[ENV_AGENT_DIR];
+  if (envDir) {
+    if (envDir === "~") return homedir();
+    if (envDir.startsWith("~/")) return homedir() + envDir.slice(1);
+    return envDir;
+  }
+  return join(homedir(), CONFIG_DIR_NAME);
+}
+
+// vendor/computer-use-axi/src/persist.ts
+function stateRootDir(env = process.env) {
+  const override = env.PIE_COMPUTER_USE_STATE_DIR?.trim();
+  if (override) return override;
+  return path.join(getConfigDir(), "computer-use");
+}
+function statesDir(env = process.env) {
+  return path.join(stateRootDir(env), "states");
+}
+function outputsDir(env = process.env) {
+  return path.join(stateRootDir(env), "outputs");
+}
+function runtimeStatePath(env = process.env) {
+  return path.join(stateRootDir(env), "runtime.json");
+}
+function brokerStateDir(env = process.env) {
+  return path.join(stateRootDir(env), "broker");
+}
+function brokerManifestPath(env = process.env) {
+  return path.join(brokerStateDir(env), "manifest.json");
+}
+function loadBrokerManifest(env = process.env) {
+  const manifest = readJsonFile(brokerManifestPath(env));
+  if (!manifest || typeof manifest.generation !== "string") return void 0;
+  return {
+    generation: manifest.generation,
+    helperGeneration: typeof manifest.helperGeneration === "string" ? manifest.helperGeneration : "",
+    stateIds: Array.isArray(manifest.stateIds) ? manifest.stateIds.filter((id) => typeof id === "string" && /^[A-Za-z0-9-]{1,128}$/.test(id)).slice(0, 256) : [],
+    updatedAt: Number.isFinite(manifest.updatedAt) ? manifest.updatedAt : 0
+  };
+}
+function saveBrokerManifest(manifest, env = process.env) {
+  mkdirSync2(brokerStateDir(env), { recursive: true, mode: 448 });
+  writeJsonAtomic(brokerManifestPath(env), { ...manifest, stateIds: manifest.stateIds.slice(0, 256) });
+}
+function brokerDrainMarkerPath(env = process.env) {
+  return path.join(brokerStateDir(env), "draining.json");
+}
+function loadDrainMarker(env = process.env) {
+  const marker = readJsonFile(brokerDrainMarkerPath(env));
+  if (!marker || typeof marker !== "object" || !Number.isFinite(marker.pid)) return void 0;
+  return {
+    pid: Math.trunc(marker.pid),
+    startedAt: Number.isFinite(marker.startedAt) ? marker.startedAt : 0,
+    deadlineAt: Number.isFinite(marker.deadlineAt) ? marker.deadlineAt : 0
+  };
+}
+function saveDrainMarker(marker, env = process.env) {
+  mkdirSync2(brokerStateDir(env), { recursive: true, mode: 448 });
+  writeJsonAtomic(brokerDrainMarkerPath(env), marker);
+}
+function clearDrainMarker(env = process.env) {
+  try {
+    const stats = lstatSync(brokerDrainMarkerPath(env));
+    if (stats.isFile() && !stats.isSymbolicLink()) unlinkSync(brokerDrainMarkerPath(env));
+  } catch {
+  }
+}
+function cleanupLegacyBrokerCache(env = process.env) {
+  let runtimeFile = false;
+  let states = 0;
+  let outputs2 = 0;
+  const runtime = runtimeStatePath(env);
+  try {
+    const stats = lstatSync(runtime);
+    if (stats.isFile() && !stats.isSymbolicLink()) {
+      unlinkSync(runtime);
+      runtimeFile = true;
+    }
+  } catch {
+  }
+  const statesDirPath = statesDir(env);
+  try {
+    for (const name of readdirSync(statesDirPath).slice(0, 512)) {
+      if (!/^[A-Za-z0-9-]+\.json$/.test(name)) continue;
+      const target = path.join(statesDirPath, name);
+      try {
+        const stats = lstatSync(target);
+        if (!stats.isFile() || stats.isSymbolicLink()) continue;
+        unlinkSync(target);
+        states += 1;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const oldOutputs = outputsDir(env);
+  try {
+    for (const name of readdirSync(oldOutputs).slice(0, 512)) {
+      if (!/^o\d+\.(txt|meta\.json)$/.test(name)) continue;
+      const target = path.join(oldOutputs, name);
+      try {
+        const stats = lstatSync(target);
+        if (!stats.isFile() || stats.isSymbolicLink()) continue;
+        unlinkSync(target);
+        outputs2 += 1;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { runtimeFile, states, outputs: outputs2 };
+}
+function writeJsonAtomic(filePath, value) {
+  mkdirSync2(path.dirname(filePath), { recursive: true });
+  const temp = `${filePath}.${process.pid}.tmp`;
+  writeFileSync(temp, JSON.stringify(value), "utf8");
+  renameSync2(temp, filePath);
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// src/runtime/computer-use-owner.ts
+var COMPUTER_USE_STANDALONE_OWNER = "standalone";
+var OWNER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@-]{0,255}$/;
+function normalizeComputerUseOwner(value) {
   if (typeof value !== "string") return COMPUTER_USE_STANDALONE_OWNER;
   const trimmed = value.trim();
   if (!trimmed) return COMPUTER_USE_STANDALONE_OWNER;
@@ -3909,14 +4499,17 @@ function normalizeComputerUseOwner(value) {
 
 // vendor/computer-use-axi/src/broker-protocol.ts
 var BROKER_PROTOCOL_VERSION = 1;
-var BROKER_ENGINE_VERSION = 1;
+var BROKER_ENGINE_VERSION = 2;
 var BROKER_PACKAGE_VERSION = "0.5.1-pie.1";
+var BROKER_RESULT_CACHE_MAX_ENTRIES = 256;
+var BROKER_REPLAY_LEDGER_MAX_IDS = 65536;
 var BROKER_MAX_FRAME_BYTES = 4 * 1024 * 1024;
 var BROKER_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
 var BROKER_MAX_QUEUED_REQUESTS = 64;
 var BROKER_MAX_CONCURRENT_REQUESTS = 16;
 var BROKER_DEFAULT_REQUEST_BUDGET_MS = 12e4;
 var BROKER_MAX_REQUEST_BUDGET_MS = 15 * 6e4;
+var BROKER_MIN_REQUEST_BUDGET_MS = 100;
 var BROKER_IDLE_EXIT_MS = 30 * 6e4;
 var BROKER_DRAIN_MAX_MS = 3e4;
 var ENGINE_COMMANDS = [
@@ -3932,7 +4525,7 @@ var ENGINE_COMMANDS = [
   "navigate_browser",
   "evaluate_browser"
 ];
-var CONTROL_COMMANDS = ["status", "stop", "debug_restart_helper"];
+var CONTROL_COMMANDS = ["status", "stop", "permissions", "debug_restart_helper"];
 function isEngineCommand(value) {
   return ENGINE_COMMANDS.includes(value);
 }
@@ -4086,6 +4679,12 @@ function validateAction(value, index) {
   return action;
 }
 function validateCommandParams(command, raw) {
+  if (command === "permissions") {
+    assertPlainRecord(raw, "params");
+    assertKeys(raw, "params", ["mode"]);
+    if (raw.mode !== "setup" && raw.mode !== "recheck") throw new BrokerProtocolError("invalid_params", "permissions mode must be setup or recheck");
+    return { mode: raw.mode };
+  }
   if (command === "status" || command === "stop") {
     if (raw === void 0 || raw === null) return {};
     assertPlainRecord(raw, "params");
@@ -4227,7 +4826,7 @@ function validateRequest(value) {
   const params = validateCommandParams(command, value.params);
   const cwd = value.cwd === void 0 ? process.cwd() : boundedString(value.cwd, "cwd", 4096);
   if (!path2.isAbsolute(cwd)) throw new BrokerProtocolError("invalid_request", "cwd must be absolute.");
-  const budgetMs = value.budgetMs === void 0 ? BROKER_DEFAULT_REQUEST_BUDGET_MS : Math.trunc(boundedNumber(value.budgetMs, "budgetMs", 100, BROKER_MAX_REQUEST_BUDGET_MS));
+  const budgetMs = value.budgetMs === void 0 ? BROKER_DEFAULT_REQUEST_BUDGET_MS : Math.trunc(boundedNumber(value.budgetMs, "budgetMs", BROKER_MIN_REQUEST_BUDGET_MS, BROKER_MAX_REQUEST_BUDGET_MS));
   return {
     requestId: value.requestId,
     ownerId,
@@ -4546,23 +5145,8 @@ import net2 from "node:net";
 import os4 from "node:os";
 import path13 from "node:path";
 
-// vendor/computer-use-axi/src/platform/coerce.ts
-function toBoolean(value) {
-  return value === true || value === "true" || value === 1;
-}
-function toFiniteNumber(value, fallback) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string") {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return fallback;
-}
-function toOptionalString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-
 // vendor/computer-use-axi/src/actions.ts
+init_coerce();
 function mouseButton(value) {
   return value === "right" || value === "middle" ? value : "left";
 }
@@ -5789,6 +6373,7 @@ function titlesMatch(tabTitle, windowTitle) {
 
 // vendor/computer-use-axi/src/config.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { AsyncLocalStorage } from "node:async_hooks";
 import path5 from "node:path";
 
 // vendor/computer-use-axi/host.ts
@@ -5803,8 +6388,11 @@ var DEFAULT_CONFIG = {
   cursor_overlay: true,
   managed_browser: "chrome"
 };
-var activeConfig = { ...DEFAULT_CONFIG };
-var activeLoadedConfig = { config: activeConfig, sources: [], env: {} };
+var operationConfig = new AsyncLocalStorage();
+var defaultLoaded = Object.freeze({ config: Object.freeze({ ...DEFAULT_CONFIG }), sources: [], env: {} });
+function withComputerUseConfig(cwd, run) {
+  return operationConfig.run(loadComputerUseConfig(cwd), run);
+}
 function parseBoolean(value) {
   if (typeof value === "boolean") return value;
   if (typeof value === "number") return value === 1 ? true : value === 0 ? false : void 0;
@@ -5860,18 +6448,19 @@ function loadComputerUseConfig(cwd) {
     if (source.values) Object.assign(config, source.values);
   }
   Object.assign(config, env);
-  activeConfig = config;
-  activeLoadedConfig = { config, sources, env };
-  return activeLoadedConfig;
+  return Object.freeze({ config: Object.freeze(config), sources, env });
 }
 function getComputerUseConfig() {
-  return activeConfig;
+  return getLoadedComputerUseConfig().config;
+}
+function getLoadedComputerUseConfig() {
+  return operationConfig.getStore() ?? defaultLoaded;
 }
 function isHeadlessMode() {
-  return activeConfig.headless;
+  return getComputerUseConfig().headless;
 }
 function isBrowserUseEnabled() {
-  return activeConfig.browser_use;
+  return getComputerUseConfig().browser_use;
 }
 
 // vendor/computer-use-axi/src/note.ts
@@ -6106,380 +6695,76 @@ function applyOutputEnvelope(tool, result, owner = COMPUTER_USE_STANDALONE_OWNER
 ${trailer}` }, ...images] };
 }
 function boundToolError(tool, error, owner = COMPUTER_USE_STANDALONE_OWNER) {
-  const message = error instanceof Error ? error.message : String(error);
-  const bytes = new TextEncoder().encode(message).byteLength;
-  const lines = message.split("\n").length;
-  if (bytes <= MODEL_TEXT_MAX_BYTES && lines <= MODEL_TEXT_MAX_LINES) return error instanceof Error ? error : new Error(message);
-  const entry = storeOutput(message, owner);
-  const preview = boundedPrefix(message, MODEL_PREVIEW_BYTES, MODEL_TEXT_MAX_LINES - 4);
-  const returnedBytes = new TextEncoder().encode(preview).byteLength;
-  const storageNote = entry.complete ? "" : `; only the first ${entry.storedBytes} bytes were stored`;
-  return new Error(`${preview}
-
-error truncated: returned ${returnedBytes} of ${entry.totalBytes} utf-8 bytes
-refine: ${refinementFor(tool)}
-continue: computer-use-axi read --ref "${entry.ref}" --offset ${returnedBytes}${storageNote}`);
-}
-function readStoredOutput(ref, offsetValue, owner = COMPUTER_USE_STANDALONE_OWNER) {
-  const entry = outputs.get(ref);
-  if (!entry || entry.owner !== normalizeComputerUseOwner(owner)) return void 0;
-  let offset = Math.min(entry.storedBytes, Math.max(0, Math.trunc(typeof offsetValue === "number" && Number.isFinite(offsetValue) ? offsetValue : 0)));
-  const requestedBytes = Math.min(entry.storedBytes - offset, OUTPUT_PAGE_BYTES + 4);
-  const buffer = new Uint8Array(Math.max(0, requestedBytes));
-  const fd = openSync2(entry.filePath, "r");
-  try {
-    if (buffer.byteLength > 0) readSync(fd, buffer, 0, buffer.byteLength, offset);
-  } finally {
-    closeSync2(fd);
-  }
-  let start = 0;
-  while (start < buffer.byteLength && (buffer[start] & 192) === 128) start += 1;
-  offset += start;
-  const slice = utf8Prefix(buffer.subarray(start), OUTPUT_PAGE_BYTES);
-  const actualEnd = offset + slice.byteLength;
-  return {
-    text: new TextDecoder().decode(slice),
-    offset,
-    limit: slice.byteLength,
-    totalBytes: entry.totalBytes,
-    hasMore: actualEnd < entry.storedBytes,
-    complete: entry.complete
-  };
-}
-function clearStoredOutputs(owner) {
-  if (owner === void 0) {
-    for (const entry of outputs.values()) {
-      try {
-        unlinkSync3(entry.filePath);
-      } catch {
-      }
-    }
-    outputs.clear();
-    outputBytes = 0;
-    return;
-  }
-  const normalized = normalizeComputerUseOwner(owner);
-  for (const [ref, entry] of [...outputs.entries()]) {
-    if (entry.owner !== normalized) continue;
-    outputs.delete(ref);
-    outputBytes = Math.max(0, outputBytes - entry.storedBytes);
-    try {
-      unlinkSync3(entry.filePath);
-    } catch {
-    }
-  }
-}
-
-// vendor/computer-use-axi/src/platform/macos/helper.ts
-import { spawn } from "node:child_process";
-import { constants as fsConstants2 } from "node:fs";
-import { access, mkdir, realpath } from "node:fs/promises";
-import net from "node:net";
-import os2 from "node:os";
-import path9 from "node:path";
-
-// vendor/computer-use-axi/src/platform/macos/helper-path.mjs
-import { accessSync, constants as fsConstants, existsSync as existsSync4 } from "node:fs";
-import os from "node:os";
-import path7 from "node:path";
-var HELPER_APP_NAME = "pie-computer-use.app";
-var SYSTEM_HELPER_APP_PATH = path7.join("/Applications", HELPER_APP_NAME);
-function resolveMacosHelperAppPath(options = {}) {
-  const env = options.env ?? process.env;
-  const explicitPath = env.PIE_COMPUTER_USE_HELPER_APP_PATH?.trim();
-  if (explicitPath) return path7.resolve(explicitPath);
-  const homeDir = options.homeDir ?? os.homedir();
-  const configDir = options.configDir ?? resolvePieConfigDir(env, homeDir);
-  const systemHelperAppPath = options.systemHelperAppPath ?? SYSTEM_HELPER_APP_PATH;
-  const fileExists = options.fileExists ?? existsSync4;
-  const directoryIsWritable = options.directoryIsWritable ?? ((directoryPath) => {
-    try {
-      accessSync(directoryPath, fsConstants.W_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  });
-  if (fileExists(systemHelperAppPath) && directoryIsWritable(path7.dirname(systemHelperAppPath))) {
-    return systemHelperAppPath;
-  }
-  return path7.join(configDir, "computer-use", HELPER_APP_NAME);
-}
-function resolvePieConfigDir(env, homeDir) {
-  const envDir = env.PIE_CODING_AGENT_DIR;
-  if (envDir) {
-    if (envDir === "~") return homeDir;
-    if (envDir.startsWith("~/")) return homeDir + envDir.slice(1);
-    return envDir;
-  }
-  return path7.join(homeDir, ".pie");
-}
-
-// vendor/computer-use-axi/src/platform/package-root.ts
-import { existsSync as existsSync5 } from "node:fs";
-import path8 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-function resolveExtensionRoot(moduleUrl) {
-  const override = process.env.PIE_COMPUTER_USE_PACKAGE_ROOT?.trim();
-  if (override) return path8.resolve(override);
-  let dir = path8.dirname(fileURLToPath2(moduleUrl));
-  for (let depth = 0; depth < 12; depth += 1) {
-    if (existsSync5(path8.join(dir, "scripts", "setup-helper.mjs"))) return dir;
-    const parent = path8.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  throw new Error(`computer-use: could not locate extension root (scripts/setup-helper.mjs) above ${path8.dirname(fileURLToPath2(moduleUrl))}. Set PIE_COMPUTER_USE_PACKAGE_ROOT.`);
-}
-
-// vendor/computer-use-axi/src/platform/macos/helper.ts
-var COMMAND_TIMEOUT_MS2 = 15e3;
-var HELPER_PROTOCOL_VERSION = 6;
-var HELPER_SETUP_TIMEOUT_MS = 6e4;
-var HELPER_APP_PATH = resolveMacosHelperAppPath();
-var HELPER_APP_EXECUTABLE_PATH = path9.join(HELPER_APP_PATH, "Contents", "MacOS", "pie-computer-use");
-var DEFAULT_HELPER_SOCKET_PATH = path9.join(os2.homedir(), "Library", "Caches", "pie-computer-use", "bridge.sock");
-var HELPER_SOCKET_PATH = process.env.PIE_COMPUTER_USE_SOCKET_PATH ?? DEFAULT_HELPER_SOCKET_PATH;
-var usingExternalHelperSocket = HELPER_SOCKET_PATH !== DEFAULT_HELPER_SOCKET_PATH;
-var PACKAGE_ROOT = resolveExtensionRoot(import.meta.url);
-var SETUP_HELPER_SCRIPT = path9.join(PACKAGE_ROOT, "scripts", "setup-helper.mjs");
-var HelperTransportError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "HelperTransportError";
-  }
-};
-var HelperCommandError = class extends Error {
-  code;
-  constructor(message, code) {
-    super(message);
-    this.name = "HelperCommandError";
-    this.code = code;
-  }
-};
-function throwIfAborted(signal) {
-  if (signal?.aborted) throw new Error("Operation aborted.");
-}
-async function sleep(ms, signal) {
-  throwIfAborted(signal);
-  await new Promise((resolve2, reject) => {
-    const timer = setTimeout(resolve2, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(new Error("Operation aborted."));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  }).finally(() => signal?.throwIfAborted?.());
-}
-async function isExecutable(filePath) {
-  try {
-    await access(filePath, fsConstants2.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isResolvedHelperExecutable(filePath) {
-  if (!filePath) return true;
-  const [actualPath, expectedPath] = await Promise.all([
-    realpath(filePath).catch(() => path9.resolve(filePath)),
-    realpath(HELPER_APP_EXECUTABLE_PATH).catch(() => path9.resolve(HELPER_APP_EXECUTABLE_PATH))
-  ]);
-  return actualPath === expectedPath;
-}
-async function runProcess(command, args, timeoutMs, signal, env) {
-  throwIfAborted(signal);
-  await new Promise((resolve2, reject) => {
-    const child = spawn(command, args, {
-      stdio: ["ignore", "pipe", "pipe"],
-      env
-    });
-    let stderr = "";
-    let stdout = "";
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      cleanup();
-      reject(new Error(`Command timed out after ${timeoutMs}ms: ${command} ${args.join(" ")}`));
-    }, timeoutMs);
-    const onAbort = () => {
-      child.kill("SIGTERM");
-      cleanup();
-      reject(new Error("Operation aborted."));
-    };
-    const cleanup = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-    };
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", (error) => {
-      cleanup();
-      reject(error);
-    });
-    child.on("close", (code) => {
-      cleanup();
-      if (code === 0) {
-        resolve2();
-        return;
-      }
-      const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
-      reject(new Error(`Command failed (${code}): ${command} ${args.join(" ")}
-${output}`.trim()));
-    });
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-var MacosHelperClient = class {
-  daemonAvailable = false;
-  requestSequence = 0;
-  diagnosticsCache;
-  get diagnostics() {
-    return this.diagnosticsCache;
-  }
-  async ensureInstalled(signal) {
-    if (usingExternalHelperSocket) return;
-    if (await isExecutable(HELPER_APP_EXECUTABLE_PATH)) {
-      return;
-    }
-    await runProcess(process.execPath, [SETUP_HELPER_SCRIPT, "--runtime"], HELPER_SETUP_TIMEOUT_MS, signal, {
-      ...process.env,
-      ELECTRON_RUN_AS_NODE: "1",
-      BUN_BE_BUN: "1"
-    });
-    if (!await isExecutable(HELPER_APP_EXECUTABLE_PATH)) {
-      throw new Error(`Failed to install pie-computer-use helper app at ${HELPER_APP_PATH}.`);
-    }
-  }
-  async launchDaemon(signal) {
-    if (usingExternalHelperSocket) throw new HelperTransportError(`External helper socket is unavailable at ${HELPER_SOCKET_PATH}.`);
-    await mkdir(path9.dirname(HELPER_SOCKET_PATH), { recursive: true });
-    await runProcess("open", ["-n", "-g", HELPER_APP_PATH, "--args", "serve", "--socket", HELPER_SOCKET_PATH], COMMAND_TIMEOUT_MS2, signal);
-  }
-  async daemonCommand(cmd, args, timeoutMs, signal) {
-    return await new Promise((resolve2, reject) => {
-      const id = `req_${++this.requestSequence}`;
-      const socket = net.createConnection(HELPER_SOCKET_PATH);
-      let buffer = "";
-      const timer = setTimeout(() => {
-        socket.destroy();
-        reject(new HelperTransportError(`Daemon command '${cmd}' timed out after ${timeoutMs}ms.`));
-      }, timeoutMs);
-      const cleanup = () => {
-        clearTimeout(timer);
-        signal?.removeEventListener("abort", onAbort);
-      };
-      const onAbort = () => {
-        socket.destroy();
-        cleanup();
-        reject(new Error("Operation aborted."));
-      };
-      signal?.addEventListener("abort", onAbort, { once: true });
-      socket.setEncoding("utf8");
-      socket.on("connect", () => socket.write(`${JSON.stringify({ id, cmd, ...args })}
-`));
-      socket.on("data", (chunk) => {
-        buffer += chunk;
-        const newline = buffer.indexOf("\n");
-        if (newline < 0) return;
-        cleanup();
-        socket.end();
-        try {
-          const parsed = JSON.parse(buffer.slice(0, newline));
-          if (parsed.ok === true) resolve2(parsed.result);
-          else reject(new HelperCommandError(parsed?.error?.message ?? `Daemon command '${cmd}' failed.`, parsed?.error?.code));
-        } catch (error) {
-          reject(error);
-        }
-      });
-      socket.on("error", (error) => {
-        cleanup();
-        reject(new HelperTransportError(error.message));
-      });
-    });
+  const message = error instanceof Error ? error.message : String(error);
+  const bytes = new TextEncoder().encode(message).byteLength;
+  const lines = message.split("\n").length;
+  if (bytes <= MODEL_TEXT_MAX_BYTES && lines <= MODEL_TEXT_MAX_LINES) return error instanceof Error ? error : new Error(message);
+  const entry = storeOutput(message, owner);
+  const preview = boundedPrefix(message, MODEL_PREVIEW_BYTES, MODEL_TEXT_MAX_LINES - 4);
+  const returnedBytes = new TextEncoder().encode(preview).byteLength;
+  const storageNote = entry.complete ? "" : `; only the first ${entry.storedBytes} bytes were stored`;
+  return new Error(`${preview}
+
+error truncated: returned ${returnedBytes} of ${entry.totalBytes} utf-8 bytes
+refine: ${refinementFor(tool)}
+continue: computer-use-axi read --ref "${entry.ref}" --offset ${returnedBytes}${storageNote}`);
+}
+function readStoredOutput(ref, offsetValue, owner = COMPUTER_USE_STANDALONE_OWNER) {
+  const entry = outputs.get(ref);
+  if (!entry || entry.owner !== normalizeComputerUseOwner(owner)) return void 0;
+  let offset = Math.min(entry.storedBytes, Math.max(0, Math.trunc(typeof offsetValue === "number" && Number.isFinite(offsetValue) ? offsetValue : 0)));
+  const requestedBytes = Math.min(entry.storedBytes - offset, OUTPUT_PAGE_BYTES + 4);
+  const buffer = new Uint8Array(Math.max(0, requestedBytes));
+  const fd = openSync2(entry.filePath, "r");
+  try {
+    if (buffer.byteLength > 0) readSync(fd, buffer, 0, buffer.byteLength, offset);
+  } finally {
+    closeSync2(fd);
   }
-  async ensureDaemon(signal) {
-    if (this.daemonAvailable) return true;
-    try {
-      await this.daemonCommand("diagnostics", {}, 1e3, signal);
-      this.daemonAvailable = true;
-      return true;
-    } catch {
-    }
-    await this.launchDaemon(signal).catch(() => void 0);
-    for (let index = 0; index < 30; index += 1) {
+  let start = 0;
+  while (start < buffer.byteLength && (buffer[start] & 192) === 128) start += 1;
+  offset += start;
+  const slice = utf8Prefix(buffer.subarray(start), OUTPUT_PAGE_BYTES);
+  const actualEnd = offset + slice.byteLength;
+  return {
+    text: new TextDecoder().decode(slice),
+    offset,
+    limit: slice.byteLength,
+    totalBytes: entry.totalBytes,
+    hasMore: actualEnd < entry.storedBytes,
+    complete: entry.complete
+  };
+}
+function clearStoredOutputs(owner) {
+  if (owner === void 0) {
+    for (const entry of outputs.values()) {
       try {
-        await this.daemonCommand("diagnostics", {}, 1e3, signal);
-        this.daemonAvailable = true;
-        return true;
+        unlinkSync3(entry.filePath);
       } catch {
-        await sleep(100, signal);
       }
     }
-    return false;
+    outputs.clear();
+    outputBytes = 0;
+    return;
   }
-  async command(cmd, args = {}, options) {
-    const timeoutMs = options?.timeoutMs ?? COMMAND_TIMEOUT_MS2;
-    if (!await this.ensureDaemon(options?.signal)) {
-      throw new HelperTransportError(`pie-computer-use helper app daemon is unavailable at ${HELPER_APP_PATH}.`);
-    }
+  const normalized = normalizeComputerUseOwner(owner);
+  for (const [ref, entry] of [...outputs.entries()]) {
+    if (entry.owner !== normalized) continue;
+    outputs.delete(ref);
+    outputBytes = Math.max(0, outputBytes - entry.storedBytes);
     try {
-      return await this.daemonCommand(cmd, args, timeoutMs, options?.signal);
-    } catch (error) {
-      this.daemonAvailable = false;
-      throw error instanceof Error ? error : new Error(String(error));
-    }
-  }
-  async restart(signal) {
-    await this.command("shutdown", {}, { signal, timeoutMs: 2e3 }).catch(() => void 0);
-    this.daemonAvailable = false;
-    await sleep(400, signal);
-    if (!await this.ensureDaemon(signal)) {
-      throw new Error(`pie-computer-use helper did not come back after restart. Helper app: ${HELPER_APP_PATH}`);
-    }
-  }
-  async diagnosticsCommand(signal) {
-    const result = await this.command("diagnostics", {}, { signal });
-    const diagnostics = {
-      protocolVersion: Math.trunc(toFiniteNumber(result?.protocolVersion, 0)),
-      architectureVersion: Math.trunc(toFiniteNumber(result?.architectureVersion, 0)),
-      invariants: Array.isArray(result?.invariants) ? result.invariants.filter((value) => typeof value === "string") : [],
-      pid: Math.trunc(toFiniteNumber(result?.pid, 0)),
-      parentPid: Math.trunc(toFiniteNumber(result?.parentPid, 0)) || void 0,
-      parentAppName: toOptionalString(result?.parentAppName),
-      parentBundleId: toOptionalString(result?.parentBundleId),
-      parentPath: toOptionalString(result?.parentPath),
-      executablePath: toOptionalString(result?.executablePath),
-      os: toOptionalString(result?.macOS),
-      arch: toOptionalString(result?.arch),
-      accessibility: toBoolean(result?.accessibility),
-      screenRecording: toBoolean(result?.screenRecording)
-    };
-    this.diagnosticsCache = diagnostics;
-    return diagnostics;
-  }
-  async ensureProtocol(signal) {
-    let diagnostics = await this.diagnosticsCommand(signal);
-    const executableMatches = await isResolvedHelperExecutable(diagnostics.executablePath);
-    if (diagnostics.protocolVersion === HELPER_PROTOCOL_VERSION && executableMatches) return diagnostics;
-    await this.restart(signal);
-    diagnostics = await this.diagnosticsCommand(signal);
-    const relaunchedExecutableMatches = await isResolvedHelperExecutable(diagnostics.executablePath);
-    if (diagnostics.protocolVersion !== HELPER_PROTOCOL_VERSION || !relaunchedExecutableMatches) {
-      this.daemonAvailable = false;
-      throw new Error(
-        `pie-computer-use helper mismatch after relaunch: expected protocol ${HELPER_PROTOCOL_VERSION} and executable ${HELPER_APP_EXECUTABLE_PATH}; got protocol ${diagnostics.protocolVersion} and executable ${diagnostics.executablePath ?? "unknown"}. Reinstall or rebuild the helper app at ${HELPER_APP_PATH}.`
-      );
+      unlinkSync3(entry.filePath);
+    } catch {
     }
-    return diagnostics;
   }
-};
-var macosHelper = new MacosHelperClient();
+}
+
+// vendor/computer-use-axi/src/bridge.ts
+init_coerce();
 
 // vendor/computer-use-axi/src/platform/macos/backend.ts
+init_coerce();
+init_helper();
 function parseApps(result) {
   const array = Array.isArray(result) ? result : result?.apps;
   if (!Array.isArray(array)) return [];
@@ -6591,6 +6876,7 @@ var macosBackend = {
 };
 
 // vendor/computer-use-axi/src/platform/macos/browser.ts
+init_helper();
 var BROWSER_WINDOW_OPEN_TIMEOUT_MS = 1e4;
 var BROWSER_BUNDLE_IDS = /* @__PURE__ */ new Set([
   "com.apple.Safari",
@@ -6688,191 +6974,15 @@ async function openBrowserLocationWithAppleScript(target, url, signal) {
   }
 }
 
-// vendor/computer-use-axi/src/permissions.ts
-function throwIfAborted2(signal) {
-  if (signal?.aborted) throw new Error("Operation aborted.");
-}
-function granted(status, kind) {
-  return status[kind] === true;
-}
-function allGranted(status, kinds) {
-  return kinds.every(({ kind }) => granted(status, kind));
-}
-function missingKinds(status, kinds) {
-  return kinds.flatMap(({ kind }) => granted(status, kind) ? [] : [kind]);
-}
-function permissionStatusSuggestsHelperRestart(status) {
-  return status.screenRecordingPreflight === true && status.screenRecording === false;
-}
-async function ensurePermissions(ctx, bridge, helperPath, signal) {
-  let status = await bridge.checkPermissions(signal);
-  if (allGranted(status, bridge.kinds)) return status;
-  if (!ctx.hasUI) throw new Error(bridge.copy.nonInteractiveError(helperPath));
-  await bridge.registerPermissions(signal).catch(() => void 0);
-  while (!allGranted(status, bridge.kinds)) {
-    throwIfAborted2(signal);
-    const missing = missingKinds(status, bridge.kinds);
-    const options = bridge.kinds.filter(({ kind }) => missing.includes(kind)).map(({ openOption }) => openOption);
-    options.push("Recheck (restarts helper)", "Cancel");
-    const choice = await ctx.ui.select(bridge.copy.prompt(status, helperPath, bridge.permissionHint), options, { signal });
-    if (!choice || choice === "Cancel") throw new Error(bridge.copy.incompleteError(helperPath));
-    const selected = bridge.kinds.find(({ openOption }) => choice === openOption);
-    if (selected) await bridge.openPermissionPane(selected.kind, signal);
-    if (choice.startsWith("Recheck")) {
-      await bridge.restartHelper(signal);
-      status = await bridge.checkPermissions(signal);
-      if (allGranted(status, bridge.kinds)) {
-        ctx.ui.notify(bridge.copy.readyMessage, "info");
-      } else {
-        ctx.ui.notify(bridge.copy.stillMissing(missingKinds(status, bridge.kinds)), "warning");
-      }
-    }
-  }
-  return status;
-}
-
-// vendor/computer-use-axi/src/platform/architecture.ts
-var PLATFORM_ARCHITECTURE_VERSION = 1;
-var REQUIRED_PLATFORM_INVARIANTS = [
-  "state-scoped-observations",
-  "bounded-observation-history",
-  "multi-root-forest",
-  "progressive-disclosure",
-  "atomic-physical-input",
-  "concurrent-requests",
-  "transactional-batching"
-];
-function assertPlatformArchitecture(platform, diagnostics) {
-  if (diagnostics.architectureVersion !== PLATFORM_ARCHITECTURE_VERSION) {
-    throw new Error(`${platform} helper architecture mismatch: expected ${PLATFORM_ARCHITECTURE_VERSION}, got ${diagnostics.architectureVersion ?? "unknown"}. Rebuild and restart the helper.`);
-  }
-  const reported = new Set(diagnostics.invariants ?? []);
-  const missing = REQUIRED_PLATFORM_INVARIANTS.filter((invariant) => !reported.has(invariant));
-  if (missing.length > 0) {
-    throw new Error(`${platform} helper does not satisfy the shared computer-use contract: ${missing.join(", ")}.`);
-  }
-}
+// vendor/computer-use-axi/src/platform/index.ts
+init_permissions2();
 
-// vendor/computer-use-axi/src/platform/macos/permissions.ts
-var GRANT_INSTRUCTIONS = "Grant Accessibility and Screen Recording to pie-computer-use.app in System Settings \u2192 Privacy & Security. Screen Recording lets the agent see the window; Accessibility lets it interact with the window.";
-var SIGNING_MIGRATION_WARNING = "If these permissions were enabled before this install/update, macOS invalidated the old grants because pie-computer-use.app was re-signed. Re-enable both toggles for the newly signed helper. If a toggle is already on, switch it off and on again.";
-var macosPermissionKinds = [
-  { kind: "accessibility", openOption: "Open Accessibility Settings (missing)" },
-  { kind: "screenRecording", openOption: "Open Screen Recording Settings (missing)" }
-];
-function permissionStatusSummary(status) {
-  const lines = [
-    `Accessibility: ${status.accessibility ? "granted" : "missing"}`,
-    `Screen Recording: ${status.screenRecording ? "granted" : "missing"}`
-  ];
-  if (status.screenRecordingPreflight && !status.screenRecording) {
-    lines.push(
-      "(Screen Recording reads granted in the TCC database but a live capture probe failed \u2014 the grant likely belongs to a different app identity, or the helper needs a restart.)"
-    );
-  }
-  return lines.join("; ");
-}
-function permissionPrompt(status, helperPath, hint) {
-  return [
-    "pie-computer-use needs macOS permissions for its helper app.",
-    permissionStatusSummary(status),
-    "",
-    `Helper: pie-computer-use.app (${helperPath})`,
-    hint,
-    "",
-    `Important: ${SIGNING_MIGRATION_WARNING}`,
-    "",
-    "pie-computer-use.app is already listed in the pane(s) \u2014 enable its toggle, then choose Recheck."
-  ].filter(Boolean).join("\n");
-}
-function missingPermissionMessage(kinds) {
-  return `Still missing after restart: ${kinds.join(" and ")}. ${SIGNING_MIGRATION_WARNING} Then choose Recheck again.`;
-}
-async function checkPermissions(signal) {
-  const result = await macosHelper.command("checkPermissions", {}, { signal });
-  const rawSource = result?.source;
-  return {
-    accessibility: toBoolean(result?.accessibility),
-    // Authoritative: the helper's live ScreenCaptureKit probe.
-    screenRecording: toBoolean(result?.screenRecordingCapturable),
-    // Keep the preflight value separate: disagreement means stale per-process
-    // TCC cache or a grant row belonging to another app identity.
-    screenRecordingPreflight: toBoolean(result?.screenRecordingPreflight),
-    source: rawSource && typeof rawSource === "object" ? {
-      // macOS attributes Accessibility / Screen Recording grants to the
-      // responsible process at the top of the launch chain. "helper-app"
-      // is the canonical installed app via LaunchServices; "caller" means
-      // grants would attach to the launching app instead.
-      attribution: rawSource.attribution === "helper-app" ? "helper-app" : "caller",
-      pid: Math.trunc(toFiniteNumber(rawSource.pid, 0)) || void 0,
-      parentPid: Math.trunc(toFiniteNumber(rawSource.parentPid, 0)) || void 0,
-      executablePath: toOptionalString(rawSource.executablePath),
-      parentPath: toOptionalString(rawSource.parentPath),
-      parentBundleId: toOptionalString(rawSource.parentBundleId),
-      os: toOptionalString(rawSource.macOS)
-    } : void 0
-  };
-}
-var registeredForHelperPid;
-async function registerPermissions(signal) {
-  const helperPid = macosHelper.diagnostics?.pid;
-  if (helperPid !== void 0 && helperPid === registeredForHelperPid) return;
-  await macosHelper.command("registerPermissions", {}, { signal, timeoutMs: 15e3 });
-  registeredForHelperPid = helperPid;
-}
-var autoRestartAttempted = false;
-async function ensureMacosReady(ctx, state, signal) {
-  await macosHelper.ensureInstalled(signal);
-  if (!await macosHelper.ensureDaemon(signal)) {
-    throw new Error(`pie-computer-use helper app daemon did not start. Helper app: ${HELPER_APP_PATH}`);
-  }
-  const helperDiagnostics = await macosHelper.ensureProtocol(signal);
-  assertPlatformArchitecture("macOS", helperDiagnostics);
-  const now = Date.now();
-  const cachedStatus = state.permissionStatus;
-  const canUseCachedPermissions = cachedStatus?.accessibility && cachedStatus.screenRecording && now - state.lastPermissionCheckAt < 2e3;
-  if (canUseCachedPermissions) {
-    return { ...state, helperDiagnostics };
-  }
-  let permissionStatus = await checkPermissions(signal);
-  let lastPermissionCheckAt = now;
-  if (!autoRestartAttempted && permissionStatusSuggestsHelperRestart(permissionStatus)) {
-    autoRestartAttempted = true;
-    await macosHelper.restart(signal).catch(() => void 0);
-    permissionStatus = await checkPermissions(signal);
-    lastPermissionCheckAt = Date.now();
-  }
-  if (!permissionStatus.accessibility || !permissionStatus.screenRecording) {
-    const attributionHint = permissionStatus.source?.attribution === "caller" ? `Warning: the helper is not running as the installed pie-computer-use.app (executable: ${permissionStatus.source?.executablePath ?? "unknown"}). Grants made now would attach to the launching app instead. Restart Pie so the canonical helper is used.` : void 0;
-    permissionStatus = await ensurePermissions(
-      ctx,
-      {
-        kinds: macosPermissionKinds,
-        copy: {
-          nonInteractiveError: (helperPath) => `computer-use setup requires an interactive session. Run Pie in interactive mode. ${GRANT_INSTRUCTIONS}
-Helper path: ${helperPath}`,
-          prompt: permissionPrompt,
-          incompleteError: (helperPath) => `pie-computer-use setup is incomplete. ${GRANT_INSTRUCTIONS} Helper path: ${helperPath}`,
-          readyMessage: "pie-computer-use is ready.",
-          stillMissing: missingPermissionMessage
-        },
-        checkPermissions: (permissionSignal) => checkPermissions(permissionSignal ?? signal),
-        registerPermissions: (permissionSignal) => registerPermissions(permissionSignal ?? signal),
-        openPermissionPane: async (kind, permissionSignal) => {
-          await macosHelper.command("openPermissionPane", { kind }, { signal: permissionSignal ?? signal });
-        },
-        restartHelper: (permissionSignal) => macosHelper.restart(permissionSignal ?? signal),
-        permissionHint: attributionHint
-      },
-      HELPER_APP_PATH,
-      signal
-    );
-    lastPermissionCheckAt = Date.now();
-  }
-  return { permissionStatus, lastPermissionCheckAt, helperDiagnostics };
-}
+// vendor/computer-use-axi/src/platform/linux/backend.ts
+init_architecture();
+init_coerce();
 
 // vendor/computer-use-axi/src/platform/linux/helper.ts
+init_package_root();
 import { spawn as spawn2 } from "node:child_process";
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { constants as fsConstants3 } from "node:fs";
@@ -7272,7 +7382,11 @@ var linuxBackend = {
   }
 };
 
+// vendor/computer-use-axi/src/platform/windows/backend.ts
+init_coerce();
+
 // vendor/computer-use-axi/src/platform/windows/helper.ts
+init_package_root();
 import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { constants as fsConstants4 } from "node:fs";
@@ -7430,6 +7544,7 @@ var WindowsHelperClient = class {
 var windowsHelper = new WindowsHelperClient();
 
 // vendor/computer-use-axi/src/platform/windows/backend.ts
+init_architecture();
 function normalizedProcessName2(appName) {
   return appName.toLowerCase().replace(/\.exe$/i, "");
 }
@@ -7970,10 +8085,10 @@ function shouldPreferForegroundModalWindow(current, candidate) {
 }
 
 // vendor/computer-use-axi/src/state.ts
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var SavedStates = class {
   store;
-  operations = new AsyncLocalStorage();
+  operations = new AsyncLocalStorage2();
   constructor(store = new StateStore(128)) {
     this.store = store;
   }
@@ -8241,6 +8356,8 @@ function bumpHelperGeneration() {
   return helperGeneration;
 }
 function expireStatesAfterHelperRestart(reason = "the native helper restarted") {
+  runtimeState.permissionStatus = void 0;
+  runtimeState.lastPermissionCheckAt = 0;
   const ids = savedStates.store.ids?.() ?? [];
   for (const id of ids) expiredStateReasons.set(id, reason);
   savedStates.clear();
@@ -8460,7 +8577,6 @@ function emptyActivation() {
   return { activated: false, unminimized: false, raised: false };
 }
 async function ensureReady3(ctx, signal) {
-  loadComputerUseConfig(ctx.cwd);
   throwIfAborted3(signal);
   const ready = await currentPlatformBackend.ensureReady(
     ctx,
@@ -10079,12 +10195,11 @@ async function executeTool(tool, ctx, params, signal, run, runtime) {
   operation.signal = signal ?? runtime?.signal;
   operation.onDispatch = runtime?.onDispatch;
   if (requestedStateId && stateRecord) assertStateAccess(requestedStateId, stateRecord, operation);
-  return await savedStates.operations.run(operation, async () => {
+  return await withComputerUseConfig(ctx.cwd, () => savedStates.operations.run(operation, async () => {
     try {
       const browserOnly = operation.contextId || ["launch_browser", "navigate_browser", "evaluate_browser"].includes(tool) || tool === "find_roots" && params.kind === "browser_page" || tool === "observe_ui" && runtimeState.browserContextByRoot.has(params.root ?? "");
       await resourceScheduler.read("session-lifecycle", async () => {
         if (browserOnly || outputRef) {
-          loadComputerUseConfig(ctx.cwd);
           if (browserOnly && !outputRef && tool !== "find_roots" && !isBrowserUseEnabled()) {
             throw new Error("Browser use is disabled by computer-use config. Enable browser_use to control browser pages.");
           }
@@ -10097,7 +10212,7 @@ async function executeTool(tool, ctx, params, signal, run, runtime) {
     } finally {
       for (const artifactId of operation.artifactIds ?? []) engineArtifacts?.unpin(artifactId);
     }
-  });
+  }));
 }
 var BROKER_PERFORMERS = {
   find_roots: performListWindows,
@@ -10272,6 +10387,9 @@ async function startBroker(options = {}) {
   });
   saveBrokerManifest({ generation, helperGeneration: helperGeneration2, stateIds: [], updatedAt: Date.now() });
   const entries = /* @__PURE__ */ new Map();
+  const acceptedIds = /* @__PURE__ */ new Set();
+  const resultCacheLimit = options.resultCacheLimit ?? BROKER_RESULT_CACHE_MAX_ENTRIES;
+  const replayLedgerLimit = options.replayLedgerLimit ?? BROKER_REPLAY_LEDGER_MAX_IDS;
   const owners = /* @__PURE__ */ new Set();
   const knownStateIds = /* @__PURE__ */ new Set();
   let active = 0;
@@ -10279,6 +10397,7 @@ async function startBroker(options = {}) {
   let lastActivity = Date.now();
   let drainRequested = false;
   let stopping = false;
+  let permissionSetupInFlight = false;
   let idleTimer;
   let statusHandle;
   const persistManifest = () => {
@@ -10401,8 +10520,12 @@ async function startBroker(options = {}) {
     }
   };
   const handleEngineRequest = async (request, socket) => {
-    if (stopping || drainRequested) {
-      send(socket, { type: "response", requestId: request.requestId, ok: false, state: "error", generation, helperGeneration: currentHelperGenerationSafe(), error: { code: "broker_draining", message: "The broker is shutting down and draining in-flight work; this request was not accepted. Retry after it exits.", dispatched: false } });
+    if (stopping || drainRequested || permissionSetupInFlight) {
+      send(socket, { type: "response", requestId: request.requestId, ok: false, state: "error", generation, helperGeneration: currentHelperGenerationSafe(), error: { code: "broker_draining", message: "The broker is draining or performing permission setup; this request was not accepted. Retry after it finishes.", dispatched: false } });
+      return;
+    }
+    if (request.generation && request.generation !== generation) {
+      send(socket, { type: "response", requestId: request.requestId, ok: false, state: "error", generation, helperGeneration: currentHelperGenerationSafe(), error: { code: "generation_mismatch", message: "Request belongs to another broker generation. Observe again; do not replay old actions." } });
       return;
     }
     const key = request.requestId;
@@ -10419,18 +10542,23 @@ async function startBroker(options = {}) {
       else respond({ ...existing, socket }, "error", void 0, existing.error);
       return;
     }
-    if (request.generation && request.generation !== generation) {
-      send(socket, { type: "response", requestId: request.requestId, ok: false, state: "error", generation, helperGeneration: currentHelperGenerationSafe(), error: { code: "generation_mismatch", message: `This state belongs to broker generation ${request.generation}; the live broker is ${generation}. Observe again.` } });
+    if (acceptedIds.has(key) || acceptedIds.size >= replayLedgerLimit) {
+      send(socket, { type: "response", requestId: key, ok: false, state: "error", generation, helperGeneration: currentHelperGenerationSafe(), error: { code: acceptedIds.has(key) ? "request_id_expired" : "request_ledger_full", message: acceptedIds.has(key) ? "Result expired; this requestId cannot be replayed. Observe again." : "Replay ledger is full. Stop the broker safely, then observe in a new generation. Do not replay prior actions.", dispatched: false } });
       return;
     }
-    if (entries.size >= 256) {
+    if (entries.size >= resultCacheLimit) {
       for (const [id, candidate] of entries) {
-        if (candidate.state === "done" || candidate.state === "error" || candidate.state === "unknown") {
+        if (candidate.state === "done" || candidate.state === "error") {
           entries.delete(id);
           break;
         }
       }
     }
+    if (entries.size >= resultCacheLimit) {
+      send(socket, { type: "response", requestId: key, ok: false, state: "error", generation, helperGeneration: currentHelperGenerationSafe(), error: { code: "broker_busy", message: "Request retention is full of unconfirmed work; no action dispatched.", dispatched: false } });
+      return;
+    }
+    acceptedIds.add(key);
     const entry = {
       requestId: request.requestId,
       ownerId: request.ownerId,
@@ -10485,6 +10613,31 @@ async function startBroker(options = {}) {
       send(socket, { type: "response", requestId: request.requestId, ok: true, state: "done", generation, helperGeneration: currentHelperGenerationSafe(), result: statusHandle?.status() });
       return;
     }
+    if (request.command === "permissions") {
+      const reply = (result, error) => send(socket, { type: "response", requestId: request.requestId, ok: !error, state: error ? "error" : "done", generation, helperGeneration: currentHelperGenerationSafe(), result, error });
+      if (permissionSetupInFlight || [...entries.values()].some((entry) => ["running", "queued", "unknown"].includes(entry.state))) {
+        reply(void 0, { code: "broker_busy", message: "Permission setup requires an idle broker with no unconfirmed actions. Wait for work to settle first.", dispatched: false });
+        return;
+      }
+      permissionSetupInFlight = true;
+      try {
+        if (process.platform !== "darwin" || options.testCommands) throw new Error("macOS permission setup requires a real macOS desktop backend.");
+        const mode = request.params.mode;
+        if (mode === "recheck") {
+          liveHelperGeneration = bumpHelperGeneration();
+          expireStatesAfterHelperRestart();
+        }
+        const { setupMacosPermissions: setupMacosPermissions2 } = await Promise.resolve().then(() => (init_permissions2(), permissions_exports));
+        const status = await setupMacosPermissions2(mode);
+        const ready = status.accessibility && status.screenRecording;
+        reply({ details: status, isError: !ready, content: [{ type: "text", text: ready ? "Permissions granted. Observe a fresh root before acting." : "Grant Accessibility and Screen Recording to pie-computer-use.app in the opened Settings panes, then run 'computer-use-axi permissions recheck'." }] });
+      } catch (error) {
+        reply(void 0, { code: "permission_setup_failed", message: error instanceof Error ? error.message : String(error) });
+      } finally {
+        permissionSetupInFlight = false;
+      }
+      return;
+    }
     if (request.command === "debug_restart_helper") {
       if (!options.testCommands) {
         send(socket, { type: "response", requestId: request.requestId, ok: false, state: "error", generation, helperGeneration: currentHelperGenerationSafe(), error: { code: "unknown_command", message: "Test commands are disabled." } });
@@ -10620,7 +10773,7 @@ async function startBroker(options = {}) {
           });
           continue;
         }
-        void (request.command === "status" || request.command === "stop" || request.command === "debug_restart_helper" ? handleControl(request, socket) : handleEngineRequest(request, socket));
+        void (request.command === "status" || request.command === "stop" || request.command === "permissions" || request.command === "debug_restart_helper" ? handleControl(request, socket) : handleEngineRequest(request, socket));
       }
     });
     socket.on("close", () => {
@@ -10696,7 +10849,7 @@ async function startBroker(options = {}) {
       }
     }
     const deadline = Date.now() + BROKER_DRAIN_MAX_MS;
-    while ([...entries.values()].some((entry) => entry.state === "running" || entry.state === "unknown") && Date.now() < deadline) {
+    while ((permissionSetupInFlight || [...entries.values()].some((entry) => entry.state === "running" || entry.state === "unknown")) && Date.now() < deadline) {
       await sleep3(50);
     }
     persistManifest();
@@ -10773,7 +10926,7 @@ async function startBroker(options = {}) {
   idleTimer = setInterval(() => {
     if (stopping) return;
     const uncertain = [...entries.values()].some((entry) => entry.state === "running" || entry.state === "unknown" || entry.state === "queued");
-    if (uncertain) return;
+    if (uncertain || permissionSetupInFlight) return;
     if (Date.now() - lastActivity < idleExitMs) return;
     void shutdown("idle");
   }, Math.min(6e4, Math.max(1e3, Math.floor(idleExitMs / 4))));
@@ -10815,8 +10968,13 @@ async function loadTestOnlyBackend() {
 }
 async function main() {
   const fake = await loadTestOnlyBackend();
+  const testCommands = process.env.PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS === "1";
   const handle = await startBroker({
-    testCommands: process.env.PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS === "1",
+    testCommands,
+    // Fail-closed capacity contract hooks (tests only; both require the
+    // explicit test-command switch and are ignored in every other build).
+    resultCacheLimit: testCommands && Number.isFinite(Number(process.env.PIE_COMPUTER_USE_TEST_RESULT_CACHE_LIMIT)) ? Math.trunc(Number(process.env.PIE_COMPUTER_USE_TEST_RESULT_CACHE_LIMIT)) : void 0,
+    replayLedgerLimit: testCommands && Number.isFinite(Number(process.env.PIE_COMPUTER_USE_TEST_REPLAY_LEDGER_LIMIT)) ? Math.trunc(Number(process.env.PIE_COMPUTER_USE_TEST_REPLAY_LEDGER_LIMIT)) : void 0,
     restartTestHelper: fake ? () => fake.fakeControl.restart() : void 0,
     onShutdown: () => {
       setTimeout(() => process.exit(0), 50).unref();