local-commander-agent-linux-arm64 0.3.46 → 0.3.48

package/runtime/agent.mjs

@@ -2138,7 +2138,7 @@ var require_extension = __commonJS({
       if (dest[name2] === void 0) dest[name2] = [elem];
       else dest[name2].push(elem);
     }
-    function parse3(header) {
+    function parse4(header) {
       const offers = /* @__PURE__ */ Object.create(null);
       let params = /* @__PURE__ */ Object.create(null);
       let mustUnescape = false;
@@ -2278,7 +2278,7 @@ var require_extension = __commonJS({
         }).join(", ");
       }).join(", ");
     }
-    module.exports = { format, parse: parse3 };
+    module.exports = { format, parse: parse4 };
   }
 });
 
@@ -2289,9 +2289,9 @@ var require_websocket = __commonJS({
     var EventEmitter = __require("events");
     var https2 = __require("https");
     var http2 = __require("http");
-    var net2 = __require("net");
+    var net3 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes10, createHash: createHash21 } = __require("crypto");
+    var { randomBytes: randomBytes11, createHash: createHash21 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2312,7 +2312,7 @@ var require_websocket = __commonJS({
     var {
       EventTarget: { addEventListener, removeEventListener }
     } = require_event_target();
-    var { format, parse: parse3 } = require_extension();
+    var { format, parse: parse4 } = require_extension();
     var { toBuffer } = require_buffer_util();
     var kAborted = /* @__PURE__ */ Symbol("kAborted");
     var protocolVersions = [8, 13];
@@ -2842,7 +2842,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes10(16).toString("base64");
+      const key = randomBytes11(16).toString("base64");
       const request = isSecure ? https2.request : http2.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -3002,7 +3002,7 @@ var require_websocket = __commonJS({
           }
           let extensions;
           try {
-            extensions = parse3(secWebSocketExtensions);
+            extensions = parse4(secWebSocketExtensions);
           } catch (err) {
             const message2 = "Invalid Sec-WebSocket-Extensions header";
             abortHandshake(websocket, socket, message2);
@@ -3046,12 +3046,12 @@ var require_websocket = __commonJS({
     }
     function netConnect2(options) {
       options.path = options.socketPath;
-      return net2.connect(options);
+      return net3.connect(options);
     }
     function tlsConnect(options) {
       options.path = void 0;
       if (!options.servername && options.servername !== "") {
-        options.servername = net2.isIP(options.host) ? "" : options.host;
+        options.servername = net3.isIP(options.host) ? "" : options.host;
       }
       return tls2.connect(options);
     }
@@ -3294,7 +3294,7 @@ var require_subprotocol = __commonJS({
   "node_modules/ws/lib/subprotocol.js"(exports, module) {
     "use strict";
     var { tokenChars } = require_validation();
-    function parse3(header) {
+    function parse4(header) {
       const protocols = /* @__PURE__ */ new Set();
       let start = -1;
       let end = -1;
@@ -3330,7 +3330,7 @@ var require_subprotocol = __commonJS({
       protocols.add(protocol2);
       return protocols;
     }
-    module.exports = { parse: parse3 };
+    module.exports = { parse: parse4 };
   }
 });
 
@@ -5583,18 +5583,18 @@ var validateAsync = async (schema, value, _ctx) => {
   return result2.issues.length === 0;
 };
 var _encode = (_Err) => {
-  const parse3 = _parse(_Err);
+  const parse4 = _parse(_Err);
   const fn = (schema, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return parse3(schema, value, ctx, finalizeParams(fn, _params));
+    return parse4(schema, value, ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
 var encode = /* @__PURE__ */ _encode($ZodRealError);
 var _decode = (_Err) => {
-  const parse3 = _parse(_Err);
+  const parse4 = _parse(_Err);
   const fn = (schema, value, _ctx, _params) => {
-    return parse3(schema, value, _ctx, finalizeParams(fn, _params));
+    return parse4(schema, value, _ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
@@ -26479,10 +26479,12 @@ var ServerFrameSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({ type: external_exports.literal("workspace_ack"), version: external_exports.literal(1), requestId: uuid11, workspaceGrantId: uuid11, accepted: external_exports.boolean(), code: external_exports.string().max(64).optional() }).strict(),
   external_exports.object({ type: external_exports.literal("revoke"), version: external_exports.literal(1), reason: external_exports.enum(["device_revoked", "account_revoked", "server_shutdown", "connection_replaced"]) }).strict()
 ]);
+var WORKSPACE_ACCESS_MODE_CAPABILITY = "workspaceAccessModeV1";
+var WorkspaceAccessModeSchema = external_exports.enum(["full", "scoped"]);
 var ClientFrameSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({ type: external_exports.literal("ready"), version: external_exports.literal(1), safeSlots: external_exports.number().int().min(1).max(128), platform: external_exports.literal("win32"), agentVersion: external_exports.string().regex(/^[A-Za-z0-9._+-]{1,64}$/), supervisor: external_exports.boolean() }).strict(),
   external_exports.object({ type: external_exports.literal("heartbeat"), version: external_exports.literal(1), connectionEpoch: epoch2 }).strict(),
-  external_exports.object({ type: external_exports.literal("workspace_grant"), version: external_exports.literal(1), requestId: uuid11, workspaceGrantId: uuid11, rootHash: hash3, displayName: external_exports.string().min(1).max(120), policyVersion: external_exports.number().int().min(1).max(2147483647) }).strict(),
+  external_exports.object({ type: external_exports.literal("workspace_grant"), version: external_exports.literal(1), requestId: uuid11, workspaceGrantId: uuid11, rootHash: hash3, displayName: external_exports.string().min(1).max(120), policyVersion: external_exports.number().int().min(1).max(2147483647), accessMode: WorkspaceAccessModeSchema.optional() }).strict(),
   external_exports.object({ type: external_exports.literal("workspace_revoke"), version: external_exports.literal(1), requestId: uuid11, workspaceGrantId: uuid11 }).strict(),
   external_exports.object({ type: external_exports.literal("prepared"), version: external_exports.literal(1), binding: ExecutionBindingSchema }).strict(),
   external_exports.object({ type: external_exports.literal("accepted"), version: external_exports.literal(1), binding: ExecutionBindingSchema }).strict(),
@@ -27043,9 +27045,9 @@ var NativeJournal = class _NativeJournal {
       if (!validPid(pid)) throw failure2("JOURNAL_INPUT_INVALID");
       if (e.state !== "running" || !e.supervisors) throw failure2("JOURNAL_STATE_INVALID");
       if (containment !== void 0) {
-        const linux = validLinuxContainment(containment), darwin = !linux && validDarwinContainment(containment);
-        if (!linux && !darwin || !e.supervisors.includes(pid) || e.linuxSupervisors?.some((s) => s.pid === pid) || e.darwinSupervisors?.some((s) => s.pid === pid)) throw failure2("JOURNAL_INPUT_INVALID");
-        if (linux) (e.linuxSupervisors ??= []).push({ pid, containment: clone2(containment) });
+        const linux2 = validLinuxContainment(containment), darwin = !linux2 && validDarwinContainment(containment);
+        if (!linux2 && !darwin || !e.supervisors.includes(pid) || e.linuxSupervisors?.some((s) => s.pid === pid) || e.darwinSupervisors?.some((s) => s.pid === pid)) throw failure2("JOURNAL_INPUT_INVALID");
+        if (linux2) (e.linuxSupervisors ??= []).push({ pid, containment: clone2(containment) });
         else (e.darwinSupervisors ??= []).push({ pid, containment: clone2(containment) });
       } else {
         if (e.supervisors.length >= MAX_SUPERVISORS) throw failure2("JOURNAL_SUPERVISOR_LIMIT");
@@ -27943,11 +27945,16 @@ var WindowsPrivateStore = class _WindowsPrivateStore {
     if (process.platform !== "win32") for (const name2 of ["owner-key.json", "owner-key.dat", "owner-key.lock"]) approved.add(name2);
     if (names.length && !names.includes(MARKER)) throw fail2("STORE_DIRECTORY_UNKNOWN");
     const memoryFile = (name2) => name2 === "host-memory.json" || /^host-memory\.json\.[1-9][0-9]{0,9}\.tmp$/.test(name2);
-    if (names.some((name2) => !approved.has(name2) && !memoryFile(name2))) throw fail2("STORE_DIRECTORY_UNKNOWN");
+    const switchFile = (name2) => name2 === "screenshot-acceptance-enabled" || name2 === "screenshot-disabled-by-owner";
+    if (names.some((name2) => !approved.has(name2) && !memoryFile(name2) && !switchFile(name2))) throw fail2("STORE_DIRECTORY_UNKNOWN");
     for (const name2 of names.filter(memoryFile)) {
       const stat2 = await lstat4(path10.join(absolute2, name2));
       if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.size > 32768) throw fail2("STORE_DIRECTORY_INVALID");
     }
+    for (const name2 of names.filter(switchFile)) {
+      const stat2 = await lstat4(path10.join(absolute2, name2));
+      if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.size > 4096) throw fail2("STORE_DIRECTORY_INVALID");
+    }
     for (const name2 of ["agent-process.json", "optimization", ".local-commander"]) {
       if (!names.includes(name2)) continue;
       const filename = path10.join(absolute2, name2), stat2 = await lstat4(filename);
@@ -28918,8 +28925,8 @@ var HostMemory = class {
 };
 
 // agent/src/tools.ts
-import { constants as constants7 } from "node:fs";
-import { lstat as lstat7, open as open6, readdir as readdir4, realpath as realpath7, rename as rename4, rm as rm6 } from "node:fs/promises";
+import { constants as constants8 } from "node:fs";
+import { lstat as lstat8, open as open6, readdir as readdir5, realpath as realpath7, rename as rename4, rm as rm6 } from "node:fs/promises";
 import path18 from "node:path";
 import { createHash as createHash14, randomUUID as randomUUID7 } from "node:crypto";
 
@@ -29366,22 +29373,1025 @@ async function runSupervised(helper, request, options = {}) {
 
 // agent/src/screen-capture.ts
 import { execFile as execFile4 } from "node:child_process";
-import { mkdtemp, readFile as readFile6, rm as rm5 } from "node:fs/promises";
+import { randomBytes as randomBytes6 } from "node:crypto";
+import { constants as constants7 } from "node:fs";
+import { access as access3, lstat as lstat7, mkdtemp, readFile as readFile6, readdir as readdir4, rm as rm5, unlink as unlink2 } from "node:fs/promises";
 import os4 from "node:os";
 import path17 from "node:path";
+
+// agent/src/dbus-portal.ts
+import net from "node:net";
+function sessionBusSocket(address) {
+  for (const entry of (address ?? "").split(";")) {
+    if (!entry.startsWith("unix:")) continue;
+    for (const part of entry.slice(5).split(",")) {
+      const at = part.indexOf("="), key = part.slice(0, at), value = decodeURIComponent(part.slice(at + 1));
+      if (at > 0 && value && key === "path") return value;
+      if (at > 0 && value && key === "abstract") return "\0" + value;
+    }
+  }
+  return null;
+}
+var Writer = class {
+  bytes = [];
+  align(n) {
+    while (this.bytes.length % n) this.bytes.push(0);
+  }
+  byte(v) {
+    this.bytes.push(v & 255);
+  }
+  u32(v) {
+    this.align(4);
+    this.bytes.push(v & 255, v >>> 8 & 255, v >>> 16 & 255, v >>> 24 & 255);
+  }
+  str(v) {
+    const b = Buffer.from(v, "utf8");
+    this.u32(b.length);
+    this.bytes.push(...b, 0);
+  }
+  sig(v) {
+    this.byte(v.length);
+    this.bytes.push(...Buffer.from(v, "ascii"), 0);
+  }
+  /** Basic value or variant: `s`, `o`, `g`, `u`, `b`, `v` ([signature, value]). */
+  put(type, value) {
+    if (type === "s" || type === "o") this.str(String(value));
+    else if (type === "g") this.sig(String(value));
+    else if (type === "u") this.u32(Number(value));
+    else if (type === "b") this.u32(value ? 1 : 0);
+    else if (type === "v") {
+      const [inner, v] = value;
+      this.sig(inner);
+      this.put(inner, v);
+    } else throw Error("type " + type);
+  }
+  /** a{sv} */
+  dict(entries) {
+    this.u32(0);
+    const lengthAt = this.bytes.length - 4;
+    this.align(8);
+    const start = this.bytes.length;
+    for (const [key, value] of entries) {
+      this.align(8);
+      this.str(key);
+      this.put("v", value);
+    }
+    const length = this.bytes.length - start;
+    this.bytes.splice(lengthAt, 4, length & 255, length >>> 8 & 255, length >>> 16 & 255, length >>> 24 & 255);
+  }
+};
+var Reader = class {
+  constructor(data, at, le) {
+    this.data = data;
+    this.at = at;
+    this.le = le;
+  }
+  data;
+  at;
+  le;
+  align(n) {
+    this.at = Math.ceil(this.at / n) * n;
+  }
+  u32() {
+    this.align(4);
+    const v = this.le ? this.data.readUInt32LE(this.at) : this.data.readUInt32BE(this.at);
+    this.at += 4;
+    return v;
+  }
+  /** Reads one complete type from `sig` starting at `i`; returns the value and the index after the type. */
+  read(sig2, i) {
+    const c = sig2[i];
+    const fixed = { y: 1, n: 2, q: 2, b: 4, i: 4, u: 4, h: 4, x: 8, t: 8, d: 8 };
+    if (c in fixed) {
+      const size = fixed[c];
+      this.align(size);
+      const v = size === 1 ? this.data[this.at] : size === 2 ? this.le ? this.data.readUInt16LE(this.at) : this.data.readUInt16BE(this.at) : size === 4 ? this.le ? this.data.readUInt32LE(this.at) : this.data.readUInt32BE(this.at) : null;
+      this.at += size;
+      return [c === "b" ? v === 1 : v, i + 1];
+    }
+    if (c === "s" || c === "o") {
+      const n = this.u32(), v = this.data.toString("utf8", this.at, this.at + n);
+      this.at += n + 1;
+      return [v, i + 1];
+    }
+    if (c === "g") {
+      const n = this.data[this.at], v = this.data.toString("ascii", this.at + 1, this.at + 1 + n);
+      this.at += n + 2;
+      return [v, i + 1];
+    }
+    if (c === "v") {
+      const [inner] = this.read("g", 0);
+      return [this.read(inner, 0)[0], i + 1];
+    }
+    if (c === "(" || c === "{") {
+      this.align(8);
+      const close = c === "(" ? ")" : "}", values = [];
+      let j = i + 1;
+      while (sig2[j] !== close) {
+        const [v, next] = this.read(sig2, j);
+        values.push(v);
+        j = next;
+      }
+      return [values, j + 1];
+    }
+    if (c === "a") {
+      const n = this.u32(), element = sig2[i + 1];
+      this.align("xtd({".includes(element) ? 8 : element === "n" || element === "q" ? 2 : element === "y" || element === "g" || element === "v" ? 1 : 4);
+      const end = this.at + n, values = [];
+      let next = skip(sig2, i + 1);
+      while (this.at < end) {
+        const [v, j] = this.read(sig2, i + 1);
+        values.push(v);
+        next = j;
+      }
+      return [values, next];
+    }
+    throw Error("signature " + sig2);
+  }
+};
+function skip(sig2, i) {
+  const c = sig2[i];
+  if (c === "a") return skip(sig2, i + 1);
+  if (c === "(" || c === "{") {
+    let j = i + 1;
+    while (sig2[j] !== (c === "(" ? ")" : "}")) j = skip(sig2, j);
+    return j + 1;
+  }
+  return i + 1;
+}
+function parse3(data) {
+  const le = data[0] === 108, r = new Reader(data, 4, le), bodyLength = r.u32(), serial = r.u32();
+  const [fields] = r.read("a(yv)", 0);
+  const message2 = { type: data[1], serial, signature: "", body: [] };
+  for (const [code, value] of fields) {
+    if (code === 1) message2.path = String(value);
+    else if (code === 2) message2.interface = String(value);
+    else if (code === 3) message2.member = String(value);
+    else if (code === 4) message2.errorName = String(value);
+    else if (code === 5) message2.replySerial = Number(value);
+    else if (code === 8) message2.signature = String(value);
+  }
+  r.align(8);
+  const end = r.at + bodyLength;
+  for (let i = 0; i < message2.signature.length && r.at < end; ) {
+    const [v, next] = r.read(message2.signature, i);
+    message2.body.push(v);
+    i = next;
+  }
+  return message2;
+}
+function frameLength(data) {
+  if (data.length < 16) return 0;
+  const le = data[0] === 108, u = (at) => le ? data.readUInt32LE(at) : data.readUInt32BE(at);
+  const length = Math.ceil((16 + u(12)) / 8) * 8 + u(4);
+  return data.length >= length ? length : 0;
+}
+async function portalScreenshot(socket, uid, token, signal) {
+  const connection = net.createConnection({ path: socket });
+  try {
+    return await new Promise((resolve, reject) => {
+      let serial = 0, buffer = Buffer.alloc(0), authenticated = false, requestPath = "";
+      const pending = /* @__PURE__ */ new Map();
+      const fail7 = (error62) => reject(error62 instanceof Error ? error62 : Error(String(error62)));
+      const abort = () => fail7(Error("ABORTED"));
+      if (signal.aborted) return abort();
+      signal.addEventListener("abort", abort, { once: true });
+      connection.on("error", fail7);
+      connection.on("close", () => fail7(Error("CLOSED")));
+      const call = (destination, path30, iface, member, signature = "", body = () => {
+      }) => new Promise((done, failed) => {
+        const payload2 = new Writer();
+        body(payload2);
+        const header = new Writer(), fields = [[1, "o", path30], [2, "s", iface], [3, "s", member], [6, "s", destination]];
+        if (signature) fields.push([8, "g", signature]);
+        header.byte(108);
+        header.byte(1);
+        header.byte(0);
+        header.byte(1);
+        header.u32(payload2.bytes.length);
+        header.u32(++serial);
+        header.u32(0);
+        const lengthAt = header.bytes.length - 4;
+        header.align(8);
+        const start = header.bytes.length;
+        for (const [code, type, value] of fields) {
+          header.align(8);
+          header.byte(code);
+          header.sig(type);
+          header.put(type, value);
+        }
+        const length = header.bytes.length - start;
+        header.bytes.splice(lengthAt, 4, length & 255, length >>> 8 & 255, length >>> 16 & 255, length >>> 24 & 255);
+        header.align(8);
+        pending.set(serial, (reply) => reply.type === 3 ? failed(Error(reply.errorName ?? "DBUS_ERROR")) : done(reply));
+        connection.write(Buffer.from([...header.bytes, ...payload2.bytes]));
+      });
+      const bus = (member, signature, body) => call("org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", member, signature, body);
+      connection.on("data", (chunk) => {
+        try {
+          receive(chunk);
+        } catch (error62) {
+          fail7(error62);
+        }
+      });
+      const receive = (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        if (buffer.length > 1048576) return fail7(Error("OVERSIZED"));
+        if (!authenticated) {
+          const end = buffer.indexOf("\r\n");
+          if (end < 0) return;
+          const line = buffer.toString("ascii", 0, end);
+          buffer = buffer.subarray(end + 2);
+          if (!line.startsWith("OK ")) return fail7(Error("AUTH"));
+          authenticated = true;
+          connection.write("BEGIN\r\n");
+          void (async () => {
+            const unique = String((await bus("Hello")).body[0]);
+            requestPath = "/org/freedesktop/portal/desktop/request/" + unique.slice(1).replace(/\./g, "_") + "/" + token;
+            await bus("AddMatch", "s", (w) => w.put("s", "type='signal',interface='org.freedesktop.portal.Request',member='Response',path='" + requestPath + "'"));
+            const handle = await call(
+              "org.freedesktop.portal.Desktop",
+              "/org/freedesktop/portal/desktop",
+              "org.freedesktop.portal.Screenshot",
+              "Screenshot",
+              "sa{sv}",
+              (w) => {
+                w.put("s", "");
+                w.dict([["handle_token", ["s", token]], ["interactive", ["b", false]]]);
+              }
+            );
+            if (handle.body[0] !== requestPath) {
+              requestPath = String(handle.body[0]);
+              await bus("AddMatch", "s", (w) => w.put("s", "type='signal',interface='org.freedesktop.portal.Request',member='Response',path='" + requestPath + "'"));
+            }
+          })().catch(fail7);
+        }
+        for (let length = frameLength(buffer); authenticated && length; length = frameLength(buffer)) {
+          const message2 = parse3(buffer.subarray(0, length));
+          buffer = buffer.subarray(length);
+          if ((message2.type === 2 || message2.type === 3) && message2.replySerial !== void 0) {
+            pending.get(message2.replySerial)?.(message2);
+            pending.delete(message2.replySerial);
+          } else if (message2.type === 4 && message2.member === "Response" && message2.path === requestPath && message2.signature === "ua{sv}") {
+            const results2 = message2.body[1], uri = results2.find(([key]) => key === "uri")?.[1];
+            resolve({ code: Number(message2.body[0]), uri: typeof uri === "string" ? uri : void 0 });
+          }
+        }
+      };
+      connection.on("connect", () => connection.write("\0AUTH EXTERNAL " + Buffer.from(String(uid), "ascii").toString("hex") + "\r\n"));
+    });
+  } finally {
+    connection.destroy();
+  }
+}
+
+// agent/src/screen-image.ts
+import { inflateSync } from "node:zlib";
+var MAX_EDGE = 16384;
+var MAX_PIXELS = 67108864;
+function sizeOk(width, height) {
+  return Number.isSafeInteger(width) && Number.isSafeInteger(height) && width > 0 && height > 0 && width <= MAX_EDGE && height <= MAX_EDGE && width * height <= MAX_PIXELS;
+}
+function decodePng(data) {
+  if (data.length < 33 || data.readUInt32BE(0) !== 2303741511 || data.readUInt32BE(4) !== 218765834) return null;
+  let width = 0, height = 0, channels = 0;
+  const idat = [];
+  for (let at = 8; at + 12 <= data.length; ) {
+    const length = data.readUInt32BE(at), type = data.toString("latin1", at + 4, at + 8), body = at + 8;
+    if (body + length + 4 > data.length) return null;
+    if (type === "IHDR") {
+      if (length !== 13) return null;
+      width = data.readUInt32BE(body);
+      height = data.readUInt32BE(body + 4);
+      const depth = data[body + 8], color = data[body + 9], interlace = data[body + 12];
+      channels = color === 0 ? 1 : color === 2 ? 3 : color === 4 ? 2 : color === 6 ? 4 : 0;
+      if (depth !== 8 || !channels || interlace !== 0 || data[body + 10] !== 0 || data[body + 11] !== 0 || !sizeOk(width, height)) return null;
+    } else if (type === "IDAT") idat.push(data.subarray(body, body + length));
+    else if (type === "IEND") break;
+    at = body + length + 4;
+  }
+  if (!channels || !idat.length) return null;
+  const stride = width * channels, expected = (stride + 1) * height;
+  let raw;
+  try {
+    raw = inflateSync(Buffer.concat(idat), { maxOutputLength: expected });
+  } catch {
+    return null;
+  }
+  if (raw.length !== expected) return null;
+  const rgb = Buffer.alloc(width * height * 3);
+  let previous = Buffer.alloc(stride), current2 = Buffer.alloc(stride);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)], line = raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
+    for (let x = 0; x < stride; x++) {
+      const a = x >= channels ? current2[x - channels] : 0, b = previous[x], c = x >= channels ? previous[x - channels] : 0;
+      let value = line[x];
+      if (filter === 1) value += a;
+      else if (filter === 2) value += b;
+      else if (filter === 3) value += a + b >> 1;
+      else if (filter === 4) {
+        const p = a + b - c, pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
+        value += pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+      } else if (filter !== 0) return null;
+      current2[x] = value & 255;
+    }
+    for (let x = 0, o = y * width * 3; x < width; x++, o += 3) {
+      const i = x * channels;
+      if (channels <= 2) rgb[o] = rgb[o + 1] = rgb[o + 2] = current2[i];
+      else {
+        rgb[o] = current2[i];
+        rgb[o + 1] = current2[i + 1];
+        rgb[o + 2] = current2[i + 2];
+      }
+    }
+    [previous, current2] = [current2, previous];
+  }
+  return { width, height, rgb };
+}
+function decodeXwd(data) {
+  if (data.length < 100) return null;
+  const field = (index) => data.readUInt32BE(index * 4);
+  const headerSize = field(0), version2 = field(1), format = field(2), width = field(4), height = field(5), byteOrder = field(7);
+  const bitsPerPixel = field(11), bytesPerLine = field(12), visualClass = field(13), masks = [field(14), field(15), field(16)], colors = field(19);
+  if (version2 !== 7 || format !== 2 || headerSize < 100 || ![4, 5].includes(visualClass) || ![24, 32].includes(bitsPerPixel) || !sizeOk(width, height) || colors > 65536) return null;
+  const pixelBytes = bitsPerPixel / 8, start = headerSize + colors * 12;
+  if (bytesPerLine < width * pixelBytes || start + bytesPerLine * height > data.length || masks.some((mask) => !mask)) return null;
+  const shifts = masks.map((mask) => {
+    let shift = 0;
+    while (!(mask >>> shift & 1)) shift++;
+    return shift;
+  });
+  const scales = masks.map((mask, i) => 255 / (mask >>> shifts[i]));
+  const rgb = Buffer.alloc(width * height * 3);
+  for (let y = 0; y < height; y++) for (let x = 0, at = start + y * bytesPerLine, o = y * width * 3; x < width; x++, at += pixelBytes, o += 3) {
+    const pixel = pixelBytes === 4 ? byteOrder === 0 ? data.readUInt32LE(at) : data.readUInt32BE(at) : byteOrder === 0 ? data[at] | data[at + 1] << 8 | data[at + 2] << 16 : data[at] << 16 | data[at + 1] << 8 | data[at + 2];
+    for (let c = 0; c < 3; c++) rgb[o + c] = Math.round(((pixel & masks[c]) >>> 0 >>> shifts[c]) * scales[c]);
+  }
+  return { width, height, rgb };
+}
+function downscale(image, edge) {
+  const scale = Math.min(1, edge / Math.max(image.width, image.height));
+  if (scale >= 1) return image;
+  const width = Math.max(1, Math.round(image.width * scale)), height = Math.max(1, Math.round(image.height * scale));
+  const xs = Array.from({ length: width + 1 }, (_, x) => Math.min(image.width, Math.floor(x * image.width / width)));
+  const ys = Array.from({ length: height + 1 }, (_, y) => Math.min(image.height, Math.floor(y * image.height / height)));
+  const rgb = Buffer.alloc(width * height * 3), sums = new Float64Array(width * 3);
+  for (let y = 0; y < height; y++) {
+    sums.fill(0);
+    for (let sy = ys[y]; sy < ys[y + 1]; sy++) for (let x = 0; x < width; x++) for (let sx = xs[x]; sx < xs[x + 1]; sx++) {
+      const i = (sy * image.width + sx) * 3;
+      sums[x * 3] = sums[x * 3] + image.rgb[i];
+      sums[x * 3 + 1] = sums[x * 3 + 1] + image.rgb[i + 1];
+      sums[x * 3 + 2] = sums[x * 3 + 2] + image.rgb[i + 2];
+    }
+    for (let x = 0; x < width; x++) {
+      const count3 = (ys[y + 1] - ys[y]) * (xs[x + 1] - xs[x]);
+      for (let c = 0; c < 3; c++) rgb[(y * width + x) * 3 + c] = Math.round(sums[x * 3 + c] / count3);
+    }
+  }
+  return { width, height, rgb };
+}
+var ZIGZAG = [
+  0,
+  1,
+  5,
+  6,
+  14,
+  15,
+  27,
+  28,
+  2,
+  4,
+  7,
+  13,
+  16,
+  26,
+  29,
+  42,
+  3,
+  8,
+  12,
+  17,
+  25,
+  30,
+  41,
+  43,
+  9,
+  11,
+  18,
+  24,
+  31,
+  40,
+  44,
+  53,
+  10,
+  19,
+  23,
+  32,
+  39,
+  45,
+  52,
+  54,
+  20,
+  22,
+  33,
+  38,
+  46,
+  51,
+  55,
+  60,
+  21,
+  34,
+  37,
+  47,
+  50,
+  56,
+  59,
+  61,
+  35,
+  36,
+  48,
+  49,
+  57,
+  58,
+  62,
+  63
+];
+var LUMA_QUANT = [
+  16,
+  11,
+  10,
+  16,
+  24,
+  40,
+  51,
+  61,
+  12,
+  12,
+  14,
+  19,
+  26,
+  58,
+  60,
+  55,
+  14,
+  13,
+  16,
+  24,
+  40,
+  57,
+  69,
+  56,
+  14,
+  17,
+  22,
+  29,
+  51,
+  87,
+  80,
+  62,
+  18,
+  22,
+  37,
+  56,
+  68,
+  109,
+  103,
+  77,
+  24,
+  35,
+  55,
+  64,
+  81,
+  104,
+  113,
+  92,
+  49,
+  64,
+  78,
+  87,
+  103,
+  121,
+  120,
+  101,
+  72,
+  92,
+  95,
+  98,
+  112,
+  100,
+  103,
+  99
+];
+var CHROMA_QUANT = [17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99, 47, 66, ...Array(38).fill(99)];
+var AC_LUMA_VALUES = [
+  1,
+  2,
+  3,
+  0,
+  4,
+  17,
+  5,
+  18,
+  33,
+  49,
+  65,
+  6,
+  19,
+  81,
+  97,
+  7,
+  34,
+  113,
+  20,
+  50,
+  129,
+  145,
+  161,
+  8,
+  35,
+  66,
+  177,
+  193,
+  21,
+  82,
+  209,
+  240,
+  36,
+  51,
+  98,
+  114,
+  130,
+  9,
+  10,
+  22,
+  23,
+  24,
+  25,
+  26,
+  37,
+  38,
+  39,
+  40,
+  41,
+  42,
+  52,
+  53,
+  54,
+  55,
+  56,
+  57,
+  58,
+  67,
+  68,
+  69,
+  70,
+  71,
+  72,
+  73,
+  74,
+  83,
+  84,
+  85,
+  86,
+  87,
+  88,
+  89,
+  90,
+  99,
+  100,
+  101,
+  102,
+  103,
+  104,
+  105,
+  106,
+  115,
+  116,
+  117,
+  118,
+  119,
+  120,
+  121,
+  122,
+  131,
+  132,
+  133,
+  134,
+  135,
+  136,
+  137,
+  138,
+  146,
+  147,
+  148,
+  149,
+  150,
+  151,
+  152,
+  153,
+  154,
+  162,
+  163,
+  164,
+  165,
+  166,
+  167,
+  168,
+  169,
+  170,
+  178,
+  179,
+  180,
+  181,
+  182,
+  183,
+  184,
+  185,
+  186,
+  194,
+  195,
+  196,
+  197,
+  198,
+  199,
+  200,
+  201,
+  202,
+  210,
+  211,
+  212,
+  213,
+  214,
+  215,
+  216,
+  217,
+  218,
+  225,
+  226,
+  227,
+  228,
+  229,
+  230,
+  231,
+  232,
+  233,
+  234,
+  241,
+  242,
+  243,
+  244,
+  245,
+  246,
+  247,
+  248,
+  249,
+  250
+];
+var AC_CHROMA_VALUES = [
+  0,
+  1,
+  2,
+  3,
+  17,
+  4,
+  5,
+  33,
+  49,
+  6,
+  18,
+  65,
+  81,
+  7,
+  97,
+  113,
+  19,
+  34,
+  50,
+  129,
+  8,
+  20,
+  66,
+  145,
+  161,
+  177,
+  193,
+  9,
+  35,
+  51,
+  82,
+  240,
+  21,
+  98,
+  114,
+  209,
+  10,
+  22,
+  36,
+  52,
+  225,
+  37,
+  241,
+  23,
+  24,
+  25,
+  26,
+  38,
+  39,
+  40,
+  41,
+  42,
+  53,
+  54,
+  55,
+  56,
+  57,
+  58,
+  67,
+  68,
+  69,
+  70,
+  71,
+  72,
+  73,
+  74,
+  83,
+  84,
+  85,
+  86,
+  87,
+  88,
+  89,
+  90,
+  99,
+  100,
+  101,
+  102,
+  103,
+  104,
+  105,
+  106,
+  115,
+  116,
+  117,
+  118,
+  119,
+  120,
+  121,
+  122,
+  130,
+  131,
+  132,
+  133,
+  134,
+  135,
+  136,
+  137,
+  138,
+  146,
+  147,
+  148,
+  149,
+  150,
+  151,
+  152,
+  153,
+  154,
+  162,
+  163,
+  164,
+  165,
+  166,
+  167,
+  168,
+  169,
+  170,
+  178,
+  179,
+  180,
+  181,
+  182,
+  183,
+  184,
+  185,
+  186,
+  194,
+  195,
+  196,
+  197,
+  198,
+  199,
+  200,
+  201,
+  202,
+  210,
+  211,
+  212,
+  213,
+  214,
+  215,
+  216,
+  217,
+  218,
+  226,
+  227,
+  228,
+  229,
+  230,
+  231,
+  232,
+  233,
+  234,
+  242,
+  243,
+  244,
+  245,
+  246,
+  247,
+  248,
+  249,
+  250
+];
+var DC_VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+var HUFFMAN = [
+  [0, [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], DC_VALUES],
+  [16, [0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125], AC_LUMA_VALUES],
+  [1, [0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], DC_VALUES],
+  [17, [0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119], AC_CHROMA_VALUES]
+];
+var CODES = HUFFMAN.map(([, counts, values]) => {
+  const table2 = [];
+  let code = 0, at = 0;
+  counts.forEach((count3, index) => {
+    for (let i = 0; i < count3; i++) table2[values[at++]] = [code++, index + 1];
+    code <<= 1;
+  });
+  return table2;
+});
+var AAN = [1, 1.387039845, 1.306562965, 1.175875602, 1, 0.785694958, 0.5411961, 0.275899379];
+function quantTables(quality) {
+  const factor = quality < 50 ? 5e3 / quality : 200 - quality * 2;
+  const scaled = (base) => base.map((value) => Math.min(255, Math.max(1, Math.floor((value * factor + 50) / 100))));
+  const divisors = (table2) => Float64Array.from(table2, (value, k) => 1 / (value * AAN[k >> 3] * AAN[k & 7] * 8));
+  const luma = scaled(LUMA_QUANT), chroma = scaled(CHROMA_QUANT);
+  return { luma, chroma, lumaDivisors: divisors(luma), chromaDivisors: divisors(chroma) };
+}
+var BitWriter = class {
+  buffer = Buffer.alloc(65536);
+  length = 0;
+  bits = 0;
+  count = 0;
+  byte(value) {
+    if (this.length === this.buffer.length) {
+      const next = Buffer.alloc(this.buffer.length * 2);
+      this.buffer.copy(next);
+      this.buffer = next;
+    }
+    this.buffer[this.length++] = value;
+  }
+  bytes(values) {
+    for (const value of values) this.byte(value);
+  }
+  write(code, length) {
+    this.bits = (this.bits << length | code) >>> 0;
+    this.count += length;
+    while (this.count >= 8) {
+      const value = this.bits >>> this.count - 8 & 255;
+      this.byte(value);
+      if (value === 255) this.byte(0);
+      this.count -= 8;
+      this.bits &= (1 << this.count) - 1;
+    }
+  }
+  flush() {
+    if (this.count > 0) this.write((1 << 8 - this.count) - 1, 8 - this.count);
+  }
+  result() {
+    return Buffer.from(this.buffer.subarray(0, this.length));
+  }
+};
+function transform2(block, divisors, out) {
+  for (let pass = 0; pass < 2; pass++) for (let i = 0; i < 8; i++) {
+    const step = pass ? 8 : 1, base = pass ? i : i * 8, at = (k) => base + k * step;
+    const d0 = block[at(0)], d1 = block[at(1)], d2 = block[at(2)], d3 = block[at(3)], d4 = block[at(4)], d5 = block[at(5)], d6 = block[at(6)], d7 = block[at(7)];
+    const t0 = d0 + d7, t7 = d0 - d7, t1 = d1 + d6, t6 = d1 - d6, t2 = d2 + d5, t5 = d2 - d5, t3 = d3 + d4, t4 = d3 - d4;
+    const t10 = t0 + t3, t13 = t0 - t3, t11 = t1 + t2, t12 = t1 - t2;
+    block[at(0)] = t10 + t11;
+    block[at(4)] = t10 - t11;
+    const z1 = (t12 + t13) * 0.707106781;
+    block[at(2)] = t13 + z1;
+    block[at(6)] = t13 - z1;
+    const o10 = t4 + t5, o11 = t5 + t6, o12 = t6 + t7;
+    const z5 = (o10 - o12) * 0.382683433, z2 = 0.5411961 * o10 + z5, z4 = 1.306562965 * o12 + z5, z3 = o11 * 0.707106781;
+    const z11 = t7 + z3, z13 = t7 - z3;
+    block[at(5)] = z13 + z2;
+    block[at(3)] = z13 - z2;
+    block[at(1)] = z11 + z4;
+    block[at(7)] = z11 - z4;
+  }
+  for (let k = 0; k < 64; k++) out[ZIGZAG[k]] = Math.round(block[k] * divisors[k]);
+}
+function magnitude(value) {
+  const absolute2 = Math.abs(value);
+  let length = 0;
+  while (absolute2 >> length) length++;
+  return [value < 0 ? value + (1 << length) - 1 : value, length];
+}
+function encodeJpeg(image, quality) {
+  const { width, height, rgb } = image, tables = quantTables(Math.min(100, Math.max(1, Math.round(quality))));
+  const out = new BitWriter(), word = (value) => [value >> 8, value & 255];
+  out.bytes([255, 216, 255, 224, 0, 16, 74, 70, 73, 70, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0]);
+  out.bytes([255, 219, 0, 132]);
+  for (const [id2, table2] of [[0, tables.luma], [1, tables.chroma]]) {
+    const zig = new Array(64);
+    table2.forEach((value, k) => {
+      zig[ZIGZAG[k]] = value;
+    });
+    out.bytes([id2, ...zig]);
+  }
+  out.bytes([255, 192, 0, 17, 8, ...word(height), ...word(width), 3, 1, 34, 0, 2, 17, 1, 3, 17, 1]);
+  out.bytes([255, 196, ...word(2 + HUFFMAN.reduce((sum, [, , values]) => sum + 17 + values.length, 0))]);
+  for (const [id2, counts, values] of HUFFMAN) out.bytes([id2, ...counts, ...values]);
+  out.bytes([255, 218, 0, 12, 3, 1, 0, 2, 17, 3, 17, 0, 63, 0]);
+  const block = new Float64Array(64), coefficients = new Int32Array(64), dc = [0, 0, 0];
+  const Y = new Float64Array(256), Cb = new Float64Array(256), Cr = new Float64Array(256);
+  const encode5 = (component, divisors) => {
+    transform2(block, divisors, coefficients);
+    const dcCodes = CODES[component ? 2 : 0], acCodes = CODES[component ? 3 : 1];
+    const diff = coefficients[0] - dc[component];
+    dc[component] = coefficients[0];
+    const [bits, size] = magnitude(diff);
+    out.write(...dcCodes[size]);
+    if (size) out.write(bits, size);
+    let last = 63;
+    while (last > 0 && coefficients[last] === 0) last--;
+    for (let k = 1, zeros = 0; k <= last; k++) {
+      if (coefficients[k] === 0) {
+        zeros++;
+        continue;
+      }
+      while (zeros >= 16) {
+        out.write(...acCodes[240]);
+        zeros -= 16;
+      }
+      const [value, length] = magnitude(coefficients[k]);
+      out.write(...acCodes[(zeros << 4) + length]);
+      out.write(value, length);
+      zeros = 0;
+    }
+    if (last < 63) out.write(...acCodes[0]);
+  };
+  for (let my = 0; my < height; my += 16) for (let mx = 0; mx < width; mx += 16) {
+    for (let y = 0; y < 16; y++) for (let x = 0; x < 16; x++) {
+      const i = (Math.min(height - 1, my + y) * width + Math.min(width - 1, mx + x)) * 3, r = rgb[i], g = rgb[i + 1], b = rgb[i + 2];
+      Y[y * 16 + x] = 0.299 * r + 0.587 * g + 0.114 * b - 128;
+      Cb[y * 16 + x] = -0.168736 * r - 0.331264 * g + 0.5 * b;
+      Cr[y * 16 + x] = 0.5 * r - 0.418688 * g - 0.081312 * b;
+    }
+    for (const [ox, oy] of [[0, 0], [8, 0], [0, 8], [8, 8]]) {
+      for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) block[y * 8 + x] = Y[(oy + y) * 16 + ox + x];
+      encode5(0, tables.lumaDivisors);
+    }
+    for (const [component, plane] of [[1, Cb], [2, Cr]]) {
+      for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) {
+        const at = y * 32 + x * 2;
+        block[y * 8 + x] = (plane[at] + plane[at + 1] + plane[at + 16] + plane[at + 17]) / 4;
+      }
+      encode5(component, tables.chromaDivisors);
+    }
+  }
+  out.flush();
+  out.bytes([255, 217]);
+  return out.result();
+}
+function fitJpeg(image, maxEdge, maxBytes) {
+  for (const edge of [maxEdge, 1280, 1024, 800, 640]) {
+    const scaled = downscale(image, edge);
+    for (const quality of [75, 60, 45, 35]) {
+      const data = encodeJpeg(scaled, quality);
+      if (data.length <= maxBytes) return { data, width: scaled.width, height: scaled.height };
+    }
+  }
+  return null;
+}
+
+// agent/src/screen-capture.ts
 var SCREENSHOT_MAX_JPEG_BYTES = 131072;
 var SCREENSHOT_MAX_EDGE = 1568;
 function screenshotEnabled(env = process.env) {
   return env.LC_SCREENSHOT_ENABLED === "true";
 }
 var SCREENSHOT_ACCEPTANCE_FILE = "screenshot-acceptance-enabled";
+var SCREENSHOT_OWNER_OFF_FILE = "screenshot-disabled-by-owner";
 var ScreenCaptureError = class extends Error {
-  constructor(code) {
+  constructor(code, detail) {
     super(code);
     this.code = code;
+    this.detail = detail;
     this.name = "ScreenCaptureError";
   }
   code;
+  detail;
 };
 var KNOWN = /^(SCREEN_UNAVAILABLE|SCREEN_LOCKED|SCREEN_ENCODER_UNAVAILABLE|SCREENSHOT_TOO_LARGE|ARGUMENT_INVALID)$/;
 function jpegSize(data) {
@@ -29397,12 +30407,12 @@ function jpegSize(data) {
   }
   return null;
 }
-function run(file2, args, signal, maxBuffer = 65536) {
+function run(file2, args, signal, maxBuffer = 65536, env = buildChildEnvironment(process.env, process.platform)) {
   return new Promise((resolve, reject) => {
     execFile4(
       file2,
       args,
-      { encoding: "buffer", timeout: 15e3, maxBuffer, windowsHide: true, shell: false, env: buildChildEnvironment(process.env, process.platform), signal },
+      { encoding: "buffer", timeout: 15e3, maxBuffer, windowsHide: true, shell: false, env, signal },
       (error62, stdout, stderr) => error62 ? reject(Object.assign(error62, { stdout, stderr })) : resolve({ stdout, stderr })
     );
   });
@@ -29467,11 +30477,141 @@ async function mac3(signal) {
     });
   }
 }
+var SESSION_KEYS = ["DISPLAY", "WAYLAND_DISPLAY", "XAUTHORITY", "XDG_RUNTIME_DIR", "DBUS_SESSION_BUS_ADDRESS", "XDG_SESSION_TYPE", "XDG_CURRENT_DESKTOP"];
+var SESSION_VALUE = /^[A-Za-z0-9_.:,;=@+/-]{1,256}$/;
+var LINUX_SOURCE_BYTES = 150994944;
+async function linuxTool(name2) {
+  for (const directory of ["/usr/bin", "/bin", "/usr/local/bin"]) {
+    const file2 = path17.posix.join(directory, name2);
+    try {
+      await access3(file2, constants7.X_OK);
+      return file2;
+    } catch {
+    }
+  }
+  return null;
+}
+async function linuxSession(signal) {
+  const session = {}, uid = process.getuid?.();
+  const take = (key, value) => {
+    if (value && !session[key] && SESSION_VALUE.test(value)) session[key] = value;
+  };
+  const base = buildChildEnvironment(process.env, "linux");
+  for (const key of SESSION_KEYS) take(key, process.env[key]);
+  if (!session.DISPLAY && !session.WAYLAND_DISPLAY) {
+    const systemctl = await linuxTool("systemctl");
+    if (systemctl) try {
+      const { stdout } = await run(systemctl, ["--user", "show-environment"], signal, 262144, base);
+      for (const line of stdout.toString("utf8").split("\n")) {
+        const at = line.indexOf("=");
+        if (at > 0 && SESSION_KEYS.includes(line.slice(0, at))) take(line.slice(0, at), line.slice(at + 1));
+      }
+    } catch {
+      if (signal.aborted) throw new ScreenCaptureError("CANCELLED");
+    }
+  }
+  if (uid !== void 0) take("XDG_RUNTIME_DIR", "/run/user/" + uid);
+  if (!session.DISPLAY && !session.WAYLAND_DISPLAY) {
+    if (session.XDG_RUNTIME_DIR) for (const name2 of ["wayland-0", "wayland-1"]) {
+      const socket = await lstat7(path17.posix.join(session.XDG_RUNTIME_DIR, name2)).catch(() => null);
+      if (socket?.isSocket() && socket.uid === uid) {
+        session.WAYLAND_DISPLAY = name2;
+        break;
+      }
+    }
+    if (!session.WAYLAND_DISPLAY) {
+      const servers = [];
+      for (const name2 of await readdir4("/tmp/.X11-unix").catch(() => [])) {
+        const n = /^X(\d{1,4})$/.exec(name2)?.[1], socket = n ? await lstat7("/tmp/.X11-unix/" + name2).catch(() => null) : null;
+        if (n && socket?.isSocket()) servers.push({ n: Number(n), own: socket.uid === uid });
+      }
+      const server = servers.sort((a, b) => Number(b.own) - Number(a.own) || a.n - b.n)[0];
+      if (server) session.DISPLAY = ":" + server.n;
+    }
+  }
+  if (session.DISPLAY && !session.XAUTHORITY) {
+    const file2 = path17.posix.join(os4.homedir(), ".Xauthority");
+    if ((await lstat7(file2).catch(() => null))?.isFile()) take("XAUTHORITY", file2);
+  }
+  if (session.XDG_RUNTIME_DIR) take("DBUS_SESSION_BUS_ADDRESS", "unix:path=" + session.XDG_RUNTIME_DIR + "/bus");
+  const wayland = !!session.WAYLAND_DISPLAY || session.XDG_SESSION_TYPE === "wayland";
+  return { env: { ...base, ...session }, wayland, x11: !wayland && !!session.DISPLAY };
+}
+async function busSocket(env) {
+  const socket = sessionBusSocket(env.DBUS_SESSION_BUS_ADDRESS);
+  if (!socket || socket.startsWith("\0")) return socket;
+  return (await lstat7(socket).catch(() => null))?.isSocket() ? socket : null;
+}
+async function portalCapture(socket, signal) {
+  const token = "lc" + randomBytes6(8).toString("hex"), started = Date.now(), uid = process.getuid?.();
+  if (uid === void 0) throw new ScreenCaptureError("SCREEN_UNAVAILABLE");
+  let answer;
+  try {
+    answer = await portalScreenshot(socket, uid, token, AbortSignal.any([signal, AbortSignal.timeout(3e4)]));
+  } catch {
+    throw new ScreenCaptureError(signal.aborted ? "CANCELLED" : "SCREEN_UNAVAILABLE");
+  }
+  const { code, uri } = answer;
+  if (code === 1) throw new ScreenCaptureError("SCREEN_RECORDING_PERMISSION_REQUIRED");
+  if (code !== 0 || !uri?.startsWith("file://")) throw new ScreenCaptureError("SCREEN_UNAVAILABLE");
+  const file2 = decodeURIComponent(new URL(uri).pathname), info = await lstat7(file2);
+  const fresh = info.isFile() && info.uid === uid && info.mtimeMs >= started - 5e3;
+  try {
+    if (!fresh || info.size > LINUX_SOURCE_BYTES) throw new ScreenCaptureError("SCREEN_UNAVAILABLE");
+    return await readFile6(file2);
+  } finally {
+    if (fresh) await unlink2(file2).catch(() => {
+    });
+  }
+}
+async function linux(signal) {
+  const session = await linuxSession(signal);
+  if (!session.wayland && !session.x11) throw new ScreenCaptureError("SCREENSHOT_UNSUPPORTED", { reason: "NO_DISPLAY" });
+  const output2 = (args) => async (tool) => (await run(tool, args, signal, LINUX_SOURCE_BYTES, session.env)).stdout;
+  const portal = (socket) => portalCapture(socket, signal);
+  const methods = session.wayland ? [["grim", "grim", output2(["-t", "png", "-"])], ["portal", "", portal]] : [
+    ["xwd", "xwd", output2(["-root", "-silent"])],
+    ["import", "import", output2(["-silent", "-window", "root", "png:-"])],
+    ["maim", "maim", output2(["-f", "png"])],
+    ["portal", "", portal]
+  ];
+  const tried = [];
+  for (const [name2, program, capture2] of methods) {
+    const tool = program ? await linuxTool(program) : await busSocket(session.env);
+    if (!tool) {
+      tried.push(name2 + ":missing");
+      continue;
+    }
+    let image;
+    try {
+      const source = await capture2(tool);
+      image = decodePng(source) ?? decodeXwd(source);
+    } catch (error62) {
+      if (signal.aborted) throw new ScreenCaptureError("CANCELLED");
+      if (error62 instanceof ScreenCaptureError && error62.code === "SCREEN_RECORDING_PERMISSION_REQUIRED") throw error62;
+      tried.push(name2 + ":failed");
+      continue;
+    }
+    if (!image) {
+      tried.push(name2 + ":unreadable");
+      continue;
+    }
+    const fitted = fitJpeg(image, SCREENSHOT_MAX_EDGE, SCREENSHOT_MAX_JPEG_BYTES);
+    if (!fitted) throw new ScreenCaptureError("SCREENSHOT_TOO_LARGE");
+    return { ...fitted, sourceWidth: image.width, sourceHeight: image.height };
+  }
+  throw new ScreenCaptureError("SCREENSHOT_UNSUPPORTED", {
+    reason: tried.every((entry) => entry.endsWith(":missing")) ? "NO_CAPTURE_TOOL" : "CAPTURE_FAILED",
+    session: session.wayland ? "wayland" : "x11",
+    tried
+  });
+}
 async function captureScreen(options) {
   if (options.signal.aborted) throw new ScreenCaptureError("CANCELLED");
   if (process.platform === "win32") return windows(options.ownerBridgePath, options.signal);
   if (process.platform === "darwin") return mac3(options.signal);
-  throw new ScreenCaptureError("SCREENSHOT_UNSUPPORTED");
+  if (process.platform === "linux") return linux(options.signal);
+  throw new ScreenCaptureError("SCREENSHOT_UNSUPPORTED", { reason: "PLATFORM_UNSUPPORTED" });
 }
 
 // agent/src/tools.ts
@@ -29504,7 +30644,7 @@ function stopped(signal) {
   if (signal.aborted) fail3("CANCELLED");
 }
 async function readBoundedFile(file2, maxBytes, bridge, signal) {
-  const stat2 = await lstat7(file2);
+  const stat2 = await lstat8(file2);
   if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.size > maxBytes) fail3("FILE_UNSUPPORTED_OR_TOO_LARGE");
   if (process.platform === "win32") {
     if (maxBytes <= 1048576 || stat2.size <= 1048576) return readWindowsFile(bridge, file2, Math.min(maxBytes, 1048576), signal);
@@ -29512,7 +30652,7 @@ async function readBoundedFile(file2, maxBytes, bridge, signal) {
     if (read.truncated) fail3("FILE_UNSUPPORTED_OR_TOO_LARGE");
     return read.data;
   }
-  const handle = await open6(file2, constants7.O_RDONLY | (constants7.O_NOFOLLOW ?? 0));
+  const handle = await open6(file2, constants8.O_RDONLY | (constants8.O_NOFOLLOW ?? 0));
   try {
     const current2 = await handle.stat();
     if (!current2.isFile() || current2.size > maxBytes) fail3("FILE_UNSUPPORTED_OR_TOO_LARGE");
@@ -29767,7 +30907,7 @@ var NativeTools = class {
         }
         if (bytes3.length > MAX_FILE_WRITE_BYTES) fail3("FILE_WRITE_LIMIT");
         const temp = path18.join(path18.dirname(target), ".lc-write-" + randomUUID7() + ".tmp");
-        const handle = await open6(temp, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
+        const handle = await open6(temp, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
         try {
           await handle.writeFile(bytes3);
           await handle.sync();
@@ -29783,7 +30923,7 @@ var NativeTools = class {
                 break;
               } catch (error62) {
                 if (process.platform !== "win32" || !["EPERM", "EBUSY", "EACCES"].includes(error62.code ?? "")) throw error62;
-                if (attempt === 4) fail3((await lstat7(target)).mode & 128 ? "FILE_IN_USE" : "FILE_READ_ONLY");
+                if (attempt === 4) fail3((await lstat8(target)).mode & 128 ? "FILE_IN_USE" : "FILE_READ_ONLY");
                 await delay2(50 << attempt);
                 stopped(signal);
               }
@@ -29899,14 +31039,26 @@ var NativeTools = class {
       } };
     }
     if (call.name === "take_screenshot") {
-      if (!screenshotEnabled() && !await lstat7(path18.join(this.options.stateDirectory, SCREENSHOT_ACCEPTANCE_FILE)).then((s) => s.isFile(), () => false)) fail3("SCREENSHOT_DISABLED");
+      if (!screenshotEnabled() && !await lstat8(path18.join(this.options.stateDirectory, SCREENSHOT_ACCEPTANCE_FILE)).then((s) => s.isFile(), () => false)) fail3("SCREENSHOT_DISABLED");
       if (!workspace2.fullAccess) fail3("FULL_ACCESS_REQUIRED");
+      if (await lstat8(path18.join(this.options.stateDirectory, SCREENSHOT_OWNER_OFF_FILE)).then(() => true, (error62) => error62.code !== "ENOENT")) fail3("SCREENSHOT_DISABLED_BY_OWNER");
       const bridge = this.options.ownerBridgePath ?? path18.join(path18.dirname(this.options.helperPath), "OwnerBridge.exe");
       return { call, claims: [{ path: path18.join(this.options.stateDirectory, "screen-capture"), mode: "read" }], run: async (signal) => {
         let shot;
         try {
           shot = await captureScreen({ ownerBridgePath: bridge, signal });
         } catch (error62) {
+          if (error62 instanceof ScreenCaptureError && error62.detail) return {
+            exitCode: 1,
+            timedOut: false,
+            cancelled: false,
+            treeTerminated: true,
+            stdout: JSON.stringify({ type: "screenshot_error", resultCode: error62.code, ...error62.detail }),
+            stderr: "",
+            stdoutTruncated: false,
+            stderrTruncated: false,
+            resultCode: error62.code
+          };
           fail3(error62 instanceof Error && /^[A-Z_]{1,40}$/.test(error62.message) ? error62.message : "SCREEN_UNAVAILABLE");
         }
         return result({
@@ -30070,7 +31222,7 @@ var NativeTools = class {
       )?.file : void 0);
       if (!candidate || !path18.isAbsolute(candidate)) fail3("COMMAND_NOT_FOUND");
       const executable = await realpath7(candidate).catch(() => fail3("COMMAND_NOT_FOUND"));
-      if (!(await lstat7(executable)).isFile()) fail3("COMMAND_NOT_FOUND");
+      if (!(await lstat8(executable)).isFile()) fail3("COMMAND_NOT_FOUND");
       if (denied.has(commandKey(executable))) fail3("COMMAND_NOT_ALLOWED");
       for (const key of workspace2.deniedCommands ?? []) {
         const configured = this.options.programs[key]?.executable;
@@ -30112,7 +31264,7 @@ var NativeTools = class {
       const candidate = process.platform === "win32" ? source : await resolvePosixExecutable(source);
       if (!candidate) continue;
       try {
-        const stat2 = await lstat7(candidate);
+        const stat2 = await lstat8(candidate);
         if (!stat2.isFile() || stat2.isSymbolicLink() || !equalPath3(candidate, await realpath7(candidate))) continue;
       } catch {
         continue;
@@ -30130,7 +31282,7 @@ var NativeTools = class {
       const current2 = queue.shift();
       let names;
       try {
-        names = await readdir4(current2.path, { withFileTypes: true });
+        names = await readdir5(current2.path, { withFileTypes: true });
       } catch (error62) {
         if (current2.level === 0) throw error62;
         continue;
@@ -30155,7 +31307,7 @@ var NativeTools = class {
           entries.push({ path: path18.relative(root, resolved), type: "directory" });
           if (current2.level < depth) queue.push({ path: resolved, level: current2.level + 1 });
         } else if (item.isFile()) {
-          const stat2 = await lstat7(resolved).catch(() => null);
+          const stat2 = await lstat8(resolved).catch(() => null);
           if (stat2) entries.push({ path: path18.relative(root, resolved), type: "file", size: stat2.size });
         }
       }
@@ -30168,7 +31320,7 @@ var NativeTools = class {
     while (guard.isWithin(directory, workspace2.root)) {
       const dotGit = path18.join(directory, ".git");
       try {
-        const stat2 = await lstat7(dotGit);
+        const stat2 = await lstat8(dotGit);
         if (stat2.isSymbolicLink()) fail3("GIT_METADATA_CHANGED");
         let gitDir;
         if (stat2.isDirectory()) gitDir = await realpath7(dotGit);
@@ -30186,7 +31338,7 @@ var NativeTools = class {
         } catch (e) {
           if (e.code !== "ENOENT") throw e;
         }
-        if (!(await lstat7(common)).isDirectory() || guard.isWithin(common, this.options.stateDirectory)) fail3("GIT_METADATA_CHANGED");
+        if (!(await lstat8(common)).isDirectory() || guard.isWithin(common, this.options.stateDirectory)) fail3("GIT_METADATA_CHANGED");
         if (!guard.isWithin(common, workspace2.root) && (!workspace2.gitCommonDir || !equalPath3(common, workspace2.gitCommonDir))) fail3("GIT_COMMON_DIRECTORY_NOT_APPROVED");
         return common;
       } catch (e) {
@@ -30942,7 +32094,45 @@ function journalBinding(entry, binding2) {
 function journalResult(value, code) {
   return { ...value, resultCode: code ?? (value.treeTerminated ? value.cancelled ? "CANCELLED" : value.timedOut ? "TIMEOUT" : value.exitCode === 0 ? "SUCCESS" : "USER_PROGRAM_FAILED" : "EXECUTION_UNKNOWN") };
 }
-var knownCodes = /* @__PURE__ */ new Set(["PROJECT_IDENTITY_UNKNOWN", "PROJECT_IDENTITY_MISMATCH", "INVALID_TOOL_ARGUMENTS", "LOCAL_PERMISSION_REQUIRED", "PATH_NOT_ALLOWED", "FILE_CHANGED", "FILE_NOT_FOUND", "FILE_ALREADY_EXISTS", "REPLACEMENT_NOT_UNIQUE", "OUTPUT_LIMIT_EXCEEDED", "BINARY_FILE_NOT_SUPPORTED", "FILE_UNSUPPORTED_OR_TOO_LARGE", "INVALID_LINE_RANGE", "FILE_IN_USE", "FILE_READ_ONLY", "FILE_WRITE_LIMIT", "GIT_METADATA_CHANGED", "GIT_COMMON_DIRECTORY_NOT_APPROVED", "GIT_NOT_INSTALLED", "LOCALHOST_NOT_ALLOWED", "COMMAND_NOT_ALLOWED", "WORKSPACE_CHANGED", "WORKSPACE_UNAVAILABLE", "RESOURCE_BUSY", "AGENT_PAUSED", "CANCELLED_BEFORE_ACCEPTANCE", "ADMISSION_DEADLINE_EXPIRED"]);
+var knownCodes = /* @__PURE__ */ new Set([
+  "PROJECT_IDENTITY_UNKNOWN",
+  "PROJECT_IDENTITY_MISMATCH",
+  "INVALID_TOOL_ARGUMENTS",
+  "LOCAL_PERMISSION_REQUIRED",
+  "PATH_NOT_ALLOWED",
+  "FILE_CHANGED",
+  "FILE_NOT_FOUND",
+  "FILE_ALREADY_EXISTS",
+  "REPLACEMENT_NOT_UNIQUE",
+  "OUTPUT_LIMIT_EXCEEDED",
+  "BINARY_FILE_NOT_SUPPORTED",
+  "FILE_UNSUPPORTED_OR_TOO_LARGE",
+  "INVALID_LINE_RANGE",
+  "FILE_IN_USE",
+  "FILE_READ_ONLY",
+  "FILE_WRITE_LIMIT",
+  "GIT_METADATA_CHANGED",
+  "GIT_COMMON_DIRECTORY_NOT_APPROVED",
+  "GIT_NOT_INSTALLED",
+  "LOCALHOST_NOT_ALLOWED",
+  "COMMAND_NOT_ALLOWED",
+  "WORKSPACE_CHANGED",
+  "WORKSPACE_UNAVAILABLE",
+  "RESOURCE_BUSY",
+  "AGENT_PAUSED",
+  "CANCELLED_BEFORE_ACCEPTANCE",
+  "ADMISSION_DEADLINE_EXPIRED",
+  // take_screenshot refusals (#434, #486): without these the client sees TOOL_FAILED.
+  "FULL_ACCESS_REQUIRED",
+  "SCREENSHOT_DISABLED",
+  "SCREENSHOT_DISABLED_BY_OWNER",
+  "SCREENSHOT_UNSUPPORTED",
+  "SCREENSHOT_TOO_LARGE",
+  "SCREEN_UNAVAILABLE",
+  "SCREEN_LOCKED",
+  "SCREEN_ENCODER_UNAVAILABLE",
+  "SCREEN_RECORDING_PERMISSION_REQUIRED"
+]);
 function safeCode(error62) {
   const code = error62 instanceof NativeToolError ? error62.code : error62 instanceof Error ? error62.message : "";
   return knownCodes.has(code) || /^GUARD_[A-Z_]{1,30}$/.test(code) ? code : "TOOL_FAILED";
@@ -31375,9 +32565,9 @@ var NativeRelayBridge = class {
 };
 
 // agent/src/local-direct.ts
-import net from "node:net";
+import net2 from "node:net";
 import path20 from "node:path";
-import { createHmac as createHmac2, hkdfSync, randomBytes as randomBytes6, randomUUID as randomUUID8, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
+import { createHmac as createHmac2, hkdfSync, randomBytes as randomBytes7, randomUUID as randomUUID8, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
 import { mkdir as mkdir7, readFile as readFile8, rename as rename5, rm as rm7, writeFile as writeFile3 } from "node:fs/promises";
 var LocalDirectError = class extends Error {
   constructor(code) {
@@ -31414,7 +32604,7 @@ function sameProof(candidate, expected) {
   const a = Buffer.from(candidate), b = Buffer.from(expected);
   return a.length === b.length && timingSafeEqual3(a, b);
 }
-var nonce = () => randomBytes6(32).toString("base64url");
+var nonce = () => randomBytes7(32).toString("base64url");
 var NONCE = /^[A-Za-z0-9_-]{43}$/;
 function codeOf(error62) {
   const code = error62 instanceof NativeToolError || error62 instanceof LocalDirectError ? error62.code : error62 instanceof Error ? error62.message : "";
@@ -31496,7 +32686,7 @@ var LocalDirectServer = class _LocalDirectServer {
       });
       return null;
     }
-    const server = net.createServer(), self = new _LocalDirectServer(server, options);
+    const server = net2.createServer(), self = new _LocalDirectServer(server, options);
     server.on("connection", (socket) => self.accept(socket));
     await new Promise((resolve, reject) => {
       server.once("error", reject);
@@ -31653,7 +32843,7 @@ var LocalDirectClient = class _LocalDirectClient {
   static async connect(options) {
     if (!await localDirectEnabled(options.directory)) fail4("LOCAL_ACCESS_DISABLED");
     const endpoint2 = await readEndpoint(options.directory);
-    const socket = net.createConnection({ host: "127.0.0.1", port: endpoint2.port });
+    const socket = net2.createConnection({ host: "127.0.0.1", port: endpoint2.port });
     let handler = () => {
     };
     const lines = new Lines(socket, (frame) => handler(frame));
@@ -37176,8 +38366,8 @@ var require_content_type = /* @__PURE__ */ __commonJSMin(((exports) => {
   var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
   var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
   var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-  exports.parse = parse3;
-  function parse3(string4) {
+  exports.parse = parse4;
+  function parse4(string4) {
     if (!string4) throw new TypeError("argument string is required");
     var header = typeof string4 === "object" ? getcontenttype(string4) : string4;
     if (typeof header !== "string") throw new TypeError("argument string is required to be a string");
@@ -37701,9 +38891,9 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants10) {
+    optimizeNames(names, constants11) {
       if (!names[this.name.str]) return;
-      if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants10);
+      if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants11);
       return this;
     }
     get names() {
@@ -37720,9 +38910,9 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants10) {
+    optimizeNames(names, constants11) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) return;
-      this.rhs = optimizeExpr(this.rhs, names, constants10);
+      this.rhs = optimizeExpr(this.rhs, names, constants11);
       return this;
     }
     get names() {
@@ -37781,8 +38971,8 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
     optimizeNodes() {
       return `${this.code}` ? this : void 0;
     }
-    optimizeNames(names, constants10) {
-      this.code = optimizeExpr(this.code, names, constants10);
+    optimizeNames(names, constants11) {
+      this.code = optimizeExpr(this.code, names, constants11);
       return this;
     }
     get names() {
@@ -37808,12 +38998,12 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       }
       return nodes.length > 0 ? this : void 0;
     }
-    optimizeNames(names, constants10) {
+    optimizeNames(names, constants11) {
       const { nodes } = this;
       let i = nodes.length;
       while (i--) {
         const n = nodes[i];
-        if (n.optimizeNames(names, constants10)) continue;
+        if (n.optimizeNames(names, constants11)) continue;
         subtractNames(names, n.names);
         nodes.splice(i, 1);
       }
@@ -37860,11 +39050,11 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       if (cond === false || !this.nodes.length) return void 0;
       return this;
     }
-    optimizeNames(names, constants10) {
+    optimizeNames(names, constants11) {
       var _a3;
-      this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants10);
-      if (!(super.optimizeNames(names, constants10) || this.else)) return;
-      this.condition = optimizeExpr(this.condition, names, constants10);
+      this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants11);
+      if (!(super.optimizeNames(names, constants11) || this.else)) return;
+      this.condition = optimizeExpr(this.condition, names, constants11);
       return this;
     }
     get names() {
@@ -37886,9 +39076,9 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants10) {
-      if (!super.optimizeNames(names, constants10)) return;
-      this.iteration = optimizeExpr(this.iteration, names, constants10);
+    optimizeNames(names, constants11) {
+      if (!super.optimizeNames(names, constants11)) return;
+      this.iteration = optimizeExpr(this.iteration, names, constants11);
       return this;
     }
     get names() {
@@ -37923,9 +39113,9 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants10) {
-      if (!super.optimizeNames(names, constants10)) return;
-      this.iterable = optimizeExpr(this.iterable, names, constants10);
+    optimizeNames(names, constants11) {
+      if (!super.optimizeNames(names, constants11)) return;
+      this.iterable = optimizeExpr(this.iterable, names, constants11);
       return this;
     }
     get names() {
@@ -37964,11 +39154,11 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       (_b = this.finally) === null || _b === void 0 || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants10) {
+    optimizeNames(names, constants11) {
       var _a3, _b;
-      super.optimizeNames(names, constants10);
-      (_a3 = this.catch) === null || _a3 === void 0 || _a3.optimizeNames(names, constants10);
-      (_b = this.finally) === null || _b === void 0 || _b.optimizeNames(names, constants10);
+      super.optimizeNames(names, constants11);
+      (_a3 = this.catch) === null || _a3 === void 0 || _a3.optimizeNames(names, constants11);
+      (_b = this.finally) === null || _b === void 0 || _b.optimizeNames(names, constants11);
       return this;
     }
     get names() {
@@ -38217,7 +39407,7 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
   function addExprNames(names, from) {
     return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
   }
-  function optimizeExpr(expr, names, constants10) {
+  function optimizeExpr(expr, names, constants11) {
     if (expr instanceof code_1.Name) return replaceName(expr);
     if (!canOptimize(expr)) return expr;
     return new code_1._Code(expr._items.reduce((items, c) => {
@@ -38227,13 +39417,13 @@ var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
       return items;
     }, []));
     function replaceName(n) {
-      const c = constants10[n.str];
+      const c = constants11[n.str];
       if (c === void 0 || names[n.str] !== 1) return n;
       delete names[n.str];
       return c;
     }
     function canOptimize(e) {
-      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants10[c.str] !== void 0);
+      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants11[c.str] !== void 0);
     }
   }
   function subtractNames(names, from) {
@@ -40365,21 +41555,21 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
   const { SCHEMES, getSchemeHandler } = require_schemes();
   function normalize(uri, options) {
-    if (typeof uri === "string") uri = serialize(parse3(uri, options), options);
-    else if (typeof uri === "object") uri = parse3(serialize(uri, options), options);
+    if (typeof uri === "string") uri = serialize(parse4(uri, options), options);
+    else if (typeof uri === "object") uri = parse4(serialize(uri, options), options);
     return uri;
   }
   function resolve(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
+    const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
   function resolveComponent(base, relative, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
-      base = parse3(serialize(base, options), options);
-      relative = parse3(serialize(relative, options), options);
+      base = parse4(serialize(base, options), options);
+      relative = parse4(serialize(relative, options), options);
     }
     options = options || {};
     if (!options.tolerant && relative.scheme) {
@@ -40423,7 +41613,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   function equal(uriA, uriB, options) {
     if (typeof uriA === "string") {
       uriA = unescape(uriA);
-      uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), {
+      uriA = serialize(normalizeComponentEncoding(parse4(uriA, options), true), {
         ...options,
         skipEscape: true
       });
@@ -40433,7 +41623,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     });
     if (typeof uriB === "string") {
       uriB = unescape(uriB);
-      uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), {
+      uriB = serialize(normalizeComponentEncoding(parse4(uriB, options), true), {
         ...options,
         skipEscape: true
       });
@@ -40486,7 +41676,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     return uriTokens.join("");
   }
   const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-  function parse3(uri, opts) {
+  function parse4(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
       scheme: void 0,
@@ -40547,7 +41737,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     resolveComponent,
     equal,
     serialize,
-    parse: parse3
+    parse: parse4
   };
   module.exports = fastUri;
   module.exports.default = fastUri;
@@ -45827,7 +47017,7 @@ var DESCRIPTIONS = {
   git_log: ["Recent Git commits of the repository at a workspace-relative path.", { readOnlyHint: true, openWorldHint: false }],
   project_snapshot: ["Compact project overview: Git state and, with startup, AGENTS.md policy and task continuation.", { readOnlyHint: true, openWorldHint: false }],
   command_run: ["Run one executable with an argument array (no shell parsing), hidden, with captured output. Uses this user account's rights within the owner's grant.", { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }],
-  take_screenshot: ["Take a still image of this computer's primary screen, returned as a JPEG image. Needs a Full Access workspace; the lock screen is never captured.", { readOnlyHint: true, openWorldHint: false }],
+  take_screenshot: ["Take a still image of this computer's primary screen, returned as a JPEG image. It contains everything visible on the screen, including any open passwords, keys or private messages. Needs a Full Access workspace; the lock screen is never captured.", { readOnlyHint: true, openWorldHint: false }],
   localhost_request: ["HTTP request to a service on this computer (localhost only).", { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }]
 };
 var workspace = external_exports.string().min(1).max(4096).optional().describe("Workspace grant id, root path (for example D:\\) or display name from workspace_list. Optional when only one workspace is approved.");
@@ -46349,6 +47539,7 @@ async function connectOnce(options) {
     const incidents = Array.isArray(readyFrame.capabilities) && readyFrame.capabilities.includes("incidentBatchV1");
     const monitorHeartbeat = Array.isArray(readyFrame.capabilities) && readyFrame.capabilities.includes("monitorHeartbeatV1") && typeof readyFrame.heartbeatMs === "number" && Number.isInteger(readyFrame.heartbeatMs) && readyFrame.heartbeatMs >= 1e3 && readyFrame.heartbeatMs <= 6e4 ? readyFrame.heartbeatMs : void 0;
     const nativeStatus = Array.isArray(readyFrame.capabilities) && readyFrame.capabilities.includes(NATIVE_STATUS_CAPABILITY) && options.status;
+    const accessModes = Array.isArray(readyFrame.capabilities) && readyFrame.capabilities.includes(WORKSPACE_ACCESS_MODE_CAPABILITY);
     const reportStatus = () => {
       if (!nativeStatus) return;
       const { safeSlots, active, queued, paused } = nativeStatus();
@@ -46575,7 +47766,16 @@ async function connectOnce(options) {
       registerWorkspace: (workspace2) => {
         if (pendingWorkspace.size >= 32) return Promise.reject(new RelayClientError("RELAY_PENDING_LIMIT"));
         const requestId = randomUUID10();
-        const event = { type: "workspace_grant", version: 1, requestId, workspaceGrantId: workspace2.workspaceGrantId, rootHash: workspace2.rootHash, displayName: workspace2.displayName, policyVersion: workspace2.policyVersion };
+        const event = {
+          type: "workspace_grant",
+          version: 1,
+          requestId,
+          workspaceGrantId: workspace2.workspaceGrantId,
+          rootHash: workspace2.rootHash,
+          displayName: workspace2.displayName,
+          policyVersion: workspace2.policyVersion,
+          ...accessModes ? { accessMode: workspace2.fullAccess === true ? "full" : "scoped" } : {}
+        };
         return new Promise((resolve, reject) => {
           const timer = setTimeout(() => {
             pendingWorkspace.delete(requestId);
@@ -46624,14 +47824,14 @@ import { spawn as spawn5 } from "node:child_process";
 import { createHash as createHash16 } from "node:crypto";
 import os6 from "node:os";
 import { open as open7 } from "node:fs/promises";
-import { constants as constants8 } from "node:fs";
+import { constants as constants9 } from "node:fs";
 import path21 from "node:path";
 var MACHINE_GUID = /^\s*MachineGuid\s+REG_SZ\s+([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\s*$/m;
 async function readMachineGuid(timeoutMs2 = 5e3) {
   if (process.platform === "linux") {
     let handle;
     try {
-      handle = await open7("/etc/machine-id", constants8.O_RDONLY | constants8.O_NOFOLLOW);
+      handle = await open7("/etc/machine-id", constants9.O_RDONLY | constants9.O_NOFOLLOW);
       const stat2 = await handle.stat();
       if (!stat2.isFile() || stat2.size > 128) return null;
       const data = Buffer.alloc(129);
@@ -46680,7 +47880,7 @@ async function readComputerName(timeoutMs2 = 5e3) {
   if (process.platform === "linux") {
     let handle;
     try {
-      handle = await open7("/etc/hostname", constants8.O_RDONLY | constants8.O_NOFOLLOW);
+      handle = await open7("/etc/hostname", constants9.O_RDONLY | constants9.O_NOFOLLOW);
       const data = Buffer.alloc(257), { bytesRead } = await handle.read(data, 0, data.length, 0);
       const name2 = data.subarray(0, bytesRead).toString("utf8").trim();
       if (bytesRead <= 256 && valid(name2)) return name2;
@@ -47263,8 +48463,8 @@ async function deliverGuardEvidence(target, packet, options = {}) {
 }
 
 // agent/src/optimization-ledger.ts
-import { constants as constants9 } from "node:fs";
-import { lstat as lstat8, mkdir as mkdir8, open as open8, readFile as readFile9, realpath as realpath8 } from "node:fs/promises";
+import { constants as constants10 } from "node:fs";
+import { lstat as lstat9, mkdir as mkdir8, open as open8, readFile as readFile9, realpath as realpath8 } from "node:fs/promises";
 import path22 from "node:path";
 var MAX_LEDGER_BYTES = 64 * 1024 * 1024;
 var MAX_NOTICE_LEDGER_BYTES = 8 * 1024 * 1024;
@@ -47276,7 +48476,7 @@ async function safeDirectory2(directory) {
   let current2 = absolute2;
   for (; ; ) {
     try {
-      if ((await lstat8(current2)).isSymbolicLink()) throw failure5("OPTIMIZATION_LEDGER_DIRECTORY_INVALID");
+      if ((await lstat9(current2)).isSymbolicLink()) throw failure5("OPTIMIZATION_LEDGER_DIRECTORY_INVALID");
     } catch (error62) {
       if (error62.code !== "ENOENT") throw error62;
     }
@@ -47285,7 +48485,7 @@ async function safeDirectory2(directory) {
     current2 = parent;
   }
   await mkdir8(absolute2, { recursive: true, mode: 448 });
-  const stat2 = await lstat8(absolute2);
+  const stat2 = await lstat9(absolute2);
   if (!stat2.isDirectory() || stat2.isSymbolicLink()) throw failure5("OPTIMIZATION_LEDGER_DIRECTORY_INVALID");
   return realpath8(absolute2);
 }
@@ -47319,7 +48519,7 @@ var OptimizationLedger = class _OptimizationLedger {
     const noticesFilename = path22.join(dir, "live-efficiency-notices.v1.jsonl");
     let existing = "";
     try {
-      const stat2 = await lstat8(filename);
+      const stat2 = await lstat9(filename);
       if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.size > MAX_LEDGER_BYTES) {
         throw failure5("OPTIMIZATION_LEDGER_INVALID");
       }
@@ -47329,13 +48529,13 @@ var OptimizationLedger = class _OptimizationLedger {
     }
     const handle = await open8(
       filename,
-      constants9.O_CREAT | constants9.O_APPEND | constants9.O_WRONLY | (constants9.O_NOFOLLOW ?? 0),
+      constants10.O_CREAT | constants10.O_APPEND | constants10.O_WRONLY | (constants10.O_NOFOLLOW ?? 0),
       384
     );
     const ledger = new _OptimizationLedger(filename, handle, noticesFilename);
     try {
       try {
-        const noticeStat = await lstat8(noticesFilename);
+        const noticeStat = await lstat9(noticesFilename);
         if (!noticeStat.isFile() || noticeStat.isSymbolicLink() || noticeStat.size > MAX_NOTICE_LEDGER_BYTES) throw failure5("OPTIMIZATION_NOTICE_LEDGER_INVALID");
         const notices = await readFile9(noticesFilename, "utf8");
         for (const line of notices.split("\n")) {
@@ -47417,7 +48617,7 @@ var OptimizationLedger = class _OptimizationLedger {
       const marker = JSON.stringify({ sessionId: event.sessionId, checkpointCalls, deliveredAt: (/* @__PURE__ */ new Date()).toISOString() }) + "\n";
       let currentBytes = 0;
       try {
-        const stat2 = await lstat8(this.noticesFilename);
+        const stat2 = await lstat9(this.noticesFilename);
         if (!stat2.isFile() || stat2.isSymbolicLink()) throw failure5("OPTIMIZATION_NOTICE_LEDGER_INVALID");
         currentBytes = stat2.size;
       } catch (error62) {
@@ -47426,7 +48626,7 @@ var OptimizationLedger = class _OptimizationLedger {
       if (currentBytes + Buffer.byteLength(marker, "utf8") > MAX_NOTICE_LEDGER_BYTES) throw failure5("OPTIMIZATION_NOTICE_LEDGER_CAPACITY_EXCEEDED");
       const markerHandle = await open8(
         this.noticesFilename,
-        constants9.O_CREAT | constants9.O_APPEND | constants9.O_WRONLY | (constants9.O_NOFOLLOW ?? 0),
+        constants10.O_CREAT | constants10.O_APPEND | constants10.O_WRONLY | (constants10.O_NOFOLLOW ?? 0),
         384
       );
       try {
@@ -47465,7 +48665,7 @@ var OptimizationLedger = class _OptimizationLedger {
 
 // agent/src/monitor.ts
 import { createHash as createHash17, randomUUID as randomUUID12 } from "node:crypto";
-import { lstat as lstat9, mkdir as mkdir9, open as open9, rename as rename6, rm as rm8 } from "node:fs/promises";
+import { lstat as lstat10, mkdir as mkdir9, open as open9, rename as rename6, rm as rm8 } from "node:fs/promises";
 import path23 from "node:path";
 import os7 from "node:os";
 
@@ -47732,7 +48932,7 @@ var ProductionMonitor = class {
   async write(file2, contents) {
     const directory = path23.dirname(file2);
     await mkdir9(directory, { recursive: true, mode: 448 });
-    const stat2 = await lstat9(directory);
+    const stat2 = await lstat10(directory);
     if (!stat2.isDirectory() || stat2.isSymbolicLink()) throw Error("MONITOR_DIRECTORY_INVALID");
     const temporary = file2 + "." + this.instanceId + ".tmp";
     const handle = await open9(temporary, "wx", 384);
@@ -48155,26 +49355,26 @@ var NativeFabricObserver = class {
 };
 
 // agent/src/native-fabric-startup.ts
-import { lstat as lstat11, mkdir as mkdir12, open as open11, readFile as readFile10 } from "node:fs/promises";
+import { lstat as lstat12, mkdir as mkdir12, open as open11, readFile as readFile10 } from "node:fs/promises";
 import path26 from "node:path";
 
 // src/agent-fabric-service.ts
-import { lstat as lstat10, mkdir as mkdir11, realpath as realpath9 } from "node:fs/promises";
+import { lstat as lstat11, mkdir as mkdir11, realpath as realpath9 } from "node:fs/promises";
 import { watch } from "node:fs";
 import path25 from "node:path";
 
 // src/agent-runtime-identity.ts
-import { createHash as createHash19, randomBytes as randomBytes7, randomUUID as randomUUID14, timingSafeEqual as timingSafeEqual4 } from "node:crypto";
+import { createHash as createHash19, randomBytes as randomBytes8, randomUUID as randomUUID14, timingSafeEqual as timingSafeEqual4 } from "node:crypto";
 
 // src/agent-fabric-state.ts
 import { randomUUID as randomUUID13 } from "node:crypto";
-import { mkdir as mkdir10, open as open10, rename as rename7, unlink as unlink2 } from "node:fs/promises";
+import { mkdir as mkdir10, open as open10, rename as rename7, unlink as unlink3 } from "node:fs/promises";
 import path24 from "node:path";
 var queues = /* @__PURE__ */ new Map();
 var FabricStateFile = class {
-  constructor(file2, maxBytes, parse3) {
+  constructor(file2, maxBytes, parse4) {
     this.maxBytes = maxBytes;
-    this.parse = parse3;
+    this.parse = parse4;
     this.file = path24.resolve(file2);
   }
   maxBytes;
@@ -48250,7 +49450,7 @@ var FabricStateFile = class {
           }
           await rename7(temporary, this.file);
         } finally {
-          await unlink2(temporary).catch((error62) => {
+          await unlink3(temporary).catch((error62) => {
             if (error62.code !== "ENOENT") throw error62;
           });
         }
@@ -48264,7 +49464,7 @@ var FabricStateFile = class {
         } finally {
           await current2.close();
         }
-        await unlink2(lockPath);
+        await unlink3(lockPath);
       }
     });
   }
@@ -48318,7 +49518,7 @@ var AgentRuntimeIdentityStore = class {
     return this.serial((state) => {
       if (state.bindings.length >= MAX_BINDINGS) throw Error("RUNTIME_IDENTITY_LIMIT");
       const runtimeId = "rt-" + randomUUID14();
-      const runtimeKey = randomBytes7(32).toString("base64url");
+      const runtimeKey = randomBytes8(32).toString("base64url");
       const now = this.now();
       state.bindings.push({ runtimeId, keyHash: encodedDigest(runtimeKey), createdAt: now, lastUsedAt: now, revoked: false });
       return { runtimeId, runtimeKey };
@@ -48883,18 +50083,18 @@ var AgentFabricService = class _AgentFabricService {
     const absolute2 = path25.resolve(directory);
     for (let current2 = absolute2; ; current2 = path25.dirname(current2)) {
       try {
-        if ((await lstat10(current2)).isSymbolicLink()) throw Error("FABRIC_DIRECTORY_INVALID");
+        if ((await lstat11(current2)).isSymbolicLink()) throw Error("FABRIC_DIRECTORY_INVALID");
       } catch (error62) {
         if (error62.code !== "ENOENT") throw error62;
       }
       if (path25.dirname(current2) === current2) break;
     }
     if (initialize) await mkdir11(absolute2, { recursive: true, mode: 448 });
-    if (!(await lstat10(absolute2)).isDirectory() || (await realpath9(absolute2)).toLowerCase() !== absolute2.toLowerCase())
+    if (!(await lstat11(absolute2)).isDirectory() || (await realpath9(absolute2)).toLowerCase() !== absolute2.toLowerCase())
       throw Error("FABRIC_DIRECTORY_INVALID");
     const present = /* @__PURE__ */ new Set();
     for (const name2 of ["binding.json", "mailbox.json", "identities.json"]) {
-      const file2 = await lstat10(path25.join(absolute2, name2)).catch((error62) => {
+      const file2 = await lstat11(path25.join(absolute2, name2)).catch((error62) => {
         if (error62.code === "ENOENT") return null;
         throw error62;
       });
@@ -48917,7 +50117,7 @@ var AgentFabricService = class _AgentFabricService {
         state.initialized = true;
       }
       const snapshot2 = await service2.mailbox.snapshot();
-      if (snapshot2.workers.some((worker) => worker.runtimeId !== null)) await lstat10(path25.join(absolute2, "identities.json"));
+      if (snapshot2.workers.some((worker) => worker.runtimeId !== null)) await lstat11(path25.join(absolute2, "identities.json"));
     }, initialize ? () => expected : void 0);
     return service2;
   }
@@ -49010,12 +50210,12 @@ async function openNativeFabric(stateDirectory, enrollment, box, initialize = tr
   } catch (error62) {
     if (error62.code !== "EEXIST") throw error62;
   }
-  const parentInfo = await lstat11(parent);
+  const parentInfo = await lstat12(parent);
   if (!parentInfo.isDirectory() || parentInfo.isSymbolicLink()) throw Error("FABRIC_DIRECTORY_INVALID");
   const expected = JSON.stringify({ version: 1, controllerId, tenantId });
   let fresh = false;
   try {
-    const info = await lstat11(marker);
+    const info = await lstat12(marker);
     if (!info.isFile() || info.isSymbolicLink() || info.size > 2048 || await readFile10(marker, "utf8") !== expected)
       throw Error("FABRIC_BINDING_CHANGED");
   } catch (error62) {
@@ -49043,7 +50243,7 @@ async function openNativeFabric(stateDirectory, enrollment, box, initialize = tr
     return credential;
   };
   async function capability(workerId) {
-    const file2 = credentialFile(workerId), info = await lstat11(file2);
+    const file2 = credentialFile(workerId), info = await lstat12(file2);
     if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) throw Error("FABRIC_CREDENTIAL_UNKNOWN");
     const encoded = await readFile10(file2, "utf8");
     if (decode4(encoded).workerId !== workerId) throw Error("FABRIC_WORKER_DENIED");
@@ -49197,14 +50397,14 @@ function supervisorLiveness(helperPath, options = {}) {
 
 // agent/src/content-audit.ts
 import { createReadStream } from "node:fs";
-import { appendFile, lstat as lstat12, mkdir as mkdir13, open as open12, readdir as readdir5, readFile as readFile11, rename as rename8, rm as rm9, writeFile as writeFile4 } from "node:fs/promises";
+import { appendFile, lstat as lstat13, mkdir as mkdir13, open as open12, readdir as readdir6, readFile as readFile11, rename as rename8, rm as rm9, writeFile as writeFile4 } from "node:fs/promises";
 import path28 from "node:path";
 import { performance as performance3 } from "node:perf_hooks";
 import { createInterface as createInterface2 } from "node:readline";
-import { randomBytes as randomBytes9 } from "node:crypto";
+import { randomBytes as randomBytes10 } from "node:crypto";
 
 // src/audit-crypto.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, createHash as createHash20, randomBytes as randomBytes8 } from "node:crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, createHash as createHash20, randomBytes as randomBytes9 } from "node:crypto";
 import { promisify as promisify3 } from "node:util";
 import { gunzipSync, gzip, gzipSync } from "node:zlib";
 var gzipAsync = promisify3(gzip);
@@ -49256,7 +50456,7 @@ async function encryptAuditRecordAsync(record2, keyInput, keyId2) {
 function sealCompressed(compressed, keyInput, keyId2) {
   const key = parseAuditRecoveryKey(keyInput);
   const kid = keyId2?.trim() || auditRecoveryKeyId(key);
-  const iv = randomBytes8(IV_BYTES);
+  const iv = randomBytes9(IV_BYTES);
   try {
     const cipher = createCipheriv3("aes-256-gcm", key, iv, { authTagLength: TAG_BYTES });
     cipher.setAAD(additionalData(kid));
@@ -49371,13 +50571,13 @@ function contentAuditDirectory(stateDir) {
 }
 async function plainDirectory(dir) {
   await mkdir13(dir, { recursive: true, mode: 448 });
-  const info = await lstat12(dir);
+  const info = await lstat13(dir);
   if (info.isSymbolicLink() || !info.isDirectory()) throw Error("AUDIT_DIRECTORY_INVALID");
 }
 async function auditFiles(dir) {
   let names;
   try {
-    names = await readdir5(dir);
+    names = await readdir6(dir);
   } catch (error62) {
     if (error62.code === "ENOENT") return [];
     throw error62;
@@ -49386,13 +50586,13 @@ async function auditFiles(dir) {
   for (const name2 of names) {
     const match = FILE.exec(name2);
     if (!match) continue;
-    const info = await lstat12(path28.join(dir, name2));
+    const info = await lstat13(path28.join(dir, name2));
     if (info.isFile()) files.push({ name: name2, kind: match[1], day: match[2], bytes: info.size });
   }
   return files.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function writeJsonAtomic(file2, value) {
-  const temp = `${file2}.${randomBytes9(6).toString("hex")}.tmp`;
+  const temp = `${file2}.${randomBytes10(6).toString("hex")}.tmp`;
   try {
     await writeFile4(temp, JSON.stringify(value) + "\n", { flag: "wx", mode: 384 });
     await rename8(temp, file2);
@@ -49629,7 +50829,7 @@ async function restoreContentAudit(input2, output2, key) {
 }
 
 // agent/src/main.ts
-var AGENT_VERSION2 = true ? "0.3.46" : "0.3.2";
+var AGENT_VERSION2 = true ? "0.3.48" : "0.3.2";
 var NETWORK_PUBLIC_KEY = true ? "-----BEGIN PUBLIC KEY-----\nMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAvmu+81vWtJBQDZNHcAIW\nzCSxpG+R9RBsum2df5mP2cOW+wyUDTpnYquFge1qgI5YYTF96j0xCyXL8B9FeNWs\n939opWNmv53j+CQlS4cEIQhBbZSCu0eC4icsVEzBhvf68MB+E668SOtZBcVTEnyh\n96PTcupxS10rQJBWDinbKBXRC2gvGYeu01rWa/nsrndy4vAYP5t3yQtdOC8e8mr0\n+2Mg2Qhiq+KiTCtDd+L9oXvoLqqJYbzUIveNGha25AWxF1Weblp0gOM87hell5gV\nK7q4ZLUq/wBRGYNmQRdLyV7/WRE1FFPSW21/SBZQ/5aU4UqJU/MjMcrJUrnRKngz\nYKmo0czkxS3N7Q2KVxomgR1AQSuQFKMrboZYKjShADp9RIYUxzs7cYg51Of5PnHh\n6Ax+VevDGfzjMD+yHuyxYZqCtX4OwgolJxz63UQbzKlris+8xb5lLYTbIuz90Pss\nn6HK/F5May25c6oMmS3nh/NsiZopL1OvdtWKTt1L4WlRAgMBAAE=\n-----END PUBLIC KEY-----\n" : "";
 var AI_CONNECTION_SHIPPED = false;
 function processAlive(pid) {