sessionpipe-core 0.12.0 → 0.13.1

package/dist/index.js

@@ -1,4 +1,4 @@
-// sessionpipe-core 0.12.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe-core 0.13.1 · Apache-2.0 · https://sessionpipe.org
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -59,7 +59,7 @@ var safeId = (s) => String(s).replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 160);
 // src/adapters/claude-code.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import { userInfo } from "node:os";
 import path4 from "node:path";
 
@@ -211,7 +211,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;
@@ -221,10 +228,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);
@@ -247,27 +261,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 });
@@ -379,6 +417,41 @@ function readJson(file) {
   const f = readJsonFile(file);
   return f.ok ? f.value : {};
 }
+function refused(file, e, what, existed) {
+  const { code, syscall } = e;
+  const why = `can't ${what} it (${code ?? String(e)})`;
+  if (what === "remove" || syscall === "open" || syscall === "mkdir")
+    return { file, changed: false, skipped: true, note: `${why}; not touched` };
+  return {
+    file,
+    changed: true,
+    skipped: true,
+    ...existed ? {} : { created: true },
+    note: `${why} part way; check the file before the harness reads it`
+  };
+}
+function writeBack(file, text, existed = true) {
+  try {
+    mkdirSync(path3.dirname(file), { recursive: true });
+    writeFileSync(file, text);
+    return null;
+  } catch (e) {
+    return refused(file, e, "write", existed);
+  }
+}
+function removeEmptied(file, empty) {
+  try {
+    unlinkSync(file);
+    return { file, changed: true, note: "removed (sessionpipe created it)" };
+  } catch (e) {
+    const bad = refused(file, e, "remove", true);
+    return writeBack(file, empty) ?? {
+      file,
+      changed: true,
+      note: `emptied; ${bad.note.replace(/; not touched$/, "")}, so the empty file stays`
+    };
+  }
+}
 function entryFor(event, harness, cmd, o) {
   const matcher = o.matcherFor(event);
   return {
@@ -420,8 +493,8 @@ function installClaudeShaped(file, harness, events, cmd, o) {
   }
   if (changed) {
     settings2.hooks = hooks;
-    mkdirSync(path3.dirname(file), { recursive: true });
-    writeFileSync(file, formatJson(settings2, f));
+    const bad = writeBack(file, formatJson(settings2, f), f.existed);
+    if (bad) return bad;
   }
   return { file, changed, created: !f.existed && changed };
 }
@@ -444,12 +517,8 @@ function uninstallClaudeShaped(file, events, opts = {}) {
   }
   if (!changed) return { file, changed: false };
   if (!Object.keys(hooks).length) delete settings2.hooks;
-  if (opts.created && !Object.keys(settings2).length) {
-    unlinkSync(file);
-    return { file, changed: true, note: "removed (sessionpipe created it)" };
-  }
-  writeFileSync(file, formatJson(settings2, f));
-  return { file, changed: true };
+  if (opts.created && !Object.keys(settings2).length) return removeEmptied(file, formatJson(settings2, f));
+  return writeBack(file, formatJson(settings2, f)) ?? { file, changed: true };
 }
 function installedClaudeShaped(file, harness, events, cmd, o) {
   const f = readJsonFile(file);
@@ -528,7 +597,7 @@ var claudeCode = {
   configFiles: (env = process.env) => claudeDirs(env).map(settingsIn),
   install: (cmd, env = process.env, opts = {}) => claudeDirs(env).flatMap((d) => {
     const hooks = installClaudeShaped(settingsIn(d), NAME, eventsFor(opts.lean), cmd, OPTS);
-    const line = opts.statusLine === void 0 ? null : statusLine(settingsIn(d), opts.statusLine, cmd);
+    const line = opts.statusLine === void 0 || hooks.skipped ? null : statusLine(settingsIn(d), opts.statusLine, cmd);
     return line ? [hooks, line] : [hooks];
   }),
   uninstall: (env = process.env, opts = {}) => claudeDirs(env).map((d) => {
@@ -536,7 +605,9 @@ var claudeCode = {
     const hooks = uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS, {
       created: opts.created?.includes(settingsIn(d))
     });
-    return line && !hooks.changed ? line : hooks;
+    if (line?.changed && !line.skipped && hooks.skipped)
+      return { ...hooks, note: `status line removed, hooks not: ${hooks.note?.replace(/; not touched$/, "")}` };
+    return line && !hooks.changed && !hooks.skipped ? line : hooks;
   }),
   installed: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
     file: settingsIn(d),
@@ -631,7 +702,8 @@ var claudeCode = {
             attention_id: call_id ?? permissionId(),
             kind: "permission",
             tool,
-            message: tool ? `${tool}${describe(s.tool_input)}` : void 0
+            message: tool ? `${tool}${describe(s.tool_input)}` : void 0,
+            agent_id
           })
         );
         break;
@@ -640,7 +712,8 @@ var claudeCode = {
           ev("attention.needed", {
             attention_id: `notif-${Date.now()}`,
             kind: notifKind(s.notification_type),
-            message: typeof s.message === "string" ? s.message.slice(0, 200) : void 0
+            message: typeof s.message === "string" ? s.message.slice(0, 200) : void 0,
+            agent_id
           })
         );
         break;
@@ -765,8 +838,11 @@ function statusLine(file, want, cmd) {
   if (want ? ours && cur?.command === command && cur?.refreshInterval === LINE_REFRESH_S : !ours) return null;
   if (want) f.value.statusLine = { type: "command", command, refreshInterval: LINE_REFRESH_S };
   else delete f.value.statusLine;
-  writeFileSync2(file, formatJson(f.value, f));
-  return { file, changed: true, note: want ? "status line written (account limits)" : "status line removed" };
+  return writeBack(file, formatJson(f.value, f), f.existed) ?? {
+    file,
+    changed: true,
+    note: want ? "status line written (account limits)" : "status line removed"
+  };
 }
 var epochIso = (t) => typeof t === "number" && t > 0 && t < 1e11 ? new Date(t * 1e3).toISOString() : void 0;
 var WINDOW_MINUTES = { five_hour: 300, seven_day: 10080 };
@@ -1635,6 +1711,41 @@ import path7 from "node:path";
 import { spawn } from "node:child_process";
 import { accessSync, constants, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
 import path6 from "node:path";
+
+// 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;
+}
+
+// src/adapters/headless.ts
 var JOB_TIMEOUT_MS = 30 * 6e4;
 var OUT_CAP = 1024 * 1024;
 function isExe(p) {
@@ -1682,7 +1793,7 @@ function probe(bin, args) {
   return s ? { ...s, shell: false } : { file: [`"${bin}"`, ...args].join(" "), args: [], shell: true };
 }
 function jobEnv(env = process.env) {
-  return { ...env, SESSIONPIPE_CONTROL_JOB: "1" };
+  return { ...withoutLineage(env), SESSIONPIPE_CONTROL_JOB: "1" };
 }
 function runHeadless(bin, args, o) {
   return new Promise((resolve) => {
@@ -1904,7 +2015,9 @@ function startAcp(o) {
   try {
     child = spawn2(c.file, c.args, {
       cwd: o.cwd,
-      env: jobEnv(o.env),
+      // The caller's env as given (the daemon's is jobEnv's already, with the ask's
+      // lineage on top), marked as a control job.
+      env: { ...o.env, SESSIONPIPE_CONTROL_JOB: "1" },
       stdio: ["pipe", "pipe", "pipe"],
       detached: process.platform !== "win32",
       windowsHide: true
@@ -2091,18 +2204,18 @@ function startAcp(o) {
           );
           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 };
+          const refused2 = deniedNote(t.denied, t.count);
+          if (stop === "end_turn" || stop === "max_tokens") return { reply: words + refused2 };
           if (stop === "refusal") return { reply: `${words}
 
-(${label} refused the request.)${refused}` };
+(${label} refused the request.)${refused2}` };
           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}` };
+(The turn was cancelled.)${refused2}` };
           return { reply: "", error: `${label} ended the turn with ${stop || "no stop reason"}` };
         } catch (e) {
           return { reply: "", error: e.message };
@@ -2163,16 +2276,7 @@ function startAcp(o) {
 }
 
 // src/adapters/antigravity.ts
-import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync5,
-  realpathSync,
-  statSync as statSync4,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
-} from "node:fs";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync5, realpathSync, statSync as statSync4 } from "node:fs";
 import path8 from "node:path";
 var NAME2 = "antigravity";
 var HOOK_NAME = "sessionpipe";
@@ -2204,10 +2308,8 @@ var antigravity = {
     const e = entry(cmd);
     if (JSON.stringify(hooks[HOOK_NAME]) === JSON.stringify(e)) return [{ file, changed: false }];
     hooks[HOOK_NAME] = e;
-    mkdirSync2(path8.dirname(file), { recursive: true });
-    writeFileSync3(file, formatJson(hooks, f));
     return [
-      {
+      writeBack(file, formatJson(hooks, f), f.existed) ?? {
         file,
         changed: true,
         created: !f.existed,
@@ -2223,12 +2325,8 @@ var antigravity = {
     const hooks = f.value;
     if (!(HOOK_NAME in hooks)) return [{ file, changed: false }];
     delete hooks[HOOK_NAME];
-    if (opts.created?.includes(file) && !Object.keys(hooks).length) {
-      unlinkSync2(file);
-      return [{ file, changed: true, note: "removed (sessionpipe created it)" }];
-    }
-    writeFileSync3(file, formatJson(hooks, f));
-    return [{ file, changed: true }];
+    if (opts.created?.includes(file) && !Object.keys(hooks).length) return [removeEmptied(file, formatJson(hooks, f))];
+    return [writeBack(file, formatJson(hooks, f)) ?? { file, changed: true }];
   },
   installed(cmd, env = process.env) {
     const file = hooksFile(env);
@@ -2591,7 +2689,10 @@ var reading = () => new AgyReading();
 // 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,
@@ -2601,17 +2702,26 @@ __export(claude_code_control_exports, {
   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: () => offeredLevels2,
   outputArgs: () => outputArgs,
   parseAuthStatus: () => parseAuthStatus,
   parseCaps: () => parseCaps,
   parseResult: () => parseResult,
+  peerClass: () => peerClass,
   recentlyWritten: () => recentlyWritten,
+  relaunchMode: () => relaunchMode,
+  resolveHome: () => resolveHome,
   runClaude: () => runClaude,
   sessionFolder: () => sessionFolder
 });
@@ -2630,10 +2740,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"]
 };
@@ -2705,6 +2815,8 @@ var LEVEL_MODE = {
 };
 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") {
@@ -2724,6 +2836,7 @@ function modeFlags(level, caps) {
 }
 var ceilingLevel = (mode) => mode === "inherit" ? "safe" : mode;
 function offeredLevels2(mode, caps) {
+  if (caps.unread) return [];
   return START_PERMISSIONS.filter(
     (l) => levelRank(l) <= levelRank(ceilingLevel(mode)) && (l === "safe" || caps.modes.includes(LEVEL_MODE[l]))
   );
@@ -2749,7 +2862,7 @@ function claudeArgs(o) {
   };
 }
 function claudeEnv(configDir, env = process.env) {
-  const e = { ...env };
+  const e = withoutLineage(env);
   for (const k of [
     "CLAUDECODE",
     "CLAUDE_CODE_SESSION_ID",
@@ -2806,43 +2919,73 @@ function loginHint(configDir, platform = process.platform) {
     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) {
-  let help = "";
+function detectCaps(bin, timeoutMs = 3e4) {
   const c = probe(bin, ["--help"]);
   try {
-    help = execFileSync3(c.file, c.args, {
-      encoding: "utf8",
-      timeout: 3e4,
-      env: claudeEnv(),
-      stdio: ["ignore", "pipe", "pipe"],
-      maxBuffer: 4 * 1024 * 1024,
-      shell: c.shell
-    });
+    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) {
-    help = String(e?.stdout || "");
+    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: `\`${path10.basename(bin)} --help\` ${why}` };
   }
-  return parseCaps(help);
 }
-function findTranscript(session, dirs) {
-  if (!UUID_RE2.test(session)) return null;
-  for (const dir of dirs) {
-    let projects = [];
+function transcriptIn(session, dir) {
+  let projects = [];
+  try {
+    projects = readdirSync4(path10.join(dir, "projects"), { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const p of projects) {
+    if (!p.isDirectory()) continue;
+    const file = path10.join(dir, "projects", p.name, `${session}.jsonl`);
     try {
-      projects = readdirSync4(path10.join(dir, "projects"), { withFileTypes: true });
+      if (statSync5(file).isFile()) return { file, configDir: dir, project: p.name };
     } catch {
-      continue;
-    }
-    for (const p of projects) {
-      if (!p.isDirectory()) continue;
-      const file = path10.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_RE2.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_RE2.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) => path10.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;
@@ -2914,22 +3057,105 @@ function pidAlive(pid) {
     return e.code === "EPERM";
   }
 }
-function liveProcess(session, configDir) {
-  let names = [];
+var registryRow = (file, configDir, j) => {
+  const pid = Number(j.pid ?? path10.basename(file).slice(0, -5));
+  const str2 = (v) => typeof v === "string" && v ? v : null;
+  let keyFile = null;
   try {
-    names = readdirSync4(path10.join(configDir, "sessions")).filter((n) => /^\d+\.json$/.test(n));
+    const want = new RegExp(`^${pid}\\.[0-9a-f]{64}\\.key$`);
+    const hit = readdirSync4(path10.dirname(file)).find((n) => want.test(n));
+    if (hit) keyFile = path10.join(path10.dirname(file), hit);
   } catch {
-    return false;
   }
-  for (const n of names) {
+  return {
+    configDir,
+    file,
+    pid,
+    socket: str2(j.messagingSocketPath),
+    peerProtocol: typeof j.peerProtocol === "number" ? j.peerProtocol : null,
+    procStart: str2(j.procStart),
+    status: str2(j.status),
+    kind: str2(j.kind),
+    entrypoint: str2(j.entrypoint),
+    keyFile
+  };
+};
+function liveRecords(session, dirs) {
+  const out = [];
+  for (const dir of typeof dirs === "string" ? [dirs] : dirs) {
+    let names = [];
     try {
-      const j = JSON.parse(readFileSync6(path10.join(configDir, "sessions", n), "utf8"));
-      if (String(j.sessionId) !== session) continue;
-      if (pidAlive(Number(j.pid ?? n.slice(0, -5)))) return true;
+      names = readdirSync4(path10.join(dir, "sessions")).filter((n) => /^\d+\.json$/.test(n));
     } catch {
+      continue;
+    }
+    for (const n of names) {
+      const file = path10.join(dir, "sessions", n);
+      let j;
+      try {
+        j = JSON.parse(readFileSync6(file, "utf8"));
+      } catch {
+        continue;
+      }
+      if (String(j.sessionId) !== session) continue;
+      const row = registryRow(file, dir, j);
+      if (pidAlive(row.pid)) out.push(row);
     }
   }
-  return false;
+  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 = os5.homedir()) {
+  const file = path10.join(configDir ?? path10.join(home, ".claude"), "settings.json");
+  let j;
+  try {
+    j = JSON.parse(readFileSync6(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;
@@ -2971,7 +3197,7 @@ function parseResult(stdout) {
 var isUuid = (s) => typeof s === "string" && UUID_RE2.test(s);
 
 // src/adapters/codex.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync4, readdirSync as readdirSync5, readFileSync as readFileSync7 } from "node:fs";
 import path11 from "node:path";
 
 // src/adapters/codex-config.ts
@@ -3124,29 +3350,30 @@ var configFile2 = (env) => path11.join(codexHome(env), "config.toml");
 var sessionsDir = (env) => path11.join(codexHome(env), "sessions");
 var validTool3 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
 var endReason2 = (r) => r === "clear" || r === "logout" || r === "exit" ? r : "other";
+var UNTIL_APPROVED = "Codex will report nothing until you approve the hooks: start `codex` and accept the hook review";
 function installNotify(cmd, env) {
   const file = configFile2(env);
   let text = "";
+  let existed = true;
   try {
     text = readFileSync7(file, "utf8");
-  } catch {
+  } catch (e) {
+    existed = e.code !== "ENOENT";
   }
   const argv = cmd([NAME3, "notify"]).argv;
   const line = `notify = ${JSON.stringify(argv)}`;
   const n = readNotify(text);
-  const write = (next) => {
-    mkdirSync3(path11.dirname(file), { recursive: true });
-    writeFileSync4(file, next);
+  const write = (next, note) => {
+    const bad = writeBack(file, next, existed);
+    return bad ? { ...bad, note: `${bad.note}. ${UNTIL_APPROVED}` } : { file, changed: true, note };
   };
   if (n && !n.other) {
     if (!n.misplaced && JSON.stringify(n.argv) === JSON.stringify(argv))
       return { file, changed: false, note: "notify current" };
-    write(withNotify(text, line));
-    return {
-      file,
-      changed: true,
-      note: n.misplaced ? "notify moved to the top level (it sat inside a [table], where Codex never reads it)" : "notify updated"
-    };
+    return write(
+      withNotify(text, line),
+      n.misplaced ? "notify moved to the top level (it sat inside a [table], where Codex never reads it)" : "notify updated"
+    );
   }
   if (n?.other) {
     const prev = previousNotify(n.argv);
@@ -3155,20 +3382,20 @@ function installNotify(cmd, env) {
         if (JSON.stringify(prev) === JSON.stringify(argv))
           return { file, changed: false, note: "notify current (after Codex Computer Use)" };
       }
-      if (!prev || OURS2.test(JSON.stringify(prev))) {
-        write(replaceNotify(text, n, `notify = ${withPreviousRaw(n.raw, argv)}`));
-        return { file, changed: true, note: "chained after Codex Computer Use (--previous-notify)" };
-      }
+      if (!prev || OURS2.test(JSON.stringify(prev)))
+        return write(
+          replaceNotify(text, n, `notify = ${withPreviousRaw(n.raw, argv)}`),
+          "chained after Codex Computer Use (--previous-notify)"
+        );
     }
     return {
       file,
       changed: false,
       skipped: true,
-      note: `notify belongs to ${(n.argv?.[0] ?? n.raw).replace(/^.*\//, "").slice(0, 40)}; left alone. Codex will report nothing until you approve the hooks: start \`codex\` and accept the hook review`
+      note: `notify belongs to ${(n.argv?.[0] ?? n.raw).replace(/^.*\//, "").slice(0, 40)}; left alone. ${UNTIL_APPROVED}`
     };
   }
-  write(withNotify(text, line));
-  return { file, changed: true, note: "notify set at the top level" };
+  return write(withNotify(text, line), "notify set at the top level");
 }
 function uninstallNotify(env) {
   const file = configFile2(env);
@@ -3180,15 +3407,13 @@ function uninstallNotify(env) {
   }
   const n = readNotify(text);
   if (!n) return { file, changed: false };
-  if (!n.other) {
-    writeFileSync4(file, withoutNotify(text));
-    return { file, changed: true };
-  }
+  if (!n.other) return writeBack(file, withoutNotify(text)) ?? { file, changed: true };
   const prev = previousNotify(n.argv);
-  if (isComputerUse(n.argv) && prev && OURS2.test(JSON.stringify(prev))) {
-    writeFileSync4(file, replaceNotify(text, n, `notify = ${stripPreviousRaw(n.raw)}`));
-    return { file, changed: true };
-  }
+  if (isComputerUse(n.argv) && prev && OURS2.test(JSON.stringify(prev)))
+    return writeBack(file, replaceNotify(text, n, `notify = ${stripPreviousRaw(n.raw)}`)) ?? {
+      file,
+      changed: true
+    };
   return { file, changed: false };
 }
 function findRollout(threadId, env = process.env) {
@@ -3220,8 +3445,12 @@ function rolloutMeta(file) {
   return scanLines(file, (line) => parseLines([line])[0] ?? {});
 }
 function ofAnotherThread(file, id) {
+  const other = threadOf(file);
+  return !!other && other !== id.toLowerCase();
+}
+function threadOf(file) {
   const m = /-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl(?:\.zst)?$/i.exec(file);
-  return !!m?.[1] && m[1].toLowerCase() !== id.toLowerCase();
+  return m?.[1] ? m[1].toLowerCase() : null;
 }
 var codex = {
   name: NAME3,
@@ -3300,6 +3529,8 @@ var codex = {
     const turn_id = typeof s.turn_id === "string" ? s.turn_id : void 0;
     const tool = validTool3(s.tool_name) ? s.tool_name : void 0;
     const call_id = typeof s.tool_use_id === "string" ? s.tool_use_id : void 0;
+    const thread = typeof s.transcript_path === "string" ? threadOf(s.transcript_path) : null;
+    const agent_id = typeof s.agent_id === "string" && s.agent_id ? s.agent_id : typeof s.subagent_id === "string" && s.subagent_id ? s.subagent_id : thread && thread !== String(id).toLowerCase() ? thread : void 0;
     const ev = (type, data) => ({ type, data: prune3(data), harnessEvent: event });
     const events = [];
     switch (event) {
@@ -3319,17 +3550,30 @@ var codex = {
         );
         break;
       case "PreToolUse":
-        if (tool) events.push(ev("tool.started", { tool, call_id, turn_id, input: s.tool_input }));
+        if (tool) events.push(ev("tool.started", { tool, call_id, turn_id, agent_id, input: s.tool_input }));
         break;
       case "PostToolUse":
         if (tool)
           events.push(
-            ev("tool.ended", { tool, call_id, turn_id, ok: true, input: s.tool_input, output: s.tool_response })
+            ev("tool.ended", {
+              tool,
+              call_id,
+              turn_id,
+              agent_id,
+              ok: true,
+              input: s.tool_input,
+              output: s.tool_response
+            })
           );
         break;
       case "PermissionRequest":
         events.push(
-          ev("attention.needed", { attention_id: call_id ?? `perm-${Date.now()}`, kind: "permission", tool })
+          ev("attention.needed", {
+            attention_id: call_id ?? `perm-${Date.now()}`,
+            kind: "permission",
+            tool,
+            agent_id
+          })
         );
         break;
       case "Stop":
@@ -3987,7 +4231,7 @@ var CHAIN_LIMIT = 4e3;
 var CHAIN_SQL = `WITH RECURSIVE chain(node_id, parent_node_id, chat_message, created_at) AS (
   SELECT node_id, parent_node_id, chat_message, created_at FROM message_nodes
    WHERE session_id = ? AND node_id = (SELECT main_chain_id FROM sessions WHERE id = ?)
-  UNION ALL
+  UNION
   SELECT m.node_id, m.parent_node_id, m.chat_message, m.created_at FROM message_nodes m
     JOIN chain c ON m.node_id = c.parent_node_id AND m.session_id = ? AND m.node_id >= ?
 )
@@ -4265,7 +4509,7 @@ function drivableHarnesses(env = process.env) {
 }
 
 // src/config.ts
-import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "node:fs";
+import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync2 } from "node:fs";
 import path15 from "node:path";
 var DEFAULT_CONFIG = { sinks: [], harnesses: {}, update_check: true, keep_days: 30 };
 function readConfig(file = configFile()) {
@@ -4281,9 +4525,36 @@ function readConfig(file = configFile()) {
     return { ...DEFAULT_CONFIG, sinks: [], harnesses: {} };
   }
 }
+function configProblem(file) {
+  let text;
+  try {
+    text = readFileSync10(file, "utf8");
+  } catch (e) {
+    const code = e.code;
+    return code === "ENOENT" ? void 0 : `could not be read (${code})`;
+  }
+  if (!text.trim()) return void 0;
+  if (text.charCodeAt(0) === 65279) return "starts with a byte-order mark (save it as UTF-8 without one)";
+  try {
+    const j = JSON.parse(text);
+    return j && typeof j === "object" && !Array.isArray(j) ? void 0 : "is not a JSON object";
+  } catch (e) {
+    const m = e.message;
+    const at = (/line \d+ column \d+/.exec(m) ?? /position \d+/.exec(m))?.[0];
+    return `is not valid JSON${at ? ` at ${at}` : ""}`;
+  }
+}
+function assertConfigWritable(file = configFile()) {
+  const problem = configProblem(file);
+  if (problem)
+    throw new Error(
+      `${tilde(file)} ${problem}, so it was not written over: that would lose its machine name and sinks. Fix it, or move it aside to start again, then run this again.`
+    );
+}
 function writeConfig(c, file = configFile()) {
-  mkdirSync4(path15.dirname(file), { recursive: true, mode: 448 });
-  writeFileSync5(file, `${JSON.stringify(c, null, 2)}
+  assertConfigWritable(file);
+  mkdirSync2(path15.dirname(file), { recursive: true, mode: 448 });
+  writeFileSync2(file, `${JSON.stringify(c, null, 2)}
 `, { mode: 384 });
   if (process.platform !== "win32" && existsSync8(file)) {
     try {
@@ -4347,36 +4618,21 @@ 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 { randomBytes as randomBytes3 } from "node:crypto";
 import {
   appendFileSync,
   closeSync as closeSync3,
   existsSync as existsSync9,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync3,
   openSync as openSync3,
   readdirSync as readdirSync6,
   readFileSync as readFileSync11,
   readSync as readSync3,
   renameSync,
   statSync as statSync6,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync6
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "node:fs";
 import path16 from "node:path";
 var READ_CHUNK = 1024 * 1024;
@@ -4406,8 +4662,8 @@ var Outbox = class {
     } catch {
     }
     if (n < 0) n = this.lastSeqInFile(ref) + 1;
-    mkdirSync5(path16.dirname(f), { recursive: true, mode: 448 });
-    writeFileSync6(f, String(n + 1), { mode: 384 });
+    mkdirSync3(path16.dirname(f), { recursive: true, mode: 448 });
+    writeFileSync3(f, String(n + 1), { mode: 384 });
     return n;
   }
   lastSeqInFile(ref) {
@@ -4425,7 +4681,7 @@ var Outbox = class {
   }
   append(ref, events) {
     if (!events.length) return;
-    mkdirSync5(this.dir(ref.harness), { recursive: true, mode: 448 });
+    mkdirSync3(this.dir(ref.harness), { recursive: true, mode: 448 });
     appendFileSync(this.file(ref), `${events.map((e) => JSON.stringify(e)).join("\n")}
 `, { mode: 384 });
   }
@@ -4495,34 +4751,106 @@ var Outbox = class {
       closeSync3(fd);
     }
   }
-  /** Files older than `days` are pruned; the cursor files with them. */
+  /** Files older than `days` are pruned, and each sink's cursor into them. The seq
+   *  counter stays: a session resumed after the window counts on from where it was,
+   *  so a receiver's (harness, session, seq) dedup doesn't take its new events for
+   *  ones it already has, and the sinks read the new file from its start.
+   *  It all happens under the drain's `flush` lock, since a drain holds the whole
+   *  cursor map and writes it back: a file and its cursor keys go together, so a
+   *  session resumed in between can't keep a key past its new file's end. While a
+   *  drain runs, nothing is pruned (0); the next prune does it. It never throws: it
+   *  is a cleanup, and a hook's drain comes after it. */
   prune(days, now = Date.now()) {
+    let release = null;
+    try {
+      release = takeNamedLock(this.root, "flush");
+    } catch {
+    }
+    if (!release) return 0;
     let n = 0;
-    const cutoff = now - days * 864e5;
-    for (const ref of this.sessions()) {
-      const f = this.file(ref);
-      try {
-        if (statSync6(f).mtimeMs < cutoff) {
-          unlinkSync3(f);
-          try {
-            unlinkSync3(this.seqFile(ref));
-          } catch {
+    try {
+      const cutoff = now - days * 864e5;
+      const aged = this.sessions().filter((ref) => {
+        try {
+          return statSync6(this.file(ref)).mtimeMs < cutoff;
+        } catch {
+          return false;
+        }
+      });
+      this.dropStaleCursors(new Set(aged.map((ref) => `${ref.harness}/${ref.session}`)));
+      for (const ref of aged) {
+        const f = this.file(ref);
+        try {
+          if (statSync6(f).mtimeMs < cutoff) {
+            unlinkSync2(f);
+            n++;
           }
-          n++;
+        } catch {
         }
-      } catch {
       }
+    } catch {
+    } finally {
+      release();
     }
     return n;
   }
+  /** A sink's cursor into a session file about to be pruned (`gone`), or one already
+   *  missing (an earlier prune, an older release, by hand) is removed. The caller
+   *  holds the `flush` lock. */
+  dropStaleCursors(gone) {
+    let names = [];
+    try {
+      names = readdirSync6(path16.join(this.root, "cursors")).filter((n) => n.endsWith(".json"));
+    } catch {
+    }
+    const stale = (c) => Object.keys(c).filter((k) => {
+      if (gone.has(k)) return true;
+      const i = k.indexOf("/");
+      return !existsSync9(this.file({ harness: k.slice(0, i), session: k.slice(i + 1) }));
+    });
+    for (const n of names) {
+      const s = new Cursors(this.root, n.slice(0, -5));
+      const c = s.read();
+      const keys = stale(c);
+      if (!keys.length) continue;
+      for (const k of keys) delete c[k];
+      s.write(c);
+    }
+  }
   delete(ref) {
+    this.dropCursors(ref);
     for (const f of [this.file(ref), this.seqFile(ref)]) {
       try {
-        unlinkSync3(f);
+        unlinkSync2(f);
       } catch {
       }
     }
   }
+  /** The key every sink's cursor holds for a session is removed with the session's
+   *  file: the key alone pointed into the old file, and a session that went on (still
+   *  running, or resumed later) had its new file's first events unsent until it grew
+   *  past that offset. Every file under <state>/cursors is taken (a sink since taken
+   *  out of the config still has one; one that doesn't parse reads as empty and is
+   *  left), by the key a drain writes (the file's own name, `safeId`) and by the ref
+   *  as given. The caller holds the drain's `flush` lock: a drain holds the whole
+   *  cursor map and writes it back, so a key dropped under it would come back. */
+  dropCursors(ref) {
+    const keys = /* @__PURE__ */ new Set([`${ref.harness}/${ref.session}`, `${safeId(ref.harness)}/${safeId(ref.session)}`]);
+    let names = [];
+    try {
+      names = readdirSync6(path16.join(this.root, "cursors")).filter((n) => n.endsWith(".json"));
+    } catch {
+      return;
+    }
+    for (const n of names) {
+      const s = new Cursors(this.root, n.slice(0, -5));
+      const c = s.read();
+      const had = Object.keys(c).filter((k) => keys.has(k));
+      if (!had.length) continue;
+      for (const k of had) delete c[k];
+      s.write(c);
+    }
+  }
 };
 var Cursors = class {
   constructor(root, sink) {
@@ -4534,18 +4862,21 @@ var Cursors = class {
   file() {
     return path16.join(this.root, "cursors", `${safeId(this.sink)}.json`);
   }
+  /** The map; empty when the file is missing, cut off mid-write, or holds anything
+   *  but an object (`null`, a list), so a drain never indexes into those. */
   read() {
     try {
-      return JSON.parse(readFileSync11(this.file(), "utf8"));
+      const c = JSON.parse(readFileSync11(this.file(), "utf8"));
+      return c && typeof c === "object" && !Array.isArray(c) ? c : {};
     } catch {
       return {};
     }
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path16.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync3(path16.dirname(f), { recursive: true, mode: 448 });
     const tmp = `${f}.${process.pid}.tmp`;
-    writeFileSync6(tmp, JSON.stringify(c), { mode: 384 });
+    writeFileSync3(tmp, JSON.stringify(c), { mode: 384 });
     renameSync(tmp, f);
   }
   key(ref) {
@@ -4557,25 +4888,54 @@ function takeLock(root, ref, staleMs = 5 * 6e4) {
 }
 function takeNamedLock(root, name, staleMs = 5 * 6e4) {
   const dir = path16.join(root, "locks");
-  mkdirSync5(dir, { recursive: true, mode: 448 });
+  mkdirSync3(dir, { recursive: true, mode: 448 });
   const f = path16.join(dir, `${name}.lock`);
+  const nonce = randomBytes3(8).toString("hex");
+  const mine = `${process.pid} ${nonce}`;
+  let body = null;
   try {
-    if (Date.now() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(readFileSync11(f, "utf8")))) unlinkSync3(f);
-    else return null;
+    body = readFileSync11(f, "utf8");
+    const stale = Date.now() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(body.split(" ")[0]));
+    if (!stale) return null;
   } catch {
+    body = null;
+  }
+  if (body !== null) {
+    const aside = `${f}.${process.pid}.${nonce}.stale`;
+    try {
+      renameSync(f, aside);
+    } catch {
+      return null;
+    }
+    const moved = readFileSync11(aside, "utf8");
+    unlinkSync2(aside);
+    if (moved !== body) {
+      try {
+        writeFileSync3(f, moved, { flag: "wx" });
+      } catch {
+      }
+      return null;
+    }
   }
   try {
-    writeFileSync6(f, String(process.pid), { flag: "wx" });
+    writeFileSync3(f, mine, { flag: "wx" });
   } catch {
     return null;
   }
   return () => {
     try {
-      unlinkSync3(f);
+      if (readFileSync11(f, "utf8") === mine) unlinkSync2(f);
     } catch {
     }
   };
 }
+async function waitNamedLock(root, name, forMs, everyMs = 100) {
+  for (let waited = 0; ; waited += everyMs) {
+    const release = takeNamedLock(root, name);
+    if (release || waited >= forMs) return release;
+    await new Promise((r) => setTimeout(r, everyMs));
+  }
+}
 function processAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return true;
   try {
@@ -4590,7 +4950,7 @@ function processAlive(pid) {
 import { createHash as createHash4 } from "node:crypto";
 var RULESET_PII = "pii@1";
 var EMAIL = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
-var PHONE = /(?<![\w.])(?:\+\d{1,3}[ .-]?)?(?:\(\d{2,4}\)[ .-]?)?\d{2,4}(?:[ .-]?\d{2,4}){1,3}(?!\w)/g;
+var PHONE = /(?<![\w.])(?:(?<!\)[ .-]?|\+\d{1,3}[ .-]?)(\+?(?:19|20)\d{2}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01]))(?:(?= (?:[01]?\d|2[0-3]):)|(?!\w|[ .-]\d\d))|(?:\+\d{1,3}[ .-]?)?(?:\(\d{2,4}\)[ .-]?)?\d{2,4}(?:[ .-]?\d{2,4}){1,3}(?!\w))/g;
 function looksPhone(s) {
   const digits = s.replace(/\D/g, "");
   if (digits.length < 7 || digits.length > 15) return false;
@@ -4601,7 +4961,7 @@ function looksPhone(s) {
 function reducePii(text, home) {
   if (!text) return text;
   let out = text.replace(EMAIL, "[email]");
-  out = out.replace(PHONE, (m) => looksPhone(m) ? "[phone]" : m);
+  out = out.replace(PHONE, (m, date) => !date && looksPhone(m) ? "[phone]" : m);
   if (home) {
     const h = home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     out = out.replace(new RegExp(`(?<![A-Za-z0-9_])${h}(?=/|$|\\s|["'\`])`, "g"), "~");
@@ -4801,6 +5161,8 @@ var TYPE_TIER = {
   "subagent.ended": 1,
   "context.compacted": 1,
   "limits.observed": 1,
+  "delegation.started": 0,
+  "delegation.ended": 0,
   native: 3
 };
 var DATA_ALLOW = {
@@ -4811,17 +5173,19 @@ 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"] },
-  "attention.needed": { 0: ["attention_id", "kind"], 1: ["tool", "message"] },
+  "attention.needed": { 0: ["attention_id", "kind"], 1: ["tool", "message", "agent_id"] },
   "attention.cleared": { 0: ["attention_id", "how"] },
   "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",
@@ -4837,7 +5201,8 @@ var SESSION_ALLOW = [
   "account_id",
   "attended",
   "parent_id",
-  "launched_by"
+  "launched_by",
+  "delegated_by"
 ];
 var MAX_SIDE = 2e4;
 var MAX_IO = 64 * 1024;
@@ -4876,6 +5241,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) {
@@ -4902,7 +5269,7 @@ function shortId(harness, id) {
 }
 
 // src/sinks/file.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4 } from "node:fs";
 import path17 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
@@ -4917,7 +5284,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path17.dirname(this.file), { recursive: true });
+      mkdirSync4(path17.dirname(this.file), { recursive: true });
       appendFileSync2(this.file, `${events.map((e) => JSON.stringify(e)).join("\n")}
 `);
       return { ok: true, acknowledged: events.length, accepted: events.length, duplicates: 0, rejected: [] };
@@ -4955,13 +5322,16 @@ var PROTOCOL_VERSION = 1;
 export {
   ADAPTERS,
   AG_STALE_PRETOOL,
+  ASK_CHAIN_ENV,
   Cursors,
   DEFAULT_CONFIG,
+  DELEGATED_BY_ENV,
   DEVIN_EVENTS,
   FileSink,
   HELLO_HARNESSES_MAX,
   JOB_TIMEOUT_MS,
   LAUNCHED_BY_ENV,
+  LINEAGE_ENV,
   Outbox,
   PROTOCOL_VERSION,
   REDACTED,
@@ -4974,6 +5344,7 @@ export {
   antigravity,
   antigravityAnswer,
   antigravity_control_exports as antigravityControl,
+  assertConfigWritable,
   capTail,
   claudeAccounts,
   claudeCode,
@@ -4983,6 +5354,7 @@ export {
   codex,
   codex_control_exports as codexControl,
   configFile,
+  delegatedBy,
   deniedNote,
   devin,
   devinConfigDir,
@@ -5003,6 +5375,7 @@ export {
   makeEvent,
   notClaudeCode,
   pairTurns,
+  peerAsk,
   processAlive,
   readAntigravity,
   readClaude,
@@ -5025,6 +5398,8 @@ export {
   tilde,
   ulid,
   untilde,
+  waitNamedLock,
+  withoutLineage,
   writeConfig
 };
 //# sourceMappingURL=index.js.map