sessionpipe 0.1.0 → 0.2.0

package/dist/worker.js

@@ -1,16 +1,20 @@
 #!/usr/bin/env node
-// sessionpipe 0.1.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe 0.2.0 · Apache-2.0 · https://sessionpipe.org
 
 // src/worker.ts
-import { readFileSync as readFileSync9, unlinkSync as unlinkSync2 } from "node:fs";
-
-// src/run.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync8, renameSync as renameSync2, statSync as statSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import os2 from "node:os";
-import path11 from "node:path";
+import { readFileSync as readFileSync9, unlinkSync as unlinkSync5 } from "node:fs";
 
 // ../core/src/adapters/antigravity.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  realpathSync,
+  statSync as statSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
 import path4 from "node:path";
 
 // ../core/src/paths.ts
@@ -237,28 +241,67 @@ function readAntigravity(lines, from) {
 }
 
 // ../core/src/adapters/claude-shaped.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import path3 from "node:path";
 var OURS = /sessionpipe[^"\n]*[\\/]hook\.js"?\s+[a-z][a-z-]*\s+[A-Za-z]+\s*$/;
 var isOurs = (h) => Array.isArray(h?.hooks) && h.hooks.some((x) => typeof x.command === "string" && OURS.test(x.command));
-function readJson(file) {
+function readJsonFile(file) {
+  let raw;
   try {
-    return JSON.parse(readFileSync(file, "utf8"));
+    raw = readFileSync(file, "utf8");
   } catch {
-    return {};
+    return { ok: true, existed: false, value: {}, raw: "", indent: "  ", eol: "\n", finalNewline: true };
   }
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    const hint = /^\s*\/\/|\/\*/m.test(raw) ? "not plain JSON (it has comments)" : "not plain JSON";
+    return { ok: false, existed: true, reason: hint };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { ok: false, existed: true, reason: "not a JSON object" };
+  const eol = raw.includes("\r\n") ? "\r\n" : "\n";
+  const m = /^( +|\t+)\S/m.exec(raw);
+  const indent = m?.[1] ?? "  ";
+  return {
+    ok: true,
+    existed: true,
+    value,
+    raw,
+    indent,
+    eol,
+    finalNewline: /\r?\n$/.test(raw)
+  };
+}
+function formatJson(value, f) {
+  const text = JSON.stringify(value, null, f.indent).replace(/\n/g, f.eol);
+  return f.finalNewline ? text + f.eol : text;
 }
 function entryFor(event, harness, cmd, o) {
   const matcher = o.matcherFor(event);
   return {
     ...matcher !== void 0 ? { matcher } : {},
-    hooks: [{ type: "command", command: cmd([harness, event]).command, timeout: o.timeout }]
+    hooks: [{ type: "command", command: cmd([harness, event]).command, timeout: o.timeoutFor?.(event) ?? o.timeout }]
   };
 }
 function installClaudeShaped(file, harness, events, cmd, o) {
-  const settings2 = readJson(file);
+  const f = readJsonFile(file);
+  if (!f.ok) return { file, changed: false, skipped: true, note: `${f.reason}; not touched` };
+  const settings2 = f.value;
   const hooks = settings2.hooks && typeof settings2.hooks === "object" ? settings2.hooks : {};
   let changed = false;
+  const want = new Set(events);
+  for (const ev of Object.keys(hooks)) {
+    if (want.has(ev)) continue;
+    const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
+    const kept = list.filter((h) => !isOurs(h));
+    if (kept.length !== list.length) {
+      changed = true;
+      if (kept.length) hooks[ev] = kept;
+      else delete hooks[ev];
+    }
+  }
   for (const ev of events) {
     const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
     const entry2 = entryFor(ev, harness, cmd, o);
@@ -277,19 +320,19 @@ function installClaudeShaped(file, harness, events, cmd, o) {
   if (changed) {
     settings2.hooks = hooks;
     mkdirSync(path3.dirname(file), { recursive: true });
-    writeFileSync(file, `${JSON.stringify(settings2, null, 2)}
-`);
+    writeFileSync(file, formatJson(settings2, f));
   }
-  return { file, changed };
+  return { file, changed, created: !f.existed && changed };
 }
-function uninstallClaudeShaped(file, events) {
+function uninstallClaudeShaped(file, events, opts = {}) {
   if (!existsSync(file)) return { file, changed: false };
-  const raw = readFileSync(file, "utf8");
-  const settings2 = readJson(file);
+  const f = readJsonFile(file);
+  if (!f.ok) return { file, changed: false, skipped: true, note: `${f.reason}; not touched` };
+  const settings2 = f.value;
   const hooks = settings2.hooks;
   if (!hooks || typeof hooks !== "object") return { file, changed: false };
   let changed = false;
-  for (const ev of events) {
+  for (const ev of [...events, ...Object.keys(hooks)]) {
     const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
     const kept = list.filter((h) => !isOurs(h));
     if (kept.length !== list.length) {
@@ -300,13 +343,17 @@ function uninstallClaudeShaped(file, events) {
   }
   if (!changed) return { file, changed: false };
   if (!Object.keys(hooks).length) delete settings2.hooks;
-  const next = `${JSON.stringify(settings2, null, 2)}
-`;
-  if (next !== raw) writeFileSync(file, next);
+  if (opts.created && !Object.keys(settings2).length) {
+    unlinkSync(file);
+    return { file, changed: true, note: "removed (sessionpipe created it)" };
+  }
+  const next = formatJson(settings2, f);
+  if (next !== f.raw) writeFileSync(file, next);
   return { file, changed: true };
 }
 function installedClaudeShaped(file, harness, events, cmd, o) {
-  const hooks = readJson(file).hooks ?? {};
+  const f = readJsonFile(file);
+  const hooks = f.ok ? f.value.hooks ?? {} : {};
   let present = 0;
   let current = 0;
   for (const ev of events) {
@@ -315,6 +362,9 @@ function installedClaudeShaped(file, harness, events, cmd, o) {
     if (mine.length) present++;
     if (mine.length === 1 && JSON.stringify(mine[0]) === JSON.stringify(entryFor(ev, harness, cmd, o))) current++;
   }
+  for (const ev of Object.keys(hooks))
+    if (!events.includes(ev) && (Array.isArray(hooks[ev]) ? hooks[ev] : []).some((h) => isOurs(h)))
+      return "stale";
   if (!present) return "missing";
   return current === events.length ? "current" : "stale";
 }
@@ -329,10 +379,13 @@ var projectsDir = (env) => path4.join(gemini(env), "config", "projects");
 var dataDirs = (env) => ["antigravity", "antigravity-cli", "antigravity-ide"].map((d) => path4.join(gemini(env), d));
 var ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 var validTool = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
-function entry(cmd) {
+function entry(cmd, lean) {
   const handler = (e) => ({ type: "command", command: cmd([NAME, e]).command, timeout: 5 });
   const out = { enabled: true };
-  for (const e of AG_EVENTS) out[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
+  for (const e of AG_EVENTS) {
+    if (lean && e === "PreToolUse") continue;
+    out[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
+  }
   return out;
 }
 var antigravity = {
@@ -340,34 +393,49 @@ var antigravity = {
   events: AG_EVENTS,
   detect: (env = process.env) => existsSync2(path4.join(gemini(env), "config")) || dataDirs(env).some((d) => existsSync2(d)),
   configFiles: (env = process.env) => [hooksFile(env)],
-  install(cmd, env = process.env) {
+  install(cmd, env = process.env, opts = {}) {
     const file = hooksFile(env);
-    const hooks = readJson(file);
-    const e = entry(cmd);
+    const f = readJsonFile(file);
+    if (!f.ok) return [{ file, changed: false, skipped: true, note: `${f.reason}; not touched` }];
+    const hooks = f.value;
+    const e = entry(cmd, opts.lean);
     if (JSON.stringify(hooks[HOOK_NAME]) === JSON.stringify(e)) return [{ file, changed: false }];
     hooks[HOOK_NAME] = e;
     mkdirSync2(path4.dirname(file), { recursive: true });
-    writeFileSync2(file, `${JSON.stringify(hooks, null, 2)}
-`);
+    writeFileSync2(file, formatJson(hooks, f));
     return [
-      { file, changed: true, note: "hooks.json is read when a conversation starts; open ones report after a restart" }
+      {
+        file,
+        changed: true,
+        created: !f.existed,
+        note: "hooks.json is read when a conversation starts; open ones report after a restart"
+      }
     ];
   },
-  uninstall(env = process.env) {
+  uninstall(env = process.env, opts = {}) {
     const file = hooksFile(env);
     if (!existsSync2(file)) return [{ file, changed: false }];
-    const hooks = readJson(file);
+    const f = readJsonFile(file);
+    if (!f.ok) return [{ file, changed: false, skipped: true, note: `${f.reason}; not touched` }];
+    const hooks = f.value;
     if (!(HOOK_NAME in hooks)) return [{ file, changed: false }];
     delete hooks[HOOK_NAME];
-    writeFileSync2(file, `${JSON.stringify(hooks, null, 2)}
-`);
+    if (opts.created?.includes(file) && !Object.keys(hooks).length) {
+      unlinkSync2(file);
+      return [{ file, changed: true, note: "removed (sessionpipe created it)" }];
+    }
+    writeFileSync2(file, formatJson(hooks, f));
     return [{ file, changed: true }];
   },
-  installed(cmd, env = process.env) {
+  installed(cmd, env = process.env, opts = {}) {
     const file = hooksFile(env);
-    const have = readJson(file)[HOOK_NAME];
+    const f = readJsonFile(file);
+    const have = f.ok ? f.value[HOOK_NAME] : void 0;
     return [
-      { file, state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd)) ? "current" : "stale" }
+      {
+        file,
+        state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd, opts.lean)) ? "current" : "stale"
+      }
     ];
   },
   fromHook(input) {
@@ -633,9 +701,18 @@ var CLAUDE_EVENTS = [
   "SubagentStop",
   "PreCompact",
   "PostCompact",
-  "SessionEnd"
+  "SessionEnd",
+  "StopFailure"
 ];
-var OPTS = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
+var LEAN_SKIP = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUseFailure"]);
+var eventsFor = (lean) => lean ? CLAUDE_EVENTS.filter((e) => !LEAN_SKIP.has(e)) : [...CLAUDE_EVENTS];
+var OPTS = {
+  matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0,
+  timeout: 5,
+  // The hook waits up to 125 s for a verified control answer, and only when control
+  // is paired on this machine; everywhere else it exits in milliseconds as before.
+  timeoutFor: (e) => e === "PermissionRequest" ? 130 : void 0
+};
 var DESKTOP_ID = /^local_[A-Za-z0-9-]{1,64}$/;
 function claudeDirs(env = process.env, home = HOME) {
   const out = [];
@@ -666,11 +743,13 @@ var claudeCode = {
   events: CLAUDE_EVENTS,
   detect: (env = process.env) => claudeDirs(env).some((d) => existsSync3(d)),
   configFiles: (env = process.env) => claudeDirs(env).map(settingsIn),
-  install: (cmd, env = process.env) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd, OPTS)),
-  uninstall: (env = process.env) => claudeDirs(env).map((d) => uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS)),
-  installed: (cmd, env = process.env) => claudeDirs(env).map((d) => ({
+  install: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd, OPTS)),
+  uninstall: (env = process.env, opts = {}) => claudeDirs(env).map(
+    (d) => uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS, { created: opts.created?.includes(settingsIn(d)) })
+  ),
+  installed: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
     file: settingsIn(d),
-    state: installedClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd, OPTS)
+    state: installedClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd, OPTS)
   })),
   fromHook(input) {
     const event = input.argv[1] ?? "";
@@ -761,6 +840,15 @@ var claudeCode = {
       case "Stop":
         events.push(ev("turn.ended", { turn_id, reason: "stop" }));
         break;
+      case "StopFailure":
+        events.push(
+          ev("turn.ended", {
+            turn_id,
+            reason: "error",
+            error: typeof s.error === "string" ? s.error.slice(0, 200) : void 0
+          })
+        );
+        break;
       case "SubagentStart":
         events.push(
           ev("subagent.started", {
@@ -1068,9 +1156,9 @@ function claudeFacts(file, sessionId, hints, state) {
   }
   const name = live?.name ? { title: live.name, source: live.name_source } : typeof mem.name === "string" ? { title: mem.name, source: mem.name_source } : null;
   const pick = name && name.source === "custom" && name || custom && { title: custom, source: "custom" } || name || ai && { title: ai, source: "harness" };
-  let ask = typeof mem.first_ask === "string" ? mem.first_ask : firstAsk(H);
-  if (!ask && size > 64 * 1024 && !mem.first_ask_none) {
-    ask = scanLines(file, (l) => {
+  let ask2 = typeof mem.first_ask === "string" ? mem.first_ask : firstAsk(H);
+  if (!ask2 && size > 64 * 1024 && !mem.first_ask_none) {
+    ask2 = scanLines(file, (l) => {
       try {
         const t = askText(JSON.parse(l));
         return t ? appTitle(t) : null;
@@ -1078,17 +1166,17 @@ function claudeFacts(file, sessionId, hints, state) {
         return null;
       }
     });
-    if (!ask && size > 16 * 1024 * 1024) state.save(NAME2, id, { first_ask_none: true });
+    if (!ask2 && size > 16 * 1024 * 1024) state.save(NAME2, id, { first_ask_none: true });
   }
-  if (ask) {
-    out.first_ask = ask;
-    if (!mem.first_ask) state.save(NAME2, id, { first_ask: ask });
+  if (ask2) {
+    out.first_ask = ask2;
+    if (!mem.first_ask) state.save(NAME2, id, { first_ask: ask2 });
   }
   if (pick) {
     out.title = String(pick.title).slice(0, 120);
     out.title_source = pick.source;
-  } else if (ask) {
-    out.title = ask;
+  } else if (ask2) {
+    out.title = ask2;
     out.title_source = "first-ask";
   }
   const acct = claudeAccount(dir);
@@ -1272,6 +1360,7 @@ var CODEX_EVENTS = [
   "SessionEnd"
 ];
 var OPTS2 = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
+var eventsFor2 = (lean) => lean ? CODEX_EVENTS.filter((e) => e !== "PreToolUse") : [...CODEX_EVENTS];
 var codexHome = (env) => env.CODEX_HOME || path6.join(HOME, ".codex");
 var hooksFile2 = (env) => path6.join(codexHome(env), "hooks.json");
 var configFile2 = (env) => path6.join(codexHome(env), "config.toml");
@@ -1320,7 +1409,8 @@ function installNotify(cmd, env) {
     return {
       file,
       changed: false,
-      note: `left alone: notify runs ${n.raw.slice(0, 80)} (hooks.json carries the events; the notify fallback is off)`
+      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`
     };
   }
   write(withNotify(text, line));
@@ -1377,14 +1467,21 @@ var codex = {
   events: CODEX_EVENTS,
   detect: (env = process.env) => existsSync4(codexHome(env)),
   configFiles: (env = process.env) => [hooksFile2(env), configFile2(env)],
-  install: (cmd, env = process.env) => [
-    installClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd, OPTS2),
+  install: (cmd, env = process.env, opts = {}) => [
+    installClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd, OPTS2),
     installNotify(cmd, env)
   ],
-  uninstall: (env = process.env) => [uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS), uninstallNotify(env)],
-  installed: (cmd, env = process.env) => {
+  uninstall: (env = process.env, opts = {}) => [
+    uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS, { created: opts.created?.includes(hooksFile2(env)) }),
+    uninstallNotify(env)
+  ],
+  installed: (cmd, env = process.env, opts = {}) => {
     const out = [
-      { file: hooksFile2(env), state: installedClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd, OPTS2) }
+      {
+        file: hooksFile2(env),
+        state: installedClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd, OPTS2),
+        note: "Codex runs non-managed hooks only after the review in `codex` (/hooks); until then nothing is reported unless the notify fallback is ours"
+      }
     ];
     let text = "";
     try {
@@ -1572,6 +1669,7 @@ function codexFacts(file) {
 }
 
 // ../core/src/adapters/gemini-cli.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
 import path7 from "node:path";
 var NAME4 = "gemini-cli";
@@ -1589,17 +1687,61 @@ var OPTS3 = { matcherFor: (e) => /Tool/.test(e) ? ".*" : void 0, timeout: 5e3 };
 var geminiDir = (env) => env.GEMINI_CLI_HOME || path7.join(HOME, ".gemini");
 var settings = (env) => path7.join(geminiDir(env), "settings.json");
 var validTool4 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
+var eventsFor3 = (lean) => lean ? GEMINI_EVENTS.filter((e) => e !== "BeforeTool") : [...GEMINI_EVENTS];
+function geminiHooksActive(settingsFile) {
+  let tools;
+  try {
+    tools = JSON.parse(readFileSync5(settingsFile, "utf8")).tools;
+  } catch {
+  }
+  if (tools?.enableHooks === true) return { active: true };
+  if (tools?.enableHooks === false)
+    return { active: false, note: "inactive: tools.enableHooks is false in settings.json" };
+  let version = "";
+  try {
+    version = execFileSync3("gemini", ["--version"], {
+      encoding: "utf8",
+      timeout: 4e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return {
+      active: true,
+      note: "could not run `gemini --version`; hooks need tools.enableHooks on versions before 0.46"
+    };
+  }
+  const m = /(\d+)\.(\d+)/.exec(version);
+  if (m && (Number(m[1]) > 0 || Number(m[2]) >= 46)) return { active: true };
+  return {
+    active: false,
+    note: `inactive: Gemini CLI ${version || "?"} runs hooks only with "tools": {"enableHooks": true} in settings.json`
+  };
+}
 var geminiCli = {
   name: NAME4,
   events: GEMINI_EVENTS,
   // ~/.gemini also belongs to Antigravity; Gemini CLI is here when its settings or its chat logs exist.
   detect: (env = process.env) => existsSync5(settings(env)) || existsSync5(path7.join(geminiDir(env), "tmp")),
   configFiles: (env = process.env) => [settings(env)],
-  install: (cmd, env = process.env) => [installClaudeShaped(settings(env), NAME4, GEMINI_EVENTS, cmd, OPTS3)],
-  uninstall: (env = process.env) => [uninstallClaudeShaped(settings(env), GEMINI_EVENTS)],
-  installed: (cmd, env = process.env) => [
-    { file: settings(env), state: installedClaudeShaped(settings(env), NAME4, GEMINI_EVENTS, cmd, OPTS3) }
+  install: (cmd, env = process.env, opts = {}) => {
+    const r = installClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd, OPTS3);
+    const a = geminiHooksActive(settings(env));
+    return [a.note && !r.skipped ? { ...r, note: [r.note, a.note].filter(Boolean).join("; ") } : r];
+  },
+  uninstall: (env = process.env, opts = {}) => [
+    uninstallClaudeShaped(settings(env), GEMINI_EVENTS, { created: opts.created?.includes(settings(env)) })
   ],
+  installed: (cmd, env = process.env, opts = {}) => {
+    const state = installedClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd, OPTS3);
+    const a = geminiHooksActive(settings(env));
+    return [
+      {
+        file: settings(env),
+        state: state === "current" && !a.active ? "inactive" : state,
+        ...a.note ? { note: a.note } : {}
+      }
+    ];
+  },
   fromHook(input) {
     const event = input.argv[1] ?? "";
     let s = {};
@@ -1810,7 +1952,7 @@ import {
   readSync as readSync2,
   renameSync,
   statSync as statSync4,
-  unlinkSync,
+  unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync5
 } from "node:fs";
 import path9 from "node:path";
@@ -1838,8 +1980,8 @@ var Outbox = class {
     } catch {
       n = this.lastSeqInFile(ref) + 1;
     }
-    mkdirSync5(path9.dirname(f), { recursive: true });
-    writeFileSync5(f, String(n + 1));
+    mkdirSync5(path9.dirname(f), { recursive: true, mode: 448 });
+    writeFileSync5(f, String(n + 1), { mode: 384 });
     return n;
   }
   lastSeqInFile(ref) {
@@ -1857,9 +1999,9 @@ var Outbox = class {
   }
   append(ref, events) {
     if (!events.length) return;
-    mkdirSync5(this.dir(ref.harness), { recursive: true });
+    mkdirSync5(this.dir(ref.harness), { recursive: true, mode: 448 });
     appendFileSync(this.file(ref), `${events.map((e) => JSON.stringify(e)).join("\n")}
-`);
+`, { mode: 384 });
   }
   /** Every session file, newest first. */
   sessions() {
@@ -1923,9 +2065,9 @@ var Outbox = class {
       const f = this.file(ref);
       try {
         if (statSync4(f).mtimeMs < cutoff) {
-          unlinkSync(f);
+          unlinkSync3(f);
           try {
-            unlinkSync(this.seqFile(ref));
+            unlinkSync3(this.seqFile(ref));
           } catch {
           }
           n++;
@@ -1938,7 +2080,7 @@ var Outbox = class {
   delete(ref) {
     for (const f of [this.file(ref), this.seqFile(ref)]) {
       try {
-        unlinkSync(f);
+        unlinkSync3(f);
       } catch {
       }
     }
@@ -1963,9 +2105,9 @@ var Cursors = class {
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path9.dirname(f), { recursive: true });
+    mkdirSync5(path9.dirname(f), { recursive: true, mode: 448 });
     const tmp = `${f}.${process.pid}.tmp`;
-    writeFileSync5(tmp, JSON.stringify(c));
+    writeFileSync5(tmp, JSON.stringify(c), { mode: 384 });
     renameSync(tmp, f);
   }
   key(ref) {
@@ -1974,10 +2116,10 @@ var Cursors = class {
 };
 function takeLock(root, ref, staleMs = 5 * 6e4) {
   const dir = path9.join(root, "locks");
-  mkdirSync5(dir, { recursive: true });
+  mkdirSync5(dir, { recursive: true, mode: 448 });
   const f = path9.join(dir, `${safeId(ref.harness)}-${safeId(ref.session)}.lock`);
   try {
-    if (Date.now() - statSync4(f).mtimeMs > staleMs) unlinkSync(f);
+    if (Date.now() - statSync4(f).mtimeMs > staleMs) unlinkSync3(f);
     else return null;
   } catch {
   }
@@ -1988,7 +2130,7 @@ function takeLock(root, ref, staleMs = 5 * 6e4) {
   }
   return () => {
     try {
-      unlinkSync(f);
+      unlinkSync3(f);
     } catch {
     }
   };
@@ -2124,7 +2266,7 @@ function redactAssignments(text) {
 function isSecretName(name) {
   if (/^[A-Z0-9_]+_KEY$/.test(name)) return true;
   const flat = name.toLowerCase().replace(/[_-]/g, "");
-  return /(?:pass(?:word|wd|phrase|code)?|pwd|secret|secretkey|secretaccesskey|clientsecret|apikey|accesskey|accesstoken|authtoken|refreshtoken|privatekey|token|credential|creds)s?$/.test(
+  return /(?:pass(?:word|wd|phrase|code)|pwd|secret|secretkey|secretaccesskey|clientsecret|apikey|accesskey|accesstoken|authtoken|refreshtoken|privatekey|token|credential|creds)s?$/.test(
     flat
   );
 }
@@ -2213,7 +2355,7 @@ var DATA_ALLOW = {
   "session.backfill": { 0: ["started_at", "last_at", "turns"] },
   "session.forgotten": { 0: [] },
   "turn.started": { 0: ["turn_id"], 1: ["prompt_chars"] },
-  "turn.ended": { 0: ["turn_id", "reason", "ms"] },
+  "turn.ended": { 0: ["turn_id", "reason", "ms"], 1: ["error"] },
   "turn.transcript": { 2: ["turn", "user", "assistant", "at"] },
   "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"] },
@@ -2334,9 +2476,66 @@ var StdoutSink = class {
   }
 };
 
+// src/run.ts
+import {
+  appendFileSync as appendFileSync3,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync8,
+  renameSync as renameSync2,
+  statSync as statSync5,
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync6
+} from "node:fs";
+import os3 from "node:os";
+import path12 from "node:path";
+
+// src/control/local.ts
+import net from "node:net";
+import os2 from "node:os";
+import path11 from "node:path";
+function socketPath(state, env = process.env) {
+  if (env.SESSIONPIPE_SOCKET) return env.SESSIONPIPE_SOCKET;
+  if (process.platform === "win32") return `\\\\.\\pipe\\sessionpipe-control-${os2.userInfo().username}`;
+  return path11.join(state, "control.sock");
+}
+function ask(sock, req, timeoutMs) {
+  return new Promise((resolve) => {
+    let buf = "";
+    let done = false;
+    const s = net.connect(sock);
+    const finish = (r) => {
+      if (done) return;
+      done = true;
+      clearTimeout(t);
+      s.destroy();
+      resolve(r);
+    };
+    const t = setTimeout(() => finish(null), timeoutMs);
+    s.on("connect", () => s.write(`${JSON.stringify(req)}
+`));
+    s.on("data", (d) => {
+      buf += d.toString("utf8");
+      const i = buf.indexOf("\n");
+      if (i < 0) return;
+      try {
+        finish(JSON.parse(buf.slice(0, i)));
+      } catch {
+        finish(null);
+      }
+    });
+    s.on("error", () => finish(null));
+    s.on("close", () => finish(null));
+  });
+}
+
 // src/http-sink.ts
-import { createHmac, randomUUID } from "node:crypto";
+import { createHash as createHash3, createHmac } from "node:crypto";
 var TIMEOUT_MS = 15e3;
+function webhookId(events) {
+  return `msg_${createHash3("sha256").update(events.map((e) => e.id).join(",")).digest("base64url").slice(0, 32)}`;
+}
 var HttpSink = class {
   constructor(cfg, tier) {
     this.cfg = cfg;
@@ -2359,7 +2558,7 @@ var HttpSink = class {
     const headers = { "content-type": "application/json", "sessionpipe-protocol": "1" };
     if (this.cfg.token) headers.authorization = `Bearer ${this.cfg.token}`;
     if (this.cfg.secret?.startsWith("whsec_")) {
-      const id = `msg_${randomUUID()}`;
+      const id = webhookId(events);
       const ts = Math.floor(Date.now() / 1e3);
       const key = Buffer.from(this.cfg.secret.slice(6), "base64");
       const sig = createHmac("sha256", key).update(`${id}.${ts}.${body}`).digest("base64");
@@ -2420,10 +2619,57 @@ var HttpSink = class {
 };
 
 // src/run.ts
+async function tellDaemon(state, job2, session, transcript) {
+  const sock = socketPath(state);
+  if (process.platform !== "win32" && !existsSync8(sock)) return;
+  await ask(
+    sock,
+    {
+      op: "event",
+      session: `claude-code:${session}`,
+      event: job2.event,
+      cwd: job2.cwd,
+      ...transcript ? { transcript } : {}
+    },
+    300
+  );
+}
+function enqueueJob(state, job2) {
+  const jobs = jobsDir(state);
+  mkdirSync7(jobs, { recursive: true, mode: 448 });
+  const f = path12.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
+  writeFileSync6(f, JSON.stringify(job2), { mode: 384 });
+  return f;
+}
+async function sweepJobs(state, olderThanMs = 3e3, limit = 20) {
+  const jobs = jobsDir(state);
+  let names = [];
+  try {
+    names = readdirSync6(jobs).filter((n) => n.endsWith(".json"));
+  } catch {
+    return 0;
+  }
+  let ran = 0;
+  for (const n of names.sort().slice(0, limit)) {
+    const f = path12.join(jobs, n);
+    let job2 = null;
+    try {
+      if (Date.now() - statSync5(f).mtimeMs < olderThanMs) continue;
+      job2 = JSON.parse(readFileSync8(f, "utf8"));
+      unlinkSync4(f);
+    } catch {
+      continue;
+    }
+    await runJob(job2, { state }).catch(() => {
+    });
+    ran++;
+  }
+  return ran;
+}
 function log(state, line) {
   try {
-    mkdirSync7(state, { recursive: true });
-    const f = path11.join(state, "log");
+    mkdirSync7(state, { recursive: true, mode: 448 });
+    const f = path12.join(state, "log");
     try {
       if (statSync5(f).size > 1024 * 1024) renameSync2(f, `${f}.1`);
     } catch {
@@ -2434,7 +2680,7 @@ function log(state, line) {
   }
 }
 function factsState(state) {
-  const file = (h, s) => path11.join(state, "facts", safeId(h), `${safeId(s)}.json`);
+  const file = (h, s) => path12.join(state, "facts", safeId(h), `${safeId(s)}.json`);
   return {
     get(h, s) {
       try {
@@ -2447,8 +2693,8 @@ function factsState(state) {
       const cur = this.get(h, s);
       const next = { ...cur, ...patch };
       if (JSON.stringify(next) === JSON.stringify(cur)) return;
-      mkdirSync7(path11.dirname(file(h, s)), { recursive: true });
-      writeFileSync6(file(h, s), JSON.stringify(next));
+      mkdirSync7(path12.dirname(file(h, s)), { recursive: true, mode: 448 });
+      writeFileSync6(file(h, s), JSON.stringify(next), { mode: 384 });
     }
   };
 }
@@ -2459,7 +2705,7 @@ function buildSinks(sinks) {
     const tier = Math.min(s.tier, s.max_tier ?? 3);
     if (s.url === "stdout") out.push(new StdoutSink(s.name, tier, !!s.pii));
     else if (s.url.startsWith("file:"))
-      out.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os2.homedir()), tier, !!s.pii));
+      out.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os3.homedir()), tier, !!s.pii));
     else if (/^https?:\/\//.test(s.url)) out.push(new HttpSink(s, tier));
   }
   return out;
@@ -2471,14 +2717,17 @@ async function runJob(job2, opts = {}) {
   if (!adapter) return { events: [], delivered: {} };
   const r = adapter.fromHook({ argv: job2.argv, stdin: job2.stdin, env: { ...process.env, ...job2.env }, cwd: job2.cwd });
   if (!r || !r.session.id) return { events: [], delivered: {} };
+  if (job2.harness === "claude-code") await tellDaemon(state, job2, r.session.id, r.transcript);
   const outbox = new Outbox(state);
   const ref = { harness: job2.harness, session: r.session.id };
-  const release = takeLock(state, ref);
+  let release = takeLock(state, ref);
+  for (let wait = 50; !release && wait <= 3200; wait *= 2) {
+    await new Promise((res) => setTimeout(res, wait));
+    release = takeLock(state, ref);
+  }
   if (!release) {
-    log(state, `${job2.harness} ${job2.event}: session ${r.session.id} locked, re-queued`);
-    const jobs = path11.join(state, "jobs");
-    mkdirSync7(jobs, { recursive: true });
-    writeFileSync6(path11.join(jobs, `${Date.now().toString(36)}-requeue.json`), JSON.stringify(job2));
+    log(state, `${job2.harness} ${job2.event}: session ${r.session.id} locked for 6 s, re-queued`);
+    enqueueJob(state, job2);
     return { events: [], delivered: {} };
   }
   try {
@@ -2503,7 +2752,7 @@ async function runJob(job2, opts = {}) {
       ...learned.branch ? { branch: learned.branch } : {},
       id: r.session.id,
       seq: 0,
-      machine: machineName(cfg, os2.hostname()),
+      machine: machineName(cfg, os3.hostname()),
       ...cwdRaw ? { cwd: tilde(cwdRaw) } : {},
       ...r.session.model ? { model: r.session.model } : {}
     };
@@ -2542,7 +2791,10 @@ async function runJob(job2, opts = {}) {
       if (read.turns.length)
         facts.save(job2.harness, r.session.id, { transcript_line: read.line, transcript_turns: turnNo });
     }
-    outbox.append(ref, events);
+    outbox.append(
+      ref,
+      events.map((e) => ({ ...e, session: redactDeep(e.session), data: redactDeep(e.data) }))
+    );
     log(
       state,
       `${job2.harness} ${job2.event}: ${events.map((e) => e.type).join(",") || "nothing"} (${r.session.id.slice(0, 8)})`
@@ -2568,34 +2820,57 @@ async function flush(state, sinkConfigs, outbox, first) {
     const cursors = new Cursors(state, sink.name);
     const c = cursors.read();
     let sent = 0;
+    let stalled = false;
+    let batch = [];
+    let pending = {};
+    const send = async () => {
+      if (!batch.length) {
+        Object.assign(c, pending);
+        pending = {};
+        cursors.write(c);
+        return true;
+      }
+      const res = await sink.send(batch);
+      if (!res.ok) {
+        log(state, `sink ${sink.name}: ${res.status ?? ""} ${res.error ?? ""} \u2192 ${res.action ?? "retry"}`);
+        if (res.action === "pause" || res.action === "lower-tier") applySinkVerdict(sink.name, res);
+        if (res.action !== "drop") {
+          batch = [];
+          pending = {};
+          return false;
+        }
+      }
+      sent += batch.length;
+      Object.assign(c, pending);
+      cursors.write(c);
+      batch = [];
+      pending = {};
+      return true;
+    };
     for (const ref of refs) {
-      if (sent >= MAX_PER_RUN) break;
-      let offset = c[cursors.key(ref)] ?? 0;
-      let stalled = false;
-      while (sent < MAX_PER_RUN) {
-        const { events, offset: next } = outbox.read(ref, offset, BATCH);
+      if (stalled || sent >= MAX_PER_RUN) break;
+      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);
         if (!events.length) break;
-        const filtered = events.map((e) => filterEvent(e, sink.tier, sink.pii, { home: os2.homedir() })).filter((e) => !!e);
-        let ok = true;
-        if (filtered.length) {
-          const res = await sink.send(filtered);
-          ok = res.ok;
-          if (!ok) {
-            log(state, `sink ${sink.name}: ${res.status ?? ""} ${res.error ?? ""} \u2192 ${res.action ?? "retry"}`);
-            if (res.action === "pause" || res.action === "lower-tier") applySinkVerdict(sink.name, res);
-            if (res.action === "drop") ok = true;
-          }
-          if (ok) sent += filtered.length;
-        }
-        if (!ok) {
-          stalled = true;
-          break;
+        for (const e of events) {
+          const f = filterEvent(e, sink.tier, sink.pii, { home: os3.homedir() });
+          if (f) batch.push(f);
         }
         offset = next;
-        c[cursors.key(ref)] = offset;
-        cursors.write(c);
+        pending[cursors.key(ref)] = offset;
+        if (batch.length >= BATCH) {
+          if (!await send()) {
+            stalled = true;
+            break;
+          }
+          if (sent >= MAX_PER_RUN) break;
+        }
       }
-      if (stalled) break;
+    }
+    if (!stalled && (batch.length || Object.keys(pending).length)) {
+      if (!await send()) stalled = true;
     }
     delivered[sink.name] = sent;
   }
@@ -2612,6 +2887,7 @@ function applySinkVerdict(name, res) {
   } catch {
   }
 }
+var jobsDir = (state) => path12.join(state, "jobs");
 
 // src/worker.ts
 var jobFile = process.argv[2];
@@ -2622,12 +2898,13 @@ try {
 } catch {
 }
 try {
-  unlinkSync2(jobFile);
+  unlinkSync5(jobFile);
 } catch {
 }
 if (!job) process.exit(0);
 var deadline = setTimeout(() => process.exit(0), 15e3);
 deadline.unref();
 runJob(job).catch(() => {
+}).then(() => sweepJobs(stateDir())).catch(() => {
 }).finally(() => process.exit(0));
 //# sourceMappingURL=worker.js.map