@scp-dev/cli 0.1.3 → 0.2.1

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

@@ -5,10 +5,14 @@ import {
   DIRECTIVE_CLOSE,
   HOOK_COMMAND,
   NO_INJECT,
+  OPENCODE_WAKE,
   PARENT_EXCEPTION,
   PUSH_WAIT,
   PUSH_WAIT_DEFAULT_S,
   REPLY_HOW,
+  TLDR,
+  TLDR_EVERY_DEFAULT,
+  WAKE,
   agyHookSet,
   claudeVersionFile,
   hasOurHooks,
@@ -21,6 +25,7 @@ import {
   musePlugin,
   nudgeText,
   opencodePlugin,
+  promptTitle,
   pushText,
   pushWait,
   relayHookCommand,
@@ -29,13 +34,16 @@ import {
   stopContinues,
   subagentIntro,
   summarize,
+  titleText,
+  tldrEvery,
+  transcriptTitle,
   unreadPointer
-} from "./chunk-ABR5UABL.js";
+} from "./chunk-HF4KP6AR.js";
 import {
   SUBAGENT
 } from "./chunk-YYSLYVNZ.js";
-import "./chunk-3PGDKPRN.js";
-import "./chunk-M2DCR2J4.js";
+import "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
 export {
   AGY_HOOK_SET,
   AGY_UNVERIFIED,
@@ -43,11 +51,15 @@ export {
   DIRECTIVE_CLOSE,
   HOOK_COMMAND,
   NO_INJECT,
+  OPENCODE_WAKE,
   PARENT_EXCEPTION,
   PUSH_WAIT,
   PUSH_WAIT_DEFAULT_S,
   REPLY_HOW,
   SUBAGENT,
+  TLDR,
+  TLDR_EVERY_DEFAULT,
+  WAKE,
   agyHookSet,
   claudeVersionFile,
   hasOurHooks,
@@ -60,6 +72,7 @@ export {
   musePlugin,
   nudgeText,
   opencodePlugin,
+  promptTitle,
   pushText,
   pushWait,
   relayHookCommand,
@@ -68,5 +81,8 @@ export {
   stopContinues,
   subagentIntro,
   summarize,
+  titleText,
+  tldrEvery,
+  transcriptTitle,
   unreadPointer
 };

package/dist/install-2ZM3IYXG.js

@@ -0,0 +1,14 @@
+import {
+  hooksTarget,
+  installHooks,
+  mcpInstall
+} from "./chunk-KC5AV5NQ.js";
+import "./chunk-HF4KP6AR.js";
+import "./chunk-YYSLYVNZ.js";
+import "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
+export {
+  hooksTarget,
+  installHooks,
+  mcpInstall
+};

package/dist/join-BH5CS6SL.js

@@ -0,0 +1,45 @@
+import {
+  RelayUsage,
+  localHandle,
+  relayIdentity,
+  sessionKey,
+  startDaemon,
+  walkNow
+} from "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/join.ts
+import { CLI_NAME } from "@scp-dev/core";
+import { connectBroker, readSessionMarker, relayDir } from "@scp-dev/broker";
+async function joinCommand(values, positionals, cwd, out) {
+  if (positionals.length > 1) throw new RelayUsage(`${CLI_NAME} join takes one handle, or none to keep the session's name`);
+  const handle = positionals[0] === void 0 ? void 0 : localHandle(positionals[0]);
+  const { keys, self } = walkNow();
+  const key = self.at(-1);
+  const match = key === void 0 ? null : /^pid:(\d+):(.+)$/.exec(key);
+  if (!match) throw new RelayUsage(`${CLI_NAME} join runs in an agent session's shell: no harness process runs this shell`);
+  const dir = relayDir();
+  const known = readSessionMarker(dir, sessionKey(process.env, key))?.handle;
+  const claim = relayIdentity({
+    ...known ? { as: known } : {},
+    ...typeof values.harness === "string" ? { harness: values.harness } : {},
+    fallbackHarness: "cli",
+    cwd,
+    env: process.env,
+    harnessPid: () => Number(match[1]),
+    startOf: () => match[2],
+    lineageOf: () => keys.slice(Math.max(0, keys.indexOf(key)))
+  });
+  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`);
+  } finally {
+    client.close();
+  }
+  return 0;
+}
+export {
+  joinCommand
+};

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

@@ -1,17 +1,14 @@
 import {
   machineName
-} from "./chunk-5UWLTO2Y.js";
+} from "./chunk-MXQ7B3CQ.js";
 import {
+  RelayUsage,
   activeRelay,
   saveCredential
-} from "./chunk-BUC5G5PY.js";
-import {
-  RelayUsage
-} from "./chunk-URSBFDR6.js";
-import "./chunk-3PGDKPRN.js";
+} from "./chunk-ZLL5EGI2.js";
 import {
   note
-} from "./chunk-M2DCR2J4.js";
+} from "./chunk-MNTIEWKF.js";
 
 // src/login.ts
 import { spawn } from "child_process";

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

@@ -11,20 +11,18 @@ import {
   open,
   preset,
   selectorList,
+  shortHostname,
   stamp,
   startDaemon,
   time
-} from "./chunk-URSBFDR6.js";
-import {
-  shortHostname
-} from "./chunk-3PGDKPRN.js";
+} from "./chunk-ZLL5EGI2.js";
 import {
   FAILED,
   exitFlushed,
   note,
   parseSeconds,
   printTable
-} from "./chunk-M2DCR2J4.js";
+} from "./chunk-MNTIEWKF.js";
 
 // src/main.ts
 import { text as readAll } from "stream/consumers";
@@ -35,7 +33,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.1.3",
+  version: "0.2.1",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -66,6 +64,8 @@ var package_default = {
     "smol-toml": "^1.9.1"
   },
   devDependencies: {
+    "@openai/codex": "0.159.0",
+    "opencode-ai": "1.18.34",
     tsup: "^8.5.1"
   },
   publishConfig: {
@@ -98,7 +98,8 @@ 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
+  ${CLI_NAME} list [--all]                agents on the relay: address, title, presence, 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} 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"
@@ -123,8 +124,10 @@ usage:
                                                  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
-  ${CLI_NAME} send <to> [text|-]                 send a message (- or no text reads stdin); a line per recipient says when it sees it
-        [--reply-to ID] [--thread ID] [--private] [--attach PATH]...   --thread takes a thread id or the <id> of a message in it
+  ${CLI_NAME} send <to> [text|-]                 send a message (- or no text reads stdin); a line per recipient says when it sees it,
+        [--reply-to ID] [--thread ID] [--private] [--attach PATH]... [--live]   and "queued: no live session holds <addr>" for one
+                                                 that is offline; --live refuses those (not_live) and queues nothing;
+                                                 --thread takes a thread id or the <id> of a message in it
   ${CLI_NAME} reply <id> [text|-]                reply to message <id>: to its sender, in its thread, marking it read; <id> may
                                                  also be another's message in a thread you sent or got a message in
   ${CLI_NAME} inbox [--wait S] [--keep]          your unread messages, then marked read (--keep leaves them unread); --wait waits up
@@ -225,6 +228,10 @@ 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
+                                                 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
   ${CLI_NAME} peers [--all] [--roots]            who you may message: title, status and the rule that admits each; offline ones and
                                                  sessions nobody spawned that spawned nobody only with --all (--roots: those sessions)
   ${CLI_NAME} why <from> <to>                    whether from may message to, and why
@@ -260,6 +267,19 @@ agent sessions:
   ${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.
+  Without --name, ${CLI_NAME} claude asks the session to pick its own name with ${CLI_NAME} name <name>.
+  ${CLI_NAME} join [<handle>]                    put the session that runs this shell on the relay (it then shows in list,
+                                                 peers can message it, and its hooks hand it new messages), named <handle>
+                                                 when given; on a joined session it renames it in place. Works for a session
+                                                 started before the hooks were installed too. Tell any session: ${CLI_NAME} join <name>
+  ${CLI_NAME} name [<handle>] [--endpoint EP]    print this session's address, or rename it in place: id, mail, threads, status
+                                                 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} 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
+  hooked session when it starts.
 
 relay:
   ${CLI_NAME} relay use <url> | show            select a relay, or show its source and credential status
@@ -275,7 +295,8 @@ identity:
   --as HANDLE (or --as=HANDLE, anywhere on the line, or $SCP_NAME, a local handle; a leading me/ is dropped) acts as that agent, with --harness H
   ($SCP_HARNESS, default cli), $SCP_LABELS (role=impl,lane=relay) and $SCP_PARENT. An offline
   agent of the same handle and harness is taken back with its inbox; a handle a live session holds is refused, never
-  renamed. Run from that agent's own process, it acts as the agent, narrowing only.
+  suffixed. Run from that agent's own process, it acts as the agent, narrowing only. A session renamed with join or
+  name keeps its new handle: its hooks, its shim and commands with $SCP_NAME from its shell claim that one.
   Without --as, at a terminal or with --human you are your own human inbox (me/); messages sent with --human and no
   terminal are marked tty="false" and get no scope exemption. From an agent's process, --human acts as that agent.
   Without either and without a terminal, a command acts as the agent whose harness process runs this shell (the
@@ -325,7 +346,10 @@ var VERB_OPTIONS = {
 var IDENTITY = ["as", "harness", "human", "json", "cloud", "machine"];
 var VERBS = {
   list: [...IDENTITY, "all", "tree", "roots", "contacts"],
-  send: [...IDENTITY, "reply-to", "thread", "private", "attach"],
+  send: [...IDENTITY, "reply-to", "thread", "private", "attach", "live"],
+  join: ["harness", "json"],
+  leave: [...IDENTITY, "endpoint"],
+  name: [...IDENTITY, "endpoint"],
   inbox: [...IDENTITY, "wait", "ack", "keep"],
   reply: IDENTITY,
   ack: [...IDENTITY, "all"],
@@ -496,11 +520,13 @@ async function relayMain(argv, cwd = process.cwd()) {
     out(package_default.version);
     return 0;
   }
-  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 === "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 === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-KT5235WX.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-V66GYUNC.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -527,11 +553,11 @@ async function relayMain(argv, cwd = process.cwd()) {
     return daemon(values.idle, values.policy);
   }
   if (verb === "mcp")
-    return (await import("./mcp-GI5OMTUT.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-RXAVQBMP.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-4KQQWGGB.js")).installHooks({
+    return (await import("./install-2ZM3IYXG.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -542,25 +568,26 @@ async function relayMain(argv, cwd = process.cwd()) {
       out
     });
   }
-  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 === "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 === "login") {
-    const code = await (await import("./relay-W2NFUE2U.js")).loginMain(positionals, values);
+    const code = await (await import("./relay-QDX2BNZH.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 === "logout") return (await import("./relay-QDX2BNZH.js")).logoutMain(positionals, values.json === true);
   if (verb === "cloud") {
-    const code = await (await import("./remote-GC4XN44U.js")).cloudMain(positionals, values, cloudStatus);
+    const code = await (await import("./remote-2OWBWLJH.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 === "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-GC4XN44U.js")).machinesVerb(client, positionals, values.json === true);
+    if (verb === "machines") return await (await import("./remote-2OWBWLJH.js")).machinesVerb(client, positionals, values.json === true);
     return await runVerb(opened, verb, values, positionals, cwd);
   } finally {
     client.close();
@@ -591,7 +618,7 @@ async function relinkBroker() {
     client.close();
   }
   if (!result.restarting) return result;
-  await (await import("./daemon-SUTLTY5U.js")).exited(pid);
+  await (await import("./daemon-OMJY7T2F.js")).exited(pid);
   return cloudStatus();
 }
 async function relinkRunning() {
@@ -611,7 +638,7 @@ async function daemonControl(positionals, values) {
   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);
+  const pid = await (await import("./daemon-OMJY7T2F.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;
@@ -737,9 +764,9 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       return 0;
     }
     case "peek":
-      return (await import("./peek-X4SEGEUB.js")).peekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-M2HQVO4O.js")).peekCommand(localClient(client, broker, verb), values, positionals);
     case "set-peek":
-      return (await import("./peek-X4SEGEUB.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-M2HQVO4O.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>`);
@@ -765,13 +792,13 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
         ...attachments.length ? { attachments } : {}
       };
       if (verb === "send") {
-        const result2 = await client.request("send", params);
+        const result2 = await client.request("send", { ...params, ...values.live ? { live: true } : {} });
         if (asJson) json(result2);
         else if (result2.held) out(heldText(result2.held));
         else {
           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}`);
+          for (const line of [...lines, ...result2.warnings ?? []]) 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`);
         }
@@ -940,6 +967,30 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       else out(`${view.address}: ${view.status ? statusText(view.status) : "-"}`);
       return 0;
     }
+    case "name": {
+      if (positionals.length > 1) throw new RelayUsage(`${CLI_NAME} name takes one handle, or none to print your address`);
+      const endpoint = values.endpoint;
+      if (!positionals.length) {
+        if (endpoint !== void 0) throw new RelayUsage(`${CLI_NAME} name --endpoint EP takes the new handle`);
+        if (me?.kind !== "agent") throw new RelayUsage(`${CLI_NAME} name: this shell is no joined session; ${CLI_NAME} join <name> joins it`);
+        if (asJson) json({ address: me.address });
+        else out(me.address);
+        return 0;
+      }
+      const before = endpoint ?? me?.address;
+      const view = await client.request("rename", { handle: positionals[0], ...endpoint !== void 0 ? { endpoint } : {} });
+      if (asJson) json(view);
+      else out(before && before !== view.address ? `${before} is now ${view.address}` : `${view.address}`);
+      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;
+      const view = await client.request("leave", endpoint !== void 0 ? { endpoint } : {});
+      if (asJson) json(view);
+      else out(`${view.address} left the relay: offline, no messages pushed; its mail is kept until ${CLI_NAME} join`);
+      return 0;
+    }
     case "set-title": {
       if (!positionals.length) throw new RelayUsage(`${CLI_NAME} set-title takes the title text ("" clears it)`);
       const view = await client.request("title", { text: positionals.join(" ") });
@@ -1292,7 +1343,7 @@ async function daemon(idle, policyFile) {
   });
   let broker;
   try {
-    const { daemonBridge } = await import("./remote-GC4XN44U.js");
+    const { daemonBridge } = await import("./remote-2OWBWLJH.js");
     const bridge = await daemonBridge();
     broker = await startBroker({
       dir: relayDir(),

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

@@ -1,24 +1,23 @@
 import {
   spawnDetached
-} from "./chunk-ABP5AKFH.js";
+} from "./chunk-25ZVL5LD.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-IH2RJRIW.js";
+import "./chunk-NJLFHBSS.js";
 import {
   mcpInstall
-} from "./chunk-QQZF5TQD.js";
+} from "./chunk-KC5AV5NQ.js";
+import "./chunk-HF4KP6AR.js";
+import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
   RelayUsage,
-  startDaemon
-} from "./chunk-URSBFDR6.js";
-import "./chunk-ABR5UABL.js";
-import "./chunk-YYSLYVNZ.js";
-import {
   harnessPid,
+  membership,
   psParent,
-  relayIdentity
-} from "./chunk-3PGDKPRN.js";
-import "./chunk-M2DCR2J4.js";
+  relayIdentity,
+  startDaemon
+} from "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
 
 // src/mcp.ts
 import { CLI_NAME, validHandle } from "@scp-dev/core";
@@ -45,6 +44,7 @@ async function relayMcpCommand(values, positionals) {
   await runRelayMcp({
     connect: () => connectBroker(dir, () => startDaemon(dir)),
     claim,
+    membership: () => membership(process.env, claim.session),
     input: process.stdin,
     output: (line) => void process.stdout.write(line),
     env: process.env,

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

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

package/dist/pi-IAVFVOOO.js

@@ -0,0 +1,71 @@
+import {
+  RelayUsage
+} from "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/pi.ts
+import { spawn } from "child_process";
+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.
+  $SCP_PI_BIN picks the pi binary (default pi on PATH), $SCP_PI_EXTENSION the extension file.`;
+function piLaunch(args, env, extension) {
+  let name;
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      rest.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg === "--name" || arg === "--as") {
+      name = args[++i];
+      if (name === void 0) throw new RelayUsage(`${CLI_NAME} pi ${arg} takes a name`);
+    } else if (arg.startsWith("--name=") || arg.startsWith("--as=")) name = arg.slice(arg.indexOf("=") + 1);
+    else rest.push(arg);
+  }
+  name = name?.replace(/^me\//, "");
+  if (name !== void 0 && !validHandle(name)) throw new RelayUsage(`${JSON.stringify(name)} is not a valid agent handle`);
+  return {
+    argv: [env.SCP_PI_BIN || "pi", "--extension", extension, ...rest],
+    env: { ...env, SCP_HARNESS: "pi", ...name !== void 0 ? { SCP_NAME: name } : {} }
+  };
+}
+function extensionPath(env) {
+  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`);
+  }
+}
+async function piCommand(args) {
+  const own = args.includes("--") ? args.slice(0, args.indexOf("--")) : args;
+  if (own.includes("--help") || own.includes("-h")) {
+    process.stdout.write(`${PI_HELP}
+`);
+    return 0;
+  }
+  const launch = piLaunch(args, process.env, extensionPath(process.env));
+  return await new Promise((resolve, reject) => {
+    const child = spawn(launch.argv[0], launch.argv.slice(1), { env: launch.env, stdio: "inherit" });
+    const forward = (signal) => child.kill(signal);
+    const signals = ["SIGTERM", "SIGHUP"];
+    const ignore = () => {
+    };
+    for (const signal of signals) process.on(signal, forward);
+    process.on("SIGINT", ignore);
+    child.once("error", (error) => reject(new RelayUsage(`could not start ${launch.argv[0]}: ${error.message}`)));
+    child.once("exit", (code, signal) => {
+      for (const each of signals) process.off(each, forward);
+      process.off("SIGINT", ignore);
+      resolve(code ?? (signal ? 1 : 0));
+    });
+  });
+}
+export {
+  PI_HELP,
+  piCommand,
+  piLaunch
+};

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

@@ -3,6 +3,7 @@ import {
   activeRelay,
   checkRelayUrl,
   configDir,
+  joinMode,
   loginMain,
   logoutMain,
   readCredentials,
@@ -10,16 +11,16 @@ import {
   relayVerb,
   removeCredential,
   saveCredential,
+  setJoinMode,
   writePrivateJson
-} from "./chunk-BUC5G5PY.js";
-import "./chunk-URSBFDR6.js";
-import "./chunk-3PGDKPRN.js";
-import "./chunk-M2DCR2J4.js";
+} from "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
 export {
   DEFAULT_RELAY,
   activeRelay,
   checkRelayUrl,
   configDir,
+  joinMode,
   loginMain,
   logoutMain,
   readCredentials,
@@ -27,5 +28,6 @@ export {
   relayVerb,
   removeCredential,
   saveCredential,
+  setJoinMode,
   writePrivateJson
 };

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

@@ -9,11 +9,9 @@ import {
   machinesVerb,
   openCloud,
   readCloudFile
-} from "./chunk-5UWLTO2Y.js";
-import "./chunk-BUC5G5PY.js";
-import "./chunk-URSBFDR6.js";
-import "./chunk-3PGDKPRN.js";
-import "./chunk-M2DCR2J4.js";
+} from "./chunk-MXQ7B3CQ.js";
+import "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
 export {
   CloudRelayClient,
   CloudUsage,

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

@@ -15,13 +15,12 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-IH2RJRIW.js";
-import "./chunk-QQZF5TQD.js";
-import "./chunk-URSBFDR6.js";
-import "./chunk-ABR5UABL.js";
+} from "./chunk-NJLFHBSS.js";
+import "./chunk-KC5AV5NQ.js";
+import "./chunk-HF4KP6AR.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-3PGDKPRN.js";
-import "./chunk-M2DCR2J4.js";
+import "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
 export {
   SETUP_HARNESSES,
   SETUP_HELP,

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

@@ -29,17 +29,16 @@ import {
   steerArgv,
   transcriptReplies,
   workerName
-} from "./chunk-ABP5AKFH.js";
+} from "./chunk-25ZVL5LD.js";
 import {
   SPAWN_HELP
 } from "./chunk-KN7WEIE4.js";
-import "./chunk-IH2RJRIW.js";
-import "./chunk-QQZF5TQD.js";
-import "./chunk-URSBFDR6.js";
-import "./chunk-ABR5UABL.js";
+import "./chunk-NJLFHBSS.js";
+import "./chunk-KC5AV5NQ.js";
+import "./chunk-HF4KP6AR.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-3PGDKPRN.js";
-import "./chunk-M2DCR2J4.js";
+import "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
 export {
   MESSAGING,
   SPAWN_HELP,