sessionpipe-core 0.9.0 → 0.11.0

package/dist/index.js

@@ -1,22 +1,33 @@
-// sessionpipe-core 0.9.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe-core 0.11.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,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import path4 from "node:path";
+// src/adapters/claude-code-pool.ts
+var claude_code_pool_exports = {};
+__export(claude_code_pool_exports, {
+  POOL_ENDPOINTS: () => POOL_ENDPOINTS,
+  PoolAuthError: () => PoolAuthError,
+  PoolUpstreamError: () => PoolUpstreamError,
+  beginLogin: () => beginLogin,
+  completeLogin: () => completeLogin,
+  fetchProfile: () => fetchProfile,
+  fetchUsage: () => fetchUsage,
+  importableLogins: () => importableLogins,
+  keychainService: () => keychainService,
+  parseUserId: () => parseUserId,
+  readLimits: () => readLimits,
+  refreshCredential: () => refreshCredential,
+  upstreamHeaders: () => upstreamHeaders,
+  usageLimits: () => usageLimits,
+  withAccount: () => withAccount
+});
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { readFileSync as readFileSync3 } from "node:fs";
+import os2 from "node:os";
+import path5 from "node:path";
 
 // src/paths.ts
 import os from "node:os";
@@ -39,8 +50,19 @@ function tilde(p, home = homeDir()) {
   if (p === home) return "~";
   return p.startsWith(home + path.sep) || p.startsWith(`${home}/`) ? `~${p.slice(home.length)}` : p;
 }
+function untilde(p, home = homeDir()) {
+  if (p === "~") return home;
+  return /^~[\\/]/.test(p) ? path.join(home, p.slice(2)) : p;
+}
 var safeId = (s) => String(s).replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 160);
 
+// src/adapters/claude-code.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { userInfo } from "node:os";
+import path4 from "node:path";
+
 // src/readers/files.ts
 import { closeSync, fstatSync, openSync, readdirSync, readSync, statSync } from "node:fs";
 import path2 from "node:path";
@@ -131,6 +153,38 @@ function recentFiles(root, depth, sinceMs, match) {
   return out;
 }
 
+// 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) {
+  const ssh = /^(?:ssh:\/\/)?git@([^:/]+)[:/](.+?)(?:\.git)?$/.exec(url);
+  if (ssh) return `${ssh[1]}/${ssh[2]}`;
+  return url.replace(/\/\/[^/@]*@/, "//").replace(/^https?:\/\//, "").replace(/\.git$/, "");
+}
+
 // src/adapters/codex-rollout.ts
 function codexSubagent(meta) {
   if (meta?.type !== "session_meta") return false;
@@ -290,8 +344,10 @@ function readJsonFile(file) {
   try {
     raw = readFileSync(file, "utf8");
   } catch {
-    return { ok: true, existed: false, value: {}, raw: "", indent: "  ", eol: "\n", finalNewline: true };
+    return { ok: true, existed: false, value: {}, raw: "", indent: "  ", eol: "\n", finalNewline: true, bom: false };
   }
+  const bom = raw.charCodeAt(0) === 65279;
+  if (bom) raw = raw.slice(1);
   let value;
   try {
     value = JSON.parse(raw);
@@ -311,12 +367,13 @@ function readJsonFile(file) {
     raw,
     indent,
     eol,
-    finalNewline: /\r?\n$/.test(raw)
+    finalNewline: /\r?\n$/.test(raw),
+    bom
   };
 }
 function formatJson(value, f) {
   const text = JSON.stringify(value, null, f.indent).replace(/\n/g, f.eol);
-  return f.finalNewline ? text + f.eol : text;
+  return (f.bom ? "\uFEFF" : "") + (f.finalNewline ? text + f.eol : text);
 }
 function readJson(file) {
   const f = readJsonFile(file);
@@ -412,74 +469,79 @@ function installedClaudeShaped(file, harness, events, cmd, o) {
   return current === events.length ? "current" : "stale";
 }
 
-// src/adapters/antigravity.ts
-var NAME = "antigravity";
-var HOOK_NAME = "sessionpipe";
-var AG_EVENTS = ["PreInvocation", "PostInvocation", "PostToolUse", "Stop"];
-var AG_STALE_PRETOOL = '{"decision":"ask","reason":"sessionpipe: an outdated PreToolUse hook is still loaded. Restart this conversation (or run sessionpipe install) to drop it."}\n';
-var antigravityAnswer = (event) => event === "PreToolUse" ? AG_STALE_PRETOOL : "{}\n";
-var gemini = (env) => env.GEMINI_CLI_HOME || path4.join(homeDir(), ".gemini");
-var hooksFile = (env) => path4.join(gemini(env), "config", "hooks.json");
-var projectsDir = (env) => path4.join(gemini(env), "config", "projects");
-var dataDirs = (env) => ["antigravity", "antigravity-cli", "antigravity-ide"].map((d) => path4.join(gemini(env), d));
-var ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
-var validTool = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
-function entry(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;
+// src/adapters/claude-code.ts
+var NAME = "claude-code";
+var CLAUDE_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "PermissionRequest",
+  "Notification",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "PostCompact",
+  "SessionEnd",
+  "StopFailure"
+];
+var LEAN_SKIP = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUseFailure"]);
+var eventsFor = (lean) => lean ? CLAUDE_EVENTS.filter((e) => !LEAN_SKIP.has(e)) : [...CLAUDE_EVENTS];
+var OPTS = {
+  matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0,
+  timeout: 5,
+  // 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 = env.HOME || homeDir()) {
+  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 readdirSync2(home, { withFileTypes: true })) {
+      if (!e.isDirectory() || !/^\.claude[-_.]/.test(e.name)) continue;
+      const d = path4.join(home, e.name);
+      if (existsSync2(path4.join(d, "projects")) || existsSync2(path4.join(d, "settings.json"))) add(d);
+    }
+  } catch {
+  }
+  return out.filter((d, i) => i === 0 || existsSync2(d));
 }
-var antigravity = {
+var settingsIn = (dir) => path4.join(dir, "settings.json");
+var configDirOf = (transcript) => path4.dirname(path4.dirname(path4.dirname(transcript)));
+var validTool = (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: NAME,
-  events: AG_EVENTS,
-  detect: (env = process.env) => existsSync2(path4.join(gemini(env), "config")) || dataDirs(env).some((d) => existsSync2(d)),
-  configFiles: (env = process.env) => [hooksFile(env)],
-  install(cmd, env = process.env) {
-    const file = hooksFile(env);
-    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);
-    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, formatJson(hooks, f));
-    return [
-      {
-        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, opts = {}) {
-    const file = hooksFile(env);
-    if (!existsSync2(file)) return [{ file, changed: false }];
-    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];
-    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) {
-    const file = hooksFile(env);
-    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"
-      }
-    ];
-  },
+  events: CLAUDE_EVENTS,
+  detect: (env = process.env) => claudeDirs(env).some((d) => existsSync2(d)),
+  configFiles: (env = process.env) => claudeDirs(env).map(settingsIn),
+  install: (cmd, env = process.env, opts = {}) => claudeDirs(env).flatMap((d) => {
+    const hooks = installClaudeShaped(settingsIn(d), NAME, eventsFor(opts.lean), cmd, OPTS);
+    const line = opts.statusLine === void 0 ? null : statusLine(settingsIn(d), opts.statusLine, cmd);
+    return line ? [hooks, line] : [hooks];
+  }),
+  uninstall: (env = process.env, opts = {}) => claudeDirs(env).map((d) => {
+    const line = statusLine(settingsIn(d), false);
+    const hooks = uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS, {
+      created: opts.created?.includes(settingsIn(d))
+    });
+    return line && !hooks.changed ? line : hooks;
+  }),
+  installed: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
+    file: settingsIn(d),
+    state: installedClaudeShaped(settingsIn(d), NAME, eventsFor(opts.lean), cmd, OPTS)
+  })),
   fromHook(input) {
     const event = input.argv[1] ?? "";
     let s = {};
@@ -488,226 +550,1087 @@ var antigravity = {
       if (j && typeof j === "object" && !Array.isArray(j)) s = j;
     } catch {
     }
-    const id = s.conversationId ?? s.session_id ?? s.sessionId;
-    const stdout = antigravityAnswer(event);
-    if (!id) return { session: { id: "" }, events: [], stdout };
-    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 id = s.session_id ?? s.sessionId;
+    if (!id) return null;
+    if (notClaudeCode(String(id), s)) 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 = validTool(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: 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", {}));
+      case "SessionStart":
+        events.push(ev("session.started", { source: pickSource(s.source ?? s.trigger) }));
         break;
-      case "PostInvocation":
+      case "UserPromptSubmit": {
+        const prompt = typeof s.prompt === "string" ? s.prompt : void 0;
+        events.push(
+          ev("turn.started", {
+            turn_id,
+            prompt_chars: prompt === void 0 ? void 0 : [...prompt].length,
+            // Claude Code's hook schema documents `source`
+            // (user | sdk | system | loop_wakeup | schedule_wakeup | poll_event) and says a
+            // payload may omit it while the field rolls out; 2.1.304's payload has no such
+            // key at all. Forwarded verbatim, shape-guarded only: the list is the harness's
+            // to extend.
+            submitted_by: harnessWord(s.source),
+            // One of Claude Code's own prompt wrappers: the prompt is a block the harness
+            // wrote, so it is not the person's words. Absent is unknown, never "the person" —
+            // and `true` is never "no person caused this turn", because a Talk or
+            // `sessionpipe wait` delivery hands the person's own message over inside a
+            // <task-notification> (PROTOCOL.md §4).
+            injected: prompt !== void 0 && injectedBlock(prompt) ? true : void 0
+          })
+        );
         break;
+      }
       case "PreToolUse":
-        if (tool) events.push(ev("tool.started", { tool, input: toolCall?.args }));
+        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("session.heartbeat", {}));
-        else
+        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
+              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", { reason: s.error ? "error" : "stop" }));
+        events.push(
+          ev("turn.ended", {
+            turn_id,
+            reason: "stop",
+            background: Array.isArray(s.background_tasks) ? s.background_tasks.length : void 0
+          })
+        );
         break;
-      default:
-        return { session, events: [], stdout };
-    }
-    const r = { session, events, stdout, 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) {
-    if (!transcript) return {};
-    return antigravityFacts(transcript, {
-      conversation: session.id,
-      workspaces: hints.workspaces ?? (session.cwd ? [session.cwd] : []),
-      env: process.env
-    });
+      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", {
+            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;
+      case "StatusLine": {
+        const limits = claudeLimits(s.rate_limits);
+        if (!limits) return null;
+        events.push(ev("limits.observed", limits));
+        break;
+      }
+      default:
+        return null;
+    }
+    const hints = {};
+    if (event === "UserPromptSubmit" && typeof s.prompt === "string") hints.prompt = s.prompt;
+    const host = input.env.CLAUDE_CODE_HOST_SESSION_ID;
+    if (host && DESKTOP_ID.test(host)) hints.desktop_id = host;
+    const attended = input.env.CLAUDE_CODE_SESSION_ATTENDED;
+    if (attended === "1" || attended === "0") hints.attended = attended === "1" || !!input.env.SESSIONPIPE_CONTROL_JOB;
+    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 = readFileSync2(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}`;
+    if (typeof hints.attended === "boolean") out.attended = hints.attended || !!out.url;
+    return out;
   },
+  remoteFacts: (session, local, transcript, state, env = process.env) => claudeRemoteFacts(session.id, local, transcript, state, env),
   backfill(sinceMs, env = process.env) {
     const rows2 = [];
-    for (const data of dataDirs(env)) {
-      let ids = [];
-      try {
-        ids = readdirSync2(path4.join(data, "brain")).filter((n) => /^[0-9a-f-]{36}$/i.test(n));
-      } catch {
-      }
-      for (const id of ids) {
-        const f = path4.join(data, "brain", id, ".system_generated", "logs", "transcript.jsonl");
-        try {
-          if (statSync2(f).mtimeMs < sinceMs) continue;
-        } catch {
-          continue;
-        }
-        const facts = antigravityFacts(f, { conversation: id, workspaces: [], env });
-        if (!facts.started_at || !facts.last_at) continue;
-        const { started_at, last_at, first_ask: _fa, harness_version: _hv, ...rest } = facts;
-        rows2.push({ session: { id, ...rest }, started_at, last_at });
-      }
+    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;
+      rows2.push({
+        session: { id, ...rest, ...gitFacts(cwd), ...rest.branch ? { branch: rest.branch } : {} },
+        started_at,
+        last_at,
+        transcript: f
+      });
     }
     return rows2;
   }
 };
+var LINE_REFRESH_S = 60;
+function statusLine(file, want, cmd) {
+  const f = readJsonFile(file);
+  if (!f.ok) return null;
+  const cur = f.value.statusLine;
+  const ours = typeof cur?.command === "string" && OURS.test(cur.command);
+  const command = cmd?.([NAME, "StatusLine"]).command;
+  if (want && cur && !ours)
+    return { file, changed: false, skipped: true, note: "a status line of your own is set; limits are not read" };
+  if (want ? ours && cur?.command === command && cur?.refreshInterval === LINE_REFRESH_S : !ours) return null;
+  if (want) f.value.statusLine = { type: "command", command, refreshInterval: LINE_REFRESH_S };
+  else delete f.value.statusLine;
+  writeFileSync2(file, formatJson(f.value, f));
+  return { file, changed: true, note: want ? "status line written (account limits)" : "status line removed" };
+}
+var epochIso = (t) => typeof t === "number" && t > 0 && t < 1e11 ? new Date(t * 1e3).toISOString() : void 0;
+var WINDOW_MINUTES = { five_hour: 300, seven_day: 10080 };
+function claudeLimits(rl) {
+  if (!rl || typeof rl !== "object" || Array.isArray(rl)) return null;
+  const windows = [];
+  for (const [id, w] of Object.entries(rl)) {
+    if (!/^[a-z0-9_]{1,64}$/.test(id) || typeof w?.used_percentage !== "number" || w.used_percentage < 0) continue;
+    windows.push(
+      prune({
+        id,
+        used_percent: w.used_percentage,
+        window_minutes: WINDOW_MINUTES[id],
+        resets_at: epochIso(w.resets_at)
+      })
+    );
+  }
+  return windows.length ? { windows: windows.slice(0, 8) } : null;
+}
 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)) {
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function notClaudeCode(id, s) {
+  return typeof s.transcript_path !== "string" && !UUID.test(id);
+}
+function pickSource(v) {
+  return typeof v === "string" && ["startup", "resume", "clear", "compact", "fork"].includes(v) ? v : "unknown";
+}
+var harnessWord = (v) => typeof v === "string" && /^[A-Za-z0-9][A-Za-z0-9_.-]{0,39}$/.test(v) ? v : void 0;
+var WRAPPER = /^<(?:task-notification|cross-session-message|system-reminder|local-command-stdout|command-[a-z-]+)[\s/>]/i;
+var injectedBlock = (prompt) => WRAPPER.test(prompt.trim());
+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 = readdirSync2(path4.join(dir, "sessions")).filter((n) => n.endsWith(".json"));
+  } catch {
+  }
+  for (const n of names) {
     try {
-      s = decodeURIComponent(new URL(s).pathname);
+      const e = registryEntry(JSON.parse(readFileSync2(path4.join(dir, "sessions", n), "utf8")));
+      if (e?.sessionId) map.set(e.sessionId, e);
     } catch {
-      return null;
     }
-    if (process.platform === "win32" && /^\/[A-Za-z]:/.test(s)) s = s.slice(1);
-  } else if (/^[a-z][a-z0-9+.-]*:\/\//i.test(s)) return null;
-  if (!path4.isAbsolute(s)) return null;
-  return path4.resolve(s);
+  }
+  liveCache.set(dir, map);
+  return map;
 }
-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];
+function claudeLiveByPid(dir, pid) {
+  if (!pid) return null;
   try {
-    const r = realpathSync.native(p);
-    if (r !== p) out.push(r);
+    return registryEntry(JSON.parse(readFileSync2(path4.join(dir, "sessions", `${pid}.json`), "utf8")));
   } catch {
+    return null;
   }
-  return out;
 }
-function agProjects(dir) {
+function claudePid(env = process.env) {
+  try {
+    const dirs = claudeDirs(env);
+    const has = (pid2) => dirs.some((d) => existsSync2(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 = readFileSync2(`/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 EMAIL_RE = /^[^@\s]{1,64}@[^@\s]{1,189}$/;
+function claudeLogin(dir, home = homeDir()) {
+  const files = [path4.join(dir, ".claude.json")];
+  if (path4.resolve(dir) === path4.join(home, ".claude")) files.unshift(path4.join(home, ".claude.json"));
+  for (const f of files) {
+    try {
+      const a = JSON.parse(readFileSync2(f, "utf8")).oauthAccount;
+      if (typeof a?.accountUuid === "string" && a.accountUuid) {
+        const email = typeof a.emailAddress === "string" && EMAIL_RE.test(a.emailAddress) ? a.emailAddress : void 0;
+        return { id: a.accountUuid.slice(0, 128), ...email ? { email } : {} };
+      }
+    } catch {
+    }
+  }
+  return apiAccount(dir);
+}
+var ANTHROPIC_HOST = /(^|\.)anthropic\.com$/i;
+function apiAccount(dir) {
+  const base = readJson(settingsIn(dir)).env?.ANTHROPIC_BASE_URL;
+  if (typeof base !== "string") return null;
+  let u;
+  try {
+    u = new URL(base.trim());
+  } catch {
+    return null;
+  }
+  if (u.protocol !== "https:" && u.protocol !== "http:" || !u.hostname || ANTHROPIC_HOST.test(u.hostname))
+    return null;
+  const origin = `${u.protocol}//${u.host}`;
+  return { id: `api-${createHash("sha256").update(origin).digest("hex").slice(0, 16)}`, name: u.host };
+}
+var accountCache = /* @__PURE__ */ new Map();
+function claudeAccount(dir) {
+  const hit = accountCache.get(dir);
+  if (hit !== void 0) return hit;
+  const acct = claudeLogin(dir)?.id ?? null;
+  accountCache.set(dir, acct);
+  return acct;
+}
+function claudeAccounts(dirs, home = homeDir()) {
   const out = [];
-  let names = [];
+  for (const d of dirs) {
+    const l = claudeLogin(d, home);
+    if (!l) continue;
+    const seen = out.find((a) => a.id === l.id);
+    if (!seen) out.push({ harness: NAME, ...l });
+    else if (!seen.email && l.email) seen.email = l.email;
+  }
+  return out;
+}
+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 {
-    names = readdirSync2(dir).filter((n) => n.endsWith(".json"));
+    size = statSync2(file).size;
   } catch {
     return out;
   }
-  for (const n of names) {
-    const id = n.slice(0, -5);
-    if (!ID_RE.test(id)) continue;
-    let j;
+  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(NAME, 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 = statSync2(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(NAME, 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(NAME, 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(NAME, 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(NAME, id, { first_ask_none: true });
+  }
+  if (ask) {
+    out.first_ask = ask;
+    if (!mem.first_ask) state.save(NAME, 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;
+}
+var REMOTE_RETRY_MS = 6e4;
+var REMOTE_REFRESH_MS = 30 * 6e4;
+var CLAUDE_API = "https://api.anthropic.com";
+var KEYCHAIN = "Claude Code-credentials";
+var REMOTE_TIMEOUT_MS = 3e3;
+var KEYCHAIN_TIMEOUT_MS = 2e3;
+var REMOTE_MAX_BYTES = 1 << 20;
+var cleanName = (s) => s.replace(/[\p{Cc}\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/gu, " ").replace(/\s+/g, " ").trim();
+async function claudeRemoteFacts(id, local, transcript, state, env, now = Date.now()) {
+  if (!transcript || !local.url || !LINK_RE.test(local.url) || local.title_source === "custom") return {};
+  const mem = state.get(NAME, id);
+  let title = typeof mem.remote_title === "string" ? mem.remote_title : null;
+  if (now - (Number(mem.remote_at) || 0) >= (title ? REMOTE_REFRESH_MS : REMOTE_RETRY_MS)) {
+    state.save(NAME, id, { remote_at: now });
+    const token = claudeAiToken(configDirOf(transcript), env, now);
+    const got = token ? await claudeAiTitle(local.url.slice(local.url.lastIndexOf("/") + 1), token) : void 0;
+    if (got !== void 0) {
+      title = got?.slice(0, 200) ?? null;
+      state.save(NAME, id, { remote_title: title });
+    }
+  }
+  return title ? { title: title.slice(0, 120), title_source: "harness" } : {};
+}
+function keychainServices(dir, env) {
+  const named = (p) => `${KEYCHAIN}-${createHash("sha256").update(p.normalize("NFC")).digest("hex").slice(0, 8)}`;
+  const out = /* @__PURE__ */ new Set();
+  if (env.CLAUDE_CONFIG_DIR && path4.resolve(env.CLAUDE_CONFIG_DIR) === dir) out.add(named(env.CLAUDE_CONFIG_DIR));
+  if (dir === path4.join(env.HOME || homeDir(), ".claude")) out.add(KEYCHAIN);
+  out.add(named(dir));
+  return [...out];
+}
+var tokenCache = /* @__PURE__ */ new Map();
+function claudeAiToken(dir, env, now) {
+  const hit = tokenCache.get(dir);
+  if (hit && hit.expires > now + 6e4) return hit.token;
+  const raw = [];
+  if (process.platform === "darwin")
+    for (const service of keychainServices(dir, env)) {
+      try {
+        const user = env.USER || userInfo().username;
+        const account = /^[\w.-]+$/.test(user) ? user : "claude-code-user";
+        raw.push(
+          execFileSync2("security", ["find-generic-password", "-a", account, "-w", "-s", service], {
+            encoding: "utf8",
+            timeout: KEYCHAIN_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "ignore"]
+          })
+        );
+        break;
+      } catch {
+      }
+    }
+  try {
+    raw.push(readFileSync2(path4.join(dir, ".credentials.json"), "utf8"));
+  } catch {
+  }
+  for (const r of raw) {
     try {
-      j = JSON.parse(readFileSync2(path4.join(dir, n), "utf8"));
+      const t = r.trim();
+      const o = JSON.parse(/^(?:[0-9a-f]{2})+$/i.test(t) ? Buffer.from(t, "hex").toString("utf8") : t).claudeAiOauth;
+      if (typeof o?.accessToken !== "string" || !o.accessToken) continue;
+      const expires = typeof o.expiresAt === "number" ? o.expiresAt : Number.POSITIVE_INFINITY;
+      if (expires <= now + 6e4) continue;
+      tokenCache.set(dir, { token: o.accessToken, expires });
+      return o.accessToken;
     } catch {
+    }
+  }
+  return null;
+}
+async function claudeAiTitle(bridge, token) {
+  try {
+    const r = await fetch(`${CLAUDE_API}/v1/code/sessions/${bridge}`, {
+      headers: { Authorization: `Bearer ${token}`, "anthropic-version": "2023-06-01", "User-Agent": "sessionpipe" },
+      redirect: "error",
+      signal: AbortSignal.timeout(REMOTE_TIMEOUT_MS)
+    });
+    if (r.status !== 200 || Number(r.headers.get("content-length")) > REMOTE_MAX_BYTES) return void 0;
+    const text = await r.text();
+    if (text.length > REMOTE_MAX_BYTES) return void 0;
+    const j = JSON.parse(text);
+    const s = j?.response_shape ?? j?.session ?? j;
+    const bare = (x) => x.replace(/^(?:session|cse)_/, "");
+    if (typeof s?.id !== "string" || bare(s.id) !== bare(bridge)) return void 0;
+    return typeof s.title === "string" && cleanName(s.title) || null;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/adapters/claude-code-pool.ts
+var POOL_ENDPOINTS = {
+  authorize: "https://claude.com/cai/oauth/authorize",
+  token: "https://platform.claude.com/v1/oauth/token",
+  callback: "https://platform.claude.com/oauth/code/callback",
+  profile: "https://api.anthropic.com/api/oauth/profile",
+  usage: "https://api.anthropic.com/api/oauth/usage",
+  api: "https://api.anthropic.com",
+  clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+  // The six Claude Code itself asks for with this client id: a token minted with fewer
+  // than the client's usual set is the kind of thing that fails only live.
+  scopes: [
+    "user:inference",
+    "user:profile",
+    "org:create_api_key",
+    "user:sessions:claude_code",
+    "user:mcp_servers",
+    "user:file_upload"
+  ],
+  beta: "oauth-2025-04-20"
+};
+var PoolAuthError = class extends Error {
+};
+var PoolUpstreamError = class extends Error {
+};
+var PREFIX = "anthropic-ratelimit-unified-";
+var WINDOW_IDS = { "5h": "five_hour", "7d": "seven_day" };
+var WINDOW_MINUTES2 = { five_hour: 300, seven_day: 10080 };
+var STATUSES = /* @__PURE__ */ new Set(["allowed", "allowed_warning", "rejected"]);
+var ID_RE = /^[a-z0-9_]{1,64}$/;
+function entries(h) {
+  const out = [];
+  if (h instanceof Headers) {
+    h.forEach((v, k) => {
+      out.push([k.toLowerCase(), v]);
+    });
+    return out;
+  }
+  for (const [k, v] of Object.entries(h)) {
+    const s = Array.isArray(v) ? v[0] : v;
+    if (typeof s === "string") out.push([k.toLowerCase(), s]);
+  }
+  return out;
+}
+function isoTime(v) {
+  if (typeof v === "number") return v > 0 && v < 1e11 ? new Date(v * 1e3).toISOString() : void 0;
+  if (typeof v !== "string") return void 0;
+  const s = v.trim();
+  if (/^\d+(\.\d+)?$/.test(s)) return isoTime(Number(s));
+  if (!/^\d{4}-\d{2}-\d{2}T/.test(s)) return void 0;
+  const t = Date.parse(s);
+  return Number.isFinite(t) ? new Date(t).toISOString() : void 0;
+}
+var percentOf = (n) => Math.round(Math.max(0, n) * 10) / 10;
+var windowId = (part) => WINDOW_IDS[part] ?? `seven_day_${part.slice(3)}`;
+function readLimits(headers, now) {
+  const seen = /* @__PURE__ */ new Map();
+  const out = { windows: [], observed_at: now };
+  let any = false;
+  for (const [name, value] of entries(headers)) {
+    if (!name.startsWith(PREFIX)) continue;
+    any = true;
+    const rest = name.slice(PREFIX.length);
+    if (rest === "status") {
+      if (STATUSES.has(value)) out.status = value;
       continue;
     }
-    const folders = [];
-    for (const r of j?.projectResources?.resources ?? []) {
-      const f = agPath(r?.folderUri ?? r?.gitFolder?.folderUri);
-      if (f) folders.push(...agVariants(f));
+    if (rest === "representative-claim") {
+      if (ID_RE.test(value)) out.claim = value;
+      continue;
+    }
+    if (rest === "reset") {
+      const t = isoTime(value);
+      if (t) out.resets_at = t;
+      continue;
+    }
+    const m = /^(5h|7d|7d_[a-z0-9_]+)-(utilization|reset)$/.exec(rest);
+    if (!m) continue;
+    const id = windowId(m[1]);
+    if (!ID_RE.test(id)) continue;
+    const w = seen.get(id) ?? {};
+    seen.set(id, w);
+    if (m[2] === "utilization") {
+      const n = Number(value);
+      if (value.trim() && Number.isFinite(n)) w.used = percentOf(n * 100);
+    } else {
+      const t = isoTime(value);
+      if (t) w.resets_at = t;
     }
-    if (folders.length) out.push({ id, folders });
+  }
+  if (!any) return null;
+  for (const [id, w] of seen) {
+    if (w.used === void 0) continue;
+    const minutes = WINDOW_MINUTES2[id];
+    out.windows.push({
+      id,
+      used_percent: w.used,
+      ...w.resets_at ? { resets_at: w.resets_at } : {},
+      ...minutes ? { window_minutes: minutes } : {}
+    });
   }
   return out;
 }
-function agMatchProject(projects, workspaces) {
-  const ws = [];
-  for (const w of workspaces) {
-    const p = agPath(w);
-    if (p) ws.push(...agVariants(p));
+function usageLimits(json, now) {
+  if (!json || typeof json !== "object" || Array.isArray(json)) return null;
+  const windows = [];
+  for (const [id, v] of Object.entries(json)) {
+    if (!ID_RE.test(id) || !v || typeof v !== "object" || Array.isArray(v)) continue;
+    const w = v;
+    if (typeof w.utilization !== "number" || !Number.isFinite(w.utilization)) continue;
+    const resets_at = isoTime(w.resets_at);
+    const minutes = WINDOW_MINUTES2[id];
+    windows.push({
+      id,
+      used_percent: percentOf(w.utilization),
+      ...resets_at ? { resets_at } : {},
+      ...minutes ? { window_minutes: minutes } : {}
+    });
   }
-  let best = null;
-  let bestLen = -1;
-  for (const pr of projects)
-    for (const f of pr.folders) {
-      const within = ws.some((w) => w === f || w.startsWith(f.endsWith(path4.sep) ? f : f + path4.sep));
-      if (within && f.length > bestLen) {
-        best = pr.id;
-        bestLen = f.length;
-      }
+  return windows.length ? { windows: windows.slice(0, 8), observed_at: now } : null;
+}
+var UUID2 = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+var UUID_RE = new RegExp(`^${UUID2}$`, "i");
+var LEGACY_ACCOUNT = new RegExp(`(?:^|_)account_(${UUID2})(?=_|$)`, "i");
+var LEGACY_SESSION = new RegExp(`(?:^|_)session_(${UUID2})$`, "i");
+function userIdOf(body) {
+  let v = body;
+  if (Buffer.isBuffer(v) || typeof v === "string") {
+    try {
+      v = JSON.parse(v.toString());
+    } catch {
+      return null;
     }
-  return best;
+  }
+  const id = v?.metadata?.user_id;
+  return typeof id === "string" && id.length <= 4096 ? id : null;
+}
+function partsOf(id) {
+  if (id.startsWith("{")) {
+    try {
+      const j = JSON.parse(id);
+      return {
+        ...typeof j.session_id === "string" && j.session_id ? { session: j.session_id } : {},
+        ...typeof j.account_uuid === "string" && UUID_RE.test(j.account_uuid) ? { account: j.account_uuid } : {}
+      };
+    } catch {
+      return {};
+    }
+  }
+  const s = LEGACY_SESSION.exec(id)?.[1];
+  const a = LEGACY_ACCOUNT.exec(id)?.[1];
+  return { ...s ? { session: s } : {}, ...a ? { account: a } : {} };
+}
+function parseUserId(body) {
+  const id = userIdOf(body);
+  return id === null ? null : partsOf(id);
+}
+function withAccount(body, accountUuid) {
+  if (!UUID_RE.test(accountUuid)) return body;
+  const id = userIdOf(body);
+  if (id === null) return body;
+  const current = partsOf(id).account;
+  if (current && current.toLowerCase() === accountUuid.toLowerCase()) return body;
+  const empty = !current && id.startsWith("{") && emptyAccountSlot(id);
+  if (!current && !empty) return body;
+  const text = body.toString("utf8");
+  const literal = JSON.stringify(id).slice(1, -1);
+  const was = current ?? "";
+  const at = current ? literal.indexOf(current) : literal.indexOf(EMPTY_SLOT) + EMPTY_SLOT.length;
+  const ms = [...text.matchAll(/"user_id"\s*:\s*"((?:[^"\\]|\\.)*)"/g)].filter((x) => x[1] === literal);
+  if (!ms.length) return body;
+  if (ms.length === 1) {
+    const m = ms[0];
+    const start = m.index + m[0].length - 1 - literal.length + at;
+    return Buffer.from(text.slice(0, start) + accountUuid + text.slice(start + was.length), "utf8");
+  }
+  const j = JSON.parse(text);
+  if (current) j.metadata.user_id = id.replace(current, accountUuid);
+  else
+    j.metadata.user_id = JSON.stringify({ ...JSON.parse(id), account_uuid: accountUuid });
+  return Buffer.from(JSON.stringify(j), "utf8");
+}
+var EMPTY_SLOT = '\\"account_uuid\\":\\"';
+function emptyAccountSlot(id) {
+  try {
+    return JSON.parse(id).account_uuid === "";
+  } catch {
+    return false;
+  }
+}
+var DROP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "te",
+  "trailer",
+  "upgrade",
+  "host",
+  "content-length",
+  "authorization",
+  "x-api-key"
+]);
+function upstreamHeaders(req, access) {
+  const out = {};
+  for (const [k, v] of Object.entries(req)) {
+    const name = k.toLowerCase();
+    if (v === void 0 || DROP.has(name) || name.startsWith("proxy-")) continue;
+    out[name] = Array.isArray(v) ? v.join(", ") : v;
+  }
+  out.authorization = `Bearer ${access}`;
+  const betas = (out["anthropic-beta"] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+  if (!betas.includes(POOL_ENDPOINTS.beta)) betas.push(POOL_ENDPOINTS.beta);
+  out["anthropic-beta"] = betas.join(",");
+  return out;
+}
+function beginLogin(random = randomBytes) {
+  const verifier = random(32).toString("base64url");
+  const state = random(32).toString("base64url");
+  const challenge = createHash2("sha256").update(verifier).digest("base64url");
+  const u = new URL(POOL_ENDPOINTS.authorize);
+  u.searchParams.append("code", "true");
+  u.searchParams.append("client_id", POOL_ENDPOINTS.clientId);
+  u.searchParams.append("response_type", "code");
+  u.searchParams.append("redirect_uri", POOL_ENDPOINTS.callback);
+  u.searchParams.append("scope", POOL_ENDPOINTS.scopes.join(" "));
+  u.searchParams.append("code_challenge", challenge);
+  u.searchParams.append("code_challenge_method", "S256");
+  u.searchParams.append("state", state);
+  return { url: u.toString(), verifier, state };
+}
+function pastedCode(pasted, state) {
+  const s = pasted.trim();
+  if (!s) throw new PoolAuthError("Paste the code the sign-in page shows.");
+  if (/^https?:\/\//i.test(s)) {
+    let u;
+    try {
+      u = new URL(s);
+    } catch {
+      throw new PoolAuthError("That is not the sign-in page's code.");
+    }
+    const code2 = u.searchParams.get("code");
+    const st2 = u.searchParams.get("state");
+    if (!code2) throw new PoolAuthError("That URL carries no code.");
+    if (st2 !== null && st2 !== state) throw new PoolAuthError("That code belongs to another sign-in; start again.");
+    return code2;
+  }
+  const hash = s.indexOf("#");
+  if (hash < 0) return s;
+  const code = s.slice(0, hash).trim();
+  const st = s.slice(hash + 1).trim();
+  if (!code) throw new PoolAuthError("Paste the code the sign-in page shows.");
+  if (st && st !== state) throw new PoolAuthError("That code belongs to another sign-in; start again.");
+  return code;
+}
+var JSON_HEADERS = { "content-type": "application/json", "anthropic-beta": POOL_ENDPOINTS.beta };
+async function post(fetch2, url, body, what) {
+  try {
+    return await fetch2(url, { method: "POST", headers: JSON_HEADERS, body: JSON.stringify(body) });
+  } catch (e) {
+    throw new PoolUpstreamError(`${what}: ${e.message || "no answer from Anthropic"}`);
+  }
+}
+async function get(fetch2, url, access, what) {
+  try {
+    return await fetch2(url, { headers: { authorization: `Bearer ${access}`, "anthropic-beta": POOL_ENDPOINTS.beta } });
+  } catch (e) {
+    throw new PoolUpstreamError(`${what}: ${e.message || "no answer from Anthropic"}`);
+  }
+}
+async function jsonOf(r) {
+  try {
+    return await r.json();
+  } catch {
+    return null;
+  }
 }
-function antigravityRemoteUrl(transcript, opts) {
-  const i = transcript.indexOf(`${path4.sep}brain${path4.sep}`);
-  const dirs = (i > 0 ? [transcript.slice(0, i)] : []).concat(dataDirs(opts.env));
-  for (const d of dirs) {
+function credentialOf(j, now, keepRefresh, what) {
+  const t = j;
+  const refresh = typeof t?.refresh_token === "string" && t.refresh_token ? t.refresh_token : keepRefresh;
+  if (!t || typeof t.access_token !== "string" || !t.access_token || !refresh || typeof t.expires_in !== "number")
+    throw new PoolUpstreamError(`${what}: Anthropic's answer had no token in it`);
+  return { access: t.access_token, refresh, expires_at: now + t.expires_in * 1e3 };
+}
+async function completeLogin(code, pending, fetch2, now) {
+  const c = pastedCode(code, pending.state);
+  const r = await post(
+    fetch2,
+    POOL_ENDPOINTS.token,
+    {
+      grant_type: "authorization_code",
+      code: c,
+      state: pending.state,
+      client_id: POOL_ENDPOINTS.clientId,
+      redirect_uri: POOL_ENDPOINTS.callback,
+      code_verifier: pending.verifier
+    },
+    "sign-in"
+  );
+  if (r.status >= 400 && r.status < 500)
+    throw new PoolAuthError(`Anthropic did not accept the code (HTTP ${r.status}); start the sign-in again.`);
+  if (!r.ok) throw new PoolUpstreamError(`sign-in: Anthropic answered HTTP ${r.status}; try again in a minute`);
+  const credential = credentialOf(await jsonOf(r), now(), void 0, "sign-in");
+  const profile = await fetchProfile(credential.access, fetch2);
+  return { credential, profile };
+}
+async function refreshCredential(cred, fetch2, now) {
+  const r = await post(
+    fetch2,
+    POOL_ENDPOINTS.token,
+    { grant_type: "refresh_token", refresh_token: cred.refresh, client_id: POOL_ENDPOINTS.clientId },
+    "refresh"
+  );
+  if (r.status === 400 || r.status === 401)
+    throw new PoolAuthError("This account's sign-in has expired; sign in again.");
+  if (!r.ok) throw new PoolUpstreamError(`refresh: Anthropic answered HTTP ${r.status}; try again in a minute`);
+  return credentialOf(await jsonOf(r), now(), cred.refresh, "refresh");
+}
+async function fetchProfile(access, fetch2) {
+  const r = await get(fetch2, POOL_ENDPOINTS.profile, access, "profile");
+  if (r.status === 401 || r.status === 403)
+    throw new PoolAuthError("Anthropic does not know this token; sign in again.");
+  if (!r.ok) throw new PoolUpstreamError(`profile: Anthropic answered HTTP ${r.status}; try again in a minute`);
+  const j = await jsonOf(r);
+  const a = j?.account;
+  if (typeof a?.uuid !== "string" || !UUID_RE.test(a.uuid) || typeof a.email !== "string" || !a.email)
+    throw new PoolUpstreamError("profile: Anthropic's answer did not say whose token this is");
+  const org = j?.organization?.name;
+  const plan = a.subscription_type;
+  return {
+    account_uuid: a.uuid.toLowerCase(),
+    email: a.email,
+    ...typeof org === "string" && org ? { org } : {},
+    ...typeof plan === "string" && plan ? { plan } : {}
+  };
+}
+async function fetchUsage(access, fetch2, now) {
+  const r = await get(fetch2, POOL_ENDPOINTS.usage, access, "usage");
+  if (r.status === 401 || r.status === 403)
+    throw new PoolAuthError("Anthropic does not know this token; sign in again.");
+  if (!r.ok) throw new PoolUpstreamError(`usage: Anthropic answered HTTP ${r.status}; try again in a minute`);
+  return usageLimits(await jsonOf(r), now());
+}
+var SERVICE = "Claude Code-credentials";
+function keychainService(dir, home, platform = process.platform) {
+  const norm = (x) => platform === "win32" ? path5.resolve(x).toLowerCase() : path5.resolve(x);
+  if (norm(dir) === norm(path5.join(home, ".claude"))) return SERVICE;
+  return `${SERVICE}-${createHash2("sha256").update(dir).digest("hex").slice(0, 8)}`;
+}
+function keychainUser(env) {
+  let u = env.USER;
+  if (!u) {
     try {
-      const m = /installation_uuid:\s*"([0-9a-f-]{36})"/i.exec(
-        readFileSync2(path4.join(d, "antigravity_state.pbtxt"), "utf8")
-      );
-      if (!m) continue;
-      const base = `https://antigravity.google.com/r/${m[1]}-v2`;
-      const conv = opts.conversation ?? "";
-      if (!ID_RE.test(conv) || !opts.workspaces?.length) return base;
-      const project = agMatchProject(agProjects(opts.projectsDir ?? projectsDir(opts.env)), opts.workspaces);
-      return project ? `${base}?p=${encodeURIComponent(`c/${conv}?section=${project}`)}` : base;
+      u = os2.userInfo().username;
     } catch {
+      u = "";
     }
   }
-  return null;
+  return /^[a-zA-Z0-9._-]+$/.test(u) ? u : "claude-code-user";
 }
-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;
+function credentialIn(text) {
+  try {
+    const o = JSON.parse(text).claudeAiOauth;
+    if (typeof o?.accessToken !== "string" || !o.accessToken || typeof o.refreshToken !== "string" || !o.refreshToken)
+      return null;
+    return {
+      access: o.accessToken,
+      refresh: o.refreshToken,
+      expires_at: typeof o.expiresAt === "number" ? o.expiresAt : 0
+    };
+  } catch {
+    return null;
   }
-  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);
+}
+var EMAIL_RE2 = /^[^@\s]{1,64}@[^@\s]{1,189}$/;
+var readText = (f) => readFileSync3(f, "utf8");
+function importableLogins(env, exec, readFile = readText, platform = process.platform) {
+  const out = [];
+  const home = env.HOME || homeDir();
+  const user = keychainUser(env);
+  for (const dir of claudeDirs(env, home)) {
+    let credential = null;
+    let source = "file";
+    if (platform === "darwin") {
+      const service = keychainService(dir, home, platform);
+      for (const args of [
+        ["find-generic-password", "-s", service, "-a", user, "-w"],
+        ["find-generic-password", "-s", service, "-w"]
+      ]) {
+        try {
+          credential = credentialIn(exec("security", args).trim());
+        } catch {
+        }
+        if (credential) break;
+      }
+      if (credential) source = "keychain";
+    }
+    if (!credential) {
+      try {
+        credential = credentialIn(readFile(path5.join(dir, ".credentials.json")));
+      } catch {
+      }
+    }
+    if (!credential) continue;
+    out.push({ dir, credential, ...whoIs(dir, home, readFile), source });
   }
   return out;
 }
+function whoIs(dir, home, readFile) {
+  const files = [path5.join(dir, ".claude.json")];
+  if (path5.resolve(dir) === path5.join(home, ".claude")) files.unshift(path5.join(home, ".claude.json"));
+  for (const f of files) {
+    try {
+      const a = JSON.parse(readFile(f)).oauthAccount;
+      if (typeof a?.accountUuid === "string" && UUID_RE.test(a.accountUuid)) {
+        const email = typeof a.emailAddress === "string" && EMAIL_RE2.test(a.emailAddress) ? a.emailAddress : void 0;
+        return { account_uuid: a.accountUuid.toLowerCase(), ...email ? { email } : {} };
+      }
+    } catch {
+    }
+  }
+  return {};
+}
 
-// src/adapters/antigravity-control.ts
-var antigravity_control_exports = {};
-__export(antigravity_control_exports, {
-  AgyReading: () => AgyReading,
-  agyArgs: () => agyArgs,
-  agyEnv: () => agyEnv,
-  agyError: () => agyError,
-  agyLine: () => agyLine,
-  agyModeFlags: () => agyModeFlags,
-  findAgy: () => findAgy,
-  reading: () => reading
+// src/adapters/acp-control.ts
+var acp_control_exports = {};
+__export(acp_control_exports, {
+  ACP_AGENTS: () => ACP_AGENTS,
+  ACP_HARNESSES: () => ACP_HARNESSES,
+  acpAgent: () => acpAgent,
+  acpHarnesses: () => acpHarnesses,
+  acpOverride: () => acpOverride,
+  errorWords: () => errorWords,
+  findAcpAgent: () => findAcpAgent,
+  permissionChoice: () => permissionChoice,
+  startAcp: () => startAcp
 });
-import os2 from "node:os";
-import path6 from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import os3 from "node:os";
+import path7 from "node:path";
 
 // src/adapters/headless.ts
 import { spawn } from "node:child_process";
 import { accessSync, constants, statSync as statSync3 } from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 var JOB_TIMEOUT_MS = 30 * 6e4;
 var OUT_CAP = 1024 * 1024;
 function isExe(p) {
@@ -721,11 +1644,11 @@ function isExe(p) {
 }
 function findBinary(o) {
   if (o.override && isExe(o.override)) return o.override;
-  for (const d of String(o.env?.PATH || "").split(path5.delimiter)) {
-    if (!d || !path5.isAbsolute(d)) continue;
-    for (const n of o.names) if (isExe(path5.join(d, n))) return path5.join(d, n);
+  for (const d of String(o.env?.PATH || "").split(path6.delimiter)) {
+    if (!d || !path6.isAbsolute(d)) continue;
+    for (const n of o.names) if (isExe(path6.join(d, n))) return path6.join(d, n);
   }
-  for (const d of o.dirs) for (const n of o.names) if (isExe(path5.join(d, n))) return path5.join(d, n);
+  for (const d of o.dirs) for (const n of o.names) if (isExe(path6.join(d, n))) return path6.join(d, n);
   return null;
 }
 function jobEnv(env = process.env) {
@@ -846,229 +1769,441 @@ function runFailure(label, res) {
   return null;
 }
 
-// src/adapters/antigravity-control.ts
-var LABEL = "Antigravity";
-function findAgy(env = process.env, home = os2.homedir()) {
-  return findBinary({
-    override: env.SESSIONPIPE_AGY,
-    names: process.platform === "win32" ? ["agy.exe", "agy.cmd"] : ["agy"],
+// src/adapters/acp-control.ts
+var ACP_AGENTS = [
+  { harness: "gemini-cli", registry: "gemini", label: "Gemini CLI", bin: "gemini", args: ["--acp"] },
+  { harness: "devin", registry: "devin", label: "Devin", bin: "devin", args: ["acp"] },
+  { harness: "opencode", registry: "opencode", label: "OpenCode", bin: "opencode", args: ["acp"] },
+  { harness: "cursor", registry: "cursor", label: "Cursor", bin: "cursor-agent", args: ["acp"] },
+  { harness: "copilot-cli", registry: "github-copilot-cli", label: "Copilot CLI", bin: "copilot", args: ["--acp"] },
+  {
+    harness: "droid",
+    registry: "factory-droid",
+    label: "Droid",
+    bin: "droid",
+    args: ["exec", "--output-format", "acp-daemon"]
+  },
+  { harness: "goose", registry: "goose", label: "goose", bin: "goose", args: ["acp"] },
+  { harness: "kilo", registry: "kilo", label: "Kilo", bin: "kilo", args: ["acp"] },
+  {
+    harness: "qwen-code",
+    registry: "qwen-code",
+    label: "Qwen Code",
+    bin: "qwen",
+    args: ["--acp", "--experimental-skills"]
+  },
+  { harness: "cline", registry: "cline", label: "Cline", bin: "cline", args: ["--acp"] },
+  { harness: "auggie", registry: "auggie", label: "Auggie", bin: "auggie", args: ["--acp"] },
+  { harness: "kimi", registry: "kimi", label: "Kimi CLI", bin: "kimi", args: ["acp"] },
+  { harness: "amp", registry: "amp-acp", label: "Amp", bin: "amp-acp", args: [] },
+  { harness: "mistral-vibe", registry: "mistral-vibe", label: "Mistral Vibe", bin: "vibe-acp", args: [] },
+  { harness: "bob", registry: "bob", label: "Bob", bin: "bob", args: ["acp"] },
+  { harness: "grok-build", registry: "grok-build", label: "Grok Build", bin: "grok", args: ["agent", "stdio"] },
+  { harness: "qoder", registry: "qoder", label: "Qoder CLI", bin: "qodercli", args: ["--acp"] },
+  { harness: "minimax-code", registry: "minimax-code", label: "MiniMax Code", bin: "mcode", args: ["acp"] },
+  { harness: "codebuddy-code", registry: "codebuddy-code", label: "Codebuddy Code", bin: "codebuddy", args: ["--acp"] },
+  { harness: "nova", registry: "nova", label: "Nova", bin: "nova", args: ["acp"] },
+  { harness: "dimcode", registry: "dimcode", label: "DimCode", bin: "dim", args: ["acp"] },
+  { harness: "dirac", registry: "dirac", label: "Dirac", bin: "dirac", args: ["--acp"] },
+  { harness: "harn", registry: "harn", label: "Harn", bin: "harn", args: ["serve", "acp"] },
+  { harness: "vtcode", registry: "vtcode", label: "VT Code", bin: "vtcode", args: ["acp"] },
+  { harness: "stakpak", registry: "stakpak", label: "Stakpak", bin: "stakpak", args: ["acp"] },
+  { harness: "crow-cli", registry: "crow-cli", label: "crow-cli", bin: "crow-cli", args: ["acp"] },
+  { harness: "corust-agent", registry: "corust-agent", label: "Corust Agent", bin: "corust-agent-acp", args: [] },
+  { harness: "cortex-code", registry: "cortex-code", label: "Cortex Code", bin: "cortex", args: ["acp", "serve"] },
+  { harness: "kimchi", registry: "kimchi", label: "Kimchi", bin: "kimchi", args: ["--mode", "acp"] }
+];
+var ACP_HARNESSES = ACP_AGENTS.map((a) => a.harness);
+var acpAgent = (harness) => ACP_AGENTS.find((a) => a.harness === harness);
+var acpOverride = (harness) => `SESSIONPIPE_ACP_${harness.toUpperCase().replace(/-/g, "_")}`;
+function findAcpAgent(harness, env = process.env, home = os3.homedir(), nodeDir = path7.dirname(process.execPath)) {
+  const a = acpAgent(harness);
+  if (!a) return null;
+  const bin = findBinary({
+    override: env[acpOverride(harness)],
+    names: process.platform === "win32" ? [`${a.bin}.exe`, `${a.bin}.cmd`] : [a.bin],
     env,
-    dirs: [path6.join(home, ".local", "bin"), "/opt/homebrew/bin", "/usr/local/bin"]
+    dirs: [
+      nodeDir,
+      path7.join(home, ".local", "bin"),
+      path7.join(home, ".cargo", "bin"),
+      "/opt/homebrew/bin",
+      "/usr/local/bin"
+    ]
   });
+  return bin ? { bin, args: a.args } : null;
 }
-function agyModeFlags(mode) {
-  return mode === "auto" ? ["--mode", "accept-edits"] : [];
-}
-function agyArgs(o) {
-  const prompt = o.prompt.startsWith("-") ? ` ${o.prompt}` : o.prompt;
-  return [
-    ...o.resume ? ["--conversation", o.resume] : [],
-    "-p",
-    prompt,
-    "--output-format",
-    "stream-json",
-    ...agyModeFlags(o.mode)
-  ];
+function acpHarnesses(env = process.env) {
+  return ACP_HARNESSES.filter((h) => findAcpAgent(h, env));
 }
-var agyEnv = (env = process.env) => jobEnv(env);
-function agyLine(line) {
-  let j;
-  try {
-    j = JSON.parse(line);
-  } catch {
-    return null;
+var obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : null;
+var str = (v) => typeof v === "string" ? v : "";
+function permissionChoice(options, mode) {
+  const list = (Array.isArray(options) ? options : []).map(obj).filter((o) => !!o && !!str(o.optionId)).map((o) => ({ optionId: str(o.optionId), kind: str(o.kind) }));
+  const want = mode === "auto" ? ["allow_once", "allow_always"] : ["reject_once", "reject_always"];
+  for (const k of want) {
+    const hit = list.find((o) => o.kind === k);
+    if (hit) return hit;
   }
-  if (!j || typeof j !== "object") return null;
-  const str = (v) => typeof v === "string" ? v : "";
-  const out = {};
-  if (j.event === "init") {
-    if (str(j.conversation_id)) out.session = str(j.conversation_id);
-  } else if (j.event === "step_update") {
-    const s = j.step_update ?? {};
-    if (str(s.conversation_id)) out.session = str(s.conversation_id);
-    if (s.step_type === "agent_response" && str(s.text_delta))
-      out.delta = { step: Number(s.step_index ?? 0), text: str(s.text_delta) };
-    if (s.step_type === "error_message") {
-      const why = str(s.text_delta) || str(s.error) || str(s.message);
-      if (why) out.note = why;
-    }
-  } else if (j.event === "result") {
-    const r = j.result ?? {};
-    if (str(r.conversation_id)) out.session = str(r.conversation_id);
-    out.result = {
-      status: str(r.status),
-      response: str(r.response),
-      error: str(r.error),
-      denied: Array.isArray(r.denied_actions) ? r.denied_actions : []
-    };
-  } else return null;
-  return Object.keys(out).length ? out : null;
-}
-function deniedName(d) {
-  if (typeof d === "string") return d.slice(0, 80);
-  if (!d || typeof d !== "object") return null;
-  const o = d;
-  for (const k of ["tool_name", "toolName", "name", "tool", "action", "type"])
-    if (typeof o[k] === "string" && o[k]) return o[k].slice(0, 80);
   return null;
 }
-function agyError(stderr) {
-  const s = String(stderr || "");
-  const i = s.lastIndexOf("AGY_ERROR:");
-  if (i < 0) return "";
-  const raw = s.slice(i + "AGY_ERROR:".length).trim();
-  try {
-    const j = JSON.parse(raw);
-    for (const k of ["message", "error", "detail"]) if (typeof j[k] === "string" && j[k]) return j[k];
-  } catch {
-  }
-  return raw.split("\n")[0].slice(0, 300);
+function errorWords(err) {
+  const message = str(err.message);
+  const data = str(err.data) || str(obj(err.data)?.message);
+  return data && data !== message ? message ? `${message}: ${data}` : data : message;
 }
-var AgyReading = class {
-  session = null;
-  lines = 0;
-  buf = "";
-  step = null;
-  result = null;
-  note = null;
-  get text() {
-    return this.buf;
-  }
-  feed(line) {
-    this.lines++;
-    const p = agyLine(line);
-    if (!p) return false;
-    if (p.session && !this.session) this.session = p.session;
-    if (p.note) this.note = p.note;
-    if (p.result) this.result = p.result;
-    if (!p.delta) return false;
-    if (this.step !== null && p.delta.step !== this.step && this.buf && !this.buf.endsWith("\n\n")) this.buf += "\n\n";
-    this.step = p.delta.step;
-    this.buf += p.delta.text;
-    return true;
+function toolName(call, titles) {
+  if (!call) return null;
+  const t = str(call.title) || titles.get(str(call.toolCallId)) || str(call.name) || str(call.toolCallId);
+  return t ? t.slice(0, 80) : null;
+}
+var CLIENT_INFO = { name: "sessionpipe", title: "sessionpipe control", version: "1" };
+function startAcp(o) {
+  const now = o.now ?? Date.now;
+  const log = o.log ?? (() => {
+  });
+  const label = o.label;
+  let child;
+  try {
+    child = spawn2(o.bin, o.args, {
+      cwd: o.cwd,
+      env: jobEnv(o.env),
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: process.platform !== "win32",
+      windowsHide: true
+    });
+  } catch (e) {
+    return Promise.resolve({ failed: `couldn't start ${label}: ${e.message}` });
   }
-  outcome(res) {
-    const broke = runFailure(LABEL, res);
-    if (broke) return { failed: broke };
-    const r = this.result;
-    if (!r) {
-      const why = agyError(res.stderr) || this.note || "";
-      return {
-        failed: `Antigravity exited (${res.signal || `code ${res.code}`}) without an answer${why ? `: ${why}` : ""}`
-      };
+  const kill = (sig) => {
+    try {
+      if (process.platform !== "win32" && child.pid) process.kill(-child.pid, sig);
+      else child.kill(sig);
+    } catch {
     }
-    if (r.status !== "SUCCESS")
-      return { failed: r.error || agyError(res.stderr) || this.note || "Antigravity reported an error" };
-    const names = [...new Set(r.denied.map(deniedName).filter((n) => !!n))];
-    const text = r.response.trim() ? r.response.trim() : this.buf.trim() || "(Antigravity finished without a written reply.)";
-    return { reply: text + deniedNote(names, r.denied.length) };
-  }
-};
-var reading = () => new AgyReading();
-
-// 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 statSync4 } from "node:fs";
-import path7 from "node:path";
-
-// 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) => {
+  };
+  let gone = null;
+  let errTail = "";
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const write = (m) => {
+    if (gone) return;
     try {
-      return execFileSync("git", ["-C", cwd, ...args], {
-        encoding: "utf8",
-        timeout: 1500,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
+      child.stdin?.write(`${JSON.stringify(m)}
+`);
     } 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) {
-  const ssh = /^(?:ssh:\/\/)?git@([^:/]+)[:/](.+?)(?:\.git)?$/.exec(url);
-  if (ssh) return `${ssh[1]}/${ssh[2]}`;
-  return url.replace(/\/\/[^/@]*@/, "//").replace(/^https?:\/\//, "").replace(/\.git$/, "");
-}
+  const request = (method, params, timeoutMs) => new Promise((resolve, reject) => {
+    if (gone) return reject(new Error(gone));
+    const id = nextId++;
+    const t = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error(`${label} didn't answer ${method} in ${Math.round(timeoutMs / 1e3)} s`));
+    }, timeoutMs);
+    t.unref();
+    pending.set(id, {
+      resolve: (r) => {
+        clearTimeout(t);
+        resolve(r);
+      },
+      reject: (e) => {
+        clearTimeout(t);
+        reject(e);
+      }
+    });
+    write({ jsonrpc: "2.0", id, method, params });
+  });
+  const notify = (method, params) => write({ jsonrpc: "2.0", method, params });
+  let turn = null;
+  const titles = /* @__PURE__ */ new Map();
+  const onUpdate = (u) => {
+    if (!u) return;
+    const kind = str(u.sessionUpdate);
+    if (kind === "tool_call" && str(u.toolCallId) && str(u.title)) {
+      if (titles.size >= 200) titles.clear();
+      titles.set(str(u.toolCallId), str(u.title));
+      return;
+    }
+    if (kind !== "agent_message_chunk" || !turn) return;
+    const c = obj(u.content);
+    if (c?.type !== "text" || !str(c.text)) return;
+    const mid = str(u.messageId) || null;
+    if (turn.message !== void 0 && mid !== turn.message && turn.text.trim())
+      turn.text = `${turn.text.trimEnd()}
 
-// 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",
-  "StopFailure"
-];
-var LEAN_SKIP = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUseFailure"]);
-var eventsFor = (lean) => lean ? CLAUDE_EVENTS.filter((e) => !LEAN_SKIP.has(e)) : [...CLAUDE_EVENTS];
-var OPTS = {
-  matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0,
-  timeout: 5,
-  // 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 = env.HOME || homeDir()) {
-  const out = [];
-  const add = (d) => {
-    if (!d) return;
-    const r = path7.resolve(d);
-    if (!out.includes(r)) out.push(r);
+`;
+    turn.message = mid;
+    turn.text += str(c.text);
+    o.onText?.(turn.text);
+  };
+  const onRequest = (id, method, params) => {
+    if (method !== "session/request_permission") {
+      write({ jsonrpc: "2.0", id, error: { code: -32601, message: `Method not found: ${method}` } });
+      return;
+    }
+    const pick = permissionChoice(params?.options, o.mode);
+    if (!pick?.kind.startsWith("allow")) {
+      const name = toolName(obj(params?.toolCall), titles);
+      if (turn) {
+        turn.count++;
+        if (name && !turn.denied.includes(name) && turn.denied.length < 20) turn.denied.push(name);
+      }
+    }
+    write({
+      jsonrpc: "2.0",
+      id,
+      result: { outcome: pick ? { outcome: "selected", optionId: pick.optionId } : { outcome: "cancelled" } }
+    });
   };
-  add(path7.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 = path7.join(home, e.name);
-      if (existsSync3(path7.join(d, "projects")) || existsSync3(path7.join(d, "settings.json"))) add(d);
+  const onLine = (line) => {
+    let m;
+    try {
+      m = obj(JSON.parse(line));
+    } catch {
+      return;
     }
-  } catch {
+    if (!m) return;
+    const method = str(m.method);
+    if (method) {
+      if (m.id !== void 0) onRequest(m.id, method, obj(m.params));
+      else if (method === "session/update") onUpdate(obj(obj(m.params)?.update));
+      return;
+    }
+    const p = typeof m.id === "number" ? pending.get(m.id) : void 0;
+    if (!p) return;
+    pending.delete(m.id);
+    const err = obj(m.error);
+    if (err) p.reject(new Error(errorWords(err) || `${label} returned error ${String(err.code ?? "?")}`));
+    else p.resolve(m.result);
+  };
+  let partial = "";
+  child.stdout?.on("data", (b) => {
+    const lines = (partial + b.toString("utf8")).split("\n");
+    partial = lines.pop();
+    for (const l of lines) if (l.trim()) onLine(l);
+    if (partial.length > 4 * 1024 * 1024) partial = "";
+  });
+  child.stderr?.on("data", (b) => {
+    errTail = (errTail + b.toString("utf8")).slice(-4e3);
+  });
+  const left = (why) => {
+    if (gone) return;
+    gone = why;
+    for (const p of pending.values()) p.reject(new Error(why));
+    pending.clear();
+  };
+  child.on("error", (e) => left(`couldn't start ${label}: ${e.message}`));
+  const exited = (code, signal) => {
+    const tail = errTail.trim().split("\n").slice(-3).join(" ").trim();
+    left(`${label} exited (${signal || `code ${code}`})${tail ? `: ${tail}` : ""}`);
+  };
+  child.on("exit", exited);
+  child.on("close", exited);
+  let closed = false;
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    try {
+      child.stdin?.end();
+    } catch {
+    }
+    const grace = o.closeGraceMs ?? 2e3;
+    const t = setTimeout(() => kill("SIGTERM"), grace);
+    t.unref();
+    const k = setTimeout(() => kill("SIGKILL"), grace * 6);
+    k.unref();
+    child.once("exit", () => {
+      clearTimeout(t);
+      clearTimeout(k);
+    });
+  };
+  const open = o.openTimeoutMs ?? 6e4;
+  function held(session) {
+    let busy = false;
+    let lastUsed = now();
+    return {
+      session,
+      mode: "api",
+      get busy() {
+        return busy;
+      },
+      get lastUsed() {
+        return lastUsed;
+      },
+      get closed() {
+        return closed || !!gone;
+      },
+      async send(text) {
+        if (closed) return { reply: "", error: `${label} was closed` };
+        busy = true;
+        lastUsed = now();
+        const t = { text: "", denied: [], count: 0 };
+        turn = t;
+        const limit = o.timeoutMs ?? JOB_TIMEOUT_MS;
+        let timedOut = false;
+        const timer = setTimeout(() => {
+          timedOut = true;
+          notify("session/cancel", { sessionId: session });
+          setTimeout(close, 5e3).unref();
+        }, limit);
+        timer.unref();
+        try {
+          const res = obj(
+            await request("session/prompt", { sessionId: session, prompt: [{ type: "text", text }] }, limit + 1e4)
+          );
+          const stop = str(res?.stopReason);
+          const words = t.text.trim() || `(${label} finished without a written reply.)`;
+          const refused = deniedNote(t.denied, t.count);
+          if (stop === "end_turn" || stop === "max_tokens") return { reply: words + refused };
+          if (stop === "refusal") return { reply: `${words}
+
+(${label} refused the request.)${refused}` };
+          if (stop === "cancelled")
+            return timedOut ? {
+              reply: "",
+              error: `${label} was still working after ${Math.round(limit / 6e4)} minutes, so it was stopped`
+            } : { reply: `${words}
+
+(The turn was cancelled.)${refused}` };
+          return { reply: "", error: `${label} ended the turn with ${stop || "no stop reason"}` };
+        } catch (e) {
+          return { reply: "", error: e.message };
+        } finally {
+          clearTimeout(timer);
+          turn = null;
+          busy = false;
+          lastUsed = now();
+        }
+      },
+      async interrupt() {
+        notify("session/cancel", { sessionId: session });
+      },
+      close
+    };
   }
-  return out.filter((d, i) => i === 0 || existsSync3(d));
+  return (async () => {
+    let signIn = "";
+    try {
+      const init = obj(
+        await request(
+          "initialize",
+          {
+            protocolVersion: 1,
+            clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+            clientInfo: CLIENT_INFO
+          },
+          open
+        )
+      );
+      const caps = obj(init?.agentCapabilities);
+      const info = obj(init?.agentInfo);
+      log(
+        `${label}: ${str(info?.name) || "agent"} ${str(info?.version)} (ACP ${String(init?.protocolVersion ?? "?")})`
+      );
+      const methods = Array.isArray(init?.authMethods) ? init.authMethods.map(obj) : [];
+      if (methods.length) {
+        const how = str(methods[0]?.description) || str(methods[0]?.name);
+        signIn = ` (if ${label} wants a sign-in, do it at the machine's terminal${how ? `: ${how}` : ""})`;
+      }
+      if (o.load) {
+        if (!caps?.loadSession) {
+          close();
+          return { unsupported: `${label} can't reopen a session once it has been closed (no session/load)` };
+        }
+        await request("session/load", { sessionId: o.load, cwd: o.cwd, mcpServers: [] }, open);
+        return { held: held(o.load) };
+      }
+      const res = obj(await request("session/new", { cwd: o.cwd, mcpServers: [] }, open));
+      const session = str(res?.sessionId);
+      if (!session) throw new Error(`${label} opened a session without naming it`);
+      return { held: held(session) };
+    } catch (e) {
+      close();
+      return { failed: `${e.message}${signIn}` };
+    }
+  })();
 }
-var settingsIn = (dir) => path7.join(dir, "settings.json");
-var configDirOf = (transcript) => path7.dirname(path7.dirname(path7.dirname(transcript)));
+
+// src/adapters/antigravity.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync4,
+  realpathSync,
+  statSync as statSync4,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import path8 from "node:path";
+var NAME2 = "antigravity";
+var HOOK_NAME = "sessionpipe";
+var AG_EVENTS = ["PreInvocation", "PostInvocation", "PostToolUse", "Stop"];
+var AG_STALE_PRETOOL = '{"decision":"ask","reason":"sessionpipe: an outdated PreToolUse hook is still loaded. Restart this conversation (or run sessionpipe install) to drop it."}\n';
+var antigravityAnswer = (event) => event === "PreToolUse" ? AG_STALE_PRETOOL : "{}\n";
+var gemini = (env) => env.GEMINI_CLI_HOME || path8.join(homeDir(), ".gemini");
+var hooksFile = (env) => path8.join(gemini(env), "config", "hooks.json");
+var projectsDir = (env) => path8.join(gemini(env), "config", "projects");
+var dataDirs = (env) => ["antigravity", "antigravity-cli", "antigravity-ide"].map((d) => path8.join(gemini(env), d));
+var ID_RE2 = /^[A-Za-z0-9_-]{1,128}$/;
 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 = {
+function entry(cmd) {
+  const handler = (e) => ({ type: "command", command: cmd([NAME2, 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: 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, 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, eventsFor(opts.lean), cmd, OPTS)
-  })),
+  events: AG_EVENTS,
+  detect: (env = process.env) => existsSync3(path8.join(gemini(env), "config")) || dataDirs(env).some((d) => existsSync3(d)),
+  configFiles: (env = process.env) => [hooksFile(env)],
+  install(cmd, env = process.env) {
+    const file = hooksFile(env);
+    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);
+    if (JSON.stringify(hooks[HOOK_NAME]) === JSON.stringify(e)) return [{ file, changed: false }];
+    hooks[HOOK_NAME] = e;
+    mkdirSync2(path8.dirname(file), { recursive: true });
+    writeFileSync3(file, formatJson(hooks, f));
+    return [
+      {
+        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, opts = {}) {
+    const file = hooksFile(env);
+    if (!existsSync3(file)) return [{ file, changed: false }];
+    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];
+    if (opts.created?.includes(file) && !Object.keys(hooks).length) {
+      unlinkSync2(file);
+      return [{ file, changed: true, note: "removed (sessionpipe created it)" }];
+    }
+    writeFileSync3(file, formatJson(hooks, f));
+    return [{ file, changed: true }];
+  },
+  installed(cmd, env = process.env) {
+    const file = hooksFile(env);
+    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"
+      }
+    ];
+  },
   fromHook(input) {
     const event = input.argv[1] ?? "";
     let s = {};
@@ -1077,170 +2212,87 @@ var claudeCode = {
       if (j && typeof j === "object" && !Array.isArray(j)) s = j;
     } catch {
     }
-    const id = s.session_id ?? s.sessionId;
-    if (!id) return null;
-    if (notClaudeCode(String(id), s)) 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 id = s.conversationId ?? s.session_id ?? s.sessionId;
+    const stdout = antigravityAnswer(event);
+    if (!id) return { session: { id: "" }, events: [], stdout };
+    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 = validTool2(toolCall?.name) ? toolCall?.name : validTool2(s.toolName) ? s.toolName : void 0;
     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) }));
+      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 "UserPromptSubmit":
-        events.push(
-          ev("turn.started", {
-            turn_id,
-            prompt_chars: typeof s.prompt === "string" ? [...s.prompt].length : void 0
-          })
-        );
+      case "PostInvocation":
         break;
       case "PreToolUse":
-        if (tool) events.push(ev("tool.started", { tool, call_id, turn_id, agent_id, input: s.tool_input }));
+        if (tool) events.push(ev("tool.started", { tool, input: toolCall?.args }));
         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)
+        if (!tool) events.push(ev("session.heartbeat", {}));
+        else
           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
+              ok: !s.error,
+              error: typeof s.error === "string" ? s.error.slice(0, 2e3) : void 0,
+              input: toolCall?.args
             })
           );
         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 "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", {
-            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) }));
+        events.push(ev("turn.ended", { reason: s.error ? "error" : "stop" }));
         break;
       default:
-        return null;
+        return { session, events: [], stdout };
     }
-    const hints = {};
-    if (event === "UserPromptSubmit" && typeof s.prompt === "string") hints.prompt = s.prompt;
-    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;
+    const r = { session, events, stdout, hints: { workspaces } };
+    if (typeof s.transcriptPath === "string") r.transcript = s.transcriptPath;
     return r;
   },
   readTranscript(file, fromLine) {
     let text = "";
     try {
-      text = readFileSync3(file, "utf8");
+      text = readFileSync4(file, "utf8");
     } catch {
       return { turns: [], line: fromLine };
     }
-    return readClaude(text.split("\n"), fromLine);
+    return readAntigravity(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;
+  facts(session, transcript, hints) {
+    if (!transcript) return {};
+    return antigravityFacts(transcript, {
+      conversation: session.id,
+      workspaces: hints.workspaces ?? (session.cwd ? [session.cwd] : []),
+      env: process.env
+    });
   },
   backfill(sinceMs, env = process.env) {
     const rows2 = [];
-    const files = [];
-    for (const d of claudeDirs(env))
-      files.push(...recentFiles(path7.join(d, "projects"), 1, sinceMs, (n) => /^[0-9a-f-]{36}\.jsonl$/.test(n)));
-    const noState = { get: () => ({}), save: () => {
-    } };
-    for (const f of files) {
-      const id = path7.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;
-      rows2.push({
-        session: { id, ...rest, ...gitFacts(cwd), ...rest.branch ? { branch: rest.branch } : {} },
-        started_at,
-        last_at
-      });
+    for (const data of dataDirs(env)) {
+      let ids = [];
+      try {
+        ids = readdirSync3(path8.join(data, "brain")).filter((n) => /^[0-9a-f-]{36}$/i.test(n));
+      } catch {
+      }
+      for (const id of ids) {
+        const f = path8.join(data, "brain", id, ".system_generated", "logs", "transcript.jsonl");
+        try {
+          if (statSync4(f).mtimeMs < sinceMs) continue;
+        } catch {
+          continue;
+        }
+        const facts = antigravityFacts(f, { conversation: id, workspaces: [], env });
+        if (!facts.started_at || !facts.last_at) continue;
+        const { started_at, last_at, first_ask: _fa, harness_version: _hv, ...rest } = facts;
+        rows2.push({ session: { id, ...rest }, started_at, last_at });
+      }
     }
     return rows2;
   }
@@ -1249,307 +2301,266 @@ function prune2(o) {
   for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
   return o;
 }
-var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function notClaudeCode(id, s) {
-  return typeof s.transcript_path !== "string" && !UUID.test(id);
-}
-function pickSource(v) {
-  return typeof v === "string" && ["startup", "resume", "clear", "compact", "fork"].includes(v) ? v : "unknown";
+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 (!path8.isAbsolute(s)) return null;
+  return path8.resolve(s);
 }
-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);
+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 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
-  };
+  return out;
 }
-var liveCache = /* @__PURE__ */ new Map();
-function claudeLive(dir) {
-  const hit = liveCache.get(dir);
-  if (hit) return hit;
-  const map = /* @__PURE__ */ new Map();
+function agProjects(dir) {
+  const out = [];
   let names = [];
   try {
-    names = readdirSync3(path7.join(dir, "sessions")).filter((n) => n.endsWith(".json"));
+    names = readdirSync3(dir).filter((n) => n.endsWith(".json"));
   } catch {
+    return out;
   }
   for (const n of names) {
+    const id = n.slice(0, -5);
+    if (!ID_RE2.test(id)) continue;
+    let j;
     try {
-      const e = registryEntry(JSON.parse(readFileSync3(path7.join(dir, "sessions", n), "utf8")));
-      if (e?.sessionId) map.set(e.sessionId, e);
+      j = JSON.parse(readFileSync4(path8.join(dir, n), "utf8"));
     } catch {
+      continue;
     }
-  }
-  liveCache.set(dir, map);
-  return map;
-}
-function claudeLiveByPid(dir, pid) {
-  if (!pid) return null;
-  try {
-    return registryEntry(JSON.parse(readFileSync3(path7.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(path7.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;
+    const folders = [];
+    for (const r of j?.projectResources?.resources ?? []) {
+      const f = agPath(r?.folderUri ?? r?.gitFolder?.folderUri);
+      if (f) folders.push(...agVariants(f));
     }
-  } catch {
+    if (folders.length) out.push({ id, folders });
   }
-  return null;
+  return out;
 }
-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;
-      }
-    };
+function agMatchProject(projects, workspaces) {
+  const ws = [];
+  for (const w of workspaces) {
+    const p = agPath(w);
+    if (p) ws.push(...agVariants(p));
   }
-  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]));
+  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(path8.sep) ? f : f + path8.sep));
+      if (within && f.length > bestLen) {
+        best = pr.id;
+        bestLen = f.length;
+      }
     }
-  } catch {
-  }
-  return (pid) => table.get(pid) || 0;
+  return best;
 }
-var EMAIL_RE = /^[^@\s]{1,64}@[^@\s]{1,189}$/;
-function claudeLogin(dir, home = homeDir()) {
-  const files = [path7.join(dir, ".claude.json")];
-  if (path7.resolve(dir) === path7.join(home, ".claude")) files.unshift(path7.join(home, ".claude.json"));
-  for (const f of files) {
+function antigravityRemoteUrl(transcript, opts) {
+  const i = transcript.indexOf(`${path8.sep}brain${path8.sep}`);
+  const dirs = (i > 0 ? [transcript.slice(0, i)] : []).concat(dataDirs(opts.env));
+  for (const d of dirs) {
     try {
-      const a = JSON.parse(readFileSync3(f, "utf8")).oauthAccount;
-      if (typeof a?.accountUuid === "string" && a.accountUuid) {
-        const email = typeof a.emailAddress === "string" && EMAIL_RE.test(a.emailAddress) ? a.emailAddress : void 0;
-        return { id: a.accountUuid.slice(0, 128), ...email ? { email } : {} };
-      }
+      const m = /installation_uuid:\s*"([0-9a-f-]{36})"/i.exec(
+        readFileSync4(path8.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_RE2.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;
 }
-var accountCache = /* @__PURE__ */ new Map();
-function claudeAccount(dir) {
-  const hit = accountCache.get(dir);
-  if (hit !== void 0) return hit;
-  const acct = claudeLogin(dir)?.id ?? null;
-  accountCache.set(dir, acct);
-  return acct;
-}
-function claudeAccounts(dirs, home = homeDir()) {
-  const out = [];
-  for (const d of dirs) {
-    const l = claudeLogin(d, home);
-    if (!l) continue;
-    const seen = out.find((a) => a.id === l.id);
-    if (!seen) out.push({ harness: NAME2, ...l });
-    else if (!seen.email && l.email) seen.email = l.email;
+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;
   }
-  return out;
-}
-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]}`;
-    }
+  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 null;
-}
-function appTitle(text) {
-  const t = String(text).replace(/\s+/g, " ").trim();
-  return t.length > 50 ? `${t.slice(0, 50)}...` : t;
+  return out;
 }
-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;
+
+// src/adapters/antigravity-control.ts
+var antigravity_control_exports = {};
+__export(antigravity_control_exports, {
+  AgyReading: () => AgyReading,
+  agyArgs: () => agyArgs,
+  agyEnv: () => agyEnv,
+  agyError: () => agyError,
+  agyLine: () => agyLine,
+  agyModeFlags: () => agyModeFlags,
+  defaultLevel: () => defaultLevel,
+  findAgy: () => findAgy,
+  offeredLevels: () => offeredLevels,
+  reading: () => reading
+});
+import os4 from "node:os";
+import path9 from "node:path";
+var LABEL = "Antigravity";
+function findAgy(env = process.env, home = os4.homedir()) {
+  return findBinary({
+    override: env.SESSIONPIPE_AGY,
+    names: process.platform === "win32" ? ["agy.exe", "agy.cmd"] : ["agy"],
+    env,
+    dirs: [path9.join(home, ".local", "bin"), "/opt/homebrew/bin", "/usr/local/bin"]
+  });
 }
-function firstAsk(records) {
-  for (const j of records) {
-    const t = askText(j);
-    if (t) return appTitle(t);
-  }
-  return null;
+function agyModeFlags(level) {
+  if (level === "read") throw new Error("Antigravity has no read-only mode");
+  return level === "safe" || level === "inherit" ? [] : ["--mode", "accept-edits"];
 }
-function scanTitles(file, from, found) {
-  const out = { custom: found.custom ?? null, ai: found.ai ?? null, upto: from };
-  let size = 0;
+var offeredLevels = (mode) => mode === "auto" ? ["safe", "edits"] : ["safe"];
+var defaultLevel = (mode) => mode === "auto" ? "edits" : mode;
+function agyArgs(o) {
+  const prompt = o.prompt.startsWith("-") ? ` ${o.prompt}` : o.prompt;
+  return [
+    ...o.resume ? ["--conversation", o.resume] : [],
+    "-p",
+    prompt,
+    "--output-format",
+    "stream-json",
+    ...agyModeFlags(o.permission)
+  ];
+}
+var agyEnv = (env = process.env) => jobEnv(env);
+function agyLine(line) {
+  let j;
   try {
-    size = statSync4(file).size;
+    j = JSON.parse(line);
   } catch {
-    return out;
-  }
-  if (size < from) {
-    out.upto = 0;
-    out.custom = out.ai = null;
-    from = 0;
+    return null;
   }
-  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);
+  if (!j || typeof j !== "object") return null;
+  const str2 = (v) => typeof v === "string" ? v : "";
   const out = {};
-  const id = sessionId || path7.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;
+  if (j.event === "init") {
+    if (str2(j.conversation_id)) out.session = str2(j.conversation_id);
+  } else if (j.event === "step_update") {
+    const s = j.step_update ?? {};
+    if (str2(s.conversation_id)) out.session = str2(s.conversation_id);
+    if (s.step_type === "agent_response" && str2(s.text_delta))
+      out.delta = { step: Number(s.step_index ?? 0), text: str2(s.text_delta) };
+    if (s.step_type === "error_message") {
+      const why = str2(s.text_delta) || str2(s.error) || str2(s.message);
+      if (why) out.note = why;
+    }
+  } else if (j.event === "result") {
+    const r = j.result ?? {};
+    if (str2(r.conversation_id)) out.session = str2(r.conversation_id);
+    out.result = {
+      status: str2(r.status),
+      response: str2(r.response),
+      error: str2(r.error),
+      denied: Array.isArray(r.denied_actions) ? r.denied_actions : []
+    };
+  } else return null;
+  return Object.keys(out).length ? out : null;
+}
+function deniedName(d) {
+  if (typeof d === "string") return d.slice(0, 80);
+  if (!d || typeof d !== "object") return null;
+  const o = d;
+  for (const k of ["tool_name", "toolName", "name", "tool", "action", "type"])
+    if (typeof o[k] === "string" && o[k]) return o[k].slice(0, 80);
+  return null;
+}
+function agyError(stderr) {
+  const s = String(stderr || "");
+  const i = s.lastIndexOf("AGY_ERROR:");
+  if (i < 0) return "";
+  const raw = s.slice(i + "AGY_ERROR:".length).trim();
   try {
-    size = statSync4(file).size;
+    const j = JSON.parse(raw);
+    for (const k of ["message", "error", "detail"]) if (typeof j[k] === "string" && j[k]) return j[k];
   } 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 });
+  return raw.split("\n")[0].slice(0, 300);
+}
+var AgyReading = class {
+  session = null;
+  lines = 0;
+  buf = "";
+  step = null;
+  result = null;
+  note = null;
+  get text() {
+    return this.buf;
   }
-  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";
+  feed(line) {
+    this.lines++;
+    const p = agyLine(line);
+    if (!p) return false;
+    if (p.session && !this.session) this.session = p.session;
+    if (p.note) this.note = p.note;
+    if (p.result) this.result = p.result;
+    if (!p.delta) return false;
+    if (this.step !== null && p.delta.step !== this.step && this.buf && !this.buf.endsWith("\n\n")) this.buf += "\n\n";
+    this.step = p.delta.step;
+    this.buf += p.delta.text;
+    return true;
   }
-  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;
+  outcome(res) {
+    const broke = runFailure(LABEL, res);
+    if (broke) return { failed: broke };
+    const r = this.result;
+    if (!r) {
+      const why = agyError(res.stderr) || this.note || "";
+      return {
+        failed: `Antigravity exited (${res.signal || `code ${res.code}`}) without an answer${why ? `: ${why}` : ""}`
+      };
     }
+    if (r.status !== "SUCCESS")
+      return { failed: r.error || agyError(res.stderr) || this.note || "Antigravity reported an error" };
+    const names = [...new Set(r.denied.map(deniedName).filter((n) => !!n))];
+    const text = r.response.trim() ? r.response.trim() : this.buf.trim() || "(Antigravity finished without a written reply.)";
+    return { reply: text + deniedNote(names, r.denied.length) };
   }
-  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;
-}
+};
+var reading = () => new AgyReading();
 
 // src/adapters/claude-code-control.ts
 var claude_code_control_exports = {};
 __export(claude_code_control_exports, {
   JOB_TIMEOUT_MS: () => JOB_TIMEOUT_MS,
+  ceilingLevel: () => ceilingLevel,
+  claudeArgs: () => claudeArgs,
   claudeEnv: () => claudeEnv,
   claudeLogin: () => claudeLogin2,
   cmpVersion: () => cmpVersion,
+  defaultLevel: () => defaultLevel2,
   detectCaps: () => detectCaps,
   findClaude: () => findClaude,
   findTranscript: () => findTranscript,
@@ -1558,6 +2569,8 @@ __export(claude_code_control_exports, {
   loginCommand: () => loginCommand,
   loginHint: () => loginHint,
   modeFlags: () => modeFlags,
+  offeredLevels: () => offeredLevels2,
+  outputArgs: () => outputArgs,
   parseAuthStatus: () => parseAuthStatus,
   parseCaps: () => parseCaps,
   parseResult: () => parseResult,
@@ -1566,10 +2579,33 @@ __export(claude_code_control_exports, {
   sessionFolder: () => sessionFolder
 });
 import { execFile, execFileSync as execFileSync3 } from "node:child_process";
-import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync4, readSync as readSync2, statSync as statSync5 } from "node:fs";
-import os3 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;
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync5, readSync as readSync2, statSync as statSync5 } from "node:fs";
+import os5 from "node:os";
+import path10 from "node:path";
+
+// src/control/verify.ts
+var GRANT_MAX_MS = 24 * 36e5;
+var SKEW_MS = 5 * 6e4;
+var MACHINE_MAX_AGE_MS = 24 * 36e5;
+var RECEIVER_MAX_AGE_MS = 10 * 6e4;
+var NONCE_TTL_MS = 25 * 36e5;
+var MODEL_RE = /^[A-Za-z0-9][A-Za-z0-9._:/@[\]-]*$/;
+var START_PERMISSIONS = ["read", "safe", "edits", "auto"];
+var levelRank = (l) => START_PERMISSIONS.indexOf(l);
+var FIELDS = {
+  prompt: ["text", "files"],
+  "permission.answer": ["for", "decision"],
+  cancel: [],
+  start: ["text", "cwd", "files", "permission", "model"],
+  "key.add": ["key", "name"],
+  pool: ["pool_action", "pool_account", "pool_order", "pool_code"]
+};
+var POOL_FIELDS = FIELDS.pool;
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+
+// src/adapters/claude-code-control.ts
+var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var LIVE_WRITE_MS = 9e4;
 var cmpVersion = (a, b) => {
   const pa = a.split(".").map(Number);
@@ -1578,28 +2614,28 @@ var cmpVersion = (a, b) => {
     if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
   return 0;
 };
-function findClaude(env = process.env, home = os3.homedir()) {
+function findClaude(env = process.env, home = os5.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 d of String(env.PATH || "").split(path10.delimiter)) {
+    if (!d || !path10.isAbsolute(d)) continue;
+    for (const n of names) if (isExe(path10.join(d, n))) return path10.join(d, n);
   }
   for (const p of [
-    path8.join(home, ".claude", "local", "claude"),
-    path8.join(home, ".local", "bin", "claude"),
+    path10.join(home, ".claude", "local", "claude"),
+    path10.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");
+  const app = path10.join(home, "Library", "Application Support", "Claude", "claude-code");
   let versions = [];
   try {
     versions = readdirSync4(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");
+    const p = path10.join(app, v, "claude.app", "Contents", "MacOS", "claude");
     if (isExe(p)) return p;
   }
   return null;
@@ -1625,11 +2661,19 @@ function parseCaps(help) {
     stream: !!optionBlock(help, "--include-partial-messages")
   };
 }
-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"] };
+var LEVEL_MODE = {
+  read: "plan",
+  edits: "acceptEdits",
+  auto: "auto"
+};
+function modeFlags(level, caps) {
+  if (level === "inherit") return { args: [] };
+  if (level === "auto" && !caps.modes.includes("auto"))
+    return { error: "this machine is in auto mode, but its Claude Code has no auto permission mode" };
+  if (level !== "safe") {
+    const m = LEVEL_MODE[level];
+    if (!caps.modes.includes(m)) return { error: `this machine's Claude Code has no ${m} permission mode` };
+    return { args: ["--permission-mode", m] };
   }
   if (caps.modes.includes("dontAsk")) return { args: ["--permission-mode", "dontAsk"] };
   const args = [];
@@ -1641,6 +2685,32 @@ function modeFlags(mode, caps) {
   if (caps.promptsNone) args.push("--permission-prompts", "none");
   return { args };
 }
+var ceilingLevel = (mode) => mode === "inherit" ? "safe" : mode;
+function offeredLevels2(mode, caps) {
+  return START_PERMISSIONS.filter(
+    (l) => levelRank(l) <= levelRank(ceilingLevel(mode)) && (l === "safe" || caps.modes.includes(LEVEL_MODE[l]))
+  );
+}
+var defaultLevel2 = (mode) => mode;
+function outputArgs(caps) {
+  return caps.stream ? ["--output-format", "stream-json", "--verbose", "--include-partial-messages"] : ["--output-format", "json"];
+}
+function claudeArgs(o) {
+  const mf = modeFlags(o.level, o.caps);
+  if ("error" in mf) return mf;
+  const where = o.resume ? ["--resume", o.resume, ...o.fork ? ["--fork-session"] : []] : ["--session-id", o.session];
+  return {
+    args: [
+      "-p",
+      ...outputArgs(o.caps),
+      ...mf.args,
+      ...o.model ? ["--model", o.model] : [],
+      ...o.allowedTools?.length ? [`--allowedTools=${o.allowedTools.join(",")}`] : [],
+      ...where,
+      o.prompt.startsWith("-") ? ` ${o.prompt}` : o.prompt
+    ]
+  };
+}
 function claudeEnv(configDir, env = process.env) {
   const e = { ...env };
   for (const k of [
@@ -1654,7 +2724,7 @@ function claudeEnv(configDir, env = process.env) {
     delete e[k];
   e.SESSIONPIPE_CONTROL_JOB = "1";
   if (configDir !== void 0) {
-    if (path8.resolve(configDir) === path8.resolve(os3.homedir(), ".claude")) delete e.CLAUDE_CONFIG_DIR;
+    if (path10.resolve(configDir) === path10.resolve(os5.homedir(), ".claude")) delete e.CLAUDE_CONFIG_DIR;
     else e.CLAUDE_CONFIG_DIR = configDir;
   }
   return e;
@@ -1687,12 +2757,12 @@ function claudeLogin2(bin, configDir, env = process.env) {
   });
 }
 function loginCommand(configDir) {
-  const home = os3.homedir();
-  const isDefault = !configDir || path8.resolve(configDir) === path8.resolve(home, ".claude");
+  const home = os5.homedir();
+  const isDefault = !configDir || path10.resolve(configDir) === path10.resolve(home, ".claude");
   return isDefault ? "`claude auth login`" : `\`CLAUDE_CONFIG_DIR=${configDir.replace(home, "~")} claude auth login\``;
 }
 function loginHint(configDir, platform = process.platform) {
-  const shown = configDir ? configDir.replace(os3.homedir(), "~") : "~/.claude";
+  const shown = configDir ? configDir.replace(os5.homedir(), "~") : "~/.claude";
   const login = loginCommand(configDir);
   if (platform === "darwin")
     return `Claude Code (${shown}) isn't signed in as this machine's background service sees it. On a Mac its login lives in the login keychain, which a background service can read only while someone is logged in at the screen: log in at the Mac, or run ${login} there.`;
@@ -1714,17 +2784,17 @@ function detectCaps(bin) {
   return parseCaps(help);
 }
 function findTranscript(session, dirs) {
-  if (!UUID_RE.test(session)) return null;
+  if (!UUID_RE2.test(session)) return null;
   for (const dir of dirs) {
     let projects = [];
     try {
-      projects = readdirSync4(path8.join(dir, "projects"), { withFileTypes: true });
+      projects = readdirSync4(path10.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`);
+      const file = path10.join(dir, "projects", p.name, `${session}.jsonl`);
       try {
         if (statSync5(file).isFile()) return { file, configDir: dir, project: p.name };
       } catch {
@@ -1746,7 +2816,7 @@ function sessionFolder(t, cap2 = 8 * 1024 * 1024) {
     } catch {
       return null;
     }
-    if (!j || typeof j.cwd !== "string" || !path8.isAbsolute(j.cwd)) return null;
+    if (!j || typeof j.cwd !== "string" || !path10.isAbsolute(j.cwd)) return null;
     if (projectName(j.cwd) === t.project) return j.cwd;
     first ??= j.cwd;
     count++;
@@ -1807,13 +2877,13 @@ function pidAlive(pid) {
 function liveProcess(session, configDir) {
   let names = [];
   try {
-    names = readdirSync4(path8.join(configDir, "sessions")).filter((n) => /^\d+\.json$/.test(n));
+    names = readdirSync4(path10.join(configDir, "sessions")).filter((n) => /^\d+\.json$/.test(n));
   } catch {
     return false;
   }
   for (const n of names) {
     try {
-      const j = JSON.parse(readFileSync4(path8.join(configDir, "sessions", n), "utf8"));
+      const j = JSON.parse(readFileSync5(path10.join(configDir, "sessions", n), "utf8"));
       if (String(j.sessionId) !== session) continue;
       if (pidAlive(Number(j.pid ?? n.slice(0, -5)))) return true;
     } catch {
@@ -1858,14 +2928,14 @@ function parseResult(stdout) {
   }
   return null;
 }
-var isUuid = (s) => typeof s === "string" && UUID_RE.test(s);
+var isUuid = (s) => typeof s === "string" && UUID_RE2.test(s);
 
 // src/adapters/codex.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
-import path9 from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import path11 from "node:path";
 
 // src/adapters/codex-config.ts
-var NOTIFY_LINE = /^[ \t]*notify[ \t]*=[ \t]*(\[.*\])[ \t]*(?:#.*)?$/m;
+var NOTIFY_LINE = /^[ \t]*notify[ \t]*=[ \t]*(\[.*\])[ \t]*(?:#.*)?(?=\r?$)/m;
 var NOTIFY_KEY = /^[ \t]*notify[ \t]*=/m;
 var OURS2 = /(?:hook\.js|sessionpipe-hook)",\s*"codex",\s*"notify"/;
 function scan(line, st) {
@@ -1955,10 +3025,11 @@ function dropLine(text, index, length) {
 }
 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}`;
+  const body = head.replace(/\s*$/, "");
+  const eol = (body.includes("\n") ? body : text).includes("\r\n") ? "\r\n" : "\n";
+  const top = head.trim() ? head.replace(/\s*$/, eol) : "";
+  if (!tail) return top + line + eol;
+  return `${top + line}${eol}${eol}${tail}`;
 }
 function withNotify(text, line) {
   const n = readNotify(text);
@@ -2007,25 +3078,25 @@ var CODEX_EVENTS = [
 ];
 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 || path9.join(homeDir(), ".codex");
-var hooksFile2 = (env) => path9.join(codexHome(env), "hooks.json");
-var configFile2 = (env) => path9.join(codexHome(env), "config.toml");
-var sessionsDir = (env) => path9.join(codexHome(env), "sessions");
+var codexHome = (env) => env.CODEX_HOME || path11.join(homeDir(), ".codex");
+var hooksFile2 = (env) => path11.join(codexHome(env), "hooks.json");
+var configFile2 = (env) => path11.join(codexHome(env), "config.toml");
+var sessionsDir = (env) => path11.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 = configFile2(env);
   let text = "";
   try {
-    text = readFileSync5(file, "utf8");
+    text = readFileSync6(file, "utf8");
   } catch {
   }
   const argv = cmd([NAME3, "notify"]).argv;
   const line = `notify = ${JSON.stringify(argv)}`;
   const n = readNotify(text);
   const write = (next) => {
-    mkdirSync3(path9.dirname(file), { recursive: true });
-    writeFileSync3(file, next);
+    mkdirSync3(path11.dirname(file), { recursive: true });
+    writeFileSync4(file, next);
   };
   if (n && !n.other) {
     if (!n.misplaced && JSON.stringify(n.argv) === JSON.stringify(argv))
@@ -2063,19 +3134,19 @@ function uninstallNotify(env) {
   const file = configFile2(env);
   let text;
   try {
-    text = readFileSync5(file, "utf8");
+    text = readFileSync6(file, "utf8");
   } catch {
     return { file, changed: false };
   }
   const n = readNotify(text);
   if (!n) return { file, changed: false };
   if (!n.other) {
-    writeFileSync3(file, withoutNotify(text));
+    writeFileSync4(file, withoutNotify(text));
     return { file, changed: true };
   }
   const prev = previousNotify(n.argv);
   if (isComputerUse(n.argv) && prev && OURS2.test(JSON.stringify(prev))) {
-    writeFileSync3(file, replaceNotify(text, n, `notify = ${stripPreviousRaw(n.raw)}`));
+    writeFileSync4(file, replaceNotify(text, n, `notify = ${stripPreviousRaw(n.raw)}`));
     return { file, changed: true };
   }
   return { file, changed: false };
@@ -2091,7 +3162,7 @@ function findRollout(threadId, env = process.env) {
       return;
     }
     for (const n of names.sort().reverse()) {
-      const p = path9.join(dir, n);
+      const p = path11.join(dir, n);
       if (n.endsWith(`-${threadId}.jsonl`)) {
         best = p;
         return;
@@ -2135,7 +3206,7 @@ var codex = {
     ];
     let text = "";
     try {
-      text = readFileSync5(configFile2(env), "utf8");
+      text = readFileSync6(configFile2(env), "utf8");
     } catch {
     }
     const n = readNotify(text);
@@ -2181,7 +3252,7 @@ var codex = {
       if (j && typeof j === "object" && !Array.isArray(j)) s = j;
     } catch {
     }
-    const id = s.session_id;
+    const id = s.session_id ?? s.thread_id ?? s.conversation_id ?? s["thread-id"] ?? s["session-id"];
     if (!id) return null;
     if (s.transcript_path === null) return null;
     const session = { id: String(id), cwd: typeof s.cwd === "string" ? s.cwd : input.cwd };
@@ -2262,7 +3333,7 @@ var codex = {
   readTranscript(file, fromLine) {
     let text = "";
     try {
-      text = readFileSync5(file, "utf8");
+      text = readFileSync6(file, "utf8");
     } catch {
       return { turns: [], line: fromLine };
     }
@@ -2276,7 +3347,7 @@ var codex = {
   backfill(sinceMs, env = process.env) {
     const rows2 = [];
     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(path9.basename(f));
+      const m = /([0-9a-f]{8}-[0-9a-f-]{27,})\.jsonl$/i.exec(path11.basename(f));
       if (!m?.[1]) continue;
       if (codexSubagent(rolloutMeta(f))) continue;
       const facts = codexFacts(f);
@@ -2285,12 +3356,40 @@ var codex = {
       rows2.push({ session: { id: m[1], ...rest }, started_at, last_at });
     }
     return rows2;
-  }
+  },
+  limits: (transcript) => codexLimits(transcript)
 };
+var epochIso2 = (t) => typeof t === "number" && t > 0 && t < 1e11 ? new Date(t * 1e3).toISOString() : void 0;
 function prune3(o) {
   for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
   return o;
 }
+function codexLimits(file) {
+  const { tail } = ends(file, 0, 256 * 1024);
+  for (const r of parseLines(tail).reverse()) {
+    const p = r.payload;
+    if (r.type !== "event_msg" || p?.type !== "token_count") continue;
+    if (!p.rate_limits || typeof p.rate_limits !== "object") continue;
+    const rl = p.rate_limits;
+    if (rl.limit_id != null && rl.limit_id !== "codex") continue;
+    const windows = [];
+    for (const id of ["primary", "secondary"]) {
+      const w = rl[id];
+      if (typeof w?.used_percent !== "number" || w.used_percent < 0) continue;
+      windows.push(
+        prune3({
+          id,
+          used_percent: w.used_percent,
+          window_minutes: Number.isInteger(w.window_minutes) && Number(w.window_minutes) > 0 ? Number(w.window_minutes) : void 0,
+          resets_at: epochIso2(w.resets_at)
+        })
+      );
+    }
+    if (!windows.length) return null;
+    return prune3({ windows, plan: typeof rl.plan_type === "string" ? rl.plan_type.slice(0, 64) : void 0 });
+  }
+  return null;
+}
 function codexFacts(file) {
   const { head, tail } = ends(file, 128 * 1024, 64 * 1024);
   let H = parseLines(head);
@@ -2343,38 +3442,71 @@ __export(codex_control_exports, {
   codexLine: () => codexLine,
   codexLogin: () => codexLogin,
   codexModeFlags: () => codexModeFlags,
+  codexModels: () => codexModels,
+  defaultLevel: () => defaultLevel3,
   findCodex: () => findCodex,
   findRollout: () => findRollout,
+  offeredLevels: () => offeredLevels3,
   reading: () => reading2
 });
 import { execFile as execFile2 } from "node:child_process";
-import os4 from "node:os";
-import path10 from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import os6 from "node:os";
+import path12 from "node:path";
 var LABEL2 = "Codex";
-function findCodex(env = process.env, home = os4.homedir(), nodeDir = path10.dirname(process.execPath)) {
+function findCodex(env = process.env, home = os6.homedir(), nodeDir = path12.dirname(process.execPath)) {
   return findBinary({
     override: env.SESSIONPIPE_CODEX,
     names: process.platform === "win32" ? ["codex.exe", "codex.cmd"] : ["codex"],
     env,
-    dirs: [nodeDir, path10.join(home, ".local", "bin"), "/opt/homebrew/bin", "/usr/local/bin"]
+    dirs: [nodeDir, path12.join(home, ".local", "bin"), "/opt/homebrew/bin", "/usr/local/bin"]
   });
 }
-function codexModeFlags(mode, resume = false) {
+function codexModeFlags(level, resume = false) {
+  if (level === "inherit") return [];
+  const sandbox = level === "read" ? "read-only" : "workspace-write";
   if (resume)
-    return mode === "auto" ? [
+    return level === "auto" ? [
       "-c",
       'sandbox_mode="workspace-write"',
       "-c",
       'approval_policy="on-request"',
       "-c",
       'approvals_reviewer="auto_review"'
-    ] : ["-c", 'sandbox_mode="workspace-write"'];
-  return mode === "auto" ? ["--approve-for-me"] : ["-s", "workspace-write"];
+    ] : ["-c", `sandbox_mode="${sandbox}"`];
+  return level === "auto" ? ["--approve-for-me"] : ["-s", sandbox];
 }
+var offeredLevels3 = (mode) => mode === "auto" ? ["read", "safe", "auto"] : ["read", "safe"];
+var defaultLevel3 = (mode) => mode;
 function codexArgs(o) {
   const common = ["--json", "--skip-git-repo-check"];
-  if (o.resume) return ["exec", "resume", ...common, ...codexModeFlags(o.mode, true), "--", o.resume, o.prompt];
-  return ["exec", ...common, ...o.cwd ? ["-C", o.cwd] : [], ...codexModeFlags(o.mode), "--", o.prompt];
+  const model = o.model ? ["-m", o.model] : [];
+  if (o.resume)
+    return ["exec", "resume", ...common, ...codexModeFlags(o.permission, true), ...model, "--", o.resume, o.prompt];
+  return [
+    "exec",
+    ...common,
+    ...o.cwd ? ["-C", o.cwd] : [],
+    ...codexModeFlags(o.permission),
+    ...model,
+    "--",
+    o.prompt
+  ];
+}
+function codexModels(env = process.env, home = os6.homedir()) {
+  try {
+    const file = path12.join(env.CODEX_HOME || path12.join(home, ".codex"), "models_cache.json");
+    const j = JSON.parse(readFileSync7(file, "utf8"));
+    if (!Array.isArray(j.models)) return [];
+    const out = [];
+    for (const m of j.models)
+      if (m && m.visibility === "list" && typeof m.slug === "string" && MODEL_RE.test(m.slug) && m.slug.length <= 100) {
+        if (!out.includes(m.slug)) out.push(m.slug);
+      }
+    return out.slice(0, 50);
+  } catch {
+    return [];
+  }
 }
 var codexEnv = (env = process.env) => jobEnv(env);
 var LOGIN_HINT = "Codex isn't signed in on this machine: run `codex login --device-auth` there.";
@@ -2401,22 +3533,22 @@ function codexLine(line) {
     return null;
   }
   if (!j || typeof j !== "object") return null;
-  const str = (v) => typeof v === "string" ? v : "";
+  const str2 = (v) => typeof v === "string" ? v : "";
   switch (j.type) {
     case "thread.started":
-      return str(j.thread_id) ? { session: str(j.thread_id) } : null;
+      return str2(j.thread_id) ? { session: str2(j.thread_id) } : null;
     case "item.completed": {
       const it = j.item;
-      if (it?.type === "agent_message" && str(it.text)) return { message: str(it.text) };
-      if (it?.type === "error" && str(it.message)) return { warning: str(it.message) };
+      if (it?.type === "agent_message" && str2(it.text)) return { message: str2(it.text) };
+      if (it?.type === "error" && str2(it.message)) return { warning: str2(it.message) };
       return null;
     }
     case "turn.completed":
       return { done: true };
     case "turn.failed":
-      return { done: true, failed: str(j.error?.message) || "Codex reported an error" };
+      return { done: true, failed: str2(j.error?.message) || "Codex reported an error" };
     case "error":
-      return str(j.message) ? { note: str(j.message) } : null;
+      return str2(j.message) ? { note: str2(j.message) } : null;
     default:
       return null;
   }
@@ -2467,9 +3599,9 @@ function codexStderr(stderr) {
 var reading2 = () => new CodexReading();
 
 // src/adapters/devin.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync6, readlinkSync } from "node:fs";
-import path11 from "node:path";
+import path13 from "node:path";
 
 // src/readers/sqlite.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
@@ -2653,11 +3785,11 @@ function foreignEvent(file) {
   return Object.keys(hooks).find((k) => !ok.includes(k));
 }
 var homeOf = (env) => env.HOME || homeDir();
-var appData = (env) => env.APPDATA || path11.join(homeOf(env), "AppData", "Roaming");
-var devinConfigDir = (env = process.env) => process.platform === "win32" ? path11.join(appData(env), "devin") : path11.join(env.XDG_CONFIG_HOME || path11.join(homeOf(env), ".config"), "devin");
-var configFile3 = (env) => path11.join(devinConfigDir(env), "config.json");
-var devinDataDir = (env = process.env) => process.platform === "win32" ? path11.join(appData(env), "devin", "cli") : path11.join(env.XDG_DATA_HOME || path11.join(homeOf(env), ".local", "share"), "devin", "cli");
-var sessionsDb = (env) => path11.join(devinDataDir(env), "sessions.db");
+var appData = (env) => env.APPDATA || path13.join(homeOf(env), "AppData", "Roaming");
+var devinConfigDir = (env = process.env) => process.platform === "win32" ? path13.join(appData(env), "devin") : path13.join(env.XDG_CONFIG_HOME || path13.join(homeOf(env), ".config"), "devin");
+var configFile3 = (env) => path13.join(devinConfigDir(env), "config.json");
+var devinDataDir = (env = process.env) => process.platform === "win32" ? path13.join(appData(env), "devin", "cli") : path13.join(env.XDG_DATA_HOME || path13.join(homeOf(env), ".local", "share"), "devin", "cli");
+var sessionsDb = (env) => path13.join(devinDataDir(env), "sessions.db");
 var SESSION_ID = /^[A-Za-z0-9._:-]{1,128}$/;
 var validTool4 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
 var endReason3 = (r) => r === "clear" || r === "logout" || r === "exit" ? r : "other";
@@ -2708,7 +3840,7 @@ var devin = {
     const tool = validTool4(s.tool_name) ? s.tool_name : void 0;
     const call_id = typeof s.tool_use_id === "string" ? s.tool_use_id : void 0;
     const response = s.tool_response && typeof s.tool_response === "object" && !Array.isArray(s.tool_response) ? s.tool_response : void 0;
-    const permissionId = () => `perm-${createHash2("sha256").update(`${turn_id ?? ""}|${tool ?? ""}|${JSON.stringify(s.tool_input ?? null)}`).digest("hex").slice(0, 16)}`;
+    const permissionId = () => `perm-${createHash3("sha256").update(`${turn_id ?? ""}|${tool ?? ""}|${JSON.stringify(s.tool_input ?? null)}`).digest("hex").slice(0, 16)}`;
     const ev = (type, data) => ({ type, data: prune4(data), harnessEvent: event });
     const events = [];
     switch (event) {
@@ -2829,7 +3961,7 @@ var BACKFILL_SQL = `SELECT s.id, ${SESSION_FIELDS} FROM sessions s
 function sessionFacts(row) {
   const out = {};
   if (typeof row.model === "string" && row.model) out.model = row.model;
-  if (typeof row.working_directory === "string" && path11.isAbsolute(row.working_directory))
+  if (typeof row.working_directory === "string" && path13.isAbsolute(row.working_directory))
     out.cwd = row.working_directory;
   const started = Number(row.created_at);
   const last = Number(row.last_activity_at);
@@ -2874,8 +4006,8 @@ function readDevinChain(db, session, fromLine) {
 }
 function devinVersion(env = process.env) {
   try {
-    const target = readlinkSync(path11.join(devinDataDir(env), "_versions", "current"));
-    const name = path11.basename(target);
+    const target = readlinkSync(path13.join(devinDataDir(env), "_versions", "current"));
+    const name = path13.basename(target);
     return /^[0-9][0-9A-Za-z.+-]{0,63}$/.test(name) ? name : void 0;
   } catch {
     return void 0;
@@ -2889,8 +4021,8 @@ function devinAccount(env = process.env) {
 
 // src/adapters/gemini-cli.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
-import path12 from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
+import path14 from "node:path";
 var NAME5 = "gemini-cli";
 var GEMINI_EVENTS = [
   "SessionStart",
@@ -2903,26 +4035,31 @@ var GEMINI_EVENTS = [
   "SessionEnd"
 ];
 var OPTS4 = { matcherFor: (e) => /Tool/.test(e) ? ".*" : void 0, timeout: 5e3 };
-var geminiDir = (env) => env.GEMINI_CLI_HOME || path12.join(homeDir(), ".gemini");
-var settings = (env) => path12.join(geminiDir(env), "settings.json");
+var geminiDir = (env) => env.GEMINI_CLI_HOME || path14.join(homeDir(), ".gemini");
+var settings = (env) => path14.join(geminiDir(env), "settings.json");
 var validTool5 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
 var eventsFor4 = (lean) => lean ? GEMINI_EVENTS.filter((e) => e !== "BeforeTool") : [...GEMINI_EVENTS];
+function geminiVersion(platform = process.platform, env = process.env) {
+  const win = platform === "win32";
+  const bin = win ? findBinary({ names: ["gemini.exe", "gemini.cmd"], dirs: [path14.dirname(process.execPath)], env }) : "gemini";
+  if (!bin) throw new Error("no gemini on PATH");
+  const o = {
+    encoding: "utf8",
+    timeout: 4e3,
+    stdio: ["ignore", "pipe", "ignore"],
+    env
+  };
+  const out = /\.cmd$/i.test(bin) ? execFileSync5(`"${bin}" --version`, { ...o, shell: true }) : execFileSync5(bin, ["--version"], o);
+  return out.trim();
+}
 function geminiHooksActive(settingsFile) {
-  let tools;
-  try {
-    tools = JSON.parse(readFileSync6(settingsFile, "utf8")).tools;
-  } catch {
-  }
+  const tools = readJson(settingsFile).tools;
   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 = execFileSync5("gemini", ["--version"], {
-      encoding: "utf8",
-      timeout: 4e3,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
+    version = geminiVersion();
   } catch {
     return {
       active: true,
@@ -2940,7 +4077,7 @@ var geminiCli = {
   name: NAME5,
   events: GEMINI_EVENTS,
   // ~/.gemini also belongs to Antigravity; Gemini CLI is here when its settings or its chat logs exist.
-  detect: (env = process.env) => existsSync7(settings(env)) || existsSync7(path12.join(geminiDir(env), "tmp")),
+  detect: (env = process.env) => existsSync7(settings(env)) || existsSync7(path14.join(geminiDir(env), "tmp")),
   configFiles: (env = process.env) => [settings(env)],
   install: (cmd, env = process.env, opts = {}) => {
     const r = installClaudeShaped(settings(env), NAME5, eventsFor4(opts.lean), cmd, OPTS4);
@@ -3038,7 +4175,7 @@ var geminiCli = {
   readTranscript(file, fromLine) {
     let text = "";
     try {
-      text = readFileSync6(file, "utf8");
+      text = readFileSync8(file, "utf8");
     } catch {
       return { turns: [], line: fromLine };
     }
@@ -3076,21 +4213,23 @@ function prune5(o) {
 // src/adapters/index.ts
 var ADAPTERS = [claudeCode, codex, geminiCli, antigravity, devin];
 var adapterByName = (name) => ADAPTERS.find((a) => a.name === name);
+var HELLO_HARNESSES_MAX = 20;
 function drivableHarnesses(env = process.env) {
   return [
     ...findClaude(env) ? ["claude-code"] : [],
     ...findCodex(env) ? ["codex"] : [],
-    ...findAgy(env) ? ["antigravity"] : []
-  ];
+    ...findAgy(env) ? ["antigravity"] : [],
+    ...acpHarnesses(env)
+  ].slice(0, HELLO_HARNESSES_MAX);
 }
 
 // src/config.ts
-import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import path13 from "node:path";
+import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
+import path15 from "node:path";
 var DEFAULT_CONFIG = { sinks: [], harnesses: {}, update_check: true, keep_days: 30 };
 function readConfig(file = configFile()) {
   try {
-    const j = JSON.parse(readFileSync7(file, "utf8"));
+    const j = JSON.parse(readFileSync9(file, "utf8"));
     return {
       ...DEFAULT_CONFIG,
       ...j,
@@ -3102,8 +4241,8 @@ function readConfig(file = configFile()) {
   }
 }
 function writeConfig(c, file = configFile()) {
-  mkdirSync4(path13.dirname(file), { recursive: true, mode: 448 });
-  writeFileSync4(file, `${JSON.stringify(c, null, 2)}
+  mkdirSync4(path15.dirname(file), { recursive: true, mode: 448 });
+  writeFileSync5(file, `${JSON.stringify(c, null, 2)}
 `, { mode: 384 });
   if (process.platform !== "win32" && existsSync8(file)) {
     try {
@@ -3118,7 +4257,7 @@ function machineName(c, hostname) {
 }
 
 // src/ulid.ts
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes2 } from "node:crypto";
 var ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var lastTime = 0;
 var lastRand = [];
@@ -3143,7 +4282,7 @@ function ulid(now = Date.now()) {
     }
   } else {
     lastTime = now;
-    lastRand = Array.from(randomBytes(16), (b) => b % 32);
+    lastRand = Array.from(randomBytes2(16), (b) => b % 32);
   }
   return encodeTime(now) + lastRand.map((v) => ALPHABET[v]).join("");
 }
@@ -3167,6 +4306,22 @@ function makeEvent(a, ctx) {
   };
 }
 
+// src/launched-by.ts
+var LAUNCHED_BY_ENV = "SESSIONPIPE_LAUNCHED_BY";
+var LAUNCHED_BY = /^[a-z][a-z0-9-]{0,39}:[A-Za-z0-9._:-]{1,128}$/;
+function launchedBy(env) {
+  const v = env[LAUNCHED_BY_ENV]?.trim();
+  return v && LAUNCHED_BY.test(v) ? v : void 0;
+}
+function readHook(adapter, input) {
+  const r = adapter.fromHook(input);
+  if (r && !r.session.parent_id) {
+    const launcher = launchedBy(input.env);
+    if (launcher && launcher !== `${adapter.name}:${r.session.id}`) r.session.launched_by = launcher;
+  }
+  return r;
+}
+
 // src/outbox.ts
 import {
   appendFileSync,
@@ -3175,14 +4330,14 @@ import {
   mkdirSync as mkdirSync5,
   openSync as openSync3,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync10,
   readSync as readSync3,
   renameSync,
   statSync as statSync6,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import path14 from "node:path";
+import path16 from "node:path";
 var READ_CHUNK = 1024 * 1024;
 var READ_MAX = 8 * 1024 * 1024;
 var Outbox = class {
@@ -3191,13 +4346,13 @@ var Outbox = class {
   }
   root;
   dir(harness) {
-    return path14.join(this.root, "outbox", safeId(harness));
+    return path16.join(this.root, "outbox", safeId(harness));
   }
   file(ref) {
-    return path14.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
+    return path16.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
   }
   seqFile(ref) {
-    return path14.join(this.dir(ref.harness), `${safeId(ref.session)}.seq`);
+    return path16.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). */
@@ -3205,19 +4360,19 @@ var Outbox = class {
     const f = this.seqFile(ref);
     let n = -1;
     try {
-      const t = readFileSync8(f, "utf8").trim();
+      const t = readFileSync10(f, "utf8").trim();
       if (/^\d+$/.test(t)) n = Number(t);
     } catch {
     }
     if (n < 0) n = this.lastSeqInFile(ref) + 1;
-    mkdirSync5(path14.dirname(f), { recursive: true, mode: 448 });
-    writeFileSync5(f, String(n + 1), { mode: 384 });
+    mkdirSync5(path16.dirname(f), { recursive: true, mode: 448 });
+    writeFileSync6(f, String(n + 1), { mode: 384 });
     return n;
   }
   lastSeqInFile(ref) {
     const f = this.file(ref);
     if (!existsSync9(f)) return -1;
-    const lines = readFileSync8(f, "utf8").trim().split("\n");
+    const lines = readFileSync10(f, "utf8").trim().split("\n");
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
         const j = JSON.parse(lines[i]);
@@ -3236,10 +4391,10 @@ var Outbox = class {
   /** Every session file, newest first. */
   sessions() {
     const out = [];
-    const base = path14.join(this.root, "outbox");
+    const base = path16.join(this.root, "outbox");
     if (!existsSync9(base)) return [];
     for (const h of readdirSync6(base)) {
-      const d = path14.join(base, h);
+      const d = path16.join(base, h);
       let names = [];
       try {
         names = readdirSync6(d).filter((n) => n.endsWith(".jsonl"));
@@ -3248,7 +4403,7 @@ var Outbox = class {
       }
       for (const n of names) {
         try {
-          out.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync6(path14.join(d, n)).mtimeMs });
+          out.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync6(path16.join(d, n)).mtimeMs });
         } catch {
         }
       }
@@ -3336,20 +4491,20 @@ var Cursors = class {
   root;
   sink;
   file() {
-    return path14.join(this.root, "cursors", `${safeId(this.sink)}.json`);
+    return path16.join(this.root, "cursors", `${safeId(this.sink)}.json`);
   }
   read() {
     try {
-      return JSON.parse(readFileSync8(this.file(), "utf8"));
+      return JSON.parse(readFileSync10(this.file(), "utf8"));
     } catch {
       return {};
     }
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path14.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync5(path16.dirname(f), { recursive: true, mode: 448 });
     const tmp = `${f}.${process.pid}.tmp`;
-    writeFileSync5(tmp, JSON.stringify(c), { mode: 384 });
+    writeFileSync6(tmp, JSON.stringify(c), { mode: 384 });
     renameSync(tmp, f);
   }
   key(ref) {
@@ -3360,16 +4515,16 @@ function takeLock(root, ref, staleMs = 5 * 6e4) {
   return takeNamedLock(root, `${safeId(ref.harness)}-${safeId(ref.session)}`, staleMs);
 }
 function takeNamedLock(root, name, staleMs = 5 * 6e4) {
-  const dir = path14.join(root, "locks");
+  const dir = path16.join(root, "locks");
   mkdirSync5(dir, { recursive: true, mode: 448 });
-  const f = path14.join(dir, `${name}.lock`);
+  const f = path16.join(dir, `${name}.lock`);
   try {
-    if (Date.now() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(readFileSync8(f, "utf8")))) unlinkSync3(f);
+    if (Date.now() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(readFileSync10(f, "utf8")))) unlinkSync3(f);
     else return null;
   } catch {
   }
   try {
-    writeFileSync5(f, String(process.pid), { flag: "wx" });
+    writeFileSync6(f, String(process.pid), { flag: "wx" });
   } catch {
     return null;
   }
@@ -3391,7 +4546,7 @@ function processAlive(pid) {
 }
 
 // src/privacy/pii.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var RULESET_PII = "pii@1";
 var EMAIL = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
 var PHONE = /(?<![\w.])(?:\+\d{1,3}[ .-]?)?(?:\(\d{2,4}\)[ .-]?)?\d{2,4}(?:[ .-]?\d{2,4}){1,3}(?!\w)/g;
@@ -3413,7 +4568,7 @@ function reducePii(text, home) {
   return out;
 }
 function hashMachine(name) {
-  return createHash3("sha256").update(name).digest("hex").slice(0, 8);
+  return createHash4("sha256").update(name).digest("hex").slice(0, 8);
 }
 function reducePiiDeep(v, home) {
   if (typeof v === "string") return reducePii(v, home);
@@ -3604,6 +4759,7 @@ var TYPE_TIER = {
   "subagent.started": 1,
   "subagent.ended": 1,
   "context.compacted": 1,
+  "limits.observed": 1,
   native: 3
 };
 var DATA_ALLOW = {
@@ -3612,8 +4768,8 @@ var DATA_ALLOW = {
   "session.ended": { 0: ["reason"] },
   "session.backfill": { 0: ["started_at", "last_at", "turns"] },
   "session.forgotten": { 0: [] },
-  "turn.started": { 0: ["turn_id"], 1: ["prompt_chars"] },
-  "turn.ended": { 0: ["turn_id", "reason", "ms"], 1: ["error"] },
+  "turn.started": { 0: ["turn_id", "submitted_by", "injected"], 1: ["prompt_chars"] },
+  "turn.ended": { 0: ["turn_id", "reason", "ms", "background"], 1: ["error"] },
   "turn.transcript": { 2: ["turn", "user", "assistant", "at"] },
   "turn.progress": { 2: ["turn", "user", "assistant", "at"] },
   "tool.started": { 1: ["tool", "call_id", "turn_id", "agent_id"], 3: ["input"] },
@@ -3623,7 +4779,8 @@ var DATA_ALLOW = {
   "attention.cleared": { 0: ["attention_id", "how"] },
   "subagent.started": { 1: ["agent_id", "agent_type"] },
   "subagent.ended": { 1: ["agent_id", "agent_type"] },
-  "context.compacted": { 1: ["trigger"] }
+  "context.compacted": { 1: ["trigger"] },
+  "limits.observed": { 1: ["windows", "plan", "account_id"] }
 };
 var SESSION_ALLOW = [
   "id",
@@ -3637,7 +4794,9 @@ var SESSION_ALLOW = [
   "title_source",
   "url",
   "account_id",
-  "parent_id"
+  "attended",
+  "parent_id",
+  "launched_by"
 ];
 var MAX_SIDE = 2e4;
 var MAX_IO = 64 * 1024;
@@ -3686,7 +4845,9 @@ function filterEvent(event, tier, pii, opts = {}) {
     const s = reducePiiDeep(out.session, opts.home);
     if (typeof s.machine === "string") s.machine = hashMachine(s.machine);
     delete s.account_id;
-    out = { ...out, session: s, data: reducePiiDeep(out.data, opts.home) };
+    const d = reducePiiDeep(out.data, opts.home);
+    delete d.account_id;
+    out = { ...out, session: s, data: d };
     rulesets.push(RULESET_PII);
   }
   out.privacy = { rulesets, pii };
@@ -3694,14 +4855,14 @@ function filterEvent(event, tier, pii, opts = {}) {
 }
 
 // src/short-id.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function shortId(harness, id) {
-  return createHash4("sha256").update(`sessionpipe.session:${harness}:${id}`).digest("hex").slice(0, 8);
+  return createHash5("sha256").update(`sessionpipe.session:${harness}:${id}`).digest("hex").slice(0, 8);
 }
 
 // src/sinks/file.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import path15 from "node:path";
+import path17 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
     this.name = name;
@@ -3715,7 +4876,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path15.dirname(this.file), { recursive: true });
+      mkdirSync6(path17.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: [] };
@@ -3757,7 +4918,9 @@ export {
   DEFAULT_CONFIG,
   DEVIN_EVENTS,
   FileSink,
+  HELLO_HARNESSES_MAX,
   JOB_TIMEOUT_MS,
+  LAUNCHED_BY_ENV,
   Outbox,
   PROTOCOL_VERSION,
   REDACTED,
@@ -3765,6 +4928,7 @@ export {
   RULESET_SECRETS,
   StdoutSink,
   TYPE_TIER,
+  acp_control_exports as acpControl,
   adapterByName,
   antigravity,
   antigravityAnswer,
@@ -3774,6 +4938,7 @@ export {
   claudeCode,
   claude_code_control_exports as claudeControl,
   claudeDirs,
+  claude_code_pool_exports as claudePool,
   codex,
   codex_control_exports as codexControl,
   configFile,
@@ -3792,6 +4957,7 @@ export {
   isSecretName,
   isUlid,
   jobEnv,
+  launchedBy,
   machineName,
   makeEvent,
   notClaudeCode,
@@ -3803,6 +4969,7 @@ export {
   readConfig,
   readDevinChain,
   readGemini,
+  readHook,
   redactDeep,
   redactSecrets,
   reducePii,
@@ -3816,6 +4983,7 @@ export {
   takeNamedLock,
   tilde,
   ulid,
+  untilde,
   writeConfig
 };
 //# sourceMappingURL=index.js.map