@cydm/pie 2.7.3 → 2.7.5

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

@@ -48,6 +48,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// vendor/computer-use-axi/src/test-backend-guard.ts
+function requireFakeBackend(env = process.env) {
+  return env.PIE_COMPUTER_USE_REQUIRE_FAKE_BACKEND === "1";
+}
+function assertNativeBackendAllowed() {
+  if (requireFakeBackend()) throw new Error("Required fake backend: native desktop access is forbidden (backend not installed in this module instance).");
+}
+function resolveTestOnlyBackend(env = process.env) {
+  if (requireFakeBackend(env) && (env.PIE_COMPUTER_USE_FAKE_BACKEND !== "1" || env.PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS !== "1")) {
+    throw new Error("Required fake backend needs PIE_COMPUTER_USE_FAKE_BACKEND=1 and PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS=1.");
+  }
+  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 };
+}
+var init_test_backend_guard = __esm({
+  "vendor/computer-use-axi/src/test-backend-guard.ts"() {
+  }
+});
+
 // vendor/computer-use-axi/src/platform/coerce.ts
 function toBoolean(value) {
   return value === true || value === "true" || value === 1;
@@ -2307,7 +2332,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net4 = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash4 } = __require("crypto");
+    var { randomBytes, createHash: createHash5 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2988,7 +3013,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3357,7 +3382,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash4 } = __require("crypto");
+    var { createHash: createHash5 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3664,7 +3689,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -3852,6 +3877,7 @@ async function isResolvedHelperExecutable(filePath) {
   return actualPath === expectedPath;
 }
 async function runProcess(command, args, timeoutMs, signal, env) {
+  assertNativeBackendAllowed();
   throwIfAborted(signal);
   await new Promise((resolve2, reject) => {
     const child = spawn(command, args, {
@@ -3900,6 +3926,7 @@ ${output}`.trim()));
 var COMMAND_TIMEOUT_MS2, HELPER_PROTOCOL_VERSION, HELPER_SETUP_TIMEOUT_MS, HELPER_APP_PATH, HELPER_APP_EXECUTABLE_PATH, DEFAULT_HELPER_SOCKET_PATH, HELPER_SOCKET_PATH, usingExternalHelperSocket, PACKAGE_ROOT, SETUP_HELPER_SCRIPT, HelperTransportError, HelperCommandError, MacosHelperClient, macosHelper;
 var init_helper = __esm({
   "vendor/computer-use-axi/src/platform/macos/helper.ts"() {
+    init_test_backend_guard();
     init_coerce();
     init_helper_path();
     init_package_root();
@@ -3935,6 +3962,7 @@ var init_helper = __esm({
         return this.diagnosticsCache;
       }
       async ensureInstalled(signal) {
+        assertNativeBackendAllowed();
         if (usingExternalHelperSocket) return;
         if (await isExecutable(HELPER_APP_EXECUTABLE_PATH)) {
           return;
@@ -3949,11 +3977,13 @@ var init_helper = __esm({
         }
       }
       async launchDaemon(signal) {
+        assertNativeBackendAllowed();
         if (usingExternalHelperSocket) throw new HelperTransportError(`External helper socket is unavailable at ${HELPER_SOCKET_PATH}.`);
         await mkdir(path9.dirname(HELPER_SOCKET_PATH), { recursive: true });
         await runProcess("open", ["-n", "-g", HELPER_APP_PATH, "--args", "serve", "--socket", HELPER_SOCKET_PATH], COMMAND_TIMEOUT_MS2, signal);
       }
       async daemonCommand(cmd, args, timeoutMs, signal) {
+        assertNativeBackendAllowed();
         return await new Promise((resolve2, reject) => {
           const id = `req_${++this.requestSequence}`;
           const socket = net.createConnection(HELPER_SOCKET_PATH);
@@ -3996,6 +4026,7 @@ var init_helper = __esm({
         });
       }
       async ensureDaemon(signal) {
+        assertNativeBackendAllowed();
         if (this.daemonAvailable) return true;
         try {
           await this.daemonCommand("diagnostics", {}, 1e3, signal);
@@ -4028,6 +4059,7 @@ var init_helper = __esm({
         }
       }
       async restart(signal) {
+        assertNativeBackendAllowed();
         await this.command("shutdown", {}, { signal, timeoutMs: 2e3 }).catch(() => void 0);
         this.daemonAvailable = false;
         await sleep(400, signal);
@@ -4310,23 +4342,25 @@ var init_permissions2 = __esm({
 });
 
 // vendor/computer-use-axi/src/broker-server.ts
-import { createHash as createHash3, randomUUID as randomUUID8 } from "node:crypto";
+init_test_backend_guard();
+import { createHash as createHash4, 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";
+import { closeSync, existsSync as existsSync3, lstatSync as lstatSync3, mkdirSync as mkdirSync4, openSync, readdirSync as readdirSync2, rmdirSync as rmdirSync2, unlinkSync as unlinkSync2, writeSync } from "node:fs";
+import path4 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";
+import path3 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";
+// vendor/computer-use-axi/src/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { AsyncLocalStorage } from "node:async_hooks";
 import path from "node:path";
 
 // src/config.ts
@@ -4370,26 +4404,151 @@ function getConfigDir() {
   return join(homedir(), CONFIG_DIR_NAME);
 }
 
+// vendor/computer-use-axi/host.ts
+function getAgentDir() {
+  return getConfigDir();
+}
+
+// vendor/computer-use-axi/src/config.ts
+var DEFAULT_CONFIG = {
+  browser_use: true,
+  headless: false,
+  cursor_overlay: true,
+  managed_browser: "chrome"
+};
+var REQUEST_ENV_KEYS = ["PIE_COMPUTER_USE_BROWSER_USE", "PIE_COMPUTER_USE_HEADLESS", "PIE_COMPUTER_USE_CURSOR_OVERLAY", "PIE_COMPUTER_USE_MANAGED_BROWSER", "PIE_COMPUTER_USE_HELIUM_EXECUTABLE", "PIE_COMPUTER_USE_CHROME_EXECUTABLE", "PIE_COMPUTER_USE_CDP_PORT", "PIE_COMPUTER_USE_DELIVERY_POLICY", "PIE_COMPUTER_USE_EVENT_DELIVERY"];
+function captureComputerUseEnvironment(env = process.env) {
+  const out = {};
+  for (const key of REQUEST_ENV_KEYS) {
+    const value = env[key]?.trim();
+    if (!value) continue;
+    if (Buffer.byteLength(value) > 4096 || value.includes("\0")) throw new Error(`Invalid ${key}`);
+    if (["PIE_COMPUTER_USE_BROWSER_USE", "PIE_COMPUTER_USE_HEADLESS", "PIE_COMPUTER_USE_CURSOR_OVERLAY"].includes(key)) {
+      const parsed = parseBoolean(value);
+      if (parsed === void 0) throw new Error(`Invalid ${key}`);
+      out[key] = String(parsed);
+    } else if (key === "PIE_COMPUTER_USE_MANAGED_BROWSER") {
+      if (value !== "helium" && value !== "chrome") throw new Error(`Invalid ${key}`);
+      out[key] = value;
+    } else if (key === "PIE_COMPUTER_USE_DELIVERY_POLICY" || key === "PIE_COMPUTER_USE_EVENT_DELIVERY") {
+      const policy = value.toLowerCase();
+      if (!["default", "background", "pid", "foreground", "hid", "ax_only", "ax-only"].includes(policy)) throw new Error(`Invalid ${key}`);
+      out[key] = policy;
+    } else if (key === "PIE_COMPUTER_USE_CDP_PORT") {
+      if (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > 65535) throw new Error(`Invalid ${key}`);
+      out[key] = String(Number(value));
+    } else {
+      if (!path.isAbsolute(value)) throw new Error(`Invalid ${key}: expected absolute path`);
+      out[key] = value;
+    }
+  }
+  return Object.freeze(out);
+}
+var managedCdpPort;
+function setManagedCdpPort(port) {
+  managedCdpPort = port;
+}
+function getComputerUseEnvironmentValue(key) {
+  return operationConfig.getStore()?.environment[key] ?? (key === "PIE_COMPUTER_USE_CDP_PORT" ? managedCdpPort : void 0);
+}
+var operationConfig = new AsyncLocalStorage();
+var defaultLoaded = Object.freeze({ config: Object.freeze({ ...DEFAULT_CONFIG }), sources: [], env: {}, environment: {} });
+function withComputerUseConfig(cwd, run, environment) {
+  return operationConfig.run(loadComputerUseConfig(cwd, environment), run);
+}
+function parseBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value === 1 ? true : value === 0 ? false : void 0;
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on", "enabled"].includes(normalized)) return true;
+  if (["0", "false", "no", "off", "disabled"].includes(normalized)) return false;
+  return void 0;
+}
+function normalizePartial(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw.computer_use && typeof raw.computer_use === "object" ? raw.computer_use : raw;
+  const out = {};
+  const browserUse = parseBoolean(source.browser_use);
+  const headless = parseBoolean(source.headless);
+  const cursorOverlay = parseBoolean(source.cursor_overlay);
+  if (browserUse !== void 0) out.browser_use = browserUse;
+  if (headless !== void 0) out.headless = headless;
+  if (cursorOverlay !== void 0) out.cursor_overlay = cursorOverlay;
+  const managedBrowser = source.managed_browser;
+  if (managedBrowser === "helium" || managedBrowser === "chrome") out.managed_browser = managedBrowser;
+  return out;
+}
+function readConfigFile(filePath) {
+  if (!existsSync2(filePath)) return { path: filePath, exists: false };
+  try {
+    const parsed = JSON.parse(readFileSync2(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) };
+  }
+}
+function readEnv(environment) {
+  const out = {};
+  const browserUse = parseBoolean(environment.PIE_COMPUTER_USE_BROWSER_USE);
+  const headless = parseBoolean(environment.PIE_COMPUTER_USE_HEADLESS);
+  const cursorOverlay = parseBoolean(environment.PIE_COMPUTER_USE_CURSOR_OVERLAY);
+  if (browserUse !== void 0) out.browser_use = browserUse;
+  if (headless !== void 0) out.headless = headless;
+  if (cursorOverlay !== void 0) out.cursor_overlay = cursorOverlay;
+  const managedBrowser = environment.PIE_COMPUTER_USE_MANAGED_BROWSER;
+  if (managedBrowser === "helium" || managedBrowser === "chrome") out.managed_browser = managedBrowser;
+  return out;
+}
+function loadComputerUseConfig(cwd, environment = captureComputerUseEnvironment()) {
+  const sources = [
+    readConfigFile(path.join(getAgentDir(), "extensions", "computer-use.json")),
+    readConfigFile(path.join(cwd, ".pie", "computer-use.json"))
+  ];
+  environment = captureComputerUseEnvironment(environment);
+  const env = readEnv(environment);
+  const config = { ...DEFAULT_CONFIG };
+  for (const source of sources) {
+    if (source.values) Object.assign(config, source.values);
+  }
+  Object.assign(config, env);
+  return Object.freeze({ config: Object.freeze(config), sources, env, environment });
+}
+function getComputerUseConfig() {
+  return getLoadedComputerUseConfig().config;
+}
+function getLoadedComputerUseConfig() {
+  return operationConfig.getStore() ?? defaultLoaded;
+}
+function isHeadlessMode() {
+  return getComputerUseConfig().headless;
+}
+function isBrowserUseEnabled() {
+  return getComputerUseConfig().browser_use;
+}
+
 // vendor/computer-use-axi/src/persist.ts
+import { lstatSync, mkdirSync as mkdirSync2, opendirSync, readdirSync, readFileSync as readFileSync3, renameSync as renameSync2, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
+import path2 from "node:path";
 function stateRootDir(env = process.env) {
   const override = env.PIE_COMPUTER_USE_STATE_DIR?.trim();
   if (override) return override;
-  return path.join(getConfigDir(), "computer-use");
+  return path2.join(getConfigDir(), "computer-use");
 }
 function statesDir(env = process.env) {
-  return path.join(stateRootDir(env), "states");
+  return path2.join(stateRootDir(env), "states");
 }
 function outputsDir(env = process.env) {
-  return path.join(stateRootDir(env), "outputs");
+  return path2.join(stateRootDir(env), "outputs");
 }
 function runtimeStatePath(env = process.env) {
-  return path.join(stateRootDir(env), "runtime.json");
+  return path2.join(stateRootDir(env), "runtime.json");
 }
 function brokerStateDir(env = process.env) {
-  return path.join(stateRootDir(env), "broker");
+  return path2.join(stateRootDir(env), "broker");
 }
 function brokerManifestPath(env = process.env) {
-  return path.join(brokerStateDir(env), "manifest.json");
+  return path2.join(brokerStateDir(env), "manifest.json");
 }
 function loadBrokerManifest(env = process.env) {
   const manifest = readJsonFile(brokerManifestPath(env));
@@ -4406,7 +4565,7 @@ function saveBrokerManifest(manifest, env = process.env) {
   writeJsonAtomic(brokerManifestPath(env), { ...manifest, stateIds: manifest.stateIds.slice(0, 256) });
 }
 function brokerDrainMarkerPath(env = process.env) {
-  return path.join(brokerStateDir(env), "draining.json");
+  return path2.join(brokerStateDir(env), "draining.json");
 }
 function loadDrainMarker(env = process.env) {
   const marker = readJsonFile(brokerDrainMarkerPath(env));
@@ -4445,7 +4604,7 @@ function cleanupLegacyBrokerCache(env = process.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);
+      const target = path2.join(statesDirPath, name);
       try {
         const stats = lstatSync(target);
         if (!stats.isFile() || stats.isSymbolicLink()) continue;
@@ -4460,7 +4619,7 @@ function cleanupLegacyBrokerCache(env = process.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);
+      const target = path2.join(oldOutputs, name);
       try {
         const stats = lstatSync(target);
         if (!stats.isFile() || stats.isSymbolicLink()) continue;
@@ -4471,17 +4630,54 @@ function cleanupLegacyBrokerCache(env = process.env) {
     }
   } catch {
   }
+  outputs2 += cleanupOrphanOwnerOutputs(path2.join(oldOutputs, "owners"));
   return { runtimeFile, states, outputs: outputs2 };
 }
+function cleanupOrphanOwnerOutputs(root) {
+  try {
+    const stat = lstatSync(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("Unsafe computer-use outputs directory");
+  } catch (error) {
+    if (error.code === "ENOENT") return 0;
+    throw error;
+  }
+  let remaining = 65536;
+  let removed = 0;
+  const visit = (directory, depth) => {
+    const handle = opendirSync(directory);
+    try {
+      for (let entry = handle.readSync(); entry; entry = handle.readSync()) {
+        if (--remaining < 0) throw new Error("Computer-use stale output cleanup budget exceeded; refusing unaccounted output storage");
+        const target = path2.join(directory, entry.name);
+        const stat = lstatSync(target);
+        if (stat.isSymbolicLink()) {
+          unlinkSync(target);
+          continue;
+        }
+        if (stat.isDirectory() && depth === 0) {
+          visit(target, 1);
+          rmdirSync(target);
+        } else if (stat.isFile() && depth === 1 && /^\d+\.txt$/.test(entry.name)) {
+          unlinkSync(target);
+          removed++;
+        } else throw new Error(`Unexpected computer-use output entry: ${target}`);
+      }
+    } finally {
+      handle.closeSync();
+    }
+  };
+  visit(root, 0);
+  return removed;
+}
 function writeJsonAtomic(filePath, value) {
-  mkdirSync2(path.dirname(filePath), { recursive: true });
+  mkdirSync2(path2.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"));
+    return JSON.parse(readFileSync3(filePath, "utf8"));
   } catch {
     return void 0;
   }
@@ -4498,8 +4694,8 @@ function normalizeComputerUseOwner(value) {
 }
 
 // vendor/computer-use-axi/src/broker-protocol.ts
-var BROKER_PROTOCOL_VERSION = 1;
-var BROKER_ENGINE_VERSION = 2;
+var BROKER_PROTOCOL_VERSION = 3;
+var BROKER_ENGINE_VERSION = 4;
 var BROKER_PACKAGE_VERSION = "0.5.1-pie.1";
 var BROKER_RESULT_CACHE_MAX_ENTRIES = 256;
 var BROKER_REPLAY_LEDGER_MAX_IDS = 65536;
@@ -4825,7 +5021,19 @@ function validateRequest(value) {
   }
   const params = validateCommandParams(command, value.params);
   const cwd = value.cwd === void 0 ? process.cwd() : boundedString(value.cwd, "cwd", 4096);
-  if (!path2.isAbsolute(cwd)) throw new BrokerProtocolError("invalid_request", "cwd must be absolute.");
+  if (!path3.isAbsolute(cwd)) throw new BrokerProtocolError("invalid_request", "cwd must be absolute.");
+  const rawEnvironment = value.environment ?? {};
+  assertPlainRecord(rawEnvironment, "environment");
+  assertKeys(rawEnvironment, "environment", REQUEST_ENV_KEYS);
+  for (const entry of Object.values(rawEnvironment)) {
+    if (typeof entry !== "string") throw new BrokerProtocolError("invalid_request", "environment values must be strings.");
+  }
+  let environment;
+  try {
+    environment = captureComputerUseEnvironment(rawEnvironment);
+  } catch (error) {
+    throw new BrokerProtocolError("invalid_request", String(error));
+  }
   const budgetMs = value.budgetMs === void 0 ? BROKER_DEFAULT_REQUEST_BUDGET_MS : Math.trunc(boundedNumber(value.budgetMs, "budgetMs", BROKER_MIN_REQUEST_BUDGET_MS, BROKER_MAX_REQUEST_BUDGET_MS));
   return {
     requestId: value.requestId,
@@ -4835,6 +5043,7 @@ function validateRequest(value) {
     command,
     params,
     cwd,
+    environment,
     budgetMs
   };
 }
@@ -4844,8 +5053,10 @@ function validateHello(value) {
   if (value.protocolVersion !== BROKER_PROTOCOL_VERSION) {
     throw new BrokerProtocolError("protocol_mismatch", `Protocol mismatch: broker ${BROKER_PROTOCOL_VERSION}, client ${String(value.protocolVersion)}.`);
   }
+  if (value.buildIdentity !== BROKER_BUILD.identity) throw new BrokerProtocolError("build_mismatch", "Broker engine build identity differs.");
   return {
     type: "hello",
+    buildIdentity: value.buildIdentity,
     protocolVersion: value.protocolVersion,
     clientVersion: value.clientVersion === void 0 ? void 0 : boundedString(value.clientVersion, "clientVersion", 128)
   };
@@ -4874,6 +5085,7 @@ var FrameDecoder = class {
     for (; ; ) {
       const newline = this.buffer.indexOf(10);
       if (newline < 0) break;
+      if (newline > this.maxBytes) throw new BrokerProtocolError("frame_too_large", `Frame exceeds the ${this.maxBytes}-byte limit.`);
       const line = this.buffer.subarray(0, newline).toString("utf8").trim();
       this.buffer = this.buffer.subarray(newline + 1);
       if (!line) continue;
@@ -4898,11 +5110,11 @@ function resolveBrokerEndpoint(env = process.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");
+  const socketPath = socketOverride || path3.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) };
+  return { kind: "unix-socket", path: socketPath, directory: path3.dirname(socketPath) };
 }
 function ensurePrivateDirectory(directory) {
   mkdirSync3(directory, { recursive: true, mode: 448 });
@@ -4921,8 +5133,8 @@ function canonicalize(value) {
   }
   return value;
 }
-function requestFingerprint(command, params, cwd) {
-  const seed = JSON.stringify({ command, params: canonicalize(params), cwd });
+function requestFingerprint(command, params, cwd, environment = {}) {
+  const seed = JSON.stringify({ command, params: canonicalize(params), cwd, environment: canonicalize(environment) });
   return createHash("sha256").update(seed).digest("hex").slice(0, 32);
 }
 
@@ -4953,8 +5165,9 @@ var ArtifactStore = class {
   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"));
+    const root = path4.join(this.options.root, safeComponent(generation, "generation"));
+    const ownerKey = `owner-${createHash2("sha256").update(normalizeComputerUseOwner(owner)).digest("hex")}`;
+    const ownerDir = path4.join(root, ownerKey);
     ensurePrivateDirectory(this.options.root);
     ensurePrivateDirectory(root);
     ensurePrivateDirectory(ownerDir);
@@ -4964,7 +5177,7 @@ var ArtifactStore = class {
     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 absolutePath = path4.join(directory, `${artifactId}.${extensionFor(input.mimeType)}`);
     const fd = openSync(absolutePath, "wx", 384);
     try {
       let offset = 0;
@@ -4993,6 +5206,16 @@ var ArtifactStore = class {
     this.sweep();
     return record;
   }
+  /** Hold existing evidence while a hydrated observation is used. */
+  pinForState(stateId2) {
+    const ids = [];
+    for (const record of this.records.values()) {
+      if (record.stateId !== stateId2) continue;
+      this.pin(record.artifactId);
+      ids.push(record.artifactId);
+    }
+    return ids;
+  }
   pin(artifactId) {
     this.pins.set(artifactId, (this.pins.get(artifactId) ?? 0) + 1);
   }
@@ -5044,13 +5267,13 @@ var ArtifactStore = class {
   /** 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 directory = path4.join(this.options.root, generation);
+    if (!existsSync3(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);
+      const ownerDir = path4.join(directory, name);
       let ownerStats;
       try {
         ownerStats = lstatSync3(ownerDir);
@@ -5059,7 +5282,7 @@ var ArtifactStore = class {
       }
       if (ownerStats.isSymbolicLink() || !ownerStats.isDirectory()) continue;
       for (const file of readdirSync2(ownerDir)) {
-        const target = path3.join(ownerDir, file);
+        const target = path4.join(ownerDir, file);
         let fileStats;
         try {
           fileStats = lstatSync3(target);
@@ -5071,12 +5294,12 @@ var ArtifactStore = class {
         removed += 1;
       }
       try {
-        rmdirSync(ownerDir);
+        rmdirSync2(ownerDir);
       } catch {
       }
     }
     try {
-      rmdirSync(directory);
+      rmdirSync2(directory);
     } catch {
     }
     return removed;
@@ -5100,7 +5323,7 @@ var ArtifactStore = class {
     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);
+      const directory = path4.join(this.options.root, name);
       let stats;
       try {
         stats = lstatSync3(directory);
@@ -5132,11 +5355,12 @@ var ArtifactStore = class {
 };
 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");
+  if (base) return path4.resolve(base);
+  return path4.join(stateRootDir(env), "artifacts");
 }
 
 // vendor/computer-use-axi/src/bridge.ts
+init_test_backend_guard();
 import { spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { constants as fsConstants5, mkdtempSync } from "node:fs";
@@ -5160,7 +5384,7 @@ 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 path4(value, env) {
+function path5(value, env) {
   if (!Array.isArray(value) || value.length < 2) throw new Error("drag.path must contain at least two points.");
   return value.map((point, index) => {
     const x = Array.isArray(point) ? toFiniteNumber(point[0], NaN) : toFiniteNumber(point?.x, NaN);
@@ -5192,7 +5416,7 @@ function nativeTarget(action, operation, env) {
     env.validatePoint(x, y);
     return { x, y };
   }
-  if (operation === "drag" && action.path?.length) return path4(action.path, env)[0];
+  if (operation === "drag" && action.path?.length) return path5(action.path, env)[0];
   throw new Error(`${operation} requires either ref or both x and y.`);
 }
 function focusedTarget(env) {
@@ -5262,7 +5486,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: path4(action.path, env) }, usesCurrentFocus: false, needsForeground: false };
+      return { action: operation, target, params: { path: path5(action.path, env) }, usesCurrentFocus: false, needsForeground: false };
     case "moveMouse":
       return { action: operation, target, params: {}, usesCurrentFocus: false, needsForeground: false };
   }
@@ -5288,6 +5512,7 @@ function outcomeAfterObservedValues(current, actions, valueForRef) {
 }
 
 // vendor/computer-use-axi/src/cdp.ts
+init_test_backend_guard();
 import { randomUUID as randomUUID3 } from "node:crypto";
 
 // ../../node_modules/ws/wrapper.mjs
@@ -5791,6 +6016,7 @@ var CdpTab = class _CdpTab {
   loadFired;
   static async connect(wsUrl, targetId, title, epoch = connectionEpoch) {
     assertConnectionEpoch(epoch);
+    assertNativeBackendAllowed();
     const ws = new wrapper_default(wsUrl);
     connectingSockets.add(ws);
     try {
@@ -5950,6 +6176,7 @@ var CdpTab = class _CdpTab {
     return entries;
   }
   send(method, params = {}) {
+    assertNativeBackendAllowed();
     const id = this.nextId++;
     return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
@@ -6027,7 +6254,7 @@ var CdpTab = class _CdpTab {
 };
 var connectedTabs = /* @__PURE__ */ new Map();
 var connectingTabs = /* @__PURE__ */ new Map();
-var lastConnectFailureAt = 0;
+var lastConnectFailureAt = /* @__PURE__ */ new Map();
 function disconnectCdp() {
   if (disconnecting) return disconnecting;
   connectionEpoch++;
@@ -6036,62 +6263,64 @@ function disconnectCdp() {
   connectingSockets.clear();
   connectedTabs.clear();
   connectingTabs.clear();
-  lastConnectFailureAt = 0;
+  lastConnectFailureAt.clear();
   disconnecting = Promise.all(tabs.map((tab) => tab.close())).then(() => void 0).finally(() => {
     disconnecting = void 0;
   });
   return disconnecting;
 }
-function cdpEnabled() {
-  const rawPort = process.env.PIE_COMPUTER_USE_CDP_PORT ?? "";
+function cdpEnabled(rawPort = getComputerUseEnvironmentValue("PIE_COMPUTER_USE_CDP_PORT") ?? "") {
   if (!/^\d+$/.test(rawPort)) return false;
   const port = Number(rawPort);
   return Number.isInteger(port) && port > 0 && port <= 65535 && typeof wrapper_default !== "undefined";
 }
 async function cdpTabForWindow(windowTitle, frame) {
   const epoch = connectionEpoch;
-  if (!cdpEnabled()) return void 0;
-  if (Date.now() - lastConnectFailureAt < CONNECT_FAILURE_RETRY_MS) return void 0;
+  const port = getComputerUseEnvironmentValue("PIE_COMPUTER_USE_CDP_PORT") ?? "";
+  if (!cdpEnabled(port)) return void 0;
+  if (Date.now() - (lastConnectFailureAt.get(port) ?? 0) < CONNECT_FAILURE_RETRY_MS) return void 0;
   try {
     assertConnectionEpoch(epoch);
-    for (const tab of connectedTabs.values()) {
+    for (const [key2, tab] of connectedTabs) {
+      if (!key2.startsWith(`${port}:`)) continue;
       if (tab.isOpen && titlesMatch(tab.title, windowTitle) && await tabMatchesFrame(tab, frame)) {
         assertConnectionEpoch(epoch);
         if (tab.isOpen) return tab;
       }
     }
-    const pages = await cdpPages(epoch);
+    const pages = await cdpPages(epoch, port);
     const match = await pickTab(pages, windowTitle, frame, epoch);
     assertConnectionEpoch(epoch);
     if (!match) return void 0;
-    const existing = connectedTabs.get(match.id);
+    const key = `${port}:${match.id}`;
+    const existing = connectedTabs.get(key);
     if (existing?.isOpen) {
       existing.title = match.title;
       return existing;
     }
-    let connecting = connectingTabs.get(match.id);
+    let connecting = connectingTabs.get(key);
     if (!connecting) {
       connecting = CdpTab.connect(match.webSocketDebuggerUrl, match.id, match.title, epoch);
-      connectingTabs.set(match.id, connecting);
+      connectingTabs.set(key, connecting);
     }
     let connected;
     try {
       connected = await connecting;
     } finally {
-      if (connectingTabs.get(match.id) === connecting) connectingTabs.delete(match.id);
+      if (connectingTabs.get(key) === connecting) connectingTabs.delete(key);
     }
     assertConnectionEpoch(epoch);
-    connectedTabs.set(match.id, connected);
+    connectedTabs.set(key, connected);
     return connected;
   } catch {
-    if (epoch === connectionEpoch && !disconnecting) lastConnectFailureAt = Date.now();
+    if (epoch === connectionEpoch && !disconnecting) lastConnectFailureAt.set(port, Date.now());
     return void 0;
   }
 }
-async function listCdpPageContexts() {
-  const pages = await cdpPages();
+async function listCdpPageContexts(port = getComputerUseEnvironmentValue("PIE_COMPUTER_USE_CDP_PORT")) {
+  const pages = await cdpPages(connectionEpoch, port);
   return pages.map((page) => ({
-    contextId: cdpContextId(page.id),
+    contextId: cdpContextId(page.id, port),
     targetId: page.id,
     title: page.title,
     url: page.url ?? ""
@@ -6208,14 +6437,18 @@ async function withCdpContextTab(contextId, run) {
 }
 async function cdpPageForContext(contextId, epoch) {
   if (!contextId.startsWith(CDP_CONTEXT_PREFIX)) return void 0;
-  const targetId = contextId.slice(CDP_CONTEXT_PREFIX.length);
-  const pages = await cdpPages(epoch);
+  const identity = contextId.slice(CDP_CONTEXT_PREFIX.length);
+  const separator = identity.indexOf(":");
+  if (separator < 1) return void 0;
+  const port = identity.slice(0, separator);
+  const targetId = identity.slice(separator + 1);
+  const pages = await cdpPages(epoch, port);
   return pages.find((candidate) => candidate.id === targetId);
 }
-async function cdpPages(epoch = connectionEpoch) {
+async function cdpPages(epoch = connectionEpoch, port = getComputerUseEnvironmentValue("PIE_COMPUTER_USE_CDP_PORT")) {
   assertConnectionEpoch(epoch);
-  if (!cdpEnabled()) return [];
-  const port = process.env.PIE_COMPUTER_USE_CDP_PORT;
+  if (!port || !cdpEnabled(port)) return [];
+  assertNativeBackendAllowed();
   const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(2e3) });
   const targets = await response.json();
   assertConnectionEpoch(epoch);
@@ -6223,8 +6456,8 @@ async function cdpPages(epoch = connectionEpoch) {
     (target) => target.type === "page" && target.webSocketDebuggerUrl && isLocalDebuggerWebSocket(target.webSocketDebuggerUrl, port)
   );
 }
-function cdpContextId(targetId) {
-  return `${CDP_CONTEXT_PREFIX}${targetId}`;
+function cdpContextId(targetId, port) {
+  return `${CDP_CONTEXT_PREFIX}${port}:${targetId}`;
 }
 function axString(raw) {
   const value = raw?.value ?? raw;
@@ -6371,98 +6604,6 @@ function titlesMatch(tabTitle, windowTitle) {
   return tab === win || win.startsWith(tab) || tab.startsWith(win);
 }
 
-// vendor/computer-use-axi/src/config.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { AsyncLocalStorage } from "node:async_hooks";
-import path5 from "node:path";
-
-// vendor/computer-use-axi/host.ts
-function getAgentDir() {
-  return getConfigDir();
-}
-
-// vendor/computer-use-axi/src/config.ts
-var DEFAULT_CONFIG = {
-  browser_use: true,
-  headless: false,
-  cursor_overlay: true,
-  managed_browser: "chrome"
-};
-var operationConfig = new AsyncLocalStorage();
-var defaultLoaded = Object.freeze({ config: Object.freeze({ ...DEFAULT_CONFIG }), sources: [], env: {} });
-function withComputerUseConfig(cwd, run) {
-  return operationConfig.run(loadComputerUseConfig(cwd), run);
-}
-function parseBoolean(value) {
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") return value === 1 ? true : value === 0 ? false : void 0;
-  if (typeof value !== "string") return void 0;
-  const normalized = value.trim().toLowerCase();
-  if (["1", "true", "yes", "on", "enabled"].includes(normalized)) return true;
-  if (["0", "false", "no", "off", "disabled"].includes(normalized)) return false;
-  return void 0;
-}
-function normalizePartial(raw) {
-  if (!raw || typeof raw !== "object") return {};
-  const source = raw.computer_use && typeof raw.computer_use === "object" ? raw.computer_use : raw;
-  const out = {};
-  const browserUse = parseBoolean(source.browser_use);
-  const headless = parseBoolean(source.headless);
-  const cursorOverlay = parseBoolean(source.cursor_overlay);
-  if (browserUse !== void 0) out.browser_use = browserUse;
-  if (headless !== void 0) out.headless = headless;
-  if (cursorOverlay !== void 0) out.cursor_overlay = cursorOverlay;
-  const managedBrowser = source.managed_browser;
-  if (managedBrowser === "helium" || managedBrowser === "chrome") out.managed_browser = managedBrowser;
-  return out;
-}
-function readConfigFile(filePath) {
-  if (!existsSync3(filePath)) return { path: filePath, exists: false };
-  try {
-    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) };
-  }
-}
-function readEnv() {
-  const out = {};
-  const browserUse = parseBoolean(process.env.PIE_COMPUTER_USE_BROWSER_USE);
-  const headless = parseBoolean(process.env.PIE_COMPUTER_USE_HEADLESS);
-  const cursorOverlay = parseBoolean(process.env.PIE_COMPUTER_USE_CURSOR_OVERLAY);
-  if (browserUse !== void 0) out.browser_use = browserUse;
-  if (headless !== void 0) out.headless = headless;
-  if (cursorOverlay !== void 0) out.cursor_overlay = cursorOverlay;
-  const managedBrowser = process.env.PIE_COMPUTER_USE_MANAGED_BROWSER;
-  if (managedBrowser === "helium" || managedBrowser === "chrome") out.managed_browser = managedBrowser;
-  return out;
-}
-function loadComputerUseConfig(cwd) {
-  const sources = [
-    readConfigFile(path5.join(getAgentDir(), "extensions", "computer-use.json")),
-    readConfigFile(path5.join(cwd, ".pie", "computer-use.json"))
-  ];
-  const env = readEnv();
-  const config = { ...DEFAULT_CONFIG };
-  for (const source of sources) {
-    if (source.values) Object.assign(config, source.values);
-  }
-  Object.assign(config, env);
-  return Object.freeze({ config: Object.freeze(config), sources, env });
-}
-function getComputerUseConfig() {
-  return getLoadedComputerUseConfig().config;
-}
-function getLoadedComputerUseConfig() {
-  return operationConfig.getStore() ?? defaultLoaded;
-}
-function isHeadlessMode() {
-  return getComputerUseConfig().headless;
-}
-function isBrowserUseEnabled() {
-  return getComputerUseConfig().browser_use;
-}
-
 // vendor/computer-use-axi/src/note.ts
 function normalizedLabel(value) {
   return value.toLowerCase().replace(/\s+/g, " ").trim();
@@ -6616,8 +6757,9 @@ function renderNote(note) {
 }
 
 // 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 { closeSync as closeSync2, openSync as openSync2, readSync, readdirSync as readdirSync3, statSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import path6 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
 var MODEL_TEXT_MAX_BYTES = 48 * 1024;
 var MODEL_TEXT_MAX_LINES = 2e3;
 var OUTPUT_PAGE_BYTES = 16 * 1024;
@@ -6629,8 +6771,13 @@ var outputs = /* @__PURE__ */ new Map();
 var nextOutputId = 1;
 var outputBytes = 0;
 function outputDirectoryFor(owner) {
-  const dir = path6.join(outputsDir(), "owners", normalizeComputerUseOwner(owner));
-  mkdirSync5(dir, { recursive: true, mode: 448 });
+  const root = outputsDir();
+  const owners = path6.join(root, "owners");
+  const ownerKey = `owner-${createHash3("sha256").update(normalizeComputerUseOwner(owner)).digest("hex")}`;
+  const dir = path6.join(owners, ownerKey);
+  ensurePrivateDirectory(root);
+  ensurePrivateDirectory(owners);
+  ensurePrivateDirectory(dir);
   return dir;
 }
 function utf8Prefix(bytes, maxBytes) {
@@ -6762,6 +6909,9 @@ function clearStoredOutputs(owner) {
 // vendor/computer-use-axi/src/bridge.ts
 init_coerce();
 
+// vendor/computer-use-axi/src/platform/index.ts
+init_test_backend_guard();
+
 // vendor/computer-use-axi/src/platform/macos/backend.ts
 init_coerce();
 init_helper();
@@ -6982,6 +7132,7 @@ init_architecture();
 init_coerce();
 
 // vendor/computer-use-axi/src/platform/linux/helper.ts
+init_test_backend_guard();
 init_package_root();
 import { spawn as spawn2 } from "node:child_process";
 import { randomUUID as randomUUID4 } from "node:crypto";
@@ -7005,6 +7156,7 @@ async function isExecutable2(filePath) {
 async function runProcess2(command, args, timeoutMs, signal, env) {
   if (signal?.aborted) throw new Error("Operation aborted.");
   await new Promise((resolve2, reject) => {
+    assertNativeBackendAllowed();
     const child = spawn2(command, args, { stdio: ["ignore", "pipe", "pipe"], env });
     let stdout = "";
     let stderr = "";
@@ -7092,6 +7244,7 @@ var LinuxHelperClient = class {
     this.buffer = "";
   }
   async ensureInstalled(signal) {
+    assertNativeBackendAllowed();
     if (await isExecutable2(this.helperPath) && this.installChecked) return;
     if (!this.installPromise) {
       const installPromise = (async () => {
@@ -7135,6 +7288,7 @@ var LinuxHelperClient = class {
     return await waitForShared(this.processPromise, signal);
   }
   async startProcess() {
+    assertNativeBackendAllowed();
     const child = spawn2(this.helperPath, [], { stdio: ["pipe", "pipe", "pipe"] });
     child.stdout.setEncoding("utf8");
     child.stderr.setEncoding("utf8");
@@ -7187,6 +7341,7 @@ var LinuxHelperClient = class {
     }
   }
   async command(cmd, args = {}, options) {
+    assertNativeBackendAllowed();
     const child = await this.process(options?.signal);
     const id = randomUUID4();
     const timeoutMs = options?.timeoutMs ?? COMMAND_TIMEOUT_MS3;
@@ -7386,6 +7541,7 @@ var linuxBackend = {
 init_coerce();
 
 // vendor/computer-use-axi/src/platform/windows/helper.ts
+init_test_backend_guard();
 init_package_root();
 import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID5 } from "node:crypto";
@@ -7409,6 +7565,7 @@ async function isExecutable3(filePath) {
 async function runProcess3(command, args, timeoutMs, signal, env) {
   if (signal?.aborted) throw new Error("Operation aborted.");
   await new Promise((resolve2, reject) => {
+    assertNativeBackendAllowed();
     const child = spawn3(command, args, { stdio: ["ignore", "pipe", "pipe"], env });
     let stdout = "";
     let stderr = "";
@@ -7469,6 +7626,7 @@ var WindowsHelperClient = class {
     child.unref();
   }
   async ensureInstalled(signal) {
+    assertNativeBackendAllowed();
     if (await isExecutable3(WINDOWS_HELPER_PATH) && this.installChecked) return;
     await runProcess3(process.execPath, [SETUP_HELPER_SCRIPT3, "--platform", "windows", "--runtime"], HELPER_SETUP_TIMEOUT_MS3, signal, { ...process.env, ELECTRON_RUN_AS_NODE: "1", BUN_BE_BUN: "1" });
     this.installChecked = true;
@@ -7477,6 +7635,7 @@ var WindowsHelperClient = class {
   async process(signal) {
     await this.ensureInstalled(signal);
     if (this.child && this.child.exitCode === null && !this.child.killed) return this.child;
+    assertNativeBackendAllowed();
     const child = spawn3(WINDOWS_HELPER_PATH, [], { stdio: ["pipe", "pipe", "pipe"] });
     child.stdout.setEncoding("utf8");
     child.stderr.setEncoding("utf8");
@@ -7522,6 +7681,7 @@ var WindowsHelperClient = class {
     }
   }
   async command(cmd, args = {}, options) {
+    assertNativeBackendAllowed();
     const child = await this.process(options?.signal);
     const id = randomUUID5();
     const timeoutMs = options?.timeoutMs ?? COMMAND_TIMEOUT_MS4;
@@ -7745,10 +7905,17 @@ var UnsupportedPlatformBackend = class {
   }
 };
 function platformBackendForRuntime(platform = process.platform) {
-  if (platform === "darwin") return macosPlatformBackend;
-  if (platform === "win32") return windowsBackend;
-  if (platform === "linux") return linuxBackend;
-  return new UnsupportedPlatformBackend(platform);
+  const backend = platform === "darwin" ? macosPlatformBackend : platform === "win32" ? windowsBackend : platform === "linux" ? linuxBackend : new UnsupportedPlatformBackend(platform);
+  return new Proxy(backend, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== "function") return value;
+      return (...args) => {
+        assertNativeBackendAllowed();
+        return Reflect.apply(value, target, args);
+      };
+    }
+  });
 }
 var currentPlatformBackend = platformBackendForRuntime();
 var backendOverrideInstalled = false;
@@ -8377,6 +8544,7 @@ function desktopResourceKey(target) {
 }
 function persistOperation(state) {
   if (!state.currentTarget || !state.currentCapture || !state.currentLook || !state.currentOutline) return;
+  if (expiredStateReasons.has(state.currentCapture.stateId) || state.helperGeneration !== helperGeneration) return;
   const resourceKey = state.resourceKey ?? desktopResourceKey(state.currentTarget);
   const epoch = state.epoch ?? resourceScheduler.epoch(resourceKey);
   savedStates.saveDesktop(state, resourceKey, epoch);
@@ -8400,10 +8568,7 @@ async function releaseComputerUseSession() {
   });
   await attempt("drain scheduler", () => drain);
   await attempt("release owned browser", () => releaseOwnedBrowserState(runtimeState));
-  if (runtimeState.managedBrowserCdpPort && process.env.PIE_COMPUTER_USE_CDP_PORT === runtimeState.managedBrowserCdpPort) {
-    if (runtimeState.previousCdpPort === void 0) delete process.env.PIE_COMPUTER_USE_CDP_PORT;
-    else process.env.PIE_COMPUTER_USE_CDP_PORT = runtimeState.previousCdpPort;
-  }
+  setManagedCdpPort(void 0);
   runtimeState.previousCdpPort = void 0;
   if (runtimeState.managedBrowser === void 0) {
     runtimeState.managedBrowserCdpPort = void 0;
@@ -8427,7 +8592,7 @@ function currentRuntimeMode() {
 }
 function currentDeliveryPolicy() {
   if (isHeadlessMode()) return "background";
-  const value = (process.env.PIE_COMPUTER_USE_DELIVERY_POLICY ?? process.env.PIE_COMPUTER_USE_EVENT_DELIVERY ?? "default").toLowerCase();
+  const value = (getComputerUseEnvironmentValue("PIE_COMPUTER_USE_DELIVERY_POLICY") ?? getComputerUseEnvironmentValue("PIE_COMPUTER_USE_EVENT_DELIVERY") ?? "default").toLowerCase();
   return value === "background" || value === "pid" ? "background" : value === "foreground" || value === "hid" ? "foreground" : value === "ax_only" || value === "ax-only" ? "ax_only" : "default";
 }
 function nativeInputDelivery(policy = currentDeliveryPolicy()) {
@@ -9358,7 +9523,7 @@ async function refreshBrowserSnapshot(contextId, tool, base) {
   const browser = await cdpSnapshotForContext(contextId);
   if (!browser) throw new Error(`Browser root '${contextId}' is no longer available. Call find_roots and observe_ui again.`);
   const state = operationState();
-  const resourceKey = state.resourceKey ?? `cdp:${browser.targetId}`;
+  const resourceKey = state.resourceKey ?? `cdp:${browser.contextId.slice(BROWSER_CONTEXT_PREFIX.length)}`;
   return browserObservationResult(browser, resourceKey, state.epoch ?? resourceScheduler.epoch(resourceKey), tool, base);
 }
 function sliceText(value, offsetValue, _limitValue) {
@@ -9997,7 +10162,7 @@ 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]);
+  const override = trimOrUndefined(getComputerUseEnvironmentValue(overrideName));
   if (override) return [path13.resolve(override)];
   const platformCandidates = process.platform === "darwin" ? browser === "helium" ? [
     "/Applications/Helium.app/Contents/MacOS/Helium",
@@ -10038,7 +10203,7 @@ async function managedBrowserExecutable(browser) {
     }
   }
   const overrideName = browser === "helium" ? "PIE_COMPUTER_USE_HELIUM_EXECUTABLE" : "PIE_COMPUTER_USE_CHROME_EXECUTABLE";
-  if (trimOrUndefined(process.env[overrideName])) {
+  if (trimOrUndefined(getComputerUseEnvironmentValue(overrideName))) {
     throw new Error(`${browser} executable from ${overrideName} was not found or is not executable: ${candidates[0]}.`);
   }
   throw new Error(`${browser} executable was not found. Set ${overrideName} to its absolute path.`);
@@ -10068,6 +10233,7 @@ async function waitForCdpPort(port, signal) {
   throw new Error(`Managed browser did not expose CDP on port ${port} within ${MANAGED_BROWSER_READY_TIMEOUT_MS}ms.`);
 }
 async function performLaunchBrowser(params, signal) {
+  assertNativeBackendAllowed();
   const browser = getComputerUseConfig().managed_browser;
   const executable = await managedBrowserExecutable(browser);
   const port = await freeTcpPort();
@@ -10084,9 +10250,6 @@ async function performLaunchBrowser(params, signal) {
     "--no-default-browser-check",
     url
   ];
-  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: true });
   managedBrowser.unref();
   const stalePid = runtimeState.managedBrowserPid;
@@ -10101,22 +10264,21 @@ async function performLaunchBrowser(params, signal) {
   runtimeState.managedBrowserPid = managedBrowser.pid;
   runtimeState.managedBrowserProfileDir = profileDir;
   persistRuntimeBridgeState();
-  process.env.PIE_COMPUTER_USE_CDP_PORT = String(port);
+  setManagedCdpPort(String(port));
   try {
     await waitForCdpPort(port, signal);
   } catch (error) {
     if (runtimeState.managedBrowser === managedBrowser) {
       await releaseOwnedBrowserState(runtimeState);
-      if (runtimeState.previousCdpPort === void 0) delete process.env.PIE_COMPUTER_USE_CDP_PORT;
-      else process.env.PIE_COMPUTER_USE_CDP_PORT = runtimeState.previousCdpPort;
+      setManagedCdpPort(void 0);
       runtimeState.managedBrowserCdpPort = void 0;
       runtimeState.previousCdpPort = void 0;
     }
     throw error;
   }
-  const page = (await listCdpPageContexts())[0];
+  const page = (await listCdpPageContexts(String(port)))[0];
   if (!page) throw new Error("Managed browser launched without a CDP page context.");
-  const resourceKey = `cdp:${page.targetId}`;
+  const resourceKey = `cdp:${page.contextId.slice(BROWSER_CONTEXT_PREFIX.length)}`;
   const scheduled = await resourceScheduler.read(resourceKey, async () => await cdpSnapshotForContext(page.contextId));
   if (!scheduled.value) throw new Error("Managed browser page could not be observed after launch.");
   return browserObservationResult(scheduled.value, resourceKey, scheduled.epoch, "launch_browser");
@@ -10177,6 +10339,9 @@ async function executeTool(tool, ctx, params, signal, run, runtime) {
   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 && expiredStateReasons.has(requestedStateId)) {
+    throw new Error(`State '${requestedStateId}' expired because ${expiredStateReasons.get(requestedStateId)}. Observe the root again.`);
+  }
   if (requestedStateId && !stateRecord) {
     const reason = expiredStateReasons.get(requestedStateId);
     if (reason) {
@@ -10196,6 +10361,7 @@ async function executeTool(tool, ctx, params, signal, run, runtime) {
   operation.onDispatch = runtime?.onDispatch;
   if (requestedStateId && stateRecord) assertStateAccess(requestedStateId, stateRecord, operation);
   return await withComputerUseConfig(ctx.cwd, () => savedStates.operations.run(operation, async () => {
+    if (requestedStateId) operation.artifactIds = engineArtifacts?.pinForState(requestedStateId) ?? [];
     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 () => {
@@ -10212,7 +10378,7 @@ async function executeTool(tool, ctx, params, signal, run, runtime) {
     } finally {
       for (const artifactId of operation.artifactIds ?? []) engineArtifacts?.unpin(artifactId);
     }
-  }));
+  }), runtime?.environment);
 }
 var BROKER_PERFORMERS = {
   find_roots: performListWindows,
@@ -10317,7 +10483,7 @@ async function probeBroker(endpoint, timeoutMs = 800) {
     };
     socket.setTimeout(timeoutMs, () => finish({ error: "timeout" }));
     socket.on("connect", () => {
-      socket.write(encodeFrame({ type: "hello", protocolVersion: BROKER_PROTOCOL_VERSION, clientVersion: "probe" }));
+      socket.write(encodeFrame({ type: "hello", protocolVersion: BROKER_PROTOCOL_VERSION, clientVersion: "probe", buildIdentity: BROKER_BUILD.identity }));
     });
     socket.on("data", (chunk) => {
       try {
@@ -10364,8 +10530,7 @@ async function startBroker(options = {}) {
   const helperGeneration2 = randomUUID8();
   let liveHelperGeneration = helperGeneration2;
   const startedAt = Date.now();
-  const legacyCache = cleanupLegacyBrokerCache();
-  const prior = loadBrokerManifest();
+  let legacyCache;
   const artifacts = new ArtifactStore({
     root: artifactsRoot(),
     generation,
@@ -10374,18 +10539,6 @@ async function startBroker(options = {}) {
       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 acceptedIds = /* @__PURE__ */ new Set();
   const resultCacheLimit = options.resultCacheLimit ?? BROKER_RESULT_CACHE_MAX_ENTRIES;
@@ -10506,6 +10659,7 @@ async function startBroker(options = {}) {
         helperGeneration: currentHelperGenerationSafe(),
         requestId: request.requestId,
         cwd: request.cwd,
+        environment: request.environment,
         signal: entry.controller.signal,
         onDispatch: () => {
           entry.dispatched = true;
@@ -10529,7 +10683,7 @@ async function startBroker(options = {}) {
       return;
     }
     const key = request.requestId;
-    const fingerprint = requestFingerprint(request.command, request.params, request.cwd);
+    const fingerprint = requestFingerprint(request.command, request.params, request.cwd, request.environment);
     const existing = entries.get(key);
     if (existing) {
       if (existing.ownerId !== request.ownerId || existing.command !== request.command || existing.fingerprint !== fingerprint) {
@@ -10741,7 +10895,8 @@ async function startBroker(options = {}) {
               pid: process.pid,
               startedAt,
               platform: process.platform,
-              transport: endpoint.kind
+              transport: endpoint.kind,
+              backend: { fakeInstalled: options.fakeBackendInstalled === true, requireFake: requireFakeBackend() }
             });
           } catch (error) {
             helloRejected = true;
@@ -10829,6 +10984,23 @@ async function startBroker(options = {}) {
         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.`);
       }
     }
+    legacyCache = cleanupLegacyBrokerCache();
+    const prior = loadBrokerManifest();
+    try {
+      artifacts.cleanupOtherGenerations(generation);
+    } catch {
+    }
+    configureEngineRuntime({
+      generation,
+      helperGeneration: helperGeneration2,
+      artifacts,
+      expiredStateIds: prior?.stateIds ?? [],
+      previousGeneration: prior?.generation
+    });
+    saveBrokerManifest({ generation, helperGeneration: helperGeneration2, stateIds: [], updatedAt: Date.now() });
+  } catch (error) {
+    if (server.listening) server.close();
+    throw error;
   } finally {
     bootstrapLock();
   }
@@ -10881,13 +11053,6 @@ async function startBroker(options = {}) {
       clearDrainMarker();
     } catch {
     }
-    if (endpoint.kind === "unix-socket") {
-      try {
-        const stats = lstatSync4(endpoint.path);
-        if (stats.isSocket()) unlinkSync4(endpoint.path);
-      } catch {
-      }
-    }
     options.onShutdown?.();
     void reason;
   };
@@ -10913,7 +11078,7 @@ async function startBroker(options = {}) {
         uncertain,
         requests: entries.size,
         ownerCount: owners.size,
-        ownerFingerprints: [...owners].map((owner) => createHash3("sha256").update(owner).digest("hex").slice(0, 12)),
+        ownerFingerprints: [...owners].map((owner) => createHash4("sha256").update(owner).digest("hex").slice(0, 12)),
         artifacts: artifacts.stats(),
         legacyCache,
         idleExitMs
@@ -10934,19 +11099,8 @@ async function startBroker(options = {}) {
   return statusHandle;
 }
 
-// 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 };
-}
-
 // vendor/computer-use-axi/src/broker-main.ts
+init_test_backend_guard();
 async function loadTestOnlyBackend() {
   const decision = resolveTestOnlyBackend();
   if (decision.warning) process.stderr.write(`computer-use-axi broker: ${decision.warning}
@@ -10959,6 +11113,7 @@ async function loadTestOnlyBackend() {
     setPlatformBackend(fake);
     return fake;
   } catch (error) {
+    if (requireFakeBackend()) throw new Error("Required fake backend failed to load; refusing native fallback.", { cause: 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.
 `
@@ -10971,6 +11126,7 @@ async function main() {
   const testCommands = process.env.PIE_COMPUTER_USE_ENABLE_TEST_COMMANDS === "1";
   const handle = await startBroker({
     testCommands,
+    fakeBackendInstalled: Boolean(fake),
     // Fail-closed capacity contract hooks (tests only; both require the
     // explicit test-command switch and are ignored in every other build).
     resultCacheLimit: testCommands && Number.isFinite(Number(process.env.PIE_COMPUTER_USE_TEST_RESULT_CACHE_LIMIT)) ? Math.trunc(Number(process.env.PIE_COMPUTER_USE_TEST_RESULT_CACHE_LIMIT)) : void 0,