@corenel/sidecar 0.4.0 → 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";
 
@@ -22041,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) {
@@ -22507,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";
@@ -22524,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;
@@ -23142,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 "";
     }
@@ -23173,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;
@@ -23213,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();
@@ -23265,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) {
@@ -23282,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) {
@@ -23314,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");
       }
     },
     {
@@ -23338,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}`;
       }
     },
@@ -23357,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");
       }
     },
     {
@@ -23376,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");
       }
     },
@@ -23395,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}`;
       }
     }
@@ -23458,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}`);
@@ -23534,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() {
@@ -23623,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 [];
@@ -23740,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;
@@ -23750,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.
@@ -23767,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 {
@@ -23789,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));
@@ -23807,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 }));
@@ -24068,8 +24135,8 @@ 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";
+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",
@@ -24092,7 +24159,7 @@ var COVERAGE_REPORT_MARKERS = /* @__PURE__ */ new Set([
 ]);
 async function looksLikeGeneratedCoverage(absDir) {
   try {
-    const names = await fs4.readdir(absDir);
+    const names = await fs5.readdir(absDir);
     return names.some((n2) => COVERAGE_REPORT_MARKERS.has(n2));
   } catch {
     return false;
@@ -24135,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}`);
@@ -24163,21 +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) });
         }
       }
@@ -24186,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;
@@ -24198,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();
@@ -24429,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");
@@ -24455,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");
@@ -24498,9 +24565,9 @@ 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 });
     });
   });
 }
@@ -24675,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`);
@@ -25148,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" };
       };
@@ -25291,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 authTokenPath() {
-  return join4(corenelDir2(), "token");
+function sidecarDir(base = homedir3()) {
+  return join5(corenelDir2(base), "sidecar");
+}
+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;
@@ -27067,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 {
@@ -27106,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) {
@@ -27129,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 || {};
@@ -27687,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];
@@ -27698,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({
@@ -28076,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 });
@@ -28144,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 = [];
@@ -28158,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 {
@@ -28181,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 };
 }
 
@@ -28289,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(() => {
@@ -28427,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(() => {
@@ -28682,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);
@@ -28689,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 {
@@ -30075,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 = {
@@ -36933,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";
@@ -38446,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) {
@@ -38926,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)}`);
     }
   }
@@ -38955,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;
@@ -39235,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;
@@ -39267,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;
@@ -39303,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);
@@ -39324,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();
   }
@@ -39343,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;
   }
 }
@@ -39498,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]) => ({
@@ -39522,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,
@@ -39533,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 [];
   }
@@ -40025,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)." },
@@ -40075,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.",
     "",
@@ -40274,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) {
@@ -40288,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}`);
     }
@@ -40314,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();
@@ -40329,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();
@@ -40352,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_./~-]+$/;
@@ -40426,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 });
     });
   });
 }
@@ -40445,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";
@@ -40470,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") {
@@ -40627,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;
@@ -40668,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 : {};
 }
@@ -40682,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;
@@ -40692,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) {
@@ -40737,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) {
@@ -40749,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;
@@ -40764,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;
@@ -40775,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() {
@@ -40872,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;
@@ -41171,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(", ")})`);
@@ -41205,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}`);
@@ -41215,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)`);
@@ -41557,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);
@@ -41569,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"));
@@ -41615,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
     });
@@ -41755,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));
@@ -41767,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");
   }
@@ -41795,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 });
@@ -41807,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
@@ -41829,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
@@ -41936,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,
@@ -42020,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) {
@@ -42081,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) {
@@ -42097,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);