@slayzone/computer 0.36.3 → 0.36.4

package/dist/bin.cjs

@@ -1453,7 +1453,7 @@ var require_receiver = __commonJS({
 var require_sender = __commonJS({
   "../../../node_modules/ws/lib/sender.js"(exports2, module2) {
     "use strict";
-    var { Duplex } = require("stream");
+    var { Duplex: Duplex2 } = require("stream");
     var { randomFillSync } = require("crypto");
     var {
       types: { isUint8Array }
@@ -2330,11 +2330,11 @@ var require_websocket = __commonJS({
     "use strict";
     var EventEmitter = require("events");
     var https = require("https");
-    var http2 = require("http");
+    var http3 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes, createHash } = require("crypto");
-    var { Duplex, Readable } = require("stream");
+    var { randomBytes: randomBytes2, createHash } = require("crypto");
+    var { Duplex: Duplex2, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
     var Receiver2 = require_receiver();
@@ -2884,8 +2884,8 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes(16).toString("base64");
-      const request = isSecure ? https.request : http2.request;
+      const key = randomBytes2(16).toString("base64");
+      const request = isSecure ? https.request : http3.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -3238,7 +3238,7 @@ var require_stream = __commonJS({
   "../../../node_modules/ws/lib/stream.js"(exports2, module2) {
     "use strict";
     var WebSocket2 = require_websocket();
-    var { Duplex } = require("stream");
+    var { Duplex: Duplex2 } = require("stream");
     function emitClose(stream) {
       stream.emit("close");
     }
@@ -3256,7 +3256,7 @@ var require_stream = __commonJS({
     }
     function createWebSocketStream2(ws, options) {
       let terminateOnDestroy = true;
-      const duplex = new Duplex({
+      const duplex = new Duplex2({
         ...options,
         autoDestroy: false,
         emitClose: false,
@@ -3381,8 +3381,8 @@ var require_websocket_server = __commonJS({
   "../../../node_modules/ws/lib/websocket-server.js"(exports2, module2) {
     "use strict";
     var EventEmitter = require("events");
-    var http2 = require("http");
-    var { Duplex } = require("stream");
+    var http3 = require("http");
+    var { Duplex: Duplex2 } = require("stream");
     var { createHash } = require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -3462,8 +3462,8 @@ var require_websocket_server = __commonJS({
           );
         }
         if (options.port != null) {
-          this._server = http2.createServer((req, res) => {
-            const body = http2.STATUS_CODES[426];
+          this._server = http3.createServer((req, res) => {
+            const body = http3.STATUS_CODES[426];
             res.writeHead(426, {
               "Content-Length": body.length,
               "Content-Type": "text/plain"
@@ -3752,7 +3752,7 @@ var require_websocket_server = __commonJS({
       this.destroy();
     }
     function abortHandshake(socket, code, message, headers) {
-      message = message || http2.STATUS_CODES[code];
+      message = message || http3.STATUS_CODES[code];
       headers = {
         Connection: "close",
         "Content-Type": "text/html",
@@ -3761,7 +3761,7 @@ var require_websocket_server = __commonJS({
       };
       socket.once("finish", socket.destroy);
       socket.end(
-        `HTTP/1.1 ${code} ${http2.STATUS_CODES[code]}\r
+        `HTTP/1.1 ${code} ${http3.STATUS_CODES[code]}\r
 ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
       );
     }
@@ -5220,10 +5220,10 @@ var init_agent_hooks = __esm({
   }
 });
 
-// raw-import:/tmp/slz-publish-wt.GgutIu/packages/shared/hooks/src/notify.sh
+// raw-import:/tmp/slz-publish-wt.a2Pyg4/packages/shared/hooks/src/notify.sh
 var notify_default;
 var init_notify = __esm({
-  "raw-import:/tmp/slz-publish-wt.GgutIu/packages/shared/hooks/src/notify.sh"() {
+  "raw-import:/tmp/slz-publish-wt.a2Pyg4/packages/shared/hooks/src/notify.sh"() {
     notify_default = `#!/bin/sh
 # SlayZone agent lifecycle hook \u2014 BENIGN DUMB FORWARDER.
 #
@@ -5385,10 +5385,10 @@ exit 0
   }
 });
 
-// raw-import:/tmp/slz-publish-wt.GgutIu/packages/shared/hooks/src/opencode-plugin.js
+// raw-import:/tmp/slz-publish-wt.a2Pyg4/packages/shared/hooks/src/opencode-plugin.js
 var opencode_plugin_default;
 var init_opencode_plugin = __esm({
-  "raw-import:/tmp/slz-publish-wt.GgutIu/packages/shared/hooks/src/opencode-plugin.js"() {
+  "raw-import:/tmp/slz-publish-wt.a2Pyg4/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";
   }
 });
@@ -5431,7 +5431,7 @@ var init_agent_hooks2 = __esm({
 });
 
 // src/bin.ts
-var import_node_os10 = require("node:os");
+var import_node_os11 = require("node:os");
 var import_node_path18 = require("node:path");
 
 // ../../shared/platform/src/config-prompt.ts
@@ -25569,7 +25569,7 @@ function date4(params) {
 
 // ../../domains/computer-transport/src/shared/frames.ts
 var COMPUTER_EXIT_NEEDS_RE_ENROLLMENT = 78;
-var COMPUTER_PROTOCOL_VERSION = 3;
+var COMPUTER_PROTOCOL_VERSION = 4;
 var ComputerTransportErrorCodes = {
   /** Command is part of the contract but not implemented by this peer. */
   unimplemented: -32001,
@@ -25671,12 +25671,14 @@ var ComputerNotificationMethods = {
 };
 var ptyDataParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
+  spawnId: external_exports.string().min(1).optional(),
   /** Monotonic per-session sequence number, preserved end-to-end. */
   seq: external_exports.number().int().nonnegative(),
   data: external_exports.string()
 });
 var ptyExitParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
+  spawnId: external_exports.string().min(1).optional(),
   exitCode: external_exports.number().int().nullable(),
   signal: external_exports.string().nullable().optional(),
   /**
@@ -25828,6 +25830,9 @@ var ptySpawnParamsSchema = external_exports.object({
   startupTimeoutMs: external_exports.number().int().positive().optional(),
   command: external_exports.string().min(1),
   args: external_exports.array(external_exports.string()).optional(),
+  /** New computers resolve their own login shell; command/args remain for older peers. */
+  computerShell: external_exports.boolean().optional(),
+  computerShellCommand: external_exports.string().optional(),
   /**
    * Absolute cwd. Optional now: when absent the COMPUTER resolves it from
    * `projectId` against its own `project.*` mapping, because the hub cannot —
@@ -25846,6 +25851,19 @@ var ptySpawnParamsSchema = external_exports.object({
 }).refine((p) => p.cwd !== void 0 || p.projectId !== void 0, {
   message: "pty.spawn needs either cwd or projectId"
 });
+var HUB_PTY_ENV_KEYS = [
+  "SLAYZONE_TASK_ID",
+  "SLAYZONE_PROJECT_ID",
+  "SLAYZONE_AGENT_ID",
+  "SLAYZONE_AGENT_HOOK_CONTEXT"
+];
+function pickHubPtyEnv(env) {
+  const picked = {};
+  for (const key of HUB_PTY_ENV_KEYS) {
+    if (env?.[key] !== void 0) picked[key] = env[key];
+  }
+  return picked;
+}
 var ptySpawnResultSchema = external_exports.object({
   pid: external_exports.number().int(),
   /** The computer armed the requested `startupTimeoutMs`. Absent from a computer
@@ -25854,10 +25872,12 @@ var ptySpawnResultSchema = external_exports.object({
 });
 var ptyKillParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
+  spawnId: spawnIdField,
   signal: external_exports.string().optional()
 });
 var ptyPrioritizeParamsSchema = external_exports.object({
-  sessionId: external_exports.string().min(1)
+  sessionId: external_exports.string().min(1),
+  spawnId: spawnIdField
 });
 var ptyPrioritizeResultSchema = external_exports.object({
   ok: external_exports.literal(true),
@@ -25865,6 +25885,7 @@ var ptyPrioritizeResultSchema = external_exports.object({
 });
 var ptyBackgroundJobsParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
+  spawnId: spawnIdField,
   jobs: external_exports.array(
     external_exports.object({
       id: external_exports.string().min(1),
@@ -25893,15 +25914,18 @@ var ptyDoctorResultSchema = external_exports.object({
 });
 var ptyResizeParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
+  spawnId: spawnIdField,
   cols: external_exports.number().int().positive(),
   rows: external_exports.number().int().positive()
 });
 var ptyWriteParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
+  spawnId: spawnIdField,
   data: external_exports.string()
 });
 var ptyGetBufferSinceParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
+  spawnId: spawnIdField,
   /**
    * Exclusive lower bound — frames with `seq > this` are replayed.
    *
@@ -25943,6 +25967,7 @@ var ptyWarmSpawnParamsSchema = external_exports.object({
   warmId: external_exports.string().min(1),
   command: external_exports.string().min(1),
   args: external_exports.array(external_exports.string()).optional(),
+  computerShell: external_exports.boolean().optional(),
   cwd: external_exports.string().min(1),
   env: external_exports.record(external_exports.string(), external_exports.string()).optional(),
   cols: external_exports.number().int().positive().optional(),
@@ -26432,6 +26457,20 @@ function wsDataToText(data) {
   return data.toString("utf8");
 }
 
+// ../../domains/computer-transport/src/shared/http-tunnel.ts
+var HTTP_TUNNEL_PREFIX = "cli.v1.";
+var HTTP_TUNNEL_CHUNK = 32 * 1024;
+var httpTunnelParamsSchema = external_exports.object({
+  id: external_exports.string().min(1).max(100),
+  data: external_exports.string().max(Math.ceil(HTTP_TUNNEL_CHUNK / 3) * 4).optional(),
+  end: external_exports.boolean().optional()
+}).strict();
+var httpTunnelOpenResultSchema = external_exports.object({ id: external_exports.string().min(1).max(100) });
+var httpTunnelReadResultSchema = external_exports.object({
+  data: external_exports.string().max(Math.ceil(HTTP_TUNNEL_CHUNK / 3) * 4),
+  end: external_exports.boolean()
+});
+
 // ../../domains/computer-transport/src/client/backoff.ts
 var DEFAULT_BACKOFF = {
   initialDelayMs: 100,
@@ -26925,6 +26964,64 @@ var HubDialer = class {
   }
 };
 
+// ../../domains/computer-transport/src/client/http-tunnel.ts
+var import_node_stream = require("node:stream");
+async function openHttpTunnel(requester) {
+  const { id } = httpTunnelOpenResultSchema.parse(
+    await requester.request(`${HTTP_TUNNEL_PREFIX}open`)
+  );
+  let reading = false;
+  const socket = new import_node_stream.Duplex({
+    read() {
+      if (reading) return;
+      reading = true;
+      void (async () => {
+        try {
+          while (!socket.destroyed) {
+            const result = httpTunnelReadResultSchema.parse(
+              await requester.request(`${HTTP_TUNNEL_PREFIX}read`, { id })
+            );
+            const more = result.data ? socket.push(Buffer.from(result.data, "base64")) : true;
+            if (result.end) {
+              socket.push(null);
+              break;
+            }
+            if (!more) break;
+          }
+        } catch (error62) {
+          socket.destroy(error62 instanceof Error ? error62 : new Error(String(error62)));
+        } finally {
+          reading = false;
+        }
+      })();
+    },
+    write(chunk, _encoding, done) {
+      void (async () => {
+        for (let offset = 0; offset < chunk.length; offset += HTTP_TUNNEL_CHUNK) {
+          await requester.request(`${HTTP_TUNNEL_PREFIX}write`, {
+            id,
+            data: chunk.subarray(offset, offset + HTTP_TUNNEL_CHUNK).toString("base64")
+          });
+        }
+      })().then(() => done(), done);
+    },
+    final(done) {
+      void requester.request(`${HTTP_TUNNEL_PREFIX}write`, { id, end: true }).then(() => done(), done);
+    },
+    destroy(error62, done) {
+      void requester.request(`${HTTP_TUNNEL_PREFIX}close`, { id }).catch(() => {
+      });
+      done(error62);
+    }
+  });
+  Object.assign(socket, {
+    setTimeout: () => socket,
+    setNoDelay: () => socket,
+    setKeepAlive: () => socket
+  });
+  return socket;
+}
+
 // src/config.ts
 var import_node_fs2 = require("node:fs");
 var import_node_os2 = require("node:os");
@@ -27446,8 +27543,10 @@ function assertHubLocalExecEnabled(refusal) {
 
 // ../../shared/platform/src/env-manifest.ts
 var ENV_MANIFEST = {
-  // --- secret: credentials/tokens, never in a terminal ---
+  // --- secret: credentials/tokens, never inherited into a terminal ---
   SLAYZONE_HUB_TOKEN: "secret",
+  SLAYZONE_CLI_RELAY_TOKEN: "secret",
+  // computer-issued capability, re-added per session
   // 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
@@ -27482,6 +27581,8 @@ var ENV_MANIFEST = {
   // 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_CLI_RELAY_ADDRESS: "infra",
+  // computer loopback; re-added per session
   SLAYZONE_HUB_LISTEN_ADDRESS: "infra",
   // hub-only; where the hub listens
   SLAYZONE_HUB_PUBLIC_ADDRESS: "infra",
@@ -28089,6 +28190,155 @@ function createAgentHookServer(ctx) {
   });
 }
 
+// src/cli-relay.ts
+var import_node_http2 = __toESM(require("node:http"), 1);
+var import_node_crypto3 = require("node:crypto");
+function responseHeaders(headers) {
+  const excluded = /* @__PURE__ */ new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "proxy-connection",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    ...(headers.connection ?? "").split(",").map((name) => name.trim().toLowerCase())
+  ]);
+  return Object.fromEntries(Object.entries(headers).filter(([name]) => !excluded.has(name)));
+}
+async function createComputerCliRelay(requester) {
+  const tokens = /* @__PURE__ */ new Map();
+  const responses = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  const server = import_node_http2.default.createServer((req, res) => {
+    const token = req.headers.authorization?.replace(/^Bearer /, "") ?? "";
+    const requests = tokens.get(token);
+    if (!requests) {
+      res.writeHead(401, { "content-type": "application/json" }).end(
+        JSON.stringify({
+          error: "CLI relay capability is missing or expired. Open a new task terminal."
+        })
+      );
+      return;
+    }
+    if (responses.size >= 32) {
+      res.writeHead(429).end("Too many CLI relay requests");
+      return;
+    }
+    let upstream;
+    let receivedResponse = false;
+    let cancelled = false;
+    responses.add(res);
+    requests.add(res);
+    res.on("close", () => {
+      responses.delete(res);
+      requests.delete(res);
+      cancelled = true;
+      upstream?.destroy();
+    });
+    void openHttpTunnel(requester).then((socket) => {
+      if (cancelled || !tokens.has(token)) {
+        socket.destroy();
+        return;
+      }
+      const headers = { connection: "close" };
+      for (const name of ["content-type", "content-length", "accept", "last-event-id"]) {
+        if (req.headers[name] !== void 0) headers[name] = req.headers[name];
+      }
+      const agent = new import_node_http2.default.Agent({ keepAlive: false });
+      agent.createConnection = () => socket;
+      upstream = import_node_http2.default.request(
+        {
+          host: "relay",
+          path: req.url,
+          method: req.method,
+          headers,
+          agent
+        },
+        (response) => {
+          receivedResponse = true;
+          const stopUpload = () => {
+            req.unpipe(upstream);
+            req.resume();
+          };
+          if ((response.statusCode ?? 502) >= 400) stopUpload();
+          response.on("end", stopUpload);
+          res.writeHead(response.statusCode ?? 502, responseHeaders(response.headers));
+          response.on("error", () => res.destroy());
+          response.pipe(res);
+        }
+      );
+      active.add(upstream);
+      const current = upstream;
+      upstream.on("close", () => {
+        active.delete(current);
+        agent.destroy();
+      });
+      upstream.on("error", () => {
+        if (receivedResponse) return;
+        if (res.headersSent) res.destroy();
+        else
+          res.writeHead(503, { "content-type": "application/json" }).end(
+            JSON.stringify({
+              error: "CLI relay lost its hub connection. Check the computer connection, then retry."
+            })
+          );
+      });
+      req.on("aborted", () => upstream?.destroy());
+      req.pipe(upstream);
+    }).catch(() => {
+      if (!res.headersSent)
+        res.writeHead(503, { "content-type": "application/json" }).end(
+          JSON.stringify({
+            error: "CLI relay unavailable. Check the computer connection and update hub and computer together."
+          })
+        );
+    });
+  });
+  await new Promise((resolve9, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve9);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("CLI relay failed to bind");
+  const disconnect = () => {
+    for (const response of responses) {
+      if (response.headersSent) response.destroy();
+      else
+        response.writeHead(503, { "content-type": "application/json" }).end(
+          JSON.stringify({
+            error: "CLI relay lost its hub connection. Check the computer connection, then retry."
+          })
+        );
+    }
+    for (const request of active) request.destroy(new Error("hub disconnected"));
+  };
+  return {
+    url: `http://127.0.0.1:${address.port}`,
+    issue() {
+      const token = (0, import_node_crypto3.randomBytes)(32).toString("hex");
+      const requests = /* @__PURE__ */ new Set();
+      tokens.set(token, requests);
+      return {
+        token,
+        revoke() {
+          tokens.delete(token);
+          for (const response of requests) response.destroy();
+        }
+      };
+    },
+    disconnect,
+    async close() {
+      tokens.clear();
+      disconnect();
+      server.closeAllConnections();
+      await new Promise((resolve9) => server.close(() => resolve9()));
+    }
+  };
+}
+
 // src/handlers/fs.ts
 var import_node_fs7 = require("node:fs");
 var import_promises7 = require("node:fs/promises");
@@ -31613,18 +31863,37 @@ function resolveCommand(command, env, cwd) {
 }
 
 // src/handlers/spawn-env.ts
-function buildSpawnEnv(ctx, overrides) {
+var import_node_os9 = require("node:os");
+function buildSpawnEnv(ctx, overrides, capability) {
   const merged = overrides ? { ...sanitizeSpawnEnv(process.env), ...overrides } : sanitizeSpawnEnv(process.env);
   if (ctx.agentHookUrl) {
     merged.SLAYZONE_AGENT_HOOK_URL = ctx.agentHookUrl;
     delete merged.SLAYZONE_HUB_TOKEN;
   }
   if (ctx.hubAddress) merged.SLAYZONE_HUB_ADDRESS = ctx.hubAddress;
+  delete merged.SLAYZONE_CLI_RELAY_ADDRESS;
+  delete merged.SLAYZONE_CLI_RELAY_TOKEN;
+  if (capability && ctx.cliRelay) {
+    delete merged.SLAYZONE_HUB_TOKEN;
+    merged.SLAYZONE_CLI_RELAY_ADDRESS = new URL(ctx.cliRelay.url).host;
+    merged.SLAYZONE_CLI_RELAY_TOKEN = capability.token;
+  }
   if (ctx.config.binOverrideDir) {
     merged.PATH = mergePathLists(ctx.config.binOverrideDir, merged.PATH);
   }
   return merged;
 }
+function buildPtySpawnEnv(ctx, hubEnv, capability) {
+  const env = buildSpawnEnv(ctx, pickHubPtyEnv(hubEnv), capability);
+  const account = (0, import_node_os9.userInfo)();
+  env.HOME = account.homedir;
+  env.USER = account.username;
+  env.LOGNAME = account.username;
+  env.SHELL = resolveUserShell();
+  env.TERM = "xterm-256color";
+  env.COLORTERM = "truecolor";
+  return env;
+}
 
 // src/handlers/proc.ts
 var MAX_BUFFER_SIZE = 750 * 1024;
@@ -31717,11 +31986,14 @@ function createProcHandlers(ctx, getProjectPaths, options = {}) {
     const cwd = spawnCwd(resolved, ctx.config.allowedRoots);
     const existing = procs.get(params.sessionId);
     if (existing) {
+      existing.revokeCli?.();
       killTree(existing.child);
       procs.delete(params.sessionId);
     }
-    const env = buildSpawnEnv(ctx, params.env);
+    const capability = ctx.cliRelay?.issue();
+    const env = buildSpawnEnv(ctx, params.env, capability);
     if (!params.shell && resolveCommand(params.command, env, cwd) === null) {
+      capability?.revoke();
       throw refuse2(
         ProcRefusalReasons.binaryNotFound,
         `${params.command} was not found on this computer's PATH`,
@@ -31729,17 +32001,24 @@ function createProcHandlers(ctx, getProjectPaths, options = {}) {
       );
     }
     const invocation = params.shell ? buildShellInvocation(params.command) : { file: params.command, args: params.args ?? [] };
-    const child = (0, import_node_child_process8.spawn)(invocation.file, invocation.args, {
-      ...cwd ? { cwd } : {},
-      env,
-      // stdin PIPED (was 'ignore') so `proc.write` can reach the child.
-      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
-    });
+    let child;
+    try {
+      child = (0, import_node_child_process8.spawn)(invocation.file, invocation.args, {
+        ...cwd ? { cwd } : {},
+        env,
+        // stdin PIPED (was 'ignore') so `proc.write` can reach the child.
+        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
+      });
+    } catch (error62) {
+      capability?.revoke();
+      throw error62;
+    }
     const buffer = new RingBuffer(MAX_BUFFER_SIZE);
     const session = {
+      revokeCli: capability?.revoke,
       child,
       buffer,
       ...params.spawnId !== void 0 ? { spawnId: params.spawnId } : {},
@@ -31754,6 +32033,7 @@ function createProcHandlers(ctx, getProjectPaths, options = {}) {
       ctx.log("proc stdin error", { sessionId: params.sessionId, error: err.message });
     });
     const settle2 = (payload) => {
+      capability?.revoke();
       releaseSlot(session);
       if (procs.get(params.sessionId) !== session) return;
       procs.delete(params.sessionId);
@@ -31914,6 +32194,7 @@ function createProcHandlers(ctx, getProjectPaths, options = {}) {
     }
     queued.clear();
     for (const [sessionId, session] of procs) {
+      session.revokeCli?.();
       releaseSlot(session);
       killTree(session.child);
       ctx.log("proc disposed on shutdown", { sessionId });
@@ -32179,6 +32460,72 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
   const spawnPty = options.spawnPty ?? pty.spawn;
   const installProblems2 = options.nodePtyInstallProblems ?? installProblemsOnDisk;
   const queued = /* @__PURE__ */ new Map();
+  const starts = /* @__PURE__ */ new Map();
+  function serializeStart(id, spawnId, run) {
+    const prior = starts.get(id)?.promise ?? Promise.resolve();
+    const record2 = { spawnId, promise: void 0, cancelled: false };
+    const assertActive = () => {
+      if (record2.cancelled) throw new Error(`pty ${id}: spawn killed before start`);
+    };
+    const current = prior.catch(() => {
+    }).then(() => {
+      assertActive();
+      return run(assertActive);
+    });
+    record2.promise = current;
+    starts.set(id, record2);
+    void current.finally(() => {
+      if (starts.get(id)?.promise === current) starts.delete(id);
+    }).catch(() => {
+    });
+    return current;
+  }
+  async function waitForExit(session, timeoutMs) {
+    let timer;
+    try {
+      return await Promise.race([
+        session.exited.then(() => true),
+        new Promise((resolve9) => {
+          timer = setTimeout(() => resolve9(false), timeoutMs);
+          timer.unref?.();
+        })
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  function stopPty(session, signal) {
+    if (session.stopping) return session.stopping;
+    session.stopping = (async () => {
+      try {
+        session.proc.kill(signal);
+      } catch {
+      }
+      if (await waitForExit(session, 2e3)) return;
+      try {
+        session.proc.kill("SIGKILL");
+      } catch {
+      }
+      if (!await waitForExit(session, 2e3)) {
+        throw new Error(`pty ${session.id}: process ${session.proc.pid} did not exit`);
+      }
+    })();
+    void session.stopping.catch(() => {
+      session.stopping = void 0;
+    });
+    return session.stopping;
+  }
+  async function stopBeforeReplacement(id) {
+    const old = sessions.get(id);
+    if (!old) return;
+    old.replacing = true;
+    try {
+      await stopPty(old);
+    } catch (err) {
+      old.replacing = false;
+      throw err;
+    }
+  }
   function resolveCwd(opts) {
     if (opts.cwd) return spawnCwd(opts.cwd, ctx.config.allowedRoots);
     if (!opts.projectId) throw new Error("pty.spawn needs either cwd or projectId");
@@ -32188,33 +32535,31 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
   }
   function spawnSession(id, opts) {
     const cwd = resolveCwd(opts);
-    const existing = sessions.get(id);
-    if (existing) {
-      existing.deadline?.cancel();
-      releaseAdmission(existing);
-      try {
-        existing.proc.kill();
-      } catch {
-      }
-      sessions.delete(id);
-    }
+    if (sessions.has(id)) throw new Error(`pty ${id}: old process still live`);
+    const capability = ctx.cliRelay?.issue();
     let proc;
     try {
       proc = spawnPty(opts.command, opts.args ?? [], {
         name: "xterm-color",
         cwd,
-        env: buildSpawnEnv(ctx, opts.env),
+        env: buildPtySpawnEnv(ctx, opts.env, capability),
         cols: opts.cols ?? 80,
         rows: opts.rows ?? 24
       });
     } catch (err) {
+      capability?.revoke();
       throw explainSpawnFailure(err);
     }
     const buffer = new RingBuffer(MAX_BUFFER_SIZE2);
+    let resolveExit;
+    const exited = new Promise((resolve9) => resolveExit = resolve9);
     const session = {
+      revokeCli: capability?.revoke,
       proc,
       buffer,
       id,
+      exited,
+      resolveExit,
       ...opts.warm ? { warm: opts.warm } : {},
       ...opts.spawnId !== void 0 ? { spawnId: opts.spawnId } : {}
     };
@@ -32233,11 +32578,14 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
       if (session.warm) return;
       ctx.dialer.notify(ComputerNotificationMethods.ptyData, {
         sessionId: session.id,
+        ...session.spawnId ? { spawnId: session.spawnId } : {},
         seq,
         data
       });
     });
     proc.onExit(({ exitCode, signal }) => {
+      capability?.revoke();
+      session.resolveExit();
       reap(
         session,
         typeof exitCode === "number" ? exitCode : null,
@@ -32263,6 +32611,16 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     sessions.delete(session.id);
     session.deadline?.cancel();
     releaseAdmission(session);
+    if (session.replacing) {
+      tombstones.add(session.id, {
+        spawnId: session.spawnId,
+        pid: session.proc.pid,
+        exitCode,
+        signal,
+        reason: "replaced"
+      });
+      return;
+    }
     if (session.warm) {
       ctx.log("warm pty exited before adoption", { warmId: session.id });
       return;
@@ -32270,6 +32628,7 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     const reason = session.exitReason;
     const delivered = ctx.dialer.notify(ComputerNotificationMethods.ptyExit, {
       sessionId: session.id,
+      ...session.spawnId ? { spawnId: session.spawnId } : {},
       exitCode,
       signal,
       ...reason ? { reason } : {}
@@ -32305,11 +32664,20 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     slot.release();
   }
   function startSession(params) {
-    const session = spawnSession(params.sessionId, params);
+    const shell = params.computerShell ? resolveUserShell() : params.command;
+    const args = params.computerShell ? [
+      ...getShellStartupArgs(shell),
+      ...params.computerShellCommand ? ["-c", params.computerShellCommand] : []
+    ] : params.args;
+    const session = spawnSession(params.sessionId, {
+      ...params,
+      command: shell,
+      args
+    });
     ctx.log("pty spawned", {
       sessionId: params.sessionId,
       pid: session.proc.pid,
-      command: params.command
+      command: shell
     });
     return {
       pid: session.proc.pid,
@@ -32361,16 +32729,26 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
       }
       const waitedMs = Date.now() - enqueuedAt;
       if (waitedMs >= 1e3) ctx.log("agent start admitted after queueing", { id, lane, waitedMs });
-      item.resolve(reply);
+      Promise.resolve(reply).then(item.resolve, (err) => {
+        slot.release();
+        item.reject(err);
+      });
     });
     return promise2;
   }
   function spawn6(rawParams) {
     const params = ptySpawnParamsSchema.parse(rawParams);
+    const starting = starts.get(params.sessionId);
+    if (starting && params.spawnId !== void 0 && starting.spawnId === params.spawnId) {
+      return starting.promise;
+    }
     if (params.spawnId !== void 0) {
       const live = sessions.get(params.sessionId);
       if (live && !live.warm && live.spawnId === params.spawnId) {
-        return { pid: live.proc.pid, ...live.deadline ? { startupDeadline: true } : {} };
+        return {
+          pid: live.proc.pid,
+          ...live.deadline ? { startupDeadline: true } : {}
+        };
       }
       if (tombstones.ran(params.sessionId, params.spawnId)) {
         throw new Error(
@@ -32380,7 +32758,11 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     }
     if (params.admission === void 0) {
       const prior = queued.get(params.sessionId);
-      const reply = startSession(params);
+      const reply = sessions.has(params.sessionId) || starts.has(params.sessionId) ? serializeStart(params.sessionId, params.spawnId, async (assertActive) => {
+        await stopBeforeReplacement(params.sessionId);
+        assertActive();
+        return startSession(params);
+      }) : startSession(params);
       if (prior) {
         queued.delete(params.sessionId);
         admission.cancel(prior.ticket);
@@ -32388,11 +32770,15 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
       }
       return reply;
     }
-    return enqueueSpawn(params.sessionId, params.admission, params, (slot, item) => {
-      const reply = startSession({
-        ...params,
-        ...item.cols !== void 0 ? { cols: item.cols } : {},
-        ...item.rows !== void 0 ? { rows: item.rows } : {}
+    return enqueueSpawn(params.sessionId, params.admission, params, async (slot, item) => {
+      const reply = await serializeStart(params.sessionId, params.spawnId, async (assertActive) => {
+        await stopBeforeReplacement(params.sessionId);
+        assertActive();
+        return startSession({
+          ...params,
+          ...item.cols !== void 0 ? { cols: item.cols } : {},
+          ...item.rows !== void 0 ? { rows: item.rows } : {}
+        });
       });
       const session = sessions.get(params.sessionId);
       session.admissionSlot = slot;
@@ -32401,18 +32787,28 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     });
   }
   function startWarm(params, cols, rows) {
+    const shell = params.computerShell ? resolveUserShell() : params.command;
     const session = spawnSession(params.warmId, {
       ...params,
+      command: shell,
+      args: params.computerShell ? getShellStartupArgs(shell) : params.args,
       ...cols !== void 0 ? { cols } : {},
       ...rows !== void 0 ? { rows } : {},
       warm: { cwd: params.cwd, startedAt: Date.now() }
     });
     if (params.postSpawnCommand) session.proc.write(`${params.postSpawnCommand}\r`);
-    ctx.log("warm pty spawned", { warmId: params.warmId, pid: session.proc.pid });
+    ctx.log("warm pty spawned", {
+      warmId: params.warmId,
+      pid: session.proc.pid
+    });
     return session;
   }
   function warmSpawn(rawParams) {
     const params = ptyWarmSpawnParamsSchema.parse(rawParams);
+    const live = sessions.get(params.warmId);
+    if (live?.warm) return Promise.resolve({ pid: live.proc.pid });
+    const waiting = queued.get(params.warmId);
+    if (waiting) return waiting.promise;
     return enqueueSpawn(params.warmId, "warm", params, (slot, item) => {
       const session = startWarm(params, item.cols, item.rows);
       session.admissionSlot = slot;
@@ -32431,11 +32827,15 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
   function prioritize(rawParams) {
     const params = ptyPrioritizeParamsSchema.parse(rawParams);
     const item = queued.get(params.sessionId);
-    return { ok: true, queued: item ? admission.prioritize(item.ticket) : false };
+    return {
+      ok: true,
+      queued: item && (params.spawnId === void 0 || item.spawnId === params.spawnId) ? admission.prioritize(item.ticket) : false
+    };
   }
   async function backgroundJobs(rawParams) {
     const params = ptyBackgroundJobsParamsSchema.parse(rawParams);
-    const pid = sessions.get(params.sessionId)?.proc.pid;
+    const session = sessions.get(params.sessionId);
+    const pid = session && (params.spawnId === void 0 || session.spawnId === params.spawnId) ? session.proc.pid : void 0;
     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 };
@@ -32443,14 +32843,17 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
   async function doctor(rawParams) {
     const params = ptyDoctorParamsSchema.parse(rawParams);
     await options.pathReady;
-    const env = buildSpawnEnv(ctx);
+    const env = buildPtySpawnEnv(ctx);
     const binaries = await Promise.all(
-      params.binaries.map(async (binary) => ({ binary, path: await findOnPath(binary, env) }))
+      params.binaries.map(async (binary) => ({
+        binary,
+        path: await findOnPath(binary, env)
+      }))
     );
     return {
       ok: true,
       problems: installProblems2(),
-      shellExists: shellExists(params.shell),
+      shellExists: shellExists(resolveUserShell()),
       binaries
     };
   }
@@ -32459,6 +32862,14 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
   }
   function warmAdopt(rawParams) {
     const params = ptyWarmAdoptParamsSchema.parse(rawParams);
+    const adopted2 = sessions.get(params.sessionId);
+    if (adopted2?.spawnId === params.warmId) {
+      return {
+        pid: adopted2.proc.pid,
+        data: adopted2.buffer.toString(),
+        seq: adopted2.buffer.getCurrentSeq()
+      };
+    }
     const session = sessions.get(params.warmId);
     if (!session || !session.warm) {
       throw new RpcError(
@@ -32468,16 +32879,15 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     }
     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
-      });
+      throw new RpcError(
+        ComputerTransportErrorCodes.unknownComputer,
+        `session ${params.sessionId} already has live process ${displaced.proc.pid}`
+      );
     }
     sessions.delete(params.warmId);
     session.id = params.sessionId;
     delete session.warm;
+    session.spawnId = params.warmId;
     sessions.set(params.sessionId, session);
     releaseAdmission(session);
     const data = session.buffer.toString();
@@ -32489,16 +32899,12 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     });
     return { pid: session.proc.pid, data, seq };
   }
-  function warmKill(rawParams) {
+  async function warmKill(rawParams) {
     const params = ptyWarmKillParamsSchema.parse(rawParams);
     cancelQueued(params.warmId, "killed");
     const session = sessions.get(params.warmId);
     if (!session) return { ok: true };
-    sessions.delete(params.warmId);
-    try {
-      session.proc.kill();
-    } catch {
-    }
+    await stopPty(session);
     return { ok: true };
   }
   function warmList() {
@@ -32514,58 +32920,55 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     }
     return { warms };
   }
-  function kill(rawParams) {
+  async function kill(rawParams) {
     const params = ptyKillParamsSchema.parse(rawParams);
-    const waiting = queued.get(params.sessionId);
-    if (waiting) {
+    const starting = starts.get(params.sessionId);
+    if (starting && (params.spawnId === void 0 || starting.spawnId === params.spawnId)) {
+      starting.cancelled = true;
+    }
+    const live = sessions.get(params.sessionId);
+    const pending = queued.get(params.sessionId);
+    if (pending && (params.spawnId === void 0 || pending.spawnId === params.spawnId)) {
       const delivered = ctx.dialer.notify(ComputerNotificationMethods.ptyExit, {
         sessionId: params.sessionId,
+        ...pending.spawnId ? { spawnId: pending.spawnId } : {},
         exitCode: null,
         signal: params.signal ?? "SIGHUP",
         reason: "killed-before-start"
       });
       tombstones.add(params.sessionId, {
-        spawnId: waiting.spawnId,
+        spawnId: pending.spawnId,
         exitCode: null,
         signal: params.signal ?? "SIGHUP",
         reason: "killed-before-start"
       });
       if (!delivered)
-        ctx.log("kill of a queued start not delivered", { sessionId: params.sessionId });
+        ctx.log("kill of a queued start not delivered", {
+          sessionId: params.sessionId
+        });
       cancelQueued(params.sessionId, "killed");
-      const superseded = sessions.get(params.sessionId);
-      if (superseded) {
-        sessions.delete(params.sessionId);
-        superseded.deadline?.cancel();
-        releaseAdmission(superseded);
-        try {
-          superseded.proc.kill(params.signal);
-        } catch {
-        }
-      }
+      if (live && params.spawnId === void 0) await stopPty(live, params.signal);
       return { ok: true };
     }
-    const session = sessions.get(params.sessionId);
-    if (!session) {
+    if (!live || params.spawnId !== void 0 && live.spawnId !== params.spawnId) {
       ctx.log("pty kill on unknown session", { sessionId: params.sessionId });
       return { ok: true };
     }
-    try {
-      session.proc.kill(params.signal);
-    } catch (err) {
-      ctx.log("pty kill failed", { sessionId: params.sessionId, error: String(err) });
-    }
+    await stopPty(live, params.signal);
     return { ok: true };
   }
   function resize(rawParams) {
     const params = ptyResizeParamsSchema.parse(rawParams);
     const waiting = queued.get(params.sessionId);
     if (waiting) {
+      if (params.spawnId !== void 0 && waiting.spawnId !== params.spawnId) return { ok: true };
       waiting.cols = params.cols;
       waiting.rows = params.rows;
       return { ok: true };
     }
     const session = sessions.get(params.sessionId);
+    if (session && params.spawnId !== void 0 && session.spawnId !== params.spawnId)
+      return { ok: true };
     if (!session) {
       ctx.log("pty resize on unknown session", { sessionId: params.sessionId });
       return { ok: true };
@@ -32577,10 +32980,13 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     const params = ptyWriteParamsSchema.parse(rawParams);
     const waiting = queued.get(params.sessionId);
     if (waiting) {
+      if (params.spawnId !== void 0 && waiting.spawnId !== params.spawnId) return { ok: true };
       waiting.writes.push(params.data);
       return { ok: true };
     }
     const session = sessions.get(params.sessionId);
+    if (session && params.spawnId !== void 0 && session.spawnId !== params.spawnId)
+      return { ok: true };
     if (!session) {
       ctx.log("pty write on unknown session", { sessionId: params.sessionId });
       return { ok: true };
@@ -32606,7 +33012,9 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
   }
   function getBufferSince(rawParams) {
     const params = ptyGetBufferSinceParamsSchema.parse(rawParams);
-    const buffer = sessions.get(params.sessionId)?.buffer ?? tombstones.get(params.sessionId)?.buffer;
+    const live = sessions.get(params.sessionId);
+    const exited = tombstones.get(params.sessionId);
+    const buffer = live && (params.spawnId === void 0 || live.spawnId === params.spawnId) ? live.buffer : exited && (params.spawnId === void 0 || exited.spawnId === params.spawnId) ? exited.buffer : void 0;
     if (!buffer) return { frames: [] };
     const frames = buffer.getChunksSince(params.seq).map((c) => ({ seq: c.seq, data: c.data }));
     return { frames };
@@ -32614,6 +33022,7 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
   function disposeAll() {
     dropQueued("computer shutting down");
     for (const [sessionId, session] of sessions) {
+      session.revokeCli?.();
       session.deadline?.cancel();
       releaseAdmission(session);
       try {
@@ -32700,12 +33109,12 @@ function createComputerConfigHandlers(ctx) {
 
 // src/project-paths.ts
 var import_promises10 = require("node:fs/promises");
-var import_node_crypto3 = require("node:crypto");
-var import_node_os9 = require("node:os");
+var import_node_crypto4 = require("node:crypto");
+var import_node_os10 = require("node:os");
 var import_node_path16 = 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_os9.homedir)();
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? (0, import_node_os10.homedir)();
   return (0, import_node_path16.join)(home, ".slayzone");
 }
 var projectPathEntrySchema = external_exports.object({
@@ -32747,7 +33156,7 @@ async function readFileMap(filePath) {
 }
 async function writeFileMap(filePath, map2) {
   await (0, import_promises10.mkdir)((0, import_node_path16.dirname)(filePath), { recursive: true, mode: 448 });
-  const tmpPath = `${filePath}.tmp-${process.pid}-${(0, import_node_crypto3.randomUUID)()}`;
+  const tmpPath = `${filePath}.tmp-${process.pid}-${(0, import_node_crypto4.randomUUID)()}`;
   await (0, import_promises10.writeFile)(tmpPath, `${JSON.stringify(map2, null, 2)}
 `, { mode: 384 });
   try {
@@ -32814,6 +33223,10 @@ function createHubRequestHandler(deps2) {
     ...deps2.agentHookUrl ? { agentHookUrl: deps2.agentHookUrl } : {},
     ...deps2.hubAddress ? { hubAddress: deps2.hubAddress } : {}
   };
+  const cliReady = deps2.cliRelayReady?.then((relay) => {
+    ctx.cliRelay = relay;
+  });
+  void cliReady?.catch(() => log("CLI relay is unavailable"));
   const pty2 = createPtyHandlers(ctx, deps2.getProjectPaths, {
     ...deps2.admission ? { admission: deps2.admission } : {},
     ...deps2.pathReady ? { pathReady: deps2.pathReady } : {}
@@ -32873,6 +33286,8 @@ function createHubRequestHandler(deps2) {
       throw err;
     }
     try {
+      if (method === HubToComputerMethods.ptySpawn || method === HubToComputerMethods.ptyWarmSpawn || method === HubToComputerMethods.procSpawn)
+        await cliReady;
       if (deps2.pathReady && !ptyMethods.has(method)) await deps2.pathReady;
       const result = await entry(params);
       record2("ok");
@@ -32977,7 +33392,10 @@ function startComputer(config2, deps2 = {}) {
         count: store.list().length
       });
     }).catch((err) => log("project path map failed to load", { hubUrl, error: String(err) }));
+    const cliRelayReady = createComputerCliRelay(dialer);
+    void cliRelayReady.catch(() => log("CLI relay failed to start", { hubUrl }));
     dispatch = createHubRequestHandler({
+      cliRelayReady,
       shutdown: (reason) => {
         log("computer shutdown requested by hub", { hubUrl, reason });
         void handle.stop().then(() => deps2.onShutdown?.(reason));
@@ -32998,6 +33416,11 @@ function startComputer(config2, deps2 = {}) {
       ({ computerId, mode }) => log("connected to hub", { hubUrl, computerId, mode })
     );
     dialer.events.on("disconnected", ({ reason }) => {
+      void cliRelayReady.then(
+        (relay) => relay.disconnect(),
+        () => {
+        }
+      );
       log("disconnected from hub", { hubUrl, reason });
       dispatch.hubDisconnected(String(reason));
     });
@@ -33026,6 +33449,11 @@ function startComputer(config2, deps2 = {}) {
       dialer,
       dispose: async () => {
         dispatch.dispose();
+        await cliRelayReady.then(
+          (relay) => relay.close(),
+          () => {
+          }
+        );
         if (agentHookServer) await agentHookServer.close();
         await dialer.stop();
       }
@@ -33095,7 +33523,7 @@ async function maybeInteractiveSetup() {
         configKey: "computerName",
         envKey: "SLAYZONE_COMPUTER_NAME",
         label: "Computer display name",
-        hint: `default: ${(0, import_node_os10.hostname)()}`
+        hint: `default: ${(0, import_node_os11.hostname)()}`
       }
     ]
   });