@slayzone/computer 0.36.0 → 0.36.1

package/dist/bin.cjs

@@ -6,11 +6,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -98,10 +107,10 @@ var require_constants = __commonJS({
       EMPTY_BUFFER: Buffer.alloc(0),
       GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
       hasBlob,
-      kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
-      kListener: Symbol("kListener"),
-      kStatusCode: Symbol("status-code"),
-      kWebSocket: Symbol("websocket"),
+      kForOnEventAttribute: /* @__PURE__ */ Symbol("kIsForOnEventAttribute"),
+      kListener: /* @__PURE__ */ Symbol("kListener"),
+      kStatusCode: /* @__PURE__ */ Symbol("status-code"),
+      kWebSocket: /* @__PURE__ */ Symbol("websocket"),
       NOOP: () => {
       }
     };
@@ -187,8 +196,8 @@ var require_buffer_util = __commonJS({
 var require_limiter = __commonJS({
   "../../../node_modules/ws/lib/limiter.js"(exports2, module2) {
     "use strict";
-    var kDone = Symbol("kDone");
-    var kRun = Symbol("kRun");
+    var kDone = /* @__PURE__ */ Symbol("kDone");
+    var kRun = /* @__PURE__ */ Symbol("kRun");
     var Limiter = class {
       /**
        * Creates a new `Limiter`.
@@ -243,11 +252,11 @@ var require_permessage_deflate = __commonJS({
     var { kStatusCode } = require_constants();
     var FastBuffer = Buffer[Symbol.species];
     var TRAILER = Buffer.from([0, 0, 255, 255]);
-    var kPerMessageDeflate = Symbol("permessage-deflate");
-    var kTotalLength = Symbol("total-length");
-    var kCallback = Symbol("callback");
-    var kBuffers = Symbol("buffers");
-    var kError = Symbol("error");
+    var kPerMessageDeflate = /* @__PURE__ */ Symbol("permessage-deflate");
+    var kTotalLength = /* @__PURE__ */ Symbol("total-length");
+    var kCallback = /* @__PURE__ */ Symbol("callback");
+    var kBuffers = /* @__PURE__ */ Symbol("buffers");
+    var kError = /* @__PURE__ */ Symbol("error");
     var zlibLimiter;
     var PerMessageDeflate2 = class {
       /**
@@ -1453,7 +1462,7 @@ var require_sender = __commonJS({
     var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
     var { isBlob, isValidStatusCode } = require_validation();
     var { mask: applyMask, toBuffer } = require_buffer_util();
-    var kByteLength = Symbol("kByteLength");
+    var kByteLength = /* @__PURE__ */ Symbol("kByteLength");
     var maskBuffer = Buffer.alloc(4);
     var RANDOM_POOL_SIZE = 8 * 1024;
     var randomPool;
@@ -1938,14 +1947,14 @@ var require_event_target = __commonJS({
   "../../../node_modules/ws/lib/event-target.js"(exports2, module2) {
     "use strict";
     var { kForOnEventAttribute, kListener } = require_constants();
-    var kCode = Symbol("kCode");
-    var kData = Symbol("kData");
-    var kError = Symbol("kError");
-    var kMessage = Symbol("kMessage");
-    var kReason = Symbol("kReason");
-    var kTarget = Symbol("kTarget");
-    var kType = Symbol("kType");
-    var kWasClean = Symbol("kWasClean");
+    var kCode = /* @__PURE__ */ Symbol("kCode");
+    var kData = /* @__PURE__ */ Symbol("kData");
+    var kError = /* @__PURE__ */ Symbol("kError");
+    var kMessage = /* @__PURE__ */ Symbol("kMessage");
+    var kReason = /* @__PURE__ */ Symbol("kReason");
+    var kTarget = /* @__PURE__ */ Symbol("kTarget");
+    var kType = /* @__PURE__ */ Symbol("kType");
+    var kWasClean = /* @__PURE__ */ Symbol("kWasClean");
     var Event = class {
       /**
        * Create a new `Event`.
@@ -2347,7 +2356,7 @@ var require_websocket = __commonJS({
     } = require_event_target();
     var { format, parse: parse3 } = require_extension();
     var { toBuffer } = require_buffer_util();
-    var kAborted = Symbol("kAborted");
+    var kAborted = /* @__PURE__ */ Symbol("kAborted");
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
@@ -2380,11 +2389,23 @@ var require_websocket = __commonJS({
           this._isServer = false;
           this._redirects = 0;
           if (protocols === void 0) {
-            protocols = [];
+            if (!options || options.protocols === void 0) {
+              protocols = [];
+            } else if (Array.isArray(options.protocols)) {
+              protocols = options.protocols;
+            } else {
+              protocols = [options.protocols];
+            }
           } else if (!Array.isArray(protocols)) {
             if (typeof protocols === "object" && protocols !== null) {
               options = protocols;
-              protocols = [];
+              if (options.protocols === void 0) {
+                protocols = [];
+              } else if (Array.isArray(options.protocols)) {
+                protocols = options.protocols;
+              } else {
+                protocols = [options.protocols];
+              }
             } else {
               protocols = [protocols];
             }
@@ -2581,7 +2602,6 @@ var require_websocket = __commonJS({
           }
           return;
         }
-        this._readyState = _WebSocket.CLOSING;
         this._sender.close(code, data, !this._isServer, (err) => {
           if (err) return;
           this._closeFrameSent = true;
@@ -2589,6 +2609,7 @@ var require_websocket = __commonJS({
             this._socket.end();
           }
         });
+        this._readyState = _WebSocket.CLOSING;
         setCloseTimer(this);
       }
       /**
@@ -2813,6 +2834,7 @@ var require_websocket = __commonJS({
         socketPath: void 0,
         hostname: void 0,
         protocol: void 0,
+        protocols: void 0,
         timeout: void 0,
         method: "GET",
         host: void 0,
@@ -3755,61 +3777,347 @@ var require_websocket_server = __commonJS({
   }
 });
 
-// ../../../node_modules/ignore/index.js
+// ../../shared/platform/src/fs-utils.ts
+async function writeFileIfChanged(filePath, content, mode) {
+  const target = await resolveTarget(filePath);
+  const buf = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
+  const existing = await safeReadFile(target);
+  if (existing && existing.equals(buf)) return false;
+  await import_promises3.default.mkdir(import_path2.default.dirname(target), { recursive: true });
+  const tmp = `${target}.tmp.${import_crypto.default.randomBytes(6).toString("hex")}`;
+  await import_promises3.default.writeFile(tmp, buf);
+  if (mode != null && process.platform !== "win32") {
+    await import_promises3.default.chmod(tmp, mode);
+  }
+  await import_promises3.default.rename(tmp, target);
+  return true;
+}
+async function updateFileAtomically(filePath, merge2, opts = {}) {
+  const { mode, retries = 5 } = opts;
+  const target = await resolveTarget(filePath);
+  await import_promises3.default.mkdir(import_path2.default.dirname(target), { recursive: true });
+  const release = await acquireLock(`${target}.lock`);
+  try {
+    for (let attempt = 0; ; attempt++) {
+      const baseline = await safeReadFile(target);
+      const merged = await merge2(baseline);
+      if (merged == null) return false;
+      const buf = Buffer.isBuffer(merged) ? merged : Buffer.from(merged, "utf8");
+      if (baseline && baseline.equals(buf)) return false;
+      const tmp = `${target}.tmp.${import_crypto.default.randomBytes(6).toString("hex")}`;
+      await import_promises3.default.writeFile(tmp, buf);
+      if (mode != null && process.platform !== "win32") {
+        await import_promises3.default.chmod(tmp, mode);
+      }
+      if (sameBytes(baseline, await safeReadFile(target))) {
+        await import_promises3.default.rename(tmp, target);
+        return true;
+      }
+      await import_promises3.default.rm(tmp, { force: true });
+      if (attempt >= retries) {
+        throw new Error(
+          `[fs-utils] updateFileAtomically: ${target} kept changing underneath ${retries + 1} merge attempts \u2014 giving up rather than writing a stale merge`
+        );
+      }
+      await sleep(2 ** attempt + Math.floor(Math.random() * 5));
+    }
+  } finally {
+    await release();
+  }
+}
+async function acquireLock(lockPath) {
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  for (; ; ) {
+    try {
+      const handle = await import_promises3.default.open(lockPath, "wx");
+      await handle.writeFile(`${process.pid} ${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+      await handle.close();
+      return async () => {
+        await import_promises3.default.rm(lockPath, { force: true });
+      };
+    } catch (err) {
+      if (!isCode(err, "EEXIST")) throw err;
+      const age = await lockAgeMs(lockPath);
+      if (age === null) continue;
+      if (age > LOCK_STALE_MS) {
+        await import_promises3.default.rm(lockPath, { force: true });
+        continue;
+      }
+      if (Date.now() > deadline) {
+        throw new Error(`[fs-utils] timed out after ${LOCK_TIMEOUT_MS}ms waiting for ${lockPath}`);
+      }
+      await sleep(5 + Math.floor(Math.random() * 10));
+    }
+  }
+}
+async function lockAgeMs(lockPath) {
+  try {
+    return Date.now() - (await import_promises3.default.stat(lockPath)).mtimeMs;
+  } catch (err) {
+    if (isCode(err, "ENOENT")) return null;
+    throw err;
+  }
+}
+function sameBytes(a, b) {
+  if (a === null || b === null) return a === b;
+  return a.equals(b);
+}
+function sleep(ms) {
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
+}
+async function safeReadFile(p) {
+  try {
+    return await import_promises3.default.readFile(p);
+  } catch (err) {
+    if (isENOENT(err)) return null;
+    throw err;
+  }
+}
+async function resolveTarget(p) {
+  try {
+    const stat2 = await import_promises3.default.lstat(p);
+    if (stat2.isSymbolicLink()) return await import_promises3.default.realpath(p);
+  } catch (err) {
+    if (!isENOENT(err)) throw err;
+  }
+  return p;
+}
+function isENOENT(err) {
+  return isCode(err, "ENOENT");
+}
+function isCode(err, code) {
+  return typeof err === "object" && err != null && err.code === code;
+}
+var import_promises3, import_path2, import_crypto, LOCK_STALE_MS, LOCK_TIMEOUT_MS;
+var init_fs_utils = __esm({
+  "../../shared/platform/src/fs-utils.ts"() {
+    "use strict";
+    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_path2 = __toESM(require("path"), 1);
+    import_crypto = __toESM(require("crypto"), 1);
+    LOCK_STALE_MS = 1e4;
+    LOCK_TIMEOUT_MS = 5e3;
+  }
+});
+
+// ../../domains/file-editor/node_modules/ignore/index.js
 var require_ignore = __commonJS({
-  "../../../node_modules/ignore/index.js"(exports2, module2) {
+  "../../domains/file-editor/node_modules/ignore/index.js"(exports2, module2) {
     function makeArray(subject) {
       return Array.isArray(subject) ? subject : [subject];
     }
+    var UNDEFINED = void 0;
     var EMPTY = "";
     var SPACE = " ";
     var ESCAPE = "\\";
-    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
+    var REGEX_TEST_BLANK_LINE = /^\uFEFF? *$/;
     var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
     var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
     var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
     var REGEX_SPLITALL_CRLF = /\r?\n/g;
-    var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+    var DOUBLE_SLASH = "//";
+    var SLASH_CODE = 47;
+    var DOT_CODE = 46;
     var SLASH = "/";
     var TMP_KEY_IGNORE = "node-ignore";
     if (typeof Symbol !== "undefined") {
-      TMP_KEY_IGNORE = Symbol.for("node-ignore");
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
     }
     var KEY_IGNORE = TMP_KEY_IGNORE;
-    var define = (object2, key, value) => Object.defineProperty(object2, key, { value });
-    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var define = (object2, key, value) => {
+      Object.defineProperty(object2, key, { value });
+      return value;
+    };
     var RETURN_FALSE = () => false;
-    var sanitizeRange = (range) => range.replace(
-      REGEX_REGEXP_RANGE,
-      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
-    );
     var cleanRangeBackSlash = (slashes) => {
       const { length } = slashes;
       return slashes.slice(0, length - length % 2);
     };
+    var POSIX_CLASSES = {
+      alnum: "0-9A-Za-z",
+      alpha: "A-Za-z",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1f\\x7f",
+      digit: "0-9",
+      graph: "!-.0-~",
+      lower: "a-z",
+      print: " -.0-~",
+      punct: "!-.:-@\\[-`{-~",
+      // git's `sane-ctype.h` classifies \v and \f as control, not space,
+      //   unlike C's `isspace`
+      space: " \\t\\n\\r",
+      upper: "A-Z",
+      xdigit: "0-9A-Fa-f"
+    };
+    var CLASS_MEMBERS_TO_ESCAPE = "\\]^-[";
+    var escapeMember = (char) => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0 ? char : ESCAPE + char;
+    var NON_SLASH = "(?!\\/)";
+    var classSource = (negated, body) => {
+      if (negated) {
+        return `[^\\/${body}]`;
+      }
+      const source = `[${body}]`;
+      return new RegExp(source).test("/") ? NON_SLASH + source : source;
+    };
+    var scanBracket = (pattern, start) => {
+      const { length } = pattern;
+      let index = start + 1;
+      let negated = EMPTY;
+      const lead = pattern[index];
+      if (lead === "!" || lead === "^") {
+        negated = "^";
+        index++;
+      }
+      let body = EMPTY;
+      let prev = EMPTY;
+      for (; ; ) {
+        const char = pattern[index];
+        if (char === UNDEFINED) {
+          return null;
+        }
+        if (char === ESCAPE) {
+          const escaped = pattern[index + 1];
+          if (escaped === UNDEFINED) {
+            return null;
+          }
+          body += escapeMember(escaped);
+          prev = escaped;
+          index++;
+        } else if (char === "-" && prev && index + 1 < length && pattern[index + 1] !== "]") {
+          index++;
+          let to = pattern[index];
+          if (to === ESCAPE) {
+            to = pattern[index += 1];
+          }
+          if (prev <= to) {
+            body += `-${escapeMember(to)}`;
+          }
+          prev = EMPTY;
+        } else if (char === "[" && pattern[index + 1] === ":") {
+          const nameStart = index + 2;
+          let end = nameStart;
+          while (end < length && pattern[end] !== "]") {
+            end++;
+          }
+          if (end === length) {
+            return null;
+          }
+          if (end > nameStart && pattern[end - 1] === ":") {
+            const expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
+            if (expanded === UNDEFINED) {
+              return null;
+            }
+            body += expanded;
+            prev = EMPTY;
+            index = end;
+          } else {
+            body += escapeMember("[");
+            prev = "[";
+            index = nameStart - 2;
+          }
+        } else {
+          body += escapeMember(char);
+          prev = char;
+        }
+        index++;
+        if (pattern[index] === "]") {
+          return {
+            end: index,
+            source: classSource(negated, body)
+          };
+        }
+      }
+    };
+    var NEVER_MATCH = "[]";
+    var PLACEHOLDER = "\0";
+    var REGEX_RESTORE_PLACEHOLDER = new RegExp(
+      `${PLACEHOLDER}(\\d+)${PLACEHOLDER}`,
+      "g"
+    );
+    var TRAILING_WILDCARD = "\uE000";
+    var extractBrackets = (pattern) => {
+      const sources = [];
+      const hold = (source) => `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`;
+      const { length } = pattern;
+      let out = EMPTY;
+      let index = 0;
+      while (index < length) {
+        const char = pattern[index];
+        if (char === ESCAPE) {
+          const escaped = pattern[index + 1];
+          if (escaped === "*" || escaped === "[" || escaped === SPACE || escaped === ESCAPE) {
+            out += pattern.slice(index, index + 2);
+          } else {
+            out += hold(
+              REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped
+            );
+          }
+          index += 2;
+        } else if (char === PLACEHOLDER) {
+          out += hold(`[${PLACEHOLDER}]`);
+          index++;
+        } else if (char === "[") {
+          const scanned = scanBracket(pattern, index);
+          if (scanned === null) {
+            out += hold(NEVER_MATCH);
+            index = length;
+          } else {
+            out += hold(scanned.source);
+            index = scanned.end + 1;
+          }
+        } else {
+          out += char;
+          index++;
+        }
+      }
+      return {
+        source: out,
+        sources
+      };
+    };
+    var DIRECT = null;
+    var REGEX_INNER_SLASH = /\/(?!$)/;
     var REPLACERS = [
       [
-        // remove BOM
+        // Remove BOM
         // TODO:
         // Other similar zero-width characters?
         /^\uFEFF/,
+        () => EMPTY,
+        "\uFEFF"
+      ],
+      [
+        // A trailing line terminator, left on when a whole file's contents are
+        //   added as one pattern rather than split into lines. git never sees one
+        //   -- it reads a `.gitignore` line by line -- so it is not part of the
+        //   pattern and is dropped here, apart from the trailing-space trimming,
+        //   which follows git in touching spaces and nothing else.
+        /[\r\n]+$/,
         () => EMPTY
       ],
       // > Trailing spaces are ignored unless they are quoted with backslash ("\")
       [
+        // Only spaces, never tabs or other whitespace: git trims a trailing run
+        //   of `' '` and nothing else (dir.c, `trim_trailing_spaces`, a single
+        //   `case ' '`), so a pattern ending in a tab keeps it as a literal.
         // (a\ ) -> (a )
         // (a  ) -> (a)
         // (a ) -> (a)
         // (a \ ) -> (a  )
-        /((?:\\\\)*?)(\\?\s+)$/,
+        /((?:\\\\)*?)(\\? +)$/,
         (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
       ],
-      // replace (\ ) with ' '
+      // Replace (\ ) with ' '
+      // Only a space: an escaped tab or other whitespace is already a literal by
+      //   the time it reaches here, and a bare tab must be left as one, not turned
+      //   into a space.
       // (\ ) -> ' '
       // (\\ ) -> '\\ '
       // (\\\ ) -> '\\ '
       [
-        /(\\+?)\s/g,
+        /(\\+?) /g,
         (_, m1) => {
           const { length } = m1;
           return m1.slice(0, length - length % 2) + SPACE;
@@ -3838,7 +4146,8 @@ var require_ignore = __commonJS({
       [
         // > a question mark (?) matches a single character
         /(?!\\)\?/g,
-        () => "[^/]"
+        () => "[^/]",
+        "?"
       ],
       // leading slash
       [
@@ -3846,12 +4155,14 @@ var require_ignore = __commonJS({
         // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
         // A leading slash matches the beginning of the pathname
         /^\//,
-        () => "^"
+        () => "^",
+        SLASH
       ],
       // replace special metacharacter slash after the leading slash
       [
         /\//g,
-        () => "\\/"
+        () => "\\/",
+        SLASH
       ],
       [
         // > A leading "**" followed by a slash means match in all directories.
@@ -3860,18 +4171,23 @@ var require_ignore = __commonJS({
         // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
         // >   under directory "foo".
         // Notice that the '*'s have been replaced as '\\*'
-        /^\^*\\\*\\\*\\\//,
+        /^\^*(?:\\\*\\\*\\\/)+/,
         // '**/foo' <-> 'foo'
-        () => "^(?:.*\\/)?"
+        () => "^(?:.*\\/)?",
+        "*"
       ],
       // starting
       [
         // there will be no leading '/'
         //   (which has been replaced by section "leading slash")
         // If starts with '**', adding a '^' to the regular expression also works
-        /^(?=[^^])/,
-        function startingReplacer() {
-          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        DIRECT,
+        (source, pattern) => {
+          if (!source || source[0] === "^") {
+            return source;
+          }
+          const anchor2 = !REGEX_INNER_SLASH.test(pattern) ? "(?:^|\\/)" : "^";
+          return anchor2 + source;
         }
       ],
       // two globstars
@@ -3881,7 +4197,8 @@ var require_ignore = __commonJS({
         // Zero, one or several directories
         // should not use '*', or it will be replaced by the next replacer
         // Check if it is not the last `'/**'`
-        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+        (_, index, str) => index + 6 < str.length ? str.slice(index + 6) === "\\/" ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : "\\/.+",
+        "*"
       ],
       // normal intermediate wildcards
       [
@@ -3896,32 +4213,56 @@ var require_ignore = __commonJS({
         (_, p1, p2) => {
           const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
           return p1 + unescaped;
-        }
+        },
+        "*"
+      ],
+      // trailing wildcard, held apart from a literal star
+      [
+        // The step above leaves a trailing `*` alone, so a single `\*` is all that
+        //   can be left at the end here. Whether it is a wildcard or a literal
+        //   turns on the backslashes the user put in front of it: the escaper has
+        //   since doubled every one, so what stands here is those `2N` doubled
+        //   backslashes and then the star's own escape. An even number of the
+        //   original `N` leaves the star unescaped -- a wildcard -- and an odd
+        //   number escapes it -- a literal. This runs while the two are still
+        //   distinct, before the unescape steps below collapse the literal onto
+        //   the very `\*` a wildcard leaves behind.
+        /(^|[^\\])((?:\\\\)*)\\\*$/,
+        (match, p1, p2) => (
+          // `p2` holds the doubled user backslashes; half of them is `N`.
+          p2.length / 2 % 2 === 0 ? p1 + p2 + TRAILING_WILDCARD : match
+        ),
+        "*"
       ],
       [
         // unescape, revert step 3 except for back slash
         // For example, if a user escape a '\\*',
         // after step 3, the result will be '\\\\\\*'
         /\\\\\\(?=[$.|*+(){^])/g,
-        () => ESCAPE
+        () => ESCAPE,
+        ESCAPE + ESCAPE
       ],
       [
         // '\\\\' -> '\\'
         /\\\\/g,
-        () => ESCAPE
+        () => ESCAPE,
+        ESCAPE + ESCAPE
       ],
       [
-        // > The range notation, e.g. [a-zA-Z],
-        // > can be used to match one of the characters in a range.
+        // Every real bracket expression -- POSIX classes included -- has already
+        //   been held aside by `extractBrackets`, so the only `[` left in the
+        //   pattern is an escaped, literal one.
         // `\` is escaped by step 3
-        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
-        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+        /\\\[([^\]/]*?)(\\*)($|\])/g,
+        // '\\[bar]' -> '\\\\[bar\\]'
+        (match, range, endEscape, close) => `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`,
+        "["
       ],
       // ending
       [
         // 'js' will not match 'js.'
         // 'ab' will not match 'abc'
-        /(?:[^*])$/,
+        DIRECT,
         // WTF!
         // https://git-scm.com/docs/gitignore
         // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
@@ -3932,70 +4273,320 @@ var require_ignore = __commonJS({
         // 'js*' will not match 'a.js'
         // 'js/' will not match 'a.js'
         // 'js' will match 'a.js' and 'a.js/'
-        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
-      ],
-      // trailing wildcard
-      [
-        /(\^|\\\/)?\\\*$/,
-        (_, p1) => {
-          const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
-          return `${prefix}(?=$|\\/$)`;
+        (source) => {
+          const last = source[source.length - 1];
+          if (!last || last === TRAILING_WILDCARD) {
+            return source;
+          }
+          return last === SLASH ? `${source}$` : `${source}(?=$|\\/$)`;
         }
       ]
     ];
-    var regexCache = /* @__PURE__ */ Object.create(null);
-    var makeRegex = (pattern, ignoreCase) => {
-      let source = regexCache[pattern];
-      if (!source) {
-        source = REPLACERS.reduce(
-          (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
-          pattern
-        );
-        regexCache[pattern] = source;
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var WILDCARD = "[^\\/]*";
+    var separatorAfter = (run, at) => {
+      let separator = EMPTY;
+      for (let index = at + 1; index < run.length && !run[index].wildcard; index++) {
+        separator += run[index].single;
+      }
+      return separator;
+    };
+    var pinWildcards = (source) => {
+      if (source.indexOf(WILDCARD) < 0) {
+        return source;
+      }
+      const tokens = [];
+      const { length } = source;
+      let index = 0;
+      while (index < length) {
+        const char = source[index];
+        if (source.startsWith(WILDCARD, index)) {
+          tokens.push({ wildcard: true });
+          index += WILDCARD.length;
+        } else if (char === "[") {
+          let end = index + 1;
+          if (source[end] === "^") {
+            end++;
+          }
+          if (source[end] === "]") {
+            end++;
+          }
+          while (end < length && source[end] !== "]") {
+            end += source[end] === ESCAPE ? 2 : 1;
+          }
+          end++;
+          tokens.push({ single: source.slice(index, end) });
+          index = end;
+        } else if (char === ESCAPE) {
+          tokens.push({ single: source.slice(index, index + 2) });
+          index += 2;
+        } else if (char === "(") {
+          let depth = 0;
+          let end = index;
+          do {
+            if (source[end] === ESCAPE) {
+              end++;
+            } else if (source[end] === "(") {
+              depth++;
+            } else if (source[end] === ")") {
+              depth--;
+            }
+            end++;
+          } while (end < length && depth > 0);
+          if ("*+?".indexOf(source[end]) >= 0) {
+            end++;
+          }
+          tokens.push({ boundary: source.slice(index, end) });
+          index = end;
+        } else if (char === "^" || char === "$") {
+          tokens.push({ boundary: char });
+          index++;
+        } else {
+          tokens.push({ single: char });
+          index++;
+        }
+      }
+      let out = EMPTY;
+      let run = [];
+      const flush = () => {
+        let lastWildcard;
+        run.forEach((token, at) => {
+          if (token.wildcard) {
+            lastWildcard = at;
+          }
+        });
+        run.forEach((token, at) => {
+          if (!token.wildcard) {
+            out += token.single;
+            return;
+          }
+          out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at)})[^\\/])*`;
+        });
+        run = [];
+      };
+      tokens.forEach((token) => {
+        if (token.boundary === void 0) {
+          run.push(token);
+          return;
+        }
+        flush();
+        out += token.boundary;
+      });
+      flush();
+      return out;
+    };
+    var makeRegexPrefix = (pattern) => {
+      const { source, sources } = extractBrackets(pattern);
+      const replaced = REPLACERS.reduce(
+        // A pass whose matcher finds nothing hands back the very string it was
+        //   given, so asking first costs a search and saves a rewrite. Ten of the
+        //   fifteen passes never fire for a typical .gitignore line, and between
+        //   them they were 45% of this chain.
+        (prev, [matcher, replacer, required2]) => {
+          if (matcher === DIRECT) {
+            return replacer(prev, pattern);
+          }
+          if (required2 !== UNDEFINED && prev.indexOf(required2) < 0) {
+            return prev;
+          }
+          return matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev;
+        },
+        source
+      );
+      return sources.length ? replaced.replace(
+        REGEX_RESTORE_PLACEHOLDER,
+        (match, index) => sources[index]
+      ) : replaced;
+    };
+    var matchesBasename = (body) => {
+      const index = body.indexOf(SLASH);
+      return index < 0 || index === body.length - 1;
+    };
+    var basenameOf = (path9) => {
+      const end = path9.length - 1;
+      const index = path9.lastIndexOf(
+        SLASH,
+        path9[end] === SLASH ? end - 1 : end
+      );
+      return index < 0 ? path9 : path9.slice(index + 1);
+    };
+    var parentOf = (path9) => {
+      if (path9.charCodeAt(0) === SLASH_CODE || path9.indexOf(DOUBLE_SLASH) >= 0) {
+        const slices = path9.split(SLASH).filter(Boolean);
+        slices.pop();
+        return slices.length ? slices.join(SLASH) + SLASH : EMPTY;
       }
-      return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+      const end = path9.length - 1;
+      const cut = path9.lastIndexOf(
+        SLASH,
+        path9.charCodeAt(end) === SLASH_CODE ? end - 1 : end
+      );
+      return cut < 0 ? EMPTY : path9.slice(0, cut + 1);
     };
     var isString = (subject) => typeof subject === "string";
     var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
-    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
     var IgnoreRule = class {
-      constructor(origin, pattern, negative, regex) {
-        this.origin = origin;
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
         this.pattern = pattern;
+        this.mark = mark;
         this.negative = negative;
-        this.regex = regex;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      // Worked out on first use and kept behind an own property, the way `regex`
+      //   caches itself in `_regex`. Deciding it in the constructor instead would
+      //   add a fourth `defineProperty` to every rule ever built, which cost 4% of
+      //   every compile -- including the compiles of rules that are never matched
+      //   against anything.
+      get _basenameOnly() {
+        return define(this, "_basenameOnly", matchesBasename(this.body));
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = pinWildcards(this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        ));
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
       }
     };
-    var createRule = (pattern, ignoreCase) => {
-      const origin = pattern;
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
       let negative = false;
-      if (pattern.indexOf("!") === 0) {
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
         negative = true;
-        pattern = pattern.substr(1);
+        body = body.substr(1);
       }
-      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
-      const regex = makeRegex(pattern, ignoreCase);
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
       return new IgnoreRule(
-        origin,
         pattern,
+        mark,
+        body,
+        ignoreCase,
         negative,
-        regex
+        regexPrefix
       );
     };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+        this._basenameCount = 0;
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._basenameCount += pattern._rules._basenameCount;
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+          if (matchesBasename(rule.body)) {
+            this._basenameCount++;
+          }
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path9, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        const rules = this._rules;
+        const { length } = rules;
+        const shortcut = this._basenameCount * 2 >= length;
+        const basename5 = shortcut ? basenameOf(path9) : path9;
+        for (let index = 0; index < length; index++) {
+          const rule = rules[index];
+          const { negative } = rule;
+          const skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
+          if (!skip && rule[mode].test(
+            shortcut && rule._basenameOnly ? basename5 : path9
+          )) {
+            ignored = !negative;
+            unignored = negative;
+            matchedRule = negative ? UNDEFINED : rule;
+          }
+        }
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path8, originalPath, doThrow) => {
-      if (!isString(path8)) {
+    var checkPath = (path9, originalPath, doThrow) => {
+      if (!isString(path9)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path8) {
+      if (!path9) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path8)) {
+      if (checkPath.isNotRelative(path9)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -4004,7 +4595,26 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path8) => REGEX_TEST_INVALID_PATH.test(path8);
+    var isNotRelative = (path9) => {
+      const first = path9.charCodeAt(0);
+      if (first === SLASH_CODE) {
+        return true;
+      }
+      if (first !== DOT_CODE) {
+        return false;
+      }
+      if (path9.length === 1) {
+        return true;
+      }
+      const second = path9.charCodeAt(1);
+      if (second === SLASH_CODE) {
+        return true;
+      }
+      if (second !== DOT_CODE) {
+        return false;
+      }
+      return path9.length === 2 || path9.charCodeAt(2) === SLASH_CODE;
+    };
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -4014,255 +4624,87 @@ var require_ignore = __commonJS({
         allowRelativePaths = false
       } = {}) {
         define(this, KEY_IGNORE, true);
-        this._rules = [];
-        this._ignoreCase = ignoreCase;
-        this._allowRelativePaths = allowRelativePaths;
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
         this._initCache();
       }
       _initCache() {
         this._ignoreCache = /* @__PURE__ */ Object.create(null);
         this._testCache = /* @__PURE__ */ Object.create(null);
       }
-      _addPattern(pattern) {
-        if (pattern && pattern[KEY_IGNORE]) {
-          this._rules = this._rules.concat(pattern._rules);
-          this._added = true;
-          return;
-        }
-        if (checkPattern(pattern)) {
-          const rule = createRule(pattern, this._ignoreCase);
-          this._added = true;
-          this._rules.push(rule);
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
         }
-      }
-      // @param {Array<string> | string | Ignore} pattern
-      add(pattern) {
-        this._added = false;
-        makeArray(
-          isString(pattern) ? splitPattern(pattern) : pattern
-        ).forEach(this._addPattern, this);
-        if (this._added) {
-          this._initCache();
-        }
-        return this;
+        return this;
       }
       // legacy
       addPattern(pattern) {
         return this.add(pattern);
       }
-      //          |           ignored : unignored
-      // negative |   0:0   |   0:1   |   1:0   |   1:1
-      // -------- | ------- | ------- | ------- | --------
-      //     0    |  TEST   |  TEST   |  SKIP   |    X
-      //     1    |  TESTIF |  SKIP   |  TEST   |    X
-      // - SKIP: always skip
-      // - TEST: always test
-      // - TESTIF: only test if checkUnignored
-      // - X: that never happen
-      // @param {boolean} whether should check if the path is unignored,
-      //   setting `checkUnignored` to `false` could reduce additional
-      //   path matching.
-      // @returns {TestResult} true if a file is ignored
-      _testOne(path8, checkUnignored) {
-        let ignored = false;
-        let unignored = false;
-        this._rules.forEach((rule) => {
-          const { negative } = rule;
-          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
-            return;
-          }
-          const matched = rule.regex.test(path8);
-          if (matched) {
-            ignored = !negative;
-            unignored = negative;
-          }
-        });
-        return {
-          ignored,
-          unignored
-        };
-      }
       // @returns {TestResult}
-      _test(originalPath, cache, checkUnignored, slices) {
-        const path8 = originalPath && checkPath.convert(originalPath);
+      _test(originalPath, cache, checkUnignored) {
+        const path9 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path8,
+          path9,
           originalPath,
-          this._allowRelativePaths ? RETURN_FALSE : throwError
+          this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path8, cache, checkUnignored, slices);
+        return this._t(path9, cache, checkUnignored);
       }
-      _t(path8, cache, checkUnignored, slices) {
-        if (path8 in cache) {
-          return cache[path8];
+      checkIgnore(path9) {
+        if (path9.charCodeAt(path9.length - 1) !== SLASH_CODE) {
+          return this.test(path9);
         }
-        if (!slices) {
-          slices = path8.split(SLASH);
+        const parentPath = parentOf(path9);
+        if (parentPath) {
+          const parent = this._t(parentPath, this._testCache, true);
+          if (parent.ignored) {
+            return parent;
+          }
         }
-        slices.pop();
-        if (!slices.length) {
-          return cache[path8] = this._testOne(path8, checkUnignored);
-        }
-        const parent = this._t(
-          slices.join(SLASH) + SLASH,
-          cache,
-          checkUnignored,
-          slices
-        );
-        return cache[path8] = parent.ignored ? parent : this._testOne(path8, checkUnignored);
+        return this._rules.test(path9, false, MODE_CHECK_IGNORE);
+      }
+      _t(path9, cache, checkUnignored) {
+        if (path9 in cache) {
+          return cache[path9];
+        }
+        const parentPath = parentOf(path9);
+        const parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
+        return cache[path9] = parent && parent.ignored ? parent : this._rules.test(path9, checkUnignored, MODE_IGNORE);
       }
-      ignores(path8) {
-        return this._test(path8, this._ignoreCache, false).ignored;
+      ignores(path9) {
+        return this._test(path9, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path8) => !this.ignores(path8);
+        return (path9) => !this.ignores(path9);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path8) {
-        return this._test(path8, this._testCache, true);
+      test(path9) {
+        return this._test(path9, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE);
-    factory.isPathValid = isPathValid;
-    factory.default = factory;
-    module2.exports = factory;
+    var isPathValid = (path9) => checkPath(path9 && checkPath.convert(path9), path9, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path9) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path9) || isNotRelative(path9);
+    };
     if (
       // Detect `process` so that it can run in browsers.
-      typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
+      typeof process !== "undefined" && process.platform === "win32"
     ) {
-      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
-      checkPath.convert = makePosix;
-      const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path8) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
-    }
-  }
-});
-
-// ../../shared/platform/src/fs-utils.ts
-async function writeFileIfChanged(filePath, content, mode) {
-  const target = await resolveTarget(filePath);
-  const buf = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
-  const existing = await safeReadFile(target);
-  if (existing && existing.equals(buf)) return false;
-  await import_promises7.default.mkdir(import_path2.default.dirname(target), { recursive: true });
-  const tmp = `${target}.tmp.${import_crypto.default.randomBytes(6).toString("hex")}`;
-  await import_promises7.default.writeFile(tmp, buf);
-  if (mode != null && process.platform !== "win32") {
-    await import_promises7.default.chmod(tmp, mode);
-  }
-  await import_promises7.default.rename(tmp, target);
-  return true;
-}
-async function updateFileAtomically(filePath, merge2, opts = {}) {
-  const { mode, retries = 5 } = opts;
-  const target = await resolveTarget(filePath);
-  await import_promises7.default.mkdir(import_path2.default.dirname(target), { recursive: true });
-  const release = await acquireLock(`${target}.lock`);
-  try {
-    for (let attempt = 0; ; attempt++) {
-      const baseline = await safeReadFile(target);
-      const merged = await merge2(baseline);
-      if (merged == null) return false;
-      const buf = Buffer.isBuffer(merged) ? merged : Buffer.from(merged, "utf8");
-      if (baseline && baseline.equals(buf)) return false;
-      const tmp = `${target}.tmp.${import_crypto.default.randomBytes(6).toString("hex")}`;
-      await import_promises7.default.writeFile(tmp, buf);
-      if (mode != null && process.platform !== "win32") {
-        await import_promises7.default.chmod(tmp, mode);
-      }
-      if (sameBytes(baseline, await safeReadFile(target))) {
-        await import_promises7.default.rename(tmp, target);
-        return true;
-      }
-      await import_promises7.default.rm(tmp, { force: true });
-      if (attempt >= retries) {
-        throw new Error(
-          `[fs-utils] updateFileAtomically: ${target} kept changing underneath ${retries + 1} merge attempts \u2014 giving up rather than writing a stale merge`
-        );
-      }
-      await sleep(2 ** attempt + Math.floor(Math.random() * 5));
-    }
-  } finally {
-    await release();
-  }
-}
-async function acquireLock(lockPath) {
-  const deadline = Date.now() + LOCK_TIMEOUT_MS;
-  for (; ; ) {
-    try {
-      const handle = await import_promises7.default.open(lockPath, "wx");
-      await handle.writeFile(`${process.pid} ${(/* @__PURE__ */ new Date()).toISOString()}
-`);
-      await handle.close();
-      return async () => {
-        await import_promises7.default.rm(lockPath, { force: true });
-      };
-    } catch (err) {
-      if (!isCode(err, "EEXIST")) throw err;
-      const age = await lockAgeMs(lockPath);
-      if (age === null) continue;
-      if (age > LOCK_STALE_MS) {
-        await import_promises7.default.rm(lockPath, { force: true });
-        continue;
-      }
-      if (Date.now() > deadline) {
-        throw new Error(`[fs-utils] timed out after ${LOCK_TIMEOUT_MS}ms waiting for ${lockPath}`);
-      }
-      await sleep(5 + Math.floor(Math.random() * 10));
+      setupWindows();
     }
-  }
-}
-async function lockAgeMs(lockPath) {
-  try {
-    return Date.now() - (await import_promises7.default.stat(lockPath)).mtimeMs;
-  } catch (err) {
-    if (isCode(err, "ENOENT")) return null;
-    throw err;
-  }
-}
-function sameBytes(a, b) {
-  if (a === null || b === null) return a === b;
-  return a.equals(b);
-}
-function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
-}
-async function safeReadFile(p) {
-  try {
-    return await import_promises7.default.readFile(p);
-  } catch (err) {
-    if (isENOENT(err)) return null;
-    throw err;
-  }
-}
-async function resolveTarget(p) {
-  try {
-    const stat2 = await import_promises7.default.lstat(p);
-    if (stat2.isSymbolicLink()) return await import_promises7.default.realpath(p);
-  } catch (err) {
-    if (!isENOENT(err)) throw err;
-  }
-  return p;
-}
-function isENOENT(err) {
-  return isCode(err, "ENOENT");
-}
-function isCode(err, code) {
-  return typeof err === "object" && err != null && err.code === code;
-}
-var import_promises7, import_path2, import_crypto, LOCK_STALE_MS, LOCK_TIMEOUT_MS;
-var init_fs_utils = __esm({
-  "../../shared/platform/src/fs-utils.ts"() {
-    "use strict";
-    import_promises7 = __toESM(require("fs/promises"), 1);
-    import_path2 = __toESM(require("path"), 1);
-    import_crypto = __toESM(require("crypto"), 1);
-    LOCK_STALE_MS = 1e4;
-    LOCK_TIMEOUT_MS = 5e3;
+    module2.exports = factory;
+    factory.default = factory;
+    module2.exports.isPathValid = isPathValid;
+    define(module2.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
   }
 });
 
@@ -4412,7 +4854,7 @@ var init_claude_hook_installer = __esm({
 // ../../shared/platform/src/agent-hooks/gemini-hook-installer.ts
 async function isGeminiInstalled() {
   try {
-    await execFileAsync2("gemini", ["--version"], { timeout: 2e3 });
+    await execFileAsync3("gemini", ["--version"], { timeout: 2e3 });
     return true;
   } catch {
     return false;
@@ -4493,16 +4935,16 @@ function isManagedSlayzoneHook2(hook) {
   const cmd = typeof h.command === "string" ? h.command : "";
   return cmd.includes(".slayzone/hooks/notify.sh") || cmd.includes("/slayzone/hooks/notify.sh");
 }
-var import_node_child_process7, import_node_util, execFileAsync2, MARKER_KEY2, GEMINI_HOOK_EVENTS, TOOL_MATCHED_EVENTS2;
+var import_node_child_process10, import_node_util2, execFileAsync3, MARKER_KEY2, GEMINI_HOOK_EVENTS, TOOL_MATCHED_EVENTS2;
 var init_gemini_hook_installer = __esm({
   "../../shared/platform/src/agent-hooks/gemini-hook-installer.ts"() {
     "use strict";
-    import_node_child_process7 = require("node:child_process");
-    import_node_util = require("node:util");
+    import_node_child_process10 = require("node:child_process");
+    import_node_util2 = require("node:util");
     init_dirs();
     init_fs_utils();
     init_hook_paths();
-    execFileAsync2 = (0, import_node_util.promisify)(import_node_child_process7.execFile);
+    execFileAsync3 = (0, import_node_util2.promisify)(import_node_child_process10.execFile);
     MARKER_KEY2 = "_slayzoneManaged";
     GEMINI_HOOK_EVENTS = [
       "SessionStart",
@@ -4601,9 +5043,9 @@ function isManagedSlayzoneHook3(hook) {
 async function uninstallCodexWrapper(opts = {}) {
   const target = opts.wrapperPath ?? import_path4.default.join(getSlayzoneBinDir(), "codex");
   try {
-    const content = await import_promises9.default.readFile(target, "utf8");
+    const content = await import_promises10.default.readFile(target, "utf8");
     if (!content.includes("slayzone codex wrapper")) return false;
-    await import_promises9.default.unlink(target);
+    await import_promises10.default.unlink(target);
     return true;
   } catch (err) {
     if (isENOENT2(err)) return false;
@@ -4638,11 +5080,11 @@ function isAtLeast(v, min) {
 function isENOENT2(err) {
   return typeof err === "object" && err != null && err.code === "ENOENT";
 }
-var import_promises9, import_path4, import_child_process2, import_util10, execP, MARKER_KEY3, CODEX_HOOK_EVENTS, TOOL_MATCHED_EVENTS3, MIN_CODEX_VERSION;
+var import_promises10, import_path4, import_child_process2, import_util10, execP, MARKER_KEY3, CODEX_HOOK_EVENTS, TOOL_MATCHED_EVENTS3, MIN_CODEX_VERSION;
 var init_codex_hook_installer = __esm({
   "../../shared/platform/src/agent-hooks/codex-hook-installer.ts"() {
     "use strict";
-    import_promises9 = __toESM(require("fs/promises"), 1);
+    import_promises10 = __toESM(require("fs/promises"), 1);
     import_path4 = __toESM(require("path"), 1);
     import_child_process2 = require("child_process");
     import_util10 = require("util");
@@ -4667,7 +5109,7 @@ var init_codex_hook_installer = __esm({
 // ../../shared/platform/src/agent-hooks/antigravity-hook-installer.ts
 async function isAntigravityInstalled() {
   try {
-    await execFileAsync3("agy", ["--version"], { timeout: 2e3 });
+    await execFileAsync4("agy", ["--version"], { timeout: 2e3 });
     return true;
   } catch {
     return false;
@@ -4729,16 +5171,16 @@ function buildEntry(event, scriptPath) {
   if (TOOL_MATCHED_EVENTS4.has(event)) entry.matcher = "*";
   return entry;
 }
-var import_node_child_process8, import_node_util2, execFileAsync3, SLAYZONE_HOOK_NAME, ANTIGRAVITY_HOOK_EVENTS, TOOL_MATCHED_EVENTS4;
+var import_node_child_process11, import_node_util3, execFileAsync4, SLAYZONE_HOOK_NAME, ANTIGRAVITY_HOOK_EVENTS, TOOL_MATCHED_EVENTS4;
 var init_antigravity_hook_installer = __esm({
   "../../shared/platform/src/agent-hooks/antigravity-hook-installer.ts"() {
     "use strict";
-    import_node_child_process8 = require("node:child_process");
-    import_node_util2 = require("node:util");
+    import_node_child_process11 = require("node:child_process");
+    import_node_util3 = require("node:util");
     init_dirs();
     init_fs_utils();
     init_hook_paths();
-    execFileAsync3 = (0, import_node_util2.promisify)(import_node_child_process8.execFile);
+    execFileAsync4 = (0, import_node_util3.promisify)(import_node_child_process11.execFile);
     SLAYZONE_HOOK_NAME = "slayzone-notify";
     ANTIGRAVITY_HOOK_EVENTS = ["PreInvocation", "PostToolUse", "Stop"];
     TOOL_MATCHED_EVENTS4 = /* @__PURE__ */ new Set(["PostToolUse"]);
@@ -4778,10 +5220,10 @@ var init_agent_hooks = __esm({
   }
 });
 
-// raw-import:/tmp/slz-publish-wt.vI4qKd/packages/shared/hooks/src/notify.sh
+// raw-import:/tmp/slz-publish-wt.C8azA7/packages/shared/hooks/src/notify.sh
 var notify_default;
 var init_notify = __esm({
-  "raw-import:/tmp/slz-publish-wt.vI4qKd/packages/shared/hooks/src/notify.sh"() {
+  "raw-import:/tmp/slz-publish-wt.C8azA7/packages/shared/hooks/src/notify.sh"() {
     notify_default = `#!/bin/sh
 # SlayZone agent lifecycle hook \u2014 BENIGN DUMB FORWARDER.
 #
@@ -4943,10 +5385,10 @@ exit 0
   }
 });
 
-// raw-import:/tmp/slz-publish-wt.vI4qKd/packages/shared/hooks/src/opencode-plugin.js
+// raw-import:/tmp/slz-publish-wt.C8azA7/packages/shared/hooks/src/opencode-plugin.js
 var opencode_plugin_default;
 var init_opencode_plugin = __esm({
-  "raw-import:/tmp/slz-publish-wt.vI4qKd/packages/shared/hooks/src/opencode-plugin.js"() {
+  "raw-import:/tmp/slz-publish-wt.C8azA7/packages/shared/hooks/src/opencode-plugin.js"() {
     opencode_plugin_default = "// SlayZone opencode plugin v1\n//\n// Forwards OpenCode SDK session lifecycle events to the SlayZone agent-hook\n// notify script over a local shell exec. Plugin is loaded by OpenCode from\n//   ${XDG_CONFIG_HOME:-~/.config}/opencode/plugin/slayzone-notify.js\n//\n// The {{NOTIFY_PATH}} placeholder is substituted by the SlayZone installer\n// (packages/apps/app/src/main/agent-hooks/opencode-plugin-installer.ts) at\n// install time with the absolute path to `~/.slayzone/hooks/notify.sh`.\n//\n// Behavior:\n//   - No-op when SLAYZONE_TASK_ID is unset (plugin only fires inside SlayZone PTYs).\n//   - Subagent (child session) events are suppressed \u2014 oh-my-opencode + similar\n//     tools spawn many child sessions and would otherwise flap Start/Stop.\n//   - On client.session.list() error, sessions are assumed CHILD (safer to\n//     suppress than emit a false-positive Start/Stop).\n//   - Handles both modern (session.status w/ nested type) and legacy\n//     (session.busy / session.idle) event shapes for forward compat.\n//   - Singleton guard prevents double-load if OpenCode re-imports the plugin.\n\nexport const SlayzoneNotifyPlugin = async ({ $, client }) => {\n  if (globalThis.__slayzoneOpencodePluginV1) return {}\n  globalThis.__slayzoneOpencodePluginV1 = true\n  if (!process?.env?.SLAYZONE_TASK_ID) return {}\n\n  const notifyPath = '{{NOTIFY_PATH}}'\n  let currentState = 'idle' // 'idle' | 'busy'\n  let rootSessionID = null // first non-child session we see\n  let stopSent = false // dedup Stop emits\n  const childSessionCache = new Map() // sessionID -> isChild bool\n\n  const notify = async (eventName) => {\n    const payload = JSON.stringify({ hook_event_name: eventName })\n    try {\n      await $`bash ${notifyPath} ${payload}`\n    } catch {\n      // Hook failures must never bubble into the OpenCode TUI.\n    }\n  }\n\n  const isChildSession = async (sessionID) => {\n    if (!sessionID) return true\n    if (!client?.session?.list) return true\n    if (childSessionCache.has(sessionID)) return childSessionCache.get(sessionID)\n    try {\n      const sessions = await client.session.list()\n      const session = sessions.data?.find((s) => s.id === sessionID)\n      const isChild = !!session?.parentID\n      childSessionCache.set(sessionID, isChild)\n      return isChild\n    } catch {\n      // On error, assume CHILD \u2014 safer than emitting a false-positive Start/Stop.\n      return true\n    }\n  }\n\n  const handleBusy = async (sessionID) => {\n    if (!rootSessionID) rootSessionID = sessionID\n    if (sessionID !== rootSessionID) return\n    if (currentState === 'idle') {\n      currentState = 'busy'\n      stopSent = false\n      await notify('Start')\n    }\n  }\n\n  const handleStop = async (sessionID) => {\n    if (rootSessionID && sessionID !== rootSessionID) return\n    if (currentState === 'busy' && !stopSent) {\n      currentState = 'idle'\n      stopSent = true\n      await notify('Stop')\n      rootSessionID = null // reset for next session\n    }\n  }\n\n  return {\n    event: async ({ event }) => {\n      const sessionID = event.properties?.sessionID ?? event.properties?.info?.id ?? null\n\n      if (event.type === 'session.created') {\n        const isChild = Boolean(event.properties?.info?.parentID)\n        if (sessionID) childSessionCache.set(sessionID, isChild)\n        if (!isChild) await notify('SessionStart')\n        return\n      }\n\n      if (event.type === 'session.deleted') {\n        const cached = sessionID ? childSessionCache.get(sessionID) : undefined\n        const isChild = cached !== undefined ? cached : await isChildSession(sessionID)\n        if (!isChild) await notify('SessionEnd')\n        if (sessionID) childSessionCache.delete(sessionID)\n        return\n      }\n\n      if (await isChildSession(sessionID)) return\n\n      if (event.type === 'session.status') {\n        const status = event.properties?.status\n        if (status?.type === 'busy') await handleBusy(sessionID)\n        else if (status?.type === 'idle') await handleStop(sessionID)\n      }\n      // Backwards-compat: some OpenCode versions emit busy/idle as top-level events.\n      if (event.type === 'session.busy') await handleBusy(sessionID)\n      if (event.type === 'session.idle') await handleStop(sessionID)\n      if (event.type === 'session.error') await handleStop(sessionID)\n    },\n    'permission.ask': async (_permission, output) => {\n      if (output.status === 'ask') await notify('PermissionRequest')\n    }\n  }\n}\n";
   }
 });
@@ -4989,8 +5431,8 @@ var init_agent_hooks2 = __esm({
 });
 
 // src/bin.ts
-var import_node_os7 = require("node:os");
-var import_node_path10 = require("node:path");
+var import_node_os8 = require("node:os");
+var import_node_path14 = require("node:path");
 
 // ../../shared/platform/src/config-prompt.ts
 var import_promises = require("node:readline/promises");
@@ -5025,14 +5467,14 @@ function coerceComputerConfig(raw) {
   }
   return cfg;
 }
-function readJsonObject(path8) {
+function readJsonObject(path9) {
   let raw;
   try {
-    raw = (0, import_node_fs.readFileSync)(path8, "utf8");
+    raw = (0, import_node_fs.readFileSync)(path9, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     process.stderr.write(
-      `[slayzone-config] cannot read ${path8}: ${err instanceof Error ? err.message : String(err)} \u2014 using empty config
+      `[slayzone-config] cannot read ${path9}: ${err instanceof Error ? err.message : String(err)} \u2014 using empty config
 `
     );
     return null;
@@ -5042,61 +5484,61 @@ function readJsonObject(path8) {
     parsed = JSON.parse(raw);
   } catch (err) {
     process.stderr.write(
-      `[slayzone-config] ${path8} is not valid JSON: ${err instanceof Error ? err.message : String(err)} \u2014 using empty config
+      `[slayzone-config] ${path9} is not valid JSON: ${err instanceof Error ? err.message : String(err)} \u2014 using empty config
 `
     );
     return null;
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    process.stderr.write(`[slayzone-config] ${path8} is not a JSON object \u2014 using empty config
+    process.stderr.write(`[slayzone-config] ${path9} is not a JSON object \u2014 using empty config
 `);
     return null;
   }
   return parsed;
 }
-function writeJsonAtomic(path8, data) {
-  const dir = (0, import_node_path.dirname)(path8);
+function writeJsonAtomic(path9, data) {
+  const dir = (0, import_node_path.dirname)(path9);
   (0, import_node_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
-  const tmpPath = `${path8}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path9}.tmp-${process.pid}-${Date.now()}`;
   (0, import_node_fs.writeFileSync)(tmpPath, `${JSON.stringify(data, null, 2)}
 `, { mode: 384 });
   try {
-    (0, import_node_fs.renameSync)(tmpPath, path8);
+    (0, import_node_fs.renameSync)(tmpPath, path9);
   } catch (err) {
     (0, import_node_fs.rmSync)(tmpPath, { force: true });
     throw err;
   }
 }
-function loadComputerConfigFile(path8 = getComputerConfigFilePath()) {
-  const raw = readJsonObject(path8);
+function loadComputerConfigFile(path9 = getComputerConfigFilePath()) {
+  const raw = readJsonObject(path9);
   if (raw) return coerceComputerConfig(raw);
-  const legacy = readJsonObject(legacyConfigFilePathFor(path8));
+  const legacy = readJsonObject(legacyConfigFilePathFor(path9));
   return legacy ? coerceComputerConfig(legacy) : {};
 }
-function ignoredComputerConfigKeys(path8 = getComputerConfigFilePath()) {
-  const raw = readJsonObject(path8) ?? readJsonObject(legacyConfigFilePathFor(path8));
+function ignoredComputerConfigKeys(path9 = getComputerConfigFilePath()) {
+  const raw = readJsonObject(path9) ?? readJsonObject(legacyConfigFilePathFor(path9));
   if (!raw) return [];
   return IGNORED_COMPUTER_CONFIG_KEYS.filter((key) => raw[key] !== void 0);
 }
-function saveComputerConfigFile(cfg, path8 = getComputerConfigFilePath()) {
-  writeJsonAtomic(path8, cfg);
+function saveComputerConfigFile(cfg, path9 = getComputerConfigFilePath()) {
+  writeJsonAtomic(path9, cfg);
 }
-function updateComputerConfigFile(patch, path8 = getComputerConfigFilePath()) {
-  const current = readJsonObject(path8);
+function updateComputerConfigFile(patch, path9 = getComputerConfigFilePath()) {
+  const current = readJsonObject(path9);
   const merged = current ? coerceComputerConfig(current) : {};
   for (const [k, v] of Object.entries(patch)) {
     if (v !== void 0) merged[k] = v;
   }
-  saveComputerConfigFile(merged, path8);
+  saveComputerConfigFile(merged, path9);
   return merged;
 }
-function updateJsonFile(patch, path8) {
-  const current = readJsonObject(path8) ?? {};
+function updateJsonFile(patch, path9) {
+  const current = readJsonObject(path9) ?? {};
   const merged = { ...current };
   for (const [k, v] of Object.entries(patch)) {
     if (v !== void 0) merged[k] = v;
   }
-  writeJsonAtomic(path8, merged);
+  writeJsonAtomic(path9, merged);
 }
 
 // ../../shared/platform/src/config-prompt.ts
@@ -5168,10 +5610,10 @@ function isLoopbackAuthority(addr) {
     return false;
   }
 }
-function hubUrlFromAddr(addr, kind, path8 = "") {
+function hubUrlFromAddr(addr, kind, path9 = "") {
   const secure = !isLoopbackAuthority(addr);
   const scheme = kind === "ws" ? secure ? "wss" : "ws" : secure ? "https" : "http";
-  return `${scheme}://${addr}${path8}`;
+  return `${scheme}://${addr}${path9}`;
 }
 function isLoopbackComputerUrl(url2) {
   let host;
@@ -5183,6 +5625,68 @@ function isLoopbackComputerUrl(url2) {
   return LOOPBACK_HOSTS.has(host) || host.startsWith("127.");
 }
 
+// ../../shared/platform/src/parent-watch.ts
+var PARENT_POLL_INTERVAL_MS = 1e3;
+var SUPERVISED_STOP_DEADLINE_MS = 5e3;
+var SUPERVISED_STOP_SIGKILL_GRACE_MS = SUPERVISED_STOP_DEADLINE_MS + 1e3;
+function pidExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function isBrokenPipe(err) {
+  return err?.code === "EPIPE";
+}
+function watchParent(opts) {
+  const stdin2 = opts.stdin ?? process.stdin;
+  const outputs = opts.outputs ?? [process.stdout, process.stderr];
+  const getPpid = opts.getPpid ?? (() => process.ppid);
+  const isAlive = opts.isAlive ?? pidExists;
+  const platform3 = opts.platform ?? process.platform;
+  const parentPid = getPpid();
+  let armed = true;
+  let poll = null;
+  const stop = () => {
+    armed = false;
+    if (poll) clearInterval(poll);
+    poll = null;
+  };
+  const fire = (reason) => {
+    if (!armed) return;
+    stop();
+    opts.onParentDeath(reason);
+  };
+  const onPipeClosed = () => fire("parent-pipe-closed");
+  stdin2.on("end", onPipeClosed);
+  stdin2.on("close", onPipeClosed);
+  stdin2.on("error", onPipeClosed);
+  stdin2.resume();
+  stdin2.unref?.();
+  for (const output2 of outputs) {
+    output2.on("error", (err) => {
+      if (!isBrokenPipe(err)) throw err;
+      fire("parent-output-closed");
+    });
+  }
+  const check2 = () => {
+    const ppid = getPpid();
+    if (ppid !== parentPid || platform3 !== "win32" && ppid === 1) {
+      fire("parent-reparented");
+      return;
+    }
+    if (!isAlive(parentPid)) fire("parent-exited");
+  };
+  check2();
+  if (armed) {
+    poll = setInterval(check2, opts.pollIntervalMs ?? PARENT_POLL_INTERVAL_MS);
+    poll.unref();
+  }
+  return { stop };
+}
+
 // ../../domains/computer-transport/src/shared/rpc.ts
 var RpcError = class _RpcError extends Error {
   code;
@@ -5237,16 +5741,23 @@ var DuplexRpc = class {
    * Issue a JSON-RPC request. Resolves with the `result` payload, rejects with
    * `RpcError` on a JSON-RPC error reply, `RpcTimeoutError` on timeout, or
    * `RpcDisposedError` on disposal. `timeoutMs <= 0` disables the timeout.
+   *
+   * `actor`, when given, rides as the envelope's top-level `actor` member (who
+   * asked — hub → computer requests only; see `requestActorSchema`).
    */
-  request(method, params, timeoutMs) {
+  request(method, params, timeoutMs, actor) {
     if (this.disposed) {
       return Promise.reject(new RpcDisposedError(this.label));
     }
     const effectiveTimeout = timeoutMs ?? this.opts.defaultRequestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     const id = this.nextId++;
-    const envelope = JSON.stringify(
-      params === void 0 ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params }
-    );
+    const envelope = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      ...params === void 0 ? {} : { params },
+      ...actor === void 0 ? {} : { actor }
+    });
     return new Promise((resolve7, reject) => {
       const timer = effectiveTimeout > 0 ? setTimeout(() => {
         this.pending.delete(id);
@@ -5322,7 +5833,7 @@ var DuplexRpc = class {
     if (typeof msg.method === "string") {
       if (hasId) {
         if (this.opts.onPeerRequest) {
-          this.opts.onPeerRequest(msg.method, msg.params, rawId);
+          this.opts.onPeerRequest(msg.method, msg.params, rawId, msg.actor);
         } else {
           this.respondError(
             rawId,
@@ -6183,10 +6694,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path8) {
-  if (!path8)
+function getElementAtPath(obj, path9) {
+  if (!path9)
     return obj;
-  return path8.reduce((acc, key) => acc?.[key], obj);
+  return path9.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6526,11 +7037,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path8, issues) {
+function prefixIssues(path9, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path8);
+    iss.path.unshift(path9);
     return iss;
   });
 }
@@ -6980,16 +7491,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path8 = []) => {
+  const processError = (error63, path9 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...issue2.path];
+        const fullpath = [...path9, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -7028,17 +7539,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error63, path8 = []) => {
+  const processError = (error63, path9 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...issue2.path];
+        const fullpath = [...path9, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7077,8 +7588,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path8) {
+  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path9) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -7364,8 +7875,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter2) => {
-  const escapedDelim = escapeRegex(delimiter2 ?? ":");
+var mac = (delimiter3) => {
+  const escapedDelim = escapeRegex(delimiter3 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 };
 var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -18269,8 +18780,8 @@ function registry() {
 var globalRegistry = globalThis.__zod_globalRegistry;
 
 // ../../../node_modules/zod/v4/core/compile.js
-var INVALID = Symbol.for("zod.compile.invalid");
-var FALLBACK_FLAG = Symbol.for("zod.compile.fallback");
+var INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
+var FALLBACK_FLAG = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
 var ZodCompileAsyncError = class extends Error {
   constructor(message = "z.compile does not support async refinements, transforms, or checks") {
     super(message);
@@ -22050,7 +22561,7 @@ var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
-var UNREPRESENTABLE_DEFAULT = Symbol();
+var UNREPRESENTABLE_DEFAULT = /* @__PURE__ */ Symbol();
 function serializeDefaultValue(value, schema, ctx, json2, params) {
   let unrepresentable = false;
   const serialized = JSON.stringify(value, (_, val) => {
@@ -24180,13 +24691,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path8 = ref.slice(1).split("/").filter(Boolean);
-  if (path8.length === 0) {
+  const path9 = ref.slice(1).split("/").filter(Boolean);
+  if (path9.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path8[0] === defsKey) {
-    const key = path8[1] === void 0 ? void 0 : decodeJSONPointerSegment(path8[1]);
+  if (path9[0] === defsKey) {
+    const key = path9[1] === void 0 ? void 0 : decodeJSONPointerSegment(path9[1]);
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -24814,7 +25325,7 @@ function fromJSONSchema(schema, params) {
 }
 
 // ../../../node_modules/zod/v4/core/visit.js
-var RESOLVING = Symbol("z.visit/resolving");
+var RESOLVING = /* @__PURE__ */ Symbol("z.visit/resolving");
 function visit(schema, fnOrHandlers) {
   const fn = typeof fnOrHandlers === "function" ? fnOrHandlers : (node2, rewritten) => {
     const h = fnOrHandlers[node2._zod.def.type];
@@ -25037,7 +25548,7 @@ function date4(params) {
 
 // ../../domains/computer-transport/src/shared/frames.ts
 var COMPUTER_EXIT_NEEDS_RE_ENROLLMENT = 78;
-var COMPUTER_PROTOCOL_VERSION = 2;
+var COMPUTER_PROTOCOL_VERSION = 3;
 var ComputerTransportErrorCodes = {
   /** Command is part of the contract but not implemented by this peer. */
   unimplemented: -32001,
@@ -25053,8 +25564,20 @@ var ComputerTransportErrorCodes = {
    * computer retries, and gets in once the incumbent's connection is gone.
    * Older computers treat any unlisted code as transient too.
    */
-  computerInUse: -32005
+  computerInUse: -32005,
+  /**
+   * The computer refused the request by its own local policy (T-27): a hub-pushed
+   * `allowedRoots` change, or a path / spawn cwd outside its `allowedRoots`. Not
+   * transient — retrying the same request is refused again. The hub audits it as
+   * `denied` and the message says what to do on the device.
+   */
+  refusedByComputer: -32006
 };
+var requestActorSchema = external_exports.object({
+  userId: external_exports.string().min(1).max(200).nullable(),
+  /** `trpc <path>` / `METHOD /path` the request entered the hub through. */
+  route: external_exports.string().max(200).nullable()
+});
 var ComputerToHubMethods = {
   enroll: "enroll",
   hello: "hello",
@@ -25078,15 +25601,25 @@ var enrollParamsSchema = external_exports.object({
 });
 var enrollResultSchema = external_exports.object({
   computerId: external_exports.string().min(1),
-  apiKey: external_exports.string().min(1)
+  apiKey: external_exports.string().min(1),
+  /** The hub's protocol version (v3+). Absent = an older hub; the computer refuses it. */
+  protocolVersion: external_exports.number().int().positive().optional()
 });
 var helloParamsSchema = external_exports.object({
   apiKey: external_exports.string().min(1),
   epoch: epochField,
-  hostId: hostIdField
+  hostId: hostIdField,
+  /**
+   * v3+. Before v3 only `enroll` carried a version, so a computer enrolled long ago
+   * reconnected on any protocol. Absent = a pre-v3 computer; a v3 hub refuses it
+   * with `protocolMismatch`.
+   */
+  protocolVersion: external_exports.number().int().positive().optional()
 });
 var helloResultSchema = external_exports.object({
-  computerId: external_exports.string().min(1)
+  computerId: external_exports.string().min(1),
+  /** The hub's protocol version (v3+). Absent = an older hub; the computer refuses it. */
+  protocolVersion: external_exports.number().int().positive().optional()
 });
 var heartbeatParamsSchema = external_exports.object({
   /** Sender wall-clock ms, for skew diagnostics. */
@@ -25161,6 +25694,8 @@ var HubToComputerMethods = {
   ptyList: "pty.list",
   /** Move a session still waiting for an agent-start slot to the front (tab revealed). */
   ptyPrioritize: "pty.prioritize",
+  /** Which of claude's background jobs still have a live process under a session. */
+  ptyBackgroundJobs: "pty.backgroundJobs",
   // warm pool (pre-warmed agents live ON the computer — see server/warm-*)
   ptyWarmSpawn: "pty.warmSpawn",
   ptyWarmAdopt: "pty.warmAdopt",
@@ -25281,6 +25816,21 @@ var ptyPrioritizeResultSchema = external_exports.object({
   ok: external_exports.literal(true),
   queued: external_exports.boolean()
 });
+var ptyBackgroundJobsParamsSchema = external_exports.object({
+  sessionId: external_exports.string().min(1),
+  jobs: external_exports.array(
+    external_exports.object({
+      id: external_exports.string().min(1),
+      kind: external_exports.enum(["shell", "monitor"]),
+      command: external_exports.string().nullable()
+    })
+  ).max(256)
+});
+var ptyBackgroundJobsResultSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  supported: external_exports.boolean(),
+  alive: external_exports.array(external_exports.string())
+});
 var ptyResizeParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
   cols: external_exports.number().int().positive(),
@@ -26007,7 +26557,7 @@ var HubDialer = class {
       write: (line) => {
         ws.send(line);
       },
-      onPeerRequest: (method, params, id) => this.handleHubRequest(conn, method, params, id),
+      onPeerRequest: (method, params, id, actor) => this.handleHubRequest(conn, method, params, id, actor),
       onNotification: (method, params) => this.events.emit("notification", { method, params }),
       onParseError: (line, err) => {
         this.log("computer dialer received malformed frame", { error: String(err), line });
@@ -26048,6 +26598,22 @@ var HubDialer = class {
     });
     return enrollResultSchema.parse(raw);
   }
+  /**
+   * v3 (T-27): refuse a hub that does not echo our protocol version. Only a hub
+   * older than v3 omits it, and such a hub sends no actor with its requests, so
+   * nothing it asked for could be logged against a user. Fatal, like an enroll
+   * mismatch: retrying the same hub cannot fix it; upgrading it does.
+   */
+  hubSpeaksOurProtocol(conn, hubVersion) {
+    if (hubVersion === COMPUTER_PROTOCOL_VERSION) return true;
+    this.fatal(
+      new Error(
+        `hub speaks computer protocol ${hubVersion === void 0 ? "older than v3" : `v${hubVersion}`}, this computer speaks v${COMPUTER_PROTOCOL_VERSION} \u2014 upgrade the hub and this computer to the same SlayZone release`
+      ),
+      conn
+    );
+    return false;
+  }
   async authenticate(conn) {
     this.setState("authenticating");
     try {
@@ -26057,14 +26623,20 @@ var HubDialer = class {
           const raw = await conn.rpc.request(ComputerToHubMethods.hello, {
             apiKey: stored.apiKey,
             epoch: this.epoch,
+            protocolVersion: COMPUTER_PROTOCOL_VERSION,
             // Reconnect is the ONLY moment the hub can learn that this computer
             // adopted a peer's host id while it was offline.
             ...this.opts.identity.hostId ? { hostId: this.opts.identity.hostId } : {}
           });
           const result2 = helloResultSchema.parse(raw);
+          if (!this.hubSpeaksOurProtocol(conn, result2.protocolVersion)) return;
           this.onAuthenticated(conn, result2.computerId, "hello");
           return;
         } catch (err) {
+          if (err instanceof RpcError && err.code === ComputerTransportErrorCodes.protocolMismatch) {
+            this.fatal(new Error(`hub refused reconnect: ${err.message}`), conn);
+            return;
+          }
           if (!(err instanceof RpcError) || err.code !== ComputerTransportErrorCodes.unauthorized)
             throw err;
           if (!this.opts.joinToken) {
@@ -26137,6 +26709,7 @@ var HubDialer = class {
           throw retryErr;
         }
       }
+      if (!this.hubSpeaksOurProtocol(conn, result.protocolVersion)) return;
       try {
         await this.opts.credentialStore.save({
           computerId: result.computerId,
@@ -26184,7 +26757,7 @@ var HubDialer = class {
     }, intervalMs);
     conn.heartbeatTimer.unref?.();
   }
-  handleHubRequest(conn, method, params, id) {
+  handleHubRequest(conn, method, params, id, actor) {
     if (method === HubToComputerMethods.ping) {
       conn.rpc.respond(id, { ts: Date.now() });
       return;
@@ -26200,7 +26773,7 @@ var HubDialer = class {
     }
     void (async () => {
       try {
-        const result = await handler(method, params);
+        const result = await handler(method, params, actor);
         conn.rpc.respond(id, result ?? null);
       } catch (err) {
         if (err instanceof RpcError) {
@@ -26311,7 +26884,19 @@ var computerConfigSchema = external_exports.object({
   /** Filesystem roots this computer may operate under (fs./git. commands). */
   allowedRoots: external_exports.array(external_exports.string().min(1)),
   /** Capability tags advertised at enrollment. */
-  capabilities: external_exports.array(external_exports.string().min(1))
+  capabilities: external_exports.array(external_exports.string().min(1)),
+  /**
+   * May a hub change `allowedRoots` (`computer.setAllowedRoots`)? T-27: folder
+   * limits are the device user's decision, so NO by default — set them on the
+   * device (`slay computer roots`, or `computer.config.json`).
+   *
+   * Derived only, in {@link loadComputerConfig}: true for the desktop app's own
+   * supervised computer when every hub it dials is on loopback — there the hub is
+   * the local app (login off, same user, same machine), and it widens the jail for
+   * projects the user adds. No file key and no env var sets it, so nothing a hub
+   * can write turns it on.
+   */
+  hubMayEditRoots: external_exports.boolean().optional()
 });
 var ENV_VARS = {
   // Authority ONLY — `host[:port]`, no scheme, no path. The dial scheme
@@ -26363,13 +26948,36 @@ function realpathBoundary(target) {
     }
   }
 }
-function assertPathAllowed(candidate, allowedRoots) {
+var JailViolationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JailViolationError";
+  }
+};
+var protectedPaths = [];
+function setProtectedPaths(paths) {
+  protectedPaths = paths.map((p) => realpathBoundary(p));
+}
+function isInside(path9, dir) {
+  return path9 === dir || path9.startsWith(dir + import_node_path3.sep);
+}
+function isProtectedPath(absolute) {
+  return protectedPaths.some((guarded) => isInside(absolute, guarded));
+}
+function assertPathAllowed(candidate, allowedRoots, opts = {}) {
   if (allowedRoots.length === 0) {
-    throw new Error(
+    throw new JailViolationError(
       `computer has no allowedRoots configured; refusing filesystem access to '${candidate}'`
     );
   }
   const resolved = realpathBoundary(candidate);
+  for (const guarded of protectedPaths) {
+    if (isInside(resolved, guarded) || opts.subtree && isInside(guarded, resolved)) {
+      throw new JailViolationError(
+        `path '${candidate}' holds this computer's own state (config, credentials or request log); refused`
+      );
+    }
+  }
   for (const root of allowedRoots) {
     let realRoot;
     try {
@@ -26377,14 +26985,24 @@ function assertPathAllowed(candidate, allowedRoots) {
     } catch {
       continue;
     }
-    if (resolved === realRoot || resolved.startsWith(realRoot + import_node_path3.sep)) {
+    if (isInside(resolved, realRoot)) {
       return resolved;
     }
   }
-  throw new Error(
+  throw new JailViolationError(
     `path '${candidate}' is outside the computer's allowedRoots [${allowedRoots.join(", ")}]`
   );
 }
+function spawnCwd(cwd, allowedRoots) {
+  if (cwd !== void 0) return assertPathAllowed(cwd, allowedRoots);
+  for (const root of allowedRoots) {
+    try {
+      return import_node_fs2.realpathSync.native((0, import_node_path3.resolve)(root));
+    } catch {
+    }
+  }
+  throw new JailViolationError("computer has no existing allowedRoots; refusing to start a process");
+}
 function fromSharedConfig(shared) {
   const out = {};
   if (shared.hubUrl !== void 0) out.hubUrl = shared.hubUrl;
@@ -26419,6 +27037,9 @@ function loadComputerConfig(env = process.env, shared = env === process.env && e
     ...envJoinToken !== void 0 ? { joinToken: envJoinToken } : {}
   };
   const result = computerConfigSchema.safeParse(merged);
+  if (result.success) {
+    result.data.hubMayEditRoots = env.SLAYZONE_SUPERVISED === "1" && effectiveHubUrls(result.data).every((url2) => isLoopbackComputerUrl(url2));
+  }
   if (!result.success) {
     const issues = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
     throw new Error(
@@ -26461,71 +27082,587 @@ function effectiveHubUrls(config2) {
   return [...new Set(all)];
 }
 
-// src/host-id.ts
-var import_node_crypto2 = require("node:crypto");
-var import_promises3 = require("node:fs/promises");
-var import_node_os3 = require("node:os");
-var import_node_path4 = require("node:path");
-function slayzoneRootDir2() {
-  if (process.env.SLAYZONE_ROOT) return process.env.SLAYZONE_ROOT;
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? (0, import_node_os3.homedir)();
-  return (0, import_node_path4.join)(home, ".slayzone");
-}
-function hostIdFilePath(baseDir) {
-  return (0, import_node_path4.join)(baseDir ?? slayzoneRootDir2(), "computer.host.json");
-}
-function legacyHostIdFilePath(baseDir) {
-  return (0, import_node_path4.join)(baseDir ?? slayzoneRootDir2(), "computer.host-id.json");
-}
-function sharedHostIdPath() {
-  return process.platform === "win32" ? null : "/tmp/slayzone-host-id";
-}
-var hostIdFileSchema = external_exports.object({ hostId: external_exports.string().min(1), updatedAt: external_exports.number() });
-async function readDurable(filePath) {
-  try {
-    const parsed = hostIdFileSchema.safeParse(JSON.parse(await (0, import_promises3.readFile)(filePath, "utf-8")));
-    return parsed.success ? parsed.data.hostId : null;
-  } catch {
-    return null;
-  }
-}
-async function writeDurable(filePath, hostId) {
-  await (0, import_promises3.mkdir)((0, import_node_path4.dirname)(filePath), { recursive: true, mode: 448 });
-  const tmpPath = `${filePath}.tmp-${process.pid}`;
-  await (0, import_promises3.writeFile)(tmpPath, `${JSON.stringify({ hostId, updatedAt: Date.now() }, null, 2)}
-`, {
-    mode: 384
-  });
-  try {
-    await (0, import_promises3.rename)(tmpPath, filePath);
-  } catch (err) {
-    await (0, import_promises3.rm)(tmpPath, { force: true });
-    throw err;
-  }
-}
-async function readShared(sharedPath) {
-  try {
-    const raw = (await (0, import_promises3.readFile)(sharedPath, "utf-8")).trim();
-    return raw.length > 0 ? raw : null;
-  } catch {
-    return null;
-  }
-}
-async function writeShared(sharedPath, hostId) {
-  try {
-    const fh2 = await (0, import_promises3.open)(sharedPath, import_promises3.constants.O_WRONLY | import_promises3.constants.O_CREAT | import_promises3.constants.O_EXCL);
-    try {
-      await fh2.chmod(438);
-      await fh2.writeFile(`${hostId}
-`);
-    } finally {
-      await fh2.close();
+// src/login-shell-path.ts
+var import_node_path5 = require("node:path");
+
+// ../../shared/platform/src/index.ts
+init_dirs();
+
+// ../../shared/platform/src/paths.ts
+init_dirs();
+
+// ../../shared/platform/src/hub-switches.ts
+var HUB_SWITCH_ENV = {
+  requireLogin: "SLAYZONE_HUB_REQUIRE_LOGIN",
+  enablePassword: "SLAYZONE_HUB_ENABLE_PASSWORD",
+  enableSso: "SLAYZONE_HUB_ENABLE_SSO",
+  enableProcesses: "SLAYZONE_HUB_ENABLE_PROCESSES",
+  enableIntegrations: "SLAYZONE_HUB_ENABLE_INTEGRATIONS"
+};
+var HUB_SSO_ENV = {
+  tenantId: "SLAYZONE_HUB_SSO_TENANT_ID",
+  clientId: "SLAYZONE_HUB_SSO_CLIENT_ID",
+  /** PEM certificate registered on the Entra app (its SHA-256 thumbprint goes in each assertion). Env only. */
+  certPath: "SLAYZONE_HUB_SSO_CERT_PATH",
+  /** PEM private key of that certificate (RSA, unencrypted). Env only. */
+  keyPath: "SLAYZONE_HUB_SSO_KEY_PATH",
+  /** `0|1`, default `1`: refuse a sign-in whose ID token's `amr` does not contain `mfa`. */
+  requireMfa: "SLAYZONE_HUB_SSO_REQUIRE_MFA"
+};
+var RETIRED_HUB_SSO_CLIENT_SECRET_ENV = "SLAYZONE_HUB_SSO_CLIENT_SECRET";
+var HUB_ADDRESS_ENV = {
+  /** Where the hub LISTENS. Renamed from `SLAYZONE_HUB_ADDRESS`, which now only
+   *  means "the hub to connect to" on a computer / `slay`. */
+  listen: "SLAYZONE_HUB_LISTEN_ADDRESS",
+  /** How OTHER machines reach the hub (`host[:port]`, no scheme). */
+  public: "SLAYZONE_HUB_PUBLIC_ADDRESS",
+  /** Signing key of hub-auth. */
+  authSecret: "SLAYZONE_HUB_AUTH_SECRET"
+};
+var LEGACY_HUB_LISTEN_ENV = "SLAYZONE_HUB_ADDRESS";
+var HUB_SESSION_RETENTION_DAYS_ENV = "SLAYZONE_HUB_SESSION_RETENTION_DAYS";
+var HUB_ALLOWED_WEB_ORIGINS_ENV = "SLAYZONE_HUB_ALLOWED_WEB_ORIGINS";
+var HUB_TRUSTED_PROXIES_ENV = "SLAYZONE_HUB_TRUSTED_PROXIES";
+var HUB_CONVEX_ADDRESS_ENV = "SLAYZONE_HUB_CONVEX_ADDRESS";
+var HUB_PROCESS_ENV = [
+  ...Object.values(HUB_SWITCH_ENV),
+  ...Object.values(HUB_SSO_ENV),
+  RETIRED_HUB_SSO_CLIENT_SECRET_ENV,
+  ...Object.values(HUB_ADDRESS_ENV),
+  LEGACY_HUB_LISTEN_ENV,
+  HUB_ALLOWED_WEB_ORIGINS_ENV,
+  HUB_TRUSTED_PROXIES_ENV,
+  HUB_SESSION_RETENTION_DAYS_ENV,
+  HUB_CONVEX_ADDRESS_ENV
+];
+
+// ../../shared/platform/src/security-log.ts
+var import_node_async_hooks = require("node:async_hooks");
+var LINE_SEPARATOR = String.fromCharCode(8232);
+var PARAGRAPH_SEPARATOR = String.fromCharCode(8233);
+var contextStore = new import_node_async_hooks.AsyncLocalStorage();
+
+// ../../shared/platform/src/hub-switch-refusal.ts
+var MESSAGES = {
+  HUB_PROCESSES_DISABLED: `This hub does not run processes, automation commands, terminals or agents itself (${HUB_SWITCH_ENV.enableProcesses}=0).`,
+  HUB_INTEGRATIONS_DISABLED: `Integrations are switched off on this hub (${HUB_SWITCH_ENV.enableIntegrations}=0).`,
+  NO_COMPUTER_CONNECTED: `Connect a computer: this hub does not read project files or run git, gh or other commands itself (${HUB_SWITCH_ENV.enableProcesses}=0).`,
+  HUB_PASSWORD_DISABLED: `Password sign-in is switched off on this hub (${HUB_SWITCH_ENV.enablePassword}=0).`,
+  HUB_CONVEX_NOT_CONFIGURED: `GitHub sign-in is off on this hub: no Convex deployment is configured (${HUB_CONVEX_ADDRESS_ENV}).`,
+  HUB_CONVEX_MISMATCH: `This hub starts GitHub sign-in only against its own Convex deployment (${HUB_CONVEX_ADDRESS_ENV}); the request named another.`
+};
+var VARIABLES = {
+  HUB_PROCESSES_DISABLED: HUB_SWITCH_ENV.enableProcesses,
+  HUB_INTEGRATIONS_DISABLED: HUB_SWITCH_ENV.enableIntegrations,
+  NO_COMPUTER_CONNECTED: HUB_SWITCH_ENV.enableProcesses,
+  HUB_PASSWORD_DISABLED: HUB_SWITCH_ENV.enablePassword,
+  HUB_CONVEX_NOT_CONFIGURED: HUB_CONVEX_ADDRESS_ENV,
+  HUB_CONVEX_MISMATCH: HUB_CONVEX_ADDRESS_ENV
+};
+
+// ../../shared/platform/src/env-manifest.ts
+var ENV_MANIFEST = {
+  // --- secret: credentials/tokens, never in a terminal ---
+  SLAYZONE_HUB_TOKEN: "secret",
+  // HMAC signing key for ALL of hub-auth (better-auth's session/cookie signer AND
+  // the computer enroll/api-key credentials) — hence `HUB_AUTH`, not the former
+  // `HUB_COMPUTER_TRANSPORT_SECRET`, which named just one of its consumers. Rule 2
+  // (name by what the value IS). `_SECRET` = a key you HOLD and sign with, vs
+  // `_TOKEN` = a bearer you PRESENT (SLAYZONE_HUB_TOKEN above).
+  SLAYZONE_HUB_AUTH_SECRET: "secret",
+  // Hub-scoped by VALUE: the hub mints it, and it embeds the hub's url and a
+  // secret verified against the hub's `join_tokens`
+  // row. `mintJoinToken` binds it to NO computer (computer_id stays NULL until
+  // redemption), so any computer can redeem any unused token — there is no computer in
+  // the value to name. Rule 2 (name by what the value IS, not who reads it).
+  SLAYZONE_HUB_JOIN_TOKEN: "secret",
+  // Retired before it was ever read: Entra sign-in authenticates with a certificate
+  // (SLAYZONE_HUB_SSO_CERT_PATH / _KEY_PATH below), and boot refuses a hub that still
+  // sets this (B7). Still classified `secret` so a leftover value never reaches a
+  // terminal or a log.
+  SLAYZONE_HUB_SSO_CLIENT_SECRET: "secret",
+  // Per-boot bearer the desktop's `/cap` listener requires on every connection
+  // (desktop-bridge-server.ts `verifyClient`). Loopback is NOT trusted there —
+  // the threat this closes is another loopback process finding the port — so
+  // this is a real credential, `secret`-scoped like the two above it.
+  SLAYZONE_DESKTOP_BRIDGE_TOKEN: "secret",
+  // The pre-rename `SLAYZONE_RUNNER_JOIN_TOKEN` is deliberately UNLISTED: it is
+  // retired, not aliased. It never shipped (the published computer betas read
+  // `SLAYZONE_JOIN_TOKEN`), so no operator env carries it and there is nothing to
+  // keep working. Unlisted ⇒ the fail-closed default strips it, same as every
+  // other retired name in this rename sweep.
+  // --- infra: SlayZone wiring a terminal must not reinterpret ---
+  // The hub to CONNECT to, host[:port] (computer, `slay`); the scheme derives from
+  // the host (loopback → http/ws, else https/wss). A hub no longer reads this name:
+  // it LISTENS on SLAYZONE_HUB_LISTEN_ADDRESS, and a hub that still gets the old
+  // name refuses to boot. Stripping both here keeps a terminal's dial address from
+  // ever being mistaken for another process's listen address.
+  SLAYZONE_HUB_ADDRESS: "infra",
+  SLAYZONE_HUB_LISTEN_ADDRESS: "infra",
+  // hub-only; where the hub listens
+  SLAYZONE_HUB_PUBLIC_ADDRESS: "infra",
+  // hub-only; how other machines reach it, written into join tokens
+  // Hub-only; the front ends (IPs/CIDRs, comma-separated) whose X-Forwarded-For names
+  // the client (client-address.ts). Not `_ADDRESS`: these are networks, not an authority.
+  SLAYZONE_HUB_TRUSTED_PROXIES: "infra",
+  // Per-hub switches (0|1) replacing SLAYZONE_MODE. Infra: they describe THIS hub
+  // process, so a task terminal must not inherit them (a hub started from one would
+  // otherwise pick up its parent's switches by accident).
+  SLAYZONE_HUB_REQUIRE_LOGIN: "infra",
+  SLAYZONE_HUB_ENABLE_PASSWORD: "infra",
+  SLAYZONE_HUB_ENABLE_SSO: "infra",
+  SLAYZONE_HUB_ENABLE_PROCESSES: "infra",
+  SLAYZONE_HUB_ENABLE_INTEGRATIONS: "infra",
+  SLAYZONE_HUB_SSO_TENANT_ID: "infra",
+  SLAYZONE_HUB_SSO_CLIENT_ID: "infra",
+  // Paths to the Entra client certificate and its private key, and the MFA switch.
+  // Infra, not secret: a path is not the key (the file's own permissions protect it),
+  // but a task terminal must still never inherit a hub's SSO wiring.
+  SLAYZONE_HUB_SSO_CERT_PATH: "infra",
+  SLAYZONE_HUB_SSO_KEY_PATH: "infra",
+  SLAYZONE_HUB_SSO_REQUIRE_MFA: "infra",
+  // Operator-facing hub name (`slay hub ls`/`stop` address a hub by it). Infra,
+  // not global: it identifies THIS hub process, so inheriting it into a task
+  // terminal — which may target a different hub entirely — would mislabel.
+  SLAYZONE_HUB_NAME: "infra",
+  // Days THIS hub keeps session content (T-23, hub session-retention.ts); 0 = off, the
+  // default. Infra like the switches: a hub started from a task terminal must not
+  // inherit its parent's period and start deleting.
+  SLAYZONE_HUB_SESSION_RETENTION_DAYS: "infra",
+  // The Convex deployment (host[:port]) the hub starts GitHub sign-in against — never
+  // a client-named one (T-99). Hub process config, set by the desktop app for its hub.
+  SLAYZONE_HUB_CONVEX_ADDRESS: "infra",
+  SLAYZONE_DESKTOP_BRIDGE_ADDRESS: "infra",
+  // sidecar→desktop capability bridge + REST proxy
+  SLAYZONE_SUPERVISED: "infra",
+  // "started by the desktop app" flag
+  SLAYZONE_USER_DATA_DIR: "infra",
+  // Playwright Electron userData redirect
+  SLAYZONE_SIDECAR_HOT_RESTART: "infra",
+  SLAYZONE_BOOT_LOG_PATH: "infra",
+  SLAYZONE_DEBUG_BOOT: "infra",
+  SLAYZONE_REGISTER_DEV_PROTOCOL: "infra",
+  SLAYZONE_NONINTERACTIVE: "infra",
+  // Historical opt-IN, now a NO-OP: e2e runs computer-ON by default, so the boot
+  // gate no longer reads this. Kept manifested because specs still set it to
+  // document "this spec wants a computer" (an unmanifested var would be stripped
+  // by sanitizeSpawnEnv, fail-closed, and read as a silent typo).
+  SLAYZONE_E2E_ALLOW_COMPUTER: "infra",
+  // Opt-OUT, and the only lever that changes behavior now: set by the specs that
+  // must boot computer-less (remote-mode, sidecar-crash, and the "hub accepts
+  // computers with none spawned" contract test).
+  SLAYZONE_E2E_NO_COMPUTER: "infra",
+  SLAYZONE_E2E_INSTALL_HOOKS: "infra",
+  // Redirects the MACHINE-WIDE ~/.slayzone (hooks/, bin/) — the files shared by
+  // every SlayZone process on the box, which deliberately do NOT follow
+  // SLAYZONE_ROOT. Sandbox redirect for tests, same role as the per-provider
+  // overrides below. `infra`: a spawned terminal must never inherit it, or an
+  // agent would resolve a different notify.sh than the one wired into its hooks.
+  SLAYZONE_MACHINE_DIR: "infra",
+  // per-provider config/hook/plugin path overrides (test/sandbox redirects)
+  SLAYZONE_CLAUDE_SETTINGS_PATH: "infra",
+  SLAYZONE_GEMINI_SETTINGS_PATH: "infra",
+  SLAYZONE_CODEX_HOOKS_PATH: "infra",
+  SLAYZONE_ANTIGRAVITY_HOOKS_PATH: "infra",
+  SLAYZONE_OPENCODE_PLUGIN_PATH: "infra",
+  // --- identity: per-task/agent; overlay re-adds the correct value per spawn ---
+  SLAYZONE_TASK_ID: "identity",
+  SLAYZONE_PROJECT_ID: "identity",
+  // `SLAYZONE_SESSION_ID` (a warm agent's pre-task identity) is RETIRED and
+  // deliberately unlisted: warm agents boot with SLAYZONE_TASK_ID now.
+  SLAYZONE_AGENT_ID: "identity",
+  SLAYZONE_AGENT_HOOK_URL: "identity",
+  // Pairs with _HOOK_URL (where to post / who is posting). The pre-v4 name
+  // `SLAYZONE_HOOK_CONTEXT` is RETIRED and deliberately unlisted: unlisted =
+  // stripped (fail closed), and the old-name value an older release channel's app
+  // supplies rides its OWN per-spawn overlay (applied after sanitizeSpawnEnv), so
+  // notify.sh v4's fallback read still sees it. A manifest entry would only let a
+  // stale inherited value survive.
+  SLAYZONE_AGENT_HOOK_CONTEXT: "identity",
+  // --- global: same app-wide, safe to inherit verbatim ---
+  SLAYZONE_RELEASE_CHANNEL: "global",
+  // attribution-only (hook envelope channel)
+  // INSTALL IDENTITY — which SlayZone install this process tree belongs to, not
+  // which task/session. A child MUST resolve the SAME install as its parent: the
+  // `slay` CLI derives its DB from BOTH (getStorageDir() reads ROOT; the
+  // filename is `slayzone{.dev}.sqlite` per DEV — apps/cli/src/db.ts getDbPath).
+  // Strip either and a bare `slay` in a dev-app task terminal exits 1
+  // ("Database not found … Re-run with --dev"), and under an isolated e2e ROOT a
+  // child would escape the sandbox to the real ~/.slayzone. Neither is a
+  // credential and neither can be reinterpreted as a different kind of target
+  // (unlike a hub address), so both inherit verbatim.
+  //
+  // ROOT is NOT covered by the identity overlay: buildMcpEnv sets it only inside
+  // setHookIdentity(), gated on a hook-capable agent mode — a plain `terminal`
+  // PTY, a non-hook agent, or a pre-warmed pool spawn gets no overlay at all.
+  SLAYZONE_ROOT: "global",
+  SLAYZONE_DEV: "global"
+};
+var NON_PREFIXED_INFRA = /* @__PURE__ */ new Set([
+  "ELECTRON_RUN_AS_NODE",
+  "NODE_PATH",
+  "PLAYWRIGHT"
+]);
+function sanitizeSpawnEnv(base) {
+  const out = {};
+  for (const [key, value] of Object.entries(base)) {
+    if (typeof value !== "string") continue;
+    if (NON_PREFIXED_INFRA.has(key)) continue;
+    if (key.startsWith("SLAYZONE_")) {
+      if (ENV_MANIFEST[key] === "global") out[key] = value;
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+// ../../shared/platform/src/index.ts
+init_fs_utils();
+
+// ../../shared/platform/src/migrations.ts
+init_dirs();
+
+// ../../shared/platform/src/cli-install.ts
+var import_child_process = require("child_process");
+var import_util9 = require("util");
+var execFileAsync = (0, import_util9.promisify)(import_child_process.execFile);
+var WINDOWS_SHIM = [
+  "@echo off",
+  `for /f "tokens=1 delims=." %%v in ('node -e "process.stdout.write(process.versions.node)"') do set NODE_MAJOR=%%v`,
+  "if %NODE_MAJOR% LEQ 22 (",
+  '  node --experimental-sqlite --no-warnings "%~dp0slay.js" %*',
+  ") else (",
+  '  node --no-warnings "%~dp0slay.js" %*',
+  ")",
+  ""
+].join("\r\n");
+
+// ../../shared/platform/src/shell.ts
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_os2 = require("os");
+var shellOverride = null;
+function shellExists(shellPath) {
+  if ((0, import_os2.platform)() === "win32") return import_node_fs3.default.existsSync(shellPath);
+  try {
+    import_node_fs3.default.accessSync(shellPath, import_node_fs3.default.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function defaultShellForPlatform() {
+  if ((0, import_os2.platform)() === "win32") return process.env.COMSPEC || "cmd.exe";
+  if ((0, import_os2.platform)() === "darwin") return "/bin/zsh";
+  return "/bin/bash";
+}
+function resolveUserShell() {
+  if (shellOverride && shellExists(shellOverride)) return shellOverride;
+  const fromEnv = process.env.SHELL?.trim();
+  if (fromEnv && shellExists(fromEnv)) return fromEnv;
+  try {
+    const fromUser = (0, import_os2.userInfo)().shell?.trim();
+    if (fromUser && shellExists(fromUser)) return fromUser;
+  } catch {
+  }
+  return defaultShellForPlatform();
+}
+function getShellStartupArgs(shellPath) {
+  if ((0, import_os2.platform)() === "win32") return [];
+  const shell = shellPath.toLowerCase();
+  const name = shell.split("/").pop() ?? shell;
+  if (name === "zsh" || name === "bash" || name === "fish") {
+    return ["-i", "-l"];
+  }
+  return [];
+}
+function buildShellInvocation(command) {
+  const shell = resolveUserShell();
+  if ((0, import_os2.platform)() === "win32") return { file: shell, args: ["/c", command] };
+  const isFish = shell.endsWith("/fish");
+  return { file: shell, args: [...isFish ? ["-i", "-l"] : ["-l"], "-c", command] };
+}
+
+// ../../shared/platform/src/process-tree.ts
+var import_node_child_process = require("node:child_process");
+var PROCESS_TREE_DETACHED = process.platform !== "win32";
+function killPidTree(pid, signal = "SIGTERM") {
+  if (process.platform === "win32") {
+    try {
+      (0, import_node_child_process.execFileSync)("taskkill", ["/T", "/F", "/PID", String(pid)]);
+    } catch {
+    }
+  } else {
+    try {
+      process.kill(-pid, signal);
+    } catch {
+    }
+  }
+}
+
+// ../../shared/platform/src/login-shell-path.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_os3 = require("node:os");
+var import_node_path4 = __toESM(require("node:path"), 1);
+var LOGIN_SHELL_PATH_MARKER = "__SLAYZONE_PATH__";
+var LOGIN_SHELL_PATH_PROBE_TIMEOUT_MS = 5e3;
+function loginShellPathProbes(shell) {
+  if ((0, import_node_os3.platform)() === "win32") return [];
+  const value = shell.endsWith("/fish") ? '(string join ":" $PATH)' : '"$PATH"';
+  const cmd = `printf '\\n${LOGIN_SHELL_PATH_MARKER}%s\\n' ${value}`;
+  return [
+    // Interactive login first — sources .zshrc/.bashrc where pnpm/nvm add PATH
+    { file: shell, args: [...getShellStartupArgs(shell), "-c", cmd] },
+    // Fallback: login only — sources .zprofile/.bash_profile
+    { file: shell, args: ["-l", "-c", cmd] }
+  ];
+}
+function parseLoginShellPathOutput(stdout2) {
+  for (const line of stdout2.split(/\r?\n/).reverse()) {
+    if (!line.startsWith(LOGIN_SHELL_PATH_MARKER)) continue;
+    return line.slice(LOGIN_SHELL_PATH_MARKER.length).trim() || null;
+  }
+  return null;
+}
+function mergePathLists(primary, secondary) {
+  const entries = /* @__PURE__ */ new Set();
+  for (const entry of [
+    ...primary.split(import_node_path4.default.delimiter),
+    ...(secondary ?? "").split(import_node_path4.default.delimiter)
+  ]) {
+    if (entry) entries.add(entry);
+  }
+  return [...entries].join(import_node_path4.default.delimiter);
+}
+function runProbe(probe, env) {
+  return new Promise((resolve7) => {
+    const child = (0, import_node_child_process2.execFile)(
+      probe.file,
+      probe.args,
+      { encoding: "utf-8", timeout: LOGIN_SHELL_PATH_PROBE_TIMEOUT_MS, env },
+      (err, stdout2) => resolve7(err ? null : parseLoginShellPathOutput(stdout2))
+    );
+    child.stdin?.end();
+  });
+}
+async function probeLoginShellPath(opts = {}) {
+  for (const probe of loginShellPathProbes(opts.shell ?? resolveUserShell())) {
+    const probed = await runProbe(probe, opts.env ?? process.env);
+    if (probed) return probed;
+  }
+  return null;
+}
+
+// ../../shared/platform/src/slz-file-url.ts
+var SLZ_FILE_HOST = "app";
+var SLZ_FILE_PREFIX = `slz-file://${SLZ_FILE_HOST}`;
+
+// ../../shared/platform/src/ipc-dedup.ts
+var UNCHANGED = Object.freeze({ __ipc_unchanged__: true });
+
+// src/login-shell-path.ts
+async function adoptLoginShellPath(opts = {}) {
+  const env = opts.env ?? process.env;
+  const probed = await probeLoginShellPath({ env, ...opts.shell ? { shell: opts.shell } : {} });
+  if (!probed) return null;
+  const before = new Set((env.PATH ?? "").split(import_node_path5.delimiter));
+  env.PATH = mergePathLists(probed, env.PATH);
+  return { added: env.PATH.split(import_node_path5.delimiter).filter((entry) => !before.has(entry)) };
+}
+
+// src/main.ts
+var import_node_fs10 = require("node:fs");
+var import_node_path13 = require("node:path");
+
+// src/request-log.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path6 = require("node:path");
+var REQUEST_LOG_DIR_NAME = "request-log";
+var REQUEST_LOG_FILE_NAME = "requests.log";
+var DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+var DEFAULT_KEEP = 9;
+var MAX_STRING = 300;
+function clip(value) {
+  if (typeof value !== "string") return void 0;
+  return value.length > MAX_STRING ? `${value.slice(0, MAX_STRING)}\u2026` : value;
+}
+function programName(command) {
+  if (typeof command !== "string") return void 0;
+  const first = command.trim().split(/\s+/)[0] ?? "";
+  const base = first.split(/[\\/]/).pop() ?? "";
+  return /^[A-Za-z0-9._+-]{1,64}$/.test(base) ? base : void 0;
+}
+function ghSubcommand(args) {
+  if (!Array.isArray(args)) return void 0;
+  const words = [];
+  for (const a of args.slice(0, 2)) {
+    if (typeof a !== "string" || !/^[a-z][a-z-]{0,31}$/.test(a)) break;
+    words.push(a);
+  }
+  return words.length > 0 ? words.join(" ") : void 0;
+}
+var TARGET_KEYS = [
+  "sessionId",
+  "warmId",
+  "watchId",
+  "projectId",
+  "cwd",
+  "path",
+  "rootPath",
+  "filePath",
+  "dirPath",
+  "targetPath",
+  "oldPath",
+  "newPath",
+  "srcPath",
+  "destPath",
+  "absoluteSrc",
+  "targetDir",
+  "repoPath",
+  "projectPath",
+  "worktreePath",
+  "branch",
+  "signal"
+];
+function summarizeTarget(method, params) {
+  if (params === null || typeof params !== "object") return {};
+  const p = params;
+  const out = {};
+  for (const key of TARGET_KEYS) {
+    const v = clip(p[key]);
+    if (v !== void 0) out[key] = v;
+  }
+  const program = programName(p.command);
+  if (program) out.program = program;
+  if (p.shell === true) out.shell = true;
+  if (method === "gh.exec") {
+    const sub = ghSubcommand(p.args);
+    if (sub) out.subcommand = sub;
+  }
+  if (Array.isArray(p.roots)) {
+    out.roots = p.roots.slice(0, 20).map(clip).filter((r) => r !== void 0);
+  }
+  return out;
+}
+function createRequestLog(opts) {
+  const dir = (0, import_node_path6.join)(opts.stateDir, REQUEST_LOG_DIR_NAME);
+  const filePath = (0, import_node_path6.join)(dir, REQUEST_LOG_FILE_NAME);
+  const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+  const keep = Math.max(1, opts.keep ?? DEFAULT_KEEP);
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true, mode: 448 });
+  (0, import_node_fs4.chmodSync)(dir, 448);
+  (0, import_node_fs4.closeSync)((0, import_node_fs4.openSync)(filePath, "a", 384));
+  (0, import_node_fs4.chmodSync)(filePath, 384);
+  let size = (0, import_node_fs4.statSync)(filePath).size;
+  const rotate = () => {
+    for (let i = keep - 1; i >= 1; i--) {
+      try {
+        (0, import_node_fs4.renameSync)(`${filePath}.${i}`, `${filePath}.${i + 1}`);
+      } catch {
+      }
+    }
+    (0, import_node_fs4.renameSync)(filePath, `${filePath}.1`);
+    size = 0;
+  };
+  const append = (line) => {
+    const fd = (0, import_node_fs4.openSync)(filePath, "a", 384);
+    try {
+      (0, import_node_fs4.writeSync)(fd, line);
+    } finally {
+      (0, import_node_fs4.closeSync)(fd);
+    }
+    size += Buffer.byteLength(line);
+  };
+  return {
+    filePath,
+    record(entry) {
+      try {
+        const line = `${JSON.stringify({
+          ts: now().toISOString(),
+          hub: entry.hub,
+          method: entry.method,
+          actor: entry.actor,
+          target: summarizeTarget(entry.method, entry.params),
+          result: entry.result,
+          ...entry.code !== void 0 ? { code: entry.code } : {},
+          ...entry.reason !== void 0 ? { reason: clip(entry.reason) } : {}
+        })}
+`;
+        if (size > 0 && size + Buffer.byteLength(line) > maxBytes) rotate();
+        append(line);
+      } catch (err) {
+        opts.onError?.(err);
+      }
+    }
+  };
+}
+
+// src/host-id.ts
+var import_node_crypto2 = require("node:crypto");
+var import_promises4 = require("node:fs/promises");
+var import_node_os4 = require("node:os");
+var import_node_path7 = require("node:path");
+function slayzoneRootDir2() {
+  if (process.env.SLAYZONE_ROOT) return process.env.SLAYZONE_ROOT;
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? (0, import_node_os4.homedir)();
+  return (0, import_node_path7.join)(home, ".slayzone");
+}
+function hostIdFilePath(baseDir) {
+  return (0, import_node_path7.join)(baseDir ?? slayzoneRootDir2(), "computer.host.json");
+}
+function legacyHostIdFilePath(baseDir) {
+  return (0, import_node_path7.join)(baseDir ?? slayzoneRootDir2(), "computer.host-id.json");
+}
+function sharedHostIdPath() {
+  return process.platform === "win32" ? null : "/tmp/slayzone-host-id";
+}
+var hostIdFileSchema = external_exports.object({ hostId: external_exports.string().min(1), updatedAt: external_exports.number() });
+async function readDurable(filePath) {
+  try {
+    const parsed = hostIdFileSchema.safeParse(JSON.parse(await (0, import_promises4.readFile)(filePath, "utf-8")));
+    return parsed.success ? parsed.data.hostId : null;
+  } catch {
+    return null;
+  }
+}
+async function writeDurable(filePath, hostId) {
+  await (0, import_promises4.mkdir)((0, import_node_path7.dirname)(filePath), { recursive: true, mode: 448 });
+  const tmpPath = `${filePath}.tmp-${process.pid}`;
+  await (0, import_promises4.writeFile)(tmpPath, `${JSON.stringify({ hostId, updatedAt: Date.now() }, null, 2)}
+`, {
+    mode: 384
+  });
+  try {
+    await (0, import_promises4.rename)(tmpPath, filePath);
+  } catch (err) {
+    await (0, import_promises4.rm)(tmpPath, { force: true });
+    throw err;
+  }
+}
+async function readShared(sharedPath) {
+  try {
+    const raw = (await (0, import_promises4.readFile)(sharedPath, "utf-8")).trim();
+    return raw.length > 0 ? raw : null;
+  } catch {
+    return null;
+  }
+}
+async function writeShared(sharedPath, hostId) {
+  try {
+    const fh2 = await (0, import_promises4.open)(sharedPath, import_promises4.constants.O_WRONLY | import_promises4.constants.O_CREAT | import_promises4.constants.O_EXCL);
+    try {
+      await fh2.chmod(438);
+      await fh2.writeFile(`${hostId}
+`);
+    } finally {
+      await fh2.close();
     }
     return;
   } catch (err) {
     if (err.code !== "EEXIST") throw err;
   }
-  const fh = await (0, import_promises3.open)(sharedPath, import_promises3.constants.O_WRONLY | import_promises3.constants.O_TRUNC);
+  const fh = await (0, import_promises4.open)(sharedPath, import_promises4.constants.O_WRONLY | import_promises4.constants.O_TRUNC);
   try {
     await fh.writeFile(`${hostId}
 `);
@@ -26640,50 +27777,50 @@ function createAgentHookServer(ctx) {
 }
 
 // src/handlers/fs.ts
-var import_node_fs4 = require("node:fs");
-var import_promises5 = require("node:fs/promises");
-var import_node_os4 = require("node:os");
-var import_node_path6 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_promises6 = require("node:fs/promises");
+var import_node_os5 = require("node:os");
+var import_node_path9 = require("node:path");
 
 // ../../domains/file-editor/src/server/file-ops.ts
-var fs = __toESM(require("node:fs"), 1);
-var path2 = __toESM(require("node:path"), 1);
-var import_node_child_process = require("node:child_process");
+var fs3 = __toESM(require("node:fs"), 1);
+var path4 = __toESM(require("node:path"), 1);
+var import_node_child_process3 = require("node:child_process");
 var import_ignore = __toESM(require_ignore(), 1);
 var ALWAYS_IGNORED = /* @__PURE__ */ new Set([".git", ".DS_Store"]);
 var MAX_FILE_SIZE = 1 * 1024 * 1024;
 var FORCE_MAX_FILE_SIZE = 10 * 1024 * 1024;
 function assertWithinRoot(root, target) {
-  const resolved = path2.resolve(root, target);
-  if (!resolved.startsWith(path2.resolve(root) + path2.sep) && resolved !== path2.resolve(root)) {
+  const resolved = path4.resolve(root, target);
+  if (!resolved.startsWith(path4.resolve(root) + path4.sep) && resolved !== path4.resolve(root)) {
     throw new Error("Path traversal denied");
   }
   return resolved;
 }
 var ignoreCache = /* @__PURE__ */ new Map();
 function getIgnoreFilter(rootPath) {
-  const root = path2.resolve(rootPath);
-  const gitignorePath = path2.join(root, ".gitignore");
+  const root = path4.resolve(rootPath);
+  const gitignorePath = path4.join(root, ".gitignore");
   let mtime = 0;
   try {
-    mtime = fs.statSync(gitignorePath).mtimeMs;
+    mtime = fs3.statSync(gitignorePath).mtimeMs;
   } catch {
   }
   const cached2 = ignoreCache.get(root);
   if (cached2 && cached2.mtime === mtime) return cached2.ig;
   const ig = (0, import_ignore.default)();
   try {
-    ig.add(fs.readFileSync(gitignorePath, "utf-8"));
+    ig.add(fs3.readFileSync(gitignorePath, "utf-8"));
   } catch {
   }
   ignoreCache.set(root, { ig, mtime });
   return ig;
 }
 function invalidateIgnoreCache(rootPath) {
-  ignoreCache.delete(path2.resolve(rootPath));
+  ignoreCache.delete(path4.resolve(rootPath));
 }
 function isIgnored(rootPath, relativePath, isDir) {
-  if (ALWAYS_IGNORED.has(path2.basename(relativePath))) return true;
+  if (ALWAYS_IGNORED.has(path4.basename(relativePath))) return true;
   const ig = getIgnoreFilter(rootPath);
   return ig.ignores(isDir ? relativePath + "/" : relativePath);
 }
@@ -26691,10 +27828,10 @@ function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function readDir(rootPath, dirPath) {
-  const abs = dirPath ? assertWithinRoot(rootPath, dirPath) : path2.resolve(rootPath);
+  const abs = dirPath ? assertWithinRoot(rootPath, dirPath) : path4.resolve(rootPath);
   let entries;
   try {
-    entries = fs.readdirSync(abs, { withFileTypes: true });
+    entries = fs3.readdirSync(abs, { withFileTypes: true });
   } catch (error62) {
     if (error62?.code === "ENOENT") return [];
     throw error62;
@@ -26705,7 +27842,7 @@ function readDir(rootPath, dirPath) {
     let isDir = e.isDirectory();
     if (symlink) {
       try {
-        isDir = fs.statSync(path2.join(abs, e.name)).isDirectory();
+        isDir = fs3.statSync(path4.join(abs, e.name)).isDirectory();
       } catch {
         return null;
       }
@@ -26725,23 +27862,23 @@ function readDir(rootPath, dirPath) {
 }
 function readFile3(rootPath, filePath, force) {
   const abs = assertWithinRoot(rootPath, filePath);
-  const stat2 = fs.statSync(abs);
+  const stat2 = fs3.statSync(abs);
   if (stat2.size > FORCE_MAX_FILE_SIZE) {
     return { content: null, tooLarge: true, sizeBytes: stat2.size };
   }
   if (!force && stat2.size > MAX_FILE_SIZE) {
     return { content: null, tooLarge: true, sizeBytes: stat2.size };
   }
-  return { content: fs.readFileSync(abs, "utf-8") };
+  return { content: fs3.readFileSync(abs, "utf-8") };
 }
 function listAllFiles(rootPath) {
-  const root = path2.resolve(rootPath);
+  const root = path4.resolve(rootPath);
   const ig = getIgnoreFilter(rootPath);
   const results = [];
   function walk(dir, prefix) {
     let entries;
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -26750,7 +27887,7 @@ function listAllFiles(rootPath) {
       if (ALWAYS_IGNORED.has(e.name)) continue;
       if (ig.ignores(e.isDirectory() ? relPath + "/" : relPath)) continue;
       if (e.isDirectory()) {
-        walk(path2.join(dir, e.name), relPath);
+        walk(path4.join(dir, e.name), relPath);
       } else {
         results.push(relPath);
       }
@@ -26761,65 +27898,65 @@ function listAllFiles(rootPath) {
 }
 function writeFile3(rootPath, filePath, content) {
   const abs = assertWithinRoot(rootPath, filePath);
-  fs.mkdirSync(path2.dirname(abs), { recursive: true });
-  fs.writeFileSync(abs, content, "utf-8");
+  fs3.mkdirSync(path4.dirname(abs), { recursive: true });
+  fs3.writeFileSync(abs, content, "utf-8");
 }
 function createFile(rootPath, filePath) {
   const abs = assertWithinRoot(rootPath, filePath);
-  if (fs.existsSync(abs)) throw new Error("File already exists");
-  fs.mkdirSync(path2.dirname(abs), { recursive: true });
-  fs.writeFileSync(abs, "", "utf-8");
+  if (fs3.existsSync(abs)) throw new Error("File already exists");
+  fs3.mkdirSync(path4.dirname(abs), { recursive: true });
+  fs3.writeFileSync(abs, "", "utf-8");
 }
 function createDir(rootPath, dirPath) {
   const abs = assertWithinRoot(rootPath, dirPath);
-  fs.mkdirSync(abs, { recursive: true });
+  fs3.mkdirSync(abs, { recursive: true });
 }
 function renamePath(rootPath, oldPath, newPath) {
   const absOld = assertWithinRoot(rootPath, oldPath);
   const absNew = assertWithinRoot(rootPath, newPath);
-  if (fs.existsSync(absNew)) throw new Error("Target already exists");
-  fs.renameSync(absOld, absNew);
+  if (fs3.existsSync(absNew)) throw new Error("Target already exists");
+  fs3.renameSync(absOld, absNew);
 }
 function deletePath(rootPath, targetPath) {
   const abs = assertWithinRoot(rootPath, targetPath);
-  fs.rmSync(abs, { recursive: true });
+  fs3.rmSync(abs, { recursive: true });
 }
 function copyIn(rootPath, absoluteSrc, targetDir) {
-  const srcResolved = path2.resolve(absoluteSrc);
-  if (!fs.existsSync(srcResolved) || !fs.statSync(srcResolved).isFile()) {
+  const srcResolved = path4.resolve(absoluteSrc);
+  if (!fs3.existsSync(srcResolved) || !fs3.statSync(srcResolved).isFile()) {
     throw new Error("Source is not a file");
   }
-  const ext = path2.extname(srcResolved);
-  const stem = path2.basename(srcResolved, ext);
-  const baseName = path2.basename(srcResolved);
+  const ext = path4.extname(srcResolved);
+  const stem = path4.basename(srcResolved, ext);
+  const baseName = path4.basename(srcResolved);
   const dirRel = (targetDir ?? "").trim();
   if (dirRel) assertWithinRoot(rootPath, dirRel);
   let relPath = dirRel ? `${dirRel}/${baseName}` : baseName;
   let dest = assertWithinRoot(rootPath, relPath);
   let i = 1;
-  while (fs.existsSync(dest)) {
+  while (fs3.existsSync(dest)) {
     const candidate = `${stem} (${i})${ext}`;
     relPath = dirRel ? `${dirRel}/${candidate}` : candidate;
     dest = assertWithinRoot(rootPath, relPath);
     i++;
   }
-  fs.mkdirSync(path2.dirname(dest), { recursive: true });
-  fs.copyFileSync(srcResolved, dest);
+  fs3.mkdirSync(path4.dirname(dest), { recursive: true });
+  fs3.copyFileSync(srcResolved, dest);
   return relPath;
 }
 function copy(rootPath, srcPath, destPath) {
   const absSrc = assertWithinRoot(rootPath, srcPath);
   const absDest = assertWithinRoot(rootPath, destPath);
-  fs.cpSync(absSrc, absDest, { recursive: true });
+  fs3.cpSync(absSrc, absDest, { recursive: true });
 }
 function gitStatus(rootPath) {
-  const root = path2.resolve(rootPath);
-  if (!fs.existsSync(path2.join(root, ".git"))) {
+  const root = path4.resolve(rootPath);
+  if (!fs3.existsSync(path4.join(root, ".git"))) {
     return Promise.resolve({ files: {}, isGitRepo: false });
   }
   return new Promise((resolve7) => {
     const chunks = [];
-    const proc = (0, import_node_child_process.spawn)("git", ["status", "--porcelain"], { cwd: root });
+    const proc = (0, import_node_child_process3.spawn)("git", ["status", "--porcelain"], { cwd: root });
     proc.stdout.on("data", (chunk) => chunks.push(chunk));
     proc.on("error", () => resolve7({ files: {}, isGitRepo: false }));
     proc.on("close", (code) => {
@@ -26857,7 +27994,7 @@ function gitStatus(rootPath) {
 }
 function searchFiles(rootPath, query, options) {
   if (!query) return [];
-  const root = path2.resolve(rootPath);
+  const root = path4.resolve(rootPath);
   const ig = getIgnoreFilter(rootPath);
   const matchCase = options?.matchCase ?? false;
   const useRegex = options?.regex ?? false;
@@ -26875,7 +28012,7 @@ function searchFiles(rootPath, query, options) {
     if (totalMatches >= maxResults) return;
     let entries;
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -26885,7 +28022,7 @@ function searchFiles(rootPath, query, options) {
       if (ALWAYS_IGNORED.has(e.name)) continue;
       if (ig.ignores(e.isDirectory() ? relPath + "/" : relPath)) continue;
       if (e.isDirectory()) {
-        walk(path2.join(dir, e.name), relPath);
+        walk(path4.join(dir, e.name), relPath);
       } else {
         searchFile(root, relPath, pattern, results);
       }
@@ -26893,17 +28030,17 @@ function searchFiles(rootPath, query, options) {
   }
   function searchFile(rootDir, relPath, re, out) {
     if (totalMatches >= maxResults) return;
-    const abs = path2.join(rootDir, relPath);
+    const abs = path4.join(rootDir, relPath);
     let stat2;
     try {
-      stat2 = fs.statSync(abs);
+      stat2 = fs3.statSync(abs);
     } catch {
       return;
     }
     if (stat2.size > MAX_FILE_SIZE) return;
     let content;
     try {
-      content = fs.readFileSync(abs, "utf-8");
+      content = fs3.readFileSync(abs, "utf-8");
     } catch {
       return;
     }
@@ -26928,11 +28065,11 @@ function searchFiles(rootPath, query, options) {
 }
 
 // ../../domains/file-editor/src/server/watcher.ts
-var fs2 = __toESM(require("node:fs"), 1);
-var path3 = __toESM(require("node:path"), 1);
+var fs4 = __toESM(require("node:fs"), 1);
+var path5 = __toESM(require("node:path"), 1);
 var watchers = /* @__PURE__ */ new Map();
 function subscribeFileWatcher(rootPath, listener) {
-  const root = path3.resolve(rootPath);
+  const root = path5.resolve(rootPath);
   const existing = watchers.get(root);
   if (existing) {
     existing.listeners.add(listener);
@@ -26941,11 +28078,11 @@ function subscribeFileWatcher(rootPath, listener) {
   const debounceMap = /* @__PURE__ */ new Map();
   const listeners = /* @__PURE__ */ new Set([listener]);
   try {
-    const watcher = fs2.watch(root, { recursive: true }, (_eventType, filename) => {
+    const watcher = fs4.watch(root, { recursive: true }, (_eventType, filename) => {
       if (!filename) return;
       const relPath = filename.replace(/\\/g, "/");
       if (ignoredSafely(root, relPath)) return;
-      if (path3.basename(relPath) === ".gitignore") {
+      if (path5.basename(relPath) === ".gitignore") {
         invalidateIgnoreCache(root);
       }
       const prev = debounceMap.get(relPath);
@@ -26954,8 +28091,8 @@ function subscribeFileWatcher(rootPath, listener) {
         relPath,
         setTimeout(() => {
           debounceMap.delete(relPath);
-          const abs = path3.join(root, relPath);
-          const exists = fs2.existsSync(abs);
+          const abs = path5.join(root, relPath);
+          const exists = fs4.existsSync(abs);
           const event = {
             type: exists ? "changed" : "deleted",
             root,
@@ -26994,10 +28131,10 @@ function unsubscribe(root, listener) {
 }
 
 // ../../domains/file-editor/src/server/repo-discovery.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_fs3 = require("node:fs");
-var import_promises4 = require("node:fs/promises");
-var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_child_process4 = require("node:child_process");
+var import_node_fs5 = require("node:fs");
+var import_promises5 = require("node:fs/promises");
+var import_node_path8 = __toESM(require("node:path"), 1);
 var DEFAULT_REPO_SCAN_DEPTH = 3;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -27022,7 +28159,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
 ]);
 function git(args, cwd) {
   return new Promise((resolve7, reject) => {
-    (0, import_node_child_process2.execFile)("git", args, { cwd, maxBuffer: 8 * 1024 * 1024 }, (err, stdout2) => {
+    (0, import_node_child_process4.execFile)("git", args, { cwd, maxBuffer: 8 * 1024 * 1024 }, (err, stdout2) => {
       if (err) reject(err);
       else resolve7(stdout2);
     });
@@ -27042,17 +28179,17 @@ async function walkForGitRoots(root, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = await (0, import_promises4.readdir)(dir);
+      entries = await (0, import_promises5.readdir)(dir);
     } catch {
       return;
     }
     await Promise.all(
       entries.map(async (entry) => {
         if (SKIP_DIRS.has(entry) || entry.startsWith(".")) return;
-        const full = import_node_path5.default.join(dir, entry);
+        const full = import_node_path8.default.join(dir, entry);
         let s;
         try {
-          s = await (0, import_promises4.lstat)(full);
+          s = await (0, import_promises5.lstat)(full);
         } catch {
           return;
         }
@@ -27070,7 +28207,7 @@ async function walkForGitRoots(root, maxDepth) {
   return found;
 }
 async function listSubmodules(repoPath) {
-  if (!(0, import_node_fs3.existsSync)(import_node_path5.default.join(repoPath, ".gitmodules"))) return [];
+  if (!(0, import_node_fs5.existsSync)(import_node_path8.default.join(repoPath, ".gitmodules"))) return [];
   let out;
   try {
     out = await git(["submodule", "status", "--recursive"], repoPath);
@@ -27081,13 +28218,13 @@ async function listSubmodules(repoPath) {
   for (const line of out.split("\n")) {
     if (!line.trim()) continue;
     const m = line.match(/^[\s\-+U][0-9a-f]+\s+(\S+)/);
-    if (m) subs.push(import_node_path5.default.join(repoPath, m[1]));
+    if (m) subs.push(import_node_path8.default.join(repoPath, m[1]));
   }
   return subs;
 }
 function nameFor(rootPath, repoPath) {
-  if (repoPath === rootPath) return import_node_path5.default.basename(rootPath);
-  return import_node_path5.default.relative(rootPath, repoPath) || import_node_path5.default.basename(repoPath);
+  if (repoPath === rootPath) return import_node_path8.default.basename(rootPath);
+  return import_node_path8.default.relative(rootPath, repoPath) || import_node_path8.default.basename(repoPath);
 }
 async function discoverRepos(rootPath, maxDepth = DEFAULT_REPO_SCAN_DEPTH) {
   const rootIsGit = await isGitRepoDir(rootPath);
@@ -27100,7 +28237,7 @@ async function discoverRepos(rootPath, maxDepth = DEFAULT_REPO_SCAN_DEPTH) {
         name: nameFor(rootPath, repoPath),
         kind: repoPath === rootPath ? "project-root" : "child-repo",
         parentPath: null,
-        hasGitmodules: (0, import_node_fs3.existsSync)(import_node_path5.default.join(repoPath, ".gitmodules"))
+        hasGitmodules: (0, import_node_fs5.existsSync)(import_node_path8.default.join(repoPath, ".gitmodules"))
       });
       for (const subPath of await listSubmodules(repoPath)) {
         entries.push({
@@ -27108,7 +28245,7 @@ async function discoverRepos(rootPath, maxDepth = DEFAULT_REPO_SCAN_DEPTH) {
           name: nameFor(rootPath, subPath),
           kind: "submodule",
           parentPath: repoPath,
-          hasGitmodules: (0, import_node_fs3.existsSync)(import_node_path5.default.join(subPath, ".gitmodules"))
+          hasGitmodules: (0, import_node_fs5.existsSync)(import_node_path8.default.join(subPath, ".gitmodules"))
         });
       }
     })
@@ -27121,92 +28258,28 @@ async function discoverRepos(rootPath, maxDepth = DEFAULT_REPO_SCAN_DEPTH) {
     if (a.parentPath !== null && b.parentPath === null) return 1;
     return a.path.localeCompare(b.path);
   });
-  return entries;
-}
-
-// ../../shared/platform/src/hub-switches.ts
-var HUB_SWITCH_ENV = {
-  requireLogin: "SLAYZONE_HUB_REQUIRE_LOGIN",
-  enablePassword: "SLAYZONE_HUB_ENABLE_PASSWORD",
-  enableSso: "SLAYZONE_HUB_ENABLE_SSO",
-  enableProcesses: "SLAYZONE_HUB_ENABLE_PROCESSES",
-  enableIntegrations: "SLAYZONE_HUB_ENABLE_INTEGRATIONS"
-};
-var HUB_SSO_ENV = {
-  tenantId: "SLAYZONE_HUB_SSO_TENANT_ID",
-  clientId: "SLAYZONE_HUB_SSO_CLIENT_ID",
-  /** PEM certificate registered on the Entra app (its SHA-256 thumbprint goes in each assertion). Env only. */
-  certPath: "SLAYZONE_HUB_SSO_CERT_PATH",
-  /** PEM private key of that certificate (RSA, unencrypted). Env only. */
-  keyPath: "SLAYZONE_HUB_SSO_KEY_PATH",
-  /** `0|1`, default `1`: refuse a sign-in whose ID token's `amr` does not contain `mfa`. */
-  requireMfa: "SLAYZONE_HUB_SSO_REQUIRE_MFA"
-};
-var RETIRED_HUB_SSO_CLIENT_SECRET_ENV = "SLAYZONE_HUB_SSO_CLIENT_SECRET";
-var HUB_ADDRESS_ENV = {
-  /** Where the hub LISTENS. Renamed from `SLAYZONE_HUB_ADDRESS`, which now only
-   *  means "the hub to connect to" on a computer / `slay`. */
-  listen: "SLAYZONE_HUB_LISTEN_ADDRESS",
-  /** How OTHER machines reach the hub (`host[:port]`, no scheme). */
-  public: "SLAYZONE_HUB_PUBLIC_ADDRESS",
-  /** Signing key of hub-auth. */
-  authSecret: "SLAYZONE_HUB_AUTH_SECRET"
-};
-var LEGACY_HUB_LISTEN_ENV = "SLAYZONE_HUB_ADDRESS";
-var HUB_SESSION_RETENTION_DAYS_ENV = "SLAYZONE_HUB_SESSION_RETENTION_DAYS";
-var HUB_ALLOWED_WEB_ORIGINS_ENV = "SLAYZONE_HUB_ALLOWED_WEB_ORIGINS";
-var HUB_TRUSTED_PROXIES_ENV = "SLAYZONE_HUB_TRUSTED_PROXIES";
-var HUB_CONVEX_ADDRESS_ENV = "SLAYZONE_HUB_CONVEX_ADDRESS";
-var HUB_PROCESS_ENV = [
-  ...Object.values(HUB_SWITCH_ENV),
-  ...Object.values(HUB_SSO_ENV),
-  RETIRED_HUB_SSO_CLIENT_SECRET_ENV,
-  ...Object.values(HUB_ADDRESS_ENV),
-  LEGACY_HUB_LISTEN_ENV,
-  HUB_ALLOWED_WEB_ORIGINS_ENV,
-  HUB_TRUSTED_PROXIES_ENV,
-  HUB_SESSION_RETENTION_DAYS_ENV,
-  HUB_CONVEX_ADDRESS_ENV
-];
-
-// ../../shared/platform/src/security-log.ts
-var import_node_async_hooks = require("node:async_hooks");
-var LINE_SEPARATOR = String.fromCharCode(8232);
-var PARAGRAPH_SEPARATOR = String.fromCharCode(8233);
-var contextStore = new import_node_async_hooks.AsyncLocalStorage();
-
-// ../../shared/platform/src/hub-switch-refusal.ts
-var MESSAGES = {
-  HUB_PROCESSES_DISABLED: `This hub does not run processes, automation commands, terminals or agents itself (${HUB_SWITCH_ENV.enableProcesses}=0).`,
-  HUB_INTEGRATIONS_DISABLED: `Integrations are switched off on this hub (${HUB_SWITCH_ENV.enableIntegrations}=0).`,
-  NO_COMPUTER_CONNECTED: `Connect a computer: this hub does not read project files or run git, gh or other commands itself (${HUB_SWITCH_ENV.enableProcesses}=0).`,
-  HUB_PASSWORD_DISABLED: `Password sign-in is switched off on this hub (${HUB_SWITCH_ENV.enablePassword}=0).`,
-  HUB_CONVEX_NOT_CONFIGURED: `GitHub sign-in is off on this hub: no Convex deployment is configured (${HUB_CONVEX_ADDRESS_ENV}).`,
-  HUB_CONVEX_MISMATCH: `This hub starts GitHub sign-in only against its own Convex deployment (${HUB_CONVEX_ADDRESS_ENV}); the request named another.`
-};
-var VARIABLES = {
-  HUB_PROCESSES_DISABLED: HUB_SWITCH_ENV.enableProcesses,
-  HUB_INTEGRATIONS_DISABLED: HUB_SWITCH_ENV.enableIntegrations,
-  NO_COMPUTER_CONNECTED: HUB_SWITCH_ENV.enableProcesses,
-  HUB_PASSWORD_DISABLED: HUB_SWITCH_ENV.enablePassword,
-  HUB_CONVEX_NOT_CONFIGURED: HUB_CONVEX_ADDRESS_ENV,
-  HUB_CONVEX_MISMATCH: HUB_CONVEX_ADDRESS_ENV
-};
+  return entries;
+}
 
 // src/handlers/fs.ts
 var BROWSE_ALWAYS_HIDDEN = /* @__PURE__ */ new Set([".git", ".DS_Store", "node_modules"]);
 function createFsHandlers(ctx) {
-  const allow = (candidate) => assertPathAllowed(candidate, ctx.config.allowedRoots);
+  const allow = (candidate, subtree = false) => assertPathAllowed(candidate, ctx.config.allowedRoots, { subtree });
+  const allowIn = (rootPath, rel, subtree = false) => {
+    const root = allow(rootPath);
+    allow((0, import_node_path9.join)(root, rel), subtree);
+    return root;
+  };
   const watches = /* @__PURE__ */ new Map();
   function pathExists(rawParams) {
-    const { path: path8 } = fsPathExistsParamsSchema.parse(rawParams);
-    const resolved = allow(path8);
-    return { exists: (0, import_node_fs4.existsSync)(resolved) };
+    const { path: path9 } = fsPathExistsParamsSchema.parse(rawParams);
+    const resolved = allow(path9);
+    return { exists: (0, import_node_fs6.existsSync)(resolved) };
   }
   async function removeDir(rawParams) {
-    const { path: path8 } = fsRemoveDirParamsSchema.parse(rawParams);
-    const resolved = allow(path8);
-    await (0, import_promises5.rm)(resolved, { recursive: true, force: true });
+    const { path: path9 } = fsRemoveDirParamsSchema.parse(rawParams);
+    const resolved = allow(path9, true);
+    await (0, import_promises6.rm)(resolved, { recursive: true, force: true });
     ctx.log("fs removeDir", { path: resolved });
     return { ok: true };
   }
@@ -27215,32 +28288,32 @@ function createFsHandlers(ctx) {
     const resolvedRoots = [];
     for (const root of ctx.config.allowedRoots) {
       try {
-        resolvedRoots.push(import_node_fs4.realpathSync.native((0, import_node_path6.resolve)(root)));
+        resolvedRoots.push(import_node_fs6.realpathSync.native((0, import_node_path9.resolve)(root)));
       } catch {
       }
     }
     let home = null;
     try {
-      home = import_node_fs4.realpathSync.native((0, import_node_os4.homedir)());
+      home = import_node_fs6.realpathSync.native((0, import_node_os5.homedir)());
     } catch {
       home = null;
     }
-    return { roots: resolvedRoots, home, platform: process.platform, sep: import_node_path6.sep };
+    return { roots: resolvedRoots, home, platform: process.platform, sep: import_node_path9.sep };
   }
   async function listDir(rawParams) {
     const params = fsListDirParamsSchema.parse(rawParams);
     const abs = allow(params.path);
-    const dirents = await (0, import_promises5.readdir)(abs, { withFileTypes: true });
+    const dirents = await (0, import_promises6.readdir)(abs, { withFileTypes: true });
     const entries = [];
     for (const e of dirents) {
       if (BROWSE_ALWAYS_HIDDEN.has(e.name)) continue;
       if (!params.includeHidden && e.name.startsWith(".")) continue;
-      const full = (0, import_node_path6.join)(abs, e.name);
+      const full = (0, import_node_path9.join)(abs, e.name);
       const symlink = e.isSymbolicLink();
       let isDir = e.isDirectory();
       if (symlink) {
         try {
-          isDir = (await (0, import_promises5.stat)(full)).isDirectory();
+          isDir = (await (0, import_promises6.stat)(full)).isDirectory();
         } catch {
           continue;
         }
@@ -27251,7 +28324,7 @@ function createFsHandlers(ctx) {
         path: full,
         type: isDir ? "directory" : "file",
         ...symlink && { isSymlink: true },
-        ...isDir && (0, import_node_fs4.existsSync)((0, import_node_path6.join)(full, ".git")) && { isGitRepo: true }
+        ...isDir && (0, import_node_fs6.existsSync)((0, import_node_path9.join)(full, ".git")) && { isGitRepo: true }
       });
     }
     entries.sort((a, b) => {
@@ -27260,19 +28333,19 @@ function createFsHandlers(ctx) {
     });
     const isRoot = ctx.config.allowedRoots.some((r) => {
       try {
-        return import_node_fs4.realpathSync.native((0, import_node_path6.resolve)(r)) === abs;
+        return import_node_fs6.realpathSync.native((0, import_node_path9.resolve)(r)) === abs;
       } catch {
         return false;
       }
     });
-    return { path: abs, parent: isRoot ? null : (0, import_node_path6.dirname)(abs), entries };
+    return { path: abs, parent: isRoot ? null : (0, import_node_path9.dirname)(abs), entries };
   }
   async function mkdirHandler(rawParams) {
-    const { path: path8 } = fsMkdirParamsSchema.parse(rawParams);
-    const abs = allow(path8);
-    await (0, import_promises5.mkdir)(abs, { recursive: true });
+    const { path: path9 } = fsMkdirParamsSchema.parse(rawParams);
+    const abs = allow(path9);
+    await (0, import_promises6.mkdir)(abs, { recursive: true });
     ctx.log("fs mkdir", { path: abs });
-    return { path: import_node_fs4.realpathSync.native(abs) };
+    return { path: import_node_fs6.realpathSync.native(abs) };
   }
   function readDirHandler(rawParams) {
     const { rootPath, dirPath } = fsReadDirParamsSchema.parse(rawParams);
@@ -27280,312 +28353,166 @@ function createFsHandlers(ctx) {
   }
   function readFileHandler(rawParams) {
     const { rootPath, filePath, force } = fsReadFileParamsSchema.parse(rawParams);
-    return readFile3(allow(rootPath), filePath, force);
+    return readFile3(allowIn(rootPath, filePath), filePath, force);
   }
   function writeFileHandler(rawParams) {
     const { rootPath, filePath, content } = fsWriteFileParamsSchema.parse(rawParams);
-    writeFile3(allow(rootPath), filePath, content);
+    writeFile3(allowIn(rootPath, filePath), filePath, content);
     return { ok: true };
   }
   function createFileHandler(rawParams) {
     const { rootPath, filePath } = fsCreateFileParamsSchema.parse(rawParams);
-    createFile(allow(rootPath), filePath);
+    createFile(allowIn(rootPath, filePath), filePath);
     return { ok: true };
   }
   function createDirHandler(rawParams) {
     const { rootPath, dirPath } = fsCreateDirParamsSchema.parse(rawParams);
-    createDir(allow(rootPath), dirPath);
+    createDir(allowIn(rootPath, dirPath), dirPath);
     return { ok: true };
   }
   function renameHandler(rawParams) {
     const { rootPath, oldPath, newPath } = fsRenameParamsSchema.parse(rawParams);
-    renamePath(allow(rootPath), oldPath, newPath);
+    allowIn(rootPath, newPath, true);
+    renamePath(allowIn(rootPath, oldPath, true), oldPath, newPath);
     return { ok: true };
   }
   function deleteHandler(rawParams) {
     const { rootPath, targetPath } = fsDeleteParamsSchema.parse(rawParams);
-    deletePath(allow(rootPath), targetPath);
+    deletePath(allowIn(rootPath, targetPath, true), targetPath);
     return { ok: true };
   }
   function copyInHandler(rawParams) {
     const { rootPath, absoluteSrc, targetDir } = fsCopyInParamsSchema.parse(rawParams);
     const src = allow(absoluteSrc);
-    return { path: copyIn(allow(rootPath), src, targetDir) };
+    return { path: copyIn(allowIn(rootPath, targetDir ?? ""), src, targetDir) };
   }
   function copyHandler(rawParams) {
     const { rootPath, srcPath, destPath } = fsCopyParamsSchema.parse(rawParams);
-    copy(allow(rootPath), srcPath, destPath);
+    allowIn(rootPath, srcPath);
+    copy(allowIn(rootPath, destPath, true), srcPath, destPath);
     return { ok: true };
   }
   async function gitStatusHandler(rawParams) {
     const { rootPath } = fsGitStatusParamsSchema.parse(rawParams);
     return gitStatus(allow(rootPath));
   }
-  function searchFilesHandler(rawParams) {
-    const { rootPath, query, options } = fsSearchFilesParamsSchema.parse(rawParams);
-    const maxResults = Math.min(options?.maxResults ?? FS_MAX_SEARCH_RESULTS, FS_MAX_SEARCH_RESULTS);
-    const results = searchFiles(allow(rootPath), query, {
-      ...options,
-      maxResults
-    });
-    const total = results.reduce((n, r) => n + r.matches.length, 0);
-    return { results, truncated: total >= maxResults };
-  }
-  function listAllFilesHandler(rawParams) {
-    const { rootPath } = fsListAllFilesParamsSchema.parse(rawParams);
-    const all = listAllFiles(allow(rootPath));
-    return {
-      files: all.slice(0, FS_MAX_LIST_ALL_FILES),
-      truncated: all.length > FS_MAX_LIST_ALL_FILES
-    };
-  }
-  async function discoverReposHandler(rawParams) {
-    const { rootPath, maxDepth } = fsDiscoverReposParamsSchema.parse(rawParams);
-    return { repos: await discoverRepos(allow(rootPath), maxDepth) };
-  }
-  function watchStart(rawParams) {
-    const { watchId, rootPath } = fsWatchStartParamsSchema.parse(rawParams);
-    watches.get(watchId)?.();
-    const abs = allow(rootPath);
-    const dispose = subscribeFileWatcher(abs, (e) => {
-      const params = { watchId, type: e.type, relPath: e.relPath };
-      ctx.dialer.notify(ComputerNotificationMethods.fsChange, params);
-    });
-    watches.set(watchId, dispose);
-    return { ok: true };
-  }
-  function watchStop(rawParams) {
-    const { watchId } = fsWatchStopParamsSchema.parse(rawParams);
-    watches.get(watchId)?.();
-    watches.delete(watchId);
-    return { ok: true };
-  }
-  return {
-    [HubToComputerMethods.fsPathExists]: pathExists,
-    [HubToComputerMethods.fsRemoveDir]: removeDir,
-    [HubToComputerMethods.fsListRoots]: listRoots,
-    [HubToComputerMethods.fsListDir]: listDir,
-    [HubToComputerMethods.fsMkdir]: mkdirHandler,
-    [HubToComputerMethods.fsReadDir]: readDirHandler,
-    [HubToComputerMethods.fsReadFile]: readFileHandler,
-    [HubToComputerMethods.fsWriteFile]: writeFileHandler,
-    [HubToComputerMethods.fsCreateFile]: createFileHandler,
-    [HubToComputerMethods.fsCreateDir]: createDirHandler,
-    [HubToComputerMethods.fsRename]: renameHandler,
-    [HubToComputerMethods.fsDelete]: deleteHandler,
-    [HubToComputerMethods.fsCopyIn]: copyInHandler,
-    [HubToComputerMethods.fsCopy]: copyHandler,
-    [HubToComputerMethods.fsGitStatus]: gitStatusHandler,
-    [HubToComputerMethods.fsSearchFiles]: searchFilesHandler,
-    [HubToComputerMethods.fsListAllFiles]: listAllFilesHandler,
-    [HubToComputerMethods.fsDiscoverRepos]: discoverReposHandler,
-    [HubToComputerMethods.fsWatchStart]: watchStart,
-    [HubToComputerMethods.fsWatchStop]: watchStop
-  };
-}
-
-// src/handlers/gh.ts
-var import_node_child_process3 = require("node:child_process");
-var DEFAULT_TIMEOUT_MS = 3e4;
-var MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
-function createGhHandlers(ctx) {
-  async function ghExec(rawParams) {
-    const params = ghExecParamsSchema.parse(rawParams);
-    const cwd = assertPathAllowed(params.cwd, ctx.config.allowedRoots);
-    return new Promise((resolve7) => {
-      const child = (0, import_node_child_process3.execFile)(
-        "gh",
-        params.args,
-        {
-          cwd,
-          timeout: params.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-          maxBuffer: MAX_OUTPUT_BYTES,
-          // No env overlay: gh must see this machine's own `GH_*`/`GITHUB_TOKEN`
-          // and credential helpers. Injecting anything here would be SlayZone
-          // taking custody of credentials it deliberately does not hold.
-          env: process.env
-        },
-        (err, stdout2, stderr) => {
-          const status = err && typeof err.code === "number" ? err.code : err ? null : 0;
-          resolve7({ status, stdout: stdout2 ?? "", stderr: stderr ?? "" });
-        }
-      );
-      if (params.stdin !== void 0) {
-        child.stdin?.end(params.stdin);
-      }
-    });
-  }
-  return { [HubToComputerMethods.ghExec]: ghExec };
-}
-
-// src/handlers/git.ts
-var import_node_child_process5 = require("node:child_process");
-var import_node_fs5 = require("node:fs");
-var import_promises6 = require("node:fs/promises");
-var import_node_path7 = require("node:path");
-
-// ../../shared/platform/src/env-manifest.ts
-var ENV_MANIFEST = {
-  // --- secret: credentials/tokens, never in a terminal ---
-  SLAYZONE_HUB_TOKEN: "secret",
-  // HMAC signing key for ALL of hub-auth (better-auth's session/cookie signer AND
-  // the computer enroll/api-key credentials) — hence `HUB_AUTH`, not the former
-  // `HUB_COMPUTER_TRANSPORT_SECRET`, which named just one of its consumers. Rule 2
-  // (name by what the value IS). `_SECRET` = a key you HOLD and sign with, vs
-  // `_TOKEN` = a bearer you PRESENT (SLAYZONE_HUB_TOKEN above).
-  SLAYZONE_HUB_AUTH_SECRET: "secret",
-  // Hub-scoped by VALUE: the hub mints it, and it embeds the hub's url and a
-  // secret verified against the hub's `join_tokens`
-  // row. `mintJoinToken` binds it to NO computer (computer_id stays NULL until
-  // redemption), so any computer can redeem any unused token — there is no computer in
-  // the value to name. Rule 2 (name by what the value IS, not who reads it).
-  SLAYZONE_HUB_JOIN_TOKEN: "secret",
-  // Retired before it was ever read: Entra sign-in authenticates with a certificate
-  // (SLAYZONE_HUB_SSO_CERT_PATH / _KEY_PATH below), and boot refuses a hub that still
-  // sets this (B7). Still classified `secret` so a leftover value never reaches a
-  // terminal or a log.
-  SLAYZONE_HUB_SSO_CLIENT_SECRET: "secret",
-  // Per-boot bearer the desktop's `/cap` listener requires on every connection
-  // (desktop-bridge-server.ts `verifyClient`). Loopback is NOT trusted there —
-  // the threat this closes is another loopback process finding the port — so
-  // this is a real credential, `secret`-scoped like the two above it.
-  SLAYZONE_DESKTOP_BRIDGE_TOKEN: "secret",
-  // The pre-rename `SLAYZONE_RUNNER_JOIN_TOKEN` is deliberately UNLISTED: it is
-  // retired, not aliased. It never shipped (the published computer betas read
-  // `SLAYZONE_JOIN_TOKEN`), so no operator env carries it and there is nothing to
-  // keep working. Unlisted ⇒ the fail-closed default strips it, same as every
-  // other retired name in this rename sweep.
-  // --- infra: SlayZone wiring a terminal must not reinterpret ---
-  // The hub to CONNECT to, host[:port] (computer, `slay`); the scheme derives from
-  // the host (loopback → http/ws, else https/wss). A hub no longer reads this name:
-  // it LISTENS on SLAYZONE_HUB_LISTEN_ADDRESS, and a hub that still gets the old
-  // name refuses to boot. Stripping both here keeps a terminal's dial address from
-  // ever being mistaken for another process's listen address.
-  SLAYZONE_HUB_ADDRESS: "infra",
-  SLAYZONE_HUB_LISTEN_ADDRESS: "infra",
-  // hub-only; where the hub listens
-  SLAYZONE_HUB_PUBLIC_ADDRESS: "infra",
-  // hub-only; how other machines reach it, written into join tokens
-  // Hub-only; the front ends (IPs/CIDRs, comma-separated) whose X-Forwarded-For names
-  // the client (client-address.ts). Not `_ADDRESS`: these are networks, not an authority.
-  SLAYZONE_HUB_TRUSTED_PROXIES: "infra",
-  // Per-hub switches (0|1) replacing SLAYZONE_MODE. Infra: they describe THIS hub
-  // process, so a task terminal must not inherit them (a hub started from one would
-  // otherwise pick up its parent's switches by accident).
-  SLAYZONE_HUB_REQUIRE_LOGIN: "infra",
-  SLAYZONE_HUB_ENABLE_PASSWORD: "infra",
-  SLAYZONE_HUB_ENABLE_SSO: "infra",
-  SLAYZONE_HUB_ENABLE_PROCESSES: "infra",
-  SLAYZONE_HUB_ENABLE_INTEGRATIONS: "infra",
-  SLAYZONE_HUB_SSO_TENANT_ID: "infra",
-  SLAYZONE_HUB_SSO_CLIENT_ID: "infra",
-  // Paths to the Entra client certificate and its private key, and the MFA switch.
-  // Infra, not secret: a path is not the key (the file's own permissions protect it),
-  // but a task terminal must still never inherit a hub's SSO wiring.
-  SLAYZONE_HUB_SSO_CERT_PATH: "infra",
-  SLAYZONE_HUB_SSO_KEY_PATH: "infra",
-  SLAYZONE_HUB_SSO_REQUIRE_MFA: "infra",
-  // Operator-facing hub name (`slay hub ls`/`stop` address a hub by it). Infra,
-  // not global: it identifies THIS hub process, so inheriting it into a task
-  // terminal — which may target a different hub entirely — would mislabel.
-  SLAYZONE_HUB_NAME: "infra",
-  // Days THIS hub keeps session content (T-23, hub session-retention.ts); 0 = off, the
-  // default. Infra like the switches: a hub started from a task terminal must not
-  // inherit its parent's period and start deleting.
-  SLAYZONE_HUB_SESSION_RETENTION_DAYS: "infra",
-  // The Convex deployment (host[:port]) the hub starts GitHub sign-in against — never
-  // a client-named one (T-99). Hub process config, set by the desktop app for its hub.
-  SLAYZONE_HUB_CONVEX_ADDRESS: "infra",
-  SLAYZONE_DESKTOP_BRIDGE_ADDRESS: "infra",
-  // sidecar→desktop capability bridge + REST proxy
-  SLAYZONE_SUPERVISED: "infra",
-  // "started by the desktop app" flag
-  SLAYZONE_USER_DATA_DIR: "infra",
-  // Playwright Electron userData redirect
-  SLAYZONE_SIDECAR_HOT_RESTART: "infra",
-  SLAYZONE_BOOT_LOG_PATH: "infra",
-  SLAYZONE_DEBUG_BOOT: "infra",
-  SLAYZONE_REGISTER_DEV_PROTOCOL: "infra",
-  SLAYZONE_NONINTERACTIVE: "infra",
-  // Historical opt-IN, now a NO-OP: e2e runs computer-ON by default, so the boot
-  // gate no longer reads this. Kept manifested because specs still set it to
-  // document "this spec wants a computer" (an unmanifested var would be stripped
-  // by sanitizeSpawnEnv, fail-closed, and read as a silent typo).
-  SLAYZONE_E2E_ALLOW_COMPUTER: "infra",
-  // Opt-OUT, and the only lever that changes behavior now: set by the specs that
-  // must boot computer-less (remote-mode, sidecar-crash, and the "hub accepts
-  // computers with none spawned" contract test).
-  SLAYZONE_E2E_NO_COMPUTER: "infra",
-  SLAYZONE_E2E_INSTALL_HOOKS: "infra",
-  // Redirects the MACHINE-WIDE ~/.slayzone (hooks/, bin/) — the files shared by
-  // every SlayZone process on the box, which deliberately do NOT follow
-  // SLAYZONE_ROOT. Sandbox redirect for tests, same role as the per-provider
-  // overrides below. `infra`: a spawned terminal must never inherit it, or an
-  // agent would resolve a different notify.sh than the one wired into its hooks.
-  SLAYZONE_MACHINE_DIR: "infra",
-  // per-provider config/hook/plugin path overrides (test/sandbox redirects)
-  SLAYZONE_CLAUDE_SETTINGS_PATH: "infra",
-  SLAYZONE_GEMINI_SETTINGS_PATH: "infra",
-  SLAYZONE_CODEX_HOOKS_PATH: "infra",
-  SLAYZONE_ANTIGRAVITY_HOOKS_PATH: "infra",
-  SLAYZONE_OPENCODE_PLUGIN_PATH: "infra",
-  // --- identity: per-task/agent; overlay re-adds the correct value per spawn ---
-  SLAYZONE_TASK_ID: "identity",
-  SLAYZONE_PROJECT_ID: "identity",
-  // `SLAYZONE_SESSION_ID` (a warm agent's pre-task identity) is RETIRED and
-  // deliberately unlisted: warm agents boot with SLAYZONE_TASK_ID now.
-  SLAYZONE_AGENT_ID: "identity",
-  SLAYZONE_AGENT_HOOK_URL: "identity",
-  // Pairs with _HOOK_URL (where to post / who is posting). The pre-v4 name
-  // `SLAYZONE_HOOK_CONTEXT` is RETIRED and deliberately unlisted: unlisted =
-  // stripped (fail closed), and the old-name value an older release channel's app
-  // supplies rides its OWN per-spawn overlay (applied after sanitizeSpawnEnv), so
-  // notify.sh v4's fallback read still sees it. A manifest entry would only let a
-  // stale inherited value survive.
-  SLAYZONE_AGENT_HOOK_CONTEXT: "identity",
-  // --- global: same app-wide, safe to inherit verbatim ---
-  SLAYZONE_RELEASE_CHANNEL: "global",
-  // attribution-only (hook envelope channel)
-  // INSTALL IDENTITY — which SlayZone install this process tree belongs to, not
-  // which task/session. A child MUST resolve the SAME install as its parent: the
-  // `slay` CLI derives its DB from BOTH (getStorageDir() reads ROOT; the
-  // filename is `slayzone{.dev}.sqlite` per DEV — apps/cli/src/db.ts getDbPath).
-  // Strip either and a bare `slay` in a dev-app task terminal exits 1
-  // ("Database not found … Re-run with --dev"), and under an isolated e2e ROOT a
-  // child would escape the sandbox to the real ~/.slayzone. Neither is a
-  // credential and neither can be reinterpreted as a different kind of target
-  // (unlike a hub address), so both inherit verbatim.
-  //
-  // ROOT is NOT covered by the identity overlay: buildMcpEnv sets it only inside
-  // setHookIdentity(), gated on a hook-capable agent mode — a plain `terminal`
-  // PTY, a non-hook agent, or a pre-warmed pool spawn gets no overlay at all.
-  SLAYZONE_ROOT: "global",
-  SLAYZONE_DEV: "global"
-};
-var NON_PREFIXED_INFRA = /* @__PURE__ */ new Set([
-  "ELECTRON_RUN_AS_NODE",
-  "NODE_PATH",
-  "PLAYWRIGHT"
-]);
-function sanitizeSpawnEnv(base) {
-  const out = {};
-  for (const [key, value] of Object.entries(base)) {
-    if (typeof value !== "string") continue;
-    if (NON_PREFIXED_INFRA.has(key)) continue;
-    if (key.startsWith("SLAYZONE_")) {
-      if (ENV_MANIFEST[key] === "global") out[key] = value;
-      continue;
+  function searchFilesHandler(rawParams) {
+    const { rootPath, query, options } = fsSearchFilesParamsSchema.parse(rawParams);
+    const maxResults = Math.min(options?.maxResults ?? FS_MAX_SEARCH_RESULTS, FS_MAX_SEARCH_RESULTS);
+    const root = allow(rootPath);
+    const results = searchFiles(root, query, {
+      ...options,
+      maxResults
+    }).filter((r) => !isProtectedPath((0, import_node_path9.join)(root, r.path)));
+    const total = results.reduce((n, r) => n + r.matches.length, 0);
+    return { results, truncated: total >= maxResults };
+  }
+  function listAllFilesHandler(rawParams) {
+    const { rootPath } = fsListAllFilesParamsSchema.parse(rawParams);
+    const all = listAllFiles(allow(rootPath));
+    return {
+      files: all.slice(0, FS_MAX_LIST_ALL_FILES),
+      truncated: all.length > FS_MAX_LIST_ALL_FILES
+    };
+  }
+  async function discoverReposHandler(rawParams) {
+    const { rootPath, maxDepth } = fsDiscoverReposParamsSchema.parse(rawParams);
+    return { repos: await discoverRepos(allow(rootPath), maxDepth) };
+  }
+  function watchStart(rawParams) {
+    const { watchId, rootPath } = fsWatchStartParamsSchema.parse(rawParams);
+    watches.get(watchId)?.();
+    const abs = allow(rootPath);
+    const dispose = subscribeFileWatcher(abs, (e) => {
+      const params = { watchId, type: e.type, relPath: e.relPath };
+      ctx.dialer.notify(ComputerNotificationMethods.fsChange, params);
+    });
+    watches.set(watchId, dispose);
+    return { ok: true };
+  }
+  function watchStop(rawParams) {
+    const { watchId } = fsWatchStopParamsSchema.parse(rawParams);
+    watches.get(watchId)?.();
+    watches.delete(watchId);
+    return { ok: true };
+  }
+  function disposeAll() {
+    for (const [watchId, dispose] of watches) {
+      dispose();
+      ctx.log("fs watch disposed on shutdown", { watchId });
     }
-    out[key] = value;
+    watches.clear();
   }
-  return out;
+  const handlers = {
+    [HubToComputerMethods.fsPathExists]: pathExists,
+    [HubToComputerMethods.fsRemoveDir]: removeDir,
+    [HubToComputerMethods.fsListRoots]: listRoots,
+    [HubToComputerMethods.fsListDir]: listDir,
+    [HubToComputerMethods.fsMkdir]: mkdirHandler,
+    [HubToComputerMethods.fsReadDir]: readDirHandler,
+    [HubToComputerMethods.fsReadFile]: readFileHandler,
+    [HubToComputerMethods.fsWriteFile]: writeFileHandler,
+    [HubToComputerMethods.fsCreateFile]: createFileHandler,
+    [HubToComputerMethods.fsCreateDir]: createDirHandler,
+    [HubToComputerMethods.fsRename]: renameHandler,
+    [HubToComputerMethods.fsDelete]: deleteHandler,
+    [HubToComputerMethods.fsCopyIn]: copyInHandler,
+    [HubToComputerMethods.fsCopy]: copyHandler,
+    [HubToComputerMethods.fsGitStatus]: gitStatusHandler,
+    [HubToComputerMethods.fsSearchFiles]: searchFilesHandler,
+    [HubToComputerMethods.fsListAllFiles]: listAllFilesHandler,
+    [HubToComputerMethods.fsDiscoverRepos]: discoverReposHandler,
+    [HubToComputerMethods.fsWatchStart]: watchStart,
+    [HubToComputerMethods.fsWatchStop]: watchStop
+  };
+  return { handlers, disposeAll };
+}
+
+// src/handlers/gh.ts
+var import_node_child_process5 = require("node:child_process");
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+function createGhHandlers(ctx) {
+  async function ghExec(rawParams) {
+    const params = ghExecParamsSchema.parse(rawParams);
+    const cwd = assertPathAllowed(params.cwd, ctx.config.allowedRoots);
+    return new Promise((resolve7) => {
+      const child = (0, import_node_child_process5.execFile)(
+        "gh",
+        params.args,
+        {
+          cwd,
+          timeout: params.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+          maxBuffer: MAX_OUTPUT_BYTES,
+          // No env overlay: gh must see this machine's own `GH_*`/`GITHUB_TOKEN`
+          // and credential helpers. Injecting anything here would be SlayZone
+          // taking custody of credentials it deliberately does not hold.
+          env: process.env
+        },
+        (err, stdout2, stderr) => {
+          const status = err && typeof err.code === "number" ? err.code : err ? null : 0;
+          resolve7({ status, stdout: stdout2 ?? "", stderr: stderr ?? "" });
+        }
+      );
+      if (params.stdin !== void 0) {
+        child.stdin?.end(params.stdin);
+      }
+    });
+  }
+  return { [HubToComputerMethods.ghExec]: ghExec };
 }
 
+// src/handlers/git.ts
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs7 = require("node:fs");
+var import_promises7 = require("node:fs/promises");
+var import_node_path10 = require("node:path");
+
 // src/handlers/exec.ts
-var import_node_child_process4 = require("node:child_process");
+var import_node_child_process6 = require("node:child_process");
 function execCapture(command, args, opts = {}) {
   return new Promise((resolve7) => {
-    const child = (0, import_node_child_process4.spawn)(command, args, {
+    const child = (0, import_node_child_process6.spawn)(command, args, {
       ...opts.cwd ? { cwd: opts.cwd } : {},
       ...opts.env ? { env: opts.env } : {},
       stdio: ["ignore", "pipe", "pipe"]
@@ -27604,7 +28531,7 @@ function execCapture(command, args, opts = {}) {
     });
     child.on("error", (err) => {
       if (timer) clearTimeout(timer);
-      resolve7({ stdout: "", stderr: err.message, status: 1 });
+      resolve7({ stdout: "", stderr: err.message, status: 1, spawnError: err.message });
     });
   });
 }
@@ -27637,14 +28564,12 @@ var SETUP_SCRIPT_TIMEOUT_MS = 5 * 6e4;
 function createGitHandlers(ctx) {
   const allow = (candidate) => assertPathAllowed(candidate, ctx.config.allowedRoots);
   async function isGitRepo(rawParams) {
-    const { path: path8 } = isGitRepoParams.parse(rawParams);
-    const repoPath = allow(path8);
-    try {
-      await execGit(["rev-parse", "--git-dir"], repoPath);
-      return { isGitRepo: true };
-    } catch {
-      return { isGitRepo: false };
-    }
+    const { path: path9 } = isGitRepoParams.parse(rawParams);
+    const repoPath = allow(path9);
+    if (!(0, import_node_fs7.existsSync)(repoPath)) return { isGitRepo: false };
+    const result = await execCapture("git", ["rev-parse", "--git-dir"], { cwd: repoPath });
+    if (result.spawnError) throw new Error(`Could not start git: ${result.spawnError}`);
+    return { isGitRepo: result.status === 0 };
   }
   async function getCurrentBranch(rawParams) {
     const parsed = getCurrentBranchParams.parse(rawParams);
@@ -27674,7 +28599,7 @@ function createGitHandlers(ctx) {
     try {
       await execGit(["worktree", "remove", worktreePath, "--force"], repoPath);
     } catch (err) {
-      if (!(0, import_node_fs5.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs7.existsSync)(worktreePath)) {
         await execGit(["worktree", "prune"], repoPath);
       } else {
         throw err;
@@ -27702,13 +28627,13 @@ function createGitHandlers(ctx) {
     const params = runWorktreeSetupScriptParams.parse(rawParams);
     const worktreePath = allow(params.worktreePath);
     const repoPath = allow(params.repoPath);
-    const scriptPath = (0, import_node_path7.resolve)(worktreePath, SETUP_SCRIPT);
-    if (!(0, import_node_fs5.existsSync)(scriptPath)) return Promise.resolve({ ran: false });
+    const scriptPath = (0, import_node_path10.resolve)(worktreePath, SETUP_SCRIPT);
+    if (!(0, import_node_fs7.existsSync)(scriptPath)) return Promise.resolve({ ran: false });
     try {
-      (0, import_node_fs5.accessSync)(scriptPath, import_node_fs5.constants.X_OK);
+      (0, import_node_fs7.accessSync)(scriptPath, import_node_fs7.constants.X_OK);
     } catch {
       try {
-        (0, import_node_fs5.chmodSync)(scriptPath, 493);
+        (0, import_node_fs7.chmodSync)(scriptPath, 493);
       } catch {
         return Promise.resolve({ ran: false });
       }
@@ -27718,7 +28643,7 @@ function createGitHandlers(ctx) {
     env.REPO_PATH = repoPath;
     env.SOURCE_BRANCH = params.sourceBranch ?? "";
     return new Promise((resolvePromise) => {
-      const child = (0, import_node_child_process5.spawn)(scriptPath, [], {
+      const child = (0, import_node_child_process7.spawn)(scriptPath, [], {
         cwd: worktreePath,
         stdio: ["ignore", "pipe", "pipe"],
         env
@@ -27759,20 +28684,20 @@ function createGitHandlers(ctx) {
     } else {
       relPaths = params.customPaths ?? [];
     }
-    const repoRoot = (0, import_node_path7.resolve)(repoPath);
-    const wtRoot = (0, import_node_path7.resolve)(worktreePath);
+    const repoRoot = (0, import_node_path10.resolve)(repoPath);
+    const wtRoot = (0, import_node_path10.resolve)(worktreePath);
     let copied = 0;
     for (const rel of relPaths) {
-      const src = (0, import_node_path7.resolve)(repoPath, rel);
-      const dest = (0, import_node_path7.resolve)(worktreePath, rel);
-      if (!isInside(src, repoRoot) || !isInside(dest, wtRoot)) {
+      const src = (0, import_node_path10.resolve)(repoPath, rel);
+      const dest = (0, import_node_path10.resolve)(worktreePath, rel);
+      if (!isInside2(src, repoRoot) || !isInside2(dest, wtRoot)) {
         ctx.log("copyIgnoredFiles skipped traversal", { rel });
         continue;
       }
-      if (!(0, import_node_fs5.existsSync)(src)) continue;
+      if (!(0, import_node_fs7.existsSync)(src)) continue;
       try {
-        await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(dest), { recursive: true });
-        await (0, import_promises6.cp)(src, dest, { recursive: true, verbatimSymlinks: true });
+        await (0, import_promises7.mkdir)((0, import_node_path10.dirname)(dest), { recursive: true });
+        await (0, import_promises7.cp)(src, dest, { recursive: true, verbatimSymlinks: true });
         copied += 1;
       } catch (err) {
         ctx.log("copyIgnoredFiles copy failed", { rel, error: String(err) });
@@ -27789,83 +28714,13 @@ function createGitHandlers(ctx) {
     [GitMethods.copyIgnoredFiles]: copyIgnoredFiles
   };
 }
-function isInside(child, root) {
-  const c = (0, import_node_path7.resolve)(child);
-  return c === root || c.startsWith(root + import_node_path7.sep);
+function isInside2(child, root) {
+  const c = (0, import_node_path10.resolve)(child);
+  return c === root || c.startsWith(root + import_node_path10.sep);
 }
 
 // src/handlers/proc.ts
-var import_node_child_process6 = require("node:child_process");
-
-// ../../shared/platform/src/index.ts
-init_dirs();
-
-// ../../shared/platform/src/paths.ts
-init_dirs();
-
-// ../../shared/platform/src/index.ts
-init_fs_utils();
-
-// ../../shared/platform/src/migrations.ts
-init_dirs();
-
-// ../../shared/platform/src/cli-install.ts
-var import_child_process = require("child_process");
-var import_util9 = require("util");
-var execFileAsync = (0, import_util9.promisify)(import_child_process.execFile);
-var WINDOWS_SHIM = [
-  "@echo off",
-  `for /f "tokens=1 delims=." %%v in ('node -e "process.stdout.write(process.versions.node)"') do set NODE_MAJOR=%%v`,
-  "if %NODE_MAJOR% LEQ 22 (",
-  '  node --experimental-sqlite --no-warnings "%~dp0slay.js" %*',
-  ") else (",
-  '  node --no-warnings "%~dp0slay.js" %*',
-  ")",
-  ""
-].join("\r\n");
-
-// ../../shared/platform/src/shell.ts
-var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_os2 = require("os");
-var shellOverride = null;
-function shellExists(shellPath) {
-  if ((0, import_os2.platform)() === "win32") return import_node_fs6.default.existsSync(shellPath);
-  try {
-    import_node_fs6.default.accessSync(shellPath, import_node_fs6.default.constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function defaultShellForPlatform() {
-  if ((0, import_os2.platform)() === "win32") return process.env.COMSPEC || "cmd.exe";
-  if ((0, import_os2.platform)() === "darwin") return "/bin/zsh";
-  return "/bin/bash";
-}
-function resolveUserShell() {
-  if (shellOverride && shellExists(shellOverride)) return shellOverride;
-  const fromEnv = process.env.SHELL?.trim();
-  if (fromEnv && shellExists(fromEnv)) return fromEnv;
-  try {
-    const fromUser = (0, import_os2.userInfo)().shell?.trim();
-    if (fromUser && shellExists(fromUser)) return fromUser;
-  } catch {
-  }
-  return defaultShellForPlatform();
-}
-function buildShellInvocation(command) {
-  const shell = resolveUserShell();
-  if ((0, import_os2.platform)() === "win32") return { file: shell, args: ["/c", command] };
-  const isFish = shell.endsWith("/fish");
-  return { file: shell, args: [...isFish ? ["-i", "-l"] : ["-l"], "-c", command] };
-}
-
-// ../../shared/platform/src/slz-file-url.ts
-var SLZ_FILE_HOST = "app";
-var SLZ_FILE_PREFIX = `slz-file://${SLZ_FILE_HOST}`;
-
-// ../../shared/platform/src/ipc-dedup.ts
-var UNCHANGED = Object.freeze({ __ipc_unchanged__: true });
+var import_node_child_process8 = require("node:child_process");
 
 // src/exit-tombstones.ts
 var TOMBSTONE_TTL_MS = 10 * 6e4;
@@ -27988,6 +28843,9 @@ function createProcHandlers(ctx, getProjectPaths) {
     }
     return merged;
   }
+  function killTree(child, signal = "SIGTERM") {
+    if (typeof child.pid === "number") killPidTree(child.pid, signal);
+  }
   function procSpawn(rawParams) {
     const params = procSpawnParamsSchema.parse(rawParams);
     if (params.spawnId !== void 0) {
@@ -28000,21 +28858,21 @@ function createProcHandlers(ctx, getProjectPaths) {
       }
     }
     const resolved = params.cwd ?? (params.projectId ? getProjectPaths?.()?.get(params.projectId)?.path : void 0);
-    const cwd = resolved ? assertPathAllowed(resolved, ctx.config.allowedRoots) : void 0;
+    const cwd = spawnCwd(resolved, ctx.config.allowedRoots);
     const existing = procs.get(params.sessionId);
     if (existing) {
-      try {
-        existing.child.kill();
-      } catch {
-      }
+      killTree(existing.child);
       procs.delete(params.sessionId);
     }
     const invocation = params.shell ? buildShellInvocation(params.command) : { file: params.command, args: params.args ?? [] };
-    const child = (0, import_node_child_process6.spawn)(invocation.file, invocation.args, {
+    const child = (0, import_node_child_process8.spawn)(invocation.file, invocation.args, {
       ...cwd ? { cwd } : {},
       env: buildEnv(params.env),
       // stdin PIPED (was 'ignore') so `proc.write` can reach the child.
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      // Its own process group, so a kill reaches everything it started (`pnpm dev`
+      // → node → …), not just the shell — see `killTree`.
+      detached: PROCESS_TREE_DETACHED
     });
     const buffer = new RingBuffer(MAX_BUFFER_SIZE);
     const session = {
@@ -28081,11 +28939,7 @@ function createProcHandlers(ctx, getProjectPaths) {
       ctx.log("proc kill on unknown session", { sessionId: params.sessionId });
       return { ok: true };
     }
-    try {
-      session.child.kill(params.signal ?? "SIGTERM");
-    } catch (err) {
-      ctx.log("proc kill failed", { sessionId: params.sessionId, error: String(err) });
-    }
+    killTree(session.child, params.signal ?? "SIGTERM");
     return { ok: true };
   }
   function procWrite(rawParams) {
@@ -28123,10 +28977,7 @@ function createProcHandlers(ctx, getProjectPaths) {
   }
   function disposeAll() {
     for (const [sessionId, session] of procs) {
-      try {
-        session.child.kill();
-      } catch {
-      }
+      killTree(session.child);
       ctx.log("proc disposed on shutdown", { sessionId });
     }
     procs.clear();
@@ -28142,7 +28993,7 @@ function createProcHandlers(ctx, getProjectPaths) {
 }
 
 // src/handlers/project.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs8 = require("node:fs");
 function createProjectHandlers(ctx, getStore) {
   const allow = (candidate) => assertPathAllowed(candidate, ctx.config.allowedRoots);
   const store = () => {
@@ -28154,11 +29005,11 @@ function createProjectHandlers(ctx, getStore) {
     const { projectId } = projectResolvePathParamsSchema.parse(rawParams);
     const entry = store().get(projectId);
     if (!entry) return { path: null };
-    return { path: entry.path, exists: (0, import_node_fs7.existsSync)(entry.path) };
+    return { path: entry.path, exists: (0, import_node_fs8.existsSync)(entry.path) };
   }
   async function setPath(rawParams) {
-    const { projectId, path: path8 } = projectSetPathParamsSchema.parse(rawParams);
-    const resolved = allow(path8);
+    const { projectId, path: path9 } = projectSetPathParamsSchema.parse(rawParams);
+    const resolved = allow(path9);
     const entry = await store().set(projectId, resolved);
     ctx.log("project path recorded", { projectId, path: entry.path });
     return { path: entry.path };
@@ -28175,7 +29026,7 @@ function createProjectHandlers(ctx, getStore) {
       projects: store().list().map((e) => ({
         projectId: e.projectId,
         path: e.path,
-        exists: (0, import_node_fs7.existsSync)(e.path)
+        exists: (0, import_node_fs8.existsSync)(e.path)
       }))
     };
   }
@@ -28215,11 +29066,102 @@ function armStartupDeadline({
   return { markOutput: stop, cancel: stop };
 }
 
+// src/background-jobs.ts
+var import_node_child_process9 = require("node:child_process");
+var import_promises8 = require("node:fs/promises");
+var import_node_util = require("node:util");
+var execFileAsync2 = (0, import_node_util.promisify)(import_node_child_process9.execFile);
+var EXEC_TIMEOUT_MS = 5e3;
+function claudeEvalArg(cmd) {
+  return `'${cmd.replace(/'/g, `'"'"'`)}'`;
+}
+function parsePsRows(out) {
+  const rows = [];
+  for (const line of out.split("\n")) {
+    const m = /^\s*(\d+)\s+(\d+)\s(.*)$/.exec(line);
+    if (m) rows.push({ pid: Number(m[1]), ppid: Number(m[2]), args: m[3].trim() });
+  }
+  return rows;
+}
+function descendantsOf(rootPid, rows) {
+  const byParent = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const list = byParent.get(r.ppid);
+    if (list) list.push(r);
+    else byParent.set(r.ppid, [r]);
+  }
+  const out = [];
+  const queue = [rootPid];
+  const seen = new Set(queue);
+  while (queue.length > 0) {
+    for (const child of byParent.get(queue.shift()) ?? []) {
+      if (seen.has(child.pid)) continue;
+      seen.add(child.pid);
+      out.push(child);
+      queue.push(child.pid);
+    }
+  }
+  return out;
+}
+function matchLiveJobs(jobs, descendants, stdoutByPid) {
+  const outputs = new Set(stdoutByPid.values());
+  const alive = [];
+  for (const job of jobs) {
+    const outputFile = `/tasks/${job.id}.output`;
+    const byOutput = job.kind === "shell" && [...outputs].some((path9) => path9.endsWith(outputFile));
+    const evalArg = job.command ? `eval ${claudeEvalArg(job.command)}` : null;
+    const byCommand = evalArg !== null && descendants.some((d) => d.args.includes(evalArg));
+    if (byOutput || byCommand) alive.push(job.id);
+  }
+  return alive;
+}
+async function readStdoutPaths(pids) {
+  const out = /* @__PURE__ */ new Map();
+  if (pids.length === 0) return out;
+  if (process.platform === "linux") {
+    await Promise.all(
+      pids.map(
+        (pid2) => (0, import_promises8.readlink)(`/proc/${pid2}/fd/1`).then(
+          (path9) => void out.set(pid2, path9),
+          () => void 0
+        )
+      )
+    );
+    return out;
+  }
+  const res = await execFileAsync2(
+    "lsof",
+    ["-b", "-n", "-P", "-w", "-a", "-p", pids.join(","), "-d", "1", "-F", "pn"],
+    {
+      timeout: EXEC_TIMEOUT_MS,
+      maxBuffer: 4 * 1024 * 1024
+    }
+  ).catch((err) => ({ stdout: err.stdout ?? "" }));
+  let pid = 0;
+  for (const line of res.stdout.split("\n")) {
+    if (line.startsWith("p")) pid = Number(line.slice(1));
+    else if (line.startsWith("n") && pid) out.set(pid, line.slice(1));
+  }
+  return out;
+}
+async function probeBackgroundJobs(rootPid, jobs) {
+  if (process.platform === "win32") return null;
+  if (jobs.length === 0) return [];
+  const { stdout: stdout2 } = await execFileAsync2("ps", ["-A", "-ww", "-o", "pid=,ppid=,args="], {
+    timeout: EXEC_TIMEOUT_MS,
+    maxBuffer: 16 * 1024 * 1024
+  });
+  const descendants = descendantsOf(rootPid, parsePsRows(stdout2));
+  const needStdout = jobs.some((j) => j.kind === "shell");
+  const stdoutByPid = needStdout ? await readStdoutPaths(descendants.map((d) => d.pid)) : /* @__PURE__ */ new Map();
+  return matchLiveJobs(jobs, descendants, stdoutByPid);
+}
+
 // src/spawn-admission.ts
-var import_node_os5 = require("node:os");
+var import_node_os6 = require("node:os");
 var DEFAULT_START_CAP_MS = 5e3;
 var DEFAULT_WARM_QUIET_MS = 3e3;
-function defaultAdmissionConcurrency(cores = (0, import_node_os5.availableParallelism)()) {
+function defaultAdmissionConcurrency(cores = (0, import_node_os6.availableParallelism)()) {
   return Math.max(2, Math.min(4, Math.floor(cores / 2)));
 }
 var LANE_RANK = { foreground: 0, background: 1, warm: 2 };
@@ -28342,7 +29284,7 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
   const admission = options.admission ?? createSpawnAdmission();
   const queued = /* @__PURE__ */ new Map();
   function resolveCwd(opts) {
-    if (opts.cwd) return opts.cwd;
+    if (opts.cwd) return spawnCwd(opts.cwd, ctx.config.allowedRoots);
     if (!opts.projectId) throw new Error("pty.spawn needs either cwd or projectId");
     const entry = getProjectPaths?.()?.get(opts.projectId);
     if (!entry) {
@@ -28350,7 +29292,7 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
         `project ${opts.projectId} is not checked out on this computer \u2014 adopt a folder or enable remote git for it`
       );
     }
-    return entry.path;
+    return spawnCwd(entry.path, ctx.config.allowedRoots);
   }
   function buildEnv(overrides) {
     const merged = overrides ? { ...sanitizeSpawnEnv(process.env), ...overrides } : sanitizeSpawnEnv(process.env);
@@ -28590,6 +29532,13 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     const item = queued.get(params.sessionId);
     return { ok: true, queued: item ? admission.prioritize(item.ticket) : false };
   }
+  async function backgroundJobs(rawParams) {
+    const params = ptyBackgroundJobsParamsSchema.parse(rawParams);
+    const pid = sessions.get(params.sessionId)?.proc.pid;
+    if (pid === void 0) return { ok: true, supported: true, alive: [] };
+    const alive = await probeBackgroundJobs(pid, params.jobs);
+    return alive === null ? { ok: true, supported: false, alive: [] } : { ok: true, supported: true, alive };
+  }
   function dropQueued(reason) {
     for (const id of [...queued.keys()]) cancelQueued(id, reason);
   }
@@ -28602,6 +29551,15 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
         `no warm session ${params.warmId} to adopt`
       );
     }
+    const displaced = sessions.get(params.sessionId);
+    if (displaced) {
+      ctx.log("warm adopt displaced a live session", {
+        warmId: params.warmId,
+        sessionId: params.sessionId,
+        displacedPid: displaced.proc.pid,
+        displacedWarm: !!displaced.warm
+      });
+    }
     sessions.delete(params.warmId);
     session.id = params.sessionId;
     delete session.warm;
@@ -28759,6 +29717,7 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     [HubToComputerMethods.ptyGetBufferSince]: getBufferSince,
     [HubToComputerMethods.ptyList]: list,
     [HubToComputerMethods.ptyPrioritize]: prioritize,
+    [HubToComputerMethods.ptyBackgroundJobs]: backgroundJobs,
     [HubToComputerMethods.ptyWarmSpawn]: warmSpawn,
     [HubToComputerMethods.ptyWarmAdopt]: warmAdopt,
     [HubToComputerMethods.ptyWarmKill]: warmKill,
@@ -28768,27 +29727,46 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
 }
 
 // src/handlers/computer-config.ts
-var import_node_fs8 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path11 = require("node:path");
+function canonicalRoots(roots) {
+  const applied = [];
+  const rejected = [];
+  for (const root of roots) {
+    if (!(0, import_node_path11.isAbsolute)(root)) {
+      rejected.push({ path: root, reason: "not an absolute path" });
+      continue;
+    }
+    let real;
+    try {
+      real = import_node_fs9.realpathSync.native((0, import_node_path11.resolve)(root));
+    } catch {
+      rejected.push({ path: root, reason: "does not exist on this computer" });
+      continue;
+    }
+    if (!applied.includes(real)) applied.push(real);
+  }
+  return { roots: applied, rejected };
+}
+function reloadLocalRoots(config2, declared) {
+  if (!declared || declared.length === 0) return null;
+  const { roots } = canonicalRoots(declared);
+  if (roots.length === 0) return null;
+  const same = roots.length === config2.allowedRoots.length && roots.every((r, i) => r === config2.allowedRoots[i]);
+  if (same) return null;
+  config2.allowedRoots = roots;
+  return roots;
+}
 function createComputerConfigHandlers(ctx) {
   function setAllowedRoots(rawParams) {
     const { roots } = computerSetAllowedRootsParamsSchema.parse(rawParams);
-    const applied = [];
-    const rejected = [];
-    for (const root of roots) {
-      if (!(0, import_node_path8.isAbsolute)(root)) {
-        rejected.push({ path: root, reason: "not an absolute path" });
-        continue;
-      }
-      let real;
-      try {
-        real = import_node_fs8.realpathSync.native((0, import_node_path8.resolve)(root));
-      } catch {
-        rejected.push({ path: root, reason: "does not exist on this computer" });
-        continue;
-      }
-      if (!applied.includes(real)) applied.push(real);
+    if (!ctx.config.hubMayEditRoots) {
+      throw new RpcError(
+        ComputerTransportErrorCodes.refusedByComputer,
+        `this computer's folder limits are set on the computer itself, not by a hub \u2014 on that machine run \`slay computer roots ${ctx.config.name} --add <dir>\` (or edit allowedRoots in its computer.config.json)`
+      );
     }
+    const { roots: applied, rejected } = canonicalRoots(roots);
     if (applied.length === 0) {
       throw new Error(
         rejected.length > 0 ? `no usable roots: ${rejected.map((r) => `${r.path} (${r.reason})`).join(", ")}` : "a computer needs at least one allowed root; revoke the computer to stop it entirely"
@@ -28805,13 +29783,13 @@ function createComputerConfigHandlers(ctx) {
 }
 
 // src/project-paths.ts
-var import_promises8 = require("node:fs/promises");
-var import_node_os6 = require("node:os");
-var import_node_path9 = require("node:path");
+var import_promises9 = require("node:fs/promises");
+var import_node_os7 = require("node:os");
+var import_node_path12 = require("node:path");
 function slayzoneRootDir3() {
   if (process.env.SLAYZONE_ROOT) return process.env.SLAYZONE_ROOT;
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? (0, import_node_os6.homedir)();
-  return (0, import_node_path9.join)(home, ".slayzone");
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? (0, import_node_os7.homedir)();
+  return (0, import_node_path12.join)(home, ".slayzone");
 }
 var projectPathEntrySchema = external_exports.object({
   /** Absolute, realpath-resolved at write time. */
@@ -28820,13 +29798,13 @@ var projectPathEntrySchema = external_exports.object({
 });
 var projectMapSchema = external_exports.record(external_exports.string(), projectPathEntrySchema);
 function projectsFilePath(baseDir) {
-  return (0, import_node_path9.join)(baseDir ?? slayzoneRootDir3(), "computer.projects.json");
+  return (0, import_node_path12.join)(baseDir ?? slayzoneRootDir3(), "computer.projects.json");
 }
 var fileSchema = external_exports.record(external_exports.string(), projectMapSchema);
 async function readFileMap(filePath) {
   let raw;
   try {
-    raw = await (0, import_promises8.readFile)(filePath, "utf8");
+    raw = await (0, import_promises9.readFile)(filePath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return {};
     throw err;
@@ -28851,14 +29829,14 @@ async function readFileMap(filePath) {
   return fileSchema.parse(out);
 }
 async function writeFileMap(filePath, map2) {
-  await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(filePath), { recursive: true, mode: 448 });
+  await (0, import_promises9.mkdir)((0, import_node_path12.dirname)(filePath), { recursive: true, mode: 448 });
   const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await (0, import_promises8.writeFile)(tmpPath, `${JSON.stringify(map2, null, 2)}
+  await (0, import_promises9.writeFile)(tmpPath, `${JSON.stringify(map2, null, 2)}
 `, { mode: 384 });
   try {
-    await (0, import_promises8.rename)(tmpPath, filePath);
+    await (0, import_promises9.rename)(tmpPath, filePath);
   } catch (err) {
-    await (0, import_promises8.rm)(tmpPath, { force: true });
+    await (0, import_promises9.rm)(tmpPath, { force: true });
     throw err;
   }
 }
@@ -28871,8 +29849,8 @@ async function createProjectPathStore(hubHost, options = {}) {
     get(projectId) {
       return cache[projectId] ?? null;
     },
-    async set(projectId, path8) {
-      const entry = { path: path8, updatedAt: Date.now() };
+    async set(projectId, path9) {
+      const entry = { path: path9, updatedAt: Date.now() };
       const all = await readFileMap(filePath);
       all[hubHost] = { ...all[hubHost] ?? {}, [projectId]: entry };
       await writeFileMap(filePath, all);
@@ -28910,6 +29888,7 @@ function createHubRequestHandler(deps) {
     deps.admission ? { admission: deps.admission } : {}
   );
   const proc = createProcHandlers(ctx, deps.getProjectPaths);
+  const fs6 = createFsHandlers(ctx);
   const shutdownHandler = async (params) => {
     const parsed = computerShutdownParamsSchema.safeParse(params ?? {});
     const reason = parsed.success ? parsed.data.reason ?? "hub-requested" : "hub-requested";
@@ -28921,21 +29900,67 @@ function createHubRequestHandler(deps) {
     ...pty2.handlers,
     ...proc.handlers,
     ...createGitHandlers(ctx),
-    ...createFsHandlers(ctx),
+    ...fs6.handlers,
     ...createComputerConfigHandlers(ctx),
     ...createGhHandlers(ctx),
     ...createProjectHandlers(ctx, deps.getProjectPaths ?? (() => null))
   };
-  const handle = async (method, params) => {
+  const hub = deps.hubHost ?? "unknown";
+  const ptyMethods = new Set(Object.keys(pty2.handlers));
+  const handle = async (method, params, rawActor) => {
+    const parsedActor = requestActorSchema.safeParse(rawActor);
+    const actor = parsedActor.success ? parsedActor.data : null;
+    const record2 = (result, code, reason) => deps.requestLog?.record({
+      hub,
+      method,
+      actor,
+      params,
+      result,
+      ...code !== void 0 ? { code } : {},
+      ...reason !== void 0 ? { reason } : {}
+    });
+    if (!actor) {
+      const err = new RpcError(
+        ComputerTransportErrorCodes.protocolMismatch,
+        "hub sent no actor with this request (a hub older than computer protocol v3) \u2014 upgrade the hub to this computer's release"
+      );
+      record2("refused", err.code, err.message);
+      throw err;
+    }
     const entry = table[method];
     if (!entry) {
-      throw new RpcError(ComputerTransportErrorCodes.unimplemented, `unimplemented: ${method}`);
+      const err = new RpcError(
+        ComputerTransportErrorCodes.unimplemented,
+        `unimplemented: ${method}`
+      );
+      record2("error", err.code);
+      throw err;
+    }
+    try {
+      if (deps.pathReady && !ptyMethods.has(method)) await deps.pathReady;
+      const result = await entry(params);
+      record2("ok");
+      return result;
+    } catch (err) {
+      if (err instanceof JailViolationError) {
+        log("request refused by the path jail", { method, reason: err.message });
+        const refused = new RpcError(ComputerTransportErrorCodes.refusedByComputer, err.message);
+        record2("refused", refused.code, err.message);
+        throw refused;
+      }
+      if (err instanceof RpcError && err.code === ComputerTransportErrorCodes.refusedByComputer) {
+        log("request refused by local policy", { method, reason: err.message });
+        record2("refused", err.code, err.message);
+        throw err;
+      }
+      record2("error", err instanceof RpcError ? err.code : JSON_RPC_INTERNAL_ERROR);
+      throw err;
     }
-    return entry(params);
   };
   const dispose = () => {
     pty2.disposeAll();
     proc.disposeAll();
+    fs6.disposeAll();
   };
   const setAgentHookUrl = (url2) => {
     ctx.agentHookUrl = url2;
@@ -28964,6 +29989,36 @@ function startComputer(config2, deps = {}) {
     });
   });
   let handle;
+  const stateDir = deps.stateDir ?? (0, import_node_path13.dirname)(getComputerConfigFilePath());
+  const configFile = (0, import_node_path13.join)(stateDir, "computer.config.json");
+  setProtectedPaths([
+    configFile,
+    // The legacy file computer.config.json falls back to when absent.
+    (0, import_node_path13.join)(stateDir, "config.json"),
+    credentialsFilePath(stateDir),
+    (0, import_node_path13.join)(stateDir, REQUEST_LOG_DIR_NAME)
+  ]);
+  const requestLog = createRequestLog({
+    stateDir,
+    onError: (err) => log("request log write failed", { error: String(err) })
+  });
+  log("local request log", { file: requestLog.filePath });
+  const watchLocalRoots = !config2.hubMayEditRoots;
+  if (watchLocalRoots) {
+    (0, import_node_fs10.watchFile)(configFile, { interval: 2e3, persistent: false }, () => {
+      const declared = loadComputerConfigFile(configFile).allowedRoots;
+      const applied = reloadLocalRoots(config2, declared);
+      if (!applied) return;
+      log("allowedRoots reloaded from local config", { applied });
+      requestLog.record({
+        hub: "local",
+        method: "local.allowedRoots",
+        actor: null,
+        params: { roots: applied },
+        result: "ok"
+      });
+    });
+  }
   const admission = createSpawnAdmission();
   const connectHub = (hubUrl, isPrimary) => {
     const credentialStore = (isPrimary ? deps.credentialStore : void 0) ?? createFileCredentialStore(hubHostFromUrl(hubUrl));
@@ -28973,7 +30028,7 @@ function startComputer(config2, deps = {}) {
       identity,
       credentialStore,
       ...config2.joinToken && isPrimary ? { joinToken: config2.joinToken } : {},
-      onHubRequest: (method, params) => dispatch.handle(method, params),
+      onHubRequest: (method, params, actor) => dispatch.handle(method, params, actor),
       log
     });
     let projectPaths = null;
@@ -28994,7 +30049,10 @@ function startComputer(config2, deps = {}) {
       config: config2,
       log,
       getProjectPaths: () => projectPaths,
-      admission
+      admission,
+      requestLog,
+      hubHost: hubHostFromUrl(hubUrl),
+      ...deps.pathReady ? { pathReady: deps.pathReady } : {}
     });
     dialer.events.on(
       "connected",
@@ -29044,6 +30102,7 @@ function startComputer(config2, deps = {}) {
     dialers: connections.map((c) => c.dialer),
     stop: async () => {
       hostIdStop?.();
+      if (watchLocalRoots) (0, import_node_fs10.unwatchFile)(configFile);
       await Promise.all(connections.map((c) => c.dispose()));
     }
   };
@@ -29085,7 +30144,7 @@ async function maybeInteractiveSetup() {
         default: defaultRoot,
         transform: (raw) => {
           const roots = raw.split(",").map((r) => r.trim()).filter((r) => r.length > 0);
-          return roots.length > 0 ? { config: roots, env: roots.join(import_node_path10.delimiter) } : null;
+          return roots.length > 0 ? { config: roots, env: roots.join(import_node_path14.delimiter) } : null;
         }
       },
       {
@@ -29097,7 +30156,7 @@ async function maybeInteractiveSetup() {
         configKey: "computerName",
         envKey: "SLAYZONE_COMPUTER_NAME",
         label: "Computer display name",
-        hint: `default: ${(0, import_node_os7.hostname)()}`
+        hint: `default: ${(0, import_node_os8.hostname)()}`
       }
     ]
   });
@@ -29109,7 +30168,8 @@ async function maybeInteractiveSetup() {
   return out;
 }
 async function main() {
-  if (process.env.SLAYZONE_SUPERVISED !== "1" && !process.env.SLAYZONE_ROOT) {
+  const supervised = process.env.SLAYZONE_SUPERVISED === "1";
+  if (!supervised && !process.env.SLAYZONE_ROOT) {
     process.env.SLAYZONE_ROOT = process.cwd();
   }
   const prompted = await maybeInteractiveSetup();
@@ -29139,12 +30199,18 @@ async function main() {
 `);
   };
   for (const notice of ignoredCertPinNotices()) log(notice);
-  if (process.env.SLAYZONE_SUPERVISED !== "1") {
+  if (!supervised) {
     const { installAgentHooks: installAgentHooks2 } = await Promise.resolve().then(() => (init_agent_hooks2(), agent_hooks_exports));
     await installAgentHooks2(log);
   }
+  const pathReady = adoptLoginShellPath().then(
+    (adopted) => log(
+      adopted ? `PATH: adopted login-shell PATH (+${adopted.added.length} entries)` : "PATH: no login-shell PATH probed \u2014 keeping the inherited one"
+    )
+  );
   const handle = startComputer(config2, {
     log,
+    pathReady,
     onShutdown: () => {
       process.exitCode = 0;
     }
@@ -29157,16 +30223,27 @@ async function main() {
     if (fatal) process.exitCode = 1;
   });
   let stopping = false;
-  const gracefulStop = (signal) => {
+  const gracefulStop = (why) => {
     if (stopping) return;
     stopping = true;
-    log(`received ${signal}, stopping`);
+    log(why);
+    if (supervised) {
+      setTimeout(() => {
+        log(`still running ${SUPERVISED_STOP_DEADLINE_MS}ms after stop began \u2014 forcing exit`);
+        process.exit(1);
+      }, SUPERVISED_STOP_DEADLINE_MS).unref();
+    }
     void handle.stop().then(() => {
       process.exitCode ??= 0;
     });
   };
-  process.on("SIGINT", () => gracefulStop("SIGINT"));
-  process.on("SIGTERM", () => gracefulStop("SIGTERM"));
+  process.on("SIGINT", () => gracefulStop("received SIGINT, stopping"));
+  process.on("SIGTERM", () => gracefulStop("received SIGTERM, stopping"));
+  if (supervised) {
+    watchParent({
+      onParentDeath: (reason) => gracefulStop(`parent app is gone (${reason}), stopping`)
+    });
+  }
 }
 void main();
 //# sourceMappingURL=bin.cjs.map