@cydm/pie 2.6.12 → 2.7.1

package/dist/builtin/{extensions/computer-use/index.js → skills/computer-use-axi/computer-use-axi-broker.js}

@@ -1,15 +1,40 @@
+#!/usr/bin/env node
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  getConfigDir
-} from "../../../chunks/chunk-5353DEEC.js";
-import {
-  Type
-} from "../../../chunks/chunk-XXGYUYXI.js";
-import {
-  __commonJS,
-  __require,
-  __toESM
-} from "../../../chunks/chunk-LZQXQOPJ.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // ../../node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
@@ -2248,9 +2273,9 @@ var require_websocket = __commonJS({
     var EventEmitter = __require("events");
     var https = __require("https");
     var http = __require("http");
-    var net3 = __require("net");
+    var net4 = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash } = __require("crypto");
+    var { randomBytes, createHash: createHash4 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2931,7 +2956,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash4("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3005,12 +3030,12 @@ var require_websocket = __commonJS({
     }
     function netConnect(options) {
       options.path = options.socketPath;
-      return net3.connect(options);
+      return net4.connect(options);
     }
     function tlsConnect(options) {
       options.path = void 0;
       if (!options.servername && options.servername !== "") {
-        options.servername = net3.isIP(options.host) ? "" : options.host;
+        options.servername = net4.isIP(options.host) ? "" : options.host;
       }
       return tls.connect(options);
     }
@@ -3300,7 +3325,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash } = __require("crypto");
+    var { createHash: createHash4 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3607,7 +3632,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash4("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -3694,16 +3719,834 @@ var require_websocket_server = __commonJS({
   }
 });
 
-// builtin/extensions/computer-use/src/bridge.ts
+// 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;
+  return OWNER_PATTERN.test(trimmed) ? trimmed : COMPUTER_USE_STANDALONE_OWNER;
+}
+
+// vendor/computer-use-axi/src/broker-protocol.ts
+var BROKER_PROTOCOL_VERSION = 1;
+var BROKER_ENGINE_VERSION = 1;
+var BROKER_PACKAGE_VERSION = "0.5.1-pie.1";
+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_IDLE_EXIT_MS = 30 * 6e4;
+var BROKER_DRAIN_MAX_MS = 3e4;
+var ENGINE_COMMANDS = [
+  "find_roots",
+  "observe_ui",
+  "search_ui",
+  "expand_ui",
+  "inspect_ui",
+  "read_text",
+  "wait_for",
+  "act_ui",
+  "launch_browser",
+  "navigate_browser",
+  "evaluate_browser"
+];
+var CONTROL_COMMANDS = ["status", "stop", "debug_restart_helper"];
+function isEngineCommand(value) {
+  return ENGINE_COMMANDS.includes(value);
+}
+function isControlCommand(value) {
+  return CONTROL_COMMANDS.includes(value);
+}
+function computeBuildIdentity() {
+  const seed = `${BROKER_PROTOCOL_VERSION}:${BROKER_ENGINE_VERSION}:${BROKER_PACKAGE_VERSION}`;
+  return {
+    version: BROKER_PACKAGE_VERSION,
+    identity: createHash("sha256").update(seed).digest("hex").slice(0, 16)
+  };
+}
+var BROKER_BUILD = computeBuildIdentity();
+var BrokerProtocolError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BrokerProtocolError";
+  }
+  code;
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertPlainRecord(value, label2) {
+  if (!isRecord(value)) throw new BrokerProtocolError("invalid_frame", `${label2} must be an object.`);
+  for (const key of Object.keys(value)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      throw new BrokerProtocolError("invalid_frame", `${label2} contains a forbidden key '${key}'.`);
+    }
+  }
+}
+var REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+var STATE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]{0,127}$/;
+var ROOT_REF_PATTERN = /^@r\d{1,6}$/;
+var ELEMENT_REF_PATTERN = /^@e\d{1,6}$/;
+var OUTPUT_REF_PATTERN = /^@o\d{1,9}$/;
+function boundedString(value, label2, maxBytes) {
+  if (typeof value !== "string") throw new BrokerProtocolError("invalid_params", `${label2} must be a string.`);
+  if (Buffer.byteLength(value, "utf8") > maxBytes) throw new BrokerProtocolError("invalid_params", `${label2} is too large.`);
+  return value;
+}
+function boundedNumber(value, label2, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new BrokerProtocolError("invalid_params", `${label2} must be a finite number.`);
+  if (value < min || value > max) throw new BrokerProtocolError("invalid_params", `${label2} is out of range.`);
+  return value;
+}
+function oneOf(value, label2, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new BrokerProtocolError("invalid_params", `${label2} must be one of ${allowed.join(", ")}.`);
+  }
+  return value;
+}
+function assertKeys(value, label2, allowed) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.includes(key)) throw new BrokerProtocolError("invalid_params", `${label2} has unknown field '${key}'.`);
+  }
+}
+function stateId(value, label2 = "stateId") {
+  if (typeof value !== "string" || !STATE_ID_PATTERN.test(value)) {
+    throw new BrokerProtocolError("invalid_params", `${label2} is not a valid state id.`);
+  }
+  return value;
+}
+function elementOrOutputRef(value, label2) {
+  if (typeof value !== "string" || !ELEMENT_REF_PATTERN.test(value) && !OUTPUT_REF_PATTERN.test(value)) {
+    throw new BrokerProtocolError("invalid_params", `${label2} must be an @e or @o ref.`);
+  }
+  return value;
+}
+function elementRef(value, label2) {
+  if (typeof value !== "string" || !ELEMENT_REF_PATTERN.test(value)) {
+    throw new BrokerProtocolError("invalid_params", `${label2} must be an @e ref.`);
+  }
+  return value;
+}
+function httpUrl(value, label2) {
+  const url = boundedString(value, label2, 2048);
+  if (!/^https?:\/\//i.test(url)) throw new BrokerProtocolError("invalid_params", `${label2} must be an absolute HTTP(S) URL.`);
+  return url;
+}
+function validateCondition(value, label2) {
+  assertPlainRecord(value, label2);
+  assertKeys(value, label2, ["ref", "scopeRef", "text", "role", "value", "until", "timeoutMs"]);
+  const condition = {};
+  if (value.ref !== void 0) condition.ref = elementRef(value.ref, `${label2}.ref`);
+  if (value.scopeRef !== void 0) condition.scopeRef = elementRef(value.scopeRef, `${label2}.scopeRef`);
+  if (value.text !== void 0) condition.text = boundedString(value.text, `${label2}.text`, 8192);
+  if (value.role !== void 0) condition.role = boundedString(value.role, `${label2}.role`, 256);
+  if (value.value !== void 0) condition.value = boundedString(value.value, `${label2}.value`, 8192);
+  if (value.until !== void 0) condition.until = oneOf(value.until, `${label2}.until`, ["present", "absent"]);
+  if (value.timeoutMs !== void 0) condition.timeoutMs = boundedNumber(value.timeoutMs, `${label2}.timeoutMs`, 1, 6e4);
+  return condition;
+}
+function validateAction(value, index) {
+  const label2 = `actions[${index}]`;
+  assertPlainRecord(value, label2);
+  assertKeys(value, label2, ["action", "ref", "x", "y", "text", "keys", "scrollX", "scrollY", "path", "button", "clickCount"]);
+  const action = {
+    action: oneOf(value.action, `${label2}.action`, ["press", "click", "setText", "typeText", "keypress", "scroll", "drag", "moveMouse"])
+  };
+  if (value.ref !== void 0) action.ref = elementRef(value.ref, `${label2}.ref`);
+  if (value.x !== void 0) action.x = boundedNumber(value.x, `${label2}.x`, -1e6, 1e6);
+  if (value.y !== void 0) action.y = boundedNumber(value.y, `${label2}.y`, -1e6, 1e6);
+  if (value.text !== void 0) action.text = boundedString(value.text, `${label2}.text`, 64 * 1024);
+  if (value.keys !== void 0) {
+    if (!Array.isArray(value.keys) || value.keys.length === 0 || value.keys.length > 32) {
+      throw new BrokerProtocolError("invalid_params", `${label2}.keys must be a non-empty array of at most 32 keys.`);
+    }
+    action.keys = value.keys.map((key, keyIndex) => boundedString(key, `${label2}.keys[${keyIndex}]`, 64));
+  }
+  if (value.scrollX !== void 0) action.scrollX = boundedNumber(value.scrollX, `${label2}.scrollX`, -1e6, 1e6);
+  if (value.scrollY !== void 0) action.scrollY = boundedNumber(value.scrollY, `${label2}.scrollY`, -1e6, 1e6);
+  if (value.path !== void 0) {
+    if (!Array.isArray(value.path) || value.path.length > 256) {
+      throw new BrokerProtocolError("invalid_params", `${label2}.path must be an array of at most 256 points.`);
+    }
+    action.path = value.path.map((point, pointIndex) => {
+      if (Array.isArray(point)) {
+        if (point.length !== 2) throw new BrokerProtocolError("invalid_params", `${label2}.path[${pointIndex}] must be [x,y].`);
+        return [boundedNumber(point[0], `${label2}.path[${pointIndex}][0]`, -1e6, 1e6), boundedNumber(point[1], `${label2}.path[${pointIndex}][1]`, -1e6, 1e6)];
+      }
+      assertPlainRecord(point, `${label2}.path[${pointIndex}]`);
+      assertKeys(point, `${label2}.path[${pointIndex}]`, ["x", "y"]);
+      return {
+        x: boundedNumber(point.x, `${label2}.path[${pointIndex}].x`, -1e6, 1e6),
+        y: boundedNumber(point.y, `${label2}.path[${pointIndex}].y`, -1e6, 1e6)
+      };
+    });
+  }
+  if (value.button !== void 0) action.button = oneOf(value.button, `${label2}.button`, ["left", "right", "middle"]);
+  if (value.clickCount !== void 0) action.clickCount = Math.trunc(boundedNumber(value.clickCount, `${label2}.clickCount`, 1, 3));
+  const hasRef = typeof action.ref === "string";
+  const hasX = action.x !== void 0;
+  const hasY = action.y !== void 0;
+  if (hasX !== hasY) throw new BrokerProtocolError("invalid_params", `${label2} coordinates require both x and y.`);
+  const hasPoint = hasX && hasY;
+  if ((action.action === "click" || action.action === "moveMouse") && hasRef === hasPoint) {
+    throw new BrokerProtocolError("invalid_params", `${label2}.${String(action.action)} requires exactly one target: ref or x/y coordinates.`);
+  }
+  if (action.action === "press" && !hasRef) throw new BrokerProtocolError("invalid_params", `${label2}.press requires an actionable ref.`);
+  if (action.action === "keypress" && !Array.isArray(action.keys)) throw new BrokerProtocolError("invalid_params", `${label2}.keypress requires keys.`);
+  if (action.action === "drag" && !Array.isArray(action.path)) throw new BrokerProtocolError("invalid_params", `${label2}.drag requires path.`);
+  if (action.action === "scroll" && (action.scrollX ?? 0) === 0 && (action.scrollY ?? 0) === 0) {
+    throw new BrokerProtocolError("invalid_params", `${label2}.scroll requires a non-zero scrollX or scrollY delta.`);
+  }
+  if ((action.action === "setText" || action.action === "typeText") && typeof action.text !== "string") {
+    throw new BrokerProtocolError("invalid_params", `${label2}.${String(action.action)} requires text.`);
+  }
+  return action;
+}
+function validateCommandParams(command, raw) {
+  if (command === "status" || command === "stop") {
+    if (raw === void 0 || raw === null) return {};
+    assertPlainRecord(raw, "params");
+    assertKeys(raw, "params", []);
+    return {};
+  }
+  if (command === "debug_restart_helper") {
+    if (raw === void 0 || raw === null) return {};
+    assertPlainRecord(raw, "params");
+    assertKeys(raw, "params", []);
+    return {};
+  }
+  assertPlainRecord(raw, "params");
+  const params = raw;
+  switch (command) {
+    case "find_roots": {
+      assertKeys(params, "params", ["text", "app", "bundleId", "pid", "kind"]);
+      const out = {};
+      if (params.text !== void 0) out.text = boundedString(params.text, "text", 512);
+      if (params.app !== void 0) out.app = boundedString(params.app, "app", 512);
+      if (params.bundleId !== void 0) out.bundleId = boundedString(params.bundleId, "bundleId", 512);
+      if (params.pid !== void 0) out.pid = Math.trunc(boundedNumber(params.pid, "pid", 1, 2 ** 31 - 1));
+      if (params.kind !== void 0) out.kind = oneOf(params.kind, "kind", ["window", "menu", "sheet", "popover", "dialog", "browser_page"]);
+      return out;
+    }
+    case "observe_ui": {
+      assertKeys(params, "params", ["root", "mode", "readText"]);
+      const out = {};
+      if (params.root !== void 0) {
+        if (typeof params.root !== "string" || !ROOT_REF_PATTERN.test(params.root)) throw new BrokerProtocolError("invalid_params", "root must be an @r ref.");
+        out.root = params.root;
+      }
+      if (params.mode !== void 0) out.mode = oneOf(params.mode, "mode", ["semantic", "visual", "fused"]);
+      if (params.readText !== void 0) out.readText = oneOf(params.readText, "readText", ["auto", "always", "never"]);
+      return out;
+    }
+    case "search_ui": {
+      assertKeys(params, "params", ["stateId", "text", "role", "capability"]);
+      const out = { stateId: stateId(params.stateId) };
+      let matchers = 0;
+      if (params.text !== void 0) {
+        out.text = boundedString(params.text, "text", 512);
+        matchers += 1;
+      }
+      if (params.role !== void 0) {
+        out.role = boundedString(params.role, "role", 128);
+        matchers += 1;
+      }
+      if (params.capability !== void 0) {
+        out.capability = boundedString(params.capability, "capability", 128);
+        matchers += 1;
+      }
+      if (matchers === 0) throw new BrokerProtocolError("invalid_params", "search_ui requires text, role, or capability.");
+      return out;
+    }
+    case "expand_ui": {
+      assertKeys(params, "params", ["stateId", "ref", "depth"]);
+      const out = { stateId: stateId(params.stateId), ref: elementRef(params.ref, "ref") };
+      if (params.depth !== void 0) out.depth = Math.trunc(boundedNumber(params.depth, "depth", 1, 8));
+      return out;
+    }
+    case "inspect_ui": {
+      assertKeys(params, "params", ["stateId", "ref"]);
+      return { stateId: stateId(params.stateId), ref: elementRef(params.ref, "ref") };
+    }
+    case "read_text": {
+      assertKeys(params, "params", ["stateId", "ref", "offset"]);
+      const out = { ref: elementOrOutputRef(params.ref, "ref") };
+      if (typeof out.ref === "string" && out.ref.startsWith("@e")) out.stateId = stateId(params.stateId);
+      else if (params.stateId !== void 0) out.stateId = stateId(params.stateId);
+      if (params.offset !== void 0) out.offset = Math.trunc(boundedNumber(params.offset, "offset", 0, 2 ** 31));
+      return out;
+    }
+    case "wait_for": {
+      assertKeys(params, "params", ["stateId", "text", "role", "value", "ref", "scopeRef", "until", "timeoutMs"]);
+      const out = { stateId: stateId(params.stateId) };
+      if (params.ref !== void 0) out.ref = elementRef(params.ref, "ref");
+      if (params.scopeRef !== void 0) out.scopeRef = elementRef(params.scopeRef, "scopeRef");
+      if (params.text !== void 0) out.text = boundedString(params.text, "text", 8192);
+      if (params.role !== void 0) out.role = boundedString(params.role, "role", 256);
+      if (params.value !== void 0) out.value = boundedString(params.value, "value", 8192);
+      if (params.until !== void 0) out.until = oneOf(params.until, "until", ["present", "absent"]);
+      if (params.timeoutMs !== void 0) out.timeoutMs = boundedNumber(params.timeoutMs, "timeoutMs", 100, 6e4);
+      return out;
+    }
+    case "act_ui": {
+      assertKeys(params, "params", ["stateId", "actions", "expect"]);
+      if (!Array.isArray(params.actions) || params.actions.length === 0 || params.actions.length > 20) {
+        throw new BrokerProtocolError("invalid_params", "actions must be a non-empty array of at most 20 actions.");
+      }
+      const out = {
+        stateId: stateId(params.stateId),
+        actions: params.actions.map((action, index) => validateAction(action, index))
+      };
+      if (params.expect !== void 0) out.expect = validateCondition(params.expect, "expect");
+      return out;
+    }
+    case "launch_browser": {
+      assertKeys(params, "params", ["url"]);
+      const out = {};
+      if (params.url !== void 0) out.url = httpUrl(params.url, "url");
+      return out;
+    }
+    case "navigate_browser": {
+      assertKeys(params, "params", ["stateId", "url"]);
+      return { stateId: stateId(params.stateId), url: httpUrl(params.url, "url") };
+    }
+    case "evaluate_browser": {
+      assertKeys(params, "params", ["stateId", "expression"]);
+      const expression = boundedString(params.expression, "expression", 256 * 1024);
+      if (!expression.trim()) throw new BrokerProtocolError("invalid_params", "expression must be non-empty.");
+      return { stateId: stateId(params.stateId), expression };
+    }
+    default:
+      throw new BrokerProtocolError("unknown_command", `Unknown command '${String(command)}'.`);
+  }
+}
+function validateRequest(value) {
+  assertPlainRecord(value, "request");
+  if (value.type !== "request") throw new BrokerProtocolError("invalid_frame", "Expected a request frame.");
+  const commandCandidate = typeof value.command === "string" ? value.command : "";
+  if (value.protocolVersion !== BROKER_PROTOCOL_VERSION && commandCandidate !== "stop") {
+    throw new BrokerProtocolError("protocol_mismatch", `Protocol mismatch: broker ${BROKER_PROTOCOL_VERSION}, client ${String(value.protocolVersion)}.`);
+  }
+  if (typeof value.requestId !== "string" || !REQUEST_ID_PATTERN.test(value.requestId)) {
+    throw new BrokerProtocolError("invalid_request", "requestId is missing or malformed.");
+  }
+  const ownerId = normalizeComputerUseOwner(value.ownerId);
+  if (typeof value.ownerId === "string" && value.ownerId.trim() && ownerId === COMPUTER_USE_STANDALONE_OWNER && value.ownerId.trim() !== COMPUTER_USE_STANDALONE_OWNER) {
+    throw new BrokerProtocolError("invalid_request", "ownerId is malformed.");
+  }
+  if (!isEngineCommand(commandCandidate) && !isControlCommand(commandCandidate)) {
+    throw new BrokerProtocolError("unknown_command", `Unknown command '${commandCandidate}'.`);
+  }
+  const command = commandCandidate;
+  if (command === "debug_restart_helper" && value.params !== void 0 && value.params !== null) {
+    assertPlainRecord(value.params, "params");
+  }
+  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));
+  return {
+    requestId: value.requestId,
+    ownerId,
+    executionId: value.executionId === void 0 ? void 0 : boundedString(value.executionId, "executionId", 256),
+    generation: value.generation === void 0 ? void 0 : boundedString(value.generation, "generation", 128),
+    command,
+    params,
+    cwd,
+    budgetMs
+  };
+}
+function validateHello(value) {
+  assertPlainRecord(value, "hello");
+  if (value.type !== "hello") throw new BrokerProtocolError("invalid_frame", "Expected a hello frame.");
+  if (value.protocolVersion !== BROKER_PROTOCOL_VERSION) {
+    throw new BrokerProtocolError("protocol_mismatch", `Protocol mismatch: broker ${BROKER_PROTOCOL_VERSION}, client ${String(value.protocolVersion)}.`);
+  }
+  return {
+    type: "hello",
+    protocolVersion: value.protocolVersion,
+    clientVersion: value.clientVersion === void 0 ? void 0 : boundedString(value.clientVersion, "clientVersion", 128)
+  };
+}
+function encodeFrame(value, maxBytes = BROKER_MAX_FRAME_BYTES) {
+  let json;
+  try {
+    json = JSON.stringify(value);
+  } catch (error) {
+    throw new BrokerProtocolError("encode_failed", error instanceof Error ? error.message : String(error));
+  }
+  const bytes = Buffer.byteLength(json, "utf8");
+  if (bytes > maxBytes) throw new BrokerProtocolError("frame_too_large", `Frame of ${bytes} bytes exceeds the ${maxBytes}-byte limit.`);
+  return Buffer.from(`${json}
+`, "utf8");
+}
+var FrameDecoder = class {
+  constructor(maxBytes = BROKER_MAX_FRAME_BYTES) {
+    this.maxBytes = maxBytes;
+  }
+  maxBytes;
+  buffer = Buffer.alloc(0);
+  push(chunk) {
+    this.buffer = this.buffer.length === 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+    const frames = [];
+    for (; ; ) {
+      const newline = this.buffer.indexOf(10);
+      if (newline < 0) break;
+      const line = this.buffer.subarray(0, newline).toString("utf8").trim();
+      this.buffer = this.buffer.subarray(newline + 1);
+      if (!line) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        throw new BrokerProtocolError("invalid_json", "Frame is not valid JSON.");
+      }
+      frames.push(parsed);
+    }
+    if (this.buffer.length > this.maxBytes) {
+      throw new BrokerProtocolError("frame_too_large", `Unterminated frame exceeds the ${this.maxBytes}-byte limit.`);
+    }
+    return frames;
+  }
+};
+function resolveBrokerEndpoint(env = process.env) {
+  const socketOverride = env.PIE_COMPUTER_USE_BROKER_SOCKET?.trim();
+  if (process.platform === "win32") {
+    const seed = socketOverride || stateRootDir(env);
+    const key = createHash("sha256").update(seed).digest("hex").slice(0, 16);
+    return { kind: "named-pipe", path: `\\\\.\\pipe\\pie-computer-use-axi-${key}` };
+  }
+  const socketPath = socketOverride || path2.join(stateRootDir(env), "run", "broker.sock");
+  if (Buffer.byteLength(socketPath, "utf8") > 100) {
+    throw new BrokerProtocolError("endpoint_too_long", `Unix socket path is ${Buffer.byteLength(socketPath)} bytes (limit ~104): ${socketPath}. Set PIE_COMPUTER_USE_BROKER_SOCKET to a shorter path.`);
+  }
+  return { kind: "unix-socket", path: socketPath, directory: path2.dirname(socketPath) };
+}
+function ensurePrivateDirectory(directory) {
+  mkdirSync3(directory, { recursive: true, mode: 448 });
+  const stats = lstatSync2(directory);
+  if (stats.isSymbolicLink()) throw new BrokerProtocolError("unsafe_path", `Refusing symlinked private directory: ${directory}`);
+  if (!stats.isDirectory()) throw new BrokerProtocolError("unsafe_path", `Not a directory: ${directory}`);
+  if (process.platform !== "win32") chmodSync(directory, 448);
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    const record = value;
+    const sorted = {};
+    for (const key of Object.keys(record).sort()) sorted[key] = canonicalize(record[key]);
+    return sorted;
+  }
+  return value;
+}
+function requestFingerprint(command, params, cwd) {
+  const seed = JSON.stringify({ command, params: canonicalize(params), cwd });
+  return createHash("sha256").update(seed).digest("hex").slice(0, 32);
+}
+
+// vendor/computer-use-axi/src/artifact-store.ts
+var SAFE_COMPONENT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function safeComponent(value, label2) {
+  if (!SAFE_COMPONENT.test(value)) throw new Error(`Unsafe artifact ${label2}: ${value}`);
+  return value;
+}
+function extensionFor(mimeType) {
+  return mimeType === "image/png" ? "png" : "jpg";
+}
+var ArtifactStore = class {
+  constructor(options) {
+    this.options = options;
+    this.maxCount = options.maxCount ?? 128;
+    this.maxBytes = options.maxBytes ?? 128 * 1024 * 1024;
+    this.maxAgeMs = options.maxAgeMs ?? 30 * 6e4;
+    this.now = options.now ?? Date.now;
+  }
+  options;
+  records = /* @__PURE__ */ new Map();
+  pins = /* @__PURE__ */ new Map();
+  maxCount;
+  maxBytes;
+  maxAgeMs;
+  now;
+  totalBytes = 0;
+  /** Absolute path for one owner/generation, created 0700 and symlink-checked. */
+  directoryFor(owner, generation = this.options.generation) {
+    const root = path3.join(this.options.root, safeComponent(generation, "generation"));
+    const ownerDir = path3.join(root, safeComponent(normalizeComputerUseOwner(owner), "owner"));
+    ensurePrivateDirectory(this.options.root);
+    ensurePrivateDirectory(root);
+    ensurePrivateDirectory(ownerDir);
+    return ownerDir;
+  }
+  put(input) {
+    const generation = input.generation ?? this.options.generation;
+    const directory = this.directoryFor(input.owner, generation);
+    const artifactId = randomUUID2();
+    const absolutePath = path3.join(directory, `${artifactId}.${extensionFor(input.mimeType)}`);
+    const fd = openSync(absolutePath, "wx", 384);
+    try {
+      let offset = 0;
+      while (offset < input.bytes.byteLength) {
+        offset += writeSync(fd, input.bytes, offset, input.bytes.byteLength - offset);
+      }
+    } finally {
+      closeSync(fd);
+    }
+    const record = {
+      artifactId,
+      stateId: input.stateId,
+      owner: normalizeComputerUseOwner(input.owner),
+      generation,
+      mimeType: input.mimeType,
+      width: Math.max(1, Math.trunc(input.width)),
+      height: Math.max(1, Math.trunc(input.height)),
+      hash: createHash2("sha256").update(input.bytes).digest("hex"),
+      bytes: input.bytes.byteLength,
+      absolutePath,
+      createdAt: this.now()
+    };
+    this.records.set(artifactId, record);
+    this.totalBytes += record.bytes;
+    this.pin(artifactId);
+    this.sweep();
+    return record;
+  }
+  pin(artifactId) {
+    this.pins.set(artifactId, (this.pins.get(artifactId) ?? 0) + 1);
+  }
+  unpin(artifactId) {
+    const current = this.pins.get(artifactId) ?? 0;
+    if (current <= 1) this.pins.delete(artifactId);
+    else this.pins.set(artifactId, current - 1);
+    this.sweep();
+  }
+  get(artifactId) {
+    return this.records.get(artifactId);
+  }
+  /** Delete all artifacts belonging to one state (state eviction). */
+  dropForState(stateId2) {
+    let removed = 0;
+    for (const record of [...this.records.values()]) {
+      if (record.stateId !== stateId2) continue;
+      this.remove(record);
+      removed += 1;
+    }
+    return removed;
+  }
+  stats() {
+    return { count: this.records.size, bytes: this.totalBytes, pinned: this.pins.size, maxCount: this.maxCount, maxBytes: this.maxBytes };
+  }
+  /** Drop expired entries first, then oldest until count/byte bounds hold. */
+  sweep() {
+    const now = this.now();
+    for (const record of [...this.records.values()]) {
+      if (this.isPinned(record.artifactId)) continue;
+      if (now - record.createdAt <= this.maxAgeMs) continue;
+      this.remove(record);
+      this.options.onEvict?.(record.stateId, "age");
+    }
+    const evictOldest = (reason) => {
+      for (const record of this.records.values()) {
+        if (this.isPinned(record.artifactId)) continue;
+        this.remove(record);
+        this.options.onEvict?.(record.stateId, reason);
+        return true;
+      }
+      return false;
+    };
+    while (this.records.size > this.maxCount && evictOldest("count")) {
+    }
+    while (this.totalBytes > this.maxBytes && evictOldest("bytes")) {
+    }
+  }
+  /** Remove files for a generation that no longer owns the broker. */
+  cleanupGeneration(generation) {
+    if (!SAFE_COMPONENT.test(generation)) return 0;
+    const directory = path3.join(this.options.root, generation);
+    if (!existsSync2(directory)) return 0;
+    const stats = lstatSync3(directory);
+    if (stats.isSymbolicLink() || !stats.isDirectory()) return 0;
+    let removed = 0;
+    for (const name of readdirSync2(directory)) {
+      const ownerDir = path3.join(directory, name);
+      let ownerStats;
+      try {
+        ownerStats = lstatSync3(ownerDir);
+      } catch {
+        continue;
+      }
+      if (ownerStats.isSymbolicLink() || !ownerStats.isDirectory()) continue;
+      for (const file of readdirSync2(ownerDir)) {
+        const target = path3.join(ownerDir, file);
+        let fileStats;
+        try {
+          fileStats = lstatSync3(target);
+        } catch {
+          continue;
+        }
+        if (fileStats.isSymbolicLink() || !fileStats.isFile()) continue;
+        unlinkSync2(target);
+        removed += 1;
+      }
+      try {
+        rmdirSync(ownerDir);
+      } catch {
+      }
+    }
+    try {
+      rmdirSync(directory);
+    } catch {
+    }
+    return removed;
+  }
+  /**
+   * Remove every generation directory except the current one. A SIGKILLed
+   * broker never gets to clean up after itself, so multiple stale generations
+   * can accumulate; startup sweeps them with a strict bound and refuses to
+   * follow symlinked or unrecognized entries.
+   */
+  cleanupOtherGenerations(currentGeneration, maxGenerations = 32) {
+    const current = safeComponent(currentGeneration, "generation");
+    let names;
+    try {
+      names = readdirSync2(this.options.root);
+    } catch {
+      return 0;
+    }
+    let removed = 0;
+    let scanned = 0;
+    for (const name of names) {
+      if (scanned >= maxGenerations) break;
+      if (name === current || !SAFE_COMPONENT.test(name)) continue;
+      const directory = path3.join(this.options.root, name);
+      let stats;
+      try {
+        stats = lstatSync3(directory);
+      } catch {
+        continue;
+      }
+      if (stats.isSymbolicLink() || !stats.isDirectory()) continue;
+      scanned += 1;
+      removed += this.cleanupGeneration(name);
+    }
+    return removed;
+  }
+  close() {
+    this.records.clear();
+    this.pins.clear();
+    this.totalBytes = 0;
+  }
+  isPinned(artifactId) {
+    return (this.pins.get(artifactId) ?? 0) > 0;
+  }
+  remove(record) {
+    this.records.delete(record.artifactId);
+    this.totalBytes = Math.max(0, this.totalBytes - record.bytes);
+    try {
+      unlinkSync2(record.absolutePath);
+    } catch {
+    }
+  }
+};
+function artifactsRoot(env = process.env) {
+  const base = env.PIE_COMPUTER_USE_ARTIFACTS_DIR?.trim();
+  if (base) return path3.resolve(base);
+  return path3.join(stateRootDir(env), "artifacts");
+}
+
+// vendor/computer-use-axi/src/bridge.ts
 import { spawn as spawn4 } from "node:child_process";
-import { randomUUID as randomUUID5 } from "node:crypto";
-import { constants as fsConstants5, mkdtempSync as mkdtempSync2 } from "node:fs";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { constants as fsConstants5, mkdtempSync } from "node:fs";
 import { access as access4 } from "node:fs/promises";
 import net2 from "node:net";
-import os5 from "node:os";
-import path10 from "node:path";
+import os4 from "node:os";
+import path13 from "node:path";
 
-// builtin/extensions/computer-use/src/platform/coerce.ts
+// vendor/computer-use-axi/src/platform/coerce.ts
 function toBoolean(value) {
   return value === true || value === "true" || value === 1;
 }
@@ -3719,7 +4562,7 @@ function toOptionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 
-// builtin/extensions/computer-use/src/actions.ts
+// vendor/computer-use-axi/src/actions.ts
 function mouseButton(value) {
   return value === "right" || value === "middle" ? value : "left";
 }
@@ -3733,11 +4576,11 @@ function keys(value) {
   if (!Array.isArray(value) || value.length === 0) throw new Error("keypress.keys must contain at least one key.");
   return value.map((key) => String(key));
 }
-function path(value, env) {
+function path4(value, env) {
   if (!Array.isArray(value) || value.length < 2) throw new Error("drag.path must contain at least two points.");
-  return value.map((point2, index) => {
-    const x = Array.isArray(point2) ? toFiniteNumber(point2[0], NaN) : toFiniteNumber(point2?.x, NaN);
-    const y = Array.isArray(point2) ? toFiniteNumber(point2[1], NaN) : toFiniteNumber(point2?.y, NaN);
+  return value.map((point, index) => {
+    const x = Array.isArray(point) ? toFiniteNumber(point[0], NaN) : toFiniteNumber(point?.x, NaN);
+    const y = Array.isArray(point) ? toFiniteNumber(point[1], NaN) : toFiniteNumber(point?.y, NaN);
     env.validatePoint(x, y, `Drag point ${index + 1}`);
     return { x, y };
   });
@@ -3747,17 +4590,17 @@ function nativeTarget(action, operation, env) {
     const node = env.node(action.ref.trim());
     const semanticClick = operation === "click" || operation === "press";
     if (semanticClick && node.isTextInput) {
-      const point3 = env.center(node);
-      env.validatePoint(point3.x, point3.y);
-      return point3;
+      const point2 = env.center(node);
+      env.validatePoint(point2.x, point2.y);
+      return point2;
     }
     const onlyIncidentalActions = node.actions.every((candidate) => candidate === "AXShowMenu" || candidate === "AXScrollToVisible");
     if (node.wireRef && !node.pictureOnly && (!semanticClick || node.canPress || node.canFocus || node.canSetValue || !onlyIncidentalActions)) {
       return { ref: node.wireRef };
     }
-    const point2 = env.center(node);
-    env.validatePoint(point2.x, point2.y);
-    return point2;
+    const point = env.center(node);
+    env.validatePoint(point.x, point.y);
+    return point;
   }
   const x = toFiniteNumber(action.x, NaN);
   const y = toFiniteNumber(action.y, NaN);
@@ -3765,7 +4608,7 @@ function nativeTarget(action, operation, env) {
     env.validatePoint(x, y);
     return { x, y };
   }
-  if (operation === "drag" && action.path?.length) return path(action.path, env)[0];
+  if (operation === "drag" && action.path?.length) return path4(action.path, env)[0];
   throw new Error(`${operation} requires either ref or both x and y.`);
 }
 function focusedTarget(env) {
@@ -3835,7 +4678,7 @@ function prepareAction(action, state, env) {
     case "scroll":
       return { action: operation, target, params: { scrollX: scrollDelta(action.scrollX), scrollY: scrollDelta(action.scrollY) }, usesCurrentFocus: false, needsForeground: false };
     case "drag":
-      return { action: operation, target, params: { path: path(action.path, env) }, usesCurrentFocus: false, needsForeground: false };
+      return { action: operation, target, params: { path: path4(action.path, env) }, usesCurrentFocus: false, needsForeground: false };
     case "moveMouse":
       return { action: operation, target, params: {}, usesCurrentFocus: false, needsForeground: false };
   }
@@ -3860,8 +4703,8 @@ function outcomeAfterObservedValues(current, actions, valueForRef) {
   return matches ? "worked" : current;
 }
 
-// builtin/extensions/computer-use/src/cdp.ts
-import { randomUUID } from "node:crypto";
+// vendor/computer-use-axi/src/cdp.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // ../../node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -3874,9 +4717,9 @@ var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
-// builtin/extensions/computer-use/src/outline.ts
+// vendor/computer-use-axi/src/outline.ts
 var DEFAULT_BUDGET = { maxDepth: 2, maxNodes: 150 };
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function toString(value) {
@@ -3894,7 +4737,7 @@ function toBoolean2(value) {
   return value === true;
 }
 function parseRect(raw) {
-  const rect = isRecord(raw) ? raw : {};
+  const rect = isRecord2(raw) ? raw : {};
   return {
     x: toNumber(rect.x),
     y: toNumber(rect.y),
@@ -3905,7 +4748,7 @@ function parseRect(raw) {
 function parseText(raw) {
   if (!Array.isArray(raw)) return [];
   return raw.map((item) => {
-    if (!isRecord(item)) return void 0;
+    if (!isRecord2(item)) return void 0;
     const string = toString(item.string);
     if (!string) return void 0;
     return {
@@ -3916,7 +4759,7 @@ function parseText(raw) {
   }).filter((item) => Boolean(item));
 }
 function parseNode(raw, parent) {
-  const record = isRecord(raw) ? raw : {};
+  const record = isRecord2(raw) ? raw : {};
   const wireRef = toString(record.ref) || void 0;
   const node = {
     ref: "",
@@ -3940,7 +4783,7 @@ function parseNode(raw, parent) {
     offscreen: toBoolean2(record.offscreen),
     pictureOnly: toBoolean2(record.pictureOnly),
     truncated: toBoolean2(record.truncated),
-    scrollExtent: isRecord(record.scrollExtent) ? { seen: Math.max(0, Math.trunc(toNumber(record.scrollExtent.seen))), total: Math.max(0, Math.trunc(toNumber(record.scrollExtent.total))) } : void 0,
+    scrollExtent: isRecord2(record.scrollExtent) ? { seen: Math.max(0, Math.trunc(toNumber(record.scrollExtent.seen))), total: Math.max(0, Math.trunc(toNumber(record.scrollExtent.total))) } : void 0,
     text: parseText(record.text),
     children: [],
     parent
@@ -3949,12 +4792,12 @@ function parseNode(raw, parent) {
   return node;
 }
 function parseLookResponse(raw) {
-  const record = isRecord(raw) ? raw : {};
-  const image = isRecord(record.image) ? record.image : void 0;
-  const window = isRecord(record.window) ? record.window : {};
-  const metadata = isRecord(window.metadata) ? window.metadata : void 0;
+  const record = isRecord2(raw) ? raw : {};
+  const image = isRecord2(record.image) ? record.image : void 0;
+  const window = isRecord2(record.window) ? record.window : {};
+  const metadata = isRecord2(window.metadata) ? window.metadata : void 0;
   const outline = buildOutline(toString(record.lookId), parseNode(record.outline));
-  const readText = isRecord(record.readText) ? record.readText : void 0;
+  const readText = isRecord2(record.readText) ? record.readText : void 0;
   const requestedReadText = readText?.requested === "auto" || readText?.requested === "always" || readText?.requested === "never" ? readText.requested : void 0;
   const look = {
     lookId: toString(record.lookId),
@@ -3977,7 +4820,7 @@ function parseLookResponse(raw) {
       height: Math.max(1, Math.trunc(toNumber(image.height, 1)))
     } : void 0,
     outline: outline.root,
-    timings: isRecord(record.timings) ? Object.fromEntries(Object.entries(record.timings).map(([key, value]) => [key, toNumber(value)])) : {},
+    timings: isRecord2(record.timings) ? Object.fromEntries(Object.entries(record.timings).map(([key, value]) => [key, toNumber(value)])) : {},
     readText: readText ? { requested: requestedReadText, executed: toBoolean2(readText.executed) } : void 0,
     parsedOutline: outline
   };
@@ -4336,7 +5179,7 @@ function graftScopedOutline(outline, targetRef, scoped) {
   return target;
 }
 
-// builtin/extensions/computer-use/src/cdp.ts
+// vendor/computer-use-axi/src/cdp.ts
 var COMMAND_TIMEOUT_MS = 5e3;
 var CDP_CONTEXT_PREFIX = "browser:";
 var NAVIGATE_LOAD_TIMEOUT_MS = 1e4;
@@ -4367,11 +5210,11 @@ var CdpTab = class _CdpTab {
     const ws = new wrapper_default(wsUrl);
     connectingSockets.add(ws);
     try {
-      await new Promise((resolve, reject) => {
+      await new Promise((resolve2, reject) => {
         const timer = setTimeout(() => reject(new Error(`Timed out connecting to CDP target at ${wsUrl}`)), COMMAND_TIMEOUT_MS);
         ws.onopen = () => {
           clearTimeout(timer);
-          resolve();
+          resolve2();
         };
         ws.onerror = () => {
           clearTimeout(timer);
@@ -4419,14 +5262,14 @@ var CdpTab = class _CdpTab {
     this.loadFired = void 0;
     this.rejectAllPending(new Error("CDP connection closed."));
     if (this.ws.readyState === wrapper_default.CLOSED) return;
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       const timer = setTimeout(() => {
         this.ws.terminate();
-        resolve();
+        resolve2();
       }, 500);
       this.ws.once("close", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       if (this.ws.readyState === wrapper_default.CONNECTING) this.ws.terminate();
       else this.ws.close();
@@ -4446,13 +5289,13 @@ var CdpTab = class _CdpTab {
   }
   async navigate(url) {
     let timer;
-    const loaded = new Promise((resolve) => {
-      this.loadFired = resolve;
+    const loaded = new Promise((resolve2) => {
+      this.loadFired = resolve2;
     });
     try {
       await this.send("Page.navigate", { url });
-      await Promise.race([loaded, new Promise((resolve) => {
-        timer = setTimeout(resolve, NAVIGATE_LOAD_TIMEOUT_MS);
+      await Promise.race([loaded, new Promise((resolve2) => {
+        timer = setTimeout(resolve2, NAVIGATE_LOAD_TIMEOUT_MS);
       })]);
     } finally {
       clearTimeout(timer);
@@ -4489,11 +5332,11 @@ var CdpTab = class _CdpTab {
   async mouseAt(x, y, type, button = "left", clickCount2 = 1) {
     await this.send("Input.dispatchMouseEvent", { type, x, y, button: type === "mouseMoved" ? "none" : button, clickCount: clickCount2 });
   }
-  async dragPath(path11) {
-    if (path11.length < 2) throw new Error("CDP drag requires at least two points.");
-    await this.mouseAt(path11[0].x, path11[0].y, "mousePressed");
-    for (const point2 of path11.slice(1)) await this.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: point2.x, y: point2.y, button: "left", buttons: 1 });
-    const end = path11[path11.length - 1];
+  async dragPath(path15) {
+    if (path15.length < 2) throw new Error("CDP drag requires at least two points.");
+    await this.mouseAt(path15[0].x, path15[0].y, "mousePressed");
+    for (const point of path15.slice(1)) await this.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: point.x, y: point.y, button: "left", buttons: 1 });
+    const end = path15[path15.length - 1];
     await this.mouseAt(end.x, end.y, "mouseReleased");
   }
   async withBackendNode(backendNodeId, functionDeclaration, args = []) {
@@ -4524,7 +5367,7 @@ var CdpTab = class _CdpTab {
   }
   send(method, params = {}) {
     const id = this.nextId++;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`CDP command '${method}' timed out after ${COMMAND_TIMEOUT_MS}ms.`));
@@ -4532,7 +5375,7 @@ var CdpTab = class _CdpTab {
       this.pending.set(id, {
         resolve: (result) => {
           clearTimeout(timer);
-          resolve(result);
+          resolve2(result);
         },
         reject: (error) => {
           clearTimeout(timer);
@@ -4712,9 +5555,9 @@ async function cdpMouseForContext(contextId, x, y, type, button = "left", clickC
     return true;
   }) === true;
 }
-async function cdpDragForContext(contextId, path11) {
+async function cdpDragForContext(contextId, path15) {
   return await withCdpContextTab(contextId, async (tab) => {
-    await tab.dragPath(path11);
+    await tab.dragPath(path15);
     return true;
   }) === true;
 }
@@ -4748,7 +5591,7 @@ async function cdpSnapshotForContext(contextId) {
       tab.accessibilityTree().catch(() => [])
     ]);
     assertConnectionEpoch(epoch);
-    const snapshotId = randomUUID();
+    const snapshotId = randomUUID3();
     const { targets, outline } = cdpSnapshotOutline(snapshotId, nodes);
     return {
       contextId,
@@ -4818,7 +5661,7 @@ function cdpSnapshotOutline(snapshotId, nodes) {
   }
   const targets = [];
   const build = (raw, seen) => {
-    const nodeId = String(raw?.nodeId ?? randomUUID());
+    const nodeId = String(raw?.nodeId ?? randomUUID3());
     if (seen.has(nodeId)) return void 0;
     seen.add(nodeId);
     const role = axString(raw?.role);
@@ -4944,16 +5787,16 @@ function titlesMatch(tabTitle, windowTitle) {
   return tab === win || win.startsWith(tab) || tab.startsWith(win);
 }
 
-// builtin/extensions/computer-use/src/config.ts
-import { existsSync, readFileSync } from "node:fs";
-import path2 from "node:path";
+// vendor/computer-use-axi/src/config.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import path5 from "node:path";
 
-// builtin/extensions/computer-use/host.ts
+// vendor/computer-use-axi/host.ts
 function getAgentDir() {
   return getConfigDir();
 }
 
-// builtin/extensions/computer-use/src/config.ts
+// vendor/computer-use-axi/src/config.ts
 var DEFAULT_CONFIG = {
   browser_use: true,
   headless: false,
@@ -4986,9 +5829,9 @@ function normalizePartial(raw) {
   return out;
 }
 function readConfigFile(filePath) {
-  if (!existsSync(filePath)) return { path: filePath, exists: false };
+  if (!existsSync3(filePath)) return { path: filePath, exists: false };
   try {
-    const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(filePath, "utf-8"));
     return { path: filePath, exists: true, values: normalizePartial(parsed) };
   } catch (error) {
     return { path: filePath, exists: true, error: error instanceof Error ? error.message : String(error) };
@@ -5008,8 +5851,8 @@ function readEnv() {
 }
 function loadComputerUseConfig(cwd) {
   const sources = [
-    readConfigFile(path2.join(getAgentDir(), "extensions", "computer-use.json")),
-    readConfigFile(path2.join(cwd, ".pie", "computer-use.json"))
+    readConfigFile(path5.join(getAgentDir(), "extensions", "computer-use.json")),
+    readConfigFile(path5.join(cwd, ".pie", "computer-use.json"))
   ];
   const env = readEnv();
   const config = { ...DEFAULT_CONFIG };
@@ -5024,9 +5867,6 @@ function loadComputerUseConfig(cwd) {
 function getComputerUseConfig() {
   return activeConfig;
 }
-function getLoadedComputerUseConfig() {
-  return activeLoadedConfig;
-}
 function isHeadlessMode() {
   return activeConfig.headless;
 }
@@ -5034,7 +5874,7 @@ function isBrowserUseEnabled() {
   return activeConfig.browser_use;
 }
 
-// builtin/extensions/computer-use/src/note.ts
+// vendor/computer-use-axi/src/note.ts
 function normalizedLabel(value) {
   return value.toLowerCase().replace(/\s+/g, " ").trim();
 }
@@ -5186,10 +6026,9 @@ function renderNote(note) {
 \u2026 note byte budget reached`;
 }
 
-// builtin/extensions/computer-use/src/output.ts
-import { closeSync, mkdtempSync, openSync, readSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path3 from "node:path";
+// vendor/computer-use-axi/src/output.ts
+import { closeSync as closeSync2, mkdirSync as mkdirSync5, openSync as openSync2, readSync, readdirSync as readdirSync3, statSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import path6 from "node:path";
 var MODEL_TEXT_MAX_BYTES = 48 * 1024;
 var MODEL_TEXT_MAX_LINES = 2e3;
 var OUTPUT_PAGE_BYTES = 16 * 1024;
@@ -5198,9 +6037,13 @@ var MODEL_PREVIEW_BYTES = 16 * 1024;
 var OUTPUT_ENTRY_MAX_BYTES = 16 * 1024 * 1024;
 var OUTPUT_STORE_MAX_BYTES = 64 * 1024 * 1024;
 var outputs = /* @__PURE__ */ new Map();
-var outputDirectory;
-var outputBytes = 0;
 var nextOutputId = 1;
+var outputBytes = 0;
+function outputDirectoryFor(owner) {
+  const dir = path6.join(outputsDir(), "owners", normalizeComputerUseOwner(owner));
+  mkdirSync5(dir, { recursive: true, mode: 448 });
+  return dir;
+}
 function utf8Prefix(bytes, maxBytes) {
   if (bytes.byteLength <= maxBytes) return bytes;
   let end = Math.max(0, maxBytes);
@@ -5212,14 +6055,14 @@ function boundedPrefix(value, maxBytes, maxLines) {
   const lineBounded = lines.length > maxLines ? lines.slice(0, maxLines).join("\n") : value;
   return new TextDecoder().decode(utf8Prefix(new TextEncoder().encode(lineBounded), maxBytes));
 }
-function storeOutput(value) {
+function storeOutput(value, owner) {
   const encoded = new TextEncoder().encode(value);
   const stored = encoded.byteLength > OUTPUT_ENTRY_MAX_BYTES ? utf8Prefix(encoded, OUTPUT_ENTRY_MAX_BYTES) : encoded;
-  outputDirectory ??= mkdtempSync(path3.join(os.tmpdir(), "pie-computer-use-output-"));
+  const directory = outputDirectoryFor(owner);
   const ref = `@o${nextOutputId++}`;
-  const filePath = path3.join(outputDirectory, `${ref.slice(2)}.txt`);
-  writeFileSync(filePath, stored, { mode: 384 });
-  const entry = { ref, filePath, storedBytes: stored.byteLength, totalBytes: encoded.byteLength, complete: stored.byteLength === encoded.byteLength };
+  const filePath = path6.join(directory, `${ref.slice(2)}.txt`);
+  writeFileSync2(filePath, stored, { mode: 384 });
+  const entry = { ref, owner: normalizeComputerUseOwner(owner), filePath, storedBytes: stored.byteLength, totalBytes: encoded.byteLength, complete: stored.byteLength === encoded.byteLength };
   outputs.set(entry.ref, entry);
   outputBytes += entry.storedBytes;
   while (outputBytes > OUTPUT_STORE_MAX_BYTES && outputs.size > 1) {
@@ -5229,7 +6072,7 @@ function storeOutput(value) {
     outputs.delete(oldestRef);
     outputBytes -= oldest.storedBytes;
     try {
-      unlinkSync(oldest.filePath);
+      unlinkSync3(oldest.filePath);
     } catch {
     }
   }
@@ -5242,16 +6085,16 @@ function refinementFor(tool) {
   if (tool === "observe_ui" || tool === "expand_ui") return "use search_ui or expand a more specific ref";
   return "request a smaller or more focused result";
 }
-function applyOutputEnvelope(tool, result) {
+function applyOutputEnvelope(tool, result, owner = COMPUTER_USE_STANDALONE_OWNER) {
   const textParts = result.content.filter((part) => part.type === "text");
   const combined = textParts.map((part) => part.text).join("\n");
   const bytes = new TextEncoder().encode(combined).byteLength;
   const lines = combined === "" ? 0 : combined.split("\n").length;
   if (bytes <= MODEL_TEXT_MAX_BYTES && lines <= MODEL_TEXT_MAX_LINES) return result;
-  const entry = storeOutput(combined);
+  const entry = storeOutput(combined, owner);
   const preview = boundedPrefix(combined, MODEL_PREVIEW_BYTES, MODEL_TEXT_MAX_LINES - 4);
   const returnedBytes = new TextEncoder().encode(preview).byteLength;
-  const availability = entry.complete ? `continue: read_text({ ref: "${entry.ref}", offset: ${returnedBytes} })` : `continue: read_text({ ref: "${entry.ref}", offset: ${returnedBytes} }); only the first ${entry.storedBytes} bytes were stored, so refine for the remainder`;
+  const availability = entry.complete ? `continue: computer-use-axi read --ref "${entry.ref}" --offset ${returnedBytes}` : `continue: computer-use-axi read --ref "${entry.ref}" --offset ${returnedBytes}; only the first ${entry.storedBytes} bytes were stored, so refine for the remainder`;
   const trailer = [
     `output truncated: returned ${returnedBytes} of ${entry.totalBytes} utf-8 bytes`,
     `refine: ${refinementFor(tool)}`,
@@ -5262,12 +6105,12 @@ function applyOutputEnvelope(tool, result) {
 
 ${trailer}` }, ...images] };
 }
-function boundToolError(tool, error) {
+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);
+  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`;
@@ -5275,19 +6118,19 @@ function boundToolError(tool, error) {
 
 error truncated: returned ${returnedBytes} of ${entry.totalBytes} utf-8 bytes
 refine: ${refinementFor(tool)}
-continue: read_text({ ref: "${entry.ref}", offset: ${returnedBytes} })${storageNote}`);
+continue: computer-use-axi read --ref "${entry.ref}" --offset ${returnedBytes}${storageNote}`);
 }
-function readStoredOutput(ref, offsetValue) {
+function readStoredOutput(ref, offsetValue, owner = COMPUTER_USE_STANDALONE_OWNER) {
   const entry = outputs.get(ref);
-  if (!entry) return void 0;
+  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 = openSync(entry.filePath, "r");
+  const fd = openSync2(entry.filePath, "r");
   try {
     if (buffer.byteLength > 0) readSync(fd, buffer, 0, buffer.byteLength, offset);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
   let start = 0;
   while (start < buffer.byteLength && (buffer[start] & 192) === 128) start += 1;
@@ -5303,56 +6146,52 @@ function readStoredOutput(ref, offsetValue) {
     complete: entry.complete
   };
 }
-function clearStoredOutputs() {
-  outputs.clear();
-  if (outputDirectory) {
+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 {
-      rmSync(outputDirectory, { recursive: true, force: true });
+      unlinkSync3(entry.filePath);
     } catch {
     }
   }
-  outputDirectory = void 0;
-  outputBytes = 0;
-  nextOutputId = 1;
 }
 
-// builtin/extensions/computer-use/src/contract.ts
-var AGENT_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "find_roots",
-  "read_text",
-  "wait_for",
-  "observe_ui",
-  "search_ui",
-  "expand_ui",
-  "inspect_ui",
-  "act_ui",
-  "navigate_browser",
-  "evaluate_browser",
-  "launch_browser"
-]);
-
-// builtin/extensions/computer-use/src/platform/macos/helper.ts
+// 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 os3 from "node:os";
-import path6 from "node:path";
-
-// builtin/extensions/computer-use/src/platform/macos/helper-path.mjs
-import { accessSync, constants as fsConstants, existsSync as existsSync2 } from "node:fs";
 import os2 from "node:os";
-import path4 from "node:path";
+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 = path4.join("/Applications", HELPER_APP_NAME);
+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 path4.resolve(explicitPath);
-  const homeDir = options.homeDir ?? os2.homedir();
+  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 ?? existsSync2;
+  const fileExists = options.fileExists ?? existsSync4;
   const directoryIsWritable = options.directoryIsWritable ?? ((directoryPath) => {
     try {
       accessSync(directoryPath, fsConstants.W_OK);
@@ -5361,10 +6200,10 @@ function resolveMacosHelperAppPath(options = {}) {
       return false;
     }
   });
-  if (fileExists(systemHelperAppPath) && directoryIsWritable(path4.dirname(systemHelperAppPath))) {
+  if (fileExists(systemHelperAppPath) && directoryIsWritable(path7.dirname(systemHelperAppPath))) {
     return systemHelperAppPath;
   }
-  return path4.join(configDir, "computer-use", HELPER_APP_NAME);
+  return path7.join(configDir, "computer-use", HELPER_APP_NAME);
 }
 function resolvePieConfigDir(env, homeDir) {
   const envDir = env.PIE_CODING_AGENT_DIR;
@@ -5373,37 +6212,37 @@ function resolvePieConfigDir(env, homeDir) {
     if (envDir.startsWith("~/")) return homeDir + envDir.slice(1);
     return envDir;
   }
-  return path4.join(homeDir, ".pie");
+  return path7.join(homeDir, ".pie");
 }
 
-// builtin/extensions/computer-use/src/platform/package-root.ts
-import { existsSync as existsSync3 } from "node:fs";
-import path5 from "node:path";
-import { fileURLToPath } from "node:url";
+// 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 path5.resolve(override);
-  let dir = path5.dirname(fileURLToPath(moduleUrl));
+  if (override) return path8.resolve(override);
+  let dir = path8.dirname(fileURLToPath2(moduleUrl));
   for (let depth = 0; depth < 12; depth += 1) {
-    if (existsSync3(path5.join(dir, "scripts", "setup-helper.mjs"))) return dir;
-    const parent = path5.dirname(dir);
+    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 ${path5.dirname(fileURLToPath(moduleUrl))}. Set PIE_COMPUTER_USE_PACKAGE_ROOT.`);
+  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.`);
 }
 
-// builtin/extensions/computer-use/src/platform/macos/helper.ts
+// 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 = path6.join(HELPER_APP_PATH, "Contents", "MacOS", "pie-computer-use");
-var DEFAULT_HELPER_SOCKET_PATH = path6.join(os3.homedir(), "Library", "Caches", "pie-computer-use", "bridge.sock");
+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 = path6.join(PACKAGE_ROOT, "scripts", "setup-helper.mjs");
+var SETUP_HELPER_SCRIPT = path9.join(PACKAGE_ROOT, "scripts", "setup-helper.mjs");
 var HelperTransportError = class extends Error {
   constructor(message) {
     super(message);
@@ -5423,8 +6262,8 @@ function throwIfAborted(signal) {
 }
 async function sleep(ms, signal) {
   throwIfAborted(signal);
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(resolve, ms);
+  await new Promise((resolve2, reject) => {
+    const timer = setTimeout(resolve2, ms);
     const onAbort = () => {
       clearTimeout(timer);
       reject(new Error("Operation aborted."));
@@ -5443,14 +6282,14 @@ async function isExecutable(filePath) {
 async function isResolvedHelperExecutable(filePath) {
   if (!filePath) return true;
   const [actualPath, expectedPath] = await Promise.all([
-    realpath(filePath).catch(() => path6.resolve(filePath)),
-    realpath(HELPER_APP_EXECUTABLE_PATH).catch(() => path6.resolve(HELPER_APP_EXECUTABLE_PATH))
+    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((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const child = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env
@@ -5484,7 +6323,7 @@ async function runProcess(command, args, timeoutMs, signal, env) {
     child.on("close", (code) => {
       cleanup();
       if (code === 0) {
-        resolve();
+        resolve2();
         return;
       }
       const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
@@ -5517,11 +6356,11 @@ var MacosHelperClient = class {
   }
   async launchDaemon(signal) {
     if (usingExternalHelperSocket) throw new HelperTransportError(`External helper socket is unavailable at ${HELPER_SOCKET_PATH}.`);
-    await mkdir(path6.dirname(HELPER_SOCKET_PATH), { recursive: true });
+    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((resolve, reject) => {
+    return await new Promise((resolve2, reject) => {
       const id = `req_${++this.requestSequence}`;
       const socket = net.createConnection(HELPER_SOCKET_PATH);
       let buffer = "";
@@ -5550,7 +6389,7 @@ var MacosHelperClient = class {
         socket.end();
         try {
           const parsed = JSON.parse(buffer.slice(0, newline));
-          if (parsed.ok === true) resolve(parsed.result);
+          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);
@@ -5640,7 +6479,7 @@ var MacosHelperClient = class {
 };
 var macosHelper = new MacosHelperClient();
 
-// builtin/extensions/computer-use/src/platform/macos/backend.ts
+// vendor/computer-use-axi/src/platform/macos/backend.ts
 function parseApps(result) {
   const array = Array.isArray(result) ? result : result?.apps;
   if (!Array.isArray(array)) return [];
@@ -5751,7 +6590,7 @@ var macosBackend = {
   }
 };
 
-// builtin/extensions/computer-use/src/platform/macos/browser.ts
+// vendor/computer-use-axi/src/platform/macos/browser.ts
 var BROWSER_WINDOW_OPEN_TIMEOUT_MS = 1e4;
 var BROWSER_BUNDLE_IDS = /* @__PURE__ */ new Set([
   "com.apple.Safari",
@@ -5849,7 +6688,7 @@ async function openBrowserLocationWithAppleScript(target, url, signal) {
   }
 }
 
-// builtin/extensions/computer-use/src/permissions.ts
+// vendor/computer-use-axi/src/permissions.ts
 function throwIfAborted2(signal) {
   if (signal?.aborted) throw new Error("Operation aborted.");
 }
@@ -5892,7 +6731,7 @@ async function ensurePermissions(ctx, bridge, helperPath, signal) {
   return status;
 }
 
-// builtin/extensions/computer-use/src/platform/architecture.ts
+// vendor/computer-use-axi/src/platform/architecture.ts
 var PLATFORM_ARCHITECTURE_VERSION = 1;
 var REQUIRED_PLATFORM_INVARIANTS = [
   "state-scoped-observations",
@@ -5914,7 +6753,7 @@ function assertPlatformArchitecture(platform, diagnostics) {
   }
 }
 
-// builtin/extensions/computer-use/src/platform/macos/permissions.ts
+// 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 = [
@@ -6033,18 +6872,18 @@ Helper path: ${helperPath}`,
   return { permissionStatus, lastPermissionCheckAt, helperDiagnostics };
 }
 
-// builtin/extensions/computer-use/src/platform/linux/helper.ts
+// vendor/computer-use-axi/src/platform/linux/helper.ts
 import { spawn as spawn2 } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { constants as fsConstants3 } from "node:fs";
 import { access as access2 } from "node:fs/promises";
-import path7 from "node:path";
+import path10 from "node:path";
 var PACKAGE_ROOT2 = resolveExtensionRoot(import.meta.url);
-var SETUP_HELPER_SCRIPT2 = path7.join(PACKAGE_ROOT2, "scripts", "setup-helper.mjs");
+var SETUP_HELPER_SCRIPT2 = path10.join(PACKAGE_ROOT2, "scripts", "setup-helper.mjs");
 var HELPER_SETUP_TIMEOUT_MS2 = 6e4;
 var COMMAND_TIMEOUT_MS3 = 15e3;
 var LINUX_HELPER_PROTOCOL_VERSION = 4;
-var LINUX_HELPER_PATH = process.env.PIE_COMPUTER_USE_LINUX_HELPER_PATH || path7.join(getAgentDir(), "helpers", "computer-use", "linux-bridge");
+var LINUX_HELPER_PATH = process.env.PIE_COMPUTER_USE_LINUX_HELPER_PATH || path10.join(getAgentDir(), "helpers", "computer-use", "linux-bridge");
 async function isExecutable2(filePath) {
   try {
     await access2(filePath, fsConstants3.X_OK);
@@ -6055,7 +6894,7 @@ async function isExecutable2(filePath) {
 }
 async function runProcess2(command, args, timeoutMs, signal, env) {
   if (signal?.aborted) throw new Error("Operation aborted.");
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const child = spawn2(command, args, { stdio: ["ignore", "pipe", "pipe"], env });
     let stdout = "";
     let stderr = "";
@@ -6066,7 +6905,7 @@ async function runProcess2(command, args, timeoutMs, signal, env) {
       clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
       if (error) reject(error);
-      else resolve();
+      else resolve2();
     };
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
@@ -6095,13 +6934,13 @@ ${output}`.trim()));
 async function waitForShared(promise, signal) {
   if (!signal) return await promise;
   if (signal.aborted) throw new Error("Operation aborted.");
-  return await new Promise((resolve, reject) => {
+  return await new Promise((resolve2, reject) => {
     const onAbort = () => reject(new Error("Operation aborted."));
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve(value);
+        resolve2(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -6203,8 +7042,8 @@ var LinuxHelperClient = class {
     });
     this.child = child;
     this.buffer = "";
-    return await new Promise((resolve, reject) => {
-      child.once("spawn", () => resolve(child));
+    return await new Promise((resolve2, reject) => {
+      child.once("spawn", () => resolve2(child));
       child.once("error", reject);
     });
   }
@@ -6239,9 +7078,9 @@ var LinuxHelperClient = class {
   }
   async command(cmd, args = {}, options) {
     const child = await this.process(options?.signal);
-    const id = randomUUID2();
+    const id = randomUUID4();
     const timeoutMs = options?.timeoutMs ?? COMMAND_TIMEOUT_MS3;
-    return await new Promise((resolve, reject) => {
+    return await new Promise((resolve2, reject) => {
       const onAbort = () => {
         this.pending.delete(id);
         clearTimeout(timer);
@@ -6255,7 +7094,7 @@ var LinuxHelperClient = class {
       this.pending.set(id, {
         resolve: (value) => {
           options?.signal?.removeEventListener("abort", onAbort);
-          resolve(value);
+          resolve2(value);
         },
         reject: (error) => {
           options?.signal?.removeEventListener("abort", onAbort);
@@ -6277,7 +7116,7 @@ var LinuxHelperClient = class {
 };
 var linuxHelper = new LinuxHelperClient();
 
-// builtin/extensions/computer-use/src/platform/linux/backend.ts
+// vendor/computer-use-axi/src/platform/linux/backend.ts
 function normalizedProcessName(appName) {
   return appName.toLowerCase().split("/").pop().replace(/\.desktop$/i, "");
 }
@@ -6433,18 +7272,18 @@ var linuxBackend = {
   }
 };
 
-// builtin/extensions/computer-use/src/platform/windows/helper.ts
+// vendor/computer-use-axi/src/platform/windows/helper.ts
 import { spawn as spawn3 } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { constants as fsConstants4 } from "node:fs";
 import { access as access3 } from "node:fs/promises";
-import path8 from "node:path";
+import path11 from "node:path";
 var PACKAGE_ROOT3 = resolveExtensionRoot(import.meta.url);
-var SETUP_HELPER_SCRIPT3 = path8.join(PACKAGE_ROOT3, "scripts", "setup-helper.mjs");
+var SETUP_HELPER_SCRIPT3 = path11.join(PACKAGE_ROOT3, "scripts", "setup-helper.mjs");
 var HELPER_SETUP_TIMEOUT_MS3 = 6e4;
 var COMMAND_TIMEOUT_MS4 = 15e3;
 var WINDOWS_HELPER_PROTOCOL_VERSION = 4;
-var WINDOWS_HELPER_PATH = process.env.PIE_COMPUTER_USE_WINDOWS_HELPER_PATH || path8.join(getAgentDir(), "helpers", "computer-use", "windows-bridge.exe");
+var WINDOWS_HELPER_PATH = process.env.PIE_COMPUTER_USE_WINDOWS_HELPER_PATH || path11.join(getAgentDir(), "helpers", "computer-use", "windows-bridge.exe");
 async function isExecutable3(filePath) {
   try {
     await access3(filePath, fsConstants4.X_OK);
@@ -6455,7 +7294,7 @@ async function isExecutable3(filePath) {
 }
 async function runProcess3(command, args, timeoutMs, signal, env) {
   if (signal?.aborted) throw new Error("Operation aborted.");
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const child = spawn3(command, args, { stdio: ["ignore", "pipe", "pipe"], env });
     let stdout = "";
     let stderr = "";
@@ -6485,7 +7324,7 @@ async function runProcess3(command, args, timeoutMs, signal, env) {
     });
     child.on("close", (code) => {
       cleanup();
-      if (code === 0) return resolve();
+      if (code === 0) return resolve2();
       const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
       reject(new Error(`Command failed (${code}): ${command} ${args.join(" ")}
 ${output}`.trim()));
@@ -6570,14 +7409,14 @@ var WindowsHelperClient = class {
   }
   async command(cmd, args = {}, options) {
     const child = await this.process(options?.signal);
-    const id = randomUUID3();
+    const id = randomUUID5();
     const timeoutMs = options?.timeoutMs ?? COMMAND_TIMEOUT_MS4;
-    return await new Promise((resolve, reject) => {
+    return await new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`Helper command '${cmd}' timed out after ${timeoutMs}ms.`));
       }, timeoutMs);
-      this.pending.set(id, { resolve, reject, timer });
+      this.pending.set(id, { resolve: resolve2, reject, timer });
       child.stdin.write(`${JSON.stringify({ protocolVersion: WINDOWS_HELPER_PROTOCOL_VERSION, id, cmd, args })}
 `, (error) => {
         if (!error) return;
@@ -6590,7 +7429,7 @@ var WindowsHelperClient = class {
 };
 var windowsHelper = new WindowsHelperClient();
 
-// builtin/extensions/computer-use/src/platform/windows/backend.ts
+// vendor/computer-use-axi/src/platform/windows/backend.ts
 function normalizedProcessName2(appName) {
   return appName.toLowerCase().replace(/\.exe$/i, "");
 }
@@ -6726,7 +7565,7 @@ var windowsBackend = {
   }
 };
 
-// builtin/extensions/computer-use/src/platform/index.ts
+// vendor/computer-use-axi/src/platform/index.ts
 var macosPlatformBackend = {
   name: "macos",
   ensureReady: ensureMacosReady,
@@ -6797,9 +7636,14 @@ function platformBackendForRuntime(platform = process.platform) {
   return new UnsupportedPlatformBackend(platform);
 }
 var currentPlatformBackend = platformBackendForRuntime();
+var backendOverrideInstalled = false;
+function setPlatformBackend(backend) {
+  currentPlatformBackend = backend;
+  backendOverrideInstalled = true;
+}
 
-// builtin/extensions/computer-use/src/runtime.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+// vendor/computer-use-axi/src/runtime.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
 var StaleResourceStateError = class extends Error {
   constructor(resourceKey, expectedEpoch, actualEpoch) {
     super(`State is stale for ${resourceKey}: expected epoch ${expectedEpoch}, current epoch ${actualEpoch}.`);
@@ -6812,14 +7656,22 @@ var StaleResourceStateError = class extends Error {
   expectedEpoch;
   actualEpoch;
 };
+var OperationAbortedError = class extends Error {
+  constructor() {
+    super("Operation cancelled before dispatch.");
+    this.name = "OperationAbortedError";
+  }
+};
 var StateStore = class {
-  constructor(limit = 128) {
+  constructor(limit = 128, onEvict) {
     this.limit = limit;
+    this.onEvict = onEvict;
   }
   limit;
+  onEvict;
   records = /* @__PURE__ */ new Map();
-  create(resourceKey, epoch, value) {
-    const record = { stateId: randomUUID4(), resourceKey, epoch, value };
+  create(resourceKey, epoch, value, meta = {}) {
+    const record = { stateId: randomUUID6(), resourceKey, epoch, value, ...meta };
     this.set(record);
     return record;
   }
@@ -6829,12 +7681,25 @@ var StateStore = class {
     while (this.records.size > this.limit) {
       const oldest = this.records.keys().next().value;
       if (!oldest) break;
+      const evicted = this.records.get(oldest);
       this.records.delete(oldest);
+      if (evicted) this.onEvict?.(evicted);
     }
   }
   get(stateId2) {
     return this.records.get(stateId2);
   }
+  ids() {
+    return [...this.records.keys()];
+  }
+  /** Owner probes exist only to distinguish "expired for this owner" from
+   *  "unknown id" in diagnostics; they never return the value. */
+  ownerOf(stateId2) {
+    return this.records.get(stateId2)?.owner;
+  }
+  drop(stateId2) {
+    return this.records.delete(stateId2);
+  }
   clear() {
     this.records.clear();
   }
@@ -6843,8 +7708,15 @@ var StateStore = class {
   }
 };
 var ResourceScheduler = class {
+  constructor(hooks = {}) {
+    this.hooks = hooks;
+  }
+  hooks;
   resources = /* @__PURE__ */ new Map();
   closed = false;
+  epochs() {
+    return [...this.resources.entries()].map(([key, record]) => [key, record.epoch]);
+  }
   epoch(resourceKey) {
     return this.resource(resourceKey).epoch;
   }
@@ -6852,22 +7724,23 @@ var ResourceScheduler = class {
     const record = this.resource(resourceKey);
     record.epoch = Math.max(record.epoch, Math.max(0, Math.trunc(epoch)));
   }
-  async read(resourceKey, work) {
-    return await this.enqueue(resourceKey, async (record) => ({ value: await work(record.epoch), epoch: record.epoch }));
+  async read(resourceKey, work, signal) {
+    return await this.enqueue(resourceKey, async (record) => ({ value: await work(record.epoch), epoch: record.epoch }), signal);
   }
-  async readAt(resourceKey, expectedEpoch, work) {
+  async readAt(resourceKey, expectedEpoch, work, signal) {
     return await this.enqueue(resourceKey, async (record) => {
       if (record.epoch !== expectedEpoch) throw new StaleResourceStateError(resourceKey, expectedEpoch, record.epoch);
       return { value: await work(record.epoch), epoch: record.epoch };
-    });
+    }, signal);
   }
-  async write(resourceKey, baseEpoch, work) {
+  async write(resourceKey, baseEpoch, work, signal) {
     return await this.enqueue(resourceKey, async (record) => {
       if (record.epoch !== baseEpoch) throw new StaleResourceStateError(resourceKey, baseEpoch, record.epoch);
       const nextEpoch = record.epoch + 1;
       record.epoch = nextEpoch;
+      this.hooks.onEpochChange?.(resourceKey, nextEpoch);
       return { value: await work(nextEpoch), epoch: nextEpoch };
-    });
+    }, signal);
   }
   async drain() {
     await Promise.all([...this.resources.values()].map((record) => record.tail.catch(() => void 0)));
@@ -6885,17 +7758,22 @@ var ResourceScheduler = class {
     }
     return record;
   }
-  async enqueue(resourceKey, work) {
+  async enqueue(resourceKey, work, signal) {
     if (this.closed) throw new Error("Computer-use session is shutting down.");
     const record = this.resource(resourceKey);
     const previous = record.tail;
     let release;
-    const next = new Promise((resolve) => {
-      release = resolve;
+    const next = new Promise((resolve2) => {
+      release = resolve2;
     });
     record.tail = previous.catch(() => void 0).then(() => next);
-    await previous.catch(() => void 0);
+    if (signal?.aborted) {
+      release();
+      throw new OperationAbortedError();
+    }
     try {
+      await previous.catch(() => void 0);
+      if (signal?.aborted) throw new OperationAbortedError();
       if (this.closed) throw new Error("Computer-use session is shutting down.");
       return await work(record);
     } finally {
@@ -6903,28 +7781,108 @@ var ResourceScheduler = class {
     }
   }
 };
-
-// builtin/extensions/computer-use/src/browser-owner.ts
-import { execFile } from "node:child_process";
-import { rm } from "node:fs/promises";
-import os4 from "node:os";
-import path9 from "node:path";
-async function requestBrowserClose(port) {
-  const response = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(500) });
-  const data = await response.json();
-  if (!data.webSocketDebuggerUrl) return;
-  const url = new URL(data.webSocketDebuggerUrl);
-  if (url.hostname !== "127.0.0.1" && url.hostname !== "localhost") throw new Error("Owned browser exposed a non-local debugger.");
-  if (url.port !== port) throw new Error("Owned browser debugger port changed.");
-  await new Promise((resolve) => {
-    const ws = new wrapper_default(url);
-    let done = false;
-    const finish = () => {
-      if (done) return;
+var OwnerScopedMap = class {
+  constructor(scope) {
+    this.scope = scope;
+  }
+  scope;
+  maps = /* @__PURE__ */ new Map();
+  owner() {
+    const owner = this.scope.currentOwner();
+    return owner || COMPUTER_USE_STANDALONE_OWNER;
+  }
+  map() {
+    const owner = this.owner();
+    let map = this.maps.get(owner);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.maps.set(owner, map);
+    }
+    return map;
+  }
+  get(key) {
+    return this.map().get(key);
+  }
+  has(key) {
+    return this.map().has(key);
+  }
+  set(key, value) {
+    this.map().set(key, value);
+    return this;
+  }
+  delete(key) {
+    return this.map().delete(key);
+  }
+  values() {
+    return this.map().values();
+  }
+  entries() {
+    return this.map().entries();
+  }
+  clear() {
+    this.map().clear();
+  }
+  clearAll() {
+    this.maps.clear();
+  }
+  owners() {
+    return [...this.maps.keys()];
+  }
+};
+var OwnerScopedCounter = class {
+  constructor(scope, initial = 1) {
+    this.scope = scope;
+    this.initial = initial;
+  }
+  scope;
+  initial;
+  counters = /* @__PURE__ */ new Map();
+  owner() {
+    const owner = this.scope.currentOwner();
+    return owner || COMPUTER_USE_STANDALONE_OWNER;
+  }
+  next() {
+    const owner = this.owner();
+    const value = this.counters.get(owner) ?? this.initial;
+    this.counters.set(owner, value + 1);
+    return value;
+  }
+  current() {
+    return this.counters.get(this.owner()) ?? this.initial;
+  }
+  raiseAtLeast(value) {
+    const owner = this.owner();
+    this.counters.set(owner, Math.max(this.counters.get(owner) ?? this.initial, Math.trunc(value)));
+  }
+  clear() {
+    this.counters.delete(this.owner());
+  }
+  clearAll() {
+    this.counters.clear();
+  }
+};
+
+// vendor/computer-use-axi/src/browser-owner.ts
+import { execFile } from "node:child_process";
+import { rm } from "node:fs/promises";
+import os3 from "node:os";
+import path12 from "node:path";
+async function requestBrowserClose(port) {
+  const response = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(500) });
+  const data = await response.json();
+  if (!data.webSocketDebuggerUrl) return;
+  const url = new URL(data.webSocketDebuggerUrl);
+  if (url.hostname !== "127.0.0.1" && url.hostname !== "localhost") throw new Error("Owned browser exposed a non-local debugger.");
+  if (url.port !== port) throw new Error("Owned browser debugger port changed.");
+  await new Promise((resolve2) => {
+    const ws = new wrapper_default(url);
+    let done = false;
+    const finish = () => {
+      if (done) return;
       done = true;
       clearTimeout(timer);
       ws.terminate();
-      resolve();
+      resolve2();
     };
     const timer = setTimeout(finish, 700);
     ws.on("open", () => ws.send(JSON.stringify({ id: 1, method: "Browser.close" })));
@@ -6935,15 +7893,15 @@ async function requestBrowserClose(port) {
 }
 async function waitForExit(child, timeoutMs) {
   if (child.exitCode !== null || child.signalCode !== null) return true;
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const finish = () => {
       clearTimeout(timer);
       child.off("exit", finish);
-      resolve(true);
+      resolve2(true);
     };
     const timer = setTimeout(() => {
       child.off("exit", finish);
-      resolve(false);
+      resolve2(false);
     }, timeoutMs);
     child.once("exit", finish);
   });
@@ -6954,11 +7912,11 @@ async function releaseOwnedBrowser(child, port, profile) {
     if (!await waitForExit(child, 700)) {
       if (process.platform === "win32" && child.pid) {
         const pid = child.pid;
-        await new Promise((resolve) => {
+        await new Promise((resolve2) => {
           execFile("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
             windowsHide: true,
             timeout: 2e3
-          }, () => resolve());
+          }, () => resolve2());
         });
         if (!await waitForExit(child, 1500)) {
           try {
@@ -6979,8 +7937,8 @@ async function releaseOwnedBrowser(child, port, profile) {
     }
   }
   if (profile) {
-    const resolved = path9.resolve(profile);
-    if (path9.dirname(resolved) !== path9.resolve(os4.tmpdir()) || !/^pie-(chrome|helium)-cdp-/.test(path9.basename(resolved))) {
+    const resolved = path12.resolve(profile);
+    if (path12.dirname(resolved) !== path12.resolve(os3.tmpdir()) || !/^pie-(chrome|helium)-cdp-/.test(path12.basename(resolved))) {
       throw new Error("Refusing to remove a profile outside the owned temporary browser directory.");
     }
     await rm(resolved, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
@@ -6992,7 +7950,7 @@ async function releaseOwnedBrowserState(owner) {
   owner.managedBrowserProfileDir = void 0;
 }
 
-// builtin/extensions/computer-use/src/root-selection.ts
+// vendor/computer-use-axi/src/root-selection.ts
 function scoreWindow(window) {
   let score = 0;
   if (window.isModal) score += 180;
@@ -7011,11 +7969,14 @@ function shouldPreferForegroundModalWindow(current, candidate) {
   return candidateIsInFront && scoreWindow(candidate) >= scoreWindow(current);
 }
 
-// builtin/extensions/computer-use/src/state.ts
+// vendor/computer-use-axi/src/state.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 var SavedStates = class {
-  store = new StateStore(128);
+  store;
   operations = new AsyncLocalStorage();
+  constructor(store = new StateStore(128)) {
+    this.store = store;
+  }
   current() {
     const state = this.operations.getStore();
     if (!state) throw new Error("Computer-use operation state is unavailable.");
@@ -7047,6 +8008,9 @@ var SavedStates = class {
         currentOutline: outline2,
         resourceKey: record.resourceKey,
         epoch: record.epoch,
+        owner: record.owner,
+        generation: record.generation,
+        helperGeneration: record.helperGeneration,
         browserSnapshot: record.value.snapshot,
         contextId: record.value.snapshot.contextId
       };
@@ -7061,7 +8025,10 @@ var SavedStates = class {
       currentOutline: outline,
       currentNote: record.value.note ? structuredClone(record.value.note) : void 0,
       resourceKey: record.resourceKey,
-      epoch: record.epoch
+      epoch: record.epoch,
+      owner: record.owner,
+      generation: record.generation,
+      helperGeneration: record.helperGeneration
     };
   }
   saveDesktop(state, resourceKey, epoch) {
@@ -7070,6 +8037,9 @@ var SavedStates = class {
       stateId: state.currentCapture.stateId,
       resourceKey,
       epoch,
+      owner: state.owner,
+      generation: state.generation,
+      helperGeneration: state.helperGeneration,
       value: {
         kind: "desktop",
         target: { ...state.currentTarget },
@@ -7090,7 +8060,7 @@ var SavedStates = class {
   }
 };
 
-// builtin/extensions/computer-use/src/view.ts
+// vendor/computer-use-axi/src/view.ts
 function numericRef(ref) {
   const match = /^@e(\d+)$/.exec(ref);
   return match ? Number(match[1]) : 0;
@@ -7226,7 +8196,7 @@ function renderChanges(changes) {
   }).join("\n");
 }
 
-// builtin/extensions/computer-use/src/bridge.ts
+// vendor/computer-use-axi/src/bridge.ts
 var MISSING_TARGET_ERROR = "No current controlled window. Call observe_ui first to choose a target window.";
 var CURRENT_TARGET_GONE_ERROR = "The current controlled window is no longer available. Call observe_ui to choose a new target window.";
 var COMMAND_TIMEOUT_MS5 = 15e3;
@@ -7237,17 +8207,51 @@ var MANAGED_BROWSER_READY_TIMEOUT_MS = 15e3;
 var AUTO_IMAGE_MAX_DIMENSION = 900;
 var EXPLICIT_IMAGE_MAX_DIMENSION = 1600;
 var BROWSER_TRANSACTION_ACTIONS = /* @__PURE__ */ new Set(["press", "click", "setText", "typeText", "keypress", "scroll", "drag", "moveMouse"]);
+var ownerScope = {
+  currentOwner: () => savedStates.operations.getStore()?.owner ?? COMPUTER_USE_STANDALONE_OWNER
+};
 var runtimeState = {
   lastPermissionCheckAt: 0,
-  windowRefs: /* @__PURE__ */ new Map(),
-  windowRefByIdentity: /* @__PURE__ */ new Map(),
-  browserRootByContext: /* @__PURE__ */ new Map(),
-  browserContextByRoot: /* @__PURE__ */ new Map(),
-  nextRootRefIndex: 1
+  windowRefs: new OwnerScopedMap(ownerScope),
+  windowRefByIdentity: new OwnerScopedMap(ownerScope),
+  browserRootByContext: new OwnerScopedMap(ownerScope),
+  browserContextByRoot: new OwnerScopedMap(ownerScope),
+  nextRootRefIndex: new OwnerScopedCounter(ownerScope, 1)
 };
-var savedStates = new SavedStates();
+var engineGeneration = "";
+var helperGeneration = "";
+var engineArtifacts;
+function createStateStore() {
+  return new StateStore(128, (record) => {
+    engineArtifacts?.dropForState(record.stateId);
+  });
+}
+var savedStates = new SavedStates(createStateStore());
 var resourceScheduler = new ResourceScheduler();
 var shutdownInFlight;
+function configureEngineRuntime(options) {
+  engineGeneration = options.generation;
+  if (options.helperGeneration !== void 0) helperGeneration = options.helperGeneration;
+  engineArtifacts = options.artifacts;
+  expiredStateIds = new Set(options.expiredStateIds ?? []);
+  previousBrokerGeneration = options.previousGeneration ?? "";
+}
+function bumpHelperGeneration() {
+  helperGeneration = randomUUID7();
+  return helperGeneration;
+}
+function expireStatesAfterHelperRestart(reason = "the native helper restarted") {
+  const ids = savedStates.store.ids?.() ?? [];
+  for (const id of ids) expiredStateReasons.set(id, reason);
+  savedStates.clear();
+  return ids;
+}
+function expireStateForArtifactEviction(stateId2) {
+  expiredStateReasons.set(stateId2, "its image artifact was evicted");
+  savedStates.store.drop?.(stateId2);
+}
+function persistRuntimeBridgeState() {
+}
 function operationState() {
   return savedStates.current();
 }
@@ -7289,11 +8293,11 @@ async function releaseComputerUseSession() {
   }
   savedStates.clear();
   clearStoredOutputs();
-  runtimeState.windowRefs.clear();
-  runtimeState.windowRefByIdentity.clear();
-  runtimeState.browserRootByContext.clear();
-  runtimeState.browserContextByRoot.clear();
-  runtimeState.nextRootRefIndex = 1;
+  runtimeState.windowRefs.clearAll();
+  runtimeState.windowRefByIdentity.clearAll();
+  runtimeState.browserRootByContext.clearAll();
+  runtimeState.browserContextByRoot.clearAll();
+  runtimeState.nextRootRefIndex.clearAll();
   runtimeState.permissionStatus = void 0;
   runtimeState.helperDiagnostics = void 0;
   runtimeState.lastPermissionCheckAt = 0;
@@ -7341,10 +8345,10 @@ function throwIfAborted3(signal) {
 async function sleep2(ms, signal) {
   if (ms <= 0) return;
   throwIfAborted3(signal);
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const timer = setTimeout(() => {
       cleanup();
-      resolve();
+      resolve2();
     }, ms);
     const onAbort = () => {
       cleanup();
@@ -7364,8 +8368,9 @@ async function withWindowWriteLock(target, work) {
   const result = await resourceScheduler.write(key, baseEpoch, async (nextEpoch) => {
     state.resourceKey = key;
     state.epoch = nextEpoch;
+    state.onDispatch?.();
     return await work();
-  });
+  }, state.signal);
   return result.value;
 }
 function trimOrUndefined(value) {
@@ -7376,9 +8381,6 @@ function trimOrUndefined(value) {
 function normalizeText2(value) {
   return (value ?? "").trim().toLowerCase();
 }
-function toBoolean3(value) {
-  return value === true;
-}
 function outlineNodeCenter(node) {
   if (!node.rect) {
     throw new Error(`Outline ref '${node.ref}' has no full-look coordinates after scoped expansion. Re-observe for coordinates.`);
@@ -7546,18 +8548,20 @@ function storeWindowRef(record) {
       return updated;
     }
   }
-  const ref = `@r${runtimeState.nextRootRefIndex++}`;
+  const ref = `@r${runtimeState.nextRootRefIndex.next()}`;
   const stored = { ...record, ref };
   runtimeState.windowRefByIdentity.set(identity, ref);
   runtimeState.windowRefs.set(ref, stored);
+  persistRuntimeBridgeState();
   return stored;
 }
 function storeBrowserRootRef(contextId) {
   const existing = runtimeState.browserRootByContext.get(contextId);
   if (existing) return existing;
-  const ref = `@r${runtimeState.nextRootRefIndex++}`;
+  const ref = `@r${runtimeState.nextRootRefIndex.next()}`;
   runtimeState.browserRootByContext.set(contextId, ref);
   runtimeState.browserContextByRoot.set(ref, contextId);
+  persistRuntimeBridgeState();
   return ref;
 }
 function storeWindowRefForTarget(target) {
@@ -7792,7 +8796,7 @@ async function ensureTargetWindowId(target, signal) {
 }
 function captureForLook(look) {
   return {
-    stateId: randomUUID5(),
+    stateId: randomUUID7(),
     width: look.image?.width ?? 0,
     height: look.image?.height ?? 0,
     scaleFactor: look.window.scaleFactor,
@@ -7853,6 +8857,33 @@ async function buildToolResult(tool, summary, result, execution, _signal, imageM
   const folded = foldToBudget(result.outline);
   const renderedNote = renderNote(state.currentNote);
   const failure = tool === "act_ui" ? actionFailureMessage(execution) : void 0;
+  const image = result.look.image;
+  let artifact;
+  if (image?.jpegBase64 && engineArtifacts) {
+    const bytes = Buffer.from(image.jpegBase64, "base64");
+    const record = engineArtifacts.put({
+      owner: state.owner ?? COMPUTER_USE_STANDALONE_OWNER,
+      generation: state.generation ?? engineGeneration,
+      stateId: result.capture.stateId,
+      mimeType: image.mimeType ?? "image/jpeg",
+      width: image.width,
+      height: image.height,
+      bytes
+    });
+    state.artifactIds ??= [];
+    state.artifactIds.push(record.artifactId);
+    artifact = {
+      artifactId: record.artifactId,
+      path: record.absolutePath,
+      mimeType: record.mimeType,
+      width: record.width,
+      height: record.height,
+      sha256: record.hash,
+      bytes: record.bytes,
+      generation: record.generation,
+      stateId: record.stateId
+    };
+  }
   const details = {
     tool,
     target: {
@@ -7870,7 +8901,8 @@ async function buildToolResult(tool, summary, result, execution, _signal, imageM
       height: result.capture.height,
       scaleFactor: result.capture.scaleFactor,
       timestamp: result.capture.timestamp,
-      coordinateSpace: "window-relative-screenshot-pixels"
+      coordinateSpace: "window-relative-screenshot-pixels",
+      ...artifact ? { artifact } : {}
     },
     lookId: result.look.lookId,
     view: useDiff ? "diff" : "full",
@@ -7914,12 +8946,15 @@ ${folded.text}`;
   const fallbackText = fallbackReason ? `
 
 ${fallbackReason.message}` : "";
+  const artifactText = artifact ? `
+
+Image evidence: ${artifact.path} (${artifact.width}x${artifact.height} ${artifact.mimeType}, sha256 ${artifact.sha256}, stateId ${artifact.stateId}, generation ${artifact.generation}). Call read_file on that absolute path before using coordinates; the image belongs only to stateId ${artifact.stateId}.` : "";
   const deltaText = rootDeltaLines(execution).join("\n");
   const outcomeSummary = failure ? `UI action failed (${failure}). Some actions may already have been delivered; do not replay blindly.` : summary;
   const content = [{ type: "text", text: `${outcomeSummary}${deltaText ? `
-${deltaText}` : ""}${consoleText}${noteText}${outlineText}${fallbackText}` }];
-  if (fallbackReason && result.look.image?.jpegBase64) {
-    content.push({ type: "image", data: result.look.image.jpegBase64, mimeType: result.look.image.mimeType ?? "image/jpeg" });
+${deltaText}` : ""}${consoleText}${noteText}${outlineText}${fallbackText}${artifactText}` }];
+  if (!artifact && fallbackReason && image?.jpegBase64) {
+    content.push({ type: "image", data: image.jpegBase64, mimeType: image.mimeType ?? "image/jpeg" });
   }
   return { content, details, ...failure ? { isError: true } : {} };
 }
@@ -7947,7 +8982,7 @@ function modelRefForRootDelta(delta) {
   for (const record2 of runtimeState.windowRefs.values()) {
     if (record2.nativeWindowRef === delta.ref || record2.ref === delta.ref) return record2.ref;
   }
-  const ref = `@r${runtimeState.nextRootRefIndex++}`;
+  const ref = `@r${runtimeState.nextRootRefIndex.next()}`;
   const current = operationState().currentTarget;
   const record = {
     ref,
@@ -7965,6 +9000,7 @@ function modelRefForRootDelta(delta) {
   };
   runtimeState.windowRefs.set(ref, record);
   runtimeState.windowRefByIdentity.set(windowRecordIdentity(record), ref);
+  persistRuntimeBridgeState();
   return ref;
 }
 function executionTraceFromAct(result, policy = currentDeliveryPolicy()) {
@@ -8174,12 +9210,22 @@ async function withBrowserWrite(contextId, work) {
   const result = await resourceScheduler.write(resourceKey, baseEpoch, async (nextEpoch) => {
     state.resourceKey = resourceKey;
     state.epoch = nextEpoch;
+    state.onDispatch?.();
     return await work();
-  });
+  }, state.signal);
   return result.value;
 }
 function browserObservationResult(browser, resourceKey, epoch, tool, base) {
-  savedStates.set({ stateId: browser.snapshotId, resourceKey, epoch, value: { kind: "browser", snapshot: browser, outline: browser.outline } });
+  const operation = operationState();
+  savedStates.set({
+    stateId: browser.snapshotId,
+    resourceKey,
+    epoch,
+    owner: operation.owner,
+    generation: operation.generation,
+    helperGeneration: operation.helperGeneration,
+    value: { kind: "browser", snapshot: browser, outline: browser.outline }
+  });
   const currentOutline = restoreOutline(browser.outline);
   const transition = base ? changesBetween(restoreOutline(base.outline), currentOutline) : void 0;
   const useDiff = Boolean(transition && !transition.useFullView);
@@ -8215,8 +9261,8 @@ function sliceText(value, offsetValue, _limitValue) {
 async function performReadText(params, signal) {
   const ref = trimOrUndefined(params.ref);
   if (ref?.startsWith("@o")) {
-    const page = readStoredOutput(ref, params.offset);
-    if (!page) throw new Error(`Output ref '${ref}' is unavailable or was evicted. Rerun the focused query.`);
+    const page = readStoredOutput(ref, params.offset, operationState().owner ?? COMPUTER_USE_STANDALONE_OWNER);
+    if (!page) throw new Error(`Output ref '${ref}' is unavailable, was evicted, or belongs to another session. Rerun the focused query.`);
     const details2 = { tool: "read_text", ref, ...page };
     const suffix = page.hasMore ? `
 
@@ -8269,7 +9315,7 @@ function conditionScopeRef(params) {
   if (ref && scopeRef) throw new Error("A UI condition accepts ref or scopeRef, not both.");
   return ref ?? scopeRef;
 }
-function validateCondition(params) {
+function validateCondition2(params) {
   const text = trimOrUndefined(params.text);
   const role = trimOrUndefined(params.role);
   const value = trimOrUndefined(params.value);
@@ -8284,7 +9330,7 @@ function expectCondition(expect) {
   const hasMatcher = Boolean(trimOrUndefined(expect.text) ?? trimOrUndefined(expect.role) ?? trimOrUndefined(expect.value));
   const hasScope = Boolean(conditionScopeRef(expect));
   if (!hasMatcher && !hasScope) return void 0;
-  return validateCondition(expect);
+  return validateCondition2(expect);
 }
 function nodeWithinScope(node, scopeRef, scopeExact) {
   if (!scopeRef) return true;
@@ -8313,7 +9359,7 @@ function conditionScopeNode(outline, condition) {
 }
 async function performWaitFor(params, signal) {
   const contextId = operationState().contextId;
-  const condition = validateCondition(params);
+  const condition = validateCondition2(params);
   const { text, role, value, scopeRef, scopeExact, gone, timeoutMs } = condition;
   if (isBrowserContextId(contextId)) {
     const state2 = operationState();
@@ -8403,7 +9449,7 @@ function sameRootIdentity(a, b) {
 }
 async function performObserve(params, signal) {
   const requestedRoot = typeof params.root === "string" ? params.root : void 0;
-  if (requestedRoot && !/^@r\d+$/.test(requestedRoot)) throw new Error("observe_ui.root must be an exact @r ref issued by find_roots.");
+  if (requestedRoot && !/^@r\d+$/.test(requestedRoot)) throw new Error("observe --root must be an exact @r ref issued by roots.");
   const browserContextId = requestedRoot ? runtimeState.browserContextByRoot.get(requestedRoot) : void 0;
   if (isBrowserContextId(browserContextId)) {
     const targetId = browserContextId.slice(BROWSER_CONTEXT_PREFIX.length);
@@ -8809,8 +9855,8 @@ async function performBrowserTransaction(params, actions, signal) {
     return await refreshBrowserSnapshot(contextId, "act_ui", baseView);
   });
 }
-function normalizeActionPath(path11) {
-  return (path11 ?? []).map((point2) => Array.isArray(point2) ? { x: toFiniteNumber(point2[0], 0), y: toFiniteNumber(point2[1], 0) } : { x: toFiniteNumber(point2.x, 0), y: toFiniteNumber(point2.y, 0) });
+function normalizeActionPath(path15) {
+  return (path15 ?? []).map((point) => Array.isArray(point) ? { x: toFiniteNumber(point[0], 0), y: toFiniteNumber(point[1], 0) } : { x: toFiniteNumber(point.x, 0), y: toFiniteNumber(point.y, 0) });
 }
 function validateActionTarget(action) {
   const hasRef = Boolean(trimOrUndefined(action.ref));
@@ -8827,7 +9873,7 @@ function validateActionTarget(action) {
 }
 async function performAct(params, signal) {
   const actions = Array.isArray(params.actions) ? params.actions : [];
-  if (actions.length === 0) throw new Error("act_ui.actions must contain at least one action.");
+  if (actions.length === 0) throw new Error("act --actions must contain at least one action.");
   if (actions.length > 20) throw new Error("act_ui supports at most 20 actions per transaction.");
   for (const action of actions) validateActionTarget(action);
   if (operationState().contextId) return await performBrowserTransaction(params, actions, signal);
@@ -8836,25 +9882,25 @@ async function performAct(params, signal) {
 function managedBrowserExecutableCandidates(browser) {
   const overrideName = browser === "helium" ? "PIE_COMPUTER_USE_HELIUM_EXECUTABLE" : "PIE_COMPUTER_USE_CHROME_EXECUTABLE";
   const override = trimOrUndefined(process.env[overrideName]);
-  if (override) return [path10.resolve(override)];
+  if (override) return [path13.resolve(override)];
   const platformCandidates = process.platform === "darwin" ? browser === "helium" ? [
     "/Applications/Helium.app/Contents/MacOS/Helium",
-    path10.join(os5.homedir(), "Applications", "Helium.app", "Contents", "MacOS", "Helium")
+    path13.join(os4.homedir(), "Applications", "Helium.app", "Contents", "MacOS", "Helium")
   ] : [
     "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-    path10.join(os5.homedir(), "Applications", "Google Chrome.app", "Contents", "MacOS", "Google Chrome")
+    path13.join(os4.homedir(), "Applications", "Google Chrome.app", "Contents", "MacOS", "Google Chrome")
   ] : process.platform === "win32" ? browser === "helium" ? [
-    process.env.LOCALAPPDATA && path10.join(process.env.LOCALAPPDATA, "Helium", "Application", "helium.exe"),
-    process.env.PROGRAMFILES && path10.join(process.env.PROGRAMFILES, "Helium", "Application", "helium.exe")
+    process.env.LOCALAPPDATA && path13.join(process.env.LOCALAPPDATA, "Helium", "Application", "helium.exe"),
+    process.env.PROGRAMFILES && path13.join(process.env.PROGRAMFILES, "Helium", "Application", "helium.exe")
   ] : [
-    process.env.LOCALAPPDATA && path10.join(process.env.LOCALAPPDATA, "Google", "Chrome", "Application", "chrome.exe"),
-    process.env.PROGRAMFILES && path10.join(process.env.PROGRAMFILES, "Google", "Chrome", "Application", "chrome.exe"),
-    process.env["PROGRAMFILES(X86)"] && path10.join(process.env["PROGRAMFILES(X86)"], "Google", "Chrome", "Application", "chrome.exe")
+    process.env.LOCALAPPDATA && path13.join(process.env.LOCALAPPDATA, "Google", "Chrome", "Application", "chrome.exe"),
+    process.env.PROGRAMFILES && path13.join(process.env.PROGRAMFILES, "Google", "Chrome", "Application", "chrome.exe"),
+    process.env["PROGRAMFILES(X86)"] && path13.join(process.env["PROGRAMFILES(X86)"], "Google", "Chrome", "Application", "chrome.exe")
   ] : browser === "helium" ? [
     "/usr/bin/helium",
     "/usr/bin/helium-browser",
     "/opt/helium/chrome",
-    path10.join(os5.homedir(), ".local", "helium", "chrome")
+    path13.join(os4.homedir(), ".local", "helium", "chrome")
   ] : [
     "/usr/bin/google-chrome",
     "/usr/bin/google-chrome-stable",
@@ -8863,7 +9909,7 @@ function managedBrowserExecutableCandidates(browser) {
     "/snap/bin/chromium"
   ];
   const pathNames = browser === "helium" ? process.platform === "win32" ? ["helium.exe"] : ["helium", "helium-browser"] : process.platform === "win32" ? ["chrome.exe"] : ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"];
-  const pathCandidates = (process.env.PATH ?? "").split(path10.delimiter).filter(Boolean).flatMap((directory) => pathNames.map((name) => path10.join(directory, name)));
+  const pathCandidates = (process.env.PATH ?? "").split(path13.delimiter).filter(Boolean).flatMap((directory) => pathNames.map((name) => path13.join(directory, name)));
   return [.../* @__PURE__ */ new Set([...platformCandidates.filter((candidate) => Boolean(candidate)), ...pathCandidates])];
 }
 async function managedBrowserExecutable(browser) {
@@ -8882,13 +9928,13 @@ async function managedBrowserExecutable(browser) {
   throw new Error(`${browser} executable was not found. Set ${overrideName} to its absolute path.`);
 }
 function freeTcpPort() {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = net2.createServer();
     server.on("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const address = server.address();
       const port = typeof address === "object" && address ? address.port : 0;
-      server.close(() => port > 0 ? resolve(port) : reject(new Error("Could not allocate a local CDP port.")));
+      server.close(() => port > 0 ? resolve2(port) : reject(new Error("Could not allocate a local CDP port.")));
     });
   });
 }
@@ -8914,7 +9960,7 @@ async function performLaunchBrowser(params, signal) {
   const url = requestedUrl ?? "about:blank";
   await disconnectCdp();
   await releaseOwnedBrowserState(runtimeState);
-  const profileDir = mkdtempSync2(path10.join(os5.tmpdir(), `pie-${browser}-cdp-`));
+  const profileDir = mkdtempSync(path13.join(os4.tmpdir(), `pie-${browser}-cdp-`));
   const args = [
     `--remote-debugging-port=${port}`,
     `--user-data-dir=${profileDir}`,
@@ -8925,11 +9971,20 @@ async function performLaunchBrowser(params, signal) {
   if (runtimeState.previousCdpPort === void 0 && runtimeState.managedBrowserCdpPort === void 0) {
     runtimeState.previousCdpPort = process.env.PIE_COMPUTER_USE_CDP_PORT;
   }
-  const managedBrowser = spawn4(executable, args, { stdio: "ignore", detached: false });
+  const managedBrowser = spawn4(executable, args, { stdio: "ignore", detached: true });
   managedBrowser.unref();
+  const stalePid = runtimeState.managedBrowserPid;
+  if (stalePid !== void 0 && stalePid !== managedBrowser.pid) {
+    try {
+      process.kill(stalePid, "SIGTERM");
+    } catch {
+    }
+  }
   runtimeState.managedBrowser = managedBrowser;
   runtimeState.managedBrowserCdpPort = String(port);
+  runtimeState.managedBrowserPid = managedBrowser.pid;
   runtimeState.managedBrowserProfileDir = profileDir;
+  persistRuntimeBridgeState();
   process.env.PIE_COMPUTER_USE_CDP_PORT = String(port);
   try {
     await waitForCdpPort(port, signal);
@@ -8986,447 +10041,806 @@ async function performEvaluateBrowser(params) {
     return { content: [...successor.content, { type: "text", text: `Evaluation value: ${JSON.stringify(result.value)}` }], details };
   });
 }
-async function executeTool(tool, ctx, params, signal, run) {
+var expiredStateIds = /* @__PURE__ */ new Set();
+var previousBrokerGeneration = "";
+var expiredStateReasons = /* @__PURE__ */ new Map();
+function assertStateAccess(stateId2, record, operation) {
+  const owner = operation.owner ?? COMPUTER_USE_STANDALONE_OWNER;
+  if (record.owner !== void 0 && record.owner !== owner) {
+    throw new Error(`State '${stateId2}' is not available to this session. Observe the root again in this session.`);
+  }
+  if (record.generation !== void 0 && operation.generation !== void 0 && record.generation !== operation.generation) {
+    throw new Error(`State '${stateId2}' expired (broker generation changed from ${record.generation} to ${operation.generation}). Observe the root again.`);
+  }
+  if (record.helperGeneration !== void 0 && operation.helperGeneration !== void 0 && record.helperGeneration !== operation.helperGeneration) {
+    throw new Error(`State '${stateId2}' expired after the native helper restarted. Observe the root again.`);
+  }
+}
+async function executeTool(tool, ctx, params, signal, run, runtime) {
   if (shutdownInFlight) throw new Error("Computer-use resources are shutting down.");
   const outputRef = tool === "read_text" && trimOrUndefined(params?.ref)?.startsWith("@o") === true;
   const requestedStateId = outputRef ? void 0 : trimOrUndefined(params?.stateId);
   const stateRecord = requestedStateId ? savedStates.get(requestedStateId) : void 0;
   if (requestedStateId && !stateRecord) {
+    const reason = expiredStateReasons.get(requestedStateId);
+    if (reason) {
+      throw new Error(`State '${requestedStateId}' expired because ${reason}. Observe the root again; old state is never replayed.`);
+    }
+    if (expiredStateIds.has(requestedStateId)) {
+      throw new Error(`State '${requestedStateId}' expired (previous broker generation ${previousBrokerGeneration || "unknown"}). Observe the root again; old CLI cache is not restored.`);
+    }
     throw new Error(`State '${requestedStateId}' is unavailable or was evicted. Observe the root again.`);
   }
   const operation = savedStates.hydrate(stateRecord);
+  operation.owner = runtime?.owner ?? operation.owner ?? COMPUTER_USE_STANDALONE_OWNER;
+  operation.generation = runtime?.generation ?? operation.generation ?? engineGeneration;
+  operation.helperGeneration = runtime?.helperGeneration ?? operation.helperGeneration ?? helperGeneration;
+  operation.requestId = runtime?.requestId;
+  operation.signal = signal ?? runtime?.signal;
+  operation.onDispatch = runtime?.onDispatch;
+  if (requestedStateId && stateRecord) assertStateAccess(requestedStateId, stateRecord, operation);
   return await savedStates.operations.run(operation, async () => {
-    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.");
-        }
-      } else await ensureReady3(ctx, signal);
-    });
-    throwIfAborted3(signal);
-    const result = await run();
-    persistOperation(operation);
-    return result;
+    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.");
+          }
+        } else await ensureReady3(ctx, signal);
+      }, operation.signal);
+      throwIfAborted3(signal);
+      const result = await run();
+      persistOperation(operation);
+      return result;
+    } finally {
+      for (const artifactId of operation.artifactIds ?? []) engineArtifacts?.unpin(artifactId);
+    }
   });
 }
-function makeToolExecutor(tool, perform) {
-  return async (_toolCallId, params, signal, _onUpdate, ctx) => {
+var BROKER_PERFORMERS = {
+  find_roots: performListWindows,
+  observe_ui: performObserve,
+  search_ui: performSearchUi,
+  expand_ui: performExpandUi,
+  inspect_ui: performInspectUi,
+  read_text: performReadText,
+  wait_for: performWaitFor,
+  act_ui: performAct,
+  launch_browser: performLaunchBrowser,
+  navigate_browser: performNavigateBrowser,
+  evaluate_browser: performEvaluateBrowser
+};
+async function executeBrokerCommand(command, params, runtime) {
+  const perform = BROKER_PERFORMERS[command];
+  if (!perform) throw new Error(`Unsupported broker command '${String(command)}'.`);
+  const ctx = { cwd: runtime.cwd, getMessages: () => [] };
+  return await executeTool(command, ctx, params, runtime.signal, async () => {
+    const owner = operationState().owner ?? COMPUTER_USE_STANDALONE_OWNER;
     try {
-      return applyOutputEnvelope(tool, await executeTool(tool, ctx, params, signal, () => perform(params, signal)));
+      return applyOutputEnvelope(command, await perform(params, runtime.signal), owner);
     } catch (error) {
-      throw boundToolError(tool, error);
+      throw boundToolError(command, error, owner);
     }
-  };
+  }, runtime);
 }
-var executeFind = makeToolExecutor("find_roots", performListWindows);
-var executeReadText = makeToolExecutor("read_text", performReadText);
-var executeWaitFor = makeToolExecutor("wait_for", performWaitFor);
-var executeObserve = makeToolExecutor("observe_ui", performObserve);
-var executeSearchUi = makeToolExecutor("search_ui", performSearchUi);
-var executeExpandUi = makeToolExecutor("expand_ui", performExpandUi);
-var executeInspectUi = makeToolExecutor("inspect_ui", performInspectUi);
-var executeAct = makeToolExecutor("act_ui", performAct);
-var executeNavigateBrowser = makeToolExecutor("navigate_browser", performNavigateBrowser);
-var executeEvaluateBrowser = makeToolExecutor("evaluate_browser", performEvaluateBrowser);
-var executeLaunchBrowser = makeToolExecutor("launch_browser", performLaunchBrowser);
-function reconstructStateFromBranch(ctx) {
-  savedStates.clear();
-  clearStoredOutputs();
-  runtimeState.windowRefs.clear();
-  runtimeState.windowRefByIdentity.clear();
-  runtimeState.nextRootRefIndex = 1;
-  const restoredResources = /* @__PURE__ */ new Set();
-  for (const message of [...ctx.getMessages()].reverse()) {
-    if (!message || message.role !== "toolResult") continue;
-    if (!AGENT_TOOL_NAMES.has(message.toolName)) continue;
-    const rawDetails = message.details;
-    if (rawDetails?.tool === "find_roots" && Array.isArray(rawDetails.windows)) {
-      for (const window of rawDetails.windows) {
-        if (typeof window?.windowRef !== "string" || !Number.isFinite(window?.pid)) continue;
-        const record = {
-          ref: window.windowRef,
-          appName: typeof window.app === "string" ? window.app : "Unknown App",
-          bundleId: typeof window.bundleId === "string" ? window.bundleId : void 0,
-          pid: Math.trunc(window.pid),
-          windowTitle: typeof window.windowTitle === "string" ? window.windowTitle : "(untitled)",
-          windowId: Number.isFinite(window.windowId) ? Math.trunc(window.windowId) : void 0,
-          nativeWindowRef: typeof window.nativeWindowRef === "string" ? window.nativeWindowRef : void 0,
-          framePoints: {
-            x: toFiniteNumber(window.framePoints?.x, 0),
-            y: toFiniteNumber(window.framePoints?.y, 0),
-            w: Math.max(1, toFiniteNumber(window.framePoints?.w, 1)),
-            h: Math.max(1, toFiniteNumber(window.framePoints?.h, 1))
-          },
-          scaleFactor: Math.max(1, toFiniteNumber(window.scaleFactor, 1)),
-          isMinimized: toBoolean3(window.isMinimized),
-          isOnscreen: toBoolean3(window.isOnscreen),
-          isMain: toBoolean3(window.isMain),
-          isFocused: toBoolean3(window.isFocused)
-        };
-        runtimeState.windowRefs.set(record.ref, record);
-        runtimeState.windowRefByIdentity.set(windowRecordIdentity(record), record.ref);
-        const match = /^@r(\d+)$/.exec(record.ref);
-        if (match) runtimeState.nextRootRefIndex = Math.max(runtimeState.nextRootRefIndex, Number(match[1]) + 1);
-      }
-      continue;
-    }
-    const details = rawDetails;
-    if (!details?.target || !details?.capture) continue;
-    const app = typeof details.target.app === "string" ? details.target.app : void 0;
-    if (!app) continue;
-    if (!Number.isFinite(details.target.pid) || !Number.isFinite(details.target.windowId)) continue;
-    if (typeof details.capture.stateId !== "string") continue;
-    const target = {
-      appName: app,
-      bundleId: details.target.bundleId,
-      pid: Math.trunc(details.target.pid),
-      windowTitle: details.target.windowTitle ?? "(untitled)",
-      windowId: Math.trunc(details.target.windowId),
-      windowRef: typeof details.target.windowRef === "string" ? details.target.windowRef : void 0,
-      nativeWindowRef: typeof details.target.nativeWindowRef === "string" ? details.target.nativeWindowRef : void 0
+
+// vendor/computer-use-axi/src/broker-server.ts
+function sleep3(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireBootstrapLock(directory) {
+  ensurePrivateDirectory(directory);
+  const lockPath = path14.join(directory, "broker.lock");
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    try {
+      writeFileSync3(lockPath, String(process.pid), { flag: "wx", mode: 384 });
+      return () => {
+        try {
+          unlinkSync4(lockPath);
+        } catch {
+        }
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      let ownerPid = 0;
+      try {
+        ownerPid = Number.parseInt(readFileSync4(lockPath, "utf8").trim(), 10);
+      } catch {
+      }
+      if (Number.isInteger(ownerPid) && ownerPid > 0 && isAlive(ownerPid)) {
+        const until = Date.now() + 100;
+        while (Date.now() < until) {
+        }
+        continue;
+      }
+      try {
+        unlinkSync4(lockPath);
+      } catch {
+      }
+    }
+  }
+  throw new Error(`Could not acquire the computer-use broker bootstrap lock at ${lockPath}.`);
+}
+async function listen(server, endpoint) {
+  if (endpoint.kind === "unix-socket") ensurePrivateDirectory(endpoint.directory);
+  await new Promise((resolve2, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve2();
     };
-    const resourceKey = desktopResourceKey(target);
-    if (restoredResources.has(resourceKey)) continue;
-    const capture = {
-      stateId: details.capture.stateId,
-      width: Math.max(1, Math.trunc(toFiniteNumber(details.capture.width, 1))),
-      height: Math.max(1, Math.trunc(toFiniteNumber(details.capture.height, 1))),
-      scaleFactor: Math.max(1, toFiniteNumber(details.capture.scaleFactor, 1)),
-      timestamp: Number.isFinite(details.capture.timestamp) ? details.capture.timestamp : Date.now()
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(endpoint.path);
+  });
+  if (endpoint.kind === "unix-socket") chmodSync2(endpoint.path, 384);
+}
+async function probeBroker(endpoint, timeoutMs = 800) {
+  return await new Promise((resolve2) => {
+    const socket = net3.createConnection(endpoint.path);
+    const decoder = new FrameDecoder();
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve2(result);
+    };
+    socket.setTimeout(timeoutMs, () => finish({ error: "timeout" }));
+    socket.on("connect", () => {
+      socket.write(encodeFrame({ type: "hello", protocolVersion: BROKER_PROTOCOL_VERSION, clientVersion: "probe" }));
+    });
+    socket.on("data", (chunk) => {
+      try {
+        const frames = decoder.push(chunk);
+        for (const frame of frames) {
+          if (frame && typeof frame === "object" && frame.type === "hello") finish({ live: frame });
+        }
+      } catch (error) {
+        finish({ error: error instanceof Error ? error.message : String(error) });
+      }
+    });
+    socket.on("error", (error) => {
+      if (error.code === "ECONNREFUSED" || error.code === "ENOENT") finish({ dead: true });
+      else finish({ error: error.message });
+    });
+    socket.on("close", () => finish({ error: "closed" }));
+  });
+}
+function canProveStaleEndpoint(endpoint) {
+  if (endpoint.kind !== "unix-socket") return false;
+  try {
+    const stats = lstatSync4(endpoint.path);
+    if (!stats.isSocket()) return false;
+    return typeof process.getuid === "function" ? stats.uid === process.getuid() : true;
+  } catch {
+    return false;
+  }
+}
+function removeStaleSocket(endpoint) {
+  if (!canProveStaleEndpoint(endpoint)) throw new Error(`Refusing to remove an endpoint that cannot be proven stale: ${endpoint.path}`);
+  unlinkSync4(endpoint.path);
+}
+function collectStateIds(value, into) {
+  if (!value || typeof value !== "object") return;
+  const record = value;
+  const details = record.details;
+  const candidate = details?.stateId ?? details?.capture?.stateId;
+  if (typeof candidate === "string" && /^[A-Za-z0-9-]{1,128}$/.test(candidate)) into.add(candidate);
+}
+async function startBroker(options = {}) {
+  const endpoint = options.endpoint ?? resolveBrokerEndpoint();
+  const idleExitMs = options.idleExitMs ?? BROKER_IDLE_EXIT_MS;
+  const generation = randomUUID8();
+  const helperGeneration2 = randomUUID8();
+  let liveHelperGeneration = helperGeneration2;
+  const startedAt = Date.now();
+  const legacyCache = cleanupLegacyBrokerCache();
+  const prior = loadBrokerManifest();
+  const artifacts = new ArtifactStore({
+    root: artifactsRoot(),
+    generation,
+    onEvict: (stateId2) => {
+      artifacts.dropForState(stateId2);
+      expireStateForArtifactEviction(stateId2);
+    }
+  });
+  try {
+    artifacts.cleanupOtherGenerations(generation);
+  } catch {
+  }
+  configureEngineRuntime({
+    generation,
+    helperGeneration: helperGeneration2,
+    artifacts,
+    expiredStateIds: prior?.stateIds ?? [],
+    previousGeneration: prior?.generation
+  });
+  saveBrokerManifest({ generation, helperGeneration: helperGeneration2, stateIds: [], updatedAt: Date.now() });
+  const entries = /* @__PURE__ */ new Map();
+  const owners = /* @__PURE__ */ new Set();
+  const knownStateIds = /* @__PURE__ */ new Set();
+  let active = 0;
+  let queued = 0;
+  let lastActivity = Date.now();
+  let drainRequested = false;
+  let stopping = false;
+  let idleTimer;
+  let statusHandle;
+  const persistManifest = () => {
+    try {
+      saveBrokerManifest({ generation, helperGeneration: currentHelperGenerationSafe(), stateIds: [...knownStateIds], updatedAt: Date.now() });
+    } catch {
+    }
+  };
+  const currentHelperGenerationSafe = () => liveHelperGeneration;
+  const send = (socket, frame) => {
+    if (!socket || socket.destroyed) return;
+    try {
+      socket.write(encodeFrame(frame, BROKER_MAX_RESPONSE_BYTES));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      try {
+        socket.write(encodeFrame({ type: "response", requestId: "broker", ok: false, state: "error", generation, helperGeneration: currentHelperGenerationSafe(), error: { code: "frame_too_large", message } }));
+      } catch {
+      }
+    }
+  };
+  const respond = (entry, state, result, error) => {
+    send(entry.socket, {
+      type: "response",
+      requestId: entry.requestId,
+      ok: state === "done" || state === "in-flight",
+      state,
+      generation,
+      helperGeneration: currentHelperGenerationSafe(),
+      ...result === void 0 ? {} : { result },
+      ...error ? { error } : {}
+    });
+  };
+  const waiters = [];
+  const acquireSlot = (entry) => {
+    if (entry.controller.signal.aborted) return Promise.resolve(false);
+    if (active < BROKER_MAX_CONCURRENT_REQUESTS) {
+      active += 1;
+      return Promise.resolve(true);
+    }
+    if (waiters.length >= BROKER_MAX_QUEUED_REQUESTS) return Promise.resolve(false);
+    return new Promise((resolve2) => {
+      const waiter = {
+        start: () => {
+          entry.controller.signal.removeEventListener("abort", waiter.cancel);
+          queued = Math.max(0, queued - 1);
+          resolve2(true);
+        },
+        cancel: () => {
+          const index = waiters.indexOf(waiter);
+          if (index >= 0) waiters.splice(index, 1);
+          queued = Math.max(0, queued - 1);
+          resolve2(false);
+        }
+      };
+      queued += 1;
+      entry.controller.signal.addEventListener("abort", waiter.cancel, { once: true });
+      waiters.push(waiter);
+    });
+  };
+  const releaseSlot = () => {
+    active = Math.max(0, active - 1);
+    const next = waiters.shift();
+    if (next) {
+      active += 1;
+      next.start();
+    }
+  };
+  const finish = (entry, state, result, error) => {
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.timer = void 0;
+    if (entry.finished) {
+      if (state === "done") {
+        entry.state = "done";
+        entry.result = result;
+        entry.error = void 0;
+        if (result !== void 0) collectStateIds(result, knownStateIds);
+        if (knownStateIds.size > 0) persistManifest();
+      }
+      if (entry.slotHeld) {
+        entry.slotHeld = false;
+        releaseSlot();
+      }
+      return;
+    }
+    entry.finished = true;
+    entry.state = state;
+    entry.result = result;
+    entry.error = error;
+    if (result !== void 0) collectStateIds(result, knownStateIds);
+    if (entry.slotHeld) {
+      entry.slotHeld = false;
+      releaseSlot();
+    }
+    respond(entry, state === "unknown" ? "outcome-unknown" : state === "error" ? "error" : "done", result, error);
+    if (knownStateIds.size > 0) persistManifest();
+  };
+  const runEntry = async (entry, request) => {
+    entry.state = "running";
+    entry.dispatched = request.command === "launch_browser";
+    lastActivity = Date.now();
+    try {
+      const result = await executeBrokerCommand(request.command, request.params, {
+        owner: request.ownerId,
+        generation,
+        helperGeneration: currentHelperGenerationSafe(),
+        requestId: request.requestId,
+        cwd: request.cwd,
+        signal: entry.controller.signal,
+        onDispatch: () => {
+          entry.dispatched = true;
+        }
+      });
+      finish(entry, "done", result);
+    } catch (error) {
+      const currentState = entry.state;
+      if (currentState === "unknown" || currentState === "error") return;
+      const message = error instanceof Error ? error.message : String(error);
+      finish(entry, "error", void 0, { code: "engine_error", message, dispatched: entry.dispatched });
+    }
+  };
+  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 } });
+      return;
+    }
+    const key = request.requestId;
+    const fingerprint = requestFingerprint(request.command, request.params, request.cwd);
+    const existing = entries.get(key);
+    if (existing) {
+      if (existing.ownerId !== request.ownerId || existing.command !== request.command || existing.fingerprint !== fingerprint) {
+        send(socket, { type: "response", requestId: request.requestId, ok: false, state: "error", generation, helperGeneration: currentHelperGenerationSafe(), error: { code: "request_id_conflict", message: "This requestId was already used with a different owner, command, params, or cwd. Use a fresh requestId." } });
+        return;
+      }
+      if (existing.state === "done") respond({ ...existing, socket }, "done", existing.result);
+      else if (existing.state === "running" || existing.state === "queued") respond({ ...existing, socket }, "in-flight");
+      else if (existing.state === "unknown") respond({ ...existing, socket }, "outcome-unknown", void 0, existing.error);
+      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.` } });
+      return;
+    }
+    if (entries.size >= 256) {
+      for (const [id, candidate] of entries) {
+        if (candidate.state === "done" || candidate.state === "error" || candidate.state === "unknown") {
+          entries.delete(id);
+          break;
+        }
+      }
+    }
+    const entry = {
+      requestId: request.requestId,
+      ownerId: request.ownerId,
+      command: request.command,
+      state: "queued",
+      dispatched: false,
+      finished: false,
+      slotHeld: false,
+      controller: new AbortController(),
+      fingerprint,
+      cwd: request.cwd,
+      socket,
+      startedAt: Date.now()
     };
-    if (details.outline?.root && typeof details.outline.lookId === "string") {
-      const epoch = 0;
-      resourceScheduler.restoreEpoch(resourceKey, epoch);
-      savedStates.set({
-        stateId: capture.stateId,
-        resourceKey,
-        epoch,
-        value: {
-          kind: "desktop",
-          target,
-          capture,
-          outline: details.outline,
-          look: {
-            lookId: details.outline.lookId,
-            capturedAt: details.capture.timestamp / 1e3,
-            window: {
-              windowId: Math.trunc(details.target.windowId),
-              framePoints: { x: 0, y: 0, w: details.capture.width, h: details.capture.height },
-              scaleFactor: details.capture.scaleFactor,
-              isModal: false,
-              role: "",
-              subrole: ""
-            },
-            image: { jpegBase64: "", width: details.capture.width, height: details.capture.height },
-            timings: {}
-          },
-          note: details.note
+    entries.set(key, entry);
+    owners.add(request.ownerId);
+    entry.timer = setTimeout(() => {
+      if (entry.state === "queued") {
+        entry.controller.abort();
+        finish(entry, "error", void 0, { code: "cancelled", message: "Request was cancelled while queued; it was not dispatched.", dispatched: false });
+        return;
+      }
+      if (entry.state === "running") {
+        if (!entry.dispatched) {
+          entry.controller.abort();
+          finish(entry, "error", void 0, { code: "cancelled", message: "Request was cancelled while waiting for the resource lane; it was not dispatched.", dispatched: false });
+          return;
         }
+        finish(entry, "unknown", void 0, { code: "outcome_unknown", message: "The broker did not observe completion within the request budget. The native action may have been dispatched; do not replay it. Observe the resource again to establish a successor state.", dispatched: true });
+      }
+    }, request.budgetMs);
+    const acquired = await acquireSlot(entry);
+    if (!acquired) {
+      if (entry.state === "queued") {
+        finish(entry, "error", void 0, { code: "broker_busy", message: "The broker queue is full; no action was dispatched. Retry later." });
+      }
+      return;
+    }
+    if (entry.controller.signal.aborted) {
+      finish(entry, "error", void 0, { code: "cancelled", message: "Request was cancelled before dispatch.", dispatched: false });
+      return;
+    }
+    entry.slotHeld = true;
+    await runEntry(entry, request);
+  };
+  const handleControl = async (request, socket) => {
+    if ((stopping || drainRequested) && request.command !== "stop") {
+      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; control requests other than 'stop' are unavailable. Retry after it exits." } });
+      return;
+    }
+    if (request.command === "status") {
+      send(socket, { type: "response", requestId: request.requestId, ok: true, state: "done", generation, helperGeneration: currentHelperGenerationSafe(), result: statusHandle?.status() });
+      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." } });
+        return;
+      }
+      const helper = bumpHelperGeneration();
+      liveHelperGeneration = helper;
+      expireStatesAfterHelperRestart();
+      const fake = options.restartTestHelper?.();
+      send(socket, { type: "response", requestId: request.requestId, ok: true, state: "done", generation, helperGeneration: helper, result: { helperGeneration: helper, fakeHelperGeneration: fake } });
+      return;
+    }
+    drainRequested = true;
+    lastActivity = Date.now();
+    send(socket, { type: "response", requestId: request.requestId, ok: true, state: "done", generation, helperGeneration: currentHelperGenerationSafe(), result: { stopping: true } });
+    setTimeout(() => {
+      void shutdown("stop");
+    }, 10);
+  };
+  const connections = /* @__PURE__ */ new Set();
+  const server = net3.createServer((socket) => {
+    lastActivity = Date.now();
+    connections.add(socket);
+    const decoder = new FrameDecoder();
+    let helloOk = false;
+    let helloRejected = false;
+    const drainingConnection = stopping || drainRequested;
+    if (drainingConnection) {
+      send(socket, {
+        type: "hello",
+        ok: false,
+        error: { code: "broker_draining", message: "The broker is shutting down and draining in-flight native work. No new request was accepted; retry after it exits." },
+        protocolVersion: BROKER_PROTOCOL_VERSION,
+        build: BROKER_BUILD,
+        generation,
+        pid: process.pid,
+        startedAt
       });
-      restoredResources.add(resourceKey);
     }
+    socket.on("error", () => {
+    });
+    socket.on("data", (chunk) => {
+      let frames;
+      try {
+        frames = decoder.push(chunk);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        send(socket, { type: "hello", ok: false, error: { code: "invalid_frame", message } });
+        socket.destroy();
+        return;
+      }
+      if (drainingConnection) {
+        for (const frame of frames) {
+          let request;
+          try {
+            request = validateRequest(frame);
+          } catch {
+            continue;
+          }
+          if (request.command === "stop") {
+            void handleControl(request, socket);
+            continue;
+          }
+          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 native work; this request was not accepted. Retry after it exits.", dispatched: false } });
+        }
+        return;
+      }
+      for (const frame of frames) {
+        if (!helloOk) {
+          if (helloRejected) {
+            try {
+              const request2 = validateRequest(frame);
+              if (request2.command === "stop") {
+                void handleControl(request2, socket);
+                continue;
+              }
+            } catch {
+            }
+            send(socket, {
+              type: "hello",
+              ok: false,
+              error: { code: "protocol_mismatch", message: "Only 'stop' is accepted before a compatible handshake." },
+              protocolVersion: BROKER_PROTOCOL_VERSION,
+              build: BROKER_BUILD,
+              generation,
+              pid: process.pid,
+              startedAt
+            });
+            continue;
+          }
+          try {
+            validateHello(frame);
+            helloOk = true;
+            send(socket, {
+              type: "hello",
+              ok: true,
+              protocolVersion: BROKER_PROTOCOL_VERSION,
+              build: BROKER_BUILD,
+              generation,
+              helperGeneration: currentHelperGenerationSafe(),
+              pid: process.pid,
+              startedAt,
+              platform: process.platform,
+              transport: endpoint.kind
+            });
+          } catch (error) {
+            helloRejected = true;
+            send(socket, {
+              type: "hello",
+              ok: false,
+              error: { code: error.code ?? "protocol_mismatch", message: error instanceof Error ? error.message : String(error) },
+              protocolVersion: BROKER_PROTOCOL_VERSION,
+              build: BROKER_BUILD,
+              generation,
+              pid: process.pid,
+              startedAt
+            });
+          }
+          continue;
+        }
+        let request;
+        try {
+          request = validateRequest(frame);
+        } catch (error) {
+          send(socket, {
+            type: "response",
+            requestId: typeof frame?.requestId === "string" ? frame.requestId : "invalid",
+            ok: false,
+            state: "error",
+            generation,
+            helperGeneration: currentHelperGenerationSafe(),
+            error: { code: error.code ?? "invalid_request", message: error instanceof Error ? error.message : String(error) }
+          });
+          continue;
+        }
+        void (request.command === "status" || request.command === "stop" || request.command === "debug_restart_helper" ? handleControl(request, socket) : handleEngineRequest(request, socket));
+      }
+    });
+    socket.on("close", () => {
+      connections.delete(socket);
+      for (const entry of entries.values()) {
+        if (entry.socket !== socket) continue;
+        entry.socket = void 0;
+        if (entry.state === "queued") {
+          entry.controller.abort();
+        }
+      }
+    });
+  });
+  const bootstrapLock = endpoint.kind === "unix-socket" ? acquireBootstrapLock(endpoint.directory) : () => {
+  };
+  try {
+    let drainWaitUntil = 0;
+    const waitForDrain = async () => {
+      if (drainWaitUntil === 0) drainWaitUntil = Date.now() + BROKER_DRAIN_MAX_MS + 1e4;
+      if (Date.now() >= drainWaitUntil) return false;
+      await sleep3(100);
+      return true;
+    };
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        await listen(server, endpoint);
+        break;
+      } catch (error) {
+        if (error.code !== "EADDRINUSE") throw error;
+        const probe = await probeBroker(endpoint);
+        if (probe.live) {
+          const reply = probe.live;
+          if (reply.ok === false && reply.error.code === "broker_draining") {
+            if (await waitForDrain()) continue;
+            throw new Error(`The computer-use broker at ${endpoint.path} is still draining in-flight work. Refusing to start a second execution authority; retry shortly.`);
+          }
+          const incompatible = reply.ok === false || reply.build?.identity !== BROKER_BUILD.identity || reply.protocolVersion !== BROKER_PROTOCOL_VERSION;
+          if (incompatible) {
+            const detail = reply.ok === false ? reply.error.message : `build ${reply.build?.identity ?? "unknown"}`;
+            throw new Error(`A different computer-use broker is already listening at ${endpoint.path} (${detail}). Run 'computer-use-axi stop' to restart it safely; refusing to start a second execution authority.`);
+          }
+          throw Object.assign(new Error(`Computer-use broker already running (pid ${reply.pid}, generation ${reply.generation}) at ${endpoint.path}.`), { code: "EXISTING_BROKER", generation: reply.generation });
+        }
+        if (probe.dead && canProveStaleEndpoint(endpoint)) {
+          const marker = loadDrainMarker();
+          if (marker && isAlive(marker.pid) && Date.now() < marker.deadlineAt + 1e4) {
+            if (await waitForDrain()) continue;
+          }
+          removeStaleSocket(endpoint);
+          continue;
+        }
+        if (attempt >= 4) throw error;
+        throw new Error(`Computer-use endpoint ${endpoint.path} is in use and its owner cannot be proven stale (${probe.error ?? "no response"}). Refusing to steal it.`);
+      }
+    }
+  } finally {
+    bootstrapLock();
   }
+  const shutdown = async (reason) => {
+    if (stopping) return;
+    stopping = true;
+    drainRequested = true;
+    if (idleTimer) clearInterval(idleTimer);
+    try {
+      saveDrainMarker({ pid: process.pid, startedAt: Date.now(), deadlineAt: Date.now() + BROKER_DRAIN_MAX_MS });
+    } catch {
+    }
+    for (const entry of entries.values()) {
+      if (entry.state === "queued") {
+        entry.controller.abort();
+        if (entry.timer) clearTimeout(entry.timer);
+        entry.socket = void 0;
+      }
+    }
+    const deadline = Date.now() + BROKER_DRAIN_MAX_MS;
+    while ([...entries.values()].some((entry) => entry.state === "running" || entry.state === "unknown") && Date.now() < deadline) {
+      await sleep3(50);
+    }
+    persistManifest();
+    try {
+      await Promise.race([shutdownComputerUseSession(), sleep3(1e4)]);
+    } catch {
+    }
+    artifacts.close();
+    try {
+      artifacts.cleanupGeneration(generation);
+    } catch {
+    }
+    await new Promise((resolve2) => {
+      let settled = false;
+      const done = () => {
+        if (!settled) {
+          settled = true;
+          resolve2();
+        }
+      };
+      server.close(done);
+      const timer = setTimeout(() => {
+        for (const socket of connections) socket.destroy();
+        done();
+      }, 1e3);
+      timer.unref?.();
+    });
+    try {
+      clearDrainMarker();
+    } catch {
+    }
+    if (endpoint.kind === "unix-socket") {
+      try {
+        const stats = lstatSync4(endpoint.path);
+        if (stats.isSocket()) unlinkSync4(endpoint.path);
+      } catch {
+      }
+    }
+    options.onShutdown?.();
+    void reason;
+  };
+  statusHandle = {
+    generation,
+    helperGeneration: helperGeneration2,
+    endpoint,
+    startedAt,
+    status() {
+      const uncertain = [...entries.values()].filter((entry) => entry.state === "unknown").length;
+      return {
+        pid: process.pid,
+        generation,
+        helperGeneration: currentHelperGenerationSafe(),
+        build: BROKER_BUILD,
+        protocolVersion: BROKER_PROTOCOL_VERSION,
+        startedAt,
+        uptimeMs: Date.now() - startedAt,
+        endpoint: { kind: endpoint.kind, path: endpoint.path },
+        transportAcl: endpoint.kind === "unix-socket" ? "unix socket 0600 inside a 0700 directory" : "windows named pipe with the Node process-default DACL (not explicitly SID-scoped; unverified on this host)",
+        active,
+        queued,
+        uncertain,
+        requests: entries.size,
+        ownerCount: owners.size,
+        ownerFingerprints: [...owners].map((owner) => createHash3("sha256").update(owner).digest("hex").slice(0, 12)),
+        artifacts: artifacts.stats(),
+        legacyCache,
+        idleExitMs
+      };
+    },
+    async close() {
+      await shutdown("close");
+    }
+  };
+  idleTimer = setInterval(() => {
+    if (stopping) return;
+    const uncertain = [...entries.values()].some((entry) => entry.state === "running" || entry.state === "unknown" || entry.state === "queued");
+    if (uncertain) return;
+    if (Date.now() - lastActivity < idleExitMs) return;
+    void shutdown("idle");
+  }, Math.min(6e4, Math.max(1e3, Math.floor(idleExitMs / 4))));
+  idleTimer.unref?.();
+  return statusHandle;
 }
 
-// builtin/extensions/computer-use/index.ts
-var stateId = Type.String({ description: "Required state id owning every @e ref used by this operation" });
-var point = { x: Type.Number(), y: Type.Number() };
-var mouseButton2 = Type.Optional(Type.Union([Type.Literal("left"), Type.Literal("right"), Type.Literal("middle")]));
-var clickByRef = Type.Object({ action: Type.Literal("click"), ref: Type.String(), button: mouseButton2, clickCount: Type.Optional(Type.Number({ minimum: 1, maximum: 3 })) });
-var clickByPoint = Type.Object({ action: Type.Literal("click"), ...point, button: mouseButton2, clickCount: Type.Optional(Type.Number({ minimum: 1, maximum: 3 })) });
-var uiAction = Type.Union([
-  Type.Object({ action: Type.Literal("press"), ref: Type.String({ description: "Actionable outline ref" }) }),
-  clickByRef,
-  clickByPoint,
-  Type.Object({ action: Type.Literal("setText"), ref: Type.String({ description: "Editable outline ref" }), text: Type.String() }),
-  Type.Object({ action: Type.Literal("typeText"), ref: Type.Optional(Type.String({ description: "Omit after a click to type into the focus established by that click" })), text: Type.String() }),
-  Type.Object({ action: Type.Literal("keypress"), ref: Type.Optional(Type.String({ description: "Omit to send keys to the focused control" })), keys: Type.Array(Type.String(), { minItems: 1 }) }),
-  Type.Object({ action: Type.Literal("scroll"), ref: Type.Optional(Type.String()), scrollX: Type.Optional(Type.Number()), scrollY: Type.Optional(Type.Number()) }),
-  Type.Object({ action: Type.Literal("drag"), path: Type.Array(Type.Object(point), { minItems: 2 }) }),
-  Type.Object({ action: Type.Literal("moveMouse"), ...point })
-]);
-var conditionProperties = {
-  ref: Type.Optional(Type.String({ description: "Specific @e ref to test", maxLength: 128 })),
-  scopeRef: Type.Optional(Type.String({ description: "Restrict matching to this @e subtree", maxLength: 128 })),
-  text: Type.Optional(Type.String({ description: "Text that must match", maxLength: 512 })),
-  role: Type.Optional(Type.String({ description: "Exact normalized role", maxLength: 128 })),
-  value: Type.Optional(Type.String({ description: "Exact normalized value; normally pair with ref" })),
-  until: Type.Optional(Type.Union([Type.Literal("present"), Type.Literal("absent")], { description: "Desired condition, default present" })),
-  timeoutMs: Type.Optional(Type.Number({ description: "Maximum wait, default 10000ms", minimum: 100, maximum: 6e4 }))
-};
-var OBSERVE_RISK = {
-  riskClass: "read_only",
-  concurrencySafe: false,
-  permissionScope: "host",
-  readsHostResource: true,
-  allowedForSubagentByDefault: false
-};
-var BROWSER_RISK = {
-  riskClass: "external_side_effect",
-  concurrencySafe: false,
-  requiresPermission: true,
-  permissionScope: "host",
-  externalSideEffect: true,
-  allowedForSubagentByDefault: false
-};
-var ACT_RISK = {
-  riskClass: "external_side_effect",
-  concurrencySafe: false,
-  requiresPermission: true,
-  permissionScope: "host",
-  writesHostResource: true,
-  externalSideEffect: true,
-  highRisk: true,
-  allowedForSubagentByDefault: false
-};
-function describe(description, ...extra) {
-  const lines = [description];
-  for (const part of extra) {
-    if (!part) continue;
-    for (const line of Array.isArray(part) ? part : [part]) lines.push(line);
-  }
-  return lines.join(" ");
-}
-var findTool = {
-  name: "find_roots",
-  label: "Find Roots",
-  risk: OBSERVE_RISK,
-  description: describe(
-    "Find a bounded, ranked set of controllable UI roots with refs, geometry, and focus state.",
-    "Find a target root before observe_ui when needed. Desktop control is a last resort - prefer API/CLI/web tools when they suffice."
-  ),
-  parameters: Type.Object({
-    text: Type.Optional(Type.String({ description: "Ranked app or title text", maxLength: 256 })),
-    app: Type.Optional(Type.String({ description: "Exact normalized app name", maxLength: 256 })),
-    bundleId: Type.Optional(Type.String({ description: "Exact bundle id" })),
-    pid: Type.Optional(Type.Number({ description: "Exact process id" })),
-    kind: Type.Optional(Type.Union([Type.Literal("window"), Type.Literal("menu"), Type.Literal("sheet"), Type.Literal("popover"), Type.Literal("dialog"), Type.Literal("browser_page")], { description: "Exact root kind" }))
-  }),
-  executor: executeFind
-};
-var observeTool = {
-  name: "observe_ui",
-  label: "Observe UI",
-  risk: OBSERVE_RISK,
-  description: describe(
-    "Capture the current/frontmost root or one exact @r root and return a bounded UI outline.",
-    "Primary UI observation tool. Follow with search_ui, expand_ui, inspect_ui, or act_ui.",
-    [
-      "Use mode=semantic to skip OCR and images, visual to force them, and fused for automatic selection.",
-      "Use @e outline refs from observe_ui/search_ui for act_ui; pictureOnly refs are coordinate-only and blocked by UI-tree-only policy."
-    ]
-  ),
-  parameters: Type.Object({
-    root: Type.Optional(Type.String({ description: "Exact @r ref issued by find_roots" })),
-    mode: Type.Optional(Type.Union([Type.Literal("semantic"), Type.Literal("visual"), Type.Literal("fused")], { description: "Observation mode, default fused" }))
-  }),
-  executor: executeObserve
-};
-var searchUiTool = {
-  name: "search_ui",
-  label: "Search UI",
-  risk: OBSERVE_RISK,
-  description: describe(
-    "Return a bounded, deterministically ranked search of the cached outline. At least one predicate is required.",
-    "Find targets not shown in the compact observe_ui output; refine broad searches instead of paging matches."
-  ),
-  parameters: Type.Object({
-    text: Type.Optional(Type.String({ description: "Human-readable text or label", maxLength: 256 })),
-    role: Type.Optional(Type.String({ description: "Exact normalized role, e.g. button", maxLength: 128 })),
-    capability: Type.Optional(Type.String({ description: "Exact capability, e.g. press", maxLength: 128 })),
-    stateId
-  }),
-  executor: executeSearchUi
-};
-var expandUiTool = {
-  name: "expand_ui",
-  label: "Expand UI",
-  risk: OBSERVE_RISK,
-  description: describe(
-    "Unfold bounded local outline context for one @e ref.",
-    "Expand a specific ref instead of dumping unrelated UI."
-  ),
-  parameters: Type.Object({ ref: Type.String(), depth: Type.Optional(Type.Number({ minimum: 1, maximum: 8, description: "Subtree depth, default 3" })), stateId }),
-  executor: executeExpandUi
-};
-var inspectUiTool = {
-  name: "inspect_ui",
-  label: "Inspect UI",
-  risk: OBSERVE_RISK,
-  description: describe(
-    "Inspect one exact outline ref with fields, geometry, capabilities, and annotations.",
-    "Use when a target's evidence or provenance matters."
-  ),
-  parameters: Type.Object({ ref: Type.String(), stateId }),
-  executor: executeInspectUi
-};
-var actTool = {
-  name: "act_ui",
-  label: "Act",
-  risk: ACT_RISK,
-  description: describe(
-    "Perform one or more precisely targeted checked actions and return the successor state.",
-    "Pass dependent click/type steps together and use expect for observable completion.",
-    ["After clicking an editable region, omit ref from typeText/keypress so input follows the established focus."]
-  ),
-  parameters: Type.Object({ stateId, expect: Type.Optional(Type.Object(conditionProperties)), actions: Type.Array(uiAction, { minItems: 1, maxItems: 20 }) }),
-  executor: executeAct
-};
-var readTextTool = {
-  name: "read_text",
-  label: "Read Text",
-  risk: OBSERVE_RISK,
-  description: describe(
-    "Read a fixed-size page from an @e UI ref or immutable @o truncated-output ref.",
-    "Use @e with its stateId; @o continuation refs don't need stateId."
-  ),
-  parameters: Type.Object({ ref: Type.String(), offset: Type.Optional(Type.Number({ minimum: 0 })), stateId: Type.Optional(stateId) }),
-  executor: executeReadText
-};
-var waitForTool = {
-  name: "wait_for",
-  label: "Wait For",
-  risk: OBSERVE_RISK,
-  description: describe(
-    "Wait for one scoped UI condition and return the successor state.",
-    "Use after asynchronous UI changes instead of polling observe_ui."
-  ),
-  parameters: Type.Object({ ...conditionProperties, stateId }),
-  executor: executeWaitFor
-};
-var launchBrowserTool = {
-  name: "launch_browser",
-  label: "Launch Browser Context",
-  risk: BROWSER_RISK,
-  description: describe(
-    "Launch the configured Pie-managed CDP browser and return an observed browser-page state.",
-    "Use for browser work that needs a managed CDP context.",
-    ["Prefer curl through bash when the page is directly fetchable."]
-  ),
-  parameters: Type.Object({ url: Type.Optional(Type.String({ maxLength: 8192 })) }),
-  executor: executeLaunchBrowser
-};
-var navigateBrowserTool = {
-  name: "navigate_browser",
-  label: "Navigate Browser",
-  risk: BROWSER_RISK,
-  description: describe(
-    "Navigate an observed CDP browser-page state to an HTTP(S) URL.",
-    "Native browser windows use act_ui; this tool is CDP-only."
-  ),
-  parameters: Type.Object({ url: Type.String({ maxLength: 8192 }), stateId }),
-  executor: executeNavigateBrowser
-};
-var evaluateBrowserTool = {
-  name: "evaluate_browser",
-  label: "Evaluate Browser",
-  risk: BROWSER_RISK,
-  description: describe(
-    "Evaluate targeted JavaScript in a CDP browser-page state; returned output is strictly bounded.",
-    "Prefer observe/search/read; return selected fields, aggregates, or bounded slices."
-  ),
-  parameters: Type.Object({ stateId, expression: Type.String({ maxLength: 65536 }) }),
-  executor: executeEvaluateBrowser
-};
-var OBSERVE_TOOLS = [findTool, observeTool, searchUiTool, expandUiTool, inspectUiTool, readTextTool, waitForTool, launchBrowserTool, navigateBrowserTool, evaluateBrowserTool];
-var ACT_TOOLS = [actTool];
-function summarizeActArgs(args) {
-  const actions = args?.actions;
-  if (!Array.isArray(actions) || actions.length === 0) return "(no actions)";
-  const names = actions.map((action) => action?.action ?? "unknown");
-  const unique = [...new Set(names)];
-  return `${actions.length} action(s): ${unique.join(", ")}`;
-}
-async function confirmAct(ctx, args) {
-  if (ctx.yoloMode) return true;
-  if (!ctx.interactions.isAvailable()) return false;
-  const response = await ctx.interactions.request({
-    type: "confirm",
-    id: `computer-use:${Date.now()}`,
-    prompt: "Allow computer-use to act on your desktop (click/type/scroll/press)?",
-    detail: [
-      "Class: computer_use_act",
-      `Tool: act_ui \u2014 ${summarizeActArgs(args)}`,
-      "",
-      "The agent will synthesize real input events on your machine."
-    ].join("\n"),
-    timeoutMs: 12e4
-  }).catch(() => void 0);
-  return !!response && response.type === "confirm" && response.confirmed === true;
-}
-function blockedActResult() {
-  return {
-    content: [{
-      type: "text",
-      text: "act_ui was blocked: the user did not confirm desktop control (or no interaction handler is available). Do not retry act_ui; explain what you intended to do and ask the user how to proceed."
-    }],
-    isError: true
-  };
+// vendor/computer-use-axi/src/test-backend-guard.ts
+function resolveTestOnlyBackend(env = process.env) {
+  if (env.PIE_COMPUTER_USE_FAKE_BACKEND !== "1") return { enabled: false };
+  if (env.PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS !== "1") {
+    return {
+      enabled: false,
+      warning: "PIE_COMPUTER_USE_FAKE_BACKEND is test-only and was ignored: it requires PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS=1 as well."
+    };
+  }
+  return { enabled: true };
 }
-function registerPieTool(ctx, spec, options = {}) {
-  ctx.registerTool({
-    name: spec.name,
-    label: spec.label,
-    description: spec.description,
-    parameters: spec.parameters,
-    risk: spec.risk,
-    execute: async (args, toolContext) => {
-      if (options.confirmAct) {
-        const approved = await options.confirmAct(args);
-        if (!approved) return blockedActResult();
-      }
-      const result = await spec.executor(toolContext.toolCallId, args, toolContext.signal, void 0, ctx);
-      return result;
+
+// vendor/computer-use-axi/src/broker-main.ts
+async function loadTestOnlyBackend() {
+  const decision = resolveTestOnlyBackend();
+  if (decision.warning) process.stderr.write(`computer-use-axi broker: ${decision.warning}
+`);
+  if (!decision.enabled) return void 0;
+  const fakeBackendModule = "./platform/fake-backend.ts";
+  try {
+    const { createFakePlatformBackend } = await import(fakeBackendModule);
+    const fake = createFakePlatformBackend();
+    setPlatformBackend(fake);
+    return fake;
+  } catch (error) {
+    process.stderr.write(
+      `computer-use-axi broker: the test-only fake backend is not available in this build (${error instanceof Error ? error.message : String(error)}); continuing with the real platform backend.
+`
+    );
+    return void 0;
+  }
+}
+async function main() {
+  const fake = await loadTestOnlyBackend();
+  const handle = await startBroker({
+    testCommands: process.env.PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS === "1",
+    restartTestHelper: fake ? () => fake.fakeControl.restart() : void 0,
+    onShutdown: () => {
+      setTimeout(() => process.exit(0), 50).unref();
     }
   });
-}
-function formatConfigStatus() {
-  const loaded = getLoadedComputerUseConfig();
-  return [
-    "computer-use configuration",
-    `browser_use: ${loaded.config.browser_use ? "enabled" : "disabled"}`,
-    `managed_browser: ${loaded.config.managed_browser}`,
-    `headless: ${loaded.config.headless ? "enabled" : "disabled"}`,
-    `cursor_overlay: ${loaded.config.cursor_overlay ? "enabled" : "disabled"}`,
-    "",
-    "Sources:",
-    ...loaded.sources.map((source) => `- ${source.path}: ${source.error ? `error: ${source.error}` : source.exists ? "loaded" : "not found"}`),
-    `- env overrides: ${Object.keys(loaded.env).join(", ") || "none"}`
-  ].join("\n");
-}
-async function initializeSessionState(ctx) {
-  loadComputerUseConfig(ctx.cwd);
-  reconstructStateFromBranch(ctx);
-}
-function computerUseExtension(ctx) {
-  ctx.registerCleanup?.(() => shutdownComputerUseSession());
-  let actApproved = false;
-  const confirmActOnce = async (args) => {
-    if (actApproved) return true;
-    const approved = await confirmAct(ctx, args);
-    if (approved) actApproved = true;
-    return approved;
+  const stop = () => {
+    void handle.close().catch(() => void 0);
   };
-  for (const spec of OBSERVE_TOOLS) registerPieTool(ctx, spec);
-  for (const spec of ACT_TOOLS) registerPieTool(ctx, spec, {
-    confirmAct: async (args) => await confirmActOnce(args)
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  process.on("SIGHUP", stop);
+  process.on("uncaughtException", (error) => {
+    process.stderr.write(`computer-use-axi broker fatal: ${error instanceof Error ? error.stack ?? error.message : String(error)}
+`);
+    process.exit(1);
   });
-  ctx.registerCommand({
-    name: "computer-use",
-    description: "Show computer-use configuration",
-    handler: (commandCtx) => {
-      loadComputerUseConfig(commandCtx.cwd);
-      commandCtx.ui.notify(formatConfigStatus(), "info");
-    }
-  });
-  ctx.on("session:changed", async () => {
-    actApproved = false;
-    await shutdownComputerUseSession().catch(() => void 0);
-    await initializeSessionState(ctx);
+  process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`computer-use-axi broker unhandled rejection: ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}
+`);
   });
 }
-export {
-  computerUseExtension as default
-};
+main().catch((error) => {
+  const code = error.code;
+  process.stderr.write(`computer-use-axi broker: ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(code === "EXISTING_BROKER" ? 0 : 1);
+});