@scp-dev/cli 0.1.0 → 0.1.2

package/dist/{chunk-WSLKRAB7.js → chunk-4DNQFATX.js}

@@ -13,7 +13,7 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-RO7CUOOH.js";
+} from "./chunk-XWLF7ON2.js";
 import {
   gitToplevel
 } from "./chunk-DA3EB2YF.js";

package/dist/{chunk-IE5VI25P.js → chunk-KN7WEIE4.js}

@@ -29,7 +29,7 @@ Steer: ${CLI_NAME} send <name> <text>; a claude -p or codex exec prompt gets a n
 A codex exec worker that exited before a late steer is resumed with it (codex exec resume, at most twice).
 Harnesses: codex gets -c overrides that hand it the grant (also behind env, timeout, nohup or nice); a ${CLI_NAME}
 command from its workspace-write sandbox needs -c sandbox_workspace_write.network_access=true. codex exec
-gets --skip-git-repo-check outside a git repo and a closed stdin unless its prompt is - (read from stdin). Workers
+gets --skip-git-repo-check outside a git repo, and with its prompt in argv piped stdin only under --fg. Workers
 message with the relay MCP tools (relay_send, relay_inbox, relay_reply). claude -p and grok -p get those tools allowed
 unless you pass a permission flag. muse runs with --contributor-mode off unless you pass on. agy needs the allow rules ${CLI_NAME}
 setup writes.

package/dist/{chunk-O4J5G2X7.js → chunk-N3ZROLFA.js}

@@ -1,6 +1,6 @@
 import {
   hooksTarget
-} from "./chunk-WSLKRAB7.js";
+} from "./chunk-4DNQFATX.js";
 import {
   RelayUsage
 } from "./chunk-7KP6TAJW.js";
@@ -15,7 +15,7 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-RO7CUOOH.js";
+} from "./chunk-XWLF7ON2.js";
 import {
   gitToplevel
 } from "./chunk-DA3EB2YF.js";

package/dist/{spawn-7P4EMSVB.js → chunk-V5I7KEU7.js}

@@ -1,13 +1,9 @@
-import {
-  SPAWN_HELP
-} from "./chunk-IE5VI25P.js";
 import {
   agyRules,
   agySettingsFile,
   mcpFile,
   mountedEntry
-} from "./chunk-O4J5G2X7.js";
-import "./chunk-WSLKRAB7.js";
+} from "./chunk-N3ZROLFA.js";
 import {
   OPTIONS,
   RelayUsage,
@@ -20,8 +16,7 @@ import {
 } from "./chunk-7KP6TAJW.js";
 import {
   steerPrompt
-} from "./chunk-RO7CUOOH.js";
-import "./chunk-YYSLYVNZ.js";
+} from "./chunk-XWLF7ON2.js";
 import {
   SELF,
   detectHarness,
@@ -297,6 +292,35 @@ function closedStdin(command) {
   if (run.sub?.name === "resume") return run.operands.length >= (hasFlag(args, ["--last"]) ? 1 : 2);
   return run.sub !== void 0 || run.operands.length > 0;
 }
+var STDIN_WAIT_MS = 300;
+async function harnessStdin(waitMs) {
+  if (process.stdin.isTTY === true) return "ignore";
+  let stat;
+  try {
+    stat = fstatSync(0);
+  } catch {
+    return "ignore";
+  }
+  if (stat.isFile()) return stat.size > 0 ? "inherit" : "ignore";
+  if (!stat.isFIFO() && !stat.isSocket()) return "ignore";
+  const input = process.stdin;
+  return new Promise((resolve2) => {
+    const settle = (result) => {
+      clearTimeout(timer);
+      input.off("data", data);
+      input.off("end", ended);
+      input.off("error", ended);
+      input.pause();
+      resolve2(result);
+    };
+    const data = (chunk) => settle({ first: chunk, rest: input });
+    const ended = () => settle("ignore");
+    const timer = waitMs === void 0 ? void 0 : setTimeout(ended, waitMs);
+    input.on("data", data);
+    input.once("end", ended);
+    input.once("error", ended);
+  });
+}
 function harnessArgv(command, env, self = SELF, mount = codexMount, cwd = process.cwd(), probe = codexSkipsGitCheck) {
   const at = programAt(command);
   const program = command[at];
@@ -492,11 +516,19 @@ function runHarness(argv, env, options = {}) {
   return new Promise((resolve2) => {
     const tty = process.stdin.isTTY === true;
     const group = options.group === true && !tty && process.stdout.isTTY !== true && process.stderr.isTTY !== true;
+    const input = options.stdin ?? "inherit";
+    const piped = typeof input === "object" ? input : void 0;
     const child = spawn(argv[0], argv.slice(1), {
-      stdio: [options.stdin ?? "inherit", capture ? "pipe" : "inherit", captureErr ? "pipe" : "inherit"],
+      stdio: [typeof input === "object" ? "pipe" : input, capture ? "pipe" : "inherit", captureErr ? "pipe" : "inherit"],
       env,
       detached: group
     });
+    if (piped && child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.write(piped.first);
+      piped.rest.pipe(child.stdin);
+    }
     const pipes = [child.stdout, child.stderr].filter((pipe) => pipe !== null);
     const stdout = child.stdout ? tee(child.stdout, out) : void 0;
     const stderr = child.stderr ? tee(child.stderr, options.err ?? process.stderr) : void 0;
@@ -638,7 +670,11 @@ ${LIMIT_CUT}`);
   return replies;
 }
 function repliesOutput(replies, bytes = LIMITS.handbackBytes) {
-  const clean = replies.map((reply) => handbackOutput(reply.replace(/\r\n?/g, "\n"), false, Number.MAX_SAFE_INTEGER)).filter(Boolean);
+  const lines = (text) => text.split("\n").map((line) => line.trim()).filter(Boolean);
+  const all = replies.map((reply) => handbackOutput(reply.replace(/\r\n?/g, "\n"), false, Number.MAX_SAFE_INTEGER)).filter(Boolean);
+  const restated = (text, later) => lines(text).length >= 2 && lines(text).every((line) => lines(later).includes(line));
+  const clean = all.filter((text, i) => text === HANDBACK_CUT || !all.slice(i + 1).some((later) => restated(text, later)));
+  if (clean.every((text) => text === HANDBACK_CUT)) return "";
   const size = (text) => new TextEncoder().encode(text).length;
   const framed = (from) => {
     const text = clean.slice(from).join("\n\n");
@@ -648,7 +684,7 @@ ${text}` : text;
   };
   let fit;
   for (let from = clean.length - 1; from >= 0 && size(framed(from)) <= bytes; from--) fit = framed(from);
-  if (fit !== void 0 || !clean.length) return fit ?? "";
+  if (fit !== void 0) return fit;
   return keepLast(clean.at(-1), bytes, clean.length > 1);
 }
 function splitSpawn(args) {
@@ -682,20 +718,9 @@ function handbackBytes(value) {
 }
 var STEER_RESUMES = 2;
 async function spawnCommand(args, cwd) {
-  const split = splitSpawn(args);
-  let values;
-  try {
-    values = parseArgs({ args: split.flags, options: OPTIONS, strict: true }).values;
-  } catch (error) {
-    throw new RelayUsage(error instanceof Error ? error.message : String(error));
-  }
-  for (const key of Object.keys(values)) if (!SPAWN_OPTIONS.includes(key)) throw new RelayUsage(`${CLI_NAME} spawn does not take --${key}`);
-  if (values.bg && values.fg) throw new RelayUsage("--bg and --fg: pick one");
-  const command = split.command;
-  if (!command.length)
-    throw new RelayUsage(`${CLI_NAME} spawn runs a harness command: ${CLI_NAME} spawn [flags] [--] <harness cmd...>, e.g. ${CLI_NAME} spawn codex exec "..."`);
-  const refusal = contributorRefusal(command);
-  if (refusal) throw new RelayUsage(refusal);
+  const parsed = parseSpawn(args);
+  let values = parsed.values;
+  const { command } = parsed;
   const bytes = values["handback-bytes"] === void 0 ? void 0 : handbackBytes(values["handback-bytes"]);
   const runner = process.env[SPAWN_RUNNER];
   delete process.env[SPAWN_RUNNER];
@@ -737,8 +762,10 @@ async function spawnCommand(args, cwd) {
   const agy = agyNote(command, process.env);
   if (agy) note(agy);
   const started = handshake && ((failed) => handshake(failed ? { error: failed.message, code: failed.code } : { name, pid: process.pid }));
-  const launch = (argv, extra = {}) => runHarness(harnessArgv(argv, env), env, { ...extra, group: runner !== void 0, ...closedStdin(argv) ? { stdin: "ignore" } : {} });
-  let run = await launch(steerArgv(command, steer), started ? { started } : {});
+  const launch = (argv, extra = {}) => runHarness(harnessArgv(argv, env), env, { group: runner !== void 0, ...closedStdin(argv) ? { stdin: "ignore" } : {}, ...extra });
+  const first = steerArgv(command, steer);
+  const stdin = closedStdin(first) ? await harnessStdin(agentShell(process.env) ? STDIN_WAIT_MS : void 0) : void 0;
+  let run = await launch(first, { ...started ? { started } : {}, ...stdin ? { stdin } : {} });
   if (!run.started) {
     await spawnExit(values, cwd, grant.SCP_GRANT, run.code, name, "", walk, [], [], false);
     return run.code;
@@ -761,6 +788,32 @@ async function spawnCommand(args, cwd) {
   await spawnExit(values, cwd, grant.SCP_GRANT, run.code, name, replies || harnessOutput(run, bytes), walk, unapplied, exits, true, stderrOutput(run));
   return run.code;
 }
+function parseSpawn(args) {
+  const split = splitSpawn(args);
+  let values;
+  try {
+    values = parseArgs({ args: split.flags, options: OPTIONS, strict: true }).values;
+  } catch (error) {
+    throw new RelayUsage(error instanceof Error ? error.message : String(error));
+  }
+  if (values.help) return { values, command: split.command };
+  for (const key of Object.keys(values)) if (!SPAWN_OPTIONS.includes(key)) throw new RelayUsage(`${CLI_NAME} spawn does not take --${key}`);
+  if (values.bg && values.fg) throw new RelayUsage("--bg and --fg: pick one");
+  const command = split.command;
+  if (!command.length)
+    throw new RelayUsage(`${CLI_NAME} spawn runs a harness command: ${CLI_NAME} spawn [flags] [--] <harness cmd...>, e.g. ${CLI_NAME} spawn codex exec "..."`);
+  const refusal = contributorRefusal(command);
+  if (refusal) throw new RelayUsage(refusal);
+  if (values["handback-bytes"] !== void 0) handbackBytes(values["handback-bytes"]);
+  return { values, command };
+}
+async function spawnDetached(args, cwd) {
+  const { values } = parseSpawn(args);
+  if (values.help || values.fg) throw new RelayUsage("a detached spawn takes no --help or --fg");
+  const reply = await detachedRunner(args, cwd);
+  if ("error" in reply) throw new Error(reply.error);
+  return reply;
+}
 function agentShell(env) {
   return detectHarness(env) !== void 0 || ["SCP_NAME", "SCP_GRANT", "SCP_SESSION"].some((key) => env[key]);
 }
@@ -782,6 +835,17 @@ function once(fn) {
   };
 }
 async function detachSpawn(args, cwd) {
+  const reply = await detachedRunner(args, cwd);
+  if ("error" in reply) {
+    note(reply.error);
+    return reply.code;
+  }
+  console.log(
+    `${reply.name} started (pid ${reply.pid}) and runs in the background: its result arrives as a relay message by itself; steer it with ${CLI_NAME} send ${reply.name} <text>`
+  );
+  return 0;
+}
+async function detachedRunner(args, cwd) {
   const walk = walkNow();
   const child = spawn(SELF[0], [...SELF.slice(1), "spawn", ...args], {
     cwd,
@@ -810,13 +874,9 @@ async function detachSpawn(args, cwd) {
   if ("error" in reply) {
     if (reply.usage) throw new RelayUsage(reply.error);
     if (reply.code === void 0) throw new Error(reply.error);
-    note(reply.error);
-    return reply.code;
+    return { error: reply.error, code: reply.code };
   }
-  console.log(
-    `${reply.name} started (pid ${reply.pid}) and runs in the background: its result arrives as a relay message by itself; steer it with ${CLI_NAME} send ${reply.name} <text>`
-  );
-  return 0;
+  return reply;
 }
 async function spawnSteers(values, cwd, token, walk, take) {
   try {
@@ -853,33 +913,36 @@ async function spawnExit(values, cwd, token, code, name, output, walk, unapplied
   }
 }
 var SPAWN_GRANT_TTL_S = 3600;
+
 export {
-  MESSAGING,
-  SPAWN_HELP,
   SPAWN_RUNNER,
-  agentShell,
-  agyNote,
-  claudeTranscripts,
-  closedStdin,
+  spawnEnvironment,
   codexMount,
-  codexOverrideAt,
   codexOverrides,
-  codexSkipsGitCheck,
+  codexOverrideAt,
+  programAt,
+  MESSAGING,
   contributorRefusal,
+  codexSkipsGitCheck,
+  closedStdin,
+  STDIN_WAIT_MS,
+  harnessStdin,
   harnessArgv,
-  harnessOutput,
-  programAt,
-  repliesOutput,
   resumeArgv,
-  runHarness,
-  spawnCommand,
-  spawnDefaults,
-  spawnEnvironment,
   spawnPrompt,
+  steerArgv,
   spawnTitle,
-  splitSpawn,
+  workerName,
+  agyNote,
+  runHarness,
+  harnessOutput,
   stderrOutput,
-  steerArgv,
+  claudeTranscripts,
   transcriptReplies,
-  workerName
+  repliesOutput,
+  splitSpawn,
+  spawnDefaults,
+  spawnCommand,
+  spawnDetached,
+  agentShell
 };

package/dist/{chunk-RO7CUOOH.js → chunk-XWLF7ON2.js}

@@ -238,9 +238,16 @@ function pushText(result) {
       `Push budget used up for this prompt; read the rest with ${CLI_NAME} inbox.${running.length ? ` Workers you spawned still running: ${running.join(", ")}.` : ""}`
     );
   } else {
-    parts.push(
-      running.length ? `Workers you spawned still running: ${running.join(", ")}; their next message reaches you when you stop.` : "No worker you spawned is still running."
-    );
+    const background = result.background ?? [];
+    if (running.length) {
+      parts.push(
+        `Workers you spawned still running: ${running.join(", ")}. End your turn to wait for them; no reply needed.${background.length ? ` Also running with --no-push: ${background.join(", ")}.` : ""}`
+      );
+    } else if (background.length) {
+      parts.push(
+        `No worker your stop waits on is still running; ${background.join(", ")} (--no-push) still ${background.length === 1 ? "runs" : "run"} in the background.`
+      );
+    } else parts.push("No worker you spawned is still running.");
   }
   return parts.join("\n\n");
 }
@@ -290,7 +297,8 @@ function hookReply(harness, kind, text, unread = 0, continues = true) {
   const hookEventName = kind === "tool" ? "PostToolUse" : kind === "session_start" ? "SessionStart" : "UserPromptSubmit";
   return JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext: text } });
 }
-var NUDGE = `${CLI_NAME}: set your title and a one-line now with relay_set_title / relay_set_now so peers can find you.`;
+var DEFERS = /* @__PURE__ */ new Set(["claude-code", "codex"]);
+var NUDGE = `${CLI_NAME} (optional): a title and a one-line now (relay_set_title / relay_set_now) help peers find you; skip it when you only run workers.`;
 async function runHook(args, options) {
   const began = Date.now();
   const blockStop = args.includes(BLOCK_STOP);
@@ -391,7 +399,8 @@ async function runHook(args, options) {
         ...nudged.length ? { nudged: nudged.map((n) => n.seq) } : {},
         ...directive ? { restated: directive.restated } : {},
         ...full ? { preamble: true } : {},
-        ...intro ? { intro: true } : {}
+        ...intro ? { intro: true } : {},
+        ...event.kind === "tool" && DEFERS.has(claim.harness) ? { deferred: true } : {}
       }).catch(() => {
       });
     }
@@ -442,7 +451,7 @@ async function subagentHook(client, claim, sub, event, takes, options) {
 }
 async function push(client, harness, waitMs, began, prompts, options, continues = true) {
   const end = Date.now() + waitMs;
-  if (waitMs > 0) options.deadline?.(end - began + PUSH_PRINT_MS);
+  if (waitMs > 0) options.deadline?.(end - began + LIMITS.pushGraceS * 1e3 + PUSH_PRINT_MS);
   let result;
   for (; ; ) {
     result = await client.request("stop_wait", {

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-5CAHHN55.js");
   await run(process.argv.slice(2));
 }

package/dist/{hooks-MBKU56HG.js → hooks-O3UZXDYG.js}

@@ -30,7 +30,7 @@ import {
   subagentIntro,
   summarize,
   unreadPointer
-} from "./chunk-RO7CUOOH.js";
+} from "./chunk-XWLF7ON2.js";
 import {
   SUBAGENT
 } from "./chunk-YYSLYVNZ.js";

package/dist/{install-4HATFIFI.js → install-HFBSKSTG.js}

@@ -2,9 +2,9 @@ import {
   hooksTarget,
   installHooks,
   mcpInstall
-} from "./chunk-WSLKRAB7.js";
+} from "./chunk-4DNQFATX.js";
 import "./chunk-7KP6TAJW.js";
-import "./chunk-RO7CUOOH.js";
+import "./chunk-XWLF7ON2.js";
 import "./chunk-YYSLYVNZ.js";
 import "./chunk-DA3EB2YF.js";
 export {

package/dist/{main-QP32TYTL.js → main-5CAHHN55.js}

@@ -1,6 +1,6 @@
 import {
   SPAWN_HELP
-} from "./chunk-IE5VI25P.js";
+} from "./chunk-KN7WEIE4.js";
 import {
   OPTIONS,
   RelayUsage,
@@ -33,7 +33,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.1.0",
+  version: "0.1.2",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -78,6 +78,7 @@ import {
   LIMITS,
   PREAMBLE,
   reachLines,
+  receiptLines,
   RelayError,
   shortId,
   stripControl,
@@ -96,14 +97,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 +135,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 +194,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
@@ -348,6 +356,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 +395,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 +491,10 @@ 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-O3UZXDYG.js")).relayHookCommand(rest, startDaemon);
+  if (verb === "setup") return (await import("./setup-RDPVGE4H.js")).relaySetupCommand(rest, cwd, out);
   if (verb === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-7P4EMSVB.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-TQ3HOZTQ.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -508,11 +518,11 @@ async function relayMain(argv, cwd = process.cwd()) {
   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 === "mcp")
-    return (await import("./mcp-EQCSCD3X.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-P2AZYP5G.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-HFBSKSTG.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -524,7 +534,7 @@ async function relayMain(argv, cwd = process.cwd()) {
     });
   }
   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 === "up") return (await import("./up-KXOYO7QV.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);
@@ -697,6 +707,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;
       }
@@ -757,9 +769,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 +790,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);

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

@@ -1,11 +1,16 @@
+import {
+  spawnDetached
+} from "./chunk-V5I7KEU7.js";
+import "./chunk-KN7WEIE4.js";
+import "./chunk-N3ZROLFA.js";
 import {
   mcpInstall
-} from "./chunk-WSLKRAB7.js";
+} from "./chunk-4DNQFATX.js";
 import {
   RelayUsage,
   startDaemon
 } from "./chunk-7KP6TAJW.js";
-import "./chunk-RO7CUOOH.js";
+import "./chunk-XWLF7ON2.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   harnessPid,
@@ -41,11 +46,27 @@ async function relayMcpCommand(values, positionals) {
     output: (line) => void process.stdout.write(line),
     env: process.env,
     channels: values.channels === true,
+    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
+  ];
+}
 export {
-  relayMcpCommand
+  relayMcpCommand,
+  spawnWords
 };

package/dist/{setup-T4ZZKV7K.js → setup-RDPVGE4H.js}

@@ -14,10 +14,10 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-O4J5G2X7.js";
-import "./chunk-WSLKRAB7.js";
+} from "./chunk-N3ZROLFA.js";
+import "./chunk-4DNQFATX.js";
 import "./chunk-7KP6TAJW.js";
-import "./chunk-RO7CUOOH.js";
+import "./chunk-XWLF7ON2.js";
 import "./chunk-YYSLYVNZ.js";
 import "./chunk-DA3EB2YF.js";
 export {

package/dist/spawn-TQ3HOZTQ.js

@@ -0,0 +1,74 @@
+import {
+  MESSAGING,
+  SPAWN_RUNNER,
+  STDIN_WAIT_MS,
+  agentShell,
+  agyNote,
+  claudeTranscripts,
+  closedStdin,
+  codexMount,
+  codexOverrideAt,
+  codexOverrides,
+  codexSkipsGitCheck,
+  contributorRefusal,
+  harnessArgv,
+  harnessOutput,
+  harnessStdin,
+  programAt,
+  repliesOutput,
+  resumeArgv,
+  runHarness,
+  spawnCommand,
+  spawnDefaults,
+  spawnDetached,
+  spawnEnvironment,
+  spawnPrompt,
+  spawnTitle,
+  splitSpawn,
+  stderrOutput,
+  steerArgv,
+  transcriptReplies,
+  workerName
+} from "./chunk-V5I7KEU7.js";
+import {
+  SPAWN_HELP
+} from "./chunk-KN7WEIE4.js";
+import "./chunk-N3ZROLFA.js";
+import "./chunk-4DNQFATX.js";
+import "./chunk-7KP6TAJW.js";
+import "./chunk-XWLF7ON2.js";
+import "./chunk-YYSLYVNZ.js";
+import "./chunk-DA3EB2YF.js";
+export {
+  MESSAGING,
+  SPAWN_HELP,
+  SPAWN_RUNNER,
+  STDIN_WAIT_MS,
+  agentShell,
+  agyNote,
+  claudeTranscripts,
+  closedStdin,
+  codexMount,
+  codexOverrideAt,
+  codexOverrides,
+  codexSkipsGitCheck,
+  contributorRefusal,
+  harnessArgv,
+  harnessOutput,
+  harnessStdin,
+  programAt,
+  repliesOutput,
+  resumeArgv,
+  runHarness,
+  spawnCommand,
+  spawnDefaults,
+  spawnDetached,
+  spawnEnvironment,
+  spawnPrompt,
+  spawnTitle,
+  splitSpawn,
+  stderrOutput,
+  steerArgv,
+  transcriptReplies,
+  workerName
+};

package/dist/{up-Z4RSJMED.js → up-KXOYO7QV.js}

@@ -25,7 +25,7 @@ async function up(positionals, values, cwd, brokerStatus) {
   } else out(`already logged in to ${url}`);
   const enabled = await (await import("./remote-3BWFISXJ.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
   if (enabled !== 0) return enabled;
-  const setup = (await import("./setup-T4ZZKV7K.js")).relaySetupCommand(["--write"], cwd, out);
+  const setup = (await import("./setup-RDPVGE4H.js")).relaySetupCommand(["--write"], cwd, out);
   if (setup !== 0) return setup;
   const broker = await brokerStatus();
   if (!broker.enabled) out(`the broker that was already running stays local-only until it exits (it stops when idle); the next one links to ${url}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scp-dev/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The swarm command line tool.",
   "license": "Apache-2.0",
   "homepage": "https://scp.dev",
@@ -24,10 +24,10 @@
     "typecheck": "tsc -p ."
   },
   "dependencies": {
-    "@scp-dev/core": "0.1.0",
-    "@scp-dev/broker": "0.1.0",
-    "@scp-dev/hub": "0.1.0",
-    "@scp-dev/mcp": "0.1.0",
+    "@scp-dev/core": "0.1.1",
+    "@scp-dev/broker": "0.1.1",
+    "@scp-dev/hub": "0.1.1",
+    "@scp-dev/mcp": "0.1.1",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {