sessionpipe 0.1.0 → 0.1.1

package/dist/cli.js

@@ -1,15 +1,24 @@
 #!/usr/bin/env node
-// sessionpipe 0.1.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe 0.1.1 · Apache-2.0 · https://sessionpipe.org
 
 // src/cli.ts
-import { execFileSync as execFileSync3, spawn } from "node:child_process";
-import { readdirSync as readdirSync6, readFileSync as readFileSync9, realpathSync as realpathSync2, statSync as statSync6, unlinkSync as unlinkSync2 } from "node:fs";
+import { execFileSync as execFileSync4, spawn, spawnSync } from "node:child_process";
+import { mkdtempSync, readdirSync as readdirSync7, readFileSync as readFileSync9, realpathSync as realpathSync2, rmSync, statSync as statSync6, unlinkSync as unlinkSync5 } from "node:fs";
 import os3 from "node:os";
 import path12 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../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
@@ -236,16 +245,42 @@ 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, cmd2, o) {
   const matcher = o.matcherFor(event);
@@ -255,9 +290,22 @@ function entryFor(event, harness, cmd2, o) {
   };
 }
 function installClaudeShaped(file, harness, events, cmd2, 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, cmd2, o);
@@ -276,19 +324,19 @@ function installClaudeShaped(file, harness, events, cmd2, 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) {
@@ -299,13 +347,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, cmd2, 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) {
@@ -314,6 +366,9 @@ function installedClaudeShaped(file, harness, events, cmd2, o) {
     if (mine.length) present++;
     if (mine.length === 1 && JSON.stringify(mine[0]) === JSON.stringify(entryFor(ev, harness, cmd2, 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";
 }
@@ -328,10 +383,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(cmd2) {
+function entry(cmd2, lean) {
   const handler = (e) => ({ type: "command", command: cmd2([NAME, e]).command, timeout: 5 });
   const out2 = { enabled: true };
-  for (const e of AG_EVENTS) out2[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
+  for (const e of AG_EVENTS) {
+    if (lean && e === "PreToolUse") continue;
+    out2[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
+  }
   return out2;
 }
 var antigravity = {
@@ -339,34 +397,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(cmd2, env = process.env) {
+  install(cmd2, env = process.env, opts = {}) {
     const file = hooksFile(env);
-    const hooks = readJson(file);
-    const e = entry(cmd2);
+    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(cmd2, 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(cmd2, env = process.env) {
+  installed(cmd2, 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(cmd2)) ? "current" : "stale" }
+      {
+        file,
+        state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd2, opts.lean)) ? "current" : "stale"
+      }
     ];
   },
   fromHook(input) {
@@ -632,8 +705,11 @@ var CLAUDE_EVENTS = [
   "SubagentStop",
   "PreCompact",
   "PostCompact",
-  "SessionEnd"
+  "SessionEnd",
+  "StopFailure"
 ];
+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 };
 var DESKTOP_ID = /^local_[A-Za-z0-9-]{1,64}$/;
 function claudeDirs(env = process.env, home = HOME) {
@@ -665,11 +741,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: (cmd2, env = process.env) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd2, OPTS)),
-  uninstall: (env = process.env) => claudeDirs(env).map((d) => uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS)),
-  installed: (cmd2, env = process.env) => claudeDirs(env).map((d) => ({
+  install: (cmd2, env = process.env, opts = {}) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd2, OPTS)),
+  uninstall: (env = process.env, opts = {}) => claudeDirs(env).map(
+    (d) => uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS, { created: opts.created?.includes(settingsIn(d)) })
+  ),
+  installed: (cmd2, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
     file: settingsIn(d),
-    state: installedClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd2, OPTS)
+    state: installedClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd2, OPTS)
   })),
   fromHook(input) {
     const event = input.argv[1] ?? "";
@@ -760,6 +838,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", {
@@ -1271,6 +1358,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");
@@ -1319,7 +1407,8 @@ function installNotify(cmd2, 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));
@@ -1376,14 +1465,21 @@ var codex = {
   events: CODEX_EVENTS,
   detect: (env = process.env) => existsSync4(codexHome(env)),
   configFiles: (env = process.env) => [hooksFile2(env), configFile2(env)],
-  install: (cmd2, env = process.env) => [
-    installClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd2, OPTS2),
+  install: (cmd2, env = process.env, opts = {}) => [
+    installClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd2, OPTS2),
     installNotify(cmd2, env)
   ],
-  uninstall: (env = process.env) => [uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS), uninstallNotify(env)],
-  installed: (cmd2, env = process.env) => {
+  uninstall: (env = process.env, opts = {}) => [
+    uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS, { created: opts.created?.includes(hooksFile2(env)) }),
+    uninstallNotify(env)
+  ],
+  installed: (cmd2, env = process.env, opts = {}) => {
     const out2 = [
-      { file: hooksFile2(env), state: installedClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd2, OPTS2) }
+      {
+        file: hooksFile2(env),
+        state: installedClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd2, 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 {
@@ -1571,6 +1667,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";
@@ -1588,17 +1685,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: (cmd2, env = process.env) => [installClaudeShaped(settings(env), NAME4, GEMINI_EVENTS, cmd2, OPTS3)],
-  uninstall: (env = process.env) => [uninstallClaudeShaped(settings(env), GEMINI_EVENTS)],
-  installed: (cmd2, env = process.env) => [
-    { file: settings(env), state: installedClaudeShaped(settings(env), NAME4, GEMINI_EVENTS, cmd2, OPTS3) }
+  install: (cmd2, env = process.env, opts = {}) => {
+    const r = installClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd2, 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: (cmd2, env = process.env, opts = {}) => {
+    const state2 = installedClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd2, OPTS3);
+    const a = geminiHooksActive(settings(env));
+    return [
+      {
+        file: settings(env),
+        state: state2 === "current" && !a.active ? "inactive" : state2,
+        ...a.note ? { note: a.note } : {}
+      }
+    ];
+  },
   fromHook(input) {
     const event = input.argv[1] ?? "";
     let s = {};
@@ -1809,7 +1950,7 @@ import {
   readSync as readSync2,
   renameSync,
   statSync as statSync4,
-  unlinkSync,
+  unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync5
 } from "node:fs";
 import path9 from "node:path";
@@ -1837,8 +1978,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) {
@@ -1856,9 +1997,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() {
@@ -1922,9 +2063,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++;
@@ -1937,7 +2078,7 @@ var Outbox = class {
   delete(ref) {
     for (const f of [this.file(ref), this.seqFile(ref)]) {
       try {
-        unlinkSync(f);
+        unlinkSync3(f);
       } catch {
       }
     }
@@ -1962,9 +2103,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) {
@@ -1973,10 +2114,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 {
   }
@@ -1987,7 +2128,7 @@ function takeLock(root, ref, staleMs = 5 * 6e4) {
   }
   return () => {
     try {
-      unlinkSync(f);
+      unlinkSync3(f);
     } catch {
     }
   };
@@ -2123,7 +2264,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
   );
 }
@@ -2212,7 +2353,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,7 +2475,17 @@ var StdoutSink = class {
 };
 
 // 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 {
+  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 os2 from "node:os";
 import path11 from "node:path";
 
@@ -2424,10 +2575,17 @@ var HttpSink = class {
 };
 
 // src/run.ts
-var VERSION = true ? "0.1.0" : "0.0.0";
+var VERSION = true ? "0.1.1" : "0.0.0";
+function enqueueJob(state2, job) {
+  const jobs = jobsDir(state2);
+  mkdirSync7(jobs, { recursive: true, mode: 448 });
+  const f = path11.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
+  writeFileSync6(f, JSON.stringify(job), { mode: 384 });
+  return f;
+}
 function log(state2, line) {
   try {
-    mkdirSync7(state2, { recursive: true });
+    mkdirSync7(state2, { recursive: true, mode: 448 });
     const f = path11.join(state2, "log");
     try {
       if (statSync5(f).size > 1024 * 1024) renameSync2(f, `${f}.1`);
@@ -2452,8 +2610,8 @@ function factsState(state2) {
       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(path11.dirname(file(h, s)), { recursive: true, mode: 448 });
+      writeFileSync6(file(h, s), JSON.stringify(next), { mode: 384 });
     }
   };
 }
@@ -2478,12 +2636,14 @@ async function runJob(job, opts = {}) {
   if (!r || !r.session.id) return { events: [], delivered: {} };
   const outbox = new Outbox(state2);
   const ref = { harness: job.harness, session: r.session.id };
-  const release = takeLock(state2, ref);
+  let release = takeLock(state2, ref);
+  for (let wait = 50; !release && wait <= 3200; wait *= 2) {
+    await new Promise((res) => setTimeout(res, wait));
+    release = takeLock(state2, ref);
+  }
   if (!release) {
-    log(state2, `${job.harness} ${job.event}: session ${r.session.id} locked, re-queued`);
-    const jobs = path11.join(state2, "jobs");
-    mkdirSync7(jobs, { recursive: true });
-    writeFileSync6(path11.join(jobs, `${Date.now().toString(36)}-requeue.json`), JSON.stringify(job));
+    log(state2, `${job.harness} ${job.event}: session ${r.session.id} locked for 6 s, re-queued`);
+    enqueueJob(state2, job);
     return { events: [], delivered: {} };
   }
   try {
@@ -2547,7 +2707,10 @@ async function runJob(job, opts = {}) {
       if (read.turns.length)
         facts.save(job.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(
       state2,
       `${job.harness} ${job.event}: ${events.map((e) => e.type).join(",") || "nothing"} (${r.session.id.slice(0, 8)})`
@@ -2573,34 +2736,57 @@ async function flush(state2, sinkConfigs, outbox, first) {
     const cursors = new Cursors(state2, sink2.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 sink2.send(batch);
+      if (!res.ok) {
+        log(state2, `sink ${sink2.name}: ${res.status ?? ""} ${res.error ?? ""} \u2192 ${res.action ?? "retry"}`);
+        if (res.action === "pause" || res.action === "lower-tier") applySinkVerdict(sink2.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, sink2.tier, sink2.pii, { home: os2.homedir() })).filter((e) => !!e);
-        let ok = true;
-        if (filtered.length) {
-          const res = await sink2.send(filtered);
-          ok = res.ok;
-          if (!ok) {
-            log(state2, `sink ${sink2.name}: ${res.status ?? ""} ${res.error ?? ""} \u2192 ${res.action ?? "retry"}`);
-            if (res.action === "pause" || res.action === "lower-tier") applySinkVerdict(sink2.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, sink2.tier, sink2.pii, { home: os2.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[sink2.name] = sent;
   }
@@ -2725,9 +2911,23 @@ async function install() {
   if (viaNpx) {
     out(`  Installing sessionpipe@${VERSION} globally, so the hooks start in milliseconds\u2026`);
     try {
-      execFileSync3("npm", ["install", "-g", `sessionpipe@${VERSION}`], { stdio: ["ignore", "ignore", "inherit"] });
-      const bin = process.platform === "win32" ? "sessionpipe.cmd" : "sessionpipe";
-      execFileSync3(bin, args, { stdio: "inherit", shell: process.platform === "win32" });
+      let prefix = "";
+      try {
+        prefix = execFileSync4("npm", ["prefix", "-g"], {
+          encoding: "utf8",
+          timeout: 15e3,
+          stdio: ["ignore", "pipe", "ignore"]
+        }).trim();
+      } catch {
+      }
+      const target = /\/Cellar\/node(?:@\d+)?\/[^/]+/.test(prefix) ? path12.join(os3.homedir(), ".local") : prefix;
+      execFileSync4("npm", ["install", "-g", `sessionpipe@${VERSION}`, ...target ? ["--prefix", target] : []], {
+        stdio: ["ignore", "ignore", "inherit"]
+      });
+      const bin = process.platform === "win32" ? path12.join(target, "sessionpipe.cmd") : target ? path12.join(target, "bin", "sessionpipe") : "sessionpipe";
+      if (target && target !== prefix)
+        out(`  Installed into ${target}; make sure ${path12.join(target, "bin")} is on your PATH.`);
+      execFileSync4(bin, args, { stdio: "inherit", shell: process.platform === "win32" });
       return;
     } catch {
       out(
@@ -2739,6 +2939,8 @@ async function install() {
   const cfg = readConfig();
   const machine = flag("--machine");
   if (machine) cfg.machine = machine.slice(0, 80);
+  const sinkUrl = flag("--sink");
+  if (sinkUrl) await sinkAdd(sinkUrl, cfg);
   const adapters = selectedAdapters();
   if (!adapters.length) {
     out(
@@ -2747,24 +2949,13 @@ async function install() {
     return;
   }
   out(`  Machine: ${machineName(cfg, os3.hostname())}`);
-  const hc = hookCommand();
-  for (const a of adapters) {
-    const reports = a.install(hc);
-    cfg.harnesses[a.name] = { enabled: true };
-    for (const r of reports)
-      out(
-        `  ${r.changed ? "\u2713" : "="} ${a.name}: ${tilde(r.file)}${r.note ? ` \u2014 ${r.note}` : r.changed ? " written" : " already current"}`
-      );
-    if (a.name === "gemini-cli")
-      out("    note: Gemini CLI's own telemetry defaults logPrompts on; that is Google's setting, not sessionpipe's.");
-    if (a.name === "codex")
-      out(
-        "    note: Codex runs non-managed hooks only after you trust them: open Codex and run /hooks once. The notify fallback reports turn ends meanwhile."
-      );
-  }
+  const lean = isLean(cfg);
+  if (lean)
+    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);
   writeConfig(cfg);
-  const sinkUrl = flag("--sink");
-  if (sinkUrl) await sinkAdd(sinkUrl, cfg);
   const days = Number(flag("--backfill") ?? 30);
   if (days > 0) backfillRows(adapters, days, cfg);
   out("");
@@ -2776,10 +2967,41 @@ async function install() {
     );
   out("  Sessions already running pick up hooks on their next start (Claude Code \u2265 2.1.280 picks them up live).");
 }
+function isLean(cfg) {
+  return !cfg.sinks.some((s) => !s.paused && Math.min(s.tier, s.max_tier ?? 3) >= 1);
+}
+function installHarnesses(adapters, cfg, lean) {
+  const hc = hookCommand();
+  for (const a of adapters) {
+    const prev = cfg.harnesses[a.name] ?? {};
+    const created = new Set(prev.created ?? []);
+    const reports = a.install(hc, process.env, { lean, created: [...created] });
+    for (const r of reports) {
+      if (r.created) created.add(r.file);
+      const mark = r.skipped ? "!" : r.changed ? "\u2713" : "=";
+      out(
+        `  ${mark} ${a.name}: ${tilde(r.file)}${r.note ? ` \u2014 ${r.note}` : r.changed ? " written" : " already current"}`
+      );
+    }
+    cfg.harnesses[a.name] = { enabled: true, ...created.size ? { created: [...created] } : {} };
+    if (a.name === "gemini-cli")
+      out("    note: Gemini CLI's own telemetry defaults logPrompts on; that is Google's setting, not sessionpipe's.");
+    if (a.name === "codex" && !reports.some((r) => r.skipped))
+      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."
+      );
+  }
+}
 function uninstall() {
+  const cfg = readConfig();
   for (const a of ADAPTERS) {
-    for (const r of a.uninstall()) if (r.changed) out(`  \u2713 ${a.name}: hooks removed from ${tilde(r.file)}`);
+    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}`);
+    delete cfg.harnesses[a.name];
   }
+  writeConfig(cfg);
   if (!has("--keep-state"))
     out(
       `  Outbox and state kept under ${tilde(state)} (delete it yourself, or pass nothing: it prunes after ${readConfig().keep_days ?? 30} days).`
@@ -2810,16 +3032,17 @@ async function sink() {
     if (!s) return out(`  no sink named ${args[2]}`);
     const [sk] = buildSinks([s]);
     if (!sk) return out("  sink type not supported yet");
-    const e = makeEvent(
-      { type: "session.heartbeat", harnessEvent: "test", data: {} },
-      {
-        harness: { name: "sessionpipe" },
-        session: { id: `test-${Date.now()}`, seq: 0, machine: machineName(cfg, os3.hostname()) }
-      }
+    const session = { id: `test-${Date.now()}`, machine: machineName(cfg, os3.hostname()) };
+    const mk = (type, seq) => makeEvent(
+      { type, harnessEvent: "test", data: {} },
+      { harness: { name: "sessionpipe" }, session: { ...session, seq } }
     );
-    const r = await sk.send([filterEvent(e, sk.tier, sk.pii)]);
+    const r = await sk.send([
+      filterEvent(mk("session.heartbeat", 0), sk.tier, sk.pii),
+      filterEvent(mk("session.forgotten", 1), sk.tier, sk.pii)
+    ]);
     out(
-      r.ok ? `  \u2713 ${s.name}: ${r.status ?? "ok"} accepted ${r.accepted ?? 1}` : `  \u2717 ${s.name}: ${r.status ?? ""} ${r.error ?? ""} (${r.action})`
+      r.ok ? `  \u2713 ${s.name}: ${r.status ?? "ok"} accepted ${r.accepted ?? 2} (a heartbeat and its forget)` : `  \u2717 ${s.name}: ${r.status ?? ""} ${r.error ?? ""} (${r.action})`
     );
     return;
   }
@@ -2946,7 +3169,10 @@ function status() {
   out(`  machine:  ${machineName(cfg, os3.hostname())}   sessionpipe ${VERSION}   state ${tilde(state)}`);
   for (const a of ADAPTERS) {
     if (!a.detect() && !cfg.harnesses[a.name]) continue;
-    for (const r of a.installed(hc)) out(`  ${a.name.padEnd(12)} ${tilde(r.file).padEnd(44)} ${r.state}`);
+    for (const r of a.installed(hc, process.env, { lean: isLean(cfg) }))
+      out(
+        `  ${a.name.padEnd(12)} ${tilde(r.file).padEnd(44)} ${r.state}${r.state !== "current" && r.note ? ` \u2014 ${r.note}` : ""}`
+      );
   }
   if (!cfg.sinks.length) out("  sinks:    none (events stay in the local outbox)");
   for (const s of cfg.sinks) {
@@ -2965,14 +3191,49 @@ function status() {
     );
   }
   const t = timing();
-  if (t) out(`  hook:     p50 ${t.p50} ms \xB7 p95 ${t.p95} ms over ${t.n} runs`);
+  if (t)
+    out(
+      `  hook:     in-process p50 ${t.p50} ms over ${t.n} runs (\`sessionpipe doctor\` measures the wall clock the harness waits)`
+    );
   const jobs = jobsDir(state);
   try {
-    const n = readdirSync6(jobs).length;
+    const n = readdirSync7(jobs).length;
     if (n) out(`  jobs:     ${n} waiting`);
   } catch {
   }
 }
+function hookWall(runs = 8) {
+  const hook = path12.join(distDir, "hook.js");
+  const tmp = mkdtempSync(path12.join(os3.tmpdir(), "sessionpipe-doctor-"));
+  const env = {
+    ...process.env,
+    SESSIONPIPE_STATE: tmp,
+    SESSIONPIPE_CONFIG: path12.join(tmp, "config.json"),
+    SESSIONPIPE_NO_WORKER: "1"
+  };
+  const input = JSON.stringify({
+    session_id: "doctor",
+    hook_event_name: "PostToolUse",
+    tool_name: "Bash",
+    cwd: process.cwd()
+  });
+  const times = [];
+  try {
+    for (let i = 0; i < runs; i++) {
+      const t0 = process.hrtime.bigint();
+      const r = spawnSync(process.execPath, [hook, "claude-code", "PostToolUse"], { input, env, encoding: "utf8" });
+      if (r.status !== 0) return null;
+      times.push(Number(process.hrtime.bigint() - t0) / 1e6);
+    }
+  } catch {
+    return null;
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+  times.sort((a, b) => a - b);
+  const q = (p) => Math.round(times[Math.min(times.length - 1, Math.floor(p * times.length))] ?? 0);
+  return { n: times.length, p50: q(0.5), p95: q(0.95) };
+}
 function timing() {
   try {
     const lines = readFileSync9(path12.join(state, "timing.jsonl"), "utf8").trim().split("\n").slice(-100);
@@ -2997,6 +3258,7 @@ function doctor() {
     harnesses: {},
     sinks: [],
     timing: timing(),
+    hook_wall_ms: hookWall(),
     warnings: []
   };
   const warnings = report.warnings;
@@ -3006,8 +3268,15 @@ function doctor() {
     );
   for (const a of ADAPTERS) {
     if (!a.detect()) continue;
-    const st = a.installed(hc);
-    report.harnesses[a.name] = st.map((r) => ({ file: tilde(r.file), state: r.state }));
+    const st = a.installed(hc, process.env, { lean: isLean(cfg) });
+    report.harnesses[a.name] = st.map((r) => ({
+      file: tilde(r.file),
+      state: r.state,
+      ...r.note ? { note: r.note } : {}
+    }));
+    for (const r of st)
+      if (r.state === "inactive")
+        warnings.push(`${a.name}: hooks are written but the harness will not run them \u2014 ${r.note ?? ""}`);
     for (const r of st)
       if (r.state === "stale")
         warnings.push(
@@ -3030,9 +3299,11 @@ function doctor() {
       paused: s.paused ?? null,
       token: s.token ? `${s.token.slice(0, 4)}\u2026` : null
     });
-  const t = timing();
-  if (t && t.p50 > 150)
-    warnings.push(`hook p50 is ${t.p50} ms (target < 150). Is node on a slow disk or a network share?`);
+  const w = report.hook_wall_ms;
+  if (w && w.p50 > 150)
+    warnings.push(
+      `the harness waits ${w.p50} ms per hook (p50, target < 150): that is Node's own startup on this machine. A lean install (no sink above tier 0) hooks fewer events.`
+    );
   if (has("--json")) {
     out(JSON.stringify(report, null, 2));
     return;
@@ -3045,8 +3316,14 @@ function doctor() {
     out(
       `  sink ${s.name.padEnd(16)} tier ${s.tier}${s.max_tier !== null ? ` (receiver max ${s.max_tier})` : ""}${s.paused ? ` PAUSED ${s.paused}` : ""}`
     );
-  out(t ? `  hook p50 ${t.p50} ms \xB7 p95 ${t.p95} ms over ${t.n} runs` : "  hook timing: no runs yet");
-  for (const w of warnings) out(`  ! ${w}`);
+  const t = report.timing;
+  out(
+    w ? `  hook wall clock (what the harness waits): p50 ${w.p50} ms \xB7 p95 ${w.p95} ms over ${w.n} spawns` : "  hook wall clock: could not spawn dist/hook.js"
+  );
+  out(
+    t ? `  hook in-process: p50 ${t.p50} ms \xB7 p95 ${t.p95} ms over the last ${t.n} runs` : "  hook in-process: no runs yet"
+  );
+  for (const w2 of warnings) out(`  ! ${w2}`);
   if (!warnings.length) out("  no warnings");
 }
 async function tail() {
@@ -3120,7 +3397,7 @@ async function workerFromArgv() {
   if (!f) return;
   const job = JSON.parse(readFileSync9(f, "utf8"));
   try {
-    unlinkSync2(f);
+    unlinkSync5(f);
   } catch {
   }
   await runJob(job);
@@ -3134,7 +3411,7 @@ async function update() {
     if (j.version === VERSION) return out(`  sessionpipe ${VERSION} is current`);
     out(`  ${j.version} is available (you run ${VERSION}); installing into this copy's prefix\u2026`);
     const prefix = prefixOf(distDir);
-    execFileSync3("npm", ["install", "-g", `sessionpipe@${j.version}`, ...prefix ? ["--prefix", prefix] : []], {
+    execFileSync4("npm", ["install", "-g", `sessionpipe@${j.version}`, ...prefix ? ["--prefix", prefix] : []], {
       stdio: "inherit"
     });
     out("  re-arming hooks\u2026");