@scp-dev/cli 0.2.0 → 0.2.2

package/dist/{chunk-5DYFYLAQ.js → chunk-F5QVHJIT.js}

@@ -1,6 +1,3 @@
-import {
-  RelayUsage
-} from "./chunk-3V3DRXB2.js";
 import {
   AGY_HOOK_SET,
   AGY_UNVERIFIED,
@@ -13,10 +10,11 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-RXKBND3T.js";
+} from "./chunk-OTO6DBU6.js";
 import {
+  RelayUsage,
   gitToplevel
-} from "./chunk-E53YHYEP.js";
+} from "./chunk-E7JG5PJB.js";
 
 // src/install.ts
 import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";

package/dist/{chunk-GH7AXFUL.js → chunk-G2SQPY6E.js}

@@ -3,28 +3,26 @@ import {
   agySettingsFile,
   mcpFile,
   mountedEntry
-} from "./chunk-WV5FINTW.js";
+} from "./chunk-NOYMSD4F.js";
+import {
+  steerPrompt
+} from "./chunk-OTO6DBU6.js";
 import {
   OPTIONS,
   RelayUsage,
   SPAWN_OPTIONS,
+  detectHarness,
   grantParams,
   localClient,
   open,
   selectorList,
+  spawnerKey,
   walkNow
-} from "./chunk-3V3DRXB2.js";
-import {
-  steerPrompt
-} from "./chunk-RXKBND3T.js";
-import {
-  detectHarness,
-  spawnerKey
-} from "./chunk-E53YHYEP.js";
+} from "./chunk-E7JG5PJB.js";
 import {
   SELF,
   note
-} from "./chunk-M2DCR2J4.js";
+} from "./chunk-MNTIEWKF.js";
 
 // src/spawn.ts
 import { spawn, spawnSync } from "child_process";

package/dist/{chunk-M2DCR2J4.js → chunk-MNTIEWKF.js}

@@ -1,5 +1,6 @@
 // src/term.ts
 import { spawnSync } from "child_process";
+import { fstatSync } from "fs";
 import { CLI_NAME } from "@scp-dev/core";
 var FAILED = 125;
 var SELF = [process.execPath, ...process.versions.bun ? ["--no-env-file", "--config=/dev/null"] : [], process.argv[1]];
@@ -11,16 +12,25 @@ function note(message) {
   process.stderr.write(`${message.startsWith(`${CLI_NAME} `) ? "" : `${CLI_NAME}: `}${message}
 `);
 }
+function isSocket(fd) {
+  try {
+    return fstatSync(fd).isSocket();
+  } catch {
+    return false;
+  }
+}
 async function exitFlushed(code, waitMs = 1e4) {
-  const ended = (stream) => new Promise((resolve) => {
+  const ended = (stream, fd) => new Promise((resolve) => {
     try {
-      stream.end(() => resolve());
+      if (!isSocket(fd)) stream.end(() => resolve());
+      else if (stream.writableNeedDrain) stream.once("drain", () => resolve());
+      else stream.write("", () => resolve());
     } catch {
       resolve();
     }
   });
   let timer;
-  await Promise.race([Promise.all([ended(process.stdout), ended(process.stderr)]), new Promise((resolve) => timer = setTimeout(resolve, waitMs))]);
+  await Promise.race([Promise.all([ended(process.stdout, 1), ended(process.stderr, 2)]), new Promise((resolve) => timer = setTimeout(resolve, waitMs))]);
   clearTimeout(timer);
   process.exit(code);
 }

package/dist/{chunk-WV5FINTW.js → chunk-NOYMSD4F.js}

@@ -1,9 +1,6 @@
 import {
   hooksTarget
-} from "./chunk-5DYFYLAQ.js";
-import {
-  RelayUsage
-} from "./chunk-3V3DRXB2.js";
+} from "./chunk-F5QVHJIT.js";
 import {
   AGY_HOOK_SET,
   BLOCK_STOP,
@@ -15,10 +12,12 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-RXKBND3T.js";
+} from "./chunk-OTO6DBU6.js";
 import {
-  gitToplevel
-} from "./chunk-E53YHYEP.js";
+  RelayUsage,
+  gitToplevel,
+  setJoinMode
+} from "./chunk-E7JG5PJB.js";
 
 // src/setup.ts
 import { spawnSync } from "child_process";
@@ -50,7 +49,7 @@ var SETUP_HARNESSES = ["claude", "codex", "opencode", "grok", "muse", "agy"];
 var SERVER = "scp";
 var HOOKED = /* @__PURE__ */ new Set(["claude", "codex", "opencode", "agy", "muse"]);
 var VERIFY_TIMEOUT_MS = 6e4;
-var SETUP_HELP = `${CLI_NAME} setup [--write] [--no-hooks] [--block-stop-on-unread] [--undo] [--bin PATH] [--harness H]
+var SETUP_HELP = `${CLI_NAME} setup [--write] [--no-hooks] [--block-stop-on-unread] [--join auto|manual] [--undo] [--bin PATH] [--harness H]
   mounts the relay MCP shim in every installed harness (claude, codex, opencode, grok, muse, agy) at user scope, running
   the ${CLI_NAME} PATH finds (by that path) or --bin, and installs the relay hooks at user scope (Muse's as a plugin). Prints
   the plan; --write applies it (each file backed up next to itself as <file>.bak-<time>, its mode kept), then checks
@@ -60,6 +59,8 @@ var SETUP_HELP = `${CLI_NAME} setup [--write] [--no-hooks] [--block-stop-on-unre
   messages are unread; without it a hooks file keeps the stop hook it has. ${CLI_NAME} spawn returns at once from an
   agent's shell; while the workers it started run, a stop waits up to 600 s for their next message or handback (hooks
   install --push-wait), so results arrive by themselves. --no-hooks mounts the MCP shim only.
+  --join auto (the default) puts every hooked session on the relay when it starts; --join manual keeps a session off it
+  until it runs ${CLI_NAME} join <name> (or calls relay_join); saved in ~/.config/scp/config.json with --write.
   --undo removes only what setup added (it keeps a list in ~/.config/scp/setup.json), its hooks too unless --no-hooks.`;
 var KNOWN = {
   claude: [".local/bin/claude", ".claude/local/claude"],
@@ -954,6 +955,7 @@ function relaySetup(options, deps) {
     throw new RelayUsage(`--harness is one of ${SETUP_HARNESSES.join(", ")}`);
   }
   if (options.blockStop && (options.hooks === false || options.undo)) throw new RelayUsage(`${BLOCK_STOP} goes with the hooks: not with --no-hooks or --undo`);
+  if (options.join !== void 0 && options.undo) throw new RelayUsage("--join sets how sessions join: not with --undo");
   let added;
   try {
     added = readManifest(env);
@@ -976,6 +978,12 @@ function relaySetup(options, deps) {
   out(`${CLI_NAME} setup${options.undo ? " --undo" : ""}: ${options.write ? "applying" : "dry run, nothing is written (add --write to apply)"}`);
   let hooks = options.hooks !== false;
   let unresolved = 0;
+  if (options.join !== void 0) {
+    if (options.write) setJoinMode(env, options.join);
+    out(
+      `join: ${options.join}${options.join === "manual" ? ` (a session stays off the relay until it runs ${CLI_NAME} join <name>)` : " (every hooked session joins when it starts)"}${options.write ? "" : ", saved with --write"}`
+    );
+  }
   if (options.hooks === false) out(`hooks: ${options.undo ? "kept (--no-hooks)" : "not installed (--no-hooks); only the MCP shim is mounted"}`);
   if (!options.undo) {
     if (options.bin !== void 0) out(`mounts run: ${bin} (from --bin; they break if that file moves)`);
@@ -1136,6 +1144,7 @@ function parseSetupArgs(args) {
     "block-stop-on-unread": { type: "boolean" },
     bin: { type: "string" },
     harness: { type: "string" },
+    join: { type: "string" },
     help: { type: "boolean", short: "h" }
   };
   let parsed;
@@ -1149,10 +1158,11 @@ function parseSetupArgs(args) {
   } catch (error) {
     throw new RelayUsage(message(error));
   }
-  const { help, hooks, "no-hooks": noHooks, "block-stop-on-unread": blockStop, ...rest } = parsed.values;
+  const { help, hooks, "no-hooks": noHooks, "block-stop-on-unread": blockStop, join: joins, ...rest } = parsed.values;
   if (help) return "help";
+  if (joins !== void 0 && joins !== "auto" && joins !== "manual") throw new RelayUsage("--join takes auto or manual");
   if (hooks && noHooks) throw new RelayUsage("--hooks and --no-hooks contradict each other; the hooks are installed unless --no-hooks");
-  return { ...rest, ...noHooks ? { hooks: false } : {}, ...blockStop ? { blockStop } : {} };
+  return { ...rest, ...noHooks ? { hooks: false } : {}, ...blockStop ? { blockStop } : {}, ...joins !== void 0 ? { join: joins } : {} };
 }
 function relaySetupCommand(args, cwd, out) {
   const options = parseSetupArgs(args);

package/dist/{chunk-RXKBND3T.js → chunk-OTO6DBU6.js}

@@ -6,12 +6,17 @@ import {
 import {
   hookHarness,
   hookHarnessPid,
-  relayIdentity
-} from "./chunk-E53YHYEP.js";
+  membership,
+  normalizeHarness,
+  processKey,
+  psStart,
+  relayIdentity,
+  sessionKey
+} from "./chunk-E7JG5PJB.js";
 
 // src/hooks.ts
 import { Readable } from "stream";
-import { readFileSync, writeSync } from "fs";
+import { closeSync, fstatSync, openSync, readFileSync, readSync, writeSync } from "fs";
 import { homedir } from "os";
 import { basename, join } from "path";
 import {
@@ -24,6 +29,7 @@ import {
   redactSecrets,
   shortId,
   stripControl,
+  TITLE_CHARS,
   validHandle,
   wrapMessage
 } from "@scp-dev/core";
@@ -33,6 +39,8 @@ var HOOK_COMMAND = `${CLI_NAME} hook`;
 var BLOCK_STOP = "--block-stop-on-unread";
 var NO_INJECT = "--no-inject";
 var PUSH_WAIT = "--push-wait";
+var WAKE = "--wake";
+var OPENCODE_WAKE = "opencode-plugin";
 var PUSH_WAIT_DEFAULT_S = 600;
 var PUSH_TIMEOUT_MARGIN_S = 30;
 var PUSH_PRINT_MS = 1e3;
@@ -286,6 +294,57 @@ function claudeVersion(payload, env) {
     return void 0;
   }
 }
+var TITLE_TAIL_BYTES = 128 * 1024;
+var TITLE_LINE = /^\{"type":"(custom-title|ai-title|summary)"/;
+var OPENCODE_UNNAMED = /^(New|Child) session - \d{4}-/;
+function titleText(text) {
+  if (!text) return void 0;
+  const line = redactSecrets(stripControl(text.slice(0, 4096)).replace(/\s+/g, " ").trim()).slice(0, TITLE_CHARS).trim();
+  return line || void 0;
+}
+function promptTitle(prompt) {
+  return titleText(prompt?.split("\n").find((line) => line.trim()));
+}
+function transcriptTitle(path, session) {
+  if (!path || !session || !path.startsWith("/") || !path.endsWith(`/${session}.jsonl`)) return void 0;
+  let fd;
+  try {
+    fd = openSync(path, "r");
+    const size = fstatSync(fd).size;
+    const start = Math.max(0, size - TITLE_TAIL_BYTES);
+    const buffer = Buffer.alloc(size - start);
+    const read = readSync(fd, buffer, 0, buffer.length, start);
+    const lines = buffer.subarray(0, read).toString("utf8").split("\n");
+    if (start > 0) lines.shift();
+    const found = {};
+    for (const line of lines) {
+      const kind = TITLE_LINE.exec(line)?.[1];
+      if (!kind) continue;
+      try {
+        const record = JSON.parse(line);
+        const text = asString(record.customTitle ?? record.aiTitle ?? record.summary);
+        if (text) found[kind] = text;
+      } catch {
+      }
+    }
+    return titleText(found["custom-title"] ?? found["ai-title"] ?? found.summary);
+  } catch {
+    return void 0;
+  } finally {
+    if (fd !== void 0) closeSync(fd);
+  }
+}
+function inferredTitle(harness, event, named, payload) {
+  if (event.agent) return void 0;
+  if (event.kind === "prompt" && named === "userpromptsubmit") {
+    const text2 = promptTitle(asString(payload.prompt));
+    return text2 ? { text: text2, from: "prompt" } : void 0;
+  }
+  if (event.kind !== "stop" || named !== "stop") return void 0;
+  const own = harness === "opencode" ? asString(payload.session_title) : void 0;
+  const text = harness === "claude-code" ? transcriptTitle(asString(field(payload, "transcript_path", "transcriptPath")), asString(field(payload, "session_id", "sessionId"))) : own && !OPENCODE_UNNAMED.test(own) ? titleText(own) : void 0;
+  return text ? { text, from: "summary" } : 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 } });
@@ -298,6 +357,12 @@ function hookReply(harness, kind, text, unread = 0, continues = true) {
   return JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext: text } });
 }
 var DEFERS = /* @__PURE__ */ new Set(["claude-code", "codex"]);
+var TLDR_EVERY_DEFAULT = 10;
+var TLDR = `SCP: update your tl;dr with \`${CLI_NAME} set-now "..."\` or relay_set_now (what you are doing now).`;
+function tldrEvery(env) {
+  const raw = env.SCP_TLDR_EVERY?.trim();
+  return raw && /^\d{1,6}$/.test(raw) ? Number(raw) : TLDR_EVERY_DEFAULT;
+}
 var NUDGE = `${CLI_NAME} (optional): a title and a one-line now (relay_set_title / relay_set_now) help peers find you; skip it when you only run workers.`;
 async function runHook(args, options) {
   const began = Date.now();
@@ -305,8 +370,10 @@ async function runHook(args, options) {
   const takes = !args.includes(NO_INJECT);
   const subagents = args.includes(SUBAGENT);
   const waits = pushWait(args, options.env);
+  const wakeAt = args.indexOf(WAKE);
+  const wakeS = wakeAt < 0 ? 0 : Number(args[wakeAt + 1]);
   const [harnessArg, eventArg] = args.filter(
-    (arg, i) => arg !== BLOCK_STOP && arg !== NO_INJECT && arg !== SUBAGENT && arg !== PUSH_WAIT && args[i - 1] !== PUSH_WAIT
+    (arg, i) => arg !== BLOCK_STOP && arg !== NO_INJECT && arg !== SUBAGENT && arg !== PUSH_WAIT && args[i - 1] !== PUSH_WAIT && arg !== WAKE && args[i - 1] !== WAKE
   );
   let payload;
   try {
@@ -315,18 +382,32 @@ async function runHook(args, options) {
   } catch {
     payload = {};
   }
+  if (Number.isFinite(wakeS) && wakeS > 0) return wakeHook(harnessArg, payload, wakeS, options);
   const event = mapHookPayload(payload, eventArg);
   if (!event || options.env.SCP_TRANSPORT === "cloud") return;
   const sub = subagents && (event.kind === "tool" || event.kind === "stop") ? subagentOf(payload) : void 0;
   if (subagents && !sub) return;
   if (event.kind === "session_end") options.deadline?.(1e3);
   if (event.kind === "session_start") options.deadline?.(1500);
+  const harness = normalizeHarness(hookHarness(harnessArg, options.env), "hook");
+  const pid = (options.harnessPid ?? ((h) => hookHarnessPid(options.env, h)))(harness);
+  const started = psStart(pid);
+  const joined = membership(
+    options.env,
+    sessionKey(
+      options.env,
+      processKey(pid, () => started)
+    )
+  );
+  if ("dark" in joined) return;
   const claim = relayIdentity({
-    harness: hookHarness(harnessArg, options.env),
+    ...joined.handle ? { as: joined.handle } : {},
+    harness,
     fallbackHarness: "hook",
     cwd: event.cwd ?? options.cwd,
     env: options.env,
-    harnessPid: options.harnessPid ?? ((harness) => hookHarnessPid(options.env, harness))
+    harnessPid: () => pid,
+    startOf: () => started
   });
   if (!validHandle(claim.handle)) return;
   const named = eventName(asString(field(payload, "hook_event_name", "hookEventName")) ?? eventArg);
@@ -345,7 +426,9 @@ async function runHook(args, options) {
   const inject = takes && !event.agent && (stop || injectsAt(claim.harness, event.kind)) && (options.remaining?.() ?? Number.POSITIVE_INFINITY) >= INJECT_MIN_MS;
   try {
     const posted = [client.hello({ transient: true, claim })];
-    if (event.kind === "prompt" && named === "userpromptsubmit") posted.push(client.request("prompted", {}));
+    const every = tldrEvery(options.env);
+    const prompted = event.kind === "prompt" && named === "userpromptsubmit" ? client.request("prompted", every ? { tldr_every: every } : {}) : void 0;
+    if (prompted) posted.push(prompted);
     if (event.kind !== "prompt") {
       const session = event.agent ? void 0 : asString(field(payload, "session_id", "sessionId"));
       const transcript = session && claim.harness === "claude-code" ? asString(field(payload, "transcript_path", "transcriptPath")) : void 0;
@@ -363,6 +446,8 @@ async function runHook(args, options) {
     if (event.status) posted.push(client.request("status", { state: event.status }));
     const turn = peekTurn(event, named, payload);
     if (turn) posted.push(client.request("peek_turn", turn));
+    const title = inferredTitle(claim.harness, event, named, payload);
+    if (title) posted.push(client.request("title_infer", title));
     const injected = inject ? client.request(
       "inject",
       counts ? { count: true, ...stop ? { stop: true, directives: true, ...blockStop ? { hold_unread: true } : {} } : {} } : {}
@@ -372,7 +457,8 @@ async function runHook(args, options) {
       const untitled = hello?.status === "fulfilled" && hello.value.endpoint?.title === null;
       return untitled && (claim.harness === "claude-code" || claim.harness === "codex") ? hookReply(claim.harness, event.kind, NUDGE) : void 0;
     }
-    if (result.status !== "fulfilled" || !result.value) return;
+    const tldr = (await prompted?.catch(() => void 0))?.tldr === true ? TLDR : void 0;
+    if (result.status !== "fulfilled" || !result.value) return tldr ? hookReply(claim.harness, event.kind, tldr) : void 0;
     const continues = !stop || claim.harness !== "claude-code" || stopContinues(claudeVersion(payload, options.env));
     if (stop && !result.value.block) {
       if (waits === void 0 || !PUSHES.has(claim.harness) || !(result.value.workers || result.value.worker_unread) || result.value.pushes_left === 0) return;
@@ -384,7 +470,7 @@ async function runHook(args, options) {
     const nudged = stop ? result.value.nudge ?? [] : [];
     const intro = !stop && result.value.intro ? introText(result.value.intro, result.value.intro_key) : void 0;
     const shown = stop || counts ? void 0 : injectionText({ ...result.value, more: await moreNow(client, result.value) }, claim.harness !== "agy");
-    const text = stop ? [directive?.text, [pointer, nudgeText(nudged, result.value.nudge_more)].filter(Boolean).join("\n")].filter(Boolean).join("\n\n") : [intro, counts ? unreadPointer(result.value.unread, result.value.awaiting) : shown].filter(Boolean).join("\n\n");
+    const text = stop ? [directive?.text, [pointer, nudgeText(nudged, result.value.nudge_more)].filter(Boolean).join("\n")].filter(Boolean).join("\n\n") : [intro, counts ? unreadPointer(result.value.unread, result.value.awaiting) : shown, tldr].filter(Boolean).join("\n\n");
     if (!text || (options.remaining?.() ?? Number.POSITIVE_INFINITY) < CONFIRM_MIN_MS) return;
     const reply = hookReply(claim.harness, event.kind, text, result.value.unread, continues);
     const offered = result.value.offered ?? [];
@@ -409,6 +495,45 @@ async function runHook(args, options) {
     client.close();
   }
 }
+async function wakeHook(harnessArg, payload, waitS, options) {
+  if (options.env.SCP_TRANSPORT === "cloud" || field(payload, "agent_id", "agentId", "agent_type", "agentType", "subagentType")) return;
+  const claim = relayIdentity({
+    harness: hookHarness(harnessArg, options.env),
+    fallbackHarness: "hook",
+    cwd: asString(payload.cwd) ?? options.cwd,
+    env: options.env,
+    harnessPid: options.harnessPid ?? ((harness) => hookHarnessPid(options.env, harness))
+  });
+  if (!validHandle(claim.handle)) return;
+  const waitMs = Math.min(waitS, LIMITS.waitMaxS) * 1e3;
+  options.deadline?.(waitMs + PUSH_PRINT_MS + 1e3);
+  const client = await options.connect(false);
+  try {
+    await client.hello({ transient: true, claim });
+    const result = await client.request("inject", { wait_s: waitMs / 1e3 });
+    if (!result.offered.length) return;
+    const intro = result.intro ? introText(result.intro, result.intro_key) : void 0;
+    const shown = injectionText({ ...result, more: await moreNow(client, result) });
+    const text = [intro, shown].filter(Boolean).join("\n\n");
+    if (!text) return;
+    const reply = hookReply(claim.harness, "prompt", text);
+    if (options.stopping?.()) return;
+    if (options.print?.(reply) ?? true) {
+      const read = result.messages.flatMap((message) => message.seq === void 0 ? [] : [message.seq]);
+      await client.request("injected", {
+        seqs: result.offered,
+        hold: result.hold,
+        ...read.length ? { read } : {},
+        deferred: true,
+        ...shown && !result.brief && result.messages.length ? { preamble: true } : {},
+        ...intro ? { intro: true } : {}
+      });
+    }
+    return reply;
+  } finally {
+    client.close();
+  }
+}
 var SUBAGENT_HARNESSES = /* @__PURE__ */ new Set(["claude-code"]);
 function subagentOf(payload) {
   const id = asString(field(payload, "agent_id", "agentId"));
@@ -481,6 +606,7 @@ async function relayHookCommand(args, startDaemon) {
   const started = Date.now();
   const agy = args[0] === "agy";
   let printed = false;
+  let stopping = false;
   const print = (text) => {
     if (printed) return false;
     printed = true;
@@ -497,6 +623,11 @@ async function relayHookCommand(args, startDaemon) {
     print(void 0);
     process.exit(0);
   };
+  const terminate = () => {
+    stopping = true;
+    if (!printed) quit();
+  };
+  if (args.includes(WAKE)) process.on("SIGTERM", terminate);
   let ends = started + (agy ? 900 : 1500);
   let timer = setTimeout(quit, ends - Date.now());
   const deadline = (ms) => {
@@ -515,6 +646,7 @@ async function relayHookCommand(args, startDaemon) {
         deadline,
         remaining: () => ends - Date.now(),
         print,
+        stopping: () => stopping,
         connect: (start) => start ? connectBroker(dir, () => startDaemon(dir), 1e3) : connectBroker(dir)
       })
     );
@@ -522,6 +654,7 @@ async function relayHookCommand(args, startDaemon) {
   }
   print(void 0);
   clearTimeout(timer);
+  if (args.includes(WAKE)) process.off("SIGTERM", terminate);
   return 0;
 }
 function stopArgs(options) {
@@ -626,6 +759,54 @@ const partId = (parts: Record<string, unknown>[]) => {
 }
 
 export const Scp = async ({ client, directory }: { client: any; directory: string }) => {
+  const WAKE = process.env.SCP_WAKE !== "0"
+  const busy = new Set<string>()
+  let target: string | undefined
+  let waiter: ReturnType<typeof spawn> | undefined
+  let looping = false
+  let armed = 0
+  const cancel = () => { waiter?.kill("SIGTERM") }
+  const wake = async () => {
+    if (looping) return
+    looping = true
+    let version = armed
+    try {
+      while (WAKE && target && busy.size === 0) {
+        const id = target
+        const began = Date.now()
+        let text: string | undefined
+        try {
+          const args = ["${CLI_NAME}", "hook", "opencode", "${WAKE}", "50"]
+          const child = spawn(args[0]!, args.slice(1), { env: { ...process.env }, stdio: ["pipe", "pipe", "ignore"] })
+          waiter = child
+          const ended = new Promise<void>((resolve, reject) => {
+            child.once("error", reject)
+            child.once("close", () => resolve())
+          })
+          child.stdin!.on("error", () => {})
+          child.stdin!.end(JSON.stringify({ hook_event_name: "Wake", 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 {
+          waiter = undefined
+        }
+        if (text) {
+          version = armed
+          await client.session.promptAsync({ path: { id }, body: { parts: [{ type: "text", text }] } }).catch(() => {})
+          break
+        }
+        if (Date.now() - began < 2000) await new Promise((resolve) => setTimeout(resolve, 5000))
+      }
+    } catch {} finally {
+      looping = false
+      if (armed !== version) void wake()
+    }
+  }
+  const arm = (id: string) => {
+    target = id
+    armed++
+    void wake()
+  }
   const children = new Map<string, Promise<boolean | undefined>>()
   const failed = new Set<string>()
   const isChild = async (id: string) => {
@@ -653,11 +834,14 @@ export const Scp = async ({ client, directory }: { client: any; directory: strin
     },
     "chat.message": async (input: { sessionID: string }, output: { message?: { id?: string }; parts: Record<string, unknown>[] }) => {
       const messageID = output.message?.id
-      if (!messageID || (await isChild(input.sessionID))) return
+      if (await isChild(input.sessionID)) return
+      busy.add(input.sessionID)
+      cancel()
+      if (!messageID) return
       const text = context(await hook({ hook_event_name: "UserPromptSubmit", session_id: input.sessionID, cwd: directory }, true))
       if (text) output.parts.push({ id: partId(output.parts), sessionID: input.sessionID, messageID, type: "text", text, synthetic: true })
     },
-    event: async ({ event }: { event: { type: string; properties?: { sessionID?: string; info?: { id?: string; parentID?: string; sessionID?: string; role?: string; error?: unknown } } } }) => {
+    event: async ({ event }: { event: { type: string; properties?: { sessionID?: string; status?: { type?: string }; info?: { id?: string; parentID?: string; sessionID?: string; role?: string; error?: unknown } } } }) => {
       const info = event.properties?.info
       if (event.type === "message.updated") {
         if (info?.role === "assistant" && info.sessionID && info.error) failed.add(info.sessionID)
@@ -669,15 +853,39 @@ export const Scp = async ({ client, directory }: { client: any; directory: strin
       if (!sessionID) return
       if (event.type === "session.error") failed.add(sessionID)
       if (event.type === "session.deleted") {
+        const child = await isChild(sessionID)
         children.delete(sessionID)
         failed.delete(sessionID)
+        if (!child) {
+          busy.delete(sessionID)
+          if (target === sessionID) target = undefined
+          cancel()
+        }
+        return
       }
       if (event.type === "session.created" && info) children.set(sessionID, Promise.resolve(Boolean(info.parentID)))
-      if (!name || (await isChild(sessionID))) return
+      if (await isChild(sessionID)) return
+      if (event.type === "session.status") {
+        const status = event.properties?.status?.type
+        if (status === "busy" || status === "retry") {
+          busy.add(sessionID)
+          cancel()
+        } else if (status === "idle") busy.delete(sessionID)
+        return
+      }
+      if (event.type === "session.idle") busy.delete(sessionID)
+      if (!name) return
       const stop = name === "Stop" && !failed.has(sessionID)
-      const reply = await hook({ hook_event_name: name, session_id: sessionID, cwd: directory, ...(name === "SessionStart" ? { source: "startup" } : {}) }, stop, name !== "Stop" || stop, stop && BLOCK_STOP)
+      const title = name === "Stop" ? await client.session.get({ path: { id: sessionID } }).then((found: any) => found?.data?.title).catch(() => undefined) : undefined
+      const reply = await hook(
+        { hook_event_name: name, session_id: sessionID, cwd: directory, ...(name === "SessionStart" ? { source: "startup" } : {}), ...(typeof title === "string" ? { session_title: title } : {}) },
+        stop,
+        name !== "Stop" || stop,
+        stop && BLOCK_STOP,
+      )
       const text = reply.decision === "block" && typeof reply.reason === "string" && !reply.reason.includes("<relay-message") ? reply.reason : undefined
       if (text) await client.session.promptAsync({ path: { id: sessionID }, body: { parts: [{ type: "text", text }] } }).catch(() => {})
+      else arm(sessionID)
     },
   }
 }
@@ -727,6 +935,8 @@ export {
   BLOCK_STOP,
   NO_INJECT,
   PUSH_WAIT,
+  WAKE,
+  OPENCODE_WAKE,
   PUSH_WAIT_DEFAULT_S,
   AGY_UNVERIFIED,
   summarize,
@@ -743,7 +953,13 @@ export {
   nudgeText,
   claudeVersionFile,
   stopContinues,
+  titleText,
+  promptTitle,
+  transcriptTitle,
   hookReply,
+  TLDR_EVERY_DEFAULT,
+  TLDR,
+  tldrEvery,
   runHook,
   subagentIntro,
   relayHookCommand,

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

@@ -1,17 +1,15 @@
 import {
+  RelayUsage,
   activeRelay,
   checkRelayUrl,
   configDir,
   relayCredential,
   writePrivateJson
-} from "./chunk-3RRPUYTE.js";
-import {
-  RelayUsage
-} from "./chunk-3V3DRXB2.js";
+} from "./chunk-E7JG5PJB.js";
 import {
   note,
   printTable
-} from "./chunk-M2DCR2J4.js";
+} from "./chunk-MNTIEWKF.js";
 
 // src/remote.ts
 import { existsSync, readFileSync, rmSync } from "fs";

package/dist/{claude-YJLGFQ2P.js → claude-CVWECMRQ.js}

@@ -3,16 +3,17 @@ import {
   mcpFile,
   mountedEntry,
   whichOnPath
-} from "./chunk-WV5FINTW.js";
-import "./chunk-5DYFYLAQ.js";
+} from "./chunk-NOYMSD4F.js";
+import "./chunk-F5QVHJIT.js";
+import "./chunk-OTO6DBU6.js";
+import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
-  RelayUsage
-} from "./chunk-3V3DRXB2.js";
-import "./chunk-RXKBND3T.js";
-import "./chunk-YYSLYVNZ.js";
-import "./chunk-E53YHYEP.js";
-import "./chunk-M2DCR2J4.js";
+  RelayUsage,
+  deriveHandle,
+  joinMode
+} from "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
 
 // src/claude.ts
 import { spawn } from "child_process";
@@ -33,6 +34,14 @@ function claudeArgv(argv) {
   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 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) {
   const file = mcpFile("claude", env);
   let entry;
@@ -47,7 +56,7 @@ function mountHint(env) {
   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] [--] [claude args...]   start Claude Code with the scp channel loaded, so peer messages wake it
 `);
@@ -58,7 +67,7 @@ async function claudeCommand(argv, env = process.env, err = (line) => void proce
   if (!bin) throw new RelayUsage("claude is not on PATH");
   const hint = mountHint(env);
   if (hint) err(hint);
-  const child = spawn(bin, [...CHANNEL_FLAGS, ...args], {
+  const child = spawn(bin, [...CHANNEL_FLAGS, ...namePrompt(name, args, env, cwd), ...args], {
     stdio: "inherit",
     env: { ...env, ...name !== void 0 ? { SCP_NAME: name } : {}, [CHANNELS_ENV]: String(process.pid) }
   });
@@ -84,5 +93,6 @@ export {
   CHANNEL_FLAGS,
   claudeArgv,
   claudeCommand,
-  mountHint
+  mountHint,
+  namePrompt
 };