@corenel/sidecar 0.3.2 → 0.4.1

package/dist/cli.js

@@ -1184,8 +1184,8 @@ var require_stringifyString = __commonJS({
             case "u":
               {
                 str8 += json.slice(start, i2);
-                const code = json.substr(i2 + 2, 4);
-                switch (code) {
+                const code2 = json.substr(i2 + 2, 4);
+                switch (code2) {
                   case "0000":
                     str8 += "\\0";
                     break;
@@ -1211,8 +1211,8 @@ var require_stringifyString = __commonJS({
                     str8 += "\\P";
                     break;
                   default:
-                    if (code.substr(0, 2) === "00")
-                      str8 += "\\x" + code.substr(2);
+                    if (code2.substr(0, 2) === "00")
+                      str8 += "\\x" + code2.substr(2);
                     else
                       str8 += json.substr(i2, 6);
                 }
@@ -3711,22 +3711,22 @@ var require_errors = __commonJS({
   "../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/errors.js"(exports) {
     "use strict";
     var YAMLError = class extends Error {
-      constructor(name, pos, code, message) {
+      constructor(name, pos, code2, message) {
         super();
         this.name = name;
-        this.code = code;
+        this.code = code2;
         this.message = message;
         this.pos = pos;
       }
     };
     var YAMLParseError = class extends YAMLError {
-      constructor(pos, code, message) {
-        super("YAMLParseError", pos, code, message);
+      constructor(pos, code2, message) {
+        super("YAMLParseError", pos, code2, message);
       }
     };
     var YAMLWarning = class extends YAMLError {
-      constructor(pos, code, message) {
-        super("YAMLWarning", pos, code, message);
+      constructor(pos, code2, message) {
+        super("YAMLWarning", pos, code2, message);
       }
     };
     var prettifyError = (src, lc) => (error) => {
@@ -4632,7 +4632,7 @@ var require_resolve_flow_scalar = __commonJS({
       const { offset, type, source, end } = scalar;
       let _type;
       let value;
-      const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
+      const _onError = (rel, code2, msg) => onError(offset + rel, code2, msg);
       switch (type) {
         case "scalar":
           _type = Scalar.Scalar.PLAIN;
@@ -4827,9 +4827,9 @@ var require_resolve_flow_scalar = __commonJS({
     function parseCharCode(source, offset, length, onError) {
       const cc = source.substr(offset, length);
       const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
-      const code = ok ? parseInt(cc, 16) : NaN;
+      const code2 = ok ? parseInt(cc, 16) : NaN;
       try {
-        return String.fromCodePoint(code);
+        return String.fromCodePoint(code2);
       } catch {
         const raw = source.substr(offset - 2, length + 2);
         onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
@@ -5151,12 +5151,12 @@ var require_composer = __commonJS({
         this.prelude = [];
         this.errors = [];
         this.warnings = [];
-        this.onError = (source, code, message, warning) => {
+        this.onError = (source, code2, message, warning) => {
           const pos = getErrorPos(source);
           if (warning)
-            this.warnings.push(new errors.YAMLWarning(pos, code, message));
+            this.warnings.push(new errors.YAMLWarning(pos, code2, message));
           else
-            this.errors.push(new errors.YAMLParseError(pos, code, message));
+            this.errors.push(new errors.YAMLParseError(pos, code2, message));
         };
         this.directives = new directives.Directives({ version: options.version || "1.2" });
         this.options = options;
@@ -5318,12 +5318,12 @@ var require_cst_scalar = __commonJS({
     var stringifyString = require_stringifyString();
     function resolveAsScalar(token, strict = true, onError) {
       if (token) {
-        const _onError = (pos, code, message) => {
+        const _onError = (pos, code2, message) => {
           const offset = typeof pos === "number" ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
           if (onError)
-            onError(offset, code, message);
+            onError(offset, code2, message);
           else
-            throw new errors.YAMLParseError([offset, offset + 1], code, message);
+            throw new errors.YAMLParseError([offset, offset + 1], code2, message);
         };
         switch (token.type) {
           case "scalar":
@@ -6904,14 +6904,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs13 = this.flowScalar(this.type);
+              const fs15 = this.flowScalar(this.type);
               if (atNextItem || it2.value) {
-                map.items.push({ start, key: fs13, sep: [] });
+                map.items.push({ start, key: fs15, sep: [] });
                 this.onKeyLine = true;
               } else if (it2.sep) {
-                this.stack.push(fs13);
+                this.stack.push(fs15);
               } else {
-                Object.assign(it2, { key: fs13, sep: [] });
+                Object.assign(it2, { key: fs15, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7039,13 +7039,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs13 = this.flowScalar(this.type);
+              const fs15 = this.flowScalar(this.type);
               if (!it2 || it2.value)
-                fc.items.push({ start: [], key: fs13, sep: [] });
+                fc.items.push({ start: [], key: fs15, sep: [] });
               else if (it2.sep)
-                this.stack.push(fs13);
+                this.stack.push(fs15);
               else
-                Object.assign(it2, { key: fs13, sep: [] });
+                Object.assign(it2, { key: fs15, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -12248,11 +12248,11 @@ var require_compiler = __commonJS({
       _proto._popBuffer = function _popBuffer() {
         this.buffer = this.bufferStack.pop();
       };
-      _proto._emit = function _emit(code) {
-        this.codebuf.push(code);
+      _proto._emit = function _emit(code2) {
+        this.codebuf.push(code2);
       };
-      _proto._emitLine = function _emitLine(code) {
-        this._emit(code + "\n");
+      _proto._emitLine = function _emitLine(code2) {
+        this._emit(code2 + "\n");
       };
       _proto._emitLines = function _emitLines() {
         var _this = this;
@@ -13268,7 +13268,7 @@ var require_filters = __commonJS({
       return r2.copySafeness(str8, res);
     }
     _exports.indent = indent;
-    function join14(arr, del2, attr) {
+    function join16(arr, del2, attr) {
       del2 = del2 || "";
       if (attr) {
         arr = lib.map(arr, function(v2) {
@@ -13277,7 +13277,7 @@ var require_filters = __commonJS({
       }
       return arr.join(del2);
     }
-    _exports.join = join14;
+    _exports.join = join16;
     function last(arr) {
       return arr[arr.length - 1];
     }
@@ -13711,7 +13711,7 @@ var require_node_loaders = __commonJS({
       };
       return _setPrototypeOf(o2, p2);
     }
-    var fs13 = __require("fs");
+    var fs15 = __require("fs");
     var path = __require("path");
     var Loader2 = require_loader();
     var _require = require_precompiled_loader();
@@ -13740,7 +13740,7 @@ var require_node_loaders = __commonJS({
           } catch (e2) {
             throw new Error("watch requires chokidar to be installed");
           }
-          var paths = _this.searchPaths.filter(fs13.existsSync);
+          var paths = _this.searchPaths.filter(fs15.existsSync);
           var watcher = chokidar.watch(paths);
           watcher.on("all", function(event, fullname) {
             fullname = path.resolve(fullname);
@@ -13761,7 +13761,7 @@ var require_node_loaders = __commonJS({
         for (var i2 = 0; i2 < paths.length; i2++) {
           var basePath = path.resolve(paths[i2]);
           var p2 = path.resolve(paths[i2], name);
-          if (p2.indexOf(basePath) === 0 && fs13.existsSync(p2)) {
+          if (p2.indexOf(basePath) === 0 && fs15.existsSync(p2)) {
             fullpath = p2;
             break;
           }
@@ -13771,7 +13771,7 @@ var require_node_loaders = __commonJS({
         }
         this.pathsToNames[fullpath] = name;
         var source = {
-          src: fs13.readFileSync(fullpath, "utf-8"),
+          src: fs15.readFileSync(fullpath, "utf-8"),
           path: fullpath,
           noCache: this.noCache
         };
@@ -13823,7 +13823,7 @@ var require_node_loaders = __commonJS({
         }
         this.pathsToNames[fullpath] = name;
         var source = {
-          src: fs13.readFileSync(fullpath, "utf-8"),
+          src: fs15.readFileSync(fullpath, "utf-8"),
           path: fullpath,
           noCache: this.noCache
         };
@@ -14580,7 +14580,7 @@ var require_precompile_global = __commonJS({
 var require_precompile = __commonJS({
   "../../node_modules/.pnpm/nunjucks@3.2.4/node_modules/nunjucks/src/precompile.js"(exports, module) {
     "use strict";
-    var fs13 = __require("fs");
+    var fs15 = __require("fs");
     var path = __require("path");
     var _require = require_lib();
     var _prettifyError = _require._prettifyError;
@@ -14613,14 +14613,14 @@ var require_precompile = __commonJS({
       if (opts.isString) {
         return precompileString(input, opts);
       }
-      var pathStats = fs13.existsSync(input) && fs13.statSync(input);
+      var pathStats = fs15.existsSync(input) && fs15.statSync(input);
       var precompiled = [];
       var templates = [];
       function addTemplates(dir) {
-        fs13.readdirSync(dir).forEach(function(file) {
+        fs15.readdirSync(dir).forEach(function(file) {
           var filepath = path.join(dir, file);
           var subpath = filepath.substr(path.join(input, "/").length);
-          var stat2 = fs13.statSync(filepath);
+          var stat2 = fs15.statSync(filepath);
           if (stat2 && stat2.isDirectory()) {
             subpath += "/";
             if (!match(subpath, opts.exclude)) {
@@ -14632,13 +14632,13 @@ var require_precompile = __commonJS({
         });
       }
       if (pathStats.isFile()) {
-        precompiled.push(_precompile(fs13.readFileSync(input, "utf-8"), opts.name || input, env));
+        precompiled.push(_precompile(fs15.readFileSync(input, "utf-8"), opts.name || input, env));
       } else if (pathStats.isDirectory()) {
         addTemplates(input);
         for (var i2 = 0; i2 < templates.length; i2++) {
           var name = templates[i2].replace(path.join(input, "/"), "");
           try {
-            precompiled.push(_precompile(fs13.readFileSync(templates[i2], "utf-8"), name, env));
+            precompiled.push(_precompile(fs15.readFileSync(templates[i2], "utf-8"), name, env));
           } catch (e2) {
             if (opts.force) {
               console.error(e2);
@@ -18032,8 +18032,8 @@ var require_lib3 = __commonJS({
         stream.end();
       }
     }
-    fetch3.isRedirect = function(code) {
-      return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
+    fetch3.isRedirect = function(code2) {
+      return code2 === 301 || code2 === 302 || code2 === 303 || code2 === 307 || code2 === 308;
     };
     fetch3.Promise = global.Promise;
     module.exports = exports = fetch3;
@@ -21357,7 +21357,7 @@ __export(fileFromPath_exports, {
   fileFromPathSync: () => fileFromPathSync,
   isFile: () => isFile
 });
-import { statSync, createReadStream, promises as fs7 } from "fs";
+import { statSync, createReadStream, promises as fs9 } from "fs";
 import { basename as basename2 } from "path";
 function createFileFromPath(path, { mtimeMs, size }, filenameOrOptions, options = {}) {
   let filename;
@@ -21380,7 +21380,7 @@ function fileFromPathSync(path, filenameOrOptions, options = {}) {
   return createFileFromPath(path, stats, filenameOrOptions, options);
 }
 async function fileFromPath2(path, filenameOrOptions, options) {
-  const stats = await fs7.stat(path);
+  const stats = await fs9.stat(path);
   return createFileFromPath(path, stats, filenameOrOptions, options);
 }
 var import_node_domexception, __classPrivateFieldSet4, __classPrivateFieldGet5, _FileFromPath_path, _FileFromPath_start, MESSAGE, FileFromPath;
@@ -21421,7 +21421,7 @@ var init_fileFromPath = __esm({
         });
       }
       async *stream() {
-        const { mtimeMs } = await fs7.stat(__classPrivateFieldGet5(this, _FileFromPath_path, "f"));
+        const { mtimeMs } = await fs9.stat(__classPrivateFieldGet5(this, _FileFromPath_path, "f"));
         if (mtimeMs > this.lastModified) {
           throw new import_node_domexception.default(MESSAGE, "NotReadableError");
         }
@@ -21440,7 +21440,7 @@ var init_fileFromPath = __esm({
 });
 
 // src/cli.ts
-import { join as join13 } from "node:path";
+import { join as join15 } from "node:path";
 import { readFileSync } from "node:fs";
 import { spawn as spawn9 } from "node:child_process";
 
@@ -21692,6 +21692,7 @@ var SidecarServer = class {
       case "session-destroy":
       case "session-commit":
       case "session-snapshots":
+      case "session-snapshot-usage":
       case "session-watch":
       case "session-unwatch":
         if (!this.authed) {
@@ -21877,6 +21878,11 @@ var SidecarServer = class {
           this.ch.send({ t: "session-snapshots-result", id, snapshots });
           return;
         }
+        case "session-snapshot-usage": {
+          const usage = sessions.snapshotUsage ? await sessions.snapshotUsage() : { usedBytes: 0, budgetBytes: 0, count: 0 };
+          this.ch.send({ t: "session-snapshot-usage-result", id, usage });
+          return;
+        }
         case "session-watch": {
           if (this.sessionWatch.has(m2.sessionId)) {
             this.ch.send({ t: "session-ok", id });
@@ -22035,7 +22041,11 @@ var SidecarServer = class {
       }, {
         ...m2.root ? { root: m2.root } : {},
         ...m2.modeId ? { modeId: m2.modeId } : {},
-        ...m2.resume ? { resume: m2.resume } : {}
+        ...m2.resume ? { resume: m2.resume } : {},
+        /* Passed through untouched. The daemon does not decide WHICH servers a
+         * user has -- the client does -- and the ACP client drops them if the
+         * agent never advertised mcpCapabilities.http. */
+        ...m2.mcpServers?.length ? { mcpServers: m2.mcpServers } : {}
       });
       this.ch.send({ t: "acp-started", id: m2.id, ...started });
     } catch (err) {
@@ -22331,10 +22341,18 @@ var SidecarServer = class {
   ask = (questions) => this.hostCall("ask", "ask", [questions]).then((v2) => v2, () => null);
 };
 
-// src/wsChannel.ts
+// ../harness/sidecar/wsChannel.ts
 function wsChannel(ws) {
   let handler = null;
   let closeHandler = null;
+  const pending = [];
+  const flushPending = () => {
+    if (ws.readyState !== ws.OPEN) return;
+    while (pending.length > 0) {
+      ws.send(JSON.stringify(pending.shift()));
+    }
+  };
+  ws.on("open", flushPending);
   ws.on("message", (data) => {
     if (!handler) return;
     try {
@@ -22348,7 +22366,11 @@ function wsChannel(ws) {
   });
   return {
     send(msg) {
-      if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
+      if (ws.readyState === ws.OPEN) {
+        ws.send(JSON.stringify(msg));
+      } else if (ws.readyState === ws.CONNECTING) {
+        pending.push(msg);
+      }
     },
     onMessage(h2) {
       handler = h2;
@@ -22489,16 +22511,79 @@ keeps serving your browser, so the restart would look successful and change noth
   }
 }
 
-// src/token.ts
+// src/pidFile.ts
 import { promises as fs } from "node:fs";
+import { join } from "node:path";
+function pidPath(dir) {
+  return join(dir, "daemon.pid");
+}
+function isAlive(pid, kill = process.kill) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    kill(pid, 0);
+    return true;
+  } catch (e2) {
+    return e2?.code === "EPERM";
+  }
+}
+async function readPidFile(dir) {
+  let raw;
+  try {
+    raw = await fs.readFile(pidPath(dir), "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const o2 = JSON.parse(raw);
+    if (!o2 || typeof o2 !== "object") return null;
+    const r2 = o2;
+    if (typeof r2.pid !== "number" || typeof r2.port !== "number") return null;
+    return { pid: r2.pid, port: r2.port, startedAt: typeof r2.startedAt === "number" ? r2.startedAt : 0 };
+  } catch {
+    return null;
+  }
+}
+async function assertStateDirFree(dir, now2 = Date.now()) {
+  const rec5 = await readPidFile(dir);
+  if (!rec5 || !isAlive(rec5.pid)) return;
+  const mins = rec5.startedAt ? Math.max(0, Math.round((now2 - rec5.startedAt) / 6e4)) : null;
+  const age = mins === null ? "" : ` (started ${mins}m ago)`;
+  throw new Error(
+    `another sidecar is already using this state dir \u2014 pid ${rec5.pid} on port ${rec5.port}${age}.
+Two daemons sharing a state dir share their IDENTITY: they read the same daemon.id and
+advertise the same sidecarId, so a paired browser sees one sidecar, one sync baseline and
+one working folder for what are really several machines' worth of state.
+Run this one with its own --state-dir <dir>, or stop the other first.`
+  );
+}
+async function writePidFile(dir, port, pid = process.pid, now2 = Date.now()) {
+  await fs.mkdir(dir, { recursive: true });
+  const rec5 = { pid, port, startedAt: now2 };
+  await fs.writeFile(pidPath(dir), `${JSON.stringify(rec5)}
+`, { mode: 384 });
+}
+async function clearPidFile(dir, pid = process.pid) {
+  const rec5 = await readPidFile(dir);
+  if (!rec5 || rec5.pid !== pid) return;
+  try {
+    await fs.rm(pidPath(dir), { force: true });
+  } catch {
+  }
+}
+
+// src/token.ts
+import { promises as fs2 } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 function corenelDir() {
-  return join(homedir(), stateDirName());
+  return join2(homedir(), stateDirName());
+}
+function sidecarSubdir(stateDir = corenelDir()) {
+  return join2(stateDir, "sidecar");
 }
 function tokenPath() {
-  return join(corenelDir(), "daemon.token");
+  return join2(sidecarSubdir(), "daemon.token");
 }
 function isEnoent(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
@@ -22506,16 +22591,16 @@ function isEnoent(err) {
 async function loadOrCreateToken() {
   const path = tokenPath();
   try {
-    const existing = (await fs.readFile(path, "utf8")).trim();
+    const existing = (await fs2.readFile(path, "utf8")).trim();
     if (existing) return existing;
   } catch (err) {
     if (!isEnoent(err)) throw err;
   }
-  await fs.mkdir(corenelDir(), { recursive: true });
+  await fs2.mkdir(sidecarSubdir(), { recursive: true });
   const token = randomBytes(32).toString("hex");
-  await fs.writeFile(path, token + "\n", { mode: 384 });
+  await fs2.writeFile(path, token + "\n", { mode: 384 });
   try {
-    await fs.chmod(path, 384);
+    await fs2.chmod(path, 384);
   } catch {
   }
   return token;
@@ -23124,10 +23209,10 @@ function makeFileMirrorSource(deps) {
   };
   const readText = async (path) => {
     if (!path) return "";
-    const fs13 = await deps.files();
-    if (!fs13) return "";
+    const fs15 = await deps.files();
+    if (!fs15) return "";
     try {
-      return await fs13.read(path);
+      return await fs15.read(path);
     } catch {
       return "";
     }
@@ -23155,28 +23240,28 @@ function makeFileMirrorSource(deps) {
 }
 
 // src/auth/store.ts
-import { promises as fs2 } from "node:fs";
+import { promises as fs3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 var TOKEN_ENV = "CORENEL_TOKEN";
 function authDir(stateDir) {
-  return stateDir ?? join2(homedir2(), stateDirName());
+  return stateDir ?? join3(homedir2(), stateDirName());
 }
 function credentialPath(stateDir) {
-  return join2(authDir(stateDir), "auth.json");
+  return join3(authDir(stateDir), "auth.json");
 }
 async function saveCredential(cred, stateDir) {
   const path = credentialPath(stateDir);
-  await fs2.mkdir(authDir(stateDir), { recursive: true });
-  await fs2.writeFile(path, JSON.stringify(cred, null, 2) + "\n", { mode: 384 });
+  await fs3.mkdir(authDir(stateDir), { recursive: true });
+  await fs3.writeFile(path, JSON.stringify(cred, null, 2) + "\n", { mode: 384 });
   try {
-    await fs2.chmod(path, 384);
+    await fs3.chmod(path, 384);
   } catch {
   }
 }
 async function loadCredential(stateDir) {
   try {
-    const raw = await fs2.readFile(credentialPath(stateDir), "utf8");
+    const raw = await fs3.readFile(credentialPath(stateDir), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return null;
     const c2 = parsed;
@@ -23195,7 +23280,7 @@ async function loadCredential(stateDir) {
   }
 }
 async function clearCredential(stateDir) {
-  await fs2.rm(credentialPath(stateDir), { force: true });
+  await fs3.rm(credentialPath(stateDir), { force: true });
 }
 async function resolveCredential(env = process.env, stateDir, now2 = Date.now) {
   const fromEnv = env[TOKEN_ENV]?.trim();
@@ -23247,7 +23332,7 @@ function makeControlPlane(deps) {
 }
 
 // src/tools.ts
-import { promises as fs3 } from "node:fs";
+import { promises as fs4 } from "node:fs";
 import { spawn } from "node:child_process";
 import { resolve, relative, isAbsolute, sep, dirname } from "node:path";
 function withinRoot(root, abs) {
@@ -23264,11 +23349,11 @@ function confine(roots, rootArg, p2) {
   return abs;
 }
 async function assertRealWithinRoot(roots, abs) {
-  const realRoots = await Promise.all(roots.map((r2) => fs3.realpath(r2)));
+  const realRoots = await Promise.all(roots.map((r2) => fs4.realpath(r2)));
   let probe = abs;
   for (; ; ) {
     try {
-      const real = await fs3.realpath(probe);
+      const real = await fs4.realpath(probe);
       if (!realRoots.some((rr2) => withinRoot(rr2, real))) throw new Error(`path escapes the sidecar roots via symlink: ${abs}`);
       return;
     } catch (e2) {
@@ -23296,11 +23381,11 @@ function nodeFsTools(roots) {
       async run(args) {
         const abs = confine(roots, args.root, String(args.path ?? ""));
         await assertRealWithinRoot(roots, abs);
-        const st2 = await fs3.stat(abs);
+        const st2 = await fs4.stat(abs);
         if (st2.size > MAX_READ_BYTES) {
           throw new Error(`file too large to read (${st2.size} bytes; max ${MAX_READ_BYTES})`);
         }
-        return await fs3.readFile(abs, "utf8");
+        return await fs4.readFile(abs, "utf8");
       }
     },
     {
@@ -23320,9 +23405,9 @@ function nodeFsTools(roots) {
       mutates: true,
       async run(args) {
         const abs = confine(roots, args.root, String(args.path ?? ""));
-        await fs3.mkdir(dirname(abs), { recursive: true });
+        await fs4.mkdir(dirname(abs), { recursive: true });
         await assertRealWithinRoot(roots, abs);
-        await fs3.writeFile(abs, String(args.content ?? ""), "utf8");
+        await fs4.writeFile(abs, String(args.content ?? ""), "utf8");
         return `wrote ${args.path}`;
       }
     },
@@ -23339,11 +23424,11 @@ function nodeFsTools(roots) {
       async run(args) {
         const abs = confine(roots, args.root, String(args.path ?? ""));
         await assertRealWithinRoot(roots, abs);
-        const st2 = await fs3.stat(abs);
+        const st2 = await fs4.stat(abs);
         if (st2.size > MAX_READ_BYTES) {
           throw new Error(`file too large to read (${st2.size} bytes; max ${MAX_READ_BYTES})`);
         }
-        return (await fs3.readFile(abs)).toString("base64");
+        return (await fs4.readFile(abs)).toString("base64");
       }
     },
     {
@@ -23358,7 +23443,7 @@ function nodeFsTools(roots) {
       async run(args) {
         const abs = confine(roots, args.root, String(args.path ?? "."));
         await assertRealWithinRoot(roots, abs);
-        const entries = await fs3.readdir(abs, { withFileTypes: true });
+        const entries = await fs4.readdir(abs, { withFileTypes: true });
         return entries.map((e2) => e2.isDirectory() ? `${e2.name}/` : e2.name).join("\n");
       }
     },
@@ -23377,7 +23462,7 @@ function nodeFsTools(roots) {
         const abs = confine(roots, args.root, String(args.path ?? ""));
         await assertRealWithinRoot(roots, abs);
         if (roots.some((r2) => resolve(r2) === abs)) throw new Error("refusing to delete a sidecar root itself");
-        await fs3.rm(abs, { recursive: true, force: true });
+        await fs4.rm(abs, { recursive: true, force: true });
         return `deleted ${args.path}`;
       }
     }
@@ -23440,9 +23525,9 @@ function runShell(command, cwd, timeout) {
       clearTimeout(timer);
       resolveOut(`Error: failed to start command: ${e2 instanceof Error ? e2.message : String(e2)}`);
     });
-    child.on("close", (code, signal) => {
+    child.on("close", (code2, signal) => {
       clearTimeout(timer);
-      const status = timedOut ? `timed out after ${timeout}ms (killed)` : `exit ${code ?? "null"}${signal ? ` (signal ${signal})` : ""}`;
+      const status = timedOut ? `timed out after ${timeout}ms (killed)` : `exit ${code2 ?? "null"}${signal ? ` (signal ${signal})` : ""}`;
       const body = out.trim() || "(no output)";
       resolveOut(`${status}
 ${truncated ? "[output truncated]\n" : ""}${body}`);
@@ -23516,20 +23601,20 @@ function createNodeProcs(opts) {
       opts.log?.(`proc ${info.procId} spawn: ${line}`);
       child.stdout.on("data", (b2) => push2(entry, "out", b2.toString("utf8")));
       child.stderr.on("data", (b2) => push2(entry, "err", b2.toString("utf8")));
-      const settle = (code, signal, failure) => {
+      const settle = (code2, signal, failure) => {
         if (!entry.info.running) return;
         if (failure) push2(entry, "err", failure);
         entry.info.running = false;
         entry.info.endedAt = Date.now();
-        entry.info.exitCode = code;
+        entry.info.exitCode = code2;
         if (signal) entry.info.signal = signal;
         entry.child = null;
-        opts.log?.(`proc ${entry.info.procId} exit ${code ?? "null"}${signal ? ` (${signal})` : ""}`);
+        opts.log?.(`proc ${entry.info.procId} exit ${code2 ?? "null"}${signal ? ` (${signal})` : ""}`);
         emit({ procId: entry.info.procId, kind: "exit", info: { ...entry.info } });
         evictExited();
       };
       child.on("error", (err) => settle(null, null, `failed to start: ${err instanceof Error ? err.message : String(err)}`));
-      child.on("close", (code, signal) => settle(code, signal));
+      child.on("close", (code2, signal) => settle(code2, signal));
       return { ...info };
     },
     list() {
@@ -23605,22 +23690,22 @@ function isNotFound(e2) {
   const msg = String(e2?.message ?? e2);
   return name === "NotFoundError" || /not\s*found|no such|enoent/i.test(msg);
 }
-function fileServicePackageStore(fs13) {
-  const remove = (path) => fs13.remove(path).catch((e2) => {
+function fileServicePackageStore(fs15) {
+  const remove = (path) => fs15.remove(path).catch((e2) => {
     if (!isNotFound(e2)) throw e2;
   });
   return {
-    writeFile: (path, content) => fs13.write(path, content),
+    writeFile: (path, content) => fs15.write(path, content),
     // Present only when the backend supports binary — core feature-detects it,
     // and advertising a method that throws is worse than not advertising it.
-    ...fs13.writeBytes ? { writeBytes: (path, bytes) => fs13.writeBytes(path, bytes) } : {},
+    ...fs15.writeBytes ? { writeBytes: (path, bytes) => fs15.writeBytes(path, bytes) } : {},
     removeDir: remove,
     removeFile: remove,
-    readFile: (path) => fs13.read(path).catch(() => null),
-    ...fs13.readBytes ? { readBytes: (path) => fs13.readBytes(path) } : {},
+    readFile: (path) => fs15.read(path).catch(() => null),
+    ...fs15.readBytes ? { readBytes: (path) => fs15.readBytes(path) } : {},
     readdir: async (path) => {
       try {
-        const nodes = fs13.listDir ? await fs13.listDir(path) : await fs13.list(path);
+        const nodes = fs15.listDir ? await fs15.listDir(path) : await fs15.list(path);
         return nodes.map((n2) => n2.name);
       } catch {
         return [];
@@ -23722,9 +23807,9 @@ var SessionPackages = class {
     return !!this.deps.installer;
   }
   async filesOrThrow(sessionId) {
-    const fs13 = await this.deps.filesFor(sessionId);
-    if (!fs13) throw new Error(`no such session: ${sessionId}`);
-    return fs13;
+    const fs15 = await this.deps.filesFor(sessionId);
+    if (!fs15) throw new Error(`no such session: ${sessionId}`);
+    return fs15;
   }
   installerOrThrow() {
     const i2 = this.deps.installer;
@@ -23732,13 +23817,13 @@ var SessionPackages = class {
     return i2;
   }
   async readLock(sessionId) {
-    const fs13 = await this.filesOrThrow(sessionId);
-    const text = await fs13.read(LOCKFILE_PATH).catch(() => null);
+    const fs15 = await this.filesOrThrow(sessionId);
+    const text = await fs15.read(LOCKFILE_PATH).catch(() => null);
     return (text != null ? parseLock(text) : null) ?? emptyLock();
   }
   async writeLock(sessionId, lock) {
-    const fs13 = await this.filesOrThrow(sessionId);
-    await fs13.write(LOCKFILE_PATH, serializeLock(lock));
+    const fs15 = await this.filesOrThrow(sessionId);
+    await fs15.write(LOCKFILE_PATH, serializeLock(lock));
   }
   /**
    * Install one package into the session and pin what resolved.
@@ -23749,11 +23834,11 @@ var SessionPackages = class {
    */
   async install(sessionId, ref, type) {
     const installer = this.installerOrThrow();
-    const fs13 = await this.filesOrThrow(sessionId);
+    const fs15 = await this.filesOrThrow(sessionId);
     const installed = await installer.install({
       ref,
       root: "",
-      store: fileServicePackageStore(fs13),
+      store: fileServicePackageStore(fs15),
       ...type ? { type } : {}
     });
     try {
@@ -23771,8 +23856,8 @@ var SessionPackages = class {
   }
   async uninstall(sessionId, ref) {
     const installer = this.installerOrThrow();
-    const fs13 = await this.filesOrThrow(sessionId);
-    await installer.uninstall({ ref, root: "", store: fileServicePackageStore(fs13) });
+    const fs15 = await this.filesOrThrow(sessionId);
+    await installer.uninstall({ ref, root: "", store: fileServicePackageStore(fs15) });
     const name = ref.replace(/@[^@/]*$/, "") || ref;
     try {
       await this.writeLock(sessionId, withoutPackage(await this.readLock(sessionId), name));
@@ -23789,9 +23874,9 @@ var SessionPackages = class {
    */
   async installFromLock(sessionId) {
     const installer = this.installerOrThrow();
-    const fs13 = await this.filesOrThrow(sessionId);
+    const fs15 = await this.filesOrThrow(sessionId);
     const lock = await this.readLock(sessionId);
-    const store = fileServicePackageStore(fs13);
+    const store = fileServicePackageStore(fs15);
     const done = [];
     for (const pin of lock.packages) {
       done.push(await installer.install({ ref: `${pin.name}@${pin.version}`, root: "", store }));
@@ -24050,9 +24135,36 @@ var SessionManager = class {
 import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3 } from "node:path";
 
 // ../tools-node/fileService.ts
-import { promises as fs4 } from "node:fs";
-import { join as join3, resolve as resolve2, relative as relative2, dirname as dirname2, sep as sep2, basename, isAbsolute as isAbsolute2 } from "node:path";
-var SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".cache", ".turbo"]);
+import { promises as fs5 } from "node:fs";
+import { join as join4, resolve as resolve2, relative as relative2, dirname as dirname2, sep as sep2, basename, isAbsolute as isAbsolute2 } from "node:path";
+var SKIP = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".cache",
+  ".turbo",
+  "dist-corenel",
+  "test-results",
+  "playwright-report"
+]);
+var SKIP_PATHS = /* @__PURE__ */ new Set([".claude/skills"]);
+var COVERAGE_REPORT_MARKERS = /* @__PURE__ */ new Set([
+  "coverage-final.json",
+  "lcov.info",
+  "clover.xml",
+  "coverage-summary.json",
+  "prettify.js"
+]);
+async function looksLikeGeneratedCoverage(absDir) {
+  try {
+    const names = await fs5.readdir(absDir);
+    return names.some((n2) => COVERAGE_REPORT_MARKERS.has(n2));
+  } catch {
+    return false;
+  }
+}
 function escapesRoot(rel, platformSep = sep2) {
   if (rel === "") return false;
   if (rel === ".." || rel.startsWith(".." + platformSep)) return true;
@@ -24090,11 +24202,11 @@ var NodeFileService = class {
    * root pointing outside it. Resolve the real path (or nearest existing ancestor,
    * for a not-yet-created write target) and assert it stays within the real root. */
   async assertReal(a2) {
-    const realRoot = await fs4.realpath(this.root);
+    const realRoot = await fs5.realpath(this.root);
     let probe = a2;
     for (; ; ) {
       try {
-        const real = await fs4.realpath(probe);
+        const real = await fs5.realpath(probe);
         const rel = relative2(realRoot, real);
         if (escapesRoot(rel)) {
           throw new Error(`path escapes the workspace root via symlink: ${a2}`);
@@ -24118,19 +24230,21 @@ var NodeFileService = class {
     const walk = async (absDir) => {
       let entries;
       try {
-        entries = await fs4.readdir(absDir, { withFileTypes: true });
+        entries = await fs5.readdir(absDir, { withFileTypes: true });
       } catch {
         return [];
       }
       const out = [];
       for (const e2 of entries.sort((a2, b2) => a2.name.localeCompare(b2.name))) {
         if (SKIP.has(e2.name)) continue;
-        const absChild = join3(absDir, e2.name);
+        const absChild = join4(absDir, e2.name);
         const path = normalizeFilePath(relative2(this.root, absChild));
+        if (e2.isDirectory() && SKIP_PATHS.has(path)) continue;
+        if (e2.isDirectory() && e2.name === "coverage" && await looksLikeGeneratedCoverage(absChild)) continue;
         if (e2.isDirectory()) {
           out.push({ name: e2.name, path, kind: "directory", children: await walk(absChild) });
         } else {
-          const st2 = await fs4.stat(absChild).catch(() => null);
+          const st2 = await fs5.stat(absChild).catch(() => null);
           out.push({ name: e2.name, path, kind: "file", size: st2?.size, ext: extOf(e2.name) });
         }
       }
@@ -24139,11 +24253,11 @@ var NodeFileService = class {
     return walk(this.abs(dir));
   }
   async read(path) {
-    return fs4.readFile(await this.realAbs(path), "utf8");
+    return fs5.readFile(await this.realAbs(path), "utf8");
   }
   async stat(path) {
     try {
-      const st2 = await fs4.stat(this.abs(path));
+      const st2 = await fs5.stat(this.abs(path));
       return { path: normalizeFilePath(path), kind: st2.isDirectory() ? "directory" : "file", size: st2.size, ext: extOf(path) };
     } catch {
       return null;
@@ -24151,38 +24265,38 @@ var NodeFileService = class {
   }
   async write(path, content) {
     const a2 = this.abs(path);
-    await fs4.mkdir(dirname2(a2), { recursive: true });
+    await fs5.mkdir(dirname2(a2), { recursive: true });
     await this.assertReal(a2);
-    await fs4.writeFile(a2, content, "utf8");
+    await fs5.writeFile(a2, content, "utf8");
   }
   async writeBytes(path, bytes) {
     const a2 = this.abs(path);
-    await fs4.mkdir(dirname2(a2), { recursive: true });
+    await fs5.mkdir(dirname2(a2), { recursive: true });
     await this.assertReal(a2);
-    await fs4.writeFile(a2, bytes);
+    await fs5.writeFile(a2, bytes);
   }
   async create(path, content = "") {
     const a2 = this.abs(path);
-    await fs4.mkdir(dirname2(a2), { recursive: true });
+    await fs5.mkdir(dirname2(a2), { recursive: true });
     await this.assertReal(a2);
     try {
-      await fs4.writeFile(a2, content, { flag: "wx" });
+      await fs5.writeFile(a2, content, { flag: "wx" });
     } catch (e2) {
       if (e2.code === "EEXIST") throw new Error(`already exists: ${path}`);
       throw e2;
     }
   }
   async remove(path) {
-    await fs4.rm(await this.realAbs(path), { recursive: true, force: true });
+    await fs5.rm(await this.realAbs(path), { recursive: true, force: true });
   }
   async rename(from, to) {
     const t2 = this.abs(to);
-    await fs4.mkdir(dirname2(t2), { recursive: true });
+    await fs5.mkdir(dirname2(t2), { recursive: true });
     await this.assertReal(t2);
-    await fs4.rename(await this.realAbs(from), t2);
+    await fs5.rename(await this.realAbs(from), t2);
   }
   async mkdir(path) {
-    await fs4.mkdir(this.abs(path), { recursive: true });
+    await fs5.mkdir(this.abs(path), { recursive: true });
   }
   async search(query) {
     const q2 = query.toLowerCase();
@@ -24382,13 +24496,13 @@ function makeMsbStreamer(bin, wrap) {
     const done = new Promise((r2) => {
       resolveDone = r2;
     });
-    const settle = (code) => {
+    const settle = (code2) => {
       if (settled) return;
       settled = true;
       for (const l2 of out.flush()) onLine(l2, "out");
       for (const l2 of err.flush()) onLine(l2, "err");
       clearTimeout(timer);
-      resolveDone({ code, stdout: "", stderr: stderrText });
+      resolveDone({ code: code2, stdout: "", stderr: stderrText });
     };
     const timer = opts?.timeoutMs === void 0 ? void 0 : setTimeout(() => {
       child.kill("SIGKILL");
@@ -24408,7 +24522,7 @@ function makeMsbStreamer(bin, wrap) {
 ${e2 instanceof Error ? e2.message : String(e2)}`;
       settle(-1);
     });
-    child.on("close", (code) => settle(code ?? -1));
+    child.on("close", (code2) => settle(code2 ?? -1));
     return {
       stop: () => {
         if (!settled) child.kill("SIGTERM");
@@ -24451,13 +24565,41 @@ msb timed out after ${opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS2}ms` });
       settle({ code: -1, stdout, stderr: `${stderr}
 ${e2 instanceof Error ? e2.message : String(e2)}` });
     });
-    child.on("close", (code) => {
+    child.on("close", (code2) => {
       clearTimeout(timer);
-      settle({ code: code ?? -1, stdout, stderr });
+      settle({ code: code2 ?? -1, stdout, stderr });
     });
   });
 }
 
+// src/session/snapshotBudget.ts
+var DEFAULT_SNAPSHOT_BUDGET_BYTES = 32 * 1024 ** 3;
+function parseByteSize(spelling) {
+  const s2 = spelling.trim();
+  const m2 = /^(\d+(?:\.\d+)?)\s*([KMGT]?)i?B?$/i.exec(s2);
+  if (!m2) throw new Error(`not a size: "${spelling}" (expected e.g. "8G", "512M", or a bare byte count)`);
+  const n2 = Number(m2[1]);
+  const unit = (m2[2] ?? "").toUpperCase();
+  const mult = unit === "K" ? 1024 : unit === "M" ? 1024 ** 2 : unit === "G" ? 1024 ** 3 : unit === "T" ? 1024 ** 4 : 1;
+  return Math.round(n2 * mult);
+}
+function formatByteSize(bytes) {
+  const units = [[1024 ** 4, "T"], [1024 ** 3, "G"], [1024 ** 2, "M"], [1024, "K"]];
+  for (const [mult, suffix] of units) {
+    if (bytes >= mult) return `${(bytes / mult).toFixed(1)}${suffix}`;
+  }
+  return `${bytes}B`;
+}
+function checkSnapshotBudget(check) {
+  const { usedBytes, estimateBytes, budgetBytes } = check;
+  const projected = usedBytes + estimateBytes;
+  if (projected <= budgetBytes) return { ok: true };
+  return {
+    ok: false,
+    message: `refusing to capture: session snapshots already use ${formatByteSize(usedBytes)} of a ${formatByteSize(budgetBytes)} budget, and this capture could add up to ${formatByteSize(estimateBytes)} more. Free space by removing snapshots you no longer need (\`msb snapshot list\`, \`msb snapshot remove <name>\`), or raise the ceiling with --snapshot-budget <size>.`
+  };
+}
+
 // src/session/microvmBackend.ts
 var GUEST_WORKDIR = "/workspace";
 var seq2 = 0;
@@ -24578,6 +24720,14 @@ function makeMicrovmBackend(deps) {
     }
     return r2.stdout;
   };
+  const listSnapshotsRaw = async () => {
+    const r2 = await deps.run(snapshotListArgs());
+    if (r2.code !== 0) {
+      const detail = (r2.stderr || r2.stdout).trim().split("\n").slice(-2).join("; ");
+      throw new Error(`list snapshots failed (msb exit ${r2.code}): ${detail || "no output"}`);
+    }
+    return parseSnapshotList(r2.stdout);
+  };
   let lastReconcile = 0;
   let reconciling = false;
   const RECONCILE_MS = 1e4;
@@ -24592,9 +24742,9 @@ function makeMicrovmBackend(deps) {
       if (!live.length) return;
       const r2 = await deps.run(listArgs());
       if (r2.code !== 0) return;
-      const present = new Set(parseSandboxList(r2.stdout).map((row) => row.name));
+      const present2 = new Set(parseSandboxList(r2.stdout).map((row) => row.name));
       for (const s2 of live) {
-        if (present.has(sandboxName(s2.id))) continue;
+        if (present2.has(sandboxName(s2.id))) continue;
         if (at2 - s2.createdAt < RECONCILE_MS) continue;
         sessions.delete(s2.id);
         deps.log?.(`session ${s2.id} ended outside this daemon (sandbox ${sandboxName(s2.id)} is gone) \u2014 dropped`);
@@ -24905,7 +25055,13 @@ function makeMicrovmBackend(deps) {
           workdir,
           createdAt: Number.isFinite(stamped) && stamped > 0 ? stamped : row.createdAt ?? now2(),
           ...owner ? { owner } : {},
-          ...repoUrl && repoCommit ? { source: { url: repoUrl, commit: repoCommit, ...repoRef ? { ref: repoRef } : {} } } : {}
+          ...repoUrl && repoCommit ? { source: { url: repoUrl, commit: repoCommit, ...repoRef ? { ref: repoRef } : {} } } : {},
+          /* THE ONLY PLACE THIS IS EVER SET TRUE. `create()` never touches it,
+           * so a card can tell "this daemon booted it" from "this daemon
+           * found it already running" — procs.ts's own words: a running
+           * process nobody can see is worse than one that died, and adoption
+           * used to be invisible past this log line. */
+          adopted: true
         });
         adopted.push(id);
       }
@@ -24944,6 +25100,12 @@ function makeMicrovmBackend(deps) {
           `session ${id} must be paused before it can be captured (it is "${s2.status}"): pause first and check the drain result, or the snapshot may be torn`
         );
       }
+      const existing = await listSnapshotsRaw();
+      const usedBytes = existing.reduce((sum, snap) => sum + (snap.sizeBytes ?? 0), 0);
+      const budgetBytes = deps.snapshotBudgetBytes ?? DEFAULT_SNAPSHOT_BUDGET_BYTES;
+      const estimateBytes = parseByteSize(limits.rootDisk);
+      const budget = checkSnapshotBudget({ usedBytes, estimateBytes, budgetBytes });
+      if (!budget.ok) throw new Error(budget.message);
       const snapName = name ?? `${sandboxName(id)}-${now2()}-${++snapSeq}`;
       await msb([
         "snapshot",
@@ -24975,12 +25137,19 @@ function makeMicrovmBackend(deps) {
      * memory would show nothing after a restart while the artifacts sat on
      * disk. */
     async snapshots() {
-      const r2 = await deps.run(snapshotListArgs());
-      if (r2.code !== 0) {
-        const detail = (r2.stderr || r2.stdout).trim().split("\n").slice(-2).join("; ");
-        throw new Error(`list snapshots failed (msb exit ${r2.code}): ${detail || "no output"}`);
-      }
-      return parseSnapshotList(r2.stdout);
+      return listSnapshotsRaw();
+    },
+    /** Current usage against the refuse-at-budget ceiling, BEFORE a capture
+     * ever hits it — a budget you only learn about at the moment it stops you
+     * is a bad budget. Same arithmetic `commit()` checks against, so a caller
+     * watching this can see a refusal coming. */
+    async snapshotUsage() {
+      const existing = await listSnapshotsRaw();
+      return {
+        usedBytes: existing.reduce((sum, snap) => sum + (snap.sizeBytes ?? 0), 0),
+        budgetBytes: deps.snapshotBudgetBytes ?? DEFAULT_SNAPSHOT_BUDGET_BYTES,
+        count: existing.length
+      };
     }
   };
 }
@@ -25046,11 +25215,11 @@ function makeGuestRunner(deps) {
           onEvent(e2);
         }
       };
-      const finish = (code, stderr) => {
+      const finish = (code2, stderr) => {
         if (skipped) deps.log?.(`session ${sessionId}: ${skipped} unparseable line(s) from the guest were skipped`);
-        if (code !== 0) {
+        if (code2 !== 0) {
           const why = stderr.trim().split(NEWLINE).slice(-3).join("; ");
-          return { text: finalText(seen), stopReason: `error: guest exit ${code}${why ? ` \u2014 ${why}` : ""}` };
+          return { text: finalText(seen), stopReason: `error: guest exit ${code2}${why ? ` \u2014 ${why}` : ""}` };
         }
         return { text: finalText(seen), stopReason: "done" };
       };
@@ -25091,7 +25260,10 @@ function toInfo(h2, backend) {
     // Read from the HANDLE, so it survives every later list() — and, on the
     // microVM backend, a daemon restart, since the sandbox carries it in its
     // own labels.
-    ...h2.source ? { source: h2.source } : {}
+    ...h2.source ? { source: h2.source } : {},
+    // Same reasoning as `source`: a client cannot derive "this daemon found
+    // it running rather than booted it" from anything else it is given.
+    ...h2.adopted ? { adopted: true } : {}
   };
 }
 function makeSessionsPort(deps) {
@@ -25167,6 +25339,9 @@ function makeSessionsPort(deps) {
         ...s2.sizeBytes !== void 0 ? { sizeBytes: s2.sizeBytes } : {}
       }))
     } : {},
+    ...backend.snapshotUsage ? {
+      snapshotUsage: () => backend.snapshotUsage()
+    } : {},
     ...backend.metrics ? {
       watchMetrics: (id, onSample) => {
         const st2 = backend.metrics(id, onSample);
@@ -25183,18 +25358,21 @@ function makeSessionsPort(deps) {
 }
 
 // ../tools-node/auth.ts
-import { promises as fs5 } from "node:fs";
+import { promises as fs6 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
-function corenelDir2() {
-  return join4(homedir3(), stateDirName());
+import { join as join5 } from "node:path";
+function corenelDir2(base = homedir3()) {
+  return join5(base, stateDirName());
+}
+function sidecarDir(base = homedir3()) {
+  return join5(corenelDir2(base), "sidecar");
 }
-function authTokenPath() {
-  return join4(corenelDir2(), "token");
+function authTokenPath(base = homedir3()) {
+  return join5(corenelDir2(base), "token");
 }
 async function readAuthToken() {
   try {
-    const t2 = (await fs5.readFile(authTokenPath(), "utf8")).trim();
+    const t2 = (await fs6.readFile(authTokenPath(), "utf8")).trim();
     return t2 || null;
   } catch {
     return null;
@@ -26959,12 +27137,12 @@ var TemplateProcessingStage = class {
    */
   async loadPackageResource(context, packagePath, resourcePath, prefix) {
     try {
-      const fs13 = context.fileSystem;
+      const fs15 = context.fileSystem;
       const possibleExtensions = ["", ".prmd", ".md", ".txt"];
       for (const ext of possibleExtensions) {
         const filePath = resolvePackageFile(packagePath, resourcePath + ext);
-        if (await fs13.exists(filePath)) {
-          const contentData = await fs13.readFile(filePath);
+        if (await fs15.exists(filePath)) {
+          const contentData = await fs15.readFile(filePath);
           if (isPrompdFile(filePath)) {
             const parser2 = new PrompdParser();
             try {
@@ -26998,16 +27176,16 @@ var TemplateProcessingStage = class {
       return content;
     }
     try {
-      const fs13 = context.fileSystem;
+      const fs15 = context.fileSystem;
       const parser2 = new PrompdParser();
       let parentFile = null;
-      if (isPrompdFile(parentPath) && await fs13.exists(parentPath)) {
+      if (isPrompdFile(parentPath) && await fs15.exists(parentPath)) {
         parentFile = parentPath;
-      } else if (await fs13.exists(parentPath) && await fs13.isDirectory(parentPath)) {
-        const files = (await fs13.readdir(parentPath)).filter((f2) => isPrompdFile(f2));
+      } else if (await fs15.exists(parentPath) && await fs15.isDirectory(parentPath)) {
+        const files = (await fs15.readdir(parentPath)).filter((f2) => isPrompdFile(f2));
         if (files.length > 0) {
           const mainFile = files.find((f2) => f2 === "main.prmd" || f2 === "main.md");
-          parentFile = fs13.join(parentPath, mainFile || files[0]);
+          parentFile = fs15.join(parentPath, mainFile || files[0]);
         }
       }
       if (!parentFile) {
@@ -27021,14 +27199,14 @@ var TemplateProcessingStage = class {
         });
         return content;
       }
-      const parentFileContent = await fs13.readFile(parentFile);
+      const parentFileContent = await fs15.readFile(parentFile);
       const parentData = parser2.parseContent(parentFileContent);
-      await this.validateParentFileReferences(context, parentData.metadata, fs13, parentFile);
+      await this.validateParentFileReferences(context, parentData.metadata, fs15, parentFile);
       if (context.hasErrors()) {
         return content;
       }
       if (parentData.content) {
-        const parentDir = fs13.dirname(parentFile);
+        const parentDir = fs15.dirname(parentFile);
         parentData.content = this.resolveIncludePaths(parentData.content, parentDir);
       }
       const overrides = context.metadata?.override || {};
@@ -27579,10 +27757,10 @@ ${content}` : parentData.content;
    * Called during inheritance processing because AssetExtractionStage only runs on
    * the child file's metadata — the parent is only parsed, never fully compiled.
    */
-  async validateParentFileReferences(context, metadata, fs13, parentFile) {
+  async validateParentFileReferences(context, metadata, fs15, parentFile) {
     if (!metadata) return;
     const metadataAsRecord = metadata;
-    const parentDir = fs13.dirname(parentFile);
+    const parentDir = fs15.dirname(parentFile);
     const fileFields = ["system", "task", "user", "assistant", "response", "output", "context"];
     for (const field of fileFields) {
       const fieldValue = metadataAsRecord[field];
@@ -27590,8 +27768,8 @@ ${content}` : parentData.content;
       const refs = Array.isArray(fieldValue) ? fieldValue.filter((v2) => typeof v2 === "string") : typeof fieldValue === "string" ? [fieldValue] : [];
       for (const ref of refs) {
         if (!ref.startsWith("./") && !ref.startsWith("../")) continue;
-        const resolvedPath = fs13.resolve(parentDir, ref);
-        const exists = await Promise.resolve(fs13.exists(resolvedPath));
+        const resolvedPath = fs15.resolve(parentDir, ref);
+        const exists = await Promise.resolve(fs15.exists(resolvedPath));
         if (!exists) {
           const location = context.findLocation(/inherits:/);
           context.addDiagnostic({
@@ -27968,6 +28146,90 @@ var PrompdCompiler = class {
 var parser = new PrompdParser();
 var compiler = new PrompdCompiler();
 
+// ../tools-node/migrateHome.ts
+import { promises as fs7 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join6, dirname as dirname3 } from "node:path";
+var SIDECAR_FILES = [
+  "daemon.id",
+  "daemon.token",
+  "hosts.json",
+  "sidecar.crt",
+  "sidecar.key",
+  "sidecar.sans.json"
+];
+var SIDECAR_DIRS = ["hosts"];
+async function isDir(p2) {
+  return fs7.stat(p2).then((s2) => s2.isDirectory()).catch(() => false);
+}
+async function present(p2) {
+  return fs7.stat(p2).then(() => true).catch(() => false);
+}
+function code(e2) {
+  return e2?.code;
+}
+async function moveEntry(from, to, report) {
+  if (!await present(from)) return;
+  if (await present(to)) {
+    report.skipped.push({ path: to, reason: "destination already exists" });
+    return;
+  }
+  await fs7.mkdir(dirname3(to), { recursive: true });
+  try {
+    await fs7.rename(from, to);
+    report.moved.push(to);
+  } catch (e2) {
+    const c2 = code(e2);
+    if (c2 === "EEXIST" || c2 === "ENOTEMPTY") {
+      report.skipped.push({ path: to, reason: "moved concurrently" });
+      return;
+    }
+    if (c2 === "ENOENT") {
+      report.skipped.push({ path: to, reason: "moved concurrently" });
+      return;
+    }
+    if (c2 === "EXDEV") {
+      await fs7.cp(from, to, { recursive: true });
+      await fs7.rm(from, { recursive: true, force: true });
+      report.moved.push(to);
+      return;
+    }
+    throw e2;
+  }
+}
+async function mergeDir(from, to, report) {
+  const entries = await fs7.readdir(from, { withFileTypes: true }).catch(() => []);
+  for (const e2 of entries) {
+    const src = join6(from, e2.name);
+    const dst = join6(to, e2.name);
+    if (e2.isDirectory() && await isDir(dst)) await mergeDir(src, dst, report);
+    else await moveEntry(src, dst, report);
+  }
+  await fs7.rmdir(from).catch(() => {
+  });
+}
+async function migrateHomeLayout(base = homedir4()) {
+  const report = { moved: [], skipped: [] };
+  const home = corenelDir2(base);
+  if (!await present(home)) return report;
+  const config = join6(home, "config");
+  if (await isDir(config)) await mergeDir(config, home, report);
+  const side = sidecarDir(base);
+  for (const name of SIDECAR_FILES) {
+    await moveEntry(join6(home, name), join6(side, name), report);
+  }
+  for (const name of SIDECAR_DIRS) {
+    const src = join6(home, name);
+    if (!await isDir(src)) continue;
+    const dst = join6(side, name);
+    if (await isDir(dst)) await mergeDir(src, dst, report);
+    else await moveEntry(src, dst, report);
+  }
+  if (report.moved.length) await fs7.chmod(home, 448).catch(() => {
+  });
+  return report;
+}
+
 // src/session/wiring.ts
 async function probeMsb(run) {
   const r2 = await run(["--version"], { timeoutMs: 3e4 });
@@ -28012,6 +28274,7 @@ async function wireSessions(opts) {
     image: opts.image,
     // Safe to apply everywhere: it only rewrites drive-letter paths.
     hostPath: wslHostPath,
+    ...opts.snapshotBudgetBytes !== void 0 ? { snapshotBudgetBytes: opts.snapshotBudgetBytes } : {},
     ...opts.log ? { log: opts.log } : {}
   });
   const manager = new SessionManager({
@@ -28035,10 +28298,120 @@ async function wireSessions(opts) {
   return { manager, backend, port: makeSessionsPort({ manager, backend, guestEnv, ...portExtras(opts) }) };
 }
 
+// src/runner/owners.ts
+import { readdir } from "node:fs/promises";
+import { join as join8 } from "node:path";
+
+// src/hostsDir.ts
+import { join as join7 } from "node:path";
+var HOSTS_SEG = "hosts";
+var MAX_SYNC_PATH_LEN = 400;
+var MAX_SYNC_SEGMENTS = 24;
+var CONTROL_CHAR_RE = new RegExp(
+  "[\\u0000-\\u001f\\u007f-\\u009f]"
+);
+var DIR_NAME_RE = /^[a-z0-9_-]{1,32}$/;
+function assertSyncPath(path) {
+  if (!path) throw new Error("sync path is empty");
+  if (path.length > MAX_SYNC_PATH_LEN) throw new Error(`sync path too long (> ${MAX_SYNC_PATH_LEN})`);
+  if (CONTROL_CHAR_RE.test(path)) throw new Error("sync path contains control characters");
+  if (path.includes(":")) throw new Error("sync path contains a colon");
+  const n2 = normalizeFilePath(path);
+  if (!n2) throw new Error("sync path normalizes to empty (targets the root)");
+  const segments = n2.split("/");
+  if (segments.length > MAX_SYNC_SEGMENTS) throw new Error(`sync path has too many segments (> ${MAX_SYNC_SEGMENTS})`);
+  if (segments.some((s2) => s2 === "." || s2 === "..")) {
+    throw new Error('sync path contains a "." or ".." segment');
+  }
+}
+function hostsRoot(stateDir) {
+  return join7(stateDir, "sidecar", HOSTS_SEG);
+}
+function hostsDirFor(stateDir, dirName2) {
+  if (!DIR_NAME_RE.test(dirName2)) throw new Error(`invalid host dir name: ${dirName2}`);
+  return join7(hostsRoot(stateDir), dirName2);
+}
+var RAW = /* @__PURE__ */ new WeakMap();
+function hostFilesFor(stateDir, dirName2) {
+  const raw = new NodeFileService(hostsDirFor(stateDir, dirName2));
+  const wrapper = {
+    kind: raw.kind,
+    label: raw.label,
+    isLocalDisk: raw.isLocalDisk,
+    writable: raw.writable,
+    list: (dir) => raw.list(dir),
+    read: (path) => raw.read(path),
+    stat: (path) => raw.stat(path),
+    search: (query) => raw.search(query),
+    onChange: (_cb) => raw.onChange()
+  };
+  RAW.set(wrapper, raw);
+  return wrapper;
+}
+async function syncWrite(files, path, content) {
+  assertSyncPath(path);
+  const raw = RAW.get(files);
+  if (!raw) throw new Error("syncWrite: not a hostFilesFor() result");
+  await raw.write(path, content);
+}
+async function syncRemove(files, path) {
+  assertSyncPath(path);
+  const raw = RAW.get(files);
+  if (!raw) throw new Error("syncRemove: not a hostFilesFor() result");
+  await raw.remove(path);
+}
+
+// src/runner/owners.ts
+var WORKSPACES_SEG = "workspaces";
+var WORKSPACE_ID_RE = /^[a-z0-9_-]{1,32}$/;
+async function workspaceRootsFor(dirName2, hostDir) {
+  let entries;
+  try {
+    entries = await readdir(join8(hostDir, WORKSPACES_SEG), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (!WORKSPACE_ID_RE.test(entry.name)) continue;
+    out.push({
+      owner: `${dirName2}/ws/${entry.name}`,
+      files: new NodeFileService(join8(hostDir, WORKSPACES_SEG, entry.name)),
+      root: "crew"
+    });
+  }
+  return out;
+}
+async function listOwnerRoots(stateDir) {
+  const roots = [
+    { owner: "", files: new NodeFileService(stateDir), root: "crew" }
+  ];
+  let entries;
+  try {
+    entries = await readdir(hostsRoot(stateDir), { withFileTypes: true });
+  } catch {
+    return roots;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dirName2 = entry.name;
+    let hostDir;
+    try {
+      hostDir = hostsDirFor(stateDir, dirName2);
+    } catch {
+      continue;
+    }
+    roots.push({ owner: dirName2, files: new NodeFileService(hostDir), root: "crew" });
+    roots.push(...await workspaceRootsFor(dirName2, hostDir));
+  }
+  return roots;
+}
+
 // src/cert.ts
-import { promises as fs6 } from "node:fs";
+import { promises as fs8 } from "node:fs";
 import { networkInterfaces } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join9 } from "node:path";
 import selfsigned from "selfsigned";
 function lanIPv4s() {
   const out = [];
@@ -28049,18 +28422,18 @@ function lanIPv4s() {
   }
   return [...new Set(out)];
 }
-var certPath = () => join5(corenelDir(), "sidecar.crt");
-var keyPath = () => join5(corenelDir(), "sidecar.key");
-var sansPath = () => join5(corenelDir(), "sidecar.sans.json");
+var certPath = () => join9(sidecarSubdir(), "sidecar.crt");
+var keyPath = () => join9(sidecarSubdir(), "sidecar.key");
+var sansPath = () => join9(sidecarSubdir(), "sidecar.sans.json");
 function isIp(s2) {
   return /^\d{1,3}(?:\.\d{1,3}){3}$/.test(s2) || s2.includes(":");
 }
 async function loadOrCreateSelfSigned(extraHosts = []) {
   const sans = [...new Set(["localhost", "127.0.0.1", "::1", ...lanIPv4s(), ...extraHosts].filter(Boolean))];
   try {
-    const have = JSON.parse(await fs6.readFile(sansPath(), "utf8"));
+    const have = JSON.parse(await fs8.readFile(sansPath(), "utf8"));
     if (Array.isArray(have) && sans.every((s2) => have.includes(s2))) {
-      const [cert, key] = await Promise.all([fs6.readFile(certPath(), "utf8"), fs6.readFile(keyPath(), "utf8")]);
+      const [cert, key] = await Promise.all([fs8.readFile(certPath(), "utf8"), fs8.readFile(keyPath(), "utf8")]);
       return { cert, key, sans: have };
     }
   } catch {
@@ -28072,10 +28445,10 @@ async function loadOrCreateSelfSigned(extraHosts = []) {
     algorithm: "sha256",
     extensions: [{ name: "subjectAltName", altNames }]
   });
-  await fs6.mkdir(corenelDir(), { recursive: true });
-  await fs6.writeFile(certPath(), pems.cert, { mode: 384 });
-  await fs6.writeFile(keyPath(), pems.private, { mode: 384 });
-  await fs6.writeFile(sansPath(), JSON.stringify(sans));
+  await fs8.mkdir(sidecarSubdir(), { recursive: true });
+  await fs8.writeFile(certPath(), pems.cert, { mode: 384 });
+  await fs8.writeFile(keyPath(), pems.private, { mode: 384 });
+  await fs8.writeFile(sansPath(), JSON.stringify(sans));
   return { cert: pems.cert, key: pems.private, sans };
 }
 
@@ -28180,8 +28553,8 @@ async function startWith(bin, port, name) {
     child.stdout?.on("data", onData);
     child.stderr?.on("data", onData);
     child.on("error", (e2) => finish(() => reject(e2)));
-    child.on("exit", (code) => finish(() => reject(new Error(
-      `${bin} exited (code ${code}) before a share URL appeared \u2014 is the environment enabled? Run \`${bin} enable <token>\` once.
+    child.on("exit", (code2) => finish(() => reject(new Error(
+      `${bin} exited (code ${code2}) before a share URL appeared \u2014 is the environment enabled? Run \`${bin} enable <token>\` once.
 ${tail(out)}`
     ))));
     const timer = setTimeout(() => finish(() => {
@@ -28318,13 +28691,13 @@ function startWith2(bin, mode, log, onDown) {
     child.stdout?.on("data", onData);
     child.stderr?.on("data", onData);
     child.on("error", (e2) => finish(() => reject(e2)));
-    child.on("exit", (code) => {
+    child.on("exit", (code2) => {
       if (settled) {
-        log?.(`cloudflared exited (code ${code}) \u2014 the tunnel is down`);
-        fireDown(`cloudflared exited (code ${code})`);
+        log?.(`cloudflared exited (code ${code2}) \u2014 the tunnel is down`);
+        fireDown(`cloudflared exited (code ${code2})`);
         return;
       }
-      finish(() => reject(new Error(`${bin} exited (code ${code}) before the tunnel came up.
+      finish(() => reject(new Error(`${bin} exited (code ${code2}) before the tunnel came up.
 ${tail2(out)}`)));
     });
     const timer = setTimeout(() => finish(() => {
@@ -28573,6 +28946,14 @@ function parseCanCall(meta) {
   if (!Array.isArray(raw)) return [];
   return raw.filter((x2) => typeof x2 === "string" && isValidAgentName(x2));
 }
+function parseWorkRoots(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const out = {};
+  for (const [id, dir] of Object.entries(raw)) {
+    if (typeof dir === "string" && dir) out[id] = dir;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
 function parseSettings(text) {
   try {
     const raw = JSON.parse(text);
@@ -28580,7 +28961,13 @@ function parseSettings(text) {
       const o2 = raw;
       return {
         model: typeof o2.model === "string" ? o2.model : void 0,
-        temperature: typeof o2.temperature === "number" ? o2.temperature : void 0
+        temperature: typeof o2.temperature === "number" ? o2.temperature : void 0,
+        /* Carried through as-is. Validation belongs to the daemon, which is the
+         * only side that knows its own approved roots -- checking here would be
+         * checking against the wrong list, on the wrong machine. Non-string
+         * values are dropped per entry rather than failing the whole file: one
+         * bad key must not cost an agent every other machine's setting. */
+        workRoots: parseWorkRoots(o2.workRoots)
       };
     }
   } catch {
@@ -28891,24 +29278,75 @@ function ensureWritable(path) {
     throw new Error(`${PROMPD_INSTALL_DIR}/ install dirs are read-only (managed by package install). Refusing to modify "${path}". Install or remove packages instead of editing them directly.`);
   }
 }
-function flatten(nodes, out = []) {
-  for (const n2 of nodes) {
-    out.push(`${n2.kind === "directory" ? "[dir] " : ""}${n2.path}${n2.kind === "file" && n2.size != null ? ` (${n2.size}b)` : ""}`);
-    if (n2.children?.length) flatten(n2.children, out);
+function describe(n2) {
+  return `${n2.kind === "directory" ? "[dir] " : ""}${n2.path}${n2.kind === "file" && n2.size != null ? ` (${n2.size}b)` : ""}`;
+}
+function bfsNodes(roots, maxDepth = Infinity) {
+  const out = [];
+  let level = roots;
+  let depth = 1;
+  while (level.length) {
+    const next = [];
+    for (const n2 of level) {
+      out.push(n2);
+      if (n2.kind === "directory" && n2.children?.length && depth < maxDepth) next.push(...n2.children);
+    }
+    level = next;
+    depth++;
   }
   return out;
 }
+var LIST_FILES_MAX_ENTRIES = 300;
+function selectByBreadthFirstCap(roots, maxDepth) {
+  const bfs = bfsNodes(roots, maxDepth);
+  return { keep: new Set(bfs.slice(0, LIST_FILES_MAX_ENTRIES)), total: bfs.length };
+}
+function describeInTreeOrder(roots, keep, maxDepth = Infinity, depth = 1, out = []) {
+  for (const n2 of roots) {
+    if (!keep.has(n2)) continue;
+    out.push(describe(n2));
+    if (n2.kind === "directory" && n2.children?.length && depth < maxDepth) {
+      describeInTreeOrder(n2.children, keep, maxDepth, depth + 1, out);
+    }
+  }
+  return out;
+}
+function truncationMarker(total, maxDepth) {
+  const omitted = total - LIST_FILES_MAX_ENTRIES;
+  const omittedEntries = `${omitted} more entr${omitted === 1 ? "y" : "ies"} omitted`;
+  if (maxDepth != null && Number.isFinite(maxDepth)) {
+    return `\u2026 truncated: ${omittedEntries}. ${total} entries were collected within depth ${maxDepth}; deeper levels were not counted, so this is not the size of the whole tree. Pass \`dir\` to narrow by subdirectory, or a larger \`depth\` to go deeper.`;
+  }
+  return `\u2026 truncated: ${omittedEntries} (${total} total). Pass \`dir\` to list a specific subdirectory (narrower breadth), or \`depth\` to limit how many levels deep the listing goes (narrower depth), instead of the whole tree.`;
+}
+function normalizeDepth(args) {
+  const v2 = args["depth"];
+  if (v2 == null) return void 0;
+  const n2 = typeof v2 === "number" ? v2 : typeof v2 === "string" ? Number(v2) : NaN;
+  if (!Number.isFinite(n2)) return void 0;
+  const floored = Math.floor(n2);
+  return floored < 1 ? 1 : floored;
+}
 var listFilesTool = {
   name: "list_files",
-  description: "List files and directories in the workspace (the open folder or the virtual workspace). Optionally pass `dir` to list a subdirectory. Returns paths relative to the workspace root.",
+  description: "List files and directories in the workspace (the open folder or the virtual workspace). Start shallow and drill in: pass `depth` to limit how many levels deep the listing goes (vertical narrowing \u2014 `depth: 1` returns just the immediate children of the target, a quick orientation call) and/or `dir` to list a specific subdirectory instead of the whole tree (horizontal narrowing). Omit `depth` for a full recursive listing. Returns paths relative to the workspace root.",
   parameters: {
     type: "object",
-    properties: { dir: { type: "string", description: "Subdirectory to list (optional; omit for the root)." } }
+    properties: {
+      dir: { type: "string", description: "Subdirectory to list (optional; omit for the root)." },
+      depth: {
+        type: "number",
+        description: "How many levels deep to list (optional; omit for the full recursive tree). 1 = immediate children of `dir` (or the root) only, 2 = two levels, and so on. Values below 1 (0, negative) are treated as 1, not rejected."
+      }
+    }
   },
   async run(args, ctx) {
     const files = requireFiles(ctx);
     const nodes = await files.list(str(args, "dir") || void 0);
-    const lines = flatten(nodes);
+    const maxDepth = normalizeDepth(args);
+    const { keep, total } = selectByBreadthFirstCap(nodes, maxDepth);
+    const lines = describeInTreeOrder(nodes, keep, maxDepth);
+    if (total > LIST_FILES_MAX_ENTRIES) lines.push(truncationMarker(total, maxDepth));
     return lines.length ? lines.join("\n") : "(empty)";
   }
 };
@@ -29647,7 +30085,7 @@ function allTools() {
   return [...defaultTools, ...extensionTools()];
 }
 
-// ../crew/callAgent.ts
+// ../harness/tools/callAgent.ts
 function str5(v2) {
   return typeof v2 === "string" ? v2.trim() : "";
 }
@@ -29915,113 +30353,6 @@ function nodeCrewLocation(stateDir, scope, workspaceRoot) {
   return { files: new NodeFileService(wsRoot), root: `${stateDirName()}/crew` };
 }
 
-// src/runner/owners.ts
-import { readdir } from "node:fs/promises";
-import { join as join7 } from "node:path";
-
-// src/hostsDir.ts
-import { join as join6 } from "node:path";
-var HOSTS_SEG = "hosts";
-var MAX_SYNC_PATH_LEN = 400;
-var MAX_SYNC_SEGMENTS = 24;
-var CONTROL_CHAR_RE = new RegExp(
-  "[\\u0000-\\u001f\\u007f-\\u009f]"
-);
-var DIR_NAME_RE = /^[a-z0-9_-]{1,32}$/;
-function assertSyncPath(path) {
-  if (!path) throw new Error("sync path is empty");
-  if (path.length > MAX_SYNC_PATH_LEN) throw new Error(`sync path too long (> ${MAX_SYNC_PATH_LEN})`);
-  if (CONTROL_CHAR_RE.test(path)) throw new Error("sync path contains control characters");
-  if (path.includes(":")) throw new Error("sync path contains a colon");
-  const n2 = normalizeFilePath(path);
-  if (!n2) throw new Error("sync path normalizes to empty (targets the root)");
-  const segments = n2.split("/");
-  if (segments.length > MAX_SYNC_SEGMENTS) throw new Error(`sync path has too many segments (> ${MAX_SYNC_SEGMENTS})`);
-  if (segments.some((s2) => s2 === "." || s2 === "..")) {
-    throw new Error('sync path contains a "." or ".." segment');
-  }
-}
-function hostsDirFor(stateDir, dirName2) {
-  if (!DIR_NAME_RE.test(dirName2)) throw new Error(`invalid host dir name: ${dirName2}`);
-  return join6(stateDir, HOSTS_SEG, dirName2);
-}
-var RAW = /* @__PURE__ */ new WeakMap();
-function hostFilesFor(stateDir, dirName2) {
-  const raw = new NodeFileService(hostsDirFor(stateDir, dirName2));
-  const wrapper = {
-    kind: raw.kind,
-    label: raw.label,
-    isLocalDisk: raw.isLocalDisk,
-    writable: raw.writable,
-    list: (dir) => raw.list(dir),
-    read: (path) => raw.read(path),
-    stat: (path) => raw.stat(path),
-    search: (query) => raw.search(query),
-    onChange: (_cb) => raw.onChange()
-  };
-  RAW.set(wrapper, raw);
-  return wrapper;
-}
-async function syncWrite(files, path, content) {
-  assertSyncPath(path);
-  const raw = RAW.get(files);
-  if (!raw) throw new Error("syncWrite: not a hostFilesFor() result");
-  await raw.write(path, content);
-}
-async function syncRemove(files, path) {
-  assertSyncPath(path);
-  const raw = RAW.get(files);
-  if (!raw) throw new Error("syncRemove: not a hostFilesFor() result");
-  await raw.remove(path);
-}
-
-// src/runner/owners.ts
-var WORKSPACES_SEG = "workspaces";
-var WORKSPACE_ID_RE = /^[a-z0-9_-]{1,32}$/;
-async function workspaceRootsFor(dirName2, hostDir) {
-  let entries;
-  try {
-    entries = await readdir(join7(hostDir, WORKSPACES_SEG), { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    if (!WORKSPACE_ID_RE.test(entry.name)) continue;
-    out.push({
-      owner: `${dirName2}/ws/${entry.name}`,
-      files: new NodeFileService(join7(hostDir, WORKSPACES_SEG, entry.name)),
-      root: "crew"
-    });
-  }
-  return out;
-}
-async function listOwnerRoots(stateDir) {
-  const roots = [
-    { owner: "", files: new NodeFileService(stateDir), root: "crew" }
-  ];
-  let entries;
-  try {
-    entries = await readdir(join7(stateDir, HOSTS_SEG), { withFileTypes: true });
-  } catch {
-    return roots;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const dirName2 = entry.name;
-    let hostDir;
-    try {
-      hostDir = hostsDirFor(stateDir, dirName2);
-    } catch {
-      continue;
-    }
-    roots.push({ owner: dirName2, files: new NodeFileService(hostDir), root: "crew" });
-    roots.push(...await workspaceRootsFor(dirName2, hostDir));
-  }
-  return roots;
-}
-
 // ../../node_modules/.pnpm/openai@4.104.0_ws@8.21.0/node_modules/openai/internal/qs/formats.mjs
 var default_format = "RFC3986";
 var formatters = {
@@ -36773,10 +37104,10 @@ function statusOf(message) {
 function classifyStreamError(message, status) {
   if (/\baborted\b|AbortError/i.test(message)) return "fatal";
   if (/\b(timed out|request timeout|gateway timeout|deadline exceeded)\b/i.test(message)) return "fatal";
-  const code = status ?? statusOf(message);
-  if (code != null) {
-    if (FATAL_STATUS.has(code)) return "fatal";
-    if (TRANSIENT_STATUS.has(code)) return "transient";
+  const code2 = status ?? statusOf(message);
+  if (code2 != null) {
+    if (FATAL_STATUS.has(code2)) return "fatal";
+    if (TRANSIENT_STATUS.has(code2)) return "transient";
   }
   if (/\b(invalid[\s_-]?api[\s_-]?key|incorrect api key|unauthorized|forbidden|quota exceeded|insufficient)\b/i.test(message)) return "fatal";
   return "transient";
@@ -36875,6 +37206,7 @@ var BUILTIN_NAMESPACES = {
   ask_user: "agent",
   spawn_agent: "agent",
   spawn_agents: "agent",
+  call_agent: "agent",
   todo_write: "agent",
   // Named here as a backstop; the sidecar's own decls also carry `namespace`,
   // and an explicit field always wins (resolveNamespace). Both say the same
@@ -36893,7 +37225,17 @@ var BUILTIN_NAMESPACES = {
   view_strategy: "agent",
   run_strategy: "agent",
   list_strategies: "agent",
-  list_saved_strategies: "agent"
+  list_saved_strategies: "agent",
+  // Long-lived process control (proc_start/proc_stop/proc_list, see tools/procs.ts).
+  // `shell` is its own subject, deliberately distinct from the one-shot exec's
+  // `sidecar:shell_exec`: a process that stays running is a different risk from
+  // one that returns, and one address lets an operator ban (or allow) both
+  // start and stop together. proc_list is a read - it namespaces as `sidecar`
+  // (like the other machine-state reads) so it is NOT swept up by a `shell:*`
+  // deny; listing what is running carries none of spawn/kill's risk.
+  proc_start: "shell",
+  proc_stop: "shell",
+  proc_list: "sidecar"
 };
 function resolveNamespace(tool) {
   if (tool.namespace) return tool.namespace;
@@ -36921,6 +37263,7 @@ function toolAddress(tool) {
       }
     }
   }
+  if (ns === "shell" && (leaf === "proc_start" || leaf === "proc_stop")) leaf = "spawn";
   return `${ns}:${leaf}`;
 }
 
@@ -36932,8 +37275,12 @@ function effectiveThreshold(mode, fill = 0) {
   const factor = fill < 0.5 ? 1 : fill < 0.7 ? 0.7 : fill < 0.85 ? 0.5 : 0.35;
   return Math.max(FLOOR[mode], Math.round(BASE[mode] * factor));
 }
+var OFFLOAD_MARKER_PREFIX = "[offloaded tool result \xB7 ";
+function isOffloadPointer(content) {
+  return content.startsWith(OFFLOAD_MARKER_PREFIX);
+}
 function formatOffloadRef(ref) {
-  const head = `[offloaded tool result \xB7 ${ref.toolName} \xB7 ${ref.bytes.toLocaleString()} bytes \xB7 recall the full content with recall_result({ id: "${ref.id}" })]`;
+  const head = `${OFFLOAD_MARKER_PREFIX}${ref.toolName} \xB7 ${ref.bytes.toLocaleString()} bytes \xB7 recall the full content with recall_result({ id: "${ref.id}" })]`;
   return ref.preview ? `${head}
 --- preview ---
 ${ref.preview}${ref.bytes > ref.preview.length ? "\n\u2026(truncated)" : ""}` : head;
@@ -36956,7 +37303,9 @@ async function runAgent(args) {
   const permission = args.permission;
   const compression = args.compression;
   const ctxWindow = compression?.contextWindow;
+  const compressionStrategy = compression?.strategy ?? "eager";
   let fill = 0;
+  const deferredOffloads = [];
   const maxTurns = policy.maxTurns ?? args.maxTurns ?? 8;
   const signal = args.signal ?? new AbortController().signal;
   const emit = (e2) => args.onEvent?.(e2);
@@ -36973,6 +37322,9 @@ async function runAgent(args) {
     function: { name: t2.name, description: t2.description, parameters: t2.parameters }
   }));
   const toolByName = new Map(tools.map((t2) => [t2.name, t2]));
+  if (compressionStrategy === "deferred" && compression && compression.mode !== "off" && toolCtx.recall) {
+    await compactIncomingOffloads(messages, toolByName, compression, toolCtx.recall, emit);
+  }
   const usage = { promptTokens: 0, completionTokens: 0 };
   let text = "";
   let stopReason = "stop";
@@ -37046,6 +37398,13 @@ async function runAgent(args) {
       stopReason = "error";
       break;
     }
+    if (compressionStrategy === "deferred" && deferredOffloads.length) {
+      for (const o2 of deferredOffloads) {
+        const orig = messages[o2.index];
+        if (orig.role === "tool") messages[o2.index] = { ...orig, content: formatOffloadRef(o2.ref) };
+      }
+      deferredOffloads.length = 0;
+    }
     usage.promptTokens += streamed.usage.promptTokens;
     usage.completionTokens += streamed.usage.completionTokens;
     if (ctxWindow && ctxWindow > 0 && streamed.usage.promptTokens) {
@@ -37121,14 +37480,21 @@ async function runAgent(args) {
         const decision = await permission.check({ name: tool.name, address, mutates: tool.mutates, permission: tool.permission }, parsed);
         emit({ type: "permission", tool: tool.name, decision });
         if (decision === "deny") {
-          messages.push({ role: "tool", tool_call_id: call.id, content: "Permission denied by the user \u2014 the action was not performed." });
+          const denialMsg = args.describePermissionDenial?.(tool.name) ?? "Permission denied by the user \u2014 the action was not performed.";
+          messages.push({ role: "tool", tool_call_id: call.id, content: denialMsg });
           emit({ type: "tool-result", id: call.id, name: tool.name, result: "permission denied", isError: true });
           continue;
         }
       }
       const startedAt = Date.now();
+      let callSettled = false;
+      const stream = (text2) => {
+        if (callSettled) return;
+        emit({ type: "tool-delta", id: call.id, name: call.name, delta: text2 });
+      };
       try {
-        const result = await tool.run(parsed, { ...toolCtx, callId: call.id });
+        const result = await tool.run(parsed, { ...toolCtx, callId: call.id, stream });
+        callSettled = true;
         const durationMs = Date.now() - startedAt;
         gstate.toolCalls++;
         gstate.calledTools.add(tool.name);
@@ -37142,8 +37508,12 @@ async function runAgent(args) {
           if (result.length > effectiveThreshold(compression.mode, fill)) {
             try {
               const ref = await toolCtx.recall.record(tool.name, result);
-              out = formatOffloadRef(ref);
               emit({ type: "offload", id: ref.id, name: tool.name, bytes: ref.bytes });
+              if (compressionStrategy === "deferred") {
+                deferredOffloads.push({ index: messages.length, ref });
+              } else {
+                out = formatOffloadRef(ref);
+              }
             } catch {
               out = result;
             }
@@ -37152,6 +37522,7 @@ async function runAgent(args) {
         messages.push({ role: "tool", tool_call_id: call.id, content: out });
         emit({ type: "tool-result", id: call.id, name: call.name, result: out, durationMs });
       } catch (e2) {
+        callSettled = true;
         const errMsg = String(e2?.message || e2);
         const kind2 = classifyToolError(errMsg);
         const attempt = toolFails.fail(tool.name, kind2);
@@ -37175,6 +37546,30 @@ async function runAgent(args) {
   emit({ type: "done", reason: stopReason });
   return { messages, text, usage, stopReason };
 }
+async function compactIncomingOffloads(messages, toolByName, compression, recall, emit) {
+  const nameForCallId = /* @__PURE__ */ new Map();
+  for (const m2 of messages) {
+    if (m2.role === "assistant" && m2.tool_calls) {
+      for (const c2 of m2.tool_calls) nameForCallId.set(c2.id, c2.function.name);
+    }
+  }
+  for (let i2 = 0; i2 < messages.length; i2++) {
+    const m2 = messages[i2];
+    if (m2.role !== "tool" || typeof m2.content !== "string") continue;
+    if (isOffloadPointer(m2.content)) continue;
+    const toolName = nameForCallId.get(m2.tool_call_id);
+    if (!toolName) continue;
+    const tool = toolByName.get(toolName);
+    if (!tool || tool.noOffload) continue;
+    if (m2.content.length <= effectiveThreshold(compression.mode, 0)) continue;
+    try {
+      const ref = await recall.record(toolName, m2.content);
+      messages[i2] = { ...m2, content: formatOffloadRef(ref) };
+      emit({ type: "offload", id: ref.id, name: toolName, bytes: ref.bytes });
+    } catch {
+    }
+  }
+}
 function reconcileDanglingToolCalls(messages) {
   let idx = -1;
   for (let i2 = messages.length - 1; i2 >= 0; i2--) {
@@ -38222,7 +38617,7 @@ var NodeRunnerService = class {
 // src/runner/core.ts
 import { watch } from "node:fs";
 import { readdir as readdir2, stat } from "node:fs/promises";
-import { join as join8, relative as relative5, sep as sep3 } from "node:path";
+import { join as join10, relative as relative5, sep as sep3 } from "node:path";
 
 // src/runner/triggerConfig.ts
 function inputFor(trigger, fallback) {
@@ -38702,6 +39097,7 @@ function startDaemonCore(opts) {
       w2.on("error", (err) => log(`daemon core: watch error on "${dir}" -- ${err.message}`));
       watchers.push(w2);
     } catch (err) {
+      if (err?.code === "ENOENT") continue;
       log(`daemon core: could not watch "${dir}" -- ${err instanceof Error ? err.message : String(err)}`);
     }
   }
@@ -38731,9 +39127,9 @@ function startDaemonCore(opts) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (isExcludedSegment(entry.name, dotDir)) continue;
-        await walkForChanges(root, join8(dir, entry.name), since);
+        await walkForChanges(root, join10(dir, entry.name), since);
       } else {
-        const abs = join8(dir, entry.name);
+        const abs = join10(dir, entry.name);
         let mtimeMs;
         try {
           mtimeMs = (await stat(abs)).mtimeMs;
@@ -39011,26 +39407,26 @@ function makeRunHub(opts = {}) {
 }
 
 // src/identity.ts
-import { promises as fs8 } from "node:fs";
+import { promises as fs10 } from "node:fs";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { hostname } from "node:os";
-import { join as join9 } from "node:path";
-function idPath(dir = corenelDir()) {
-  return join9(dir, "daemon.id");
+import { join as join11 } from "node:path";
+function idPath(dir = sidecarSubdir()) {
+  return join11(dir, "daemon.id");
 }
-async function loadOrCreateSidecarId(dir = corenelDir()) {
+async function loadOrCreateSidecarId(dir = sidecarSubdir()) {
   const path = idPath(dir);
   try {
-    const existing = (await fs8.readFile(path, "utf8")).trim();
+    const existing = (await fs10.readFile(path, "utf8")).trim();
     if (existing) return existing;
   } catch (err) {
     if (!isEnoent(err)) throw err;
   }
-  await fs8.mkdir(dir, { recursive: true });
+  await fs10.mkdir(dir, { recursive: true });
   const id = randomBytes2(16).toString("hex");
-  await fs8.writeFile(path, id + "\n", { mode: 384 });
+  await fs10.writeFile(path, id + "\n", { mode: 384 });
   try {
-    await fs8.chmod(path, 384);
+    await fs10.chmod(path, 384);
   } catch {
   }
   return id;
@@ -39043,9 +39439,9 @@ function sidecarName(opts) {
 }
 
 // src/hosts.ts
-import { promises as fs9 } from "node:fs";
+import { promises as fs11 } from "node:fs";
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { join as join10 } from "node:path";
+import { join as join12 } from "node:path";
 var MAX_DIR = 32;
 var MAX_FIELD_LEN = 200;
 var MAX_HOSTS = 200;
@@ -39079,7 +39475,7 @@ function sanitizeDirName(raw) {
   return RESERVED_WINDOWS_NAMES.has(safe) ? `${safe}-host` : safe;
 }
 function hostsPath(dir) {
-  return join10(dir, "hosts.json");
+  return join12(dir, "hosts.json");
 }
 function emptyManifest() {
   return /* @__PURE__ */ Object.create(null);
@@ -39100,7 +39496,7 @@ function repairHostRecord(value, fallbackLastSeen) {
 async function read(dir, fallbackLastSeen) {
   let raw;
   try {
-    raw = await fs9.readFile(hostsPath(dir), "utf8");
+    raw = await fs11.readFile(hostsPath(dir), "utf8");
   } catch {
     return emptyManifest();
   }
@@ -39119,14 +39515,14 @@ async function read(dir, fallbackLastSeen) {
   return manifest;
 }
 async function write(dir, manifest) {
-  await fs9.mkdir(dir, { recursive: true });
+  await fs11.mkdir(dir, { recursive: true });
   const target = hostsPath(dir);
-  const tmp = join10(dir, `.hosts.json.tmp-${randomBytes3(8).toString("hex")}`);
+  const tmp = join12(dir, `.hosts.json.tmp-${randomBytes3(8).toString("hex")}`);
   try {
-    await fs9.writeFile(tmp, JSON.stringify(manifest, null, 2));
-    await fs9.rename(tmp, target);
+    await fs11.writeFile(tmp, JSON.stringify(manifest, null, 2));
+    await fs11.rename(tmp, target);
   } catch (err) {
-    await fs9.rm(tmp, { force: true }).catch(() => void 0);
+    await fs11.rm(tmp, { force: true }).catch(() => void 0);
     throw err;
   }
 }
@@ -39274,8 +39670,8 @@ function makeHostSync(opts) {
 }
 
 // src/hostsCli.ts
-import { resolve as resolve5, join as join11 } from "node:path";
-import { promises as fs10 } from "node:fs";
+import { resolve as resolve5, join as join13 } from "node:path";
+import { promises as fs12 } from "node:fs";
 async function listHosts(manifest) {
   const m2 = await manifest.list();
   return Object.entries(m2).map(([clientId, r2]) => ({
@@ -39298,7 +39694,7 @@ async function forgetHost(stateDir, manifest, dirName2) {
     return { ok: false, reason: e2 instanceof Error ? e2.message : String(e2) };
   }
   try {
-    await fs10.rm(dir, { recursive: true, force: true });
+    await fs12.rm(dir, { recursive: true, force: true });
   } catch (e2) {
     return {
       ok: false,
@@ -39309,10 +39705,10 @@ async function forgetHost(stateDir, manifest, dirName2) {
   return { ok: true };
 }
 async function checkHostsDrift(stateDir, manifest, log) {
-  const hostsRoot = join11(stateDir, HOSTS_SEG);
+  const hostsRoot2 = join13(stateDir, HOSTS_SEG);
   let entries;
   try {
-    entries = (await fs10.readdir(hostsRoot, { withFileTypes: true })).filter((d2) => d2.isDirectory()).map((d2) => d2.name);
+    entries = (await fs12.readdir(hostsRoot2, { withFileTypes: true })).filter((d2) => d2.isDirectory()).map((d2) => d2.name);
   } catch {
     return [];
   }
@@ -39377,6 +39773,114 @@ async function runHostsCli(argv) {
 
 // src/sessionsCli.ts
 import { resolve as resolve6 } from "node:path";
+
+// ../harness/sessions/fileRecallStore.ts
+var UNATTACHED_SESSION = "_unattached";
+
+// ../harness/sessions/blobGc.ts
+var DEFAULT_UNATTACHED_GRACE_MS = 30 * 60 * 1e3;
+var MARKER_ID_RE = /recall_result\(\{\s*id:\s*\\?"([^"\\]+)\\?"\s*\}\)/g;
+async function globalReferencedIds(files, root, sessionDirs) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const dir of sessionDirs) {
+    if (!dir.hasSessionLog) continue;
+    const text = await files.read(`${root}/${dir.id}/SESSION.jsonl`).catch(() => null);
+    if (text == null) continue;
+    for (const m2 of text.matchAll(MARKER_ID_RE)) {
+      const id = m2[1];
+      if (id) ids.add(id);
+    }
+  }
+  return ids;
+}
+async function listSessionDirs(files, root) {
+  const nodes = await files.list(root).catch(() => []);
+  const flat = flattenFiles(nodes).filter((f2) => f2.path.startsWith(`${root}/`));
+  const dirs = /* @__PURE__ */ new Map();
+  for (const f2 of flat) {
+    const rest = f2.path.slice(root.length + 1);
+    const slash = rest.indexOf("/");
+    if (slash < 0) continue;
+    const id = rest.slice(0, slash);
+    const isSessionLog = rest === `${id}/SESSION.jsonl`;
+    if (!dirs.has(id)) dirs.set(id, false);
+    if (isSessionLog) dirs.set(id, true);
+  }
+  return [...dirs.entries()].map(([id, hasSessionLog]) => ({ id, hasSessionLog }));
+}
+async function listBlobs(files, root, sessionId) {
+  const dir = `${root}/${sessionId}/blobs`;
+  const nodes = await files.list(dir).catch(() => []);
+  const blobFiles = flattenFiles(nodes).filter((f2) => f2.path.startsWith(`${dir}/`) && f2.path.endsWith(".json"));
+  const out = [];
+  for (const f2 of blobFiles) {
+    const text = await files.read(f2.path).catch(() => null);
+    if (text == null) continue;
+    try {
+      const record = JSON.parse(text);
+      if (record && typeof record.id === "string") out.push({ path: f2.path, record });
+    } catch {
+    }
+  }
+  return out;
+}
+async function planBlobGc(files, opts = {}) {
+  const root = opts.root ?? sessionsRoot();
+  const now2 = (opts.now ?? Date.now)();
+  const graceMs = opts.graceMs ?? DEFAULT_UNATTACHED_GRACE_MS;
+  const sessionDirs = await listSessionDirs(files, root);
+  const referenced = await globalReferencedIds(files, root, sessionDirs);
+  const reapable = [];
+  const liveUnreferenced = [];
+  for (const dir of sessionDirs) {
+    const blobs = await listBlobs(files, root, dir.id);
+    for (const { path, record } of blobs) {
+      const isReferenced = referenced.has(record.id);
+      const base = {
+        sessionId: dir.id,
+        id: record.id,
+        path,
+        bytes: record.bytes,
+        toolName: record.toolName,
+        createdAt: record.createdAt
+      };
+      if (isReferenced) continue;
+      if (dir.id === UNATTACHED_SESSION) {
+        const age = now2 - record.createdAt;
+        if (age < graceMs) continue;
+        reapable.push({
+          ...base,
+          disposition: "reap",
+          reason: `unattached, unreferenced, and ${Math.round(age / 6e4)}m old (grace is ${Math.round(graceMs / 6e4)}m)`
+        });
+        continue;
+      }
+      if (!dir.hasSessionLog) {
+        reapable.push({ ...base, disposition: "reap", reason: "owning session directory has no SESSION.jsonl" });
+        continue;
+      }
+      liveUnreferenced.push({ ...base, disposition: "report-only", reason: "unreferenced, but the owning session is live \u2014 not deleted by this tool" });
+    }
+  }
+  return {
+    reapable,
+    liveUnreferenced,
+    reapableBytes: reapable.reduce((sum, e2) => sum + e2.bytes, 0),
+    liveUnreferencedBytes: liveUnreferenced.reduce((sum, e2) => sum + e2.bytes, 0)
+  };
+}
+async function runBlobGc(files, opts = {}) {
+  const plan = await planBlobGc(files, opts);
+  if (!opts.delete) return { plan, removed: [] };
+  const removed = [];
+  for (const entry of plan.reapable) {
+    await files.remove(entry.path).catch(() => void 0);
+    removed.push(entry);
+  }
+  return { plan, removed };
+}
+
+// src/sessionsCli.ts
 async function sandboxLifecycle(run, verb, name) {
   const call = async (args) => {
     const r2 = await run(args).catch((e2) => ({ code: 1, stdout: "", stderr: String(e2) }));
@@ -39448,6 +39952,31 @@ function formatSession(r2) {
     ...r2.repo ? [`repo     ${r2.repo}`] : []
   ].join("\n");
 }
+function formatBlobGcReport(result, deleted) {
+  const line = (e2) => `  ${e2.path}  ${formatByteSize(e2.bytes)}  (${e2.reason})`;
+  const lines = [];
+  const { plan } = result;
+  if (!plan.reapable.length && !plan.liveUnreferenced.length) {
+    lines.push("no unattached blobs found.");
+    return lines.join("\n");
+  }
+  if (plan.reapable.length) {
+    lines.push(deleted ? `removed ${result.removed.length} blob(s), ${formatByteSize(plan.reapableBytes)} freed:` : `would remove ${plan.reapable.length} blob(s), ${formatByteSize(plan.reapableBytes)} total:`);
+    lines.push(...plan.reapable.map(line));
+  } else {
+    lines.push("nothing is reap-eligible.");
+  }
+  if (plan.liveUnreferenced.length) {
+    lines.push("");
+    lines.push(`${plan.liveUnreferenced.length} unreferenced blob(s) in live sessions, ${formatByteSize(plan.liveUnreferencedBytes)} total (not removed by this tool):`);
+    lines.push(...plan.liveUnreferenced.map(line));
+  }
+  if (!deleted && plan.reapable.length) {
+    lines.push("");
+    lines.push("pass --delete to remove the first list. Nothing above was touched.");
+  }
+  return lines.join("\n");
+}
 var DEFAULT_GUEST_IMAGE = "corenel-guest:dev";
 function backendFor(deps, roots, run) {
   return makeMicrovmBackend({
@@ -39619,13 +40148,28 @@ async function runSessionsCli(argv, deps) {
       return 0;
     } catch (e2) {
       err(`corenel sessions ${verb}: ${e2 instanceof Error ? e2.message : String(e2)}
+`);
+      return 1;
+    }
+  }
+  if (verb === "gc") {
+    const root = rootFrom(argv, process.cwd());
+    const doDelete = argv.includes("--delete");
+    try {
+      const files = new NodeFileService(root);
+      const result = await runBlobGc(files, { delete: doDelete });
+      out(`${formatBlobGcReport(result, doDelete)}
+`);
+      return 0;
+    } catch (e2) {
+      err(`corenel sessions gc: ${e2 instanceof Error ? e2.message : String(e2)}
 `);
       return 1;
     }
   }
   err(`corenel sessions: unknown subcommand "${verb}"
   usage: corenel sessions [list | show <id> | create [--root <dir>] | run <id> "<prompt>"
-                          | pause <id> | resume <id> | destroy <id>]
+                          | pause <id> | resume <id> | destroy <id> | gc [--delete]]
 `);
   return 1;
 }
@@ -39653,7 +40197,7 @@ var FLAGS = [
   { flag: "--app-url", arg: "<url>", help: "App to open and pair with, path included (default https://corenel.ai; prompd pairs at https://prompd.app/studio)." },
   { flag: "--daemon", help: "Run crew agents on this machine unattended: cron, file-change and run-complete triggers." },
   { flag: "--endpoint", arg: "<url>", help: "Gateway the daemon calls for model runs (default https://api.corenel.ai/api). A bare origin gets /api appended." },
-  { flag: "--state-dir", arg: "<dir>", help: "Where crew agents, sessions and tokens live (defaults to the Corenel dot-dir)." },
+  { flag: "--state-dir", arg: "<dir>", help: "Where crew agents, sessions and tokens live (defaults to the Corenel dot-dir). REQUIRED for a second sidecar on this machine: two sharing a state dir share their identity." },
   { flag: "--default-model", arg: "<id>", help: "Model for crew agents that do not name one." },
   { flag: "--name", arg: "<label>", help: "Friendly name advertised to clients (defaults to the hostname)." },
   { flag: "--max-chain-depth", arg: "<n>", help: "Cap how far run-complete triggers may chain before suppressing (default 8)." },
@@ -39664,6 +40208,7 @@ var FLAGS = [
   { flag: "--isolation", arg: "<none|microvm>", help: "How a session confines a run: none (this process) or microvm (a sandbox per session, needs msb). Default none." },
   { flag: "--msb", arg: "<path>", help: "Path to the msb binary, for --isolation microvm." },
   { flag: "--guest-image", arg: "<ref>", help: "Image a session boots (default corenel-guest:dev). Pin by digest for anything snapshotted." },
+  { flag: "--snapshot-budget", arg: "<size>", help: "Ceiling on TOTAL bytes used by session snapshots (default 32G). A capture that would exceed it is refused, never pruned; size accepts K/M/G/T suffixes." },
   { flag: "--clone-under", arg: "<dir>", help: "Let a session clone a repository into <dir>. Repeatable. Off by default; the clone runs on THIS host with your own git credentials, which never enter the session." },
   { flag: "--keep-transcripts", help: "PERMIT session runs to keep their words, not just metadata. Off by default; each run still has to ask, and none can ask past this." },
   { flag: "--acp", arg: "<target>", help: "Proxy an external ACP agent (claude-code). Needs --root." },
@@ -39702,6 +40247,11 @@ function helpText() {
     `  ${self} --daemon --default-model gpt-4.1-mini`,
     `  ${self} --root ~/work --acp claude-code --acp-policy read-only`,
     "",
+    "  A second sidecar on the same machine needs its own state dir \u2014 without one",
+    "  both read the same daemon.id and advertise the same identity, so a paired",
+    "  browser sees one sidecar where there are two:",
+    `  ${self} --root ~/other --port 4859 --state-dir ~/.corenel-other`,
+    "",
     "Reachable both ways: `corenel sidecar \u2026` through the CLI, and",
     "`corenel-sidecar \u2026` standalone, for machines that run only this.",
     "",
@@ -39792,6 +40342,7 @@ function parseArgs(argv) {
     isolation: "none",
     msbBin: process.env.MSB_BIN ?? "msb",
     guestImage: "corenel-guest:dev",
+    snapshotBudgetBytes: DEFAULT_SNAPSHOT_BUDGET_BYTES,
     selfSigned: false,
     open: false,
     appUrl: "https://corenel.ai",
@@ -39828,7 +40379,15 @@ function parseArgs(argv) {
       out.isolation = v2;
     } else if (a2 === "--msb") out.msbBin = argv[++i2];
     else if (a2 === "--guest-image") out.guestImage = argv[++i2];
-    else if (a2 === "--allow-lan") out.allowLan = true;
+    else if (a2 === "--snapshot-budget") {
+      const v2 = argv[++i2];
+      if (v2 === void 0) throw new Error('--snapshot-budget needs a size, e.g. "32G"');
+      try {
+        out.snapshotBudgetBytes = parseByteSize(v2);
+      } catch (e2) {
+        throw new Error(`--snapshot-budget: ${e2 instanceof Error ? e2.message : String(e2)}`);
+      }
+    } else if (a2 === "--allow-lan") out.allowLan = true;
     else if (a2 === "--tls-cert") out.tlsCert = resolve7(argv[++i2]);
     else if (a2 === "--tls-key") out.tlsKey = resolve7(argv[++i2]);
     else if (a2 === "--self-signed") out.selfSigned = true;
@@ -39892,7 +40451,7 @@ function assertDirectory(path, flag2) {
 }
 
 // src/roots.ts
-import { promises as fs11 } from "node:fs";
+import { promises as fs13 } from "node:fs";
 import { resolve as resolve8 } from "node:path";
 var DISABLED = "adding working directories is not enabled (no --allow-add-under)";
 function createRootsController(opts) {
@@ -39906,8 +40465,8 @@ function createRootsController(opts) {
     if (!areas.some((a2) => withinRoot(a2, abs))) {
       throw new Error(`path is outside every allowed area: ${abs}`);
     }
-    const real = await fs11.realpath(abs);
-    const realAreas = await Promise.all(areas.map((a2) => fs11.realpath(a2)));
+    const real = await fs13.realpath(abs);
+    const realAreas = await Promise.all(areas.map((a2) => fs13.realpath(a2)));
     if (!realAreas.some((a2) => withinRoot(a2, real))) {
       throw new Error(`path escapes the allowed area via symlink: ${abs}`);
     }
@@ -39932,12 +40491,12 @@ function createRootsController(opts) {
       if (!cloneAreas.some((a2) => withinRoot(a2, abs))) {
         throw new Error(`checkout is outside every --clone-under directory: ${abs}`);
       }
-      const real = await fs11.realpath(abs);
-      const realAreas = await Promise.all(cloneAreas.map((a2) => fs11.realpath(a2)));
+      const real = await fs13.realpath(abs);
+      const realAreas = await Promise.all(cloneAreas.map((a2) => fs13.realpath(a2)));
       if (!realAreas.some((a2) => withinRoot(a2, real))) {
         throw new Error(`checkout escapes its --clone-under directory via symlink: ${abs}`);
       }
-      const st2 = await fs11.stat(abs);
+      const st2 = await fs13.stat(abs);
       if (!st2.isDirectory()) throw new Error(`not a directory: ${abs}`);
       roots.push(abs);
       announce();
@@ -39947,14 +40506,14 @@ function createRootsController(opts) {
       if (path === void 0) return [...areas];
       const abs = resolve8(path);
       await assertInArea(abs);
-      const entries = await fs11.readdir(abs, { withFileTypes: true });
+      const entries = await fs13.readdir(abs, { withFileTypes: true });
       return entries.filter((e2) => e2.isDirectory()).map((e2) => e2.name);
     },
     async add(path) {
       const abs = resolve8(path);
       if (roots.some((r2) => resolve8(r2) === abs)) return;
       await assertInArea(abs);
-      const st2 = await fs11.stat(abs);
+      const st2 = await fs13.stat(abs);
       if (!st2.isDirectory()) throw new Error(`not a directory: ${abs}`);
       roots.push(abs);
       announce();
@@ -39970,8 +40529,8 @@ function createRootsController(opts) {
 
 // src/session/gitSource.ts
 import { spawn as spawn6 } from "node:child_process";
-import { promises as fs12 } from "node:fs";
-import { join as join12, resolve as resolve9 } from "node:path";
+import { promises as fs14 } from "node:fs";
+import { join as join14, resolve as resolve9 } from "node:path";
 var DEFAULT_TIMEOUT_MS3 = 10 * 6e4;
 var ALLOWED_SCHEMES = ["https://", "ssh://", "git+ssh://"];
 var SCP_LIKE = /^[A-Za-z0-9_.-]+@[A-Za-z0-9_.-]+:[A-Za-z0-9_./~-]+$/;
@@ -40044,9 +40603,9 @@ git timed out after ${opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS3}ms` });
       settle({ code: -1, stdout, stderr: `${stderr}
 ${e2 instanceof Error ? e2.message : String(e2)}` });
     });
-    child.on("close", (code) => {
+    child.on("close", (code2) => {
       clearTimeout(timer);
-      settle({ code: code ?? -1, stdout, stderr });
+      settle({ code: code2 ?? -1, stdout, stderr });
     });
   });
 }
@@ -40063,14 +40622,14 @@ function createGitSource(deps) {
     if (!areas.some((a2) => withinRoot(a2, abs))) {
       throw new Error(`clone destination is outside every allowed area: ${abs}`);
     }
-    const realAreas = await Promise.all(areas.map((a2) => fs12.realpath(a2)));
+    const realAreas = await Promise.all(areas.map((a2) => fs14.realpath(a2)));
     if (!realAreas.some((a2) => withinRoot(a2, abs))) {
       throw new Error(`clone destination escapes the allowed area via symlink: ${abs}`);
     }
   }
   async function existing(dir, url) {
     try {
-      const entries = await fs12.readdir(dir);
+      const entries = await fs14.readdir(dir);
       if (entries.length === 0) return "absent";
     } catch {
       return "absent";
@@ -40088,7 +40647,7 @@ function createGitSource(deps) {
       if (!areas.length) throw new Error(DISABLED2);
       assertCloneUrl(spec.url);
       if (spec.ref !== void 0) assertRef(spec.ref);
-      const dir = join12(areas[0], checkoutName(spec.url));
+      const dir = join14(areas[0], checkoutName(spec.url));
       await assertInArea(dir);
       const state = await existing(dir, spec.url);
       if (state === "occupied") {
@@ -40245,8 +40804,8 @@ var JsonRpcPeer = class {
       this.respondError(id, shape.code, shape.message);
     }
   }
-  respondError(id, code, message) {
-    this.write({ jsonrpc: "2.0", id, error: { code, message } });
+  respondError(id, code2, message) {
+    this.write({ jsonrpc: "2.0", id, error: { code: code2, message } });
   }
   write(value) {
     if (this.closed) return;
@@ -40286,6 +40845,10 @@ var JsonRpcPeer = class {
 
 // src/acp/client.ts
 var ACP_PROTOCOL_VERSION = 1;
+function acceptsHttpMcp(agentCapabilities) {
+  const mcp = agentCapabilities.mcpCapabilities;
+  return !!(mcp && typeof mcp === "object" && mcp.http === true);
+}
 function rec2(v2) {
   return typeof v2 === "object" && v2 !== null && !Array.isArray(v2) ? v2 : {};
 }
@@ -40300,6 +40863,10 @@ var AcpClient = class {
   currentMode = null;
   /** Whether the agent said it can reattach to an existing session. */
   canLoad = false;
+  /* Whether the agent accepts HTTP MCP servers. Recorded at initialize, read at
+   * session/new -- the schema defaults it to FALSE, so an agent that says
+   * nothing gets nothing. */
+  httpMcp = false;
   disposed = false;
   constructor(opts) {
     this.opts = opts;
@@ -40310,8 +40877,8 @@ var AcpClient = class {
       ...opts.log ? { log: opts.log } : {}
     });
     opts.transport.onData((chunk) => this.peer.push(chunk));
-    opts.transport.onExit((code) => {
-      this.peer.close(`agent exited (code ${code ?? "null"})`);
+    opts.transport.onExit((code2) => {
+      this.peer.close(`agent exited (code ${code2 ?? "null"})`);
     });
   }
   log(m2) {
@@ -40355,6 +40922,7 @@ var AcpClient = class {
     }));
     const caps = rec2(raw.agentCapabilities);
     this.canLoad = caps.loadSession === true;
+    this.httpMcp = acceptsHttpMcp(caps);
     const methods = Array.isArray(raw.authMethods) ? raw.authMethods : [];
     const version = typeof raw.protocolVersion === "number" ? raw.protocolVersion : ACP_PROTOCOL_VERSION;
     if (version !== ACP_PROTOCOL_VERSION) {
@@ -40367,9 +40935,16 @@ var AcpClient = class {
       authMethods: methods
     };
   }
-  /** `cwd` MUST be absolute per the ACP spec; the caller passes a confined root. */
-  async newSession(cwd) {
-    const raw = rec2(await this.peer.request("session/new", { cwd, mcpServers: [] }));
+  /**
+   * `cwd` MUST be absolute per the ACP spec; the caller passes a confined root.
+   *
+   * `mcpServers` is filtered by what the agent said it can take: this used to
+   * be a hardcoded `[]`, so a user's configured MCP servers never reached the
+   * agent at all and MCP was configurable but inert.
+   */
+  async newSession(cwd, mcpServers = []) {
+    const servers = this.allowedMcp(mcpServers);
+    const raw = rec2(await this.peer.request("session/new", { cwd, mcpServers: servers }));
     const id = str7(raw.sessionId);
     if (!id) throw new Error("acp: agent returned no sessionId");
     this.sessionId = id;
@@ -40382,6 +40957,22 @@ var AcpClient = class {
     this.currentMode = str7(modes.currentModeId) || null;
     return id;
   }
+  /**
+   * The MCP servers this agent will actually accept.
+   *
+   * Silently empty rather than throwing: an agent without the capability is a
+   * normal thing to be pointed at, and refusing to open a session over it would
+   * turn "no MCP here" into "no agent here". Logged once so the absence is
+   * visible rather than mysterious.
+   */
+  allowedMcp(servers) {
+    if (!servers.length) return [];
+    if (!this.httpMcp) {
+      this.log(`acp: agent does not accept HTTP MCP servers \u2014 ${servers.length} not passed`);
+      return [];
+    }
+    return servers;
+  }
   /** True when `session/load` is worth attempting. */
   supportsLoad() {
     return this.canLoad;
@@ -40393,9 +40984,9 @@ var AcpClient = class {
    * this resolves, which is what lets a caller rebuild a transcript it lost —
    * so the update handler must be wired before calling, not after.
    */
-  async loadSession(sessionId, cwd) {
+  async loadSession(sessionId, cwd, mcpServers = []) {
     if (!this.canLoad) throw new Error("agent cannot load an existing session");
-    await this.peer.request("session/load", { sessionId, cwd, mcpServers: [] });
+    await this.peer.request("session/load", { sessionId, cwd, mcpServers: this.allowedMcp(mcpServers) });
     this.sessionId = sessionId;
   }
   availableModes() {
@@ -40490,7 +41081,7 @@ function spawnAcpTransport(target, cwd, log, env) {
       if (!killed && child.stdin.writable) child.stdin.write(line);
     },
     onData: (cb) => child.stdout.on("data", (d2) => cb(d2)),
-    onExit: (cb) => child.on("exit", (code) => cb(code)),
+    onExit: (cb) => child.on("exit", (code2) => cb(code2)),
     kill: () => {
       if (killed) return;
       killed = true;
@@ -40789,7 +41380,7 @@ function makeAcpService(deps) {
   return {
     targets: () => targetIds(),
     async start(targetId, onUpdate, opts) {
-      const { root, modeId, resume } = opts ?? {};
+      const { root, modeId, resume, mcpServers } = opts ?? {};
       const target = resolveTarget(targetId);
       if (!target) {
         throw new Error(`unknown ACP target "${targetId}" (known: ${targetIds().join(", ")})`);
@@ -40823,7 +41414,7 @@ function makeAcpService(deps) {
         let resumed = false;
         if (resume && c2.supportsLoad()) {
           try {
-            await c2.loadSession(resume, cwd);
+            await c2.loadSession(resume, cwd, mcpServers ?? []);
             sessionId = resume;
             resumed = true;
             log(`acp: reattached to session ${resume}`);
@@ -40833,7 +41424,7 @@ function makeAcpService(deps) {
         } else if (resume) {
           log(`acp: ${target.label} cannot reattach to a session \u2014 starting a new one`);
         }
-        if (!sessionId) sessionId = await c2.newSession(cwd);
+        if (!sessionId) sessionId = await c2.newSession(cwd, mcpServers ?? []);
         if (!resumed && modeId && c2.availableModes().some((m2) => m2.id === modeId)) {
           await c2.setMode(modeId);
           log(`acp: mode set to ${modeId} (requested by the client)`);
@@ -41175,7 +41766,7 @@ function awaitCallback(pkce, port, timeoutMs) {
       return;
     }
     const err = url.searchParams.get("error");
-    const code = url.searchParams.get("code");
+    const code2 = url.searchParams.get("code");
     const state = url.searchParams.get("state");
     if (!stateMatches(pkce.state, state)) {
       res.writeHead(400, { "content-type": "text/html" }).end(PAGE_FAIL);
@@ -41187,13 +41778,13 @@ function awaitCallback(pkce, port, timeoutMs) {
       rejectResult(new Error(`authorization failed: ${err}`));
       return;
     }
-    if (!code) {
+    if (!code2) {
       res.writeHead(400, { "content-type": "text/html" }).end(PAGE_FAIL);
       rejectResult(new Error("callback carried no authorization code"));
       return;
     }
     res.writeHead(200, { "content-type": "text/html" }).end(PAGE_OK);
-    resolveResult({ code });
+    resolveResult({ code: code2 });
   });
   const timer = setTimeout(() => {
     rejectResult(new Error("timed out waiting for the browser callback"));
@@ -41233,11 +41824,11 @@ async function login(deps) {
     log("Opening your browser to sign in...");
     log(url);
     await deps.openBrowser(url);
-    const { code } = await result;
+    const { code: code2 } = await result;
     const tokens = await deps.exchange({
       issuer: deps.config.issuer,
       clientId: deps.config.clientId,
-      code,
+      code: code2,
       verifier: pkce.verifier,
       redirectUri
     });
@@ -41373,8 +41964,8 @@ async function main() {
   if (rawArgv[0] === "login" || rawArgv[0] === "logout" || rawArgv[0] === "auth") {
     const sub = rawArgv[0];
     const parsed = parseArgs(rawArgv.slice(1));
-    const code = sub === "login" ? await runLogin(parsed.stateDir) : sub === "logout" ? await runLogout(parsed.stateDir) : await runAuthStatus(parsed.stateDir);
-    process.exit(code);
+    const code2 = sub === "login" ? await runLogin(parsed.stateDir) : sub === "logout" ? await runLogout(parsed.stateDir) : await runAuthStatus(parsed.stateDir);
+    process.exit(code2);
   }
   if (rawArgv[0] === "acp-agent") {
     await runAcpAgent(rawArgv.slice(1));
@@ -41385,9 +41976,23 @@ async function main() {
   validateArgs(args);
   const rootsController = createRootsController({ roots: args.roots, areas: args.addUnder, cloneAreas: args.cloneUnder });
   const token = await loadOrCreateToken();
-  const sidecarId = await loadOrCreateSidecarId(args.stateDir);
+  try {
+    const note = (line) => {
+      process.stdout.write(`  ${line}
+`);
+    };
+    const migrated = await migrateHomeLayout();
+    if (migrated.moved.length) {
+      note(`layout: moved ${migrated.moved.length} item(s) into the current ~/${stateDirName()} layout`);
+    }
+    for (const left of migrated.skipped) note(`layout: left ${left.path} alone (${left.reason})`);
+  } catch (e2) {
+    process.stdout.write(`  layout: migration skipped (${e2 instanceof Error ? e2.message : String(e2)})
+`);
+  }
+  const sidecarId = await loadOrCreateSidecarId(sidecarSubdir(args.stateDir));
   const friendlyName = sidecarName({ name: args.name });
-  const hosts = makeHostsManifest(args.stateDir);
+  const hosts = makeHostsManifest(sidecarSubdir(args.stateDir));
   if (args.tlsCert && !args.tlsKey || !args.tlsCert && args.tlsKey) {
     throw new Error("TLS needs both --tls-cert and --tls-key");
   }
@@ -41413,7 +42018,9 @@ async function main() {
     process.stdout.write(`  [${(/* @__PURE__ */ new Date()).toTimeString().slice(0, 8)}] ${line}
 `);
   };
-  await checkHostsDrift(args.stateDir, hosts, slog);
+  await assertPortFree(probeAddress(args.host), args.port);
+  await assertStateDirFree(sidecarSubdir(args.stateDir));
+  await checkHostsDrift(sidecarSubdir(args.stateDir), hosts, slog);
   const hostSync = makeHostSync({ stateDir: args.stateDir, manifest: hosts, log: slog });
   const attendance = makeAttendanceRegistry({ log: slog });
   const runs = makeRunHub({ log: slog });
@@ -41425,6 +42032,25 @@ async function main() {
     roots: args.roots,
     allowShell: args.allowShell,
     defaultModel: args.defaultModel,
+    /* Which approved root this agent works in.
+     *
+     * MEMBERSHIP, never a prefix test. A prefix check would accept
+     * `<approved>/../elsewhere`, and the operator's `--root` list is the
+     * whole security boundary here: an agent definition can be PUSHED from a
+     * browser, so `settings.workRoot` is a request from a client the daemon
+     * does not trust -- exactly like the clientId that resolveIdentity
+     * refuses to take at face value.
+     *
+     * An unrecognised root falls back to the primary rather than refusing to
+     * run. Removing a --root should not silently convert an agent into a
+     * dead one; it runs where it always did, and the browser is what reports
+     * the mismatch. */
+    workRootFor: (def) => {
+      const want = def.settings.workRoots?.[sidecarId];
+      if (want && args.roots.includes(want)) return want;
+      if (want) slog(`crew: "${def.name}" asks for root "${want}", which is not approved \u2014 using ${args.roots[0]}`);
+      return args.roots[0];
+    },
     onScheduleSelf: () => core?.wake(),
     // The mirror's cue. Late-bound like `core` below: the runner is built
     // before the control plane, and a session cannot be written before both
@@ -41447,9 +42073,11 @@ async function main() {
   if (args.daemon && runner) {
     const flipped = await runner.reconcilePendingOnBoot();
     if (flipped > 0) slog(`daemon: marked ${flipped} stale pending permission record(s) dead (daemon restarted)`);
+    const hostCrewDirs = (await listOwnerRoots(args.stateDir)).filter((r2) => r2.owner !== "").map((r2) => join15(hostsDirFor(args.stateDir, r2.owner), "crew"));
     const watchDirs = [
-      join13(args.stateDir, "crew"),
-      ...args.roots.map((r2) => join13(r2, stateDirName(), "crew"))
+      join15(args.stateDir, "crew"),
+      ...args.roots.map((r2) => join15(r2, stateDirName(), "crew")),
+      ...hostCrewDirs
     ];
     core = startDaemonCore({
       // Task 12: the stall watchdog scans the SAME runner's in-flight runs
@@ -41554,7 +42182,6 @@ async function main() {
       controlPlane = null;
     }
   }
-  await assertPortFree(probeAddress(args.host), args.port);
   const procs = args.allowShell ? createNodeProcs({ roots: args.roots, log: slog }) : void 0;
   const sessions = runner ? await wireSessions({
     isolation: args.isolation,
@@ -41562,6 +42189,7 @@ async function main() {
     runner,
     image: args.guestImage,
     msbBin: args.msbBin,
+    snapshotBudgetBytes: args.snapshotBudgetBytes,
     log: slog,
     // Metadata for every session run, filed under the CALLER'S own root. The
     // runner service owns owner resolution (a wire-supplied clientId is
@@ -41637,6 +42265,9 @@ async function main() {
     },
     hostSync
   });
+  await writePidFile(sidecarSubdir(args.stateDir), args.port).catch((e2) => {
+    slog(`state dir: could not record this daemon's pid (${e2 instanceof Error ? e2.message : String(e2)})`);
+  });
   let tunnelSup = null;
   let tunnelWss = null;
   if (tunnelProvider) {
@@ -41698,6 +42329,7 @@ async function main() {
     openBrowser2(target);
   }
   const shutdown = () => {
+    void clearPidFile(sidecarSubdir(args.stateDir));
     procs?.shutdown();
     const alive = sessions?.backend.list() ?? [];
     if (alive.length) {
@@ -41714,8 +42346,8 @@ async function main() {
   process.on("SIGTERM", shutdown);
 }
 main().catch((e2) => {
-  const code = e2?.code;
-  const msg = code === "EADDRINUSE" ? `port already in use \u2014 another sidecar may be running. Stop it, or pass --port <n>.` : e2 instanceof Error ? e2.message : String(e2);
+  const code2 = e2?.code;
+  const msg = code2 === "EADDRINUSE" ? `port already in use \u2014 another sidecar may be running. Stop it, or pass --port <n>.` : e2 instanceof Error ? e2.message : String(e2);
   process.stderr.write(`corenel-sidecar: ${msg}
 `);
   process.exit(1);