sessionpipe 0.13.0 → 0.13.1

package/dist/worker.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// sessionpipe 0.13.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)
@@ -37,7 +37,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 } 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";
 
@@ -395,6 +395,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 {
@@ -436,8 +471,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 };
 }
@@ -460,12 +495,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);
@@ -544,7 +575,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) => {
@@ -552,7 +583,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),
@@ -647,7 +680,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;
@@ -656,7 +690,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;
@@ -781,8 +816,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 };
@@ -1388,16 +1426,7 @@ function runHeadless(bin, args, o) {
 }
 
 // ../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";
@@ -1429,10 +1458,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,
@@ -1448,12 +1475,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);
@@ -2186,7 +2209,7 @@ function parseResult(stdout) {
 var isUuid = (s) => typeof s === "string" && UUID_RE.test(s);
 
 // ../core/src/adapters/codex.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync4, readdirSync as readdirSync5, readFileSync as readFileSync6 } from "node:fs";
 import path8 from "node:path";
 
 // ../core/src/adapters/codex-config.ts
@@ -2339,29 +2362,30 @@ 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 = readFileSync6(file, "utf8");
-  } catch {
+  } 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(path8.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);
@@ -2370,20 +2394,20 @@ 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);
@@ -2395,15 +2419,13 @@ function uninstallNotify(env) {
   }
   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) {
@@ -2435,8 +2457,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,
@@ -2515,6 +2541,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) {
@@ -2534,17 +2562,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":
@@ -3034,7 +3075,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 >= ?
 )
@@ -3303,7 +3344,7 @@ 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 readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+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()) {
@@ -3319,9 +3360,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(path11.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 {
@@ -3385,19 +3453,20 @@ function makeEvent(a, ctx) {
 }
 
 // ../core/src/outbox.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
 import {
   appendFileSync,
   closeSync as closeSync3,
   existsSync as existsSync9,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync3,
   openSync as openSync3,
   readdirSync as readdirSync6,
   readFileSync as readFileSync9,
   readSync as readSync3,
   renameSync,
   statSync as statSync6,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync6
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "node:fs";
 import path12 from "node:path";
 var READ_CHUNK = 1024 * 1024;
@@ -3427,8 +3496,8 @@ var Outbox = class {
     } catch {
     }
     if (n < 0) n = this.lastSeqInFile(ref) + 1;
-    mkdirSync5(path12.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) {
@@ -3446,7 +3515,7 @@ 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 });
   }
@@ -3516,34 +3585,106 @@ var Outbox = class {
       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 (statSync6(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 stale2 = (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 = stale2(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) {
@@ -3555,18 +3696,21 @@ var Cursors = class {
   file() {
     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(readFileSync9(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(path12.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) {
@@ -3578,21 +3722,43 @@ function takeLock(root, ref, staleMs = 5 * 6e4) {
 }
 function takeNamedLock(root, name, staleMs = 5 * 6e4) {
   const dir = path12.join(root, "locks");
-  mkdirSync5(dir, { recursive: true, mode: 448 });
+  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() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(readFileSync9(f, "utf8")))) unlinkSync3(f);
-    else return null;
+    body = readFileSync9(f, "utf8");
+    const stale2 = Date.now() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(body.split(" ")[0]));
+    if (!stale2) 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 {
     }
   };
@@ -3611,7 +3777,7 @@ function processAlive(pid) {
 import { createHash as createHash3 } 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;
@@ -3622,7 +3788,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"), "~");
@@ -3836,7 +4002,7 @@ var DATA_ALLOW = {
   "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"] },
@@ -3927,7 +4093,7 @@ function shortId(harness, id) {
 }
 
 // ../core/src/sinks/file.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4 } from "node:fs";
 import path13 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
@@ -3942,7 +4108,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path13.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: [] };
@@ -3979,24 +4145,24 @@ var StdoutSink = class {
 import {
   appendFileSync as appendFileSync3,
   existsSync as existsSync10,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync7,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync11,
-  renameSync as renameSync3,
+  readFileSync as readFileSync12,
+  renameSync as renameSync4,
   statSync as statSync7,
-  unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync8
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import os4 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 
 // src/control/aliases.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync10, renameSync as renameSync2, writeFileSync as writeFileSync7 } from "node:fs";
+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 createHash5, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash5, randomBytes as randomBytes3 } from "node:crypto";
 var SERVICE = "sessionpipe";
 var defaultRunner = (cmd, args, input) => {
   const r = spawnSync(cmd, args, {
@@ -4020,9 +4186,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
@@ -4097,6 +4263,76 @@ 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/http-sink.ts
 import { createHash as createHash6, createHmac } from "node:crypto";
 var TIMEOUT_MS = 15e3;
@@ -4217,20 +4453,20 @@ async function tellDaemon(state, job, session, cwd, transcript) {
 var MAX_TRIES = 10;
 function enqueueJob(state, job) {
   const jobs = jobsDir(state);
-  mkdirSync8(jobs, { recursive: true, mode: 448 });
-  const f = path16.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 claimJob(file) {
   const claimed = `${file}.${process.pid}.running`;
   try {
-    renameSync3(file, claimed);
+    renameSync4(file, claimed);
   } catch {
     return null;
   }
   try {
-    return { job: JSON.parse(readFileSync11(claimed, "utf8")), file: claimed };
+    return { job: JSON.parse(readFileSync12(claimed, "utf8")), file: claimed };
   } catch {
     releaseJob(claimed);
     return null;
@@ -4239,11 +4475,11 @@ function claimJob(file) {
 function releaseJob(claimed) {
   if (!claimed) return;
   try {
-    unlinkSync4(claimed);
+    unlinkSync3(claimed);
   } catch {
   }
 }
-async function sweepJobs(state, olderThanMs = 3e3, limit = 20, abandonedMs = 6e4) {
+async function sweepJobs(state, olderThanMs = 3e3, limit = 20, abandonedMs = 6e4, o = {}) {
   const jobs = jobsDir(state);
   let names = [];
   try {
@@ -4255,17 +4491,18 @@ async function sweepJobs(state, olderThanMs = 3e3, limit = 20, abandonedMs = 6e4
   for (const n of names) {
     const m = /^(.*\.json)\.(\d+)\.running$/.exec(n);
     if (!m) continue;
-    const f = path16.join(jobs, n);
+    const f = path17.join(jobs, n);
     try {
       if (processAlive(Number(m[2])) && Date.now() - statSync7(f).mtimeMs < abandonedMs) continue;
-      renameSync3(f, path16.join(jobs, m[1]));
+      renameSync4(f, path17.join(jobs, m[1]));
       queued.push(m[1]);
     } catch {
     }
   }
   let ran = 0;
   for (const n of queued.sort().slice(0, limit)) {
-    const f = path16.join(jobs, n);
+    if (o.deadline !== void 0 && Date.now() + SWEEP_LOCK_WAIT_MS + PASS_BUDGET_MS > o.deadline) break;
+    const f = path17.join(jobs, n);
     try {
       if (Date.now() - statSync7(f).mtimeMs < olderThanMs) continue;
     } catch {
@@ -4274,21 +4511,23 @@ async function sweepJobs(state, olderThanMs = 3e3, limit = 20, abandonedMs = 6e4
     const c = claimJob(f);
     if (!c) continue;
     try {
-      await runJob(c.job, { state, claimed: c.file });
+      const r = await runJob(c.job, { state, claimed: c.file, drain: false, lockWaitMs: SWEEP_LOCK_WAIT_MS });
+      if (r.events.length) markMore(state);
     } catch {
     } finally {
       releaseJob(c.file);
     }
     ran++;
   }
+  if (ran) await drain(state, readConfig().sinks, new Outbox(state), void 0, o);
   return ran;
 }
 function log(state, line) {
   try {
-    mkdirSync8(state, { recursive: true, mode: 448 });
-    const f = path16.join(state, "log");
+    mkdirSync7(state, { recursive: true, mode: 448 });
+    const f = path17.join(state, "log");
     try {
-      if (statSync7(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}
@@ -4297,11 +4536,11 @@ function log(state, line) {
   }
 }
 function factsState(state) {
-  const file = (h, s) => path16.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(readFileSync11(file(h, s), "utf8"));
+        return JSON.parse(readFileSync12(file(h, s), "utf8"));
       } catch {
         return {};
       }
@@ -4310,8 +4549,8 @@ function factsState(state) {
       const cur = this.get(h, s);
       const next = { ...cur, ...patch };
       if (JSON.stringify(next) === JSON.stringify(cur)) return;
-      mkdirSync8(path16.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 });
     }
   };
 }
@@ -4324,7 +4563,7 @@ 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(/^~(?=\/|$)/, os4.homedir()), tier, !!s.pii));
@@ -4386,7 +4625,7 @@ async function runJob(job, opts = {}) {
     );
     return { events: [], delivered: {} };
   }
-  const id = receiverIdOf(readAliases(aliasFile(path16.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);
@@ -4423,7 +4662,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 && path16.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 ?? {};
@@ -4541,29 +4780,84 @@ 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 = path16.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 SWEEP_LOCK_WAIT_MS = 1e3;
+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();
@@ -4574,10 +4868,10 @@ async function drain(state, sinkConfigs, outbox, first) {
   }
 }
 var BACKOFF_MS = [2e3, 1e4, 6e4, 5 * 6e4, 30 * 6e4];
-var backoffFile = (state, sink) => path16.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(readFileSync11(backoffFile(state, sink), "utf8"));
+    const b = JSON.parse(readFileSync12(backoffFile(state, sink), "utf8"));
     return typeof b.until === "number" ? b : null;
   } catch {
     return null;
@@ -4590,15 +4884,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(path16.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 {
   }
 }
@@ -4608,14 +4902,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()) {
@@ -4624,11 +4935,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) {
@@ -4636,10 +4952,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,
@@ -4649,11 +4975,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);
@@ -4669,6 +5001,7 @@ async function flush(state, sinkConfigs, outbox, first, o = {}) {
         if (res.action !== "drop") {
           batch = [];
           pending = {};
+          clockNext = { ...clockNow };
           return false;
         }
       } else if (backoff) {
@@ -4678,6 +5011,7 @@ async function flush(state, sinkConfigs, outbox, first, o = {}) {
       sent += batch.length;
       Object.assign(c, pending);
       cursors.write(c);
+      commitClock();
       batch = [];
       pending = {};
       return true;
@@ -4687,11 +5021,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: os4.homedir() });
-          if (f) batch.push(f);
+          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;
@@ -4723,31 +5061,105 @@ function applySinkVerdict(name, res) {
   } catch {
   }
 }
-var jobsDir = (state) => path16.join(state, "jobs");
+var jobsDir = (state) => path17.join(state, "jobs");
+
+// src/wellknown.ts
+var WELL_KNOWN_MAX_AGE_MS = 24 * 60 * 6e4;
+var wellKnownUrl = (sinkUrl) => `${sinkUrl.replace(/\/$/, "")}/.well-known/sessionpipe`;
+async function readWellKnown(sinkUrl, timeoutMs, fetchFn = fetch) {
+  const r = await fetchFn(wellKnownUrl(sinkUrl), { signal: AbortSignal.timeout(timeoutMs) });
+  if (!r.ok) throw new Error(`HTTP ${r.status}`);
+  return await r.json();
+}
+function applyWellKnown(s, wk, tier, now = /* @__PURE__ */ new Date()) {
+  const notes = [];
+  if (typeof wk.max_tier === "number") {
+    s.max_tier = wk.max_tier;
+    if (wk.max_tier < tier)
+      notes.push(`receiver's max_tier is ${wk.max_tier}: sending tier ${wk.max_tier}, not ${tier}`);
+  }
+  if (wk.endpoints) s.endpoints = wk.endpoints;
+  const before = s.receiver_tools;
+  if (isToolsMode(wk.tools)) s.receiver_tools = wk.tools;
+  else delete s.receiver_tools;
+  if (s.receiver_tools !== before && s.receiver_tools && s.receiver_tools !== "all" && !isToolsMode(s.tools))
+    notes.push(`the receiver asks for tool events \`${s.receiver_tools}\` (--tools all keeps every one)`);
+  s.well_known_at = now.toISOString();
+  s.well_known_checked_at = s.well_known_at;
+  return notes;
+}
+var stale = (s, now) => {
+  const last = Date.parse(s.well_known_checked_at ?? s.well_known_at ?? "");
+  return !Number.isFinite(last) || now - last >= WELL_KNOWN_MAX_AGE_MS;
+};
+async function refreshWellKnown(cfg, o = {}) {
+  const now = o.now ?? Date.now;
+  let changed = false;
+  for (const s of cfg.sinks) {
+    if (!/^https?:\/\//.test(s.url) || !stale(s, now())) continue;
+    const at = new Date(now());
+    try {
+      applyWellKnown(s, await readWellKnown(s.url, o.timeoutMs ?? 3e3, o.fetchFn), s.tier, at);
+    } catch {
+      s.well_known_checked_at = at.toISOString();
+    }
+    changed = true;
+  }
+  return changed;
+}
+async function refreshSinks(o = {}) {
+  try {
+    const cfg = readConfig();
+    if (await refreshWellKnown(cfg, o)) writeConfig(cfg);
+  } catch {
+  }
+}
 
 // src/worker.ts
+var WORKER_LIFE_MS = 15e3;
+var DRAIN_ARG = "--drain";
+function startWorker(script, arg) {
+  const p = spawn2(process.execPath, [script, arg], { detached: true, stdio: "ignore", windowsHide: true });
+  p.unref();
+}
 async function workerMain(argv) {
   const jobFile = argv[2];
   if (!jobFile) return;
-  const claimed = claimJob(jobFile);
-  if (!claimed) return;
-  const deadline = setTimeout(() => process.exit(0), 15e3);
+  const script = argv[1];
+  let handedOff = false;
+  const life = {
+    deadline: Date.now() + WORKER_LIFE_MS,
+    handoff: () => {
+      if (handedOff) return;
+      handedOff = true;
+      startWorker(script, DRAIN_ARG);
+    }
+  };
+  const deadline = setTimeout(() => process.exit(0), WORKER_LIFE_MS);
   deadline.unref();
-  await runJob(claimed.job, { claimed: claimed.file }).then((r) => {
+  await refreshSinks();
+  if (jobFile === DRAIN_ARG) {
+    await drain(stateDir(), readConfig().sinks, new Outbox(stateDir()), void 0, life).then(() => sweepJobs(stateDir(), void 0, void 0, void 0, life)).catch(() => {
+    }).finally(() => clearTimeout(deadline));
+    return;
+  }
+  const claimed = claimJob(jobFile);
+  if (!claimed) {
+    clearTimeout(deadline);
+    return;
+  }
+  await runJob(claimed.job, { claimed: claimed.file, ...life }).then((r) => {
     if (!r.requeued || (claimed.job.tries ?? 0) + 1 >= MAX_TRIES) return;
-    const p = spawn2(process.execPath, [argv[1], r.requeued], {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true
-    });
-    p.unref();
+    startWorker(script, r.requeued);
   }).catch(() => {
-  }).finally(() => releaseJob(claimed.file)).then(() => sweepJobs(stateDir())).catch(() => {
+  }).finally(() => releaseJob(claimed.file)).then(() => sweepJobs(stateDir(), void 0, void 0, void 0, life)).catch(() => {
   }).finally(() => clearTimeout(deadline));
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync2(process.argv[1])).href)
   workerMain(process.argv).finally(() => process.exit(0));
 export {
+  DRAIN_ARG,
+  WORKER_LIFE_MS,
   workerMain
 };
 //# sourceMappingURL=worker.js.map