@scp-dev/cli 0.3.1 → 0.5.0

package/dist/{chunk-Q5UI4Z7H.js → chunk-2342GTME.js}

@@ -10,11 +10,11 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-XQHPDNVG.js";
 import {
   RelayUsage,
   gitToplevel
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 
 // src/install.ts
 import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";

package/dist/{chunk-3SHVJIXP.js → chunk-7RA7E5WR.js}

@@ -3,10 +3,10 @@ import {
   agySettingsFile,
   mcpFile,
   mountedEntry
-} from "./chunk-2OSUVJ2J.js";
+} from "./chunk-UKQBH4AQ.js";
 import {
   steerPrompt
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-XQHPDNVG.js";
 import {
   OPTIONS,
   RelayUsage,
@@ -18,7 +18,7 @@ import {
   selectorList,
   spawnerKey,
   walkNow
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import {
   SELF,
   note
@@ -44,8 +44,8 @@ import {
 } from "@scp-dev/core";
 var SERVER = "scp";
 var SPAWN_RUNNER = "SCP_SPAWN_RUNNER";
-var SPAWNER_IDENTITY = ["SCP_NAME", "SCP_SESSION", "SCP_GRANT", "SCP_PARENT", "SCP_HARNESS", SPAWN_RUNNER];
-var SHIM_ENV = ["SCP_GRANT", "SCP_NAME", "SCP_LABELS", "SCP_DIR", "XDG_STATE_HOME"];
+var SPAWNER_IDENTITY = ["SCP_NAME", "SCP_SESSION", "SCP_GRANT", "SCP_PARENT", "SCP_HARNESS", "SCP_SHIM_BINDING", SPAWN_RUNNER];
+var SHIM_ENV = ["SCP_GRANT", "SCP_NAME", "SCP_LABELS", "SCP_DIR", "XDG_STATE_HOME", "SCP_SHIM_BINDING"];
 function spawnEnvironment(parent, grant, labels) {
   const env = {};
   for (const [key, value] of Object.entries(parent)) if (value !== void 0 && !SPAWNER_IDENTITY.includes(key)) env[key] = value;

package/dist/{chunk-2LIJXXTL.js → chunk-AAFHLHXG.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-MNTIEWKF.js";
 
 // src/relay.ts
-import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { chmodSync as chmodSync2, mkdirSync, readFileSync as readFileSync2, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join3, dirname as dirname2 } from "path";
 import { randomUUID } from "crypto";
 import { CLI_NAME as CLI_NAME3 } from "@scp-dev/core";
@@ -16,13 +16,13 @@ import { spawn } from "child_process";
 import { closeSync, openSync, statSync, truncateSync } from "fs";
 import { join as join2 } from "path";
 import { CLI_NAME as CLI_NAME2 } from "@scp-dev/core";
-import { connectBroker, privateDir, relayDir as relayDir2 } from "@scp-dev/broker";
+import { connectBroker, privateDir as privateDir2, relayDir as relayDir3 } from "@scp-dev/broker";
 
 // src/identity.ts
-import { existsSync, realpathSync } from "fs";
+import { chmodSync, existsSync, readFileSync, realpathSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { basename, dirname, isAbsolute, join, resolve } from "path";
-import { shortHostname } from "@scp-dev/broker";
+import { privateDir, relayDir, shortHostname } from "@scp-dev/broker";
 import { GENERIC_HARNESSES, LIMITS, validHandle, validHarness } from "@scp-dev/core";
 var SHORT = { "claude-code": "claude" };
 var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "fish"]);
@@ -34,6 +34,61 @@ function detectHarness(env) {
   if (env.ANTIGRAVITY_AGENT === "1" || env.ANTIGRAVITY_CONVERSATION_ID) return "agy";
   if (env.CLAUDECODE === "1") return "claude-code";
   if (env.CODEX_THREAD_ID) return "codex";
+  if (inferring(env) && (env.CODEX_SANDBOX || env.CODEX_SANDBOX_NETWORK_DISABLED)) return "codex";
+  return void 0;
+}
+var BINDING_KEY = /^[0-9a-f]{1,128}$/;
+var BINDING_PROCESS = /^pid:([1-9][0-9]*):[A-Za-z0-9:-]{1,64}$/;
+function codexShell(env) {
+  return env.SCP_HARNESS === "codex" || inferring(env) && detectHarness(env) === "codex";
+}
+function writeShimBinding(claim, env) {
+  const pid = BINDING_PROCESS.exec(claim.process)?.[1];
+  if (claim.harness !== "codex" || !pid) return () => {
+  };
+  const text = JSON.stringify({ process: claim.process, handle: claim.handle, harness: claim.harness });
+  const names = [`pid-${pid}`, ...BINDING_KEY.test(env.SCP_SHIM_BINDING ?? "") ? [`key-${env.SCP_SHIM_BINDING}`] : []];
+  const paths = [];
+  for (const name of names) {
+    try {
+      const path = join(privateDir(join(relayDir(env), "bindings")), `${name}.json`);
+      writeFileSync(path, text, { mode: 384 });
+      chmodSync(path, 384);
+      paths.push(path);
+    } catch {
+    }
+  }
+  return () => {
+    for (const path of paths) {
+      try {
+        if (readFileSync(path, "utf8") === text) rmSync(path);
+      } catch {
+      }
+    }
+  };
+}
+function readShimBinding(env, pid, table) {
+  const read = (name, expectedPid) => {
+    try {
+      const binding = JSON.parse(readFileSync(join(relayDir(env), "bindings", `${name}.json`), "utf8"));
+      const match = typeof binding.process === "string" ? BINDING_PROCESS.exec(binding.process) : null;
+      if (match && Number(match[1]) > 1 && (expectedPid === void 0 || Number(match[1]) === expectedPid) && binding.harness === "codex" && typeof binding.handle === "string" && validHandle(binding.handle))
+        return binding;
+    } catch {
+    }
+    return void 0;
+  };
+  if (BINDING_KEY.test(env.SCP_SHIM_BINDING ?? "")) {
+    const binding = read(`key-${env.SCP_SHIM_BINDING}`);
+    if (binding) return binding;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  while (pid > 1 && !seen.has(pid)) {
+    seen.add(pid);
+    const entry = table?.get(pid);
+    if (!entry) return read(`pid-${pid}`, pid);
+    pid = entry.ppid;
+  }
   return void 0;
 }
 function normalizeHarness(raw, fallback) {
@@ -342,9 +397,9 @@ function relayIdentity(input) {
 
 // src/session.ts
 import { CLI_NAME } from "@scp-dev/core";
-import { readSessionMarker, relayDir } from "@scp-dev/broker";
+import { readSessionMarker, relayDir as relayDir2 } from "@scp-dev/broker";
 function membership(env, session) {
-  const marker = readSessionMarker(relayDir(env), session);
+  const marker = readSessionMarker(relayDir2(env), session);
   if (marker?.joined === false) return { dark: `this session left the relay; ${CLI_NAME} join (or relay_join) joins it again` };
   if (!marker?.joined && joinMode(env) === "manual") return { dark: `this session has not joined the relay; ${CLI_NAME} join <name> (or relay_join) joins it` };
   return marker?.handle ? { handle: marker.handle } : {};
@@ -471,7 +526,7 @@ var DAEMON_ENV = [
 ];
 var LOG_MAX_BYTES = 1024 * 1024;
 function startDaemon(dir) {
-  privateDir(dir);
+  privateDir2(dir);
   const logFile = join2(dir, "broker.log");
   if ((statSync(logFile, { throwIfNoEntry: false })?.size ?? 0) > LOG_MAX_BYTES) truncateSync(logFile, 0);
   const log = openSync(logFile, "a", 384);
@@ -499,11 +554,18 @@ function localHandle(raw) {
   if (handle.includes("/")) throw new RelayUsage(`--as names a local handle, not ${JSON.stringify(raw)}`);
   return handle;
 }
-function walkNow() {
-  const table = readPsTable();
-  const self = harnessLineage(process.ppid, table);
+function walkNow(env = process.env, pid = process.ppid, table = readPsTable()) {
+  const keys = lineage(pid, table);
+  const self = harnessLineage(pid, table);
+  if (!self.length && codexShell(env)) {
+    const binding = readShimBinding(env, pid, table);
+    if (binding) {
+      const bound = [...keys, binding.process];
+      return { keys: bound, self: bound, harness: "codex" };
+    }
+  }
   const harness = self.length ? harnessAt(Number(/^pid:(\d+)/.exec(self.at(-1))?.[1]), table) : void 0;
-  return { keys: lineage(process.ppid, table), self, ...harness ? { harness } : {} };
+  return { keys, self, ...harness ? { harness } : {} };
 }
 function claimHarness(values, env, walk) {
   return values.harness ?? env.SCP_HARNESS ?? (inferring(env) ? walk?.harness ?? detectHarness(env) : void 0) ?? "cli";
@@ -529,7 +591,7 @@ async function open(verb, values, cwd, bodyFromStdin, walk) {
         `${CLI_NAME2} ${verb} needs an identity: --as HANDLE (or $SCP_NAME) for an agent, or --human for your own inbox me/ (no terminal is attached, so me/ is not assumed)`
       );
     }
-    const { machineName, openCloud } = await import("./remote-P4GFUIAP.js");
+    const { machineName, openCloud } = await import("./remote-UQJ5YYCC.js");
     const handle2 = named ? localHandle(named) : void 0;
     const claim = handle2 ? {
       handle: handle2,
@@ -558,7 +620,7 @@ async function open(verb, values, cwd, bodyFromStdin, walk) {
   const handle = "handle" in joined && joined.handle ? joined.handle : named ? localHandle(named) : void 0;
   const harnessPid2 = self.length ? Number(/^pid:(\d+)/.exec(self.at(-1))?.[1]) : void 0;
   const lineageClaim = keys.length ? { lineage: keys } : {};
-  const dir = relayDir2();
+  const dir = relayDir3();
   const client = await connectBroker(dir, () => startDaemon(dir));
   try {
     let bound;
@@ -688,7 +750,7 @@ function checkRelayUrl(text, what = "relay URL") {
 function readObject(path) {
   let text;
   try {
-    text = readFileSync(path, "utf8");
+    text = readFileSync2(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw new RelayUsage(`could not read ${path}`);
@@ -704,15 +766,15 @@ function readObject(path) {
 function writePrivateJson(path, value) {
   const dir = dirname2(path);
   mkdirSync(dir, { recursive: true, mode: 448 });
-  chmodSync(dir, 448);
+  chmodSync2(dir, 448);
   const temp = join3(dir, `.${randomUUID()}.tmp`);
   try {
-    writeFileSync(temp, `${JSON.stringify(value, null, 2)}
+    writeFileSync2(temp, `${JSON.stringify(value, null, 2)}
 `, { mode: 384, flag: "wx" });
-    chmodSync(temp, 384);
+    chmodSync2(temp, 384);
     renameSync(temp, path);
   } finally {
-    rmSync(temp, { force: true });
+    rmSync2(temp, { force: true });
   }
 }
 function activeRelay(env = process.env) {
@@ -787,7 +849,7 @@ function relayVerb(positionals, asJson, env = process.env) {
 }
 async function loginMain(positionals, values) {
   if (positionals.length) throw new RelayUsage(`${CLI_NAME3} login takes only flags`);
-  return (await import("./login-AUMLI4FS.js")).login(values);
+  return (await import("./login-6MVD3VLC.js")).login(values);
 }
 function logoutMain(positionals, asJson, env = process.env) {
   if (positionals.length) throw new RelayUsage(`${CLI_NAME3} logout takes no arguments`);
@@ -802,6 +864,8 @@ function logoutMain(positionals, asJson, env = process.env) {
 export {
   shortHostname,
   detectHarness,
+  codexShell,
+  writeShimBinding,
   normalizeHarness,
   hookHarness,
   gitToplevel,
@@ -835,6 +899,7 @@ export {
   OPTIONS,
   SPAWN_OPTIONS,
   startDaemon,
+  terminalAttached,
   localHandle,
   walkNow,
   open,

package/dist/{chunk-IEFXYBX7.js → chunk-H2XQXMZU.js}

@@ -5,7 +5,7 @@ import {
   configDir,
   relayCredential,
   writePrivateJson
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import {
   note,
   printTable

package/dist/{chunk-2OSUVJ2J.js → chunk-UKQBH4AQ.js}

@@ -1,6 +1,6 @@
 import {
   hooksTarget
-} from "./chunk-Q5UI4Z7H.js";
+} from "./chunk-2342GTME.js";
 import {
   AGY_HOOK_SET,
   BLOCK_STOP,
@@ -12,12 +12,12 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-XQHPDNVG.js";
 import {
   RelayUsage,
   gitToplevel,
   setJoinMode
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 
 // src/setup.ts
 import { spawnSync } from "child_process";

package/dist/{chunk-QRWQIHV6.js → chunk-XQHPDNVG.js}

@@ -13,7 +13,7 @@ import {
   psStart,
   relayIdentity,
   sessionKey
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 
 // src/hooks.ts
 import { Readable } from "stream";
@@ -545,13 +545,26 @@ async function runHook(args, options) {
 }
 async function wakeHook(harnessArg, payload, waitS, options) {
   if (options.env.SCP_TRANSPORT === "cloud" || field(payload, "agent_id", "agentId", "agent_type", "agentType", "subagentType")) return;
+  const harness = normalizeHarness(hookHarness(harnessArg, options.env), "hook");
+  const pid = (options.harnessPid ?? ((h) => hookHarnessPid(options.env, h)))(harness);
+  const started = psStart(pid);
+  const joined = membership(
+    options.env,
+    sessionKey(
+      options.env,
+      processKey(pid, () => started)
+    )
+  );
+  if ("dark" in joined) return;
   const claim = relayIdentity({
-    harness: hookHarness(harnessArg, options.env),
+    ...joined.handle ? { as: joined.handle } : {},
+    harness,
     fallbackHarness: "hook",
     cwd: asString(payload.cwd) ?? options.cwd,
     env: options.env,
-    harnessPid: options.harnessPid ?? ((harness) => hookHarnessPid(options.env, harness)),
-    ...options.harnessPid ? {} : { inferHarness: (at) => harnessAt(at) }
+    harnessPid: () => pid,
+    ...options.harnessPid ? {} : { inferHarness: (at) => harnessAt(at) },
+    startOf: () => started
   });
   if (!validHandle(claim.handle)) return;
   const waitMs = Math.min(waitS, LIMITS.waitMaxS) * 1e3;

package/dist/{claude-EQVLST73.js → claude-RNH2E4GU.js}

@@ -3,16 +3,16 @@ import {
   mcpFile,
   mountedEntry,
   whichOnPath
-} from "./chunk-2OSUVJ2J.js";
-import "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+} from "./chunk-UKQBH4AQ.js";
+import "./chunk-2342GTME.js";
+import "./chunk-XQHPDNVG.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
   RelayUsage,
   deriveHandle,
   joinMode
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/claude.ts

package/dist/cli.js

@@ -17,6 +17,6 @@ function quietSqliteWarning() {
 // src/cli.ts
 if (!await subagentFastPath(process.argv.slice(2))) {
   quietSqliteWarning();
-  const { run } = await import("./main-ZAYVXFAG.js");
+  const { run } = await import("./main-F2NFQ2KC.js");
   await run(process.argv.slice(2));
 }

package/dist/{codex-5GZ7YPES.js → codex-OSGHQMK6.js}

@@ -3,18 +3,18 @@ import {
   codexMount,
   codexOverrides,
   toml
-} from "./chunk-3SHVJIXP.js";
+} from "./chunk-7RA7E5WR.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-2OSUVJ2J.js";
-import "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+import "./chunk-UKQBH4AQ.js";
+import "./chunk-2342GTME.js";
+import "./chunk-XQHPDNVG.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   RelayUsage,
   readPsTable,
   relayIdentity,
   startDaemon
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import {
   SELF
 } from "./chunk-MNTIEWKF.js";
@@ -29,7 +29,7 @@ import { join } from "path";
 import { PassThrough } from "stream";
 import { setTimeout as sleep } from "timers/promises";
 import { connectBroker, relayDir } from "@scp-dev/broker";
-import { CLI_NAME, validHandle } from "@scp-dev/core";
+import { CLI_NAME, RelayError, validHandle } from "@scp-dev/core";
 import { MCP_PROTOCOLS, runRelayMcp } from "@scp-dev/mcp";
 import { parse } from "smol-toml";
 var CODEX_HELP = `${CLI_NAME} codex [--name N | --as N] [--headless] [--resume THREAD] [--] [codex args...]
@@ -61,13 +61,13 @@ function codexLaunch(args, env, _self) {
   }
   name = name?.replace(/^me\//, "");
   if (name !== void 0 && !validHandle(name)) throw new RelayUsage(`${JSON.stringify(name)} is not a valid agent handle`);
-  const { SCP_SESSION: _session, SCP_GRANT: _grant, SCP_PARENT: _parent, ...clean } = env;
+  const { SCP_SESSION: _session, SCP_PARENT: _parent, ...clean } = env;
   return {
     ...name !== void 0 ? { name } : {},
     headless,
     ...resume !== void 0 ? { resume } : {},
     codexArgs: resume !== void 0 && !headless ? ["resume", resume, ...codexArgs] : codexArgs,
-    env: { ...clean, SCP_HARNESS: "codex", ...name !== void 0 ? { SCP_NAME: name } : {} }
+    env: { ...clean, SCP_HARNESS: "codex", SCP_SHIM_BINDING: randomBytes(16).toString("hex"), ...name !== void 0 ? { SCP_NAME: name } : {} }
   };
 }
 var CodexSocket = class {
@@ -398,6 +398,24 @@ function appServerPid(pid) {
   }
   return pid;
 }
+async function connectCodexChannel(connect2, claim, cwd, stopped) {
+  while (!stopped()) {
+    const client = await connect2();
+    try {
+      const hello = await client.hello({ observe: true, self: [claim.process], ...claim.grant ? { grant: claim.grant } : {}, cwd });
+      if (hello.endpoint) {
+        client.hello = async () => hello;
+        return client;
+      }
+    } catch (error) {
+      client.close();
+      if (!claim.grant || !(error instanceof RelayError) || error.code !== "unauthorized") throw error;
+    }
+    client.close();
+    await sleep(100);
+  }
+  throw new Error("codex channel stopped");
+}
 async function codexCommand(args) {
   if (args[0] === "--help" || args[0] === "-h") {
     process.stdout.write(`${CODEX_HELP}
@@ -514,24 +532,12 @@ ${stderr.toString().trim()}` : ""}`
     const broker = relayDir(launch.env);
     let lines = "";
     channel = runRelayMcp({
-      connect: async () => {
-        while (!input.writableEnded) {
-          const client = await connectBroker(broker, () => startDaemon(broker));
-          try {
-            const hello = await client.hello({ observe: true, self: [claim.process], cwd });
-            if (hello.endpoint) {
-              client.hello = async () => hello;
-              return client;
-            }
-          } catch (error) {
-            client.close();
-            throw error;
-          }
-          client.close();
-          await sleep(100);
-        }
-        throw new Error("codex channel stopped");
-      },
+      connect: () => connectCodexChannel(
+        () => connectBroker(broker, () => startDaemon(broker)),
+        claim,
+        cwd,
+        () => input.writableEnded
+      ),
       claim,
       channels: true,
       wake: "codex-app-server",
@@ -611,5 +617,6 @@ export {
   CodexWaker,
   codexCommand,
   codexLaunch,
+  connectCodexChannel,
   serverOptions
 };

package/dist/{hooks-B34E2HIP.js → hooks-BZANUJPY.js}

@@ -40,11 +40,11 @@ import {
   tldrEvery,
   transcriptTitle,
   unreadPointer
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-XQHPDNVG.js";
 import {
   SUBAGENT
 } from "./chunk-YYSLYVNZ.js";
-import "./chunk-2LIJXXTL.js";
+import "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 export {
   AGY_HOOK_SET,

package/dist/{install-6KXJY27V.js → install-25J5QB63.js}

@@ -2,10 +2,10 @@ import {
   hooksTarget,
   installHooks,
   mcpInstall
-} from "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+} from "./chunk-2342GTME.js";
+import "./chunk-XQHPDNVG.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-2LIJXXTL.js";
+import "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 export {
   hooksTarget,

package/dist/{join-FITJVZCA.js → join-EOLHE3LJ.js}

@@ -1,12 +1,13 @@
 import {
   RelayUsage,
+  codexShell,
   harnessAt,
   localHandle,
   relayIdentity,
   sessionKey,
   startDaemon,
   walkNow
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/join.ts
@@ -18,7 +19,10 @@ async function joinCommand(values, positionals, cwd, out) {
   const { keys, self } = walkNow();
   const key = self.at(-1);
   const match = key === void 0 ? null : /^pid:(\d+):(.+)$/.exec(key);
-  if (!match) throw new RelayUsage(`${CLI_NAME} join runs in an agent session's shell: no harness process runs this shell`);
+  if (!match) {
+    if (codexShell(process.env)) throw new RelayUsage(`${CLI_NAME} join: the codex sandbox hides the harness; use relay_join (MCP) instead`);
+    throw new RelayUsage(`${CLI_NAME} join runs in an agent session's shell: no harness process runs this shell`);
+  }
   const dir = relayDir();
   const known = readSessionMarker(dir, sessionKey(process.env, key))?.handle;
   const claim = relayIdentity({

package/dist/{login-AUMLI4FS.js → login-6MVD3VLC.js}

@@ -1,11 +1,11 @@
 import {
   machineName
-} from "./chunk-IEFXYBX7.js";
+} from "./chunk-H2XQXMZU.js";
 import {
   RelayUsage,
   activeRelay,
   saveCredential
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import {
   note
 } from "./chunk-MNTIEWKF.js";

package/dist/{main-ZAYVXFAG.js → main-F2NFQ2KC.js}

@@ -14,8 +14,9 @@ import {
   shortHostname,
   stamp,
   startDaemon,
+  terminalAttached,
   time
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import {
   FAILED,
   exitFlushed,
@@ -34,7 +35,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.3.1",
+  version: "0.5.0",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -105,6 +106,8 @@ results back, as with native subagents.
   ${CLI_NAME} list [--all]                agents on the relay: address, title, presence, wake, status; --all adds offline ones
   ${CLI_NAME} join [name]                 put this session on the relay, named once: ${CLI_NAME} join lead (${CLI_NAME} name renames it)
   ${CLI_NAME} join --under <parent>       link this session under an orchestrator, as a spawned worker sits: ${CLI_NAME} join --under lead
+  ${CLI_NAME} adopt <child>              ask a local root agent to link under you; it accepts with ${CLI_NAME} link accept <id>
+  ${CLI_NAME} link accept <id>           accept a link request and sit under its sender as a worker
   ${CLI_NAME} status [id]                 the fleet in short; with the id of a message you sent: who read it when
   ${CLI_NAME} peek <ep>                   a short, redacted view of a peekable agent's last turns: ${CLI_NAME} peek rev
   ${CLI_NAME} set-status <state> [note]   working, waiting, blocked or done: ${CLI_NAME} set-status done "PR open"
@@ -286,13 +289,20 @@ agent sessions:
                                                  and title stay; a handle another endpoint holds, live or offline, is refused;
                                                  a spawned worker is named by its spawner (policy defaults.rename: self lets it);
                                                  --endpoint renames another agent, for the human at a terminal
-  ${CLI_NAME} join [<handle>] --under <parent>   link the session under the agent <parent> (local, one it may message), as if
+  ${CLI_NAME} join [<handle>] --under <parent>   link the session under the agent <parent> (one it may message), as if
                                                  <parent> had spawned it: it shows under <parent> in list --tree, the dashboard
                                                  and the graph, and takes on a worker's scope (the policy's child_default: by
-                                                 default it reaches only what <parent> reaches). Narrowing, so always allowed
+                                                 default it reaches only what <parent> reaches). Narrowing, so always allowed.
+                                                 <parent> may be on another machine of the account (me/<machine>/<handle>):
+                                                 the session stays a root there, takes no child scope, and the two reach
+                                                 each other both ways
   ${CLI_NAME} adopt <child> [--parent <p>]      link a local root agent and its subtree under <p>, for the human at a terminal;
-                                                 from an agent's shell with a terminal attached <p> defaults to that agent.
-                                                 An agent without a terminal is refused: the session joins with --under itself
+                                                 <p> may be on another machine of the account (me/<machine>/<handle>).
+                                                 With --parent and a terminal, inherited $SCP_NAME and $SCP_GRANT are ignored
+                                                 unless --as is explicit. An agent without a terminal asks the child to consent,
+                                                 under itself only; the child accepts with link accept or join --under
+  ${CLI_NAME} link accept <id>                  accept a link request delivered to this session and sit under its sender as a worker;
+                                                 <id> is the full or short message id. Only the session itself may accept
   ${CLI_NAME} unlink [<child>]                  put a linked agent back at the root, its subtree along and the child scope off;
                                                  widening, so the human at a terminal only (policy defaults.unlink: self lets
                                                  an agent unlink itself). A link that would put a parent under its own child
@@ -383,6 +393,7 @@ var VERBS = {
   send: [...IDENTITY, "reply-to", "thread", "private", "attach", "live"],
   join: ["harness", "json", "under"],
   adopt: [...IDENTITY, "parent"],
+  link: IDENTITY,
   unlink: IDENTITY,
   leave: [...IDENTITY, "endpoint"],
   name: [...IDENTITY, "endpoint"],
@@ -558,14 +569,14 @@ async function relayMain(argv, cwd = process.cwd()) {
     out(cliVersion());
     return 0;
   }
-  if (verb === "hook") return (await import("./hooks-B34E2HIP.js")).relayHookCommand(rest, startDaemon);
-  if (verb === "setup") return (await import("./setup-MGDWKCNU.js")).relaySetupCommand(rest, cwd, out);
-  if (verb === "claude") return (await import("./claude-EQVLST73.js")).claudeCommand(rest);
-  if (verb === "pi") return (await import("./pi-QEZVFDNR.js")).piCommand(rest);
-  if (verb === "codex") return (await import("./codex-5GZ7YPES.js")).codexCommand(rest);
-  if (verb === "opencode") return (await import("./opencode-ORLGNHWR.js")).opencodeCommand(rest, process.env, void 0, cwd);
+  if (verb === "hook") return (await import("./hooks-BZANUJPY.js")).relayHookCommand(rest, startDaemon);
+  if (verb === "setup") return (await import("./setup-UJCIMYU4.js")).relaySetupCommand(rest, cwd, out);
+  if (verb === "claude") return (await import("./claude-RNH2E4GU.js")).claudeCommand(rest);
+  if (verb === "pi") return (await import("./pi-N3DX37PD.js")).piCommand(rest);
+  if (verb === "codex") return (await import("./codex-OSGHQMK6.js")).codexCommand(rest);
+  if (verb === "opencode") return (await import("./opencode-XV33XTL5.js")).opencodeCommand(rest, process.env, void 0, cwd);
   if (verb === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-GG7VFZA6.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-JYD7NCQT.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -573,7 +584,7 @@ async function relayMain(argv, cwd = process.cwd()) {
     }
     return spawnCommand(rest, cwd);
   }
-  if (verb === "mesh") return (await import("./mesh-H4KL5XAR.js")).meshCommand(rest);
+  if (verb === "mesh") return (await import("./mesh-OZILTV5P.js")).meshCommand(rest);
   const allowed = VERBS[verb];
   if (!allowed) throw new RelayUsage(`unknown command "${verb}"`);
   let parsed;
@@ -593,11 +604,11 @@ async function relayMain(argv, cwd = process.cwd()) {
     return daemon(values.idle, values.policy);
   }
   if (verb === "mcp")
-    return (await import("./mcp-VXBRMQB7.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-BH526TOG.js")).relayMcpCommand(values, positionals);
   if (verb === "hooks") {
     if (positionals[0] !== "install" || positionals.length > 1) throw new RelayUsage(`${CLI_NAME} hooks takes install --harness claude|codex|opencode|agy|muse`);
     if (values.write && values.print) throw new RelayUsage("--print and --write: pick one");
-    return (await import("./install-6KXJY27V.js")).installHooks({
+    return (await import("./install-25J5QB63.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -608,31 +619,48 @@ async function relayMain(argv, cwd = process.cwd()) {
       out
     });
   }
-  if (verb === "relay") return (await import("./relay-QWJM372C.js")).relayVerb(positionals, values.json === true);
-  if (verb === "up") return (await import("./up-B2NEOOC6.js")).up(positionals, values, cwd, relinkBroker);
+  if (verb === "relay") return (await import("./relay-SF3UWIPM.js")).relayVerb(positionals, values.json === true);
+  if (verb === "up") return (await import("./up-3YJU7YX6.js")).up(positionals, values, cwd, relinkBroker);
   if (verb === "login") {
-    const code = await (await import("./relay-QWJM372C.js")).loginMain(positionals, values);
+    const code = await (await import("./relay-SF3UWIPM.js")).loginMain(positionals, values);
     if (code === 0) await relinkRunning();
     return code;
   }
-  if (verb === "logout") return (await import("./relay-QWJM372C.js")).logoutMain(positionals, values.json === true);
+  if (verb === "logout") return (await import("./relay-SF3UWIPM.js")).logoutMain(positionals, values.json === true);
   if (verb === "cloud") {
-    const code = await (await import("./remote-P4GFUIAP.js")).cloudMain(positionals, values, cloudStatus);
+    const code = await (await import("./remote-UQJ5YYCC.js")).cloudMain(positionals, values, cloudStatus);
     if (code === 0 && positionals[0] === "enable") await relinkRunning();
     return code;
   }
-  if (verb === "join") return (await import("./join-FITJVZCA.js")).joinCommand(values, positionals, cwd, out);
+  if (verb === "join") return (await import("./join-EOLHE3LJ.js")).joinCommand(values, positionals, cwd, out);
   if (verb === "holds") holdsArgs(values, positionals);
   const bodyFromStdin = (verb === "send" || verb === "ask" || verb === "reply") && (positionals[1] === void 0 || positionals[1] === "-");
-  const opened = await open(verb, values, cwd, bodyFromStdin);
+  const humanAdopt = verb === "adopt" && values.parent !== void 0 && values.as === void 0 && terminalAttached(process, false);
+  const opened = humanAdopt ? await openAdoptHuman(cwd, values) : await open(verb, values, cwd, bodyFromStdin);
   const { client } = opened;
   try {
-    if (verb === "machines") return await (await import("./remote-P4GFUIAP.js")).machinesVerb(client, positionals, values.json === true);
+    if (verb === "machines") return await (await import("./remote-UQJ5YYCC.js")).machinesVerb(client, positionals, values.json === true);
     return await runVerb(opened, verb, values, positionals, cwd);
   } finally {
     client.close();
   }
 }
+async function openAdoptHuman(cwd, values) {
+  if (values.cloud || process.env.SCP_TRANSPORT === "cloud") {
+    const { openCloud } = await import("./remote-UQJ5YYCC.js");
+    return { ...await openCloud({ tty: true, ...values.machine !== void 0 ? { machine: values.machine } : {} }), broker: null, bound: "human" };
+  }
+  if (values.machine !== void 0) throw new RelayUsage("--machine names the machine of the cloud transport: add --cloud");
+  const dir = relayDir();
+  const client = await connectBroker(dir, () => startDaemon(dir));
+  try {
+    const hello = await client.hello({ human: true, tty: true, cwd, brief: true });
+    return { client, me: hello.endpoint, broker: hello.broker, where: brokerLine(hello.broker), bound: "human" };
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+}
 async function cloudStatus() {
   const dir = relayDir();
   const client = await connectBroker(dir, () => startDaemon(dir));
@@ -804,9 +832,9 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       return 0;
     }
     case "peek":
-      return (await import("./peek-YTCWVPF7.js")).peekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-LFQR6TCS.js")).peekCommand(localClient(client, broker, verb), values, positionals);
     case "set-peek":
-      return (await import("./peek-YTCWVPF7.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-LFQR6TCS.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
     case "why": {
       const [from, to] = positionals;
       if (!from || !to || positionals.length > 2) throw new RelayUsage(`${CLI_NAME} why takes <from> <to>`);
@@ -1045,6 +1073,16 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
         ...parent !== void 0 ? { parent } : {}
       });
       if (asJson) json(result);
+      else if (result.held) out(heldText(result.held));
+      else if (result.requested)
+        out(`asked ${result.endpoint.address} to link under ${result.parent}; it accepts with ${CLI_NAME} link accept ${shortId(result.requested)}`);
+      else out(`${result.endpoint.address} now sits under ${result.parent}`);
+      return 0;
+    }
+    case "link": {
+      if (positionals.length !== 2 || positionals[0] !== "accept") throw new RelayUsage(`${CLI_NAME} link takes accept <id>`);
+      const result = await client.request("link_accept", { id: positionals[1] });
+      if (asJson) json(result);
       else out(`${result.endpoint.address} now sits under ${result.parent}`);
       return 0;
     }
@@ -1416,11 +1454,11 @@ async function daemon(idle, policyFile) {
   });
   let broker;
   try {
-    const { daemonBridge } = await import("./remote-P4GFUIAP.js");
+    const { daemonBridge } = await import("./remote-UQJ5YYCC.js");
     const bridge = await daemonBridge();
     broker = await startBroker({
       dir: relayDir(),
-      ...bridge ? { bridge } : await (await import("./mesh-H4KL5XAR.js")).meshBrokerOptions(),
+      ...bridge ? { bridge } : await (await import("./mesh-OZILTV5P.js")).meshBrokerOptions(),
       bridgeConfig: () => daemonBridge(),
       ...idleMs !== void 0 ? { idleMs } : {},
       ...policyFile ? { policyPath: resolve(policyFile) } : {}

package/dist/{mcp-VXBRMQB7.js → mcp-BH526TOG.js}

@@ -1,12 +1,12 @@
 import {
   spawnDetached
-} from "./chunk-3SHVJIXP.js";
+} from "./chunk-7RA7E5WR.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-2OSUVJ2J.js";
+import "./chunk-UKQBH4AQ.js";
 import {
   mcpInstall
-} from "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+} from "./chunk-2342GTME.js";
+import "./chunk-XQHPDNVG.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
@@ -16,14 +16,15 @@ import {
   membership,
   psParent,
   relayIdentity,
-  startDaemon
-} from "./chunk-2LIJXXTL.js";
+  startDaemon,
+  writeShimBinding
+} from "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/mcp.ts
 import { CLI_NAME, validHandle } from "@scp-dev/core";
 import { connectBroker, relayDir } from "@scp-dev/broker";
-import { runRelayMcp } from "@scp-dev/mcp";
+import { runRelayMcp, sessionInboxOf } from "@scp-dev/mcp";
 var ORPHAN_CHECK_MS = 5e3;
 async function relayMcpCommand(values, positionals) {
   if (positionals[0] === "install") {
@@ -43,25 +44,35 @@ async function relayMcpCommand(values, positionals) {
     inferHarness: (pid) => harnessAt(pid)
   });
   if (!validHandle(claim.handle)) throw new RelayUsage(`${JSON.stringify(claim.handle)} is not a valid agent handle (me, user and relay are reserved)`);
-  const dir = relayDir();
+  const dir = relayDir(process.env);
+  const unbind = writeShimBinding(claim, process.env);
+  process.on("exit", unbind);
   const parent = process.ppid;
   const orphaned = setInterval(() => {
     if (process.ppid !== parent) process.exit(0);
   }, ORPHAN_CHECK_MS);
   orphaned.unref();
-  await runRelayMcp({
-    connect: () => connectBroker(dir, () => startDaemon(dir)),
-    claim,
-    membership: () => membership(process.env, claim.session),
-    input: process.stdin,
-    output: (line) => void process.stdout.write(line),
-    env: process.env,
-    channels: values.channels === true,
-    launchedWithChannels: values.channels === true && launchedWithChannels(process.env),
-    spawn: (request) => spawnDetached(spawnWords(request), request.cwd ?? claim.cwd),
-    log: (line) => void process.stderr.write(`${line}
+  const inbox = sessionInboxOf(process.env);
+  try {
+    await runRelayMcp({
+      connect: () => connectBroker(dir, () => startDaemon(dir)),
+      claim,
+      membership: () => membership(process.env, claim.session),
+      input: process.stdin,
+      output: (line) => void process.stdout.write(line),
+      env: process.env,
+      channels: values.channels === true,
+      launchedWithChannels: values.channels === true && launchedWithChannels(process.env),
+      ...inbox ? { sessionInbox: inbox } : {},
+      spawn: (request) => spawnDetached(spawnWords(request), request.cwd ?? claim.cwd),
+      log: (line) => void process.stderr.write(`${line}
 `)
-  });
+    });
+  } finally {
+    clearInterval(orphaned);
+    process.off("exit", unbind);
+    unbind();
+  }
   return 0;
 }
 function spawnWords(request) {

package/dist/mesh-OZILTV5P.js

@@ -0,0 +1,53 @@
+import {
+  RelayUsage
+} from "./chunk-AAFHLHXG.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/mesh.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { relayDir } from "@scp-dev/broker";
+var MESH_MODULE = "@scp-dev/mesh";
+async function importMesh() {
+  return await import(MESH_MODULE);
+}
+async function load() {
+  try {
+    return await importMesh();
+  } catch {
+    throw new RelayUsage("swarm mesh is experimental and runs only from a source checkout of the swarm CLI");
+  }
+}
+async function meshCommand(argv) {
+  return (await load()).meshCommand(argv);
+}
+function meshEnabled(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    return false;
+  }
+  try {
+    return JSON.parse(text)?.enabled === true;
+  } catch {
+    return true;
+  }
+}
+async function meshBrokerOptions(dir = join(relayDir(), "mesh"), options = {}) {
+  const path = join(dir, "mesh.json");
+  if (!meshEnabled(path)) return {};
+  let mesh;
+  try {
+    mesh = await (options.importMesh ?? importMesh)();
+  } catch {
+    const warn = options.warn ?? console.error;
+    warn(`mesh is enabled in ${path} but this CLI has no mesh module; running without it`);
+    return {};
+  }
+  return mesh.meshBrokerOptions(dir);
+}
+export {
+  meshBrokerOptions,
+  meshCommand
+};

package/dist/{opencode-ORLGNHWR.js → opencode-XV33XTL5.js}

@@ -2,18 +2,18 @@ import {
   mcpFile,
   mountedEntry,
   whichOnPath
-} from "./chunk-2OSUVJ2J.js";
+} from "./chunk-UKQBH4AQ.js";
 import {
   hooksTarget
-} from "./chunk-Q5UI4Z7H.js";
+} from "./chunk-2342GTME.js";
 import {
   opencodePlugin
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-XQHPDNVG.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   RelayUsage,
   gitToplevel
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/opencode.ts

package/dist/{peek-YTCWVPF7.js → peek-LFQR6TCS.js}

@@ -2,7 +2,7 @@ import {
   RelayUsage,
   peekGrant,
   stamp
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import {
   note
 } from "./chunk-MNTIEWKF.js";

package/dist/{pi-QEZVFDNR.js → pi-N3DX37PD.js}

@@ -1,6 +1,6 @@
 import {
   RelayUsage
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/pi.ts

package/dist/{relay-QWJM372C.js → relay-SF3UWIPM.js}

@@ -13,7 +13,7 @@ import {
   saveCredential,
   setJoinMode,
   writePrivateJson
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 export {
   DEFAULT_RELAY,

package/dist/{remote-P4GFUIAP.js → remote-UQJ5YYCC.js}

@@ -9,8 +9,8 @@ import {
   machinesVerb,
   openCloud,
   readCloudFile
-} from "./chunk-IEFXYBX7.js";
-import "./chunk-2LIJXXTL.js";
+} from "./chunk-H2XQXMZU.js";
+import "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 export {
   CloudRelayClient,

package/dist/{setup-MGDWKCNU.js → setup-UJCIMYU4.js}

@@ -15,11 +15,11 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-2OSUVJ2J.js";
-import "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+} from "./chunk-UKQBH4AQ.js";
+import "./chunk-2342GTME.js";
+import "./chunk-XQHPDNVG.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-2LIJXXTL.js";
+import "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 export {
   SETUP_HARNESSES,

package/dist/{spawn-GG7VFZA6.js → spawn-JYD7NCQT.js}

@@ -31,15 +31,15 @@ import {
   toml,
   transcriptReplies,
   workerName
-} from "./chunk-3SHVJIXP.js";
+} from "./chunk-7RA7E5WR.js";
 import {
   SPAWN_HELP
 } from "./chunk-KN7WEIE4.js";
-import "./chunk-2OSUVJ2J.js";
-import "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+import "./chunk-UKQBH4AQ.js";
+import "./chunk-2342GTME.js";
+import "./chunk-XQHPDNVG.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-2LIJXXTL.js";
+import "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 export {
   CODEX_VALUED,

package/dist/{up-B2NEOOC6.js → up-3YJU7YX6.js}

@@ -2,7 +2,7 @@ import {
   RelayUsage,
   activeRelay,
   relayCredential
-} from "./chunk-2LIJXXTL.js";
+} from "./chunk-AAFHLHXG.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/up.ts
@@ -29,21 +29,21 @@ async function up(positionals, values, cwd, brokerStatus) {
   const { url } = activeRelay(process.env);
   const headless = values.token !== void 0 || Boolean(process.env.SCP_TOKEN?.trim());
   if (headless || !relayCredential(process.env, url).token) {
-    const code = await (await import("./login-AUMLI4FS.js")).login({
+    const code = await (await import("./login-6MVD3VLC.js")).login({
       ...values.token !== void 0 ? { token: values.token } : {},
       ...values.label !== void 0 ? { label: values.label } : {},
       ...values["no-browser"] ? { "no-browser": true } : {}
     });
     if (code !== 0) return code;
   } else out(`already logged in to ${url}`);
-  const enabled = await (await import("./remote-P4GFUIAP.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
+  const enabled = await (await import("./remote-UQJ5YYCC.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
   if (enabled !== 0) return enabled;
-  const setup = (await import("./setup-MGDWKCNU.js")).relaySetupCommand(["--write"], cwd, out);
+  const setup = (await import("./setup-UJCIMYU4.js")).relaySetupCommand(["--write"], cwd, out);
   if (setup !== 0) return setup;
   const broker = await brokerStatus();
   if (!broker.enabled) out(`the broker is still local-only; run \`${CLI_NAME} daemon restart\` to link it to ${url}`);
   else out(`broker linked to ${broker.url ?? url}${broker.connected ? "" : " (connecting)"}`);
-  const { detectHarnesses, whichOnPath } = await import("./setup-MGDWKCNU.js");
+  const { detectHarnesses, whichOnPath } = await import("./setup-UJCIMYU4.js");
   const which = (name) => whichOnPath(name, process.env);
   const installed = new Set(detectHarnesses(process.env, which).keys());
   if (which("pi")) installed.add("pi");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scp-dev/cli",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "The swarm command line tool.",
   "license": "Apache-2.0",
   "homepage": "https://scp.dev",
@@ -24,15 +24,15 @@
     "typecheck": "tsc -p ."
   },
   "dependencies": {
-    "@scp-dev/core": "0.1.6",
-    "@scp-dev/broker": "0.2.1",
-    "@scp-dev/hub": "0.5.1",
-    "@scp-dev/mcp": "0.1.8",
+    "@scp-dev/core": "0.3.0",
+    "@scp-dev/broker": "0.4.0",
+    "@scp-dev/hub": "0.6.1",
+    "@scp-dev/mcp": "0.2.0",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {
     "@openai/codex": "0.159.0",
-    "@scp-dev/mesh": "0.0.5",
+    "@scp-dev/mesh": "0.0.7",
     "opencode-ai": "1.18.34",
     "tsup": "^8.5.1"
   },

package/dist/mesh-H4KL5XAR.js

@@ -1,28 +0,0 @@
-import {
-  RelayUsage
-} from "./chunk-2LIJXXTL.js";
-import "./chunk-MNTIEWKF.js";
-
-// src/mesh.ts
-import { existsSync } from "fs";
-import { join } from "path";
-import { relayDir } from "@scp-dev/broker";
-var MESH_MODULE = "@scp-dev/mesh";
-async function load() {
-  try {
-    return await import(MESH_MODULE);
-  } catch {
-    throw new RelayUsage("swarm mesh is experimental and runs only from a source checkout of the swarm CLI");
-  }
-}
-async function meshCommand(argv) {
-  return (await load()).meshCommand(argv);
-}
-async function meshBrokerOptions() {
-  if (!existsSync(join(relayDir(), "mesh", "mesh.json"))) return {};
-  return (await load()).meshBrokerOptions();
-}
-export {
-  meshBrokerOptions,
-  meshCommand
-};