@scp-dev/cli 0.1.0 → 0.1.3

package/dist/claude-5WTICOYS.js

@@ -0,0 +1,88 @@
+import {
+  entryArgv,
+  mcpFile,
+  mountedEntry,
+  whichOnPath
+} from "./chunk-IH2RJRIW.js";
+import "./chunk-QQZF5TQD.js";
+import {
+  CHANNELS_ENV,
+  RelayUsage
+} from "./chunk-URSBFDR6.js";
+import "./chunk-ABR5UABL.js";
+import "./chunk-YYSLYVNZ.js";
+import "./chunk-3PGDKPRN.js";
+import "./chunk-M2DCR2J4.js";
+
+// src/claude.ts
+import { spawn } from "child_process";
+import { CLI_NAME, validHandle } from "@scp-dev/core";
+var CHANNEL_FLAGS = ["--dangerously-load-development-channels", "server:scp"];
+function claudeArgv(argv) {
+  let name;
+  let i = 0;
+  if (argv[0] === "--name") {
+    if (argv[1] === void 0) throw new RelayUsage(`${CLI_NAME} claude --name takes a handle`);
+    name = argv[1];
+    i = 2;
+  } else if (argv[0]?.startsWith("--name=")) {
+    name = argv[0].slice("--name=".length);
+    i = 1;
+  }
+  if (argv[i] === "--") i++;
+  if (name !== void 0 && !validHandle(name)) throw new RelayUsage(`--name ${JSON.stringify(name)} is not a valid agent handle`);
+  return { ...name !== void 0 ? { name } : {}, args: argv.slice(i) };
+}
+function mountHint(env) {
+  const file = mcpFile("claude", env);
+  let entry;
+  try {
+    entry = mountedEntry("claude", file);
+  } catch {
+    return `${CLI_NAME} claude: ${file} is unreadable, so the scp mount is unchecked`;
+  }
+  if (!entry) return `${CLI_NAME} claude: Claude Code has no scp MCP mount; run ${CLI_NAME} setup --write`;
+  if (!entryArgv("claude", entry).includes("--channels"))
+    return `${CLI_NAME} claude: the scp mount lacks --channels, so messages will not wake this session; re-run ${CLI_NAME} setup --write`;
+  return void 0;
+}
+async function claudeCommand(argv, env = process.env, err = (line) => void process.stderr.write(`${line}
+`)) {
+  if (argv[0] === "--help" || argv[0] === "-h") {
+    process.stdout.write(`${CLI_NAME} claude [--name N] [--] [claude args...]   start Claude Code with the scp channel loaded, so peer messages wake it
+`);
+    return 0;
+  }
+  const { name, args } = claudeArgv(argv);
+  const bin = whichOnPath("claude", env);
+  if (!bin) throw new RelayUsage("claude is not on PATH");
+  const hint = mountHint(env);
+  if (hint) err(hint);
+  const child = spawn(bin, [...CHANNEL_FLAGS, ...args], {
+    stdio: "inherit",
+    env: { ...env, ...name !== void 0 ? { SCP_NAME: name } : {}, [CHANNELS_ENV]: String(process.pid) }
+  });
+  const forward = (signal) => () => void child.kill(signal);
+  const handlers = ["SIGTERM", "SIGHUP"].map((signal) => [signal, forward(signal)]);
+  const ignore = () => {
+  };
+  process.on("SIGINT", ignore);
+  for (const [signal, handler] of handlers) process.on(signal, handler);
+  try {
+    return await new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("exit", (code, signal) => resolve(code ?? (signal ? 128 + (signalNumber(signal) ?? 1) : 1)));
+    });
+  } finally {
+    process.off("SIGINT", ignore);
+    for (const [signal, handler] of handlers) process.off(signal, handler);
+  }
+}
+var SIGNALS = { SIGHUP: 1, SIGINT: 2, SIGKILL: 9, SIGTERM: 15 };
+var signalNumber = (signal) => SIGNALS[signal];
+export {
+  CHANNEL_FLAGS,
+  claudeArgv,
+  claudeCommand,
+  mountHint
+};

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-QP32TYTL.js");
+  const { run } = await import("./main-PZQAJGHQ.js");
   await run(process.argv.slice(2));
 }

package/dist/daemon-SUTLTY5U.js

@@ -0,0 +1,52 @@
+import {
+  capture
+} from "./chunk-M2DCR2J4.js";
+
+// src/daemon.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { setTimeout as sleep } from "timers/promises";
+function brokerPid(dir) {
+  let pid;
+  try {
+    pid = Number(readFileSync(join(dir, "broker.lock"), "utf8").split(":")[0]);
+  } catch {
+    return null;
+  }
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  const command = capture(["ps", "-p", String(pid), "-o", "command="])?.trim() ?? "";
+  return /(^|\s)daemon(\s|$)/.test(command) && (/scp|swarm/.test(command) || command.includes(process.argv[1] ?? "\0")) ? pid : null;
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function exited(pid, ms = 5e3) {
+  const deadline = Date.now() + ms;
+  while (alive(pid)) {
+    if (Date.now() >= deadline) return false;
+    await sleep(50);
+  }
+  return true;
+}
+async function stopBroker(dir) {
+  const pid = brokerPid(dir);
+  if (pid === null) return null;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (error) {
+    if (error.code === "ESRCH") return null;
+    throw error;
+  }
+  if (!await exited(pid)) throw new Error(`the relay broker (pid ${pid}) did not stop within 5 s`);
+  return pid;
+}
+export {
+  brokerPid,
+  exited,
+  stopBroker
+};

package/dist/{hooks-MBKU56HG.js → hooks-4YVIPZKE.js}

@@ -30,11 +30,12 @@ import {
   subagentIntro,
   summarize,
   unreadPointer
-} from "./chunk-RO7CUOOH.js";
+} from "./chunk-ABR5UABL.js";
 import {
   SUBAGENT
 } from "./chunk-YYSLYVNZ.js";
-import "./chunk-DA3EB2YF.js";
+import "./chunk-3PGDKPRN.js";
+import "./chunk-M2DCR2J4.js";
 export {
   AGY_HOOK_SET,
   AGY_UNVERIFIED,

package/dist/install-4KQQWGGB.js

@@ -0,0 +1,15 @@
+import {
+  hooksTarget,
+  installHooks,
+  mcpInstall
+} from "./chunk-QQZF5TQD.js";
+import "./chunk-URSBFDR6.js";
+import "./chunk-ABR5UABL.js";
+import "./chunk-YYSLYVNZ.js";
+import "./chunk-3PGDKPRN.js";
+import "./chunk-M2DCR2J4.js";
+export {
+  hooksTarget,
+  installHooks,
+  mcpInstall
+};

package/dist/{login-JTRUWG6Q.js → login-5Y3HPSVC.js}

@@ -1,16 +1,17 @@
 import {
   machineName
-} from "./chunk-6UFMKYPH.js";
+} from "./chunk-5UWLTO2Y.js";
 import {
   activeRelay,
   saveCredential
-} from "./chunk-4QYUPPGV.js";
+} from "./chunk-BUC5G5PY.js";
 import {
   RelayUsage
-} from "./chunk-7KP6TAJW.js";
+} from "./chunk-URSBFDR6.js";
+import "./chunk-3PGDKPRN.js";
 import {
   note
-} from "./chunk-DA3EB2YF.js";
+} from "./chunk-M2DCR2J4.js";
 
 // src/login.ts
 import { spawn } from "child_process";

package/dist/{main-QP32TYTL.js → main-PZQAJGHQ.js}

@@ -1,6 +1,6 @@
 import {
   SPAWN_HELP
-} from "./chunk-IE5VI25P.js";
+} from "./chunk-KN7WEIE4.js";
 import {
   OPTIONS,
   RelayUsage,
@@ -14,15 +14,17 @@ import {
   stamp,
   startDaemon,
   time
-} from "./chunk-7KP6TAJW.js";
+} from "./chunk-URSBFDR6.js";
+import {
+  shortHostname
+} from "./chunk-3PGDKPRN.js";
 import {
   FAILED,
   exitFlushed,
   note,
   parseSeconds,
-  printTable,
-  shortHostname
-} from "./chunk-DA3EB2YF.js";
+  printTable
+} from "./chunk-M2DCR2J4.js";
 
 // src/main.ts
 import { text as readAll } from "stream/consumers";
@@ -33,7 +35,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.1.0",
+  version: "0.1.3",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -78,6 +80,7 @@ import {
   LIMITS,
   PREAMBLE,
   reachLines,
+  receiptLines,
   RelayError,
   shortId,
   stripControl,
@@ -96,14 +99,16 @@ results back, as with native subagents.
   ${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
-  ${CLI_NAME} status                      the fleet in short: who works, waits or is blocked, unread counts
+  ${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"
 
 - spawn returns at once with the worker's name: do not background it (no &, no run_in_background).
 - A worker's messages and its handback (exit code and its whole reply) arrive by themselves: when you stop, your stop
   waits for them and continues with them, and new messages also reach you after your tool calls. No polling needed.
-- Address a worker by the name spawn printed. Steer it meanwhile with ${CLI_NAME} send <name> <text>.
+- Address a worker by the name spawn printed. Steer it meanwhile with ${CLI_NAME} send <name> <text>: it gets
+  the message after its next tool call or before it finishes, so its task need not tell it to check an inbox.
+- With the relay MCP tools: relay_spawn starts a worker in one call, relay_send steers it, relay_status reads receipts.
 - --no-push: a worker your stop does not wait on; its messages and handback still reach you after your tool calls
   or with another worker's push.
 - An <id> is a message id, its short id (the last 6 characters, shown with every message) or last.
@@ -132,6 +137,9 @@ usage:
   ${CLI_NAME} ask-wait <id> [--wait S]           keep waiting for the reply to a request
   ${CLI_NAME} status [--all] [--activity]        the fleet in short: you, agents by presence and status, who waits or is blocked,
                                                  unread counts; --activity adds the latest activity, --all counts offline agents
+  ${CLI_NAME} status <id>                        a message you sent, a line per recipient: read at HH:MM:SS, delivered at
+                                                 HH:MM:SS (a background hook handed it over; it reaches the model with its next
+                                                 request), shown by a hook at HH:MM:SS (in its context, not yet marked read), or unread
   ${CLI_NAME} watch                              a live tail of the fleet: presence, messages, status, activity
   ${CLI_NAME} set-status <state> [note]          your status line: working, waiting, blocked or done
   ${CLI_NAME} set-title <text>                   what you work on, shown in list, peers and whoami ("" clears it)
@@ -188,8 +196,10 @@ scopes (selectors are comma-separated, e.g. tree:parent,tree:children,group:team
                                                  still reach you after your tool calls, with another worker's push, or in your inbox.
                                                  codex gets -c overrides that hand the grant to its scp MCP server
                                                  (also behind env, VAR=value, timeout, nohup or nice). codex exec outside a git
-                                                 repo gets --skip-git-repo-check when its codex has it, and with its prompt in argv
-                                                 runs on /dev/null for stdin (a - prompt, or none, keeps stdin).
+                                                 repo gets --skip-git-repo-check when its codex has it. With its prompt in argv it
+                                                 runs on /dev/null for stdin, except in the foreground (--fg), where piped context
+                                                 or a file reaches it (from an agent's shell only a pipe with data within 300 ms);
+                                                 a - prompt, or none, keeps stdin.
                                                  claude -p and grok -p get the relay messaging tools allowed (--allowedTools,
                                                  grok --allow) unless you pass a permission flag. muse runs with
                                                  --contributor-mode off unless you pass --contributor-mode on (or a -c contributor
@@ -222,6 +232,7 @@ scopes (selectors are comma-separated, e.g. tree:parent,tree:children,group:team
   other process under an agent they may only narrow. An ancestor always reaches its descendants, and a recipient
   may always reply in the thread to a message it got; a reply to another message of the thread is checked as a send.
   ${CLI_NAME} daemon [--idle DURATION] [--policy FILE]   run the broker in the foreground (it otherwise starts on demand)
+  ${CLI_NAME} daemon stop|restart                stop the running broker, or replace it with a fresh one
 
 agent sessions:
   ${CLI_NAME} mcp [--as NAME] [--harness H] [--channels]   the MCP shim a harness mounts: relay tools for one agent, never me/
@@ -246,7 +257,9 @@ agent sessions:
   A Claude Code subagent's hooks give it a child endpoint, <session handle>-<type>-<first 6 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.
-  --channels pushes messages into Claude Code started with --dangerously-load-development-channels server:scp.
+  ${CLI_NAME} claude [--name N] [--] [claude args...]   start Claude Code with the scp channel loaded, so peer messages wake
+                                                 it while idle (claude --dangerously-load-development-channels server:scp; SCP_NAME=N)
+  --channels pushes messages into a Claude Code that ${CLI_NAME} claude started; setup mounts claude's shim with it.
 
 relay:
   ${CLI_NAME} relay use <url> | show            select a relay, or show its source and credential status
@@ -348,6 +361,7 @@ var VERBS = {
   machines: IDENTITY
 };
 var MESSAGE_REF = /^(last|[0-9a-z]{4,})$/;
+var ACK_ALL_PAGES = Math.ceil(2 * LIMITS.inboxMax / LIMITS.inboxPage) + 1;
 async function lookup(client, id, member = false) {
   try {
     return (await client.request("message", { id, ...member ? { member: true } : {} })).message;
@@ -386,6 +400,7 @@ function printMessage(message) {
   out(
     `#${message.seq} ${message.kind} from ${message.from.address} (${harness}) ${time(message.created_at)}  id ${shortId(message.id)} (${message.id})${message.reply_to ? `  reply to ${message.reply_to}` : ""}`
   );
+  if (message.shown_at) out(`(a hook already showed you this at ${time(message.shown_at)}; that copy may reach you after this command)`);
   out(wrapMessage(message));
   out();
 }
@@ -481,10 +496,11 @@ async function relayMain(argv, cwd = process.cwd()) {
     out(package_default.version);
     return 0;
   }
-  if (verb === "hook") return (await import("./hooks-MBKU56HG.js")).relayHookCommand(rest, startDaemon);
-  if (verb === "setup") return (await import("./setup-T4ZZKV7K.js")).relaySetupCommand(rest, cwd, out);
+  if (verb === "hook") return (await import("./hooks-4YVIPZKE.js")).relayHookCommand(rest, startDaemon);
+  if (verb === "setup") return (await import("./setup-UF4AA6RO.js")).relaySetupCommand(rest, cwd, out);
+  if (verb === "claude") return (await import("./claude-5WTICOYS.js")).claudeCommand(rest);
   if (verb === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-7P4EMSVB.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-KT5235WX.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -506,13 +522,16 @@ async function relayMain(argv, cwd = process.cwd()) {
     return 0;
   }
   for (const key of Object.keys(values)) if (!allowed.includes(key)) throw new RelayUsage(`${CLI_NAME} ${verb} does not take --${key}`);
-  if (verb === "daemon") return daemon(values.idle, values.policy);
+  if (verb === "daemon") {
+    if (positionals.length) return daemonControl(positionals, values);
+    return daemon(values.idle, values.policy);
+  }
   if (verb === "mcp")
-    return (await import("./mcp-EQCSCD3X.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-GI5OMTUT.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-4HATFIFI.js")).installHooks({
+    return (await import("./install-4KQQWGGB.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -523,18 +542,25 @@ async function relayMain(argv, cwd = process.cwd()) {
       out
     });
   }
-  if (verb === "relay") return (await import("./relay-VVJPYVXE.js")).relayVerb(positionals, values.json === true);
-  if (verb === "up") return (await import("./up-Z4RSJMED.js")).up(positionals, values, cwd, cloudStatus);
-  if (verb === "login")
-    return (await import("./relay-VVJPYVXE.js")).loginMain(positionals, values);
-  if (verb === "logout") return (await import("./relay-VVJPYVXE.js")).logoutMain(positionals, values.json === true);
-  if (verb === "cloud") return (await import("./remote-3BWFISXJ.js")).cloudMain(positionals, values, cloudStatus);
+  if (verb === "relay") return (await import("./relay-W2NFUE2U.js")).relayVerb(positionals, values.json === true);
+  if (verb === "up") return (await import("./up-VA54QWA6.js")).up(positionals, values, cwd, relinkBroker);
+  if (verb === "login") {
+    const code = await (await import("./relay-W2NFUE2U.js")).loginMain(positionals, values);
+    if (code === 0) await relinkRunning();
+    return code;
+  }
+  if (verb === "logout") return (await import("./relay-W2NFUE2U.js")).logoutMain(positionals, values.json === true);
+  if (verb === "cloud") {
+    const code = await (await import("./remote-GC4XN44U.js")).cloudMain(positionals, values, cloudStatus);
+    if (code === 0 && positionals[0] === "enable") await relinkRunning();
+    return code;
+  }
   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-3BWFISXJ.js")).machinesVerb(client, positionals, values.json === true);
+    if (verb === "machines") return await (await import("./remote-GC4XN44U.js")).machinesVerb(client, positionals, values.json === true);
     return await runVerb(opened, verb, values, positionals, cwd);
   } finally {
     client.close();
@@ -550,6 +576,55 @@ async function cloudStatus() {
     client.close();
   }
 }
+async function relinkBroker() {
+  const dir = relayDir();
+  const client = await connectBroker(dir, () => startDaemon(dir));
+  let result;
+  let pid;
+  try {
+    pid = (await client.hello({ observe: true })).broker.pid;
+    result = await client.request("bridge_relink");
+  } catch (error) {
+    if (error instanceof RelayError && error.code === "method_not_found") return cloudStatus();
+    throw error;
+  } finally {
+    client.close();
+  }
+  if (!result.restarting) return result;
+  await (await import("./daemon-SUTLTY5U.js")).exited(pid);
+  return cloudStatus();
+}
+async function relinkRunning() {
+  try {
+    await connectBroker(relayDir()).then((client) => client.close());
+  } catch {
+    return;
+  }
+  try {
+    await relinkBroker();
+  } catch (error) {
+    note(`the running broker did not link again (${error instanceof Error ? error.message : String(error)}); run \`${CLI_NAME} daemon restart\``);
+  }
+}
+async function daemonControl(positionals, values) {
+  const [action] = positionals;
+  if (positionals.length !== 1 || action !== "stop" && action !== "restart" || values.idle !== void 0 || values.policy !== void 0)
+    throw new RelayUsage(`${CLI_NAME} daemon takes stop or restart, or --idle and --policy to run in the foreground`);
+  const dir = relayDir();
+  const pid = await (await import("./daemon-SUTLTY5U.js")).stopBroker(dir);
+  if (action === "stop") {
+    out(pid === null ? "no relay broker runs" : `stopped the relay broker (pid ${pid}); the next command starts a fresh one`);
+    return 0;
+  }
+  const client = await connectBroker(dir, () => startDaemon(dir));
+  try {
+    const { broker } = await client.hello({ observe: true });
+    out(`${pid === null ? "started" : `replaced the relay broker (pid ${pid}) with`} a fresh one (pid ${broker.pid})`);
+  } finally {
+    client.close();
+  }
+  return 0;
+}
 async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, values, positionals, cwd) {
   const asJson = values.json === true;
   const attachments = (values.attach ?? []).map((path) => ({ kind: "path", path: path.startsWith("/") ? path : `${cwd}/${path}` }));
@@ -662,9 +737,9 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       return 0;
     }
     case "peek":
-      return (await import("./peek-YCOWBEPD.js")).peekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-X4SEGEUB.js")).peekCommand(localClient(client, broker, verb), values, positionals);
     case "set-peek":
-      return (await import("./peek-YCOWBEPD.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-X4SEGEUB.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>`);
@@ -697,6 +772,8 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
           const lines = reachLines(result2.deliveries);
           out(`sent ${result2.id} to ${result2.deliveries.map((d) => lines.length ? d.address : deliveryText(d)).join(", ")}${redactedText(result2.redacted)}`);
           for (const line of lines) out(`  ${line}`);
+          if (result2.deliveries.some((d) => d.state === "running" || d.state === "starting"))
+            out(`  ${CLI_NAME} status ${shortId(result2.id)} shows when it is read`);
         }
         return 0;
       }
@@ -735,9 +812,10 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
     }
     case "inbox": {
       if (values.ack && values.keep) throw new RelayUsage("--ack and --keep: pick one");
-      const { messages } = await client.request("inbox", { wait_s: waitArg(values.wait, 0) });
+      const waited = waitArg(values.wait, 0);
+      const { messages } = await client.request("inbox", { wait_s: waited });
       if (asJson) json({ preamble: PREAMBLE, messages });
-      else if (!messages.length) note("no unread messages");
+      else if (!messages.length) note(`no unread messages${waited > LIMITS.waitMaxS ? `; waited ${LIMITS.waitMaxS} s (cap)` : ""}`);
       else {
         out(PREAMBLE);
         out();
@@ -757,9 +835,9 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
           result.acked += (await client.request("ack", { seqs: seqs.slice(i, i + LIMITS.inboxPage) })).acked;
       };
       if (values.all) {
-        for (let before = -1; before !== result.acked; ) {
-          before = result.acked;
+        for (let page = 0; page < ACK_ALL_PAGES; page++) {
           const { messages } = await client.request("inbox", { wait_s: 0 });
+          if (!messages.length) break;
           await ack(messages.flatMap((m) => m.seq === void 0 ? [] : [m.seq]));
         }
       } else {
@@ -778,6 +856,20 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       return 0;
     }
     case "status": {
+      if (positionals.length) {
+        if (positionals.length > 1 || values.all || values.activity)
+          throw new RelayUsage(`${CLI_NAME} status takes one message id, or --all and --activity for the fleet`);
+        if (!broker) throw new RelayUsage(`${CLI_NAME} status <id> is the local broker's; it has no --cloud form`);
+        if (!me) throw new RelayUsage(`${CLI_NAME} status <id> reads a message you sent: pass --as HANDLE, or run it from the agent's shell or your terminal`);
+        const receipts = await client.request("receipts", { id: positionals[0] });
+        if (asJson) json(receipts);
+        else {
+          out(`${receipts.id}:`);
+          const lines = receiptLines(receipts);
+          for (const line of lines.length ? lines : ["no deliveries of it are kept any more"]) out(`  ${line}`);
+        }
+        return 0;
+      }
       const snapshot = await client.request("snapshot", { all: values.all === true });
       if (asJson) {
         json(snapshot);
@@ -1200,11 +1292,12 @@ async function daemon(idle, policyFile) {
   });
   let broker;
   try {
-    const { daemonBridge } = await import("./remote-3BWFISXJ.js");
+    const { daemonBridge } = await import("./remote-GC4XN44U.js");
     const bridge = await daemonBridge();
     broker = await startBroker({
       dir: relayDir(),
       ...bridge ? { bridge } : {},
+      bridgeConfig: () => daemonBridge(),
       ...idleMs !== void 0 ? { idleMs } : {},
       ...policyFile ? { policyPath: resolve(policyFile) } : {}
     });

package/dist/{mcp-EQCSCD3X.js → mcp-GI5OMTUT.js}

@@ -1,16 +1,24 @@
+import {
+  spawnDetached
+} from "./chunk-ABP5AKFH.js";
+import "./chunk-KN7WEIE4.js";
+import "./chunk-IH2RJRIW.js";
 import {
   mcpInstall
-} from "./chunk-WSLKRAB7.js";
+} from "./chunk-QQZF5TQD.js";
 import {
+  CHANNELS_ENV,
   RelayUsage,
   startDaemon
-} from "./chunk-7KP6TAJW.js";
-import "./chunk-RO7CUOOH.js";
+} from "./chunk-URSBFDR6.js";
+import "./chunk-ABR5UABL.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   harnessPid,
+  psParent,
   relayIdentity
-} from "./chunk-DA3EB2YF.js";
+} from "./chunk-3PGDKPRN.js";
+import "./chunk-M2DCR2J4.js";
 
 // src/mcp.ts
 import { CLI_NAME, validHandle } from "@scp-dev/core";
@@ -41,11 +49,33 @@ async function relayMcpCommand(values, positionals) {
     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}
 `)
   });
   return 0;
 }
+function spawnWords(request) {
+  return [
+    "--bg",
+    "--as",
+    request.as,
+    ...request.harness !== void 0 ? ["--harness", request.harness] : [],
+    ...request.name !== void 0 ? ["--name", request.name] : [],
+    ...request.title !== void 0 ? ["--title", request.title] : [],
+    ...request.no_push ? ["--no-push"] : [],
+    ...request.handback_bytes !== void 0 ? ["--handback-bytes", String(request.handback_bytes)] : [],
+    "--",
+    ...request.command
+  ];
+}
+function launchedWithChannels(env, harness = harnessPid, parentOf = psParent) {
+  const launcher = Number(env[CHANNELS_ENV]);
+  return Number.isInteger(launcher) && launcher > 1 && parentOf(harness())?.ppid === launcher;
+}
 export {
-  relayMcpCommand
+  launchedWithChannels,
+  relayMcpCommand,
+  spawnWords
 };

package/dist/{peek-YCOWBEPD.js → peek-X4SEGEUB.js}

@@ -2,10 +2,11 @@ import {
   RelayUsage,
   peekGrant,
   stamp
-} from "./chunk-7KP6TAJW.js";
+} from "./chunk-URSBFDR6.js";
+import "./chunk-3PGDKPRN.js";
 import {
   note
-} from "./chunk-DA3EB2YF.js";
+} from "./chunk-M2DCR2J4.js";
 
 // src/peek.ts
 import { PREAMBLE, wrapPeek, CLI_NAME } from "@scp-dev/core";

package/dist/{relay-VVJPYVXE.js → relay-W2NFUE2U.js}

@@ -11,9 +11,10 @@ import {
   removeCredential,
   saveCredential,
   writePrivateJson
-} from "./chunk-4QYUPPGV.js";
-import "./chunk-7KP6TAJW.js";
-import "./chunk-DA3EB2YF.js";
+} from "./chunk-BUC5G5PY.js";
+import "./chunk-URSBFDR6.js";
+import "./chunk-3PGDKPRN.js";
+import "./chunk-M2DCR2J4.js";
 export {
   DEFAULT_RELAY,
   activeRelay,

package/dist/{remote-3BWFISXJ.js → remote-GC4XN44U.js}

@@ -9,10 +9,11 @@ import {
   machinesVerb,
   openCloud,
   readCloudFile
-} from "./chunk-6UFMKYPH.js";
-import "./chunk-4QYUPPGV.js";
-import "./chunk-7KP6TAJW.js";
-import "./chunk-DA3EB2YF.js";
+} from "./chunk-5UWLTO2Y.js";
+import "./chunk-BUC5G5PY.js";
+import "./chunk-URSBFDR6.js";
+import "./chunk-3PGDKPRN.js";
+import "./chunk-M2DCR2J4.js";
 export {
   CloudRelayClient,
   CloudUsage,