@scp-dev/cli 0.2.3 → 0.3.0

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

@@ -1,18 +1,20 @@
 import {
+  CODEX_VALUED,
   codexMount,
-  codexOverrides
-} from "./chunk-IXCHAWOL.js";
+  codexOverrides,
+  toml
+} from "./chunk-3SHVJIXP.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-W3VNCRBX.js";
-import "./chunk-ZMVFN6MU.js";
-import "./chunk-X4ZLEM47.js";
+import "./chunk-2OSUVJ2J.js";
+import "./chunk-Q5UI4Z7H.js";
+import "./chunk-QRWQIHV6.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   RelayUsage,
   readPsTable,
   relayIdentity,
   startDaemon
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 import {
   SELF
 } from "./chunk-MNTIEWKF.js";
@@ -20,27 +22,30 @@ import {
 // src/codex.ts
 import { spawn } from "child_process";
 import { createHash, randomBytes } from "crypto";
-import { mkdtempSync, rmSync } from "fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
 import { connect } from "net";
-import { tmpdir } from "os";
+import { homedir, tmpdir } from "os";
 import { join } from "path";
 import { PassThrough } from "stream";
 import { setTimeout as sleep } from "timers/promises";
 import { connectBroker, relayDir } from "@scp-dev/broker";
 import { CLI_NAME, validHandle } from "@scp-dev/core";
 import { MCP_PROTOCOLS, runRelayMcp } from "@scp-dev/mcp";
+import { parse } from "smol-toml";
 var CODEX_HELP = `${CLI_NAME} codex [--name N | --as N] [--headless] [--resume THREAD] [--] [codex args...]
+  every codex argument, profile and config value is honoured; a -- after codex arguments is passed through.
   runs codex with relay messages waking an idle thread or steering a running turn; approvals stay with the TUI.
   --headless runs an ambient worker without a TUI; --resume THREAD reopens its thread.
   $SCP_CODEX_BIN picks the codex binary (default codex on PATH).`;
 function codexLaunch(args, env, _self) {
   let name;
+  let resume;
   let headless = false;
   const codexArgs = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--") {
-      codexArgs.push(...args.slice(i + 1));
+      codexArgs.push(...args.slice(codexArgs.length ? i : i + 1));
       break;
     }
     if (arg === "--name" || arg === "--as") {
@@ -48,6 +53,10 @@ function codexLaunch(args, env, _self) {
       if (name === void 0) throw new RelayUsage(`${CLI_NAME} codex ${arg} takes a name`);
     } else if (arg.startsWith("--name=") || arg.startsWith("--as=")) name = arg.slice(arg.indexOf("=") + 1);
     else if (arg === "--headless") headless = true;
+    else if (arg === "--resume") {
+      resume = args[++i];
+      if (resume === void 0) throw new RelayUsage(`${CLI_NAME} codex --resume takes a thread`);
+    } else if (arg.startsWith("--resume=")) resume = arg.slice("--resume=".length);
     else codexArgs.push(arg);
   }
   name = name?.replace(/^me\//, "");
@@ -56,7 +65,8 @@ function codexLaunch(args, env, _self) {
   return {
     ...name !== void 0 ? { name } : {},
     headless,
-    codexArgs,
+    ...resume !== void 0 ? { resume } : {},
+    codexArgs: resume !== void 0 && !headless ? ["resume", resume, ...codexArgs] : codexArgs,
     env: { ...clean, SCP_HARNESS: "codex", ...name !== void 0 ? { SCP_NAME: name } : {} }
   };
 }
@@ -314,18 +324,57 @@ function option(args, ...names) {
   }
   return value;
 }
-function serverOptions(args) {
-  const result = [];
-  const names = ["-c", "--config", "--enable", "--disable"];
+var SERVER_CONFIG = ["-c", "--config", "--enable", "--disable"];
+var SERVER_SETTINGS = {
+  "-m": "model",
+  "--model": "model",
+  "-s": "sandbox_mode",
+  "--sandbox": "sandbox_mode",
+  "-a": "approval_policy",
+  "--ask-for-approval": "approval_policy"
+};
+function leaves(value, path, out) {
+  if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+    for (const [key, child] of Object.entries(value)) leaves(child, [...path, key], out);
+  } else if (path.length) out.push("-c", `${path.join(".")}=${toml(value instanceof Date ? value.toISOString() : value)}`);
+}
+function serverOptions(args, env, warn = (line) => void process.stderr.write(`${line}
+`)) {
+  const profile = [];
+  const config = [];
+  const settings = [];
+  const set = (key, value) => settings.push("-c", `${key}=${toml(value)}`);
+  let conflict = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (names.includes(arg)) {
-      const value = args[++i];
-      if (value === void 0) throw new RelayUsage(`${CLI_NAME} codex ${arg} takes a value`);
-      result.push(arg, value);
-    } else if (names.some((name) => arg.startsWith(`${name}=`))) result.push(arg);
+    if (arg === "--") break;
+    const eq = arg.startsWith("--") ? arg.indexOf("=") : -1;
+    const flag = eq > 0 ? arg.slice(0, eq) : arg;
+    if (flag === "--strict-config") config.push(flag);
+    else if (flag === "--dangerously-bypass-approvals-and-sandbox" || flag === "--yolo") {
+      set("approval_policy", "never");
+      set("sandbox_mode", "danger-full-access");
+    }
+    if (!CODEX_VALUED.has(flag)) continue;
+    const value = eq > 0 ? arg.slice(eq + 1) : args[++i];
+    if (value === void 0) throw new RelayUsage(`${CLI_NAME} codex ${flag} takes a value`);
+    if (SERVER_CONFIG.includes(flag)) {
+      config.push(flag, value);
+      if (/^mcp_servers\.("scp"|scp)\./.test(value)) conflict = true;
+    } else if (flag === "-p" || flag === "--profile") {
+      const file = join(env.CODEX_HOME || join(env.HOME || homedir(), ".codex"), `${value}.config.toml`);
+      profile.length = 0;
+      if (existsSync(file)) {
+        try {
+          leaves(parse(readFileSync(file, "utf8")), [], profile);
+        } catch (error) {
+          warn(`${CLI_NAME} codex: could not read profile ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    } else if (SERVER_SETTINGS[flag]) set(SERVER_SETTINGS[flag], value);
   }
-  return result;
+  if (conflict) warn(`${CLI_NAME} codex: your -c mcp_servers.scp settings override the ones ${CLI_NAME} sets, so messages may not wake this session`);
+  return [...profile, ...config, ...settings];
 }
 async function terminate(child) {
   if (child.exitCode !== null || child.signalCode !== null || !child.pid) return;
@@ -350,8 +399,7 @@ function appServerPid(pid) {
   return pid;
 }
 async function codexCommand(args) {
-  const own = args.includes("--") ? args.slice(0, args.indexOf("--")) : args;
-  if (own.includes("--help") || own.includes("-h")) {
+  if (args[0] === "--help" || args[0] === "-h") {
     process.stdout.write(`${CODEX_HELP}
 `);
     return 0;
@@ -359,7 +407,7 @@ async function codexCommand(args) {
   const launch = codexLaunch(args, process.env, SELF);
   const cwd = process.cwd();
   const bin = launch.env.SCP_CODEX_BIN || "codex";
-  const overrides = [...codexOverrides(launch.env, codexMount(launch.env), SELF), ...serverOptions(launch.codexArgs)];
+  const overrides = [...codexOverrides(launch.env, codexMount(launch.env), SELF), ...serverOptions(launch.codexArgs, launch.env)];
   const dir = mkdtempSync(join(tmpdir(), "scp-codex-"));
   const path = join(dir, "app.sock");
   const server = spawn(bin, ["app-server", "--listen", `unix://${path}`, ...overrides], { env: launch.env, stdio: ["ignore", "ignore", "pipe"] });
@@ -448,7 +496,7 @@ ${stderr.toString().trim()}` : ""}`
     if (!socket || died) throw failure();
     let threadId;
     if (launch.headless) {
-      const resume = option(own, "--resume");
+      const resume = launch.resume;
       const model = option(launch.codexArgs, "-m", "--model");
       const sandbox = option(launch.codexArgs, "-s", "--sandbox");
       const result = await socket.request(resume ? "thread/resume" : "thread/start", {
@@ -562,5 +610,6 @@ export {
   CodexSocket,
   CodexWaker,
   codexCommand,
-  codexLaunch
+  codexLaunch,
+  serverOptions
 };

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

@@ -2,6 +2,7 @@ import {
   AGY_HOOK_SET,
   AGY_UNVERIFIED,
   BLOCK_STOP,
+  CLAUDE_CAPS,
   DIRECTIVE_CLOSE,
   HOOK_COMMAND,
   NO_INJECT,
@@ -15,6 +16,7 @@ import {
   WAKE,
   agyHookSet,
   claudeVersionFile,
+  fitText,
   hasOurHooks,
   hookEntries,
   hookReply,
@@ -38,16 +40,17 @@ import {
   tldrEvery,
   transcriptTitle,
   unreadPointer
-} from "./chunk-X4ZLEM47.js";
+} from "./chunk-QRWQIHV6.js";
 import {
   SUBAGENT
 } from "./chunk-YYSLYVNZ.js";
-import "./chunk-E7JG5PJB.js";
+import "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";
 export {
   AGY_HOOK_SET,
   AGY_UNVERIFIED,
   BLOCK_STOP,
+  CLAUDE_CAPS,
   DIRECTIVE_CLOSE,
   HOOK_COMMAND,
   NO_INJECT,
@@ -62,6 +65,7 @@ export {
   WAKE,
   agyHookSet,
   claudeVersionFile,
+  fitText,
   hasOurHooks,
   hookEntries,
   hookReply,

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

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

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

@@ -1,11 +1,12 @@
 import {
   RelayUsage,
+  harnessAt,
   localHandle,
   relayIdentity,
   sessionKey,
   startDaemon,
   walkNow
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/join.ts
@@ -27,6 +28,7 @@ async function joinCommand(values, positionals, cwd, out) {
     cwd,
     env: process.env,
     harnessPid: () => Number(match[1]),
+    inferHarness: (pid) => harnessAt(pid),
     startOf: () => match[2],
     lineageOf: () => keys.slice(Math.max(0, keys.indexOf(key)))
   });

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

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

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

@@ -15,7 +15,7 @@ import {
   stamp,
   startDaemon,
   time
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 import {
   FAILED,
   exitFlushed,
@@ -33,7 +33,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.2.3",
+  version: "0.3.0",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -137,6 +137,8 @@ usage:
   ${CLI_NAME} inbox [--wait S] [--keep]          your unread messages, then marked read (--keep leaves them unread); --wait waits up
                                                  to S seconds (max 50)
   ${CLI_NAME} ack <id|seq>... | --all            mark messages read, by message id or seq; --all marks every unread one
+  ${CLI_NAME} show <id>                          one message delivered to you, whole, read or not; it stays as it is (a hook
+                                                 shows a long message cut, ending in [truncated, N more chars: ${CLI_NAME} show <id>])
   An <id> is a message id, its short id (the last 6 characters, shown with every message) or any unique suffix of at least 4,
   or last: the newest message you were shown, refused while a newer one is unseen.
   ${CLI_NAME} ask <to> [text|-] [--wait S]       send a request and wait for its reply (default 50 s); --require-reply holds
@@ -236,6 +238,9 @@ scopes (selectors are comma-separated, e.g. tree:parent,tree:children,group:team
                                                  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} opencode [--name N] [--] [opencode args...]
+                                                 runs OpenCode with your own config and arguments, wake on: the plugin wakes an
+                                                 idle session, or opens one; refuses to start without the current plugin
   ${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
@@ -268,7 +273,7 @@ agent sessions:
   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
+  ${CLI_NAME} claude [--name N | --as 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>.
@@ -299,7 +304,8 @@ agent sessions:
 relay:
   ${CLI_NAME} relay use <url> | show            select a relay, or show its source and credential status
   ${CLI_NAME} login [--no-browser] [--token T] [--label NAME]   sign in through the browser, or save a token checked with the relay
-  ${CLI_NAME} up [--token T] [--machine NAME] [--no-browser]   log in if needed, link the broker to the hub, run setup --write
+  ${CLI_NAME} up [--token T] [--machine NAME] [--no-browser]   log in if needed, link the broker to the hub, run setup --write,
+                                                 then print the wake-enabled launch of each installed harness
   ${CLI_NAME} logout                             remove the stored credential for the active relay
   ${CLI_NAME} cloud enable [--machine NAME] | disable | status   link the local broker to the hub, or inspect its link
   ${CLI_NAME} machines [rm NAME]                 list the hub's machines, or release one
@@ -308,8 +314,8 @@ relay:
 
 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
+  ($SCP_HARNESS, default the harness this shell runs under, else cli), $SCP_LABELS (role=impl,lane=relay) and $SCP_PARENT. An offline
+  agent of the same handle and harness (or a generic one: cli, hook, mcp) is taken back with its inbox; a handle a live session holds is refused, never
   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
@@ -370,6 +376,7 @@ var VERBS = {
   inbox: [...IDENTITY, "wait", "ack", "keep"],
   reply: IDENTITY,
   ack: [...IDENTITY, "all"],
+  show: IDENTITY,
   ask: [...IDENTITY, "wait", "require-reply", "thread", "private", "attach"],
   "ask-wait": [...IDENTITY, "wait"],
   status: [...IDENTITY, "all", "activity"],
@@ -538,13 +545,14 @@ async function relayMain(argv, cwd = process.cwd()) {
     out(package_default.version);
     return 0;
   }
-  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 === "hook") return (await import("./hooks-B34E2HIP.js")).relayHookCommand(rest, startDaemon);
+  if (verb === "setup") return (await import("./setup-MGDWKCNU.js")).relaySetupCommand(rest, cwd, out);
+  if (verb === "claude") return (await import("./claude-EQVLST73.js")).claudeCommand(rest);
+  if (verb === "pi") return (await import("./pi-QEZVFDNR.js")).piCommand(rest);
+  if (verb === "codex") return (await import("./codex-5GZ7YPES.js")).codexCommand(rest);
+  if (verb === "opencode") return (await import("./opencode-ORLGNHWR.js")).opencodeCommand(rest, process.env, void 0, cwd);
   if (verb === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-BYU2X46L.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-GG7VFZA6.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -552,7 +560,7 @@ async function relayMain(argv, cwd = process.cwd()) {
     }
     return spawnCommand(rest, cwd);
   }
-  if (verb === "mesh") return (await import("./mesh-VNZV3POO.js")).meshCommand(rest);
+  if (verb === "mesh") return (await import("./mesh-H4KL5XAR.js")).meshCommand(rest);
   const allowed = VERBS[verb];
   if (!allowed) throw new RelayUsage(`unknown command "${verb}"`);
   let parsed;
@@ -572,11 +580,11 @@ async function relayMain(argv, cwd = process.cwd()) {
     return daemon(values.idle, values.policy);
   }
   if (verb === "mcp")
-    return (await import("./mcp-TUWMLGE4.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-TUXJ7LE7.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-FKGGPT6L.js")).installHooks({
+    return (await import("./install-6KXJY27V.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -587,26 +595,26 @@ async function relayMain(argv, cwd = process.cwd()) {
       out
     });
   }
-  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 === "relay") return (await import("./relay-QWJM372C.js")).relayVerb(positionals, values.json === true);
+  if (verb === "up") return (await import("./up-B2NEOOC6.js")).up(positionals, values, cwd, relinkBroker);
   if (verb === "login") {
-    const code = await (await import("./relay-U634RHIJ.js")).loginMain(positionals, values);
+    const code = await (await import("./relay-QWJM372C.js")).loginMain(positionals, values);
     if (code === 0) await relinkRunning();
     return code;
   }
-  if (verb === "logout") return (await import("./relay-U634RHIJ.js")).logoutMain(positionals, values.json === true);
+  if (verb === "logout") return (await import("./relay-QWJM372C.js")).logoutMain(positionals, values.json === true);
   if (verb === "cloud") {
-    const code = await (await import("./remote-NTHRHVEP.js")).cloudMain(positionals, values, cloudStatus);
+    const code = await (await import("./remote-P4GFUIAP.js")).cloudMain(positionals, values, cloudStatus);
     if (code === 0 && positionals[0] === "enable") await relinkRunning();
     return code;
   }
-  if (verb === "join") return (await import("./join-RGFHOSLE.js")).joinCommand(values, positionals, cwd, out);
+  if (verb === "join") return (await import("./join-FITJVZCA.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-NTHRHVEP.js")).machinesVerb(client, positionals, values.json === true);
+    if (verb === "machines") return await (await import("./remote-P4GFUIAP.js")).machinesVerb(client, positionals, values.json === true);
     return await runVerb(opened, verb, values, positionals, cwd);
   } finally {
     client.close();
@@ -783,9 +791,9 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       return 0;
     }
     case "peek":
-      return (await import("./peek-4D4VGKOW.js")).peekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-YTCWVPF7.js")).peekCommand(localClient(client, broker, verb), values, positionals);
     case "set-peek":
-      return (await import("./peek-4D4VGKOW.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-YTCWVPF7.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>`);
@@ -870,6 +878,18 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       if (!values.keep && messages.length) await client.request("ack", { seqs: messages.map((m) => m.seq) });
       return 0;
     }
+    case "show": {
+      if (positionals.length !== 1) throw new RelayUsage(`${CLI_NAME} show takes one message id`);
+      const message = await lookup(client, positionals[0]);
+      if (!message) throw new RelayUsage(`no message ${positionals[0]} was delivered to you`);
+      if (asJson) json({ preamble: PREAMBLE, message });
+      else {
+        out(PREAMBLE);
+        out();
+        printMessage(message);
+      }
+      return 0;
+    }
     case "ack": {
       const usage = `${CLI_NAME} ack takes message ids or seq numbers, or --all`;
       if (values.all ? positionals.length : !positionals.length) throw new RelayUsage(usage);
@@ -1383,11 +1403,11 @@ async function daemon(idle, policyFile) {
   });
   let broker;
   try {
-    const { daemonBridge } = await import("./remote-NTHRHVEP.js");
+    const { daemonBridge } = await import("./remote-P4GFUIAP.js");
     const bridge = await daemonBridge();
     broker = await startBroker({
       dir: relayDir(),
-      ...bridge ? { bridge } : await (await import("./mesh-VNZV3POO.js")).meshBrokerOptions(),
+      ...bridge ? { bridge } : await (await import("./mesh-H4KL5XAR.js")).meshBrokerOptions(),
       bridgeConfig: () => daemonBridge(),
       ...idleMs !== void 0 ? { idleMs } : {},
       ...policyFile ? { policyPath: resolve(policyFile) } : {}

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

@@ -1,22 +1,23 @@
 import {
   spawnDetached
-} from "./chunk-IXCHAWOL.js";
+} from "./chunk-3SHVJIXP.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-W3VNCRBX.js";
+import "./chunk-2OSUVJ2J.js";
 import {
   mcpInstall
-} from "./chunk-ZMVFN6MU.js";
-import "./chunk-X4ZLEM47.js";
+} from "./chunk-Q5UI4Z7H.js";
+import "./chunk-QRWQIHV6.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
   RelayUsage,
+  harnessAt,
   harnessPid,
   membership,
   psParent,
   relayIdentity,
   startDaemon
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/mcp.ts
@@ -37,7 +38,8 @@ async function relayMcpCommand(values, positionals) {
     fallbackHarness: "mcp",
     cwd: process.cwd(),
     env: process.env,
-    harnessPid: () => harnessPid()
+    harnessPid: () => harnessPid(),
+    inferHarness: (pid) => harnessAt(pid)
   });
   if (!validHandle(claim.handle)) throw new RelayUsage(`${JSON.stringify(claim.handle)} is not a valid agent handle (me, user and relay are reserved)`);
   const dir = relayDir();

package/dist/{mesh-VNZV3POO.js → mesh-H4KL5XAR.js}

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

package/dist/opencode-ORLGNHWR.js

@@ -0,0 +1,116 @@
+import {
+  mcpFile,
+  mountedEntry,
+  whichOnPath
+} from "./chunk-2OSUVJ2J.js";
+import {
+  hooksTarget
+} from "./chunk-Q5UI4Z7H.js";
+import {
+  opencodePlugin
+} from "./chunk-QRWQIHV6.js";
+import "./chunk-YYSLYVNZ.js";
+import {
+  RelayUsage,
+  gitToplevel
+} from "./chunk-2LIJXXTL.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/opencode.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { CLI_NAME, validHandle } from "@scp-dev/core";
+var OPENCODE_HELP = `${CLI_NAME} opencode [--name N | --as N] [--] [opencode args...]
+  runs OpenCode with your own config and arguments, wake on: the ${CLI_NAME} plugin wakes the session on a new message, and opens
+  one when none is open yet. Refuses to start without the current plugin; ${CLI_NAME} setup --write installs it.
+  $SCP_OPENCODE_BIN picks the opencode binary (default opencode on PATH).`;
+function opencodeLaunch(args, env, bin) {
+  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} opencode ${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: [bin, ...rest],
+    env: { ...env, SCP_HARNESS: "opencode", SCP_WAKE: "1", ...name !== void 0 ? { SCP_NAME: name } : {} }
+  };
+}
+function pluginState(env, cwd) {
+  const current = /* @__PURE__ */ new Set([opencodePlugin({ blockStop: false }), opencodePlugin({ blockStop: true })]);
+  const files = [hooksTarget("opencode", "project", env, cwd), hooksTarget("opencode", "user", env, cwd)].filter((file) => existsSync(file));
+  for (const file of files) {
+    try {
+      if (current.has(readFileSync(file, "utf8"))) return { file, current: true };
+    } catch {
+    }
+  }
+  return { ...files[0] ? { file: files[0] } : {}, current: false };
+}
+function pluginProblem(env, cwd) {
+  const plugin = pluginState(env, cwd);
+  if (plugin.current) return void 0;
+  const fix = `run ${CLI_NAME} setup --write (or ${CLI_NAME} hooks install --harness opencode --scope user --write)`;
+  return plugin.file ? `${CLI_NAME} opencode: ${plugin.file} is not this ${CLI_NAME}'s plugin, so wake is not guaranteed; ${fix}` : `${CLI_NAME} opencode: OpenCode has no ${CLI_NAME} plugin, so messages would not wake it; ${fix}`;
+}
+function opencodeMountHint(env, cwd) {
+  const project = gitToplevel(cwd) ?? cwd;
+  const files = [mcpFile("opencode", env), ...["opencode.json", "opencode.jsonc"].map((name) => join(project, name))];
+  for (const file of files) {
+    try {
+      if (existsSync(file) && mountedEntry("opencode", file)) return void 0;
+    } catch {
+    }
+  }
+  return `${CLI_NAME} opencode: OpenCode has no scp MCP mount, so the session has no relay tools; run ${CLI_NAME} setup --write`;
+}
+async function opencodeCommand(args, env = process.env, err = (line) => void process.stderr.write(`${line}
+`), cwd = process.cwd()) {
+  const own = args.includes("--") ? args.slice(0, args.indexOf("--")) : args;
+  if (own.includes("--help") || own.includes("-h")) {
+    process.stdout.write(`${OPENCODE_HELP}
+`);
+    return 0;
+  }
+  const bin = env.SCP_OPENCODE_BIN || whichOnPath("opencode", env);
+  if (!bin) throw new RelayUsage(`opencode is not on PATH: install it with npm i -g opencode-ai, then run ${CLI_NAME} setup --write`);
+  const launch = opencodeLaunch(args, env, bin);
+  const problem = pluginProblem(env, cwd);
+  if (problem) throw new RelayUsage(problem);
+  const hint = opencodeMountHint(env, cwd);
+  if (hint) err(hint);
+  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 {
+  OPENCODE_HELP,
+  opencodeCommand,
+  opencodeLaunch,
+  opencodeMountHint,
+  pluginProblem,
+  pluginState
+};

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

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