baychat 0.13.1 → 0.15.0

package/dist/relay/owner-pid.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.procTable = void 0;
+exports.ownerPidFor = ownerPidFor;
+exports.isRuntimeCommand = isRuntimeCommand;
+exports.currentOwnerPid = currentOwnerPid;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** How far to walk before giving up. Deep enough for shell wrappers, bounded so a cycle cannot hang an attach. */
+const MAX_HOPS = 12;
+/**
+ * The nearest ancestor that IS this runtime, or undefined when none is found.
+ *
+ * Undefined rather than a fallback to `ppid` on purpose: a witness that lies is
+ * worse than no witness. With none, the daemon keeps its previous behaviour and
+ * may spawn headlessly — the old bug. With a wrong one it spawns headlessly
+ * while the session is alive — the worse bug, and a silent one.
+ */
+function ownerPidFor(runtime, startPid, table) {
+    let pid = startPid;
+    const seen = new Set();
+    for (let hop = 0; hop < MAX_HOPS; hop++) {
+        if (pid <= 1 || seen.has(pid))
+            return undefined;
+        seen.add(pid);
+        if (isRuntimeCommand(table.commandOf(pid), runtime))
+            return pid;
+        const parent = table.parentOf(pid);
+        if (parent === undefined)
+            return undefined;
+        pid = parent;
+    }
+    return undefined;
+}
+/**
+ * Whether a command line IS the runtime, rather than merely mentioning it.
+ *
+ * Only the first two tokens are considered — the executable, and the script when
+ * that executable is an interpreter. The attach process itself runs
+ * `node …/baychat relay attach --runtime claude`, which CONTAINS "claude" as an
+ * argument; matching anywhere on the line would make every attach its own owner
+ * and defeat the check entirely.
+ */
+function isRuntimeCommand(command, runtime) {
+    if (!command)
+        return false;
+    const tokens = command.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return false;
+    if (namesRuntime(tokens[0], runtime))
+        return true;
+    // An interpreter's SCRIPT is the real executable: `node …/codex/bin/codex.js`
+    // is Codex. Only consulted behind an interpreter, and only for something that
+    // looks like a path — otherwise `grep claude syslog` would match its own
+    // search term, and every attach would match its own `--runtime claude`.
+    if (!INTERPRETERS.has(path.basename(tokens[0]).toLowerCase()))
+        return false;
+    const script = tokens[1];
+    if (!script || !/[\\/]/.test(script))
+        return false;
+    return namesRuntime(script, runtime);
+}
+const INTERPRETERS = new Set(["node", "node.exe", "bun", "deno", "python", "python3"]);
+/** `claude`, `claude.exe`, `codex.js` — the runtime's binary, however spelled. Not `claudette`. */
+function namesRuntime(token, runtime) {
+    const base = path.basename(token).toLowerCase();
+    return base === runtime || base.startsWith(`${runtime}.`);
+}
+/** Reads the live process tree from /proc. Returns nothing where /proc is absent (macOS, Windows). */
+exports.procTable = {
+    parentOf(pid) {
+        try {
+            // Field 4 of /proc/<pid>/stat is ppid. Read past the comm field, which is
+            // parenthesised and may itself contain spaces.
+            const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+            const after = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/);
+            const ppid = Number(after[1]);
+            return Number.isFinite(ppid) ? ppid : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    commandOf(pid) {
+        try {
+            return fs.readFileSync(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ").trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+};
+/** The owning runtime process for THIS attach, read from the live tree. */
+function currentOwnerPid(runtime) {
+    return ownerPidFor(runtime, process.ppid, exports.procTable);
+}

package/dist/relay/parent-watch.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Tie an attach process's life to the session that started it.
+ *
+ * WHY THIS EXISTS. `baychat relay attach` is launched in the background by a
+ * session and then blocks. Nothing connected the two: when the session ended —
+ * a `/clear`, an exit, a crash — the attach kept running, was reparented to
+ * init/systemd, and kept its socket open. The daemon reads "socket open" as
+ * "session alive", so it wrote the next wake into a dead session's socket, the
+ * orphan printed it to a terminal nobody was reading, and the relay recorded
+ * `woken via attach` — a success, for a message that was destroyed.
+ *
+ * Measured on 2026-08-30: TWO orphans were stacked on one session name, and the
+ * registry still carried the dead session's resume id, so the eventual headless
+ * fallback resumed the OLD conversation and answered the room as if it were the
+ * live session. Both halves of that failure are this one missing link.
+ *
+ * The check is "is my original parent still alive", not "has my parent changed":
+ * Windows does not reparent orphans, so a changed ppid is a Unix-only signal,
+ * while `kill(pid, 0)` answers on both. PID reuse can in principle make a dead
+ * parent look alive; that costs us one stale attach, which is the situation we
+ * are already in, and never the reverse.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processIsAlive = processIsAlive;
+exports.watchParent = watchParent;
+/** Does this process still exist? Signal 0 checks existence without delivering. */
+function processIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 1)
+        return true; // 0/1 are not a session we can track.
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM means it exists and belongs to someone else — alive, just not ours.
+        return err.code === "EPERM";
+    }
+}
+/**
+ * Call `onParentGone` once, as soon as `parentPid` is no longer running.
+ *
+ * `unref`ed so it can never be the reason a process stays up: an attach that is
+ * otherwise finished must still exit promptly.
+ */
+function watchParent(parentPid, onParentGone, opts = {}) {
+    const intervalMs = opts.intervalMs ?? 5_000;
+    const isAlive = opts.isAlive ?? processIsAlive;
+    const setIv = opts.setInterval ?? setInterval;
+    const clearIv = opts.clearInterval ?? clearInterval;
+    let fired = false;
+    const timer = setIv(() => {
+        if (fired)
+            return;
+        if (isAlive(parentPid))
+            return;
+        fired = true;
+        clearIv(timer);
+        onParentGone();
+    }, intervalMs);
+    timer.unref?.();
+    return {
+        stop: () => {
+            fired = true;
+            clearIv(timer);
+        },
+    };
+}

package/dist/relay/registry.js

@@ -121,6 +121,17 @@ class SessionRegistry {
         if (t)
             t.attached = attached;
     }
+    /**
+     * Record that a delivery to this session actually landed.
+     *
+     * Separate from `setAttached` because it means something stronger: attached is
+     * a state that can be claimed, this is an event that was observed.
+     */
+    markDelivered(name, at) {
+        const t = this.sessions.get(name);
+        if (t)
+            t.lastDeliveredAt = at;
+    }
     /**
      * Drop targets whose session is no longer live server-side.
      *

package/dist/relay/resume.js

@@ -75,6 +75,7 @@ exports.resumeIdFromSessionEnv = resumeIdFromSessionEnv;
 exports.discoverClaudeResume = discoverClaudeResume;
 exports.discoverCodexResume = discoverCodexResume;
 exports.discoverResume = discoverResume;
+exports.codexRoots = codexRoots;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -224,7 +225,7 @@ async function resumeIdFromSessionEnv(runtime, opts = {}) {
     if (!roll) {
         return {
             ok: false,
-            reason: `$${varName} names ${truncate(raw, 40)} but no top-level Codex rollout under ${codexRoot(opts)} has that id — refusing to record an id we cannot corroborate`,
+            reason: `$${varName} names ${truncate(raw, 40)} but no top-level Codex rollout under ${codexRoots(opts).join(" or ")} has that id — refusing to record an id we cannot corroborate`,
         };
     }
     return {
@@ -279,10 +280,10 @@ async function discoverClaudeResume(sessionName, opts = {}) {
  *    would refuse itself into permanent pending.
  */
 async function discoverCodexResume(sessionName, opts = {}) {
-    const root = codexRoot(opts);
-    const files = listCodexRollouts(root, opts);
+    const roots = codexRoots(opts);
+    const files = listCodexRollouts(roots, opts);
     if (files.length === 0) {
-        return { ok: false, reason: `no Codex rollouts under ${short(root)} to search` };
+        return { ok: false, reason: `no Codex rollouts under ${roots.map(short).join(" or ")} to search` };
     }
     const byConversation = new Map();
     for (const file of files) {
@@ -298,7 +299,7 @@ async function discoverCodexResume(sessionName, opts = {}) {
             byConversation.set(meta.resumeId, { resumeId: meta.resumeId, file, cwd: meta.cwd });
         }
     }
-    return oneOrRefuse([...byConversation.values()], sessionName, "Codex", root);
+    return oneOrRefuse([...byConversation.values()], sessionName, "Codex", roots.map(short).join(" or "));
 }
 /** Route to the runtime's discovery, or say the runtime has none. */
 async function discoverResume(target, opts = {}) {
@@ -415,8 +416,32 @@ function codexCommands(raw) {
 function claudeRoot(opts) {
     return opts.claudeProjectsDir ?? path.join(os.homedir(), ".claude", "projects");
 }
-function codexRoot(opts) {
-    return opts.codexSessionsDir ?? path.join(os.homedir(), ".codex", "sessions");
+/**
+ * Every directory a Codex on this machine may keep its rollouts in.
+ *
+ * NOT just `~/.codex/sessions`. A snap-installed Codex runs confined with its
+ * own HOME, so its rollouts land under `~/snap/codex/current/sessions` and the
+ * canonical directory never sees them. Searching only the canonical one means a
+ * snap session can never be identified, and is therefore permanently
+ * unreachable while detached — reported DELIVERY PENDING forever, with a reason
+ * that says no rollout recorded this attach, which is true and useless.
+ *
+ * Measured on 2026-08-30: 29 rollouts under ~/.codex/sessions from an npm
+ * install, and 1 under ~/snap/codex/34/sessions from the snap that was actually
+ * being run.
+ *
+ * An injected directory stays exclusive — a test that names a root means that
+ * root and not "that root plus whatever this machine happens to have".
+ */
+function codexRoots(opts, home = os.homedir()) {
+    if (opts.codexSessionsDir)
+        return [opts.codexSessionsDir];
+    return [
+        path.join(home, ".codex", "sessions"),
+        // `current` is snap's symlink to the live revision, so this keeps working
+        // across a snap refresh.
+        path.join(home, "snap", "codex", "current", "sessions"),
+    ];
 }
 /** `~/.claude/projects/<slug>/<uuid>.jsonl`, newest first, bounded. */
 function listClaudeTranscripts(root, opts) {
@@ -443,8 +468,8 @@ function listClaudeTranscripts(root, opts) {
     }
     return out.sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, opts.maxFiles ?? DEFAULT_MAX_FILES);
 }
-/** `~/.codex/sessions/**\/rollout-*.jsonl`, newest first, bounded. */
-function listCodexRollouts(root, opts) {
+/** `<root>/**\/rollout-*.jsonl` across every root, newest first, bounded. */
+function listCodexRollouts(roots, opts) {
     const cutoff = Date.now() - (opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS);
     const found = [];
     const walk = (dir, depth) => {
@@ -464,7 +489,10 @@ function listCodexRollouts(root, opts) {
             found.push({ file: p, mtimeMs });
         }
     };
-    walk(root, 0);
+    for (const root of roots)
+        walk(root, 0);
+    // Sorted across ALL roots together: newest-first has to mean newest on this
+    // machine, not newest within whichever directory was searched first.
     return found
         .sort((a, b) => b.mtimeMs - a.mtimeMs)
         .slice(0, opts.maxFiles ?? DEFAULT_MAX_FILES)
@@ -488,7 +516,7 @@ async function readCodexMeta(file) {
 }
 /** Locate a Codex rollout by conversation id, ignoring subagent threads. */
 async function codexRolloutById(id, opts) {
-    for (const file of listCodexRollouts(codexRoot(opts), opts)) {
+    for (const file of listCodexRollouts(codexRoots(opts), opts)) {
         const meta = await readCodexMeta(file);
         if (!meta || meta.isSubagent)
             continue;

package/dist/relay/socket.js

@@ -34,11 +34,15 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.socketPath = socketPath;
+exports.unconfineRuntimeDir = unconfineRuntimeDir;
 exports.isNamedPipe = isNamedPipe;
 exports.pidFilePath = pidFilePath;
 exports.createFrameReader = createFrameReader;
 exports.writeFrame = writeFrame;
+exports.writeFrameAck = writeFrameAck;
+exports.probeSocketDetailed = probeSocketDetailed;
 exports.probeSocket = probeSocket;
+exports.describeProbeFailure = describeProbeFailure;
 exports.unlinkStaleSocket = unlinkStaleSocket;
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
@@ -76,9 +80,34 @@ function socketPath() {
     }
     const runtimeDir = process.env.XDG_RUNTIME_DIR;
     if (runtimeDir)
-        return path.join(runtimeDir, "baychat-relay.sock");
+        return path.join(unconfineRuntimeDir(runtimeDir), "baychat-relay.sock");
     return path.join((0, config_1.configDir)(), "relay.sock");
 }
+/**
+ * The runtime dir the RELAY uses, as seen from inside a snap.
+ *
+ * A confined snap does not get the user's `XDG_RUNTIME_DIR`: snapd rewrites it
+ * to a private subdirectory, `/run/user/1000/snap.codex`. A snap-installed Codex
+ * therefore computes a socket path no relay has ever listened on, finds nothing,
+ * and reports "no relay is running" — while the real socket sits one level up,
+ * readable and connectable by the same uid. Verified on 2026-08-30: from inside
+ * `snap run --shell codex`, `/run/user/1000/baychat-relay.sock` connects fine;
+ * only the path was wrong.
+ *
+ * This is RECURRING_MISTAKES §24 again — "where it keeps its state" is not
+ * "where this copy reads" — and the same shape as `codexRoots`, which already
+ * has to know that a snap Codex keeps its rollouts somewhere else.
+ *
+ * Guarded on `SNAP` so an ordinary process is never second-guessed, and it only
+ * strips a segment that actually looks like snapd's, so a user whose runtime dir
+ * legitimately ends in something else is left alone.
+ */
+function unconfineRuntimeDir(runtimeDir, env = process.env) {
+    if (!env.SNAP)
+        return runtimeDir;
+    const parent = path.dirname(runtimeDir);
+    return /^snap\.[^/\\]+$/.test(path.basename(runtimeDir)) ? parent : runtimeDir;
+}
 /** A pipe name may not contain a backslash — it would read as another level of
  * the pipe namespace — and Windows usernames legally can (`DOMAIN\user` reaches
  * `os.userInfo()` that way on some setups). Everything outside the safe set is
@@ -129,31 +158,134 @@ function writeFrame(sock, frame) {
     sock.write(JSON.stringify(frame) + "\n");
 }
 /**
- * Is a daemon already listening?
+ * Write a frame and WAIT for the socket to take it, surfacing the failure if it
+ * does not.
+ *
+ * `writeFrame` is fire-and-forget. `sock.write()` buffers and returns, so a peer
+ * that has already gone produces an EPIPE on the socket's `error` event LATER —
+ * by which time the caller has recorded `woken`. That is a lost message filed as
+ * delivered, which is the single outcome `relay status` exists to make
+ * impossible: every other failure is at least visible as pending.
+ *
+ * Three ways this settles, and all three are needed. The write callback covers
+ * the ordinary case; the `error` event covers an EPIPE that arrives without one;
+ * `close` covers a peer that vanishes while the bytes are still buffered, which
+ * reports no error at all.
  *
- * A socket file on disk proves nothing — a killed daemon leaves one behind. The
- * only honest test is to connect: ECONNREFUSED means the file is stale and safe
- * to unlink, which is what lets `relay start` recover from a hard kill without
- * a human deleting files.
+ * HONEST LIMIT — this is a FLUSH confirmation, not a receiver acknowledgement.
+ * It proves the bytes left this process, not that the agent read them. A true
+ * end-to-end ack needs an `ack` frame back from the attach client, and every
+ * already-installed client would have to be taught to send one before the
+ * daemon could require it. What this closes is the failure that was actually
+ * observed — a dead peer recorded as woken — not the whole class.
  */
-function probeSocket(sockPath, timeoutMs = 1_000) {
+function writeFrameAck(sock, frame) {
+    return new Promise((resolve, reject) => {
+        if (sock.destroyed || sock.writableEnded) {
+            reject(new Error("the attach socket is already closed"));
+            return;
+        }
+        let settled = false;
+        const settle = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            sock.off("error", onError);
+            sock.off("close", onClose);
+            if (err)
+                reject(err);
+            else
+                resolve();
+        };
+        const onError = (err) => settle(err);
+        const onClose = () => settle(new Error("the attach socket closed before the frame was flushed"));
+        sock.once("error", onError);
+        sock.once("close", onClose);
+        sock.write(JSON.stringify(frame) + "\n", (err) => settle(err ?? undefined));
+    });
+}
+/**
+ * Probe the attach endpoint, KEEPING THE REASON IT FAILED.
+ *
+ * The boolean version of this threw the errno away, and every distinct failure
+ * arrived at the user as one sentence: "no relay is running". That sentence is
+ * true for exactly one of them. A sandboxed or differently-elevated shell that
+ * is REFUSED the pipe (EACCES/EPERM) is told the daemon does not exist, so the
+ * obvious next move is `relay start` — which spawns a SECOND daemon, and two
+ * daemons on one credential is a materially worse state than the one we were
+ * diagnosing. A wedged daemon that never accepts is likewise reported as absent.
+ *
+ * Measured on 2026-08-30: a Codex session on Windows reported "no relay is
+ * running" while a healthy relay (pid 16388) held four of its messages, and the
+ * CLI could not say which of these it had hit. Hence the reason code.
+ */
+function probeSocketDetailed(sockPath, timeoutMs = 1_000) {
     return new Promise((resolve) => {
         // The existence check is a cheap way to skip a connect that cannot succeed —
         // but a named pipe has no directory entry, so on Windows it answers "false"
         // for a perfectly healthy daemon. Skipped there; the connect below is the
         // honest test on every platform anyway.
-        if (!isNamedPipe(sockPath) && !fs.existsSync(sockPath))
-            return resolve(false);
+        if (!isNamedPipe(sockPath)) {
+            // `fs.existsSync` cannot be used here: it answers false for BOTH "there is
+            // nothing at this path" and "you may not look at this path", which is the
+            // very conflation this function exists to end. `statSync` throws an errno
+            // that separates them.
+            try {
+                fs.statSync(sockPath);
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === "ENOENT")
+                    return resolve({ alive: false, reason: "absent" });
+                const reason = code === "EACCES" || code === "EPERM" ? "denied" : "error";
+                return resolve({ alive: false, reason, code, detail: err.message });
+            }
+        }
         const sock = net.createConnection(sockPath);
-        const done = (alive) => {
+        const done = (result) => {
             sock.destroy();
-            resolve(alive);
+            resolve(result);
         };
-        sock.setTimeout(timeoutMs, () => done(false));
-        sock.on("connect", () => done(true));
-        sock.on("error", () => done(false));
+        sock.setTimeout(timeoutMs, () => done({ alive: false, reason: "timeout" }));
+        sock.on("connect", () => done({ alive: true }));
+        sock.on("error", (err) => {
+            const code = err.code;
+            // ENOENT/ECONNREFUSED genuinely mean nothing is listening. EACCES/EPERM
+            // mean something IS there and we were refused — the opposite diagnosis.
+            const reason = code === "ENOENT" || code === "ECONNREFUSED" ? "absent" : code === "EACCES" || code === "EPERM" ? "denied" : "error";
+            done({ alive: false, reason, code, detail: err.message });
+        });
     });
 }
+function probeSocket(sockPath, timeoutMs = 1_000) {
+    return probeSocketDetailed(sockPath, timeoutMs).then((r) => r.alive);
+}
+/**
+ * Turn a failed probe into a sentence that names the ACTUAL obstacle.
+ *
+ * Only `absent` may suggest `relay start`; the others must not, because
+ * starting a second daemon is the wrong move for all of them.
+ */
+function describeProbeFailure(sockPath, result) {
+    if (result.alive)
+        return "";
+    switch (result.reason) {
+        case "absent":
+            return "no relay is running — start one with `baychat relay start`";
+        case "denied":
+            return (`a relay endpoint exists at ${sockPath} but this process was refused it (${result.code}). ` +
+                `That is a permission boundary, not a missing daemon — do NOT run \`relay start\`, which would ` +
+                `create a second one. It usually means this shell runs under a different token than the relay ` +
+                `(an elevated or sandboxed shell), so run from a normal shell as the same user, or restart the ` +
+                `relay from this shell.`);
+        case "timeout":
+            return (`a relay is listening at ${sockPath} but did not accept a connection within ${1_000}ms — it is ` +
+                `probably wedged rather than absent. Check \`relay status\` from the shell that started it, and ` +
+                `stop that daemon before starting another.`);
+        default:
+            return `could not reach the relay at ${sockPath}: ${result.code ?? "unknown error"}${result.detail ? ` (${result.detail})` : ""}`;
+    }
+}
 /** Remove a socket file we have already proven dead.
  *
  * A no-op for a named pipe, which has nothing on disk to remove: Windows tears

package/dist/relay/spawn-env.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headlessSpawnEnv = headlessSpawnEnv;
+const path = __importStar(require("path"));
+/**
+ * The environment a headless turn is spawned with.
+ *
+ * WHY THIS EXISTS. A runtime installed by npm is a JavaScript file with a
+ * `#!/usr/bin/env node` shebang, so running it asks the SPAWNING process's PATH
+ * to find `node`. The relay daemon runs under systemd, whose PATH is a minimal
+ * system one — it does not contain nvm's node, or any node at all on a machine
+ * where node was never installed system-wide.
+ *
+ * Measured 2026-08-31 00:06: the headless rung became reachable for the first
+ * time and every wake died instantly with
+ * `/usr/bin/env: 'node': No such file or directory`, exit 127. The binary was
+ * correct and present; nothing could run it.
+ *
+ * This is `SessionTarget.runtimeBin` one layer down. That rule says the session
+ * identifies its own binary because only it can; this says the daemon must also
+ * hand that binary an environment it can actually start in — and the daemon is
+ * the only process that knows where its own node lives (`process.execPath`,
+ * which is exactly the interpreter a shebang is looking for).
+ *
+ * PREPENDED, not replaced: a runtime may legitimately need the rest of the
+ * inherited PATH to find its own helpers, and clobbering it would trade this
+ * failure for a subtler one.
+ */
+function headlessSpawnEnv(env = process.env, execPath = process.execPath) {
+    const nodeDir = path.dirname(execPath);
+    const current = env.PATH ?? "";
+    const parts = current.split(path.delimiter).filter(Boolean);
+    if (parts.includes(nodeDir))
+        return env;
+    return { ...env, PATH: [nodeDir, ...parts].join(path.delimiter) };
+}