sessionpipe-core 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,21 @@
-// sessionpipe-core 0.1.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe-core 0.2.0 · Apache-2.0 · https://sessionpipe.org
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/adapters/antigravity.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  realpathSync,
+  statSync as statSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
 import path4 from "node:path";
 
 // src/paths.ts
@@ -228,28 +242,67 @@ function readAntigravity(lines, from) {
 }
 
 // src/adapters/claude-shaped.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import path3 from "node:path";
 var OURS = /sessionpipe[^"\n]*[\\/]hook\.js"?\s+[a-z][a-z-]*\s+[A-Za-z]+\s*$/;
 var isOurs = (h) => Array.isArray(h?.hooks) && h.hooks.some((x) => typeof x.command === "string" && OURS.test(x.command));
-function readJson(file) {
+function readJsonFile(file) {
+  let raw;
   try {
-    return JSON.parse(readFileSync(file, "utf8"));
+    raw = readFileSync(file, "utf8");
   } catch {
-    return {};
+    return { ok: true, existed: false, value: {}, raw: "", indent: "  ", eol: "\n", finalNewline: true };
   }
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    const hint = /^\s*\/\/|\/\*/m.test(raw) ? "not plain JSON (it has comments)" : "not plain JSON";
+    return { ok: false, existed: true, reason: hint };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { ok: false, existed: true, reason: "not a JSON object" };
+  const eol = raw.includes("\r\n") ? "\r\n" : "\n";
+  const m = /^( +|\t+)\S/m.exec(raw);
+  const indent = m?.[1] ?? "  ";
+  return {
+    ok: true,
+    existed: true,
+    value,
+    raw,
+    indent,
+    eol,
+    finalNewline: /\r?\n$/.test(raw)
+  };
+}
+function formatJson(value, f) {
+  const text = JSON.stringify(value, null, f.indent).replace(/\n/g, f.eol);
+  return f.finalNewline ? text + f.eol : text;
 }
 function entryFor(event, harness, cmd, o) {
   const matcher = o.matcherFor(event);
   return {
     ...matcher !== void 0 ? { matcher } : {},
-    hooks: [{ type: "command", command: cmd([harness, event]).command, timeout: o.timeout }]
+    hooks: [{ type: "command", command: cmd([harness, event]).command, timeout: o.timeoutFor?.(event) ?? o.timeout }]
   };
 }
 function installClaudeShaped(file, harness, events, cmd, o) {
-  const settings2 = readJson(file);
+  const f = readJsonFile(file);
+  if (!f.ok) return { file, changed: false, skipped: true, note: `${f.reason}; not touched` };
+  const settings2 = f.value;
   const hooks = settings2.hooks && typeof settings2.hooks === "object" ? settings2.hooks : {};
   let changed = false;
+  const want = new Set(events);
+  for (const ev of Object.keys(hooks)) {
+    if (want.has(ev)) continue;
+    const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
+    const kept = list.filter((h) => !isOurs(h));
+    if (kept.length !== list.length) {
+      changed = true;
+      if (kept.length) hooks[ev] = kept;
+      else delete hooks[ev];
+    }
+  }
   for (const ev of events) {
     const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
     const entry2 = entryFor(ev, harness, cmd, o);
@@ -268,19 +321,19 @@ function installClaudeShaped(file, harness, events, cmd, o) {
   if (changed) {
     settings2.hooks = hooks;
     mkdirSync(path3.dirname(file), { recursive: true });
-    writeFileSync(file, `${JSON.stringify(settings2, null, 2)}
-`);
+    writeFileSync(file, formatJson(settings2, f));
   }
-  return { file, changed };
+  return { file, changed, created: !f.existed && changed };
 }
-function uninstallClaudeShaped(file, events) {
+function uninstallClaudeShaped(file, events, opts = {}) {
   if (!existsSync(file)) return { file, changed: false };
-  const raw = readFileSync(file, "utf8");
-  const settings2 = readJson(file);
+  const f = readJsonFile(file);
+  if (!f.ok) return { file, changed: false, skipped: true, note: `${f.reason}; not touched` };
+  const settings2 = f.value;
   const hooks = settings2.hooks;
   if (!hooks || typeof hooks !== "object") return { file, changed: false };
   let changed = false;
-  for (const ev of events) {
+  for (const ev of [...events, ...Object.keys(hooks)]) {
     const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
     const kept = list.filter((h) => !isOurs(h));
     if (kept.length !== list.length) {
@@ -291,13 +344,17 @@ function uninstallClaudeShaped(file, events) {
   }
   if (!changed) return { file, changed: false };
   if (!Object.keys(hooks).length) delete settings2.hooks;
-  const next = `${JSON.stringify(settings2, null, 2)}
-`;
-  if (next !== raw) writeFileSync(file, next);
+  if (opts.created && !Object.keys(settings2).length) {
+    unlinkSync(file);
+    return { file, changed: true, note: "removed (sessionpipe created it)" };
+  }
+  const next = formatJson(settings2, f);
+  if (next !== f.raw) writeFileSync(file, next);
   return { file, changed: true };
 }
 function installedClaudeShaped(file, harness, events, cmd, o) {
-  const hooks = readJson(file).hooks ?? {};
+  const f = readJsonFile(file);
+  const hooks = f.ok ? f.value.hooks ?? {} : {};
   let present = 0;
   let current = 0;
   for (const ev of events) {
@@ -306,6 +363,9 @@ function installedClaudeShaped(file, harness, events, cmd, o) {
     if (mine.length) present++;
     if (mine.length === 1 && JSON.stringify(mine[0]) === JSON.stringify(entryFor(ev, harness, cmd, o))) current++;
   }
+  for (const ev of Object.keys(hooks))
+    if (!events.includes(ev) && (Array.isArray(hooks[ev]) ? hooks[ev] : []).some((h) => isOurs(h)))
+      return "stale";
   if (!present) return "missing";
   return current === events.length ? "current" : "stale";
 }
@@ -320,10 +380,13 @@ var projectsDir = (env) => path4.join(gemini(env), "config", "projects");
 var dataDirs = (env) => ["antigravity", "antigravity-cli", "antigravity-ide"].map((d) => path4.join(gemini(env), d));
 var ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 var validTool = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
-function entry(cmd) {
+function entry(cmd, lean) {
   const handler = (e) => ({ type: "command", command: cmd([NAME, e]).command, timeout: 5 });
   const out = { enabled: true };
-  for (const e of AG_EVENTS) out[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
+  for (const e of AG_EVENTS) {
+    if (lean && e === "PreToolUse") continue;
+    out[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
+  }
   return out;
 }
 var antigravity = {
@@ -331,34 +394,49 @@ var antigravity = {
   events: AG_EVENTS,
   detect: (env = process.env) => existsSync2(path4.join(gemini(env), "config")) || dataDirs(env).some((d) => existsSync2(d)),
   configFiles: (env = process.env) => [hooksFile(env)],
-  install(cmd, env = process.env) {
+  install(cmd, env = process.env, opts = {}) {
     const file = hooksFile(env);
-    const hooks = readJson(file);
-    const e = entry(cmd);
+    const f = readJsonFile(file);
+    if (!f.ok) return [{ file, changed: false, skipped: true, note: `${f.reason}; not touched` }];
+    const hooks = f.value;
+    const e = entry(cmd, opts.lean);
     if (JSON.stringify(hooks[HOOK_NAME]) === JSON.stringify(e)) return [{ file, changed: false }];
     hooks[HOOK_NAME] = e;
     mkdirSync2(path4.dirname(file), { recursive: true });
-    writeFileSync2(file, `${JSON.stringify(hooks, null, 2)}
-`);
+    writeFileSync2(file, formatJson(hooks, f));
     return [
-      { file, changed: true, note: "hooks.json is read when a conversation starts; open ones report after a restart" }
+      {
+        file,
+        changed: true,
+        created: !f.existed,
+        note: "hooks.json is read when a conversation starts; open ones report after a restart"
+      }
     ];
   },
-  uninstall(env = process.env) {
+  uninstall(env = process.env, opts = {}) {
     const file = hooksFile(env);
     if (!existsSync2(file)) return [{ file, changed: false }];
-    const hooks = readJson(file);
+    const f = readJsonFile(file);
+    if (!f.ok) return [{ file, changed: false, skipped: true, note: `${f.reason}; not touched` }];
+    const hooks = f.value;
     if (!(HOOK_NAME in hooks)) return [{ file, changed: false }];
     delete hooks[HOOK_NAME];
-    writeFileSync2(file, `${JSON.stringify(hooks, null, 2)}
-`);
+    if (opts.created?.includes(file) && !Object.keys(hooks).length) {
+      unlinkSync2(file);
+      return [{ file, changed: true, note: "removed (sessionpipe created it)" }];
+    }
+    writeFileSync2(file, formatJson(hooks, f));
     return [{ file, changed: true }];
   },
-  installed(cmd, env = process.env) {
+  installed(cmd, env = process.env, opts = {}) {
     const file = hooksFile(env);
-    const have = readJson(file)[HOOK_NAME];
+    const f = readJsonFile(file);
+    const have = f.ok ? f.value[HOOK_NAME] : void 0;
     return [
-      { file, state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd)) ? "current" : "stale" }
+      {
+        file,
+        state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd, opts.lean)) ? "current" : "stale"
+      }
     ];
   },
   fromHook(input) {
@@ -624,9 +702,18 @@ var CLAUDE_EVENTS = [
   "SubagentStop",
   "PreCompact",
   "PostCompact",
-  "SessionEnd"
+  "SessionEnd",
+  "StopFailure"
 ];
-var OPTS = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
+var LEAN_SKIP = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUseFailure"]);
+var eventsFor = (lean) => lean ? CLAUDE_EVENTS.filter((e) => !LEAN_SKIP.has(e)) : [...CLAUDE_EVENTS];
+var OPTS = {
+  matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0,
+  timeout: 5,
+  // The hook waits up to 125 s for a verified control answer, and only when control
+  // is paired on this machine; everywhere else it exits in milliseconds as before.
+  timeoutFor: (e) => e === "PermissionRequest" ? 130 : void 0
+};
 var DESKTOP_ID = /^local_[A-Za-z0-9-]{1,64}$/;
 function claudeDirs(env = process.env, home = HOME) {
   const out = [];
@@ -657,11 +744,13 @@ var claudeCode = {
   events: CLAUDE_EVENTS,
   detect: (env = process.env) => claudeDirs(env).some((d) => existsSync3(d)),
   configFiles: (env = process.env) => claudeDirs(env).map(settingsIn),
-  install: (cmd, env = process.env) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd, OPTS)),
-  uninstall: (env = process.env) => claudeDirs(env).map((d) => uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS)),
-  installed: (cmd, env = process.env) => claudeDirs(env).map((d) => ({
+  install: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd, OPTS)),
+  uninstall: (env = process.env, opts = {}) => claudeDirs(env).map(
+    (d) => uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS, { created: opts.created?.includes(settingsIn(d)) })
+  ),
+  installed: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
     file: settingsIn(d),
-    state: installedClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd, OPTS)
+    state: installedClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd, OPTS)
   })),
   fromHook(input) {
     const event = input.argv[1] ?? "";
@@ -752,6 +841,15 @@ var claudeCode = {
       case "Stop":
         events.push(ev("turn.ended", { turn_id, reason: "stop" }));
         break;
+      case "StopFailure":
+        events.push(
+          ev("turn.ended", {
+            turn_id,
+            reason: "error",
+            error: typeof s.error === "string" ? s.error.slice(0, 200) : void 0
+          })
+        );
+        break;
       case "SubagentStart":
         events.push(
           ev("subagent.started", {
@@ -1263,6 +1361,7 @@ var CODEX_EVENTS = [
   "SessionEnd"
 ];
 var OPTS2 = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
+var eventsFor2 = (lean) => lean ? CODEX_EVENTS.filter((e) => e !== "PreToolUse") : [...CODEX_EVENTS];
 var codexHome = (env) => env.CODEX_HOME || path6.join(HOME, ".codex");
 var hooksFile2 = (env) => path6.join(codexHome(env), "hooks.json");
 var configFile2 = (env) => path6.join(codexHome(env), "config.toml");
@@ -1311,7 +1410,8 @@ function installNotify(cmd, env) {
     return {
       file,
       changed: false,
-      note: `left alone: notify runs ${n.raw.slice(0, 80)} (hooks.json carries the events; the notify fallback is off)`
+      skipped: true,
+      note: `notify belongs to ${(n.argv?.[0] ?? n.raw).replace(/^.*\//, "").slice(0, 40)}; left alone. Codex will report nothing until you approve the hooks: start \`codex\` and accept the hook review`
     };
   }
   write(withNotify(text, line));
@@ -1368,14 +1468,21 @@ var codex = {
   events: CODEX_EVENTS,
   detect: (env = process.env) => existsSync4(codexHome(env)),
   configFiles: (env = process.env) => [hooksFile2(env), configFile2(env)],
-  install: (cmd, env = process.env) => [
-    installClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd, OPTS2),
+  install: (cmd, env = process.env, opts = {}) => [
+    installClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd, OPTS2),
     installNotify(cmd, env)
   ],
-  uninstall: (env = process.env) => [uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS), uninstallNotify(env)],
-  installed: (cmd, env = process.env) => {
+  uninstall: (env = process.env, opts = {}) => [
+    uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS, { created: opts.created?.includes(hooksFile2(env)) }),
+    uninstallNotify(env)
+  ],
+  installed: (cmd, env = process.env, opts = {}) => {
     const out = [
-      { file: hooksFile2(env), state: installedClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd, OPTS2) }
+      {
+        file: hooksFile2(env),
+        state: installedClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd, OPTS2),
+        note: "Codex runs non-managed hooks only after the review in `codex` (/hooks); until then nothing is reported unless the notify fallback is ours"
+      }
     ];
     let text = "";
     try {
@@ -1563,6 +1670,7 @@ function codexFacts(file) {
 }
 
 // src/adapters/gemini-cli.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
 import path7 from "node:path";
 var NAME4 = "gemini-cli";
@@ -1580,17 +1688,61 @@ var OPTS3 = { matcherFor: (e) => /Tool/.test(e) ? ".*" : void 0, timeout: 5e3 };
 var geminiDir = (env) => env.GEMINI_CLI_HOME || path7.join(HOME, ".gemini");
 var settings = (env) => path7.join(geminiDir(env), "settings.json");
 var validTool4 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
+var eventsFor3 = (lean) => lean ? GEMINI_EVENTS.filter((e) => e !== "BeforeTool") : [...GEMINI_EVENTS];
+function geminiHooksActive(settingsFile) {
+  let tools;
+  try {
+    tools = JSON.parse(readFileSync5(settingsFile, "utf8")).tools;
+  } catch {
+  }
+  if (tools?.enableHooks === true) return { active: true };
+  if (tools?.enableHooks === false)
+    return { active: false, note: "inactive: tools.enableHooks is false in settings.json" };
+  let version = "";
+  try {
+    version = execFileSync3("gemini", ["--version"], {
+      encoding: "utf8",
+      timeout: 4e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return {
+      active: true,
+      note: "could not run `gemini --version`; hooks need tools.enableHooks on versions before 0.46"
+    };
+  }
+  const m = /(\d+)\.(\d+)/.exec(version);
+  if (m && (Number(m[1]) > 0 || Number(m[2]) >= 46)) return { active: true };
+  return {
+    active: false,
+    note: `inactive: Gemini CLI ${version || "?"} runs hooks only with "tools": {"enableHooks": true} in settings.json`
+  };
+}
 var geminiCli = {
   name: NAME4,
   events: GEMINI_EVENTS,
   // ~/.gemini also belongs to Antigravity; Gemini CLI is here when its settings or its chat logs exist.
   detect: (env = process.env) => existsSync5(settings(env)) || existsSync5(path7.join(geminiDir(env), "tmp")),
   configFiles: (env = process.env) => [settings(env)],
-  install: (cmd, env = process.env) => [installClaudeShaped(settings(env), NAME4, GEMINI_EVENTS, cmd, OPTS3)],
-  uninstall: (env = process.env) => [uninstallClaudeShaped(settings(env), GEMINI_EVENTS)],
-  installed: (cmd, env = process.env) => [
-    { file: settings(env), state: installedClaudeShaped(settings(env), NAME4, GEMINI_EVENTS, cmd, OPTS3) }
+  install: (cmd, env = process.env, opts = {}) => {
+    const r = installClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd, OPTS3);
+    const a = geminiHooksActive(settings(env));
+    return [a.note && !r.skipped ? { ...r, note: [r.note, a.note].filter(Boolean).join("; ") } : r];
+  },
+  uninstall: (env = process.env, opts = {}) => [
+    uninstallClaudeShaped(settings(env), GEMINI_EVENTS, { created: opts.created?.includes(settings(env)) })
   ],
+  installed: (cmd, env = process.env, opts = {}) => {
+    const state = installedClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd, OPTS3);
+    const a = geminiHooksActive(settings(env));
+    return [
+      {
+        file: settings(env),
+        state: state === "current" && !a.active ? "inactive" : state,
+        ...a.note ? { note: a.note } : {}
+      }
+    ];
+  },
   fromHook(input) {
     const event = input.argv[1] ?? "";
     let s = {};
@@ -1702,17 +1854,366 @@ function prune4(o) {
   return o;
 }
 
+// src/adapters/claude-code-control.ts
+var claude_code_control_exports = {};
+__export(claude_code_control_exports, {
+  JOB_TIMEOUT_MS: () => JOB_TIMEOUT_MS,
+  claudeEnv: () => claudeEnv,
+  detectCaps: () => detectCaps,
+  findClaude: () => findClaude,
+  findTranscript: () => findTranscript,
+  isUuid: () => isUuid,
+  liveProcess: () => liveProcess,
+  modeFlags: () => modeFlags,
+  parseCaps: () => parseCaps,
+  parseResult: () => parseResult,
+  recentlyWritten: () => recentlyWritten,
+  runClaude: () => runClaude,
+  sessionFolder: () => sessionFolder
+});
+import { execFileSync as execFileSync4, spawn } from "node:child_process";
+import { accessSync, closeSync as closeSync2, constants, openSync as openSync2, readdirSync as readdirSync5, readFileSync as readFileSync6, readSync as readSync2, statSync as statSync4 } from "node:fs";
+import os2 from "node:os";
+import path8 from "node:path";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var JOB_TIMEOUT_MS = 30 * 6e4;
+var OUT_CAP = 1024 * 1024;
+var LIVE_WRITE_MS = 9e4;
+function isExe(p) {
+  try {
+    if (!statSync4(p).isFile()) return false;
+    accessSync(p, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var cmpVersion = (a, b) => {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++)
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
+  return 0;
+};
+function findClaude(env = process.env, home = os2.homedir()) {
+  if (env.SESSIONPIPE_CLAUDE && isExe(env.SESSIONPIPE_CLAUDE)) return env.SESSIONPIPE_CLAUDE;
+  const names = process.platform === "win32" ? ["claude.exe", "claude.cmd"] : ["claude"];
+  for (const d of String(env.PATH || "").split(path8.delimiter)) {
+    if (!d || !path8.isAbsolute(d)) continue;
+    for (const n of names) if (isExe(path8.join(d, n))) return path8.join(d, n);
+  }
+  for (const p of [
+    path8.join(home, ".claude", "local", "claude"),
+    path8.join(home, ".local", "bin", "claude"),
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude"
+  ])
+    if (isExe(p)) return p;
+  const app = path8.join(home, "Library", "Application Support", "Claude", "claude-code");
+  let versions = [];
+  try {
+    versions = readdirSync5(app).filter((n) => /^\d+(\.\d+)*$/.test(n)).sort(cmpVersion).reverse();
+  } catch {
+  }
+  for (const v of versions) {
+    const p = path8.join(app, v, "claude.app", "Contents", "MacOS", "claude");
+    if (isExe(p)) return p;
+  }
+  return null;
+}
+function optionBlock(help, flag) {
+  const lines = help.split("\n");
+  const re = new RegExp(`^\\s{0,4}(?:-\\w, )?${flag.replace(/-/g, "\\-")}(?![\\w-])`);
+  const start = lines.findIndex((l) => re.test(l));
+  if (start < 0) return null;
+  const out = [lines[start]];
+  for (let i = start + 1; i < lines.length && lines[i]?.trim() && !/^\s{0,4}-/.test(lines[i]); i++)
+    out.push(lines[i]);
+  return out.join(" ");
+}
+function parseCaps(help) {
+  const pm = optionBlock(help, "--permission-mode");
+  const pp = optionBlock(help, "--permission-prompts");
+  return {
+    hasMode: !!pm,
+    modes: pm ? [...pm.matchAll(/"([A-Za-z]+)"/g)].map((m) => m[1]) : [],
+    promptsNone: !!pp && /"none"/.test(pp),
+    fork: !!optionBlock(help, "--fork-session")
+  };
+}
+function modeFlags(mode, caps) {
+  if (mode === "auto") {
+    if (!caps.modes.includes("auto"))
+      return { error: "this machine is in auto mode, but its Claude Code has no auto permission mode" };
+    return { args: ["--permission-mode", "auto"] };
+  }
+  if (caps.modes.includes("dontAsk")) return { args: ["--permission-mode", "dontAsk"] };
+  const args = [];
+  if (caps.hasMode)
+    args.push(
+      "--permission-mode",
+      caps.modes.includes("manual") && !caps.modes.includes("default") ? "manual" : "default"
+    );
+  if (caps.promptsNone) args.push("--permission-prompts", "none");
+  return { args };
+}
+function claudeEnv(configDir, env = process.env) {
+  const e = { ...env };
+  for (const k of [
+    "CLAUDECODE",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_HOST_SESSION_ID",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_SESSION_ATTENDED",
+    "CLAUDE_CODE_SSE_PORT"
+  ])
+    delete e[k];
+  e.SESSIONPIPE_CONTROL_JOB = "1";
+  if (configDir !== void 0) {
+    if (path8.resolve(configDir) === path8.resolve(os2.homedir(), ".claude")) delete e.CLAUDE_CONFIG_DIR;
+    else e.CLAUDE_CONFIG_DIR = configDir;
+  }
+  return e;
+}
+function detectCaps(bin) {
+  let help = "";
+  try {
+    help = execFileSync4(bin, ["--help"], {
+      encoding: "utf8",
+      timeout: 3e4,
+      env: claudeEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 4 * 1024 * 1024
+    });
+  } catch (e) {
+    help = String(e?.stdout || "");
+  }
+  return parseCaps(help);
+}
+function findTranscript(session, dirs) {
+  if (!UUID_RE.test(session)) return null;
+  for (const dir of dirs) {
+    let projects = [];
+    try {
+      projects = readdirSync5(path8.join(dir, "projects"), { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const p of projects) {
+      if (!p.isDirectory()) continue;
+      const file = path8.join(dir, "projects", p.name, `${session}.jsonl`);
+      try {
+        if (statSync4(file).isFile()) return { file, configDir: dir, project: p.name };
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+var projectName = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, "-");
+function sessionFolder(t, cap2 = 8 * 1024 * 1024) {
+  let first = null;
+  let count = 0;
+  let fd;
+  const look = (line) => {
+    if (line.indexOf('"cwd"') < 0) return null;
+    let j;
+    try {
+      j = JSON.parse(line.toString("utf8"));
+    } catch {
+      return null;
+    }
+    if (!j || typeof j.cwd !== "string" || !path8.isAbsolute(j.cwd)) return null;
+    if (projectName(j.cwd) === t.project) return j.cwd;
+    first ??= j.cwd;
+    count++;
+    return null;
+  };
+  try {
+    fd = openSync2(t.file, "r");
+    const buf = Buffer.alloc(256 * 1024);
+    let pos = 0;
+    let rest = Buffer.alloc(0);
+    let skipping = false;
+    while (pos < cap2 && count < 50) {
+      const n = readSync2(fd, buf, 0, buf.length, pos);
+      if (!n) {
+        if (!skipping && rest.length) {
+          const hit = look(rest);
+          if (hit) return hit;
+        }
+        break;
+      }
+      pos += n;
+      let chunk = rest.length ? Buffer.concat([rest, buf.subarray(0, n)]) : buf.subarray(0, n);
+      let nl = chunk.indexOf(10);
+      while (nl >= 0) {
+        const line = chunk.subarray(0, nl);
+        chunk = chunk.subarray(nl + 1);
+        if (skipping) skipping = false;
+        else {
+          const hit = look(line);
+          if (hit) return hit;
+        }
+        nl = chunk.indexOf(10);
+      }
+      if (chunk.length > 2 * 1024 * 1024) {
+        skipping = true;
+        rest = Buffer.alloc(0);
+      } else rest = skipping ? Buffer.alloc(0) : Buffer.from(chunk);
+    }
+  } catch {
+  } finally {
+    if (fd !== void 0)
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+  }
+  return first;
+}
+function pidAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function liveProcess(session, configDir) {
+  let names = [];
+  try {
+    names = readdirSync5(path8.join(configDir, "sessions")).filter((n) => /^\d+\.json$/.test(n));
+  } catch {
+    return false;
+  }
+  for (const n of names) {
+    try {
+      const j = JSON.parse(readFileSync6(path8.join(configDir, "sessions", n), "utf8"));
+      if (String(j.sessionId) !== session) continue;
+      if (pidAlive(Number(j.pid ?? n.slice(0, -5)))) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function recentlyWritten(file, ourLastEnd, now = Date.now()) {
+  let m;
+  try {
+    m = statSync4(file).mtimeMs;
+  } catch {
+    return false;
+  }
+  if (now - m > LIVE_WRITE_MS) return false;
+  return !(ourLastEnd && m <= ourLastEnd + 2e3);
+}
+function runClaude(bin, args, o) {
+  return new Promise((resolve) => {
+    let out = [];
+    let outLen = 0;
+    let tooBig = false;
+    let errTail = "";
+    let timedOut = false;
+    let settled = false;
+    let child;
+    try {
+      child = spawn(bin, args, {
+        cwd: o.cwd,
+        env: o.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+        windowsHide: true
+      });
+    } catch (e) {
+      resolve({ error: e.message });
+      return;
+    }
+    const kill = (sig) => {
+      try {
+        if (process.platform !== "win32" && child.pid) process.kill(-child.pid, sig);
+        else child.kill(sig);
+      } catch {
+        try {
+          child.kill(sig);
+        } catch {
+        }
+      }
+    };
+    child.stdout?.on("data", (b) => {
+      if (tooBig) return;
+      if (outLen + b.length > OUT_CAP) {
+        tooBig = true;
+        out = [];
+        return;
+      }
+      out.push(b);
+      outLen += b.length;
+    });
+    child.stderr?.on("data", (b) => {
+      errTail = (errTail + b.toString("utf8")).slice(-4e3);
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill("SIGTERM");
+      setTimeout(() => kill("SIGKILL"), 1e4).unref();
+    }, o.timeoutMs ?? JOB_TIMEOUT_MS);
+    const result = (code, signal) => ({
+      code,
+      signal,
+      stdout: tooBig ? null : Buffer.concat(out).toString("utf8"),
+      tooBig,
+      stderr: errTail,
+      timedOut
+    });
+    const finish = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(r);
+    };
+    child.on("error", (e) => finish({ error: e.message }));
+    child.on("exit", (code, signal) => setTimeout(() => finish(result(code, signal)), 2e3).unref());
+    child.on("close", (code, signal) => finish(result(code, signal)));
+  });
+}
+function parseResult(stdout) {
+  const s = String(stdout || "").trim();
+  if (!s) return null;
+  const pick = (j) => {
+    if (Array.isArray(j)) {
+      for (let i = j.length - 1; i >= 0; i--) if (j[i]?.type === "result") return j[i];
+      return null;
+    }
+    return j && typeof j === "object" ? j : null;
+  };
+  try {
+    return pick(JSON.parse(s));
+  } catch {
+  }
+  const lines = s.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const j = pick(JSON.parse(lines[i]));
+      if (j && (j.type === "result" || "result" in j)) return j;
+    } catch {
+    }
+  }
+  return null;
+}
+var isUuid = (s) => typeof s === "string" && UUID_RE.test(s);
+
 // src/adapters/index.ts
 var ADAPTERS = [claudeCode, codex, geminiCli, antigravity];
 var adapterByName = (name) => ADAPTERS.find((a) => a.name === name);
 
 // 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";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import path9 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"));
+    const j = JSON.parse(readFileSync7(file, "utf8"));
     return {
       ...DEFAULT_CONFIG,
       ...j,
@@ -1724,7 +2225,7 @@ function readConfig(file = configFile()) {
   }
 }
 function writeConfig(c, file = configFile()) {
-  mkdirSync4(path8.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync4(path9.dirname(file), { recursive: true, mode: 448 });
   writeFileSync4(file, `${JSON.stringify(c, null, 2)}
 `, { mode: 384 });
   if (process.platform !== "win32" && existsSync6(file)) {
@@ -1793,32 +2294,32 @@ function makeEvent(a, ctx) {
 // src/outbox.ts
 import {
   appendFileSync,
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   existsSync as existsSync7,
   mkdirSync as mkdirSync5,
-  openSync as openSync2,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync7,
-  readSync as readSync2,
+  openSync as openSync3,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync8,
+  readSync as readSync3,
   renameSync,
-  statSync as statSync4,
-  unlinkSync,
+  statSync as statSync5,
+  unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 var Outbox = class {
   constructor(root) {
     this.root = root;
   }
   root;
   dir(harness) {
-    return path9.join(this.root, "outbox", safeId(harness));
+    return path10.join(this.root, "outbox", safeId(harness));
   }
   file(ref) {
-    return path9.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
+    return path10.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
   }
   seqFile(ref) {
-    return path9.join(this.dir(ref.harness), `${safeId(ref.session)}.seq`);
+    return path10.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). */
@@ -1826,18 +2327,18 @@ var Outbox = class {
     const f = this.seqFile(ref);
     let n = 0;
     try {
-      n = Number(readFileSync7(f, "utf8")) || 0;
+      n = Number(readFileSync8(f, "utf8")) || 0;
     } catch {
       n = this.lastSeqInFile(ref) + 1;
     }
-    mkdirSync5(path9.dirname(f), { recursive: true });
-    writeFileSync5(f, String(n + 1));
+    mkdirSync5(path10.dirname(f), { recursive: true, mode: 448 });
+    writeFileSync5(f, String(n + 1), { mode: 384 });
     return n;
   }
   lastSeqInFile(ref) {
     const f = this.file(ref);
     if (!existsSync7(f)) return -1;
-    const lines = readFileSync7(f, "utf8").trim().split("\n");
+    const lines = readFileSync8(f, "utf8").trim().split("\n");
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
         const j = JSON.parse(lines[i] ?? "");
@@ -1849,26 +2350,26 @@ var Outbox = class {
   }
   append(ref, events) {
     if (!events.length) return;
-    mkdirSync5(this.dir(ref.harness), { recursive: true });
+    mkdirSync5(this.dir(ref.harness), { recursive: true, mode: 448 });
     appendFileSync(this.file(ref), `${events.map((e) => JSON.stringify(e)).join("\n")}
-`);
+`, { mode: 384 });
   }
   /** Every session file, newest first. */
   sessions() {
     const out = [];
-    const base = path9.join(this.root, "outbox");
+    const base = path10.join(this.root, "outbox");
     if (!existsSync7(base)) return [];
-    for (const h of readdirSync5(base)) {
-      const d = path9.join(base, h);
+    for (const h of readdirSync6(base)) {
+      const d = path10.join(base, h);
       let names = [];
       try {
-        names = readdirSync5(d).filter((n) => n.endsWith(".jsonl"));
+        names = readdirSync6(d).filter((n) => n.endsWith(".jsonl"));
       } catch {
         continue;
       }
       for (const n of names) {
         try {
-          out.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync4(path9.join(d, n)).mtimeMs });
+          out.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync5(path10.join(d, n)).mtimeMs });
         } catch {
         }
       }
@@ -1880,12 +2381,12 @@ var Outbox = class {
   read(ref, from, maxEvents = 500) {
     const f = this.file(ref);
     if (!existsSync7(f)) return { events: [], offset: from };
-    const size = statSync4(f).size;
+    const size = statSync5(f).size;
     if (from >= size) return { events: [], offset: from };
-    const fd = openSync2(f, "r");
+    const fd = openSync3(f, "r");
     try {
       const buf = Buffer.alloc(Math.min(size - from, 8 * 1024 * 1024));
-      const n = readSync2(fd, buf, 0, buf.length, from);
+      const n = readSync3(fd, buf, 0, buf.length, from);
       const text = buf.subarray(0, n).toString("utf8");
       const events = [];
       let offset = from;
@@ -1904,7 +2405,7 @@ var Outbox = class {
       }
       return { events, offset };
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
   }
   /** Files older than `days` are pruned; the cursor files with them. */
@@ -1914,10 +2415,10 @@ var Outbox = class {
     for (const ref of this.sessions()) {
       const f = this.file(ref);
       try {
-        if (statSync4(f).mtimeMs < cutoff) {
-          unlinkSync(f);
+        if (statSync5(f).mtimeMs < cutoff) {
+          unlinkSync3(f);
           try {
-            unlinkSync(this.seqFile(ref));
+            unlinkSync3(this.seqFile(ref));
           } catch {
           }
           n++;
@@ -1930,7 +2431,7 @@ var Outbox = class {
   delete(ref) {
     for (const f of [this.file(ref), this.seqFile(ref)]) {
       try {
-        unlinkSync(f);
+        unlinkSync3(f);
       } catch {
       }
     }
@@ -1944,20 +2445,20 @@ var Cursors = class {
   root;
   sink;
   file() {
-    return path9.join(this.root, "cursors", `${safeId(this.sink)}.json`);
+    return path10.join(this.root, "cursors", `${safeId(this.sink)}.json`);
   }
   read() {
     try {
-      return JSON.parse(readFileSync7(this.file(), "utf8"));
+      return JSON.parse(readFileSync8(this.file(), "utf8"));
     } catch {
       return {};
     }
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path9.dirname(f), { recursive: true });
+    mkdirSync5(path10.dirname(f), { recursive: true, mode: 448 });
     const tmp = `${f}.${process.pid}.tmp`;
-    writeFileSync5(tmp, JSON.stringify(c));
+    writeFileSync5(tmp, JSON.stringify(c), { mode: 384 });
     renameSync(tmp, f);
   }
   key(ref) {
@@ -1965,11 +2466,11 @@ var Cursors = class {
   }
 };
 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`);
+  const dir = path10.join(root, "locks");
+  mkdirSync5(dir, { recursive: true, mode: 448 });
+  const f = path10.join(dir, `${safeId(ref.harness)}-${safeId(ref.session)}.lock`);
   try {
-    if (Date.now() - statSync4(f).mtimeMs > staleMs) unlinkSync(f);
+    if (Date.now() - statSync5(f).mtimeMs > staleMs) unlinkSync3(f);
     else return null;
   } catch {
   }
@@ -1980,7 +2481,7 @@ function takeLock(root, ref, staleMs = 5 * 6e4) {
   }
   return () => {
     try {
-      unlinkSync(f);
+      unlinkSync3(f);
     } catch {
     }
   };
@@ -2116,7 +2617,7 @@ function redactAssignments(text) {
 function isSecretName(name) {
   if (/^[A-Z0-9_]+_KEY$/.test(name)) return true;
   const flat = name.toLowerCase().replace(/[_-]/g, "");
-  return /(?:pass(?:word|wd|phrase|code)?|pwd|secret|secretkey|secretaccesskey|clientsecret|apikey|accesskey|accesstoken|authtoken|refreshtoken|privatekey|token|credential|creds)s?$/.test(
+  return /(?:pass(?:word|wd|phrase|code)|pwd|secret|secretkey|secretaccesskey|clientsecret|apikey|accesskey|accesstoken|authtoken|refreshtoken|privatekey|token|credential|creds)s?$/.test(
     flat
   );
 }
@@ -2208,7 +2709,7 @@ var DATA_ALLOW = {
   "session.backfill": { 0: ["started_at", "last_at", "turns"] },
   "session.forgotten": { 0: [] },
   "turn.started": { 0: ["turn_id"], 1: ["prompt_chars"] },
-  "turn.ended": { 0: ["turn_id", "reason", "ms"] },
+  "turn.ended": { 0: ["turn_id", "reason", "ms"], 1: ["error"] },
   "turn.transcript": { 2: ["turn", "user", "assistant", "at"] },
   "tool.started": { 1: ["tool", "call_id", "turn_id", "agent_id"], 3: ["input"] },
   "tool.ended": { 1: ["tool", "call_id", "turn_id", "agent_id", "ms", "ok", "error"], 3: ["input", "output"] },
@@ -2286,7 +2787,7 @@ function filterEvent(event, tier, pii, opts = {}) {
 
 // src/sinks/file.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
     this.name = name;
@@ -2300,7 +2801,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path10.dirname(this.file), { recursive: true });
+      mkdirSync6(path11.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: [] };
@@ -2347,6 +2848,8 @@ export {
   adapterByName,
   antigravity,
   claudeCode,
+  claude_code_control_exports as claudeControl,
+  claudeDirs,
   codex,
   configFile,
   filterEvent,