usebeeline 0.1.126 → 0.1.130

package/dist/usebeeline.mjs

@@ -44,13 +44,13 @@ async function withKernelLock(key, work, waitMs = 6e5) {
     }
     const remaining = deadline - Date.now();
     if (remaining <= 0)
-      throw new Error("timed out waiting for Beeline installer owner");
+      throw new KernelLockBusyError();
     await new Promise((done, reject) => {
       const peer = createConnection2(address);
       peer.resume();
       const timer = setTimeout(() => {
         peer.destroy();
-        reject(new Error("timed out waiting for Beeline installer owner"));
+        reject(new KernelLockBusyError());
       }, remaining);
       const finish = () => {
         clearTimeout(timer);
@@ -62,9 +62,15 @@ async function withKernelLock(key, work, waitMs = 6e5) {
     });
   }
 }
+var KernelLockBusyError;
 var init_kernel_lock = __esm({
   "apps/body/dist/kernel-lock.js"() {
     "use strict";
+    KernelLockBusyError = class extends Error {
+      constructor() {
+        super("timed out waiting for Beeline installer owner");
+      }
+    };
   }
 });
 
@@ -1660,7 +1666,7 @@ async function registerClient(server, clientName) {
     throw new Error(`Beeline refused the registration (HTTP ${status})`);
   return value.client_id;
 }
-function signInLink(server, clientId, memberName) {
+function signInLink(server, clientId, memberName, claudeInboundFallback = false) {
   const verifier = opaque(), state = opaque();
   const query = new URLSearchParams({
     client_id: clientId,
@@ -1673,6 +1679,8 @@ function signInLink(server, clientId, memberName) {
     state,
     member_name: memberName
   });
+  if (claudeInboundFallback)
+    query.set("claude_inbound_fallback", "1");
   return { url: `${server}/mcp/oauth/authorize?${query}`, verifier, state };
 }
 async function finishSignIn(server, clientId, signIn, deadlineAt = Date.now() + 10 * 6e4, pause = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms))) {
@@ -1844,8 +1852,8 @@ function scanCodex(proc = "/proc") {
         cwd = readlinkSync(join3(proc, name, "cwd"));
       } catch {
       }
-      found.push({ pid, threadId, cwd, rollout: target });
-      break;
+      if (!found.some((s) => s.threadId === threadId))
+        found.push({ pid, threadId, cwd, rollout: target });
     }
   }
   return found;
@@ -1983,6 +1991,103 @@ var init_claude = __esm({
   }
 });
 
+// apps/body/dist/session-join/claude-mcp.js
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync as readdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+import { createInterface } from "node:readline";
+function hasClaudeMcp(dir, claudePid) {
+  if (!claudePid)
+    return false;
+  let files;
+  try {
+    files = readdirSync4(join5(dir, "claude-mcp"));
+  } catch {
+    return false;
+  }
+  return files.some((file) => {
+    try {
+      const entry = JSON.parse(readFileSync5(join5(dir, "claude-mcp", file), "utf8"));
+      return entry.claudePid === claudePid && pidAlive(entry.pid);
+    } catch {
+      return false;
+    }
+  });
+}
+async function flushClaudeMcp(dir, session2, token, post = postToClaude) {
+  if (!session2.messagingSocketPath)
+    return;
+  const joined2 = readState(dir).sessions.find((s) => s.agent === "claude-code" && (s.pid === session2.pid || s.sessionId === session2.sessionId));
+  if (!joined2)
+    return;
+  const text = takeInbox(dir, joined2.key);
+  if (!text)
+    return;
+  try {
+    await post({ path: session2.messagingSocketPath, token }, text);
+  } catch {
+    queueInbox(dir, joined2.key, text);
+  }
+}
+async function runClaudeMcp(dir, env) {
+  const chain = ancestors(process.pid);
+  let registration;
+  let flushing = false;
+  const flush2 = async () => {
+    if (flushing || !env.CLAUDE_CODE_MESSAGING_TOKEN)
+      return;
+    flushing = true;
+    try {
+      const live = scanClaude(env);
+      const session2 = chain.map((pid) => live.find((s) => s.pid === pid)).find(Boolean);
+      if (!session2)
+        return;
+      if (!registration) {
+        const folder = join5(dir, "claude-mcp");
+        mkdirSync2(folder, { recursive: true, mode: 448 });
+        registration = join5(folder, `${process.pid}.json`);
+        writeFileSync2(registration, JSON.stringify({ pid: process.pid, claudePid: session2.pid }), { mode: 384 });
+      }
+      await flushClaudeMcp(dir, session2, env.CLAUDE_CODE_MESSAGING_TOKEN);
+    } finally {
+      flushing = false;
+    }
+  };
+  const timer = setInterval(() => {
+    void flush2().catch(() => void 0);
+  }, 500);
+  try {
+    await flush2();
+    for await (const line of createInterface({ input: process.stdin })) {
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (request.id === void 0)
+        continue;
+      const result = request.method === "initialize" ? {
+        protocolVersion: request.params?.protocolVersion ?? "2025-06-18",
+        capabilities: { tools: {} },
+        serverInfo: { name: "beeline", version: "1.0.0" }
+      } : request.method === "tools/list" ? { tools: [] } : request.method === "ping" ? {} : void 0;
+      process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: request.id, ...result ? { result } : { error: { code: -32601, message: "Method not found" } } }) + "\n");
+    }
+  } finally {
+    clearInterval(timer);
+    if (registration)
+      rmSync2(registration, { force: true });
+  }
+}
+var init_claude_mcp = __esm({
+  "apps/body/dist/session-join/claude-mcp.js"() {
+    "use strict";
+    init_agents();
+    init_claude();
+    init_store();
+  }
+});
+
 // apps/body/dist/session-join/sessions.js
 function machineSources(dir, env = process.env) {
   return { claude: () => scanClaude(env), codex: () => scanCodex(), hooks: () => hookSessions(dir) };
@@ -2034,9 +2139,9 @@ var init_sessions = __esm({
 
 // apps/body/dist/session-join/bridge.js
 import { spawn as spawn4 } from "node:child_process";
-import { chmodSync as chmodSync2, closeSync as closeSync3, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync as openSync3, readFileSync as readFileSync5, readdirSync as readdirSync4, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { chmodSync as chmodSync2, closeSync as closeSync3, existsSync as existsSync2, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync6, readdirSync as readdirSync5, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { createConnection as createConnection4, createServer as createServer3 } from "node:net";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function command(runner2, joined2, args) {
   const q = (v) => /^[A-Za-z0-9_./:@=-]+$/.test(v) ? v : `"${v.replace(/(["\\$`])/g, "\\$1")}"`;
   return `${q(runner2.node)} ${q(runner2.bundle)} session ${args} --as ${q(joined2.key)}`;
@@ -2066,6 +2171,8 @@ async function deliver(dir, joined2, session2, deps = realDeps) {
     return "waiting for the app to collect it";
   if (!session2)
     return "waiting for the session to open";
+  if (joined2.agent === "claude-code" && hasClaudeMcp(dir, session2.pid))
+    return "waiting for the in-session MCP server";
   const text = takeInbox(dir, joined2.key);
   if (!text)
     return "nothing waiting";
@@ -2112,7 +2219,7 @@ async function pollOnce(dir, key, runner2, waitSeconds = 25) {
 }
 function log(dir, line) {
   try {
-    writeFileSync2(join5(dir, "bridge.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+    writeFileSync3(join6(dir, "bridge.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `, { flag: "a", mode: 384 });
   } catch {
   }
@@ -2138,8 +2245,8 @@ async function flush(dir, sources, deps = realDeps) {
   }
 }
 function serveTools(dir) {
-  const path = join5(dir, "bridge.sock");
-  rmSync2(path, { force: true });
+  const path = join6(dir, "bridge.sock");
+  rmSync3(path, { force: true });
   const server = createServer3((connection) => {
     let buffer = "", taken = false;
     connection.setEncoding("utf8");
@@ -2166,19 +2273,19 @@ function serveTools(dir) {
   server.unref();
 }
 function outboxDir(cwd) {
-  return join5(cwd, ".beeline", "outbox");
+  return join6(cwd, ".beeline", "outbox");
 }
 async function serveOutboxes(dir) {
   let served = 0;
   for (const joined2 of readState(dir).sessions) {
     let names;
     try {
-      names = readdirSync4(outboxDir(joined2.cwd));
+      names = readdirSync5(outboxDir(joined2.cwd));
     } catch {
       continue;
     }
     for (const name of names.filter((n) => n.endsWith(".request.json"))) {
-      const path = join5(outboxDir(joined2.cwd), name);
+      const path = join6(outboxDir(joined2.cwd), name);
       const taking = `${path}.taking`;
       try {
         renameSync2(path, taking);
@@ -2187,13 +2294,13 @@ async function serveOutboxes(dir) {
       }
       let answer;
       try {
-        const request = JSON.parse(readFileSync5(taking, "utf8"));
+        const request = JSON.parse(readFileSync6(taking, "utf8"));
         answer = { ok: true, data: await callTool(joined2, await accessToken(dir, joined2.key), request.name, request.args ?? {}) };
       } catch (error) {
         answer = { ok: false, error: error instanceof Error ? error.message : String(error) };
       }
-      rmSync2(taking, { force: true });
-      writeFileSync2(path.replace(/\.request\.json$/, ".result.json"), JSON.stringify(answer));
+      rmSync3(taking, { force: true });
+      writeFileSync3(path.replace(/\.request\.json$/, ".result.json"), JSON.stringify(answer));
       served++;
     }
   }
@@ -2201,17 +2308,17 @@ async function serveOutboxes(dir) {
 }
 async function toolViaOutbox(cwd, name, args, timeoutMs = 9e4) {
   const dirPath = outboxDir(cwd);
-  mkdirSync2(dirPath, { recursive: true });
-  writeFileSync2(join5(cwd, ".beeline", ".gitignore"), "*\n");
+  mkdirSync3(dirPath, { recursive: true });
+  writeFileSync3(join6(cwd, ".beeline", ".gitignore"), "*\n");
   const id = `${Date.now()}-${process.pid}`;
-  const request = join5(dirPath, `${id}.request.json`), result = join5(dirPath, `${id}.result.json`);
-  writeFileSync2(`${request}.tmp`, JSON.stringify({ name, args }));
+  const request = join6(dirPath, `${id}.request.json`), result = join6(dirPath, `${id}.result.json`);
+  writeFileSync3(`${request}.tmp`, JSON.stringify({ name, args }));
   renameSync2(`${request}.tmp`, request);
   const started = Date.now();
   while (Date.now() - started < timeoutMs) {
     try {
-      const answer = JSON.parse(readFileSync5(result, "utf8"));
-      rmSync2(result, { force: true });
+      const answer = JSON.parse(readFileSync6(result, "utf8"));
+      rmSync3(result, { force: true });
       return answer;
     } catch {
       await new Promise((resolve11) => setTimeout(resolve11, 250));
@@ -2219,12 +2326,12 @@ async function toolViaOutbox(cwd, name, args, timeoutMs = 9e4) {
     if (Date.now() - started > 5e3 && existsSync2(request))
       break;
   }
-  rmSync2(request, { force: true });
+  rmSync3(request, { force: true });
   return void 0;
 }
 function toolViaBridge(dir, key, name, args) {
   return new Promise((resolve11) => {
-    const connection = createConnection4(join5(dir, "bridge.sock"));
+    const connection = createConnection4(join6(dir, "bridge.sock"));
     let text = "";
     connection.setEncoding("utf8");
     connection.once("error", () => resolve11(void 0));
@@ -2246,16 +2353,16 @@ function toolViaBridge(dir, key, name, args) {
   });
 }
 async function runBridge(dir, runner2) {
-  const pidFile = join5(dir, "bridge.pid");
+  const pidFile = join6(dir, "bridge.pid");
   try {
     const fd = openSync3(pidFile, "wx", 384);
-    writeFileSync2(fd, String(process.pid));
+    writeFileSync3(fd, String(process.pid));
     closeSync3(fd);
   } catch {
-    const holder = Number(readFileSync5(pidFile, "utf8"));
+    const holder = Number(readFileSync6(pidFile, "utf8"));
     if (holder && holder !== process.pid && pidAlive(holder))
       return;
-    writeFileSync2(pidFile, String(process.pid), { mode: 384 });
+    writeFileSync3(pidFile, String(process.pid), { mode: 384 });
   }
   const sources = machineSources(dir);
   const polling = /* @__PURE__ */ new Map();
@@ -2270,8 +2377,8 @@ async function runBridge(dir, runner2) {
     });
   }, 500).unref();
   const stop = () => {
-    rmSync2(pidFile, { force: true });
-    rmSync2(join5(dir, "bridge.sock"), { force: true });
+    rmSync3(pidFile, { force: true });
+    rmSync3(join6(dir, "bridge.sock"), { force: true });
     process.exit(0);
   };
   process.once("SIGTERM", stop);
@@ -2304,13 +2411,13 @@ async function runBridge(dir, runner2) {
     await new Promise((resolve11) => setTimeout(resolve11, 2e3));
   }
   log(dir, `bridge ${process.pid} stopped: no joined sessions`);
-  rmSync2(pidFile, { force: true });
-  rmSync2(join5(dir, "bridge.sock"), { force: true });
+  rmSync3(pidFile, { force: true });
+  rmSync3(join6(dir, "bridge.sock"), { force: true });
   process.exit(0);
 }
 function bridgeRunning(dir) {
   try {
-    const holder = Number(readFileSync5(join5(dir, "bridge.pid"), "utf8"));
+    const holder = Number(readFileSync6(join6(dir, "bridge.pid"), "utf8"));
     return Boolean(holder) && pidAlive(holder);
   } catch {
     return false;
@@ -2319,7 +2426,7 @@ function bridgeRunning(dir) {
 function ensureBridge(dir, runner2, env = process.env) {
   if (bridgeRunning(dir))
     return;
-  const out = openSync3(join5(dir, "bridge.log"), "a", 384);
+  const out = openSync3(join6(dir, "bridge.log"), "a", 384);
   const child = spawn4(runner2.node, [runner2.bundle, "session", "bridge"], { detached: true, stdio: ["ignore", out, out], env });
   child.unref();
   closeSync3(out);
@@ -2331,6 +2438,7 @@ var init_bridge = __esm({
     init_beeline_api();
     init_codex();
     init_claude();
+    init_claude_mcp();
     init_sessions();
     init_store();
     realDeps = {
@@ -2341,190 +2449,6 @@ var init_bridge = __esm({
   }
 });
 
-// apps/body/dist/session-join/hook.js
-function normalizeEvent(event, state) {
-  if (event === "session-start")
-    return "start";
-  if (event === "user-prompt-submit")
-    return "prompt";
-  if (event === "post-tool-use")
-    return "tool";
-  if (event === "stop" || event === "poll")
-    return "stop";
-  if (event === "session-end")
-    return "end";
-  if (event === "status")
-    return state === "busy" || state === "retry" ? "prompt" : "stop";
-  return void 0;
-}
-function takesMail(agent, event) {
-  if (agent === "antigravity")
-    return ["session-start", "user-prompt-submit", "stop"].includes(event);
-  if (agent === "opencode" || agent === "hermes" || agent === "zcode")
-    return event === "poll";
-  if (agent === "pi")
-    return event === "poll" || event === "post-tool-use";
-  return ["session-start", "user-prompt-submit", "post-tool-use", "stop"].includes(event);
-}
-function formatFor(agent, event, text) {
-  const ev = normalizeEvent(event);
-  const specific = (name) => ({ hookSpecificOutput: { hookEventName: name, additionalContext: text } });
-  const block = { decision: "block", reason: text };
-  let out;
-  if (agent === "antigravity" && (ev === "start" || ev === "prompt"))
-    out = { injectSteps: [{ userMessage: text }] };
-  else if (agent === "antigravity" && ev === "stop")
-    out = { decision: "continue", reason: text };
-  else if ((agent === "opencode" || agent === "pi" || agent === "hermes" || agent === "zcode") && event === "poll")
-    return text;
-  else if (agent === "claude-code" && ev === "start")
-    out = specific("SessionStart");
-  else if (agent === "claude-code" && ev === "prompt")
-    out = specific("UserPromptSubmit");
-  else if (agent === "claude-code" && ev === "stop")
-    out = block;
-  else if (agent === "codex" && ev === "start")
-    out = specific("SessionStart");
-  else if (agent === "codex" && ev === "prompt")
-    out = specific("UserPromptSubmit");
-  else if (agent === "codex" && ev === "tool")
-    out = specific("PostToolUse");
-  else if (agent === "codex" && ev === "stop")
-    out = block;
-  else if (agent === "gemini" && ev === "start")
-    out = specific("SessionStart");
-  else if (agent === "gemini" && ev === "prompt")
-    out = specific("BeforeAgent");
-  else if (agent === "gemini" && ev === "tool")
-    out = specific("AfterTool");
-  else if (agent === "gemini" && ev === "stop")
-    out = { decision: "deny", reason: text };
-  else
-    return text;
-  return JSON.stringify(out);
-}
-function joinedFor(sessions, agent, sessionId, cwd) {
-  return sessions.find((s) => s.agent === agent && s.sessionId === sessionId) ?? sessions.find((s) => s.agent === agent && s.cwd === cwd);
-}
-function runHook(dir, input, now = Date.now()) {
-  const { agent, event, payload } = input;
-  const str = (key) => typeof payload[key] === "string" && payload[key] ? payload[key] : void 0;
-  const sessionId = input.session ?? str("session_id") ?? str("conversation_id") ?? str("conversationId") ?? str("sessionId");
-  if (!sessionId)
-    return "";
-  const env = input.env ?? process.env;
-  const cwd = str("cwd") ?? env.GEMINI_CWD ?? env.CLAUDE_PROJECT_DIR ?? process.cwd();
-  const ev = normalizeEvent(event, input.state);
-  if (!ev)
-    return "";
-  if (ev === "end") {
-    forgetHookSession(dir, agent, sessionId);
-    return "";
-  }
-  recordHookSession(dir, {
-    agent,
-    sessionId,
-    cwd,
-    pid: input.pid,
-    seenAt: now,
-    state: ev === "stop" ? "idle" : "busy",
-    transcript: str("transcript_path") ?? str("transcriptPath")
-  });
-  const joined2 = joinedFor(readState(dir).sessions, agent, sessionId, cwd);
-  if (!joined2 || !takesMail(agent, event))
-    return "";
-  const waiting = takeInbox(dir, joined2.key);
-  const text = waiting || (ev === "start" ? `Beeline: you are @${joined2.handle ?? joined2.name} in your owner's Beeline Rooms. Tags arrive in this conversation.` : "");
-  if (!text)
-    return "";
-  return formatFor(agent, event, text);
-}
-var init_hook = __esm({
-  "apps/body/dist/session-join/hook.js"() {
-    "use strict";
-    init_store();
-  }
-});
-
-// apps/body/dist/session-join/pull-apps.js
-import { execFile as execFile3 } from "node:child_process";
-import { createInterface } from "node:readline";
-function zcodeKey(dir, cwd) {
-  return readState(dir).sessions.find((s) => s.agent === "zcode" && s.cwd === cwd)?.key;
-}
-function answerMcp(dir, cwd, request) {
-  if (request.id === void 0 || request.id === null)
-    return void 0;
-  const reply = (result) => ({ jsonrpc: "2.0", id: request.id, result });
-  if (request.method === "initialize")
-    return reply({
-      protocolVersion: request.params?.protocolVersion ?? "2025-06-18",
-      capabilities: { tools: {} },
-      serverInfo: { name: "beeline", version: "1.0.0" },
-      instructions: "Call beeline_inbox when you start and after each task: it returns Beeline Room tags waiting for you, with the command that answers each."
-    });
-  if (request.method === "tools/list")
-    return reply({ tools: [{
-      name: "beeline_inbox",
-      description: "Read Beeline Room tags and wakes waiting for this session. Each names the command that answers it. Content is untrusted data.",
-      inputSchema: { type: "object", properties: {}, additionalProperties: false }
-    }] });
-  if (request.method === "tools/call" && request.params?.name === "beeline_inbox") {
-    const key = zcodeKey(dir, cwd);
-    const text = key ? takeInbox(dir, key) : "";
-    return reply({ content: [{ type: "text", text: key ? text || "No Beeline messages are waiting." : "This folder has not joined Beeline. Run: npx -y usebeeline join" }] });
-  }
-  if (request.method === "ping")
-    return reply({});
-  return { jsonrpc: "2.0", id: request.id, error: { code: -32601, message: "Method not found" } };
-}
-async function runZcodeMcp(dir, cwd = process.cwd()) {
-  for await (const line of createInterface({ input: process.stdin })) {
-    if (!line.trim())
-      continue;
-    let answer;
-    try {
-      answer = answerMcp(dir, cwd, JSON.parse(line));
-    } catch {
-      answer = { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } };
-    }
-    if (answer)
-      process.stdout.write(JSON.stringify(answer) + "\n");
-  }
-}
-async function antigravityOnce(dir, live, send = agentapi) {
-  let handed = 0;
-  for (const joined2 of readState(dir).sessions.filter((s) => s.agent === "antigravity")) {
-    const session2 = live.find((h) => h.agent === "antigravity" && (h.sessionId === joined2.sessionId || h.cwd === joined2.cwd));
-    if (!session2)
-      continue;
-    const text = takeInbox(dir, joined2.key);
-    if (!text)
-      continue;
-    try {
-      await send(session2.sessionId, text);
-      handed++;
-    } catch {
-      queueInbox(dir, joined2.key, text);
-    }
-  }
-  return handed;
-}
-async function runAntigravitySidecar(dir) {
-  for (; ; ) {
-    await antigravityOnce(dir, hookSessions(dir)).catch(() => 0);
-    await new Promise((resolve11) => setTimeout(resolve11, 3e3));
-  }
-}
-var agentapi;
-var init_pull_apps = __esm({
-  "apps/body/dist/session-join/pull-apps.js"() {
-    "use strict";
-    init_store();
-    agentapi = (sessionId, text) => new Promise((resolve11, reject) => execFile3("agentapi", ["send-message", sessionId, text], { timeout: 3e4 }, (error) => error ? reject(error) : resolve11()));
-  }
-});
-
 // apps/body/dist/session-join/templates.js
 function fill(template, node, bundle) {
   return template.replaceAll("__NODE__", node.replace(/\\/g, "\\\\")).replaceAll("__BUNDLE__", bundle.replace(/\\/g, "\\\\"));
@@ -2748,16 +2672,16 @@ def register(ctx):
 
 // apps/body/dist/session-join/setup.js
 import { spawnSync } from "node:child_process";
-import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync6, renameSync as renameSync3, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync3, chmodSync as chmodSync3 } from "node:fs";
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync as renameSync3, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync4, chmodSync as chmodSync3 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname5, join as join6 } from "node:path";
+import { dirname as dirname5, join as join7 } from "node:path";
 function home(env) {
   return env.HOME || homedir7();
 }
 function readJson(path) {
   let text;
   try {
-    text = readFileSync6(path, "utf8");
+    text = readFileSync7(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return {};
@@ -2778,27 +2702,69 @@ function object(parent, key) {
     throw new Error(`"${key}" is not a JSON object; not touching it`);
   return value;
 }
-function writeFile3(path, content) {
+function writeFile3(path, content, expected) {
   let before;
   try {
-    before = readFileSync6(path, "utf8");
+    before = readFileSync7(path, "utf8");
   } catch {
   }
   if (before === content)
     return false;
-  mkdirSync3(dirname5(path), { recursive: true });
+  mkdirSync4(dirname5(path), { recursive: true });
   const backup = `${path}.bak-${NAME}`;
   if (before !== void 0 && !existsSync3(backup) && !before.includes(" session hook "))
     copyFileSync(path, backup);
-  const temp = `${path}.tmp-${NAME}`;
-  writeFileSync3(temp, content);
+  const temp = `${path}.${process.pid}.tmp-${NAME}`;
+  writeFileSync4(temp, content);
   try {
     chmodSync3(temp, statSync4(path).mode & 511);
   } catch {
   }
+  if (expected) {
+    let latest;
+    try {
+      latest = readFileSync7(path, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        rmSync4(temp, { force: true });
+        throw error;
+      }
+    }
+    if (latest !== expected.text) {
+      rmSync4(temp, { force: true });
+      throw new ConfigChanged();
+    }
+  }
   renameSync3(temp, path);
   return true;
 }
+function mergeClaudeMcp(path, context) {
+  for (let attempt = 0; attempt < 5; attempt++) {
+    let before;
+    try {
+      before = readFileSync7(path, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+    const value = readJson(path);
+    const servers = object(value, "mcpServers");
+    if (context.remove)
+      delete servers[NAME];
+    else
+      servers[NAME] = { type: "stdio", command: context.node, args: [context.bundle, "session", "claude-mcp"] };
+    if (!Object.keys(servers).length)
+      delete value.mcpServers;
+    try {
+      const changed = writeFile3(path, JSON.stringify(value, null, 2) + "\n", { text: before });
+      return changed ? [`${context.remove ? "removed Beeline from" : "updated"} ${path}`] : [];
+    } catch (error) {
+      if (!(error instanceof ConfigChanged))
+        throw error;
+    }
+  }
+  throw new Error("Claude Code kept changing its user config; retry joining when it is idle.");
+}
 function writeJson(path, value) {
   return writeFile3(path, JSON.stringify(value, null, 2) + "\n");
 }
@@ -2846,24 +2812,26 @@ function saveJson(path, value, remove) {
   if (remove && !Object.keys(value).length && !existsSync3(`${path}.bak-${NAME}`)) {
     if (!existsSync3(path))
       return [];
-    rmSync3(path, { force: true });
+    rmSync4(path, { force: true });
     return [`removed ${path}`];
   }
   return writeJson(path, value) ? [`${remove ? "removed Beeline from" : "updated"} ${path}`] : [];
 }
 function claudeCode(context) {
   const command2 = (event) => ({ hooks: [{ type: "command", command: hookCommand(context, "claude-code", event), timeout: 10 }] });
-  return hooksFile(join6(claudeConfigDir(context.env), "settings.json"), "claude-code", [["SessionStart", command2("session-start")]], Boolean(context.remove));
+  const remove = Boolean(context.remove);
+  const path = context.env.CLAUDE_CONFIG_DIR ? join7(context.env.CLAUDE_CONFIG_DIR, ".claude.json") : join7(home(context.env), ".claude.json");
+  return [...mergeClaudeMcp(path, context), ...hooksFile(join7(claudeConfigDir(context.env), "settings.json"), "claude-code", [["SessionStart", command2("session-start")]], remove)];
 }
 function codex(context) {
   const group = (event) => ({ matcher: "*", hooks: [{ type: "command", command: hookCommand(context, "codex", event), timeout: 10 }] });
-  const lines = hooksFile(join6(codexHome(context.env), "hooks.json"), "codex", [["SessionStart", group("session-start")]], Boolean(context.remove));
+  const lines = hooksFile(join7(codexHome(context.env), "hooks.json"), "codex", [["SessionStart", group("session-start")]], Boolean(context.remove));
   if (lines.length && !context.remove)
-    lines.push('Codex asks once to trust these hooks: choose "Trust all and continue".');
+    lines.push("Codex asks once to trust Beeline\u2019s SessionStart hook if automatic trust is unavailable: open /hooks and trust only Beeline.");
   return lines;
 }
 function geminiHome(env) {
-  return env.GEMINI_CLI_HOME || join6(home(env), ".gemini");
+  return env.GEMINI_CLI_HOME || join7(home(env), ".gemini");
 }
 function gemini(context) {
   const group = (event, timeout) => ({ matcher: "*", hooks: [{
@@ -2872,7 +2840,7 @@ function gemini(context) {
     command: hookCommand(context, "gemini", event),
     timeout
   }] });
-  return hooksFile(join6(geminiHome(context.env), "settings.json"), "gemini", [
+  return hooksFile(join7(geminiHome(context.env), "settings.json"), "gemini", [
     ["SessionStart", group("session-start", 1e4)],
     ["BeforeAgent", group("user-prompt-submit", 1e4)],
     ["AfterTool", group("post-tool-use", 1e4)],
@@ -2881,9 +2849,9 @@ function gemini(context) {
   ], Boolean(context.remove));
 }
 function antigravity(context) {
-  const dir = join6(home(context.env), ".gemini/config");
+  const dir = join7(home(context.env), ".gemini/config");
   const lines = [];
-  const hooksPath = join6(dir, "hooks.json");
+  const hooksPath = join7(dir, "hooks.json");
   const hooks = readJson(hooksPath);
   if (context.remove)
     delete hooks[NAME];
@@ -2899,13 +2867,13 @@ function antigravity(context) {
     };
   }
   lines.push(...saveJson(hooksPath, hooks, Boolean(context.remove)));
-  const sidecar = join6(dir, "sidecars", NAME, "sidecar.json");
-  const configPath = join6(dir, "config.json");
+  const sidecar = join7(dir, "sidecars", NAME, "sidecar.json");
+  const configPath = join7(dir, "config.json");
   const config = readJson(configPath);
   const sidecars = object(config, "sidecars");
   if (context.remove) {
     delete sidecars[NAME];
-    rmSync3(dirname5(sidecar), { recursive: true, force: true });
+    rmSync4(dirname5(sidecar), { recursive: true, force: true });
   } else {
     if (writeJson(sidecar, {
       command: context.node,
@@ -2926,47 +2894,47 @@ function pluginFile(path, content, remove) {
   if (remove) {
     if (!existsSync3(path))
       return [];
-    rmSync3(path, { force: true });
+    rmSync4(path, { force: true });
     return [`removed ${path}`];
   }
   return writeFile3(path, content) ? [`updated ${path}`] : [];
 }
 function opencode(context) {
-  return pluginFile(join6(home(context.env), ".config/opencode/plugins", `${NAME}.ts`), fill(OPENCODE_PLUGIN, context.node, context.bundle), Boolean(context.remove));
+  return pluginFile(join7(home(context.env), ".config/opencode/plugins", `${NAME}.ts`), fill(OPENCODE_PLUGIN, context.node, context.bundle), Boolean(context.remove));
 }
 function piHome(env) {
-  return env.PI_CODING_AGENT_DIR || join6(home(env), ".pi/agent");
+  return env.PI_CODING_AGENT_DIR || join7(home(env), ".pi/agent");
 }
 function pi(context) {
-  return pluginFile(join6(piHome(context.env), "extensions", `${NAME}.ts`), fill(PI_EXTENSION, context.node, context.bundle), Boolean(context.remove));
+  return pluginFile(join7(piHome(context.env), "extensions", `${NAME}.ts`), fill(PI_EXTENSION, context.node, context.bundle), Boolean(context.remove));
 }
 function hermesRoot(env) {
-  const base = env.HERMES_HOME ? env.HERMES_HOME.replace(/^~(?=\/|$)/, home(env)) : join6(home(env), `.hermes${env.HERMES_DATA_DIR_SUFFIX ?? ""}`);
+  const base = env.HERMES_HOME ? env.HERMES_HOME.replace(/^~(?=\/|$)/, home(env)) : join7(home(env), `.hermes${env.HERMES_DATA_DIR_SUFFIX ?? ""}`);
   let active = "";
   try {
-    active = readFileSync6(join6(base, "active_profile"), "utf8").trim();
+    active = readFileSync7(join7(base, "active_profile"), "utf8").trim();
   } catch {
   }
-  if (active && active !== "default" && active !== "." && active !== ".." && !/[/\\]/.test(active) && existsSync3(join6(base, "profiles", active)))
-    return join6(base, "profiles", active);
+  if (active && active !== "default" && active !== "." && active !== ".." && !/[/\\]/.test(active) && existsSync3(join7(base, "profiles", active)))
+    return join7(base, "profiles", active);
   return base;
 }
 function hermes(context) {
-  const dir = join6(hermesRoot(context.env), "plugins", NAME);
+  const dir = join7(hermesRoot(context.env), "plugins", NAME);
   const remove = Boolean(context.remove);
   const lines = [
-    ...pluginFile(join6(dir, "__init__.py"), fill(HERMES_PLUGIN, context.node, context.bundle), remove),
-    ...pluginFile(join6(dir, "plugin.yaml"), HERMES_MANIFEST, remove)
+    ...pluginFile(join7(dir, "__init__.py"), fill(HERMES_PLUGIN, context.node, context.bundle), remove),
+    ...pluginFile(join7(dir, "plugin.yaml"), HERMES_MANIFEST, remove)
   ];
   if (remove)
-    rmSync3(dir, { recursive: true, force: true });
+    rmSync4(dir, { recursive: true, force: true });
   const done = spawnSync("hermes", ["plugins", remove ? "disable" : "enable", NAME], { env: context.env, stdio: "ignore", timeout: 15e3 });
   if (!remove && done.status !== 0)
     lines.push(`Run "hermes plugins enable ${NAME}" once if Hermes does not load it.`);
   return lines;
 }
 function zcodeIn(homeDir, context) {
-  const native = join6(homeDir, ".zcode/cli/config.json"), fallback = join6(homeDir, ".agents/mcp.json");
+  const native = join7(homeDir, ".zcode/cli/config.json"), fallback = join7(homeDir, ".agents/mcp.json");
   const servers = (value, isNative) => isNative ? object(object(value, "mcp"), "servers") : object(value, "mcpServers");
   const remove = Boolean(context.remove);
   const toFallback = !remove && !Object.keys(servers(readJson(native), true)).some((key) => key !== NAME) && Object.keys(servers(readJson(fallback), false)).length > 0;
@@ -2991,7 +2959,7 @@ function zcodeIn(homeDir, context) {
 function setupAgent(agent, context) {
   return SETUP[agent](context);
 }
-var NAME, SETUP;
+var NAME, ConfigChanged, SETUP;
 var init_setup = __esm({
   "apps/body/dist/session-join/setup.js"() {
     "use strict";
@@ -2999,6 +2967,8 @@ var init_setup = __esm({
     init_codex();
     init_templates();
     NAME = "beeline";
+    ConfigChanged = class extends Error {
+    };
     SETUP = {
       "claude-code": claudeCode,
       codex,
@@ -3012,15 +2982,346 @@ var init_setup = __esm({
   }
 });
 
+// apps/body/dist/session-join/claude-inbound.js
+import { existsSync as existsSync4, readFileSync as readFileSync8, rmSync as rmSync5 } from "node:fs";
+import { join as join8 } from "node:path";
+function assertClaudePolicy(env) {
+  const paths = [
+    env.CLAUDE_CODE_MANAGED_SETTINGS_PATH,
+    join8(claudeConfigDir(env), "managed-settings.json"),
+    process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : "/etc/claude-code/managed-settings.json"
+  ];
+  for (const path of paths) {
+    if (!path)
+      continue;
+    const setting = readJson(path).crossSessionInbound;
+    if (setting === "hold" || setting === "refuse")
+      throw new Error(`Claude Code managed policy sets crossSessionInbound to ${setting}. Beeline wrote no app settings. Ask your administrator to allow messages.`);
+  }
+}
+async function acceptClaudeInbound(env) {
+  const dir = stateDir(env);
+  await withLock(dir, () => {
+    assertClaudePolicy(env);
+    const path = join8(claudeConfigDir(env), "settings.json");
+    const saved = join8(dir, "claude-inbound.json");
+    const value = readJson(path);
+    if (!existsSync4(saved))
+      writeFile3(saved, JSON.stringify({ present: Object.hasOwn(value, "crossSessionInbound"), value: value.crossSessionInbound }));
+    const current = readJson(path);
+    current.crossSessionInbound = "accept";
+    writeFile3(path, JSON.stringify(current, null, 2) + "\n");
+  });
+}
+async function restoreClaudeInbound(env) {
+  const dir = stateDir(env);
+  await withLock(dir, () => {
+    if (readState(dir).sessions.length)
+      return;
+    const saved = join8(dir, "claude-inbound.json");
+    if (!existsSync4(saved))
+      return;
+    assertClaudePolicy(env);
+    const old = JSON.parse(readFileSync8(saved, "utf8"));
+    const path = join8(claudeConfigDir(env), "settings.json");
+    const value = readJson(path);
+    if (value.crossSessionInbound === "accept") {
+      if (old.present)
+        value.crossSessionInbound = old.value;
+      else
+        delete value.crossSessionInbound;
+      writeFile3(path, JSON.stringify(value, null, 2) + "\n");
+    }
+    rmSync5(saved);
+  });
+}
+var init_claude_inbound = __esm({
+  "apps/body/dist/session-join/claude-inbound.js"() {
+    "use strict";
+    init_claude();
+    init_setup();
+    init_store();
+  }
+});
+
+// apps/body/dist/session-join/codex-trust.js
+import { spawn as spawn5 } from "node:child_process";
+import { join as join9 } from "node:path";
+function beelineTrustEdits(hooks, context) {
+  const path = join9(codexHome(context.env), "hooks.json");
+  const expected = hookCommand(context, "codex", "session-start");
+  const own2 = hooks.filter((h) => h.sourcePath === path && h.source === "user" && !h.isManaged && h.pluginId === null && h.eventName === "sessionStart" && h.handlerType === "command" && h.command === expected && h.matcher === "*" && h.timeoutSec === 10 && h.key.startsWith(path) && /^:session_start:\d+:\d+$/.test(h.key.slice(path.length)) && /^sha256:[0-9a-f]{64}$/.test(h.currentHash));
+  if (own2.length !== 1)
+    return [];
+  const hook = own2[0];
+  return [{ keyPath: `hooks.state.${JSON.stringify(hook.key)}.trusted_hash`, value: hook.currentHash, mergeStrategy: "replace" }];
+}
+async function trustCodexHook(context, bin, cwd) {
+  const child = spawn5(bin, ["app-server", "--stdio"], { env: context.env, cwd, stdio: ["pipe", "pipe", "ignore"] });
+  let id = 0, buffer = "";
+  const pending = /* @__PURE__ */ new Map();
+  const fail = () => {
+    for (const p of pending.values())
+      p.reject();
+    pending.clear();
+  };
+  child.once("error", fail);
+  child.once("exit", fail);
+  child.stdin.on("error", fail);
+  child.stdout.on("data", (chunk) => {
+    buffer += String(chunk);
+    if (buffer.length > 2 << 20) {
+      fail();
+      child.kill();
+      return;
+    }
+    for (; ; ) {
+      const end = buffer.indexOf("\n");
+      if (end < 0)
+        break;
+      const line = buffer.slice(0, end);
+      buffer = buffer.slice(end + 1);
+      try {
+        const answer = JSON.parse(line);
+        const p = answer.id === void 0 ? void 0 : pending.get(answer.id);
+        if (p) {
+          pending.delete(answer.id);
+          if (answer.error)
+            p.reject();
+          else
+            p.resolve(answer.result);
+        }
+      } catch {
+      }
+    }
+  });
+  const request = (method, params) => new Promise((resolve11, reject) => {
+    const key = ++id;
+    pending.set(key, { resolve: resolve11, reject: () => reject(new Error("Codex hook trust unavailable")) });
+    child.stdin.write(JSON.stringify({ id: key, method, params }) + "\n");
+  });
+  const timer = setTimeout(() => {
+    fail();
+    child.kill();
+  }, 15e3);
+  try {
+    await request("initialize", { clientInfo: { name: "beeline-session-join", version: "1" }, capabilities: { experimentalApi: true } });
+    const list = await request("hooks/list", { cwds: [cwd] });
+    if (!Array.isArray(list.data))
+      return false;
+    const edits = beelineTrustEdits(list.data.flatMap((entry) => entry.hooks ?? []), context);
+    if (edits.length !== 1)
+      return false;
+    const result = await request("config/batchWrite", { edits, reloadUserConfig: true });
+    return result.status === "ok";
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+    child.kill();
+  }
+}
+var init_codex_trust = __esm({
+  "apps/body/dist/session-join/codex-trust.js"() {
+    "use strict";
+    init_codex();
+    init_setup();
+  }
+});
+
+// apps/body/dist/session-join/hook.js
+function normalizeEvent(event, state) {
+  if (event === "session-start")
+    return "start";
+  if (event === "user-prompt-submit")
+    return "prompt";
+  if (event === "post-tool-use")
+    return "tool";
+  if (event === "stop" || event === "poll")
+    return "stop";
+  if (event === "session-end")
+    return "end";
+  if (event === "status")
+    return state === "busy" || state === "retry" ? "prompt" : "stop";
+  return void 0;
+}
+function takesMail(agent, event) {
+  if (agent === "antigravity")
+    return ["session-start", "user-prompt-submit", "stop"].includes(event);
+  if (agent === "opencode" || agent === "hermes" || agent === "zcode")
+    return event === "poll";
+  if (agent === "pi")
+    return event === "poll" || event === "post-tool-use";
+  return ["session-start", "user-prompt-submit", "post-tool-use", "stop"].includes(event);
+}
+function formatFor(agent, event, text) {
+  const ev = normalizeEvent(event);
+  const specific = (name) => ({ hookSpecificOutput: { hookEventName: name, additionalContext: text } });
+  const block = { decision: "block", reason: text };
+  let out;
+  if (agent === "antigravity" && (ev === "start" || ev === "prompt"))
+    out = { injectSteps: [{ userMessage: text }] };
+  else if (agent === "antigravity" && ev === "stop")
+    out = { decision: "continue", reason: text };
+  else if ((agent === "opencode" || agent === "pi" || agent === "hermes" || agent === "zcode") && event === "poll")
+    return text;
+  else if (agent === "claude-code" && ev === "start")
+    out = specific("SessionStart");
+  else if (agent === "claude-code" && ev === "prompt")
+    out = specific("UserPromptSubmit");
+  else if (agent === "claude-code" && ev === "stop")
+    out = block;
+  else if (agent === "codex" && ev === "start")
+    out = specific("SessionStart");
+  else if (agent === "codex" && ev === "prompt")
+    out = specific("UserPromptSubmit");
+  else if (agent === "codex" && ev === "tool")
+    out = specific("PostToolUse");
+  else if (agent === "codex" && ev === "stop")
+    out = block;
+  else if (agent === "gemini" && ev === "start")
+    out = specific("SessionStart");
+  else if (agent === "gemini" && ev === "prompt")
+    out = specific("BeforeAgent");
+  else if (agent === "gemini" && ev === "tool")
+    out = specific("AfterTool");
+  else if (agent === "gemini" && ev === "stop")
+    out = { decision: "deny", reason: text };
+  else
+    return text;
+  return JSON.stringify(out);
+}
+function joinedFor(sessions, agent, sessionId, cwd) {
+  return sessions.find((s) => s.agent === agent && s.sessionId === sessionId) ?? sessions.find((s) => s.agent === agent && s.cwd === cwd);
+}
+function runHook(dir, input, now = Date.now()) {
+  const { agent, event, payload } = input;
+  const str = (key) => typeof payload[key] === "string" && payload[key] ? payload[key] : void 0;
+  const sessionId = input.session ?? str("session_id") ?? str("conversation_id") ?? str("conversationId") ?? str("sessionId");
+  if (!sessionId)
+    return "";
+  const env = input.env ?? process.env;
+  const cwd = str("cwd") ?? env.GEMINI_CWD ?? env.CLAUDE_PROJECT_DIR ?? process.cwd();
+  const ev = normalizeEvent(event, input.state);
+  if (!ev)
+    return "";
+  if (ev === "end") {
+    forgetHookSession(dir, agent, sessionId);
+    return "";
+  }
+  recordHookSession(dir, {
+    agent,
+    sessionId,
+    cwd,
+    pid: input.pid,
+    seenAt: now,
+    state: ev === "stop" ? "idle" : "busy",
+    transcript: str("transcript_path") ?? str("transcriptPath")
+  });
+  const joined2 = joinedFor(readState(dir).sessions, agent, sessionId, cwd);
+  if (!joined2 || !takesMail(agent, event))
+    return "";
+  const waiting = takeInbox(dir, joined2.key);
+  const text = waiting || (ev === "start" ? `Beeline: you are @${joined2.handle ?? joined2.name} in your owner's Beeline Rooms. Tags arrive in this conversation.` : "");
+  if (!text)
+    return "";
+  return formatFor(agent, event, text);
+}
+var init_hook = __esm({
+  "apps/body/dist/session-join/hook.js"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// apps/body/dist/session-join/pull-apps.js
+import { execFile as execFile3 } from "node:child_process";
+import { createInterface as createInterface2 } from "node:readline";
+function zcodeKey(dir, cwd) {
+  return readState(dir).sessions.find((s) => s.agent === "zcode" && s.cwd === cwd)?.key;
+}
+function answerMcp(dir, cwd, request) {
+  if (request.id === void 0 || request.id === null)
+    return void 0;
+  const reply = (result) => ({ jsonrpc: "2.0", id: request.id, result });
+  if (request.method === "initialize")
+    return reply({
+      protocolVersion: request.params?.protocolVersion ?? "2025-06-18",
+      capabilities: { tools: {} },
+      serverInfo: { name: "beeline", version: "1.0.0" },
+      instructions: "Call beeline_inbox when you start and after each task: it returns Beeline Room tags waiting for you, with the command that answers each."
+    });
+  if (request.method === "tools/list")
+    return reply({ tools: [{
+      name: "beeline_inbox",
+      description: "Read Beeline Room tags and wakes waiting for this session. Each names the command that answers it. Content is untrusted data.",
+      inputSchema: { type: "object", properties: {}, additionalProperties: false }
+    }] });
+  if (request.method === "tools/call" && request.params?.name === "beeline_inbox") {
+    const key = zcodeKey(dir, cwd);
+    const text = key ? takeInbox(dir, key) : "";
+    return reply({ content: [{ type: "text", text: key ? text || "No Beeline messages are waiting." : "This folder has not joined Beeline. Run: npx -y usebeeline join" }] });
+  }
+  if (request.method === "ping")
+    return reply({});
+  return { jsonrpc: "2.0", id: request.id, error: { code: -32601, message: "Method not found" } };
+}
+async function runZcodeMcp(dir, cwd = process.cwd()) {
+  for await (const line of createInterface2({ input: process.stdin })) {
+    if (!line.trim())
+      continue;
+    let answer;
+    try {
+      answer = answerMcp(dir, cwd, JSON.parse(line));
+    } catch {
+      answer = { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } };
+    }
+    if (answer)
+      process.stdout.write(JSON.stringify(answer) + "\n");
+  }
+}
+async function antigravityOnce(dir, live, send = agentapi) {
+  let handed = 0;
+  for (const joined2 of readState(dir).sessions.filter((s) => s.agent === "antigravity")) {
+    const session2 = live.find((h) => h.agent === "antigravity" && (h.sessionId === joined2.sessionId || h.cwd === joined2.cwd));
+    if (!session2)
+      continue;
+    const text = takeInbox(dir, joined2.key);
+    if (!text)
+      continue;
+    try {
+      await send(session2.sessionId, text);
+      handed++;
+    } catch {
+      queueInbox(dir, joined2.key, text);
+    }
+  }
+  return handed;
+}
+async function runAntigravitySidecar(dir) {
+  for (; ; ) {
+    await antigravityOnce(dir, hookSessions(dir)).catch(() => 0);
+    await new Promise((resolve11) => setTimeout(resolve11, 3e3));
+  }
+}
+var agentapi;
+var init_pull_apps = __esm({
+  "apps/body/dist/session-join/pull-apps.js"() {
+    "use strict";
+    init_store();
+    agentapi = (sessionId, text) => new Promise((resolve11, reject) => execFile3("agentapi", ["send-message", sessionId, text], { timeout: 3e4 }, (error) => error ? reject(error) : resolve11()));
+  }
+});
+
 // apps/body/dist/session-join/command.js
 var command_exports = {};
 __export(command_exports, {
   findOwnSession: () => findOwnSession,
   runSessionCommand: () => runSessionCommand
 });
-import { spawn as spawn5, spawnSync as spawnSync2 } from "node:child_process";
-import { copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync7, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { delimiter, join as join7, resolve as resolve9 } from "node:path";
+import { spawn as spawn6, spawnSync as spawnSync2 } from "node:child_process";
+import { copyFileSync as copyFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync9, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { delimiter, join as join10, resolve as resolve9 } from "node:path";
 import { createHash as createHash6, randomUUID } from "node:crypto";
 function flag(args, name) {
   const index = args.indexOf(name);
@@ -3038,8 +3339,8 @@ function words(args, valued) {
 }
 function which(bin, env) {
   for (const dir of (env.PATH ?? "").split(delimiter)) {
-    const path = join7(dir, bin);
-    if (dir && existsSync4(path))
+    const path = join10(dir, bin);
+    if (dir && existsSync5(path))
       return path;
   }
   return void 0;
@@ -3047,13 +3348,13 @@ function which(bin, env) {
 function runner(dir, env) {
   if (env.BEELINE_SESSION_BUNDLE)
     return { node: process.execPath, bundle: env.BEELINE_SESSION_BUNDLE };
-  const bundle = join7(dir, "usebeeline.mjs");
+  const bundle = join10(dir, "usebeeline.mjs");
   const running = resolve9(process.argv[1] ?? "");
   if (running !== bundle && running.endsWith(".mjs")) {
-    mkdirSync4(dir, { recursive: true, mode: 448 });
+    mkdirSync5(dir, { recursive: true, mode: 448 });
     copyFileSync2(running, bundle);
   }
-  return { node: process.execPath, bundle: existsSync4(bundle) ? bundle : running };
+  return { node: process.execPath, bundle: existsSync5(bundle) ? bundle : running };
 }
 function gitRoot(cwd) {
   const result = spawnSync2("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", timeout: 5e3 });
@@ -3076,12 +3377,13 @@ function findOwnSession(env, dir) {
       sessionId,
       pid: own2?.pid ?? detected.pid,
       chosen: own2 ? chosenName(own2) : void 0,
-      note: held ? 'This session skips permission prompts, so Claude Code holds Beeline messages for your OK. To let them in, set "crossSessionInbound": "accept" in Claude Code settings.' : void 0
+      claudeInboundFallback: held && !hasClaudeMcp(dir, own2?.pid ?? detected.pid)
     };
   }
   if (detected.agent === "codex") {
     const thread = env.CODEX_THREAD_ID ?? env.CODEX_SESSION_ID;
-    const own2 = scanCodex().find((s) => s.threadId === thread || detected.pid !== void 0 && s.pid === detected.pid);
+    const live = scanCodex();
+    const own2 = thread ? live.find((s) => s.threadId === thread) : live.find((s) => detected.pid !== void 0 && s.pid === detected.pid);
     return { agent: "codex", cwd: own2?.cwd ?? cwd, sessionId: thread ?? own2?.threadId, pid: own2?.pid ?? detected.pid };
   }
   const reported = hookSessions(dir).filter((h) => h.agent === detected.agent && h.cwd === cwd).sort((a, b) => b.seenAt - a.seenAt)[0];
@@ -3092,8 +3394,10 @@ function serverUrl(args, env) {
 }
 async function joinCommand(args, env) {
   const dir = stateDir(env);
-  const run2 = runner(dir, env);
   const own2 = findOwnSession(env, dir);
+  if (own2.agent === "claude-code")
+    assertClaudePolicy(env);
+  const run2 = runner(dir, env);
   const key = sessionKey(own2.agent, own2.cwd);
   const server = serverUrl(args, env);
   const existing = readState(dir).sessions.find((s) => s.key === key && s.server === server);
@@ -3116,7 +3420,7 @@ async function joinCommand(args, env) {
   const taken = new Set(readState(dir).sessions.filter((s) => s.key !== key).map((s) => s.name));
   const name = pickName(flag(args, "--name") ?? own2.chosen, defaultName(own2.agent, own2.cwd, gitRoot(own2.cwd)), (n) => taken.has(n));
   const clientId = await registerClient(server, agentLabel(own2.agent));
-  const signIn = signInLink(server, clientId, name);
+  const signIn = signInLink(server, clientId, name, own2.claudeInboundFallback);
   const pending = {
     server,
     clientId,
@@ -3127,13 +3431,14 @@ async function joinCommand(args, env) {
     sessionId: own2.sessionId,
     pid: own2.pid,
     agentBin: own2.agent === "codex" ? which("codex", env) : void 0,
-    startedAt: Date.now()
+    startedAt: Date.now(),
+    claudeInboundFallback: own2.claudeInboundFallback
   };
-  mkdirSync4(join7(dir, "pending"), { recursive: true, mode: 448 });
-  const file = join7(dir, "pending", `${createHash6("sha256").update(signIn.state).digest("hex").slice(0, 24)}.json`);
-  writeFileSync4(file, JSON.stringify(pending), { mode: 384 });
-  const out = join7(dir, "bridge.log");
-  const child = spawn5(run2.node, [run2.bundle, "session", "finish-join", file], { detached: true, stdio: "ignore", env: { ...env, BEELINE_SESSION_BUNDLE: run2.bundle } });
+  mkdirSync5(join10(dir, "pending"), { recursive: true, mode: 448 });
+  const file = join10(dir, "pending", `${createHash6("sha256").update(signIn.state).digest("hex").slice(0, 24)}.json`);
+  writeFileSync5(file, JSON.stringify(pending), { mode: 384 });
+  const out = join10(dir, "bridge.log");
+  const child = spawn6(run2.node, [run2.bundle, "session", "finish-join", file], { detached: true, stdio: "ignore", env: { ...env, BEELINE_SESSION_BUNDLE: run2.bundle } });
   child.unref();
   console.log([
     `Show your person this link. They open it on any device (a phone works) and sign in with GitHub or Google:`,
@@ -3142,16 +3447,18 @@ async function joinCommand(args, env) {
     "",
     `This ${agentLabel(own2.agent)} session joins their Beeline Rooms as "${name}" (they can rename it on the Allow page).`,
     `Nothing else to run: once they tap Allow, a confirmation arrives in this conversation. The link expires in 10 minutes.`,
-    ...own2.note ? ["", own2.note] : [],
     ...env.BEELINE_SESSION_DEBUG ? [`(log: ${out})`] : []
   ].join("\n"));
 }
 async function finishJoin(file, env) {
   const dir = stateDir(env);
   const run2 = runner(dir, env);
-  const pending = JSON.parse(readFileSync7(file, "utf8"));
+  const pending = JSON.parse(readFileSync9(file, "utf8"));
   try {
     const tokens = await finishSignIn(pending.server, pending.clientId, pending.signIn, pending.startedAt + 10 * 6e4);
+    if (pending.agent === "claude-code") {
+      assertClaudePolicy(env);
+    }
     const key = sessionKey(pending.agent, pending.cwd);
     const joined2 = {
       key,
@@ -3172,25 +3479,48 @@ async function finishJoin(file, env) {
     };
     const first = await callTool(joined2, tokens.access_token, "list_mentions", {});
     joined2.cursor = first.nextCursor;
+    joined2.deliveredWakes = first.wakes.map((w) => w.id);
+    joined2.wakesSeenAt = first.wakes.map((w) => w.createdAt).sort().at(-1);
     const me = await callTool(joined2, tokens.access_token, "list_rooms", {});
     joined2.name = me.you?.name ?? joined2.name;
     joined2.handle = me.you?.handle ?? void 0;
     await callTool(joined2, tokens.access_token, "set_profile", { name: joined2.name }).catch(() => void 0);
+    if (pending.agent === "claude-code" && pending.claudeInboundFallback && !hasClaudeMcp(dir, pending.pid)) {
+      const transcript = pending.sessionId ? claudeTranscript(pending.sessionId, env) : void 0;
+      if (transcript && permissionMode(transcript) === "bypassPermissions") {
+        await acceptClaudeInbound(env);
+        await new Promise((resolve11) => setTimeout(resolve11, 1e3));
+      }
+    }
     await updateState(dir, (state) => {
       state.sessions = state.sessions.filter((s) => s.key !== key);
       state.sessions.push(joined2);
+      const waiting = [...first.mentions.map((m) => renderMention(m, joined2, run2)), ...first.wakes.map((w) => renderWake(w, joined2, run2))];
+      if (waiting.length)
+        queueInbox(dir, key, waiting.join("\n\n"));
     });
     const changes = setupAgent(pending.agent, { env, node: run2.node, bundle: run2.bundle });
+    if (pending.agent === "codex" && await trustCodexHook({ env, node: run2.node, bundle: run2.bundle }, pending.agentBin ?? "codex", pending.cwd)) {
+      const prompt = changes.findIndex((line) => line.startsWith("Codex asks once"));
+      if (prompt >= 0)
+        changes.splice(prompt, 1);
+      changes.push("Trusted only Beeline\u2019s SessionStart hook, pinned to its current Codex hash.");
+    }
     ensureBridge(dir, run2, env);
     const rooms = me.rooms.map((r) => r.name).slice(0, 5).join(", ");
     await announce(joined2, `Beeline: you joined as @${joined2.handle ?? joined2.name}${rooms ? ` in ${rooms}` : ""}. When someone tags you there, the message arrives here with the command that answers it.${changes.length ? `
 (${changes.join("; ")})` : ""}`, dir);
   } finally {
-    rmSync4(file, { force: true });
+    rmSync6(file, { force: true });
   }
 }
 async function announce(joined2, text, dir) {
   if (joined2.agent === "claude-code") {
+    if (hasClaudeMcp(dir, joined2.pid)) {
+      const { queueInbox: queueInbox3 } = await Promise.resolve().then(() => (init_store(), store_exports));
+      queueInbox3(dir, joined2.key, text);
+      return;
+    }
     const session2 = scanClaude().find((s) => s.sessionId === joined2.sessionId || s.pid === joined2.pid);
     if (session2?.messagingSocketPath) {
       await postToClaude({ path: session2.messagingSocketPath }, text).catch(() => void 0);
@@ -3218,7 +3548,7 @@ function own(args, env) {
 }
 async function ownTool(dir, joined2, name, args) {
   let bridged = await toolViaBridge(dir, joined2.key, name, args);
-  if (!bridged && existsSync4(join7(dir, "bridge.pid")) && process.cwd().startsWith(joined2.cwd))
+  if (!bridged && existsSync5(join10(dir, "bridge.pid")) && process.cwd().startsWith(joined2.cwd))
     bridged = await toolViaOutbox(joined2.cwd, name, args);
   if (bridged) {
     if (!bridged.ok)
@@ -3236,6 +3566,8 @@ async function session(args, env) {
     return finishJoin(rest[0] ?? "", env);
   if (sub === "mcp")
     return runZcodeMcp(dir);
+  if (sub === "claude-mcp")
+    return runClaudeMcp(dir, env);
   if (sub === "antigravity-sidecar")
     return runAntigravitySidecar(dir);
   if (sub === "hook") {
@@ -3316,6 +3648,7 @@ async function session(args, env) {
       return state.sessions;
     });
     const r = runner(dir, env);
+    await restoreClaudeInbound(env);
     const changes = left.some((s) => s.agent === joined2.agent) ? [] : setupAgent(joined2.agent, { env, node: r.node, bundle: r.bundle, remove: true });
     console.log([`@${joined2.handle ?? joined2.name} left Beeline on this machine.`, ...changes].join("\n"));
     return;
@@ -3337,8 +3670,19 @@ function readStdin(limitMs) {
   });
 }
 async function runSessionCommand(args, env = process.env) {
-  if (args[0] === "join")
-    return joinCommand(args.slice(1), env);
+  if (args[0] === "join") {
+    try {
+      return await joinCommand(args.slice(1), env);
+    } catch (error) {
+      const failure = error;
+      const cause = failure?.cause;
+      const denied = [failure, cause].some((e) => e && (["EACCES", "EPERM", "EROFS"].includes(e.code ?? "") || e.code === "ENOENT" && e.syscall === "mkdir"));
+      if (detectAgent(env)?.agent === "codex" && denied) {
+        throw new Error('Codex blocked access needed to join Beeline. Run /permissions, pick "Ask for approval", then run Join again. Choose "Yes, proceed" for the Join command once; no permanent allowance or Full Access is needed.', { cause: error });
+      }
+      throw error;
+    }
+  }
   return session(args.slice(1), env);
 }
 var VALUED;
@@ -3349,7 +3693,10 @@ var init_command = __esm({
     init_beeline_api();
     init_bridge();
     init_claude();
+    init_claude_inbound();
+    init_claude_mcp();
     init_codex();
+    init_codex_trust();
     init_hook();
     init_pull_apps();
     init_setup();
@@ -3359,7 +3706,7 @@ var init_command = __esm({
 });
 
 // apps/body/dist/recovery-cli.js
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { readFile as readFile4, readdir as readdir5, stat as stat2, unlink } from "node:fs/promises";
 import { resolve as resolve10 } from "node:path";
 
@@ -3988,7 +4335,7 @@ async function main() {
   const entry = await resolveBundleEntrypoint(layout.libDir);
   if (!entry)
     throw new Error("no installed Beeline body; run npx usebeeline connect");
-  const child = spawn6(process.execPath, [entry, ...args], {
+  const child = spawn7(process.execPath, [entry, ...args], {
     env: {
       ...process.env,
       BEELINE_LIB_DIR: layout.libDir,
@@ -4006,7 +4353,7 @@ async function convergeDependencies(layout, deadlineAt) {
   if (!entry)
     throw new Error("dependency phase has no selected body");
   await new Promise((done, reject) => {
-    const child = spawn6(process.execPath, [entry, "converge-dependencies"], {
+    const child = spawn7(process.execPath, [entry, "converge-dependencies"], {
       env: { ...process.env, BEELINE_LIB_DIR: layout.libDir, BEELINE_INTERNAL_RECOVERY: "1" },
       stdio: "inherit"
     });