sessionpipe 0.11.0 → 0.13.0

package/dist/worker.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
-// sessionpipe 0.11.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe 0.13.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/worker.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { realpathSync as realpathSync2 } from "node:fs";
 import { pathToFileURL } from "node:url";
 
@@ -184,7 +189,14 @@ ${m.text}`;
         continue;
       }
       if (cur) turns.push(cur);
-      cur = { user: m.text, assistant: "", at: m.at, startLine: m.line, endLine: m.line };
+      cur = {
+        user: m.text,
+        assistant: "",
+        at: m.at,
+        startLine: m.line,
+        endLine: m.line,
+        ...m.injected ? { injected: true } : {}
+      };
     } else {
       if (!cur) cur = { user: "", assistant: "", at: m.at, startLine: m.line, endLine: m.line };
       cur.assistant += (cur.assistant ? "\n\n" : "") + m.text;
@@ -194,10 +206,17 @@ ${m.text}`;
   if (cur?.assistant) turns.push(cur);
   const line = cur && !cur.assistant ? cur.startLine : endLine;
   const out = {
-    turns: turns.map((t) => ({ user: t.user, assistant: t.assistant, at: t.at, endLine: t.endLine })),
+    turns: turns.map((t) => ({
+      user: t.user,
+      assistant: t.assistant,
+      at: t.at,
+      endLine: t.endLine,
+      ...t.injected ? { injected: true } : {}
+    })),
     line
   };
-  if (cur && !cur.assistant && cur.user) out.open = { user: cur.user, at: cur.at };
+  if (cur && !cur.assistant && cur.user)
+    out.open = { user: cur.user, at: cur.at, ...cur.injected ? { injected: true } : {} };
   return out;
 }
 var isInjected = (text) => /^<[a-z_-]+(?:\s[^>]*)?>/i.test(text) && /<\/[a-z_-]+>\s*$/i.test(text) || /^<!--\s/.test(text) || /^<command-/.test(text);
@@ -220,27 +239,51 @@ var textParts = (c, kinds) => {
     (b) => b && typeof b === "object" && kinds.includes(b.type ?? "") && typeof b.text === "string"
   ).map((b) => b.text).join("\n");
 };
+var SPOKEN = /* @__PURE__ */ new Set(["human", "peer"]);
+var PEER_INTRO = /sent a message[^\n]*:$/;
+var PEER_OUTRO = "\n\nThis came from another ";
+var ENVELOPE = /^<cross-session-message\b[^>]*>\n([\s\S]*)\n<\/cross-session-message>$/;
+function peerAsk(origin, text) {
+  const body = origin?.body;
+  let t = typeof body === "string" && body.trim() ? body : text;
+  if (t !== body) {
+    const nl = t.indexOf("\n");
+    if (nl > 0 && PEER_INTRO.test(t.slice(0, nl))) t = t.slice(nl + 1);
+    const outro = t.indexOf(PEER_OUTRO);
+    if (outro > 0) t = t.slice(0, outro);
+  }
+  return (ENVELOPE.exec(t.trim())?.[1] ?? t).trim();
+}
 var queuedPrompt = (a) => {
   if (!a || typeof a !== "object") return "";
   const q = a;
   if (q.type !== "queued_command" || (q.commandMode ?? "prompt") !== "prompt") return "";
-  if (q.origin?.kind && q.origin.kind !== "human") return "";
-  return textParts(q.prompt, ["text"]).trim();
+  const kind = q.origin?.kind ?? "human";
+  if (!SPOKEN.has(kind)) return "";
+  const text = textParts(q.prompt, ["text"]).trim();
+  return kind === "peer" ? peerAsk(q.origin, text) : text;
 };
+var channelText = (text) => /^<channel\b[^>]*>([\s\S]*)<\/channel>$/.exec(text)?.[1]?.trim() ?? "";
 function readClaude(lines, from) {
   const msgs = [];
   for (let i = from; i < lines.length; i++) {
     const j = lines[i] ? parse(lines[i]) : null;
     if (!j || j.isSidechain) continue;
     const origin = j.origin;
-    if (j.type === "user" && (j.isMeta || j.isCompactSummary || j.repeatsCompactSummary || origin?.kind && origin.kind !== "human"))
-      continue;
+    const channel = j.type === "user" && origin?.kind === "channel";
+    const peer = origin?.kind === "peer";
+    if (j.type === "user" && (j.isCompactSummary || j.repeatsCompactSummary)) continue;
+    if (j.type === "user" && !channel && !peer && (j.isMeta || origin?.kind && origin.kind !== "human")) continue;
     const at = Date.parse(String(j.timestamp ?? "")) || Date.now();
     const c = j.message?.content;
-    if (j.type === "user") {
-      const text = textParts(c, ["text"]).trim();
+    if (channel) {
+      const text = channelText(textParts(c, ["text"]).trim());
+      if (text) msgs.push({ role: "user", text, at, line: i, injected: true });
+    } else if (j.type === "user") {
+      const raw = textParts(c, ["text"]).trim();
+      const text = peer ? peerAsk(origin, raw) : raw;
       if (!text || isInjected(text)) continue;
-      msgs.push({ role: "user", text, at, line: i });
+      msgs.push({ role: "user", text, at, line: i, ...peer ? { injected: true } : {} });
     } else if (j.type === "assistant" && Array.isArray(c)) {
       const text = textParts(c, ["text"]).trim();
       if (text) msgs.push({ role: "assistant", text, at, line: i });
@@ -618,13 +661,7 @@ var claudeCode = {
         );
         break;
       case "Stop":
-        events.push(
-          ev("turn.ended", {
-            turn_id,
-            reason: "stop",
-            background: Array.isArray(s.background_tasks) ? s.background_tasks.length : void 0
-          })
-        );
+        events.push(ev("turn.ended", { turn_id, reason: "stop", background: backgroundCount(s.background_tasks) }));
         break;
       case "StopFailure":
         events.push(
@@ -647,7 +684,8 @@ var claudeCode = {
         events.push(
           ev("subagent.ended", {
             agent_id: String(s.agent_id ?? ""),
-            agent_type: typeof s.agent_type === "string" ? s.agent_type : void 0
+            agent_type: typeof s.agent_type === "string" ? s.agent_type : void 0,
+            background: backgroundCount(s.background_tasks, String(s.agent_id ?? ""))
           })
         );
         break;
@@ -722,6 +760,15 @@ var claudeCode = {
     return rows2;
   }
 };
+var WAITER_RE = /(?:^|[\s"'`/\\])sessionpipe(?:\.\w+)?["']?\s+wait(?:\s|$)/;
+function backgroundCount(tasks, ending) {
+  if (!Array.isArray(tasks)) return void 0;
+  return tasks.filter((t) => {
+    const task = t;
+    if (ending !== void 0 && task?.id === ending) return false;
+    return !(typeof task?.command === "string" && WAITER_RE.test(task.command));
+  }).length;
+}
 var LINE_REFRESH_S = 60;
 function statusLine(file, want, cmd) {
   const f = readJsonFile(file);
@@ -1150,8 +1197,44 @@ async function claudeAiTitle(bridge, token) {
 }
 
 // ../core/src/adapters/headless.ts
-import { accessSync, constants, statSync as statSync3 } from "node:fs";
+import { spawn } from "node:child_process";
+import { accessSync, constants, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
 import path5 from "node:path";
+
+// ../core/src/launched-by.ts
+var LAUNCHED_BY_ENV = "SESSIONPIPE_LAUNCHED_BY";
+var DELEGATED_BY_ENV = "SESSIONPIPE_ASKED_BY";
+var ASK_CHAIN_ENV = "SESSIONPIPE_ASK_CHAIN";
+var LINEAGE_ENV = [LAUNCHED_BY_ENV, DELEGATED_BY_ENV, ASK_CHAIN_ENV];
+var SESSION_REF = /^[a-z][a-z0-9-]{0,39}:[A-Za-z0-9._:-]{1,128}$/;
+function withoutLineage(env) {
+  const e = { ...env };
+  for (const k of LINEAGE_ENV) delete e[k];
+  return e;
+}
+function refIn(env, name) {
+  const v = env[name]?.trim();
+  return v && SESSION_REF.test(v) ? v : void 0;
+}
+function launchedBy(env) {
+  return refIn(env, LAUNCHED_BY_ENV);
+}
+function delegatedBy(env) {
+  return refIn(env, DELEGATED_BY_ENV);
+}
+function readHook(adapter, input) {
+  const r = adapter.fromHook(input);
+  if (r && !r.session.parent_id) {
+    const self = `${adapter.name}:${r.session.id}`;
+    const launcher = launchedBy(input.env);
+    if (launcher && launcher !== self) r.session.launched_by = launcher;
+    const asker = delegatedBy(input.env);
+    if (asker && asker !== self) r.session.delegated_by = asker;
+  }
+  return r;
+}
+
+// ../core/src/adapters/headless.ts
 var JOB_TIMEOUT_MS = 30 * 6e4;
 var OUT_CAP = 1024 * 1024;
 function isExe(p) {
@@ -1172,13 +1255,144 @@ function findBinary(o) {
   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 shimTarget(shim) {
+  let text = "";
+  try {
+    text = readFileSync3(shim, "utf8");
+  } catch {
+    return null;
+  }
+  const m = /"%(?:~dp0|dp0%)\\([^"]+)"\s+%\*/.exec(text);
+  if (!m) return null;
+  const target = path5.resolve(path5.dirname(shim), m[1].split("\\").join(path5.sep));
+  try {
+    return statSync3(target).isFile() ? target : null;
+  } catch {
+    return null;
+  }
+}
+function spawnable(bin, args) {
+  if (!/\.(cmd|bat)$/i.test(bin)) return { file: bin, args };
+  const target = shimTarget(bin);
+  return target ? { file: process.execPath, args: [target, ...args] } : null;
+}
+var shimNote = (bin) => `${path5.basename(bin)} is a launcher script that names no program to run; point the harness's override (SESSIONPIPE_CLAUDE, SESSIONPIPE_CODEX, \u2026) at the program itself`;
+function probe(bin, args) {
+  const s = spawnable(bin, args);
+  return s ? { ...s, shell: false } : { file: [`"${bin}"`, ...args].join(" "), args: [], shell: true };
+}
+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;
+    const c = spawnable(bin, args);
+    if (!c) {
+      resolve({ error: shimNote(bin) });
+      return;
+    }
+    try {
+      child = spawn(c.file, c.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));
+    });
+  });
+}
 
 // ../core/src/adapters/antigravity.ts
 import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync2,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   realpathSync,
   statSync as statSync4,
   unlinkSync as unlinkSync2,
@@ -1307,7 +1521,7 @@ var antigravity = {
   readTranscript(file, fromLine) {
     let text = "";
     try {
-      text = readFileSync3(file, "utf8");
+      text = readFileSync4(file, "utf8");
     } catch {
       return { turns: [], line: fromLine };
     }
@@ -1386,7 +1600,7 @@ function agProjects(dir) {
     if (!ID_RE.test(id)) continue;
     let j;
     try {
-      j = JSON.parse(readFileSync3(path6.join(dir, n), "utf8"));
+      j = JSON.parse(readFileSync4(path6.join(dir, n), "utf8"));
     } catch {
       continue;
     }
@@ -1423,7 +1637,7 @@ function antigravityRemoteUrl(transcript, opts) {
   for (const d of dirs) {
     try {
       const m = /installation_uuid:\s*"([0-9a-f-]{36})"/i.exec(
-        readFileSync3(path6.join(d, "antigravity_state.pbtxt"), "utf8")
+        readFileSync4(path6.join(d, "antigravity_state.pbtxt"), "utf8")
       );
       if (!m) continue;
       const base = `https://antigravity.google.com/r/${m[1]}-v2`;
@@ -1461,6 +1675,50 @@ function antigravityFacts(file, opts) {
   return out;
 }
 
+// ../core/src/adapters/claude-code-control.ts
+var claude_code_control_exports = {};
+__export(claude_code_control_exports, {
+  CLAUDE_MODES: () => CLAUDE_MODES,
+  JOB_TIMEOUT_MS: () => JOB_TIMEOUT_MS,
+  MODE_RANK: () => MODE_RANK,
+  NO_HOME_SETTINGS: () => NO_HOME_SETTINGS,
+  ceilingLevel: () => ceilingLevel,
+  claudeArgs: () => claudeArgs,
+  claudeEnv: () => claudeEnv,
+  claudeLogin: () => claudeLogin2,
+  cmpVersion: () => cmpVersion,
+  defaultLevel: () => defaultLevel,
+  detectCaps: () => detectCaps,
+  findClaude: () => findClaude,
+  findTranscript: () => findTranscript,
+  findTranscripts: () => findTranscripts,
+  homeSettings: () => homeSettings,
+  hookMode: () => hookMode,
+  isUuid: () => isUuid,
+  liveProcess: () => liveProcess,
+  liveRecord: () => liveRecord,
+  liveRecords: () => liveRecords,
+  loginCommand: () => loginCommand,
+  loginHint: () => loginHint,
+  modeFlags: () => modeFlags,
+  modeRank: () => modeRank,
+  offeredLevels: () => offeredLevels,
+  outputArgs: () => outputArgs,
+  parseAuthStatus: () => parseAuthStatus,
+  parseCaps: () => parseCaps,
+  parseResult: () => parseResult,
+  peerClass: () => peerClass,
+  recentlyWritten: () => recentlyWritten,
+  relaunchMode: () => relaunchMode,
+  resolveHome: () => resolveHome,
+  runClaude: () => runClaude,
+  sessionFolder: () => sessionFolder
+});
+import { execFile, execFileSync as execFileSync3 } from "node:child_process";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync5, readSync as readSync2, statSync as statSync5 } from "node:fs";
+import os2 from "node:os";
+import path7 from "node:path";
+
 // ../core/src/control/verify.ts
 var GRANT_MAX_MS = 24 * 36e5;
 var SKEW_MS = 5 * 6e4;
@@ -1471,10 +1729,10 @@ 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"],
+  prompt: ["text", "files", "reply_to"],
   "permission.answer": ["for", "decision"],
   cancel: [],
-  start: ["text", "cwd", "files", "permission", "model"],
+  start: ["text", "cwd", "files", "permission", "model", "reply_to"],
   "key.add": ["key", "name"],
   pool: ["pool_action", "pool_account", "pool_order", "pool_code"]
 };
@@ -1482,9 +1740,454 @@ var POOL_FIELDS = FIELDS.pool;
 var enc = new TextEncoder();
 var dec = new TextDecoder();
 
+// ../core/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) => {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++)
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
+  return 0;
+};
+function findClaude(env = process.env, home = os2.homedir()) {
+  if (env.SESSIONPIPE_CLAUDE && isExe(env.SESSIONPIPE_CLAUDE)) return env.SESSIONPIPE_CLAUDE;
+  const names = process.platform === "win32" ? ["claude.exe", "claude.cmd"] : ["claude"];
+  for (const d of String(env.PATH || "").split(path7.delimiter)) {
+    if (!d || !path7.isAbsolute(d)) continue;
+    for (const n of names) if (isExe(path7.join(d, n))) return path7.join(d, n);
+  }
+  for (const p of [
+    path7.join(home, ".claude", "local", "claude"),
+    path7.join(home, ".local", "bin", "claude"),
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude"
+  ])
+    if (isExe(p)) return p;
+  const app = path7.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 = path7.join(app, v, "claude.app", "Contents", "MacOS", "claude");
+    if (isExe(p)) return p;
+  }
+  return null;
+}
+function optionBlock(help, flag) {
+  const lines = help.split("\n");
+  const re = new RegExp(`^\\s{0,4}(?:-\\w, )?${flag.replace(/-/g, "\\-")}(?![\\w-])`);
+  const start = lines.findIndex((l) => re.test(l));
+  if (start < 0) return null;
+  const out = [lines[start]];
+  for (let i = start + 1; i < lines.length && lines[i]?.trim() && !/^\s{0,4}-/.test(lines[i]); i++)
+    out.push(lines[i]);
+  return out.join(" ");
+}
+function parseCaps(help) {
+  const pm = optionBlock(help, "--permission-mode");
+  const pp = optionBlock(help, "--permission-prompts");
+  return {
+    hasMode: !!pm,
+    modes: pm ? [...pm.matchAll(/"([A-Za-z]+)"/g)].map((m) => m[1]) : [],
+    promptsNone: !!pp && /"none"/.test(pp),
+    fork: !!optionBlock(help, "--fork-session"),
+    stream: !!optionBlock(help, "--include-partial-messages")
+  };
+}
+var LEVEL_MODE = {
+  read: "plan",
+  edits: "acceptEdits",
+  auto: "auto"
+};
+function modeFlags(level, caps) {
+  if (level === "inherit") return { args: [] };
+  if (caps.unread)
+    return { error: `this machine couldn't read its Claude Code's options (${caps.unread}); try again in a minute` };
+  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 = [];
+  if (caps.hasMode)
+    args.push(
+      "--permission-mode",
+      caps.modes.includes("manual") && !caps.modes.includes("default") ? "manual" : "default"
+    );
+  if (caps.promptsNone) args.push("--permission-prompts", "none");
+  return { args };
+}
+var ceilingLevel = (mode) => mode === "inherit" ? "safe" : mode;
+function offeredLevels(mode, caps) {
+  if (caps.unread) return [];
+  return START_PERMISSIONS.filter(
+    (l) => levelRank(l) <= levelRank(ceilingLevel(mode)) && (l === "safe" || caps.modes.includes(LEVEL_MODE[l]))
+  );
+}
+var defaultLevel = (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 = withoutLineage(env);
+  for (const k of [
+    "CLAUDECODE",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_HOST_SESSION_ID",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_SESSION_ATTENDED",
+    "CLAUDE_CODE_SSE_PORT"
+  ])
+    delete e[k];
+  e.SESSIONPIPE_CONTROL_JOB = "1";
+  if (configDir !== void 0) {
+    if (path7.resolve(configDir) === path7.resolve(os2.homedir(), ".claude")) delete e.CLAUDE_CONFIG_DIR;
+    else e.CLAUDE_CONFIG_DIR = configDir;
+  }
+  return e;
+}
+function parseAuthStatus(stdout) {
+  const text = String(stdout || "").trim();
+  const start = text.indexOf("{");
+  if (start < 0) return { loggedIn: null };
+  try {
+    const j = JSON.parse(text.slice(start));
+    if (typeof j.loggedIn !== "boolean") return { loggedIn: null };
+    return {
+      loggedIn: j.loggedIn,
+      ...typeof j.authMethod === "string" ? { method: j.authMethod } : {},
+      ...typeof j.subscriptionType === "string" ? { subscription: j.subscriptionType } : {}
+    };
+  } catch {
+    return { loggedIn: null };
+  }
+}
+function claudeLogin2(bin, configDir, env = process.env) {
+  const c = probe(bin, ["auth", "status", "--json"]);
+  return new Promise((resolve) => {
+    execFile(
+      c.file,
+      c.args,
+      { encoding: "utf8", timeout: 2e4, env: claudeEnv(configDir, env), maxBuffer: 256 * 1024, shell: c.shell },
+      // `auth status` may exit non-zero when signed out; its JSON still says so.
+      (_err, stdout) => resolve(parseAuthStatus(stdout))
+    );
+  });
+}
+function loginCommand(configDir) {
+  const home = os2.homedir();
+  const isDefault = !configDir || path7.resolve(configDir) === path7.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(os2.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.`;
+  return `Claude Code (${shown}) isn't signed in on this machine: run ${login} there.`;
+}
+function detectCaps(bin, timeoutMs = 3e4) {
+  const c = probe(bin, ["--help"]);
+  try {
+    return parseCaps(
+      execFileSync3(c.file, c.args, {
+        encoding: "utf8",
+        timeout: timeoutMs,
+        env: claudeEnv(),
+        stdio: ["ignore", "pipe", "pipe"],
+        maxBuffer: 4 * 1024 * 1024,
+        shell: c.shell
+      })
+    );
+  } catch (e) {
+    const err = e;
+    const caps = parseCaps(String(err?.stdout || ""));
+    if (caps.hasMode) return caps;
+    const why = err?.code === "ETIMEDOUT" ? `timed out after ${timeoutMs / 1e3} s` : "failed";
+    return { ...caps, unread: `\`${path7.basename(bin)} --help\` ${why}` };
+  }
+}
+function transcriptIn(session, dir) {
+  let projects = [];
+  try {
+    projects = readdirSync4(path7.join(dir, "projects"), { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const p of projects) {
+    if (!p.isDirectory()) continue;
+    const file = path7.join(dir, "projects", p.name, `${session}.jsonl`);
+    try {
+      if (statSync5(file).isFile()) return { file, configDir: dir, project: p.name };
+    } catch {
+    }
+  }
+  return null;
+}
+function findTranscript(session, dirs) {
+  if (!UUID_RE.test(session)) return null;
+  for (const dir of dirs) {
+    const t = transcriptIn(session, dir);
+    if (t) return t;
+  }
+  return null;
+}
+function findTranscripts(session, dirs) {
+  if (!UUID_RE.test(session)) return [];
+  const out = [];
+  for (const dir of dirs) {
+    const t = transcriptIn(session, dir);
+    if (t) out.push(t);
+  }
+  return out;
+}
+var homeName = (t) => path7.basename(t.configDir);
+function resolveHome(session, dirs) {
+  const all = findTranscripts(session, dirs);
+  if (!all.length) return null;
+  if (all.length === 1) return { transcript: all[0] };
+  const live = all.filter((t) => liveRecords(session, t.configDir).length > 0);
+  if (live.length === 1) return { transcript: live[0] };
+  return {
+    ambiguous: [...new Set(all.map(homeName))].sort(),
+    live: [...new Set(live.map(homeName))].sort()
+  };
+}
+var projectName = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, "-");
+function sessionFolder(t, cap2 = 8 * 1024 * 1024) {
+  let first = null;
+  let count = 0;
+  let fd;
+  const look = (line) => {
+    if (line.indexOf('"cwd"') < 0) return null;
+    let j;
+    try {
+      j = JSON.parse(line.toString("utf8"));
+    } catch {
+      return null;
+    }
+    if (!j || typeof j.cwd !== "string" || !path7.isAbsolute(j.cwd)) return null;
+    if (projectName(j.cwd) === t.project) return j.cwd;
+    first ??= j.cwd;
+    count++;
+    return null;
+  };
+  try {
+    fd = openSync2(t.file, "r");
+    const buf = Buffer.alloc(256 * 1024);
+    let pos = 0;
+    let rest = Buffer.alloc(0);
+    let skipping = false;
+    while (pos < cap2 && count < 50) {
+      const n = readSync2(fd, buf, 0, buf.length, pos);
+      if (!n) {
+        if (!skipping && rest.length) {
+          const hit = look(rest);
+          if (hit) return hit;
+        }
+        break;
+      }
+      pos += n;
+      let chunk = rest.length ? Buffer.concat([rest, buf.subarray(0, n)]) : buf.subarray(0, n);
+      let nl = chunk.indexOf(10);
+      while (nl >= 0) {
+        const line = chunk.subarray(0, nl);
+        chunk = chunk.subarray(nl + 1);
+        if (skipping) skipping = false;
+        else {
+          const hit = look(line);
+          if (hit) return hit;
+        }
+        nl = chunk.indexOf(10);
+      }
+      if (chunk.length > 2 * 1024 * 1024) {
+        skipping = true;
+        rest = Buffer.alloc(0);
+      } else rest = skipping ? Buffer.alloc(0) : Buffer.from(chunk);
+    }
+  } catch {
+  } finally {
+    if (fd !== void 0)
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+  }
+  return first;
+}
+function pidAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+var registryRow = (file, configDir, j) => {
+  const pid = Number(j.pid ?? path7.basename(file).slice(0, -5));
+  const str = (v) => typeof v === "string" && v ? v : null;
+  let keyFile = null;
+  try {
+    const want = new RegExp(`^${pid}\\.[0-9a-f]{64}\\.key$`);
+    const hit = readdirSync4(path7.dirname(file)).find((n) => want.test(n));
+    if (hit) keyFile = path7.join(path7.dirname(file), hit);
+  } catch {
+  }
+  return {
+    configDir,
+    file,
+    pid,
+    socket: str(j.messagingSocketPath),
+    peerProtocol: typeof j.peerProtocol === "number" ? j.peerProtocol : null,
+    procStart: str(j.procStart),
+    status: str(j.status),
+    kind: str(j.kind),
+    entrypoint: str(j.entrypoint),
+    keyFile
+  };
+};
+function liveRecords(session, dirs) {
+  const out = [];
+  for (const dir of typeof dirs === "string" ? [dirs] : dirs) {
+    let names = [];
+    try {
+      names = readdirSync4(path7.join(dir, "sessions")).filter((n) => /^\d+\.json$/.test(n));
+    } catch {
+      continue;
+    }
+    for (const n of names) {
+      const file = path7.join(dir, "sessions", n);
+      let j;
+      try {
+        j = JSON.parse(readFileSync5(file, "utf8"));
+      } catch {
+        continue;
+      }
+      if (String(j.sessionId) !== session) continue;
+      const row = registryRow(file, dir, j);
+      if (pidAlive(row.pid)) out.push(row);
+    }
+  }
+  return out;
+}
+function liveRecord(session, dirs) {
+  const all = liveRecords(session, dirs);
+  return all.length === 1 ? all[0] : null;
+}
+function liveProcess(session, configDir) {
+  return liveRecords(session, configDir).length > 0;
+}
+var MODE_RANK = {
+  plan: 0,
+  default: 1,
+  manual: 1,
+  dontAsk: 1,
+  acceptEdits: 2,
+  auto: 3,
+  bypassPermissions: 4
+};
+var CLAUDE_MODES = Object.keys(MODE_RANK);
+var modeRank = (m) => m && m in MODE_RANK ? MODE_RANK[m] : -1;
+function hookMode(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  const v = typeof p.permission_mode === "string" ? p.permission_mode : p.permissionMode;
+  return typeof v === "string" && CLAUDE_MODES.includes(v) ? v : null;
+}
+function peerClass(mode) {
+  if (mode === "bypassPermissions") return "bypass";
+  if (mode === "default" || mode === "manual" || mode === "dontAsk" || mode === "acceptEdits") return "prompting";
+  return null;
+}
+var NO_HOME_SETTINGS = { defaultMode: null, disableAutoMode: false, disableBypass: false };
+function homeSettings(configDir, home = os2.homedir()) {
+  const file = path7.join(configDir ?? path7.join(home, ".claude"), "settings.json");
+  let j;
+  try {
+    j = JSON.parse(readFileSync5(file, "utf8"));
+  } catch {
+    return { ...NO_HOME_SETTINGS };
+  }
+  if (!j || typeof j !== "object" || Array.isArray(j)) return { ...NO_HOME_SETTINGS };
+  const p = j.permissions && typeof j.permissions === "object" ? j.permissions : {};
+  const off = (k) => j[k] === "disable" || p[k] === "disable";
+  return {
+    defaultMode: typeof p.defaultMode === "string" && CLAUDE_MODES.includes(p.defaultMode) ? p.defaultMode : null,
+    disableAutoMode: off("disableAutoMode"),
+    disableBypass: off("disableBypassPermissionsMode")
+  };
+}
+function relaunchMode(recorded, home) {
+  if (recorded === "plan") return recorded;
+  if ((recorded === "dontAsk" || recorded === "acceptEdits") && modeRank(home.defaultMode) >= modeRank(recorded))
+    return recorded;
+  return null;
+}
+function recentlyWritten(file, ourLastEnd, now = Date.now()) {
+  let m;
+  try {
+    m = statSync5(file).mtimeMs;
+  } catch {
+    return false;
+  }
+  if (now - m > LIVE_WRITE_MS) return false;
+  return !(ourLastEnd && m <= ourLastEnd + 2e3);
+}
+function runClaude(bin, args, o) {
+  return runHeadless(bin, args, { ...o, keep: o.keep ?? ((line) => line.includes('"type":"result"')) });
+}
+function parseResult(stdout) {
+  const s = String(stdout || "").trim();
+  if (!s) return null;
+  const pick = (j) => {
+    if (Array.isArray(j)) {
+      for (let i = j.length - 1; i >= 0; i--) if (j[i]?.type === "result") return j[i];
+      return null;
+    }
+    return j && typeof j === "object" ? j : null;
+  };
+  try {
+    return pick(JSON.parse(s));
+  } catch {
+  }
+  const lines = s.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const j = pick(JSON.parse(lines[i]));
+      if (j && (j.type === "result" || "result" in j)) return j;
+    } catch {
+    }
+  }
+  return null;
+}
+var isUuid = (s) => typeof s === "string" && UUID_RE.test(s);
+
 // ../core/src/adapters/codex.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import path8 from "node:path";
 
 // ../core/src/adapters/codex-config.ts
 var NOTIFY_LINE = /^[ \t]*notify[ \t]*=[ \t]*(\[.*\])[ \t]*(?:#.*)?(?=\r?$)/m;
@@ -1630,24 +2333,24 @@ 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 || path7.join(homeDir(), ".codex");
-var hooksFile2 = (env) => path7.join(codexHome(env), "hooks.json");
-var configFile2 = (env) => path7.join(codexHome(env), "config.toml");
-var sessionsDir = (env) => path7.join(codexHome(env), "sessions");
+var codexHome = (env) => env.CODEX_HOME || path8.join(homeDir(), ".codex");
+var hooksFile2 = (env) => path8.join(codexHome(env), "hooks.json");
+var configFile2 = (env) => path8.join(codexHome(env), "config.toml");
+var sessionsDir = (env) => path8.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 = readFileSync4(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(path7.dirname(file), { recursive: true });
+    mkdirSync3(path8.dirname(file), { recursive: true });
     writeFileSync4(file, next);
   };
   if (n && !n.other) {
@@ -1686,7 +2389,7 @@ function uninstallNotify(env) {
   const file = configFile2(env);
   let text;
   try {
-    text = readFileSync4(file, "utf8");
+    text = readFileSync6(file, "utf8");
   } catch {
     return { file, changed: false };
   }
@@ -1709,12 +2412,12 @@ function findRollout(threadId, env = process.env) {
   const walk = (dir, depth) => {
     let names = [];
     try {
-      names = readdirSync4(dir);
+      names = readdirSync5(dir);
     } catch {
       return;
     }
     for (const n of names.sort().reverse()) {
-      const p = path7.join(dir, n);
+      const p = path8.join(dir, n);
       if (n.endsWith(`-${threadId}.jsonl`)) {
         best = p;
         return;
@@ -1758,7 +2461,7 @@ var codex = {
     ];
     let text = "";
     try {
-      text = readFileSync4(configFile2(env), "utf8");
+      text = readFileSync6(configFile2(env), "utf8");
     } catch {
     }
     const n = readNotify(text);
@@ -1885,7 +2588,7 @@ var codex = {
   readTranscript(file, fromLine) {
     let text = "";
     try {
-      text = readFileSync4(file, "utf8");
+      text = readFileSync6(file, "utf8");
     } catch {
       return { turns: [], line: fromLine };
     }
@@ -1899,7 +2602,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(path7.basename(f));
+      const m = /([0-9a-f]{8}-[0-9a-f-]{27,})\.jsonl$/i.exec(path8.basename(f));
       if (!m?.[1]) continue;
       if (codexSubagent(rolloutMeta(f))) continue;
       const facts = codexFacts(f);
@@ -1986,10 +2689,10 @@ function codexFacts(file) {
 // ../core/src/adapters/devin.ts
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync6, readlinkSync } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 
 // ../core/src/readers/sqlite.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
 import { createRequire } from "node:module";
 function quiet(fn) {
@@ -2069,7 +2772,7 @@ db.close();
 process.stdout.write(JSON.stringify(out));`;
 function viaChild(file, sql, params, o) {
   try {
-    const out = execFileSync3(
+    const out = execFileSync4(
       process.execPath,
       ["--experimental-sqlite", "--no-warnings", "-e", CHILD, file, sql, JSON.stringify(params), String(o.timeoutMs)],
       {
@@ -2113,7 +2816,7 @@ function viaCli(file, sql, params, o) {
   const text = inlineParams(sql, params);
   if (!text) return null;
   try {
-    const out = execFileSync3("sqlite3", ["-readonly", "-json", file, text], {
+    const out = execFileSync4("sqlite3", ["-readonly", "-json", file, text], {
       encoding: "utf8",
       timeout: o.timeoutMs + 3e3,
       stdio: ["ignore", "pipe", "ignore"],
@@ -2170,11 +2873,11 @@ function foreignEvent(file) {
   return Object.keys(hooks).find((k) => !ok.includes(k));
 }
 var homeOf = (env) => env.HOME || homeDir();
-var appData = (env) => env.APPDATA || path8.join(homeOf(env), "AppData", "Roaming");
-var devinConfigDir = (env = process.env) => process.platform === "win32" ? path8.join(appData(env), "devin") : path8.join(env.XDG_CONFIG_HOME || path8.join(homeOf(env), ".config"), "devin");
-var configFile3 = (env) => path8.join(devinConfigDir(env), "config.json");
-var devinDataDir = (env = process.env) => process.platform === "win32" ? path8.join(appData(env), "devin", "cli") : path8.join(env.XDG_DATA_HOME || path8.join(homeOf(env), ".local", "share"), "devin", "cli");
-var sessionsDb = (env) => path8.join(devinDataDir(env), "sessions.db");
+var appData = (env) => env.APPDATA || path9.join(homeOf(env), "AppData", "Roaming");
+var devinConfigDir = (env = process.env) => process.platform === "win32" ? path9.join(appData(env), "devin") : path9.join(env.XDG_CONFIG_HOME || path9.join(homeOf(env), ".config"), "devin");
+var configFile3 = (env) => path9.join(devinConfigDir(env), "config.json");
+var devinDataDir = (env = process.env) => process.platform === "win32" ? path9.join(appData(env), "devin", "cli") : path9.join(env.XDG_DATA_HOME || path9.join(homeOf(env), ".local", "share"), "devin", "cli");
+var sessionsDb = (env) => path9.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";
@@ -2346,7 +3049,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" && path8.isAbsolute(row.working_directory))
+  if (typeof row.working_directory === "string" && path9.isAbsolute(row.working_directory))
     out.cwd = row.working_directory;
   const started = Number(row.created_at);
   const last = Number(row.last_activity_at);
@@ -2391,8 +3094,8 @@ function readDevinChain(db, session, fromLine) {
 }
 function devinVersion(env = process.env) {
   try {
-    const target = readlinkSync(path8.join(devinDataDir(env), "_versions", "current"));
-    const name = path8.basename(target);
+    const target = readlinkSync(path9.join(devinDataDir(env), "_versions", "current"));
+    const name = path9.basename(target);
     return /^[0-9][0-9A-Za-z.+-]{0,63}$/.test(name) ? name : void 0;
   } catch {
     return void 0;
@@ -2405,9 +3108,9 @@ function devinAccount(env = process.env) {
 }
 
 // ../core/src/adapters/gemini-cli.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
-import path9 from "node:path";
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+import path10 from "node:path";
 var NAME5 = "gemini-cli";
 var GEMINI_EVENTS = [
   "SessionStart",
@@ -2420,22 +3123,22 @@ var GEMINI_EVENTS = [
   "SessionEnd"
 ];
 var OPTS4 = { matcherFor: (e) => /Tool/.test(e) ? ".*" : void 0, timeout: 5e3 };
-var geminiDir = (env) => env.GEMINI_CLI_HOME || path9.join(homeDir(), ".gemini");
-var settings = (env) => path9.join(geminiDir(env), "settings.json");
+var geminiDir = (env) => env.GEMINI_CLI_HOME || path10.join(homeDir(), ".gemini");
+var settings = (env) => path10.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: [path9.dirname(process.execPath)], env }) : "gemini";
+  const bin = win ? findBinary({ names: ["gemini.exe", "gemini.cmd"], dirs: [path10.dirname(process.execPath)], env }) : "gemini";
   if (!bin) throw new Error("no gemini on PATH");
-  const o = {
+  const c = probe(bin, ["--version"]);
+  return execFileSync5(c.file, c.args, {
     encoding: "utf8",
     timeout: 4e3,
     stdio: ["ignore", "pipe", "ignore"],
-    env
-  };
-  const out = /\.cmd$/i.test(bin) ? execFileSync4(`"${bin}" --version`, { ...o, shell: true }) : execFileSync4(bin, ["--version"], o);
-  return out.trim();
+    env,
+    shell: c.shell
+  }).trim();
 }
 function geminiHooksActive(settingsFile) {
   const tools = readJson(settingsFile).tools;
@@ -2462,7 +3165,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(path9.join(geminiDir(env), "tmp")),
+  detect: (env = process.env) => existsSync7(settings(env)) || existsSync7(path10.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);
@@ -2560,7 +3263,7 @@ var geminiCli = {
   readTranscript(file, fromLine) {
     let text = "";
     try {
-      text = readFileSync5(file, "utf8");
+      text = readFileSync7(file, "utf8");
     } catch {
       return { turns: [], line: fromLine };
     }
@@ -2600,12 +3303,12 @@ var ADAPTERS = [claudeCode, codex, geminiCli, antigravity, devin];
 var adapterByName = (name) => ADAPTERS.find((a) => a.name === name);
 
 // ../core/src/config.ts
-import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import path10 from "node:path";
+import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import path11 from "node:path";
 var DEFAULT_CONFIG = { sinks: [], harnesses: {}, update_check: true, keep_days: 30 };
 function readConfig(file = configFile()) {
   try {
-    const j = JSON.parse(readFileSync6(file, "utf8"));
+    const j = JSON.parse(readFileSync8(file, "utf8"));
     return {
       ...DEFAULT_CONFIG,
       ...j,
@@ -2617,7 +3320,7 @@ function readConfig(file = configFile()) {
   }
 }
 function writeConfig(c, file = configFile()) {
-  mkdirSync4(path10.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync4(path11.dirname(file), { recursive: true, mode: 448 });
   writeFileSync5(file, `${JSON.stringify(c, null, 2)}
 `, { mode: 384 });
   if (process.platform !== "win32" && existsSync8(file)) {
@@ -2681,38 +3384,22 @@ function makeEvent(a, ctx) {
   };
 }
 
-// ../core/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;
-}
-
 // ../core/src/outbox.ts
 import {
   appendFileSync,
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   existsSync as existsSync9,
   mkdirSync as mkdirSync5,
-  openSync as openSync2,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync7,
-  readSync as readSync2,
+  openSync as openSync3,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync9,
+  readSync as readSync3,
   renameSync,
-  statSync as statSync5,
+  statSync as statSync6,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 var READ_CHUNK = 1024 * 1024;
 var READ_MAX = 8 * 1024 * 1024;
 var Outbox = class {
@@ -2721,13 +3408,13 @@ var Outbox = class {
   }
   root;
   dir(harness) {
-    return path11.join(this.root, "outbox", safeId(harness));
+    return path12.join(this.root, "outbox", safeId(harness));
   }
   file(ref) {
-    return path11.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
+    return path12.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
   }
   seqFile(ref) {
-    return path11.join(this.dir(ref.harness), `${safeId(ref.session)}.seq`);
+    return path12.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). */
@@ -2735,19 +3422,19 @@ var Outbox = class {
     const f = this.seqFile(ref);
     let n = -1;
     try {
-      const t = readFileSync7(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(path11.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync5(path12.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 = readFileSync7(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]);
@@ -2766,19 +3453,19 @@ var Outbox = class {
   /** Every session file, newest first. */
   sessions() {
     const out = [];
-    const base = path11.join(this.root, "outbox");
+    const base = path12.join(this.root, "outbox");
     if (!existsSync9(base)) return [];
-    for (const h of readdirSync5(base)) {
-      const d = path11.join(base, h);
+    for (const h of readdirSync6(base)) {
+      const d = path12.join(base, h);
       let names = [];
       try {
-        names = readdirSync5(d).filter((n) => n.endsWith(".jsonl"));
+        names = readdirSync6(d).filter((n) => n.endsWith(".jsonl"));
       } catch {
         continue;
       }
       for (const n of names) {
         try {
-          out.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync5(path11.join(d, n)).mtimeMs });
+          out.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync6(path12.join(d, n)).mtimeMs });
         } catch {
         }
       }
@@ -2794,16 +3481,16 @@ var Outbox = class {
   read(ref, from, maxEvents = 500) {
     const f = this.file(ref);
     if (!existsSync9(f)) return { events: [], offset: from };
-    const size = statSync5(f).size;
+    const size = statSync6(f).size;
     if (from >= size) return { events: [], offset: from };
-    const fd = openSync2(f, "r");
+    const fd = openSync3(f, "r");
     try {
       const events = [];
       let offset = from;
       let chunk = READ_CHUNK;
       while (events.length < maxEvents && offset < size) {
         const buf = Buffer.alloc(Math.min(size - offset, chunk));
-        const n = readSync2(fd, buf, 0, buf.length, offset);
+        const n = readSync3(fd, buf, 0, buf.length, offset);
         const text = buf.subarray(0, n).toString("utf8");
         let pos = 0;
         let used = 0;
@@ -2826,7 +3513,7 @@ var Outbox = class {
       }
       return { events, offset };
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
   }
   /** Files older than `days` are pruned; the cursor files with them. */
@@ -2836,7 +3523,7 @@ var Outbox = class {
     for (const ref of this.sessions()) {
       const f = this.file(ref);
       try {
-        if (statSync5(f).mtimeMs < cutoff) {
+        if (statSync6(f).mtimeMs < cutoff) {
           unlinkSync3(f);
           try {
             unlinkSync3(this.seqFile(ref));
@@ -2866,18 +3553,18 @@ var Cursors = class {
   root;
   sink;
   file() {
-    return path11.join(this.root, "cursors", `${safeId(this.sink)}.json`);
+    return path12.join(this.root, "cursors", `${safeId(this.sink)}.json`);
   }
   read() {
     try {
-      return JSON.parse(readFileSync7(this.file(), "utf8"));
+      return JSON.parse(readFileSync9(this.file(), "utf8"));
     } catch {
       return {};
     }
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path11.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync5(path12.dirname(f), { recursive: true, mode: 448 });
     const tmp = `${f}.${process.pid}.tmp`;
     writeFileSync6(tmp, JSON.stringify(c), { mode: 384 });
     renameSync(tmp, f);
@@ -2890,11 +3577,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 = path11.join(root, "locks");
+  const dir = path12.join(root, "locks");
   mkdirSync5(dir, { recursive: true, mode: 448 });
-  const f = path11.join(dir, `${name}.lock`);
+  const f = path12.join(dir, `${name}.lock`);
   try {
-    if (Date.now() - statSync5(f).mtimeMs > staleMs || !processAlive(Number(readFileSync7(f, "utf8")))) unlinkSync3(f);
+    if (Date.now() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(readFileSync9(f, "utf8")))) unlinkSync3(f);
     else return null;
   } catch {
   }
@@ -3132,6 +3819,8 @@ var TYPE_TIER = {
   "subagent.ended": 1,
   "context.compacted": 1,
   "limits.observed": 1,
+  "delegation.started": 0,
+  "delegation.ended": 0,
   native: 3
 };
 var DATA_ALLOW = {
@@ -3142,8 +3831,8 @@ var DATA_ALLOW = {
   "session.forgotten": { 0: [] },
   "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"] },
+  "turn.transcript": { 2: ["turn", "user", "assistant", "at", "injected"] },
+  "turn.progress": { 2: ["turn", "user", "assistant", "at", "injected"] },
   "tool.started": { 1: ["tool", "call_id", "turn_id", "agent_id"], 3: ["input"] },
   "tool.ended": { 1: ["tool", "call_id", "turn_id", "agent_id", "ms", "ok", "error"], 3: ["input", "output"] },
   "files.changed": { 1: ["paths"] },
@@ -3152,7 +3841,9 @@ var DATA_ALLOW = {
   "subagent.started": { 1: ["agent_id", "agent_type"] },
   "subagent.ended": { 1: ["agent_id", "agent_type"] },
   "context.compacted": { 1: ["trigger"] },
-  "limits.observed": { 1: ["windows", "plan", "account_id"] }
+  "limits.observed": { 1: ["windows", "plan", "account_id"] },
+  "delegation.started": { 0: ["ask_id", "via", "harness", "to"], 1: ["text"] },
+  "delegation.ended": { 0: ["ask_id", "to", "ok", "ms", "error", "relayed"], 2: ["reply"] }
 };
 var SESSION_ALLOW = [
   "id",
@@ -3168,7 +3859,8 @@ var SESSION_ALLOW = [
   "account_id",
   "attended",
   "parent_id",
-  "launched_by"
+  "launched_by",
+  "delegated_by"
 ];
 var MAX_SIDE = 2e4;
 var MAX_IO = 64 * 1024;
@@ -3207,6 +3899,8 @@ function filterEvent(event, tier, pii, opts = {}) {
   if (data.input !== void 0) data.input = cap(data.input, MAX_IO);
   if (data.output !== void 0) data.output = cap(data.output, MAX_IO);
   if (typeof data.message === "string") data.message = cap(data.message, 200);
+  if (event.type === "delegation.started" && typeof data.text === "string") data.text = cap(data.text, 200);
+  if (event.type === "delegation.ended" && typeof data.reply === "string") data.reply = cap(data.reply, MAX_SIDE);
   const rulesets = [];
   let out = { ...event, tier, session, data, privacy: { rulesets, pii } };
   if (tier > 0) {
@@ -3234,7 +3928,7 @@ function shortId(harness, id) {
 
 // ../core/src/sinks/file.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
     this.name = name;
@@ -3248,7 +3942,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path12.dirname(this.file), { recursive: true });
+      mkdirSync6(path13.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: [] };
@@ -3286,19 +3980,19 @@ import {
   appendFileSync as appendFileSync3,
   existsSync as existsSync10,
   mkdirSync as mkdirSync8,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync9,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync11,
   renameSync as renameSync3,
-  statSync as statSync6,
+  statSync as statSync7,
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import os3 from "node:os";
-import path15 from "node:path";
+import os4 from "node:os";
+import path16 from "node:path";
 
 // src/control/aliases.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync8, renameSync as renameSync2, writeFileSync as writeFileSync7 } from "node:fs";
-import path13 from "node:path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync10, renameSync as renameSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import path14 from "node:path";
 
 // src/secrets.ts
 import { spawnSync } from "node:child_process";
@@ -3342,10 +4036,10 @@ function startOptionsOf(v) {
 }
 
 // src/control/aliases.ts
-var aliasFile = (controlDir) => path13.join(controlDir, "aliases.json");
+var aliasFile = (controlDir) => path14.join(controlDir, "aliases.json");
 function readAliases(file) {
   try {
-    const j = JSON.parse(readFileSync8(file, "utf8"));
+    const j = JSON.parse(readFileSync10(file, "utf8"));
     if (!j || typeof j !== "object" || Array.isArray(j)) return {};
     const out = {};
     for (const [k, v] of Object.entries(j)) {
@@ -3366,12 +4060,12 @@ function receiverIdOf(all, harness, id) {
 
 // src/control/local.ts
 import net from "node:net";
-import os2 from "node:os";
-import path14 from "node:path";
+import os3 from "node:os";
+import path15 from "node:path";
 function socketPath(state, env = process.env) {
   if (env.SESSIONPIPE_SOCKET) return env.SESSIONPIPE_SOCKET;
-  if (process.platform === "win32") return `\\\\.\\pipe\\sessionpipe-control-${os2.userInfo().username}`;
-  return path14.join(state, "control.sock");
+  if (process.platform === "win32") return `\\\\.\\pipe\\sessionpipe-control-${os3.userInfo().username}`;
+  return path15.join(state, "control.sock");
 }
 function ask(sock, req, timeoutMs) {
   return new Promise((resolve) => {
@@ -3502,6 +4196,11 @@ var HttpSink = class {
 async function tellDaemon(state, job, session, cwd, transcript) {
   const sock = socketPath(state);
   if (process.platform !== "win32" && !existsSync10(sock)) return;
+  let mode = null;
+  try {
+    mode = claude_code_control_exports.hookMode(JSON.parse(job.stdin));
+  } catch {
+  }
   await ask(
     sock,
     {
@@ -3509,7 +4208,8 @@ async function tellDaemon(state, job, session, cwd, transcript) {
       session: `${job.harness}:${session}`,
       event: job.event,
       ...cwd ? { cwd } : {},
-      ...transcript ? { transcript } : {}
+      ...transcript ? { transcript } : {},
+      ...mode ? { mode } : {}
     },
     300
   );
@@ -3518,7 +4218,7 @@ var MAX_TRIES = 10;
 function enqueueJob(state, job) {
   const jobs = jobsDir(state);
   mkdirSync8(jobs, { recursive: true, mode: 448 });
-  const f = path15.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
+  const f = path16.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
   writeFileSync8(f, JSON.stringify(job), { mode: 384 });
   return f;
 }
@@ -3530,7 +4230,7 @@ function claimJob(file) {
     return null;
   }
   try {
-    return { job: JSON.parse(readFileSync9(claimed, "utf8")), file: claimed };
+    return { job: JSON.parse(readFileSync11(claimed, "utf8")), file: claimed };
   } catch {
     releaseJob(claimed);
     return null;
@@ -3547,7 +4247,7 @@ async function sweepJobs(state, olderThanMs = 3e3, limit = 20, abandonedMs = 6e4
   const jobs = jobsDir(state);
   let names = [];
   try {
-    names = readdirSync6(jobs);
+    names = readdirSync7(jobs);
   } catch {
     return 0;
   }
@@ -3555,19 +4255,19 @@ async function sweepJobs(state, olderThanMs = 3e3, limit = 20, abandonedMs = 6e4
   for (const n of names) {
     const m = /^(.*\.json)\.(\d+)\.running$/.exec(n);
     if (!m) continue;
-    const f = path15.join(jobs, n);
+    const f = path16.join(jobs, n);
     try {
-      if (processAlive(Number(m[2])) && Date.now() - statSync6(f).mtimeMs < abandonedMs) continue;
-      renameSync3(f, path15.join(jobs, m[1]));
+      if (processAlive(Number(m[2])) && Date.now() - statSync7(f).mtimeMs < abandonedMs) continue;
+      renameSync3(f, path16.join(jobs, m[1]));
       queued.push(m[1]);
     } catch {
     }
   }
   let ran = 0;
   for (const n of queued.sort().slice(0, limit)) {
-    const f = path15.join(jobs, n);
+    const f = path16.join(jobs, n);
     try {
-      if (Date.now() - statSync6(f).mtimeMs < olderThanMs) continue;
+      if (Date.now() - statSync7(f).mtimeMs < olderThanMs) continue;
     } catch {
       continue;
     }
@@ -3586,9 +4286,9 @@ async function sweepJobs(state, olderThanMs = 3e3, limit = 20, abandonedMs = 6e4
 function log(state, line) {
   try {
     mkdirSync8(state, { recursive: true, mode: 448 });
-    const f = path15.join(state, "log");
+    const f = path16.join(state, "log");
     try {
-      if (statSync6(f).size > 1024 * 1024) renameSync3(f, `${f}.1`);
+      if (statSync7(f).size > 1024 * 1024) renameSync3(f, `${f}.1`);
     } catch {
     }
     appendFileSync3(f, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
@@ -3597,11 +4297,11 @@ function log(state, line) {
   }
 }
 function factsState(state) {
-  const file = (h, s) => path15.join(state, "facts", safeId(h), `${safeId(s)}.json`);
+  const file = (h, s) => path16.join(state, "facts", safeId(h), `${safeId(s)}.json`);
   return {
     get(h, s) {
       try {
-        return JSON.parse(readFileSync9(file(h, s), "utf8"));
+        return JSON.parse(readFileSync11(file(h, s), "utf8"));
       } catch {
         return {};
       }
@@ -3610,7 +4310,7 @@ function factsState(state) {
       const cur = this.get(h, s);
       const next = { ...cur, ...patch };
       if (JSON.stringify(next) === JSON.stringify(cur)) return;
-      mkdirSync8(path15.dirname(file(h, s)), { recursive: true, mode: 448 });
+      mkdirSync8(path16.dirname(file(h, s)), { recursive: true, mode: 448 });
       writeFileSync8(file(h, s), JSON.stringify(next), { mode: 384 });
     }
   };
@@ -3627,7 +4327,7 @@ function buildSinks(sinks, o = {}) {
     const tier = Math.min(s.tier, s.max_tier ?? 3);
     if (s.url === "stdout") out.push(new StdoutSink(s.name, tier, !!s.pii));
     else if (s.url.startsWith("file:"))
-      out.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os3.homedir()), tier, !!s.pii));
+      out.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os4.homedir()), tier, !!s.pii));
     else if (/^https?:\/\//.test(s.url)) out.push(new HttpSink(s, tier));
   }
   return out;
@@ -3635,13 +4335,14 @@ function buildSinks(sinks, o = {}) {
 var PROGRESS_MS = 2e4;
 function openTurn(read, o) {
   const last = read.turns[read.turns.length - 1];
-  const fresh = (user, at) => ({
+  const fresh = (user, at, injected) => ({
     turn: o.base + read.turns.length,
     user: user.slice(0, MAX_TURN_SIDE),
     assistant: "",
-    at
+    at,
+    ...injected ? { injected: true } : {}
   });
-  if (read.open) return fresh(read.open.user, read.open.at);
+  if (read.open) return fresh(read.open.user, read.open.at, read.open.injected);
   const prompt = o.prompt?.trim();
   if (prompt && !isInjected(prompt) && !(last && last.user.includes(prompt.slice(0, 200)))) return fresh(prompt, o.at);
   if (!last) return null;
@@ -3649,6 +4350,7 @@ function openTurn(read, o) {
     turn: o.base + read.turns.length - 1,
     user: last.user.slice(0, MAX_TURN_SIDE),
     assistant: capTail(last.assistant, MAX_TURN_SIDE),
+    ...last.injected ? { injected: true } : {},
     at: last.at
   };
 }
@@ -3656,6 +4358,7 @@ var MAX_TURN_SIDE = 2e4;
 var JOB_OWN_ENV = [
   "CLAUDE_CODE_SESSION_ATTENDED",
   "CLAUDE_CODE_HOST_SESSION_ID",
+  "SESSIONPIPE_ASKED_BY",
   "SESSIONPIPE_CONTROL_JOB",
   "SESSIONPIPE_LAUNCHED_BY"
 ];
@@ -3683,7 +4386,7 @@ async function runJob(job, opts = {}) {
     );
     return { events: [], delivered: {} };
   }
-  const id = receiverIdOf(readAliases(aliasFile(path15.join(state, "control"))), job.harness, r.session.id) ?? r.session.id;
+  const id = receiverIdOf(readAliases(aliasFile(path16.join(state, "control"))), job.harness, r.session.id) ?? r.session.id;
   const claudeEnd = job.harness === "claude-code" && r.events.some((e) => e.type === "session.ended");
   if (!claudeEnd) await tellDaemon(state, job, id, r.session.cwd, r.transcript);
   const outbox = new Outbox(state);
@@ -3720,7 +4423,7 @@ async function runJob(job, opts = {}) {
       learned = rest;
       if (harness_version) facts.save(job.harness, id, { harness_version });
       facts.save(job.harness, id, { session: { ...mem.session, ...learned } });
-      if (CWD_FROM_HOOKS.has(job.harness) && r.session.cwd && path15.isAbsolute(r.session.cwd))
+      if (CWD_FROM_HOOKS.has(job.harness) && r.session.cwd && path16.isAbsolute(r.session.cwd))
         facts.save(job.harness, id, { cwd: r.session.cwd });
     }
     const known = mem.session ?? {};
@@ -3733,10 +4436,11 @@ async function runJob(job, opts = {}) {
       ...learned.branch ? { branch: learned.branch } : {},
       id,
       seq: 0,
-      machine: machineName(cfg, os3.hostname()),
+      machine: machineName(cfg, os4.hostname()),
       ...cwdRaw ? { cwd: tilde(cwdRaw) } : {},
       ...r.session.model ? { model: r.session.model } : {},
-      ...r.session.launched_by ? { launched_by: r.session.launched_by } : {}
+      ...r.session.launched_by ? { launched_by: r.session.launched_by } : {},
+      ...r.session.delegated_by ? { delegated_by: r.session.delegated_by } : {}
     };
     const version = facts.get(job.harness, id).harness_version ?? void 0;
     for (const a of r.events) {
@@ -3790,7 +4494,13 @@ async function runJob(job, opts = {}) {
             {
               type: "turn.transcript",
               harnessEvent: job.event,
-              data: { turn: turnNo++, user: t.user, assistant: t.assistant, at: new Date(t.at).toISOString() }
+              data: {
+                turn: turnNo++,
+                user: t.user,
+                assistant: t.assistant,
+                at: new Date(t.at).toISOString(),
+                ...t.injected ? { injected: true } : {}
+              }
             },
             {
               harness: { name: job.harness, ...version ? { version } : {} },
@@ -3836,7 +4546,7 @@ async function runJob(job, opts = {}) {
   return { events, delivered };
 }
 async function drain(state, sinkConfigs, outbox, first) {
-  const more = path15.join(state, "locks", "flush.more");
+  const more = path16.join(state, "locks", "flush.more");
   let release = takeNamedLock(state, "flush");
   if (!release) {
     try {
@@ -3864,10 +4574,10 @@ async function drain(state, sinkConfigs, outbox, first) {
   }
 }
 var BACKOFF_MS = [2e3, 1e4, 6e4, 5 * 6e4, 30 * 6e4];
-var backoffFile = (state, sink) => path15.join(state, "backoff", `${safeId(sink)}.json`);
+var backoffFile = (state, sink) => path16.join(state, "backoff", `${safeId(sink)}.json`);
 function readBackoff(state, sink) {
   try {
-    const b = JSON.parse(readFileSync9(backoffFile(state, sink), "utf8"));
+    const b = JSON.parse(readFileSync11(backoffFile(state, sink), "utf8"));
     return typeof b.until === "number" ? b : null;
   } catch {
     return null;
@@ -3880,7 +4590,7 @@ function noteFailure(state, sink, res, prev) {
   const b = { until: Date.now() + wait, failures, why: `${res.status ?? ""} ${res.error ?? ""}`.trim() };
   const f = backoffFile(state, sink);
   try {
-    mkdirSync8(path15.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync8(path16.dirname(f), { recursive: true, mode: 448 });
     writeFileSync8(f, JSON.stringify(b), { mode: 384 });
   } catch {
   }
@@ -3980,7 +4690,7 @@ async function flush(state, sinkConfigs, outbox, first, o = {}) {
         const { events, offset: next } = outbox.read(ref, offset, room);
         if (!events.length) break;
         for (const e of events) {
-          const f = filterEvent(e, sink.tier, sink.pii, { home: os3.homedir() });
+          const f = filterEvent(e, sink.tier, sink.pii, { home: os4.homedir() });
           if (f) batch.push(f);
         }
         offset = next;
@@ -4013,7 +4723,7 @@ function applySinkVerdict(name, res) {
   } catch {
   }
 }
-var jobsDir = (state) => path15.join(state, "jobs");
+var jobsDir = (state) => path16.join(state, "jobs");
 
 // src/worker.ts
 async function workerMain(argv) {
@@ -4025,7 +4735,7 @@ async function workerMain(argv) {
   deadline.unref();
   await runJob(claimed.job, { claimed: claimed.file }).then((r) => {
     if (!r.requeued || (claimed.job.tries ?? 0) + 1 >= MAX_TRIES) return;
-    const p = spawn(process.execPath, [argv[1], r.requeued], {
+    const p = spawn2(process.execPath, [argv[1], r.requeued], {
       detached: true,
       stdio: "ignore",
       windowsHide: true