@scp-dev/cli 0.2.1 → 0.2.3

package/dist/{chunk-ZLL5EGI2.js → chunk-E7JG5PJB.js}

@@ -374,7 +374,8 @@ var OPTIONS = {
   who: { type: "boolean" },
   peek: { type: "string" },
   endpoint: { type: "string" },
-  live: { type: "boolean" }
+  live: { type: "boolean" },
+  parent: { type: "string" }
 };
 var SPAWN_OPTIONS = [
   "as",
@@ -486,7 +487,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-2OWBWLJH.js");
+    const { machineName, openCloud } = await import("./remote-NTHRHVEP.js");
     const handle2 = named ? localHandle(named) : void 0;
     const claim = handle2 ? {
       handle: handle2,
@@ -743,7 +744,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-UB72MU7W.js")).login(values);
+  return (await import("./login-IPS75GLQ.js")).login(values);
 }
 function logoutMain(positionals, asJson, env = process.env) {
   if (positionals.length) throw new RelayUsage(`${CLI_NAME3} logout takes no arguments`);

package/dist/{chunk-25ZVL5LD.js → chunk-IXCHAWOL.js}

@@ -3,10 +3,10 @@ import {
   agySettingsFile,
   mcpFile,
   mountedEntry
-} from "./chunk-NJLFHBSS.js";
+} from "./chunk-W3VNCRBX.js";
 import {
   steerPrompt
-} from "./chunk-HF4KP6AR.js";
+} from "./chunk-X4ZLEM47.js";
 import {
   OPTIONS,
   RelayUsage,
@@ -18,7 +18,7 @@ import {
   selectorList,
   spawnerKey,
   walkNow
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 import {
   SELF,
   note

package/dist/{chunk-NJLFHBSS.js → chunk-W3VNCRBX.js}

@@ -1,6 +1,6 @@
 import {
   hooksTarget
-} from "./chunk-KC5AV5NQ.js";
+} from "./chunk-ZMVFN6MU.js";
 import {
   AGY_HOOK_SET,
   BLOCK_STOP,
@@ -12,12 +12,12 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-HF4KP6AR.js";
+} from "./chunk-X4ZLEM47.js";
 import {
   RelayUsage,
   gitToplevel,
   setJoinMode
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 
 // src/setup.ts
 import { spawnSync } from "child_process";
@@ -35,6 +35,7 @@ import {
   mkdtempSync,
   readFileSync,
   readlinkSync,
+  realpathSync,
   renameSync,
   rmSync,
   statSync,
@@ -611,6 +612,23 @@ function museInstalled(env) {
   }
 }
 var installedFrom = (record) => record && isObject(record.source) ? String(record.source.path) : void 0;
+function samePath(a, b) {
+  if (a === void 0) return false;
+  if (a === b) return true;
+  try {
+    return realpathSync(a) === realpathSync(b);
+  } catch {
+    return false;
+  }
+}
+function museReviewNeeded(cli, run) {
+  try {
+    const caps = JSON.parse(run([cli, "plugins", "inspect", SERVER, "--json"]).output).runtime_capabilities;
+    return Array.isArray(caps) && caps.some((cap) => isObject(cap) && cap.status === "review_needed");
+  } catch {
+    return false;
+  }
+}
 function pluginDir(manifest) {
   return dirname(dirname(manifest));
 }
@@ -655,19 +673,24 @@ function planHooks(plan, harness, ctx) {
     const from = installedFrom(record);
     const current = content ?? readFileSync(resolved(file), "utf8");
     const disabled = record?.enabled === false;
-    const install = content !== void 0 || from !== dir || record?.manifest_sha256 !== sha256(current);
-    if (!install && !disabled) {
+    const install = content !== void 0 || !samePath(from, dir) || record?.manifest_sha256 !== sha256(current);
+    const cli = ctx.found.get("muse");
+    const review = install || museReviewNeeded(cli, run);
+    if (!install && !disabled && !review) {
       note(plan, harness, `hooks: up to date in ${file}${held}`);
       return;
     }
-    const cli = ctx.found.get("muse");
-    const commands = [...install ? [[cli, "plugins", "install", dir, "--scope", "user"]] : [], ...disabled ? [[cli, "plugins", "enable", SERVER]] : []];
-    const head = install ? `${content ? "write" : "install"} the ${CLI_NAME} plugin ${file}${held}${from && from !== dir ? `, replacing the scp plugin installed from ${from}` : ""}${disabled ? ", and enable it, which Muse has disabled" : ""}` : `enable the ${CLI_NAME} plugin ${file}, which Muse has disabled`;
+    const commands = [
+      ...install ? [[cli, "plugins", "install", dir, "--scope", "user"]] : [],
+      ...disabled ? [[cli, "plugins", "enable", SERVER]] : [],
+      ...review ? [[cli, "plugins", "approve", SERVER]] : []
+    ];
+    const head = install ? `${content ? "write" : "install"} the ${CLI_NAME} plugin ${file}${held}${from && !samePath(from, dir) ? `, replacing the scp plugin installed from ${from}` : ""}${disabled ? ", and enable it, which Muse has disabled" : ""}` : disabled ? `enable the ${CLI_NAME} plugin ${file}, which Muse has disabled` : `approve the hooks of the ${CLI_NAME} plugin ${file}, which Muse holds for review`;
     addStep(plan, {
       harness,
       label: "hooks",
       file,
-      plan: [head, ...commands.map(shown), ...install ? ["Muse asks you to review a plugin's hooks before it runs them"] : []],
+      plan: [head, ...commands.map(shown), ...review ? ["approves its hooks: a headless muse exec runs no hook Muse holds for review"] : []],
       apply: () => {
         const next = install ? desiredHooks(kind, file, blockStop) : void 0;
         const saved = next === void 0 ? void 0 : writeFile(file, next, now, { mode: 420 });
@@ -741,7 +764,7 @@ function planUnhook(plan, harness, kind, file, items, ctx) {
   const gone = { harness, label: "hooks", file, plan: [`forget ${file}, which is gone`], apply: () => void 0, manifest: forgotten };
   if (kind === "muse") {
     const cli = ctx.found.get("muse");
-    const installed = installedFrom(museInstalled(ctx.env)) === pluginDir(file);
+    const installed = samePath(installedFrom(museInstalled(ctx.env)), pluginDir(file));
     if (!existsSync(target) && !installed) {
       addStep(plan, gone);
       return;
@@ -936,7 +959,7 @@ function verifyMusePlugin(cli, dir, run, manifest) {
   } catch {
     return { ok: false, line: `unknown: muse plugins list --json exited ${result.code}: ${lastLine(result.output)}` };
   }
-  const ours = installedFrom(record) === dir;
+  const ours = samePath(installedFrom(record), dir);
   if (manifest === void 0) return { ok: !ours, line: ours ? "still installed (muse plugins list)" : "removed (muse plugins list)" };
   if (!ours) return { ok: false, line: "failed: muse plugins list does not show the scp plugin from setup" };
   const current = record.manifest_sha256 === sha256(manifest) && record.enabled !== false;

package/dist/{chunk-HF4KP6AR.js → chunk-X4ZLEM47.js}

@@ -12,7 +12,7 @@ import {
   psStart,
   relayIdentity,
   sessionKey
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 
 // src/hooks.ts
 import { Readable } from "stream";
@@ -345,6 +345,15 @@ function inferredTitle(harness, event, named, payload) {
   const text = harness === "claude-code" ? transcriptTitle(asString(field(payload, "transcript_path", "transcriptPath")), asString(field(payload, "session_id", "sessionId"))) : own && !OPENCODE_UNNAMED.test(own) ? titleText(own) : void 0;
   return text ? { text, from: "summary" } : void 0;
 }
+function launchedSubagent(harness, event, payload) {
+  if (harness !== "claude-code" || event.kind !== "tool" || event.agent || !/^(agent|task)$/i.test(event.tool ?? "")) return void 0;
+  const input = field(payload, "tool_input", "toolInput");
+  const response = field(payload, "tool_response", "toolResponse");
+  if (typeof input !== "object" || typeof response !== "object" || Array.isArray(response)) return void 0;
+  const id = asString(response.agentId);
+  const title = titleText(asString(input.description));
+  return id && title && /^[A-Za-z0-9_-]{1,64}$/.test(id) ? { id, title } : void 0;
+}
 function hookReply(harness, kind, text, unread = 0, continues = true) {
   if (kind === "stop" && harness === "claude-code" && continues)
     return JSON.stringify({ hookSpecificOutput: { hookEventName: "Stop", additionalContext: text } });
@@ -448,6 +457,8 @@ async function runHook(args, options) {
     if (turn) posted.push(client.request("peek_turn", turn));
     const title = inferredTitle(claim.harness, event, named, payload);
     if (title) posted.push(client.request("title_infer", title));
+    const launched = launchedSubagent(claim.harness, event, payload);
+    if (launched) posted.push(client.request("subagent_title", launched));
     const injected = inject ? client.request(
       "inject",
       counts ? { count: true, ...stop ? { stop: true, directives: true, ...blockStop ? { hold_unread: true } : {} } : {} } : {}
@@ -510,6 +521,8 @@ async function wakeHook(harnessArg, payload, waitS, options) {
   const client = await options.connect(false);
   try {
     await client.hello({ transient: true, claim });
+    await client.request("wake", { via: OPENCODE_WAKE }).catch(() => {
+    });
     const result = await client.request("inject", { wait_s: waitMs / 1e3 });
     if (!result.offered.length) return;
     const intro = result.intro ? introText(result.intro, result.intro_key) : void 0;

package/dist/{chunk-MXQ7B3CQ.js → chunk-ZDU53ZRF.js}

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

package/dist/{chunk-KC5AV5NQ.js → chunk-ZMVFN6MU.js}

@@ -10,11 +10,11 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-HF4KP6AR.js";
+} from "./chunk-X4ZLEM47.js";
 import {
   RelayUsage,
   gitToplevel
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 
 // src/install.ts
 import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
@@ -166,7 +166,7 @@ function injectionNotes(harness, scope, target, blockStop, wait) {
       ];
     case "muse":
       return [
-        `Muse loads hooks only from plugins: muse plugins install ${dirname(dirname(target))} --scope ${scope}`,
+        `Muse loads hooks only from plugins: muse plugins install ${dirname(dirname(target))} --scope ${scope}, then muse plugins approve scp (a headless muse exec runs no hook Muse holds for review)`,
         `new relay messages reach the model after each tool call and with each prompt; ${held}`,
         pushed,
         "Muse hands plugin hooks no SCP_* variables: they key the session by the harness process, so set no SCP_SESSION for Muse's shim"

package/dist/{claude-WTCPUYU3.js → claude-JD7WXMAT.js}

@@ -3,16 +3,16 @@ import {
   mcpFile,
   mountedEntry,
   whichOnPath
-} from "./chunk-NJLFHBSS.js";
-import "./chunk-KC5AV5NQ.js";
-import "./chunk-HF4KP6AR.js";
+} from "./chunk-W3VNCRBX.js";
+import "./chunk-ZMVFN6MU.js";
+import "./chunk-X4ZLEM47.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
   RelayUsage,
   deriveHandle,
   joinMode
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.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-I4F53MMA.js");
+  const { run } = await import("./main-SQKCKV3B.js");
   await run(process.argv.slice(2));
 }

package/dist/{codex-YZZNH6IQ.js → codex-4IIM6ZE2.js}

@@ -1,18 +1,18 @@
 import {
   codexMount,
   codexOverrides
-} from "./chunk-25ZVL5LD.js";
+} from "./chunk-IXCHAWOL.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-NJLFHBSS.js";
-import "./chunk-KC5AV5NQ.js";
-import "./chunk-HF4KP6AR.js";
+import "./chunk-W3VNCRBX.js";
+import "./chunk-ZMVFN6MU.js";
+import "./chunk-X4ZLEM47.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   RelayUsage,
   readPsTable,
   relayIdentity,
   startDaemon
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 import {
   SELF
 } from "./chunk-MNTIEWKF.js";
@@ -486,6 +486,7 @@ ${stderr.toString().trim()}` : ""}`
       },
       claim,
       channels: true,
+      wake: "codex-app-server",
       input,
       env: launch.env,
       output: (chunk) => {

package/dist/{hooks-4B5NOH7X.js → hooks-P4J6OZCO.js}

@@ -38,11 +38,11 @@ import {
   tldrEvery,
   transcriptTitle,
   unreadPointer
-} from "./chunk-HF4KP6AR.js";
+} from "./chunk-X4ZLEM47.js";
 import {
   SUBAGENT
 } from "./chunk-YYSLYVNZ.js";
-import "./chunk-ZLL5EGI2.js";
+import "./chunk-E7JG5PJB.js";
 import "./chunk-MNTIEWKF.js";
 export {
   AGY_HOOK_SET,

package/dist/{install-2ZM3IYXG.js → install-FKGGPT6L.js}

@@ -2,10 +2,10 @@ import {
   hooksTarget,
   installHooks,
   mcpInstall
-} from "./chunk-KC5AV5NQ.js";
-import "./chunk-HF4KP6AR.js";
+} from "./chunk-ZMVFN6MU.js";
+import "./chunk-X4ZLEM47.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-ZLL5EGI2.js";
+import "./chunk-E7JG5PJB.js";
 import "./chunk-MNTIEWKF.js";
 export {
   hooksTarget,

package/dist/{join-BH5CS6SL.js → join-RGFHOSLE.js}

@@ -5,7 +5,7 @@ import {
   sessionKey,
   startDaemon,
   walkNow
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/join.ts
@@ -32,9 +32,12 @@ async function joinCommand(values, positionals, cwd, out) {
   });
   const client = await connectBroker(dir, () => startDaemon(dir));
   try {
-    const hello = await client.hello({ transient: true, claim, join: handle ? { handle } : {} });
-    if (values.json === true) out(JSON.stringify(hello.endpoint, null, 2));
-    else out(`joined as ${hello.endpoint.address}: peers can message it, and its hooks hand it new messages at turn boundaries`);
+    const under = typeof values.under === "string" ? values.under : void 0;
+    const hello = await client.hello({ transient: true, claim, join: { ...handle ? { handle } : {}, ...under ? { under } : {} } });
+    const view = hello.endpoint;
+    if (values.json === true) out(JSON.stringify(view, null, 2));
+    else
+      out(`joined as ${view.address}${view.parent ? ` under ${view.parent}` : ""}: peers can message it, and its hooks hand it new messages at turn boundaries`);
   } finally {
     client.close();
   }

package/dist/{login-UB72MU7W.js → login-IPS75GLQ.js}

@@ -1,11 +1,11 @@
 import {
   machineName
-} from "./chunk-MXQ7B3CQ.js";
+} from "./chunk-ZDU53ZRF.js";
 import {
   RelayUsage,
   activeRelay,
   saveCredential
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 import {
   note
 } from "./chunk-MNTIEWKF.js";

package/dist/{main-I4F53MMA.js → main-SQKCKV3B.js}

@@ -15,7 +15,7 @@ import {
   stamp,
   startDaemon,
   time
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 import {
   FAILED,
   exitFlushed,
@@ -33,7 +33,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.2.1",
+  version: "0.2.3",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -65,6 +65,7 @@ var package_default = {
   },
   devDependencies: {
     "@openai/codex": "0.159.0",
+    "@scp-dev/mesh": "workspace:*",
     "opencode-ai": "1.18.34",
     tsup: "^8.5.1"
   },
@@ -79,11 +80,13 @@ import {
   deliveryText,
   LIMITS,
   PREAMBLE,
+  presenceText,
   reachLines,
   receiptLines,
   RelayError,
   shortId,
   stripControl,
+  wakeText,
   widenText,
   wrapMessage,
   CLI_NAME
@@ -98,8 +101,9 @@ results back, as with native subagents.
   ${CLI_NAME} reply <id> [text|-]         answer a message in its thread: ${CLI_NAME} reply 5af1f2 "done"
   ${CLI_NAME} ask <to> [text|-] [--wait S]   send a request and wait for its reply: ${CLI_NAME} ask lead "which branch?"
   ${CLI_NAME} inbox [--wait S]            your unread messages, then marked read: ${CLI_NAME} inbox
-  ${CLI_NAME} list [--all]                agents on the relay: address, title, presence, status; --all adds offline ones
+  ${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} 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"
@@ -120,7 +124,7 @@ More: ${CLI_NAME} help --all (the full reference), ${CLI_NAME} <verb> --help (on
 var RELAY_HELP = `${CLI_NAME}: messages between the agent sessions on this machine, and a live view of the fleet
 
 usage:
-  ${CLI_NAME} list [--all] [--roots] [--tree]    agents on the relay: address, title, presence, status, cwd; offline ones only with --all;
+  ${CLI_NAME} list [--all] [--roots] [--tree]    agents on the relay: address, title, presence, wake, status, cwd; offline only with --all;
                                                  sessions nobody spawned that spawned nobody fold into one line, --roots (or --all) lists
                                                  them; --tree nests them by parent; (you) marks your own
   ${CLI_NAME} list --contacts                    the endpoints of other accounts your contacts let you reach: address, harness, presence
@@ -228,7 +232,7 @@ scopes (selectors are comma-separated, e.g. tree:parent,tree:children,group:team
                                                  messages with the relay MCP tools (relay_send, relay_inbox, relay_reply). A
                                                  ${CLI_NAME} command from codex's workspace-write sandbox also needs
                                                  -c sandbox_workspace_write.network_access=true (the relay socket counts as network)
-  ${CLI_NAME} pi [--name N] [--] [pi args...]    runs pi with the @scp-dev/pi extension: the relay tools, and each new
+  ${CLI_NAME} pi [--name N] [--] [pi args...]    runs pi with the bundled SCP extension: the relay tools, and each new
                                                  message as a turn (steering a running one, waking an idle session)
   ${CLI_NAME} codex [--name N] [--headless] [--] [codex args...]
                                                  runs codex with relay messages waking an idle thread or steering a running turn
@@ -261,7 +265,7 @@ agent sessions:
   ${CLI_NAME} hook <harness> [event]             what those hooks run: one event from the hook JSON on stdin; prints only the reply
   A session's shim and hooks share one endpoint, keyed by $SCP_SESSION, else the harness process's pid and start time.
   Without --as or $SCP_NAME the handle is <harness>-<worktree>; labels gain machine=<short hostname>.
-  A Claude Code subagent's hooks give it a child endpoint, <session handle>-<type>-<first 6 of its id>, whose messages
+  A Claude Code subagent's hooks give it a child endpoint, <session handle>-<short type>-<first 4 of its id>, whose messages
   reach it after its tools; its shell is the session's, so it acts as that child with --as.
   Grok runs the Claude Code hooks, labelled grok; Muse takes them as a plugin; Codex runs new hooks after /hooks review.
   ${CLI_NAME} claude [--name N] [--] [claude args...]   start Claude Code with the scp channel loaded, so peer messages wake
@@ -276,6 +280,17 @@ 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
+                                                 <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
+  ${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
+  ${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
+                                                 (a cycle) is refused; both are audited, as adopt and unlink
   ${CLI_NAME} leave [--endpoint EP]              take this session off the relay: offline, no messages pushed, mail kept until
                                                  ${CLI_NAME} join; a spawned worker stays joined while it runs
   With setup --join manual a session stays off the relay until it runs ${CLI_NAME} join; the default, auto, joins every
@@ -347,7 +362,9 @@ var IDENTITY = ["as", "harness", "human", "json", "cloud", "machine"];
 var VERBS = {
   list: [...IDENTITY, "all", "tree", "roots", "contacts"],
   send: [...IDENTITY, "reply-to", "thread", "private", "attach", "live"],
-  join: ["harness", "json"],
+  join: ["harness", "json", "under"],
+  adopt: [...IDENTITY, "parent"],
+  unlink: IDENTITY,
   leave: [...IDENTITY, "endpoint"],
   name: [...IDENTITY, "endpoint"],
   inbox: [...IDENTITY, "wait", "ack", "keep"],
@@ -449,15 +466,16 @@ function printEndpoints(endpoints, me, host = shortHostname()) {
   const row = (e, indent) => [
     `${indent}${addressCell(e, me)}`,
     e.title ?? "",
-    e.presence,
+    presenceText(e),
+    wakeText(e),
     e.status ? statusText(e.status) : e.kind === "human" ? "" : "-",
     Object.entries(e.labels).filter(([k]) => k !== "machine").map(([k, v]) => `${k}=${v}`).join(","),
     shortCwd(e.cwd),
     ...peek ? [e.peekable ?? ""] : []
   ];
-  const blank = (first) => [first, "", "", "", "", "", ...peek ? [""] : []];
+  const blank = (first) => [first, "", "", "", "", "", "", ...peek ? [""] : []];
   const rows = [
-    ["ADDRESS", "TITLE", "PRESENCE", "STATUS", "LABELS", "CWD", ...peek ? ["PEEK"] : []],
+    ["ADDRESS", "TITLE", "PRESENCE", "WAKE", "STATUS", "LABELS", "CWD", ...peek ? ["PEEK"] : []],
     ...endpoints.filter((e) => e.kind === "human").map((e) => row(e, ""))
   ];
   const machines = /* @__PURE__ */ new Map();
@@ -520,13 +538,13 @@ async function relayMain(argv, cwd = process.cwd()) {
     out(package_default.version);
     return 0;
   }
-  if (verb === "hook") return (await import("./hooks-4B5NOH7X.js")).relayHookCommand(rest, startDaemon);
-  if (verb === "setup") return (await import("./setup-HPH7HE6O.js")).relaySetupCommand(rest, cwd, out);
-  if (verb === "claude") return (await import("./claude-WTCPUYU3.js")).claudeCommand(rest);
-  if (verb === "pi") return (await import("./pi-IAVFVOOO.js")).piCommand(rest);
-  if (verb === "codex") return (await import("./codex-YZZNH6IQ.js")).codexCommand(rest);
+  if (verb === "hook") return (await import("./hooks-P4J6OZCO.js")).relayHookCommand(rest, startDaemon);
+  if (verb === "setup") return (await import("./setup-RO7356M4.js")).relaySetupCommand(rest, cwd, out);
+  if (verb === "claude") return (await import("./claude-JD7WXMAT.js")).claudeCommand(rest);
+  if (verb === "pi") return (await import("./pi-JZ4DXY7V.js")).piCommand(rest);
+  if (verb === "codex") return (await import("./codex-4IIM6ZE2.js")).codexCommand(rest);
   if (verb === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-V66GYUNC.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-BYU2X46L.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -534,6 +552,7 @@ async function relayMain(argv, cwd = process.cwd()) {
     }
     return spawnCommand(rest, cwd);
   }
+  if (verb === "mesh") return (await import("./mesh-VNZV3POO.js")).meshCommand(rest);
   const allowed = VERBS[verb];
   if (!allowed) throw new RelayUsage(`unknown command "${verb}"`);
   let parsed;
@@ -553,11 +572,11 @@ async function relayMain(argv, cwd = process.cwd()) {
     return daemon(values.idle, values.policy);
   }
   if (verb === "mcp")
-    return (await import("./mcp-RXAVQBMP.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-TUWMLGE4.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-2ZM3IYXG.js")).installHooks({
+    return (await import("./install-FKGGPT6L.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -568,26 +587,26 @@ async function relayMain(argv, cwd = process.cwd()) {
       out
     });
   }
-  if (verb === "relay") return (await import("./relay-QDX2BNZH.js")).relayVerb(positionals, values.json === true);
-  if (verb === "up") return (await import("./up-2YGEDA5J.js")).up(positionals, values, cwd, relinkBroker);
+  if (verb === "relay") return (await import("./relay-U634RHIJ.js")).relayVerb(positionals, values.json === true);
+  if (verb === "up") return (await import("./up-GDD24GPL.js")).up(positionals, values, cwd, relinkBroker);
   if (verb === "login") {
-    const code = await (await import("./relay-QDX2BNZH.js")).loginMain(positionals, values);
+    const code = await (await import("./relay-U634RHIJ.js")).loginMain(positionals, values);
     if (code === 0) await relinkRunning();
     return code;
   }
-  if (verb === "logout") return (await import("./relay-QDX2BNZH.js")).logoutMain(positionals, values.json === true);
+  if (verb === "logout") return (await import("./relay-U634RHIJ.js")).logoutMain(positionals, values.json === true);
   if (verb === "cloud") {
-    const code = await (await import("./remote-2OWBWLJH.js")).cloudMain(positionals, values, cloudStatus);
+    const code = await (await import("./remote-NTHRHVEP.js")).cloudMain(positionals, values, cloudStatus);
     if (code === 0 && positionals[0] === "enable") await relinkRunning();
     return code;
   }
-  if (verb === "join") return (await import("./join-BH5CS6SL.js")).joinCommand(values, positionals, cwd, out);
+  if (verb === "join") return (await import("./join-RGFHOSLE.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 { client } = opened;
   try {
-    if (verb === "machines") return await (await import("./remote-2OWBWLJH.js")).machinesVerb(client, positionals, values.json === true);
+    if (verb === "machines") return await (await import("./remote-NTHRHVEP.js")).machinesVerb(client, positionals, values.json === true);
     return await runVerb(opened, verb, values, positionals, cwd);
   } finally {
     client.close();
@@ -663,7 +682,7 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
         out(`${me.address} (${me.kind}${me.harness ? `, ${me.harness}` : ""})`);
         const how = bound === "as" ? "--as" : bound === "lineage" ? "this shell's harness process" : bound === "human" ? "human inbox" : "-";
         const fields = [
-          ["presence", me.presence],
+          ["presence", presenceText(me)],
           ["title", me.title ?? "-"],
           ...me.kind === "human" ? [] : [
             ["status", me.status?.state ?? "-"],
@@ -764,9 +783,9 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       return 0;
     }
     case "peek":
-      return (await import("./peek-M2HQVO4O.js")).peekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-4D4VGKOW.js")).peekCommand(localClient(client, broker, verb), values, positionals);
     case "set-peek":
-      return (await import("./peek-M2HQVO4O.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-4D4VGKOW.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>`);
@@ -983,6 +1002,26 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       else out(before && before !== view.address ? `${before} is now ${view.address}` : `${view.address}`);
       return 0;
     }
+    case "adopt": {
+      if (positionals.length !== 1) throw new RelayUsage(`${CLI_NAME} adopt takes the child to link: ${CLI_NAME} adopt <child> [--parent <p>]`);
+      const parent = values.parent;
+      if (parent === void 0 && me?.kind !== "agent")
+        throw new RelayUsage(`${CLI_NAME} adopt: name the parent with --parent <p> (run from an agent's shell, it defaults to that agent)`);
+      const result = await client.request("adopt", {
+        endpoint: positionals[0],
+        ...parent !== void 0 ? { parent } : {}
+      });
+      if (asJson) json(result);
+      else out(`${result.endpoint.address} now sits under ${result.parent}`);
+      return 0;
+    }
+    case "unlink": {
+      if (positionals.length > 1) throw new RelayUsage(`${CLI_NAME} unlink takes one child, or none for this session`);
+      const result = await client.request("unlink", positionals.length ? { endpoint: positionals[0] } : {});
+      if (asJson) json(result);
+      else out(`${result.endpoint.address} is a root again (was under ${result.parent})`);
+      return 0;
+    }
     case "leave": {
       if (positionals.length) throw new RelayUsage(`${CLI_NAME} leave takes no arguments (--endpoint EP for the human at a terminal)`);
       const endpoint = values.endpoint;
@@ -1187,7 +1226,7 @@ function printTree(endpoints, me) {
     if (e.parent && byAddress.has(e.parent) && e.parent !== e.address) children.set(e.parent, [...children.get(e.parent) ?? [], e]);
     else roots.push(e);
   }
-  const rows = [["ADDRESS", "SCOPE", "TITLE", "PRESENCE", "STATUS", "LABELS", "CWD"]];
+  const rows = [["ADDRESS", "SCOPE", "TITLE", "PRESENCE", "WAKE", "STATUS", "LABELS", "CWD"]];
   const seen = /* @__PURE__ */ new Set();
   const walk = (e, depth) => {
     if (seen.has(e.address)) return;
@@ -1197,7 +1236,8 @@ function printTree(endpoints, me) {
       `${"  ".repeat(depth)}${addressCell(e, me)}`,
       e.kind === "human" ? "" : e.scope ?? "open",
       e.title ?? "",
-      e.presence,
+      presenceText(e),
+      wakeText(e),
       e.status ? statusText(e.status) : e.kind === "human" ? "" : "-",
       labels,
       shortCwd(e.cwd)
@@ -1211,7 +1251,7 @@ var STATES = ["working", "waiting", "blocked", "done"];
 function printSummary(snapshot, me, all) {
   if (me)
     out(
-      `you: ${me.address} (${me.kind}${me.harness ? `, ${me.harness}` : ""}) ${me.presence}${me.title ? ` ${quoted(me.title)}` : ""}${me.kind === "human" ? "" : `, status ${me.status ? statusText(me.status) : "-"}`}`
+      `you: ${me.address} (${me.kind}${me.harness ? `, ${me.harness}` : ""}) ${presenceText(me)}${me.title ? ` ${quoted(me.title)}` : ""}${me.kind === "human" ? "" : `, status ${me.status ? statusText(me.status) : "-"}`}`
     );
   const agents = snapshot.endpoints.filter((e) => e.kind !== "human");
   const count = (presence) => agents.filter((e) => e.presence === presence).length;
@@ -1343,11 +1383,11 @@ async function daemon(idle, policyFile) {
   });
   let broker;
   try {
-    const { daemonBridge } = await import("./remote-2OWBWLJH.js");
+    const { daemonBridge } = await import("./remote-NTHRHVEP.js");
     const bridge = await daemonBridge();
     broker = await startBroker({
       dir: relayDir(),
-      ...bridge ? { bridge } : {},
+      ...bridge ? { bridge } : await (await import("./mesh-VNZV3POO.js")).meshBrokerOptions(),
       bridgeConfig: () => daemonBridge(),
       ...idleMs !== void 0 ? { idleMs } : {},
       ...policyFile ? { policyPath: resolve(policyFile) } : {}

package/dist/{mcp-RXAVQBMP.js → mcp-TUWMLGE4.js}

@@ -1,12 +1,12 @@
 import {
   spawnDetached
-} from "./chunk-25ZVL5LD.js";
+} from "./chunk-IXCHAWOL.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-NJLFHBSS.js";
+import "./chunk-W3VNCRBX.js";
 import {
   mcpInstall
-} from "./chunk-KC5AV5NQ.js";
-import "./chunk-HF4KP6AR.js";
+} from "./chunk-ZMVFN6MU.js";
+import "./chunk-X4ZLEM47.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
@@ -16,7 +16,7 @@ import {
   psParent,
   relayIdentity,
   startDaemon
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/mcp.ts

package/dist/mesh-VNZV3POO.js

@@ -0,0 +1,28 @@
+import {
+  RelayUsage
+} from "./chunk-E7JG5PJB.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
+};

package/dist/{peek-M2HQVO4O.js → peek-4D4VGKOW.js}

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

package/dist/{pi-IAVFVOOO.js → pi-JZ4DXY7V.js}

@@ -1,14 +1,15 @@
 import {
   RelayUsage
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/pi.ts
 import { spawn } from "child_process";
+import { existsSync } from "fs";
 import { fileURLToPath } from "url";
 import { CLI_NAME, validHandle } from "@scp-dev/core";
 var PI_HELP = `${CLI_NAME} pi [--name NAME | --as NAME] [--] [pi args...]
-  runs pi with the @scp-dev/pi extension: the relay tools, and each new message as a turn, waking the session when idle.
+  runs pi with the bundled SCP extension: the relay tools, and each new message as a turn, waking the session when idle.
   $SCP_PI_BIN picks the pi binary (default pi on PATH), $SCP_PI_EXTENSION the extension file.`;
 function piLaunch(args, env, extension) {
   let name;
@@ -32,13 +33,13 @@ function piLaunch(args, env, extension) {
     env: { ...env, SCP_HARNESS: "pi", ...name !== void 0 ? { SCP_NAME: name } : {} }
   };
 }
-function extensionPath(env) {
+function extensionPath(env, base = import.meta.url) {
   if (env.SCP_PI_EXTENSION) return env.SCP_PI_EXTENSION;
-  try {
-    return fileURLToPath(import.meta.resolve("@scp-dev/pi"));
-  } catch {
-    throw new RelayUsage(`${CLI_NAME} pi needs the @scp-dev/pi extension: install it next to ${CLI_NAME}, or set $SCP_PI_EXTENSION to its file`);
+  for (const candidate of ["./pi-extension.js", "../../pi/src/index.ts"]) {
+    const file = fileURLToPath(new URL(candidate, base));
+    if (existsSync(file)) return file;
   }
+  throw new RelayUsage(`${CLI_NAME} pi found no pi extension next to ${CLI_NAME}: reinstall it, or set $SCP_PI_EXTENSION to the extension file`);
 }
 async function piCommand(args) {
   const own = args.includes("--") ? args.slice(0, args.indexOf("--")) : args;
@@ -66,6 +67,7 @@ async function piCommand(args) {
 }
 export {
   PI_HELP,
+  extensionPath,
   piCommand,
   piLaunch
 };

package/dist/pi-extension.js

@@ -0,0 +1,137 @@
+// ../pi/src/index.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+var PROTOCOL = "2025-06-18";
+var CHANNEL = "notifications/claude/channel";
+function swarmWords(env) {
+  const raw = env.SCP_PI_SWARM;
+  if (!raw) return ["swarm"];
+  const words = JSON.parse(raw);
+  if (!Array.isArray(words) || !words.length || !words.every((word) => typeof word === "string"))
+    throw new Error("SCP_PI_SWARM must be a JSON array of strings");
+  return words;
+}
+function shimArgv(env) {
+  return [...swarmWords(env), "mcp", "--harness", "pi", "--channels", ...env.SCP_NAME ? ["--as", env.SCP_NAME] : []];
+}
+var McpLink = class {
+  child;
+  pending = /* @__PURE__ */ new Map();
+  next = 1;
+  closed = false;
+  constructor(argv, env, onPush, onExit) {
+    this.child = spawn(argv[0], argv.slice(1), { env, stdio: ["pipe", "pipe", "ignore"] });
+    this.child.stdin.on("error", () => {
+    });
+    createInterface({ input: this.child.stdout }).on("line", (line) => {
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (typeof message.id === "number" && this.pending.has(message.id)) {
+        const waiter = this.pending.get(message.id);
+        this.pending.delete(message.id);
+        const error = message.error;
+        if (error) waiter.reject(new Error(error.message ?? "mcp error"));
+        else waiter.resolve(message.result ?? {});
+        return;
+      }
+      if (message.method === CHANNEL) {
+        const params = message.params ?? {};
+        if (typeof params.content === "string") onPush(params.content, params.meta ?? {});
+      }
+    });
+    this.child.once("error", () => this.fail(null, onExit));
+    this.child.once("exit", (code) => this.fail(code, onExit));
+  }
+  fail(code, onExit) {
+    if (this.closed) return;
+    this.closed = true;
+    for (const waiter of this.pending.values()) waiter.reject(new Error("the scp shim exited"));
+    this.pending.clear();
+    onExit(code);
+  }
+  request(method, params = {}) {
+    if (this.closed) return Promise.reject(new Error("the scp shim exited"));
+    const id = this.next++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+    });
+  }
+  notify(method, params = {}) {
+    if (!this.closed) this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
+`);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.child.stdin.end();
+    this.child.kill();
+  }
+};
+function toolResult(result) {
+  const content = (result.content ?? []).flatMap(
+    (part) => part.type === "text" && typeof part.text === "string" ? [{ type: "text", text: part.text }] : []
+  );
+  if (result.isError) throw new Error(content.map((part) => part.text).join("\n") || "the relay tool failed");
+  return { content, details: {} };
+}
+function scp(pi) {
+  let link;
+  const warn = (ctx, text) => {
+    if (ctx.hasUI) ctx.ui.notify(text, "warning");
+  };
+  pi.on("session_start", async (_event, ctx) => {
+    if (process.env.SCP_PI === "0") return;
+    link?.close();
+    const current = new McpLink(
+      shimArgv(process.env),
+      process.env,
+      (content, meta) => {
+        pi.sendMessage({ customType: "scp", content, display: true, details: meta }, { triggerTurn: true, deliverAs: "steer" });
+      },
+      (code) => {
+        if (link === current) warn(ctx, `scp: the relay shim exited (${code ?? "error"}); relay tools are unavailable`);
+      }
+    );
+    link = current;
+    try {
+      await current.request("initialize", {
+        protocolVersion: PROTOCOL,
+        capabilities: { experimental: { "claude/channel": {} } },
+        clientInfo: { name: "pi", version: "1" }
+      });
+      const { tools } = await current.request("tools/list");
+      for (const tool of tools ?? []) {
+        pi.registerTool({
+          name: tool.name,
+          label: tool.name,
+          description: tool.description ?? tool.name,
+          parameters: tool.inputSchema ?? { type: "object", properties: {} },
+          async execute(_id, params) {
+            if (link !== current) throw new Error("this scp session ended");
+            return toolResult(await current.request("tools/call", { name: tool.name, arguments: params ?? {} }));
+          }
+        });
+      }
+      current.notify("notifications/initialized");
+    } catch (error) {
+      warn(ctx, `scp: could not start the relay shim: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+  pi.on("session_shutdown", async () => {
+    link?.close();
+    link = void 0;
+  });
+}
+export {
+  McpLink,
+  scp as default,
+  shimArgv,
+  swarmWords,
+  toolResult
+};

package/dist/{relay-QDX2BNZH.js → relay-U634RHIJ.js}

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

package/dist/{remote-2OWBWLJH.js → remote-NTHRHVEP.js}

@@ -9,8 +9,8 @@ import {
   machinesVerb,
   openCloud,
   readCloudFile
-} from "./chunk-MXQ7B3CQ.js";
-import "./chunk-ZLL5EGI2.js";
+} from "./chunk-ZDU53ZRF.js";
+import "./chunk-E7JG5PJB.js";
 import "./chunk-MNTIEWKF.js";
 export {
   CloudRelayClient,

package/dist/{setup-HPH7HE6O.js → setup-RO7356M4.js}

@@ -15,11 +15,11 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-NJLFHBSS.js";
-import "./chunk-KC5AV5NQ.js";
-import "./chunk-HF4KP6AR.js";
+} from "./chunk-W3VNCRBX.js";
+import "./chunk-ZMVFN6MU.js";
+import "./chunk-X4ZLEM47.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-ZLL5EGI2.js";
+import "./chunk-E7JG5PJB.js";
 import "./chunk-MNTIEWKF.js";
 export {
   SETUP_HARNESSES,

package/dist/{spawn-V66GYUNC.js → spawn-BYU2X46L.js}

@@ -29,15 +29,15 @@ import {
   steerArgv,
   transcriptReplies,
   workerName
-} from "./chunk-25ZVL5LD.js";
+} from "./chunk-IXCHAWOL.js";
 import {
   SPAWN_HELP
 } from "./chunk-KN7WEIE4.js";
-import "./chunk-NJLFHBSS.js";
-import "./chunk-KC5AV5NQ.js";
-import "./chunk-HF4KP6AR.js";
+import "./chunk-W3VNCRBX.js";
+import "./chunk-ZMVFN6MU.js";
+import "./chunk-X4ZLEM47.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-ZLL5EGI2.js";
+import "./chunk-E7JG5PJB.js";
 import "./chunk-MNTIEWKF.js";
 export {
   MESSAGING,

package/dist/{up-2YGEDA5J.js → up-GDD24GPL.js}

@@ -2,7 +2,7 @@ import {
   RelayUsage,
   activeRelay,
   relayCredential
-} from "./chunk-ZLL5EGI2.js";
+} from "./chunk-E7JG5PJB.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/up.ts
@@ -14,16 +14,16 @@ 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-UB72MU7W.js")).login({
+    const code = await (await import("./login-IPS75GLQ.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-2OWBWLJH.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
+  const enabled = await (await import("./remote-NTHRHVEP.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
   if (enabled !== 0) return enabled;
-  const setup = (await import("./setup-HPH7HE6O.js")).relaySetupCommand(["--write"], cwd, out);
+  const setup = (await import("./setup-RO7356M4.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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scp-dev/cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "The swarm command line tool.",
   "license": "Apache-2.0",
   "homepage": "https://scp.dev",
@@ -24,14 +24,15 @@
     "typecheck": "tsc -p ."
   },
   "dependencies": {
-    "@scp-dev/core": "0.1.2",
-    "@scp-dev/broker": "0.1.3",
-    "@scp-dev/hub": "0.2.0",
-    "@scp-dev/mcp": "0.1.3",
+    "@scp-dev/core": "0.1.4",
+    "@scp-dev/broker": "0.1.5",
+    "@scp-dev/hub": "0.3.1",
+    "@scp-dev/mcp": "0.1.5",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {
     "@openai/codex": "0.159.0",
+    "@scp-dev/mesh": "0.0.2",
     "opencode-ai": "1.18.34",
     "tsup": "^8.5.1"
   },