sessionpipe 0.1.0

package/dist/cli.js

@@ -0,0 +1,3158 @@
+#!/usr/bin/env node
+// sessionpipe 0.1.0 · 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 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 path4 from "node:path";
+
+// ../core/src/paths.ts
+import os from "node:os";
+import path from "node:path";
+var HOME = os.homedir();
+function configFile(env = process.env) {
+  if (env.SESSIONPIPE_CONFIG) return path.resolve(env.SESSIONPIPE_CONFIG);
+  if (process.platform === "win32")
+    return path.join(env.APPDATA || path.join(HOME, "AppData", "Roaming"), "sessionpipe", "config.json");
+  return path.join(env.XDG_CONFIG_HOME || path.join(HOME, ".config"), "sessionpipe", "config.json");
+}
+function stateDir(env = process.env) {
+  if (env.SESSIONPIPE_STATE) return path.resolve(env.SESSIONPIPE_STATE);
+  if (process.platform === "win32")
+    return path.join(env.LOCALAPPDATA || path.join(HOME, "AppData", "Local"), "sessionpipe");
+  return path.join(env.XDG_STATE_HOME || path.join(HOME, ".local", "state"), "sessionpipe");
+}
+function tilde(p, home = HOME) {
+  if (!p) return p;
+  if (p === home) return "~";
+  return p.startsWith(home + path.sep) || p.startsWith(`${home}/`) ? `~${p.slice(home.length)}` : p;
+}
+var safeId = (s) => String(s).replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 160);
+
+// ../core/src/readers/files.ts
+import { closeSync, fstatSync, openSync, readdirSync, readSync, statSync } from "node:fs";
+import path2 from "node:path";
+function ends(file, headBytes, tailBytes) {
+  let fd;
+  try {
+    fd = openSync(file, "r");
+    const size = fstatSync(fd).size;
+    const read = (pos, len) => {
+      const b = Buffer.alloc(len);
+      const n = readSync(fd, b, 0, len, pos);
+      return b.subarray(0, n).toString("utf8");
+    };
+    const head = read(0, Math.min(size, headBytes));
+    const tail2 = size > headBytes ? read(Math.max(0, size - tailBytes), Math.min(size, tailBytes)) : head;
+    return { head: head.split("\n").slice(0, -1), tail: tail2.split("\n").slice(size > headBytes ? 1 : 0) };
+  } catch {
+    return { head: [], tail: [] };
+  } finally {
+    if (fd !== void 0)
+      try {
+        closeSync(fd);
+      } catch {
+      }
+  }
+}
+var parseLines = (lines) => lines.map((l) => {
+  try {
+    return JSON.parse(l);
+  } catch {
+    return null;
+  }
+}).filter((x) => !!x);
+function scanLines(file, visit, cap2 = 16 * 1024 * 1024) {
+  let fd;
+  try {
+    fd = openSync(file, "r");
+    const buf = Buffer.alloc(1024 * 1024);
+    let pos = 0;
+    let rest = Buffer.alloc(0);
+    while (pos < cap2) {
+      const n = readSync(fd, buf, 0, buf.length, pos);
+      if (!n) break;
+      pos += n;
+      let chunk = Buffer.concat([rest, buf.subarray(0, n)]);
+      let nl = chunk.indexOf(10);
+      while (nl >= 0) {
+        const r = visit(chunk.subarray(0, nl).toString("utf8"));
+        if (r !== null) return r;
+        chunk = chunk.subarray(nl + 1);
+        nl = chunk.indexOf(10);
+      }
+      rest = chunk;
+    }
+  } catch {
+  } finally {
+    if (fd !== void 0)
+      try {
+        closeSync(fd);
+      } catch {
+      }
+  }
+  return null;
+}
+function recentFiles(root, depth, sinceMs, match) {
+  const out2 = [];
+  const walk = (dir, d) => {
+    let names = [];
+    try {
+      names = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of names) {
+      const p = path2.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (d < depth) walk(p, d + 1);
+        continue;
+      }
+      if (!match(e.name)) continue;
+      try {
+        if (statSync(p).mtimeMs >= sinceMs) out2.push(p);
+      } catch {
+      }
+    }
+  };
+  walk(root, 0);
+  return out2;
+}
+
+// ../core/src/readers/transcripts.ts
+function pairTurns(msgs, endLine) {
+  const turns = [];
+  let cur = null;
+  for (const m of msgs) {
+    if (m.role === "user") {
+      if (cur && !cur.assistant) {
+        cur.user += `
+
+${m.text}`;
+        continue;
+      }
+      if (cur) turns.push(cur);
+      cur = { user: m.text, assistant: "", at: m.at, startLine: m.line, endLine: m.line };
+    } else {
+      if (!cur) cur = { user: "", assistant: "", at: m.at, startLine: m.line, endLine: m.line };
+      cur.assistant += (cur.assistant ? "\n\n" : "") + m.text;
+      cur.endLine = m.line;
+    }
+  }
+  if (cur?.assistant) turns.push(cur);
+  const line = cur && !cur.assistant ? cur.startLine : endLine;
+  return { turns: turns.map((t) => ({ user: t.user, assistant: t.assistant, at: t.at, endLine: t.endLine })), line };
+}
+var isInjected = (text) => /^<[a-z_-]+>/i.test(text) && /<\/[a-z_-]+>\s*$/i.test(text) || /^<!--\s/.test(text) || /^<command-/.test(text);
+var endOf = (lines) => lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+var parse = (raw) => {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var textParts = (c, kinds) => {
+  if (typeof c === "string") return c;
+  if (!Array.isArray(c)) return "";
+  return c.filter(
+    (b) => b && typeof b === "object" && kinds.includes(b.type ?? "") && typeof b.text === "string"
+  ).map((b) => b.text).join("\n");
+};
+function readClaude(lines, from) {
+  const msgs = [];
+  for (let i = from; i < lines.length; i++) {
+    const j = lines[i] ? parse(lines[i]) : null;
+    if (!j || j.isSidechain) continue;
+    const origin = j.origin;
+    if (j.type === "user" && (j.isMeta || origin?.kind && origin.kind !== "human")) continue;
+    const at = Date.parse(String(j.timestamp ?? "")) || Date.now();
+    const c = j.message?.content;
+    if (j.type === "user") {
+      const text = textParts(c, ["text"]).trim();
+      if (!text || isInjected(text)) continue;
+      msgs.push({ role: "user", text, at, line: i });
+    } else if (j.type === "assistant" && Array.isArray(c)) {
+      const text = textParts(c, ["text"]).trim();
+      if (text) msgs.push({ role: "assistant", text, at, line: i });
+    }
+  }
+  return pairTurns(msgs, endOf(lines));
+}
+function readCodex(lines, from) {
+  const msgs = [];
+  for (let i = from; i < lines.length; i++) {
+    const j = lines[i] ? parse(lines[i]) : null;
+    if (!j || j.type !== "response_item") continue;
+    const p = j.payload;
+    if (!p || p.type !== "message") continue;
+    const at = Date.parse(String(j.timestamp ?? "")) || Date.now();
+    const text = textParts(p.content, ["input_text", "output_text"]).trim();
+    if (!text) continue;
+    if (p.role === "user") {
+      if (/^<[a-z_-]+>/i.test(text)) continue;
+      msgs.push({ role: "user", text, at, line: i });
+    } else if (p.role === "assistant") msgs.push({ role: "assistant", text, at, line: i });
+  }
+  return pairTurns(msgs, endOf(lines));
+}
+function readGemini(lines, from) {
+  const msgs = [];
+  for (let i = from; i < lines.length; i++) {
+    const j = lines[i] ? parse(lines[i]) : null;
+    if (!j) continue;
+    const role = j.type === "user" ? "user" : j.type === "gemini" || j.type === "model" ? "assistant" : null;
+    if (!role) continue;
+    const raw = j.content ?? j.message ?? j.text;
+    const text = (typeof raw === "string" ? raw : textParts(raw, ["text"])).trim();
+    if (!text) continue;
+    const at = Date.parse(String(j.timestamp ?? "")) || Date.now();
+    msgs.push({ role, text, at, line: i });
+  }
+  return pairTurns(msgs, endOf(lines));
+}
+function readAntigravity(lines, from) {
+  const msgs = [];
+  for (let i = from; i < lines.length; i++) {
+    const j = lines[i] ? parse(lines[i]) : null;
+    if (!j || typeof j.content !== "string") continue;
+    const at = Date.parse(String(j.created_at ?? j.timestamp ?? "")) || Date.now();
+    if (j.type === "USER_INPUT") {
+      const m = /<USER_REQUEST>([\s\S]*?)(?:<\/USER_REQUEST>|$)/.exec(j.content);
+      const text = (m ? m[1] ?? "" : j.content).trim();
+      if (text) msgs.push({ role: "user", text, at, line: i });
+    } else if (j.type === "PLANNER_RESPONSE") {
+      const text = j.content.trim();
+      if (text) msgs.push({ role: "assistant", text, at, line: i });
+    }
+  }
+  return pairTurns(msgs, endOf(lines));
+}
+
+// ../core/src/adapters/claude-shaped.ts
+import { existsSync, mkdirSync, readFileSync, 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) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function entryFor(event, harness, cmd2, o) {
+  const matcher = o.matcherFor(event);
+  return {
+    ...matcher !== void 0 ? { matcher } : {},
+    hooks: [{ type: "command", command: cmd2([harness, event]).command, timeout: o.timeout }]
+  };
+}
+function installClaudeShaped(file, harness, events, cmd2, o) {
+  const settings2 = readJson(file);
+  const hooks = settings2.hooks && typeof settings2.hooks === "object" ? settings2.hooks : {};
+  let changed = false;
+  for (const ev of events) {
+    const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
+    const entry2 = entryFor(ev, harness, cmd2, o);
+    const mine = list.filter((h) => isOurs(h));
+    if (mine.length === 1 && JSON.stringify(mine[0]) === JSON.stringify(entry2)) continue;
+    hooks[ev] = list.filter((h) => !isOurs(h)).concat([entry2]);
+    changed = true;
+  }
+  if (o.top) {
+    for (const [k, v] of Object.entries(o.top))
+      if (settings2[k] !== v) {
+        settings2[k] = v;
+        changed = true;
+      }
+  }
+  if (changed) {
+    settings2.hooks = hooks;
+    mkdirSync(path3.dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify(settings2, null, 2)}
+`);
+  }
+  return { file, changed };
+}
+function uninstallClaudeShaped(file, events) {
+  if (!existsSync(file)) return { file, changed: false };
+  const raw = readFileSync(file, "utf8");
+  const settings2 = readJson(file);
+  const hooks = settings2.hooks;
+  if (!hooks || typeof hooks !== "object") return { file, changed: false };
+  let changed = false;
+  for (const ev of events) {
+    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];
+    }
+  }
+  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);
+  return { file, changed: true };
+}
+function installedClaudeShaped(file, harness, events, cmd2, o) {
+  const hooks = readJson(file).hooks ?? {};
+  let present = 0;
+  let current = 0;
+  for (const ev of events) {
+    const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
+    const mine = list.filter((h) => isOurs(h));
+    if (mine.length) present++;
+    if (mine.length === 1 && JSON.stringify(mine[0]) === JSON.stringify(entryFor(ev, harness, cmd2, o))) current++;
+  }
+  if (!present) return "missing";
+  return current === events.length ? "current" : "stale";
+}
+
+// ../core/src/adapters/antigravity.ts
+var NAME = "antigravity";
+var HOOK_NAME = "sessionpipe";
+var AG_EVENTS = ["PreInvocation", "PostInvocation", "PreToolUse", "PostToolUse", "Stop"];
+var gemini = (env) => env.GEMINI_CLI_HOME || path4.join(HOME, ".gemini");
+var hooksFile = (env) => path4.join(gemini(env), "config", "hooks.json");
+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) {
+  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)];
+  return out2;
+}
+var antigravity = {
+  name: NAME,
+  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) {
+    const file = hooksFile(env);
+    const hooks = readJson(file);
+    const e = entry(cmd2);
+    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)}
+`);
+    return [
+      { file, changed: true, note: "hooks.json is read when a conversation starts; open ones report after a restart" }
+    ];
+  },
+  uninstall(env = process.env) {
+    const file = hooksFile(env);
+    if (!existsSync2(file)) return [{ file, changed: false }];
+    const hooks = readJson(file);
+    if (!(HOOK_NAME in hooks)) return [{ file, changed: false }];
+    delete hooks[HOOK_NAME];
+    writeFileSync2(file, `${JSON.stringify(hooks, null, 2)}
+`);
+    return [{ file, changed: true }];
+  },
+  installed(cmd2, env = process.env) {
+    const file = hooksFile(env);
+    const have = readJson(file)[HOOK_NAME];
+    return [
+      { file, state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd2)) ? "current" : "stale" }
+    ];
+  },
+  fromHook(input) {
+    const event = input.argv[1] ?? "";
+    let s = {};
+    try {
+      s = input.stdin ? JSON.parse(input.stdin) : {};
+    } catch {
+    }
+    const id = s.conversationId ?? s.session_id ?? s.sessionId;
+    if (!id) return { session: { id: "" }, events: [], stdout: "{}\n" };
+    const workspaces = agWorkspaces(s.workspacePaths);
+    const session = { id: String(id), cwd: workspaces[0] ?? input.cwd };
+    if (typeof s.modelName === "string" && s.modelName !== "auto") session.model = s.modelName;
+    const toolCall = s.toolCall;
+    const tool = validTool(toolCall?.name) ? toolCall?.name : validTool(s.toolName) ? s.toolName : void 0;
+    const ev = (type, data) => ({ type, data: prune(data), harnessEvent: event });
+    const events = [];
+    switch (event) {
+      case "PreInvocation":
+        if (Number(s.invocationNum) === 0 || s.invocationNum === void 0) {
+          events.push(ev("session.started", { source: "unknown" }));
+          events.push(ev("turn.started", {}));
+        } else events.push(ev("session.heartbeat", {}));
+        break;
+      case "PostInvocation":
+        break;
+      case "PreToolUse":
+        if (tool) events.push(ev("tool.started", { tool, input: toolCall?.args }));
+        break;
+      case "PostToolUse":
+        if (tool)
+          events.push(
+            ev("tool.ended", {
+              tool,
+              ok: !s.error,
+              error: typeof s.error === "string" ? s.error.slice(0, 2e3) : void 0,
+              input: toolCall?.args
+            })
+          );
+        break;
+      case "Stop":
+        events.push(ev("turn.ended", { reason: s.error ? "error" : "stop" }));
+        break;
+      default:
+        return { session, events: [], stdout: "{}\n" };
+    }
+    const r = { session, events, stdout: "{}\n", hints: { workspaces } };
+    if (typeof s.transcriptPath === "string") r.transcript = s.transcriptPath;
+    return r;
+  },
+  readTranscript(file, fromLine) {
+    let text = "";
+    try {
+      text = readFileSync2(file, "utf8");
+    } catch {
+      return { turns: [], line: fromLine };
+    }
+    return readAntigravity(text.split("\n"), fromLine);
+  },
+  facts(session, transcript, hints, state2) {
+    if (!transcript) return {};
+    return antigravityFacts(transcript, {
+      conversation: session.id,
+      workspaces: hints.workspaces ?? (session.cwd ? [session.cwd] : []),
+      state: state2,
+      env: process.env
+    });
+  },
+  backfill(sinceMs, env = process.env) {
+    const rows = [];
+    const noState = { get: () => ({}), save: () => {
+    } };
+    for (const data of dataDirs(env)) {
+      let ids = [];
+      try {
+        ids = readdirSync2(path4.join(data, "brain")).filter((n) => /^[0-9a-f-]{36}$/i.test(n));
+      } catch {
+      }
+      for (const id of ids) {
+        const f = path4.join(data, "brain", id, ".system_generated", "logs", "transcript.jsonl");
+        try {
+          if (statSync2(f).mtimeMs < sinceMs) continue;
+        } catch {
+          continue;
+        }
+        const facts = antigravityFacts(f, { conversation: id, workspaces: [], state: noState, env });
+        if (!facts.started_at || !facts.last_at) continue;
+        const { started_at, last_at, first_ask: _fa, harness_version: _hv, ...rest } = facts;
+        rows.push({ session: { id, ...rest }, started_at, last_at });
+      }
+    }
+    return rows;
+  }
+};
+function prune(o) {
+  for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
+  return o;
+}
+function agPath(p) {
+  if (typeof p !== "string" || !p) return null;
+  let s = p;
+  if (/^file:/i.test(s)) {
+    try {
+      s = decodeURIComponent(new URL(s).pathname);
+    } catch {
+      return null;
+    }
+    if (process.platform === "win32" && /^\/[A-Za-z]:/.test(s)) s = s.slice(1);
+  } else if (/^[a-z][a-z0-9+.-]*:\/\//i.test(s)) return null;
+  if (!path4.isAbsolute(s)) return null;
+  return path4.resolve(s);
+}
+var agWorkspaces = (paths) => (Array.isArray(paths) ? paths : []).map(agPath).filter((p) => !!p).filter((p, i, a) => a.indexOf(p) === i);
+function agVariants(p) {
+  const out2 = [p];
+  try {
+    const r = realpathSync.native(p);
+    if (r !== p) out2.push(r);
+  } catch {
+  }
+  return out2;
+}
+function agProjects(dir) {
+  const out2 = [];
+  let names = [];
+  try {
+    names = readdirSync2(dir).filter((n) => n.endsWith(".json"));
+  } catch {
+    return out2;
+  }
+  for (const n of names) {
+    const id = n.slice(0, -5);
+    if (!ID_RE.test(id)) continue;
+    let j;
+    try {
+      j = JSON.parse(readFileSync2(path4.join(dir, n), "utf8"));
+    } catch {
+      continue;
+    }
+    const folders = [];
+    for (const r of j?.projectResources?.resources ?? []) {
+      const f = agPath(r?.folderUri);
+      if (f) folders.push(...agVariants(f));
+    }
+    if (folders.length) out2.push({ id, folders });
+  }
+  return out2;
+}
+function agMatchProject(projects, workspaces) {
+  const ws = [];
+  for (const w of workspaces) {
+    const p = agPath(w);
+    if (p) ws.push(...agVariants(p));
+  }
+  let best = null;
+  let bestLen = -1;
+  for (const pr of projects)
+    for (const f of pr.folders) {
+      const within = ws.some((w) => w === f || w.startsWith(f.endsWith(path4.sep) ? f : f + path4.sep));
+      if (within && f.length > bestLen) {
+        best = pr.id;
+        bestLen = f.length;
+      }
+    }
+  return best;
+}
+function antigravityRemoteUrl(transcript, opts) {
+  const i = transcript.indexOf(`${path4.sep}brain${path4.sep}`);
+  const dirs = (i > 0 ? [transcript.slice(0, i)] : []).concat(dataDirs(opts.env));
+  for (const d of dirs) {
+    try {
+      const m = /installation_uuid:\s*"([0-9a-f-]{36})"/i.exec(
+        readFileSync2(path4.join(d, "antigravity_state.pbtxt"), "utf8")
+      );
+      if (!m) continue;
+      const base = `https://antigravity.google.com/r/${m[1]}-v2`;
+      const conv = opts.conversation ?? "";
+      if (!ID_RE.test(conv) || !opts.workspaces?.length) return base;
+      const project = agMatchProject(agProjects(opts.projectsDir ?? projectsDir(opts.env)), opts.workspaces);
+      return project ? `${base}?p=${encodeURIComponent(`c/${conv}?section=${project}`)}` : base;
+    } catch {
+    }
+  }
+  return null;
+}
+function antigravityFacts(file, opts) {
+  const { head, tail: tail2 } = ends(file, 128 * 1024, 64 * 1024);
+  const H = parseLines(head);
+  const T = parseLines(tail2);
+  const out2 = {};
+  const url = antigravityRemoteUrl(file, opts);
+  if (url) out2.url = url;
+  for (const j of H) {
+    if (j.type !== "USER_INPUT" || typeof j.content !== "string") continue;
+    const m = /<USER_REQUEST>([\s\S]*?)(?:<\/USER_REQUEST>|$)/.exec(j.content);
+    const text = (m ? m[1] ?? "" : j.content).trim();
+    const line = (text.split("\n").find((l) => l.trim()) ?? "").trim();
+    if (!line || /^<[a-z_-]+>/i.test(line)) continue;
+    out2.title = line.length > 80 ? `${line.slice(0, 80).replace(/\s+\S*$/, "")}\u2026` : line;
+    out2.title_source = "first-ask";
+    break;
+  }
+  const times = H.concat(T).map((j) => Date.parse(String(j.created_at ?? j.timestamp ?? ""))).filter((n) => n > 0);
+  if (times.length) {
+    out2.started_at = Math.min(...times);
+    out2.last_at = Math.max(...times);
+  }
+  return out2;
+}
+
+// ../core/src/adapters/claude-code.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
+import path5 from "node:path";
+
+// ../core/src/readers/git.ts
+import { execFileSync } from "node:child_process";
+var cache = /* @__PURE__ */ new Map();
+function gitFacts(cwd) {
+  if (!cwd) return {};
+  const hit = cache.get(cwd);
+  if (hit) return hit;
+  const run = (args2) => {
+    try {
+      return execFileSync("git", ["-C", cwd, ...args2], {
+        encoding: "utf8",
+        timeout: 1500,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+      return "";
+    }
+  };
+  const out2 = {};
+  const repo = run(["remote", "get-url", "origin"]);
+  if (repo) out2.repo = stripCredentials(repo);
+  const branch = run(["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (branch && branch !== "HEAD") out2.branch = branch;
+  cache.set(cwd, out2);
+  return out2;
+}
+function stripCredentials(url) {
+  let u = url.replace(/\/\/[^/@]*@/, "//");
+  const ssh = /^(?:ssh:\/\/)?git@([^:/]+)[:/](.+?)(?:\.git)?$/.exec(u);
+  if (ssh) u = `${ssh[1]}/${ssh[2]}`;
+  return u.replace(/^https?:\/\//, "").replace(/\.git$/, "");
+}
+
+// ../core/src/adapters/claude-code.ts
+var NAME2 = "claude-code";
+var CLAUDE_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "PermissionRequest",
+  "Notification",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "PostCompact",
+  "SessionEnd"
+];
+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) {
+  const out2 = [];
+  const add = (d) => {
+    if (!d) return;
+    const r = path5.resolve(d);
+    if (!out2.includes(r)) out2.push(r);
+  };
+  add(path5.join(home, ".claude"));
+  add(env.CLAUDE_CONFIG_DIR);
+  try {
+    for (const e of readdirSync3(home, { withFileTypes: true })) {
+      if (!e.isDirectory() || !/^\.claude[-_.]/.test(e.name)) continue;
+      const d = path5.join(home, e.name);
+      if (existsSync3(path5.join(d, "projects")) || existsSync3(path5.join(d, "settings.json"))) add(d);
+    }
+  } catch {
+  }
+  return out2.filter((d, i) => i === 0 || existsSync3(d));
+}
+var settingsIn = (dir) => path5.join(dir, "settings.json");
+var configDirOf = (transcript) => path5.dirname(path5.dirname(path5.dirname(transcript)));
+var validTool2 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
+var endReason = (r) => r === "clear" || r === "logout" || r === "exit" ? r : r === "prompt_input_exit" ? "exit" : "other";
+var notifKind = (t) => t === "permission_prompt" ? "permission" : t === "idle_prompt" ? "idle" : t === "elicitation_dialog" ? "elicitation" : "question";
+var claudeCode = {
+  name: NAME2,
+  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) => ({
+    file: settingsIn(d),
+    state: installedClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd2, OPTS)
+  })),
+  fromHook(input) {
+    const event = input.argv[1] ?? "";
+    let s = {};
+    try {
+      s = input.stdin ? JSON.parse(input.stdin) : {};
+    } catch {
+    }
+    const id = s.session_id ?? s.sessionId;
+    if (!id) return null;
+    const session = { id: String(id), cwd: typeof s.cwd === "string" ? s.cwd : input.cwd };
+    if (typeof s.model === "string") session.model = s.model;
+    if (typeof s.agent_id === "string" && event.startsWith("Subagent") === false && s.agent_id)
+      session.parent_id = null;
+    const turn_id = typeof s.prompt_id === "string" ? s.prompt_id : void 0;
+    const tool = validTool2(s.tool_name) ? s.tool_name : void 0;
+    const call_id = typeof s.tool_use_id === "string" ? s.tool_use_id : void 0;
+    const ms = typeof s.duration_ms === "number" ? Math.round(s.duration_ms) : void 0;
+    const agent_id = typeof s.agent_id === "string" ? s.agent_id : void 0;
+    const permissionId = () => `perm-${createHash("sha256").update(`${turn_id ?? ""}|${tool ?? ""}|${JSON.stringify(s.tool_input ?? null)}`).digest("hex").slice(0, 16)}`;
+    const ev = (type, data) => ({ type, data: prune2(data), harnessEvent: event });
+    const events = [];
+    switch (event) {
+      case "SessionStart":
+        events.push(ev("session.started", { source: pickSource(s.source ?? s.trigger) }));
+        break;
+      case "UserPromptSubmit":
+        events.push(
+          ev("turn.started", {
+            turn_id,
+            prompt_chars: typeof s.prompt === "string" ? [...s.prompt].length : void 0
+          })
+        );
+        break;
+      case "PreToolUse":
+        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,
+              agent_id,
+              ms,
+              ok: true,
+              input: s.tool_input,
+              output: s.tool_response
+            })
+          );
+        break;
+      case "PostToolUseFailure":
+        if (tool)
+          events.push(
+            ev("tool.ended", {
+              tool,
+              call_id,
+              turn_id,
+              agent_id,
+              ms,
+              ok: false,
+              error: errText(s.error ?? s.tool_response),
+              input: s.tool_input,
+              output: s.tool_response
+            })
+          );
+        break;
+      case "PermissionRequest":
+        events.push(
+          ev("attention.needed", {
+            attention_id: call_id ?? permissionId(),
+            kind: "permission",
+            tool,
+            message: tool ? `${tool}${describe(s.tool_input)}` : void 0
+          })
+        );
+        break;
+      case "Notification":
+        events.push(
+          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
+          })
+        );
+        break;
+      case "Stop":
+        events.push(ev("turn.ended", { turn_id, reason: "stop" }));
+        break;
+      case "SubagentStart":
+        events.push(
+          ev("subagent.started", {
+            agent_id: String(s.agent_id ?? ""),
+            agent_type: typeof s.agent_type === "string" ? s.agent_type : void 0
+          })
+        );
+        break;
+      case "SubagentStop":
+        events.push(
+          ev("subagent.ended", {
+            agent_id: String(s.agent_id ?? ""),
+            agent_type: typeof s.agent_type === "string" ? s.agent_type : void 0
+          })
+        );
+        break;
+      case "PreCompact":
+        events.push(ev("context.compacted", { trigger: s.trigger === "manual" ? "manual" : "auto" }));
+        break;
+      case "PostCompact":
+        break;
+      // PreCompact already said it; a second event would double-count
+      case "SessionEnd":
+        events.push(ev("session.ended", { reason: endReason(s.reason) }));
+        break;
+      default:
+        return null;
+    }
+    const hints = {};
+    const host = input.env.CLAUDE_CODE_HOST_SESSION_ID;
+    if (host && DESKTOP_ID.test(host)) hints.desktop_id = host;
+    if (event !== "PreToolUse" && event !== "PostToolUse") hints.claude_pid = claudePid(input.env);
+    const r = { session, events, hints };
+    if (typeof s.transcript_path === "string") r.transcript = s.transcript_path;
+    return r;
+  },
+  readTranscript(file, fromLine) {
+    let text = "";
+    try {
+      text = readFileSync3(file, "utf8");
+    } catch {
+      return { turns: [], line: fromLine };
+    }
+    return readClaude(text.split("\n"), fromLine);
+  },
+  facts(session, transcript, hints, state2) {
+    const out2 = {};
+    if (transcript) Object.assign(out2, claudeFacts(transcript, session.id, hints, state2));
+    const cwd = out2.cwd ?? session.cwd;
+    Object.assign(out2, gitFacts(cwd), out2.branch ? { branch: out2.branch } : {});
+    if (!out2.url && typeof hints.desktop_id === "string") out2.url = `claude://code/continue/${hints.desktop_id}`;
+    return out2;
+  },
+  backfill(sinceMs, env = process.env) {
+    const rows = [];
+    const files = [];
+    for (const d of claudeDirs(env))
+      files.push(...recentFiles(path5.join(d, "projects"), 1, sinceMs, (n) => /^[0-9a-f-]{36}\.jsonl$/.test(n)));
+    const noState = { get: () => ({}), save: () => {
+    } };
+    for (const f of files) {
+      const id = path5.basename(f, ".jsonl");
+      const facts = claudeFacts(f, id, {}, noState);
+      if (!facts.started_at || !facts.last_at) continue;
+      const { started_at, last_at, first_ask: _fa, harness_version: _hv, ...rest } = facts;
+      const cwd = rest.cwd;
+      rows.push({
+        session: { id, ...rest, ...gitFacts(cwd), ...rest.branch ? { branch: rest.branch } : {} },
+        started_at,
+        last_at
+      });
+    }
+    return rows;
+  }
+};
+function prune2(o) {
+  for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
+  return o;
+}
+function pickSource(v) {
+  return typeof v === "string" && ["startup", "resume", "clear", "compact", "fork"].includes(v) ? v : "unknown";
+}
+function errText(v) {
+  if (typeof v === "string") return v.slice(0, 2e3);
+  if (v && typeof v === "object") {
+    const e = v;
+    if (typeof e.error === "string") return e.error.slice(0, 2e3);
+    if (typeof e.message === "string") return e.message.slice(0, 2e3);
+  }
+  return void 0;
+}
+function describe(input) {
+  if (!input || typeof input !== "object") return "";
+  const i = input;
+  const v = i.command ?? i.file_path ?? i.path ?? i.url ?? i.pattern;
+  return typeof v === "string" ? ` ${v.slice(0, 120)}` : "";
+}
+var NAME_RANK = {
+  user: "custom",
+  auto: "harness",
+  hook: "harness",
+  peer: "harness"
+};
+function registryEntry(j) {
+  if (!j || typeof j !== "object") return null;
+  const r = j;
+  const source = r.nameSource ? NAME_RANK[r.nameSource] : void 0;
+  return {
+    sessionId: r.sessionId ? String(r.sessionId) : null,
+    name: source && typeof r.name === "string" && r.name.trim() ? r.name.trim() : null,
+    name_source: source ?? null,
+    bridge: typeof r.bridgeSessionId === "string" ? r.bridgeSessionId : null
+  };
+}
+var liveCache = /* @__PURE__ */ new Map();
+function claudeLive(dir) {
+  const hit = liveCache.get(dir);
+  if (hit) return hit;
+  const map = /* @__PURE__ */ new Map();
+  let names = [];
+  try {
+    names = readdirSync3(path5.join(dir, "sessions")).filter((n) => n.endsWith(".json"));
+  } catch {
+  }
+  for (const n of names) {
+    try {
+      const e = registryEntry(JSON.parse(readFileSync3(path5.join(dir, "sessions", n), "utf8")));
+      if (e?.sessionId) map.set(e.sessionId, e);
+    } catch {
+    }
+  }
+  liveCache.set(dir, map);
+  return map;
+}
+function claudeLiveByPid(dir, pid) {
+  if (!pid) return null;
+  try {
+    return registryEntry(JSON.parse(readFileSync3(path5.join(dir, "sessions", `${pid}.json`), "utf8")));
+  } catch {
+    return null;
+  }
+}
+function claudePid(env = process.env) {
+  try {
+    const dirs = claudeDirs(env);
+    const has2 = (pid2) => dirs.some((d) => existsSync3(path5.join(d, "sessions", `${pid2}.json`)));
+    let pid = process.ppid;
+    if (has2(pid)) return pid;
+    const parent = parentOf();
+    for (let hop = 0; hop < 6 && pid > 1; hop++) {
+      pid = parent(pid);
+      if (pid > 1 && has2(pid)) return pid;
+    }
+  } catch {
+  }
+  return null;
+}
+function parentOf() {
+  if (process.platform === "linux") {
+    return (pid) => {
+      try {
+        const st = readFileSync3(`/proc/${pid}/stat`, "utf8");
+        return Number(st.slice(st.lastIndexOf(")") + 2).split(" ")[1]) || 0;
+      } catch {
+        return 0;
+      }
+    };
+  }
+  const table = /* @__PURE__ */ new Map();
+  try {
+    const out2 = execFileSync2("ps", ["-axo", "pid=,ppid="], {
+      encoding: "utf8",
+      timeout: 2e3,
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    for (const l of out2.split("\n")) {
+      const m = /^\s*(\d+)\s+(\d+)/.exec(l);
+      if (m) table.set(Number(m[1]), Number(m[2]));
+    }
+  } catch {
+  }
+  return (pid) => table.get(pid) || 0;
+}
+var accountCache = /* @__PURE__ */ new Map();
+function claudeAccount(dir) {
+  const hit = accountCache.get(dir);
+  if (hit !== void 0) return hit;
+  const files = [path5.join(dir, ".claude.json")];
+  if (path5.resolve(dir) === path5.join(HOME, ".claude")) files.unshift(path5.join(HOME, ".claude.json"));
+  let acct = null;
+  for (const f of files) {
+    try {
+      const a = JSON.parse(readFileSync3(f, "utf8")).oauthAccount;
+      if (a?.accountUuid) {
+        acct = String(a.accountUuid);
+        break;
+      }
+    } catch {
+    }
+  }
+  accountCache.set(dir, acct);
+  return acct;
+}
+var LINK_RE = /^https:\/\/claude\.ai\/code\/session_[A-Za-z0-9]+$/;
+function transcriptLink(records) {
+  for (let i = records.length - 1; i >= 0; i--) {
+    const j = records[i];
+    if (j.type === "system" && j.subtype === "bridge_status" && typeof j.url === "string" && LINK_RE.test(j.url))
+      return j.url;
+    if (j.type === "bridge-session" && typeof j.bridgeSessionId === "string") {
+      const m = /^(?:cse|session)_([A-Za-z0-9]+)$/.exec(j.bridgeSessionId);
+      if (m) return `https://claude.ai/code/session_${m[1]}`;
+    }
+  }
+  return null;
+}
+function appTitle(text) {
+  const t = String(text).replace(/\s+/g, " ").trim();
+  return t.length > 50 ? `${t.slice(0, 50)}...` : t;
+}
+function askText(j) {
+  if (!j || j.type !== "user" || j.isMeta || j.isSidechain) return null;
+  const origin = j.origin;
+  if (origin?.kind && origin.kind !== "human") return null;
+  const c = j.message?.content;
+  const text = (typeof c === "string" ? c : Array.isArray(c) ? c.filter((b) => b && b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n") : "").trim();
+  if (!text || isInjected(text)) return null;
+  return text;
+}
+function firstAsk(records) {
+  for (const j of records) {
+    const t = askText(j);
+    if (t) return appTitle(t);
+  }
+  return null;
+}
+function scanTitles(file, from, found) {
+  const out2 = { custom: found.custom ?? null, ai: found.ai ?? null, upto: from };
+  let size = 0;
+  try {
+    size = statSync3(file).size;
+  } catch {
+    return out2;
+  }
+  if (size < from) {
+    out2.upto = 0;
+    out2.custom = out2.ai = null;
+    from = 0;
+  }
+  let pos = 0;
+  scanLines(
+    file,
+    (l) => {
+      pos += Buffer.byteLength(l, "utf8") + 1;
+      if (pos <= from || l.indexOf('-title"') < 0) return null;
+      try {
+        const j = JSON.parse(l);
+        if (j.type === "custom-title" && j.customTitle) out2.custom = j.customTitle;
+        if (j.type === "ai-title" && j.aiTitle) out2.ai = j.aiTitle;
+      } catch {
+      }
+      return null;
+    },
+    512 * 1024 * 1024
+  );
+  out2.upto = size;
+  return out2;
+}
+function claudeFacts(file, sessionId, hints, state2) {
+  const { head, tail: tail2 } = ends(file, 64 * 1024, 256 * 1024);
+  const H = parseLines(head);
+  const T = parseLines(tail2);
+  const out2 = {};
+  const id = sessionId || path5.basename(file, ".jsonl");
+  const mem = state2.get(NAME2, id);
+  let custom = null;
+  let ai = null;
+  for (const j of H.concat(T)) {
+    if (j.type === "custom-title" && typeof j.customTitle === "string") custom = j.customTitle;
+    if (j.type === "ai-title" && typeof j.aiTitle === "string") ai = j.aiTitle;
+  }
+  let size = 0;
+  try {
+    size = statSync3(file).size;
+  } catch {
+  }
+  if (!custom && !ai && size > 64 * 1024 + 256 * 1024) {
+    const s = scanTitles(file, Number(mem.scan_upto) || 0, {
+      custom: mem.scan_custom,
+      ai: mem.scan_ai
+    });
+    custom = s.custom;
+    ai = s.ai;
+    state2.save(NAME2, id, { scan_upto: s.upto, scan_custom: s.custom, scan_ai: s.ai });
+  }
+  const dir = configDirOf(file);
+  const live = claudeLive(dir).get(id) ?? claudeLiveByPid(dir, hints.claude_pid);
+  if (live?.name) state2.save(NAME2, id, { name: live.name, name_source: live.name_source });
+  const bridge = live?.bridge && /^session_[A-Za-z0-9]+$/.test(live.bridge) ? `https://claude.ai/code/${live.bridge}` : null;
+  const url = bridge ?? transcriptLink(T) ?? transcriptLink(H) ?? (typeof mem.url === "string" ? mem.url : null);
+  if (url) {
+    out2.url = url;
+    state2.save(NAME2, id, { url });
+  }
+  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) => {
+      try {
+        const t = askText(JSON.parse(l));
+        return t ? appTitle(t) : null;
+      } catch {
+        return null;
+      }
+    });
+    if (!ask && size > 16 * 1024 * 1024) state2.save(NAME2, id, { first_ask_none: true });
+  }
+  if (ask) {
+    out2.first_ask = ask;
+    if (!mem.first_ask) state2.save(NAME2, id, { first_ask: ask });
+  }
+  if (pick) {
+    out2.title = String(pick.title).slice(0, 120);
+    out2.title_source = pick.source;
+  } else if (ask) {
+    out2.title = ask;
+    out2.title_source = "first-ask";
+  }
+  const acct = claudeAccount(dir);
+  if (acct) out2.account_id = acct;
+  for (let i = T.length - 1; i >= 0; i--) {
+    const m = T[i].message?.model;
+    if (T[i]?.type === "assistant" && m && m !== "<synthetic>") {
+      out2.model = m;
+      break;
+    }
+  }
+  const meta = [...T].reverse().find((j) => j.version) ?? H.find((j) => j.version);
+  if (meta?.version) out2.harness_version = String(meta.version);
+  const times = H.concat(T).map((j) => Date.parse(String(j.timestamp ?? ""))).filter((n) => n > 0);
+  if (times.length) {
+    out2.started_at = Math.min(...times);
+    out2.last_at = Math.max(...times);
+  }
+  const withCwd = H.find((j) => typeof j.cwd === "string");
+  if (withCwd) {
+    out2.cwd = withCwd.cwd;
+    if (typeof withCwd.gitBranch === "string" && withCwd.gitBranch !== "HEAD") out2.branch = withCwd.gitBranch;
+  }
+  return out2;
+}
+
+// ../core/src/adapters/codex.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import path6 from "node:path";
+
+// ../core/src/adapters/codex-config.ts
+var NOTIFY_LINE = /^[ \t]*notify[ \t]*=[ \t]*(\[.*\])[ \t]*(?:#.*)?$/m;
+var NOTIFY_KEY = /^[ \t]*notify[ \t]*=/m;
+var OURS2 = /hook\.js",\s*"codex",\s*"notify"/;
+function scan(line, st) {
+  let i = 0;
+  while (i < line.length) {
+    if (st.str) {
+      const j = line.indexOf(st.str, i);
+      if (j < 0) return;
+      i = j + 3;
+      st.str = null;
+      continue;
+    }
+    const ch = line[i];
+    if (ch === "#") return;
+    if (line.startsWith('"""', i) || line.startsWith("'''", i)) {
+      st.str = line.slice(i, i + 3);
+      i += 3;
+      continue;
+    }
+    if (ch === '"') {
+      i++;
+      while (i < line.length && line[i] !== '"') i += line[i] === "\\" ? 2 : 1;
+      i++;
+      continue;
+    }
+    if (ch === "'") {
+      const j = line.indexOf("'", i + 1);
+      i = j < 0 ? line.length : j + 1;
+      continue;
+    }
+    if (ch === "[") st.depth++;
+    else if (ch === "]") st.depth = Math.max(0, st.depth - 1);
+    i++;
+  }
+}
+function firstTableAt(text) {
+  const st = { depth: 0, str: null };
+  let pos = 0;
+  for (const line of text.split("\n")) {
+    if (!st.str && st.depth === 0 && /^[ \t]*\[/.test(line)) return pos;
+    scan(line, st);
+    pos += line.length + 1;
+  }
+  return -1;
+}
+function split(text) {
+  const at = firstTableAt(text);
+  return at < 0 ? { head: text, tail: "", at: text.length } : { head: text.slice(0, at), tail: text.slice(at), at };
+}
+function parseArgv(raw) {
+  try {
+    const a = JSON.parse(raw);
+    return Array.isArray(a) && a.every((x) => typeof x === "string") ? a : null;
+  } catch {
+    return null;
+  }
+}
+function readNotify(text) {
+  const { head, tail: tail2, at } = split(text);
+  const m = NOTIFY_LINE.exec(head);
+  if (m)
+    return {
+      raw: m[1] ?? "",
+      argv: parseArgv(m[1] ?? ""),
+      index: m.index,
+      length: m[0].length,
+      misplaced: false,
+      other: !OURS2.test(m[1] ?? "")
+    };
+  const k = NOTIFY_KEY.exec(head);
+  if (k) {
+    const rest = head.slice(k.index).split("\n")[0] ?? "";
+    return {
+      raw: rest.replace(NOTIFY_KEY, "").trim(),
+      argv: null,
+      index: k.index,
+      length: 0,
+      misplaced: false,
+      other: true
+    };
+  }
+  const t = NOTIFY_LINE.exec(tail2);
+  if (t && OURS2.test(t[1] ?? ""))
+    return {
+      raw: t[1] ?? "",
+      argv: parseArgv(t[1] ?? ""),
+      index: at + t.index,
+      length: t[0].length,
+      misplaced: true,
+      other: false
+    };
+  return null;
+}
+function dropLine(text, index, length) {
+  return text.slice(0, index) + text.slice(index + length).replace(/^\r?\n/, "");
+}
+function insertTopLevel(text, line) {
+  const { head, tail: tail2 } = split(text);
+  if (!tail2) return (head.trim() ? head.replace(/\s*$/, "\n") : "") + line + "\n";
+  return `${(head.trim() ? head.replace(/\s*$/, "\n") : "") + line}
+
+${tail2}`;
+}
+function withNotify(text, line) {
+  const n = readNotify(text);
+  if (n && !n.misplaced && !n.other) return text.slice(0, n.index) + line + text.slice(n.index + n.length);
+  if (n?.misplaced) return insertTopLevel(dropLine(text, n.index, n.length), line);
+  return insertTopLevel(text, line);
+}
+function replaceNotify(text, line) {
+  const n = readNotify(text);
+  if (!n || n.misplaced || !n.length) return null;
+  return text.slice(0, n.index) + line + text.slice(n.index + n.length);
+}
+function withoutNotify(text) {
+  const n = readNotify(text);
+  if (!n || n.other || !n.length) return text;
+  return dropLine(text, n.index, n.length);
+}
+var PREVIOUS = "--previous-notify";
+function previousNotify(argv) {
+  if (!Array.isArray(argv)) return null;
+  const i = argv.indexOf(PREVIOUS);
+  return i >= 0 && typeof argv[i + 1] === "string" ? parseArgv(argv[i + 1]) : null;
+}
+function stripPreviousRaw(raw) {
+  return raw.replace(/,\s*"--previous-notify",\s*"(?:[^"\\]|\\.)*"\s*(?=\])/, "");
+}
+function withPreviousRaw(raw, prev) {
+  const base = stripPreviousRaw(raw).replace(/\s*\]\s*$/, "");
+  return `${base}, "--previous-notify", ${JSON.stringify(JSON.stringify(prev))}]`;
+}
+var isComputerUse = (argv) => Array.isArray(argv) && typeof argv[0] === "string" && /(^|\/)SkyComputerUseClient$/.test(argv[0]);
+
+// ../core/src/adapters/codex.ts
+var NAME3 = "codex";
+var CODEX_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PermissionRequest",
+  "Stop",
+  "Interrupt",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "PostCompact",
+  "SessionEnd"
+];
+var OPTS2 = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
+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");
+var sessionsDir = (env) => path6.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";
+function installNotify(cmd2, env) {
+  const file = configFile2(env);
+  let text = "";
+  try {
+    text = readFileSync4(file, "utf8");
+  } catch {
+  }
+  const argv = cmd2([NAME3, "notify"]).argv;
+  const line = `notify = ${JSON.stringify(argv)}`;
+  const n = readNotify(text);
+  const write = (next) => {
+    mkdirSync3(path6.dirname(file), { recursive: true });
+    writeFileSync3(file, next);
+  };
+  if (n && !n.other) {
+    if (!n.misplaced && JSON.stringify(n.argv) === JSON.stringify(argv))
+      return { file, changed: false, note: "notify current" };
+    write(withNotify(text, line));
+    return {
+      file,
+      changed: true,
+      note: n.misplaced ? "notify moved to the top level (it sat inside a [table], where Codex never reads it)" : "notify updated"
+    };
+  }
+  if (n?.other) {
+    const prev = previousNotify(n.argv);
+    if (isComputerUse(n.argv)) {
+      if (prev && OURS2.test(JSON.stringify(prev))) {
+        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))) {
+        const next = replaceNotify(text, `notify = ${withPreviousRaw(n.raw, argv)}`);
+        if (next) {
+          write(next);
+          return { file, changed: true, note: "chained after Codex Computer Use (--previous-notify)" };
+        }
+      }
+    }
+    return {
+      file,
+      changed: false,
+      note: `left alone: notify runs ${n.raw.slice(0, 80)} (hooks.json carries the events; the notify fallback is off)`
+    };
+  }
+  write(withNotify(text, line));
+  return { file, changed: true, note: "notify set at the top level" };
+}
+function uninstallNotify(env) {
+  const file = configFile2(env);
+  let text;
+  try {
+    text = readFileSync4(file, "utf8");
+  } catch {
+    return { file, changed: false };
+  }
+  const n = readNotify(text);
+  if (!n) return { file, changed: false };
+  if (!n.other) {
+    writeFileSync3(file, withoutNotify(text));
+    return { file, changed: true };
+  }
+  const prev = previousNotify(n.argv);
+  if (isComputerUse(n.argv) && prev && OURS2.test(JSON.stringify(prev))) {
+    const next = replaceNotify(text, `notify = ${stripPreviousRaw(n.raw)}`);
+    if (next) writeFileSync3(file, next);
+    return { file, changed: true };
+  }
+  return { file, changed: false };
+}
+function findRollout(threadId, env) {
+  let best = null;
+  const walk = (dir, depth) => {
+    let names = [];
+    try {
+      names = readdirSync4(dir);
+    } catch {
+      return;
+    }
+    for (const n of names.sort().reverse()) {
+      const p = path6.join(dir, n);
+      if (n.endsWith(".jsonl") && n.includes(threadId)) {
+        best = p;
+        return;
+      }
+      if (depth < 3) {
+        walk(p, depth + 1);
+        if (best) return;
+      }
+    }
+  };
+  walk(sessionsDir(env), 0);
+  return best;
+}
+var codex = {
+  name: NAME3,
+  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),
+    installNotify(cmd2, env)
+  ],
+  uninstall: (env = process.env) => [uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS), uninstallNotify(env)],
+  installed: (cmd2, env = process.env) => {
+    const out2 = [
+      { file: hooksFile2(env), state: installedClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd2, OPTS2) }
+    ];
+    let text = "";
+    try {
+      text = readFileSync4(configFile2(env), "utf8");
+    } catch {
+    }
+    const n = readNotify(text);
+    const argv = cmd2([NAME3, "notify"]).argv;
+    const prev = n ? previousNotify(n.argv) : null;
+    const ours = n && (!n.other || prev && JSON.stringify(prev) === JSON.stringify(argv));
+    out2.push({
+      file: configFile2(env),
+      state: !n || n.other && !ours ? "missing" : n.misplaced ? "misplaced" : JSON.stringify(n.argv) === JSON.stringify(argv) || prev && JSON.stringify(prev) === JSON.stringify(argv) ? "current" : "stale"
+    });
+    return out2;
+  },
+  fromHook(input) {
+    const event = input.argv[1] ?? "";
+    let s = {};
+    if (event === "notify") {
+      const raw = input.argv.find((a) => a.startsWith("{")) ?? input.stdin;
+      try {
+        s = raw ? JSON.parse(raw) : {};
+      } catch {
+      }
+      const id2 = s["thread-id"] ?? s.thread_id ?? s["session-id"] ?? s.session_id;
+      if (!id2) return null;
+      const r2 = {
+        session: { id: String(id2), cwd: typeof s.cwd === "string" ? s.cwd : input.cwd },
+        events: [
+          {
+            type: "turn.ended",
+            data: { reason: "stop", ...typeof s["turn-id"] === "string" ? { turn_id: s["turn-id"] } : {} },
+            harnessEvent: "notify"
+          }
+        ],
+        hints: {}
+      };
+      const file = findRollout(String(id2), input.env);
+      if (file) r2.transcript = file;
+      return r2;
+    }
+    try {
+      s = input.stdin ? JSON.parse(input.stdin) : {};
+    } catch {
+    }
+    const id = s.session_id;
+    if (!id) return null;
+    const session = { id: String(id), cwd: typeof s.cwd === "string" ? s.cwd : input.cwd };
+    if (typeof s.model === "string") session.model = s.model;
+    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 ev = (type, data) => ({ type, data: prune3(data), harnessEvent: event });
+    const events = [];
+    switch (event) {
+      case "SessionStart":
+        events.push(
+          ev("session.started", {
+            source: typeof s.source === "string" && ["startup", "resume", "clear", "compact", "fork"].includes(s.source) ? s.source : "unknown"
+          })
+        );
+        break;
+      case "UserPromptSubmit":
+        events.push(
+          ev("turn.started", {
+            turn_id,
+            prompt_chars: typeof s.prompt === "string" ? [...s.prompt].length : void 0
+          })
+        );
+        break;
+      case "PreToolUse":
+        if (tool) events.push(ev("tool.started", { tool, call_id, turn_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 })
+          );
+        break;
+      case "PermissionRequest":
+        events.push(
+          ev("attention.needed", { attention_id: call_id ?? `perm-${Date.now()}`, kind: "permission", tool })
+        );
+        break;
+      case "Stop":
+        events.push(ev("turn.ended", { turn_id, reason: "stop" }));
+        break;
+      case "Interrupt":
+        events.push(ev("turn.ended", { turn_id, reason: "interrupt" }));
+        break;
+      case "SubagentStart":
+        events.push(
+          ev("subagent.started", {
+            agent_id: String(s.agent_id ?? s.subagent_id ?? ""),
+            agent_type: typeof s.agent_type === "string" ? s.agent_type : void 0
+          })
+        );
+        break;
+      case "SubagentStop":
+        events.push(
+          ev("subagent.ended", {
+            agent_id: String(s.agent_id ?? s.subagent_id ?? ""),
+            agent_type: typeof s.agent_type === "string" ? s.agent_type : void 0
+          })
+        );
+        break;
+      case "PreCompact":
+        events.push(ev("context.compacted", { trigger: s.trigger === "manual" ? "manual" : "auto" }));
+        break;
+      case "PostCompact":
+        break;
+      case "SessionEnd":
+        events.push(ev("session.ended", { reason: endReason2(s.reason) }));
+        break;
+      default:
+        return null;
+    }
+    const r = { session, events, hints: {} };
+    if (typeof s.transcript_path === "string") r.transcript = s.transcript_path;
+    return r;
+  },
+  readTranscript(file, fromLine) {
+    let text = "";
+    try {
+      text = readFileSync4(file, "utf8");
+    } catch {
+      return { turns: [], line: fromLine };
+    }
+    return readCodex(text.split("\n"), fromLine);
+  },
+  facts(session, transcript) {
+    const out2 = {};
+    if (transcript) Object.assign(out2, codexFacts(transcript));
+    return out2;
+  },
+  backfill(sinceMs, env = process.env) {
+    const rows = [];
+    for (const f of recentFiles(sessionsDir(env), 3, sinceMs, (n) => /^rollout-.*\.jsonl$/.test(n))) {
+      const m = /([0-9a-f]{8}-[0-9a-f-]{27,})\.jsonl$/i.exec(path6.basename(f));
+      if (!m?.[1]) continue;
+      const facts = codexFacts(f);
+      if (!facts.started_at || !facts.last_at) continue;
+      const { started_at, last_at, first_ask: _fa, harness_version: _hv, ...rest } = facts;
+      rows.push({ session: { id: m[1], ...rest }, started_at, last_at });
+    }
+    return rows;
+  }
+};
+function prune3(o) {
+  for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
+  return o;
+}
+function codexFacts(file) {
+  const { head, tail: tail2 } = ends(file, 128 * 1024, 64 * 1024);
+  const H = parseLines(head);
+  const T = parseLines(tail2);
+  const out2 = {};
+  const meta = H.find((j) => j.type === "session_meta" && j.payload);
+  if (meta?.payload) {
+    const p = meta.payload;
+    if (p.cwd) out2.cwd = p.cwd;
+    if (p.cli_version) out2.harness_version = String(p.cli_version);
+    if (p.git?.branch) out2.branch = p.git.branch;
+    if (p.git?.repository_url) out2.repo = String(p.git.repository_url).replace(/\/\/[^/@]*@/, "//");
+  }
+  const ctx = H.concat(T).reverse().find((j) => j.type === "turn_context" && j.payload?.model);
+  if (ctx?.payload?.model) out2.model = ctx.payload.model;
+  for (const j of H) {
+    const p = j.payload;
+    if (j.type !== "response_item" || !p || p.type !== "message" || p.role !== "user") continue;
+    const text = (p.content ?? []).filter((b) => b && b.type === "input_text" && typeof b.text === "string").map((b) => b.text).join("\n").trim();
+    if (!text || /^<[a-z_-]+>/i.test(text)) continue;
+    const line = text.split("\n").find((l) => l.trim()) ?? "";
+    out2.title = line.length > 80 ? `${line.slice(0, 80).replace(/\s+\S*$/, "")}\u2026` : line;
+    out2.title_source = "first-ask";
+    break;
+  }
+  const times = H.concat(T).map((j) => Date.parse(String(j.timestamp ?? ""))).filter((n) => n > 0);
+  if (times.length) {
+    out2.started_at = Math.min(...times);
+    out2.last_at = Math.max(...times);
+  }
+  return out2;
+}
+
+// ../core/src/adapters/gemini-cli.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import path7 from "node:path";
+var NAME4 = "gemini-cli";
+var GEMINI_EVENTS = [
+  "SessionStart",
+  "BeforeAgent",
+  "BeforeTool",
+  "AfterTool",
+  "Notification",
+  "AfterAgent",
+  "PreCompress",
+  "SessionEnd"
+];
+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 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) }
+  ],
+  fromHook(input) {
+    const event = input.argv[1] ?? "";
+    let s = {};
+    try {
+      s = input.stdin ? JSON.parse(input.stdin) : {};
+    } catch {
+    }
+    const id = s.session_id;
+    if (!id) return null;
+    const session = { id: String(id), cwd: typeof s.cwd === "string" ? s.cwd : input.cwd };
+    const tool = validTool4(s.tool_name) ? s.tool_name : void 0;
+    const ev = (type, data) => ({ type, data: prune4(data), harnessEvent: event });
+    const events = [];
+    switch (event) {
+      case "SessionStart":
+        events.push(
+          ev("session.started", {
+            source: typeof s.source === "string" && ["startup", "resume", "clear"].includes(s.source) ? s.source : "unknown"
+          })
+        );
+        break;
+      case "BeforeAgent":
+        events.push(
+          ev("turn.started", { prompt_chars: typeof s.prompt === "string" ? [...s.prompt].length : void 0 })
+        );
+        break;
+      case "BeforeTool":
+        if (tool) events.push(ev("tool.started", { tool, input: s.tool_input }));
+        break;
+      case "AfterTool": {
+        const resp = s.tool_response;
+        const err = resp && typeof resp === "object" && resp.error ? String(typeof resp.error === "string" ? resp.error : JSON.stringify(resp.error)).slice(0, 2e3) : void 0;
+        if (tool)
+          events.push(
+            ev("tool.ended", {
+              tool,
+              ok: !err,
+              error: err,
+              input: s.tool_input,
+              output: resp?.llmContent ?? s.tool_response
+            })
+          );
+        break;
+      }
+      case "Notification":
+        events.push(
+          ev("attention.needed", {
+            attention_id: `notif-${Date.now()}`,
+            kind: s.notification_type === "ToolPermission" ? "permission" : "question",
+            message: typeof s.message === "string" ? s.message.slice(0, 200) : void 0
+          })
+        );
+        break;
+      case "AfterAgent":
+        events.push(ev("turn.ended", { reason: "stop" }));
+        break;
+      case "PreCompress":
+        events.push(ev("context.compacted", { trigger: s.trigger === "manual" ? "manual" : "auto" }));
+        break;
+      case "SessionEnd":
+        events.push(
+          ev("session.ended", {
+            reason: s.reason === "clear" || s.reason === "logout" || s.reason === "exit" ? s.reason : s.reason === "prompt_input_exit" ? "exit" : "other"
+          })
+        );
+        break;
+      default:
+        return null;
+    }
+    const r = { session, events, hints: {} };
+    if (typeof s.transcript_path === "string") r.transcript = s.transcript_path;
+    return r;
+  },
+  readTranscript(file, fromLine) {
+    let text = "";
+    try {
+      text = readFileSync5(file, "utf8");
+    } catch {
+      return { turns: [], line: fromLine };
+    }
+    return readGemini(text.split("\n"), fromLine);
+  },
+  facts(_session, transcript) {
+    const out2 = {};
+    if (!transcript) return out2;
+    const { head, tail: tail2 } = ends(transcript, 64 * 1024, 64 * 1024);
+    const H = parseLines(head);
+    const T = parseLines(tail2);
+    const first = H.find((j) => j.type === "user");
+    const raw = first ? first.content ?? first.message ?? first.text : void 0;
+    const text = typeof raw === "string" ? raw.trim() : "";
+    if (text) {
+      const line = text.split("\n").find((l) => l.trim()) ?? "";
+      out2.title = line.length > 80 ? `${line.slice(0, 80).replace(/\s+\S*$/, "")}\u2026` : line;
+      out2.title_source = "first-ask";
+    }
+    const times = H.concat(T).map((j) => Date.parse(String(j.timestamp ?? ""))).filter((n) => n > 0);
+    if (times.length) {
+      out2.started_at = Math.min(...times);
+      out2.last_at = Math.max(...times);
+    }
+    return out2;
+  },
+  backfill: () => []
+  // chat logs are keyed by a project hash, not a session id we can name; the first hook of a resumed session reports it
+};
+function prune4(o) {
+  for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
+  return o;
+}
+
+// ../core/src/adapters/index.ts
+var ADAPTERS = [claudeCode, codex, geminiCli, antigravity];
+var adapterByName = (name) => ADAPTERS.find((a) => a.name === name);
+
+// ../core/src/config.ts
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import path8 from "node:path";
+var DEFAULT_CONFIG = { sinks: [], harnesses: {}, update_check: true, keep_days: 30 };
+function readConfig(file = configFile()) {
+  try {
+    const j = JSON.parse(readFileSync6(file, "utf8"));
+    return {
+      ...DEFAULT_CONFIG,
+      ...j,
+      sinks: Array.isArray(j.sinks) ? j.sinks : [],
+      harnesses: j.harnesses && typeof j.harnesses === "object" ? j.harnesses : {}
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG, sinks: [], harnesses: {} };
+  }
+}
+function writeConfig(c, file = configFile()) {
+  mkdirSync4(path8.dirname(file), { recursive: true, mode: 448 });
+  writeFileSync4(file, `${JSON.stringify(c, null, 2)}
+`, { mode: 384 });
+  if (process.platform !== "win32" && existsSync6(file)) {
+    try {
+      chmodSync(file, 384);
+    } catch {
+    }
+  }
+}
+function machineName(c, hostname) {
+  if (c.machine) return String(c.machine).slice(0, 80);
+  return hostname.replace(/\.(local|lan|home)$/i, "");
+}
+
+// ../core/src/ulid.ts
+import { randomBytes } from "node:crypto";
+var ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var lastTime = 0;
+var lastRand = [];
+function encodeTime(t) {
+  let out2 = "";
+  let n = t;
+  for (let i = 0; i < 10; i++) {
+    out2 = ALPHABET[n % 32] + out2;
+    n = Math.floor(n / 32);
+  }
+  return out2;
+}
+function ulid(now = Date.now()) {
+  if (now === lastTime) {
+    for (let i = lastRand.length - 1; i >= 0; i--) {
+      const v = (lastRand[i] ?? 0) + 1;
+      if (v < 32) {
+        lastRand[i] = v;
+        break;
+      }
+      lastRand[i] = 0;
+    }
+  } else {
+    lastTime = now;
+    const b = randomBytes(16);
+    lastRand = Array.from({ length: 16 }, (_, i) => (b[i] ?? 0) % 32);
+  }
+  return encodeTime(now) + lastRand.map((v) => ALPHABET[v]).join("");
+}
+
+// ../core/src/events.ts
+function makeEvent(a, ctx) {
+  const now = ctx.now ?? Date.now();
+  const harness = { name: ctx.harness.name, event: a.harnessEvent };
+  if (ctx.harness.version) harness.version = ctx.harness.version;
+  return {
+    protocol: 1,
+    id: ulid(now),
+    type: a.type,
+    time: new Date(now).toISOString(),
+    tier: 3,
+    harness,
+    session: ctx.session,
+    privacy: { rulesets: [], pii: false },
+    data: a.data
+  };
+}
+
+// ../core/src/outbox.ts
+import {
+  appendFileSync,
+  closeSync as closeSync2,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync5,
+  openSync as openSync2,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync7,
+  readSync as readSync2,
+  renameSync,
+  statSync as statSync4,
+  unlinkSync,
+  writeFileSync as writeFileSync5
+} from "node:fs";
+import path9 from "node:path";
+var Outbox = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  dir(harness) {
+    return path9.join(this.root, "outbox", safeId(harness));
+  }
+  file(ref) {
+    return path9.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
+  }
+  seqFile(ref) {
+    return path9.join(this.dir(ref.harness), `${safeId(ref.session)}.seq`);
+  }
+  /** The next seq for a session, persisted (survives a hibernating machine and a
+   *  restart; an in-memory counter would restart at 0 and collide). */
+  nextSeq(ref) {
+    const f = this.seqFile(ref);
+    let n = 0;
+    try {
+      n = Number(readFileSync7(f, "utf8")) || 0;
+    } catch {
+      n = this.lastSeqInFile(ref) + 1;
+    }
+    mkdirSync5(path9.dirname(f), { recursive: true });
+    writeFileSync5(f, String(n + 1));
+    return n;
+  }
+  lastSeqInFile(ref) {
+    const f = this.file(ref);
+    if (!existsSync7(f)) return -1;
+    const lines = readFileSync7(f, "utf8").trim().split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const j = JSON.parse(lines[i] ?? "");
+        if (typeof j.session?.seq === "number") return j.session.seq;
+      } catch {
+      }
+    }
+    return -1;
+  }
+  append(ref, events) {
+    if (!events.length) return;
+    mkdirSync5(this.dir(ref.harness), { recursive: true });
+    appendFileSync(this.file(ref), `${events.map((e) => JSON.stringify(e)).join("\n")}
+`);
+  }
+  /** Every session file, newest first. */
+  sessions() {
+    const out2 = [];
+    const base = path9.join(this.root, "outbox");
+    if (!existsSync7(base)) return [];
+    for (const h of readdirSync5(base)) {
+      const d = path9.join(base, h);
+      let names = [];
+      try {
+        names = readdirSync5(d).filter((n) => n.endsWith(".jsonl"));
+      } catch {
+        continue;
+      }
+      for (const n of names) {
+        try {
+          out2.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync4(path9.join(d, n)).mtimeMs });
+        } catch {
+        }
+      }
+    }
+    return out2.sort((a, b) => b.mtime - a.mtime).map((x) => x.ref);
+  }
+  /** Read events after byte offset `from`; returns them and the new offset. Lines
+   *  are read whole; a partial trailing line (a write in progress) is left. */
+  read(ref, from, maxEvents = 500) {
+    const f = this.file(ref);
+    if (!existsSync7(f)) return { events: [], offset: from };
+    const size = statSync4(f).size;
+    if (from >= size) return { events: [], offset: from };
+    const fd = openSync2(f, "r");
+    try {
+      const buf = Buffer.alloc(Math.min(size - from, 8 * 1024 * 1024));
+      const n = readSync2(fd, buf, 0, buf.length, from);
+      const text = buf.subarray(0, n).toString("utf8");
+      const events = [];
+      let offset = from;
+      let pos = 0;
+      while (events.length < maxEvents) {
+        const nl = text.indexOf("\n", pos);
+        if (nl < 0) break;
+        const line = text.slice(pos, nl);
+        pos = nl + 1;
+        offset = from + Buffer.byteLength(text.slice(0, pos), "utf8");
+        if (!line.trim()) continue;
+        try {
+          events.push(JSON.parse(line));
+        } catch {
+        }
+      }
+      return { events, offset };
+    } finally {
+      closeSync2(fd);
+    }
+  }
+  /** Files older than `days` are pruned; the cursor files with them. */
+  prune(days, now = Date.now()) {
+    let n = 0;
+    const cutoff = now - days * 864e5;
+    for (const ref of this.sessions()) {
+      const f = this.file(ref);
+      try {
+        if (statSync4(f).mtimeMs < cutoff) {
+          unlinkSync(f);
+          try {
+            unlinkSync(this.seqFile(ref));
+          } catch {
+          }
+          n++;
+        }
+      } catch {
+      }
+    }
+    return n;
+  }
+  delete(ref) {
+    for (const f of [this.file(ref), this.seqFile(ref)]) {
+      try {
+        unlinkSync(f);
+      } catch {
+      }
+    }
+  }
+};
+var Cursors = class {
+  constructor(root, sink2) {
+    this.root = root;
+    this.sink = sink2;
+  }
+  root;
+  sink;
+  file() {
+    return path9.join(this.root, "cursors", `${safeId(this.sink)}.json`);
+  }
+  read() {
+    try {
+      return JSON.parse(readFileSync7(this.file(), "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  write(c) {
+    const f = this.file();
+    mkdirSync5(path9.dirname(f), { recursive: true });
+    const tmp = `${f}.${process.pid}.tmp`;
+    writeFileSync5(tmp, JSON.stringify(c));
+    renameSync(tmp, f);
+  }
+  key(ref) {
+    return `${ref.harness}/${ref.session}`;
+  }
+};
+function takeLock(root, ref, staleMs = 5 * 6e4) {
+  const dir = path9.join(root, "locks");
+  mkdirSync5(dir, { recursive: true });
+  const f = path9.join(dir, `${safeId(ref.harness)}-${safeId(ref.session)}.lock`);
+  try {
+    if (Date.now() - statSync4(f).mtimeMs > staleMs) unlinkSync(f);
+    else return null;
+  } catch {
+  }
+  try {
+    writeFileSync5(f, String(process.pid), { flag: "wx" });
+  } catch {
+    return null;
+  }
+  return () => {
+    try {
+      unlinkSync(f);
+    } catch {
+    }
+  };
+}
+
+// ../core/src/privacy/pii.ts
+import { createHash as createHash2 } 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;
+function looksPhone(s) {
+  const digits = s.replace(/\D/g, "");
+  if (digits.length < 7 || digits.length > 15) return false;
+  if (!/[+() .-]/.test(s)) return false;
+  if (!/[+() -]/.test(s)) return false;
+  return true;
+}
+function reducePii(text, home) {
+  if (!text) return text;
+  let out2 = text.replace(EMAIL, "[email]");
+  out2 = out2.replace(PHONE, (m) => looksPhone(m) ? "[phone]" : m);
+  if (home) {
+    const h = home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out2 = out2.replace(new RegExp(`(?<![A-Za-z0-9_])${h}(?=/|$|\\s|["'\`])`, "g"), "~");
+  }
+  return out2;
+}
+function hashMachine(name) {
+  return createHash2("sha256").update(name).digest("hex").slice(0, 8);
+}
+function reducePiiDeep(v, home) {
+  if (typeof v === "string") return reducePii(v, home);
+  if (Array.isArray(v)) return v.map((x) => reducePiiDeep(x, home));
+  if (v && typeof v === "object") {
+    const out2 = {};
+    for (const [k, x] of Object.entries(v)) out2[k] = reducePiiDeep(x, home);
+    return out2;
+  }
+  return v;
+}
+
+// ../core/src/privacy/secrets.ts
+var RULESET_SECRETS = "secrets@1";
+var REDACTED = "[redacted]";
+var TOKEN_PATTERNS = [
+  /-----BEGIN [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----|$)/g,
+  /\b(?:AKIA|ASIA|ABIA|ACCA)[0-9A-Z]{16}\b/g,
+  // AWS access key id
+  /\bgh[pousr]_[A-Za-z0-9]{30,}\b/g,
+  // GitHub
+  /\bgithub_pat_[A-Za-z0-9_]{30,}\b/g,
+  /\bglpat-[A-Za-z0-9_-]{20,}\b/g,
+  // GitLab
+  /\bxox[abposre]-[A-Za-z0-9-]{10,}\b/g,
+  // Slack
+  /\bhttps:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/_-]+/g,
+  /\bhttps:\/\/(?:ptb\.|canary\.)?discord(?:app)?\.com\/api\/webhooks\/[0-9]+\/[A-Za-z0-9_-]+/g,
+  /\bsk-(?:ant-|proj-|svcacct-|admin-|or-v1-)?[A-Za-z0-9_-]{20,}\b/g,
+  // Anthropic, OpenAI, DeepSeek, OpenRouter
+  /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/g,
+  // Stripe secret / restricted
+  /\bwhsec_[A-Za-z0-9+/=]{20,}/g,
+  // Stripe / Svix / Standard Webhooks secret
+  /\bAIza[0-9A-Za-z_-]{35}\b/g,
+  // Google API key
+  /\bya29\.[0-9A-Za-z_-]{20,}/g,
+  // Google OAuth access token
+  /\b1\/\/0[0-9A-Za-z_-]{30,}/g,
+  // Google OAuth refresh token
+  /\bGOCSPX-[0-9A-Za-z_-]{20,}/g,
+  // Google OAuth client secret
+  /\bxai-[A-Za-z0-9]{30,}\b/g,
+  /\bgsk_[A-Za-z0-9]{30,}\b/g,
+  // Groq
+  /\bpplx-[A-Za-z0-9]{30,}\b/g,
+  // Perplexity
+  /\bhf_[A-Za-z0-9]{30,}\b/g,
+  // Hugging Face
+  /\bpcsk_[A-Za-z0-9_]{30,}\b/g,
+  // Pinecone
+  /\bnpm_[A-Za-z0-9]{30,}\b/g,
+  /\bpypi-[A-Za-z0-9_-]{50,}/g,
+  /\bSG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}/g,
+  // SendGrid
+  /\bshp(?:at|ss|ca|pa)_[a-fA-F0-9]{32}\b/g,
+  // Shopify
+  /\bdop_v1_[a-f0-9]{64}\b/g,
+  // DigitalOcean
+  /\b(?:lin_api|lin_oauth)_[A-Za-z0-9]{30,}\b/g,
+  // Linear
+  /\b(?:ntn|secret)_[A-Za-z0-9]{40,}\b/g,
+  // Notion
+  /\bsbp_[a-f0-9]{40}\b/g,
+  // Supabase
+  /\bfigd_[A-Za-z0-9_-]{30,}/g,
+  // Figma
+  /\bdp\.(?:pt|st|sa|ct)\.[A-Za-z0-9]{30,}/g,
+  // Doppler
+  /\bgrn_[A-Za-z0-9_-]{20,}/g,
+  // Granola
+  /\bss_[a-f0-9]{32,}\b/g,
+  // spacesheep API keys
+  /\b[0-9]{8,10}:AA[A-Za-z0-9_-]{33}\b/g,
+  // Telegram bot token
+  /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g
+  // JWT
+];
+var URL_CREDENTIALS = /\b([a-z][a-z0-9+.-]{1,20}:\/\/[^\s:/@'"`<>]{1,100}:)([^\s@/'"`<>]{1,200})(@)/gi;
+var AUTH_HEADER = /\b((?:Bearer|Basic|Token)\s+)([A-Za-z0-9._~+/=-]{16,})/g;
+var SECRET_WORD = "(?:pass(?:word|wd|phrase|code)?s?|pwd|secret(?:[ _-]?key)?s?|client[ _-]?secret|api[ _-]?keys?|apikeys?|access[ _-]?keys?|access[ _-]?tokens?|auth[ _-]?tokens?|refresh[ _-]?tokens?|private[ _-]?keys?|tokens?|credentials?|creds)";
+var NAME_SEP = /(?<![A-Za-z0-9_])([A-Za-z][A-Za-z0-9_-]{1,79})(["']?\s{0,3}(?::=|=>|=|:)\s{0,3})/g;
+var VALUE = /"([^"\n]{1,300})"|'([^'\n]{1,300})'|`([^`\n]{1,300})`|([^\s"'`,;&)}\]]{1,300})/y;
+function redactAssignments(text) {
+  let out2 = "";
+  let last = 0;
+  NAME_SEP.lastIndex = 0;
+  for (let m = NAME_SEP.exec(text); m; m = NAME_SEP.exec(text)) {
+    const name = m[1] ?? "";
+    if (!isSecretName(name)) continue;
+    VALUE.lastIndex = NAME_SEP.lastIndex;
+    const v = VALUE.exec(text);
+    if (!v) continue;
+    const value = v[1] ?? v[2] ?? v[3] ?? v[4] ?? "";
+    NAME_SEP.lastIndex = VALUE.lastIndex;
+    if (isPlaceholder(value) || value.includes(REDACTED)) continue;
+    if (/tokens?$/i.test(name) && /^\d+(?:[.,]\d+)*[km]?$/i.test(value)) continue;
+    const q = v[1] != null ? '"' : v[2] != null ? "'" : v[3] != null ? "`" : "";
+    out2 += text.slice(last, v.index) + q + REDACTED + q;
+    last = VALUE.lastIndex;
+  }
+  return last ? out2 + text.slice(last) : 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(
+    flat
+  );
+}
+var PROSE = new RegExp(
+  `(\\b${SECRET_WORD}(?:[ \\t]{1,3}(?:is|was|=|:|to|as|of|for[ \\t]{1,3}\\S{1,40}[ \\t]{1,3}is))?[ \\t]{1,3})(["'\`]?)([^\\s"'\`]{6,200})\\2`,
+  "gi"
+);
+function isPlaceholder(v) {
+  const s = v.replace(/[.,;:!?]+$/, "");
+  if (!s) return true;
+  if (/^(?:string|number|boolean|bool|str|int|any|unknown|null|undefined|none|nil|true|false|optional|required|text|varchar|password|secret|token|env|string\[\]|object|bytes)$/i.test(
+    s
+  ))
+    return true;
+  if (/^\[?redacted\]?$/i.test(s) || /^\*+$/.test(s) || /^x{3,}$/i.test(s) || /^\.{3}$|^…$/.test(s)) return true;
+  if (/^[<{$%]/.test(s)) return true;
+  if (/^(?:process\.env|env|os\.environ|c\.env|this\.env|import\.meta\.env|getenv|config|settings|secrets|args|opts|options|req|request|body|params|input|data|user|self|this)\b/i.test(
+    s
+  ))
+    return true;
+  if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/.test(s)) return true;
+  if (/[(]/.test(s)) return true;
+  if (/^(?:your|my|the|a|an|some|new|old)[-_ ]/i.test(s)) return true;
+  return false;
+}
+function looksSecret(v) {
+  const s = v.replace(/[.,;:!?)]+$/, "");
+  if (s.length < 6) return false;
+  if (isPlaceholder(s)) return false;
+  if (/^https?:\/\//i.test(s)) return false;
+  if (/^[a-z]+(?:[-'][a-z]+)*$/.test(s)) return false;
+  if (/^[A-Z][a-z]+$/.test(s)) return false;
+  if (/^\d+(?:[.,]\d+)*[a-z%]*$/i.test(s)) return false;
+  if (/^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/.test(s)) return false;
+  const kinds = [/[a-z]/, /[A-Z]/, /[0-9]/, /[^A-Za-z0-9]/].filter((r) => r.test(s)).length;
+  return kinds >= 3 || /[0-9]/.test(s) && /[A-Za-z]/.test(s);
+}
+function redactSecrets(text) {
+  if (!text) return text;
+  let out2 = text;
+  for (const re of TOKEN_PATTERNS) out2 = out2.replace(re, REDACTED);
+  out2 = out2.replace(URL_CREDENTIALS, (_m, head, _pw, at) => `${head}${REDACTED}${at}`);
+  out2 = out2.replace(AUTH_HEADER, (m, head, v) => v.includes(REDACTED) ? m : `${head}${REDACTED}`);
+  out2 = redactAssignments(out2);
+  out2 = out2.replace(
+    PROSE,
+    (m, head, q, v) => !looksSecret(v) || v.includes(REDACTED) ? m : `${head}${q}${REDACTED}${q}`
+  );
+  return out2;
+}
+function redactDeep(v) {
+  if (typeof v === "string") return redactSecrets(v);
+  if (Array.isArray(v)) return v.map(redactDeep);
+  if (v && typeof v === "object") {
+    const out2 = {};
+    for (const [k, x] of Object.entries(v)) out2[k] = redactDeep(x);
+    return out2;
+  }
+  return v;
+}
+
+// ../core/src/privacy/filter.ts
+var TYPE_TIER = {
+  "session.started": 0,
+  "session.heartbeat": 0,
+  "session.ended": 0,
+  "session.backfill": 0,
+  "session.forgotten": 0,
+  "turn.started": 0,
+  "turn.ended": 0,
+  "turn.transcript": 2,
+  "tool.started": 1,
+  "tool.ended": 1,
+  "files.changed": 1,
+  "attention.needed": 0,
+  "attention.cleared": 0,
+  "subagent.started": 1,
+  "subagent.ended": 1,
+  "context.compacted": 1,
+  native: 3
+};
+var DATA_ALLOW = {
+  "session.started": { 0: ["source"] },
+  "session.heartbeat": { 0: [] },
+  "session.ended": { 0: ["reason"] },
+  "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.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"] },
+  "files.changed": { 1: ["paths"] },
+  "attention.needed": { 0: ["attention_id", "kind"], 1: ["tool", "message"] },
+  "attention.cleared": { 0: ["attention_id", "how"] },
+  "subagent.started": { 1: ["agent_id", "agent_type"] },
+  "subagent.ended": { 1: ["agent_id", "agent_type"] },
+  "context.compacted": { 1: ["trigger"] }
+};
+var SESSION_ALLOW = [
+  "id",
+  "seq",
+  "machine",
+  "cwd",
+  "repo",
+  "branch",
+  "model",
+  "title",
+  "title_source",
+  "url",
+  "account_id",
+  "parent_id"
+];
+var MAX_SIDE = 2e4;
+var MAX_IO = 64 * 1024;
+function allowedKeys(type, tier) {
+  const table = DATA_ALLOW[type];
+  if (!table) return null;
+  const out2 = [];
+  for (let t = 0; t <= tier; t++) for (const k of table[t] ?? []) out2.push(k);
+  return out2;
+}
+function cap(v, max) {
+  if (typeof v === "string") return v.length > max ? `${v.slice(0, max)}\u2026` : v;
+  if (v && typeof v === "object") {
+    const s = JSON.stringify(v);
+    return s.length > max ? `${s.slice(0, max)}\u2026` : v;
+  }
+  return v;
+}
+function filterEvent(event, tier, pii, opts = {}) {
+  const minTier = TYPE_TIER[event.type];
+  if (minTier !== void 0 && minTier > tier) return null;
+  if (event.type === "native" && tier < 3) return null;
+  const session = {};
+  for (const k of SESSION_ALLOW)
+    if (event.session[k] !== void 0)
+      session[k] = event.session[k];
+  let data = {};
+  const keys = allowedKeys(event.type, tier);
+  if (keys === null) data = { ...event.data };
+  else for (const k of keys) if (event.data[k] !== void 0) data[k] = event.data[k];
+  if (typeof data.user === "string") data.user = cap(data.user, MAX_SIDE);
+  if (typeof data.assistant === "string") data.assistant = cap(data.assistant, MAX_SIDE);
+  if (data.input !== void 0) data.input = cap(data.input, MAX_IO);
+  if (data.output !== void 0) data.output = cap(data.output, MAX_IO);
+  if (typeof data.message === "string") data.message = cap(data.message, 200);
+  const rulesets = [];
+  let out2 = { ...event, tier, session, data, privacy: { rulesets, pii } };
+  if (tier > 0) {
+    out2 = { ...out2, session: redactDeep(out2.session), data: redactDeep(out2.data) };
+    rulesets.push(RULESET_SECRETS);
+  }
+  if (pii) {
+    const s = reducePiiDeep(out2.session, opts.home);
+    if (typeof s.machine === "string") s.machine = hashMachine(s.machine);
+    delete s.account_id;
+    out2 = { ...out2, session: s, data: reducePiiDeep(out2.data, opts.home) };
+    rulesets.push(RULESET_PII);
+  }
+  out2.privacy = { rulesets, pii };
+  return out2;
+}
+
+// ../core/src/sinks/file.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
+import path10 from "node:path";
+var FileSink = class {
+  constructor(name, file, tier, pii) {
+    this.name = name;
+    this.file = file;
+    this.tier = tier;
+    this.pii = pii;
+  }
+  name;
+  file;
+  tier;
+  pii;
+  async send(events) {
+    try {
+      mkdirSync6(path10.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: [] };
+    } catch (e) {
+      return { ok: false, acknowledged: 0, error: String(e.message), action: "retry" };
+    }
+  }
+};
+
+// ../core/src/sinks/stdout.ts
+var StdoutSink = class {
+  constructor(name, tier, pii, write = (l) => process.stdout.write(`${l}
+`)) {
+    this.name = name;
+    this.tier = tier;
+    this.pii = pii;
+    this.write = write;
+  }
+  name;
+  tier;
+  pii;
+  write;
+  async send(events) {
+    for (const e of events) this.write(JSON.stringify(e));
+    return { ok: true, acknowledged: events.length, accepted: events.length, duplicates: 0, rejected: [] };
+  }
+};
+
+// 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";
+
+// src/http-sink.ts
+import { createHmac, randomUUID } from "node:crypto";
+var TIMEOUT_MS = 15e3;
+var HttpSink = class {
+  constructor(cfg, tier) {
+    this.cfg = cfg;
+    this.tier = tier;
+    this.name = cfg.name;
+    this.pii = !!cfg.pii;
+    this.url = cfg.url.replace(/\/$/, "");
+  }
+  cfg;
+  tier;
+  name;
+  pii;
+  url;
+  eventsUrl() {
+    const ep = this.cfg.endpoints?.events ?? "/api/sessionpipe/v1/events";
+    return /^https?:\/\//.test(ep) ? ep : this.url + ep;
+  }
+  async send(events) {
+    const body = JSON.stringify({ events });
+    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 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");
+      headers["webhook-id"] = id;
+      headers["webhook-timestamp"] = String(ts);
+      headers["webhook-signature"] = `v1,${sig}`;
+    }
+    const ctl = new AbortController();
+    const t = setTimeout(() => ctl.abort(), TIMEOUT_MS);
+    try {
+      const r = await fetch(this.eventsUrl(), { method: "POST", headers, body, signal: ctl.signal });
+      const text = await r.text();
+      let j = {};
+      try {
+        j = text ? JSON.parse(text) : {};
+      } catch {
+      }
+      if (r.status === 202 || r.status === 200) {
+        return {
+          ok: true,
+          acknowledged: events.length,
+          accepted: Number(j.accepted ?? events.length),
+          duplicates: Number(j.duplicates ?? 0),
+          rejected: Array.isArray(j.rejected) ? j.rejected : [],
+          ...typeof j.max_tier === "number" ? { max_tier: j.max_tier } : {},
+          status: r.status
+        };
+      }
+      const err = typeof j.reason === "string" ? j.reason : text.slice(0, 200);
+      if (r.status === 400) return { ok: false, acknowledged: 0, status: 400, error: err, action: "drop" };
+      if (r.status === 401) return { ok: false, acknowledged: 0, status: 401, error: err, action: "pause" };
+      if (r.status === 403)
+        return {
+          ok: false,
+          acknowledged: 0,
+          status: 403,
+          error: err,
+          action: "lower-tier",
+          ...typeof j.max_tier === "number" ? { max_tier: j.max_tier } : {}
+        };
+      if (r.status === 413) return { ok: false, acknowledged: 0, status: 413, error: err, action: "split" };
+      if (r.status === 429)
+        return {
+          ok: false,
+          acknowledged: 0,
+          status: 429,
+          error: err,
+          action: "retry",
+          retryAfterMs: Number(r.headers.get("retry-after") ?? 60) * 1e3
+        };
+      return { ok: false, acknowledged: 0, status: r.status, error: err, action: "retry" };
+    } catch (e) {
+      return { ok: false, acknowledged: 0, error: String(e.message ?? e), action: "retry" };
+    } finally {
+      clearTimeout(t);
+    }
+  }
+};
+
+// src/run.ts
+var VERSION = true ? "0.1.0" : "0.0.0";
+function log(state2, line) {
+  try {
+    mkdirSync7(state2, { recursive: true });
+    const f = path11.join(state2, "log");
+    try {
+      if (statSync5(f).size > 1024 * 1024) renameSync2(f, `${f}.1`);
+    } catch {
+    }
+    appendFileSync3(f, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+  } catch {
+  }
+}
+function factsState(state2) {
+  const file = (h, s) => path11.join(state2, "facts", safeId(h), `${safeId(s)}.json`);
+  return {
+    get(h, s) {
+      try {
+        return JSON.parse(readFileSync8(file(h, s), "utf8"));
+      } catch {
+        return {};
+      }
+    },
+    save(h, s, patch) {
+      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));
+    }
+  };
+}
+function buildSinks(sinks) {
+  const out2 = [];
+  for (const s of sinks) {
+    if (s.paused) continue;
+    const tier = Math.min(s.tier, 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(/^~(?=\/|$)/, os2.homedir()), tier, !!s.pii));
+    else if (/^https?:\/\//.test(s.url)) out2.push(new HttpSink(s, tier));
+  }
+  return out2;
+}
+async function runJob(job, opts = {}) {
+  const state2 = opts.state ?? stateDir();
+  const cfg = readConfig();
+  const adapter = adapterByName(job.harness);
+  if (!adapter) return { events: [], delivered: {} };
+  const r = adapter.fromHook({ argv: job.argv, stdin: job.stdin, env: { ...process.env, ...job.env }, cwd: job.cwd });
+  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);
+  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));
+    return { events: [], delivered: {} };
+  }
+  try {
+    const facts = factsState(state2);
+    const mem = facts.get(job.harness, r.session.id);
+    const heavy = !/^(PreToolUse|PostToolUse|PostToolUseFailure|BeforeTool|AfterTool|PostInvocation)$/.test(job.event);
+    let learned = {};
+    if (heavy) {
+      const f = adapter.facts(r.session, r.transcript, r.hints ?? {}, facts);
+      const { started_at: _s, last_at: _l, first_ask: _fa, harness_version, ...rest } = f;
+      learned = rest;
+      if (harness_version) facts.save(job.harness, r.session.id, { harness_version });
+      facts.save(job.harness, r.session.id, { session: { ...mem.session, ...learned } });
+    }
+    const known = mem.session ?? {};
+    const cwdRaw = learned.cwd ?? r.session.cwd ?? known.cwd;
+    const git = heavy ? gitFacts(cwdRaw) : {};
+    const session = {
+      ...known,
+      ...learned,
+      ...git,
+      ...learned.branch ? { branch: learned.branch } : {},
+      id: r.session.id,
+      seq: 0,
+      machine: machineName(cfg, os2.hostname()),
+      ...cwdRaw ? { cwd: tilde(cwdRaw) } : {},
+      ...r.session.model ? { model: r.session.model } : {}
+    };
+    const version = facts.get(job.harness, r.session.id).harness_version ?? void 0;
+    const events = [];
+    for (const a of r.events) {
+      const e = makeEvent(a, {
+        harness: { name: job.harness, ...version ? { version } : {} },
+        session: { ...session, seq: outbox.nextSeq(ref) },
+        now: opts.now ?? job.at
+      });
+      events.push(e);
+    }
+    const wantsTranscript = cfg.sinks.some((s) => !s.paused && Math.min(s.tier, s.max_tier ?? 3) >= 2);
+    if (wantsTranscript && r.transcript && r.events.some((e) => e.type === "turn.ended" || e.type === "session.ended")) {
+      const cur = facts.get(job.harness, r.session.id);
+      const fromLine = Number(cur.transcript_line) || 0;
+      let turnNo = Number(cur.transcript_turns) || 0;
+      const read = adapter.readTranscript(r.transcript, fromLine);
+      for (const t of read.turns) {
+        events.push(
+          makeEvent(
+            {
+              type: "turn.transcript",
+              harnessEvent: job.event,
+              data: { turn: turnNo++, user: t.user, assistant: t.assistant, at: new Date(t.at).toISOString() }
+            },
+            {
+              harness: { name: job.harness, ...version ? { version } : {} },
+              session: { ...session, seq: outbox.nextSeq(ref) },
+              now: opts.now ?? job.at
+            }
+          )
+        );
+      }
+      if (read.turns.length)
+        facts.save(job.harness, r.session.id, { transcript_line: read.line, transcript_turns: turnNo });
+    }
+    outbox.append(ref, events);
+    log(
+      state2,
+      `${job.harness} ${job.event}: ${events.map((e) => e.type).join(",") || "nothing"} (${r.session.id.slice(0, 8)})`
+    );
+    const delivered = await flush(state2, cfg.sinks, outbox, ref);
+    if (Math.random() < 0.02) outbox.prune(cfg.keep_days ?? 30);
+    return { events, delivered };
+  } finally {
+    release();
+  }
+}
+var BATCH = 50;
+var MAX_PER_RUN = 500;
+async function flush(state2, sinkConfigs, outbox, first) {
+  const delivered = {};
+  const sinks = buildSinks(sinkConfigs);
+  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);
+  }
+  for (const sink2 of sinks) {
+    const cursors = new Cursors(state2, sink2.name);
+    const c = cursors.read();
+    let sent = 0;
+    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 (!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;
+        }
+        offset = next;
+        c[cursors.key(ref)] = offset;
+        cursors.write(c);
+      }
+      if (stalled) break;
+    }
+    delivered[sink2.name] = sent;
+  }
+  return delivered;
+}
+function applySinkVerdict(name, res) {
+  try {
+    const cfg = readConfig();
+    const s = cfg.sinks.find((x) => x.name === name);
+    if (!s) return;
+    if (res.action === "pause") s.paused = `${(/* @__PURE__ */ new Date()).toISOString()} ${res.error ?? "unauthorized"}`;
+    if (res.action === "lower-tier" && typeof res.max_tier === "number") s.max_tier = res.max_tier;
+    writeConfig(cfg);
+  } catch {
+  }
+}
+var jobsDir = (state2) => path11.join(state2, "jobs");
+
+// src/cli.ts
+process.stdout.on("error", (e) => {
+  if (e.code === "EPIPE") process.exit(0);
+});
+var args = process.argv.slice(2);
+var cmd = args[0] ?? "help";
+var flag = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : void 0;
+};
+var has = (name) => args.includes(name);
+var out = (s = "") => {
+  process.stdout.write(`${s}
+`);
+};
+var state = stateDir();
+var distDir = path12.dirname(fileURLToPath(import.meta.url));
+function hookCommand() {
+  const node = stableNode(process.execPath);
+  let script = path12.join(distDir, "hook.js");
+  try {
+    script = realpathSync2(script);
+  } catch {
+  }
+  return (a) => ({
+    argv: [node, script, ...a],
+    command: `${JSON.stringify(node)} ${JSON.stringify(script)} ${a.join(" ")}`
+  });
+}
+function stableNode(exe) {
+  const m = /^(.*)\/Cellar\/(node(?:@\d+)?)\/[^/]+\/bin\/node$/.exec(exe);
+  if (!m) return exe;
+  let real;
+  try {
+    real = realpathSync2(exe);
+  } catch {
+    return exe;
+  }
+  for (const c of [`${m[1]}/opt/${m[2]}/bin/node`, `${m[1]}/bin/node`]) {
+    try {
+      if (realpathSync2(c) === real) return c;
+    } catch {
+    }
+  }
+  return exe;
+}
+var viaNpx = /[\\/]_npx[\\/]/.test(distDir) || /[\\/]\.npm[\\/]/.test(distDir);
+function selectedAdapters() {
+  const named = ADAPTERS.filter((a) => has(`--${a.name}`));
+  if (named.length) return named;
+  return ADAPTERS.filter((a) => a.detect());
+}
+async function main() {
+  switch (cmd) {
+    case "install":
+      return install();
+    case "uninstall":
+      return uninstall();
+    case "sink":
+      return sink();
+    case "status":
+      return status();
+    case "doctor":
+      return doctor();
+    case "tail":
+      return tail();
+    case "backfill":
+      return backfill();
+    case "forget":
+      return forget();
+    case "replay":
+      return replay();
+    case "update":
+      return update();
+    case "worker":
+      return workerFromArgv();
+    case "hook":
+      out("sessionpipe hook is dist/hook.js; harnesses run it directly");
+      return;
+    case "--version":
+    case "-v":
+    case "version":
+      out(VERSION);
+      return;
+    default:
+      return help();
+  }
+}
+function help() {
+  out(`sessionpipe ${VERSION} \u2014 an open protocol for what your coding agents are doing
+
+  sessionpipe install [--claude-code --codex --gemini-cli --antigravity] [--machine NAME] [--backfill DAYS] [--sink URL --tier N]
+  sessionpipe uninstall [--keep-state]
+  sessionpipe sink add <url|file:PATH|stdout> [--tier 0-3] [--token T] [--pii] [--control] [--name N]
+  sessionpipe sink list | remove <name> | test <name>
+  sessionpipe status | doctor [--json]
+  sessionpipe tail [--session ID] [--tier N] [--harness NAME]
+  sessionpipe backfill [--days 30] | forget <harness> <session> | replay --sink NAME
+  sessionpipe update
+
+Docs: https://sessionpipe.org \xB7 nothing leaves this machine until you add a sink.`);
+}
+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" });
+      return;
+    } catch {
+      out(
+        "  ! couldn't install globally (`npm install -g sessionpipe` failed). Run it yourself, then `sessionpipe install`."
+      );
+      process.exit(1);
+    }
+  }
+  const cfg = readConfig();
+  const machine = flag("--machine");
+  if (machine) cfg.machine = machine.slice(0, 80);
+  const adapters = selectedAdapters();
+  if (!adapters.length) {
+    out(
+      "  No supported harness found on this machine (Claude Code, Codex, Gemini CLI, Antigravity). Pass --<harness> to force one."
+    );
+    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."
+      );
+  }
+  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("");
+  const live = cfg.sinks.filter((s) => !s.paused);
+  if (live.length) out(`  Reporting to ${live.map((s) => `${s.name} (tier ${s.tier})`).join(", ")}.`);
+  else
+    out(
+      "  Nothing leaves this machine yet: events go to the local outbox. `sessionpipe tail` shows them; `sessionpipe sink add <url> --tier N` sends them."
+    );
+  out("  Sessions already running pick up hooks on their next start (Claude Code \u2265 2.1.280 picks them up live).");
+}
+function uninstall() {
+  for (const a of ADAPTERS) {
+    for (const r of a.uninstall()) if (r.changed) out(`  \u2713 ${a.name}: hooks removed from ${tilde(r.file)}`);
+  }
+  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).`
+    );
+  out("  Done. Every config file is byte-identical except for the entries sessionpipe wrote.");
+}
+async function sink() {
+  const sub = args[1];
+  const cfg = readConfig();
+  if (sub === "add" && args[2]) return sinkAdd(args[2], cfg);
+  if (sub === "list") {
+    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}` : ""}`
+      );
+    return;
+  }
+  if (sub === "remove" && args[2]) {
+    const n = cfg.sinks.length;
+    cfg.sinks = cfg.sinks.filter((s) => s.name !== args[2]);
+    writeConfig(cfg);
+    out(cfg.sinks.length < n ? `  \u2713 removed ${args[2]}` : `  no sink named ${args[2]}`);
+    return;
+  }
+  if (sub === "test" && args[2]) {
+    const s = cfg.sinks.find((x) => x.name === args[2]);
+    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 r = await sk.send([filterEvent(e, 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})`
+    );
+    return;
+  }
+  out(
+    "usage: sessionpipe sink add <url|file:PATH|stdout> [--tier N] [--token T] [--pii] [--control] [--name N] | list | remove <name> | test <name>"
+  );
+}
+async function sinkAdd(url, cfg) {
+  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);
+  const s = { name, url, tier, pii: has("--pii"), control: has("--control") };
+  const token = flag("--token");
+  if (token) s.token = token;
+  const secret = flag("--secret");
+  if (secret) s.secret = secret;
+  if (/^https?:\/\//.test(url)) {
+    try {
+      const r = await fetch(`${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();
+      if (s.control && !(wk.capabilities ?? []).includes("control")) {
+        out("  receiver does not list `control`; --control ignored");
+        s.control = false;
+      }
+    } catch (e) {
+      out(
+        `  ! ${url} has no readable /.well-known/sessionpipe (${e.message}); added anyway, at tier ${tier}`
+      );
+    }
+  }
+  cfg.sinks = cfg.sinks.filter((x) => x.name !== name).concat([s]);
+  writeConfig(cfg);
+  out(
+    `  \u2713 sink ${name}: ${url} at tier ${Math.min(tier, s.max_tier ?? 3)}${s.pii ? ", pii" : ""}${s.control ? ", control" : ""}`
+  );
+  out(`    tier ${tier} sends: ${TIER_TEXT[Math.min(tier, s.max_tier ?? 3)]}`);
+}
+var TIER_TEXT = {
+  0: "session state and timing, machine, folder, repo, branch, model, title, link, the KIND of attention needed \u2014 no tool names, no words",
+  1: "tier 0 + tool names, durations, ok/error, file paths, the attention message, subagents, compactions \u2014 no prompts",
+  2: "tier 1 + your prompts and the assistant's text, secrets removed",
+  3: "everything, including tool input and output"
+};
+function backfillRows(adapters, days, cfg) {
+  const since = Date.now() - days * 864e5;
+  const outbox = new Outbox(state);
+  let n = 0;
+  const machine = machineName(cfg, os3.hostname());
+  for (const a of adapters) {
+    for (const row of a.backfill(since)) {
+      const ref = { harness: a.name, session: row.session.id };
+      const facts = factsState(state).get(a.name, row.session.id);
+      if (facts.backfilled) continue;
+      const { id, ...rest } = row.session;
+      const e = makeEvent(
+        {
+          type: "session.backfill",
+          harnessEvent: "backfill",
+          data: {
+            started_at: new Date(row.started_at).toISOString(),
+            last_at: new Date(row.last_at).toISOString(),
+            ...row.turns !== void 0 ? { turns: row.turns } : {}
+          }
+        },
+        {
+          harness: { name: a.name },
+          session: { ...rest, id, seq: outbox.nextSeq(ref), machine, ...rest.cwd ? { cwd: tilde(rest.cwd) } : {} },
+          now: row.last_at
+        }
+      );
+      outbox.append(ref, [e]);
+      factsState(state).save(a.name, row.session.id, { backfilled: true });
+      n++;
+    }
+  }
+  out(`  \u2713 Backfill: ${n} session${n === 1 ? "" : "s"} from the last ${days} days queued as session.backfill`);
+  void flush(state, cfg.sinks, outbox);
+}
+function backfill() {
+  backfillRows(selectedAdapters(), Number(flag("--days") ?? 30), readConfig());
+}
+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, os3.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}`);
+  }
+  outbox.delete(ref);
+  out("  local outbox for the session removed");
+}
+async function replay() {
+  const name = flag("--sink");
+  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 d = await flush(state, sinks, new Outbox(state));
+  for (const [k, v] of Object.entries(d)) out(`  ${k}: ${v} event${v === 1 ? "" : "s"} delivered`);
+}
+function status() {
+  const cfg = readConfig();
+  const hc = hookCommand();
+  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}`);
+  }
+  if (!cfg.sinks.length) out("  sinks:    none (events stay in the local outbox)");
+  for (const s of cfg.sinks) {
+    const c = new Cursors(state, s.name).read();
+    const outbox = new Outbox(state);
+    let pending = 0;
+    for (const ref of outbox.sessions()) {
+      const f = outbox.file(ref);
+      try {
+        pending += Math.max(0, statSync6(f).size - (c[`${ref.harness}/${ref.session}`] ?? 0)) > 0 ? 1 : 0;
+      } catch {
+      }
+    }
+    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"}`
+    );
+  }
+  const t = timing();
+  if (t) out(`  hook:     p50 ${t.p50} ms \xB7 p95 ${t.p95} ms over ${t.n} runs`);
+  const jobs = jobsDir(state);
+  try {
+    const n = readdirSync6(jobs).length;
+    if (n) out(`  jobs:     ${n} waiting`);
+  } catch {
+  }
+}
+function timing() {
+  try {
+    const lines = readFileSync9(path12.join(state, "timing.jsonl"), "utf8").trim().split("\n").slice(-100);
+    const ms = lines.map((l) => JSON.parse(l).ms).filter((x) => x >= 0).sort((a, b) => a - b);
+    if (!ms.length) return null;
+    const q = (p) => Math.round(ms[Math.min(ms.length - 1, Math.floor(p * ms.length))] ?? 0);
+    return { n: ms.length, p50: q(0.5), p95: q(0.95) };
+  } catch {
+    return null;
+  }
+}
+function doctor() {
+  const cfg = readConfig();
+  const hc = hookCommand();
+  const report = {
+    version: VERSION,
+    node: process.version,
+    node_path: stableNode(process.execPath),
+    machine: machineName(cfg, os3.hostname()),
+    state,
+    config: configFile(),
+    harnesses: {},
+    sinks: [],
+    timing: timing(),
+    warnings: []
+  };
+  const warnings = report.warnings;
+  if (/\/Cellar\/node(?:@\d+)?\/[^/]+\//.test(distDir))
+    warnings.push(
+      "sessionpipe is installed inside Homebrew's versioned node folder; `brew upgrade node` will delete it. Install with `npm install -g --prefix ~/.local sessionpipe`."
+    );
+  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 }));
+    for (const r of st)
+      if (r.state === "stale")
+        warnings.push(
+          `${a.name}: the hook in ${tilde(r.file)} points at an old node or script path; run \`sessionpipe install\` again.`
+        );
+    for (const r of st)
+      if (r.state === "misplaced")
+        warnings.push(
+          `${a.name}: the notify line in ${tilde(r.file)} sits inside a [table], where Codex never reads it; run \`sessionpipe install\` again.`
+        );
+  }
+  for (const s of cfg.sinks)
+    report.sinks.push({
+      name: s.name,
+      url: s.url,
+      tier: s.tier,
+      max_tier: s.max_tier ?? null,
+      pii: !!s.pii,
+      control: !!s.control,
+      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?`);
+  if (has("--json")) {
+    out(JSON.stringify(report, null, 2));
+    return;
+  }
+  out(`  sessionpipe ${VERSION} \xB7 node ${process.version} at ${report.node_path}`);
+  out(`  config ${tilde(configFile())} \xB7 state ${tilde(state)}`);
+  for (const [h, st] of Object.entries(report.harnesses))
+    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}` : ""}`
+    );
+  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}`);
+  if (!warnings.length) out("  no warnings");
+}
+async function tail() {
+  const tier = Math.max(0, Math.min(3, Number(flag("--tier") ?? 1)));
+  const onlySession = flag("--session");
+  const onlyHarness = flag("--harness");
+  const outbox = new Outbox(state);
+  const offsets = /* @__PURE__ */ new Map();
+  const fmt = (e) => {
+    const t = e.time.slice(11, 19);
+    const d = e.data;
+    let detail = "";
+    switch (e.type) {
+      case "session.started":
+        detail = `source=${d.source}  ${e.session.cwd ?? ""} ${e.session.branch ?? ""}`;
+        break;
+      case "turn.started":
+        detail = d.prompt_chars !== void 0 ? `prompt_chars=${d.prompt_chars}` : "";
+        break;
+      case "tool.started":
+        detail = String(d.tool ?? "");
+        break;
+      case "tool.ended":
+        detail = `${d.tool} ${d.ok ? "ok" : "error"}${d.ms !== void 0 ? ` ${d.ms}ms` : ""}`;
+        break;
+      case "attention.needed":
+        detail = `${d.kind}${d.tool ? ` ${d.tool}` : ""}${d.message ? ` "${String(d.message).slice(0, 60)}"` : ""}`;
+        break;
+      case "turn.ended":
+        detail = String(d.reason ?? "");
+        break;
+      case "session.ended":
+        detail = `reason=${d.reason}`;
+        break;
+      case "turn.transcript":
+        detail = `#${d.turn} "${String(d.user).slice(0, 50).replace(/\s+/g, " ")}"`;
+        break;
+      case "session.backfill":
+        detail = `${e.session.title ?? ""}`;
+        break;
+      default:
+        detail = JSON.stringify(d).slice(0, 80);
+    }
+    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(state)}/outbox (Ctrl-C to stop)`);
+  for (const ref of outbox.sessions()) {
+    try {
+      offsets.set(`${ref.harness}/${ref.session}`, has("--all") ? 0 : statSync6(outbox.file(ref)).size);
+    } catch {
+    }
+  }
+  for (; ; ) {
+    for (const ref of outbox.sessions()) {
+      if (onlyHarness && ref.harness !== onlyHarness) continue;
+      if (onlySession && !ref.session.startsWith(onlySession)) continue;
+      const k = `${ref.harness}/${ref.session}`;
+      const from = offsets.get(k) ?? 0;
+      const { events, offset } = outbox.read(ref, from, 200);
+      offsets.set(k, offset);
+      for (const e of events) {
+        const f = filterEvent(e, tier, false);
+        if (f) out(has("--json") ? JSON.stringify(f) : fmt(f));
+      }
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+}
+async function workerFromArgv() {
+  const f = args[1];
+  if (!f) return;
+  const job = JSON.parse(readFileSync9(f, "utf8"));
+  try {
+    unlinkSync2(f);
+  } catch {
+  }
+  await runJob(job);
+}
+async function update() {
+  if (process.env.SESSIONPIPE_NO_UPDATE_CHECK) return out("  update check is off (SESSIONPIPE_NO_UPDATE_CHECK)");
+  try {
+    const r = await fetch("https://registry.npmjs.org/sessionpipe/latest", { signal: AbortSignal.timeout(8e3) });
+    const j = await r.json();
+    if (!j.version) throw new Error("no version");
+    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] : []], {
+      stdio: "inherit"
+    });
+    out("  re-arming hooks\u2026");
+    const bin = prefix ? path12.join(prefix, "bin", "sessionpipe") : "sessionpipe";
+    const p = spawn(bin, ["install", "--backfill", "0"], { stdio: "inherit" });
+    await new Promise((r2) => p.on("exit", r2));
+  } catch (e) {
+    out(`  couldn't check npm: ${e.message}`);
+  }
+}
+function prefixOf(p) {
+  const re = process.platform === "win32" ? /^(.*?)[\\/]node_modules[\\/]sessionpipe[\\/]/ : /^(.*)\/lib\/node_modules\/sessionpipe\//;
+  const m = re.exec(p);
+  return m?.[1] ?? null;
+}
+main().catch((e) => {
+  process.stderr.write(`sessionpipe: ${e.message}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map