sessionpipe 0.12.0 → 0.13.1

package/dist/index.js

@@ -1,4 +1,9 @@
-// sessionpipe 0.12.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe 0.13.1 · Apache-2.0 · https://sessionpipe.org
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/http-sink.ts
 import { createHash, createHmac } from "node:crypto";
@@ -99,16 +104,16 @@ var HttpSink = class {
 import {
   appendFileSync as appendFileSync3,
   existsSync as existsSync10,
-  mkdirSync as mkdirSync8,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync10,
-  renameSync as renameSync3,
-  statSync as statSync6,
-  unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync8
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync12,
+  renameSync as renameSync4,
+  statSync as statSync7,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import os3 from "node:os";
-import path15 from "node:path";
+import os4 from "node:os";
+import path17 from "node:path";
 
 // ../core/src/paths.ts
 import os from "node:os";
@@ -136,7 +141,7 @@ var safeId = (s) => String(s).replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 160);
 // ../core/src/adapters/claude-code.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import { userInfo } from "node:os";
 import path4 from "node:path";
 
@@ -288,7 +293,14 @@ ${m.text}`;
         continue;
       }
       if (cur) turns.push(cur);
-      cur = { user: m.text, assistant: "", at: m.at, startLine: m.line, endLine: m.line };
+      cur = {
+        user: m.text,
+        assistant: "",
+        at: m.at,
+        startLine: m.line,
+        endLine: m.line,
+        ...m.injected ? { injected: true } : {}
+      };
     } else {
       if (!cur) cur = { user: "", assistant: "", at: m.at, startLine: m.line, endLine: m.line };
       cur.assistant += (cur.assistant ? "\n\n" : "") + m.text;
@@ -298,10 +310,17 @@ ${m.text}`;
   if (cur?.assistant) turns.push(cur);
   const line = cur && !cur.assistant ? cur.startLine : endLine;
   const out = {
-    turns: turns.map((t) => ({ user: t.user, assistant: t.assistant, at: t.at, endLine: t.endLine })),
+    turns: turns.map((t) => ({
+      user: t.user,
+      assistant: t.assistant,
+      at: t.at,
+      endLine: t.endLine,
+      ...t.injected ? { injected: true } : {}
+    })),
     line
   };
-  if (cur && !cur.assistant && cur.user) out.open = { user: cur.user, at: cur.at };
+  if (cur && !cur.assistant && cur.user)
+    out.open = { user: cur.user, at: cur.at, ...cur.injected ? { injected: true } : {} };
   return out;
 }
 var isInjected = (text) => /^<[a-z_-]+(?:\s[^>]*)?>/i.test(text) && /<\/[a-z_-]+>\s*$/i.test(text) || /^<!--\s/.test(text) || /^<command-/.test(text);
@@ -324,27 +343,51 @@ var textParts = (c, kinds) => {
     (b) => b && typeof b === "object" && kinds.includes(b.type ?? "") && typeof b.text === "string"
   ).map((b) => b.text).join("\n");
 };
+var SPOKEN = /* @__PURE__ */ new Set(["human", "peer"]);
+var PEER_INTRO = /sent a message[^\n]*:$/;
+var PEER_OUTRO = "\n\nThis came from another ";
+var ENVELOPE = /^<cross-session-message\b[^>]*>\n([\s\S]*)\n<\/cross-session-message>$/;
+function peerAsk(origin, text) {
+  const body = origin?.body;
+  let t = typeof body === "string" && body.trim() ? body : text;
+  if (t !== body) {
+    const nl = t.indexOf("\n");
+    if (nl > 0 && PEER_INTRO.test(t.slice(0, nl))) t = t.slice(nl + 1);
+    const outro = t.indexOf(PEER_OUTRO);
+    if (outro > 0) t = t.slice(0, outro);
+  }
+  return (ENVELOPE.exec(t.trim())?.[1] ?? t).trim();
+}
 var queuedPrompt = (a) => {
   if (!a || typeof a !== "object") return "";
   const q = a;
   if (q.type !== "queued_command" || (q.commandMode ?? "prompt") !== "prompt") return "";
-  if (q.origin?.kind && q.origin.kind !== "human") return "";
-  return textParts(q.prompt, ["text"]).trim();
+  const kind = q.origin?.kind ?? "human";
+  if (!SPOKEN.has(kind)) return "";
+  const text = textParts(q.prompt, ["text"]).trim();
+  return kind === "peer" ? peerAsk(q.origin, text) : text;
 };
+var channelText = (text) => /^<channel\b[^>]*>([\s\S]*)<\/channel>$/.exec(text)?.[1]?.trim() ?? "";
 function readClaude(lines, from) {
   const msgs = [];
   for (let i = from; i < lines.length; i++) {
     const j = lines[i] ? parse(lines[i]) : null;
     if (!j || j.isSidechain) continue;
     const origin = j.origin;
-    if (j.type === "user" && (j.isMeta || j.isCompactSummary || j.repeatsCompactSummary || origin?.kind && origin.kind !== "human"))
-      continue;
+    const channel = j.type === "user" && origin?.kind === "channel";
+    const peer = origin?.kind === "peer";
+    if (j.type === "user" && (j.isCompactSummary || j.repeatsCompactSummary)) continue;
+    if (j.type === "user" && !channel && !peer && (j.isMeta || origin?.kind && origin.kind !== "human")) continue;
     const at = Date.parse(String(j.timestamp ?? "")) || Date.now();
     const c = j.message?.content;
-    if (j.type === "user") {
-      const text = textParts(c, ["text"]).trim();
+    if (channel) {
+      const text = channelText(textParts(c, ["text"]).trim());
+      if (text) msgs.push({ role: "user", text, at, line: i, injected: true });
+    } else if (j.type === "user") {
+      const raw = textParts(c, ["text"]).trim();
+      const text = peer ? peerAsk(origin, raw) : raw;
       if (!text || isInjected(text)) continue;
-      msgs.push({ role: "user", text, at, line: i });
+      msgs.push({ role: "user", text, at, line: i, ...peer ? { injected: true } : {} });
     } else if (j.type === "assistant" && Array.isArray(c)) {
       const text = textParts(c, ["text"]).trim();
       if (text) msgs.push({ role: "assistant", text, at, line: i });
@@ -456,6 +499,41 @@ function readJson(file) {
   const f = readJsonFile(file);
   return f.ok ? f.value : {};
 }
+function refused(file, e, what, existed) {
+  const { code, syscall } = e;
+  const why = `can't ${what} it (${code ?? String(e)})`;
+  if (what === "remove" || syscall === "open" || syscall === "mkdir")
+    return { file, changed: false, skipped: true, note: `${why}; not touched` };
+  return {
+    file,
+    changed: true,
+    skipped: true,
+    ...existed ? {} : { created: true },
+    note: `${why} part way; check the file before the harness reads it`
+  };
+}
+function writeBack(file, text, existed = true) {
+  try {
+    mkdirSync(path3.dirname(file), { recursive: true });
+    writeFileSync(file, text);
+    return null;
+  } catch (e) {
+    return refused(file, e, "write", existed);
+  }
+}
+function removeEmptied(file, empty) {
+  try {
+    unlinkSync(file);
+    return { file, changed: true, note: "removed (sessionpipe created it)" };
+  } catch (e) {
+    const bad = refused(file, e, "remove", true);
+    return writeBack(file, empty) ?? {
+      file,
+      changed: true,
+      note: `emptied; ${bad.note.replace(/; not touched$/, "")}, so the empty file stays`
+    };
+  }
+}
 function entryFor(event, harness, cmd, o) {
   const matcher = o.matcherFor(event);
   return {
@@ -497,8 +575,8 @@ function installClaudeShaped(file, harness, events, cmd, o) {
   }
   if (changed) {
     settings2.hooks = hooks;
-    mkdirSync(path3.dirname(file), { recursive: true });
-    writeFileSync(file, formatJson(settings2, f));
+    const bad = writeBack(file, formatJson(settings2, f), f.existed);
+    if (bad) return bad;
   }
   return { file, changed, created: !f.existed && changed };
 }
@@ -521,12 +599,8 @@ function uninstallClaudeShaped(file, events, opts = {}) {
   }
   if (!changed) return { file, changed: false };
   if (!Object.keys(hooks).length) delete settings2.hooks;
-  if (opts.created && !Object.keys(settings2).length) {
-    unlinkSync(file);
-    return { file, changed: true, note: "removed (sessionpipe created it)" };
-  }
-  writeFileSync(file, formatJson(settings2, f));
-  return { file, changed: true };
+  if (opts.created && !Object.keys(settings2).length) return removeEmptied(file, formatJson(settings2, f));
+  return writeBack(file, formatJson(settings2, f)) ?? { file, changed: true };
 }
 function installedClaudeShaped(file, harness, events, cmd, o) {
   const f = readJsonFile(file);
@@ -605,7 +679,7 @@ var claudeCode = {
   configFiles: (env = process.env) => claudeDirs(env).map(settingsIn),
   install: (cmd, env = process.env, opts = {}) => claudeDirs(env).flatMap((d) => {
     const hooks = installClaudeShaped(settingsIn(d), NAME, eventsFor(opts.lean), cmd, OPTS);
-    const line = opts.statusLine === void 0 ? null : statusLine(settingsIn(d), opts.statusLine, cmd);
+    const line = opts.statusLine === void 0 || hooks.skipped ? null : statusLine(settingsIn(d), opts.statusLine, cmd);
     return line ? [hooks, line] : [hooks];
   }),
   uninstall: (env = process.env, opts = {}) => claudeDirs(env).map((d) => {
@@ -613,7 +687,9 @@ var claudeCode = {
     const hooks = uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS, {
       created: opts.created?.includes(settingsIn(d))
     });
-    return line && !hooks.changed ? line : hooks;
+    if (line?.changed && !line.skipped && hooks.skipped)
+      return { ...hooks, note: `status line removed, hooks not: ${hooks.note?.replace(/; not touched$/, "")}` };
+    return line && !hooks.changed && !hooks.skipped ? line : hooks;
   }),
   installed: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
     file: settingsIn(d),
@@ -708,7 +784,8 @@ var claudeCode = {
             attention_id: call_id ?? permissionId(),
             kind: "permission",
             tool,
-            message: tool ? `${tool}${describe(s.tool_input)}` : void 0
+            message: tool ? `${tool}${describe(s.tool_input)}` : void 0,
+            agent_id
           })
         );
         break;
@@ -717,7 +794,8 @@ var claudeCode = {
           ev("attention.needed", {
             attention_id: `notif-${Date.now()}`,
             kind: notifKind(s.notification_type),
-            message: typeof s.message === "string" ? s.message.slice(0, 200) : void 0
+            message: typeof s.message === "string" ? s.message.slice(0, 200) : void 0,
+            agent_id
           })
         );
         break;
@@ -842,8 +920,11 @@ function statusLine(file, want, cmd) {
   if (want ? ours && cur?.command === command && cur?.refreshInterval === LINE_REFRESH_S : !ours) return null;
   if (want) f.value.statusLine = { type: "command", command, refreshInterval: LINE_REFRESH_S };
   else delete f.value.statusLine;
-  writeFileSync2(file, formatJson(f.value, f));
-  return { file, changed: true, note: want ? "status line written (account limits)" : "status line removed" };
+  return writeBack(file, formatJson(f.value, f), f.existed) ?? {
+    file,
+    changed: true,
+    note: want ? "status line written (account limits)" : "status line removed"
+  };
 }
 var epochIso = (t) => typeof t === "number" && t > 0 && t < 1e11 ? new Date(t * 1e3).toISOString() : void 0;
 var WINDOW_MINUTES = { five_hour: 300, seven_day: 10080 };
@@ -1258,8 +1339,44 @@ async function claudeAiTitle(bridge, token) {
 }
 
 // ../core/src/adapters/headless.ts
+import { spawn } from "node:child_process";
 import { accessSync, constants, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
 import path5 from "node:path";
+
+// ../core/src/launched-by.ts
+var LAUNCHED_BY_ENV = "SESSIONPIPE_LAUNCHED_BY";
+var DELEGATED_BY_ENV = "SESSIONPIPE_ASKED_BY";
+var ASK_CHAIN_ENV = "SESSIONPIPE_ASK_CHAIN";
+var LINEAGE_ENV = [LAUNCHED_BY_ENV, DELEGATED_BY_ENV, ASK_CHAIN_ENV];
+var SESSION_REF = /^[a-z][a-z0-9-]{0,39}:[A-Za-z0-9._:-]{1,128}$/;
+function withoutLineage(env) {
+  const e = { ...env };
+  for (const k of LINEAGE_ENV) delete e[k];
+  return e;
+}
+function refIn(env, name) {
+  const v = env[name]?.trim();
+  return v && SESSION_REF.test(v) ? v : void 0;
+}
+function launchedBy(env) {
+  return refIn(env, LAUNCHED_BY_ENV);
+}
+function delegatedBy(env) {
+  return refIn(env, DELEGATED_BY_ENV);
+}
+function readHook(adapter, input) {
+  const r = adapter.fromHook(input);
+  if (r && !r.session.parent_id) {
+    const self = `${adapter.name}:${r.session.id}`;
+    const launcher = launchedBy(input.env);
+    if (launcher && launcher !== self) r.session.launched_by = launcher;
+    const asker = delegatedBy(input.env);
+    if (asker && asker !== self) r.session.delegated_by = asker;
+  }
+  return r;
+}
+
+// ../core/src/adapters/headless.ts
 var JOB_TIMEOUT_MS = 30 * 6e4;
 var OUT_CAP = 1024 * 1024;
 function isExe(p) {
@@ -1301,22 +1418,119 @@ function spawnable(bin, args) {
   const target = shimTarget(bin);
   return target ? { file: process.execPath, args: [target, ...args] } : null;
 }
+var shimNote = (bin) => `${path5.basename(bin)} is a launcher script that names no program to run; point the harness's override (SESSIONPIPE_CLAUDE, SESSIONPIPE_CODEX, \u2026) at the program itself`;
 function probe(bin, args) {
   const s = spawnable(bin, args);
   return s ? { ...s, shell: false } : { file: [`"${bin}"`, ...args].join(" "), args: [], shell: true };
 }
+function runHeadless(bin, args, o) {
+  return new Promise((resolve) => {
+    let out = [];
+    let outLen = 0;
+    let tooBig = false;
+    let errTail = "";
+    let timedOut = false;
+    let settled = false;
+    let child;
+    const c = spawnable(bin, args);
+    if (!c) {
+      resolve({ error: shimNote(bin) });
+      return;
+    }
+    try {
+      child = spawn(c.file, c.args, {
+        cwd: o.cwd,
+        env: o.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+        windowsHide: true
+      });
+    } catch (e) {
+      resolve({ error: e.message });
+      return;
+    }
+    const kill = (sig) => {
+      try {
+        if (process.platform !== "win32" && child.pid) process.kill(-child.pid, sig);
+        else child.kill(sig);
+      } catch {
+        try {
+          child.kill(sig);
+        } catch {
+        }
+      }
+    };
+    const keep = (line) => {
+      if (!o.keep?.(line)) return;
+      out = [Buffer.from(line)];
+      outLen = line.length;
+    };
+    let partial = "";
+    child.stdout?.on("data", (b) => {
+      if (o.onLine) {
+        const chunk = partial + b.toString("utf8");
+        const lines = chunk.split("\n");
+        partial = lines.pop();
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            o.onLine(line);
+          } catch {
+          }
+          keep(line);
+        }
+        if (partial.length > OUT_CAP) partial = "";
+        return;
+      }
+      if (tooBig) return;
+      if (outLen + b.length > OUT_CAP) {
+        tooBig = true;
+        out = [];
+        return;
+      }
+      out.push(b);
+      outLen += b.length;
+    });
+    child.stderr?.on("data", (b) => {
+      errTail = (errTail + b.toString("utf8")).slice(-4e3);
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill("SIGTERM");
+      setTimeout(() => kill("SIGKILL"), 1e4).unref();
+    }, o.timeoutMs ?? JOB_TIMEOUT_MS);
+    const result = (code, signal) => ({
+      code,
+      signal,
+      stdout: tooBig ? null : Buffer.concat(out).toString("utf8"),
+      tooBig,
+      stderr: errTail,
+      timedOut
+    });
+    const finish = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(r);
+    };
+    child.on("error", (e) => finish({ error: e.message }));
+    child.on("exit", (code, signal) => setTimeout(() => finish(result(code, signal)), 2e3).unref());
+    child.on("close", (code, signal) => {
+      if (o.onLine && partial.trim()) {
+        try {
+          o.onLine(partial);
+        } catch {
+        }
+        keep(partial);
+        partial = "";
+      }
+      finish(result(code, signal));
+    });
+  });
+}
 
 // ../core/src/adapters/antigravity.ts
-import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync4,
-  realpathSync,
-  statSync as statSync4,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
-} from "node:fs";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, realpathSync, statSync as statSync4 } from "node:fs";
 import path6 from "node:path";
 var NAME2 = "antigravity";
 var HOOK_NAME = "sessionpipe";
@@ -1348,10 +1562,8 @@ var antigravity = {
     const e = entry(cmd);
     if (JSON.stringify(hooks[HOOK_NAME]) === JSON.stringify(e)) return [{ file, changed: false }];
     hooks[HOOK_NAME] = e;
-    mkdirSync2(path6.dirname(file), { recursive: true });
-    writeFileSync3(file, formatJson(hooks, f));
     return [
-      {
+      writeBack(file, formatJson(hooks, f), f.existed) ?? {
         file,
         changed: true,
         created: !f.existed,
@@ -1367,12 +1579,8 @@ var antigravity = {
     const hooks = f.value;
     if (!(HOOK_NAME in hooks)) return [{ file, changed: false }];
     delete hooks[HOOK_NAME];
-    if (opts.created?.includes(file) && !Object.keys(hooks).length) {
-      unlinkSync2(file);
-      return [{ file, changed: true, note: "removed (sessionpipe created it)" }];
-    }
-    writeFileSync3(file, formatJson(hooks, f));
-    return [{ file, changed: true }];
+    if (opts.created?.includes(file) && !Object.keys(hooks).length) return [removeEmptied(file, formatJson(hooks, f))];
+    return [writeBack(file, formatJson(hooks, f)) ?? { file, changed: true }];
   },
   installed(cmd, env = process.env) {
     const file = hooksFile(env);
@@ -1594,6 +1802,50 @@ function antigravityFacts(file, opts) {
   return out;
 }
 
+// ../core/src/adapters/claude-code-control.ts
+var claude_code_control_exports = {};
+__export(claude_code_control_exports, {
+  CLAUDE_MODES: () => CLAUDE_MODES,
+  JOB_TIMEOUT_MS: () => JOB_TIMEOUT_MS,
+  MODE_RANK: () => MODE_RANK,
+  NO_HOME_SETTINGS: () => NO_HOME_SETTINGS,
+  ceilingLevel: () => ceilingLevel,
+  claudeArgs: () => claudeArgs,
+  claudeEnv: () => claudeEnv,
+  claudeLogin: () => claudeLogin2,
+  cmpVersion: () => cmpVersion,
+  defaultLevel: () => defaultLevel,
+  detectCaps: () => detectCaps,
+  findClaude: () => findClaude,
+  findTranscript: () => findTranscript,
+  findTranscripts: () => findTranscripts,
+  homeSettings: () => homeSettings,
+  hookMode: () => hookMode,
+  isUuid: () => isUuid,
+  liveProcess: () => liveProcess,
+  liveRecord: () => liveRecord,
+  liveRecords: () => liveRecords,
+  loginCommand: () => loginCommand,
+  loginHint: () => loginHint,
+  modeFlags: () => modeFlags,
+  modeRank: () => modeRank,
+  offeredLevels: () => offeredLevels,
+  outputArgs: () => outputArgs,
+  parseAuthStatus: () => parseAuthStatus,
+  parseCaps: () => parseCaps,
+  parseResult: () => parseResult,
+  peerClass: () => peerClass,
+  recentlyWritten: () => recentlyWritten,
+  relaunchMode: () => relaunchMode,
+  resolveHome: () => resolveHome,
+  runClaude: () => runClaude,
+  sessionFolder: () => sessionFolder
+});
+import { execFile, execFileSync as execFileSync3 } from "node:child_process";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync5, readSync as readSync2, statSync as statSync5 } from "node:fs";
+import os2 from "node:os";
+import path7 from "node:path";
+
 // ../core/src/control/verify.ts
 var GRANT_MAX_MS = 24 * 36e5;
 var SKEW_MS = 5 * 6e4;
@@ -1604,10 +1856,10 @@ var MODEL_RE = /^[A-Za-z0-9][A-Za-z0-9._:/@[\]-]*$/;
 var START_PERMISSIONS = ["read", "safe", "edits", "auto"];
 var levelRank = (l) => START_PERMISSIONS.indexOf(l);
 var FIELDS = {
-  prompt: ["text", "files"],
+  prompt: ["text", "files", "reply_to"],
   "permission.answer": ["for", "decision"],
   cancel: [],
-  start: ["text", "cwd", "files", "permission", "model"],
+  start: ["text", "cwd", "files", "permission", "model", "reply_to"],
   "key.add": ["key", "name"],
   pool: ["pool_action", "pool_account", "pool_order", "pool_code"]
 };
@@ -1615,9 +1867,454 @@ var POOL_FIELDS = FIELDS.pool;
 var enc = new TextEncoder();
 var dec = new TextDecoder();
 
+// ../core/src/adapters/claude-code-control.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var LIVE_WRITE_MS = 9e4;
+var cmpVersion = (a, b) => {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++)
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
+  return 0;
+};
+function findClaude(env = process.env, home = os2.homedir()) {
+  if (env.SESSIONPIPE_CLAUDE && isExe(env.SESSIONPIPE_CLAUDE)) return env.SESSIONPIPE_CLAUDE;
+  const names = process.platform === "win32" ? ["claude.exe", "claude.cmd"] : ["claude"];
+  for (const d of String(env.PATH || "").split(path7.delimiter)) {
+    if (!d || !path7.isAbsolute(d)) continue;
+    for (const n of names) if (isExe(path7.join(d, n))) return path7.join(d, n);
+  }
+  for (const p of [
+    path7.join(home, ".claude", "local", "claude"),
+    path7.join(home, ".local", "bin", "claude"),
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude"
+  ])
+    if (isExe(p)) return p;
+  const app = path7.join(home, "Library", "Application Support", "Claude", "claude-code");
+  let versions = [];
+  try {
+    versions = readdirSync4(app).filter((n) => /^\d+(\.\d+)*$/.test(n)).sort(cmpVersion).reverse();
+  } catch {
+  }
+  for (const v of versions) {
+    const p = path7.join(app, v, "claude.app", "Contents", "MacOS", "claude");
+    if (isExe(p)) return p;
+  }
+  return null;
+}
+function optionBlock(help, flag) {
+  const lines = help.split("\n");
+  const re = new RegExp(`^\\s{0,4}(?:-\\w, )?${flag.replace(/-/g, "\\-")}(?![\\w-])`);
+  const start = lines.findIndex((l) => re.test(l));
+  if (start < 0) return null;
+  const out = [lines[start]];
+  for (let i = start + 1; i < lines.length && lines[i]?.trim() && !/^\s{0,4}-/.test(lines[i]); i++)
+    out.push(lines[i]);
+  return out.join(" ");
+}
+function parseCaps(help) {
+  const pm = optionBlock(help, "--permission-mode");
+  const pp = optionBlock(help, "--permission-prompts");
+  return {
+    hasMode: !!pm,
+    modes: pm ? [...pm.matchAll(/"([A-Za-z]+)"/g)].map((m) => m[1]) : [],
+    promptsNone: !!pp && /"none"/.test(pp),
+    fork: !!optionBlock(help, "--fork-session"),
+    stream: !!optionBlock(help, "--include-partial-messages")
+  };
+}
+var LEVEL_MODE = {
+  read: "plan",
+  edits: "acceptEdits",
+  auto: "auto"
+};
+function modeFlags(level, caps) {
+  if (level === "inherit") return { args: [] };
+  if (caps.unread)
+    return { error: `this machine couldn't read its Claude Code's options (${caps.unread}); try again in a minute` };
+  if (level === "auto" && !caps.modes.includes("auto"))
+    return { error: "this machine is in auto mode, but its Claude Code has no auto permission mode" };
+  if (level !== "safe") {
+    const m = LEVEL_MODE[level];
+    if (!caps.modes.includes(m)) return { error: `this machine's Claude Code has no ${m} permission mode` };
+    return { args: ["--permission-mode", m] };
+  }
+  if (caps.modes.includes("dontAsk")) return { args: ["--permission-mode", "dontAsk"] };
+  const args = [];
+  if (caps.hasMode)
+    args.push(
+      "--permission-mode",
+      caps.modes.includes("manual") && !caps.modes.includes("default") ? "manual" : "default"
+    );
+  if (caps.promptsNone) args.push("--permission-prompts", "none");
+  return { args };
+}
+var ceilingLevel = (mode) => mode === "inherit" ? "safe" : mode;
+function offeredLevels(mode, caps) {
+  if (caps.unread) return [];
+  return START_PERMISSIONS.filter(
+    (l) => levelRank(l) <= levelRank(ceilingLevel(mode)) && (l === "safe" || caps.modes.includes(LEVEL_MODE[l]))
+  );
+}
+var defaultLevel = (mode) => mode;
+function outputArgs(caps) {
+  return caps.stream ? ["--output-format", "stream-json", "--verbose", "--include-partial-messages"] : ["--output-format", "json"];
+}
+function claudeArgs(o) {
+  const mf = modeFlags(o.level, o.caps);
+  if ("error" in mf) return mf;
+  const where = o.resume ? ["--resume", o.resume, ...o.fork ? ["--fork-session"] : []] : ["--session-id", o.session];
+  return {
+    args: [
+      "-p",
+      ...outputArgs(o.caps),
+      ...mf.args,
+      ...o.model ? ["--model", o.model] : [],
+      ...o.allowedTools?.length ? [`--allowedTools=${o.allowedTools.join(",")}`] : [],
+      ...where,
+      o.prompt.startsWith("-") ? ` ${o.prompt}` : o.prompt
+    ]
+  };
+}
+function claudeEnv(configDir, env = process.env) {
+  const e = withoutLineage(env);
+  for (const k of [
+    "CLAUDECODE",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_HOST_SESSION_ID",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_SESSION_ATTENDED",
+    "CLAUDE_CODE_SSE_PORT"
+  ])
+    delete e[k];
+  e.SESSIONPIPE_CONTROL_JOB = "1";
+  if (configDir !== void 0) {
+    if (path7.resolve(configDir) === path7.resolve(os2.homedir(), ".claude")) delete e.CLAUDE_CONFIG_DIR;
+    else e.CLAUDE_CONFIG_DIR = configDir;
+  }
+  return e;
+}
+function parseAuthStatus(stdout) {
+  const text = String(stdout || "").trim();
+  const start = text.indexOf("{");
+  if (start < 0) return { loggedIn: null };
+  try {
+    const j = JSON.parse(text.slice(start));
+    if (typeof j.loggedIn !== "boolean") return { loggedIn: null };
+    return {
+      loggedIn: j.loggedIn,
+      ...typeof j.authMethod === "string" ? { method: j.authMethod } : {},
+      ...typeof j.subscriptionType === "string" ? { subscription: j.subscriptionType } : {}
+    };
+  } catch {
+    return { loggedIn: null };
+  }
+}
+function claudeLogin2(bin, configDir, env = process.env) {
+  const c = probe(bin, ["auth", "status", "--json"]);
+  return new Promise((resolve) => {
+    execFile(
+      c.file,
+      c.args,
+      { encoding: "utf8", timeout: 2e4, env: claudeEnv(configDir, env), maxBuffer: 256 * 1024, shell: c.shell },
+      // `auth status` may exit non-zero when signed out; its JSON still says so.
+      (_err, stdout) => resolve(parseAuthStatus(stdout))
+    );
+  });
+}
+function loginCommand(configDir) {
+  const home = os2.homedir();
+  const isDefault = !configDir || path7.resolve(configDir) === path7.resolve(home, ".claude");
+  return isDefault ? "`claude auth login`" : `\`CLAUDE_CONFIG_DIR=${configDir.replace(home, "~")} claude auth login\``;
+}
+function loginHint(configDir, platform = process.platform) {
+  const shown = configDir ? configDir.replace(os2.homedir(), "~") : "~/.claude";
+  const login = loginCommand(configDir);
+  if (platform === "darwin")
+    return `Claude Code (${shown}) isn't signed in as this machine's background service sees it. On a Mac its login lives in the login keychain, which a background service can read only while someone is logged in at the screen: log in at the Mac, or run ${login} there.`;
+  return `Claude Code (${shown}) isn't signed in on this machine: run ${login} there.`;
+}
+function detectCaps(bin, timeoutMs = 3e4) {
+  const c = probe(bin, ["--help"]);
+  try {
+    return parseCaps(
+      execFileSync3(c.file, c.args, {
+        encoding: "utf8",
+        timeout: timeoutMs,
+        env: claudeEnv(),
+        stdio: ["ignore", "pipe", "pipe"],
+        maxBuffer: 4 * 1024 * 1024,
+        shell: c.shell
+      })
+    );
+  } catch (e) {
+    const err = e;
+    const caps = parseCaps(String(err?.stdout || ""));
+    if (caps.hasMode) return caps;
+    const why = err?.code === "ETIMEDOUT" ? `timed out after ${timeoutMs / 1e3} s` : "failed";
+    return { ...caps, unread: `\`${path7.basename(bin)} --help\` ${why}` };
+  }
+}
+function transcriptIn(session, dir) {
+  let projects = [];
+  try {
+    projects = readdirSync4(path7.join(dir, "projects"), { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const p of projects) {
+    if (!p.isDirectory()) continue;
+    const file = path7.join(dir, "projects", p.name, `${session}.jsonl`);
+    try {
+      if (statSync5(file).isFile()) return { file, configDir: dir, project: p.name };
+    } catch {
+    }
+  }
+  return null;
+}
+function findTranscript(session, dirs) {
+  if (!UUID_RE.test(session)) return null;
+  for (const dir of dirs) {
+    const t = transcriptIn(session, dir);
+    if (t) return t;
+  }
+  return null;
+}
+function findTranscripts(session, dirs) {
+  if (!UUID_RE.test(session)) return [];
+  const out = [];
+  for (const dir of dirs) {
+    const t = transcriptIn(session, dir);
+    if (t) out.push(t);
+  }
+  return out;
+}
+var homeName = (t) => path7.basename(t.configDir);
+function resolveHome(session, dirs) {
+  const all = findTranscripts(session, dirs);
+  if (!all.length) return null;
+  if (all.length === 1) return { transcript: all[0] };
+  const live = all.filter((t) => liveRecords(session, t.configDir).length > 0);
+  if (live.length === 1) return { transcript: live[0] };
+  return {
+    ambiguous: [...new Set(all.map(homeName))].sort(),
+    live: [...new Set(live.map(homeName))].sort()
+  };
+}
+var projectName = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, "-");
+function sessionFolder(t, cap2 = 8 * 1024 * 1024) {
+  let first = null;
+  let count = 0;
+  let fd;
+  const look = (line) => {
+    if (line.indexOf('"cwd"') < 0) return null;
+    let j;
+    try {
+      j = JSON.parse(line.toString("utf8"));
+    } catch {
+      return null;
+    }
+    if (!j || typeof j.cwd !== "string" || !path7.isAbsolute(j.cwd)) return null;
+    if (projectName(j.cwd) === t.project) return j.cwd;
+    first ??= j.cwd;
+    count++;
+    return null;
+  };
+  try {
+    fd = openSync2(t.file, "r");
+    const buf = Buffer.alloc(256 * 1024);
+    let pos = 0;
+    let rest = Buffer.alloc(0);
+    let skipping = false;
+    while (pos < cap2 && count < 50) {
+      const n = readSync2(fd, buf, 0, buf.length, pos);
+      if (!n) {
+        if (!skipping && rest.length) {
+          const hit = look(rest);
+          if (hit) return hit;
+        }
+        break;
+      }
+      pos += n;
+      let chunk = rest.length ? Buffer.concat([rest, buf.subarray(0, n)]) : buf.subarray(0, n);
+      let nl = chunk.indexOf(10);
+      while (nl >= 0) {
+        const line = chunk.subarray(0, nl);
+        chunk = chunk.subarray(nl + 1);
+        if (skipping) skipping = false;
+        else {
+          const hit = look(line);
+          if (hit) return hit;
+        }
+        nl = chunk.indexOf(10);
+      }
+      if (chunk.length > 2 * 1024 * 1024) {
+        skipping = true;
+        rest = Buffer.alloc(0);
+      } else rest = skipping ? Buffer.alloc(0) : Buffer.from(chunk);
+    }
+  } catch {
+  } finally {
+    if (fd !== void 0)
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+  }
+  return first;
+}
+function pidAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+var registryRow = (file, configDir, j) => {
+  const pid = Number(j.pid ?? path7.basename(file).slice(0, -5));
+  const str = (v) => typeof v === "string" && v ? v : null;
+  let keyFile = null;
+  try {
+    const want = new RegExp(`^${pid}\\.[0-9a-f]{64}\\.key$`);
+    const hit = readdirSync4(path7.dirname(file)).find((n) => want.test(n));
+    if (hit) keyFile = path7.join(path7.dirname(file), hit);
+  } catch {
+  }
+  return {
+    configDir,
+    file,
+    pid,
+    socket: str(j.messagingSocketPath),
+    peerProtocol: typeof j.peerProtocol === "number" ? j.peerProtocol : null,
+    procStart: str(j.procStart),
+    status: str(j.status),
+    kind: str(j.kind),
+    entrypoint: str(j.entrypoint),
+    keyFile
+  };
+};
+function liveRecords(session, dirs) {
+  const out = [];
+  for (const dir of typeof dirs === "string" ? [dirs] : dirs) {
+    let names = [];
+    try {
+      names = readdirSync4(path7.join(dir, "sessions")).filter((n) => /^\d+\.json$/.test(n));
+    } catch {
+      continue;
+    }
+    for (const n of names) {
+      const file = path7.join(dir, "sessions", n);
+      let j;
+      try {
+        j = JSON.parse(readFileSync5(file, "utf8"));
+      } catch {
+        continue;
+      }
+      if (String(j.sessionId) !== session) continue;
+      const row = registryRow(file, dir, j);
+      if (pidAlive(row.pid)) out.push(row);
+    }
+  }
+  return out;
+}
+function liveRecord(session, dirs) {
+  const all = liveRecords(session, dirs);
+  return all.length === 1 ? all[0] : null;
+}
+function liveProcess(session, configDir) {
+  return liveRecords(session, configDir).length > 0;
+}
+var MODE_RANK = {
+  plan: 0,
+  default: 1,
+  manual: 1,
+  dontAsk: 1,
+  acceptEdits: 2,
+  auto: 3,
+  bypassPermissions: 4
+};
+var CLAUDE_MODES = Object.keys(MODE_RANK);
+var modeRank = (m) => m && m in MODE_RANK ? MODE_RANK[m] : -1;
+function hookMode(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  const v = typeof p.permission_mode === "string" ? p.permission_mode : p.permissionMode;
+  return typeof v === "string" && CLAUDE_MODES.includes(v) ? v : null;
+}
+function peerClass(mode) {
+  if (mode === "bypassPermissions") return "bypass";
+  if (mode === "default" || mode === "manual" || mode === "dontAsk" || mode === "acceptEdits") return "prompting";
+  return null;
+}
+var NO_HOME_SETTINGS = { defaultMode: null, disableAutoMode: false, disableBypass: false };
+function homeSettings(configDir, home = os2.homedir()) {
+  const file = path7.join(configDir ?? path7.join(home, ".claude"), "settings.json");
+  let j;
+  try {
+    j = JSON.parse(readFileSync5(file, "utf8"));
+  } catch {
+    return { ...NO_HOME_SETTINGS };
+  }
+  if (!j || typeof j !== "object" || Array.isArray(j)) return { ...NO_HOME_SETTINGS };
+  const p = j.permissions && typeof j.permissions === "object" ? j.permissions : {};
+  const off = (k) => j[k] === "disable" || p[k] === "disable";
+  return {
+    defaultMode: typeof p.defaultMode === "string" && CLAUDE_MODES.includes(p.defaultMode) ? p.defaultMode : null,
+    disableAutoMode: off("disableAutoMode"),
+    disableBypass: off("disableBypassPermissionsMode")
+  };
+}
+function relaunchMode(recorded, home) {
+  if (recorded === "plan") return recorded;
+  if ((recorded === "dontAsk" || recorded === "acceptEdits") && modeRank(home.defaultMode) >= modeRank(recorded))
+    return recorded;
+  return null;
+}
+function recentlyWritten(file, ourLastEnd, now = Date.now()) {
+  let m;
+  try {
+    m = statSync5(file).mtimeMs;
+  } catch {
+    return false;
+  }
+  if (now - m > LIVE_WRITE_MS) return false;
+  return !(ourLastEnd && m <= ourLastEnd + 2e3);
+}
+function runClaude(bin, args, o) {
+  return runHeadless(bin, args, { ...o, keep: o.keep ?? ((line) => line.includes('"type":"result"')) });
+}
+function parseResult(stdout) {
+  const s = String(stdout || "").trim();
+  if (!s) return null;
+  const pick = (j) => {
+    if (Array.isArray(j)) {
+      for (let i = j.length - 1; i >= 0; i--) if (j[i]?.type === "result") return j[i];
+      return null;
+    }
+    return j && typeof j === "object" ? j : null;
+  };
+  try {
+    return pick(JSON.parse(s));
+  } catch {
+  }
+  const lines = s.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const j = pick(JSON.parse(lines[i]));
+      if (j && (j.type === "result" || "result" in j)) return j;
+    } catch {
+    }
+  }
+  return null;
+}
+var isUuid = (s) => typeof s === "string" && UUID_RE.test(s);
+
 // ../core/src/adapters/codex.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync4, readdirSync as readdirSync5, readFileSync as readFileSync6 } from "node:fs";
+import path8 from "node:path";
 
 // ../core/src/adapters/codex-config.ts
 var NOTIFY_LINE = /^[ \t]*notify[ \t]*=[ \t]*(\[.*\])[ \t]*(?:#.*)?(?=\r?$)/m;
@@ -1763,35 +2460,36 @@ var CODEX_EVENTS = [
 ];
 var OPTS2 = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
 var eventsFor2 = (lean) => lean ? CODEX_EVENTS.filter((e) => e !== "PreToolUse") : [...CODEX_EVENTS];
-var codexHome = (env) => env.CODEX_HOME || path7.join(homeDir(), ".codex");
-var hooksFile2 = (env) => path7.join(codexHome(env), "hooks.json");
-var configFile2 = (env) => path7.join(codexHome(env), "config.toml");
-var sessionsDir = (env) => path7.join(codexHome(env), "sessions");
+var codexHome = (env) => env.CODEX_HOME || path8.join(homeDir(), ".codex");
+var hooksFile2 = (env) => path8.join(codexHome(env), "hooks.json");
+var configFile2 = (env) => path8.join(codexHome(env), "config.toml");
+var sessionsDir = (env) => path8.join(codexHome(env), "sessions");
 var validTool3 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
 var endReason2 = (r) => r === "clear" || r === "logout" || r === "exit" ? r : "other";
+var UNTIL_APPROVED = "Codex will report nothing until you approve the hooks: start `codex` and accept the hook review";
 function installNotify(cmd, env) {
   const file = configFile2(env);
   let text = "";
+  let existed = true;
   try {
-    text = readFileSync5(file, "utf8");
-  } catch {
+    text = readFileSync6(file, "utf8");
+  } catch (e) {
+    existed = e.code !== "ENOENT";
   }
   const argv = cmd([NAME3, "notify"]).argv;
   const line = `notify = ${JSON.stringify(argv)}`;
   const n = readNotify(text);
-  const write = (next) => {
-    mkdirSync3(path7.dirname(file), { recursive: true });
-    writeFileSync4(file, next);
+  const write = (next, note) => {
+    const bad = writeBack(file, next, existed);
+    return bad ? { ...bad, note: `${bad.note}. ${UNTIL_APPROVED}` } : { file, changed: true, note };
   };
   if (n && !n.other) {
     if (!n.misplaced && JSON.stringify(n.argv) === JSON.stringify(argv))
       return { file, changed: false, note: "notify current" };
-    write(withNotify(text, line));
-    return {
-      file,
-      changed: true,
-      note: n.misplaced ? "notify moved to the top level (it sat inside a [table], where Codex never reads it)" : "notify updated"
-    };
+    return write(
+      withNotify(text, line),
+      n.misplaced ? "notify moved to the top level (it sat inside a [table], where Codex never reads it)" : "notify updated"
+    );
   }
   if (n?.other) {
     const prev = previousNotify(n.argv);
@@ -1800,40 +2498,38 @@ function installNotify(cmd, env) {
         if (JSON.stringify(prev) === JSON.stringify(argv))
           return { file, changed: false, note: "notify current (after Codex Computer Use)" };
       }
-      if (!prev || OURS2.test(JSON.stringify(prev))) {
-        write(replaceNotify(text, n, `notify = ${withPreviousRaw(n.raw, argv)}`));
-        return { file, changed: true, note: "chained after Codex Computer Use (--previous-notify)" };
-      }
+      if (!prev || OURS2.test(JSON.stringify(prev)))
+        return write(
+          replaceNotify(text, n, `notify = ${withPreviousRaw(n.raw, argv)}`),
+          "chained after Codex Computer Use (--previous-notify)"
+        );
     }
     return {
       file,
       changed: false,
       skipped: true,
-      note: `notify belongs to ${(n.argv?.[0] ?? n.raw).replace(/^.*\//, "").slice(0, 40)}; left alone. Codex will report nothing until you approve the hooks: start \`codex\` and accept the hook review`
+      note: `notify belongs to ${(n.argv?.[0] ?? n.raw).replace(/^.*\//, "").slice(0, 40)}; left alone. ${UNTIL_APPROVED}`
     };
   }
-  write(withNotify(text, line));
-  return { file, changed: true, note: "notify set at the top level" };
+  return write(withNotify(text, line), "notify set at the top level");
 }
 function uninstallNotify(env) {
   const file = configFile2(env);
   let text;
   try {
-    text = readFileSync5(file, "utf8");
+    text = readFileSync6(file, "utf8");
   } catch {
     return { file, changed: false };
   }
   const n = readNotify(text);
   if (!n) return { file, changed: false };
-  if (!n.other) {
-    writeFileSync4(file, withoutNotify(text));
-    return { file, changed: true };
-  }
+  if (!n.other) return writeBack(file, withoutNotify(text)) ?? { file, changed: true };
   const prev = previousNotify(n.argv);
-  if (isComputerUse(n.argv) && prev && OURS2.test(JSON.stringify(prev))) {
-    writeFileSync4(file, replaceNotify(text, n, `notify = ${stripPreviousRaw(n.raw)}`));
-    return { file, changed: true };
-  }
+  if (isComputerUse(n.argv) && prev && OURS2.test(JSON.stringify(prev)))
+    return writeBack(file, replaceNotify(text, n, `notify = ${stripPreviousRaw(n.raw)}`)) ?? {
+      file,
+      changed: true
+    };
   return { file, changed: false };
 }
 function findRollout(threadId, env = process.env) {
@@ -1842,12 +2538,12 @@ function findRollout(threadId, env = process.env) {
   const walk = (dir, depth) => {
     let names = [];
     try {
-      names = readdirSync4(dir);
+      names = readdirSync5(dir);
     } catch {
       return;
     }
     for (const n of names.sort().reverse()) {
-      const p = path7.join(dir, n);
+      const p = path8.join(dir, n);
       if (n.endsWith(`-${threadId}.jsonl`)) {
         best = p;
         return;
@@ -1865,8 +2561,12 @@ function rolloutMeta(file) {
   return scanLines(file, (line) => parseLines([line])[0] ?? {});
 }
 function ofAnotherThread(file, id) {
+  const other = threadOf(file);
+  return !!other && other !== id.toLowerCase();
+}
+function threadOf(file) {
   const m = /-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl(?:\.zst)?$/i.exec(file);
-  return !!m?.[1] && m[1].toLowerCase() !== id.toLowerCase();
+  return m?.[1] ? m[1].toLowerCase() : null;
 }
 var codex = {
   name: NAME3,
@@ -1891,7 +2591,7 @@ var codex = {
     ];
     let text = "";
     try {
-      text = readFileSync5(configFile2(env), "utf8");
+      text = readFileSync6(configFile2(env), "utf8");
     } catch {
     }
     const n = readNotify(text);
@@ -1945,6 +2645,8 @@ var codex = {
     const turn_id = typeof s.turn_id === "string" ? s.turn_id : void 0;
     const tool = validTool3(s.tool_name) ? s.tool_name : void 0;
     const call_id = typeof s.tool_use_id === "string" ? s.tool_use_id : void 0;
+    const thread = typeof s.transcript_path === "string" ? threadOf(s.transcript_path) : null;
+    const agent_id = typeof s.agent_id === "string" && s.agent_id ? s.agent_id : typeof s.subagent_id === "string" && s.subagent_id ? s.subagent_id : thread && thread !== String(id).toLowerCase() ? thread : void 0;
     const ev = (type, data) => ({ type, data: prune3(data), harnessEvent: event });
     const events = [];
     switch (event) {
@@ -1964,17 +2666,30 @@ var codex = {
         );
         break;
       case "PreToolUse":
-        if (tool) events.push(ev("tool.started", { tool, call_id, turn_id, input: s.tool_input }));
+        if (tool) events.push(ev("tool.started", { tool, call_id, turn_id, agent_id, input: s.tool_input }));
         break;
       case "PostToolUse":
         if (tool)
           events.push(
-            ev("tool.ended", { tool, call_id, turn_id, ok: true, input: s.tool_input, output: s.tool_response })
+            ev("tool.ended", {
+              tool,
+              call_id,
+              turn_id,
+              agent_id,
+              ok: true,
+              input: s.tool_input,
+              output: s.tool_response
+            })
           );
         break;
       case "PermissionRequest":
         events.push(
-          ev("attention.needed", { attention_id: call_id ?? `perm-${Date.now()}`, kind: "permission", tool })
+          ev("attention.needed", {
+            attention_id: call_id ?? `perm-${Date.now()}`,
+            kind: "permission",
+            tool,
+            agent_id
+          })
         );
         break;
       case "Stop":
@@ -2018,7 +2733,7 @@ var codex = {
   readTranscript(file, fromLine) {
     let text = "";
     try {
-      text = readFileSync5(file, "utf8");
+      text = readFileSync6(file, "utf8");
     } catch {
       return { turns: [], line: fromLine };
     }
@@ -2032,7 +2747,7 @@ var codex = {
   backfill(sinceMs, env = process.env) {
     const rows2 = [];
     for (const f of recentFiles(sessionsDir(env), 3, sinceMs, (n) => /^rollout-.*\.jsonl$/.test(n))) {
-      const m = /([0-9a-f]{8}-[0-9a-f-]{27,})\.jsonl$/i.exec(path7.basename(f));
+      const m = /([0-9a-f]{8}-[0-9a-f-]{27,})\.jsonl$/i.exec(path8.basename(f));
       if (!m?.[1]) continue;
       if (codexSubagent(rolloutMeta(f))) continue;
       const facts = codexFacts(f);
@@ -2119,10 +2834,10 @@ function codexFacts(file) {
 // ../core/src/adapters/devin.ts
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync6, readlinkSync } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 
 // ../core/src/readers/sqlite.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
 import { createRequire } from "node:module";
 function quiet(fn) {
@@ -2202,7 +2917,7 @@ db.close();
 process.stdout.write(JSON.stringify(out));`;
 function viaChild(file, sql, params, o) {
   try {
-    const out = execFileSync3(
+    const out = execFileSync4(
       process.execPath,
       ["--experimental-sqlite", "--no-warnings", "-e", CHILD, file, sql, JSON.stringify(params), String(o.timeoutMs)],
       {
@@ -2246,7 +2961,7 @@ function viaCli(file, sql, params, o) {
   const text = inlineParams(sql, params);
   if (!text) return null;
   try {
-    const out = execFileSync3("sqlite3", ["-readonly", "-json", file, text], {
+    const out = execFileSync4("sqlite3", ["-readonly", "-json", file, text], {
       encoding: "utf8",
       timeout: o.timeoutMs + 3e3,
       stdio: ["ignore", "pipe", "ignore"],
@@ -2303,11 +3018,11 @@ function foreignEvent(file) {
   return Object.keys(hooks).find((k) => !ok.includes(k));
 }
 var homeOf = (env) => env.HOME || homeDir();
-var appData = (env) => env.APPDATA || path8.join(homeOf(env), "AppData", "Roaming");
-var devinConfigDir = (env = process.env) => process.platform === "win32" ? path8.join(appData(env), "devin") : path8.join(env.XDG_CONFIG_HOME || path8.join(homeOf(env), ".config"), "devin");
-var configFile3 = (env) => path8.join(devinConfigDir(env), "config.json");
-var devinDataDir = (env = process.env) => process.platform === "win32" ? path8.join(appData(env), "devin", "cli") : path8.join(env.XDG_DATA_HOME || path8.join(homeOf(env), ".local", "share"), "devin", "cli");
-var sessionsDb = (env) => path8.join(devinDataDir(env), "sessions.db");
+var appData = (env) => env.APPDATA || path9.join(homeOf(env), "AppData", "Roaming");
+var devinConfigDir = (env = process.env) => process.platform === "win32" ? path9.join(appData(env), "devin") : path9.join(env.XDG_CONFIG_HOME || path9.join(homeOf(env), ".config"), "devin");
+var configFile3 = (env) => path9.join(devinConfigDir(env), "config.json");
+var devinDataDir = (env = process.env) => process.platform === "win32" ? path9.join(appData(env), "devin", "cli") : path9.join(env.XDG_DATA_HOME || path9.join(homeOf(env), ".local", "share"), "devin", "cli");
+var sessionsDb = (env) => path9.join(devinDataDir(env), "sessions.db");
 var SESSION_ID = /^[A-Za-z0-9._:-]{1,128}$/;
 var validTool4 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
 var endReason3 = (r) => r === "clear" || r === "logout" || r === "exit" ? r : "other";
@@ -2464,7 +3179,7 @@ var CHAIN_LIMIT = 4e3;
 var CHAIN_SQL = `WITH RECURSIVE chain(node_id, parent_node_id, chat_message, created_at) AS (
   SELECT node_id, parent_node_id, chat_message, created_at FROM message_nodes
    WHERE session_id = ? AND node_id = (SELECT main_chain_id FROM sessions WHERE id = ?)
-  UNION ALL
+  UNION
   SELECT m.node_id, m.parent_node_id, m.chat_message, m.created_at FROM message_nodes m
     JOIN chain c ON m.node_id = c.parent_node_id AND m.session_id = ? AND m.node_id >= ?
 )
@@ -2479,7 +3194,7 @@ var BACKFILL_SQL = `SELECT s.id, ${SESSION_FIELDS} FROM sessions s
 function sessionFacts(row) {
   const out = {};
   if (typeof row.model === "string" && row.model) out.model = row.model;
-  if (typeof row.working_directory === "string" && path8.isAbsolute(row.working_directory))
+  if (typeof row.working_directory === "string" && path9.isAbsolute(row.working_directory))
     out.cwd = row.working_directory;
   const started = Number(row.created_at);
   const last = Number(row.last_activity_at);
@@ -2524,8 +3239,8 @@ function readDevinChain(db, session, fromLine) {
 }
 function devinVersion(env = process.env) {
   try {
-    const target = readlinkSync(path8.join(devinDataDir(env), "_versions", "current"));
-    const name = path8.basename(target);
+    const target = readlinkSync(path9.join(devinDataDir(env), "_versions", "current"));
+    const name = path9.basename(target);
     return /^[0-9][0-9A-Za-z.+-]{0,63}$/.test(name) ? name : void 0;
   } catch {
     return void 0;
@@ -2538,9 +3253,9 @@ function devinAccount(env = process.env) {
 }
 
 // ../core/src/adapters/gemini-cli.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
-import path9 from "node:path";
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+import path10 from "node:path";
 var NAME5 = "gemini-cli";
 var GEMINI_EVENTS = [
   "SessionStart",
@@ -2553,16 +3268,16 @@ var GEMINI_EVENTS = [
   "SessionEnd"
 ];
 var OPTS4 = { matcherFor: (e) => /Tool/.test(e) ? ".*" : void 0, timeout: 5e3 };
-var geminiDir = (env) => env.GEMINI_CLI_HOME || path9.join(homeDir(), ".gemini");
-var settings = (env) => path9.join(geminiDir(env), "settings.json");
+var geminiDir = (env) => env.GEMINI_CLI_HOME || path10.join(homeDir(), ".gemini");
+var settings = (env) => path10.join(geminiDir(env), "settings.json");
 var validTool5 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
 var eventsFor4 = (lean) => lean ? GEMINI_EVENTS.filter((e) => e !== "BeforeTool") : [...GEMINI_EVENTS];
 function geminiVersion(platform = process.platform, env = process.env) {
   const win = platform === "win32";
-  const bin = win ? findBinary({ names: ["gemini.exe", "gemini.cmd"], dirs: [path9.dirname(process.execPath)], env }) : "gemini";
+  const bin = win ? findBinary({ names: ["gemini.exe", "gemini.cmd"], dirs: [path10.dirname(process.execPath)], env }) : "gemini";
   if (!bin) throw new Error("no gemini on PATH");
   const c = probe(bin, ["--version"]);
-  return execFileSync4(c.file, c.args, {
+  return execFileSync5(c.file, c.args, {
     encoding: "utf8",
     timeout: 4e3,
     stdio: ["ignore", "pipe", "ignore"],
@@ -2595,7 +3310,7 @@ var geminiCli = {
   name: NAME5,
   events: GEMINI_EVENTS,
   // ~/.gemini also belongs to Antigravity; Gemini CLI is here when its settings or its chat logs exist.
-  detect: (env = process.env) => existsSync7(settings(env)) || existsSync7(path9.join(geminiDir(env), "tmp")),
+  detect: (env = process.env) => existsSync7(settings(env)) || existsSync7(path10.join(geminiDir(env), "tmp")),
   configFiles: (env = process.env) => [settings(env)],
   install: (cmd, env = process.env, opts = {}) => {
     const r = installClaudeShaped(settings(env), NAME5, eventsFor4(opts.lean), cmd, OPTS4);
@@ -2693,7 +3408,7 @@ var geminiCli = {
   readTranscript(file, fromLine) {
     let text = "";
     try {
-      text = readFileSync6(file, "utf8");
+      text = readFileSync7(file, "utf8");
     } catch {
       return { turns: [], line: fromLine };
     }
@@ -2733,12 +3448,12 @@ var ADAPTERS = [claudeCode, codex, geminiCli, antigravity, devin];
 var adapterByName = (name) => ADAPTERS.find((a) => a.name === name);
 
 // ../core/src/config.ts
-import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import path10 from "node:path";
+import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "node:fs";
+import path11 from "node:path";
 var DEFAULT_CONFIG = { sinks: [], harnesses: {}, update_check: true, keep_days: 30 };
 function readConfig(file = configFile()) {
   try {
-    const j = JSON.parse(readFileSync7(file, "utf8"));
+    const j = JSON.parse(readFileSync8(file, "utf8"));
     return {
       ...DEFAULT_CONFIG,
       ...j,
@@ -2749,9 +3464,36 @@ function readConfig(file = configFile()) {
     return { ...DEFAULT_CONFIG, sinks: [], harnesses: {} };
   }
 }
+function configProblem(file) {
+  let text;
+  try {
+    text = readFileSync8(file, "utf8");
+  } catch (e) {
+    const code = e.code;
+    return code === "ENOENT" ? void 0 : `could not be read (${code})`;
+  }
+  if (!text.trim()) return void 0;
+  if (text.charCodeAt(0) === 65279) return "starts with a byte-order mark (save it as UTF-8 without one)";
+  try {
+    const j = JSON.parse(text);
+    return j && typeof j === "object" && !Array.isArray(j) ? void 0 : "is not a JSON object";
+  } catch (e) {
+    const m = e.message;
+    const at = (/line \d+ column \d+/.exec(m) ?? /position \d+/.exec(m))?.[0];
+    return `is not valid JSON${at ? ` at ${at}` : ""}`;
+  }
+}
+function assertConfigWritable(file = configFile()) {
+  const problem = configProblem(file);
+  if (problem)
+    throw new Error(
+      `${tilde(file)} ${problem}, so it was not written over: that would lose its machine name and sinks. Fix it, or move it aside to start again, then run this again.`
+    );
+}
 function writeConfig(c, file = configFile()) {
-  mkdirSync4(path10.dirname(file), { recursive: true, mode: 448 });
-  writeFileSync5(file, `${JSON.stringify(c, null, 2)}
+  assertConfigWritable(file);
+  mkdirSync2(path11.dirname(file), { recursive: true, mode: 448 });
+  writeFileSync2(file, `${JSON.stringify(c, null, 2)}
 `, { mode: 384 });
   if (process.platform !== "win32" && existsSync8(file)) {
     try {
@@ -2814,38 +3556,23 @@ function makeEvent(a, ctx) {
   };
 }
 
-// ../core/src/launched-by.ts
-var LAUNCHED_BY_ENV = "SESSIONPIPE_LAUNCHED_BY";
-var LAUNCHED_BY = /^[a-z][a-z0-9-]{0,39}:[A-Za-z0-9._:-]{1,128}$/;
-function launchedBy(env) {
-  const v = env[LAUNCHED_BY_ENV]?.trim();
-  return v && LAUNCHED_BY.test(v) ? v : void 0;
-}
-function readHook(adapter, input) {
-  const r = adapter.fromHook(input);
-  if (r && !r.session.parent_id) {
-    const launcher = launchedBy(input.env);
-    if (launcher && launcher !== `${adapter.name}:${r.session.id}`) r.session.launched_by = launcher;
-  }
-  return r;
-}
-
 // ../core/src/outbox.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
 import {
   appendFileSync,
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   existsSync as existsSync9,
-  mkdirSync as mkdirSync5,
-  openSync as openSync2,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync8,
-  readSync as readSync2,
+  mkdirSync as mkdirSync3,
+  openSync as openSync3,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync9,
+  readSync as readSync3,
   renameSync,
-  statSync as statSync5,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync6
+  statSync as statSync6,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 var READ_CHUNK = 1024 * 1024;
 var READ_MAX = 8 * 1024 * 1024;
 var Outbox = class {
@@ -2854,13 +3581,13 @@ var Outbox = class {
   }
   root;
   dir(harness) {
-    return path11.join(this.root, "outbox", safeId(harness));
+    return path12.join(this.root, "outbox", safeId(harness));
   }
   file(ref) {
-    return path11.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
+    return path12.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
   }
   seqFile(ref) {
-    return path11.join(this.dir(ref.harness), `${safeId(ref.session)}.seq`);
+    return path12.join(this.dir(ref.harness), `${safeId(ref.session)}.seq`);
   }
   /** The next seq for a session, persisted (survives a hibernating machine and a
    *  restart; an in-memory counter would restart at 0 and collide). */
@@ -2868,19 +3595,19 @@ var Outbox = class {
     const f = this.seqFile(ref);
     let n = -1;
     try {
-      const t = readFileSync8(f, "utf8").trim();
+      const t = readFileSync9(f, "utf8").trim();
       if (/^\d+$/.test(t)) n = Number(t);
     } catch {
     }
     if (n < 0) n = this.lastSeqInFile(ref) + 1;
-    mkdirSync5(path11.dirname(f), { recursive: true, mode: 448 });
-    writeFileSync6(f, String(n + 1), { mode: 384 });
+    mkdirSync3(path12.dirname(f), { recursive: true, mode: 448 });
+    writeFileSync3(f, String(n + 1), { mode: 384 });
     return n;
   }
   lastSeqInFile(ref) {
     const f = this.file(ref);
     if (!existsSync9(f)) return -1;
-    const lines = readFileSync8(f, "utf8").trim().split("\n");
+    const lines = readFileSync9(f, "utf8").trim().split("\n");
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
         const j = JSON.parse(lines[i]);
@@ -2892,26 +3619,26 @@ var Outbox = class {
   }
   append(ref, events) {
     if (!events.length) return;
-    mkdirSync5(this.dir(ref.harness), { recursive: true, mode: 448 });
+    mkdirSync3(this.dir(ref.harness), { recursive: true, mode: 448 });
     appendFileSync(this.file(ref), `${events.map((e) => JSON.stringify(e)).join("\n")}
 `, { mode: 384 });
   }
   /** Every session file, newest first. */
   sessions() {
     const out = [];
-    const base = path11.join(this.root, "outbox");
+    const base = path12.join(this.root, "outbox");
     if (!existsSync9(base)) return [];
-    for (const h of readdirSync5(base)) {
-      const d = path11.join(base, h);
+    for (const h of readdirSync6(base)) {
+      const d = path12.join(base, h);
       let names = [];
       try {
-        names = readdirSync5(d).filter((n) => n.endsWith(".jsonl"));
+        names = readdirSync6(d).filter((n) => n.endsWith(".jsonl"));
       } catch {
         continue;
       }
       for (const n of names) {
         try {
-          out.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync5(path11.join(d, n)).mtimeMs });
+          out.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync6(path12.join(d, n)).mtimeMs });
         } catch {
         }
       }
@@ -2927,16 +3654,16 @@ var Outbox = class {
   read(ref, from, maxEvents = 500) {
     const f = this.file(ref);
     if (!existsSync9(f)) return { events: [], offset: from };
-    const size = statSync5(f).size;
+    const size = statSync6(f).size;
     if (from >= size) return { events: [], offset: from };
-    const fd = openSync2(f, "r");
+    const fd = openSync3(f, "r");
     try {
       const events = [];
       let offset = from;
       let chunk = READ_CHUNK;
       while (events.length < maxEvents && offset < size) {
         const buf = Buffer.alloc(Math.min(size - offset, chunk));
-        const n = readSync2(fd, buf, 0, buf.length, offset);
+        const n = readSync3(fd, buf, 0, buf.length, offset);
         const text = buf.subarray(0, n).toString("utf8");
         let pos = 0;
         let used = 0;
@@ -2959,37 +3686,109 @@ var Outbox = class {
       }
       return { events, offset };
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
   }
-  /** Files older than `days` are pruned; the cursor files with them. */
+  /** Files older than `days` are pruned, and each sink's cursor into them. The seq
+   *  counter stays: a session resumed after the window counts on from where it was,
+   *  so a receiver's (harness, session, seq) dedup doesn't take its new events for
+   *  ones it already has, and the sinks read the new file from its start.
+   *  It all happens under the drain's `flush` lock, since a drain holds the whole
+   *  cursor map and writes it back: a file and its cursor keys go together, so a
+   *  session resumed in between can't keep a key past its new file's end. While a
+   *  drain runs, nothing is pruned (0); the next prune does it. It never throws: it
+   *  is a cleanup, and a hook's drain comes after it. */
   prune(days, now = Date.now()) {
+    let release = null;
+    try {
+      release = takeNamedLock(this.root, "flush");
+    } catch {
+    }
+    if (!release) return 0;
     let n = 0;
-    const cutoff = now - days * 864e5;
-    for (const ref of this.sessions()) {
-      const f = this.file(ref);
-      try {
-        if (statSync5(f).mtimeMs < cutoff) {
-          unlinkSync3(f);
-          try {
-            unlinkSync3(this.seqFile(ref));
-          } catch {
+    try {
+      const cutoff = now - days * 864e5;
+      const aged = this.sessions().filter((ref) => {
+        try {
+          return statSync6(this.file(ref)).mtimeMs < cutoff;
+        } catch {
+          return false;
+        }
+      });
+      this.dropStaleCursors(new Set(aged.map((ref) => `${ref.harness}/${ref.session}`)));
+      for (const ref of aged) {
+        const f = this.file(ref);
+        try {
+          if (statSync6(f).mtimeMs < cutoff) {
+            unlinkSync2(f);
+            n++;
           }
-          n++;
+        } catch {
         }
-      } catch {
       }
+    } catch {
+    } finally {
+      release();
     }
     return n;
   }
+  /** A sink's cursor into a session file about to be pruned (`gone`), or one already
+   *  missing (an earlier prune, an older release, by hand) is removed. The caller
+   *  holds the `flush` lock. */
+  dropStaleCursors(gone) {
+    let names = [];
+    try {
+      names = readdirSync6(path12.join(this.root, "cursors")).filter((n) => n.endsWith(".json"));
+    } catch {
+    }
+    const stale = (c) => Object.keys(c).filter((k) => {
+      if (gone.has(k)) return true;
+      const i = k.indexOf("/");
+      return !existsSync9(this.file({ harness: k.slice(0, i), session: k.slice(i + 1) }));
+    });
+    for (const n of names) {
+      const s = new Cursors(this.root, n.slice(0, -5));
+      const c = s.read();
+      const keys = stale(c);
+      if (!keys.length) continue;
+      for (const k of keys) delete c[k];
+      s.write(c);
+    }
+  }
   delete(ref) {
+    this.dropCursors(ref);
     for (const f of [this.file(ref), this.seqFile(ref)]) {
       try {
-        unlinkSync3(f);
+        unlinkSync2(f);
       } catch {
       }
     }
   }
+  /** The key every sink's cursor holds for a session is removed with the session's
+   *  file: the key alone pointed into the old file, and a session that went on (still
+   *  running, or resumed later) had its new file's first events unsent until it grew
+   *  past that offset. Every file under <state>/cursors is taken (a sink since taken
+   *  out of the config still has one; one that doesn't parse reads as empty and is
+   *  left), by the key a drain writes (the file's own name, `safeId`) and by the ref
+   *  as given. The caller holds the drain's `flush` lock: a drain holds the whole
+   *  cursor map and writes it back, so a key dropped under it would come back. */
+  dropCursors(ref) {
+    const keys = /* @__PURE__ */ new Set([`${ref.harness}/${ref.session}`, `${safeId(ref.harness)}/${safeId(ref.session)}`]);
+    let names = [];
+    try {
+      names = readdirSync6(path12.join(this.root, "cursors")).filter((n) => n.endsWith(".json"));
+    } catch {
+      return;
+    }
+    for (const n of names) {
+      const s = new Cursors(this.root, n.slice(0, -5));
+      const c = s.read();
+      const had = Object.keys(c).filter((k) => keys.has(k));
+      if (!had.length) continue;
+      for (const k of had) delete c[k];
+      s.write(c);
+    }
+  }
 };
 var Cursors = class {
   constructor(root, sink) {
@@ -2999,20 +3798,23 @@ var Cursors = class {
   root;
   sink;
   file() {
-    return path11.join(this.root, "cursors", `${safeId(this.sink)}.json`);
+    return path12.join(this.root, "cursors", `${safeId(this.sink)}.json`);
   }
+  /** The map; empty when the file is missing, cut off mid-write, or holds anything
+   *  but an object (`null`, a list), so a drain never indexes into those. */
   read() {
     try {
-      return JSON.parse(readFileSync8(this.file(), "utf8"));
+      const c = JSON.parse(readFileSync9(this.file(), "utf8"));
+      return c && typeof c === "object" && !Array.isArray(c) ? c : {};
     } catch {
       return {};
     }
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path11.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync3(path12.dirname(f), { recursive: true, mode: 448 });
     const tmp = `${f}.${process.pid}.tmp`;
-    writeFileSync6(tmp, JSON.stringify(c), { mode: 384 });
+    writeFileSync3(tmp, JSON.stringify(c), { mode: 384 });
     renameSync(tmp, f);
   }
   key(ref) {
@@ -3023,22 +3825,44 @@ function takeLock(root, ref, staleMs = 5 * 6e4) {
   return takeNamedLock(root, `${safeId(ref.harness)}-${safeId(ref.session)}`, staleMs);
 }
 function takeNamedLock(root, name, staleMs = 5 * 6e4) {
-  const dir = path11.join(root, "locks");
-  mkdirSync5(dir, { recursive: true, mode: 448 });
-  const f = path11.join(dir, `${name}.lock`);
+  const dir = path12.join(root, "locks");
+  mkdirSync3(dir, { recursive: true, mode: 448 });
+  const f = path12.join(dir, `${name}.lock`);
+  const nonce = randomBytes2(8).toString("hex");
+  const mine = `${process.pid} ${nonce}`;
+  let body = null;
   try {
-    if (Date.now() - statSync5(f).mtimeMs > staleMs || !processAlive(Number(readFileSync8(f, "utf8")))) unlinkSync3(f);
-    else return null;
+    body = readFileSync9(f, "utf8");
+    const stale = Date.now() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(body.split(" ")[0]));
+    if (!stale) return null;
   } catch {
+    body = null;
+  }
+  if (body !== null) {
+    const aside = `${f}.${process.pid}.${nonce}.stale`;
+    try {
+      renameSync(f, aside);
+    } catch {
+      return null;
+    }
+    const moved = readFileSync9(aside, "utf8");
+    unlinkSync2(aside);
+    if (moved !== body) {
+      try {
+        writeFileSync3(f, moved, { flag: "wx" });
+      } catch {
+      }
+      return null;
+    }
   }
   try {
-    writeFileSync6(f, String(process.pid), { flag: "wx" });
+    writeFileSync3(f, mine, { flag: "wx" });
   } catch {
     return null;
   }
   return () => {
     try {
-      unlinkSync3(f);
+      if (readFileSync9(f, "utf8") === mine) unlinkSync2(f);
     } catch {
     }
   };
@@ -3057,7 +3881,7 @@ function processAlive(pid) {
 import { createHash as createHash4 } from "node:crypto";
 var RULESET_PII = "pii@1";
 var EMAIL = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
-var PHONE = /(?<![\w.])(?:\+\d{1,3}[ .-]?)?(?:\(\d{2,4}\)[ .-]?)?\d{2,4}(?:[ .-]?\d{2,4}){1,3}(?!\w)/g;
+var PHONE = /(?<![\w.])(?:(?<!\)[ .-]?|\+\d{1,3}[ .-]?)(\+?(?:19|20)\d{2}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01]))(?:(?= (?:[01]?\d|2[0-3]):)|(?!\w|[ .-]\d\d))|(?:\+\d{1,3}[ .-]?)?(?:\(\d{2,4}\)[ .-]?)?\d{2,4}(?:[ .-]?\d{2,4}){1,3}(?!\w))/g;
 function looksPhone(s) {
   const digits = s.replace(/\D/g, "");
   if (digits.length < 7 || digits.length > 15) return false;
@@ -3068,7 +3892,7 @@ function looksPhone(s) {
 function reducePii(text, home) {
   if (!text) return text;
   let out = text.replace(EMAIL, "[email]");
-  out = out.replace(PHONE, (m) => looksPhone(m) ? "[phone]" : m);
+  out = out.replace(PHONE, (m, date) => !date && looksPhone(m) ? "[phone]" : m);
   if (home) {
     const h = home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     out = out.replace(new RegExp(`(?<![A-Za-z0-9_])${h}(?=/|$|\\s|["'\`])`, "g"), "~");
@@ -3265,6 +4089,8 @@ var TYPE_TIER = {
   "subagent.ended": 1,
   "context.compacted": 1,
   "limits.observed": 1,
+  "delegation.started": 0,
+  "delegation.ended": 0,
   native: 3
 };
 var DATA_ALLOW = {
@@ -3275,17 +4101,19 @@ var DATA_ALLOW = {
   "session.forgotten": { 0: [] },
   "turn.started": { 0: ["turn_id", "submitted_by", "injected"], 1: ["prompt_chars"] },
   "turn.ended": { 0: ["turn_id", "reason", "ms", "background"], 1: ["error"] },
-  "turn.transcript": { 2: ["turn", "user", "assistant", "at"] },
-  "turn.progress": { 2: ["turn", "user", "assistant", "at"] },
+  "turn.transcript": { 2: ["turn", "user", "assistant", "at", "injected"] },
+  "turn.progress": { 2: ["turn", "user", "assistant", "at", "injected"] },
   "tool.started": { 1: ["tool", "call_id", "turn_id", "agent_id"], 3: ["input"] },
   "tool.ended": { 1: ["tool", "call_id", "turn_id", "agent_id", "ms", "ok", "error"], 3: ["input", "output"] },
   "files.changed": { 1: ["paths"] },
-  "attention.needed": { 0: ["attention_id", "kind"], 1: ["tool", "message"] },
+  "attention.needed": { 0: ["attention_id", "kind"], 1: ["tool", "message", "agent_id"] },
   "attention.cleared": { 0: ["attention_id", "how"] },
   "subagent.started": { 1: ["agent_id", "agent_type"] },
   "subagent.ended": { 1: ["agent_id", "agent_type"] },
   "context.compacted": { 1: ["trigger"] },
-  "limits.observed": { 1: ["windows", "plan", "account_id"] }
+  "limits.observed": { 1: ["windows", "plan", "account_id"] },
+  "delegation.started": { 0: ["ask_id", "via", "harness", "to"], 1: ["text"] },
+  "delegation.ended": { 0: ["ask_id", "to", "ok", "ms", "error", "relayed"], 2: ["reply"] }
 };
 var SESSION_ALLOW = [
   "id",
@@ -3301,7 +4129,8 @@ var SESSION_ALLOW = [
   "account_id",
   "attended",
   "parent_id",
-  "launched_by"
+  "launched_by",
+  "delegated_by"
 ];
 var MAX_SIDE = 2e4;
 var MAX_IO = 64 * 1024;
@@ -3340,6 +4169,8 @@ function filterEvent(event, tier, pii, opts = {}) {
   if (data.input !== void 0) data.input = cap(data.input, MAX_IO);
   if (data.output !== void 0) data.output = cap(data.output, MAX_IO);
   if (typeof data.message === "string") data.message = cap(data.message, 200);
+  if (event.type === "delegation.started" && typeof data.text === "string") data.text = cap(data.text, 200);
+  if (event.type === "delegation.ended" && typeof data.reply === "string") data.reply = cap(data.reply, MAX_SIDE);
   const rulesets = [];
   let out = { ...event, tier, session, data, privacy: { rulesets, pii } };
   if (tier > 0) {
@@ -3366,8 +4197,8 @@ function shortId(harness, id) {
 }
 
 // ../core/src/sinks/file.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import path12 from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4 } from "node:fs";
+import path13 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
     this.name = name;
@@ -3381,7 +4212,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path12.dirname(this.file), { recursive: true });
+      mkdirSync4(path13.dirname(this.file), { recursive: true });
       appendFileSync2(this.file, `${events.map((e) => JSON.stringify(e)).join("\n")}
 `);
       return { ok: true, acknowledged: events.length, accepted: events.length, duplicates: 0, rejected: [] };
@@ -3415,12 +4246,12 @@ var StdoutSink = class {
 };
 
 // src/control/aliases.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync9, renameSync as renameSync2, writeFileSync as writeFileSync7 } from "node:fs";
-import path13 from "node:path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync10, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import path14 from "node:path";
 
 // src/secrets.ts
 import { spawnSync } from "node:child_process";
-import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes3 } from "node:crypto";
 var SERVICE = "sessionpipe";
 var defaultRunner = (cmd, args, input) => {
   const r = spawnSync(cmd, args, {
@@ -3444,9 +4275,9 @@ function secretGet(store, account, run = defaultRunner) {
 function sinkWithSecrets(s, run = defaultRunner) {
   if (!s.token_in) return s;
   const token = secretGet(s.token_in, sinkAccount(s.name), run);
-  if (!token) return null;
   const secret = secretGet(s.token_in, sinkAccount(s.name, "secret"), run);
-  return { ...s, token, ...secret ? { secret } : {} };
+  if (!token && !secret) return null;
+  return { ...s, ...token ? { token } : {}, ...secret ? { secret } : {} };
 }
 
 // src/control/store.ts
@@ -3460,10 +4291,10 @@ function startOptionsOf(v) {
 }
 
 // src/control/aliases.ts
-var aliasFile = (controlDir) => path13.join(controlDir, "aliases.json");
+var aliasFile = (controlDir) => path14.join(controlDir, "aliases.json");
 function readAliases(file) {
   try {
-    const j = JSON.parse(readFileSync9(file, "utf8"));
+    const j = JSON.parse(readFileSync10(file, "utf8"));
     if (!j || typeof j !== "object" || Array.isArray(j)) return {};
     const out = {};
     for (const [k, v] of Object.entries(j)) {
@@ -3484,12 +4315,12 @@ function receiverIdOf(all, harness, id) {
 
 // src/control/local.ts
 import net from "node:net";
-import os2 from "node:os";
-import path14 from "node:path";
+import os3 from "node:os";
+import path15 from "node:path";
 function socketPath(state, env = process.env) {
   if (env.SESSIONPIPE_SOCKET) return env.SESSIONPIPE_SOCKET;
-  if (process.platform === "win32") return `\\\\.\\pipe\\sessionpipe-control-${os2.userInfo().username}`;
-  return path14.join(state, "control.sock");
+  if (process.platform === "win32") return `\\\\.\\pipe\\sessionpipe-control-${os3.userInfo().username}`;
+  return path15.join(state, "control.sock");
 }
 function ask(sock, req, timeoutMs) {
   return new Promise((resolve) => {
@@ -3521,10 +4352,85 @@ function ask(sock, req, timeoutMs) {
   });
 }
 
+// src/fold.ts
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync11, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import path16 from "node:path";
+var TOOLS_MODES = ["all", "main", "beat"];
+var TOOL_FOLD_MS = 6e4;
+var KEEP_MS = 24 * 60 * 6e4;
+function isToolsMode(v) {
+  return typeof v === "string" && TOOLS_MODES.includes(v);
+}
+function toolsMode(s) {
+  if (isToolsMode(s.tools)) return s.tools;
+  if (isToolsMode(s.receiver_tools)) return s.receiver_tools;
+  return "all";
+}
+var agentOf = (e) => typeof e.data.agent_id === "string" ? e.data.agent_id : "";
+var thins = (mode, agent) => mode === "beat" || mode === "main" && agent !== "";
+var askKey = (key, agent) => `${key}\0ask\0${agent}`;
+function sendTool(e, mode, clock, key) {
+  if (mode === "all") return true;
+  const agent = agentOf(e);
+  const t = Date.parse(e.time);
+  if (e.type === "attention.needed") {
+    if (thins(mode, agent)) clock[askKey(key, agent)] = Number.isFinite(t) ? t : 0;
+    return true;
+  }
+  if (e.type !== "tool.started" && e.type !== "tool.ended" || !thins(mode, agent)) return true;
+  if (e.type === "tool.started") return false;
+  if (!Number.isFinite(t)) return true;
+  const ask2 = askKey(key, agent);
+  const asked = clock[ask2];
+  if (asked !== void 0 && t >= asked) {
+    delete clock[ask2];
+    clock[key] = t;
+    return true;
+  }
+  const last = clock[key];
+  if (last !== void 0 && t > last - TOOL_FOLD_MS && t < last + TOOL_FOLD_MS) return false;
+  clock[key] = t;
+  return true;
+}
+var ToolClock = class {
+  constructor(root, sink) {
+    this.root = root;
+    this.sink = sink;
+  }
+  root;
+  sink;
+  file() {
+    return path16.join(this.root, "folds", `${safeId(this.sink)}.json`);
+  }
+  read() {
+    try {
+      const j = JSON.parse(readFileSync11(this.file(), "utf8"));
+      return j && typeof j === "object" && !Array.isArray(j) ? j : {};
+    } catch {
+      return {};
+    }
+  }
+  write(c) {
+    const newest = Math.max(0, ...Object.values(c).filter(Number.isFinite));
+    const kept = {};
+    for (const [k, v] of Object.entries(c)) if (Number.isFinite(v) && v >= newest - KEEP_MS) kept[k] = v;
+    const f = this.file();
+    mkdirSync6(path16.dirname(f), { recursive: true, mode: 448 });
+    const tmp = `${f}.${process.pid}.tmp`;
+    writeFileSync5(tmp, JSON.stringify(kept), { mode: 384 });
+    renameSync3(tmp, f);
+  }
+};
+
 // src/run.ts
 async function tellDaemon(state, job, session, cwd, transcript) {
   const sock = socketPath(state);
   if (process.platform !== "win32" && !existsSync10(sock)) return;
+  let mode = null;
+  try {
+    mode = claude_code_control_exports.hookMode(JSON.parse(job.stdin));
+  } catch {
+  }
   await ask(
     sock,
     {
@@ -3532,31 +4438,32 @@ async function tellDaemon(state, job, session, cwd, transcript) {
       session: `${job.harness}:${session}`,
       event: job.event,
       ...cwd ? { cwd } : {},
-      ...transcript ? { transcript } : {}
+      ...transcript ? { transcript } : {},
+      ...mode ? { mode } : {}
     },
     300
   );
 }
 function enqueueJob(state, job) {
   const jobs = jobsDir(state);
-  mkdirSync8(jobs, { recursive: true, mode: 448 });
-  const f = path15.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
-  writeFileSync8(f, JSON.stringify(job), { mode: 384 });
+  mkdirSync7(jobs, { recursive: true, mode: 448 });
+  const f = path17.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
+  writeFileSync6(f, JSON.stringify(job), { mode: 384 });
   return f;
 }
 function releaseJob(claimed) {
   if (!claimed) return;
   try {
-    unlinkSync4(claimed);
+    unlinkSync3(claimed);
   } catch {
   }
 }
 function log(state, line) {
   try {
-    mkdirSync8(state, { recursive: true, mode: 448 });
-    const f = path15.join(state, "log");
+    mkdirSync7(state, { recursive: true, mode: 448 });
+    const f = path17.join(state, "log");
     try {
-      if (statSync6(f).size > 1024 * 1024) renameSync3(f, `${f}.1`);
+      if (statSync7(f).size > 1024 * 1024) renameSync4(f, `${f}.1`);
     } catch {
     }
     appendFileSync3(f, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
@@ -3565,11 +4472,11 @@ function log(state, line) {
   }
 }
 function factsState(state) {
-  const file = (h, s) => path15.join(state, "facts", safeId(h), `${safeId(s)}.json`);
+  const file = (h, s) => path17.join(state, "facts", safeId(h), `${safeId(s)}.json`);
   return {
     get(h, s) {
       try {
-        return JSON.parse(readFileSync10(file(h, s), "utf8"));
+        return JSON.parse(readFileSync12(file(h, s), "utf8"));
       } catch {
         return {};
       }
@@ -3578,8 +4485,8 @@ function factsState(state) {
       const cur = this.get(h, s);
       const next = { ...cur, ...patch };
       if (JSON.stringify(next) === JSON.stringify(cur)) return;
-      mkdirSync8(path15.dirname(file(h, s)), { recursive: true, mode: 448 });
-      writeFileSync8(file(h, s), JSON.stringify(next), { mode: 384 });
+      mkdirSync7(path17.dirname(file(h, s)), { recursive: true, mode: 448 });
+      writeFileSync6(file(h, s), JSON.stringify(next), { mode: 384 });
     }
   };
 }
@@ -3592,10 +4499,10 @@ function buildSinks(sinks, o = {}) {
       o.locked?.(raw.name);
       continue;
     }
-    const tier = Math.min(s.tier, s.max_tier ?? 3);
+    const tier = Math.trunc(Math.min(Number(s.tier) || 0, s.max_tier ?? 3));
     if (s.url === "stdout") out.push(new StdoutSink(s.name, tier, !!s.pii));
     else if (s.url.startsWith("file:"))
-      out.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os3.homedir()), tier, !!s.pii));
+      out.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os4.homedir()), tier, !!s.pii));
     else if (/^https?:\/\//.test(s.url)) out.push(new HttpSink(s, tier));
   }
   return out;
@@ -3603,13 +4510,14 @@ function buildSinks(sinks, o = {}) {
 var PROGRESS_MS = 2e4;
 function openTurn(read, o) {
   const last = read.turns[read.turns.length - 1];
-  const fresh = (user, at) => ({
+  const fresh = (user, at, injected) => ({
     turn: o.base + read.turns.length,
     user: user.slice(0, MAX_TURN_SIDE),
     assistant: "",
-    at
+    at,
+    ...injected ? { injected: true } : {}
   });
-  if (read.open) return fresh(read.open.user, read.open.at);
+  if (read.open) return fresh(read.open.user, read.open.at, read.open.injected);
   const prompt = o.prompt?.trim();
   if (prompt && !isInjected(prompt) && !(last && last.user.includes(prompt.slice(0, 200)))) return fresh(prompt, o.at);
   if (!last) return null;
@@ -3617,6 +4525,7 @@ function openTurn(read, o) {
     turn: o.base + read.turns.length - 1,
     user: last.user.slice(0, MAX_TURN_SIDE),
     assistant: capTail(last.assistant, MAX_TURN_SIDE),
+    ...last.injected ? { injected: true } : {},
     at: last.at
   };
 }
@@ -3624,6 +4533,7 @@ var MAX_TURN_SIDE = 2e4;
 var JOB_OWN_ENV = [
   "CLAUDE_CODE_SESSION_ATTENDED",
   "CLAUDE_CODE_HOST_SESSION_ID",
+  "SESSIONPIPE_ASKED_BY",
   "SESSIONPIPE_CONTROL_JOB",
   "SESSIONPIPE_LAUNCHED_BY"
 ];
@@ -3651,7 +4561,7 @@ async function runJob(job, opts = {}) {
     );
     return { events: [], delivered: {} };
   }
-  const id = receiverIdOf(readAliases(aliasFile(path15.join(state, "control"))), job.harness, r.session.id) ?? r.session.id;
+  const id = receiverIdOf(readAliases(aliasFile(path17.join(state, "control"))), job.harness, r.session.id) ?? r.session.id;
   const claudeEnd = job.harness === "claude-code" && r.events.some((e) => e.type === "session.ended");
   if (!claudeEnd) await tellDaemon(state, job, id, r.session.cwd, r.transcript);
   const outbox = new Outbox(state);
@@ -3688,7 +4598,7 @@ async function runJob(job, opts = {}) {
       learned = rest;
       if (harness_version) facts.save(job.harness, id, { harness_version });
       facts.save(job.harness, id, { session: { ...mem.session, ...learned } });
-      if (CWD_FROM_HOOKS.has(job.harness) && r.session.cwd && path15.isAbsolute(r.session.cwd))
+      if (CWD_FROM_HOOKS.has(job.harness) && r.session.cwd && path17.isAbsolute(r.session.cwd))
         facts.save(job.harness, id, { cwd: r.session.cwd });
     }
     const known = mem.session ?? {};
@@ -3701,10 +4611,11 @@ async function runJob(job, opts = {}) {
       ...learned.branch ? { branch: learned.branch } : {},
       id,
       seq: 0,
-      machine: machineName(cfg, os3.hostname()),
+      machine: machineName(cfg, os4.hostname()),
       ...cwdRaw ? { cwd: tilde(cwdRaw) } : {},
       ...r.session.model ? { model: r.session.model } : {},
-      ...r.session.launched_by ? { launched_by: r.session.launched_by } : {}
+      ...r.session.launched_by ? { launched_by: r.session.launched_by } : {},
+      ...r.session.delegated_by ? { delegated_by: r.session.delegated_by } : {}
     };
     const version = facts.get(job.harness, id).harness_version ?? void 0;
     for (const a of r.events) {
@@ -3758,7 +4669,13 @@ async function runJob(job, opts = {}) {
             {
               type: "turn.transcript",
               harnessEvent: job.event,
-              data: { turn: turnNo++, user: t.user, assistant: t.assistant, at: new Date(t.at).toISOString() }
+              data: {
+                turn: turnNo++,
+                user: t.user,
+                assistant: t.assistant,
+                at: new Date(t.at).toISOString(),
+                ...t.injected ? { injected: true } : {}
+              }
             },
             {
               harness: { name: job.harness, ...version ? { version } : {} },
@@ -3799,29 +4716,83 @@ async function runJob(job, opts = {}) {
   } finally {
     release();
   }
-  const delivered = await drain(state, cfg.sinks, outbox, ref) ?? {};
   if (Math.random() < 0.02) outbox.prune(cfg.keep_days ?? 30);
+  const delivered = opts.drain === false ? {} : await drain(state, cfg.sinks, outbox, ref, {
+    ...opts.clock ? { clock: opts.clock } : {},
+    ...opts.deadline !== void 0 ? { deadline: opts.deadline } : {},
+    ...opts.handoff ? { handoff: opts.handoff } : {}
+  }) ?? {};
   return { events, delivered };
 }
-async function drain(state, sinkConfigs, outbox, first) {
-  const more = path15.join(state, "locks", "flush.more");
+var REAL_CLOCK = { now: () => Date.now(), sleep: (ms) => new Promise((r) => setTimeout(r, ms)) };
+var PACE_MS = 1e3;
+var sentFile = (state) => path17.join(state, "locks", "flush.sent");
+function lastSent(state) {
+  try {
+    return Number(readFileSync12(sentFile(state), "utf8"));
+  } catch {
+    return 0;
+  }
+}
+function noteSent(state, at) {
+  try {
+    mkdirSync7(path17.dirname(sentFile(state)), { recursive: true, mode: 448 });
+    writeFileSync6(sentFile(state), String(at), { mode: 384 });
+  } catch {
+  }
+}
+function waitingForReceiver(state, sinkConfigs, outbox, now) {
+  const receivers = sinkConfigs.filter(
+    (s) => !s.paused && /^https?:\/\//.test(s.url) && !((readBackoff(state, s.name)?.until ?? 0) > now)
+  );
+  if (!receivers.length) return false;
+  const refs = outbox.sessions();
+  for (const s of receivers) {
+    const cursors = new Cursors(state, s.name);
+    const c = cursors.read();
+    for (const ref of refs) {
+      try {
+        if (statSync7(outbox.file(ref)).size > (c[cursors.key(ref)] ?? 0)) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+var PASS_BUDGET_MS = 3e3;
+var moreFile = (state) => path17.join(state, "locks", "flush.more");
+function markMore(state) {
+  try {
+    mkdirSync7(path17.dirname(moreFile(state)), { recursive: true, mode: 448 });
+    writeFileSync6(moreFile(state), "", { mode: 384 });
+  } catch {
+  }
+}
+async function drain(state, sinkConfigs, outbox, first, o = {}) {
+  const clock = o.clock ?? REAL_CLOCK;
+  const more = moreFile(state);
   let release = takeNamedLock(state, "flush");
   if (!release) {
-    try {
-      writeFileSync8(more, "", { mode: 384 });
-    } catch {
-    }
+    markMore(state);
     release = takeNamedLock(state, "flush");
     if (!release) return null;
   }
   const delivered = {};
   for (; ; ) {
-    try {
-      unlinkSync4(more);
-    } catch {
+    if (o.deadline !== void 0 && clock.now() + PASS_BUDGET_MS > o.deadline) {
+      markMore(state);
+      release();
+      o.handoff?.();
+      return delivered;
     }
     try {
-      for (const [k, v] of Object.entries(await flush(state, sinkConfigs, outbox, first)))
+      const wait = Math.min(PACE_MS, lastSent(state) + PACE_MS - clock.now());
+      if (wait > 0 && waitingForReceiver(state, sinkConfigs, outbox, clock.now())) await clock.sleep(wait);
+      try {
+        unlinkSync3(more);
+      } catch {
+      }
+      for (const [k, v] of Object.entries(await flush(state, sinkConfigs, outbox, first, { clock })))
         delivered[k] = (delivered[k] ?? 0) + v;
     } finally {
       release();
@@ -3832,10 +4803,10 @@ async function drain(state, sinkConfigs, outbox, first) {
   }
 }
 var BACKOFF_MS = [2e3, 1e4, 6e4, 5 * 6e4, 30 * 6e4];
-var backoffFile = (state, sink) => path15.join(state, "backoff", `${safeId(sink)}.json`);
+var backoffFile = (state, sink) => path17.join(state, "backoff", `${safeId(sink)}.json`);
 function readBackoff(state, sink) {
   try {
-    const b = JSON.parse(readFileSync10(backoffFile(state, sink), "utf8"));
+    const b = JSON.parse(readFileSync12(backoffFile(state, sink), "utf8"));
     return typeof b.until === "number" ? b : null;
   } catch {
     return null;
@@ -3848,15 +4819,15 @@ function noteFailure(state, sink, res, prev) {
   const b = { until: Date.now() + wait, failures, why: `${res.status ?? ""} ${res.error ?? ""}`.trim() };
   const f = backoffFile(state, sink);
   try {
-    mkdirSync8(path15.dirname(f), { recursive: true, mode: 448 });
-    writeFileSync8(f, JSON.stringify(b), { mode: 384 });
+    mkdirSync7(path17.dirname(f), { recursive: true, mode: 448 });
+    writeFileSync6(f, JSON.stringify(b), { mode: 384 });
   } catch {
   }
   return b;
 }
 function clearBackoff(state, sink) {
   try {
-    unlinkSync4(backoffFile(state, sink));
+    unlinkSync3(backoffFile(state, sink));
   } catch {
   }
 }
@@ -3866,14 +4837,31 @@ var BATCH = 50;
 var MAX_PER_RUN = 500;
 async function flush(state, sinkConfigs, outbox, first, o = {}) {
   const delivered = {};
+  const clock = o.clock ?? REAL_CLOCK;
   const sinks = buildSinks(sinkConfigs, {
     locked: (name) => log(state, `sink ${name}: its token is in a keychain this process can't read; left for later`)
   });
+  const modes = new Map(sinkConfigs.map((s) => [s.name, toolsMode(s)]));
   const refs = outbox.sessions();
   if (first) {
     const k = `${first.harness}/${safeId(first.session)}`;
     refs.sort((a, b) => `${a.harness}/${a.session}` === k ? -1 : `${b.harness}/${b.session}` === k ? 1 : 0);
   }
+  const unreadable = /* @__PURE__ */ new Set();
+  const readOrSkip = (ref, offset, room) => {
+    try {
+      return outbox.read(ref, offset, room);
+    } catch (e) {
+      const code = e.code;
+      if (typeof code !== "string") throw e;
+      const f = outbox.file(ref);
+      if (!unreadable.has(f)) {
+        unreadable.add(f);
+        log(state, `drain: can't read ${f} (${code}); skipped, its cursors stay`);
+      }
+      return null;
+    }
+  };
   const drainSink = async (sink) => {
     let backoff = readBackoff(state, sink.name);
     if (backoff && !o.force && backoff.until > Date.now()) {
@@ -3882,11 +4870,16 @@ async function flush(state, sinkConfigs, outbox, first, o = {}) {
     }
     const cursors = new Cursors(state, sink.name);
     const c = cursors.read();
+    const mode = modes.get(sink.name);
+    const tools = new ToolClock(state, sink.name);
+    let clockNow = mode === "all" ? {} : tools.read();
+    let clockNext = { ...clockNow };
     let sent = 0;
     let stalled = false;
     let batch = [];
     let pending = {};
     const deliver = async (events) => {
+      if (sink instanceof HttpSink) noteSent(state, clock.now());
       const res = await sink.send(events);
       if (res.ok || res.action !== "split") return res;
       if (events.length === 1) {
@@ -3894,10 +4887,20 @@ async function flush(state, sinkConfigs, outbox, first, o = {}) {
         log(state, `sink ${sink.name}: 413 ${res.error ?? ""} \u2192 event ${e.id} (${e.type}) is too large alone, dropped`);
         return { ok: true, acknowledged: 0, accepted: 0, duplicates: 0, rejected: [{ id: e.id, reason: "too_large" }] };
       }
+      const part = async (some) => {
+        const r = await deliver(some);
+        if (r.ok || r.action !== "drop") return r;
+        log(
+          state,
+          `sink ${sink.name}: ${r.status ?? ""} ${r.error ?? ""} \u2192 drop, ${some.length} of ${events.length} events`
+        );
+        const rejected = some.map((e) => ({ id: e.id, reason: "dropped" }));
+        return { ok: true, acknowledged: 0, accepted: 0, duplicates: 0, rejected };
+      };
       const half = Math.ceil(events.length / 2);
-      const a = await deliver(events.slice(0, half));
+      const a = await part(events.slice(0, half));
       if (!a.ok) return a;
-      const b = await deliver(events.slice(half));
+      const b = await part(events.slice(half));
       if (!b.ok) return b;
       return {
         ok: true,
@@ -3907,11 +4910,17 @@ async function flush(state, sinkConfigs, outbox, first, o = {}) {
         rejected: [...a.rejected ?? [], ...b.rejected ?? []]
       };
     };
+    const commitClock = () => {
+      if (mode === "all" || JSON.stringify(clockNext) === JSON.stringify(clockNow)) return;
+      tools.write(clockNext);
+      clockNow = { ...clockNext };
+    };
     const send = async () => {
       if (!batch.length) {
         Object.assign(c, pending);
         pending = {};
         cursors.write(c);
+        commitClock();
         return true;
       }
       const res = await deliver(batch);
@@ -3927,6 +4936,7 @@ async function flush(state, sinkConfigs, outbox, first, o = {}) {
         if (res.action !== "drop") {
           batch = [];
           pending = {};
+          clockNext = { ...clockNow };
           return false;
         }
       } else if (backoff) {
@@ -3936,6 +4946,7 @@ async function flush(state, sinkConfigs, outbox, first, o = {}) {
       sent += batch.length;
       Object.assign(c, pending);
       cursors.write(c);
+      commitClock();
       batch = [];
       pending = {};
       return true;
@@ -3945,11 +4956,15 @@ async function flush(state, sinkConfigs, outbox, first, o = {}) {
       let offset = pending[cursors.key(ref)] ?? c[cursors.key(ref)] ?? 0;
       for (; ; ) {
         const room = BATCH - batch.length;
-        const { events, offset: next } = outbox.read(ref, offset, room);
+        const read = readOrSkip(ref, offset, room);
+        if (!read) break;
+        const { events, offset: next } = read;
         if (!events.length) break;
         for (const e of events) {
-          const f = filterEvent(e, sink.tier, sink.pii, { home: os3.homedir() });
-          if (f) batch.push(f);
+          const f = filterEvent(e, sink.tier, sink.pii, { home: os4.homedir() });
+          if (!f) continue;
+          if (sendTool(f, mode, clockNext, cursors.key(ref))) batch.push(f);
+          else if (o.thinned) o.thinned[sink.name] = (o.thinned[sink.name] ?? 0) + 1;
         }
         offset = next;
         pending[cursors.key(ref)] = offset;
@@ -3981,7 +4996,7 @@ function applySinkVerdict(name, res) {
   } catch {
   }
 }
-var jobsDir = (state) => path15.join(state, "jobs");
+var jobsDir = (state) => path17.join(state, "jobs");
 export {
   HttpSink,
   buildSinks,