@scp-dev/cli 0.0.0-stage → 0.1.2

package/dist/chunk-V5I7KEU7.js

@@ -0,0 +1,948 @@
+import {
+  agyRules,
+  agySettingsFile,
+  mcpFile,
+  mountedEntry
+} from "./chunk-N3ZROLFA.js";
+import {
+  OPTIONS,
+  RelayUsage,
+  SPAWN_OPTIONS,
+  grantParams,
+  localClient,
+  open,
+  selectorList,
+  walkNow
+} from "./chunk-7KP6TAJW.js";
+import {
+  steerPrompt
+} from "./chunk-XWLF7ON2.js";
+import {
+  SELF,
+  detectHarness,
+  note,
+  spawnerKey
+} from "./chunk-DA3EB2YF.js";
+
+// src/spawn.ts
+import { spawn, spawnSync } from "child_process";
+import { closeSync, existsSync, constants as files, fstatSync, openSync, readFileSync, readSync, realpathSync, writeSync } from "fs";
+import { constants, homedir } from "os";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "path";
+import { parseArgs } from "util";
+import {
+  CLI_NAME,
+  PEEK,
+  findSecret,
+  HANDBACK_CUT,
+  handbackOutput,
+  keepLast,
+  LIMITS,
+  redactSecrets,
+  steerNote,
+  stripControl
+} from "@scp-dev/core";
+var SERVER = "scp";
+var SPAWN_RUNNER = "SCP_SPAWN_RUNNER";
+var SPAWNER_IDENTITY = ["SCP_NAME", "SCP_SESSION", "SCP_GRANT", "SCP_PARENT", "SCP_HARNESS", SPAWN_RUNNER];
+var SHIM_ENV = ["SCP_GRANT", "SCP_NAME", "SCP_LABELS", "SCP_DIR", "XDG_STATE_HOME"];
+function spawnEnvironment(parent, grant, labels) {
+  const env = {};
+  for (const [key, value] of Object.entries(parent)) if (value !== void 0 && !SPAWNER_IDENTITY.includes(key)) env[key] = value;
+  return { ...env, ...grant, ...labels !== void 0 ? { SCP_LABELS: labels } : {} };
+}
+function codexMount(env) {
+  try {
+    return mountedEntry("codex", mcpFile("codex", env));
+  } catch {
+    return void 0;
+  }
+}
+function toml(value) {
+  if (typeof value === "string") return JSON.stringify(value).replaceAll("\x7F", "\\u007f");
+  if (Array.isArray(value)) return `[${value.map(toml).join(", ")}]`;
+  if (value && typeof value === "object")
+    return `{ ${Object.entries(value).map(([k, v]) => `${JSON.stringify(k)} = ${toml(v)}`).join(", ")} }`;
+  return JSON.stringify(value);
+}
+function codexOverrides(env, mount, self) {
+  const kept = Array.isArray(mount?.env_vars) ? mount.env_vars : [];
+  const names = SHIM_ENV.filter((name) => env[name] !== void 0 && !kept.includes(name));
+  const key = (field) => `mcp_servers.${SERVER}.${field}`;
+  const set = (field, value) => ["-c", `${key(field)}=${toml(value)}`];
+  return [
+    ...mount ? [] : [...set("command", self[0]), ...set("args", [...self.slice(1), "mcp", "--harness", "codex"])],
+    ...set("env_vars", [...kept, ...names]),
+    ...set("enabled", true),
+    ...mount && "default_tools_approval_mode" in mount ? [] : set("default_tools_approval_mode", "approve")
+  ];
+}
+var CODEX_VALUED = /* @__PURE__ */ new Set([
+  "-c",
+  "--config",
+  "--enable",
+  "--disable",
+  "--remote",
+  "--remote-auth-token-env",
+  "-i",
+  "--image",
+  "-m",
+  "--model",
+  "--local-provider",
+  "-p",
+  "--profile",
+  "-s",
+  "--sandbox",
+  "-C",
+  "--cd",
+  "--add-dir",
+  "-a",
+  "--ask-for-approval"
+]);
+var CODEX_SESSIONS = /* @__PURE__ */ new Set(["exec", "e", "review", "resume", "fork"]);
+function codexOverrideAt(args) {
+  let i = 0;
+  while (i < args.length && args[i].startsWith("-") && args[i] !== "--") i += CODEX_VALUED.has(args[i]) ? 2 : 1;
+  if (i >= args.length || !CODEX_SESSIONS.has(args[i])) return [0];
+  const at = [0, i + 1];
+  if (args[i] === "exec" || args[i] === "e") {
+    let j = i + 1;
+    while (j < args.length && args[j].startsWith("-") && args[j] !== "--") j += CODEX_EXEC_VALUED.has(args[j]) ? 2 : 1;
+    if (args[j] === "resume" || args[j] === "review") at.push(j + 1);
+  }
+  return at;
+}
+var ENV_VALUED = /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir", "-S", "--split-string"]);
+var TIMEOUT_VALUED = /* @__PURE__ */ new Set(["-s", "--signal", "-k", "--kill-after"]);
+function programAt(command) {
+  let i = 0;
+  const skipFlags = (valued) => {
+    while (i < command.length && command[i].startsWith("-") && command[i] !== "--") i += valued.has(command[i]) ? 2 : 1;
+    if (command[i] === "--") i++;
+  };
+  while (i < command.length) {
+    const word = command[i];
+    const name = basename(word);
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) i++;
+    else if (name === "env") {
+      i++;
+      skipFlags(ENV_VALUED);
+    } else if (name === "nohup") i++;
+    else if (name === "nice") {
+      i++;
+      skipFlags(/* @__PURE__ */ new Set(["-n", "--adjustment"]));
+    } else if (name === "timeout") {
+      i++;
+      skipFlags(TIMEOUT_VALUED);
+      i++;
+    } else break;
+  }
+  return i;
+}
+var MESSAGING = [
+  "relay_send",
+  "relay_ask",
+  "relay_ask_wait",
+  "relay_reply",
+  "relay_inbox",
+  "relay_list",
+  "relay_peers",
+  "relay_whoami",
+  "relay_set_status",
+  "relay_set_now",
+  "relay_set_title"
+].map((tool) => `mcp__${SERVER}__${tool}`);
+var PRESETS = {
+  claude: {
+    headless: ["-p", "--print"],
+    own: ["--allowedTools", "--allowed-tools", "--dangerously-skip-permissions", "--permission-mode"],
+    allow: ["--allowedTools", ...MESSAGING]
+  },
+  grok: {
+    headless: ["-p", "--single", "--prompt-file", "--prompt-json"],
+    own: ["--allow", "--allowedTools", "--allowed-tools", "--always-approve", "--permission-mode"],
+    allow: MESSAGING.flatMap((tool) => ["--allow", tool])
+  }
+};
+var MUSE_VALUED = /* @__PURE__ */ new Set([
+  "--agents",
+  "--provider",
+  "--preset",
+  "--model",
+  "--contributor-mode",
+  "-c",
+  "--config",
+  "--reasoning-effort",
+  "--effort",
+  "--base-url",
+  "--image",
+  "--workspace",
+  "--worktree-base",
+  "--worktree-existing",
+  "--approval-mode",
+  "--permission-profile",
+  "--approval-judge",
+  "--sandbox-network",
+  "--echo-delay-ms"
+]);
+var MUSE_MODE = "--contributor-mode";
+var MUSE_OPTIONAL = { "-w": /* @__PURE__ */ new Set(["off", "create", "existing"]), "--worktree": /* @__PURE__ */ new Set(["off", "create", "existing"]) };
+var MUSE_CONFIG = /* @__PURE__ */ new Set(["-c", "--config"]);
+var MUSE_MODES_ALLOWED = /* @__PURE__ */ new Set(["off", "on"]);
+function museOptionsEnd(args, start = 0) {
+  let i = start;
+  while (i < args.length && args[i].startsWith("-") && args[i] !== "--") {
+    const word = args[i];
+    i += word.includes("=") ? 1 : MUSE_VALUED.has(word) || MUSE_OPTIONAL[word]?.has(args[i + 1] ?? "") ? 2 : 1;
+  }
+  return i;
+}
+function museModeAt(args) {
+  const i = museOptionsEnd(args);
+  return args[i] === "exec" ? i + 1 : 0;
+}
+function configMode(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed === false ? "off" : parsed === true ? "on" : typeof parsed === "string" ? parsed : value;
+  } catch {
+    return value;
+  }
+}
+function museModes(args) {
+  const end = args.indexOf("--");
+  const words = end < 0 ? args : args.slice(0, end);
+  const modes = [];
+  for (const [i, word] of words.entries()) {
+    if (word === MUSE_MODE) modes.push(words[i + 1]);
+    else if (word.startsWith(`${MUSE_MODE}=`)) modes.push(word.slice(MUSE_MODE.length + 1));
+    const eq = word.indexOf("=");
+    const setting = MUSE_CONFIG.has(word) ? words[i + 1] : eq > 0 && MUSE_CONFIG.has(word.slice(0, eq)) ? word.slice(eq + 1) : void 0;
+    const split = setting?.indexOf("=") ?? -1;
+    if (setting !== void 0 && split > 0 && /contributor/i.test(setting.slice(0, split))) modes.push(configMode(setting.slice(split + 1)));
+  }
+  return modes;
+}
+function contributorRefusal(command) {
+  const at = programAt(command);
+  if (command[at] === void 0 || basename(command[at]) !== "muse") return null;
+  for (const mode of museModes(command.slice(at + 1))) {
+    if (mode === void 0 || !MUSE_MODES_ALLOWED.has(mode))
+      return `${CLI_NAME} spawn: muse runs with ${MUSE_MODE} off or on, not ${mode === void 0 ? "a bare flag" : JSON.stringify(mode)}`;
+  }
+  return null;
+}
+function hasFlag(args, flags) {
+  const end = args.indexOf("--");
+  return (end < 0 ? args : args.slice(0, end)).some((arg) => flags.some((flag) => arg === flag || flag.startsWith("--") && arg.startsWith(`${flag}=`)));
+}
+var SKIP_GIT = "--skip-git-repo-check";
+var PROBE_MS = 3e3;
+var probes = /* @__PURE__ */ new Map();
+function codexSkipsGitCheck(program, env) {
+  let takes = probes.get(program);
+  if (takes === void 0) {
+    const help = spawnSync(program, ["exec", "--help"], { env, encoding: "utf8", timeout: PROBE_MS, stdio: ["ignore", "pipe", "ignore"] });
+    takes = help.status === 0 && help.stdout.includes(SKIP_GIT);
+    probes.set(program, takes);
+  }
+  return takes;
+}
+function inGit(dir) {
+  for (let at = dir; ; at = dirname(at)) {
+    if (existsSync(join(at, ".git"))) return true;
+    if (dirname(at) === at) return false;
+  }
+}
+function codexExec(args) {
+  let cd;
+  const options = (from, valued) => {
+    let i2 = from;
+    while (i2 < args.length && args[i2].startsWith("-") && args[i2] !== "--" && args[i2] !== "-") {
+      const word2 = args[i2];
+      if (word2 === "-C" || word2 === "--cd") cd = args[i2 + 1];
+      else if (word2.startsWith("--cd=")) cd = word2.slice(5);
+      i2 += valued.has(word2) ? 2 : 1;
+    }
+    return i2;
+  };
+  const exec = options(0, CODEX_VALUED);
+  if (args[exec] !== "exec" && args[exec] !== "e") return void 0;
+  let i = options(exec + 1, CODEX_EXEC_VALUED);
+  const word = args[i];
+  const sub = word === "resume" || word === "review" ? { name: word, at: i } : void 0;
+  const operands = [];
+  for (i = sub ? i + 1 : i; i < args.length; i++) {
+    i = options(i, CODEX_EXEC_VALUED);
+    if (i >= args.length) break;
+    if (args[i] === "--") {
+      operands.push(...args.slice(i + 1));
+      break;
+    }
+    operands.push(args[i]);
+  }
+  return { exec, ...sub ? { sub } : {}, operands, ...cd !== void 0 ? { cd } : {} };
+}
+function closedStdin(command) {
+  const at = programAt(command);
+  if (command[at] === void 0 || basename(command[at]) !== "codex") return false;
+  const args = command.slice(at + 1);
+  const run = codexExec(args);
+  if (!run || run.operands.includes("-")) return false;
+  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];
+  const name = program === void 0 ? void 0 : basename(program);
+  const args = command.slice(at + 1);
+  const preset = name === void 0 ? void 0 : PRESETS[name];
+  if (preset) {
+    if (!hasFlag(args, preset.headless) || hasFlag(args, preset.own)) return command;
+    const end = args.indexOf("--");
+    return end < 0 ? [...command, ...preset.allow] : [...command.slice(0, at + 1 + end), ...preset.allow, ...command.slice(at + 1 + end)];
+  }
+  if (name === "muse") {
+    if (museModes(args).length) return command;
+    const mode = at + 1 + museModeAt(args);
+    return [...command.slice(0, mode), MUSE_MODE, "off", ...command.slice(mode)];
+  }
+  if (name !== "codex") return command;
+  const run = codexExec(args);
+  const skip = run && run.sub?.name !== "review" && !hasFlag(args, [SKIP_GIT]) && !inGit(resolve(cwd, run.cd ?? ".")) && probe(program, env);
+  const after = run && (run.sub?.at ?? run.exec) + 1;
+  const words = skip && after ? [...args.slice(0, after), SKIP_GIT, ...args.slice(after)] : args;
+  const overrides = codexOverrides(env, mount(env), self);
+  const points = codexOverrideAt(words);
+  return [
+    ...command.slice(0, at + 1),
+    ...words.flatMap((arg, i) => points.includes(i) ? [...overrides, arg] : [arg]),
+    ...points.includes(words.length) ? overrides : []
+  ];
+}
+var CLAUDE_VALUED = /* @__PURE__ */ new Set([
+  "--model",
+  "--fallback-model",
+  "--output-format",
+  "--input-format",
+  "--permission-mode",
+  "--settings",
+  "--setting-sources",
+  "--mcp-config",
+  "--allowedTools",
+  "--allowed-tools",
+  "--disallowedTools",
+  "--disallowed-tools",
+  "--tools",
+  "--add-dir",
+  "--append-system-prompt",
+  "--system-prompt",
+  "--session-id",
+  "--resume",
+  "-r",
+  "--max-turns",
+  "--agents",
+  "--agent",
+  "--plugin-dir",
+  "--permission-prompt-tool",
+  "--effort",
+  "--betas"
+]);
+var CODEX_EXEC_VALUED = /* @__PURE__ */ new Set([...CODEX_VALUED, "--output-schema", "--color", "-o", "--output-last-message"]);
+function promptAt(command) {
+  const at = programAt(command);
+  const name = command[at] === void 0 ? void 0 : basename(command[at]);
+  const args = command.slice(at + 1);
+  const end = args.indexOf("--");
+  if (name === "claude") {
+    if (!hasFlag(args, PRESETS.claude.headless)) return void 0;
+    if (end >= 0) return end + 1 < args.length ? { at: at + args.length, from: at + end + 2 } : void 0;
+    for (let i2 = args.length - 1; i2 >= 0; i2--)
+      if (!args[i2].startsWith("-") && !CLAUDE_VALUED.has(args[i2 - 1] ?? "")) return args[i2] ? { at: at + 1 + i2 } : void 0;
+    return void 0;
+  }
+  if (name !== "codex") return void 0;
+  let i = 0;
+  while (i < args.length && args[i].startsWith("-")) i += CODEX_VALUED.has(args[i]) ? 2 : 1;
+  if (args[i] !== "exec" && args[i] !== "e") return void 0;
+  for (i++; i < args.length; i++) {
+    const word = args[i];
+    if (word === "--") return args[i + 1] === "-" || !args[i + 1] ? void 0 : { at: at + 2 + i };
+    if (word.startsWith("-")) {
+      if (CODEX_EXEC_VALUED.has(word)) i++;
+      continue;
+    }
+    return word === "-" || word === "resume" || word === "review" || !word ? void 0 : { at: at + 1 + i };
+  }
+  return void 0;
+}
+var RESUME_TAKES = /* @__PURE__ */ new Set([
+  "-c",
+  "--config",
+  "--enable",
+  "--disable",
+  "--strict-config",
+  "-m",
+  "--model",
+  "--dangerously-bypass-approvals-and-sandbox",
+  "--dangerously-bypass-hook-trust",
+  "--skip-git-repo-check",
+  "--ignore-user-config",
+  "--ignore-rules",
+  "--output-schema",
+  "--json",
+  "-o",
+  "--output-last-message"
+]);
+var RESUME_DROPS = /* @__PURE__ */ new Set(["-i", "--image", "--worktree", "--thread-source"]);
+function resumeArgv(command, session, prompt) {
+  const found = promptAt(command);
+  const at = programAt(command);
+  if (!found || command[at] === void 0 || basename(command[at]) !== "codex") return void 0;
+  let exec = at + 1;
+  while (exec < command.length && command[exec].startsWith("-")) exec += CODEX_VALUED.has(command[exec]) ? 2 : 1;
+  const before = [];
+  const after = [];
+  for (let i = exec + 1; i < command.length; i++) {
+    const word = command[i];
+    if (i === found.at || word === "--") continue;
+    const eq = word.startsWith("--") ? word.indexOf("=") : -1;
+    const flag = eq > 0 ? word.slice(0, eq) : word;
+    const valued = eq < 0 && CODEX_EXEC_VALUED.has(flag);
+    const value = eq > 0 ? word.slice(eq + 1) : valued ? command[i + 1] : void 0;
+    const words = valued ? command.slice(i, i + 2) : [word];
+    if (valued) i++;
+    if (flag === "--ephemeral") return void 0;
+    if (flag === "-s" || flag === "--sandbox") after.push("-c", `sandbox_mode=${JSON.stringify(value ?? "")}`);
+    else if (!RESUME_DROPS.has(flag)) (RESUME_TAKES.has(flag) ? after : before).push(...words);
+  }
+  return [...command.slice(0, exec + 1), ...before, "resume", ...after, session, prompt];
+}
+function spawnPrompt(command) {
+  const found = promptAt(command);
+  return found ? command.slice(found.from ?? found.at, found.at + 1).join(" ") || void 0 : void 0;
+}
+var STEER_KEY = /^[0-9a-z]{6}$/;
+function steerArgv(command, steer) {
+  const found = promptAt(command);
+  if (!found || typeof steer?.key !== "string" || !STEER_KEY.test(steer.key) || typeof steer.parent !== "string" || !/^[^\s\]]+$/.test(steer.parent))
+    return command;
+  return command.map((word, i) => i === found.at ? `${word}${steerNote(steer.parent, steer.key)}` : word);
+}
+var TITLE_CHARS = 64;
+function spawnTitle(command) {
+  const first = spawnPrompt(command)?.split("\n").map((text) => stripControl(text).replace(/\s+/g, " ").trim()).find(Boolean);
+  if (!first) return void 0;
+  const line = redactSecrets(first);
+  const end = line.length > TITLE_CHARS && /[\ud800-\udbff]/.test(line[TITLE_CHARS - 1]) ? TITLE_CHARS - 1 : TITLE_CHARS;
+  const title = line.slice(0, end).trim();
+  return findSecret(title) ? void 0 : title;
+}
+var NAME_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+function nameSuffix() {
+  return Array.from(crypto.getRandomValues(new Uint8Array(5)), (byte) => NAME_ALPHABET[byte % NAME_ALPHABET.length]).join("");
+}
+function workerName(command, random = nameSuffix) {
+  const program = command[programAt(command)];
+  const harness = (program === void 0 ? "" : basename(program)).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, "").slice(0, 57);
+  return `${harness || "worker"}-${random()}`;
+}
+function agyNote(command, env) {
+  const at = programAt(command);
+  const args = command.slice(at + 1);
+  if (command[at] === void 0 || basename(command[at]) !== "agy" || !hasFlag(args, ["-p", "--print", "--prompt"]) || hasFlag(args, ["--dangerously-skip-permissions"]))
+    return null;
+  let allow;
+  try {
+    allow = JSON.parse(readFileSync(agySettingsFile(env), "utf8"))?.permissions?.allow;
+  } catch {
+  }
+  if (Array.isArray(allow) && agyRules().every((rule) => allow.includes(rule))) return null;
+  return `${CLI_NAME} spawn: headless agy denies the relay tools without the permission rules ${CLI_NAME} setup writes to ${agySettingsFile(env)}; run ${CLI_NAME} setup`;
+}
+var FORWARDED = ["SIGINT", "SIGQUIT", "SIGTERM", "SIGHUP"];
+var TAIL_BYTES = 16 * 1024;
+var DRAIN_MS = 2e3;
+function tee(from, to) {
+  let tail = Buffer.alloc(0);
+  let cut = false;
+  from.on("data", (chunk) => {
+    tail = Buffer.concat([tail, chunk]);
+    if (tail.length > TAIL_BYTES) {
+      tail = tail.subarray(tail.length - TAIL_BYTES);
+      cut = true;
+    }
+    if (!to.write(chunk)) {
+      from.pause();
+      to.once("drain", () => from.resume());
+    }
+  });
+  return { bytes: () => new Uint8Array(tail), cut: () => cut };
+}
+function runHarness(argv, env, options = {}) {
+  const capture = options.capture ?? process.stdout.isTTY !== true;
+  const captureErr = options.captureErr ?? process.stderr.isTTY !== true;
+  const out = options.out ?? process.stdout;
+  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: [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;
+    let open2 = pipes.length;
+    let settled = false;
+    let started = false;
+    const drained = [];
+    for (const pipe of pipes) {
+      pipe.once("close", () => {
+        if (--open2 === 0) for (const fn of drained.splice(0)) fn();
+      });
+    }
+    const handlers = FORWARDED.map((signal) => {
+      const handler = () => {
+        if (tty && (signal === "SIGINT" || signal === "SIGQUIT")) return;
+        if (child.exitCode !== null || child.signalCode !== null) return;
+        try {
+          if (group && child.pid) process.kill(-child.pid, signal);
+          else child.kill(signal);
+        } catch {
+        }
+      };
+      process.on(signal, handler);
+      return [signal, handler];
+    });
+    const done = async (code) => {
+      if (settled) return;
+      settled = true;
+      if (open2 > 0) {
+        const timer = setTimeout(() => {
+          for (const pipe of pipes) pipe.destroy();
+        }, DRAIN_MS);
+        await new Promise((next) => open2 === 0 ? next() : drained.push(next));
+        clearTimeout(timer);
+      }
+      if (capture) await new Promise((next) => out.write("", () => next()));
+      for (const [signal, handler] of handlers) process.off(signal, handler);
+      resolve2({
+        code,
+        tail: stdout?.bytes() ?? new Uint8Array(),
+        cut: stdout?.cut() ?? false,
+        err: stderr?.bytes() ?? new Uint8Array(),
+        errCut: stderr?.cut() ?? false,
+        started
+      });
+    };
+    child.once("spawn", () => {
+      started = true;
+      options.started?.();
+    });
+    child.once("error", (error) => {
+      const failed = {
+        message: `${CLI_NAME} spawn: ${argv[0]}: ${error.code === "ENOENT" ? "command not found" : error.message}`,
+        code: error.code === "ENOENT" ? 127 : 126
+      };
+      if (options.started) options.started(failed);
+      else note(failed.message);
+      void done(failed.code);
+    });
+    child.once("exit", (code, signal) => void done(code ?? 128 + (signal ? constants.signals[signal] ?? 0 : 0)));
+  });
+}
+function harnessOutput(run, bytes) {
+  let start = 0;
+  if (run.cut) while (start < run.tail.length && (run.tail[start] & 192) === 128) start++;
+  return handbackOutput(new TextDecoder().decode(run.tail.subarray(start)), run.cut, bytes);
+}
+var EARLIER_STDERR = "[earlier stderr cut]";
+function stderrOutput(run, bytes = LIMITS.stderrBytes) {
+  let start = 0;
+  if (run.errCut) while (start < run.err.length && (run.err[start] & 192) === 128) start++;
+  const text = new TextDecoder().decode(run.err.subarray(start));
+  const clean = handbackOutput(run.errCut ? text.slice(text.indexOf("\n") + 1) : text, false, Number.MAX_SAFE_INTEGER);
+  const encoded = new TextEncoder().encode(clean);
+  if (encoded.length <= bytes) return run.errCut && clean ? `${EARLIER_STDERR}
+${clean}` : clean;
+  let from = encoded.length - bytes;
+  const line = encoded.indexOf(10, from - 1);
+  if (line >= 0 && line + 1 < encoded.length) from = line + 1;
+  else while (from < encoded.length && (encoded[from] & 192) === 128) from++;
+  return `${EARLIER_STDERR}
+${new TextDecoder().decode(encoded.subarray(from))}`;
+}
+var TRANSCRIPT_BYTES = 4 * 1024 * 1024;
+var LIMIT_CUT = "[reply cut at the model's output limit]";
+function prompted(entry, content) {
+  if (entry.isMeta === true || entry.isCompactSummary === true || entry.toolUseResult !== void 0) return false;
+  const blocks = Array.isArray(content) ? content : [content];
+  if (blocks.some((block) => block?.type === "tool_result")) return false;
+  const texts = blocks.map((block) => typeof block === "string" ? block : block?.type === "text" ? block.text : void 0);
+  return texts.some((text) => typeof text === "string" && text.trim() !== "" && !text.startsWith("Stop hook feedback"));
+}
+function claudeTranscripts(env) {
+  return join(env.CLAUDE_CONFIG_DIR || join(env.HOME || homedir(), ".claude"), "projects");
+}
+function transcriptReplies(path, session, root, bytes = TRANSCRIPT_BYTES) {
+  if (!isAbsolute(path) || basename(path) !== `${session}.jsonl`) return [];
+  try {
+    if (!realpathSync(path).startsWith(realpathSync(root) + sep)) return [];
+  } catch {
+    return [];
+  }
+  let text;
+  let start;
+  let fd;
+  try {
+    fd = openSync(path, files.O_RDONLY | files.O_NOFOLLOW | files.O_NONBLOCK);
+    const stat = fstatSync(fd);
+    if (!stat.isFile()) return [];
+    start = Math.max(0, stat.size - bytes);
+    const buffer = Buffer.alloc(stat.size - start);
+    text = buffer.subarray(0, readSync(fd, buffer, 0, buffer.length, start)).toString("utf8");
+  } catch {
+    return [];
+  } finally {
+    if (fd !== void 0) closeSync(fd);
+  }
+  let replies = start > 0 ? [HANDBACK_CUT] : [];
+  for (const line of text.split("\n").slice(start > 0 ? 1 : 0)) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!entry || typeof entry !== "object" || entry.isSidechain === true || entry.sessionId !== session) continue;
+    const message = entry.message;
+    const content = message && typeof message === "object" ? message.content : void 0;
+    if (entry.type === "user" && prompted(entry, content)) replies = [];
+    if (entry.type !== "assistant") continue;
+    const before = replies.length;
+    for (const block of Array.isArray(content) ? content : [content]) {
+      const reply = typeof block === "string" ? block : block?.type === "text" ? block.text : void 0;
+      if (typeof reply === "string" && reply.trim()) replies.push(reply);
+    }
+    if (replies.length > before && message.stop_reason === "max_tokens") replies.push(`${replies.pop()}
+${LIMIT_CUT}`);
+  }
+  return replies;
+}
+function repliesOutput(replies, bytes = LIMITS.handbackBytes) {
+  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");
+    return from > 0 ? `${HANDBACK_CUT}
+
+${text}` : text;
+  };
+  let fit;
+  for (let from = clean.length - 1; from >= 0 && size(framed(from)) <= bytes; from--) fit = framed(from);
+  if (fit !== void 0) return fit;
+  return keepLast(clean.at(-1), bytes, clean.length > 1);
+}
+function splitSpawn(args) {
+  let i = 0;
+  while (i < args.length && args[i].startsWith("-") && args[i] !== "--") {
+    const flag = args[i];
+    const option = flag.startsWith("--") && !flag.includes("=") ? OPTIONS[flag.slice(2)] : void 0;
+    i += option?.type === "string" ? 2 : 1;
+  }
+  return { flags: args.slice(0, i), command: args.slice(args[i] === "--" ? i + 1 : i) };
+}
+function spawnDefaults(values, command, random, spawner) {
+  const scoped = ["scope", "rules", "in", "out", "allow"].some((key) => values[key] !== void 0);
+  const under = typeof values.under === "string" ? values.under : void 0;
+  const reach = [
+    ...spawner && under && under.replace(/^me\//, "") !== spawner ? [`ep:${spawner}`] : [],
+    ...(selectorList(values.group) ?? []).map((group) => `group:${group}`)
+  ];
+  const title = values.title === void 0 ? spawnTitle(command) : void 0;
+  return {
+    ...values,
+    ...scoped ? {} : { scope: "parent", ...reach.length ? { allow: reach } : {} },
+    ...title ? { title } : {},
+    ...values.name === void 0 ? { name: workerName(command, random) } : {}
+  };
+}
+function handbackBytes(value) {
+  const bytes = /^\d+$/.test(value) ? Number(value) : 0;
+  if (bytes < 1 || bytes > LIMITS.handbackBytes) throw new RelayUsage(`--handback-bytes takes whole bytes, 1 to ${LIMITS.handbackBytes}`);
+  return bytes;
+}
+var STEER_RESUMES = 2;
+async function spawnCommand(args, cwd) {
+  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];
+  if (runner === void 0 && (values.bg === true || values.fg !== true && (process.stdout.isTTY !== true || process.stdin.isTTY !== true && agentShell(process.env))))
+    return detachSpawn(args, cwd);
+  const channel = runner === void 0 ? void 0 : handshakeChannel();
+  const handshake = channel === void 0 ? void 0 : once((reply) => {
+    try {
+      writeSync(channel, `${JSON.stringify(reply)}
+`);
+      closeSync(channel);
+    } catch {
+    }
+  });
+  const bound = spawnerKey();
+  const prompt = values.peek === void 0 ? void 0 : spawnPrompt(command)?.slice(0, PEEK.rawChars);
+  const walk = runner === void 0 ? walkNow() : JSON.parse(runner);
+  let grant;
+  let steer;
+  try {
+    const opened = await open("spawn", values, cwd, false, walk);
+    const { me } = opened;
+    const client = localClient(opened.client, opened.broker, "spawn");
+    try {
+      values = spawnDefaults(values, command, void 0, me?.kind === "agent" && me.address.startsWith("me/") ? me.address.slice(3) : void 0);
+      const params = { ttl_s: SPAWN_GRANT_TTL_S, ...grantParams(values), ...bound ? { bind_process: bound } : {}, spawn: true, ...prompt ? { prompt } : {} };
+      const granted = await client.grant(params);
+      grant = granted.env;
+      steer = granted.steer;
+    } finally {
+      client.close();
+    }
+  } catch (error) {
+    handshake?.({ error: error instanceof Error ? error.message : String(error), ...error instanceof RelayUsage ? { usage: true } : {} });
+    throw error;
+  }
+  const name = values.name;
+  const env = spawnEnvironment(process.env, grant, values.labels);
+  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, { 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;
+  }
+  const exits = [Date.now()];
+  let unapplied = [];
+  for (let round = 0; round < STEER_RESUMES && run.code === 0 && resumeArgv(command, "", ""); round++) {
+    const pending = await spawnSteers(values, cwd, grant.SCP_GRANT, walk, true);
+    if (!pending?.session || !pending.steers.length) break;
+    const resumed = await launch(resumeArgv(command, pending.session, steerPrompt(pending.steers)));
+    exits.push(Date.now());
+    if (resumed.code !== 0) {
+      unapplied = pending.steers.map((message) => message.id);
+      break;
+    }
+    run = resumed;
+  }
+  const worker = await spawnSteers(values, cwd, grant.SCP_GRANT, walk, false);
+  const replies = worker?.session && worker.transcript ? repliesOutput(transcriptReplies(worker.transcript, worker.session, claudeTranscripts(process.env)), bytes) : "";
+  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]);
+}
+function handshakeChannel() {
+  try {
+    const fd = openSync("/dev/fd/3", "w");
+    closeSync(3);
+    return fd;
+  } catch {
+    return 3;
+  }
+}
+function once(fn) {
+  let done = false;
+  return (...args) => {
+    if (done) return;
+    done = true;
+    fn(...args);
+  };
+}
+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,
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore", "pipe"],
+    env: { ...process.env, [SPAWN_RUNNER]: JSON.stringify(walk) }
+  });
+  const channel = child.stdio[3];
+  const line = await new Promise((resolve2) => {
+    let text = "";
+    channel.on("data", (chunk) => {
+      text += chunk.toString();
+      if (text.includes("\n")) resolve2(text.slice(0, text.indexOf("\n")));
+    });
+    channel.once("end", () => resolve2(text));
+    child.once("error", () => resolve2(""));
+  });
+  channel.destroy();
+  child.unref();
+  let reply;
+  try {
+    reply = JSON.parse(line);
+  } catch {
+  }
+  if (!reply) throw new Error(`${CLI_NAME} spawn: the detached runner ended before the harness started`);
+  if ("error" in reply) {
+    if (reply.usage) throw new RelayUsage(reply.error);
+    if (reply.code === void 0) throw new Error(reply.error);
+    return { error: reply.error, code: reply.code };
+  }
+  return reply;
+}
+async function spawnSteers(values, cwd, token, walk, take) {
+  try {
+    const opened = await open("spawn", values, cwd, false, walk);
+    const client = localClient(opened.client, opened.broker, "spawn");
+    try {
+      return await client.spawnSteers({ grant: token, take });
+    } finally {
+      client.close();
+    }
+  } catch {
+    return void 0;
+  }
+}
+async function spawnExit(values, cwd, token, code, name, output, walk, unapplied = [], exits = [], started = true, stderr = "") {
+  try {
+    const opened = await open("spawn", values, cwd, false, walk);
+    const client = localClient(opened.client, opened.broker, "spawn");
+    try {
+      await client.spawnExit({
+        grant: token,
+        code: Math.min(code, 255),
+        ...output ? { output } : {},
+        ...stderr ? { stderr } : {},
+        ...unapplied.length ? { unapplied } : {},
+        ...exits.length ? { exits } : {},
+        ...started ? {} : { started: false }
+      });
+    } finally {
+      client.close();
+    }
+  } catch (error) {
+    note(`${CLI_NAME} spawn: could not mark ${name} as exited: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+var SPAWN_GRANT_TTL_S = 3600;
+
+export {
+  SPAWN_RUNNER,
+  spawnEnvironment,
+  codexMount,
+  codexOverrides,
+  codexOverrideAt,
+  programAt,
+  MESSAGING,
+  contributorRefusal,
+  codexSkipsGitCheck,
+  closedStdin,
+  STDIN_WAIT_MS,
+  harnessStdin,
+  harnessArgv,
+  resumeArgv,
+  spawnPrompt,
+  steerArgv,
+  spawnTitle,
+  workerName,
+  agyNote,
+  runHarness,
+  harnessOutput,
+  stderrOutput,
+  claudeTranscripts,
+  transcriptReplies,
+  repliesOutput,
+  splitSpawn,
+  spawnDefaults,
+  spawnCommand,
+  spawnDetached,
+  agentShell
+};