@scp-dev/cli 0.2.4 → 0.3.0

package/dist/{chunk-E7JG5PJB.js → chunk-2LIJXXTL.js}

@@ -23,7 +23,7 @@ import { existsSync, realpathSync } from "fs";
 import { tmpdir } from "os";
 import { basename, dirname, isAbsolute, join, resolve } from "path";
 import { shortHostname } from "@scp-dev/broker";
-import { LIMITS, validHandle, validHarness } from "@scp-dev/core";
+import { GENERIC_HARNESSES, LIMITS, validHandle, validHarness } from "@scp-dev/core";
 var SHORT = { "claude-code": "claude" };
 var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "fish"]);
 var LABEL_KEY = /^[a-z0-9][a-z0-9._-]{0,31}$/;
@@ -156,6 +156,42 @@ function command(args) {
   return basename(args.split(/\s+/)[0].replace(/^-/, "")).toLowerCase();
 }
 var namesHarness = (words) => words.some((word) => !word.startsWith("-") && word.split("/").some((part) => HARNESSES.has(part.toLowerCase().replace(/\..*$/, ""))));
+var HARNESS_IDS = /* @__PURE__ */ new Map([
+  ["claude", "claude-code"],
+  ["claude-code", "claude-code"],
+  ["codex", "codex"],
+  ["opencode", "opencode"],
+  ["opencode-ai", "opencode"],
+  ["grok", "grok"],
+  ["grok-cli", "grok"],
+  ["muse", "muse"],
+  ["agy", "agy"],
+  ["antigravity", "agy"],
+  ["gemini", "gemini"],
+  ["gemini-cli", "gemini"],
+  ["pi", "pi"],
+  ["pi-coding-agent", "pi"]
+]);
+var harnessId = (name) => HARNESS_IDS.get(name.toLowerCase().replace(/\..*$/, ""));
+function harnessOf(args) {
+  if (!args) return void 0;
+  const name = command(args);
+  const own = harnessId(name);
+  if (own) return own;
+  if (!INTERPRETERS.has(name) && !RUNNERS.has(name) && !FETCHERS.has(name) && !/^python[0-9.]*$/.test(name)) return void 0;
+  for (const word of args.split(/\s+/).slice(1)) {
+    if (word.startsWith("-")) continue;
+    for (const part of word.split("/").reverse()) {
+      const id = part === "pi" ? void 0 : harnessId(part);
+      if (id) return id;
+    }
+  }
+  return void 0;
+}
+var inferring = (env) => env.SCP_HARNESS_DETECT !== "0";
+function harnessAt(pid, table = readPsTable()) {
+  return inferring(process.env) ? harnessOf(table?.get(pid)?.args) : void 0;
+}
 var roots;
 function workspaceRoots() {
   if (roots) return roots;
@@ -284,10 +320,11 @@ function hookHarnessPid(env, harness, ppid = process.ppid, parentOf = psParent)
   return harnessPid(ppid, parentOf);
 }
 function relayIdentity(input) {
-  const harness = resolveHarness(input.harness, input.env, input.fallbackHarness);
+  const resolved = resolveHarness(input.harness, input.env, input.fallbackHarness);
+  const pid = input.harnessPid(resolved);
+  const harness = GENERIC_HARNESSES.has(resolved) && input.inferHarness?.(pid) || resolved;
   const cwd = isAbsolute(input.cwd) ? input.cwd : resolve(input.cwd);
   const handle = input.as ?? input.env.SCP_NAME ?? deriveHandle(harness, cwd);
-  const pid = input.harnessPid(harness);
   const harnessProcess = processKey(pid, input.startOf);
   const keys = input.lineageOf ? input.lineageOf(pid) : lineage(pid);
   return {
@@ -464,7 +501,12 @@ function localHandle(raw) {
 }
 function walkNow() {
   const table = readPsTable();
-  return { keys: lineage(process.ppid, table), self: harnessLineage(process.ppid, table) };
+  const self = harnessLineage(process.ppid, table);
+  const harness = self.length ? harnessAt(Number(/^pid:(\d+)/.exec(self.at(-1))?.[1]), table) : void 0;
+  return { keys: lineage(process.ppid, table), self, ...harness ? { harness } : {} };
+}
+function claimHarness(values, env, walk) {
+  return values.harness ?? env.SCP_HARNESS ?? (inferring(env) ? walk?.harness ?? detectHarness(env) : void 0) ?? "cli";
 }
 async function open(verb, values, cwd, bodyFromStdin, walk) {
   const named = values.as ?? process.env.SCP_NAME;
@@ -487,11 +529,11 @@ async function open(verb, values, cwd, bodyFromStdin, walk) {
         `${CLI_NAME2} ${verb} needs an identity: --as HANDLE (or $SCP_NAME) for an agent, or --human for your own inbox me/ (no terminal is attached, so me/ is not assumed)`
       );
     }
-    const { machineName, openCloud } = await import("./remote-NTHRHVEP.js");
+    const { machineName, openCloud } = await import("./remote-P4GFUIAP.js");
     const handle2 = named ? localHandle(named) : void 0;
     const claim = handle2 ? {
       handle: handle2,
-      harness: values.harness ?? process.env.SCP_HARNESS ?? "cli",
+      harness: claimHarness(values, process.env, walk ?? walkNow()),
       cwd,
       ...process.env.SCP_PARENT ? { parent: process.env.SCP_PARENT } : {},
       labels: labelsFor(process.env, machineName(values.machine))
@@ -510,7 +552,8 @@ async function open(verb, values, cwd, bodyFromStdin, walk) {
     };
   }
   if (values.machine !== void 0) throw new RelayUsage("--machine names the machine of the cloud transport: add --cloud");
-  const { keys, self } = walk ?? walkNow();
+  const here = walk ?? walkNow();
+  const { keys, self } = here;
   const joined = !values.as && named && self.length ? membership(process.env, sessionKey(process.env, self.at(-1))) : {};
   const handle = "handle" in joined && joined.handle ? joined.handle : named ? localHandle(named) : void 0;
   const harnessPid2 = self.length ? Number(/^pid:(\d+)/.exec(self.at(-1))?.[1]) : void 0;
@@ -526,7 +569,7 @@ async function open(verb, values, cwd, bodyFromStdin, walk) {
         claim: {
           handle,
           exact: true,
-          harness: values.harness ?? process.env.SCP_HARNESS ?? "cli",
+          harness: claimHarness(values, process.env, here),
           cwd,
           ...process.env.SCP_PARENT ? { parent: process.env.SCP_PARENT } : {},
           labels: labelsFor(process.env),
@@ -744,7 +787,7 @@ function relayVerb(positionals, asJson, env = process.env) {
 }
 async function loginMain(positionals, values) {
   if (positionals.length) throw new RelayUsage(`${CLI_NAME3} login takes only flags`);
-  return (await import("./login-IPS75GLQ.js")).login(values);
+  return (await import("./login-AUMLI4FS.js")).login(values);
 }
 function logoutMain(positionals, asJson, env = process.env) {
   if (positionals.length) throw new RelayUsage(`${CLI_NAME3} logout takes no arguments`);
@@ -767,6 +810,7 @@ export {
   sessionKey,
   psStart,
   readPsTable,
+  harnessAt,
   spawnerKey,
   psParent,
   harnessPid,

package/dist/{chunk-W3VNCRBX.js → chunk-2OSUVJ2J.js}

@@ -1,6 +1,6 @@
 import {
   hooksTarget
-} from "./chunk-ZMVFN6MU.js";
+} from "./chunk-Q5UI4Z7H.js";
 import {
   AGY_HOOK_SET,
   BLOCK_STOP,
@@ -12,12 +12,12 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-X4ZLEM47.js";
+} from "./chunk-QRWQIHV6.js";
 import {
   RelayUsage,
   gitToplevel,
   setJoinMode
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 
 // src/setup.ts
 import { spawnSync } from "child_process";

package/dist/{chunk-IXCHAWOL.js → chunk-3SHVJIXP.js}

@@ -3,10 +3,10 @@ import {
   agySettingsFile,
   mcpFile,
   mountedEntry
-} from "./chunk-W3VNCRBX.js";
+} from "./chunk-2OSUVJ2J.js";
 import {
   steerPrompt
-} from "./chunk-X4ZLEM47.js";
+} from "./chunk-QRWQIHV6.js";
 import {
   OPTIONS,
   RelayUsage,
@@ -18,7 +18,7 @@ import {
   selectorList,
   spawnerKey,
   walkNow
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 import {
   SELF,
   note
@@ -918,7 +918,9 @@ export {
   SPAWN_RUNNER,
   spawnEnvironment,
   codexMount,
+  toml,
   codexOverrides,
+  CODEX_VALUED,
   codexOverrideAt,
   programAt,
   MESSAGING,

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

@@ -5,7 +5,7 @@ import {
   configDir,
   relayCredential,
   writePrivateJson
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 import {
   note,
   printTable
@@ -150,13 +150,15 @@ function readCloudFile(path, env = process.env) {
   }
   if (value.redact !== void 0 && typeof value.redact !== "boolean") throw new Error(`${path}: redact is true or false`);
   if (value.private_ok !== void 0 && typeof value.private_ok !== "boolean") throw new Error(`${path}: private_ok is true or false`);
+  if (value.mirror_local !== void 0 && typeof value.mirror_local !== "boolean") throw new Error(`${path}: mirror_local is true or false`);
   return {
     bridge: true,
     machine: value.machine,
     url,
     ...value.mirror ? { mirror: value.mirror } : {},
     ...value.redact !== void 0 ? { redact: value.redact } : {},
-    ...value.private_ok !== void 0 ? { private_ok: value.private_ok } : {}
+    ...value.private_ok !== void 0 ? { private_ok: value.private_ok } : {},
+    ...value.mirror_local !== void 0 ? { mirror_local: value.mirror_local } : {}
   };
 }
 async function daemonBridge(env = process.env, log = console.error) {
@@ -184,7 +186,8 @@ async function daemonBridge(env = process.env, log = console.error) {
     machine: file.machine,
     mirror: file.mirror,
     redact: file.redact,
-    privateOk: file.private_ok
+    privateOk: file.private_ok,
+    mirrorLocal: file.mirror_local
   };
 }
 async function cloudMain(positionals, values, brokerStatus) {

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

@@ -10,11 +10,11 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-X4ZLEM47.js";
+} from "./chunk-QRWQIHV6.js";
 import {
   RelayUsage,
   gitToplevel
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 
 // src/install.ts
 import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";

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

@@ -4,6 +4,7 @@ import {
   readCapped
 } from "./chunk-YYSLYVNZ.js";
 import {
+  harnessAt,
   hookHarness,
   hookHarnessPid,
   membership,
@@ -12,7 +13,7 @@ import {
   psStart,
   relayIdentity,
   sessionKey
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 
 // src/hooks.ts
 import { Readable } from "stream";
@@ -354,9 +355,44 @@ function launchedSubagent(harness, event, payload) {
   const title = titleText(asString(input.description));
   return id && title && /^[A-Za-z0-9_-]{1,64}$/.test(id) ? { id, title } : void 0;
 }
-function hookReply(harness, kind, text, unread = 0, continues = true) {
-  if (kind === "stop" && harness === "claude-code" && continues)
-    return JSON.stringify({ hookSpecificOutput: { hookEventName: "Stop", additionalContext: text } });
+var CLAUDE_CAPS = { context: { chars: 8e3, lines: 200 }, reason: { chars: 2e3, lines: 20 } };
+var MARKER_ROOM = 80;
+var BLOCK = /(<relay-message [^>]*?\bshort="([^"]*)"[^>]*>\n)([\s\S]*?)(\n<\/relay-message>)/g;
+var cutAt = (text, chars) => text.slice(0, chars > 0 && /[\ud800-\udbff]/.test(text[chars - 1] ?? "") ? chars - 1 : chars);
+function fitText(text, cap2) {
+  const parts = [];
+  let at = 0;
+  for (const match of text.matchAll(BLOCK)) {
+    parts.push(text.slice(at, match.index) + match[1], { short: match[2], body: match[3], chars: match[3].length, lines: match[3].split("\n").length });
+    at = match.index + match[0].length - match[4].length;
+  }
+  parts.push(text.slice(at));
+  const blocks = parts.filter((part) => typeof part !== "string");
+  const render = () => parts.map((part) => {
+    if (typeof part === "string") return part;
+    if (part.chars >= part.body.length && part.lines >= part.body.split("\n").length) return part.body;
+    const head = cutAt(part.body.split("\n").slice(0, part.lines).join("\n"), part.chars).trimEnd();
+    const marker = `[truncated, ${part.body.length - head.length} more chars: ${CLI_NAME} show ${part.short}]`;
+    return head ? `${head}
+${marker}` : marker;
+  }).join("");
+  for (let i = blocks.length - 1, rendered = render(); ; rendered = render()) {
+    const chars = rendered.length - cap2.chars;
+    const lines = rendered.split("\n").length - cap2.lines;
+    if (chars <= 0 && lines <= 0) return rendered;
+    while (i >= 0 && blocks[i].chars === 0 && blocks[i].lines === 0) i--;
+    if (i < 0) return rendered;
+    const block = blocks[i];
+    if (chars > 0) block.chars = Math.max(0, Math.min(block.chars, block.body.length) - chars - MARKER_ROOM);
+    if (lines > 0) block.lines = Math.max(0, Math.min(block.lines, block.body.split("\n").length) - lines - 1);
+    if (chars <= 0 && block.lines === 0) block.chars = 0;
+    if (lines <= 0 && block.chars === 0) block.lines = 0;
+  }
+}
+function hookReply(harness, kind, raw, unread = 0, continues = true) {
+  const claude = harness === "claude-code";
+  const text = claude ? fitText(raw, kind === "stop" && !continues ? CLAUDE_CAPS.reason : CLAUDE_CAPS.context) : raw;
+  if (kind === "stop" && claude && continues) return JSON.stringify({ hookSpecificOutput: { hookEventName: "Stop", additionalContext: text } });
   if (kind === "stop")
     return JSON.stringify(
       harness === "agy" ? { decision: "continue", reason: text } : { decision: "block", reason: text, ...harness === "opencode" ? { unread } : {} }
@@ -416,6 +452,7 @@ async function runHook(args, options) {
     cwd: event.cwd ?? options.cwd,
     env: options.env,
     harnessPid: () => pid,
+    ...options.harnessPid ? {} : { inferHarness: (at) => harnessAt(at) },
     startOf: () => started
   });
   if (!validHandle(claim.handle)) return;
@@ -513,7 +550,8 @@ async function wakeHook(harnessArg, payload, waitS, options) {
     fallbackHarness: "hook",
     cwd: asString(payload.cwd) ?? options.cwd,
     env: options.env,
-    harnessPid: options.harnessPid ?? ((harness) => hookHarnessPid(options.env, harness))
+    harnessPid: options.harnessPid ?? ((harness) => hookHarnessPid(options.env, harness)),
+    ...options.harnessPid ? {} : { inferHarness: (at) => harnessAt(at) }
   });
   if (!validHandle(claim.handle)) return;
   const waitMs = Math.min(waitS, LIMITS.waitMaxS) * 1e3;
@@ -729,6 +767,8 @@ function opencodePlugin(options = {}) {
 import { spawn } from "node:child_process"
 import { text as readAll } from "node:stream/consumers"
 const BLOCK_STOP = ${options.blockStop === true}
+/** before a session exists, the waiter starts this long after load, so a session opened at launch claims the first message */
+const STARTUP_MS = 3000
 
 type Reply = { hookSpecificOutput?: { additionalContext?: unknown }; decision?: unknown; reason?: unknown }
 
@@ -775,6 +815,7 @@ export const Scp = async ({ client, directory }: { client: any; directory: strin
   const WAKE = process.env.SCP_WAKE !== "0"
   const busy = new Set<string>()
   let target: string | undefined
+  let fresh = true
   let waiter: ReturnType<typeof spawn> | undefined
   let looping = false
   let armed = 0
@@ -784,7 +825,7 @@ export const Scp = async ({ client, directory }: { client: any; directory: strin
     looping = true
     let version = armed
     try {
-      while (WAKE && target && busy.size === 0) {
+      while (WAKE && busy.size === 0 && (target || fresh)) {
         const id = target
         const began = Date.now()
         let text: string | undefined
@@ -797,7 +838,7 @@ export const Scp = async ({ client, directory }: { client: any; directory: strin
             child.once("close", () => resolve())
           })
           child.stdin!.on("error", () => {})
-          child.stdin!.end(JSON.stringify({ hook_event_name: "Wake", session_id: id, cwd: directory }))
+          child.stdin!.end(JSON.stringify({ hook_event_name: "Wake", ...(id ? { session_id: id } : {}), cwd: directory }))
           const [output] = await Promise.all([readAll(child.stdout!), ended])
           text = output.trim() ? context(JSON.parse(output) as Reply) : undefined
         } catch {} finally {
@@ -805,7 +846,8 @@ export const Scp = async ({ client, directory }: { client: any; directory: strin
         }
         if (text) {
           version = armed
-          await client.session.promptAsync({ path: { id }, body: { parts: [{ type: "text", text }] } }).catch(() => {})
+          const into = target ?? (await client.session.create({ body: {} }).then((made: any) => made?.data?.id).catch(() => undefined))
+          if (into) await client.session.promptAsync({ path: { id: into }, body: { parts: [{ type: "text", text }] } }).catch(() => {})
           break
         }
         if (Date.now() - began < 2000) await new Promise((resolve) => setTimeout(resolve, 5000))
@@ -817,6 +859,7 @@ export const Scp = async ({ client, directory }: { client: any; directory: strin
   }
   const arm = (id: string) => {
     target = id
+    fresh = false
     armed++
     void wake()
   }
@@ -835,6 +878,9 @@ export const Scp = async ({ client, directory }: { client: any; directory: strin
     if (child === undefined && children.get(id) === known) children.delete(id)
     return child === true
   }
+  setTimeout(() => {
+    if (fresh && busy.size === 0) void wake()
+  }, STARTUP_MS).unref?.()
   return {
     "tool.execute.after": async (input: { tool: string; sessionID: string; args?: unknown }, output: { output?: unknown }) => {
       const payload = { hook_event_name: "PostToolUse", session_id: input.sessionID, cwd: directory, tool_name: input.tool, tool_input: input.args }
@@ -969,6 +1015,8 @@ export {
   titleText,
   promptTitle,
   transcriptTitle,
+  CLAUDE_CAPS,
+  fitText,
   hookReply,
   TLDR_EVERY_DEFAULT,
   TLDR,

package/dist/claude-EQVLST73.js

@@ -0,0 +1,130 @@
+import {
+  entryArgv,
+  mcpFile,
+  mountedEntry,
+  whichOnPath
+} from "./chunk-2OSUVJ2J.js";
+import "./chunk-Q5UI4Z7H.js";
+import "./chunk-QRWQIHV6.js";
+import "./chunk-YYSLYVNZ.js";
+import {
+  CHANNELS_ENV,
+  RelayUsage,
+  deriveHandle,
+  joinMode
+} from "./chunk-2LIJXXTL.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/claude.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+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;
+  for (; ; ) {
+    const arg = argv[i];
+    if (arg === "--name" || arg === "--as") {
+      if (argv[i + 1] === void 0) throw new RelayUsage(`${CLI_NAME} claude ${arg} takes a handle`);
+      name = argv[i + 1];
+      i += 2;
+    } else if (arg?.startsWith("--name=") || arg?.startsWith("--as=")) {
+      name = arg.slice(arg.indexOf("=") + 1);
+      i++;
+    } else break;
+  }
+  if (argv[i] === "--") i++;
+  name = name?.replace(/^me\//, "");
+  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 claudeLaunchArgs(args, added) {
+  const end = args.indexOf("--");
+  const at = end < 0 ? args.length : end;
+  const channels = args.some((arg, i) => i < at && (arg === "server:scp" || arg === `${CHANNEL_FLAGS[0]}=server:scp`)) ? [] : CHANNEL_FLAGS;
+  return [...args.slice(0, at), ...channels, ...added, ...args.slice(at)];
+}
+var STRICT_HINT = `${CLI_NAME} claude: --strict-mcp-config without --mcp-config drops the scp mount, so messages cannot wake this session`;
+function externalMcp(args) {
+  return args.some((arg) => arg === "--mcp-config" || arg.startsWith("--mcp-config="));
+}
+function namePrompt(name, args, env, cwd) {
+  if (name !== void 0 || joinMode(env) === "manual" || args.some((arg) => /^--(append-)?system-prompt/.test(arg))) return [];
+  const handle = env.SCP_NAME || deriveHandle("claude-code", cwd);
+  return [
+    "--append-system-prompt",
+    `You are on the SCP network as ${handle}. Pick a short descriptive name for yourself with \`${CLI_NAME} name <name>\` when you know what you're working on.`
+  ];
+}
+function mountHint(env, cwd = process.cwd()) {
+  const file = mcpFile("claude", env);
+  const entries = [];
+  try {
+    const user = mountedEntry("claude", file);
+    if (user) entries.push(user);
+    const config = existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
+    const local = config.projects?.[cwd]?.mcpServers?.scp;
+    if (local && typeof local === "object") entries.push(local);
+  } catch {
+    return `${CLI_NAME} claude: ${file} is unreadable, so the scp mount is unchecked; fix it or run ${CLI_NAME} setup --write`;
+  }
+  const project = join(cwd, ".mcp.json");
+  try {
+    const entry = existsSync(project) ? mountedEntry("claude", project) : void 0;
+    if (entry) entries.push(entry);
+  } catch {
+  }
+  if (!entries.length) return `${CLI_NAME} claude: Claude Code has no scp MCP mount, so messages cannot wake this session; run ${CLI_NAME} setup --write`;
+  if (!entries.some((entry) => entryArgv("claude", entry).includes("--channels")))
+    return `${CLI_NAME} claude: the scp mount lacks --channels, so messages cannot wake this session; run ${CLI_NAME} setup --write`;
+  return void 0;
+}
+async function claudeCommand(argv, env = process.env, err = (line) => void process.stderr.write(`${line}
+`), cwd = process.cwd()) {
+  if (argv[0] === "--help" || argv[0] === "-h") {
+    process.stdout.write(
+      `${CLI_NAME} claude [--name N | --as 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 external = externalMcp(args);
+  const hint = external ? void 0 : args.includes("--strict-mcp-config") ? STRICT_HINT : mountHint(env, cwd);
+  if (hint) throw new RelayUsage(hint);
+  if (external) err(`${CLI_NAME} claude: using your --mcp-config; it needs the scp server with --channels for messages to wake this session`);
+  const child = spawn(bin, claudeLaunchArgs(args, namePrompt(name, args, env, cwd)), {
+    cwd,
+    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,
+  claudeLaunchArgs,
+  mountHint,
+  namePrompt
+};

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