sessionpipe-core 0.9.0 → 0.10.0

package/dist/index.js

@@ -1,10 +1,525 @@
-// sessionpipe-core 0.9.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe-core 0.10.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/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 { spawn as spawn2 } from "node:child_process";
+import os from "node:os";
+import path2 from "node:path";
+
+// src/adapters/headless.ts
+import { spawn } from "node:child_process";
+import { accessSync, constants, statSync } from "node:fs";
+import path from "node:path";
+var JOB_TIMEOUT_MS = 30 * 6e4;
+var OUT_CAP = 1024 * 1024;
+function isExe(p) {
+  try {
+    if (!statSync(p).isFile()) return false;
+    accessSync(p, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findBinary(o) {
+  if (o.override && isExe(o.override)) return o.override;
+  for (const d of String(o.env?.PATH || "").split(path.delimiter)) {
+    if (!d || !path.isAbsolute(d)) continue;
+    for (const n of o.names) if (isExe(path.join(d, n))) return path.join(d, n);
+  }
+  for (const d of o.dirs) for (const n of o.names) if (isExe(path.join(d, n))) return path.join(d, n);
+  return null;
+}
+function jobEnv(env = process.env) {
+  return { ...env, SESSIONPIPE_CONTROL_JOB: "1" };
+}
+function runHeadless(bin, args, o) {
+  return new Promise((resolve) => {
+    let out = [];
+    let outLen = 0;
+    let tooBig = false;
+    let errTail = "";
+    let timedOut = false;
+    let settled = false;
+    let child;
+    try {
+      child = spawn(bin, args, {
+        cwd: o.cwd,
+        env: o.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+        windowsHide: true
+      });
+    } catch (e) {
+      resolve({ error: e.message });
+      return;
+    }
+    const kill = (sig) => {
+      try {
+        if (process.platform !== "win32" && child.pid) process.kill(-child.pid, sig);
+        else child.kill(sig);
+      } catch {
+        try {
+          child.kill(sig);
+        } catch {
+        }
+      }
+    };
+    const keep = (line) => {
+      if (!o.keep?.(line)) return;
+      out = [Buffer.from(line)];
+      outLen = line.length;
+    };
+    let partial = "";
+    child.stdout?.on("data", (b) => {
+      if (o.onLine) {
+        const chunk = partial + b.toString("utf8");
+        const lines = chunk.split("\n");
+        partial = lines.pop();
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            o.onLine(line);
+          } catch {
+          }
+          keep(line);
+        }
+        if (partial.length > OUT_CAP) partial = "";
+        return;
+      }
+      if (tooBig) return;
+      if (outLen + b.length > OUT_CAP) {
+        tooBig = true;
+        out = [];
+        return;
+      }
+      out.push(b);
+      outLen += b.length;
+    });
+    child.stderr?.on("data", (b) => {
+      errTail = (errTail + b.toString("utf8")).slice(-4e3);
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill("SIGTERM");
+      setTimeout(() => kill("SIGKILL"), 1e4).unref();
+    }, o.timeoutMs ?? JOB_TIMEOUT_MS);
+    const result = (code, signal) => ({
+      code,
+      signal,
+      stdout: tooBig ? null : Buffer.concat(out).toString("utf8"),
+      tooBig,
+      stderr: errTail,
+      timedOut
+    });
+    const finish = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(r);
+    };
+    child.on("error", (e) => finish({ error: e.message }));
+    child.on("exit", (code, signal) => setTimeout(() => finish(result(code, signal)), 2e3).unref());
+    child.on("close", (code, signal) => {
+      if (o.onLine && partial.trim()) {
+        try {
+          o.onLine(partial);
+        } catch {
+        }
+        keep(partial);
+        partial = "";
+      }
+      finish(result(code, signal));
+    });
+  });
+}
+function stderrTail(stderr, n = 3) {
+  return String(stderr || "").trim().split("\n").slice(-n).join(" ").trim();
+}
+function deniedNote(names, count) {
+  if (!count) return "";
+  return `
+
+(Not allowed on this machine, since nobody was there to approve: ${names.join(", ") || `${count} action(s)`}.)`;
+}
+function runFailure(label, res) {
+  if (res.error) return `couldn't start ${label}: ${res.error}`;
+  if (res.timedOut) return `${label} was still working after 30 minutes, so it was stopped`;
+  return null;
+}
+
+// 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 = os.homedir(), nodeDir = path2.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: [
+      nodeDir,
+      path2.join(home, ".local", "bin"),
+      path2.join(home, ".cargo", "bin"),
+      "/opt/homebrew/bin",
+      "/usr/local/bin"
+    ]
+  });
+  return bin ? { bin, args: a.args } : null;
+}
+function acpHarnesses(env = process.env) {
+  return ACP_HARNESSES.filter((h) => findAcpAgent(h, env));
+}
+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;
+  }
+  return null;
+}
+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;
+}
+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}` });
+  }
+  const kill = (sig) => {
+    try {
+      if (process.platform !== "win32" && child.pid) process.kill(-child.pid, sig);
+      else child.kill(sig);
+    } catch {
+    }
+  };
+  let gone = null;
+  let errTail = "";
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const write = (m) => {
+    if (gone) return;
+    try {
+      child.stdin?.write(`${JSON.stringify(m)}
+`);
+    } catch {
+    }
+  };
+  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()}
+
+`;
+    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" } }
+    });
+  };
+  const onLine = (line) => {
+    let m;
+    try {
+      m = obj(JSON.parse(line));
+    } catch {
+      return;
+    }
+    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 (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}` };
+    }
+  })();
+}
+
 // src/adapters/antigravity.ts
 import {
   existsSync as existsSync2,
@@ -12,38 +527,42 @@ import {
   readdirSync as readdirSync2,
   readFileSync as readFileSync2,
   realpathSync,
-  statSync as statSync2,
+  statSync as statSync3,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import path4 from "node:path";
+import path6 from "node:path";
 
 // src/paths.ts
-import os from "node:os";
-import path from "node:path";
-var homeDir = () => os.homedir();
+import os2 from "node:os";
+import path3 from "node:path";
+var homeDir = () => os2.homedir();
 function configFile(env = process.env) {
-  if (env.SESSIONPIPE_CONFIG) return path.resolve(env.SESSIONPIPE_CONFIG);
+  if (env.SESSIONPIPE_CONFIG) return path3.resolve(env.SESSIONPIPE_CONFIG);
   if (process.platform === "win32")
-    return path.join(env.APPDATA || path.join(homeDir(), "AppData", "Roaming"), "sessionpipe", "config.json");
-  return path.join(env.XDG_CONFIG_HOME || path.join(homeDir(), ".config"), "sessionpipe", "config.json");
+    return path3.join(env.APPDATA || path3.join(homeDir(), "AppData", "Roaming"), "sessionpipe", "config.json");
+  return path3.join(env.XDG_CONFIG_HOME || path3.join(homeDir(), ".config"), "sessionpipe", "config.json");
 }
 function stateDir(env = process.env) {
-  if (env.SESSIONPIPE_STATE) return path.resolve(env.SESSIONPIPE_STATE);
+  if (env.SESSIONPIPE_STATE) return path3.resolve(env.SESSIONPIPE_STATE);
   if (process.platform === "win32")
-    return path.join(env.LOCALAPPDATA || path.join(homeDir(), "AppData", "Local"), "sessionpipe");
-  return path.join(env.XDG_STATE_HOME || path.join(homeDir(), ".local", "state"), "sessionpipe");
+    return path3.join(env.LOCALAPPDATA || path3.join(homeDir(), "AppData", "Local"), "sessionpipe");
+  return path3.join(env.XDG_STATE_HOME || path3.join(homeDir(), ".local", "state"), "sessionpipe");
 }
 function tilde(p, home = homeDir()) {
   if (!p) return p;
   if (p === home) return "~";
-  return p.startsWith(home + path.sep) || p.startsWith(`${home}/`) ? `~${p.slice(home.length)}` : p;
+  return p.startsWith(home + path3.sep) || p.startsWith(`${home}/`) ? `~${p.slice(home.length)}` : p;
+}
+function untilde(p, home = homeDir()) {
+  if (p === "~") return home;
+  return /^~[\\/]/.test(p) ? path3.join(home, p.slice(2)) : p;
 }
 var safeId = (s) => String(s).replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 160);
 
 // src/readers/files.ts
-import { closeSync, fstatSync, openSync, readdirSync, readSync, statSync } from "node:fs";
-import path2 from "node:path";
+import { closeSync, fstatSync, openSync, readdirSync, readSync, statSync as statSync2 } from "node:fs";
+import path4 from "node:path";
 function ends(file, headBytes, tailBytes) {
   let fd;
   try {
@@ -115,14 +634,14 @@ function recentFiles(root, depth, sinceMs, match) {
       return;
     }
     for (const e of names) {
-      const p = path2.join(dir, e.name);
+      const p = path4.join(dir, e.name);
       if (e.isDirectory()) {
         if (d < depth) walk(p, d + 1);
         continue;
       }
       if (!match(e.name)) continue;
       try {
-        if (statSync(p).mtimeMs >= sinceMs) out.push(p);
+        if (statSync2(p).mtimeMs >= sinceMs) out.push(p);
       } catch {
       }
     }
@@ -282,7 +801,7 @@ function readAntigravity(lines, from) {
 
 // src/adapters/claude-shaped.ts
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import path3 from "node:path";
+import path5 from "node:path";
 var OURS = /(?:sessionpipe[^"\n]*[\\/]hook\.js|[\\/]sessionpipe-hook)"?\s+[a-z][a-z-]*\s+[A-Za-z]+\s*$/;
 var isOurs = (h) => Array.isArray(h?.hooks) && h.hooks.some((x) => typeof x.command === "string" && OURS.test(x.command));
 function readJsonFile(file) {
@@ -363,7 +882,7 @@ function installClaudeShaped(file, harness, events, cmd, o) {
   }
   if (changed) {
     settings2.hooks = hooks;
-    mkdirSync(path3.dirname(file), { recursive: true });
+    mkdirSync(path5.dirname(file), { recursive: true });
     writeFileSync(file, formatJson(settings2, f));
   }
   return { file, changed, created: !f.existed && changed };
@@ -418,10 +937,10 @@ 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 gemini = (env) => env.GEMINI_CLI_HOME || path6.join(homeDir(), ".gemini");
+var hooksFile = (env) => path6.join(gemini(env), "config", "hooks.json");
+var projectsDir = (env) => path6.join(gemini(env), "config", "projects");
+var dataDirs = (env) => ["antigravity", "antigravity-cli", "antigravity-ide"].map((d) => path6.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) {
@@ -433,7 +952,7 @@ function entry(cmd) {
 var antigravity = {
   name: NAME,
   events: AG_EVENTS,
-  detect: (env = process.env) => existsSync2(path4.join(gemini(env), "config")) || dataDirs(env).some((d) => existsSync2(d)),
+  detect: (env = process.env) => existsSync2(path6.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);
@@ -443,7 +962,7 @@ var antigravity = {
     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 });
+    mkdirSync2(path6.dirname(file), { recursive: true });
     writeFileSync2(file, formatJson(hooks, f));
     return [
       {
@@ -554,13 +1073,13 @@ var antigravity = {
     for (const data of dataDirs(env)) {
       let ids = [];
       try {
-        ids = readdirSync2(path4.join(data, "brain")).filter((n) => /^[0-9a-f-]{36}$/i.test(n));
+        ids = readdirSync2(path6.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");
+        const f = path6.join(data, "brain", id, ".system_generated", "logs", "transcript.jsonl");
         try {
-          if (statSync2(f).mtimeMs < sinceMs) continue;
+          if (statSync3(f).mtimeMs < sinceMs) continue;
         } catch {
           continue;
         }
@@ -588,8 +1107,8 @@ function agPath(p) {
     }
     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);
+  if (!path6.isAbsolute(s)) return null;
+  return path6.resolve(s);
 }
 var agWorkspaces = (paths) => (Array.isArray(paths) ? paths : []).map(agPath).filter((p) => !!p).filter((p, i, a) => a.indexOf(p) === i);
 function agVariants(p) {
@@ -614,7 +1133,7 @@ function agProjects(dir) {
     if (!ID_RE.test(id)) continue;
     let j;
     try {
-      j = JSON.parse(readFileSync2(path4.join(dir, n), "utf8"));
+      j = JSON.parse(readFileSync2(path6.join(dir, n), "utf8"));
     } catch {
       continue;
     }
@@ -637,7 +1156,7 @@ function agMatchProject(projects, workspaces) {
   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));
+      const within = ws.some((w) => w === f || w.startsWith(f.endsWith(path6.sep) ? f : f + path6.sep));
       if (within && f.length > bestLen) {
         best = pr.id;
         bestLen = f.length;
@@ -646,12 +1165,12 @@ function agMatchProject(projects, workspaces) {
   return best;
 }
 function antigravityRemoteUrl(transcript, opts) {
-  const i = transcript.indexOf(`${path4.sep}brain${path4.sep}`);
+  const i = transcript.indexOf(`${path6.sep}brain${path6.sep}`);
   const dirs = (i > 0 ? [transcript.slice(0, i)] : []).concat(dataDirs(opts.env));
   for (const d of dirs) {
     try {
       const m = /installation_uuid:\s*"([0-9a-f-]{36})"/i.exec(
-        readFileSync2(path4.join(d, "antigravity_state.pbtxt"), "utf8")
+        readFileSync2(path6.join(d, "antigravity_state.pbtxt"), "utf8")
       );
       if (!m) continue;
       const base = `https://antigravity.google.com/r/${m[1]}-v2`;
@@ -698,167 +1217,28 @@ __export(antigravity_control_exports, {
   agyError: () => agyError,
   agyLine: () => agyLine,
   agyModeFlags: () => agyModeFlags,
+  defaultLevel: () => defaultLevel,
   findAgy: () => findAgy,
+  offeredLevels: () => offeredLevels,
   reading: () => reading
 });
-import os2 from "node:os";
-import path6 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";
-var JOB_TIMEOUT_MS = 30 * 6e4;
-var OUT_CAP = 1024 * 1024;
-function isExe(p) {
-  try {
-    if (!statSync3(p).isFile()) return false;
-    accessSync(p, constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-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 o.dirs) for (const n of o.names) if (isExe(path5.join(d, n))) return path5.join(d, n);
-  return null;
-}
-function jobEnv(env = process.env) {
-  return { ...env, SESSIONPIPE_CONTROL_JOB: "1" };
-}
-function runHeadless(bin, args, o) {
-  return new Promise((resolve) => {
-    let out = [];
-    let outLen = 0;
-    let tooBig = false;
-    let errTail = "";
-    let timedOut = false;
-    let settled = false;
-    let child;
-    try {
-      child = spawn(bin, args, {
-        cwd: o.cwd,
-        env: o.env,
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: process.platform !== "win32",
-        windowsHide: true
-      });
-    } catch (e) {
-      resolve({ error: e.message });
-      return;
-    }
-    const kill = (sig) => {
-      try {
-        if (process.platform !== "win32" && child.pid) process.kill(-child.pid, sig);
-        else child.kill(sig);
-      } catch {
-        try {
-          child.kill(sig);
-        } catch {
-        }
-      }
-    };
-    const keep = (line) => {
-      if (!o.keep?.(line)) return;
-      out = [Buffer.from(line)];
-      outLen = line.length;
-    };
-    let partial = "";
-    child.stdout?.on("data", (b) => {
-      if (o.onLine) {
-        const chunk = partial + b.toString("utf8");
-        const lines = chunk.split("\n");
-        partial = lines.pop();
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            o.onLine(line);
-          } catch {
-          }
-          keep(line);
-        }
-        if (partial.length > OUT_CAP) partial = "";
-        return;
-      }
-      if (tooBig) return;
-      if (outLen + b.length > OUT_CAP) {
-        tooBig = true;
-        out = [];
-        return;
-      }
-      out.push(b);
-      outLen += b.length;
-    });
-    child.stderr?.on("data", (b) => {
-      errTail = (errTail + b.toString("utf8")).slice(-4e3);
-    });
-    const timer = setTimeout(() => {
-      timedOut = true;
-      kill("SIGTERM");
-      setTimeout(() => kill("SIGKILL"), 1e4).unref();
-    }, o.timeoutMs ?? JOB_TIMEOUT_MS);
-    const result = (code, signal) => ({
-      code,
-      signal,
-      stdout: tooBig ? null : Buffer.concat(out).toString("utf8"),
-      tooBig,
-      stderr: errTail,
-      timedOut
-    });
-    const finish = (r) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(r);
-    };
-    child.on("error", (e) => finish({ error: e.message }));
-    child.on("exit", (code, signal) => setTimeout(() => finish(result(code, signal)), 2e3).unref());
-    child.on("close", (code, signal) => {
-      if (o.onLine && partial.trim()) {
-        try {
-          o.onLine(partial);
-        } catch {
-        }
-        keep(partial);
-        partial = "";
-      }
-      finish(result(code, signal));
-    });
-  });
-}
-function stderrTail(stderr, n = 3) {
-  return String(stderr || "").trim().split("\n").slice(-n).join(" ").trim();
-}
-function deniedNote(names, count) {
-  if (!count) return "";
-  return `
-
-(Not allowed on this machine, since nobody was there to approve: ${names.join(", ") || `${count} action(s)`}.)`;
-}
-function runFailure(label, res) {
-  if (res.error) return `couldn't start ${label}: ${res.error}`;
-  if (res.timedOut) return `${label} was still working after 30 minutes, so it was stopped`;
-  return null;
-}
-
-// src/adapters/antigravity-control.ts
+import os3 from "node:os";
+import path7 from "node:path";
 var LABEL = "Antigravity";
-function findAgy(env = process.env, home = os2.homedir()) {
+function findAgy(env = process.env, home = os3.homedir()) {
   return findBinary({
     override: env.SESSIONPIPE_AGY,
     names: process.platform === "win32" ? ["agy.exe", "agy.cmd"] : ["agy"],
     env,
-    dirs: [path6.join(home, ".local", "bin"), "/opt/homebrew/bin", "/usr/local/bin"]
+    dirs: [path7.join(home, ".local", "bin"), "/opt/homebrew/bin", "/usr/local/bin"]
   });
 }
-function agyModeFlags(mode) {
-  return mode === "auto" ? ["--mode", "accept-edits"] : [];
+function agyModeFlags(level) {
+  if (level === "read") throw new Error("Antigravity has no read-only mode");
+  return level === "safe" || level === "inherit" ? [] : ["--mode", "accept-edits"];
 }
+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 [
@@ -867,7 +1247,7 @@ function agyArgs(o) {
     prompt,
     "--output-format",
     "stream-json",
-    ...agyModeFlags(o.mode)
+    ...agyModeFlags(o.permission)
   ];
 }
 var agyEnv = (env = process.env) => jobEnv(env);
@@ -879,26 +1259,26 @@ function agyLine(line) {
     return null;
   }
   if (!j || typeof j !== "object") return null;
-  const str = (v) => typeof v === "string" ? v : "";
+  const str2 = (v) => typeof v === "string" ? v : "";
   const out = {};
   if (j.event === "init") {
-    if (str(j.conversation_id)) out.session = str(j.conversation_id);
+    if (str2(j.conversation_id)) out.session = str2(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 (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 = str(s.text_delta) || str(s.error) || str(s.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 (str(r.conversation_id)) out.session = str(r.conversation_id);
+    if (str2(r.conversation_id)) out.session = str2(r.conversation_id);
     out.result = {
-      status: str(r.status),
-      response: str(r.response),
-      error: str(r.error),
+      status: str2(r.status),
+      response: str2(r.response),
+      error: str2(r.error),
       denied: Array.isArray(r.denied_actions) ? r.denied_actions : []
     };
   } else return null;
@@ -970,7 +1350,7 @@ var reading = () => new AgyReading();
 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";
+import path8 from "node:path";
 
 // src/readers/git.ts
 import { execFileSync } from "node:child_process";
@@ -1036,23 +1416,23 @@ function claudeDirs(env = process.env, home = env.HOME || homeDir()) {
   const out = [];
   const add = (d) => {
     if (!d) return;
-    const r = path7.resolve(d);
+    const r = path8.resolve(d);
     if (!out.includes(r)) out.push(r);
   };
-  add(path7.join(home, ".claude"));
+  add(path8.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 d = path8.join(home, e.name);
+      if (existsSync3(path8.join(d, "projects")) || existsSync3(path8.join(d, "settings.json"))) add(d);
     }
   } catch {
   }
   return out.filter((d, i) => i === 0 || existsSync3(d));
 }
-var settingsIn = (dir) => path7.join(dir, "settings.json");
-var configDirOf = (transcript) => path7.dirname(path7.dirname(path7.dirname(transcript)));
+var settingsIn = (dir) => path8.join(dir, "settings.json");
+var configDirOf = (transcript) => path8.dirname(path8.dirname(path8.dirname(transcript)));
 var validTool2 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
 var endReason = (r) => r === "clear" || r === "logout" || r === "exit" ? r : r === "prompt_input_exit" ? "exit" : "other";
 var notifKind = (t) => t === "permission_prompt" ? "permission" : t === "idle_prompt" ? "idle" : t === "elicitation_dialog" ? "elicitation" : "question";
@@ -1096,14 +1476,28 @@ var claudeCode = {
       case "SessionStart":
         events.push(ev("session.started", { source: pickSource(s.source ?? s.trigger) }));
         break;
-      case "UserPromptSubmit":
+      case "UserPromptSubmit": {
+        const prompt = typeof s.prompt === "string" ? s.prompt : void 0;
         events.push(
           ev("turn.started", {
             turn_id,
-            prompt_chars: typeof s.prompt === "string" ? [...s.prompt].length : void 0
+            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, call_id, turn_id, agent_id, input: s.tool_input }));
         break;
@@ -1158,7 +1552,13 @@ var claudeCode = {
         );
         break;
       case "Stop":
-        events.push(ev("turn.ended", { turn_id, reason: "stop" }));
+        events.push(
+          ev("turn.ended", {
+            turn_id,
+            reason: "stop",
+            background: Array.isArray(s.background_tasks) ? s.background_tasks.length : void 0
+          })
+        );
         break;
       case "StopFailure":
         events.push(
@@ -1201,6 +1601,8 @@ var claudeCode = {
     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;
@@ -1221,17 +1623,18 @@ var claudeCode = {
     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;
   },
   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)));
+      files.push(...recentFiles(path8.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 id = path8.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;
@@ -1256,6 +1659,9 @@ function notClaudeCode(id, s) {
 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") {
@@ -1295,12 +1701,12 @@ function claudeLive(dir) {
   const map = /* @__PURE__ */ new Map();
   let names = [];
   try {
-    names = readdirSync3(path7.join(dir, "sessions")).filter((n) => n.endsWith(".json"));
+    names = readdirSync3(path8.join(dir, "sessions")).filter((n) => n.endsWith(".json"));
   } catch {
   }
   for (const n of names) {
     try {
-      const e = registryEntry(JSON.parse(readFileSync3(path7.join(dir, "sessions", n), "utf8")));
+      const e = registryEntry(JSON.parse(readFileSync3(path8.join(dir, "sessions", n), "utf8")));
       if (e?.sessionId) map.set(e.sessionId, e);
     } catch {
     }
@@ -1311,7 +1717,7 @@ function claudeLive(dir) {
 function claudeLiveByPid(dir, pid) {
   if (!pid) return null;
   try {
-    return registryEntry(JSON.parse(readFileSync3(path7.join(dir, "sessions", `${pid}.json`), "utf8")));
+    return registryEntry(JSON.parse(readFileSync3(path8.join(dir, "sessions", `${pid}.json`), "utf8")));
   } catch {
     return null;
   }
@@ -1319,7 +1725,7 @@ function claudeLiveByPid(dir, pid) {
 function claudePid(env = process.env) {
   try {
     const dirs = claudeDirs(env);
-    const has = (pid2) => dirs.some((d) => existsSync3(path7.join(d, "sessions", `${pid2}.json`)));
+    const has = (pid2) => dirs.some((d) => existsSync3(path8.join(d, "sessions", `${pid2}.json`)));
     let pid = process.ppid;
     if (has(pid)) return pid;
     const parent = parentOf();
@@ -1360,8 +1766,8 @@ function parentOf() {
 }
 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"));
+  const files = [path8.join(dir, ".claude.json")];
+  if (path8.resolve(dir) === path8.join(home, ".claude")) files.unshift(path8.join(home, ".claude.json"));
   for (const f of files) {
     try {
       const a = JSON.parse(readFileSync3(f, "utf8")).oauthAccount;
@@ -1372,7 +1778,27 @@ function claudeLogin(dir, home = homeDir()) {
     } catch {
     }
   }
-  return null;
+  return apiAccount(dir);
+}
+var ANTHROPIC_HOST = /(^|\.)anthropic\.com$/i;
+function apiAccount(dir) {
+  let base;
+  try {
+    base = JSON.parse(readFileSync3(settingsIn(dir), "utf8")).env?.ANTHROPIC_BASE_URL;
+  } catch {
+    return null;
+  }
+  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) {
@@ -1463,7 +1889,7 @@ function claudeFacts(file, sessionId, hints, state) {
   const H = parseLines(head);
   const T = parseLines(tail);
   const out = {};
-  const id = sessionId || path7.basename(file, ".jsonl");
+  const id = sessionId || path8.basename(file, ".jsonl");
   const mem = state.get(NAME2, id);
   let custom = null;
   let ai = null;
@@ -1547,9 +1973,12 @@ function claudeFacts(file, sessionId, hints, state) {
 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 +1987,8 @@ __export(claude_code_control_exports, {
   loginCommand: () => loginCommand,
   loginHint: () => loginHint,
   modeFlags: () => modeFlags,
+  offeredLevels: () => offeredLevels2,
+  outputArgs: () => outputArgs,
   parseAuthStatus: () => parseAuthStatus,
   parseCaps: () => parseCaps,
   parseResult: () => parseResult,
@@ -1567,8 +1998,22 @@ __export(claude_code_control_exports, {
 });
 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";
+import os4 from "node:os";
+import path9 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 enc = new TextEncoder();
+var dec = new TextDecoder();
+
+// src/adapters/claude-code-control.ts
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var LIVE_WRITE_MS = 9e4;
 var cmpVersion = (a, b) => {
@@ -1578,28 +2023,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 = os4.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(path9.delimiter)) {
+    if (!d || !path9.isAbsolute(d)) continue;
+    for (const n of names) if (isExe(path9.join(d, n))) return path9.join(d, n);
   }
   for (const p of [
-    path8.join(home, ".claude", "local", "claude"),
-    path8.join(home, ".local", "bin", "claude"),
+    path9.join(home, ".claude", "local", "claude"),
+    path9.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 = path9.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 = path9.join(app, v, "claude.app", "Contents", "MacOS", "claude");
     if (isExe(p)) return p;
   }
   return null;
@@ -1625,11 +2070,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 +2094,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 +2133,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 (path9.resolve(configDir) === path9.resolve(os4.homedir(), ".claude")) delete e.CLAUDE_CONFIG_DIR;
     else e.CLAUDE_CONFIG_DIR = configDir;
   }
   return e;
@@ -1687,12 +2166,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 = os4.homedir();
+  const isDefault = !configDir || path9.resolve(configDir) === path9.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(os4.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.`;
@@ -1718,13 +2197,13 @@ function findTranscript(session, dirs) {
   for (const dir of dirs) {
     let projects = [];
     try {
-      projects = readdirSync4(path8.join(dir, "projects"), { withFileTypes: true });
+      projects = readdirSync4(path9.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 = path9.join(dir, "projects", p.name, `${session}.jsonl`);
       try {
         if (statSync5(file).isFile()) return { file, configDir: dir, project: p.name };
       } catch {
@@ -1746,7 +2225,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" || !path9.isAbsolute(j.cwd)) return null;
     if (projectName(j.cwd) === t.project) return j.cwd;
     first ??= j.cwd;
     count++;
@@ -1807,13 +2286,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(path9.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(readFileSync4(path9.join(configDir, "sessions", n), "utf8"));
       if (String(j.sessionId) !== session) continue;
       if (pidAlive(Number(j.pid ?? n.slice(0, -5)))) return true;
     } catch {
@@ -1862,7 +2341,7 @@ var isUuid = (s) => typeof s === "string" && UUID_RE.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 path10 from "node:path";
 
 // src/adapters/codex-config.ts
 var NOTIFY_LINE = /^[ \t]*notify[ \t]*=[ \t]*(\[.*\])[ \t]*(?:#.*)?$/m;
@@ -2007,10 +2486,10 @@ 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 || path10.join(homeDir(), ".codex");
+var hooksFile2 = (env) => path10.join(codexHome(env), "hooks.json");
+var configFile2 = (env) => path10.join(codexHome(env), "config.toml");
+var sessionsDir = (env) => path10.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) {
@@ -2024,7 +2503,7 @@ function installNotify(cmd, env) {
   const line = `notify = ${JSON.stringify(argv)}`;
   const n = readNotify(text);
   const write = (next) => {
-    mkdirSync3(path9.dirname(file), { recursive: true });
+    mkdirSync3(path10.dirname(file), { recursive: true });
     writeFileSync3(file, next);
   };
   if (n && !n.other) {
@@ -2091,7 +2570,7 @@ function findRollout(threadId, env = process.env) {
       return;
     }
     for (const n of names.sort().reverse()) {
-      const p = path9.join(dir, n);
+      const p = path10.join(dir, n);
       if (n.endsWith(`-${threadId}.jsonl`)) {
         best = p;
         return;
@@ -2181,7 +2660,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 };
@@ -2276,7 +2755,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(path10.basename(f));
       if (!m?.[1]) continue;
       if (codexSubagent(rolloutMeta(f))) continue;
       const facts = codexFacts(f);
@@ -2343,38 +2822,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 readFileSync6 } from "node:fs";
+import os5 from "node:os";
+import path11 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 = os5.homedir(), nodeDir = path11.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, path11.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 = os5.homedir()) {
+  try {
+    const file = path11.join(env.CODEX_HOME || path11.join(home, ".codex"), "models_cache.json");
+    const j = JSON.parse(readFileSync6(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 +2913,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;
   }
@@ -2469,7 +2981,7 @@ var reading2 = () => new CodexReading();
 // src/adapters/devin.ts
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync6, readlinkSync } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 
 // src/readers/sqlite.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
@@ -2653,11 +3165,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 || path12.join(homeOf(env), "AppData", "Roaming");
+var devinConfigDir = (env = process.env) => process.platform === "win32" ? path12.join(appData(env), "devin") : path12.join(env.XDG_CONFIG_HOME || path12.join(homeOf(env), ".config"), "devin");
+var configFile3 = (env) => path12.join(devinConfigDir(env), "config.json");
+var devinDataDir = (env = process.env) => process.platform === "win32" ? path12.join(appData(env), "devin", "cli") : path12.join(env.XDG_DATA_HOME || path12.join(homeOf(env), ".local", "share"), "devin", "cli");
+var sessionsDb = (env) => path12.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";
@@ -2829,7 +3341,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" && path12.isAbsolute(row.working_directory))
     out.cwd = row.working_directory;
   const started = Number(row.created_at);
   const last = Number(row.last_activity_at);
@@ -2874,8 +3386,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(path12.join(devinDataDir(env), "_versions", "current"));
+    const name = path12.basename(target);
     return /^[0-9][0-9A-Za-z.+-]{0,63}$/.test(name) ? name : void 0;
   } catch {
     return void 0;
@@ -2889,8 +3401,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 readFileSync7 } from "node:fs";
+import path13 from "node:path";
 var NAME5 = "gemini-cli";
 var GEMINI_EVENTS = [
   "SessionStart",
@@ -2903,14 +3415,14 @@ 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 || path13.join(homeDir(), ".gemini");
+var settings = (env) => path13.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 geminiHooksActive(settingsFile) {
   let tools;
   try {
-    tools = JSON.parse(readFileSync6(settingsFile, "utf8")).tools;
+    tools = JSON.parse(readFileSync7(settingsFile, "utf8")).tools;
   } catch {
   }
   if (tools?.enableHooks === true) return { active: true };
@@ -2940,7 +3452,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(path13.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 +3550,7 @@ var geminiCli = {
   readTranscript(file, fromLine) {
     let text = "";
     try {
-      text = readFileSync6(file, "utf8");
+      text = readFileSync7(file, "utf8");
     } catch {
       return { turns: [], line: fromLine };
     }
@@ -3076,21 +3588,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 readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
+import path14 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(readFileSync8(file, "utf8"));
     return {
       ...DEFAULT_CONFIG,
       ...j,
@@ -3102,7 +3616,7 @@ function readConfig(file = configFile()) {
   }
 }
 function writeConfig(c, file = configFile()) {
-  mkdirSync4(path13.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync4(path14.dirname(file), { recursive: true, mode: 448 });
   writeFileSync4(file, `${JSON.stringify(c, null, 2)}
 `, { mode: 384 });
   if (process.platform !== "win32" && existsSync8(file)) {
@@ -3167,6 +3681,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 +3705,14 @@ import {
   mkdirSync as mkdirSync5,
   openSync as openSync3,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   readSync as readSync3,
   renameSync,
   statSync as statSync6,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 var READ_CHUNK = 1024 * 1024;
 var READ_MAX = 8 * 1024 * 1024;
 var Outbox = class {
@@ -3191,13 +3721,13 @@ var Outbox = class {
   }
   root;
   dir(harness) {
-    return path14.join(this.root, "outbox", safeId(harness));
+    return path15.join(this.root, "outbox", safeId(harness));
   }
   file(ref) {
-    return path14.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
+    return path15.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
   }
   seqFile(ref) {
-    return path14.join(this.dir(ref.harness), `${safeId(ref.session)}.seq`);
+    return path15.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 +3735,19 @@ var Outbox = class {
     const f = this.seqFile(ref);
     let n = -1;
     try {
-      const t = readFileSync8(f, "utf8").trim();
+      const t = readFileSync9(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 });
+    mkdirSync5(path15.dirname(f), { recursive: true, mode: 448 });
     writeFileSync5(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 = readFileSync9(f, "utf8").trim().split("\n");
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
         const j = JSON.parse(lines[i]);
@@ -3236,10 +3766,10 @@ var Outbox = class {
   /** Every session file, newest first. */
   sessions() {
     const out = [];
-    const base = path14.join(this.root, "outbox");
+    const base = path15.join(this.root, "outbox");
     if (!existsSync9(base)) return [];
     for (const h of readdirSync6(base)) {
-      const d = path14.join(base, h);
+      const d = path15.join(base, h);
       let names = [];
       try {
         names = readdirSync6(d).filter((n) => n.endsWith(".jsonl"));
@@ -3248,7 +3778,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(path15.join(d, n)).mtimeMs });
         } catch {
         }
       }
@@ -3336,18 +3866,18 @@ var Cursors = class {
   root;
   sink;
   file() {
-    return path14.join(this.root, "cursors", `${safeId(this.sink)}.json`);
+    return path15.join(this.root, "cursors", `${safeId(this.sink)}.json`);
   }
   read() {
     try {
-      return JSON.parse(readFileSync8(this.file(), "utf8"));
+      return JSON.parse(readFileSync9(this.file(), "utf8"));
     } catch {
       return {};
     }
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path14.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync5(path15.dirname(f), { recursive: true, mode: 448 });
     const tmp = `${f}.${process.pid}.tmp`;
     writeFileSync5(tmp, JSON.stringify(c), { mode: 384 });
     renameSync(tmp, f);
@@ -3360,11 +3890,11 @@ 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 = path15.join(root, "locks");
   mkdirSync5(dir, { recursive: true, mode: 448 });
-  const f = path14.join(dir, `${name}.lock`);
+  const f = path15.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(readFileSync9(f, "utf8")))) unlinkSync3(f);
     else return null;
   } catch {
   }
@@ -3612,8 +4142,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"] },
@@ -3637,7 +4167,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;
@@ -3701,7 +4233,7 @@ function shortId(harness, id) {
 
 // src/sinks/file.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
     this.name = name;
@@ -3715,7 +4247,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path15.dirname(this.file), { recursive: true });
+      mkdirSync6(path16.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 +4289,9 @@ export {
   DEFAULT_CONFIG,
   DEVIN_EVENTS,
   FileSink,
+  HELLO_HARNESSES_MAX,
   JOB_TIMEOUT_MS,
+  LAUNCHED_BY_ENV,
   Outbox,
   PROTOCOL_VERSION,
   REDACTED,
@@ -3765,6 +4299,7 @@ export {
   RULESET_SECRETS,
   StdoutSink,
   TYPE_TIER,
+  acp_control_exports as acpControl,
   adapterByName,
   antigravity,
   antigravityAnswer,
@@ -3792,6 +4327,7 @@ export {
   isSecretName,
   isUlid,
   jobEnv,
+  launchedBy,
   machineName,
   makeEvent,
   notClaudeCode,
@@ -3803,6 +4339,7 @@ export {
   readConfig,
   readDevinChain,
   readGemini,
+  readHook,
   redactDeep,
   redactSecrets,
   reducePii,
@@ -3816,6 +4353,7 @@ export {
   takeNamedLock,
   tilde,
   ulid,
+  untilde,
   writeConfig
 };
 //# sourceMappingURL=index.js.map