sessionpipe 0.13.0 → 0.13.1

package/dist/cli.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 = (target2, all) => {
   for (var name in all)
@@ -12,14 +12,14 @@ import {
   existsSync as existsSync21,
   mkdtempSync,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync23,
+  readFileSync as readFileSync24,
   realpathSync as realpathSync9,
   rmSync as rmSync3,
   statSync as statSync14,
-  unlinkSync as unlinkSync9
+  unlinkSync as unlinkSync8
 } from "node:fs";
 import os15 from "node:os";
-import path38 from "node:path";
+import path39 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../core/src/adapters/claude-code-pool.ts
@@ -76,7 +76,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";
 
@@ -434,6 +434,41 @@ function readJson(file) {
   const f = readJsonFile(file);
   return f.ok ? f.value : {};
 }
+function refused(file, e, what, existed) {
+  const { code, syscall } = e;
+  const why2 = `can't ${what} it (${code ?? String(e)})`;
+  if (what === "remove" || syscall === "open" || syscall === "mkdir")
+    return { file, changed: false, skipped: true, note: `${why2}; not touched` };
+  return {
+    file,
+    changed: true,
+    skipped: true,
+    ...existed ? {} : { created: true },
+    note: `${why2} 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 bad2 = refused(file, e, "remove", true);
+    return writeBack(file, empty) ?? {
+      file,
+      changed: true,
+      note: `emptied; ${bad2.note.replace(/; not touched$/, "")}, so the empty file stays`
+    };
+  }
+}
 function entryFor(event, harness, cmd, o) {
   const matcher = o.matcherFor(event);
   return {
@@ -475,8 +510,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 bad2 = writeBack(file, formatJson(settings2, f), f.existed);
+    if (bad2) return bad2;
   }
   return { file, changed, created: !f.existed && changed };
 }
@@ -499,12 +534,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);
@@ -583,7 +614,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 line2 = opts.statusLine === void 0 ? null : statusLine(settingsIn(d), opts.statusLine, cmd);
+    const line2 = opts.statusLine === void 0 || hooks.skipped ? null : statusLine(settingsIn(d), opts.statusLine, cmd);
     return line2 ? [hooks, line2] : [hooks];
   }),
   uninstall: (env = process.env, opts = {}) => claudeDirs(env).map((d) => {
@@ -591,7 +622,9 @@ var claudeCode = {
     const hooks = uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS, {
       created: opts.created?.includes(settingsIn(d))
     });
-    return line2 && !hooks.changed ? line2 : hooks;
+    if (line2?.changed && !line2.skipped && hooks.skipped)
+      return { ...hooks, note: `status line removed, hooks not: ${hooks.note?.replace(/; not touched$/, "")}` };
+    return line2 && !hooks.changed && !hooks.skipped ? line2 : hooks;
   }),
   installed: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
     file: settingsIn(d),
@@ -686,7 +719,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;
@@ -695,7 +729,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;
@@ -820,8 +855,11 @@ function statusLine(file, want, cmd) {
   if (want ? ours && cur?.command === command2 && cur?.refreshInterval === LINE_REFRESH_S : !ours) return null;
   if (want) f.value.statusLine = { type: "command", command: command2, 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 };
@@ -2183,18 +2221,18 @@ function startAcp(o) {
           );
           const stop = str(res?.stopReason);
           const words = t.text.trim() || `(${label} finished without a written reply.)`;
-          const refused = deniedNote(t.denied, t.count);
-          if (stop === "end_turn" || stop === "max_tokens") return { reply: words + refused };
+          const refused2 = deniedNote(t.denied, t.count);
+          if (stop === "end_turn" || stop === "max_tokens") return { reply: words + refused2 };
           if (stop === "refusal") return { reply: `${words}
 
-(${label} refused the request.)${refused}` };
+(${label} refused the request.)${refused2}` };
           if (stop === "cancelled")
             return timedOut ? {
               reply: "",
               error: `${label} was still working after ${Math.round(limit / 6e4)} minutes, so it was stopped`
             } : { reply: `${words}
 
-(The turn was cancelled.)${refused}` };
+(The turn was cancelled.)${refused2}` };
           return { reply: "", error: `${label} ended the turn with ${stop || "no stop reason"}` };
         } catch (e) {
           return { reply: "", error: e.message };
@@ -2255,16 +2293,7 @@ function startAcp(o) {
 }
 
 // ../core/src/adapters/antigravity.ts
-import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync5,
-  realpathSync,
-  statSync as statSync4,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
-} from "node:fs";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync5, realpathSync, statSync as statSync4 } from "node:fs";
 import path8 from "node:path";
 var NAME2 = "antigravity";
 var HOOK_NAME = "sessionpipe";
@@ -2296,10 +2325,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(path8.dirname(file), { recursive: true });
-    writeFileSync3(file, formatJson(hooks, f));
     return [
-      {
+      writeBack(file, formatJson(hooks, f), f.existed) ?? {
         file,
         changed: true,
         created: !f.existed,
@@ -2315,12 +2342,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);
@@ -3711,7 +3734,7 @@ function parseResult(stdout) {
 var isUuid = (s) => typeof s === "string" && UUID_RE3.test(s);
 
 // ../core/src/adapters/codex.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync4, readdirSync as readdirSync5, readFileSync as readFileSync7 } from "node:fs";
 import path11 from "node:path";
 
 // ../core/src/adapters/codex-config.ts
@@ -3864,29 +3887,30 @@ var configFile2 = (env) => path11.join(codexHome(env), "config.toml");
 var sessionsDir = (env) => path11.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 = readFileSync7(file, "utf8");
-  } catch {
+  } catch (e) {
+    existed = e.code !== "ENOENT";
   }
   const argv = cmd([NAME3, "notify"]).argv;
   const line2 = `notify = ${JSON.stringify(argv)}`;
   const n = readNotify(text);
-  const write = (next) => {
-    mkdirSync3(path11.dirname(file), { recursive: true });
-    writeFileSync4(file, next);
+  const write = (next, note) => {
+    const bad2 = writeBack(file, next, existed);
+    return bad2 ? { ...bad2, note: `${bad2.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, line2));
-    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, line2),
+      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);
@@ -3895,20 +3919,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, line2));
-  return { file, changed: true, note: "notify set at the top level" };
+  return write(withNotify(text, line2), "notify set at the top level");
 }
 function uninstallNotify(env) {
   const file = configFile2(env);
@@ -3920,15 +3944,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) {
@@ -3960,8 +3982,12 @@ function rolloutMeta(file) {
   return scanLines(file, (line2) => parseLines([line2])[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,
@@ -4040,6 +4066,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) {
@@ -4059,17 +4087,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":
@@ -4727,7 +4768,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 >= ?
 )
@@ -5005,7 +5046,7 @@ function drivableHarnesses(env = process.env) {
 }
 
 // ../core/src/config.ts
-import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "node:fs";
+import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync2 } from "node:fs";
 import path15 from "node:path";
 var DEFAULT_CONFIG = { sinks: [], harnesses: {}, update_check: true, keep_days: 30 };
 function readConfig(file = configFile()) {
@@ -5021,9 +5062,36 @@ function readConfig(file = configFile()) {
     return { ...DEFAULT_CONFIG, sinks: [], harnesses: {} };
   }
 }
+function configProblem(file) {
+  let text;
+  try {
+    text = readFileSync10(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(path15.dirname(file), { recursive: true, mode: 448 });
-  writeFileSync5(file, `${JSON.stringify(c, null, 2)}
+  assertConfigWritable(file);
+  mkdirSync2(path15.dirname(file), { recursive: true, mode: 448 });
+  writeFileSync2(file, `${JSON.stringify(c, null, 2)}
 `, { mode: 384 });
   if (process.platform !== "win32" && existsSync8(file)) {
     try {
@@ -5087,19 +5155,20 @@ function makeEvent(a, ctx) {
 }
 
 // ../core/src/outbox.ts
+import { randomBytes as randomBytes3 } 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 readFileSync11,
   readSync as readSync3,
   renameSync,
   statSync as statSync6,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync6
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "node:fs";
 import path16 from "node:path";
 var READ_CHUNK = 1024 * 1024;
@@ -5129,8 +5198,8 @@ var Outbox = class {
     } catch {
     }
     if (n < 0) n = this.lastSeqInFile(ref) + 1;
-    mkdirSync5(path16.dirname(f), { recursive: true, mode: 448 });
-    writeFileSync6(f, String(n + 1), { mode: 384 });
+    mkdirSync3(path16.dirname(f), { recursive: true, mode: 448 });
+    writeFileSync3(f, String(n + 1), { mode: 384 });
     return n;
   }
   lastSeqInFile(ref) {
@@ -5148,7 +5217,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 });
   }
@@ -5218,34 +5287,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(gone2) {
+    let names = [];
+    try {
+      names = readdirSync6(path16.join(this.root, "cursors")).filter((n) => n.endsWith(".json"));
+    } catch {
+    }
+    const stale = (c) => Object.keys(c).filter((k) => {
+      if (gone2.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(path16.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, sink2) {
@@ -5257,18 +5398,21 @@ var Cursors = class {
   file() {
     return path16.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(readFileSync11(this.file(), "utf8"));
+      const c = JSON.parse(readFileSync11(this.file(), "utf8"));
+      return c && typeof c === "object" && !Array.isArray(c) ? c : {};
     } catch {
       return {};
     }
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path16.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync3(path16.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) {
@@ -5280,25 +5424,54 @@ function takeLock(root, ref, staleMs = 5 * 6e4) {
 }
 function takeNamedLock(root, name, staleMs = 5 * 6e4) {
   const dir = path16.join(root, "locks");
-  mkdirSync5(dir, { recursive: true, mode: 448 });
+  mkdirSync3(dir, { recursive: true, mode: 448 });
   const f = path16.join(dir, `${name}.lock`);
+  const nonce = randomBytes3(8).toString("hex");
+  const mine = `${process.pid} ${nonce}`;
+  let body = null;
   try {
-    if (Date.now() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(readFileSync11(f, "utf8")))) unlinkSync3(f);
-    else return null;
+    body = readFileSync11(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 = readFileSync11(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 (readFileSync11(f, "utf8") === mine) unlinkSync2(f);
     } catch {
     }
   };
 }
+async function waitNamedLock(root, name, forMs, everyMs = 100) {
+  for (let waited = 0; ; waited += everyMs) {
+    const release = takeNamedLock(root, name);
+    if (release || waited >= forMs) return release;
+    await new Promise((r) => setTimeout(r, everyMs));
+  }
+}
 function processAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return true;
   try {
@@ -5313,7 +5486,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;
@@ -5324,7 +5497,7 @@ function looksPhone(s) {
 function reducePii(text, home) {
   if (!text) return text;
   let out2 = text.replace(EMAIL, "[email]");
-  out2 = out2.replace(PHONE, (m) => looksPhone(m) ? "[phone]" : m);
+  out2 = out2.replace(PHONE, (m, date) => !date && looksPhone(m) ? "[phone]" : m);
   if (home) {
     const h = home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     out2 = out2.replace(new RegExp(`(?<![A-Za-z0-9_])${h}(?=/|$|\\s|["'\`])`, "g"), "~");
@@ -5538,7 +5711,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"] },
@@ -5629,7 +5802,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 path17 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
@@ -5644,7 +5817,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path17.dirname(this.file), { recursive: true });
+      mkdirSync4(path17.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: [] };
@@ -5678,9 +5851,9 @@ var StdoutSink = class {
 };
 
 // src/ask.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync13, readFileSync as readFileSync17, statSync as statSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync18, statSync as statSync8, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "node:fs";
 import os12 from "node:os";
-import path28 from "node:path";
+import path29 from "node:path";
 
 // src/connect.ts
 import path18 from "node:path";
@@ -5714,10 +5887,17 @@ function connectFolders(o) {
   }
   return picked.length ? { folders: picked, from: "recent" } : { folders: [], from: "none" };
 }
+function tierArg(argv, fallback) {
+  const i = argv.indexOf("--tier");
+  if (i < 0) return fallback;
+  const v = argv[i + 1] ?? "";
+  const n = /^-?\d+$/.test(v.trim()) ? Number(v) : Number.NaN;
+  if (Number.isNaN(n)) throw new Error(`--tier takes 0, 1, 2 or 3${v ? `, not "${v}"` : ""}`);
+  return Math.max(0, Math.min(3, n));
+}
 function connectTier(flag2, current) {
-  if (flag2 !== void 0 && flag2 !== "")
-    return Math.max(0, Math.min(3, Math.trunc(Number(flag2)) || 0));
-  return Math.max(2, Math.min(3, current ?? 0));
+  if (flag2 !== void 0) return flag2;
+  return Math.max(2, Math.min(3, Math.trunc(Number(current) || 0)));
 }
 
 // src/control/local.ts
@@ -5795,13 +5975,13 @@ function askMany(sock, req, onReply, timeoutMs) {
 }
 
 // src/control/pair.ts
-import { randomBytes as randomBytes4 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync5, mkdirSync as mkdirSync9, openSync as openSync5 } from "node:fs";
+import { randomBytes as randomBytes5 } from "node:crypto";
+import { chmodSync as chmodSync3, closeSync as closeSync5, mkdirSync as mkdirSync7, openSync as openSync5 } from "node:fs";
 import path22 from "node:path";
 
 // ../core/src/service/index.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import os8 from "node:os";
 import path20 from "node:path";
 var execQuiet = (cmd, args2) => execFileSync6(cmd, args2, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 });
@@ -5879,8 +6059,8 @@ function installService(o) {
   };
   const write = (file) => {
     if (o.dryRun) return;
-    mkdirSync7(path20.dirname(file.path), { recursive: true });
-    writeFileSync7(file.path, file.text);
+    mkdirSync5(path20.dirname(file.path), { recursive: true });
+    writeFileSync4(file.path, file.text);
   };
   if (platform === "darwin") {
     write(f.plist);
@@ -5931,7 +6111,7 @@ function uninstallService(o) {
   };
   const remove = (file) => {
     files.push(file);
-    if (!o.dryRun) unlinkSync4(file);
+    if (!o.dryRun) unlinkSync3(file);
   };
   if (platform === "darwin" && existsSync10(f.plist.path)) {
     run("launchctl", ["bootout", `gui/${uid}/${o.label}`]);
@@ -5953,17 +6133,17 @@ import {
   closeSync as closeSync4,
   existsSync as existsSync11,
   fsyncSync,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync6,
   openSync as openSync4,
   readFileSync as readFileSync12,
   renameSync as renameSync2,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync5
 } from "node:fs";
 import path21 from "node:path";
 
 // src/secrets.ts
 import { spawnSync } from "node:child_process";
-import { createHash as createHash6, randomBytes as randomBytes3 } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes4 } from "node:crypto";
 var SERVICE2 = "sessionpipe";
 var defaultRunner = (cmd, args2, input) => {
   const r = spawnSync(cmd, args2, {
@@ -6006,8 +6186,8 @@ function secretDel(store, account, run = defaultRunner) {
   else run("secret-tool", ["clear", "service", SERVICE2, "account", account]);
 }
 function probe2(store, run = defaultRunner) {
-  const account = `probe:${randomBytes3(6).toString("hex")}`;
-  const ok = secretSet(store, account, randomBytes3(12).toString("base64url"), run);
+  const account = `probe:${randomBytes4(6).toString("hex")}`;
+  const ok = secretSet(store, account, randomBytes4(12).toString("base64url"), run);
   secretDel(store, account, run);
   return ok;
 }
@@ -6018,13 +6198,18 @@ function bestStore(env = process.env, platform = process.platform, run = default
   for (const s of candidates) if (probe2(s, run)) return s;
   return "file";
 }
-var storeLabel = (s) => s === "keychain" ? "the macOS Keychain" : s === "secret-service" ? "the Secret Service keyring" : "a 0600 file";
+var storeLabel = (s, platform = process.platform) => s === "keychain" ? "the macOS Keychain" : s === "secret-service" ? "the Secret Service keyring" : platform === "win32" ? "a file under your profile" : "a 0600 file";
+var fileKept = (platform = process.platform) => platform === "win32" ? "your profile's permissions" : "0600";
+function keysFileNote(platform = process.platform, env = process.env) {
+  if (platform === "win32") return "under your profile's permissions (Windows has no keychain sessionpipe uses)";
+  return `at 0600 \u2014 no unlocked keychain in this session${env.SSH_CONNECTION ? " (an ssh shell)" : ""}`;
+}
 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 } : {} };
 }
 function moveSinkSecrets(to, o = {}) {
   const run = o.run ?? defaultRunner;
@@ -6081,9 +6266,9 @@ var askOn = (c) => c.ask !== false;
 var controlFile = (env = process.env) => path21.join(path21.dirname(configFile(env)), "control.json");
 var controlState = (env = process.env) => path21.join(stateDir(env), "control");
 function writePrivate(file, value) {
-  mkdirSync8(path21.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync6(path21.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync8(tmp, `${JSON.stringify(value, null, 2)}
+  writeFileSync5(tmp, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
   renameSync2(tmp, file);
   try {
@@ -6182,7 +6367,7 @@ var NonceStore = class {
     const t = this.seenAt.get(nonce);
     if (t !== void 0 && t > this.now() - NONCE_TTL_MS) return true;
     const at = this.now();
-    mkdirSync8(path21.dirname(this.file), { recursive: true, mode: 448 });
+    mkdirSync6(path21.dirname(this.file), { recursive: true, mode: 448 });
     const fd = openSync4(this.file, "a", 384);
     try {
       appendFileSync3(fd, `${JSON.stringify({ n: nonce, t: at })}
@@ -6200,8 +6385,8 @@ var NonceStore = class {
     for (const [n, t] of this.seenAt) if (t <= cut2) this.seenAt.delete(n);
     if (!existsSync11(this.file) && !this.seenAt.size) return;
     const body = [...this.seenAt].map(([n, t]) => JSON.stringify({ n, t })).join("\n");
-    mkdirSync8(path21.dirname(this.file), { recursive: true, mode: 448 });
-    writeFileSync8(`${this.file}.tmp`, body ? `${body}
+    mkdirSync6(path21.dirname(this.file), { recursive: true, mode: 448 });
+    writeFileSync5(`${this.file}.tmp`, body ? `${body}
 ` : "", { mode: 384 });
     renameSync2(`${this.file}.tmp`, this.file);
   }
@@ -6230,13 +6415,13 @@ var AckOutbox = class {
     }
   }
   add(a) {
-    mkdirSync8(path21.dirname(this.file), { recursive: true, mode: 448 });
+    mkdirSync6(path21.dirname(this.file), { recursive: true, mode: 448 });
     appendFileSync3(this.file, `${JSON.stringify(a)}
 `, { mode: 384 });
   }
   keep(left) {
-    mkdirSync8(path21.dirname(this.file), { recursive: true, mode: 448 });
-    writeFileSync8(`${this.file}.tmp`, left.map((a) => JSON.stringify(a)).join("\n") + (left.length ? "\n" : ""), {
+    mkdirSync6(path21.dirname(this.file), { recursive: true, mode: 448 });
+    writeFileSync5(`${this.file}.tmp`, left.map((a) => JSON.stringify(a)).join("\n") + (left.length ? "\n" : ""), {
       mode: 384
     });
     renameSync2(`${this.file}.tmp`, this.file);
@@ -6290,7 +6475,7 @@ var writeState = (file, s) => writePrivate(file, {
 });
 
 // src/control/pair.ts
-var VERSION = true ? "0.13.0" : "0.0.0";
+var VERSION = true ? "0.13.1" : "0.0.0";
 var RENEW_FOR_MS = 60 * 6e4;
 async function json(r) {
   try {
@@ -6339,7 +6524,7 @@ async function pair(o) {
     throw new Error(
       `${o.url} needs a key to pair: add it as a sink first (\`sessionpipe sink add ${o.url} --token \u2026\`) or pass --token.`
     );
-  const pollKey = o.token ? null : randomBytes4(32).toString("base64url");
+  const pollKey = o.token ? null : randomBytes5(32).toString("base64url");
   const cfg = readControl(o.env) ?? { name: o.name, folders: [], mode: o.mode, receivers: [] };
   cfg.name = o.name || cfg.name;
   cfg.mode = o.mode;
@@ -6502,7 +6687,7 @@ var spec = (o) => ({
 });
 function installService2(o) {
   const logDir = controlState(o.env);
-  mkdirSync9(logDir, { recursive: true, mode: 448 });
+  mkdirSync7(logDir, { recursive: true, mode: 448 });
   const log2 = path22.join(logDir, "daemon.log");
   try {
     closeSync5(openSync5(log2, "a", 384));
@@ -6548,12 +6733,12 @@ ${RE_ARM}`;
 
 // src/runtime.ts
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { readFileSync as readFileSync16, realpathSync as realpathSync3 } from "node:fs";
+import { readFileSync as readFileSync17, realpathSync as realpathSync3 } from "node:fs";
 import os11 from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 
 // src/launcher.ts
-import { accessSync as accessSync2, chmodSync as chmodSync4, constants as constants2, mkdirSync as mkdirSync10, readFileSync as readFileSync13, renameSync as renameSync3, rmSync, writeFileSync as writeFileSync9 } from "node:fs";
+import { accessSync as accessSync2, chmodSync as chmodSync4, constants as constants2, mkdirSync as mkdirSync8, readFileSync as readFileSync13, renameSync as renameSync3, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
 import os9 from "node:os";
 import path23 from "node:path";
 var LAUNCHER = "sessionpipe-hook";
@@ -6585,14 +6770,14 @@ function writeIfChanged(file, body, mode) {
   } catch {
   }
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync9(tmp, body, { mode });
+  writeFileSync6(tmp, body, { mode });
   renameSync3(tmp, file);
   chmodSync4(file, mode);
   return true;
 }
 function installLauncher(o) {
   const dir = dataDir(o.env);
-  mkdirSync10(dir, { recursive: true, mode: 493 });
+  mkdirSync8(dir, { recursive: true, mode: 493 });
   let changed = false;
   for (const f of COPIED)
     changed = writeIfChanged(path23.join(dir, f), readFileSync13(path23.join(o.distDir, f)), 420) || changed;
@@ -6650,19 +6835,19 @@ function launcherState(version, env = process.env) {
 import {
   appendFileSync as appendFileSync4,
   existsSync as existsSync12,
-  mkdirSync as mkdirSync12,
+  mkdirSync as mkdirSync11,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync15,
-  renameSync as renameSync5,
+  readFileSync as readFileSync16,
+  renameSync as renameSync6,
   statSync as statSync7,
-  unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync11
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync9
 } from "node:fs";
 import os10 from "node:os";
-import path25 from "node:path";
+import path26 from "node:path";
 
 // src/control/aliases.ts
-import { chmodSync as chmodSync5, mkdirSync as mkdirSync11, readFileSync as readFileSync14, renameSync as renameSync4, writeFileSync as writeFileSync10 } from "node:fs";
+import { chmodSync as chmodSync5, mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync4, writeFileSync as writeFileSync7 } from "node:fs";
 import path24 from "node:path";
 var aliasFile = (controlDir) => path24.join(controlDir, "aliases.json");
 function readAliases(file) {
@@ -6681,9 +6866,9 @@ function readAliases(file) {
   }
 }
 function writeAliases(file, all) {
-  mkdirSync11(path24.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync9(path24.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync10(tmp, `${JSON.stringify(all, null, 2)}
+  writeFileSync7(tmp, `${JSON.stringify(all, null, 2)}
 `, { mode: 384 });
   renameSync4(tmp, file);
   try {
@@ -6697,6 +6882,76 @@ function receiverIdOf(all, harness, id) {
   return null;
 }
 
+// src/fold.ts
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync15, renameSync as renameSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import path25 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, sink2) {
+    this.root = root;
+    this.sink = sink2;
+  }
+  root;
+  sink;
+  file() {
+    return path25.join(this.root, "folds", `${safeId(this.sink)}.json`);
+  }
+  read() {
+    try {
+      const j = JSON.parse(readFileSync15(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 kept2 = {};
+    for (const [k, v] of Object.entries(c)) if (Number.isFinite(v) && v >= newest - KEEP_MS) kept2[k] = v;
+    const f = this.file();
+    mkdirSync10(path25.dirname(f), { recursive: true, mode: 448 });
+    const tmp = `${f}.${process.pid}.tmp`;
+    writeFileSync8(tmp, JSON.stringify(kept2), { mode: 384 });
+    renameSync5(tmp, f);
+  }
+};
+
 // src/http-sink.ts
 import { createHash as createHash7, createHmac } from "node:crypto";
 var TIMEOUT_MS = 15e3;
@@ -6814,27 +7069,27 @@ async function tellDaemon(state2, job, session, cwd, transcript) {
     300
   );
 }
-var VERSION2 = true ? "0.13.0" : "0.0.0";
+var VERSION2 = true ? "0.13.1" : "0.0.0";
 function enqueueJob(state2, job) {
   const jobs = jobsDir(state2);
-  mkdirSync12(jobs, { recursive: true, mode: 448 });
-  const f = path25.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
-  writeFileSync11(f, JSON.stringify(job), { mode: 384 });
+  mkdirSync11(jobs, { recursive: true, mode: 448 });
+  const f = path26.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
+  writeFileSync9(f, JSON.stringify(job), { mode: 384 });
   return f;
 }
 function releaseJob(claimed) {
   if (!claimed) return;
   try {
-    unlinkSync5(claimed);
+    unlinkSync4(claimed);
   } catch {
   }
 }
 function log(state2, line2) {
   try {
-    mkdirSync12(state2, { recursive: true, mode: 448 });
-    const f = path25.join(state2, "log");
+    mkdirSync11(state2, { recursive: true, mode: 448 });
+    const f = path26.join(state2, "log");
     try {
-      if (statSync7(f).size > 1024 * 1024) renameSync5(f, `${f}.1`);
+      if (statSync7(f).size > 1024 * 1024) renameSync6(f, `${f}.1`);
     } catch {
     }
     appendFileSync4(f, `${(/* @__PURE__ */ new Date()).toISOString()} ${line2}
@@ -6843,11 +7098,11 @@ function log(state2, line2) {
   }
 }
 function factsState(state2) {
-  const file = (h, s) => path25.join(state2, "facts", safeId(h), `${safeId(s)}.json`);
+  const file = (h, s) => path26.join(state2, "facts", safeId(h), `${safeId(s)}.json`);
   return {
     get(h, s) {
       try {
-        return JSON.parse(readFileSync15(file(h, s), "utf8"));
+        return JSON.parse(readFileSync16(file(h, s), "utf8"));
       } catch {
         return {};
       }
@@ -6856,8 +7111,8 @@ function factsState(state2) {
       const cur = this.get(h, s);
       const next = { ...cur, ...patch };
       if (JSON.stringify(next) === JSON.stringify(cur)) return;
-      mkdirSync12(path25.dirname(file(h, s)), { recursive: true, mode: 448 });
-      writeFileSync11(file(h, s), JSON.stringify(next), { mode: 384 });
+      mkdirSync11(path26.dirname(file(h, s)), { recursive: true, mode: 448 });
+      writeFileSync9(file(h, s), JSON.stringify(next), { mode: 384 });
     }
   };
 }
@@ -6870,7 +7125,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") out2.push(new StdoutSink(s.name, tier, !!s.pii));
     else if (s.url.startsWith("file:"))
       out2.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os10.homedir()), tier, !!s.pii));
@@ -6932,7 +7187,7 @@ async function runJob(job, opts = {}) {
     );
     return { events: [], delivered: {} };
   }
-  const id = receiverIdOf(readAliases(aliasFile(path25.join(state2, "control"))), job.harness, r.session.id) ?? r.session.id;
+  const id = receiverIdOf(readAliases(aliasFile(path26.join(state2, "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(state2, job, id, r.session.cwd, r.transcript);
   const outbox = new Outbox(state2);
@@ -6969,7 +7224,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 && path25.isAbsolute(r.session.cwd))
+      if (CWD_FROM_HOOKS.has(job.harness) && r.session.cwd && path26.isAbsolute(r.session.cwd))
         facts.save(job.harness, id, { cwd: r.session.cwd });
     }
     const known = mem.session ?? {};
@@ -7087,8 +7342,12 @@ async function runJob(job, opts = {}) {
   } finally {
     release();
   }
-  const delivered = await drain(state2, cfg.sinks, outbox, ref) ?? {};
   if (Math.random() < 0.02) outbox.prune(cfg.keep_days ?? 30);
+  const delivered = opts.drain === false ? {} : await drain(state2, 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 appendObserved(state2, harness, id, data, opts = {}) {
@@ -7127,25 +7386,75 @@ async function appendObserved(state2, harness, id, data, opts = {}) {
   await drain(state2, cfg.sinks, outbox, ref);
   return e;
 }
-async function drain(state2, sinkConfigs, outbox, first) {
-  const more = path25.join(state2, "locks", "flush.more");
+var REAL_CLOCK = { now: () => Date.now(), sleep: (ms2) => new Promise((r) => setTimeout(r, ms2)) };
+var PACE_MS = 1e3;
+var sentFile = (state2) => path26.join(state2, "locks", "flush.sent");
+function lastSent(state2) {
+  try {
+    return Number(readFileSync16(sentFile(state2), "utf8"));
+  } catch {
+    return 0;
+  }
+}
+function noteSent(state2, at) {
+  try {
+    mkdirSync11(path26.dirname(sentFile(state2)), { recursive: true, mode: 448 });
+    writeFileSync9(sentFile(state2), String(at), { mode: 384 });
+  } catch {
+  }
+}
+function waitingForReceiver(state2, sinkConfigs, outbox, now) {
+  const receivers = sinkConfigs.filter(
+    (s) => !s.paused && /^https?:\/\//.test(s.url) && !((readBackoff(state2, s.name)?.until ?? 0) > now)
+  );
+  if (!receivers.length) return false;
+  const refs = outbox.sessions();
+  for (const s of receivers) {
+    const cursors = new Cursors(state2, 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 = (state2) => path26.join(state2, "locks", "flush.more");
+function markMore(state2) {
+  try {
+    mkdirSync11(path26.dirname(moreFile(state2)), { recursive: true, mode: 448 });
+    writeFileSync9(moreFile(state2), "", { mode: 384 });
+  } catch {
+  }
+}
+async function drain(state2, sinkConfigs, outbox, first, o = {}) {
+  const clock = o.clock ?? REAL_CLOCK;
+  const more = moreFile(state2);
   let release = takeNamedLock(state2, "flush");
   if (!release) {
-    try {
-      writeFileSync11(more, "", { mode: 384 });
-    } catch {
-    }
+    markMore(state2);
     release = takeNamedLock(state2, "flush");
     if (!release) return null;
   }
   const delivered = {};
   for (; ; ) {
-    try {
-      unlinkSync5(more);
-    } catch {
+    if (o.deadline !== void 0 && clock.now() + PASS_BUDGET_MS > o.deadline) {
+      markMore(state2);
+      release();
+      o.handoff?.();
+      return delivered;
     }
     try {
-      for (const [k, v] of Object.entries(await flush(state2, sinkConfigs, outbox, first)))
+      const wait = Math.min(PACE_MS, lastSent(state2) + PACE_MS - clock.now());
+      if (wait > 0 && waitingForReceiver(state2, sinkConfigs, outbox, clock.now())) await clock.sleep(wait);
+      try {
+        unlinkSync4(more);
+      } catch {
+      }
+      for (const [k, v] of Object.entries(await flush(state2, sinkConfigs, outbox, first, { clock })))
         delivered[k] = (delivered[k] ?? 0) + v;
     } finally {
       release();
@@ -7156,10 +7465,10 @@ async function drain(state2, sinkConfigs, outbox, first) {
   }
 }
 var BACKOFF_MS = [2e3, 1e4, 6e4, 5 * 6e4, 30 * 6e4];
-var backoffFile = (state2, sink2) => path25.join(state2, "backoff", `${safeId(sink2)}.json`);
+var backoffFile = (state2, sink2) => path26.join(state2, "backoff", `${safeId(sink2)}.json`);
 function readBackoff(state2, sink2) {
   try {
-    const b = JSON.parse(readFileSync15(backoffFile(state2, sink2), "utf8"));
+    const b = JSON.parse(readFileSync16(backoffFile(state2, sink2), "utf8"));
     return typeof b.until === "number" ? b : null;
   } catch {
     return null;
@@ -7172,15 +7481,15 @@ function noteFailure(state2, sink2, res, prev) {
   const b = { until: Date.now() + wait, failures, why: `${res.status ?? ""} ${res.error ?? ""}`.trim() };
   const f = backoffFile(state2, sink2);
   try {
-    mkdirSync12(path25.dirname(f), { recursive: true, mode: 448 });
-    writeFileSync11(f, JSON.stringify(b), { mode: 384 });
+    mkdirSync11(path26.dirname(f), { recursive: true, mode: 448 });
+    writeFileSync9(f, JSON.stringify(b), { mode: 384 });
   } catch {
   }
   return b;
 }
 function clearBackoff(state2, sink2) {
   try {
-    unlinkSync5(backoffFile(state2, sink2));
+    unlinkSync4(backoffFile(state2, sink2));
   } catch {
   }
 }
@@ -7191,14 +7500,31 @@ var BATCH = 50;
 var MAX_PER_RUN = 500;
 async function flush(state2, sinkConfigs, outbox, first, o = {}) {
   const delivered = {};
+  const clock = o.clock ?? REAL_CLOCK;
   const sinks = buildSinks(sinkConfigs, {
     locked: (name) => log(state2, `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(state2, `drain: can't read ${f} (${code}); skipped, its cursors stay`);
+      }
+      return null;
+    }
+  };
   const drainSink = async (sink2) => {
     let backoff = readBackoff(state2, sink2.name);
     if (backoff && !o.force && backoff.until > Date.now()) {
@@ -7207,11 +7533,16 @@ async function flush(state2, sinkConfigs, outbox, first, o = {}) {
     }
     const cursors = new Cursors(state2, sink2.name);
     const c = cursors.read();
+    const mode = modes.get(sink2.name);
+    const tools = new ToolClock(state2, sink2.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 (sink2 instanceof HttpSink) noteSent(state2, clock.now());
       const res = await sink2.send(events);
       if (res.ok || res.action !== "split") return res;
       if (events.length === 1) {
@@ -7219,10 +7550,20 @@ async function flush(state2, sinkConfigs, outbox, first, o = {}) {
         log(state2, `sink ${sink2.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(
+          state2,
+          `sink ${sink2.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,
@@ -7232,11 +7573,17 @@ async function flush(state2, 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);
@@ -7252,6 +7599,7 @@ async function flush(state2, sinkConfigs, outbox, first, o = {}) {
         if (res.action !== "drop") {
           batch = [];
           pending = {};
+          clockNext = { ...clockNow };
           return false;
         }
       } else if (backoff) {
@@ -7261,6 +7609,7 @@ async function flush(state2, sinkConfigs, outbox, first, o = {}) {
       sent += batch.length;
       Object.assign(c, pending);
       cursors.write(c);
+      commitClock();
       batch = [];
       pending = {};
       return true;
@@ -7270,11 +7619,15 @@ async function flush(state2, 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, sink2.tier, sink2.pii, { home: os10.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[sink2.name] = (o.thinned[sink2.name] ?? 0) + 1;
         }
         offset = next;
         pending[cursors.key(ref)] = offset;
@@ -7306,12 +7659,12 @@ function applySinkVerdict(name, res) {
   } catch {
   }
 }
-var jobsDir = (state2) => path25.join(state2, "jobs");
+var jobsDir = (state2) => path26.join(state2, "jobs");
 
 // src/update.ts
 import { spawn as spawn4 } from "node:child_process";
 import { accessSync as accessSync3, constants as constants3, existsSync as existsSync13, realpathSync as realpathSync2 } from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 
 // ../core/src/version.ts
 import { spawn as spawn3 } from "node:child_process";
@@ -7399,11 +7752,11 @@ function globalPrefix(distDir2, platform = process.platform) {
   if (viaNpx(distDir2)) return null;
   const prefix = prefixOf(distDir2, platform);
   if (!prefix) return null;
-  const bin = platform === "win32" ? path26.join(prefix, "sessionpipe.cmd") : path26.join(prefix, "bin", "sessionpipe");
+  const bin = platform === "win32" ? path27.join(prefix, "sessionpipe.cmd") : path27.join(prefix, "bin", "sessionpipe");
   return existsSync13(bin) ? prefix : null;
 }
 function unwritable(prefix, platform = process.platform) {
-  const dir = platform === "win32" ? path26.join(prefix, "node_modules") : path26.join(prefix, "lib", "node_modules");
+  const dir = platform === "win32" ? path27.join(prefix, "node_modules") : path27.join(prefix, "lib", "node_modules");
   try {
     accessSync3(dir, constants3.W_OK);
     return null;
@@ -7412,8 +7765,8 @@ function unwritable(prefix, platform = process.platform) {
   }
 }
 function npmArgv(node, platform = process.platform) {
-  const dir = path26.dirname(node);
-  const candidates = platform === "win32" ? [path26.join(dir, "node_modules", "npm", "bin", "npm-cli.js")] : [path26.join(dir, "npm"), path26.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")];
+  const dir = path27.dirname(node);
+  const candidates = platform === "win32" ? [path27.join(dir, "node_modules", "npm", "bin", "npm-cli.js")] : [path27.join(dir, "npm"), path27.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")];
   for (const c of candidates) {
     try {
       const real = realpathSync2(c);
@@ -7458,7 +7811,7 @@ var execCapture = (argv, o) => new Promise((resolve) => {
 });
 var lastLine = (r) => (r.error || r.stderr.trim().split("\n").filter(Boolean).slice(-2).join(" ") || `exit ${r.code}`).slice(0, 300);
 async function installedVersion(o) {
-  const r = await (o.exec ?? execCapture)([o.node, path26.join(o.distDir, "cli.js"), "--version"], {
+  const r = await (o.exec ?? execCapture)([o.node, path27.join(o.distDir, "cli.js"), "--version"], {
     env: o.env ?? process.env,
     timeoutMs: 3e4
   });
@@ -7470,7 +7823,7 @@ async function installVersion(version, o) {
   const platform = o.platform ?? process.platform;
   const exec = o.exec ?? execCapture;
   const base = o.env ?? process.env;
-  const env = { ...base, PATH: [path26.dirname(o.node), base.PATH].filter(Boolean).join(path26.delimiter) };
+  const env = { ...base, PATH: [path27.dirname(o.node), base.PATH].filter(Boolean).join(path27.delimiter) };
   const prefix = globalPrefix(o.distDir, platform);
   if (!prefix)
     return { ok: false, ms: Date.now() - t0, stage: "prefix", error: "this copy isn't a global npm install" };
@@ -7501,7 +7854,7 @@ async function installVersion(version, o) {
   let hooks = "no harness set up here; nothing to re-arm";
   if (o.harnesses.length) {
     const h = await exec(
-      [o.node, path26.join(o.distDir, "cli.js"), "install", "--backfill", "0", ...o.harnesses.map((n) => `--${n}`)],
+      [o.node, path27.join(o.distDir, "cli.js"), "install", "--backfill", "0", ...o.harnesses.map((n) => `--${n}`)],
       { env, timeoutMs: 2 * 6e4 }
     );
     hooks = h.code === 0 ? `hooks re-armed for ${o.harnesses.join(", ")}` : `re-arming the hooks failed (${lastLine(h)}); \`sessionpipe install\` does it`;
@@ -7542,7 +7895,7 @@ function installLocation() {
   }
   return {
     prefix,
-    target: /\/Cellar\/node(?:@\d+)?\/[^/]+/.test(prefix) ? path27.join(os11.homedir(), ".local") : prefix
+    target: /\/Cellar\/node(?:@\d+)?\/[^/]+/.test(prefix) ? path28.join(os11.homedir(), ".local") : prefix
   };
 }
 function assertSetupVersion(allowDowngrade, target2) {
@@ -7557,7 +7910,7 @@ function assertSetupVersion(allowDowngrade, target2) {
   check(hooks.version, hooks.file);
   const prefix = target2 ?? installLocation().target;
   if (!prefix) return;
-  const pkg = path27.join(
+  const pkg = path28.join(
     prefix,
     ...process.platform === "win32" ? [] : ["lib"],
     "node_modules",
@@ -7566,7 +7919,7 @@ function assertSetupVersion(allowDowngrade, target2) {
   );
   let installed;
   try {
-    installed = JSON.parse(readFileSync16(pkg, "utf8")).version;
+    installed = JSON.parse(readFileSync17(pkg, "utf8")).version;
   } catch {
   }
   if (typeof installed === "string") check(installed, pkg);
@@ -7580,9 +7933,9 @@ function rerunGlobally(argv, out2, setup2) {
     execFileSync7("npm", ["install", "-g", `sessionpipe@${VERSION2}`, ...target2 ? ["--prefix", target2] : []], {
       stdio: ["ignore", "ignore", "inherit"]
     });
-    bin = process.platform === "win32" ? path27.join(target2, "sessionpipe.cmd") : target2 ? path27.join(target2, "bin", "sessionpipe") : "sessionpipe";
+    bin = process.platform === "win32" ? path28.join(target2, "sessionpipe.cmd") : target2 ? path28.join(target2, "bin", "sessionpipe") : "sessionpipe";
     if (target2 && target2 !== prefix)
-      out2(`  Installed into ${target2}; make sure ${path27.join(target2, "bin")} is on your PATH.`);
+      out2(`  Installed into ${target2}; make sure ${path28.join(target2, "bin")} is on your PATH.`);
   } catch {
     out2(
       "  ! couldn't install globally (`npm install -g sessionpipe` failed). Run it yourself, then retry this command."
@@ -7663,7 +8016,7 @@ async function askOnce(rest, flags, io, env, harnesses) {
     session = target2;
   } else if (!HARNESS.test(target2)) return usage(`${target2} isn't an agent's name (claude-code, codex, gemini-cli, \u2026)`);
   const given = flags["--text"];
-  const text = given === "-" ? (io.stdin ?? (() => readFileSync17(0, "utf8")))() : typeof given === "string" ? given : rest.slice(1).join(" ");
+  const text = given === "-" ? (io.stdin ?? (() => readFileSync18(0, "utf8")))() : typeof given === "string" ? given : rest.slice(1).join(" ");
   if (!text.trim()) return usage("nothing to ask: put the task in quotes after the agent, or pipe it with `--text -`");
   if (text.length > TEXT_MAX2)
     return usage(
@@ -7674,7 +8027,7 @@ async function askOnce(rest, flags, io, env, harnesses) {
     return usage("--permission is read or safe: an asked agent never runs wider than this machine's mode");
   const model = flags["--model"];
   if (model === "") return usage("--model needs a name");
-  const cwd = path28.resolve(typeof flags["--cwd"] === "string" ? flags["--cwd"] : process.cwd());
+  const cwd = path29.resolve(typeof flags["--cwd"] === "string" ? flags["--cwd"] : process.cwd());
   const from = waitSession(void 0, env) ?? void 0;
   const chain = (env.SESSIONPIPE_ASK_CHAIN ?? "").split(",").map((s) => s.trim()).filter(Boolean);
   const req = {
@@ -7799,9 +8152,9 @@ function on(argv, io, env, distDir2, harnesses, noService, yes) {
     );
   if (noService) io.out("  Daemon: not installed as a service (--no-service); run `sessionpipe control run` yourself");
   else {
-    let cli = path28.join(distDir2 ?? ".", "cli.js");
+    let cli = path29.join(distDir2 ?? ".", "cli.js");
     try {
-      cli = statSync8(cli).isFile() ? path28.resolve(cli) : cli;
+      cli = statSync8(cli).isFile() ? path29.resolve(cli) : cli;
     } catch {
     }
     io.out(`  Daemon: ${installService2({ node: stableNode(process.execPath), cli, env })}`);
@@ -7861,8 +8214,8 @@ ${ASK_CLOSE}`;
 function setupFiles(env = process.env) {
   const home = env.HOME || homeDir();
   return [
-    ...claudeDirs(env, home).map((d) => path28.join(d, "CLAUDE.md")),
-    path28.join(env.CODEX_HOME || path28.join(home, ".codex"), "AGENTS.md")
+    ...claudeDirs(env, home).map((d) => path29.join(d, "CLAUDE.md")),
+    path29.join(env.CODEX_HOME || path29.join(home, ".codex"), "AGENTS.md")
   ];
 }
 var sectionAt = (text) => {
@@ -7891,8 +8244,8 @@ function setupAsk(env, agents, remove) {
   const section = askSection(agents);
   const out2 = [];
   for (const file of setupFiles(env)) {
-    const had = existsSync14(file) ? readFileSync17(file, "utf8") : null;
-    if (had === null && (remove || !existsSync14(path28.dirname(file)))) {
+    const had = existsSync14(file) ? readFileSync18(file, "utf8") : null;
+    if (had === null && (remove || !existsSync14(path29.dirname(file)))) {
       out2.push({ file, did: remove ? "absent" : "skipped" });
       continue;
     }
@@ -7900,8 +8253,8 @@ function setupAsk(env, agents, remove) {
       const next2 = withoutAskSection(had);
       if (next2 === had) out2.push({ file, did: "absent" });
       else {
-        if (next2 === "") unlinkSync6(file);
-        else writeFileSync12(file, next2);
+        if (next2 === "") unlinkSync5(file);
+        else writeFileSync10(file, next2);
         out2.push({ file, did: "removed" });
       }
       continue;
@@ -7909,8 +8262,8 @@ function setupAsk(env, agents, remove) {
     const next = withAskSection(had, section);
     if (next === had) out2.push({ file, did: "unchanged" });
     else {
-      mkdirSync13(path28.dirname(file), { recursive: true });
-      writeFileSync12(file, next);
+      mkdirSync12(path29.dirname(file), { recursive: true });
+      writeFileSync10(file, next);
       out2.push({ file, did: had === null ? "added" : "updated" });
     }
   }
@@ -7934,15 +8287,15 @@ function setup(io, env, harnesses, remove) {
 }
 
 // src/control/autoupdate.ts
-import { readFileSync as readFileSync18 } from "node:fs";
-import path29 from "node:path";
+import { readFileSync as readFileSync19 } from "node:fs";
+import path30 from "node:path";
 var DAY_MS = 24 * 36e5;
 var LABEL4 = "org.sessionpipe.control";
 var UNIT2 = "sessionpipe-control.service";
-var updateFile = (env = process.env) => path29.join(controlState(env), "update.json");
+var updateFile = (env = process.env) => path30.join(controlState(env), "update.json");
 function readUpdate(file) {
   try {
-    const j = JSON.parse(readFileSync18(file, "utf8"));
+    const j = JSON.parse(readFileSync19(file, "utf8"));
     return j && typeof j === "object" ? j : {};
   } catch {
     return {};
@@ -7963,7 +8316,8 @@ function autoUpdateOff(o) {
 }
 function updateSummary(o) {
   const daemonEnv = o.rec.off?.startsWith("SESSIONPIPE_NO_UPDATE_CHECK") ? "SESSIONPIPE_NO_UPDATE_CHECK is set in the daemon's environment" : null;
-  const off3 = o.off ?? (o.paired ? daemonEnv : "it runs in the control daemon, which isn't set up here (`sessionpipe connect`)");
+  const byHand = (o.platform ?? process.platform) === "win32" ? "it runs in the control daemon, which has no service on Windows yet: it checks while `sessionpipe control run` is running" : null;
+  const off3 = o.off ?? (o.paired ? daemonEnv ?? byHand : "it runs in the control daemon, which isn't set up here (`sessionpipe connect`)");
   return {
     auto: !off3,
     off: off3,
@@ -8005,7 +8359,7 @@ function restartVia(o) {
   if (o.platform === "linux") {
     let cg = "";
     try {
-      cg = (o.cgroup ?? (() => readFileSync18("/proc/self/cgroup", "utf8")))();
+      cg = (o.cgroup ?? (() => readFileSync19("/proc/self/cgroup", "utf8")))();
     } catch {
     }
     const inUnit = cg.split("\n").some((l) => l.endsWith(`/${UNIT2}`) || l.includes(`/${UNIT2}/`));
@@ -8197,14 +8551,14 @@ var AutoUpdater = class {
 // src/control/cli.ts
 import { existsSync as existsSync20, realpathSync as realpathSync7, statSync as statSync13, unwatchFile, watchFile } from "node:fs";
 import os14 from "node:os";
-import path36 from "node:path";
+import path37 from "node:path";
 
 // src/pool/index.ts
-import { randomBytes as randomBytes5 } from "node:crypto";
+import { randomBytes as randomBytes6 } from "node:crypto";
 import { existsSync as existsSync17 } from "node:fs";
 import http2 from "node:http";
 import net2 from "node:net";
-import path32 from "node:path";
+import path33 from "node:path";
 
 // src/pool/credentials.ts
 var REFRESH_EARLY_MS = 5 * 6e4;
@@ -8346,14 +8700,14 @@ import {
   chmodSync as chmodSync6,
   existsSync as existsSync15,
   lstatSync,
-  mkdirSync as mkdirSync14,
-  readFileSync as readFileSync19,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync20,
   realpathSync as realpathSync4,
   statSync as statSync9,
-  unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync13
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import path30 from "node:path";
+import path31 from "node:path";
 var POOL_ENV_KEYS = [
   "ANTHROPIC_BASE_URL",
   "ANTHROPIC_AUTH_TOKEN",
@@ -8376,7 +8730,7 @@ var anySet = (env) => POOL_ENV_KEYS.some((k) => env[k] !== void 0);
 function readJsonFile2(file) {
   let raw;
   try {
-    raw = readFileSync19(file, "utf8");
+    raw = readFileSync20(file, "utf8");
   } catch {
     return { ok: true, existed: false, value: {}, shape: { indent: "  ", eol: "\n", finalNewline: true }, raw: "" };
   }
@@ -8402,7 +8756,7 @@ function formatJson2(value, f) {
   const text = JSON.stringify(value, null, f.indent).replace(/\n/g, f.eol);
   return f.finalNewline ? text + f.eol : text;
 }
-var settingsIn2 = (dir) => path30.join(dir, "settings.json");
+var settingsIn2 = (dir) => path31.join(dir, "settings.json");
 var envOf = (settings2) => settings2.env && typeof settings2.env === "object" && !Array.isArray(settings2.env) ? settings2.env : null;
 var target = (file) => {
   try {
@@ -8422,7 +8776,7 @@ var same = (a, b) => {
   };
   return a === b || real(a) === real(b);
 };
-var kept = (keep, file) => path30.join(keep, `${createHash8("sha256").update(file).digest("hex").slice(0, 16)}.json`);
+var kept = (keep, file) => path31.join(keep, `${createHash8("sha256").update(file).digest("hex").slice(0, 16)}.json`);
 var looseDir = (dir) => {
   try {
     return process.platform !== "win32" && (statSync9(dir).mode & 18) !== 0;
@@ -8460,11 +8814,11 @@ function installPoolEnv(dirs, o) {
     if (!changed) return { file, changed: false, ...note };
     settings2.env = env;
     if (o.keep && f.existed && !existsSync15(kept(o.keep, file))) {
-      mkdirSync14(o.keep, { recursive: true, mode: 448 });
-      writeFileSync13(kept(o.keep, file), f.raw, { mode: 384 });
+      mkdirSync13(o.keep, { recursive: true, mode: 448 });
+      writeFileSync11(kept(o.keep, file), f.raw, { mode: 384 });
     }
-    mkdirSync14(path30.dirname(file), { recursive: true, mode: 448 });
-    writeFileSync13(file, formatJson2(settings2, f.shape));
+    mkdirSync13(path31.dirname(file), { recursive: true, mode: 448 });
+    writeFileSync11(file, formatJson2(settings2, f.shape));
     try {
       chmodSync6(file, 384);
     } catch {
@@ -8485,20 +8839,20 @@ function uninstallPoolEnv(dirs, o) {
     for (const k of POOL_ENV_KEYS) delete env[k];
     if (!Object.keys(env).length) delete settings2.env;
     if (o.created?.some((c) => same(c, file)) && !Object.keys(settings2).length) {
-      unlinkSync7(file);
+      unlinkSync6(file);
       return { file, changed: true, note: "removed (sessionpipe created it)" };
     }
     const original = o.keep ? kept(o.keep, file) : null;
     let text = formatJson2(settings2, f.shape);
     if (original && existsSync15(original)) {
-      const raw = readFileSync19(original, "utf8");
+      const raw = readFileSync20(original, "utf8");
       try {
         if (JSON.stringify(JSON.parse(raw)) === JSON.stringify(settings2)) text = raw;
       } catch {
       }
-      unlinkSync7(original);
+      unlinkSync6(original);
     }
-    writeFileSync13(file, text);
+    writeFileSync11(file, text);
     return { file, changed: true };
   });
 }
@@ -9003,16 +9357,16 @@ function startPoolServer(deps) {
 }
 
 // src/pool/store.ts
-import { existsSync as existsSync16, readFileSync as readFileSync20 } from "node:fs";
-import path31 from "node:path";
-var poolFile = (env = process.env) => path31.join(path31.dirname(configFile(env)), "pool.json");
-var poolSecretsFile = (env = process.env) => path31.join(path31.dirname(configFile(env)), "pool.secrets.json");
-var poolStateFile = (env = process.env) => path31.join(stateDir(env), "pool", "state.json");
+import { existsSync as existsSync16, readFileSync as readFileSync21 } from "node:fs";
+import path32 from "node:path";
+var poolFile = (env = process.env) => path32.join(path32.dirname(configFile(env)), "pool.json");
+var poolSecretsFile = (env = process.env) => path32.join(path32.dirname(configFile(env)), "pool.secrets.json");
+var poolStateFile = (env = process.env) => path32.join(stateDir(env), "pool", "state.json");
 var EMPTY = { on: false, port: 0, accounts: [] };
 var UUID_RE5 = /^[0-9a-f-]{8,64}$/i;
 function readJson2(file) {
   try {
-    const j = JSON.parse(readFileSync20(file, "utf8"));
+    const j = JSON.parse(readFileSync21(file, "utf8"));
     return j && typeof j === "object" && !Array.isArray(j) ? j : null;
   } catch {
     return null;
@@ -9270,7 +9624,7 @@ function openPool(deps) {
   const mint = () => {
     placeSecrets();
     const before = secrets2.get(cfg, TOKEN_NAME);
-    const t = randomBytes5(32).toString("base64url");
+    const t = randomBytes6(32).toString("base64url");
     if (!secrets2.set(cfg, TOKEN_NAME, t)) throw new PoolError("pool", "the secrets store refused the pool's token");
     if (before && secrets2.set(cfg, PREVIOUS_TOKEN_NAME, before)) cfg.rotated_at = new Date(now()).toISOString();
     saveConfig();
@@ -9298,7 +9652,7 @@ function openPool(deps) {
     token: token ?? "",
     lastPort: cfg.last_port,
     lastToken,
-    keep: path32.join(stateDir(env), "pool", "settings")
+    keep: path33.join(stateDir(env), "pool", "settings")
   });
   const resync = () => {
     const by = new Map(policy.accounts.map((a) => [a.id, a]));
@@ -9838,15 +10192,15 @@ async function runChannel(session, input, write, o) {
 
 // src/control/daemon.ts
 import { randomUUID } from "node:crypto";
-import { chmodSync as chmodSync7, existsSync as existsSync19, mkdirSync as mkdirSync16, readFileSync as readFileSync22, realpathSync as realpathSync6, statSync as statSync12, unlinkSync as unlinkSync8 } from "node:fs";
+import { chmodSync as chmodSync7, existsSync as existsSync19, mkdirSync as mkdirSync15, readFileSync as readFileSync23, realpathSync as realpathSync6, statSync as statSync12, unlinkSync as unlinkSync7 } from "node:fs";
 import net4 from "node:net";
 import os13 from "node:os";
-import path35 from "node:path";
+import path36 from "node:path";
 
 // src/control/files.ts
 import { createHash as createHash10 } from "node:crypto";
-import { existsSync as existsSync18, lstatSync as lstatSync2, mkdirSync as mkdirSync15, realpathSync as realpathSync5, rmSync as rmSync2, writeFileSync as writeFileSync14 } from "node:fs";
-import path33 from "node:path";
+import { existsSync as existsSync18, lstatSync as lstatSync2, mkdirSync as mkdirSync14, realpathSync as realpathSync5, rmSync as rmSync2, writeFileSync as writeFileSync12 } from "node:fs";
+import path34 from "node:path";
 var FETCH_TIMEOUT_MS = 5 * 6e4;
 var FileProblem = class extends Error {
 };
@@ -9899,30 +10253,30 @@ async function fetchOne(f, o) {
 }
 var tooLong = (label, f) => new FileProblem(`${label} is larger than its signed size (${f.size} bytes)`);
 function realDir(p, why2) {
-  mkdirSync15(p, { recursive: true, mode: 448 });
+  mkdirSync14(p, { recursive: true, mode: 448 });
   if (lstatSync2(p).isSymbolicLink()) throw new FileProblem(`${why2} is a symlink`);
 }
 function writeFiles(cwd, session, files, message) {
-  const top = path33.join(cwd, ".sessionpipe");
-  const parent = path33.join(top, "files");
+  const top = path34.join(cwd, ".sessionpipe");
+  const parent = path34.join(top, "files");
   const sub = message ? `${session}/${message}` : session;
-  const dir = path33.join(parent, session, ...message ? [message] : []);
+  const dir = path34.join(parent, session, ...message ? [message] : []);
   let made = false;
   try {
     for (const part of [session, message])
       if (part === "." || part === "..") throw new FileProblem(`no folder ${part}`);
     realDir(top, ".sessionpipe");
-    const ignore = path33.join(top, ".gitignore");
-    if (!existsSync18(ignore)) writeFileSync14(ignore, "*\n", { flag: "wx", mode: 384 });
+    const ignore = path34.join(top, ".gitignore");
+    if (!existsSync18(ignore)) writeFileSync12(ignore, "*\n", { flag: "wx", mode: 384 });
     realDir(parent, ".sessionpipe/files");
-    if (message) realDir(path33.join(parent, session), `.sessionpipe/files/${session}`);
+    if (message) realDir(path34.join(parent, session), `.sessionpipe/files/${session}`);
     if (existsSync18(dir)) throw new FileProblem(`.sessionpipe/files/${sub} already exists`);
-    mkdirSync15(dir, { mode: 448 });
+    mkdirSync14(dir, { mode: 448 });
     made = true;
     if (realpathSync5.native(dir) !== dir) throw new FileProblem(".sessionpipe leads outside the session's folder");
     const rel = [];
     for (const f of files) {
-      writeFileSync14(path33.join(dir, f.name), f.bytes, { flag: "wx", mode: 384 });
+      writeFileSync12(path34.join(dir, f.name), f.bytes, { flag: "wx", mode: 384 });
       rel.push(`.sessionpipe/files/${sub}/${f.name}`);
     }
     return rel;
@@ -9947,9 +10301,9 @@ ${lines.join("\n")}`;
 
 // src/control/inbox.ts
 import { execFileSync as execFileSync8 } from "node:child_process";
-import { readFileSync as readFileSync21, statSync as statSync10 } from "node:fs";
+import { readFileSync as readFileSync22, statSync as statSync10 } from "node:fs";
 import net3 from "node:net";
-import path34 from "node:path";
+import path35 from "node:path";
 var PEER_PROTOCOL = 1;
 var CONFIRM_MS = 8e3;
 var IDLE_STATUS = "idle";
@@ -10006,9 +10360,9 @@ function vetInbox(rec, o) {
       code: "not_a_window",
       detail: "the live process holding that session isn't one of this computer's own Claude Code windows"
     };
-  if (!rec.socket || !path34.isAbsolute(rec.socket))
+  if (!rec.socket || !path35.isAbsolute(rec.socket))
     return { code: "no_inbox", detail: "that session's Claude Code published no local inbox" };
-  if (o.configDir && path34.resolve(o.configDir) !== path34.resolve(rec.configDir))
+  if (o.configDir && path35.resolve(o.configDir) !== path35.resolve(rec.configDir))
     return {
       code: "other_home",
       detail: "the live process is signed in to a different Claude Code account from the one holding that transcript"
@@ -10085,7 +10439,7 @@ var psStart = (pid) => execFileSync8("ps", ["-o", "lstart=", "-p", String(pid)],
 function peerToken(rec) {
   if (!rec.keyFile) return null;
   try {
-    const j = JSON.parse(readFileSync21(rec.keyFile, "utf8"));
+    const j = JSON.parse(readFileSync22(rec.keyFile, "utf8"));
     return typeof j.peerToken === "string" && TOKEN_RE.test(j.peerToken) ? j.peerToken : null;
   } catch {
     return null;
@@ -10480,7 +10834,7 @@ function startNamed(cmd) {
     return null;
   }
 }
-var VERSION3 = true ? "0.13.0" : "0.0.0";
+var VERSION3 = true ? "0.13.1" : "0.0.0";
 var MAX_REPLY = 2e4;
 var HELLO_EVERY_MS = 10 * 6e4;
 var TURN_FALLBACK_MS = 30 * 6e4;
@@ -10524,7 +10878,7 @@ function askProblem(req) {
   if (r.from !== void 0 && !parseSessionRef(r.from)) return "from is the asking session, <harness>:<id>";
   if (typeof r.text !== "string" || !r.text.trim() || r.text.length > TEXT_MAX)
     return `an ask needs text, at most ${TEXT_MAX} characters`;
-  if (typeof r.cwd !== "string" || !path35.isAbsolute(r.cwd) || r.cwd.length > 1024) return "cwd is an absolute folder";
+  if (typeof r.cwd !== "string" || !path36.isAbsolute(r.cwd) || r.cwd.length > 1024) return "cwd is an absolute folder";
   if (!Array.isArray(r.chain) || r.chain.length > ASK_CHAIN_MAX || r.chain.some((c) => !parseSessionRef(c)))
     return "chain is a list of sessions, <harness>:<id>, outermost first: the asks this one is nested in";
   if (r.permission !== void 0 && r.permission !== "read" && r.permission !== "safe")
@@ -10562,9 +10916,9 @@ var ControlDaemon = class {
     this.dir = dir;
     this.sock = sock;
     this.deps = deps;
-    this.nonces = new NonceStore(path35.join(dir, "nonces.jsonl"), deps.now);
-    this.acks = new AckOutbox(path35.join(dir, "acks.jsonl"));
-    this.state = readState(path35.join(dir, "state.json"), deps.now());
+    this.nonces = new NonceStore(path36.join(dir, "nonces.jsonl"), deps.now);
+    this.acks = new AckOutbox(path36.join(dir, "acks.jsonl"));
+    this.state = readState(path36.join(dir, "state.json"), deps.now());
     this.aliases = readAliases(aliasFile(dir));
   }
   cfg;
@@ -10645,7 +10999,7 @@ var ControlDaemon = class {
   // --- lifecycle ------------------------------------------------------------------
   async start() {
     this.running = true;
-    mkdirSync16(this.dir, { recursive: true, mode: 448 });
+    mkdirSync15(this.dir, { recursive: true, mode: 448 });
     await this.listen();
     await this.syncPool();
     for (const r of this.cfg.receivers) void this.pollLoop(r);
@@ -10688,7 +11042,7 @@ var ControlDaemon = class {
     this.server = null;
     if (process.platform !== "win32" && this.sockId && socketId(this.sock) === this.sockId)
       try {
-        unlinkSync8(this.sock);
+        unlinkSync7(this.sock);
       } catch {
       }
     this.sockId = null;
@@ -10838,7 +11192,7 @@ var ControlDaemon = class {
     if (other?.op === "status") throw new DaemonRunning(other.status ?? {});
     if (process.platform !== "win32") {
       try {
-        if (existsSync19(this.sock)) unlinkSync8(this.sock);
+        if (existsSync19(this.sock)) unlinkSync7(this.sock);
       } catch {
       }
     }
@@ -11479,9 +11833,9 @@ ${IN_PLACE_ANSWER}`,
   /** The folder the worker recorded for a session from its hooks (run.ts, facts). */
   factsCwd(harness, id) {
     try {
-      const f = path35.join(path35.dirname(this.dir), "facts", safeId(harness), `${safeId(id)}.json`);
-      const cwd = JSON.parse(readFileSync22(f, "utf8")).cwd;
-      return typeof cwd === "string" && path35.isAbsolute(cwd) ? cwd : void 0;
+      const f = path36.join(path36.dirname(this.dir), "facts", safeId(harness), `${safeId(id)}.json`);
+      const cwd = JSON.parse(readFileSync23(f, "utf8")).cwd;
+      return typeof cwd === "string" && path36.isAbsolute(cwd) ? cwd : void 0;
     } catch {
       return void 0;
     }
@@ -11668,7 +12022,7 @@ ${IN_PLACE_ANSWER}`,
    *  absolute, or under this user's home as `~/…` (a start's `cwd` may say either). */
   allowed(folder) {
     const dir = untilde(folder);
-    if (!path35.isAbsolute(dir)) return null;
+    if (!path36.isAbsolute(dir)) return null;
     let r;
     try {
       r = realpathSync6.native(dir);
@@ -11682,7 +12036,7 @@ ${IN_PLACE_ANSWER}`,
         rf = realpathSync6.native(f);
       } catch {
       }
-      if (r === rf || r.startsWith(rf.endsWith(path35.sep) ? rf : rf + path35.sep)) return r;
+      if (r === rf || r.startsWith(rf.endsWith(path36.sep) ? rf : rf + path36.sep)) return r;
     }
     return null;
   }
@@ -11813,7 +12167,7 @@ ${IN_PLACE_ANSWER}`,
    *  logged and nothing else: it costs a record, never a delivery. */
   saveState(what) {
     try {
-      writeState(path35.join(this.dir, "state.json"), this.state);
+      writeState(path36.join(this.dir, "state.json"), this.state);
     } catch (e) {
       this.deps.log(
         `couldn't record ${what}: ${String(
@@ -12565,7 +12919,7 @@ ${COPY_NOTE}` : "");
   recordStart(session, o) {
     this.state.started[session] = o;
     try {
-      writeState(path35.join(this.dir, "state.json"), this.state);
+      writeState(path36.join(this.dir, "state.json"), this.state);
     } catch (e) {
       this.deps.log(
         `couldn't record what ${session.slice(0, 8)} runs with: ${String(
@@ -13043,7 +13397,7 @@ ${COPY_NOTE}` : "");
     );
   }
   async record(on2, type, via, data) {
-    const state2 = path35.dirname(this.dir);
+    const state2 = path36.dirname(this.dir);
     const ref = { harness: on2.harness, session: on2.id };
     let release = takeLock(state2, ref);
     for (let i = 0; !release && i < 40; i++) {
@@ -13257,13 +13611,13 @@ function changeFolders(folders, op, dirs, home = os14.homedir()) {
     try {
       return realpathSync7.native(d);
     } catch {
-      return path36.resolve(d);
+      return path37.resolve(d);
     }
   };
   const next = [...folders];
   const said = [];
   for (const d of dirs) {
-    const abs = path36.resolve(d);
+    const abs = path37.resolve(d);
     const at = next.findIndex((f) => real(f) === real(abs));
     if (op === "remove") {
       if (at < 0) said.push(`  \xB7 ${abs} wasn't allowed`);
@@ -13300,6 +13654,7 @@ async function controlMain(argv, out2, distDir2) {
       const raw = argv[2];
       if (!raw || raw.startsWith("-")) return out2(`usage:
 ${CONTROL_HELP}`);
+      assertConfigWritable();
       if (viaNpx(distDir2)) return rerunGlobally(argv, out2);
       const url = (/^https?:\/\//.test(raw) ? raw : `https://${raw}`).replace(/\/$/, "");
       const cfg = readConfig();
@@ -13319,7 +13674,7 @@ ${CONTROL_HELP}`);
           );
       }
       const mode = parseMode(flag2("--mode")) ?? (existing?.mode && existing.receivers.length ? existing.mode : await askMode(out2));
-      const tier = argv.includes("--tier") ? Math.max(0, Math.min(3, Number(flag2("--tier")) || 0)) : 0;
+      const tier = tierArg(argv, 0);
       await pair({
         url,
         token,
@@ -13340,7 +13695,7 @@ ${CONTROL_HELP}`);
       const c = readControl();
       out2(`  Folders sessions may run in: ${c.folders.join(", ")}`);
       out2(`  Mode: ${c.mode} (${MODE_IS[c.mode]})`);
-      let cli = path36.join(distDir2, "cli.js");
+      let cli = path37.join(distDir2, "cli.js");
       try {
         cli = realpathSync7(cli);
       } catch {
@@ -13559,7 +13914,7 @@ async function runDaemon(out2, distDir2) {
       log2(`exiting ${UPDATE_EXIT} so ${via === "supervisor" ? "the supervising sessionpipe" : via} starts ${to}`);
       process.exit(UPDATE_EXIT);
     }
-    let cli = path36.join(distDir2, "cli.js");
+    let cli = path37.join(distDir2, "cli.js");
     try {
       cli = realpathSync7(cli);
     } catch {
@@ -13642,7 +13997,7 @@ function usageTable(harnesses) {
     connect: "connect <receiver> [--machine NAME] [--rename-machine] [--allow-downgrade] [--tier 0-3] [--mode safe|auto|inherit] [--folder DIR]\u2026 [--status-line|--no-status-line] [--no-service]",
     install: `install [${harnesses.map((h) => `--${h}`).join(" ")}] [--machine NAME] [--rename-machine] [--allow-downgrade] [--backfill DAYS] [--sink URL --tier N] [--status-line|--no-status-line]`,
     sink: "sink add|list|remove|test (use --help after a subcommand for its options)",
-    "sink add": "sink add <url|file:PATH|stdout> [--tier 0-3] [--token T] [--secret S] [--pii] [--name N]",
+    "sink add": "sink add <url|file:PATH|stdout> [--tier 0-3] [--token T] [--secret S] [--pii] [--tools all|main|beat] [--name N]",
     "sink list": "sink list",
     "sink remove": "sink remove <name>",
     "sink test": "sink test <name>",
@@ -13653,7 +14008,7 @@ function usageTable(harnesses) {
     tail: "tail [--session ID] [--tier 0-3] [--harness NAME] [--all] [--json]",
     backfill: `backfill [--days 30] [${harnesses.map((h) => `--${h}`).join(" ")}]`,
     forget: "forget <harness> <session>",
-    replay: "replay [--sink NAME] [--from-start]",
+    replay: "replay [--sink NAME] [--from-start] [--tools all|main|beat]",
     update: "update [off|on] (install the latest now; off/on: the daemon's daily update)",
     "update off": "update off",
     "update on": "update on",
@@ -13705,7 +14060,7 @@ function commandHelp(args2, harnesses) {
 
 // src/pool/cli.ts
 import { realpathSync as realpathSync8 } from "node:fs";
-import path37 from "node:path";
+import path38 from "node:path";
 var POOL_HELP = `  sessionpipe pool [--json]                        (the accounts in order, the room each has left)
   sessionpipe pool on | off                        (point every Claude Code here at the pool, or stop)
   sessionpipe pool add --import | --login [--code -]
@@ -13714,7 +14069,7 @@ var VENDOR_MS = 3e4;
 var LOCAL_MS = 5e3;
 var DAEMON_DOWN = "  ! the daemon isn't running, so Claude Code can't reach Claude while the pool is on: `sessionpipe control run` (or `sessionpipe pool on` again to install the service)";
 function cliPath(distDir2) {
-  const cli = path37.join(distDir2, "cli.js");
+  const cli = path38.join(distDir2, "cli.js");
   try {
     return realpathSync8(cli);
   } catch {
@@ -13913,6 +14268,32 @@ function readSecret(stdin = process.stdin, err = (s) => void process.stderr.writ
   });
 }
 
+// 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;
+}
+
 // src/cli.ts
 var print = (s = "") => {
   process.stdout.write(`${s}
@@ -13926,7 +14307,7 @@ var flag = (name) => {
   return i >= 0 ? args[i + 1] : void 0;
 };
 var has = (name) => args.includes(name);
-var distDir = path38.dirname(fileURLToPath(import.meta.url));
+var distDir = path39.dirname(fileURLToPath(import.meta.url));
 async function main(argv, io = { out: print, err: (s) => void process.stderr.write(s), exit: (c) => process.exit(c) }) {
   args = argv;
   out = io.out;
@@ -13952,7 +14333,7 @@ function hookCommand() {
     return (a) => ({ argv: [l, ...a], command: `${JSON.stringify(l)} ${a.join(" ")}` });
   }
   const node = stableNode(process.execPath);
-  let script = path38.join(distDir, "hook.js");
+  let script = path39.join(distDir, "hook.js");
   try {
     script = realpathSync9(script);
   } catch {
@@ -13962,6 +14343,15 @@ function hookCommand() {
     command: `${JSON.stringify(node)} ${JSON.stringify(script)} ${a.join(" ")}`
   });
 }
+function strayWord(valued = []) {
+  const word2 = args.slice(1).find((a, i) => !a.startsWith("-") && !valued.some((v) => v === args[i]));
+  if (word2 === void 0) return false;
+  const harness = ADAPTERS.some((a) => a.name === word2) ? `; to name that harness, pass --${word2}` : "";
+  out(`  ! \`sessionpipe ${args[0]}\` takes options only, and "${word2}" is not one${harness}.`);
+  out(`  Nothing was changed. See \`sessionpipe ${args[0]} --help\`.`);
+  process.exitCode = 2;
+  return true;
+}
 function selectedAdapters() {
   const named = ADAPTERS.filter((a) => has(`--${a.name}`));
   if (named.length) return named;
@@ -13975,6 +14365,7 @@ async function command(cmd) {
     );
     return usage ? out(usage) : help();
   }
+  if (["connect", "install", "sink", "control", "tail"].includes(cmd)) tierArg(args, 0);
   switch (cmd) {
     case "connect":
       return connect();
@@ -14037,12 +14428,12 @@ Usage:
                                   (everything, in one go: hooks, a sink, signed messages, keys)
   sessionpipe install [--claude-code --codex --gemini-cli --antigravity --devin] [--machine NAME] [--rename-machine] [--allow-downgrade] [--backfill DAYS] [--sink URL --tier N] [--status-line|--no-status-line]
   sessionpipe uninstall [--claude-code --codex --gemini-cli --antigravity --devin | --all] [--keep-state]
-  sessionpipe sink add <url|file:PATH|stdout> [--tier 0-3] [--token T] [--pii] [--name N]
+  sessionpipe sink add <url|file:PATH|stdout> [--tier 0-3] [--token T] [--pii] [--tools all|main|beat] [--name N]
   sessionpipe sink list | remove <name> | test <name>
   sessionpipe secrets [move keychain|secret-service|file]   (where the machine's keys live)
   sessionpipe status [--json] | doctor [--json]
   sessionpipe tail [--session ID] [--tier N] [--harness NAME]
-  sessionpipe backfill [--days 30] | forget <harness> <session> | replay --sink NAME
+  sessionpipe backfill [--days 30] | forget <harness> <session> | replay --sink NAME [--from-start] [--tools all|main|beat]
   sessionpipe update [off|on]       (install the latest now; off/on: the daemon's daily update)
   sessionpipe titles [on|off|refresh] (on: name Claude Code sessions as claude.ai does; off by default)
 ${CONTROL_HELP}
@@ -14052,6 +14443,7 @@ ${ASK_HELP}
 Docs: https://sessionpipe.org \xB7 nothing leaves this machine until you add a sink.`);
 }
 function setupConfig() {
+  assertConfigWritable();
   const cfg = readConfig();
   const requested = flag("--machine");
   if ((has("--machine") || has("--rename-machine")) && (!requested || requested.startsWith("-")))
@@ -14077,6 +14469,7 @@ function setupConfig() {
   return cfg;
 }
 async function install() {
+  if (strayWord(["--machine", "--backfill", "--sink", "--tier", "--name", "--token", "--secret"])) return;
   const cfg = setupConfig();
   if (viaNpx(distDir)) return rerunGlobally(args, out, { allowDowngrade: has("--allow-downgrade") });
   assertSetupVersion(has("--allow-downgrade"));
@@ -14095,11 +14488,17 @@ async function install() {
     out(
       "  No sink above tier 0: hooking one tool event per harness (the heartbeat's). `sink add \u2026 --tier 1` or higher hooks the rest."
     );
-  installHarnesses(adapters, cfg, lean);
+  const skipped = installHarnesses(adapters, cfg, lean);
   writeConfig(cfg);
   const days = Number(flag("--backfill") ?? 30);
   if (days > 0) await backfillRows(adapters, days, cfg);
   out("");
+  if (skipped.length === adapters.length) {
+    process.exitCode = 1;
+    return out(
+      `  \u2717 Nothing was hooked: ${skipped.join(", ")} ${skipped.length > 1 ? "were" : "was"} left alone, for the reason above. Fix that and run \`sessionpipe install\` again.`
+    );
+  }
   const live = cfg.sinks.filter((s) => !s.paused);
   if (live.length) out(`  Reporting to ${live.map((s) => `${s.name} (tier ${s.tier})`).join(", ")}.`);
   else
@@ -14141,6 +14540,7 @@ function rehook(cfg, wasLean) {
   writeConfig(cfg);
 }
 function installHarnesses(adapters, cfg, lean) {
+  const skipped = [];
   if (usesLauncher()) {
     const node = stableNode(process.execPath);
     const l = installLauncher({ distDir, node, version: VERSION2 });
@@ -14176,7 +14576,9 @@ function installHarnesses(adapters, cfg, lean) {
       out(
         "    note: Codex runs non-managed hooks only after you approve them: start `codex` and accept the hook review. The notify fallback reports turn ends meanwhile."
       );
+    if (reports.every((r) => r.skipped)) skipped.push(a.name);
   }
+  return skipped;
 }
 async function connect() {
   const raw = args[1];
@@ -14191,7 +14593,7 @@ async function connect() {
   const host = new URL(url).host;
   const name = machineName(cfg, os15.hostname());
   const before = cfg.sinks.find((x) => x.url.replace(/\/$/, "") === url);
-  const tier = connectTier(flag("--tier"), before?.tier);
+  const tier = connectTier(has("--tier") ? tierArg(args, 0) : void 0, before?.tier);
   out(`  Connecting ${name} to ${host}.`);
   const adapters = ADAPTERS.filter((a) => a.detect());
   if (!adapters.length)
@@ -14268,10 +14670,7 @@ async function connect() {
     const b = moveControlSecrets(store);
     const kept2 = [...a.kept, ...b.kept];
     out(`  \u2713 Keys: in ${storeLabel(store)}${kept2.length ? ` (left in the file: ${kept2.join(", ")})` : ""}`);
-  } else
-    out(
-      `  Keys: in ${tilde(path38.dirname(configFile()))} at 0600 \u2014 no unlocked keychain in this session${process.env.SSH_CONNECTION ? " (an ssh shell)" : ""}`
-    );
+  } else out(`  Keys: in ${tilde(path39.dirname(configFile()))} ${keysFileNote()}`);
   if (rows2.length) queueBackfill(rows2, 30, readConfig());
   out("");
   out(`  Done: ${name} reports to ${host} and takes messages you sign on a device it trusts.`);
@@ -14317,11 +14716,11 @@ function secrets() {
     return;
   }
   const cfg = readConfig();
-  const where = (s) => s.token_in ? `${storeLabel(s.token_in)}${sinkWithSecrets(s) ? "" : " \u2014 can't be read from this session (locked?)"}` : s.token || s.secret ? `${tilde(configFile())} (0600)` : "no key";
+  const where = (s) => s.token_in ? `${storeLabel(s.token_in)}${sinkWithSecrets(s) ? "" : " \u2014 can't be read from this session (locked?)"}` : s.token || s.secret ? `${tilde(configFile())} (${fileKept()})` : "no key";
   for (const s of cfg.sinks) out(`  sink ${s.name.padEnd(20)} ${where(s)}`);
   for (const r of readControl()?.receivers ?? [])
     out(
-      `  control ${new URL(r.url).host.padEnd(17)} ${r.token_in ? `${storeLabel(r.token_in)}${r.token ? "" : " \u2014 can't be read from this session (locked?)"}` : "control.json (0600)"}`
+      `  control ${new URL(r.url).host.padEnd(17)} ${r.token_in ? `${storeLabel(r.token_in)}${r.token ? "" : " \u2014 can't be read from this session (locked?)"}` : `control.json (${fileKept()})`}`
     );
   if (!cfg.sinks.length && !readControl()?.receivers.length) out("  no keys on this machine");
   out(`  best store from this session: ${storeLabel(bestStore())}`);
@@ -14341,6 +14740,7 @@ function unisolated() {
   }).map((a) => a.name);
 }
 async function uninstall() {
+  if (strayWord()) return;
   const named = ADAPTERS.filter((a) => has(`--${a.name}`));
   const all = !named.length;
   if (all && !has("--all")) {
@@ -14355,13 +14755,14 @@ async function uninstall() {
       return;
     }
   }
+  assertConfigWritable();
   if (all || named.some((a) => a.name === "claude-code")) await poolOffForUninstall(out);
   const cfg = readConfig();
   for (const a of all ? ADAPTERS : named) {
     const created = cfg.harnesses[a.name]?.created ?? [];
     for (const r of a.uninstall(process.env, { created }))
-      if (r.changed) out(`  \u2713 ${a.name}: ${r.note ?? `hooks removed from ${tilde(r.file)}`}`);
-      else if (r.skipped) out(`  ! ${a.name}: ${tilde(r.file)} \u2014 ${r.note}`);
+      if (r.skipped) out(`  ! ${a.name}: ${tilde(r.file)} \u2014 ${r.note}`);
+      else if (r.changed) out(`  \u2713 ${a.name}: ${r.note ?? `hooks removed from ${tilde(r.file)}`}`);
     delete cfg.harnesses[a.name];
   }
   writeConfig(cfg);
@@ -14389,7 +14790,7 @@ async function sink() {
     if (!cfg.sinks.length) out("  no sinks");
     for (const s of cfg.sinks)
       out(
-        `  ${s.name.padEnd(16)} ${s.url.padEnd(44)} tier ${s.tier}${s.max_tier !== void 0 && s.max_tier < s.tier ? ` (capped ${s.max_tier})` : ""}${s.pii ? " pii" : ""}${s.control ? " control" : ""}${s.paused ? ` PAUSED ${s.paused}` : ""}`
+        `  ${s.name.padEnd(16)} ${s.url.padEnd(44)} tier ${s.tier}${s.max_tier !== void 0 && s.max_tier < s.tier ? ` (capped ${s.max_tier})` : ""}${s.pii ? " pii" : ""}${s.control ? " control" : ""}${s.paused ? ` PAUSED ${s.paused}` : ""}${toolsNote(s.tier, s.max_tier, toolsMode(s))}`
       );
     return;
   }
@@ -14423,16 +14824,25 @@ async function sink() {
     return;
   }
   out(
-    "usage: sessionpipe sink add <url|file:PATH|stdout> [--tier N] [--token T] [--pii] [--name N] | list | remove <name> | test <name>"
+    "usage: sessionpipe sink add <url|file:PATH|stdout> [--tier N] [--token T] [--pii] [--tools all|main|beat] [--name N] | list | remove <name> | test <name>"
   );
 }
 async function sinkAdd(url, cfg) {
+  assertConfigWritable();
   const tier = Math.max(0, Math.min(3, Number(flag("--tier") ?? 0)));
   const name = flag("--name") ?? (url === "stdout" ? "stdout" : url.startsWith("file:") ? "file" : new URL(url).host);
   if (has("--control"))
     out("  --control is ignored: control is set up per machine (`sessionpipe control pair <url>`, spec/CONTROL.md)");
+  const tools = flag("--tools");
+  if (tools !== void 0 && !isToolsMode(tools)) {
+    out(`  ! --tools takes all, main or beat (got ${JSON.stringify(tools)}): nothing was changed`);
+    process.exitCode = 2;
+    return;
+  }
   const s = { name, url, tier, pii: has("--pii") };
   const prev = cfg.sinks.find((x) => x.name === name && x.url === url);
+  const keptTools = tools ?? prev?.tools;
+  if (keptTools) s.tools = keptTools;
   const token = flag("--token");
   const secret = flag("--secret");
   if (prev?.token_in && !token && !secret) s.token_in = prev.token_in;
@@ -14449,19 +14859,12 @@ async function sinkAdd(url, cfg) {
   writeConfig(cfg);
   out(`  \u2713 sink ${name}: ${url} at tier ${Math.min(tier, s.max_tier ?? 3)}${s.pii ? ", pii" : ""}`);
   out(`    tier ${tier} sends: ${TIER_TEXT[Math.min(tier, s.max_tier ?? 3)]}`);
+  if (Math.min(tier, s.max_tier ?? 3) >= 1) out(`    tool events: ${TOOLS_TEXT[toolsMode(s)]}`);
 }
 async function learnReceiver(s, tier) {
   if (!/^https?:\/\//.test(s.url)) return;
   try {
-    const r = await fetch(`${s.url.replace(/\/$/, "")}/.well-known/sessionpipe`, { signal: AbortSignal.timeout(8e3) });
-    if (!r.ok) throw new Error(`HTTP ${r.status}`);
-    const wk = await r.json();
-    if (typeof wk.max_tier === "number") {
-      s.max_tier = wk.max_tier;
-      if (wk.max_tier < tier) out(`  receiver's max_tier is ${wk.max_tier}: sending tier ${wk.max_tier}, not ${tier}`);
-    }
-    if (wk.endpoints) s.endpoints = wk.endpoints;
-    s.well_known_at = (/* @__PURE__ */ new Date()).toISOString();
+    for (const note of applyWellKnown(s, await readWellKnown(s.url, 8e3), tier)) out(`  ${note}`);
   } catch (e) {
     out(
       `  ! ${s.url} has no readable /.well-known/sessionpipe (${e.message}); added anyway, at tier ${tier}`
@@ -14474,6 +14877,14 @@ var TIER_TEXT = {
   2: "tier 1 + your prompts and the assistant's text, secrets removed",
   3: "everything, including tool input and output"
 };
+function toolsNote(tier, maxTier, mode) {
+  return Math.min(tier, maxTier ?? 3) >= 1 ? ` \xB7 tools ${mode}` : "";
+}
+var TOOLS_TEXT = {
+  all: "every tool call (--tools main: a subagent's at most one a minute)",
+  main: "the main thread's tool calls as they happen; a subagent's at most one a minute per session (--tools all: every one)",
+  beat: "at most one tool call a minute per session (--tools all: every one)"
+};
 function collectRows(adapters, days) {
   const since = Date.now() - days * 864e5;
   const rows2 = [];
@@ -14549,40 +14960,83 @@ async function queueBackfill(rows2, days, cfg, renames = false) {
   void drain(state, cfg.sinks, outbox);
   return { named, renamed };
 }
-function backfill() {
+async function backfill() {
+  if (strayWord(["--days"])) return;
   return backfillRows(selectedAdapters(), Number(flag("--days") ?? 30), readConfig());
 }
+async function flushLock() {
+  const release = await waitNamedLock(state, "flush", 1e4);
+  if (!release) {
+    process.exitCode = 1;
+    out("  \u2717 a drain is running (the flush lock is held); nothing was changed, try again in a moment");
+  }
+  return release;
+}
+async function drainIfMarked(cfg, outbox) {
+  if (existsSync21(path39.join(state, "locks", "flush.more"))) await drain(state, cfg.sinks, outbox);
+}
 async function forget() {
   const [, harness, session] = args;
   if (!harness || !session) return out("usage: sessionpipe forget <harness> <session>");
   const cfg = readConfig();
   const outbox = new Outbox(state);
   const ref = { harness, session };
-  const e = makeEvent(
-    { type: "session.forgotten", harnessEvent: "forget", data: {} },
-    {
-      harness: { name: harness },
-      session: { id: session, seq: outbox.nextSeq(ref), machine: machineName(cfg, os15.hostname()) }
+  const release = await flushLock();
+  if (!release) return;
+  try {
+    const e = makeEvent(
+      { type: "session.forgotten", harnessEvent: "forget", data: {} },
+      {
+        harness: { name: harness },
+        session: { id: session, seq: outbox.nextSeq(ref), machine: machineName(cfg, os15.hostname()) }
+      }
+    );
+    const sinks = buildSinks(cfg.sinks);
+    for (const s of sinks) {
+      const r = await s.send([filterEvent(e, s.tier, s.pii)]);
+      out(r.ok ? `  \u2713 ${s.name}: asked to delete ${harness}:${session}` : `  \u2717 ${s.name}: ${r.error ?? r.status}`);
     }
-  );
-  const sinks = buildSinks(cfg.sinks);
-  for (const s of sinks) {
-    const r = await s.send([filterEvent(e, s.tier, s.pii)]);
-    out(r.ok ? `  \u2713 ${s.name}: asked to delete ${harness}:${session}` : `  \u2717 ${s.name}: ${r.error ?? r.status}`);
+    outbox.delete(ref);
+    out("  local outbox for the session removed, and every sink's cursor into it");
+  } finally {
+    release();
   }
-  outbox.delete(ref);
-  out("  local outbox for the session removed");
+  await drainIfMarked(cfg, outbox);
 }
 async function replay() {
   const name = flag("--sink");
+  const tools = flag("--tools");
+  if (tools !== void 0 && !isToolsMode(tools)) {
+    out(`  ! --tools takes all, main or beat (got ${JSON.stringify(tools)}): nothing was sent`);
+    process.exitCode = 2;
+    return;
+  }
   const cfg = readConfig();
-  const sinks = name ? cfg.sinks.filter((s) => s.name === name) : cfg.sinks;
-  if (!sinks.length) return out("  no such sink");
-  for (const s of sinks) {
-    if (has("--from-start")) new Cursors(state, s.name).write({});
+  const chosen = name ? cfg.sinks.filter((s) => s.name === name) : cfg.sinks;
+  if (!chosen.length) return out("  no such sink");
+  const sinks = tools ? chosen.map((s) => ({ ...s, tools })) : chosen;
+  const release = await flushLock();
+  if (!release) return;
+  const outbox = new Outbox(state);
+  try {
+    for (const s of sinks) {
+      if (has("--from-start")) {
+        new Cursors(state, s.name).write({});
+        new ToolClock(state, s.name).write({});
+      }
+    }
+    const thinned = {};
+    const d = await flush(state, sinks, outbox, void 0, { force: true, thinned });
+    for (const [k, v] of Object.entries(d)) {
+      const t = thinned[k] ?? 0;
+      out(
+        `  ${k}: ${v} event${v === 1 ? "" : "s"} delivered${t ? `, ${t} tool event${t === 1 ? "" : "s"} thinned (--tools all sends every one)` : ""}`
+      );
+    }
+  } finally {
+    release();
   }
-  const d = await flush(state, sinks, new Outbox(state), void 0, { force: true });
-  for (const [k, v] of Object.entries(d)) out(`  ${k}: ${v} event${v === 1 ? "" : "s"} delivered`);
+  await drainIfMarked(cfg, outbox);
 }
 async function controlHealth() {
   if (!pairedCount()) return null;
@@ -14657,13 +15111,14 @@ async function status2() {
       tier: s.tier,
       max_tier: s.max_tier ?? null,
       pii: !!s.pii,
+      tools: toolsMode(s),
       control: !!s.control,
       paused: s.paused ?? null,
       pending_sessions: pending
     });
     if (!json2)
       out(
-        `  sink      ${s.name.padEnd(16)} tier ${Math.min(s.tier, s.max_tier ?? 3)}  ${s.paused ? `PAUSED ${s.paused}` : pending ? `${pending} session file(s) with undelivered events` : "up to date"}`
+        `  sink      ${s.name.padEnd(16)} tier ${Math.min(s.tier, s.max_tier ?? 3)}  ${s.paused ? `PAUSED ${s.paused}` : pending ? `${pending} session file(s) with undelivered events` : "up to date"}${toolsNote(s.tier, s.max_tier, toolsMode(s))}`
       );
   }
   const control = await controlHealth();
@@ -14709,12 +15164,12 @@ async function status2() {
   else if (jobs) out(`  jobs:     ${jobs} waiting`);
 }
 function hookWall(runs = 8) {
-  const hook = path38.join(distDir, "hook.js");
-  const tmp = mkdtempSync(path38.join(os15.tmpdir(), "sessionpipe-doctor-"));
+  const hook = path39.join(distDir, "hook.js");
+  const tmp = mkdtempSync(path39.join(os15.tmpdir(), "sessionpipe-doctor-"));
   const env = {
     ...process.env,
     SESSIONPIPE_STATE: tmp,
-    SESSIONPIPE_CONFIG: path38.join(tmp, "config.json"),
+    SESSIONPIPE_CONFIG: path39.join(tmp, "config.json"),
     SESSIONPIPE_NO_WORKER: "1"
   };
   const input = JSON.stringify({
@@ -14745,7 +15200,7 @@ function hookWall(runs = 8) {
 }
 function timing() {
   try {
-    const lines = readFileSync23(path38.join(state, "timing.jsonl"), "utf8").trim().split("\n").slice(-100);
+    const lines = readFileSync24(path39.join(state, "timing.jsonl"), "utf8").trim().split("\n").slice(-100);
     const ms2 = lines.map((l) => JSON.parse(l).ms).filter((x) => x >= 0).sort((a, b) => a - b);
     if (!ms2.length) return null;
     const q = (p) => Math.round(
@@ -14874,6 +15329,7 @@ async function doctor() {
       tier: s.tier,
       max_tier: s.max_tier ?? null,
       pii: !!s.pii,
+      tools: toolsMode(s),
       control: !!s.control,
       paused: s.paused ?? null,
       token: s.token_in ? `in ${s.token_in}` : s.token ? `${s.token.slice(0, 4)}\u2026` : null
@@ -14893,7 +15349,7 @@ async function doctor() {
     for (const r of st) out(`  ${h.padEnd(12)} ${r.file.padEnd(44)} ${r.state}`);
   for (const s of report.sinks)
     out(
-      `  sink ${s.name.padEnd(16)} tier ${s.tier}${s.max_tier !== null ? ` (receiver max ${s.max_tier})` : ""}${s.paused ? ` PAUSED ${s.paused}` : ""}`
+      `  sink ${s.name.padEnd(16)} tier ${s.tier}${s.max_tier !== null ? ` (receiver max ${s.max_tier})` : ""}${s.paused ? ` PAUSED ${s.paused}` : ""}${toolsNote(s.tier, s.max_tier, s.tools)}`
     );
   controlLines(health);
   const lr = report.launcher;
@@ -14917,7 +15373,7 @@ async function doctor() {
   if (!warnings.length) out("  no warnings");
 }
 async function tail() {
-  const tier = Math.max(0, Math.min(3, Number(flag("--tier") ?? 1)));
+  const tier = tierArg(args, 1);
   const onlySession = flag("--session");
   const onlyHarness = flag("--harness");
   const outbox = new Outbox(state);
@@ -14966,7 +15422,7 @@ async function tail() {
     }
     return `${t} ${e.harness.name.padEnd(11)} ${e.session.id.slice(0, 4)}\u2026  ${e.type.padEnd(17)} ${detail}`;
   };
-  out(`sessionpipe tail \xB7 tier ${tier} \xB7 ${tilde(path38.join(state, "outbox"))} (Ctrl-C to stop)`);
+  out(`sessionpipe tail \xB7 tier ${tier} \xB7 ${tilde(path39.join(state, "outbox"))} (Ctrl-C to stop)`);
   for (const ref of outbox.sessions()) {
     try {
       offsets.set(`${ref.harness}/${ref.session}`, has("--all") ? 0 : statSync14(outbox.file(ref)).size);
@@ -14992,9 +15448,9 @@ async function tail() {
 async function workerFromArgv() {
   const f = args[1];
   if (!f) return;
-  const job = JSON.parse(readFileSync23(f, "utf8"));
+  const job = JSON.parse(readFileSync24(f, "utf8"));
   try {
-    unlinkSync9(f);
+    unlinkSync8(f);
   } catch {
   }
   await runJob(job);
@@ -15018,6 +15474,10 @@ async function update() {
       sub === "off" ? "  \u2713 The control daemon no longer checks npm or updates itself. `sessionpipe update` still updates by hand; `sessionpipe update on` undoes this." : "  \u2713 The control daemon checks npm once a day and installs a new release when it's idle."
     );
   }
+  if (sub !== void 0) {
+    process.exitCode = 2;
+    return out("usage: sessionpipe update [off|on]");
+  }
   if (process.env.SESSIONPIPE_NO_UPDATE_CHECK) return out("  update check is off (SESSIONPIPE_NO_UPDATE_CHECK)");
   let latest;
   try {