sessionpipe-conformance 0.1.0

package/dist/index.js

@@ -0,0 +1,1753 @@
+// sessionpipe-conformance 0.1.0 · Apache-2.0 · https://sessionpipe.org
+
+// src/index.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+
+// ../core/src/adapters/antigravity.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path3 from "node:path";
+
+// ../core/src/paths.ts
+import os from "node:os";
+var HOME = os.homedir();
+
+// ../core/src/readers/files.ts
+import { closeSync, fstatSync, openSync, readdirSync, readSync, statSync } from "node:fs";
+import path 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 tail = size > headBytes ? read(Math.max(0, size - tailBytes), Math.min(size, tailBytes)) : head;
+    return { head: head.split("\n").slice(0, -1), tail: tail.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, cap = 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 < cap) {
+      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 out = [];
+  const walk = (dir, d) => {
+    let names = [];
+    try {
+      names = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of names) {
+      const p = path.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) out.push(p);
+      } catch {
+      }
+    }
+  };
+  walk(root, 0);
+  return out;
+}
+
+// ../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 path2 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, cmd, o) {
+  const matcher = o.matcherFor(event);
+  return {
+    ...matcher !== void 0 ? { matcher } : {},
+    hooks: [{ type: "command", command: cmd([harness, event]).command, timeout: o.timeout }]
+  };
+}
+function installClaudeShaped(file, harness, events, cmd, 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, cmd, 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(path2.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, cmd, 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, cmd, 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 || path3.join(HOME, ".gemini");
+var hooksFile = (env) => path3.join(gemini(env), "config", "hooks.json");
+var projectsDir = (env) => path3.join(gemini(env), "config", "projects");
+var dataDirs = (env) => ["antigravity", "antigravity-cli", "antigravity-ide"].map((d) => path3.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) {
+  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)];
+  return out;
+}
+var antigravity = {
+  name: NAME,
+  events: AG_EVENTS,
+  detect: (env = process.env) => existsSync2(path3.join(gemini(env), "config")) || dataDirs(env).some((d) => existsSync2(d)),
+  configFiles: (env = process.env) => [hooksFile(env)],
+  install(cmd, env = process.env) {
+    const file = hooksFile(env);
+    const hooks = readJson(file);
+    const e = entry(cmd);
+    if (JSON.stringify(hooks[HOOK_NAME]) === JSON.stringify(e)) return [{ file, changed: false }];
+    hooks[HOOK_NAME] = e;
+    mkdirSync2(path3.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(cmd, env = process.env) {
+    const file = hooksFile(env);
+    const have = readJson(file)[HOOK_NAME];
+    return [
+      { file, state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd)) ? "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, state) {
+    if (!transcript) return {};
+    return antigravityFacts(transcript, {
+      conversation: session.id,
+      workspaces: hints.workspaces ?? (session.cwd ? [session.cwd] : []),
+      state,
+      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(path3.join(data, "brain")).filter((n) => /^[0-9a-f-]{36}$/i.test(n));
+      } catch {
+      }
+      for (const id of ids) {
+        const f = path3.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 (!path3.isAbsolute(s)) return null;
+  return path3.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 out = [p];
+  try {
+    const r = realpathSync.native(p);
+    if (r !== p) out.push(r);
+  } catch {
+  }
+  return out;
+}
+function agProjects(dir) {
+  const out = [];
+  let names = [];
+  try {
+    names = readdirSync2(dir).filter((n) => n.endsWith(".json"));
+  } catch {
+    return out;
+  }
+  for (const n of names) {
+    const id = n.slice(0, -5);
+    if (!ID_RE.test(id)) continue;
+    let j;
+    try {
+      j = JSON.parse(readFileSync2(path3.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) out.push({ id, folders });
+  }
+  return out;
+}
+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(path3.sep) ? f : f + path3.sep));
+      if (within && f.length > bestLen) {
+        best = pr.id;
+        bestLen = f.length;
+      }
+    }
+  return best;
+}
+function antigravityRemoteUrl(transcript, opts) {
+  const i = transcript.indexOf(`${path3.sep}brain${path3.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(path3.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 } = ends(file, 128 * 1024, 64 * 1024);
+  const H = parseLines(head);
+  const T = parseLines(tail);
+  const out = {};
+  const url = antigravityRemoteUrl(file, opts);
+  if (url) out.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;
+    out.title = line.length > 80 ? `${line.slice(0, 80).replace(/\s+\S*$/, "")}\u2026` : line;
+    out.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) {
+    out.started_at = Math.min(...times);
+    out.last_at = Math.max(...times);
+  }
+  return out;
+}
+
+// ../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 path4 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 = (args) => {
+    try {
+      return execFileSync("git", ["-C", cwd, ...args], {
+        encoding: "utf8",
+        timeout: 1500,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+      return "";
+    }
+  };
+  const out = {};
+  const repo = run(["remote", "get-url", "origin"]);
+  if (repo) out.repo = stripCredentials(repo);
+  const branch = run(["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (branch && branch !== "HEAD") out.branch = branch;
+  cache.set(cwd, out);
+  return out;
+}
+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 out = [];
+  const add = (d) => {
+    if (!d) return;
+    const r = path4.resolve(d);
+    if (!out.includes(r)) out.push(r);
+  };
+  add(path4.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 = path4.join(home, e.name);
+      if (existsSync3(path4.join(d, "projects")) || existsSync3(path4.join(d, "settings.json"))) add(d);
+    }
+  } catch {
+  }
+  return out.filter((d, i) => i === 0 || existsSync3(d));
+}
+var settingsIn = (dir) => path4.join(dir, "settings.json");
+var configDirOf = (transcript) => path4.dirname(path4.dirname(path4.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: (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) => ({
+    file: settingsIn(d),
+    state: installedClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd, 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, state) {
+    const out = {};
+    if (transcript) Object.assign(out, claudeFacts(transcript, session.id, hints, state));
+    const cwd = out.cwd ?? session.cwd;
+    Object.assign(out, gitFacts(cwd), out.branch ? { branch: out.branch } : {});
+    if (!out.url && typeof hints.desktop_id === "string") out.url = `claude://code/continue/${hints.desktop_id}`;
+    return out;
+  },
+  backfill(sinceMs, env = process.env) {
+    const rows = [];
+    const files = [];
+    for (const d of claudeDirs(env))
+      files.push(...recentFiles(path4.join(d, "projects"), 1, sinceMs, (n) => /^[0-9a-f-]{36}\.jsonl$/.test(n)));
+    const noState = { get: () => ({}), save: () => {
+    } };
+    for (const f of files) {
+      const id = path4.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(path4.join(dir, "sessions")).filter((n) => n.endsWith(".json"));
+  } catch {
+  }
+  for (const n of names) {
+    try {
+      const e = registryEntry(JSON.parse(readFileSync3(path4.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(path4.join(dir, "sessions", `${pid}.json`), "utf8")));
+  } catch {
+    return null;
+  }
+}
+function claudePid(env = process.env) {
+  try {
+    const dirs = claudeDirs(env);
+    const has = (pid2) => dirs.some((d) => existsSync3(path4.join(d, "sessions", `${pid2}.json`)));
+    let pid = process.ppid;
+    if (has(pid)) return pid;
+    const parent = parentOf();
+    for (let hop = 0; hop < 6 && pid > 1; hop++) {
+      pid = parent(pid);
+      if (pid > 1 && has(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 out = execFileSync2("ps", ["-axo", "pid=,ppid="], {
+      encoding: "utf8",
+      timeout: 2e3,
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    for (const l of out.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 = [path4.join(dir, ".claude.json")];
+  if (path4.resolve(dir) === path4.join(HOME, ".claude")) files.unshift(path4.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 out = { custom: found.custom ?? null, ai: found.ai ?? null, upto: from };
+  let size = 0;
+  try {
+    size = statSync3(file).size;
+  } catch {
+    return out;
+  }
+  if (size < from) {
+    out.upto = 0;
+    out.custom = out.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) out.custom = j.customTitle;
+        if (j.type === "ai-title" && j.aiTitle) out.ai = j.aiTitle;
+      } catch {
+      }
+      return null;
+    },
+    512 * 1024 * 1024
+  );
+  out.upto = size;
+  return out;
+}
+function claudeFacts(file, sessionId, hints, state) {
+  const { head, tail } = ends(file, 64 * 1024, 256 * 1024);
+  const H = parseLines(head);
+  const T = parseLines(tail);
+  const out = {};
+  const id = sessionId || path4.basename(file, ".jsonl");
+  const mem = state.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;
+    state.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) state.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) {
+    out.url = url;
+    state.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) state.save(NAME2, id, { first_ask_none: true });
+  }
+  if (ask) {
+    out.first_ask = ask;
+    if (!mem.first_ask) state.save(NAME2, id, { first_ask: ask });
+  }
+  if (pick) {
+    out.title = String(pick.title).slice(0, 120);
+    out.title_source = pick.source;
+  } else if (ask) {
+    out.title = ask;
+    out.title_source = "first-ask";
+  }
+  const acct = claudeAccount(dir);
+  if (acct) out.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>") {
+      out.model = m;
+      break;
+    }
+  }
+  const meta = [...T].reverse().find((j) => j.version) ?? H.find((j) => j.version);
+  if (meta?.version) out.harness_version = String(meta.version);
+  const times = H.concat(T).map((j) => Date.parse(String(j.timestamp ?? ""))).filter((n) => n > 0);
+  if (times.length) {
+    out.started_at = Math.min(...times);
+    out.last_at = Math.max(...times);
+  }
+  const withCwd = H.find((j) => typeof j.cwd === "string");
+  if (withCwd) {
+    out.cwd = withCwd.cwd;
+    if (typeof withCwd.gitBranch === "string" && withCwd.gitBranch !== "HEAD") out.branch = withCwd.gitBranch;
+  }
+  return out;
+}
+
+// ../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 path5 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, 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(tail);
+  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 } = split(text);
+  if (!tail) return (head.trim() ? head.replace(/\s*$/, "\n") : "") + line + "\n";
+  return `${(head.trim() ? head.replace(/\s*$/, "\n") : "") + line}
+
+${tail}`;
+}
+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 || path5.join(HOME, ".codex");
+var hooksFile2 = (env) => path5.join(codexHome(env), "hooks.json");
+var configFile = (env) => path5.join(codexHome(env), "config.toml");
+var sessionsDir = (env) => path5.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(cmd, env) {
+  const file = configFile(env);
+  let text = "";
+  try {
+    text = readFileSync4(file, "utf8");
+  } catch {
+  }
+  const argv = cmd([NAME3, "notify"]).argv;
+  const line = `notify = ${JSON.stringify(argv)}`;
+  const n = readNotify(text);
+  const write = (next) => {
+    mkdirSync3(path5.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 = configFile(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 = path5.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), configFile(env)],
+  install: (cmd, env = process.env) => [
+    installClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd, OPTS2),
+    installNotify(cmd, env)
+  ],
+  uninstall: (env = process.env) => [uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS), uninstallNotify(env)],
+  installed: (cmd, env = process.env) => {
+    const out = [
+      { file: hooksFile2(env), state: installedClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd, OPTS2) }
+    ];
+    let text = "";
+    try {
+      text = readFileSync4(configFile(env), "utf8");
+    } catch {
+    }
+    const n = readNotify(text);
+    const argv = cmd([NAME3, "notify"]).argv;
+    const prev = n ? previousNotify(n.argv) : null;
+    const ours = n && (!n.other || prev && JSON.stringify(prev) === JSON.stringify(argv));
+    out.push({
+      file: configFile(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 out;
+  },
+  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 out = {};
+    if (transcript) Object.assign(out, codexFacts(transcript));
+    return out;
+  },
+  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(path5.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 } = ends(file, 128 * 1024, 64 * 1024);
+  const H = parseLines(head);
+  const T = parseLines(tail);
+  const out = {};
+  const meta = H.find((j) => j.type === "session_meta" && j.payload);
+  if (meta?.payload) {
+    const p = meta.payload;
+    if (p.cwd) out.cwd = p.cwd;
+    if (p.cli_version) out.harness_version = String(p.cli_version);
+    if (p.git?.branch) out.branch = p.git.branch;
+    if (p.git?.repository_url) out.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) out.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()) ?? "";
+    out.title = line.length > 80 ? `${line.slice(0, 80).replace(/\s+\S*$/, "")}\u2026` : line;
+    out.title_source = "first-ask";
+    break;
+  }
+  const times = H.concat(T).map((j) => Date.parse(String(j.timestamp ?? ""))).filter((n) => n > 0);
+  if (times.length) {
+    out.started_at = Math.min(...times);
+    out.last_at = Math.max(...times);
+  }
+  return out;
+}
+
+// ../core/src/adapters/gemini-cli.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import path6 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 || path6.join(HOME, ".gemini");
+var settings = (env) => path6.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(path6.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) }
+  ],
+  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 out = {};
+    if (!transcript) return out;
+    const { head, tail } = ends(transcript, 64 * 1024, 64 * 1024);
+    const H = parseLines(head);
+    const T = parseLines(tail);
+    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()) ?? "";
+      out.title = line.length > 80 ? `${line.slice(0, 80).replace(/\s+\S*$/, "")}\u2026` : line;
+      out.title_source = "first-ask";
+    }
+    const times = H.concat(T).map((j) => Date.parse(String(j.timestamp ?? ""))).filter((n) => n > 0);
+    if (times.length) {
+      out.started_at = Math.min(...times);
+      out.last_at = Math.max(...times);
+    }
+    return out;
+  },
+  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);
+
+// src/index.ts
+function matches(expect, got, pathStr = "") {
+  if (expect === "*") return null;
+  if (Array.isArray(expect)) {
+    if (!Array.isArray(got) || got.length !== expect.length) return `${pathStr}: expected ${expect.length} items`;
+    for (let i = 0; i < expect.length; i++) {
+      const r = matches(expect[i], got[i], `${pathStr}[${i}]`);
+      if (r) return r;
+    }
+    return null;
+  }
+  if (expect && typeof expect === "object") {
+    if (!got || typeof got !== "object") return `${pathStr}: expected an object`;
+    for (const [k, v] of Object.entries(expect)) {
+      const r = matches(v, got[k], `${pathStr}.${k}`);
+      if (r) return r;
+    }
+    return null;
+  }
+  return expect === got ? null : `${pathStr}: expected ${JSON.stringify(expect)}, got ${JSON.stringify(got)}`;
+}
+async function runAdapterFixtures(files) {
+  const results = [];
+  for (const file of files) {
+    const fx = JSON.parse(readFileSync6(file, "utf8"));
+    const adapter = adapterByName(fx.harness);
+    if (!adapter) {
+      results.push({ file, ok: false, why: `no adapter ${fx.harness}` });
+      continue;
+    }
+    const r = adapter.fromHook({
+      argv: fx.input.argv,
+      stdin: fx.input.stdin,
+      env: fx.input.env ?? {},
+      cwd: fx.input.cwd ?? "/"
+    });
+    if (!r) {
+      results.push({ file, ok: false, why: "fromHook returned null" });
+      continue;
+    }
+    let why = matches(
+      fx.expect.map((e) => e.type),
+      r.events.map((e) => e.type),
+      "types"
+    );
+    if (!why)
+      for (const [i, e] of fx.expect.entries()) {
+        const got = r.events[i];
+        why = matches(e.harness.event, got?.harnessEvent, `[${i}].harness.event`) ?? matches(e.data, got?.data, `[${i}].data`) ?? matches({ ...e.session, seq: "*" }, r.session, `[${i}].session`);
+        if (why) break;
+      }
+    results.push(why ? { file, ok: false, why } : { file, ok: true });
+  }
+  const failed = results.filter((r) => !r.ok).length;
+  const table = results.map((r) => `${r.ok ? "ok  " : "FAIL"} ${r.file}${r.why ? ` \u2014 ${r.why}` : ""}`).join("\n");
+  return { results, failed, table };
+}
+export {
+  runAdapterFixtures
+};
+//# sourceMappingURL=index.js.map