@slayzone/computer 0.36.2 → 0.36.3

package/dist/bin.cjs

@@ -4415,26 +4415,26 @@ var require_ignore = __commonJS({
       const index = body.indexOf(SLASH);
       return index < 0 || index === body.length - 1;
     };
-    var basenameOf = (path9) => {
-      const end = path9.length - 1;
-      const index = path9.lastIndexOf(
+    var basenameOf = (path11) => {
+      const end = path11.length - 1;
+      const index = path11.lastIndexOf(
         SLASH,
-        path9[end] === SLASH ? end - 1 : end
+        path11[end] === SLASH ? end - 1 : end
       );
-      return index < 0 ? path9 : path9.slice(index + 1);
+      return index < 0 ? path11 : path11.slice(index + 1);
     };
-    var parentOf = (path9) => {
-      if (path9.charCodeAt(0) === SLASH_CODE || path9.indexOf(DOUBLE_SLASH) >= 0) {
-        const slices = path9.split(SLASH).filter(Boolean);
+    var parentOf = (path11) => {
+      if (path11.charCodeAt(0) === SLASH_CODE || path11.indexOf(DOUBLE_SLASH) >= 0) {
+        const slices = path11.split(SLASH).filter(Boolean);
         slices.pop();
         return slices.length ? slices.join(SLASH) + SLASH : EMPTY;
       }
-      const end = path9.length - 1;
-      const cut = path9.lastIndexOf(
+      const end = path11.length - 1;
+      const cut = path11.lastIndexOf(
         SLASH,
-        path9.charCodeAt(end) === SLASH_CODE ? end - 1 : end
+        path11.charCodeAt(end) === SLASH_CODE ? end - 1 : end
       );
-      return cut < 0 ? EMPTY : path9.slice(0, cut + 1);
+      return cut < 0 ? EMPTY : path11.slice(0, cut + 1);
     };
     var isString2 = (subject) => typeof subject === "string";
     var checkPattern = (pattern) => pattern && isString2(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
@@ -4543,20 +4543,20 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path9, checkUnignored, mode) {
+      test(path11, 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;
+        const basename5 = shortcut ? basenameOf(path11) : path11;
         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
+            shortcut && rule._basenameOnly ? basename5 : path11
           )) {
             ignored = !negative;
             unignored = negative;
@@ -4576,17 +4576,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path9, originalPath, doThrow) => {
-      if (!isString2(path9)) {
+    var checkPath = (path11, originalPath, doThrow) => {
+      if (!isString2(path11)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path9) {
+      if (!path11) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path9)) {
+      if (checkPath.isNotRelative(path11)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -4595,25 +4595,25 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path9) => {
-      const first = path9.charCodeAt(0);
+    var isNotRelative = (path11) => {
+      const first = path11.charCodeAt(0);
       if (first === SLASH_CODE) {
         return true;
       }
       if (first !== DOT_CODE) {
         return false;
       }
-      if (path9.length === 1) {
+      if (path11.length === 1) {
         return true;
       }
-      const second = path9.charCodeAt(1);
+      const second = path11.charCodeAt(1);
       if (second === SLASH_CODE) {
         return true;
       }
       if (second !== DOT_CODE) {
         return false;
       }
-      return path9.length === 2 || path9.charCodeAt(2) === SLASH_CODE;
+      return path11.length === 2 || path11.charCodeAt(2) === SLASH_CODE;
     };
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
@@ -4644,56 +4644,56 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored) {
-        const path9 = originalPath && checkPath.convert(originalPath);
+        const path11 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path9,
+          path11,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path9, cache, checkUnignored);
+        return this._t(path11, cache, checkUnignored);
       }
-      checkIgnore(path9) {
-        if (path9.charCodeAt(path9.length - 1) !== SLASH_CODE) {
-          return this.test(path9);
+      checkIgnore(path11) {
+        if (path11.charCodeAt(path11.length - 1) !== SLASH_CODE) {
+          return this.test(path11);
         }
-        const parentPath = parentOf(path9);
+        const parentPath = parentOf(path11);
         if (parentPath) {
           const parent = this._t(parentPath, this._testCache, true);
           if (parent.ignored) {
             return parent;
           }
         }
-        return this._rules.test(path9, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path11, false, MODE_CHECK_IGNORE);
       }
-      _t(path9, cache, checkUnignored) {
-        if (path9 in cache) {
-          return cache[path9];
+      _t(path11, cache, checkUnignored) {
+        if (path11 in cache) {
+          return cache[path11];
         }
-        const parentPath = parentOf(path9);
+        const parentPath = parentOf(path11);
         const parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
-        return cache[path9] = parent && parent.ignored ? parent : this._rules.test(path9, checkUnignored, MODE_IGNORE);
+        return cache[path11] = parent && parent.ignored ? parent : this._rules.test(path11, checkUnignored, MODE_IGNORE);
       }
-      ignores(path9) {
-        return this._test(path9, this._ignoreCache, false).ignored;
+      ignores(path11) {
+        return this._test(path11, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path9) => !this.ignores(path9);
+        return (path11) => !this.ignores(path11);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path9) {
-        return this._test(path9, this._testCache, true);
+      test(path11) {
+        return this._test(path11, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path9) => checkPath(path9 && checkPath.convert(path9), path9, RETURN_FALSE);
+    var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str2) => /^\\\\\?\\/.test(str2) || /["<>|\u0000-\u001F]+/u.test(str2) ? str2 : str2.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);
+      checkPath.isNotRelative = (path11) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path11) || isNotRelative(path11);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -5220,10 +5220,10 @@ var init_agent_hooks = __esm({
   }
 });
 
-// raw-import:/tmp/slz-publish-wt.AbcjgE/packages/shared/hooks/src/notify.sh
+// raw-import:/tmp/slz-publish-wt.GgutIu/packages/shared/hooks/src/notify.sh
 var notify_default;
 var init_notify = __esm({
-  "raw-import:/tmp/slz-publish-wt.AbcjgE/packages/shared/hooks/src/notify.sh"() {
+  "raw-import:/tmp/slz-publish-wt.GgutIu/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.AbcjgE/packages/shared/hooks/src/opencode-plugin.js
+// raw-import:/tmp/slz-publish-wt.GgutIu/packages/shared/hooks/src/opencode-plugin.js
 var opencode_plugin_default;
 var init_opencode_plugin = __esm({
-  "raw-import:/tmp/slz-publish-wt.AbcjgE/packages/shared/hooks/src/opencode-plugin.js"() {
+  "raw-import:/tmp/slz-publish-wt.GgutIu/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,8 +5431,8 @@ var init_agent_hooks2 = __esm({
 });
 
 // src/bin.ts
-var import_node_os9 = require("node:os");
-var import_node_path15 = require("node:path");
+var import_node_os10 = require("node:os");
+var import_node_path18 = require("node:path");
 
 // ../../shared/platform/src/config-prompt.ts
 var import_promises = require("node:readline/promises");
@@ -5467,14 +5467,14 @@ function coerceComputerConfig(raw) {
   }
   return cfg;
 }
-function readJsonObject(path9) {
+function readJsonObject(path11) {
   let raw;
   try {
-    raw = (0, import_node_fs.readFileSync)(path9, "utf8");
+    raw = (0, import_node_fs.readFileSync)(path11, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     process.stderr.write(
-      `[slayzone-config] cannot read ${path9}: ${err instanceof Error ? err.message : String(err)} \u2014 using empty config
+      `[slayzone-config] cannot read ${path11}: ${err instanceof Error ? err.message : String(err)} \u2014 using empty config
 `
     );
     return null;
@@ -5484,61 +5484,61 @@ function readJsonObject(path9) {
     parsed = JSON.parse(raw);
   } catch (err) {
     process.stderr.write(
-      `[slayzone-config] ${path9} is not valid JSON: ${err instanceof Error ? err.message : String(err)} \u2014 using empty config
+      `[slayzone-config] ${path11} 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] ${path9} is not a JSON object \u2014 using empty config
+    process.stderr.write(`[slayzone-config] ${path11} is not a JSON object \u2014 using empty config
 `);
     return null;
   }
   return parsed;
 }
-function writeJsonAtomic(path9, data) {
-  const dir = (0, import_node_path.dirname)(path9);
+function writeJsonAtomic(path11, data) {
+  const dir = (0, import_node_path.dirname)(path11);
   (0, import_node_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
-  const tmpPath = `${path9}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = `${path11}.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, path9);
+    (0, import_node_fs.renameSync)(tmpPath, path11);
   } catch (err) {
     (0, import_node_fs.rmSync)(tmpPath, { force: true });
     throw err;
   }
 }
-function loadComputerConfigFile(path9 = getComputerConfigFilePath()) {
-  const raw = readJsonObject(path9);
+function loadComputerConfigFile(path11 = getComputerConfigFilePath()) {
+  const raw = readJsonObject(path11);
   if (raw) return coerceComputerConfig(raw);
-  const legacy = readJsonObject(legacyConfigFilePathFor(path9));
+  const legacy = readJsonObject(legacyConfigFilePathFor(path11));
   return legacy ? coerceComputerConfig(legacy) : {};
 }
-function ignoredComputerConfigKeys(path9 = getComputerConfigFilePath()) {
-  const raw = readJsonObject(path9) ?? readJsonObject(legacyConfigFilePathFor(path9));
+function ignoredComputerConfigKeys(path11 = getComputerConfigFilePath()) {
+  const raw = readJsonObject(path11) ?? readJsonObject(legacyConfigFilePathFor(path11));
   if (!raw) return [];
   return IGNORED_COMPUTER_CONFIG_KEYS.filter((key) => raw[key] !== void 0);
 }
-function saveComputerConfigFile(cfg, path9 = getComputerConfigFilePath()) {
-  writeJsonAtomic(path9, cfg);
+function saveComputerConfigFile(cfg, path11 = getComputerConfigFilePath()) {
+  writeJsonAtomic(path11, cfg);
 }
-function updateComputerConfigFile(patch, path9 = getComputerConfigFilePath()) {
-  const current = readJsonObject(path9);
+function updateComputerConfigFile(patch, path11 = getComputerConfigFilePath()) {
+  const current = readJsonObject(path11);
   const merged = current ? coerceComputerConfig(current) : {};
   for (const [k, v] of Object.entries(patch)) {
     if (v !== void 0) merged[k] = v;
   }
-  saveComputerConfigFile(merged, path9);
+  saveComputerConfigFile(merged, path11);
   return merged;
 }
-function updateJsonFile(patch, path9) {
-  const current = readJsonObject(path9) ?? {};
+function updateJsonFile(patch, path11) {
+  const current = readJsonObject(path11) ?? {};
   const merged = { ...current };
   for (const [k, v] of Object.entries(patch)) {
     if (v !== void 0) merged[k] = v;
   }
-  writeJsonAtomic(path9, merged);
+  writeJsonAtomic(path11, merged);
 }
 
 // ../../shared/platform/src/config-prompt.ts
@@ -5610,10 +5610,10 @@ function isLoopbackAuthority(addr) {
     return false;
   }
 }
-function hubUrlFromAddr(addr, kind, path9 = "") {
+function hubUrlFromAddr(addr, kind, path11 = "") {
   const secure = !isLoopbackAuthority(addr);
   const scheme = kind === "ws" ? secure ? "wss" : "ws" : secure ? "https" : "http";
-  return `${scheme}://${addr}${path9}`;
+  return `${scheme}://${addr}${path11}`;
 }
 function hubAddrFromUrl(url2) {
   let u;
@@ -6715,10 +6715,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7058,11 +7058,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -7512,16 +7512,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path9 = []) => {
+  const processError = (error63, path11 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -7560,17 +7560,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error63, path9 = []) => {
+  const processError = (error63, path11 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7609,8 +7609,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path9) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -7896,8 +7896,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 = (delimiter3) => {
-  const escapedDelim = escapeRegex(delimiter3 ?? ":");
+var mac = (delimiter4) => {
+  const escapedDelim = escapeRegex(delimiter4 ?? ":");
   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])$/;
@@ -22585,14 +22585,14 @@ var nonoptionalProcessor = (schema, ctx, _json, params) => {
 var UNREPRESENTABLE_DEFAULT = /* @__PURE__ */ Symbol();
 function serializeDefaultValue(value, schema, ctx, json2, params) {
   let unrepresentable = false;
-  const serialized = JSON.stringify(value, (_, val) => {
+  const serialized2 = JSON.stringify(value, (_, val) => {
     if (typeof val !== "bigint")
       return val;
     unrepresentable = true;
     return null;
   });
   if (!unrepresentable)
-    return JSON.parse(serialized);
+    return JSON.parse(serialized2);
   handleUnrepresentable(schema, ctx, json2, params, "BigInt defaults cannot be represented in JSON Schema");
   return UNREPRESENTABLE_DEFAULT;
 }
@@ -24712,13 +24712,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path9 = ref.slice(1).split("/").filter(Boolean);
-  if (path9.length === 0) {
+  const path11 = ref.slice(1).split("/").filter(Boolean);
+  if (path11.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path9[0] === defsKey) {
-    const key = path9[1] === void 0 ? void 0 : decodeJSONPointerSegment(path9[1]);
+  if (path11[0] === defsKey) {
+    const key = path11[1] === void 0 ? void 0 : decodeJSONPointerSegment(path11[1]);
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -25592,8 +25592,20 @@ var ComputerTransportErrorCodes = {
    * 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
+  refusedByComputer: -32006,
+  /**
+   * An agent for a project this computer holds no folder for. Not transient, and
+   * not a policy refusal: the user picks the project's folder on this computer
+   * (or the hub delivers it), then the same spawn works.
+   */
+  projectNotPlaced: -32007
 };
+function projectNotPlacedError(projectId) {
+  return new RpcError(
+    ComputerTransportErrorCodes.projectNotPlaced,
+    `This computer has no folder for project ${projectId}. Pick the project's folder on this computer, then try again.`
+  );
+}
 var requestActorSchema = external_exports.object({
   userId: external_exports.string().min(1).max(200).nullable(),
   /** `trpc <path>` / `METHOD /path` the request entered the hub through. */
@@ -25684,13 +25696,19 @@ var procDataParamsSchema = external_exports.object({
   /** Monotonic per-session sequence number for `stdout`. Absent on stderr. */
   seq: external_exports.number().int().nonnegative().optional(),
   data: external_exports.string(),
-  stream: external_exports.enum(["stdout", "stderr"]).optional()
+  stream: external_exports.enum(["stdout", "stderr"]).optional(),
+  /** The spawn attempt that produced this output; the hub drops a replaced attempt's. */
+  spawnId: external_exports.string().min(1).optional()
 });
 var procExitParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
   exitCode: external_exports.number().int().nullable(),
   signal: external_exports.string().nullable().optional(),
-  reason: external_exports.string().min(1).optional()
+  reason: external_exports.string().min(1).optional(),
+  /** The spawn attempt that exited. */
+  spawnId: external_exports.string().min(1).optional(),
+  /** Why the process could not run (e.g. the OS refused to start it). */
+  error: external_exports.string().optional()
 });
 var fsChangeParamsSchema = external_exports.object({
   watchId: external_exports.string().min(1),
@@ -25717,6 +25735,8 @@ var HubToComputerMethods = {
   ptyPrioritize: "pty.prioritize",
   /** Which of claude's background jobs still have a live process under a session. */
   ptyBackgroundJobs: "pty.backgroundJobs",
+  /** Doctor's facts about this computer: node-pty install, the shell, agent binaries. */
+  ptyDoctor: "pty.doctor",
   // warm pool (pre-warmed agents live ON the computer — see server/warm-*)
   ptyWarmSpawn: "pty.warmSpawn",
   ptyWarmAdopt: "pty.warmAdopt",
@@ -25775,7 +25795,13 @@ var HubToComputerMethods = {
   /** Edit the computer's own path-jail (Settings → Computers). */
   computerSetAllowedRoots: "computer.setAllowedRoots",
   /** Run `gh` on the computer (PR panel). One frame, not one per gh subcommand. */
-  ghExec: "gh.exec"
+  ghExec: "gh.exec",
+  /**
+   * Read the active branch of a Claude Code session file on the computer (a
+   * resumed or handed-over conversation's history for the chat timeline). Only
+   * that file: the path is built from the cwd and a uuid, nothing else.
+   */
+  claudeSessionRead: "claudeSession.read"
 };
 var spawnIdField = external_exports.string().min(1).optional();
 var exitedSessionSchema = external_exports.object({
@@ -25852,6 +25878,19 @@ var ptyBackgroundJobsResultSchema = external_exports.object({
   supported: external_exports.boolean(),
   alive: external_exports.array(external_exports.string())
 });
+var ptyDoctorParamsSchema = external_exports.object({
+  shell: external_exports.string().min(1).max(4096),
+  /** Plain command names only (`claude`, `cursor-agent`), never paths or syntax. */
+  binaries: external_exports.array(
+    external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._+-]*$/)
+  ).max(16)
+}).strict();
+var ptyDoctorResultSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  problems: external_exports.array(external_exports.object({ check: external_exports.string(), detail: external_exports.string(), fix: external_exports.string() })),
+  shellExists: external_exports.boolean(),
+  binaries: external_exports.array(external_exports.object({ binary: external_exports.string(), path: external_exports.string().nullable() }))
+});
 var ptyResizeParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
   cols: external_exports.number().int().positive(),
@@ -26005,6 +26044,22 @@ var ghExecResultSchema = external_exports.object({
   stdout: external_exports.string(),
   stderr: external_exports.string()
 });
+var claudeSessionReadParamsSchema = external_exports.object({
+  cwd: external_exports.string().min(1).optional(),
+  projectId: external_exports.string().min(1).optional(),
+  sessionId: external_exports.string().uuid(),
+  /** Newest records to return at most. */
+  maxRecords: external_exports.number().int().positive().max(5e3),
+  /** Their total JSON size at most (large tool results are shortened first). */
+  maxBytes: external_exports.number().int().positive().max(16 * 1024 * 1024)
+});
+var claudeSessionReadResultSchema = external_exports.object({
+  /** False: no session file for that id in that cwd's project dir. */
+  found: external_exports.boolean(),
+  records: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())),
+  /** Older records of the branch that were not sent (the caps). */
+  omitted: external_exports.number().int().nonnegative()
+});
 var computerShutdownParamsSchema = external_exports.object({
   reason: external_exports.string().optional(),
   /** Grace period before the computer may hard-exit. */
@@ -26252,7 +26307,9 @@ var procSpawnParamsSchema = external_exports.object({
    */
   shell: external_exports.boolean().optional(),
   cwd: external_exports.string().min(1).optional(),
-  env: external_exports.record(external_exports.string(), external_exports.string()).optional()
+  env: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+  /** Agent-start admission lane (chat agents), as for `pty.spawn`. Absent: start at once. */
+  admission: ptySpawnAdmissionSchema.optional()
 });
 var procSpawnResultSchema = external_exports.object({
   /** `null` when the OS never assigned one (immediate spawn failure). The computer
@@ -26262,12 +26319,38 @@ var procSpawnResultSchema = external_exports.object({
 });
 var procKillParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
-  signal: external_exports.string().optional()
+  signal: external_exports.string().optional(),
+  /** Only kill this attempt: a kill meant for a replaced process must not hit its successor. */
+  spawnId: spawnIdField
 });
 var procWriteParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
-  data: external_exports.string()
+  data: external_exports.string(),
+  /** Only write to this attempt; a replaced process is refused (`stale-spawn`). */
+  spawnId: spawnIdField,
+  /**
+   * Idempotency key: a write the hub retries (its reply was lost) is written once.
+   * The reply is sent only after the bytes reached the process's stdin, and a
+   * write that cannot be delivered (unknown session, replaced attempt, broken pipe)
+   * is refused rather than acked — so `{ok:true}` means delivered.
+   */
+  writeId: external_exports.string().min(1).max(200).optional()
 });
+var procWriteResultSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  delivered: external_exports.literal(true).optional(),
+  duplicate: external_exports.boolean().optional()
+});
+var ProcRefusalReasons = {
+  /** `proc.spawn`: the command is not on the computer's PATH. `data.binary` names it. */
+  binaryNotFound: "binary-not-found",
+  /** `proc.write`: no process under this session id. */
+  unknownSession: "unknown-session",
+  /** `proc.write`: the session now runs a different spawn attempt. */
+  staleSpawn: "stale-spawn",
+  /** `proc.write`: the process's stdin is closed or broken. */
+  stdinClosed: "stdin-closed"
+};
 var procGetBufferSinceParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
   seq: external_exports.number().int()
@@ -26917,7 +27000,17 @@ var computerConfigSchema = external_exports.object({
    * 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()
+  hubMayEditRoots: external_exports.boolean().optional(),
+  /**
+   * A directory whose executables take precedence over PATH for every process this
+   * computer starts — prepended in `buildSpawnEnv`, the one place both the pty and
+   * the proc handler build a child's env. Exists so tests can swap an agent CLI for
+   * a scripted fake (`@slayzone/test-utils/fake-claude`): a dir merely prepended to
+   * the inherited PATH loses, because the computer adopts the login-shell PATH with
+   * its entries FIRST at boot (login-shell-path.ts). Absolute: a relative dir would
+   * resolve against each spawn's cwd. Env channel only (`ENV_VARS.binOverrideDir`).
+   */
+  binOverrideDir: external_exports.string().min(1).refine((dir) => (0, import_node_path3.isAbsolute)(dir), { message: "must be an absolute path" }).optional()
 });
 var ENV_VARS = {
   // Authority ONLY — `host[:port]`, no scheme, no path. The dial scheme
@@ -26936,7 +27029,9 @@ var ENV_VARS = {
   // named its CONSUMER, which is what CLAUDE.md rule 2 forbids. `_TOKEN` suffix +
   // `HUB_` family per rule 3, matching the domain term used everywhere else
   // (`szjt1.`, the `join_tokens` table, mintJoinToken, POST /api/computers/join-token).
-  joinToken: "SLAYZONE_HUB_JOIN_TOKEN"
+  joinToken: "SLAYZONE_HUB_JOIN_TOKEN",
+  // Read only by the computer (rule 2), a directory (rule 3). See `binOverrideDir`.
+  binOverrideDir: "SLAYZONE_COMPUTER_BIN_OVERRIDE_DIR"
   // No alias for the pre-rename `SLAYZONE_RUNNER_JOIN_TOKEN`: it never shipped.
   // The published computer betas (0.36.0-beta.2/3) read `SLAYZONE_JOIN_TOKEN`, and
   // the name it was renamed FROM only ever existed on unreleased main, so there is
@@ -26979,8 +27074,8 @@ 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 isInside(path11, dir) {
+  return path11 === dir || path11.startsWith(dir + import_node_path3.sep);
 }
 function isProtectedPath(absolute) {
   return protectedPaths.some((guarded) => isInside(absolute, guarded));
@@ -27055,7 +27150,8 @@ function loadComputerConfig(env = process.env, shared = env === process.env && e
     // <ROOT>/computer.config.json — base under env (spread after). The single config file.
     ...fromShared,
     ...hubUrlFromEnv !== void 0 ? { hubUrl: hubUrlFromEnv } : {},
-    ...envJoinToken !== void 0 ? { joinToken: envJoinToken } : {}
+    ...envJoinToken !== void 0 ? { joinToken: envJoinToken } : {},
+    ...env[ENV_VARS.binOverrideDir] !== void 0 ? { binOverrideDir: env[ENV_VARS.binOverrideDir] } : {}
   };
   const result = computerConfigSchema.safeParse(merged);
   if (result.success) {
@@ -27452,6 +27548,11 @@ var ENV_MANIFEST = {
   // 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",
+  // Computer-only: a directory whose executables take precedence over PATH for
+  // every process the computer starts (spawn-env.ts). The e2e chat group puts its
+  // fake `claude` there — a dir merely prepended to the inherited PATH loses to the
+  // login-shell PATH the computer adopts at boot. Infra: an agent must not inherit it.
+  SLAYZONE_COMPUTER_BIN_OVERRIDE_DIR: "infra",
   // per-provider config/hook/plugin path overrides (test/sandbox redirects)
   SLAYZONE_CLAUDE_SETTINGS_PATH: "infra",
   SLAYZONE_GEMINI_SETTINGS_PATH: "infra",
@@ -27499,16 +27600,16 @@ var NON_PREFIXED_INFRA = /* @__PURE__ */ new Set([
 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;
+    if (keptInSpawnEnv(key, value)) out[key] = value;
   }
   return out;
 }
+function keptInSpawnEnv(key, value) {
+  if (typeof value !== "string") return false;
+  if (NON_PREFIXED_INFRA.has(key)) return false;
+  if (key.startsWith("SLAYZONE_")) return ENV_MANIFEST[key] === "global";
+  return true;
+}
 
 // ../../shared/platform/src/index.ts
 init_fs_utils();
@@ -27569,6 +27670,15 @@ function getShellStartupArgs(shellPath) {
   }
   return [];
 }
+function quoteForShell(arg) {
+  if ((0, import_os2.platform)() === "win32") {
+    if (arg.length === 0) return '""';
+    if (!/[\s"&|<>^%!]/.test(arg)) return arg;
+    return `"${arg.replace(/"/g, '""')}"`;
+  }
+  if (arg.length === 0) return "''";
+  return `'${arg.replace(/'/g, `'"'"'`)}'`;
+}
 function buildShellInvocation(command) {
   const shell = resolveUserShell();
   if ((0, import_os2.platform)() === "win32") return { file: shell, args: ["/c", command] };
@@ -27645,6 +27755,16 @@ async function probeLoginShellPath(opts = {}) {
   }
   return null;
 }
+var FIND_ON_PATH_TIMEOUT_MS = 3e3;
+function findOnPath(name, env) {
+  const [file2, args] = (0, import_node_os3.platform)() === "win32" ? ["where", [name]] : ["/bin/sh", ["-c", `command -v ${quoteForShell(name)}`]];
+  return new Promise((resolve9) => {
+    (0, import_node_child_process2.execFile)(file2, args, { timeout: FIND_ON_PATH_TIMEOUT_MS, env }, (err, stdout2) => {
+      const found = err ? "" : String(stdout2).trim().split("\n")[0]?.trim();
+      resolve9(found ? found : null);
+    });
+  });
+}
 
 // ../../shared/platform/src/slz-file-url.ts
 var SLZ_FILE_HOST = "app";
@@ -27664,8 +27784,8 @@ async function adoptLoginShellPath(opts = {}) {
 }
 
 // src/main.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path17 = require("node:path");
 
 // src/request-log.ts
 var import_node_fs4 = require("node:fs");
@@ -28465,9 +28585,9 @@ var WORKSPACE_MAX_SEARCH_RESULTS = 2e3;
 function createLocalWorkspaceFs() {
   return refuseOnSwitchedOffHub(createUnguardedLocalWorkspaceFs());
 }
-function refuseOnSwitchedOffHub(fs7) {
+function refuseOnSwitchedOffHub(fs8) {
   const guarded = {};
-  for (const [op, fn] of Object.entries(fs7)) {
+  for (const [op, fn] of Object.entries(fs8)) {
     guarded[op] = (...args) => {
       assertHubLocalExecEnabled({ op: `fs.${op}` });
       return fn(...args);
@@ -28492,8 +28612,8 @@ function createUnguardedLocalWorkspaceFs() {
         sep: import_node_path9.sep
       };
     },
-    async listDir(path9, options) {
-      const abs = import_node_fs6.realpathSync.native((0, import_node_path9.resolve)(path9));
+    async listDir(path11, options) {
+      const abs = import_node_fs6.realpathSync.native((0, import_node_path9.resolve)(path11));
       const dirents = await (0, import_promises6.readdir)(abs, { withFileTypes: true });
       const entries = [];
       for (const e of dirents) {
@@ -28525,13 +28645,13 @@ function createUnguardedLocalWorkspaceFs() {
       const parent = (0, import_node_path9.dirname)(abs);
       return { path: abs, parent: parent === abs ? null : parent, entries };
     },
-    async mkdir(path9) {
-      const abs = (0, import_node_path9.resolve)(path9);
+    async mkdir(path11) {
+      const abs = (0, import_node_path9.resolve)(path11);
       await (0, import_promises6.mkdir)(abs, { recursive: true });
       return { path: import_node_fs6.realpathSync.native(abs) };
     },
-    pathExists(path9) {
-      return (0, import_node_fs6.existsSync)((0, import_node_path9.resolve)(path9));
+    pathExists(path11) {
+      return (0, import_node_fs6.existsSync)((0, import_node_path9.resolve)(path11));
     },
     // A hub has no path-jail — `allowedRoots` is a computer concept. Saying so is
     // better than accepting the edit and discarding it, which would leave the
@@ -28546,12 +28666,12 @@ function createUnguardedLocalWorkspaceFs() {
     // the fork sidecar and tests, neither of which should be minting a new
     // persistent state file for a mapping a real computer owns.
     resolveProjectPath(projectId) {
-      const path9 = localProjectPaths.get(projectId);
-      if (!path9) return { path: null };
-      return { path: path9, exists: (0, import_node_fs6.existsSync)(path9) };
+      const path11 = localProjectPaths.get(projectId);
+      if (!path11) return { path: null };
+      return { path: path11, exists: (0, import_node_fs6.existsSync)(path11) };
     },
-    setProjectPath(projectId, path9) {
-      const abs = import_node_fs6.realpathSync.native((0, import_node_path9.resolve)(path9));
+    setProjectPath(projectId, path11) {
+      const abs = import_node_fs6.realpathSync.native((0, import_node_path9.resolve)(path11));
       localProjectPaths.set(projectId, abs);
       return { path: abs };
     },
@@ -28591,12 +28711,12 @@ function createUnguardedLocalWorkspaceFs() {
 function createLocalWorkspaceFsAdapters(local = createLocalWorkspaceFs()) {
   return {
     listRoots: async () => local.listRoots(),
-    listDir: async (_r, path9, options) => local.listDir(path9, options),
-    mkdir: async (_r, path9) => local.mkdir(path9),
-    pathExists: async (_r, path9) => local.pathExists(path9),
+    listDir: async (_r, path11, options) => local.listDir(path11, options),
+    mkdir: async (_r, path11) => local.mkdir(path11),
+    pathExists: async (_r, path11) => local.pathExists(path11),
     setAllowedRoots: async (_r, roots) => local.setAllowedRoots(roots),
     resolveProjectPath: async (_r, projectId) => local.resolveProjectPath(projectId),
-    setProjectPath: async (_r, projectId, path9) => local.setProjectPath(projectId, path9),
+    setProjectPath: async (_r, projectId, path11) => local.setProjectPath(projectId, path11),
     forgetProjectPath: async (_r, projectId) => local.forgetProjectPath(projectId),
     readDir: async (_r, rootPath, dirPath) => local.readDir(rootPath, dirPath),
     readFile: async (_r, rootPath, filePath, force) => local.readFile(rootPath, filePath, force),
@@ -28686,28 +28806,28 @@ var noop = () => {
 var freezeIfAvailable = (obj) => {
   if (Object.freeze) Object.freeze(obj);
 };
-function createInnerProxy(callback, path9, memo2) {
+function createInnerProxy(callback, path11, memo2) {
   var _memo$cacheKey;
-  const cacheKey = path9.join(".");
+  const cacheKey = path11.join(".");
   (_memo$cacheKey = memo2[cacheKey]) !== null && _memo$cacheKey !== void 0 || (memo2[cacheKey] = new Proxy(noop, {
     get(_obj, key) {
       if (typeof key !== "string" || key === "then") return;
-      return createInnerProxy(callback, [...path9, key], memo2);
+      return createInnerProxy(callback, [...path11, key], memo2);
     },
     apply(_1, _2, args) {
-      const lastOfPath = path9[path9.length - 1];
-      if (lastOfPath === "valueOf" || lastOfPath === "toString" || lastOfPath === "toJSON") return `tRPC.proxy(${path9.slice(0, -1).join(".")})`;
+      const lastOfPath = path11[path11.length - 1];
+      if (lastOfPath === "valueOf" || lastOfPath === "toString" || lastOfPath === "toJSON") return `tRPC.proxy(${path11.slice(0, -1).join(".")})`;
       let opts = {
         args,
-        path: path9
+        path: path11
       };
       if (lastOfPath === "call") opts = {
         args: args.length >= 2 ? [args[1]] : [],
-        path: path9.slice(0, -1)
+        path: path11.slice(0, -1)
       };
       else if (lastOfPath === "apply") opts = {
         args: args.length >= 2 ? args[1] : [],
-        path: path9.slice(0, -1)
+        path: path11.slice(0, -1)
       };
       freezeIfAvailable(opts.args);
       freezeIfAvailable(opts.path);
@@ -28886,12 +29006,12 @@ function createRouterFactory(config2) {
         })
       };
     }
-    function step(from, path9 = []) {
+    function step(from, path11 = []) {
       const aggregate = emptyObject();
       for (const [key, item] of Object.entries(from !== null && from !== void 0 ? from : {})) {
         if (isLazy(item)) {
-          lazy3[[...path9, key].join(".")] = createLazyLoader({
-            path: path9,
+          lazy3[[...path11, key].join(".")] = createLazyLoader({
+            path: path11,
             ref: item,
             key,
             aggregate
@@ -28899,14 +29019,14 @@ function createRouterFactory(config2) {
           continue;
         }
         if (isRouter(item)) {
-          aggregate[key] = step(item._def.record, [...path9, key]);
+          aggregate[key] = step(item._def.record, [...path11, key]);
           continue;
         }
         if (!isProcedure(item)) {
-          aggregate[key] = step(item, [...path9, key]);
+          aggregate[key] = step(item, [...path11, key]);
           continue;
         }
-        const newPath = [...path9, key].join(".");
+        const newPath = [...path11, key].join(".");
         if (procedures[newPath]) throw new Error(`Duplicate key: ${newPath}`);
         procedures[newPath] = item;
         aggregate[key] = item;
@@ -28930,14 +29050,14 @@ function createRouterFactory(config2) {
 function isProcedure(procedureOrRouter) {
   return typeof procedureOrRouter === "function";
 }
-async function getProcedureAtPath(router2, path9) {
+async function getProcedureAtPath(router2, path11) {
   const { _def } = router2;
-  let procedure = _def.procedures[path9];
+  let procedure = _def.procedures[path11];
   while (!procedure) {
-    const key = Object.keys(_def.lazy).find((key2) => path9 === key2 || path9.startsWith(key2 + "."));
+    const key = Object.keys(_def.lazy).find((key2) => path11 === key2 || path11.startsWith(key2 + "."));
     if (!key) return null;
     await _def.lazy[key].load();
-    procedure = _def.procedures[path9];
+    procedure = _def.procedures[path11];
   }
   return procedure;
 }
@@ -28946,15 +29066,15 @@ function createCallerFactory() {
     const { _def } = router2;
     return function createCaller(ctxOrCallback, opts) {
       return createRecursiveProxy(async (innerOpts) => {
-        const { path: path9, args } = innerOpts;
-        const fullPath = path9.join(".");
-        if (path9.length === 1 && path9[0] === "_def") return _def;
+        const { path: path11, args } = innerOpts;
+        const fullPath = path11.join(".");
+        if (path11.length === 1 && path11[0] === "_def") return _def;
         const procedure = await getProcedureAtPath(router2, fullPath);
         let ctx = void 0;
         try {
           if (!procedure) throw new TRPCError({
             code: "NOT_FOUND",
-            message: `No procedure found on path "${path9}"`
+            message: `No procedure found on path "${path11}"`
           });
           ctx = isFunction(ctxOrCallback) ? await Promise.resolve(ctxOrCallback()) : ctxOrCallback;
           return await procedure({
@@ -29558,7 +29678,7 @@ var isURL = (payload) => payload instanceof URL;
 
 // ../../../node_modules/superjson/dist/pathstringifier.js
 var escapeKey = (key) => key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
-var stringifyPath = (path9) => path9.map(String).map(escapeKey).join(".");
+var stringifyPath = (path11) => path11.map(String).map(escapeKey).join(".");
 var parsePath = (string4, legacyPaths) => {
   const result = [];
   let segment = "";
@@ -29805,26 +29925,26 @@ var getNthKey = (value, n) => {
   }
   return keys.next().value;
 };
-function validatePath(path9) {
-  if (includes(path9, "__proto__")) {
+function validatePath(path11) {
+  if (includes(path11, "__proto__")) {
     throw new Error("__proto__ is not allowed as a property");
   }
-  if (includes(path9, "prototype")) {
+  if (includes(path11, "prototype")) {
     throw new Error("prototype is not allowed as a property");
   }
-  if (includes(path9, "constructor")) {
+  if (includes(path11, "constructor")) {
     throw new Error("constructor is not allowed as a property");
   }
 }
-var getDeep = (object2, path9) => {
-  validatePath(path9);
-  for (let i = 0; i < path9.length; i++) {
-    const key = path9[i];
+var getDeep = (object2, path11) => {
+  validatePath(path11);
+  for (let i = 0; i < path11.length; i++) {
+    const key = path11[i];
     if (isSet(object2)) {
       object2 = getNthKey(object2, +key);
     } else if (isMap(object2)) {
       const row = +key;
-      const type = +path9[++i] === 0 ? "key" : "value";
+      const type = +path11[++i] === 0 ? "key" : "value";
       const keyOfRow = getNthKey(object2, row);
       switch (type) {
         case "key":
@@ -29840,14 +29960,14 @@ var getDeep = (object2, path9) => {
   }
   return object2;
 };
-var setDeep = (object2, path9, mapper) => {
-  validatePath(path9);
-  if (path9.length === 0) {
+var setDeep = (object2, path11, mapper) => {
+  validatePath(path11);
+  if (path11.length === 0) {
     return mapper(object2);
   }
   let parent = object2;
-  for (let i = 0; i < path9.length - 1; i++) {
-    const key = path9[i];
+  for (let i = 0; i < path11.length - 1; i++) {
+    const key = path11[i];
     if (isArray(parent)) {
       const index = +key;
       parent = parent[index];
@@ -29857,12 +29977,12 @@ var setDeep = (object2, path9, mapper) => {
       const row = +key;
       parent = getNthKey(parent, row);
     } else if (isMap(parent)) {
-      const isEnd = i === path9.length - 2;
+      const isEnd = i === path11.length - 2;
       if (isEnd) {
         break;
       }
       const row = +key;
-      const type = +path9[++i] === 0 ? "key" : "value";
+      const type = +path11[++i] === 0 ? "key" : "value";
       const keyOfRow = getNthKey(parent, row);
       switch (type) {
         case "key":
@@ -29874,7 +29994,7 @@ var setDeep = (object2, path9, mapper) => {
       }
     }
   }
-  const lastKey = path9[path9.length - 1];
+  const lastKey = path11[path11.length - 1];
   if (isArray(parent)) {
     parent[+lastKey] = mapper(parent[+lastKey]);
   } else if (isPlainObject2(parent)) {
@@ -29889,7 +30009,7 @@ var setDeep = (object2, path9, mapper) => {
     }
   }
   if (isMap(parent)) {
-    const row = +path9[path9.length - 2];
+    const row = +path11[path11.length - 2];
     const keyToRow = getNthKey(parent, row);
     const type = +lastKey === 0 ? "key" : "value";
     switch (type) {
@@ -29936,16 +30056,16 @@ function traverse(tree, walker2, version2, origin = []) {
   walker2(nodeValue, origin);
 }
 function applyValueAnnotations(plain, annotations, version2, superJson) {
-  traverse(annotations, (type, path9) => {
-    plain = setDeep(plain, path9, (v) => untransformValue(v, type, superJson));
+  traverse(annotations, (type, path11) => {
+    plain = setDeep(plain, path11, (v) => untransformValue(v, type, superJson));
   }, version2);
   return plain;
 }
 function applyReferentialEqualityAnnotations(plain, annotations, version2) {
   const legacyPaths = enableLegacyPaths(version2);
-  function apply(identicalPaths, path9) {
-    const object2 = getDeep(plain, parsePath(path9, legacyPaths));
-    identicalPaths.map((path10) => parsePath(path10, legacyPaths)).forEach((identicalObjectPath) => {
+  function apply(identicalPaths, path11) {
+    const object2 = getDeep(plain, parsePath(path11, legacyPaths));
+    identicalPaths.map((path12) => parsePath(path12, legacyPaths)).forEach((identicalObjectPath) => {
       plain = setDeep(plain, identicalObjectPath, () => object2);
     });
   }
@@ -29963,12 +30083,12 @@ function applyReferentialEqualityAnnotations(plain, annotations, version2) {
   return plain;
 }
 var isDeep = (object2, superJson) => isPlainObject2(object2) || isArray(object2) || isMap(object2) || isSet(object2) || isError(object2) || isInstanceOfRegisteredClass(object2, superJson);
-function addIdentity(object2, path9, identities) {
+function addIdentity(object2, path11, identities) {
   const existingSet = identities.get(object2);
   if (existingSet) {
-    existingSet.push(path9);
+    existingSet.push(path11);
   } else {
-    identities.set(object2, [path9]);
+    identities.set(object2, [path11]);
   }
 }
 function generateReferentialEqualityAnnotations(identitites, dedupe) {
@@ -29979,7 +30099,7 @@ function generateReferentialEqualityAnnotations(identitites, dedupe) {
       return;
     }
     if (!dedupe) {
-      paths = paths.map((path9) => path9.map(String)).sort((a, b) => a.length - b.length);
+      paths = paths.map((path11) => path11.map(String)).sort((a, b) => a.length - b.length);
     }
     const [representativePath, ...identicalPaths] = paths;
     if (representativePath.length === 0) {
@@ -29998,10 +30118,10 @@ function generateReferentialEqualityAnnotations(identitites, dedupe) {
     return isEmptyObject(result) ? void 0 : result;
   }
 }
-var walker = (object2, identities, superJson, dedupe, path9 = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+var walker = (object2, identities, superJson, dedupe, path11 = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
   const primitive = isPrimitive(object2);
   if (!primitive) {
-    addIdentity(object2, path9, identities);
+    addIdentity(object2, path11, identities);
     const seen = seenObjects.get(object2);
     if (seen) {
       return dedupe ? {
@@ -30035,7 +30155,7 @@ var walker = (object2, identities, superJson, dedupe, path9 = [], objectsInThisP
     if (index === "__proto__" || index === "constructor" || index === "prototype") {
       throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
     }
-    const recursiveResult = walker(value, identities, superJson, dedupe, [...path9, index], [...objectsInThisPath, object2], seenObjects);
+    const recursiveResult = walker(value, identities, superJson, dedupe, [...path11, index], [...objectsInThisPath, object2], seenObjects);
     transformedValue[index] = recursiveResult.transformedValue;
     if (isArray(recursiveResult.annotations)) {
       innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
@@ -30281,12 +30401,12 @@ function auditAdminDenied(opts) {
     detail: { reason: "not_admin", code: ADMIN_ONLY, ...opts.detail }
   });
 }
-function adminOnlyTrpcError(path9) {
-  auditAdminDenied({ targetKind: "procedure", targetId: path9 });
+function adminOnlyTrpcError(path11) {
+  auditAdminDenied({ targetKind: "procedure", targetId: path11 });
   return new TRPCError({
     code: "FORBIDDEN",
-    message: `${path9} needs a hub admin account`,
-    cause: new AdminOnlyError(path9)
+    message: `${path11} needs a hub admin account`,
+    cause: new AdminOnlyError(path11)
   });
 }
 
@@ -30339,45 +30459,45 @@ var router = t.router;
 var middleware = t.middleware;
 var mergeRouters2 = t.mergeRouters;
 var securityContext = t.middleware(
-  ({ ctx, next, path: path9 }) => runWithSecurityContext(
-    { actor: ctx.principal?.userId ?? null, ip: peerAddress(ctx.req), route: `trpc ${path9}` },
+  ({ ctx, next, path: path11 }) => runWithSecurityContext(
+    { actor: ctx.principal?.userId ?? null, ip: peerAddress(ctx.req), route: `trpc ${path11}` },
     () => next()
   )
 );
-function auditDenied(path9, detail) {
+function auditDenied(path11, detail) {
   securityEvent({
     event: "authz.denied",
     outcome: "denied",
     targetKind: "procedure",
-    targetId: path9,
+    targetId: path11,
     detail
   });
 }
-var authGate2 = t.middleware(({ ctx, next, path: path9 }) => {
+var authGate2 = t.middleware(({ ctx, next, path: path11 }) => {
   if (getAuthGate() && !ctx.principal) {
-    auditDenied(path9, { reason: "unauthenticated" });
+    auditDenied(path11, { reason: "unauthenticated" });
     throw new TRPCError({ code: "UNAUTHORIZED", message: "hub requires authentication" });
   }
   return next();
 });
-var scopeGate = t.middleware(({ ctx, next, path: path9 }) => {
+var scopeGate = t.middleware(({ ctx, next, path: path11 }) => {
   if (!getAuthGate()) return next();
   const scopes = ctx.principal?.scopes ?? [];
-  if (!procedurePolicy().scopeAllows(scopes, path9)) {
-    auditDenied(path9, { reason: "scope", scopes });
-    throw new TRPCError({ code: "FORBIDDEN", message: `insufficient scope for ${path9}` });
+  if (!procedurePolicy().scopeAllows(scopes, path11)) {
+    auditDenied(path11, { reason: "scope", scopes });
+    throw new TRPCError({ code: "FORBIDDEN", message: `insufficient scope for ${path11}` });
   }
   return next();
 });
-var adminGate = t.middleware(({ ctx, next, path: path9 }) => {
+var adminGate = t.middleware(({ ctx, next, path: path11 }) => {
   if (!getAuthGate()) return next();
-  if (!roleAllows(procedurePolicy().adminClassOf(path9), ctx.principal?.role ?? "user")) {
-    throw adminOnlyTrpcError(path9);
+  if (!roleAllows(procedurePolicy().adminClassOf(path11), ctx.principal?.role ?? "user")) {
+    throw adminOnlyTrpcError(path11);
   }
   return next();
 });
-var ownerGate = t.middleware(async ({ ctx, next, path: path9, type, getRawInput }) => {
-  const filter = getAuthGate() ? await procedurePolicy().ownerCheck({ ctx, path: path9, type, getRawInput }) : null;
+var ownerGate = t.middleware(async ({ ctx, next, path: path11, type, getRawInput }) => {
+  const filter = getAuthGate() ? await procedurePolicy().ownerCheck({ ctx, path: path11, type, getRawInput }) : null;
   const result = await next();
   if (!filter || !result.ok) return result;
   return { ...result, data: await filter(result.data) };
@@ -30405,8 +30525,8 @@ var unsafePathRefusal = t.middleware(async ({ next }) => {
   return result;
 });
 var publicProcedure = t.procedure.use(securityContext).use(authGate2).use(adminGate).use(scopeGate).use(ownerGate).use(switchRefusal).use(unsafePathRefusal);
-var hubLocalProcedure = publicProcedure.use(({ next, path: path9 }) => {
-  assertHubLocalExecEnabled({ op: path9 });
+var hubLocalProcedure = publicProcedure.use(({ next, path: path11 }) => {
+  assertHubLocalExecEnabled({ op: path11 });
   return next();
 });
 var openProcedure = t.procedure.use(securityContext);
@@ -30496,8 +30616,8 @@ var fileEditorRouter = router({
    * should only offer this when the workspace is co-resident — the caller decides.
    */
   showInFinder: publicProcedure.input(external_exports.object({ rootPath: external_exports.string(), targetPath: external_exports.string() })).mutation(async ({ input: input2 }) => {
-    const path9 = await import("node:path");
-    const abs = input2.targetPath ? path9.resolve(input2.rootPath, input2.targetPath) : path9.resolve(input2.rootPath);
+    const path11 = await import("node:path");
+    const abs = input2.targetPath ? path11.resolve(input2.rootPath, input2.targetPath) : path11.resolve(input2.rootPath);
     getFileEditorRouterDeps().shellShowItemInFolder(abs);
   }),
   /**
@@ -30549,9 +30669,9 @@ var workspaceRouter = router({
    * surfaced as such rather than rendered as an empty directory.
    */
   listRoots: publicProcedure.input(targetInput).query(async ({ input: input2 }) => {
-    const { fs: fs7, resolveComputer, isLocalComputer } = getWorkspaceDeps();
+    const { fs: fs8, resolveComputer, isLocalComputer } = getWorkspaceDeps();
     const computerId = await resolveComputer(input2);
-    return { computerId, isLocal: isLocalComputer(computerId), ...await fs7.listRoots(computerId) };
+    return { computerId, isLocal: isLocalComputer(computerId), ...await fs8.listRoots(computerId) };
   }),
   listDir: publicProcedure.input(
     targetInput.extend({
@@ -30561,18 +30681,18 @@ var workspaceRouter = router({
       includeHidden: external_exports.boolean().optional()
     })
   ).query(async ({ input: input2 }) => {
-    const { fs: fs7, resolveComputer } = getWorkspaceDeps();
+    const { fs: fs8, resolveComputer } = getWorkspaceDeps();
     const computerId = await resolveComputer(input2);
-    const res = await fs7.listDir(computerId, input2.path, {
+    const res = await fs8.listDir(computerId, input2.path, {
       dirsOnly: input2.dirsOnly,
       includeHidden: input2.includeHidden
     });
     return { computerId, ...res };
   }),
   mkdir: publicProcedure.input(targetInput.extend({ path: external_exports.string().min(1) })).mutation(async ({ input: input2 }) => {
-    const { fs: fs7, resolveComputer } = getWorkspaceDeps();
+    const { fs: fs8, resolveComputer } = getWorkspaceDeps();
     const computerId = await resolveComputer(input2);
-    const res = await fs7.mkdir(computerId, input2.path);
+    const res = await fs8.mkdir(computerId, input2.path);
     return { computerId, ...res };
   }),
   /**
@@ -30588,9 +30708,9 @@ var workspaceRouter = router({
    * from the enforced one.
    */
   setAllowedRoots: publicProcedure.input(targetInput.extend({ roots: external_exports.array(external_exports.string().min(1)) })).mutation(async ({ input: input2 }) => {
-    const { fs: fs7, resolveComputer } = getWorkspaceDeps();
+    const { fs: fs8, resolveComputer } = getWorkspaceDeps();
     const computerId = await resolveComputer(input2);
-    return { computerId, ...await fs7.setAllowedRoots(computerId, input2.roots) };
+    return { computerId, ...await fs8.setAllowedRoots(computerId, input2.roots) };
   }),
   /**
    * Where does the target machine keep this project?
@@ -30601,13 +30721,13 @@ var workspaceRouter = router({
    * is different again: recorded, but the folder is gone.
    */
   resolveProjectPath: publicProcedure.input(targetInput.extend({ projectId: external_exports.string().min(1) })).query(async ({ input: input2 }) => {
-    const { fs: fs7, resolveComputer } = getWorkspaceDeps();
+    const { fs: fs8, resolveComputer } = getWorkspaceDeps();
     const computerId = await resolveComputer(input2);
     try {
       return {
         computerId,
         reachable: true,
-        ...await fs7.resolveProjectPath(computerId, input2.projectId)
+        ...await fs8.resolveProjectPath(computerId, input2.projectId)
       };
     } catch (err) {
       return {
@@ -30626,18 +30746,18 @@ var workspaceRouter = router({
       path: external_exports.string().min(1)
     })
   ).mutation(async ({ input: input2 }) => {
-    const { fs: fs7, resolveComputer } = getWorkspaceDeps();
+    const { fs: fs8, resolveComputer } = getWorkspaceDeps();
     const computerId = await resolveComputer(input2);
     return {
       computerId,
-      ...await fs7.setProjectPath(computerId, input2.projectId, input2.path)
+      ...await fs8.setProjectPath(computerId, input2.projectId, input2.path)
     };
   }),
   /** Drop the mapping on that machine. The checkout itself is left alone. */
   forgetProjectPath: publicProcedure.input(targetInput.extend({ projectId: external_exports.string().min(1) })).mutation(async ({ input: input2 }) => {
-    const { fs: fs7, resolveComputer } = getWorkspaceDeps();
+    const { fs: fs8, resolveComputer } = getWorkspaceDeps();
     const computerId = await resolveComputer(input2);
-    await fs7.forgetProjectPath(computerId, input2.projectId);
+    await fs8.forgetProjectPath(computerId, input2.projectId);
     return { computerId, ok: true };
   }),
   /**
@@ -30649,10 +30769,10 @@ var workspaceRouter = router({
    * "No repository path configured" for a path that was fine.
    */
   pathExists: publicProcedure.input(targetInput.extend({ path: external_exports.string().min(1) })).query(async ({ input: input2 }) => {
-    const { fs: fs7, resolveComputer } = getWorkspaceDeps();
+    const { fs: fs8, resolveComputer } = getWorkspaceDeps();
     const computerId = await resolveComputer(input2);
     try {
-      return { computerId, exists: await fs7.pathExists(computerId, input2.path), reachable: true };
+      return { computerId, exists: await fs8.pathExists(computerId, input2.path), reachable: true };
     } catch (err) {
       return {
         computerId,
@@ -30676,13 +30796,13 @@ function createFsHandlers(ctx) {
   };
   const watches = /* @__PURE__ */ new Map();
   function pathExists(rawParams) {
-    const { path: path9 } = fsPathExistsParamsSchema.parse(rawParams);
-    const resolved = allow(path9);
+    const { path: path11 } = fsPathExistsParamsSchema.parse(rawParams);
+    const resolved = allow(path11);
     return { exists: (0, import_node_fs7.existsSync)(resolved) };
   }
   async function removeDir(rawParams) {
-    const { path: path9 } = fsRemoveDirParamsSchema.parse(rawParams);
-    const resolved = allow(path9, true);
+    const { path: path11 } = fsRemoveDirParamsSchema.parse(rawParams);
+    const resolved = allow(path11, true);
     await (0, import_promises7.rm)(resolved, { recursive: true, force: true });
     ctx.log("fs removeDir", { path: resolved });
     return { ok: true };
@@ -30745,8 +30865,8 @@ function createFsHandlers(ctx) {
     return { path: abs, parent: isRoot ? null : (0, import_node_path10.dirname)(abs), entries };
   }
   async function mkdirHandler(rawParams) {
-    const { path: path9 } = fsMkdirParamsSchema.parse(rawParams);
-    const abs = allow(path9);
+    const { path: path11 } = fsMkdirParamsSchema.parse(rawParams);
+    const abs = allow(path11);
     await (0, import_promises7.mkdir)(abs, { recursive: true });
     ctx.log("fs mkdir", { path: abs });
     return { path: import_node_fs7.realpathSync.native(abs) };
@@ -30906,11 +31026,132 @@ function createGhHandlers(ctx) {
   return { [HubToComputerMethods.ghExec]: ghExec };
 }
 
+// src/handlers/claude-session.ts
+var import_node_fs8 = require("node:fs");
+var import_node_os7 = require("node:os");
+var import_node_path11 = require("node:path");
+var import_node_readline = require("node:readline");
+var LARGE_RECORD_BYTES = 32 * 1024;
+var KEEP_TOOL_TEXT = 8 * 1024;
+function encodeProjectDir(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function claudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".claude");
+}
+function sessionFile(cwd, sessionId) {
+  const candidates = /* @__PURE__ */ new Set();
+  try {
+    candidates.add((0, import_node_fs8.realpathSync)(cwd));
+  } catch {
+  }
+  candidates.add(cwd);
+  for (const dir of candidates) {
+    const file2 = (0, import_node_path11.join)(claudeConfigDir(), "projects", encodeProjectDir(dir), `${sessionId}.jsonl`);
+    if ((0, import_node_fs8.existsSync)(file2)) return file2;
+  }
+  return null;
+}
+async function* records(file2) {
+  const input2 = (0, import_node_fs8.createReadStream)(file2, { encoding: "utf8" });
+  const rl = (0, import_node_readline.createInterface)({ input: input2, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const rec = JSON.parse(trimmed);
+        if (rec && typeof rec === "object" && !Array.isArray(rec)) {
+          yield rec;
+        }
+      } catch {
+      }
+    }
+  } finally {
+    rl.close();
+    input2.destroy();
+  }
+}
+function isContent(rec) {
+  if (rec.isSidechain === true) return false;
+  if (rec.type === "user" || rec.type === "assistant") return true;
+  return rec.type === "system" && rec.subtype === "compact_boundary";
+}
+function shortened(rec) {
+  if (JSON.stringify(rec).length <= LARGE_RECORD_BYTES) return rec;
+  const message = rec.message;
+  if (!message || !Array.isArray(message.content)) return rec;
+  const cut = (text) => text.length > KEEP_TOOL_TEXT ? `${text.slice(0, KEEP_TOOL_TEXT)}
+\u2026 (shortened)` : text;
+  const content = message.content.map((block) => {
+    const b = block;
+    if (b?.type !== "tool_result") return block;
+    if (typeof b.content === "string") return { ...b, content: cut(b.content) };
+    if (Array.isArray(b.content)) {
+      return {
+        ...b,
+        content: b.content.map((part) => {
+          const p = part;
+          return p?.type === "text" && typeof p.text === "string" ? { ...p, text: cut(p.text) } : part;
+        })
+      };
+    }
+    return block;
+  });
+  const { toolUseResult: _structured, ...rest } = rec;
+  void _structured;
+  return { ...rest, message: { ...message, content } };
+}
+function createClaudeSessionHandlers(ctx, getProjectPaths) {
+  async function read(rawParams) {
+    const params = claudeSessionReadParamsSchema.parse(rawParams);
+    const resolved = params.cwd ?? (params.projectId ? getProjectPaths()?.get(params.projectId)?.path : void 0);
+    if (!resolved) throw new Error("claudeSession.read: no cwd for this session");
+    const cwd = assertPathAllowed(resolved, ctx.config.allowedRoots);
+    const file2 = sessionFile(cwd, params.sessionId);
+    if (!file2) return { found: false, records: [], omitted: 0 };
+    const links = /* @__PURE__ */ new Map();
+    let leaf = null;
+    for await (const rec of records(file2)) {
+      if (typeof rec.uuid !== "string") continue;
+      const parent = typeof rec.parentUuid === "string" ? rec.parentUuid : typeof rec.logicalParentUuid === "string" ? rec.logicalParentUuid : null;
+      const content = isContent(rec);
+      links.set(rec.uuid, { parent, content });
+      if (content && rec.type !== "system") leaf = rec.uuid;
+    }
+    const branch = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let at = leaf; at && !seen.has(at); at = links.get(at)?.parent ?? null) {
+      seen.add(at);
+      if (links.get(at)?.content) branch.push(at);
+    }
+    branch.reverse();
+    const wanted = new Set(branch.slice(-params.maxRecords));
+    const byUuid = /* @__PURE__ */ new Map();
+    for await (const rec of records(file2)) {
+      if (typeof rec.uuid === "string" && wanted.has(rec.uuid)) byUuid.set(rec.uuid, shortened(rec));
+    }
+    const picked = [];
+    let bytes = 0;
+    for (let i = branch.length - 1; i >= 0 && picked.length < params.maxRecords; i--) {
+      const rec = byUuid.get(branch[i]);
+      if (!rec) continue;
+      const size = JSON.stringify(rec).length;
+      if (bytes + size > params.maxBytes) break;
+      bytes += size;
+      picked.push(rec);
+    }
+    picked.reverse();
+    return { found: true, records: picked, omitted: branch.length - picked.length };
+  }
+  return { [HubToComputerMethods.claudeSessionRead]: read };
+}
+
 // src/handlers/git.ts
 var import_node_child_process7 = require("node:child_process");
-var import_node_fs8 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_promises8 = require("node:fs/promises");
-var import_node_path11 = require("node:path");
+var import_node_path12 = require("node:path");
 
 // src/handlers/exec.ts
 var import_node_child_process6 = require("node:child_process");
@@ -30968,9 +31209,9 @@ var SETUP_SCRIPT_TIMEOUT_MS = 5 * 6e4;
 function createGitHandlers(ctx) {
   const allow = (candidate) => assertPathAllowed(candidate, ctx.config.allowedRoots);
   async function isGitRepo(rawParams) {
-    const { path: path9 } = isGitRepoParams.parse(rawParams);
-    const repoPath = allow(path9);
-    if (!(0, import_node_fs8.existsSync)(repoPath)) return { isGitRepo: false };
+    const { path: path11 } = isGitRepoParams.parse(rawParams);
+    const repoPath = allow(path11);
+    if (!(0, import_node_fs9.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 };
@@ -31003,7 +31244,7 @@ function createGitHandlers(ctx) {
     try {
       await execGit(["worktree", "remove", worktreePath, "--force"], repoPath);
     } catch (err) {
-      if (!(0, import_node_fs8.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs9.existsSync)(worktreePath)) {
         await execGit(["worktree", "prune"], repoPath);
       } else {
         throw err;
@@ -31031,13 +31272,13 @@ function createGitHandlers(ctx) {
     const params = runWorktreeSetupScriptParams.parse(rawParams);
     const worktreePath = allow(params.worktreePath);
     const repoPath = allow(params.repoPath);
-    const scriptPath = (0, import_node_path11.resolve)(worktreePath, SETUP_SCRIPT);
-    if (!(0, import_node_fs8.existsSync)(scriptPath)) return Promise.resolve({ ran: false });
+    const scriptPath = (0, import_node_path12.resolve)(worktreePath, SETUP_SCRIPT);
+    if (!(0, import_node_fs9.existsSync)(scriptPath)) return Promise.resolve({ ran: false });
     try {
-      (0, import_node_fs8.accessSync)(scriptPath, import_node_fs8.constants.X_OK);
+      (0, import_node_fs9.accessSync)(scriptPath, import_node_fs9.constants.X_OK);
     } catch {
       try {
-        (0, import_node_fs8.chmodSync)(scriptPath, 493);
+        (0, import_node_fs9.chmodSync)(scriptPath, 493);
       } catch {
         return Promise.resolve({ ran: false });
       }
@@ -31088,19 +31329,19 @@ function createGitHandlers(ctx) {
     } else {
       relPaths = params.customPaths ?? [];
     }
-    const repoRoot = (0, import_node_path11.resolve)(repoPath);
-    const wtRoot = (0, import_node_path11.resolve)(worktreePath);
+    const repoRoot = (0, import_node_path12.resolve)(repoPath);
+    const wtRoot = (0, import_node_path12.resolve)(worktreePath);
     let copied = 0;
     for (const rel of relPaths) {
-      const src = (0, import_node_path11.resolve)(repoPath, rel);
-      const dest = (0, import_node_path11.resolve)(worktreePath, rel);
+      const src = (0, import_node_path12.resolve)(repoPath, rel);
+      const dest = (0, import_node_path12.resolve)(worktreePath, rel);
       if (!isInside2(src, repoRoot) || !isInside2(dest, wtRoot)) {
         ctx.log("copyIgnoredFiles skipped traversal", { rel });
         continue;
       }
-      if (!(0, import_node_fs8.existsSync)(src)) continue;
+      if (!(0, import_node_fs9.existsSync)(src)) continue;
       try {
-        await (0, import_promises8.mkdir)((0, import_node_path11.dirname)(dest), { recursive: true });
+        await (0, import_promises8.mkdir)((0, import_node_path12.dirname)(dest), { recursive: true });
         await (0, import_promises8.cp)(src, dest, { recursive: true, verbatimSymlinks: true });
         copied += 1;
       } catch (err) {
@@ -31119,12 +31360,13 @@ function createGitHandlers(ctx) {
   };
 }
 function isInside2(child, root) {
-  const c = (0, import_node_path11.resolve)(child);
-  return c === root || c.startsWith(root + import_node_path11.sep);
+  const c = (0, import_node_path12.resolve)(child);
+  return c === root || c.startsWith(root + import_node_path12.sep);
 }
 
 // src/handlers/proc.ts
 var import_node_child_process8 = require("node:child_process");
+var import_node_string_decoder = require("node:string_decoder");
 
 // src/exit-tombstones.ts
 var TOMBSTONE_TTL_MS = 10 * 6e4;
@@ -31223,6 +31465,153 @@ var RingBuffer = class {
   }
 };
 
+// src/spawn-admission.ts
+var import_node_os8 = require("node:os");
+var DEFAULT_START_CAP_MS = 5e3;
+var DEFAULT_WARM_QUIET_MS = 3e3;
+function defaultAdmissionConcurrency(cores = (0, import_node_os8.availableParallelism)()) {
+  return Math.max(2, Math.min(4, Math.floor(cores / 2)));
+}
+var LANE_RANK = { foreground: 0, background: 1, warm: 2 };
+function createSpawnAdmission(opts = {}) {
+  const concurrency = Math.max(1, opts.concurrency ?? defaultAdmissionConcurrency());
+  const startCapMs = opts.startCapMs ?? DEFAULT_START_CAP_MS;
+  const warmQuietMs = opts.warmQuietMs ?? DEFAULT_WARM_QUIET_MS;
+  const now = opts.now ?? Date.now;
+  const setTimer = opts.setTimer ?? ((fn, ms) => {
+    const t2 = setTimeout(fn, ms);
+    t2.unref?.();
+    return t2;
+  });
+  const clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
+  const queue = [];
+  const active = /* @__PURE__ */ new Set();
+  let arrivals = 0;
+  let promotions = 0;
+  let lastAgentActivity = Number.NEGATIVE_INFINITY;
+  let warmRetry = null;
+  let pumping = false;
+  let pumpAgain = false;
+  const activeAgents = () => [...active].filter((s) => !s.warm).length;
+  const activeWarm = () => [...active].filter((s) => s.warm).length;
+  function next() {
+    if (active.size >= concurrency || queue.length === 0) return null;
+    let best = null;
+    for (const t2 of queue) {
+      if (!best || LANE_RANK[t2.lane] < LANE_RANK[best.lane] || t2.lane === best.lane && t2.order < best.order) {
+        best = t2;
+      }
+    }
+    if (!best || best.lane !== "warm") return best;
+    if (activeAgents() > 0 || activeWarm() > 0) return null;
+    const quietLeft = lastAgentActivity + warmQuietMs - now();
+    if (quietLeft > 0) {
+      if (warmRetry === null) {
+        warmRetry = setTimer(() => {
+          warmRetry = null;
+          pump();
+        }, quietLeft);
+      }
+      return null;
+    }
+    return best;
+  }
+  function admit(ticket) {
+    queue.splice(queue.indexOf(ticket), 1);
+    const warm = ticket.lane === "warm";
+    const held = { warm, released: false, cap: null };
+    const release = () => {
+      if (held.released) return;
+      held.released = true;
+      clearTimer(held.cap);
+      active.delete(held);
+      if (!warm) lastAgentActivity = now();
+      pump();
+    };
+    held.cap = setTimer(release, startCapMs);
+    active.add(held);
+    try {
+      ticket.start({ release });
+    } catch {
+      release();
+    }
+  }
+  function pump() {
+    if (pumping) {
+      pumpAgain = true;
+      return;
+    }
+    pumping = true;
+    try {
+      do {
+        pumpAgain = false;
+        for (let t2 = next(); t2; t2 = next()) admit(t2);
+      } while (pumpAgain);
+    } finally {
+      pumping = false;
+    }
+  }
+  return {
+    enqueue(lane, start) {
+      const ticket = { lane, order: ++arrivals, start };
+      queue.push(ticket);
+      if (lane !== "warm") lastAgentActivity = now();
+      pump();
+      return ticket;
+    },
+    cancel(ticket) {
+      const i = queue.indexOf(ticket);
+      if (i < 0) return false;
+      queue.splice(i, 1);
+      pump();
+      return true;
+    },
+    prioritize(ticket) {
+      const t2 = ticket;
+      if (!queue.includes(t2)) return false;
+      t2.lane = "foreground";
+      t2.order = -++promotions;
+      pump();
+      return true;
+    },
+    isQueued(ticket) {
+      return queue.includes(ticket);
+    },
+    stats() {
+      return { queued: queue.length, active: active.size, concurrency };
+    }
+  };
+}
+
+// src/handlers/resolve-command.ts
+var import_node_fs10 = require("node:fs");
+var import_node_path13 = require("node:path");
+function isExecutableFile(file2) {
+  try {
+    if (!(0, import_node_fs10.statSync)(file2).isFile()) return false;
+    if (process.platform !== "win32") (0, import_node_fs10.accessSync)(file2, import_node_fs10.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveCommand(command, env, cwd) {
+  const suffixes = process.platform === "win32" ? ["", ...(env.PATHEXT ?? process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";")] : [""];
+  const hasDir = command.includes("/") || process.platform === "win32" && command.includes("\\");
+  if (hasDir) {
+    const base = (0, import_node_path13.isAbsolute)(command) ? command : (0, import_node_path13.join)(cwd ?? process.cwd(), command);
+    return suffixes.map((s) => base + s).find(isExecutableFile) ?? null;
+  }
+  for (const dir of (env.PATH ?? env.Path ?? "").split(import_node_path13.delimiter)) {
+    if (!dir) continue;
+    for (const suffix of suffixes) {
+      const candidate = (0, import_node_path13.join)(dir, command + suffix);
+      if (isExecutableFile(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
 // src/handlers/spawn-env.ts
 function buildSpawnEnv(ctx, overrides) {
   const merged = overrides ? { ...sanitizeSpawnEnv(process.env), ...overrides } : sanitizeSpawnEnv(process.env);
@@ -31231,6 +31620,9 @@ function buildSpawnEnv(ctx, overrides) {
     delete merged.SLAYZONE_HUB_TOKEN;
   }
   if (ctx.hubAddress) merged.SLAYZONE_HUB_ADDRESS = ctx.hubAddress;
+  if (ctx.config.binOverrideDir) {
+    merged.PATH = mergePathLists(ctx.config.binOverrideDir, merged.PATH);
+  }
   return merged;
 }
 
@@ -31247,14 +31639,67 @@ var ProcNotifications = {
   procData: ComputerNotificationMethods.procData,
   procExit: ComputerNotificationMethods.procExit
 };
-function createProcHandlers(ctx, getProjectPaths) {
+var WRITE_ID_MEMORY = 256;
+function refuse2(reason, message, data = {}) {
+  return new RpcError(ComputerTransportErrorCodes.refusedByComputer, message, {
+    reason,
+    ...data
+  });
+}
+function createProcHandlers(ctx, getProjectPaths, options = {}) {
   const procs = /* @__PURE__ */ new Map();
   const tombstones = new ExitTombstones();
+  const admission = options.admission ?? createSpawnAdmission();
+  const queued = /* @__PURE__ */ new Map();
   function killTree(child, signal = "SIGTERM") {
     if (typeof child.pid === "number") killPidTree(child.pid, signal);
   }
+  function releaseSlot(session) {
+    const slot = session.slot;
+    session.slot = null;
+    slot?.release();
+  }
   function procSpawn(rawParams) {
     const params = procSpawnParamsSchema.parse(rawParams);
+    if (!params.admission) return startProc(params, null);
+    const prior = queued.get(params.sessionId);
+    if (prior && params.spawnId !== void 0 && prior.spawnId === params.spawnId) {
+      return prior.promise;
+    }
+    let resolve9;
+    let reject;
+    const promise2 = new Promise((res, rej) => {
+      resolve9 = res;
+      reject = rej;
+    });
+    const item = {
+      ...params.spawnId !== void 0 ? { spawnId: params.spawnId } : {},
+      ticket: void 0,
+      promise: promise2,
+      resolve: resolve9,
+      reject
+    };
+    if (prior) {
+      admission.cancel(prior.ticket);
+      prior.resolve(promise2);
+    }
+    queued.set(params.sessionId, item);
+    item.ticket = admission.enqueue(params.admission, (slot) => {
+      if (queued.get(params.sessionId) !== item) {
+        slot.release();
+        return;
+      }
+      queued.delete(params.sessionId);
+      try {
+        item.resolve(startProc(params, slot));
+      } catch (err) {
+        slot.release();
+        item.reject(err);
+      }
+    });
+    return promise2;
+  }
+  function startProc(params, slot) {
     if (params.spawnId !== void 0) {
       const live = procs.get(params.sessionId);
       if (live && live.spawnId === params.spawnId) return { pid: live.child.pid ?? null };
@@ -31264,17 +31709,29 @@ function createProcHandlers(ctx, getProjectPaths) {
         );
       }
     }
-    const resolved = params.cwd ?? (params.projectId ? getProjectPaths?.()?.get(params.projectId)?.path : void 0);
+    let resolved = params.cwd || void 0;
+    if (!resolved && params.projectId) {
+      resolved = getProjectPaths?.()?.get(params.projectId)?.path;
+      if (!resolved) throw projectNotPlacedError(params.projectId);
+    }
     const cwd = spawnCwd(resolved, ctx.config.allowedRoots);
     const existing = procs.get(params.sessionId);
     if (existing) {
       killTree(existing.child);
       procs.delete(params.sessionId);
     }
+    const env = buildSpawnEnv(ctx, params.env);
+    if (!params.shell && resolveCommand(params.command, env, cwd) === null) {
+      throw refuse2(
+        ProcRefusalReasons.binaryNotFound,
+        `${params.command} was not found on this computer's PATH`,
+        { binary: params.command }
+      );
+    }
     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: buildSpawnEnv(ctx, params.env),
+      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`
@@ -31285,14 +31742,24 @@ function createProcHandlers(ctx, getProjectPaths) {
     const session = {
       child,
       buffer,
-      ...params.spawnId !== void 0 ? { spawnId: params.spawnId } : {}
+      ...params.spawnId !== void 0 ? { spawnId: params.spawnId } : {},
+      stdinBroken: null,
+      writeIds: [],
+      slot
     };
     procs.set(params.sessionId, session);
+    const tag = params.spawnId !== void 0 ? { spawnId: params.spawnId } : {};
+    child.stdin?.on("error", (err) => {
+      session.stdinBroken = err.message;
+      ctx.log("proc stdin error", { sessionId: params.sessionId, error: err.message });
+    });
     const settle2 = (payload) => {
+      releaseSlot(session);
       if (procs.get(params.sessionId) !== session) return;
       procs.delete(params.sessionId);
       const delivered = ctx.dialer.notify(ProcNotifications.procExit, {
         sessionId: params.sessionId,
+        ...tag,
         ...payload
       });
       tombstones.add(params.sessionId, {
@@ -31304,26 +31771,39 @@ function createProcHandlers(ctx, getProjectPaths) {
         ...delivered ? {} : { buffer: session.buffer }
       });
     };
-    child.stdout?.on("data", (d) => {
-      if (procs.get(params.sessionId) !== session) return;
-      const data = d.toString();
+    const stdoutDecoder = new import_node_string_decoder.StringDecoder("utf8");
+    const stderrDecoder = new import_node_string_decoder.StringDecoder("utf8");
+    const emitStdout = (data) => {
+      if (!data || procs.get(params.sessionId) !== session) return;
       const seq = buffer.append(data);
       ctx.dialer.notify(ProcNotifications.procData, {
         sessionId: params.sessionId,
+        ...tag,
         seq,
         stream: "stdout",
         data
       });
-    });
-    child.stderr?.on("data", (d) => {
-      if (procs.get(params.sessionId) !== session) return;
+    };
+    const emitStderr = (data) => {
+      if (!data || procs.get(params.sessionId) !== session) return;
       ctx.dialer.notify(ProcNotifications.procData, {
         sessionId: params.sessionId,
+        ...tag,
         stream: "stderr",
-        data: d.toString()
+        data
       });
+    };
+    child.stdout?.on("data", (d) => {
+      releaseSlot(session);
+      emitStdout(stdoutDecoder.write(d));
+    });
+    child.stderr?.on("data", (d) => {
+      releaseSlot(session);
+      emitStderr(stderrDecoder.write(d));
     });
     child.on("close", (code, signal) => {
+      emitStdout(stdoutDecoder.end());
+      emitStderr(stderrDecoder.end());
       settle2({
         exitCode: typeof code === "number" ? code : null,
         signal: signal != null ? String(signal) : null
@@ -31346,6 +31826,10 @@ function createProcHandlers(ctx, getProjectPaths) {
       ctx.log("proc kill on unknown session", { sessionId: params.sessionId });
       return { ok: true };
     }
+    if (params.spawnId !== void 0 && session.spawnId !== params.spawnId) {
+      ctx.log("proc kill for a replaced attempt", { sessionId: params.sessionId });
+      return { ok: true };
+    }
     killTree(session.child, params.signal ?? "SIGTERM");
     return { ok: true };
   }
@@ -31354,14 +31838,55 @@ function createProcHandlers(ctx, getProjectPaths) {
     const session = procs.get(params.sessionId);
     if (!session) {
       ctx.log("proc write on unknown session", { sessionId: params.sessionId });
-      return { ok: true };
+      return Promise.reject(
+        refuse2(ProcRefusalReasons.unknownSession, `proc.write: no process ${params.sessionId}`)
+      );
     }
-    try {
-      session.child.stdin?.write(params.data);
-    } catch (err) {
-      ctx.log("proc write failed", { sessionId: params.sessionId, error: String(err) });
+    if (params.spawnId !== void 0 && session.spawnId !== params.spawnId) {
+      return Promise.reject(
+        refuse2(
+          ProcRefusalReasons.staleSpawn,
+          `proc.write: ${params.sessionId} now runs a different process`
+        )
+      );
     }
-    return { ok: true };
+    if (params.writeId !== void 0 && session.writeIds.includes(params.writeId)) {
+      return Promise.resolve({ ok: true, delivered: true, duplicate: true });
+    }
+    const stdin2 = session.child.stdin;
+    if (!stdin2 || session.stdinBroken !== null || stdin2.destroyed || stdin2.writableEnded) {
+      return Promise.reject(
+        refuse2(
+          ProcRefusalReasons.stdinClosed,
+          `proc.write: ${params.sessionId} stdin is closed${session.stdinBroken ? ` (${session.stdinBroken})` : ""}`
+        )
+      );
+    }
+    if (params.writeId !== void 0) {
+      session.writeIds.push(params.writeId);
+      if (session.writeIds.length > WRITE_ID_MEMORY) session.writeIds.shift();
+    }
+    return new Promise((resolve9, reject) => {
+      const fail = (err) => {
+        if (params.writeId !== void 0) {
+          session.writeIds = session.writeIds.filter((id) => id !== params.writeId);
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        session.stdinBroken ??= message;
+        ctx.log("proc write failed", { sessionId: params.sessionId, error: message });
+        reject(
+          refuse2(ProcRefusalReasons.stdinClosed, `proc.write: ${params.sessionId}: ${message}`)
+        );
+      };
+      try {
+        stdin2.write(
+          params.data,
+          (err) => err ? fail(err) : resolve9({ ok: true, delivered: true })
+        );
+      } catch (err) {
+        fail(err);
+      }
+    });
   }
   function procGetBufferSince(rawParams) {
     const params = procGetBufferSinceParamsSchema.parse(rawParams);
@@ -31383,7 +31908,13 @@ function createProcHandlers(ctx, getProjectPaths) {
     return { sessions, exited: tombstones.list() };
   }
   function disposeAll() {
+    for (const item of queued.values()) {
+      admission.cancel(item.ticket);
+      item.reject(new Error("computer shutting down"));
+    }
+    queued.clear();
     for (const [sessionId, session] of procs) {
+      releaseSlot(session);
       killTree(session.child);
       ctx.log("proc disposed on shutdown", { sessionId });
     }
@@ -31400,7 +31931,7 @@ function createProcHandlers(ctx, getProjectPaths) {
 }
 
 // src/handlers/project.ts
-var import_node_fs9 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 function createProjectHandlers(ctx, getStore) {
   const allow = (candidate) => assertPathAllowed(candidate, ctx.config.allowedRoots);
   const store = () => {
@@ -31412,11 +31943,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_fs9.existsSync)(entry.path) };
+    return { path: entry.path, exists: (0, import_node_fs11.existsSync)(entry.path) };
   }
   async function setPath(rawParams) {
-    const { projectId, path: path9 } = projectSetPathParamsSchema.parse(rawParams);
-    const resolved = allow(path9);
+    const { projectId, path: path11 } = projectSetPathParamsSchema.parse(rawParams);
+    const resolved = allow(path11);
     const entry = await store().set(projectId, resolved);
     ctx.log("project path recorded", { projectId, path: entry.path });
     return { path: entry.path };
@@ -31433,7 +31964,7 @@ function createProjectHandlers(ctx, getStore) {
       projects: store().list().map((e) => ({
         projectId: e.projectId,
         path: e.path,
-        exists: (0, import_node_fs9.existsSync)(e.path)
+        exists: (0, import_node_fs11.existsSync)(e.path)
       }))
     };
   }
@@ -31446,8 +31977,77 @@ function createProjectHandlers(ctx, getStore) {
 }
 
 // src/handlers/pty.ts
+var import_node_module = require("node:module");
+var path8 = __toESM(require("node:path"), 1);
 var pty = __toESM(require("node-pty"), 1);
 
+// ../../shared/platform/src/node-pty-install.ts
+var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
+function pendingBuildsFrom(modulesYaml) {
+  try {
+    const parsed = JSON.parse(modulesYaml);
+    const pending = parsed?.pendingBuilds;
+    return Array.isArray(pending) && pending.every((p) => typeof p === "string") ? pending : null;
+  } catch {
+    return null;
+  }
+}
+function spawnHelperCandidates(nodePtyDir2, platform3 = process.platform, arch = process.arch) {
+  if (platform3 === "win32") return [];
+  return ["build/Release", "build/Debug", `prebuilds/${platform3}-${arch}`].map(
+    (dir) => import_node_path14.default.join(nodePtyDir2, dir, "spawn-helper")
+  );
+}
+function unpackedAsarPath(file2) {
+  return file2.replace(/app\.asar(?!\.unpacked)/, "app.asar.unpacked").replace(/node_modules\.asar(?!\.unpacked)/, "node_modules.asar.unpacked");
+}
+var shellQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+function installProblems(state) {
+  const problems = [];
+  if (state.repoRoot !== null && state.pendingBuilds && state.pendingBuilds.length > 0) {
+    problems.push({
+      check: "Install scripts ran",
+      detail: `pnpm skipped the install scripts of: ${state.pendingBuilds.join(", ")}.`,
+      fix: `cd ${shellQuote(state.repoRoot)} && pnpm rebuild --pending`
+    });
+  }
+  const broken = state.helpers.filter((h) => !h.executable).map((h) => h.path);
+  if (broken.length > 0) {
+    problems.push({
+      check: "spawn-helper executable",
+      detail: `${broken.join(", ")} ${broken.length === 1 ? "is" : "are"} not executable, so every terminal fails to start ("posix_spawnp failed").`,
+      fix: `chmod +x ${broken.map(shellQuote).join(" ")}`
+    });
+  }
+  return problems;
+}
+function readNodePtyInstall(nodePtyDir2) {
+  const nodeModules = import_node_path14.default.dirname(nodePtyDir2);
+  let pendingBuilds = null;
+  let repoRoot = null;
+  try {
+    pendingBuilds = pendingBuildsFrom(
+      import_node_fs12.default.readFileSync(import_node_path14.default.join(nodeModules, ".modules.yaml"), "utf8")
+    );
+    repoRoot = import_node_path14.default.dirname(nodeModules);
+  } catch {
+  }
+  const helpers = spawnHelperCandidates(nodePtyDir2).map(unpackedAsarPath).filter((p) => import_node_fs12.default.existsSync(p)).map((p) => ({ path: p, executable: isExecutable(p) }));
+  return { repoRoot, pendingBuilds, helpers };
+}
+function nodePtyInstallProblems(nodePtyDir2) {
+  return installProblems(readNodePtyInstall(nodePtyDir2));
+}
+function isExecutable(file2) {
+  try {
+    import_node_fs12.default.accessSync(file2, import_node_fs12.default.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // ../../shared/platform/src/startup-deadline.ts
 function armStartupDeadline({
   timeoutMs,
@@ -31515,7 +32115,7 @@ function matchLiveJobs(jobs, descendants, stdoutByPid) {
   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 byOutput = job.kind === "shell" && [...outputs].some((path11) => path11.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);
@@ -31529,7 +32129,7 @@ async function readStdoutPaths(pids) {
     await Promise.all(
       pids.map(
         (pid2) => (0, import_promises9.readlink)(`/proc/${pid2}/fd/1`).then(
-          (path9) => void out.set(pid2, path9),
+          (path11) => void out.set(pid2, path11),
           () => void 0
         )
       )
@@ -31564,141 +32164,26 @@ async function probeBackgroundJobs(rootPid, jobs) {
   return matchLiveJobs(jobs, descendants, stdoutByPid);
 }
 
-// src/spawn-admission.ts
-var import_node_os7 = require("node:os");
-var DEFAULT_START_CAP_MS = 5e3;
-var DEFAULT_WARM_QUIET_MS = 3e3;
-function defaultAdmissionConcurrency(cores = (0, import_node_os7.availableParallelism)()) {
-  return Math.max(2, Math.min(4, Math.floor(cores / 2)));
-}
-var LANE_RANK = { foreground: 0, background: 1, warm: 2 };
-function createSpawnAdmission(opts = {}) {
-  const concurrency = Math.max(1, opts.concurrency ?? defaultAdmissionConcurrency());
-  const startCapMs = opts.startCapMs ?? DEFAULT_START_CAP_MS;
-  const warmQuietMs = opts.warmQuietMs ?? DEFAULT_WARM_QUIET_MS;
-  const now = opts.now ?? Date.now;
-  const setTimer = opts.setTimer ?? ((fn, ms) => {
-    const t2 = setTimeout(fn, ms);
-    t2.unref?.();
-    return t2;
-  });
-  const clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
-  const queue = [];
-  const active = /* @__PURE__ */ new Set();
-  let arrivals = 0;
-  let promotions = 0;
-  let lastAgentActivity = Number.NEGATIVE_INFINITY;
-  let warmRetry = null;
-  let pumping = false;
-  let pumpAgain = false;
-  const activeAgents = () => [...active].filter((s) => !s.warm).length;
-  const activeWarm = () => [...active].filter((s) => s.warm).length;
-  function next() {
-    if (active.size >= concurrency || queue.length === 0) return null;
-    let best = null;
-    for (const t2 of queue) {
-      if (!best || LANE_RANK[t2.lane] < LANE_RANK[best.lane] || t2.lane === best.lane && t2.order < best.order) {
-        best = t2;
-      }
-    }
-    if (!best || best.lane !== "warm") return best;
-    if (activeAgents() > 0 || activeWarm() > 0) return null;
-    const quietLeft = lastAgentActivity + warmQuietMs - now();
-    if (quietLeft > 0) {
-      if (warmRetry === null) {
-        warmRetry = setTimer(() => {
-          warmRetry = null;
-          pump();
-        }, quietLeft);
-      }
-      return null;
-    }
-    return best;
-  }
-  function admit(ticket) {
-    queue.splice(queue.indexOf(ticket), 1);
-    const warm = ticket.lane === "warm";
-    const held = { warm, released: false, cap: null };
-    const release = () => {
-      if (held.released) return;
-      held.released = true;
-      clearTimer(held.cap);
-      active.delete(held);
-      if (!warm) lastAgentActivity = now();
-      pump();
-    };
-    held.cap = setTimer(release, startCapMs);
-    active.add(held);
-    try {
-      ticket.start({ release });
-    } catch {
-      release();
-    }
-  }
-  function pump() {
-    if (pumping) {
-      pumpAgain = true;
-      return;
-    }
-    pumping = true;
-    try {
-      do {
-        pumpAgain = false;
-        for (let t2 = next(); t2; t2 = next()) admit(t2);
-      } while (pumpAgain);
-    } finally {
-      pumping = false;
-    }
-  }
-  return {
-    enqueue(lane, start) {
-      const ticket = { lane, order: ++arrivals, start };
-      queue.push(ticket);
-      if (lane !== "warm") lastAgentActivity = now();
-      pump();
-      return ticket;
-    },
-    cancel(ticket) {
-      const i = queue.indexOf(ticket);
-      if (i < 0) return false;
-      queue.splice(i, 1);
-      pump();
-      return true;
-    },
-    prioritize(ticket) {
-      const t2 = ticket;
-      if (!queue.includes(t2)) return false;
-      t2.lane = "foreground";
-      t2.order = -++promotions;
-      pump();
-      return true;
-    },
-    isQueued(ticket) {
-      return queue.includes(ticket);
-    },
-    stats() {
-      return { queued: queue.length, active: active.size, concurrency };
-    }
-  };
-}
-
 // src/handlers/pty.ts
 var MAX_BUFFER_SIZE2 = 750 * 1024;
 var STARTUP_KILL_REAP_MS = 2e3;
+function nodePtyDir() {
+  const resolve9 = typeof require === "function" ? require.resolve : (0, import_node_module.createRequire)(process.argv[1] ?? path8.join(process.cwd(), "index.js")).resolve;
+  return path8.dirname(resolve9("node-pty/package.json"));
+}
+var installProblemsOnDisk = () => nodePtyInstallProblems(nodePtyDir());
 function createPtyHandlers(ctx, getProjectPaths, options = {}) {
   const sessions = /* @__PURE__ */ new Map();
   const tombstones = new ExitTombstones();
   const admission = options.admission ?? createSpawnAdmission();
+  const spawnPty = options.spawnPty ?? pty.spawn;
+  const installProblems2 = options.nodePtyInstallProblems ?? installProblemsOnDisk;
   const queued = /* @__PURE__ */ new Map();
   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");
     const entry = getProjectPaths?.()?.get(opts.projectId);
-    if (!entry) {
-      throw new Error(
-        `project ${opts.projectId} is not checked out on this computer \u2014 adopt a folder or enable remote git for it`
-      );
-    }
+    if (!entry) throw projectNotPlacedError(opts.projectId);
     return spawnCwd(entry.path, ctx.config.allowedRoots);
   }
   function spawnSession(id, opts) {
@@ -31713,13 +32198,18 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
       }
       sessions.delete(id);
     }
-    const proc = pty.spawn(opts.command, opts.args ?? [], {
-      name: "xterm-color",
-      cwd,
-      env: buildSpawnEnv(ctx, opts.env),
-      cols: opts.cols ?? 80,
-      rows: opts.rows ?? 24
-    });
+    let proc;
+    try {
+      proc = spawnPty(opts.command, opts.args ?? [], {
+        name: "xterm-color",
+        cwd,
+        env: buildSpawnEnv(ctx, opts.env),
+        cols: opts.cols ?? 80,
+        rows: opts.rows ?? 24
+      });
+    } catch (err) {
+      throw explainSpawnFailure(err);
+    }
     const buffer = new RingBuffer(MAX_BUFFER_SIZE2);
     const session = {
       proc,
@@ -31756,6 +32246,18 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     });
     return session;
   }
+  function explainSpawnFailure(err) {
+    const original = err instanceof Error ? err : new Error(String(err));
+    let problems;
+    try {
+      problems = installProblems2();
+    } catch {
+      return original;
+    }
+    if (problems.length === 0) return original;
+    const why = problems.map((p) => `${p.detail} Fix: ${p.fix}`).join(" ");
+    return new Error(`${original.message} ${why}`, { cause: original });
+  }
   function reap(session, exitCode, signal) {
     if (sessions.get(session.id) !== session) return;
     sessions.delete(session.id);
@@ -31938,6 +32440,20 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     const alive = await probeBackgroundJobs(pid, params.jobs);
     return alive === null ? { ok: true, supported: false, alive: [] } : { ok: true, supported: true, alive };
   }
+  async function doctor(rawParams) {
+    const params = ptyDoctorParamsSchema.parse(rawParams);
+    await options.pathReady;
+    const env = buildSpawnEnv(ctx);
+    const binaries = await Promise.all(
+      params.binaries.map(async (binary) => ({ binary, path: await findOnPath(binary, env) }))
+    );
+    return {
+      ok: true,
+      problems: installProblems2(),
+      shellExists: shellExists(params.shell),
+      binaries
+    };
+  }
   function dropQueued(reason) {
     for (const id of [...queued.keys()]) cancelQueued(id, reason);
   }
@@ -32117,6 +32633,7 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
     [HubToComputerMethods.ptyList]: list,
     [HubToComputerMethods.ptyPrioritize]: prioritize,
     [HubToComputerMethods.ptyBackgroundJobs]: backgroundJobs,
+    [HubToComputerMethods.ptyDoctor]: doctor,
     [HubToComputerMethods.ptyWarmSpawn]: warmSpawn,
     [HubToComputerMethods.ptyWarmAdopt]: warmAdopt,
     [HubToComputerMethods.ptyWarmKill]: warmKill,
@@ -32126,19 +32643,19 @@ function createPtyHandlers(ctx, getProjectPaths, options = {}) {
 }
 
 // src/handlers/computer-config.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path15 = require("node:path");
 function canonicalRoots(roots) {
   const applied = [];
   const rejected = [];
   for (const root of roots) {
-    if (!(0, import_node_path12.isAbsolute)(root)) {
+    if (!(0, import_node_path15.isAbsolute)(root)) {
       rejected.push({ path: root, reason: "not an absolute path" });
       continue;
     }
     let real;
     try {
-      real = import_node_fs10.realpathSync.native((0, import_node_path12.resolve)(root));
+      real = import_node_fs13.realpathSync.native((0, import_node_path15.resolve)(root));
     } catch {
       rejected.push({ path: root, reason: "does not exist on this computer" });
       continue;
@@ -32183,12 +32700,13 @@ function createComputerConfigHandlers(ctx) {
 
 // src/project-paths.ts
 var import_promises10 = require("node:fs/promises");
-var import_node_os8 = require("node:os");
-var import_node_path13 = require("node:path");
+var import_node_crypto3 = require("node:crypto");
+var import_node_os9 = 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_os8.homedir)();
-  return (0, import_node_path13.join)(home, ".slayzone");
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? (0, import_node_os9.homedir)();
+  return (0, import_node_path16.join)(home, ".slayzone");
 }
 var projectPathEntrySchema = external_exports.object({
   /** Absolute, realpath-resolved at write time. */
@@ -32197,7 +32715,7 @@ var projectPathEntrySchema = external_exports.object({
 });
 var projectMapSchema = external_exports.record(external_exports.string(), projectPathEntrySchema);
 function projectsFilePath(baseDir) {
-  return (0, import_node_path13.join)(baseDir ?? slayzoneRootDir3(), "computer.projects.json");
+  return (0, import_node_path16.join)(baseDir ?? slayzoneRootDir3(), "computer.projects.json");
 }
 var fileSchema = external_exports.record(external_exports.string(), projectMapSchema);
 async function readFileMap(filePath) {
@@ -32228,8 +32746,8 @@ async function readFileMap(filePath) {
   return fileSchema.parse(out);
 }
 async function writeFileMap(filePath, map2) {
-  await (0, import_promises10.mkdir)((0, import_node_path13.dirname)(filePath), { recursive: true, mode: 448 });
-  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  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)()}`;
   await (0, import_promises10.writeFile)(tmpPath, `${JSON.stringify(map2, null, 2)}
 `, { mode: 384 });
   try {
@@ -32239,6 +32757,16 @@ async function writeFileMap(filePath, map2) {
     throw err;
   }
 }
+var writeQueues = /* @__PURE__ */ new Map();
+function serialized(filePath, write) {
+  const previous = writeQueues.get(filePath) ?? Promise.resolve();
+  const next = previous.then(write, write);
+  writeQueues.set(
+    filePath,
+    next.catch(() => void 0)
+  );
+  return next;
+}
 async function createProjectPathStore(hubHost, options = {}) {
   if (!hubHost.trim()) throw new Error(`invalid hub host for project map: '${hubHost}'`);
   const filePath = projectsFilePath(options.baseDir);
@@ -32248,21 +32776,25 @@ async function createProjectPathStore(hubHost, options = {}) {
     get(projectId) {
       return cache[projectId] ?? null;
     },
-    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);
-      cache = all[hubHost];
-      return entry;
+    set(projectId, path11) {
+      return serialized(filePath, async () => {
+        const entry = { path: path11, updatedAt: Date.now() };
+        const all = await readFileMap(filePath);
+        all[hubHost] = { ...all[hubHost] ?? {}, [projectId]: entry };
+        await writeFileMap(filePath, all);
+        cache = all[hubHost];
+        return entry;
+      });
     },
-    async forget(projectId) {
-      const all = await readFileMap(filePath);
-      const forHub = { ...all[hubHost] ?? {} };
-      delete forHub[projectId];
-      all[hubHost] = forHub;
-      await writeFileMap(filePath, all);
-      cache = forHub;
+    forget(projectId) {
+      return serialized(filePath, async () => {
+        const all = await readFileMap(filePath);
+        const forHub = { ...all[hubHost] ?? {} };
+        delete forHub[projectId];
+        all[hubHost] = forHub;
+        await writeFileMap(filePath, all);
+        cache = forHub;
+      });
     },
     list() {
       return Object.entries(cache).map(([projectId, entry]) => ({ projectId, ...entry }));
@@ -32282,13 +32814,16 @@ function createHubRequestHandler(deps2) {
     ...deps2.agentHookUrl ? { agentHookUrl: deps2.agentHookUrl } : {},
     ...deps2.hubAddress ? { hubAddress: deps2.hubAddress } : {}
   };
-  const pty2 = createPtyHandlers(
+  const pty2 = createPtyHandlers(ctx, deps2.getProjectPaths, {
+    ...deps2.admission ? { admission: deps2.admission } : {},
+    ...deps2.pathReady ? { pathReady: deps2.pathReady } : {}
+  });
+  const proc = createProcHandlers(
     ctx,
     deps2.getProjectPaths,
     deps2.admission ? { admission: deps2.admission } : {}
   );
-  const proc = createProcHandlers(ctx, deps2.getProjectPaths);
-  const fs7 = createFsHandlers(ctx);
+  const fs8 = createFsHandlers(ctx);
   const shutdownHandler = async (params) => {
     const parsed = computerShutdownParamsSchema.safeParse(params ?? {});
     const reason = parsed.success ? parsed.data.reason ?? "hub-requested" : "hub-requested";
@@ -32300,9 +32835,10 @@ function createHubRequestHandler(deps2) {
     ...pty2.handlers,
     ...proc.handlers,
     ...createGitHandlers(ctx),
-    ...fs7.handlers,
+    ...fs8.handlers,
     ...createComputerConfigHandlers(ctx),
     ...createGhHandlers(ctx),
+    ...createClaudeSessionHandlers(ctx, deps2.getProjectPaths ?? (() => null)),
     ...createProjectHandlers(ctx, deps2.getProjectPaths ?? (() => null))
   };
   const hub = deps2.hubHost ?? "unknown";
@@ -32360,7 +32896,7 @@ function createHubRequestHandler(deps2) {
   const dispose = () => {
     pty2.disposeAll();
     proc.disposeAll();
-    fs7.disposeAll();
+    fs8.disposeAll();
   };
   const setAgentHookUrl = (url2) => {
     ctx.agentHookUrl = url2;
@@ -32389,14 +32925,14 @@ function startComputer(config2, deps2 = {}) {
     });
   });
   let handle;
-  const stateDir = deps2.stateDir ?? (0, import_node_path14.dirname)(getComputerConfigFilePath());
-  const configFile = (0, import_node_path14.join)(stateDir, "computer.config.json");
+  const stateDir = deps2.stateDir ?? (0, import_node_path17.dirname)(getComputerConfigFilePath());
+  const configFile = (0, import_node_path17.join)(stateDir, "computer.config.json");
   setProtectedPaths([
     configFile,
     // The legacy file computer.config.json falls back to when absent.
-    (0, import_node_path14.join)(stateDir, "config.json"),
+    (0, import_node_path17.join)(stateDir, "config.json"),
     credentialsFilePath(stateDir),
-    (0, import_node_path14.join)(stateDir, REQUEST_LOG_DIR_NAME)
+    (0, import_node_path17.join)(stateDir, REQUEST_LOG_DIR_NAME)
   ]);
   const requestLog = createRequestLog({
     stateDir,
@@ -32405,7 +32941,7 @@ function startComputer(config2, deps2 = {}) {
   log("local request log", { file: requestLog.filePath });
   const watchLocalRoots = !config2.hubMayEditRoots;
   if (watchLocalRoots) {
-    (0, import_node_fs11.watchFile)(configFile, { interval: 2e3, persistent: false }, () => {
+    (0, import_node_fs14.watchFile)(configFile, { interval: 2e3, persistent: false }, () => {
       const declared = loadComputerConfigFile(configFile).allowedRoots;
       const applied = reloadLocalRoots(config2, declared);
       if (!applied) return;
@@ -32505,7 +33041,7 @@ function startComputer(config2, deps2 = {}) {
     dialers: connections.map((c) => c.dialer),
     stop: async () => {
       hostIdStop?.();
-      if (watchLocalRoots) (0, import_node_fs11.unwatchFile)(configFile);
+      if (watchLocalRoots) (0, import_node_fs14.unwatchFile)(configFile);
       await Promise.all(connections.map((c) => c.dispose()));
     }
   };
@@ -32547,7 +33083,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_path15.delimiter) } : null;
+          return roots.length > 0 ? { config: roots, env: roots.join(import_node_path18.delimiter) } : null;
         }
       },
       {
@@ -32559,7 +33095,7 @@ async function maybeInteractiveSetup() {
         configKey: "computerName",
         envKey: "SLAYZONE_COMPUTER_NAME",
         label: "Computer display name",
-        hint: `default: ${(0, import_node_os9.hostname)()}`
+        hint: `default: ${(0, import_node_os10.hostname)()}`
       }
     ]
   });