sessionpipe 0.7.0 → 0.9.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// sessionpipe 0.7.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe 0.9.0 · Apache-2.0 · https://sessionpipe.org
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -7,10 +7,19 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { execFileSync as execFileSync7, spawnSync as spawnSync2 } from "node:child_process";
-import { mkdtempSync, readdirSync as readdirSync8, readFileSync as readFileSync15, realpathSync as realpathSync6, rmSync as rmSync2, statSync as statSync10, unlinkSync as unlinkSync7 } from "node:fs";
+import { execFileSync as execFileSync8, spawnSync as spawnSync2 } from "node:child_process";
+import {
+  existsSync as existsSync17,
+  mkdtempSync,
+  readdirSync as readdirSync8,
+  readFileSync as readFileSync16,
+  realpathSync as realpathSync7,
+  rmSync as rmSync3,
+  statSync as statSync11,
+  unlinkSync as unlinkSync7
+} from "node:fs";
 import os11 from "node:os";
-import path27 from "node:path";
+import path29 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../core/src/adapters/antigravity.ts
@@ -29,20 +38,20 @@ import path4 from "node:path";
 // ../core/src/paths.ts
 import os from "node:os";
 import path from "node:path";
-var HOME = os.homedir();
+var homeDir = () => os.homedir();
 function configFile(env = process.env) {
   if (env.SESSIONPIPE_CONFIG) return path.resolve(env.SESSIONPIPE_CONFIG);
   if (process.platform === "win32")
-    return path.join(env.APPDATA || path.join(HOME, "AppData", "Roaming"), "sessionpipe", "config.json");
-  return path.join(env.XDG_CONFIG_HOME || path.join(HOME, ".config"), "sessionpipe", "config.json");
+    return path.join(env.APPDATA || path.join(homeDir(), "AppData", "Roaming"), "sessionpipe", "config.json");
+  return path.join(env.XDG_CONFIG_HOME || path.join(homeDir(), ".config"), "sessionpipe", "config.json");
 }
 function stateDir(env = process.env) {
   if (env.SESSIONPIPE_STATE) return path.resolve(env.SESSIONPIPE_STATE);
   if (process.platform === "win32")
-    return path.join(env.LOCALAPPDATA || path.join(HOME, "AppData", "Local"), "sessionpipe");
-  return path.join(env.XDG_STATE_HOME || path.join(HOME, ".local", "state"), "sessionpipe");
+    return path.join(env.LOCALAPPDATA || path.join(homeDir(), "AppData", "Local"), "sessionpipe");
+  return path.join(env.XDG_STATE_HOME || path.join(homeDir(), ".local", "state"), "sessionpipe");
 }
-function tilde(p, home = HOME) {
+function tilde(p, home = homeDir()) {
   if (!p) return p;
   if (p === home) return "~";
   return p.startsWith(home + path.sep) || p.startsWith(`${home}/`) ? `~${p.slice(home.length)}` : p;
@@ -139,6 +148,19 @@ function recentFiles(root, depth, sinceMs, match) {
   return out2;
 }
 
+// ../core/src/adapters/codex-rollout.ts
+function codexSubagent(meta) {
+  if (meta?.type !== "session_meta") return false;
+  const p = meta.payload;
+  return !!p?.source?.subagent;
+}
+function codexReplayBoundary(meta) {
+  if (meta?.type !== "session_meta") return void 0;
+  const p = meta.payload;
+  if (!p || !p.forked_from_id && !p.source?.subagent) return void 0;
+  return (record) => typeof p.id === "string" && !!p.id && record?.type === "event_msg" && record.payload?.thread_id === p.id;
+}
+
 // ../core/src/readers/transcripts.ts
 function pairTurns(msgs, endLine) {
   const turns = [];
@@ -161,10 +183,14 @@ ${m.text}`;
   }
   if (cur?.assistant) turns.push(cur);
   const line = cur && !cur.assistant ? cur.startLine : endLine;
-  return { turns: turns.map((t) => ({ user: t.user, assistant: t.assistant, at: t.at, endLine: t.endLine })), line };
+  const out2 = {
+    turns: turns.map((t) => ({ user: t.user, assistant: t.assistant, at: t.at, endLine: t.endLine })),
+    line
+  };
+  if (cur && !cur.assistant && cur.user) out2.open = { user: cur.user, at: cur.at };
+  return out2;
 }
-var isInjected = (text) => /^<[a-z_-]+>/i.test(text) && /<\/[a-z_-]+>\s*$/i.test(text) || /^<!--\s/.test(text) || /^<command-/.test(text);
-var endOf = (lines) => lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+var isInjected = (text) => /^<[a-z_-]+(?:\s[^>]*)?>/i.test(text) && /<\/[a-z_-]+>\s*$/i.test(text) || /^<!--\s/.test(text) || /^<command-/.test(text);
 var parse = (raw) => {
   try {
     return JSON.parse(raw);
@@ -172,6 +198,11 @@ var parse = (raw) => {
     return null;
   }
 };
+var endOf = (lines) => {
+  const last = lines[lines.length - 1];
+  if (last === void 0) return 0;
+  return last === "" || parse(last) === null ? lines.length - 1 : lines.length;
+};
 var textParts = (c, kinds) => {
   if (typeof c === "string") return c;
   if (!Array.isArray(c)) return "";
@@ -179,13 +210,21 @@ var textParts = (c, kinds) => {
     (b) => b && typeof b === "object" && kinds.includes(b.type ?? "") && typeof b.text === "string"
   ).map((b) => b.text).join("\n");
 };
+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();
+};
 function readClaude(lines, from) {
   const msgs = [];
   for (let i = from; i < lines.length; i++) {
     const j = lines[i] ? parse(lines[i]) : null;
     if (!j || j.isSidechain) continue;
     const origin = j.origin;
-    if (j.type === "user" && (j.isMeta || origin?.kind && origin.kind !== "human")) continue;
+    if (j.type === "user" && (j.isMeta || j.isCompactSummary || j.repeatsCompactSummary || origin?.kind && origin.kind !== "human"))
+      continue;
     const at = Date.parse(String(j.timestamp ?? "")) || Date.now();
     const c = j.message?.content;
     if (j.type === "user") {
@@ -195,6 +234,9 @@ function readClaude(lines, from) {
     } else if (j.type === "assistant" && Array.isArray(c)) {
       const text = textParts(c, ["text"]).trim();
       if (text) msgs.push({ role: "assistant", text, at, line: i });
+    } else if (j.type === "attachment") {
+      const text = queuedPrompt(j.attachment);
+      if (text && !isInjected(text)) msgs.push({ role: "user", text, at, line: i });
     }
   }
   return pairTurns(msgs, endOf(lines));
@@ -204,7 +246,10 @@ function codexInjected(text) {
 }
 function readCodex(lines, from) {
   const msgs = [];
-  for (let i = from; i < lines.length; i++) {
+  const boundary = codexReplayBoundary(parse(lines.find((line) => line.trim()) ?? ""));
+  const start = boundary ? lines.findIndex((line) => boundary(parse(line))) : 0;
+  if (start < 0) return pairTurns(msgs, endOf(lines));
+  for (let i = Math.max(from, start); i < lines.length; i++) {
     const j = lines[i] ? parse(lines[i]) : null;
     if (!j || j.type !== "response_item") continue;
     const p = j.payload;
@@ -242,7 +287,7 @@ function readAntigravity(lines, from) {
     const at = Date.parse(String(j.created_at ?? j.timestamp ?? "")) || Date.now();
     if (j.type === "USER_INPUT") {
       const m = /<USER_REQUEST>([\s\S]*?)(?:<\/USER_REQUEST>|$)/.exec(j.content);
-      const text = (m ? m[1] ?? "" : j.content).trim();
+      const text = (m ? m[1] : j.content).trim();
       if (text) msgs.push({ role: "user", text, at, line: i });
     } else if (j.type === "PLANNER_RESPONSE") {
       const text = j.content.trim();
@@ -290,14 +335,18 @@ function formatJson(value, f) {
   const text = JSON.stringify(value, null, f.indent).replace(/\n/g, f.eol);
   return f.finalNewline ? text + f.eol : text;
 }
-function entryFor(event, harness, cmd2, o) {
+function readJson(file) {
+  const f = readJsonFile(file);
+  return f.ok ? f.value : {};
+}
+function entryFor(event, harness, cmd, o) {
   const matcher = o.matcherFor(event);
   return {
     ...matcher !== void 0 ? { matcher } : {},
-    hooks: [{ type: "command", command: cmd2([harness, event]).command, timeout: o.timeoutFor?.(event) ?? o.timeout }]
+    hooks: [{ type: "command", command: cmd([harness, event]).command, timeout: o.timeoutFor?.(event) ?? o.timeout }]
   };
 }
-function installClaudeShaped(file, harness, events, cmd2, o) {
+function installClaudeShaped(file, harness, events, cmd, o) {
   const f = readJsonFile(file);
   if (!f.ok) return { file, changed: false, skipped: true, note: `${f.reason}; not touched` };
   const settings2 = f.value;
@@ -316,7 +365,7 @@ function installClaudeShaped(file, harness, events, cmd2, o) {
   }
   for (const ev of events) {
     const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
-    const entry2 = entryFor(ev, harness, cmd2, o);
+    const entry2 = entryFor(ev, harness, cmd, o);
     const mine = list.filter((h) => isOurs(h));
     if (mine.length === 1 && JSON.stringify(mine[0]) === JSON.stringify(entry2)) continue;
     hooks[ev] = list.filter((h) => !isOurs(h)).concat([entry2]);
@@ -359,11 +408,10 @@ function uninstallClaudeShaped(file, events, opts = {}) {
     unlinkSync(file);
     return { file, changed: true, note: "removed (sessionpipe created it)" };
   }
-  const next = formatJson(settings2, f);
-  if (next !== f.raw) writeFileSync(file, next);
+  writeFileSync(file, formatJson(settings2, f));
   return { file, changed: true };
 }
-function installedClaudeShaped(file, harness, events, cmd2, o) {
+function installedClaudeShaped(file, harness, events, cmd, o) {
   const f = readJsonFile(file);
   const hooks = f.ok ? f.value.hooks ?? {} : {};
   let present = 0;
@@ -372,7 +420,7 @@ function installedClaudeShaped(file, harness, events, cmd2, o) {
     const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
     const mine = list.filter((h) => isOurs(h));
     if (mine.length) present++;
-    if (mine.length === 1 && JSON.stringify(mine[0]) === JSON.stringify(entryFor(ev, harness, cmd2, o))) current++;
+    if (mine.length === 1 && JSON.stringify(mine[0]) === JSON.stringify(entryFor(ev, harness, cmd, o))) current++;
   }
   for (const ev of Object.keys(hooks))
     if (!events.includes(ev) && (Array.isArray(hooks[ev]) ? hooks[ev] : []).some((h) => isOurs(h)))
@@ -387,14 +435,14 @@ var HOOK_NAME = "sessionpipe";
 var AG_EVENTS = ["PreInvocation", "PostInvocation", "PostToolUse", "Stop"];
 var AG_STALE_PRETOOL = '{"decision":"ask","reason":"sessionpipe: an outdated PreToolUse hook is still loaded. Restart this conversation (or run sessionpipe install) to drop it."}\n';
 var antigravityAnswer = (event) => event === "PreToolUse" ? AG_STALE_PRETOOL : "{}\n";
-var gemini = (env) => env.GEMINI_CLI_HOME || path4.join(HOME, ".gemini");
+var gemini = (env) => env.GEMINI_CLI_HOME || path4.join(homeDir(), ".gemini");
 var hooksFile = (env) => path4.join(gemini(env), "config", "hooks.json");
 var projectsDir = (env) => path4.join(gemini(env), "config", "projects");
 var dataDirs = (env) => ["antigravity", "antigravity-cli", "antigravity-ide"].map((d) => path4.join(gemini(env), d));
 var ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 var validTool = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
-function entry(cmd2) {
-  const handler = (e) => ({ type: "command", command: cmd2([NAME, e]).command, timeout: 5 });
+function entry(cmd) {
+  const handler = (e) => ({ type: "command", command: cmd([NAME, e]).command, timeout: 5 });
   const out2 = { enabled: true };
   for (const e of AG_EVENTS) out2[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
   return out2;
@@ -404,12 +452,12 @@ var antigravity = {
   events: AG_EVENTS,
   detect: (env = process.env) => existsSync2(path4.join(gemini(env), "config")) || dataDirs(env).some((d) => existsSync2(d)),
   configFiles: (env = process.env) => [hooksFile(env)],
-  install(cmd2, env = process.env) {
+  install(cmd, env = process.env) {
     const file = hooksFile(env);
     const f = readJsonFile(file);
     if (!f.ok) return [{ file, changed: false, skipped: true, note: `${f.reason}; not touched` }];
     const hooks = f.value;
-    const e = entry(cmd2);
+    const e = entry(cmd);
     if (JSON.stringify(hooks[HOOK_NAME]) === JSON.stringify(e)) return [{ file, changed: false }];
     hooks[HOOK_NAME] = e;
     mkdirSync2(path4.dirname(file), { recursive: true });
@@ -438,14 +486,14 @@ var antigravity = {
     writeFileSync2(file, formatJson(hooks, f));
     return [{ file, changed: true }];
   },
-  installed(cmd2, env = process.env) {
+  installed(cmd, env = process.env) {
     const file = hooksFile(env);
     const f = readJsonFile(file);
     const have = f.ok ? f.value[HOOK_NAME] : void 0;
     return [
       {
         file,
-        state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd2)) ? "current" : "stale"
+        state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd)) ? "current" : "stale"
       }
     ];
   },
@@ -453,7 +501,8 @@ var antigravity = {
     const event = input.argv[1] ?? "";
     let s = {};
     try {
-      s = input.stdin ? JSON.parse(input.stdin) : {};
+      const j = input.stdin ? JSON.parse(input.stdin) : {};
+      if (j && typeof j === "object" && !Array.isArray(j)) s = j;
     } catch {
     }
     const id = s.conversationId ?? s.session_id ?? s.sessionId;
@@ -509,19 +558,16 @@ var antigravity = {
     }
     return readAntigravity(text.split("\n"), fromLine);
   },
-  facts(session, transcript, hints, state2) {
+  facts(session, transcript, hints) {
     if (!transcript) return {};
     return antigravityFacts(transcript, {
       conversation: session.id,
       workspaces: hints.workspaces ?? (session.cwd ? [session.cwd] : []),
-      state: state2,
       env: process.env
     });
   },
   backfill(sinceMs, env = process.env) {
-    const rows = [];
-    const noState = { get: () => ({}), save: () => {
-    } };
+    const rows2 = [];
     for (const data of dataDirs(env)) {
       let ids = [];
       try {
@@ -535,13 +581,13 @@ var antigravity = {
         } catch {
           continue;
         }
-        const facts = antigravityFacts(f, { conversation: id, workspaces: [], state: noState, env });
+        const facts = antigravityFacts(f, { conversation: id, workspaces: [], env });
         if (!facts.started_at || !facts.last_at) continue;
         const { started_at, last_at, first_ask: _fa, harness_version: _hv, ...rest } = facts;
-        rows.push({ session: { id, ...rest }, started_at, last_at });
+        rows2.push({ session: { id, ...rest }, started_at, last_at });
       }
     }
-    return rows;
+    return rows2;
   }
 };
 function prune(o) {
@@ -591,7 +637,7 @@ function agProjects(dir) {
     }
     const folders = [];
     for (const r of j?.projectResources?.resources ?? []) {
-      const f = agPath(r?.folderUri);
+      const f = agPath(r?.folderUri ?? r?.gitFolder?.folderUri);
       if (f) folders.push(...agVariants(f));
     }
     if (folders.length) out2.push({ id, folders });
@@ -645,7 +691,7 @@ function antigravityFacts(file, opts) {
   for (const j of H) {
     if (j.type !== "USER_INPUT" || typeof j.content !== "string") continue;
     const m = /<USER_REQUEST>([\s\S]*?)(?:<\/USER_REQUEST>|$)/.exec(j.content);
-    const text = (m ? m[1] ?? "" : j.content).trim();
+    const text = (m ? m[1] : j.content).trim();
     const line = (text.split("\n").find((l) => l.trim()) ?? "").trim();
     if (!line || /^<[a-z_-]+>/i.test(line)) continue;
     out2.title = line.length > 80 ? `${line.slice(0, 80).replace(/\s+\S*$/, "")}\u2026` : line;
@@ -744,7 +790,7 @@ function runHeadless(bin, args2, o) {
       if (o.onLine) {
         const chunk = partial + b.toString("utf8");
         const lines = chunk.split("\n");
-        partial = lines.pop() ?? "";
+        partial = lines.pop();
         for (const line of lines) {
           if (!line.trim()) continue;
           try {
@@ -893,7 +939,7 @@ function agyError(stderr) {
     for (const k of ["message", "error", "detail"]) if (typeof j[k] === "string" && j[k]) return j[k];
   } catch {
   }
-  return raw.split("\n")[0]?.slice(0, 300) ?? "";
+  return raw.split("\n")[0].slice(0, 300);
 }
 var AgyReading = class {
   session = null;
@@ -970,10 +1016,9 @@ function gitFacts(cwd) {
   return out2;
 }
 function stripCredentials(url) {
-  let u = url.replace(/\/\/[^/@]*@/, "//");
-  const ssh = /^(?:ssh:\/\/)?git@([^:/]+)[:/](.+?)(?:\.git)?$/.exec(u);
-  if (ssh) u = `${ssh[1]}/${ssh[2]}`;
-  return u.replace(/^https?:\/\//, "").replace(/\.git$/, "");
+  const ssh = /^(?:ssh:\/\/)?git@([^:/]+)[:/](.+?)(?:\.git)?$/.exec(url);
+  if (ssh) return `${ssh[1]}/${ssh[2]}`;
+  return url.replace(/\/\/[^/@]*@/, "//").replace(/^https?:\/\//, "").replace(/\.git$/, "");
 }
 
 // ../core/src/adapters/claude-code.ts
@@ -1004,7 +1049,7 @@ var OPTS = {
   timeoutFor: (e) => e === "PermissionRequest" ? 130 : void 0
 };
 var DESKTOP_ID = /^local_[A-Za-z0-9-]{1,64}$/;
-function claudeDirs(env = process.env, home = env.HOME || HOME) {
+function claudeDirs(env = process.env, home = env.HOME || homeDir()) {
   const out2 = [];
   const add = (d) => {
     if (!d) return;
@@ -1033,23 +1078,25 @@ var claudeCode = {
   events: CLAUDE_EVENTS,
   detect: (env = process.env) => claudeDirs(env).some((d) => existsSync3(d)),
   configFiles: (env = process.env) => claudeDirs(env).map(settingsIn),
-  install: (cmd2, env = process.env, opts = {}) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd2, OPTS)),
+  install: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd, OPTS)),
   uninstall: (env = process.env, opts = {}) => claudeDirs(env).map(
     (d) => uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS, { created: opts.created?.includes(settingsIn(d)) })
   ),
-  installed: (cmd2, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
+  installed: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
     file: settingsIn(d),
-    state: installedClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd2, OPTS)
+    state: installedClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd, OPTS)
   })),
   fromHook(input) {
     const event = input.argv[1] ?? "";
     let s = {};
     try {
-      s = input.stdin ? JSON.parse(input.stdin) : {};
+      const j = input.stdin ? JSON.parse(input.stdin) : {};
+      if (j && typeof j === "object" && !Array.isArray(j)) s = j;
     } catch {
     }
     const id = s.session_id ?? s.sessionId;
     if (!id) return null;
+    if (notClaudeCode(String(id), s)) return null;
     const session = { id: String(id), cwd: typeof s.cwd === "string" ? s.cwd : input.cwd };
     if (typeof s.model === "string") session.model = s.model;
     if (typeof s.agent_id === "string" && event.startsWith("Subagent") === false && s.agent_id)
@@ -1168,6 +1215,7 @@ var claudeCode = {
         return null;
     }
     const hints = {};
+    if (event === "UserPromptSubmit" && typeof s.prompt === "string") hints.prompt = s.prompt;
     const host = input.env.CLAUDE_CODE_HOST_SESSION_ID;
     if (host && DESKTOP_ID.test(host)) hints.desktop_id = host;
     if (event !== "PreToolUse" && event !== "PostToolUse") hints.claude_pid = claudePid(input.env);
@@ -1193,7 +1241,7 @@ var claudeCode = {
     return out2;
   },
   backfill(sinceMs, env = process.env) {
-    const rows = [];
+    const rows2 = [];
     const files = [];
     for (const d of claudeDirs(env))
       files.push(...recentFiles(path7.join(d, "projects"), 1, sinceMs, (n) => /^[0-9a-f-]{36}\.jsonl$/.test(n)));
@@ -1205,19 +1253,23 @@ var claudeCode = {
       if (!facts.started_at || !facts.last_at) continue;
       const { started_at, last_at, first_ask: _fa, harness_version: _hv, ...rest } = facts;
       const cwd = rest.cwd;
-      rows.push({
+      rows2.push({
         session: { id, ...rest, ...gitFacts(cwd), ...rest.branch ? { branch: rest.branch } : {} },
         started_at,
         last_at
       });
     }
-    return rows;
+    return rows2;
   }
 };
 function prune2(o) {
   for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
   return o;
 }
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function notClaudeCode(id, s) {
+  return typeof s.transcript_path !== "string" && !UUID.test(id);
+}
 function pickSource(v) {
   return typeof v === "string" && ["startup", "resume", "clear", "compact", "fork"].includes(v) ? v : "unknown";
 }
@@ -1323,26 +1375,41 @@ function parentOf() {
   }
   return (pid) => table.get(pid) || 0;
 }
-var accountCache = /* @__PURE__ */ new Map();
-function claudeAccount(dir) {
-  const hit = accountCache.get(dir);
-  if (hit !== void 0) return hit;
+var EMAIL_RE = /^[^@\s]{1,64}@[^@\s]{1,189}$/;
+function claudeLogin(dir, home = homeDir()) {
   const files = [path7.join(dir, ".claude.json")];
-  if (path7.resolve(dir) === path7.join(HOME, ".claude")) files.unshift(path7.join(HOME, ".claude.json"));
-  let acct = null;
+  if (path7.resolve(dir) === path7.join(home, ".claude")) files.unshift(path7.join(home, ".claude.json"));
   for (const f of files) {
     try {
       const a = JSON.parse(readFileSync3(f, "utf8")).oauthAccount;
-      if (a?.accountUuid) {
-        acct = String(a.accountUuid);
-        break;
+      if (typeof a?.accountUuid === "string" && a.accountUuid) {
+        const email = typeof a.emailAddress === "string" && EMAIL_RE.test(a.emailAddress) ? a.emailAddress : void 0;
+        return { id: a.accountUuid.slice(0, 128), ...email ? { email } : {} };
       }
     } catch {
     }
   }
+  return null;
+}
+var accountCache = /* @__PURE__ */ new Map();
+function claudeAccount(dir) {
+  const hit = accountCache.get(dir);
+  if (hit !== void 0) return hit;
+  const acct = claudeLogin(dir)?.id ?? null;
   accountCache.set(dir, acct);
   return acct;
 }
+function claudeAccounts(dirs, home = homeDir()) {
+  const out2 = [];
+  for (const d of dirs) {
+    const l = claudeLogin(d, home);
+    if (!l) continue;
+    const seen = out2.find((a) => a.id === l.id);
+    if (!seen) out2.push({ harness: NAME2, ...l });
+    else if (!seen.email && l.email) seen.email = l.email;
+  }
+  return out2;
+}
 var LINK_RE = /^https:\/\/claude\.ai\/code\/session_[A-Za-z0-9]+$/;
 function transcriptLink(records) {
   for (let i = records.length - 1; i >= 0; i--) {
@@ -1498,7 +1565,8 @@ var claude_code_control_exports = {};
 __export(claude_code_control_exports, {
   JOB_TIMEOUT_MS: () => JOB_TIMEOUT_MS,
   claudeEnv: () => claudeEnv,
-  claudeLogin: () => claudeLogin,
+  claudeLogin: () => claudeLogin2,
+  cmpVersion: () => cmpVersion,
   detectCaps: () => detectCaps,
   findClaude: () => findClaude,
   findTranscript: () => findTranscript,
@@ -1624,7 +1692,7 @@ function parseAuthStatus(stdout) {
     return { loggedIn: null };
   }
 }
-function claudeLogin(bin, configDir, env = process.env) {
+function claudeLogin2(bin, configDir, env = process.env) {
   return new Promise((resolve) => {
     execFile(
       bin,
@@ -1875,18 +1943,13 @@ function parseArgv(raw) {
 function readNotify(text) {
   const { head, tail: tail2, at } = split(text);
   const m = NOTIFY_LINE.exec(head);
-  if (m)
-    return {
-      raw: m[1] ?? "",
-      argv: parseArgv(m[1] ?? ""),
-      index: m.index,
-      length: m[0].length,
-      misplaced: false,
-      other: !OURS2.test(m[1] ?? "")
-    };
+  if (m) {
+    const raw = m[1];
+    return { raw, argv: parseArgv(raw), index: m.index, length: m[0].length, misplaced: false, other: !OURS2.test(raw) };
+  }
   const k = NOTIFY_KEY.exec(head);
   if (k) {
-    const rest = head.slice(k.index).split("\n")[0] ?? "";
+    const rest = head.slice(k.index).split("\n")[0];
     return {
       raw: rest.replace(NOTIFY_KEY, "").trim(),
       argv: null,
@@ -1897,15 +1960,11 @@ function readNotify(text) {
     };
   }
   const t = NOTIFY_LINE.exec(tail2);
-  if (t && OURS2.test(t[1] ?? ""))
-    return {
-      raw: t[1] ?? "",
-      argv: parseArgv(t[1] ?? ""),
-      index: at + t.index,
-      length: t[0].length,
-      misplaced: true,
-      other: false
-    };
+  if (t) {
+    const raw = t[1];
+    if (OURS2.test(raw))
+      return { raw, argv: parseArgv(raw), index: at + t.index, length: t[0].length, misplaced: true, other: false };
+  }
   return null;
 }
 function dropLine(text, index, length) {
@@ -1924,9 +1983,7 @@ function withNotify(text, line) {
   if (n?.misplaced) return insertTopLevel(dropLine(text, n.index, n.length), line);
   return insertTopLevel(text, line);
 }
-function replaceNotify(text, line) {
-  const n = readNotify(text);
-  if (!n || n.misplaced || !n.length) return null;
+function replaceNotify(text, n, line) {
   return text.slice(0, n.index) + line + text.slice(n.index + n.length);
 }
 function withoutNotify(text) {
@@ -1967,20 +2024,20 @@ var CODEX_EVENTS = [
 ];
 var OPTS2 = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
 var eventsFor2 = (lean) => lean ? CODEX_EVENTS.filter((e) => e !== "PreToolUse") : [...CODEX_EVENTS];
-var codexHome = (env) => env.CODEX_HOME || path9.join(HOME, ".codex");
+var codexHome = (env) => env.CODEX_HOME || path9.join(homeDir(), ".codex");
 var hooksFile2 = (env) => path9.join(codexHome(env), "hooks.json");
 var configFile2 = (env) => path9.join(codexHome(env), "config.toml");
 var sessionsDir = (env) => path9.join(codexHome(env), "sessions");
 var 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(cmd2, env) {
+function installNotify(cmd, env) {
   const file = configFile2(env);
   let text = "";
   try {
     text = readFileSync5(file, "utf8");
   } catch {
   }
-  const argv = cmd2([NAME3, "notify"]).argv;
+  const argv = cmd([NAME3, "notify"]).argv;
   const line = `notify = ${JSON.stringify(argv)}`;
   const n = readNotify(text);
   const write = (next) => {
@@ -2005,11 +2062,8 @@ function installNotify(cmd2, env) {
           return { file, changed: false, note: "notify current (after Codex Computer Use)" };
       }
       if (!prev || OURS2.test(JSON.stringify(prev))) {
-        const next = replaceNotify(text, `notify = ${withPreviousRaw(n.raw, argv)}`);
-        if (next) {
-          write(next);
-          return { file, changed: true, note: "chained after Codex Computer Use (--previous-notify)" };
-        }
+        write(replaceNotify(text, n, `notify = ${withPreviousRaw(n.raw, argv)}`));
+        return { file, changed: true, note: "chained after Codex Computer Use (--previous-notify)" };
       }
     }
     return {
@@ -2038,8 +2092,7 @@ function uninstallNotify(env) {
   }
   const prev = previousNotify(n.argv);
   if (isComputerUse(n.argv) && prev && OURS2.test(JSON.stringify(prev))) {
-    const next = replaceNotify(text, `notify = ${stripPreviousRaw(n.raw)}`);
-    if (next) writeFileSync3(file, next);
+    writeFileSync3(file, replaceNotify(text, n, `notify = ${stripPreviousRaw(n.raw)}`));
     return { file, changed: true };
   }
   return { file, changed: false };
@@ -2069,24 +2122,31 @@ function findRollout(threadId, env = process.env) {
   walk(sessionsDir(env), 0);
   return best;
 }
+function rolloutMeta(file) {
+  return scanLines(file, (line) => parseLines([line])[0] ?? {});
+}
+function ofAnotherThread(file, id) {
+  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();
+}
 var codex = {
   name: NAME3,
   events: CODEX_EVENTS,
   detect: (env = process.env) => existsSync4(codexHome(env)),
   configFiles: (env = process.env) => [hooksFile2(env), configFile2(env)],
-  install: (cmd2, env = process.env, opts = {}) => [
-    installClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd2, OPTS2),
-    installNotify(cmd2, env)
+  install: (cmd, env = process.env, opts = {}) => [
+    installClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd, OPTS2),
+    installNotify(cmd, env)
   ],
   uninstall: (env = process.env, opts = {}) => [
     uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS, { created: opts.created?.includes(hooksFile2(env)) }),
     uninstallNotify(env)
   ],
-  installed: (cmd2, env = process.env, opts = {}) => {
+  installed: (cmd, env = process.env, opts = {}) => {
     const out2 = [
       {
         file: hooksFile2(env),
-        state: installedClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd2, OPTS2),
+        state: installedClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd, OPTS2),
         note: "Codex runs non-managed hooks only after the review in `codex` (/hooks); until then nothing is reported unless the notify fallback is ours"
       }
     ];
@@ -2096,7 +2156,7 @@ var codex = {
     } catch {
     }
     const n = readNotify(text);
-    const argv = cmd2([NAME3, "notify"]).argv;
+    const argv = cmd([NAME3, "notify"]).argv;
     const prev = n ? previousNotify(n.argv) : null;
     const ours = n && (!n.other || prev && JSON.stringify(prev) === JSON.stringify(argv));
     out2.push({
@@ -2111,11 +2171,14 @@ var codex = {
     if (event === "notify") {
       const raw = input.argv.find((a) => a.startsWith("{")) ?? input.stdin;
       try {
-        s = raw ? JSON.parse(raw) : {};
+        const j = raw ? JSON.parse(raw) : {};
+        if (j && typeof j === "object" && !Array.isArray(j)) s = j;
       } catch {
       }
       const id2 = s["thread-id"] ?? s.thread_id ?? s["session-id"] ?? s.session_id;
       if (!id2) return null;
+      const file = findRollout(String(id2), input.env);
+      if (!file || codexSubagent(rolloutMeta(file))) return null;
       const r2 = {
         session: { id: String(id2), cwd: typeof s.cwd === "string" ? s.cwd : input.cwd },
         events: [
@@ -2125,18 +2188,19 @@ var codex = {
             harnessEvent: "notify"
           }
         ],
-        hints: {}
+        hints: {},
+        transcript: file
       };
-      const file = findRollout(String(id2), input.env);
-      if (file) r2.transcript = file;
       return r2;
     }
     try {
-      s = input.stdin ? JSON.parse(input.stdin) : {};
+      const j = input.stdin ? JSON.parse(input.stdin) : {};
+      if (j && typeof j === "object" && !Array.isArray(j)) s = j;
     } catch {
     }
     const id = s.session_id;
     if (!id) return null;
+    if (s.transcript_path === null) return null;
     const session = { id: String(id), cwd: typeof s.cwd === "string" ? s.cwd : input.cwd };
     if (typeof s.model === "string") session.model = s.model;
     const turn_id = typeof s.turn_id === "string" ? s.turn_id : void 0;
@@ -2208,7 +2272,8 @@ var codex = {
         return null;
     }
     const r = { session, events, hints: {} };
-    if (typeof s.transcript_path === "string") r.transcript = s.transcript_path;
+    if (typeof s.transcript_path === "string" && !ofAnotherThread(s.transcript_path, String(id)))
+      r.transcript = s.transcript_path;
     return r;
   },
   readTranscript(file, fromLine) {
@@ -2226,16 +2291,17 @@ var codex = {
     return out2;
   },
   backfill(sinceMs, env = process.env) {
-    const rows = [];
+    const rows2 = [];
     for (const f of recentFiles(sessionsDir(env), 3, sinceMs, (n) => /^rollout-.*\.jsonl$/.test(n))) {
       const m = /([0-9a-f]{8}-[0-9a-f-]{27,})\.jsonl$/i.exec(path9.basename(f));
       if (!m?.[1]) continue;
+      if (codexSubagent(rolloutMeta(f))) continue;
       const facts = codexFacts(f);
       if (!facts.started_at || !facts.last_at) continue;
       const { started_at, last_at, first_ask: _fa, harness_version: _hv, ...rest } = facts;
-      rows.push({ session: { id: m[1], ...rest }, started_at, last_at });
+      rows2.push({ session: { id: m[1], ...rest }, started_at, last_at });
     }
-    return rows;
+    return rows2;
   }
 };
 function prune3(o) {
@@ -2244,10 +2310,11 @@ function prune3(o) {
 }
 function codexFacts(file) {
   const { head, tail: tail2 } = ends(file, 128 * 1024, 64 * 1024);
-  const H = parseLines(head);
-  const T = parseLines(tail2);
+  let H = parseLines(head);
+  let T = parseLines(tail2);
   const out2 = {};
   const meta = H.find((j) => j.type === "session_meta" && j.payload);
+  const boundary = codexReplayBoundary(meta);
   if (meta?.payload) {
     const p = meta.payload;
     if (p.cwd) out2.cwd = p.cwd;
@@ -2255,6 +2322,13 @@ function codexFacts(file) {
     if (p.git?.branch) out2.branch = p.git.branch;
     if (p.git?.repository_url) out2.repo = String(p.git.repository_url).replace(/\/\/[^/@]*@/, "//");
   }
+  if (boundary) {
+    const h = H.findIndex(boundary);
+    const t = T.findIndex(boundary);
+    H = h < 0 ? [] : H.slice(h);
+    const found = h >= 0 || t >= 0 || scanLines(file, (line) => boundary(parseLines([line])[0] ?? null) ? true : null, Number.POSITIVE_INFINITY);
+    T = t >= 0 ? T.slice(t) : found ? T : [];
+  }
   const ctx = H.concat(T).reverse().find((j) => j.type === "turn_context" && j.payload?.model);
   if (ctx?.payload?.model) out2.model = ctx.payload.model;
   for (const j of H) {
@@ -2262,12 +2336,12 @@ function codexFacts(file) {
     if (j.type !== "response_item" || !p || p.type !== "message" || p.role !== "user") continue;
     const text = (p.content ?? []).filter((b) => b && b.type === "input_text" && typeof b.text === "string").map((b) => b.text).join("\n").trim();
     if (!text || codexInjected(text)) continue;
-    const line = text.split("\n").find((l) => l.trim()) ?? "";
+    const line = text.split("\n")[0];
     out2.title = line.length > 80 ? `${line.slice(0, 80).replace(/\s+\S*$/, "")}\u2026` : line;
     out2.title_source = "first-ask";
     break;
   }
-  const times = H.concat(T).map((j) => Date.parse(String(j.timestamp ?? ""))).filter((n) => n > 0);
+  const times = (boundary && meta ? [meta, ...H, ...T] : H.concat(T)).map((j) => Date.parse(String(j.timestamp ?? ""))).filter((n) => n > 0);
   if (times.length) {
     out2.started_at = Math.min(...times);
     out2.last_at = Math.max(...times);
@@ -2409,11 +2483,432 @@ function codexStderr(stderr) {
 }
 var reading2 = () => new CodexReading();
 
-// ../core/src/adapters/gemini-cli.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "node:fs";
+// ../core/src/adapters/devin.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync6, readlinkSync } from "node:fs";
 import path11 from "node:path";
-var NAME4 = "gemini-cli";
+
+// ../core/src/readers/sqlite.ts
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { existsSync as existsSync5 } from "node:fs";
+import { createRequire } from "node:module";
+function quiet(fn) {
+  const original = process.emitWarning;
+  try {
+    process.emitWarning = ((warning, ...rest) => {
+      const kind = typeof rest[0] === "string" ? rest[0] : rest[0]?.type;
+      if (kind === "ExperimentalWarning" && /sqlite/i.test(String(warning))) return;
+      original.call(process, warning, ...rest);
+    });
+    return fn();
+  } finally {
+    process.emitWarning = original;
+  }
+}
+var ctorCache;
+function dbCtor() {
+  if (ctorCache !== void 0) return ctorCache;
+  ctorCache = null;
+  try {
+    const req = createRequire(import.meta.url);
+    const m = quiet(() => req("node:sqlite"));
+    if (typeof m?.DatabaseSync === "function") ctorCache = m.DatabaseSync;
+  } catch {
+  }
+  return ctorCache;
+}
+function plain(row) {
+  if (!row || typeof row !== "object") return null;
+  const out2 = {};
+  for (const [k, v] of Object.entries(row)) {
+    if (typeof v === "bigint") out2[k] = Number(v);
+    else if (v instanceof Uint8Array) out2[k] = null;
+    else out2[k] = v;
+  }
+  return out2;
+}
+var rows = (v) => {
+  if (!Array.isArray(v)) return null;
+  const out2 = [];
+  for (const r of v) {
+    const p = plain(r);
+    if (p) out2.push(p);
+  }
+  return out2;
+};
+function viaNode(file, sql, params, o) {
+  const C = dbCtor();
+  if (!C) return null;
+  let db;
+  try {
+    db = quiet(() => new C(file, { readOnly: true, timeout: o.timeoutMs }));
+  } catch {
+    return null;
+  }
+  try {
+    try {
+      db.exec(`PRAGMA busy_timeout = ${Math.round(o.timeoutMs)}`);
+    } catch {
+    }
+    return quiet(() => rows(db.prepare(sql).all(...params)));
+  } catch {
+    return null;
+  } finally {
+    try {
+      db.close();
+    } catch {
+    }
+  }
+}
+var CHILD = `const { DatabaseSync } = require("node:sqlite");
+const [, file, sql, params, ms] = process.argv;
+const db = new DatabaseSync(file, { readOnly: true, timeout: Number(ms) });
+try { db.exec("PRAGMA busy_timeout = " + Number(ms)); } catch {}
+const out = db.prepare(sql).all(...JSON.parse(params));
+db.close();
+process.stdout.write(JSON.stringify(out));`;
+function viaChild(file, sql, params, o) {
+  try {
+    const out2 = execFileSync4(
+      process.execPath,
+      ["--experimental-sqlite", "--no-warnings", "-e", CHILD, file, sql, JSON.stringify(params), String(o.timeoutMs)],
+      {
+        encoding: "utf8",
+        timeout: o.timeoutMs + 3e3,
+        stdio: ["ignore", "pipe", "ignore"],
+        maxBuffer: o.maxBuffer,
+        windowsHide: true
+      }
+    );
+    return rows(JSON.parse(out2 || "null"));
+  } catch {
+    return null;
+  }
+}
+var SAFE = /^[A-Za-z0-9 ._:@/+-]{0,256}$/;
+function inlineParams(sql, params) {
+  if (sql.includes("'")) return null;
+  const holes = sql.split("?").length - 1;
+  if (holes !== params.length) return null;
+  let i = 0;
+  let bad2 = false;
+  const out2 = sql.replace(/\?/g, () => {
+    const p = params[i++];
+    if (typeof p === "number") {
+      if (!Number.isFinite(p)) {
+        bad2 = true;
+        return "NULL";
+      }
+      return String(p);
+    }
+    if (typeof p !== "string" || !SAFE.test(p)) {
+      bad2 = true;
+      return "NULL";
+    }
+    return `'${p}'`;
+  });
+  return bad2 ? null : out2;
+}
+function viaCli(file, sql, params, o) {
+  const text = inlineParams(sql, params);
+  if (!text) return null;
+  try {
+    const out2 = execFileSync4("sqlite3", ["-readonly", "-json", file, text], {
+      encoding: "utf8",
+      timeout: o.timeoutMs + 3e3,
+      stdio: ["ignore", "pipe", "ignore"],
+      maxBuffer: o.maxBuffer,
+      windowsHide: true
+    }).trim();
+    if (!out2) return [];
+    return rows(JSON.parse(out2));
+  } catch {
+    return null;
+  }
+}
+function querySqlite(file, sql, params = [], opts = {}) {
+  const o = {
+    timeoutMs: opts.timeoutMs ?? 2e3,
+    engine: opts.engine ?? "auto",
+    maxBuffer: opts.maxBuffer ?? 32 * 1024 * 1024
+  };
+  if (!file) return null;
+  try {
+    if (!existsSync5(file)) return null;
+  } catch {
+    return null;
+  }
+  const ways = o.engine === "auto" ? [viaNode, viaChild, viaCli] : o.engine === "node" ? [viaNode] : o.engine === "child" ? [viaChild] : [viaCli];
+  for (const way of ways) {
+    const r = way(file, sql, params, o);
+    if (r) return r;
+  }
+  return null;
+}
+
+// ../core/src/adapters/devin.ts
+var NAME4 = "devin";
+var DEVIN_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PermissionRequest",
+  "Stop",
+  "PostCompaction",
+  "SessionEnd"
+];
+var OPTS3 = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
+var eventsFor3 = (lean) => lean ? DEVIN_EVENTS.filter((e) => e !== "PreToolUse") : [...DEVIN_EVENTS];
+var INSTALL_NOTE = "Devin drops a whole hooks file on one event name it doesn't know; `/hooks` in `devin` lists what loaded";
+var CLAUDE_NOTE = "Devin also reads ~/.claude/settings.json hooks (read_config_from.claude); a Claude-only event name there makes it ignore that file whole";
+var deadFileNote = (bad2) => `Devin loads NO hooks from this file: "${bad2}" is not one of its event names and it rejects the file whole \u2014 remove that key (\`/hooks\` in \`devin\` lists what loaded)`;
+function foreignEvent(file) {
+  const hooks = readJson(file).hooks;
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) return void 0;
+  const ok = DEVIN_EVENTS;
+  return Object.keys(hooks).find((k) => !ok.includes(k));
+}
+var homeOf = (env) => env.HOME || homeDir();
+var appData = (env) => env.APPDATA || path11.join(homeOf(env), "AppData", "Roaming");
+var devinConfigDir = (env = process.env) => process.platform === "win32" ? path11.join(appData(env), "devin") : path11.join(env.XDG_CONFIG_HOME || path11.join(homeOf(env), ".config"), "devin");
+var configFile3 = (env) => path11.join(devinConfigDir(env), "config.json");
+var devinDataDir = (env = process.env) => process.platform === "win32" ? path11.join(appData(env), "devin", "cli") : path11.join(env.XDG_DATA_HOME || path11.join(homeOf(env), ".local", "share"), "devin", "cli");
+var sessionsDb = (env) => path11.join(devinDataDir(env), "sessions.db");
+var 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";
+var pickSource2 = (v) => typeof v === "string" && ["startup", "resume", "clear", "compact", "fork"].includes(v) ? v : "unknown";
+function errText2(v) {
+  if (typeof v === "string" && v) return v.slice(0, 2e3);
+  if (v && typeof v === "object") {
+    const e = v;
+    if (typeof e.message === "string" && e.message) return e.message.slice(0, 2e3);
+    if (typeof e.error === "string" && e.error) return e.error.slice(0, 2e3);
+  }
+  return void 0;
+}
+var cut = (s, n) => s.length > n ? `${s.slice(0, n).replace(/\s+\S*$/, "")}\u2026` : s;
+var devin = {
+  name: NAME4,
+  events: DEVIN_EVENTS,
+  detect: (env = process.env) => existsSync6(devinConfigDir(env)) || existsSync6(devinDataDir(env)),
+  configFiles: (env = process.env) => [configFile3(env)],
+  install: (cmd, env = process.env, opts = {}) => {
+    const file = configFile3(env);
+    const r = installClaudeShaped(file, NAME4, eventsFor3(opts.lean), cmd, OPTS3);
+    if (r.skipped) return [r];
+    const bad2 = foreignEvent(file);
+    return [{ ...r, note: bad2 ? deadFileNote(bad2) : INSTALL_NOTE }];
+  },
+  uninstall: (env = process.env, opts = {}) => [
+    uninstallClaudeShaped(configFile3(env), DEVIN_EVENTS, { created: opts.created?.includes(configFile3(env)) })
+  ],
+  installed: (cmd, env = process.env, opts = {}) => {
+    const file = configFile3(env);
+    const state2 = installedClaudeShaped(file, NAME4, eventsFor3(opts.lean), cmd, OPTS3);
+    const bad2 = state2 === "missing" ? void 0 : foreignEvent(file);
+    return [{ file, state: bad2 ? "inactive" : state2, note: bad2 ? deadFileNote(bad2) : CLAUDE_NOTE }];
+  },
+  fromHook(input) {
+    const event = input.argv[1] ?? "";
+    let s = {};
+    try {
+      const j = input.stdin ? JSON.parse(input.stdin) : {};
+      if (j && typeof j === "object" && !Array.isArray(j)) s = j;
+    } catch {
+    }
+    const id = typeof s.session_id === "string" ? s.session_id : "";
+    if (!id) return null;
+    const session = { id, cwd: input.env.DEVIN_PROJECT_DIR ?? input.cwd };
+    const turn_id = typeof s.prompt_id === "string" ? s.prompt_id : void 0;
+    const tool = validTool4(s.tool_name) ? s.tool_name : void 0;
+    const call_id = typeof s.tool_use_id === "string" ? s.tool_use_id : void 0;
+    const response = s.tool_response && typeof s.tool_response === "object" && !Array.isArray(s.tool_response) ? s.tool_response : void 0;
+    const permissionId = () => `perm-${createHash2("sha256").update(`${turn_id ?? ""}|${tool ?? ""}|${JSON.stringify(s.tool_input ?? null)}`).digest("hex").slice(0, 16)}`;
+    const ev = (type, data) => ({ type, data: prune4(data), harnessEvent: event });
+    const events = [];
+    switch (event) {
+      case "SessionStart":
+        events.push(ev("session.started", { source: pickSource2(s.source) }));
+        break;
+      case "UserPromptSubmit":
+        events.push(
+          ev("turn.started", {
+            turn_id,
+            prompt_chars: typeof s.prompt === "string" ? [...s.prompt].length : void 0
+          })
+        );
+        break;
+      case "PreToolUse":
+        if (tool) events.push(ev("tool.started", { tool, call_id, turn_id, input: s.tool_input }));
+        break;
+      case "PostToolUse":
+        if (tool)
+          events.push(
+            ev("tool.ended", {
+              tool,
+              call_id,
+              turn_id,
+              // `ok` is required on tool.ended (PROTOCOL.md §events), so a response
+              // that carries no success flag at all reads as "nothing said it failed".
+              ok: response?.success !== false,
+              error: errText2(response?.error),
+              input: s.tool_input,
+              output: response ? response.output : s.tool_response
+            })
+          );
+        break;
+      case "PermissionRequest":
+        events.push(ev("attention.needed", { attention_id: call_id ?? permissionId(), kind: "permission", tool }));
+        break;
+      case "Stop":
+        events.push(ev("turn.ended", { turn_id, reason: "stop" }));
+        break;
+      case "PostCompaction":
+        events.push(ev("context.compacted", { trigger: "auto" }));
+        break;
+      case "SessionEnd":
+        events.push(ev("session.ended", { reason: endReason3(s.reason) }));
+        break;
+      default:
+        return null;
+    }
+    return {
+      session,
+      events,
+      hints: {},
+      transcript: transcriptRef(sessionsDb(input.env), id)
+    };
+  },
+  readTranscript(file, fromLine) {
+    const ref = splitRef(file);
+    if (!ref) return { turns: [], line: fromLine };
+    return readDevinChain(ref.db, ref.session, fromLine);
+  },
+  facts(session, transcript, _hints, _state, env = process.env) {
+    const out2 = {};
+    const version = devinVersion(env);
+    if (version) out2.harness_version = version;
+    const account = devinAccount(env);
+    if (account) out2.account_id = account;
+    const ref = splitRef(transcript) ?? { db: sessionsDb(env), session: session.id };
+    if (!SESSION_ID.test(ref.session)) return out2;
+    const rows2 = querySqlite(ref.db, SESSION_SQL, [ref.session]);
+    const row = rows2?.[0];
+    if (!row) return out2;
+    Object.assign(out2, sessionFacts(row));
+    return out2;
+  },
+  backfill(sinceMs, env = process.env) {
+    const rows2 = querySqlite(sessionsDb(env), BACKFILL_SQL, ["text", Math.floor(sinceMs / 1e3)]);
+    if (!rows2) return [];
+    const out2 = [];
+    for (const row of rows2) {
+      const id = String(row.id);
+      if (!SESSION_ID.test(id)) continue;
+      const { started_at, last_at, ...rest } = sessionFacts(row);
+      if (!started_at || !last_at) continue;
+      out2.push({ session: { id, ...rest }, started_at, last_at });
+    }
+    return out2;
+  }
+};
+function prune4(o) {
+  for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
+  return o;
+}
+var transcriptRef = (db, session) => `${db}#${session}`;
+function splitRef(ref) {
+  if (!ref) return null;
+  const at = ref.lastIndexOf("#");
+  if (at <= 0) return null;
+  const db = ref.slice(0, at);
+  const session = ref.slice(at + 1);
+  return db && SESSION_ID.test(session) ? { db, session } : null;
+}
+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
+  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 >= ?
+)
+SELECT node_id, chat_message, created_at FROM chain ORDER BY node_id DESC LIMIT ${CHAIN_LIMIT}`;
+var SESSION_FIELDS = `s.model, s.working_directory, s.created_at, s.last_activity_at,
+       (SELECT p.content FROM prompt_history p WHERE p.session_id = s.id AND p.is_shell = 0
+         ORDER BY p.timestamp ASC, p.id ASC LIMIT 1) AS first_ask`;
+var SESSION_SQL = `SELECT ${SESSION_FIELDS} FROM sessions s WHERE s.id = ? LIMIT 1`;
+var BACKFILL_SQL = `SELECT s.id, ${SESSION_FIELDS} FROM sessions s
+ WHERE s.hidden = 0 AND typeof(s.id) = ? AND s.last_activity_at >= ?
+ ORDER BY s.last_activity_at DESC LIMIT 500`;
+function sessionFacts(row) {
+  const out2 = {};
+  if (typeof row.model === "string" && row.model) out2.model = row.model;
+  if (typeof row.working_directory === "string" && path11.isAbsolute(row.working_directory))
+    out2.cwd = row.working_directory;
+  const started = Number(row.created_at);
+  const last = Number(row.last_activity_at);
+  if (Number.isFinite(started) && started > 0) out2.started_at = Math.round(started * 1e3);
+  if (Number.isFinite(last) && last > 0) out2.last_at = Math.round(last * 1e3);
+  if (typeof row.first_ask === "string") {
+    const line = row.first_ask.split("\n").find((l) => l.trim()) ?? "";
+    if (line.trim()) {
+      out2.title = cut(line.trim(), 80);
+      out2.title_source = "first-ask";
+    }
+  }
+  return out2;
+}
+function readDevinChain(db, session, fromLine) {
+  if (!SESSION_ID.test(session)) return { turns: [], line: fromLine };
+  const floor = Number.isFinite(fromLine) && fromLine > 0 ? Math.floor(fromLine) : 0;
+  const rows2 = querySqlite(db, CHAIN_SQL, [session, session, session, floor]);
+  if (!rows2?.length) return { turns: [], line: fromLine };
+  const msgs = [];
+  let end = fromLine;
+  for (const row of rows2) {
+    const node = Number(row.node_id);
+    if (!Number.isFinite(node)) continue;
+    if (node + 1 > end) end = node + 1;
+    if (node < fromLine) continue;
+    let j;
+    try {
+      j = JSON.parse(String(row.chat_message ?? ""));
+    } catch {
+      continue;
+    }
+    const text = typeof j.content === "string" ? j.content.trim() : "";
+    if (!text) continue;
+    const secs = Number(row.created_at);
+    const at = Date.parse(String(j.metadata?.created_at ?? "")) || (Number.isFinite(secs) && secs > 0 ? Math.round(secs * 1e3) : 0) || Date.now();
+    if (j.role === "user" && j.metadata?.is_user_input === true) msgs.push({ role: "user", text, at, line: node });
+    else if (j.role === "assistant") msgs.push({ role: "assistant", text, at, line: node });
+  }
+  msgs.sort((a, b) => a.line - b.line);
+  return pairTurns(msgs, end);
+}
+function devinVersion(env = process.env) {
+  try {
+    const target = readlinkSync(path11.join(devinDataDir(env), "_versions", "current"));
+    const name = path11.basename(target);
+    return /^[0-9][0-9A-Za-z.+-]{0,63}$/.test(name) ? name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function devinAccount(env = process.env) {
+  const d = readJson(configFile3(env)).devin;
+  const id = d && typeof d === "object" ? d.org_id : void 0;
+  return typeof id === "string" && /^[A-Za-z0-9_.:-]{1,128}$/.test(id) ? id : void 0;
+}
+
+// ../core/src/adapters/gemini-cli.ts
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import path12 from "node:path";
+var NAME5 = "gemini-cli";
 var GEMINI_EVENTS = [
   "SessionStart",
   "BeforeAgent",
@@ -2424,11 +2919,11 @@ var GEMINI_EVENTS = [
   "PreCompress",
   "SessionEnd"
 ];
-var OPTS3 = { matcherFor: (e) => /Tool/.test(e) ? ".*" : void 0, timeout: 5e3 };
-var geminiDir = (env) => env.GEMINI_CLI_HOME || path11.join(HOME, ".gemini");
-var settings = (env) => path11.join(geminiDir(env), "settings.json");
-var validTool4 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
-var eventsFor3 = (lean) => lean ? GEMINI_EVENTS.filter((e) => e !== "BeforeTool") : [...GEMINI_EVENTS];
+var OPTS4 = { matcherFor: (e) => /Tool/.test(e) ? ".*" : void 0, timeout: 5e3 };
+var geminiDir = (env) => env.GEMINI_CLI_HOME || path12.join(homeDir(), ".gemini");
+var settings = (env) => path12.join(geminiDir(env), "settings.json");
+var validTool5 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
+var eventsFor4 = (lean) => lean ? GEMINI_EVENTS.filter((e) => e !== "BeforeTool") : [...GEMINI_EVENTS];
 function geminiHooksActive(settingsFile) {
   let tools;
   try {
@@ -2440,7 +2935,7 @@ function geminiHooksActive(settingsFile) {
     return { active: false, note: "inactive: tools.enableHooks is false in settings.json" };
   let version = "";
   try {
-    version = execFileSync4("gemini", ["--version"], {
+    version = execFileSync5("gemini", ["--version"], {
       encoding: "utf8",
       timeout: 4e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -2459,21 +2954,21 @@ function geminiHooksActive(settingsFile) {
   };
 }
 var geminiCli = {
-  name: NAME4,
+  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) => existsSync5(settings(env)) || existsSync5(path11.join(geminiDir(env), "tmp")),
+  detect: (env = process.env) => existsSync7(settings(env)) || existsSync7(path12.join(geminiDir(env), "tmp")),
   configFiles: (env = process.env) => [settings(env)],
-  install: (cmd2, env = process.env, opts = {}) => {
-    const r = installClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd2, OPTS3);
+  install: (cmd, env = process.env, opts = {}) => {
+    const r = installClaudeShaped(settings(env), NAME5, eventsFor4(opts.lean), cmd, OPTS4);
     const a = geminiHooksActive(settings(env));
     return [a.note && !r.skipped ? { ...r, note: [r.note, a.note].filter(Boolean).join("; ") } : r];
   },
   uninstall: (env = process.env, opts = {}) => [
     uninstallClaudeShaped(settings(env), GEMINI_EVENTS, { created: opts.created?.includes(settings(env)) })
   ],
-  installed: (cmd2, env = process.env, opts = {}) => {
-    const state2 = installedClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd2, OPTS3);
+  installed: (cmd, env = process.env, opts = {}) => {
+    const state2 = installedClaudeShaped(settings(env), NAME5, eventsFor4(opts.lean), cmd, OPTS4);
     const a = geminiHooksActive(settings(env));
     return [
       {
@@ -2487,14 +2982,15 @@ var geminiCli = {
     const event = input.argv[1] ?? "";
     let s = {};
     try {
-      s = input.stdin ? JSON.parse(input.stdin) : {};
+      const j = input.stdin ? JSON.parse(input.stdin) : {};
+      if (j && typeof j === "object" && !Array.isArray(j)) s = j;
     } catch {
     }
     const id = s.session_id;
     if (!id) return null;
     const session = { id: String(id), cwd: typeof s.cwd === "string" ? s.cwd : input.cwd };
-    const tool = validTool4(s.tool_name) ? s.tool_name : void 0;
-    const ev = (type, data) => ({ type, data: prune4(data), harnessEvent: event });
+    const tool = validTool5(s.tool_name) ? s.tool_name : void 0;
+    const ev = (type, data) => ({ type, data: prune5(data), harnessEvent: event });
     const events = [];
     switch (event) {
       case "SessionStart":
@@ -2575,7 +3071,7 @@ var geminiCli = {
     const raw = first ? first.content ?? first.message ?? first.text : void 0;
     const text = typeof raw === "string" ? raw.trim() : "";
     if (text) {
-      const line = text.split("\n").find((l) => l.trim()) ?? "";
+      const line = text.split("\n")[0];
       out2.title = line.length > 80 ? `${line.slice(0, 80).replace(/\s+\S*$/, "")}\u2026` : line;
       out2.title_source = "first-ask";
     }
@@ -2589,13 +3085,13 @@ var geminiCli = {
   backfill: () => []
   // chat logs are keyed by a project hash, not a session id we can name; the first hook of a resumed session reports it
 };
-function prune4(o) {
+function prune5(o) {
   for (const k of Object.keys(o)) if (o[k] === void 0) delete o[k];
   return o;
 }
 
 // ../core/src/adapters/index.ts
-var ADAPTERS = [claudeCode, codex, geminiCli, antigravity];
+var ADAPTERS = [claudeCode, codex, geminiCli, antigravity, devin];
 var adapterByName = (name) => ADAPTERS.find((a) => a.name === name);
 function drivableHarnesses(env = process.env) {
   return [
@@ -2606,8 +3102,8 @@ function drivableHarnesses(env = process.env) {
 }
 
 // ../core/src/config.ts
-import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import path12 from "node:path";
+import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import path13 from "node:path";
 var DEFAULT_CONFIG = { sinks: [], harnesses: {}, update_check: true, keep_days: 30 };
 function readConfig(file = configFile()) {
   try {
@@ -2623,10 +3119,10 @@ function readConfig(file = configFile()) {
   }
 }
 function writeConfig(c, file = configFile()) {
-  mkdirSync4(path12.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync4(path13.dirname(file), { recursive: true, mode: 448 });
   writeFileSync4(file, `${JSON.stringify(c, null, 2)}
 `, { mode: 384 });
-  if (process.platform !== "win32" && existsSync6(file)) {
+  if (process.platform !== "win32" && existsSync8(file)) {
     try {
       chmodSync(file, 384);
     } catch {
@@ -2655,7 +3151,7 @@ function encodeTime(t) {
 function ulid(now = Date.now()) {
   if (now === lastTime) {
     for (let i = lastRand.length - 1; i >= 0; i--) {
-      const v = (lastRand[i] ?? 0) + 1;
+      const v = lastRand[i] + 1;
       if (v < 32) {
         lastRand[i] = v;
         break;
@@ -2664,8 +3160,7 @@ function ulid(now = Date.now()) {
     }
   } else {
     lastTime = now;
-    const b = randomBytes(16);
-    lastRand = Array.from({ length: 16 }, (_, i) => (b[i] ?? 0) % 32);
+    lastRand = Array.from(randomBytes(16), (b) => b % 32);
   }
   return encodeTime(now) + lastRand.map((v) => ALPHABET[v]).join("");
 }
@@ -2692,7 +3187,7 @@ function makeEvent(a, ctx) {
 import {
   appendFileSync,
   closeSync as closeSync3,
-  existsSync as existsSync7,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync5,
   openSync as openSync3,
   readdirSync as readdirSync6,
@@ -2703,42 +3198,45 @@ import {
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
+var READ_CHUNK = 1024 * 1024;
+var READ_MAX = 8 * 1024 * 1024;
 var Outbox = class {
   constructor(root) {
     this.root = root;
   }
   root;
   dir(harness) {
-    return path13.join(this.root, "outbox", safeId(harness));
+    return path14.join(this.root, "outbox", safeId(harness));
   }
   file(ref) {
-    return path13.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
+    return path14.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
   }
   seqFile(ref) {
-    return path13.join(this.dir(ref.harness), `${safeId(ref.session)}.seq`);
+    return path14.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). */
   nextSeq(ref) {
     const f = this.seqFile(ref);
-    let n = 0;
+    let n = -1;
     try {
-      n = Number(readFileSync8(f, "utf8")) || 0;
+      const t = readFileSync8(f, "utf8").trim();
+      if (/^\d+$/.test(t)) n = Number(t);
     } catch {
-      n = this.lastSeqInFile(ref) + 1;
     }
-    mkdirSync5(path13.dirname(f), { recursive: true, mode: 448 });
+    if (n < 0) n = this.lastSeqInFile(ref) + 1;
+    mkdirSync5(path14.dirname(f), { recursive: true, mode: 448 });
     writeFileSync5(f, String(n + 1), { mode: 384 });
     return n;
   }
   lastSeqInFile(ref) {
     const f = this.file(ref);
-    if (!existsSync7(f)) return -1;
+    if (!existsSync9(f)) return -1;
     const lines = readFileSync8(f, "utf8").trim().split("\n");
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
-        const j = JSON.parse(lines[i] ?? "");
+        const j = JSON.parse(lines[i]);
         if (typeof j.session?.seq === "number") return j.session.seq;
       } catch {
       }
@@ -2754,10 +3252,10 @@ var Outbox = class {
   /** Every session file, newest first. */
   sessions() {
     const out2 = [];
-    const base = path13.join(this.root, "outbox");
-    if (!existsSync7(base)) return [];
+    const base = path14.join(this.root, "outbox");
+    if (!existsSync9(base)) return [];
     for (const h of readdirSync6(base)) {
-      const d = path13.join(base, h);
+      const d = path14.join(base, h);
       let names = [];
       try {
         names = readdirSync6(d).filter((n) => n.endsWith(".jsonl"));
@@ -2766,7 +3264,7 @@ var Outbox = class {
       }
       for (const n of names) {
         try {
-          out2.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync6(path13.join(d, n)).mtimeMs });
+          out2.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync6(path14.join(d, n)).mtimeMs });
         } catch {
         }
       }
@@ -2774,31 +3272,43 @@ var Outbox = class {
     return out2.sort((a, b) => b.mtime - a.mtime).map((x) => x.ref);
   }
   /** Read events after byte offset `from`; returns them and the new offset. Lines
-   *  are read whole; a partial trailing line (a write in progress) is left. */
+   *  are read whole; a partial trailing line (a write in progress) is left. A read
+   *  takes READ_CHUNK bytes at a time, not the rest of the file: a session file grows
+   *  to tens of MB and a drain takes it in batches of 50. It reads on until the batch
+   *  is full or the file ends, so lines that parse to nothing never stop a drain; one
+   *  line longer than the chunk gets a larger one, up to READ_MAX. */
   read(ref, from, maxEvents = 500) {
     const f = this.file(ref);
-    if (!existsSync7(f)) return { events: [], offset: from };
+    if (!existsSync9(f)) return { events: [], offset: from };
     const size = statSync6(f).size;
     if (from >= size) return { events: [], offset: from };
     const fd = openSync3(f, "r");
     try {
-      const buf = Buffer.alloc(Math.min(size - from, 8 * 1024 * 1024));
-      const n = readSync3(fd, buf, 0, buf.length, from);
-      const text = buf.subarray(0, n).toString("utf8");
       const events = [];
       let offset = from;
-      let pos = 0;
-      while (events.length < maxEvents) {
-        const nl = text.indexOf("\n", pos);
-        if (nl < 0) break;
-        const line = text.slice(pos, nl);
-        pos = nl + 1;
-        offset = from + Buffer.byteLength(text.slice(0, pos), "utf8");
-        if (!line.trim()) continue;
-        try {
-          events.push(JSON.parse(line));
-        } catch {
+      let chunk = READ_CHUNK;
+      while (events.length < maxEvents && offset < size) {
+        const buf = Buffer.alloc(Math.min(size - offset, chunk));
+        const n = readSync3(fd, buf, 0, buf.length, offset);
+        const text = buf.subarray(0, n).toString("utf8");
+        let pos = 0;
+        let used = 0;
+        while (events.length < maxEvents) {
+          const nl = text.indexOf("\n", pos);
+          if (nl < 0) break;
+          const line = text.slice(pos, nl);
+          pos = nl + 1;
+          used += Buffer.byteLength(line, "utf8") + 1;
+          if (!line.trim()) continue;
+          try {
+            events.push(JSON.parse(line));
+          } catch {
+          }
         }
+        offset += used;
+        if (used) continue;
+        if (offset + n >= size || chunk >= READ_MAX) break;
+        chunk *= 2;
       }
       return { events, offset };
     } finally {
@@ -2842,7 +3352,7 @@ var Cursors = class {
   root;
   sink;
   file() {
-    return path13.join(this.root, "cursors", `${safeId(this.sink)}.json`);
+    return path14.join(this.root, "cursors", `${safeId(this.sink)}.json`);
   }
   read() {
     try {
@@ -2853,7 +3363,7 @@ var Cursors = class {
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path13.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync5(path14.dirname(f), { recursive: true, mode: 448 });
     const tmp = `${f}.${process.pid}.tmp`;
     writeFileSync5(tmp, JSON.stringify(c), { mode: 384 });
     renameSync(tmp, f);
@@ -2863,11 +3373,14 @@ var Cursors = class {
   }
 };
 function takeLock(root, ref, staleMs = 5 * 6e4) {
-  const dir = path13.join(root, "locks");
+  return takeNamedLock(root, `${safeId(ref.harness)}-${safeId(ref.session)}`, staleMs);
+}
+function takeNamedLock(root, name, staleMs = 5 * 6e4) {
+  const dir = path14.join(root, "locks");
   mkdirSync5(dir, { recursive: true, mode: 448 });
-  const f = path13.join(dir, `${safeId(ref.harness)}-${safeId(ref.session)}.lock`);
+  const f = path14.join(dir, `${name}.lock`);
   try {
-    if (Date.now() - statSync6(f).mtimeMs > staleMs) unlinkSync3(f);
+    if (Date.now() - statSync6(f).mtimeMs > staleMs || !processAlive(Number(readFileSync8(f, "utf8")))) unlinkSync3(f);
     else return null;
   } catch {
   }
@@ -2883,9 +3396,18 @@ function takeLock(root, ref, staleMs = 5 * 6e4) {
     }
   };
 }
+function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
 
 // ../core/src/privacy/pii.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } 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;
@@ -2907,7 +3429,7 @@ function reducePii(text, home) {
   return out2;
 }
 function hashMachine(name) {
-  return createHash2("sha256").update(name).digest("hex").slice(0, 8);
+  return createHash3("sha256").update(name).digest("hex").slice(0, 8);
 }
 function reducePiiDeep(v, home) {
   if (typeof v === "string") return reducePii(v, home);
@@ -2996,12 +3518,12 @@ function redactAssignments(text) {
   let last = 0;
   NAME_SEP.lastIndex = 0;
   for (let m = NAME_SEP.exec(text); m; m = NAME_SEP.exec(text)) {
-    const name = m[1] ?? "";
+    const name = m[1];
     if (!isSecretName(name)) continue;
     VALUE.lastIndex = NAME_SEP.lastIndex;
     const v = VALUE.exec(text);
     if (!v) continue;
-    const value = v[1] ?? v[2] ?? v[3] ?? v[4] ?? "";
+    const value = v[1] ?? v[2] ?? v[3] ?? v[4];
     NAME_SEP.lastIndex = VALUE.lastIndex;
     if (isPlaceholder(value) || value.includes(REDACTED)) continue;
     if (/tokens?$/i.test(name) && /^\d+(?:[.,]\d+)*[km]?$/i.test(value)) continue;
@@ -3057,7 +3579,7 @@ function redactSecrets(text) {
   let out2 = text;
   for (const re of TOKEN_PATTERNS) out2 = out2.replace(re, REDACTED);
   out2 = out2.replace(URL_CREDENTIALS, (_m, head, _pw, at) => `${head}${REDACTED}${at}`);
-  out2 = out2.replace(AUTH_HEADER, (m, head, v) => v.includes(REDACTED) ? m : `${head}${REDACTED}`);
+  out2 = out2.replace(AUTH_HEADER, (_m, head) => `${head}${REDACTED}`);
   out2 = redactAssignments(out2);
   out2 = out2.replace(
     PROSE,
@@ -3086,6 +3608,7 @@ var TYPE_TIER = {
   "turn.started": 0,
   "turn.ended": 0,
   "turn.transcript": 2,
+  "turn.progress": 2,
   "tool.started": 1,
   "tool.ended": 1,
   "files.changed": 1,
@@ -3105,6 +3628,7 @@ var DATA_ALLOW = {
   "turn.started": { 0: ["turn_id"], 1: ["prompt_chars"] },
   "turn.ended": { 0: ["turn_id", "reason", "ms"], 1: ["error"] },
   "turn.transcript": { 2: ["turn", "user", "assistant", "at"] },
+  "turn.progress": { 2: ["turn", "user", "assistant", "at"] },
   "tool.started": { 1: ["tool", "call_id", "turn_id", "agent_id"], 3: ["input"] },
   "tool.ended": { 1: ["tool", "call_id", "turn_id", "agent_id", "ms", "ok", "error"], 3: ["input", "output"] },
   "files.changed": { 1: ["paths"] },
@@ -3145,10 +3669,12 @@ function cap(v, max) {
   }
   return v;
 }
+function capTail(v, max) {
+  return v.length > max ? `\u2026${v.slice(v.length - max + 1)}` : v;
+}
 function filterEvent(event, tier, pii, opts = {}) {
   const minTier = TYPE_TIER[event.type];
   if (minTier !== void 0 && minTier > tier) return null;
-  if (event.type === "native" && tier < 3) return null;
   const session = {};
   for (const k of SESSION_ALLOW)
     if (event.session[k] !== void 0)
@@ -3158,7 +3684,8 @@ function filterEvent(event, tier, pii, opts = {}) {
   if (keys === null) data = { ...event.data };
   else for (const k of keys) if (event.data[k] !== void 0) data[k] = event.data[k];
   if (typeof data.user === "string") data.user = cap(data.user, MAX_SIDE);
-  if (typeof data.assistant === "string") data.assistant = cap(data.assistant, MAX_SIDE);
+  if (typeof data.assistant === "string")
+    data.assistant = event.type === "turn.progress" ? capTail(data.assistant, MAX_SIDE) : cap(data.assistant, MAX_SIDE);
   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);
@@ -3179,9 +3706,15 @@ function filterEvent(event, tier, pii, opts = {}) {
   return out2;
 }
 
+// ../core/src/short-id.ts
+import { createHash as createHash4 } from "node:crypto";
+function shortId(harness, id) {
+  return createHash4("sha256").update(`sessionpipe.session:${harness}:${id}`).digest("hex").slice(0, 8);
+}
+
 // ../core/src/sinks/file.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
     this.name = name;
@@ -3195,7 +3728,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path14.dirname(this.file), { recursive: true });
+      mkdirSync6(path15.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: [] };
@@ -3219,29 +3752,39 @@ var StdoutSink = class {
   pii;
   write;
   async send(events) {
-    for (const e of events) this.write(JSON.stringify(e));
-    return { ok: true, acknowledged: events.length, accepted: events.length, duplicates: 0, rejected: [] };
+    try {
+      for (const e of events) this.write(JSON.stringify(e));
+      return { ok: true, acknowledged: events.length, accepted: events.length, duplicates: 0, rejected: [] };
+    } catch (e) {
+      return { ok: false, acknowledged: 0, error: String(e.message ?? e), action: "retry" };
+    }
   }
 };
 
 // src/connect.ts
-import path15 from "node:path";
+import path16 from "node:path";
 function isBroad(dir, home) {
-  const d = path15.resolve(dir);
-  const h = path15.resolve(home);
-  if (d === path15.parse(d).root) return true;
-  return d === h || h.startsWith(d.endsWith(path15.sep) ? d : d + path15.sep);
+  const d = path16.resolve(dir);
+  const h = path16.resolve(home);
+  if (d === path16.parse(d).root) return true;
+  return d === h || h.startsWith(
+    /* v8 ignore next */
+    d.endsWith(path16.sep) ? d : d + path16.sep
+  );
 }
-var inside = (child, parent) => child !== parent && child.startsWith(parent.endsWith(path15.sep) ? parent : parent + path15.sep);
+var inside = (child, parent) => child !== parent && child.startsWith(
+  /* v8 ignore next */
+  parent.endsWith(path16.sep) ? parent : parent + path16.sep
+);
 function connectFolders(o) {
-  if (o.flags.length) return { folders: o.flags.map((d) => path15.resolve(d)), from: "flags" };
+  if (o.flags.length) return { folders: o.flags.map((d) => path16.resolve(d)), from: "flags" };
   if (o.existing.length) return { folders: [], from: "existing" };
-  if (!isBroad(o.cwd, o.home)) return { folders: [path15.resolve(o.cwd)], from: "here" };
+  if (!isBroad(o.cwd, o.home)) return { folders: [path16.resolve(o.cwd)], from: "here" };
   const exists = o.exists ?? (() => true);
   const picked = [];
   for (const raw of o.recent) {
-    if (!raw || !path15.isAbsolute(raw)) continue;
-    const d = path15.resolve(raw);
+    if (!raw || !path16.isAbsolute(raw)) continue;
+    const d = path16.resolve(raw);
     if (isBroad(d, o.home) || picked.includes(d) || !exists(d)) continue;
     if (picked.some((p) => inside(d, p))) continue;
     for (let i = picked.length - 1; i >= 0; i--) if (inside(picked[i], d)) picked.splice(i, 1);
@@ -3258,42 +3801,136 @@ function connectTier(flag2, current) {
 
 // src/control/autoupdate.ts
 import { spawn as spawn3 } from "node:child_process";
-import { readFileSync as readFileSync12 } from "node:fs";
-import path22 from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
+import path24 from "node:path";
 
 // src/update.ts
 import { spawn as spawn2 } from "node:child_process";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync9, realpathSync as realpathSync3 } from "node:fs";
-import path20 from "node:path";
+import { accessSync as accessSync3, constants as constants3, existsSync as existsSync11, realpathSync as realpathSync3 } from "node:fs";
+import path22 from "node:path";
 
 // src/runtime.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
-import { realpathSync as realpathSync2 } from "node:fs";
-import os7 from "node:os";
-import path19 from "node:path";
+import { execFileSync as execFileSync6 } from "node:child_process";
+import { readFileSync as readFileSync12, realpathSync as realpathSync2 } from "node:fs";
+import os8 from "node:os";
+import path21 from "node:path";
+
+// src/launcher.ts
+import { accessSync as accessSync2, chmodSync as chmodSync2, constants as constants2, mkdirSync as mkdirSync7, readFileSync as readFileSync9, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
+import os5 from "node:os";
+import path17 from "node:path";
+var LAUNCHER = "sessionpipe-hook";
+var COPIED = ["worker.js", "hook.js"];
+function dataDir(env = process.env) {
+  if (env.SESSIONPIPE_DATA) return path17.resolve(env.SESSIONPIPE_DATA);
+  return path17.join(env.XDG_DATA_HOME || path17.join(os5.homedir(), ".local", "share"), "sessionpipe");
+}
+var launcherPath = (env = process.env) => path17.join(dataDir(env), LAUNCHER);
+var usesLauncher = (platform = process.platform) => platform !== "win32";
+var sq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+function launcherScript(node, hook, version) {
+  return `#!/bin/sh
+# sessionpipe ${version} hook launcher, written by \`sessionpipe install\`. Harnesses run
+# this; it runs hook.js beside it with the node sessionpipe was installed with, or with
+# any node on PATH once that one is gone (an nvm uninstall, a Homebrew upgrade).
+n=${sq(node)}
+[ -x "$n" ] || n=$(command -v node) || { [ "$1" = antigravity ] && if [ "$2" = PreToolUse ]; then echo ${sq(AG_STALE_PRETOOL.trim())}; else echo '{}'; fi; exit 0; }
+exec "$n" ${sq(hook)} "$@"
+`;
+}
+function writeIfChanged(file, body, mode) {
+  try {
+    const cur = readFileSync9(file);
+    if (cur.equals(Buffer.isBuffer(body) ? body : Buffer.from(body))) {
+      chmodSync2(file, mode);
+      return false;
+    }
+  } catch {
+  }
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync6(tmp, body, { mode });
+  renameSync2(tmp, file);
+  chmodSync2(file, mode);
+  return true;
+}
+function installLauncher(o) {
+  const dir = dataDir(o.env);
+  mkdirSync7(dir, { recursive: true, mode: 493 });
+  let changed = false;
+  for (const f of COPIED)
+    changed = writeIfChanged(path17.join(dir, f), readFileSync9(path17.join(o.distDir, f)), 420) || changed;
+  const launcher = path17.join(dir, LAUNCHER);
+  changed = writeIfChanged(launcher, launcherScript(o.node, path17.join(dir, "hook.js"), o.version), 493) || changed;
+  return { launcher, changed };
+}
+function removeLauncher(env = process.env) {
+  for (const f of [LAUNCHER, ...COPIED]) rmSync(path17.join(dataDir(env), f), { force: true });
+}
+function launcherState(version, env = process.env) {
+  const file = launcherPath(env);
+  let text = "";
+  try {
+    text = readFileSync9(file, "utf8");
+  } catch {
+    return {
+      file,
+      present: false,
+      node: null,
+      nodeOk: false,
+      version: null,
+      problems: ["the hook launcher is missing; run `sessionpipe install` again"]
+    };
+  }
+  const node = /^n='((?:[^']|'\\'')*)'$/m.exec(text)?.[1]?.replace(/'\\''/g, "'") ?? null;
+  const v = /^# sessionpipe (\S+) hook launcher/m.exec(text)?.[1] ?? null;
+  let nodeOk = false;
+  try {
+    if (node) {
+      accessSync2(node, constants2.X_OK);
+      nodeOk = true;
+    }
+  } catch {
+  }
+  const problems = [];
+  if (!nodeOk)
+    problems.push(
+      `the node the hook launcher names (${node ?? "?"}) is gone; it falls back to the node on PATH. \`sessionpipe install\` points it at this one.`
+    );
+  for (const f of COPIED)
+    try {
+      accessSync2(path17.join(path17.dirname(file), f), constants2.R_OK);
+    } catch {
+      problems.push(`${f} is missing beside the hook launcher; run \`sessionpipe install\` again`);
+    }
+  if (v && v !== version)
+    problems.push(
+      `the hooks run sessionpipe ${v}, this is ${version}; run \`sessionpipe install\` to bring them up to date`
+    );
+  return { file, present: true, node, nodeOk, version: v, problems };
+}
 
 // src/run.ts
 import {
   appendFileSync as appendFileSync3,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync8,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync10,
-  renameSync as renameSync3,
+  readFileSync as readFileSync11,
+  renameSync as renameSync4,
   statSync as statSync7,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "node:fs";
-import os6 from "node:os";
-import path18 from "node:path";
+import os7 from "node:os";
+import path20 from "node:path";
 
 // src/control/aliases.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync9, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import path16 from "node:path";
-var aliasFile = (controlDir) => path16.join(controlDir, "aliases.json");
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync8, readFileSync as readFileSync10, renameSync as renameSync3, writeFileSync as writeFileSync7 } from "node:fs";
+import path18 from "node:path";
+var aliasFile = (controlDir) => path18.join(controlDir, "aliases.json");
 function readAliases(file) {
   try {
-    const j = JSON.parse(readFileSync9(file, "utf8"));
+    const j = JSON.parse(readFileSync10(file, "utf8"));
     if (!j || typeof j !== "object" || Array.isArray(j)) return {};
     const out2 = {};
     for (const [k, v] of Object.entries(j)) {
@@ -3307,13 +3944,13 @@ function readAliases(file) {
   }
 }
 function writeAliases(file, all) {
-  mkdirSync7(path16.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync8(path18.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync6(tmp, `${JSON.stringify(all, null, 2)}
+  writeFileSync7(tmp, `${JSON.stringify(all, null, 2)}
 `, { mode: 384 });
-  renameSync2(tmp, file);
+  renameSync3(tmp, file);
   try {
-    chmodSync2(file, 384);
+    chmodSync3(file, 384);
   } catch {
   }
 }
@@ -3325,12 +3962,12 @@ function receiverIdOf(all, harness, id) {
 
 // src/control/local.ts
 import net from "node:net";
-import os5 from "node:os";
-import path17 from "node:path";
+import os6 from "node:os";
+import path19 from "node:path";
 function socketPath(state2, env = process.env) {
   if (env.SESSIONPIPE_SOCKET) return env.SESSIONPIPE_SOCKET;
-  if (process.platform === "win32") return `\\\\.\\pipe\\sessionpipe-control-${os5.userInfo().username}`;
-  return path17.join(state2, "control.sock");
+  if (process.platform === "win32") return `\\\\.\\pipe\\sessionpipe-control-${os6.userInfo().username}`;
+  return path19.join(state2, "control.sock");
 }
 function ask(sock, req, timeoutMs) {
   return new Promise((resolve) => {
@@ -3363,10 +4000,17 @@ function ask(sock, req, timeoutMs) {
 }
 
 // src/http-sink.ts
-import { createHash as createHash3, createHmac } from "node:crypto";
+import { createHash as createHash5, createHmac } from "node:crypto";
 var TIMEOUT_MS = 15e3;
 function webhookId(events) {
-  return `msg_${createHash3("sha256").update(events.map((e) => e.id).join(",")).digest("base64url").slice(0, 32)}`;
+  return `msg_${createHash5("sha256").update(events.map((e) => e.id).join(",")).digest("base64url").slice(0, 32)}`;
+}
+function retryAfterMs(header, now = Date.now()) {
+  if (header === null || header.trim() === "") return 6e4;
+  const secs = Number(header);
+  if (Number.isFinite(secs)) return Math.max(0, secs) * 1e3;
+  const at = Date.parse(header);
+  return Number.isFinite(at) ? Math.max(0, at - now) : 6e4;
 }
 var HttpSink = class {
   constructor(cfg, tier) {
@@ -3439,7 +4083,7 @@ var HttpSink = class {
           status: 429,
           error: err,
           action: "retry",
-          retryAfterMs: Number(r.headers.get("retry-after") ?? 60) * 1e3
+          retryAfterMs: retryAfterMs(r.headers.get("retry-after"))
         };
       return { ok: false, acknowledged: 0, status: r.status, error: err, action: "retry" };
     } catch (e) {
@@ -3452,10 +4096,10 @@ var HttpSink = class {
 
 // src/secrets.ts
 import { spawnSync } from "node:child_process";
-import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
 var SERVICE = "sessionpipe";
-var defaultRunner = (cmd2, args2, input) => {
-  const r = spawnSync(cmd2, args2, {
+var defaultRunner = (cmd, args2, input) => {
+  const r = spawnSync(cmd, args2, {
     input: input ?? "",
     encoding: "utf8",
     timeout: 8e3,
@@ -3464,7 +4108,7 @@ var defaultRunner = (cmd2, args2, input) => {
   return { status: r.error ? null : r.status, stdout: r.stdout ?? "" };
 };
 var sinkAccount = (name, what = "token") => {
-  const scope = process.env.SESSIONPIPE_CONFIG ? `@${createHash4("sha256").update(configFile()).digest("hex").slice(0, 8)}` : "";
+  const scope = process.env.SESSIONPIPE_CONFIG ? `@${createHash6("sha256").update(configFile()).digest("hex").slice(0, 8)}` : "";
   return `sink:${name}:${what}${scope}`;
 };
 var controlAccount = (machine) => `control:${machine}`;
@@ -3566,7 +4210,7 @@ function dropSinkSecrets(s, run = defaultRunner) {
 // src/run.ts
 async function tellDaemon(state2, job, session, cwd, transcript) {
   const sock = socketPath(state2);
-  if (process.platform !== "win32" && !existsSync8(sock)) return;
+  if (process.platform !== "win32" && !existsSync10(sock)) return;
   await ask(
     sock,
     {
@@ -3579,20 +4223,27 @@ async function tellDaemon(state2, job, session, cwd, transcript) {
     300
   );
 }
-var VERSION = true ? "0.7.0" : "0.0.0";
+var VERSION = true ? "0.9.0" : "0.0.0";
 function enqueueJob(state2, job) {
   const jobs = jobsDir(state2);
-  mkdirSync8(jobs, { recursive: true, mode: 448 });
-  const f = path18.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
-  writeFileSync7(f, JSON.stringify(job), { mode: 384 });
+  mkdirSync9(jobs, { recursive: true, mode: 448 });
+  const f = path20.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
+  writeFileSync8(f, JSON.stringify(job), { mode: 384 });
   return f;
 }
+function releaseJob(claimed) {
+  if (!claimed) return;
+  try {
+    unlinkSync4(claimed);
+  } catch {
+  }
+}
 function log(state2, line) {
   try {
-    mkdirSync8(state2, { recursive: true, mode: 448 });
-    const f = path18.join(state2, "log");
+    mkdirSync9(state2, { recursive: true, mode: 448 });
+    const f = path20.join(state2, "log");
     try {
-      if (statSync7(f).size > 1024 * 1024) renameSync3(f, `${f}.1`);
+      if (statSync7(f).size > 1024 * 1024) renameSync4(f, `${f}.1`);
     } catch {
     }
     appendFileSync3(f, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
@@ -3601,11 +4252,11 @@ function log(state2, line) {
   }
 }
 function factsState(state2) {
-  const file = (h, s) => path18.join(state2, "facts", safeId(h), `${safeId(s)}.json`);
+  const file = (h, s) => path20.join(state2, "facts", safeId(h), `${safeId(s)}.json`);
   return {
     get(h, s) {
       try {
-        return JSON.parse(readFileSync10(file(h, s), "utf8"));
+        return JSON.parse(readFileSync11(file(h, s), "utf8"));
       } catch {
         return {};
       }
@@ -3614,8 +4265,8 @@ function factsState(state2) {
       const cur = this.get(h, s);
       const next = { ...cur, ...patch };
       if (JSON.stringify(next) === JSON.stringify(cur)) return;
-      mkdirSync8(path18.dirname(file(h, s)), { recursive: true, mode: 448 });
-      writeFileSync7(file(h, s), JSON.stringify(next), { mode: 384 });
+      mkdirSync9(path20.dirname(file(h, s)), { recursive: true, mode: 448 });
+      writeFileSync8(file(h, s), JSON.stringify(next), { mode: 384 });
     }
   };
 }
@@ -3631,44 +4282,80 @@ function buildSinks(sinks, o = {}) {
     const tier = Math.min(s.tier, s.max_tier ?? 3);
     if (s.url === "stdout") out2.push(new StdoutSink(s.name, tier, !!s.pii));
     else if (s.url.startsWith("file:"))
-      out2.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os6.homedir()), tier, !!s.pii));
+      out2.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os7.homedir()), tier, !!s.pii));
     else if (/^https?:\/\//.test(s.url)) out2.push(new HttpSink(s, tier));
   }
   return out2;
 }
+var PROGRESS_MS = 2e4;
+function openTurn(read, o) {
+  const last = read.turns[read.turns.length - 1];
+  const fresh = (user, at) => ({
+    turn: o.base + read.turns.length,
+    user: user.slice(0, MAX_TURN_SIDE),
+    assistant: "",
+    at
+  });
+  if (read.open) return fresh(read.open.user, read.open.at);
+  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;
+  return {
+    turn: o.base + read.turns.length - 1,
+    user: last.user.slice(0, MAX_TURN_SIDE),
+    assistant: capTail(last.assistant, MAX_TURN_SIDE),
+    at: last.at
+  };
+}
+var MAX_TURN_SIDE = 2e4;
 async function runJob(job, opts = {}) {
   const state2 = opts.state ?? stateDir();
   const cfg = readConfig();
   const adapter = adapterByName(job.harness);
-  if (!adapter) return { events: [], delivered: {} };
+  if (!adapter) {
+    log(state2, `${job.harness} ${job.event}: no adapter for harness "${job.harness}"; event dropped`);
+    return { events: [], delivered: {} };
+  }
   const r = adapter.fromHook({ argv: job.argv, stdin: job.stdin, env: { ...process.env, ...job.env }, cwd: job.cwd });
-  if (!r || !r.session.id) return { events: [], delivered: {} };
-  const id = receiverIdOf(readAliases(aliasFile(path18.join(state2, "control"))), job.harness, r.session.id) ?? r.session.id;
-  await tellDaemon(state2, job, id, r.session.cwd, r.transcript);
+  if (!r || !r.session.id) {
+    log(state2, `${job.harness} ${job.event}: the ${job.harness} adapter did not claim this payload; event dropped`);
+    return { events: [], delivered: {} };
+  }
+  const id = receiverIdOf(readAliases(aliasFile(path20.join(state2, "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(state2, job, id, r.session.cwd, r.transcript);
   const outbox = new Outbox(state2);
   const ref = { harness: job.harness, session: id };
   let release = takeLock(state2, ref);
-  for (let wait = 50; !release && wait <= 3200; wait *= 2) {
-    await new Promise((res) => setTimeout(res, wait));
+  const lockWait = opts.lockWaitMs ?? LOCK_WAIT_MS;
+  for (const until = Date.now() + lockWait; !release && Date.now() < until; ) {
+    await new Promise((res) => setTimeout(res, 50));
     release = takeLock(state2, ref);
   }
   if (!release) {
-    log(state2, `${job.harness} ${job.event}: session ${id} locked for 6 s, re-queued`);
-    enqueueJob(state2, job);
-    return { events: [], delivered: {} };
+    log(state2, `${job.harness} ${job.event}: session ${id} locked for ${lockWait / 1e3} s, re-queued`);
+    const requeued = enqueueJob(state2, { ...job, tries: (job.tries ?? 0) + 1 });
+    releaseJob(opts.claimed);
+    return { events: [], delivered: {}, requeued };
   }
+  const events = [];
   try {
     const facts = factsState(state2);
     const mem = facts.get(job.harness, id);
+    if (claudeEnd && !existsSync10(outbox.file(ref)) && Object.keys(mem).length === 0 && !(r.transcript && existsSync10(r.transcript))) {
+      releaseJob(opts.claimed);
+      return { events: [], delivered: {} };
+    }
+    if (claudeEnd) await tellDaemon(state2, job, id, r.session.cwd, r.transcript);
     const heavy = !/^(PreToolUse|PostToolUse|PostToolUseFailure|BeforeTool|AfterTool|PostInvocation)$/.test(job.event);
     let learned = {};
     if (heavy) {
-      const f = adapter.facts(r.session, r.transcript, r.hints ?? {}, facts);
+      const f = adapter.facts(r.session, r.transcript, r.hints ?? {}, facts, { ...process.env, ...job.env });
       const { started_at: _s, last_at: _l, first_ask: _fa, harness_version, ...rest } = f;
       learned = rest;
       if (harness_version) facts.save(job.harness, id, { harness_version });
       facts.save(job.harness, id, { session: { ...mem.session, ...learned } });
-      if (job.harness === "antigravity" && r.session.cwd && path18.isAbsolute(r.session.cwd))
+      if (CWD_FROM_HOOKS.has(job.harness) && r.session.cwd && path20.isAbsolute(r.session.cwd))
         facts.save(job.harness, id, { cwd: r.session.cwd });
     }
     const known = mem.session ?? {};
@@ -3681,12 +4368,11 @@ async function runJob(job, opts = {}) {
       ...learned.branch ? { branch: learned.branch } : {},
       id,
       seq: 0,
-      machine: machineName(cfg, os6.hostname()),
+      machine: machineName(cfg, os7.hostname()),
       ...cwdRaw ? { cwd: tilde(cwdRaw) } : {},
       ...r.session.model ? { model: r.session.model } : {}
     };
     const version = facts.get(job.harness, id).harness_version ?? void 0;
-    const events = [];
     for (const a of r.events) {
       const e = makeEvent(a, {
         harness: { name: job.harness, ...version ? { version } : {} },
@@ -3696,6 +4382,37 @@ async function runJob(job, opts = {}) {
       events.push(e);
     }
     const wantsTranscript = cfg.sinks.some((s) => !s.paused && Math.min(s.tier, s.max_tier ?? 3) >= 2);
+    const ending = r.events.some((e) => e.type === "turn.ended" || e.type === "session.ended");
+    const starting = r.events.some((e) => e.type === "turn.started");
+    const startedId = r.events.find((e) => e.type === "turn.started")?.data.turn_id;
+    const absorbed = starting && typeof startedId === "string" && facts.get(job.harness, id).open_turn === startedId;
+    if (wantsTranscript && r.transcript && !ending && (starting || r.events.some((e) => e.type === "tool.ended"))) {
+      const cur = facts.get(job.harness, id);
+      const at = opts.now ?? job.at;
+      if (starting || at - (Number(cur.progress_at) || 0) >= PROGRESS_MS) {
+        const p = openTurn(adapter.readTranscript(r.transcript, Number(cur.transcript_line) || 0), {
+          base: Number(cur.transcript_turns) || 0,
+          prompt: !absorbed && typeof r.hints?.prompt === "string" ? r.hints.prompt : void 0,
+          at
+        });
+        const sig = p && `${p.turn}:${p.user.length}:${p.assistant.length}`;
+        if (p && (starting || sig !== cur.progress_sig)) {
+          events.push(
+            makeEvent(
+              { type: "turn.progress", harnessEvent: job.event, data: { ...p, at: new Date(p.at).toISOString() } },
+              {
+                harness: { name: job.harness, ...version ? { version } : {} },
+                session: { ...session, seq: outbox.nextSeq(ref) },
+                now: at
+              }
+            )
+          );
+          facts.save(job.harness, id, { progress_at: at, progress_sig: sig });
+        }
+      }
+    }
+    if (starting && typeof startedId === "string" && !absorbed) facts.save(job.harness, id, { open_turn: startedId });
+    if (ending) facts.save(job.harness, id, { open_turn: null });
     if (wantsTranscript && r.transcript && r.events.some((e) => e.type === "turn.ended" || e.type === "session.ended")) {
       const cur = facts.get(job.harness, id);
       const fromLine = Number(cur.transcript_line) || 0;
@@ -3723,17 +4440,80 @@ async function runJob(job, opts = {}) {
       ref,
       events.map((e) => ({ ...e, session: redactDeep(e.session), data: redactDeep(e.data) }))
     );
-    log(state2, `${job.harness} ${job.event}: ${events.map((e) => e.type).join(",") || "nothing"} (${id.slice(0, 8)})`);
-    const delivered = await flush(state2, cfg.sinks, outbox, ref);
-    if (Math.random() < 0.02) outbox.prune(cfg.keep_days ?? 30);
-    return { events, delivered };
+    releaseJob(opts.claimed);
+    log(
+      state2,
+      `${job.harness} ${job.event}: ${events.map((e) => e.type).join(",") || "nothing"} (${shortId(job.harness, id)})`
+    );
   } finally {
     release();
   }
+  const delivered = await drain(state2, cfg.sinks, outbox, ref) ?? {};
+  if (Math.random() < 0.02) outbox.prune(cfg.keep_days ?? 30);
+  return { events, delivered };
+}
+async function drain(state2, sinkConfigs, outbox, first) {
+  const more = path20.join(state2, "locks", "flush.more");
+  let release = takeNamedLock(state2, "flush");
+  if (!release) {
+    try {
+      writeFileSync8(more, "", { mode: 384 });
+    } catch {
+    }
+    release = takeNamedLock(state2, "flush");
+    if (!release) return null;
+  }
+  const delivered = {};
+  for (; ; ) {
+    try {
+      unlinkSync4(more);
+    } catch {
+    }
+    try {
+      for (const [k, v] of Object.entries(await flush(state2, sinkConfigs, outbox, first)))
+        delivered[k] = (delivered[k] ?? 0) + v;
+    } finally {
+      release();
+    }
+    if (!existsSync10(more)) return delivered;
+    release = takeNamedLock(state2, "flush");
+    if (!release) return delivered;
+  }
 }
+var BACKOFF_MS = [2e3, 1e4, 6e4, 5 * 6e4, 30 * 6e4];
+var backoffFile = (state2, sink2) => path20.join(state2, "backoff", `${safeId(sink2)}.json`);
+function readBackoff(state2, sink2) {
+  try {
+    const b = JSON.parse(readFileSync11(backoffFile(state2, sink2), "utf8"));
+    return typeof b.until === "number" ? b : null;
+  } catch {
+    return null;
+  }
+}
+function noteFailure(state2, sink2, res, prev) {
+  const failures = (prev?.failures ?? 0) + 1;
+  const ladder = BACKOFF_MS[Math.min(failures, BACKOFF_MS.length) - 1];
+  const wait = Number.isFinite(res.retryAfterMs) ? res.retryAfterMs : ladder;
+  const b = { until: Date.now() + wait, failures, why: `${res.status ?? ""} ${res.error ?? ""}`.trim() };
+  const f = backoffFile(state2, sink2);
+  try {
+    mkdirSync9(path20.dirname(f), { recursive: true, mode: 448 });
+    writeFileSync8(f, JSON.stringify(b), { mode: 384 });
+  } catch {
+  }
+  return b;
+}
+function clearBackoff(state2, sink2) {
+  try {
+    unlinkSync4(backoffFile(state2, sink2));
+  } catch {
+  }
+}
+var LOCK_WAIT_MS = 6e3;
+var CWD_FROM_HOOKS = /* @__PURE__ */ new Set(["antigravity", "devin"]);
 var BATCH = 50;
 var MAX_PER_RUN = 500;
-async function flush(state2, sinkConfigs, outbox, first) {
+async function flush(state2, sinkConfigs, outbox, first, o = {}) {
   const delivered = {};
   const sinks = buildSinks(sinkConfigs, {
     locked: (name) => log(state2, `sink ${name}: its token is in a keychain this process can't read; left for later`)
@@ -3743,13 +4523,39 @@ async function flush(state2, sinkConfigs, outbox, first) {
     const k = `${first.harness}/${safeId(first.session)}`;
     refs.sort((a, b) => `${a.harness}/${a.session}` === k ? -1 : `${b.harness}/${b.session}` === k ? 1 : 0);
   }
-  for (const sink2 of sinks) {
+  const drainSink = async (sink2) => {
+    let backoff = readBackoff(state2, sink2.name);
+    if (backoff && !o.force && backoff.until > Date.now()) {
+      delivered[sink2.name] = 0;
+      return;
+    }
     const cursors = new Cursors(state2, sink2.name);
     const c = cursors.read();
     let sent = 0;
     let stalled = false;
     let batch = [];
     let pending = {};
+    const deliver = async (events) => {
+      const res = await sink2.send(events);
+      if (res.ok || res.action !== "split") return res;
+      if (events.length === 1) {
+        const e = events[0];
+        log(state2, `sink ${sink2.name}: 413 ${res.error ?? ""} \u2192 event ${e.id} (${e.type}) is too large alone, dropped`);
+        return { ok: true, acknowledged: 0, accepted: 0, duplicates: 0, rejected: [{ id: e.id, reason: "too_large" }] };
+      }
+      const half = Math.ceil(events.length / 2);
+      const a = await deliver(events.slice(0, half));
+      if (!a.ok) return a;
+      const b = await deliver(events.slice(half));
+      if (!b.ok) return b;
+      return {
+        ok: true,
+        acknowledged: a.acknowledged + b.acknowledged,
+        accepted: (a.accepted ?? 0) + (b.accepted ?? 0),
+        duplicates: (a.duplicates ?? 0) + (b.duplicates ?? 0),
+        rejected: [...a.rejected ?? [], ...b.rejected ?? []]
+      };
+    };
     const send = async () => {
       if (!batch.length) {
         Object.assign(c, pending);
@@ -3757,15 +4563,24 @@ async function flush(state2, sinkConfigs, outbox, first) {
         cursors.write(c);
         return true;
       }
-      const res = await sink2.send(batch);
+      const res = await deliver(batch);
       if (!res.ok) {
-        log(state2, `sink ${sink2.name}: ${res.status ?? ""} ${res.error ?? ""} \u2192 ${res.action ?? "retry"}`);
+        const action = res.action ?? "retry";
+        let wait = "";
+        if (action === "retry") {
+          backoff = noteFailure(state2, sink2.name, res, backoff);
+          wait = `, waits ${Math.round((backoff.until - Date.now()) / 1e3)} s`;
+        }
+        log(state2, `sink ${sink2.name}: ${res.status ?? ""} ${res.error ?? ""} \u2192 ${action}${wait}`);
         if (res.action === "pause" || res.action === "lower-tier") applySinkVerdict(sink2.name, res);
         if (res.action !== "drop") {
           batch = [];
           pending = {};
           return false;
         }
+      } else if (backoff) {
+        clearBackoff(state2, sink2.name);
+        backoff = null;
       }
       sent += batch.length;
       Object.assign(c, pending);
@@ -3782,7 +4597,7 @@ async function flush(state2, sinkConfigs, outbox, first) {
         const { events, offset: next } = outbox.read(ref, offset, room);
         if (!events.length) break;
         for (const e of events) {
-          const f = filterEvent(e, sink2.tier, sink2.pii, { home: os6.homedir() });
+          const f = filterEvent(e, sink2.tier, sink2.pii, { home: os7.homedir() });
           if (f) batch.push(f);
         }
         offset = next;
@@ -3800,7 +4615,8 @@ async function flush(state2, sinkConfigs, outbox, first) {
       if (!await send()) stalled = true;
     }
     delivered[sink2.name] = sent;
-  }
+  };
+  await Promise.all(sinks.map(drainSink));
   return delivered;
 }
 function applySinkVerdict(name, res) {
@@ -3814,7 +4630,7 @@ function applySinkVerdict(name, res) {
   } catch {
   }
 }
-var jobsDir = (state2) => path18.join(state2, "jobs");
+var jobsDir = (state2) => path20.join(state2, "jobs");
 
 // src/runtime.ts
 function stableNode(exe) {
@@ -3837,26 +4653,59 @@ function stableNode(exe) {
 function viaNpx(distDir2) {
   return /[\\/]_npx[\\/]/.test(distDir2) || /[\\/]\.npm[\\/]/.test(distDir2);
 }
-function rerunGlobally(argv, out2) {
+function installLocation() {
+  let prefix = "";
+  try {
+    prefix = execFileSync6("npm", ["prefix", "-g"], {
+      encoding: "utf8",
+      timeout: 15e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+  }
+  return {
+    prefix,
+    target: /\/Cellar\/node(?:@\d+)?\/[^/]+/.test(prefix) ? path21.join(os8.homedir(), ".local") : prefix
+  };
+}
+function assertSetupVersion(allowDowngrade, target) {
+  if (allowDowngrade) return;
+  const check = (installed2, where) => {
+    if (installed2 && isNewer(installed2, VERSION, true))
+      throw new Error(
+        `refusing to downgrade sessionpipe: ${installed2} is installed at ${where}; this command would install ${VERSION}. Use the installed newer CLI, or pass --allow-downgrade to force ${VERSION}.`
+      );
+  };
+  const hooks = launcherState(VERSION);
+  check(hooks.version, hooks.file);
+  const prefix = target ?? installLocation().target;
+  if (!prefix) return;
+  const pkg = path21.join(
+    prefix,
+    ...process.platform === "win32" ? [] : ["lib"],
+    "node_modules",
+    "sessionpipe",
+    "package.json"
+  );
+  let installed;
+  try {
+    installed = JSON.parse(readFileSync12(pkg, "utf8")).version;
+  } catch {
+  }
+  if (typeof installed === "string") check(installed, pkg);
+}
+function rerunGlobally(argv, out2, setup) {
+  const { prefix, target } = installLocation();
+  if (setup) assertSetupVersion(setup.allowDowngrade, target);
   out2(`  Installing sessionpipe@${VERSION} globally, so hooks and services use a persistent copy\u2026`);
   let bin;
   try {
-    let prefix = "";
-    try {
-      prefix = execFileSync5("npm", ["prefix", "-g"], {
-        encoding: "utf8",
-        timeout: 15e3,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-    } catch {
-    }
-    const target = /\/Cellar\/node(?:@\d+)?\/[^/]+/.test(prefix) ? path19.join(os7.homedir(), ".local") : prefix;
-    execFileSync5("npm", ["install", "-g", `sessionpipe@${VERSION}`, ...target ? ["--prefix", target] : []], {
+    execFileSync6("npm", ["install", "-g", `sessionpipe@${VERSION}`, ...target ? ["--prefix", target] : []], {
       stdio: ["ignore", "ignore", "inherit"]
     });
-    bin = process.platform === "win32" ? path19.join(target, "sessionpipe.cmd") : target ? path19.join(target, "bin", "sessionpipe") : "sessionpipe";
+    bin = process.platform === "win32" ? path21.join(target, "sessionpipe.cmd") : target ? path21.join(target, "bin", "sessionpipe") : "sessionpipe";
     if (target && target !== prefix)
-      out2(`  Installed into ${target}; make sure ${path19.join(target, "bin")} is on your PATH.`);
+      out2(`  Installed into ${target}; make sure ${path21.join(target, "bin")} is on your PATH.`);
   } catch {
     out2(
       "  ! couldn't install globally (`npm install -g sessionpipe` failed). Run it yourself, then retry this command."
@@ -3864,7 +4713,7 @@ function rerunGlobally(argv, out2) {
     process.exit(1);
   }
   try {
-    execFileSync5(bin, argv, { stdio: "inherit", shell: process.platform === "win32" });
+    execFileSync6(bin, argv, { stdio: "inherit", shell: process.platform === "win32" });
   } catch (e) {
     process.exit(typeof e.status === "number" ? e.status : 1);
   }
@@ -3888,9 +4737,9 @@ function compareVersions(a, b) {
   if (y.pre === null) return -1;
   return x.pre.localeCompare(y.pre, "en", { numeric: true });
 }
-function isNewer(a, b) {
+function isNewer(a, b, includePrereleases = false) {
   const x = parse2(a);
-  if (!x || x.pre !== null) return false;
+  if (!x || !includePrereleases && x.pre !== null) return false;
   const c = compareVersions(a, b);
   return c !== null && c > 0;
 }
@@ -3912,21 +4761,21 @@ function globalPrefix(distDir2, platform = process.platform) {
   if (viaNpx(distDir2)) return null;
   const prefix = prefixOf(distDir2, platform);
   if (!prefix) return null;
-  const bin = platform === "win32" ? path20.join(prefix, "sessionpipe.cmd") : path20.join(prefix, "bin", "sessionpipe");
-  return existsSync9(bin) ? prefix : null;
+  const bin = platform === "win32" ? path22.join(prefix, "sessionpipe.cmd") : path22.join(prefix, "bin", "sessionpipe");
+  return existsSync11(bin) ? prefix : null;
 }
 function unwritable(prefix, platform = process.platform) {
-  const dir = platform === "win32" ? path20.join(prefix, "node_modules") : path20.join(prefix, "lib", "node_modules");
+  const dir = platform === "win32" ? path22.join(prefix, "node_modules") : path22.join(prefix, "lib", "node_modules");
   try {
-    accessSync2(dir, constants2.W_OK);
+    accessSync3(dir, constants3.W_OK);
     return null;
   } catch {
     return `${dir} isn't writable by this user (installed with sudo?)`;
   }
 }
 function npmArgv(node, platform = process.platform) {
-  const dir = path20.dirname(node);
-  const candidates = platform === "win32" ? [path20.join(dir, "node_modules", "npm", "bin", "npm-cli.js")] : [path20.join(dir, "npm"), path20.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")];
+  const dir = path22.dirname(node);
+  const candidates = platform === "win32" ? [path22.join(dir, "node_modules", "npm", "bin", "npm-cli.js")] : [path22.join(dir, "npm"), path22.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")];
   for (const c of candidates) {
     try {
       const real = realpathSync3(c);
@@ -3937,17 +4786,17 @@ function npmArgv(node, platform = process.platform) {
   return [platform === "win32" ? "npm.cmd" : "npm"];
 }
 var execCapture = (argv, o) => new Promise((resolve) => {
-  const [cmd2, ...rest] = argv;
+  const [cmd, ...rest] = argv;
   let stdout = "";
   let stderr = "";
   const keep = (s, b) => (s + b.toString("utf8")).slice(-16e3);
   let child;
   try {
-    child = spawn2(cmd2, rest, {
+    child = spawn2(cmd, rest, {
       env: o.env,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
-      shell: process.platform === "win32" && cmd2.endsWith(".cmd")
+      shell: process.platform === "win32" && cmd.endsWith(".cmd")
     });
   } catch (e) {
     resolve({ code: null, stdout, stderr, error: e.message });
@@ -3971,7 +4820,7 @@ var execCapture = (argv, o) => new Promise((resolve) => {
 });
 var lastLine = (r) => (r.error || r.stderr.trim().split("\n").filter(Boolean).slice(-2).join(" ") || `exit ${r.code}`).slice(0, 300);
 async function installedVersion(o) {
-  const r = await (o.exec ?? execCapture)([o.node, path20.join(o.distDir, "cli.js"), "--version"], {
+  const r = await (o.exec ?? execCapture)([o.node, path22.join(o.distDir, "cli.js"), "--version"], {
     env: o.env ?? process.env,
     timeoutMs: 3e4
   });
@@ -3983,7 +4832,7 @@ async function installVersion(version, o) {
   const platform = o.platform ?? process.platform;
   const exec = o.exec ?? execCapture;
   const base = o.env ?? process.env;
-  const env = { ...base, PATH: [path20.dirname(o.node), base.PATH].filter(Boolean).join(path20.delimiter) };
+  const env = { ...base, PATH: [path22.dirname(o.node), base.PATH].filter(Boolean).join(path22.delimiter) };
   const prefix = globalPrefix(o.distDir, platform);
   if (!prefix)
     return { ok: false, ms: Date.now() - t0, stage: "prefix", error: "this copy isn't a global npm install" };
@@ -4014,7 +4863,7 @@ async function installVersion(version, o) {
   let hooks = "no harness set up here; nothing to re-arm";
   if (o.harnesses.length) {
     const h = await exec(
-      [o.node, path20.join(o.distDir, "cli.js"), "install", "--backfill", "0", ...o.harnesses.map((n) => `--${n}`)],
+      [o.node, path22.join(o.distDir, "cli.js"), "install", "--backfill", "0", ...o.harnesses.map((n) => `--${n}`)],
       { env, timeoutMs: 2 * 6e4 }
     );
     hooks = h.code === 0 ? `hooks re-armed for ${o.harnesses.join(", ")}` : `re-arming the hooks failed (${lastLine(h)}); \`sessionpipe install\` does it`;
@@ -4025,17 +4874,17 @@ async function installVersion(version, o) {
 // src/control/store.ts
 import {
   appendFileSync as appendFileSync4,
-  chmodSync as chmodSync3,
+  chmodSync as chmodSync4,
   closeSync as closeSync4,
-  existsSync as existsSync10,
+  existsSync as existsSync12,
   fsyncSync,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   openSync as openSync4,
-  readFileSync as readFileSync11,
-  renameSync as renameSync4,
-  writeFileSync as writeFileSync8
+  readFileSync as readFileSync13,
+  renameSync as renameSync5,
+  writeFileSync as writeFileSync9
 } from "node:fs";
-import path21 from "node:path";
+import path23 from "node:path";
 
 // ../core/src/control/verify.ts
 var GRANT_MAX_MS = 24 * 36e5;
@@ -4047,6 +4896,11 @@ var CMD_MAX = 48e3;
 var TEXT_MAX = 2e4;
 var NOTE_MAX = 2e3;
 var GRANT_STR_MAX = 2e3;
+var FILES_MAX = 10;
+var FILE_SIZE_MAX = 26214400;
+var FILES_TOTAL_MAX = 52428800;
+var FILE_NAME_MAX = 200;
+var FILE_TYPE_MAX = 100;
 var COMMAND_TYPE = "sessionpipe.control";
 var GRANT_TYPE = "sessionpipe.grant";
 var CONTROL_KINDS = ["prompt", "permission.answer", "cancel", "start", "key.add"];
@@ -4059,6 +4913,9 @@ var HARNESS_RE = /^[a-z][a-z0-9-]{0,39}$/;
 var SESSION_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
 var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var B64URL_RE = /^[A-Za-z0-9_-]*$/;
+var SHA256_RE = /^[A-Za-z0-9_-]{43}$/;
+var MEDIA_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
+var BAD_NAME_CHAR_RE = /[/\\\x00-\x1f\x7f]/;
 var UP = 1;
 var UV = 4;
 var enc = new TextEncoder();
@@ -4129,7 +4986,7 @@ async function importKey(key) {
       const k = await crypto.subtle.importKey("spki", u8(spki), { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" }, false, [
         "verify"
       ]);
-      const bits = k.algorithm.modulusLength ?? 0;
+      const bits = k.algorithm.modulusLength;
       return bits >= 2048 ? k : null;
     }
   } catch {
@@ -4248,7 +5105,11 @@ function parseCommand(str) {
       if (!text()) return bad("bad_fields", `a new session needs text, at most ${TEXT_MAX} characters`);
       if (typeof c.cwd !== "string" || !isAbsolute(c.cwd) || c.cwd.length > 1024)
         return bad("bad_fields", "a new session needs an absolute folder");
-      if (has2("for") || has2("decision")) return bad("bad_fields", "a start carries text and cwd");
+      if (has2("for") || has2("decision")) return bad("bad_fields", "a start carries text, cwd and files");
+      if (has2("files")) {
+        const why = filesProblem(c.files);
+        if (why) return bad("bad_fields", why);
+      }
       break;
     case "permission.answer":
       if (typeof c.for !== "string" || !c.for || c.for.length > 128) return bad("bad_fields", "which attention?");
@@ -4273,10 +5134,42 @@ function parseCommand(str) {
     }
   }
   if (c.kind !== "key.add" && (has2("key") || has2("name"))) return bad("bad_fields", "only a key.add carries a key");
+  if (c.kind !== "start" && has2("files")) return bad("bad_fields", "only a start carries files");
   if (has2("note") && (typeof c.note !== "string" || c.note.length > NOTE_MAX))
     return bad("bad_fields", `a note is text, at most ${NOTE_MAX} characters`);
   return { ok: true, cmd: c };
 }
+function filesProblem(files) {
+  if (!Array.isArray(files) || files.length < 1 || files.length > FILES_MAX)
+    return `files is a list of 1 to ${FILES_MAX} files`;
+  const seen = /* @__PURE__ */ new Set();
+  let total = 0;
+  for (const f of files) {
+    if (!f || typeof f !== "object" || Array.isArray(f)) return "each file is an object";
+    const { name, type, size, sha256: hash } = f;
+    const why = fileNameProblem(name);
+    if (why) return why;
+    const key = name.normalize("NFC").toLowerCase();
+    if (seen.has(key)) return "two files have the same name";
+    seen.add(key);
+    if (typeof type !== "string" || type.length > FILE_TYPE_MAX || !MEDIA_TYPE_RE.test(type))
+      return "a file's type isn't a media type";
+    if (!isNum(size) || !Number.isInteger(size) || size < 1 || size > FILE_SIZE_MAX)
+      return `a file is 1 byte to ${FILE_SIZE_MAX / 1048576} MiB`;
+    total += size;
+    if (typeof hash !== "string" || !SHA256_RE.test(hash)) return "a file's sha256 isn't 43 base64url characters";
+  }
+  if (total > FILES_TOTAL_MAX) return `the files add up to more than ${FILES_TOTAL_MAX / 1048576} MiB`;
+  return null;
+}
+function fileNameProblem(name) {
+  if (typeof name !== "string") return "a file has no name";
+  const n = name.normalize("NFC");
+  if (n.length < 1 || n.length > FILE_NAME_MAX) return `a file name is 1 to ${FILE_NAME_MAX} characters`;
+  if (BAD_NAME_CHAR_RE.test(n)) return "a file name has a slash, a backslash or a control character";
+  if (n.startsWith(".")) return "a file name can't start with a dot";
+  return null;
+}
 function isAbsolute(p) {
   return p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p);
 }
@@ -4298,7 +5191,7 @@ function parseGrant(str, rpId) {
   if (g.exp - g.iat > GRANT_MAX_MS + SKEW_MS) return { ok: false, why: "the grant lasts longer than a day" };
   return { ok: true, grant: g };
 }
-async function verifyCsig(cmd2, csig, pub) {
+async function verifyCsig(cmd, csig, pub) {
   const sig = fromB64url(csig);
   const spki = fromB64url(pub);
   if (sig?.length !== 64 || !spki) return false;
@@ -4306,7 +5199,7 @@ async function verifyCsig(cmd2, csig, pub) {
     const key = await crypto.subtle.importKey("spki", u8(spki), { name: "ECDSA", namedCurve: "P-256" }, false, [
       "verify"
     ]);
-    return await crypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, key, u8(sig), u8(enc.encode(cmd2)));
+    return await crypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, key, u8(sig), u8(enc.encode(cmd)));
   } catch {
     return false;
   }
@@ -4371,22 +5264,22 @@ async function checkGrantPath(s, c, o) {
 }
 
 // src/control/store.ts
-var controlFile = (env = process.env) => path21.join(path21.dirname(configFile(env)), "control.json");
-var controlState = (env = process.env) => path21.join(stateDir(env), "control");
+var controlFile = (env = process.env) => path23.join(path23.dirname(configFile(env)), "control.json");
+var controlState = (env = process.env) => path23.join(stateDir(env), "control");
 function writePrivate(file, value) {
-  mkdirSync9(path21.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync10(path23.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync8(tmp, `${JSON.stringify(value, null, 2)}
+  writeFileSync9(tmp, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
-  renameSync4(tmp, file);
+  renameSync5(tmp, file);
   try {
-    chmodSync3(file, 384);
+    chmodSync4(file, 384);
   } catch {
   }
 }
 function readControl(env = process.env, run = defaultRunner) {
   try {
-    const j = JSON.parse(readFileSync11(controlFile(env), "utf8"));
+    const j = JSON.parse(readFileSync13(controlFile(env), "utf8"));
     if (!j || !Array.isArray(j.receivers)) return null;
     return {
       name: j.name || "machine",
@@ -4403,7 +5296,7 @@ function readControl(env = process.env, run = defaultRunner) {
 }
 function pairedCount(env = process.env) {
   try {
-    const j = JSON.parse(readFileSync11(controlFile(env), "utf8"));
+    const j = JSON.parse(readFileSync13(controlFile(env), "utf8"));
     return Array.isArray(j.receivers) ? j.receivers.length : 0;
   } catch {
     return 0;
@@ -4453,15 +5346,15 @@ var NonceStore = class {
     this.now = now;
     let raw = "";
     try {
-      raw = readFileSync11(file, "utf8");
+      raw = readFileSync13(file, "utf8");
     } catch {
     }
-    const cut = this.now() - NONCE_TTL_MS;
+    const cut2 = this.now() - NONCE_TTL_MS;
     for (const line of raw.split("\n")) {
       if (!line) continue;
       try {
         const { n, t } = JSON.parse(line);
-        if (typeof n === "string" && t > cut) this.seenAt.set(n, t);
+        if (typeof n === "string" && t > cut2) this.seenAt.set(n, t);
       } catch {
       }
     }
@@ -4474,7 +5367,7 @@ var NonceStore = class {
     const t = this.seenAt.get(nonce);
     if (t !== void 0 && t > this.now() - NONCE_TTL_MS) return true;
     const at = this.now();
-    mkdirSync9(path21.dirname(this.file), { recursive: true, mode: 448 });
+    mkdirSync10(path23.dirname(this.file), { recursive: true, mode: 448 });
     const fd = openSync4(this.file, "a", 384);
     try {
       appendFileSync4(fd, `${JSON.stringify({ n: nonce, t: at })}
@@ -4488,14 +5381,14 @@ var NonceStore = class {
   };
   /** Rewrite the file with only the live window (on start, and daily). */
   compact() {
-    const cut = this.now() - NONCE_TTL_MS;
-    for (const [n, t] of this.seenAt) if (t <= cut) this.seenAt.delete(n);
-    if (!existsSync10(this.file) && !this.seenAt.size) return;
+    const cut2 = this.now() - NONCE_TTL_MS;
+    for (const [n, t] of this.seenAt) if (t <= cut2) this.seenAt.delete(n);
+    if (!existsSync12(this.file) && !this.seenAt.size) return;
     const body = [...this.seenAt].map(([n, t]) => JSON.stringify({ n, t })).join("\n");
-    mkdirSync9(path21.dirname(this.file), { recursive: true, mode: 448 });
-    writeFileSync8(`${this.file}.tmp`, body ? `${body}
+    mkdirSync10(path23.dirname(this.file), { recursive: true, mode: 448 });
+    writeFileSync9(`${this.file}.tmp`, body ? `${body}
 ` : "", { mode: 384 });
-    renameSync4(`${this.file}.tmp`, this.file);
+    renameSync5(`${this.file}.tmp`, this.file);
   }
   get size() {
     return this.seenAt.size;
@@ -4508,27 +5401,27 @@ var AckOutbox = class {
   file;
   all() {
     try {
-      return readFileSync11(this.file, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+      return readFileSync13(this.file, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
     } catch {
       return [];
     }
   }
   add(a) {
-    mkdirSync9(path21.dirname(this.file), { recursive: true, mode: 448 });
+    mkdirSync10(path23.dirname(this.file), { recursive: true, mode: 448 });
     appendFileSync4(this.file, `${JSON.stringify(a)}
 `, { mode: 384 });
   }
   keep(left) {
-    mkdirSync9(path21.dirname(this.file), { recursive: true, mode: 448 });
-    writeFileSync8(`${this.file}.tmp`, left.map((a) => JSON.stringify(a)).join("\n") + (left.length ? "\n" : ""), {
+    mkdirSync10(path23.dirname(this.file), { recursive: true, mode: 448 });
+    writeFileSync9(`${this.file}.tmp`, left.map((a) => JSON.stringify(a)).join("\n") + (left.length ? "\n" : ""), {
       mode: 384
     });
-    renameSync4(`${this.file}.tmp`, this.file);
+    renameSync5(`${this.file}.tmp`, this.file);
   }
 };
 function readState(file) {
   try {
-    const j = JSON.parse(readFileSync11(file, "utf8"));
+    const j = JSON.parse(readFileSync13(file, "utf8"));
     return { copies: j.copies && typeof j.copies === "object" ? j.copies : {} };
   } catch {
     return { copies: {} };
@@ -4541,10 +5434,10 @@ var UPDATE_EXIT = 75;
 var DAY_MS = 24 * 36e5;
 var LABEL3 = "org.sessionpipe.control";
 var UNIT = "sessionpipe-control.service";
-var updateFile = (env = process.env) => path22.join(controlState(env), "update.json");
+var updateFile = (env = process.env) => path24.join(controlState(env), "update.json");
 function readUpdate(file) {
   try {
-    const j = JSON.parse(readFileSync12(file, "utf8"));
+    const j = JSON.parse(readFileSync14(file, "utf8"));
     return j && typeof j === "object" ? j : {};
   } catch {
     return {};
@@ -4607,7 +5500,7 @@ function restartVia(o) {
   if (o.platform === "linux") {
     let cg = "";
     try {
-      cg = (o.cgroup ?? (() => readFileSync12("/proc/self/cgroup", "utf8")))();
+      cg = (o.cgroup ?? (() => readFileSync14("/proc/self/cgroup", "utf8")))();
     } catch {
     }
     const inUnit = cg.split("\n").some((l) => l.endsWith(`/${UNIT}`) || l.includes(`/${UNIT}/`));
@@ -4837,14 +5730,112 @@ function supervise(o) {
 }
 
 // src/control/cli.ts
-import { existsSync as existsSync13, realpathSync as realpathSync5, unwatchFile, watchFile } from "node:fs";
-import os9 from "node:os";
-import path25 from "node:path";
+import { existsSync as existsSync16, realpathSync as realpathSync6, statSync as statSync10, unwatchFile, watchFile } from "node:fs";
+import os10 from "node:os";
+import path28 from "node:path";
 
 // src/control/daemon.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync13, realpathSync as realpathSync4, statSync as statSync9, unlinkSync as unlinkSync5 } from "node:fs";
+import { chmodSync as chmodSync5, existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync15, realpathSync as realpathSync5, statSync as statSync9, unlinkSync as unlinkSync5 } from "node:fs";
 import net2 from "node:net";
-import path23 from "node:path";
+import path26 from "node:path";
+
+// src/control/files.ts
+import { createHash as createHash7 } from "node:crypto";
+import { existsSync as existsSync13, lstatSync, mkdirSync as mkdirSync11, realpathSync as realpathSync4, rmSync as rmSync2, writeFileSync as writeFileSync10 } from "node:fs";
+import path25 from "node:path";
+var FETCH_TIMEOUT_MS = 5 * 6e4;
+var FileProblem = class extends Error {
+};
+var b64url2 = (b) => b.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var reason = (e) => (e instanceof Error ? e.message : String(e)).slice(0, 160);
+async function fetchFiles(files, o) {
+  const out2 = [];
+  for (const file of files) {
+    let bytes;
+    try {
+      bytes = await fetchOne(file, o);
+    } catch (e) {
+      if (e instanceof FileProblem) throw e;
+      throw new FileProblem(`couldn't download ${JSON.stringify(file.name)}: ${reason(e)}`);
+    }
+    out2.push({ file, name: file.name.normalize("NFC"), bytes });
+  }
+  return out2;
+}
+async function fetchOne(f, o) {
+  const label = JSON.stringify(f.name);
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), o.timeoutMs ?? FETCH_TIMEOUT_MS);
+  try {
+    const res = await o.fetch(`${o.control.replace(/\/$/, "")}/files/${f.sha256}`, {
+      headers: { authorization: `Bearer ${o.token}` },
+      signal: ctl.signal
+    });
+    if (res.status === 404) throw new FileProblem(`${label} isn't on the receiver (never uploaded, or expired)`);
+    if (res.status !== 200) throw new FileProblem(`couldn't download ${label}: HTTP ${res.status}`);
+    if (Number(res.headers.get("content-length")) > f.size) throw tooLong(label, f);
+    const buf = new Uint8Array(f.size);
+    let got = 0;
+    const reader = res.body.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (got + value.length > f.size) throw tooLong(label, f);
+      buf.set(value, got);
+      got += value.length;
+    }
+    if (got !== f.size) throw new FileProblem(`${label} is ${got} bytes, not its signed ${f.size}`);
+    const hash = b64url2(createHash7("sha256").update(buf).digest());
+    if (hash !== f.sha256) throw new FileProblem(`${label} doesn't match its signed hash: it was changed`);
+    return buf;
+  } finally {
+    clearTimeout(t);
+    ctl.abort();
+  }
+}
+var tooLong = (label, f) => new FileProblem(`${label} is larger than its signed size (${f.size} bytes)`);
+function realDir(p, why) {
+  mkdirSync11(p, { recursive: true, mode: 448 });
+  if (lstatSync(p).isSymbolicLink()) throw new FileProblem(`${why} is a symlink`);
+}
+function writeFiles(cwd, session, files) {
+  const top = path25.join(cwd, ".sessionpipe");
+  const parent = path25.join(top, "files");
+  const dir = path25.join(parent, session);
+  let made = false;
+  try {
+    realDir(top, ".sessionpipe");
+    const ignore = path25.join(top, ".gitignore");
+    if (!existsSync13(ignore)) writeFileSync10(ignore, "*\n", { flag: "wx", mode: 384 });
+    realDir(parent, ".sessionpipe/files");
+    if (existsSync13(dir)) throw new FileProblem(`.sessionpipe/files/${session} already exists`);
+    mkdirSync11(dir, { mode: 448 });
+    made = true;
+    if (realpathSync4.native(dir) !== dir) throw new FileProblem(".sessionpipe leads outside the session's folder");
+    const rel = [];
+    for (const f of files) {
+      writeFileSync10(path25.join(dir, f.name), f.bytes, { flag: "wx", mode: 384 });
+      rel.push(`.sessionpipe/files/${session}/${f.name}`);
+    }
+    return rel;
+  } catch (e) {
+    if (made) rmSync2(dir, { recursive: true, force: true });
+    if (e instanceof FileProblem) throw e;
+    throw new FileProblem(`couldn't save the files: ${reason(e)}`);
+  }
+}
+function humanSize(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1048576) return `${Math.round(n / 1024)} KB`;
+  return `${(n / 1048576).toFixed(1)} MB`;
+}
+function withFiles(text, files, rel) {
+  const lines = files.map((f, i) => `- ${rel[i]} (${f.file.type}, ${humanSize(f.file.size)})`);
+  return `${text}
+
+Attached files (saved in this folder):
+${lines.join("\n")}`;
+}
 
 // src/control/reply.ts
 import { closeSync as closeSync5, openSync as openSync5, readSync as readSync4, statSync as statSync8 } from "node:fs";
@@ -4891,9 +5882,9 @@ async function awaitAnswer(file, from, o) {
         const n = readSync4(fd, buf, 0, buf.length, offset);
         offset += n;
         const chunk = partial + buf.subarray(0, n).toString("utf8");
-        const cut = chunk.lastIndexOf("\n");
-        partial = cut < 0 ? chunk : chunk.slice(cut + 1);
-        if (cut >= 0) lines.push(...chunk.slice(0, cut).split("\n").filter(Boolean));
+        const cut2 = chunk.lastIndexOf("\n");
+        partial = cut2 < 0 ? chunk : chunk.slice(cut2 + 1);
+        if (cut2 >= 0) lines.push(...chunk.slice(0, cut2).split("\n").filter(Boolean));
       } finally {
         closeSync5(fd);
       }
@@ -4926,7 +5917,7 @@ function kindPath(kind, harness) {
     case "prompt":
       return "prompt";
     case "permission.answer":
-      return harness === "gemini-cli" ? { unsupported: "Gemini CLI has no permission answer channel" } : "permission";
+      return harness === "gemini-cli" ? { unsupported: "Gemini CLI has no permission answer channel" } : harness === "devin" ? { unsupported: "Devin has no permission answer channel" } : "permission";
     case "cancel":
       return "cancel";
     case "start":
@@ -5046,16 +6037,16 @@ var {
   recentlyWritten: recentlyWritten2,
   sessionFolder: sessionFolder2
 } = claude_code_control_exports;
-function startNamed(cmd2) {
-  if (typeof cmd2 !== "string" || cmd2.length > 64 * 1024 || !cmd2.includes('"start"')) return null;
+function startNamed(cmd) {
+  if (typeof cmd !== "string" || cmd.length > 64 * 1024 || !cmd.includes('"start"')) return null;
   try {
-    const c = JSON.parse(cmd2);
+    const c = JSON.parse(cmd);
     return c?.kind === "start" && typeof c.session === "string" ? c.session : null;
   } catch {
     return null;
   }
 }
-var VERSION2 = true ? "0.7.0" : "0.0.0";
+var VERSION2 = true ? "0.9.0" : "0.0.0";
 var MAX_REPLY = 2e4;
 var HELLO_EVERY_MS = 10 * 6e4;
 var TURN_FALLBACK_MS = 30 * 6e4;
@@ -5091,9 +6082,9 @@ var ControlDaemon = class {
     this.dir = dir;
     this.sock = sock;
     this.deps = deps;
-    this.nonces = new NonceStore(path23.join(dir, "nonces.jsonl"), deps.now);
-    this.acks = new AckOutbox(path23.join(dir, "acks.jsonl"));
-    this.state = readState(path23.join(dir, "state.json"));
+    this.nonces = new NonceStore(path26.join(dir, "nonces.jsonl"), deps.now);
+    this.acks = new AckOutbox(path26.join(dir, "acks.jsonl"));
+    this.state = readState(path26.join(dir, "state.json"));
     this.aliases = readAliases(aliasFile(dir));
   }
   cfg;
@@ -5149,7 +6140,7 @@ var ControlDaemon = class {
   // --- lifecycle ------------------------------------------------------------------
   async start() {
     this.running = true;
-    mkdirSync10(this.dir, { recursive: true, mode: 448 });
+    mkdirSync12(this.dir, { recursive: true, mode: 448 });
     await this.listen();
     for (const r of this.cfg.receivers) void this.pollLoop(r);
     this.helloTimer = setInterval(() => void this.helloAll(), HELLO_EVERY_MS);
@@ -5173,6 +6164,7 @@ var ControlDaemon = class {
     this.running = false;
     this.paused?.go();
     for (const a of this.aborts) a.abort();
+    for (const st of this.polling.values()) st.wake?.();
     if (this.helloTimer) clearInterval(this.helloTimer);
     if (this.helloSoon) clearTimeout(this.helloSoon);
     if (this.ownTimer) clearInterval(this.ownTimer);
@@ -5242,7 +6234,12 @@ var ControlDaemon = class {
       try {
         await this.listen();
       } catch (e) {
-        this.deps.log(`couldn't listen again: ${String(e?.message || e)}`);
+        this.deps.log(
+          `couldn't listen again: ${String(
+            /* v8 ignore next -- listen() throws Errors (net, DaemonRunning) */
+            e?.message || e
+          )}`
+        );
       }
       return;
     }
@@ -5252,8 +6249,10 @@ var ControlDaemon = class {
   }
   reload(cfg) {
     const known = new Set(this.cfg.receivers.map((r) => r.control + r.machine));
+    const told = JSON.stringify([this.cfg.folders, this.cfg.mode, this.cfg.name]);
     this.cfg = cfg;
     for (const r of cfg.receivers) if (!known.has(r.control + r.machine)) void this.pollLoop(r);
+    if (this.running && JSON.stringify([cfg.folders, cfg.mode, cfg.name]) !== told) void this.helloAll();
   }
   status() {
     return {
@@ -5268,6 +6267,7 @@ var ControlDaemon = class {
           keys: r.keys.length,
           polling: !!p?.on,
           last_poll: p?.last ?? null,
+          last_poll_age_ms: p ? Math.max(0, this.deps.now() - (p.last ?? p.started)) : 0,
           last_error: p?.error ?? null
         };
       }),
@@ -5290,7 +6290,7 @@ var ControlDaemon = class {
     if (other?.op === "status") throw new DaemonRunning(other.status ?? {});
     if (process.platform !== "win32") {
       try {
-        if (existsSync11(this.sock)) unlinkSync5(this.sock);
+        if (existsSync14(this.sock)) unlinkSync5(this.sock);
       } catch {
       }
     }
@@ -5299,7 +6299,10 @@ var ControlDaemon = class {
       this.server.once("error", reject);
       this.server.listen(this.sock, () => resolve());
     });
-    if (process.platform !== "win32") this.sockId = socketId(this.sock);
+    if (process.platform !== "win32") {
+      chmodSync5(this.sock, 384);
+      this.sockId = socketId(this.sock);
+    }
   }
   onConn(s) {
     let buf = "";
@@ -5441,8 +6444,30 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
   // --- receivers ------------------------------------------------------------------
   async pollLoop(first) {
     const key = first.control + first.machine;
-    const st = { last: null, error: null, on: true };
+    const st = {
+      started: this.deps.now(),
+      last: null,
+      error: null,
+      on: true,
+      unauthorized: false,
+      authBackoff: 0,
+      wake: null
+    };
     this.polling.set(key, st);
+    const retry = (ms) => new Promise((resolve) => {
+      st.on = false;
+      if (!this.running) {
+        resolve();
+        return;
+      }
+      const timer = setTimeout(() => st.wake?.(), ms);
+      timer.unref();
+      st.wake = () => {
+        clearTimeout(timer);
+        st.wake = null;
+        resolve();
+      };
+    });
     let backoff = 0;
     let downSince = 0;
     const steps = [1e3, 2e3, 5e3, 1e4, 15e3];
@@ -5451,6 +6476,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       const r = this.cfg.receivers.find((x) => x.control + x.machine === key);
       if (!this.running || !r) break;
       if (this.paused) {
+        st.on = false;
         await this.paused.until;
         continue;
       }
@@ -5463,11 +6489,12 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
           if (!st.error?.startsWith("can't read"))
             this.deps.log(`${r.url}: can't read this machine's token from ${r.token_in ?? "its store"}; retrying`);
           st.error = `can't read this machine's token from ${r.token_in ?? "its store"} (locked?); retrying every 30 s`;
-          await new Promise((res) => setTimeout(res, 3e4));
+          await retry(3e4);
           continue;
         }
       }
       const ctl = new AbortController();
+      st.on = true;
       this.aborts.add(ctl);
       const t = setTimeout(() => ctl.abort(), 35e3);
       try {
@@ -5476,15 +6503,21 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
         u.searchParams.set("wait", "25");
         const asked = this.deps.now();
         const res = await this.deps.fetch(u, { headers: { authorization: `Bearer ${r.token}` }, signal: ctl.signal });
-        st.last = this.deps.now();
-        if (downSince && res.status < 500) {
+        if (res.status !== 200) clearTimeout(t);
+        st.unauthorized = res.status === 401;
+        if (downSince && (res.status === 200 || res.status === 204)) {
           this.deps.log(`${r.url}: back after ${Math.round((asked - downSince) / 1e3)} s (${backoff} failed tries)`);
           downSince = 0;
         }
         if (res.status === 401) {
           st.error = "the receiver no longer knows this machine (401); run `sessionpipe control pair` again";
           this.deps.log(`${r.url}: ${st.error}`);
-          break;
+          downSince ||= this.deps.now();
+          backoff++;
+          const delay = Math.min(6e4 * 2 ** st.authBackoff, 30 * 6e4);
+          st.authBackoff = Math.min(st.authBackoff + 1, 5);
+          await retry(delay);
+          continue;
         }
         if (res.status === 200) {
           let fresh = 0;
@@ -5495,29 +6528,47 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
             for (const m of body.messages ?? []) {
               if (m && !this.inflight.has(m.id)) fresh++;
               void this.handle(cur, m).catch(
-                (e) => this.deps.log(`handle ${String(m?.id).slice(-8)}: ${String(e?.message || e)}`)
+                (e) => this.deps.log(
+                  `handle ${String(m?.id).slice(-8)}: ${String(
+                    /* v8 ignore next -- handle() rejects with an Error (the ack file) */
+                    e?.message || e
+                  )}`
+                )
               );
             }
           } finally {
             this.receiving--;
           }
-          if (!fresh) await sleep2(2e3);
+          clearTimeout(t);
+          st.last = this.deps.now();
           st.error = null;
+          st.authBackoff = 0;
           backoff = 0;
+          if (!fresh) await sleep2(2e3);
         } else if (res.status === 204) {
+          st.last = this.deps.now();
           st.error = null;
+          st.authBackoff = 0;
           backoff = 0;
         } else {
           st.error = `HTTP ${res.status}`;
           downSince ||= this.deps.now();
-          await sleep2(pause(backoff++));
+          let delay = pause(backoff++);
+          if (res.status === 503) {
+            const after = res.headers.get("retry-after");
+            const ms = after && /^\d+$/.test(after) ? Number(after) * 1e3 : Date.parse(after ?? "") - this.deps.now();
+            if (Number.isFinite(ms)) delay = Math.max(delay, ms);
+          }
+          await retry(Math.min(delay, 2147483647));
         }
       } catch (e) {
         if (!this.running) break;
         if (this.paused) continue;
         st.error = String(e?.message || e).slice(0, 120);
+        st.unauthorized = false;
         downSince ||= this.deps.now();
-        await sleep2(pause(backoff++));
+        clearTimeout(t);
+        await retry(pause(backoff++));
       } finally {
         clearTimeout(t);
         this.aborts.delete(ctl);
@@ -5561,6 +6612,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     const waiting = [...this.live].filter(([, l]) => l.waiter).map(([k]) => k);
     const modes = ["waiter", "turn", "resume", "fork", ...this.deps.sdk ? ["sdk"] : []];
     const harnesses = this.harnesses();
+    const accounts = this.accounts();
     for (const r of this.cfg.receivers) {
       const body = {
         name: this.cfg.name,
@@ -5570,10 +6622,20 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
         version: VERSION2,
         waiting,
         folders: this.cfg.folders,
-        mode: this.cfg.mode
+        mode: this.cfg.mode,
+        ...accounts.length ? { accounts } : {},
+        // This daemon takes `files` on a start (an older one would start without them).
+        files: true
       };
-      await this.post(r, "/hello", body).catch(() => {
-      });
+      const res = await this.post(r, "/hello", body).catch(() => null);
+      const st = this.polling.get(r.control + r.machine);
+      if (res?.ok && st?.unauthorized) {
+        st.unauthorized = false;
+        st.authBackoff = 0;
+        st.error = null;
+        this.deps.log(`${r.url}: hello accepted; retrying control poll now`);
+        st.wake?.();
+      }
     }
   }
   async post(r, sub, body) {
@@ -5674,30 +6736,30 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       this.deps.log(`refused ${m.id.slice(-8)}: ${v.code} \u2014 ${v.why}`);
       return this.finish(r, m.id, { outcome: "refused", code: v.code, detail: v.why });
     }
-    const cmd2 = v.cmd;
-    if (cmd2.kind === "key.add") return this.addKey(r, m.id, cmd2, sent);
-    const ref = parseSessionRef(cmd2.session);
-    const kp = kindPath(cmd2.kind, ref.harness);
+    const cmd = v.cmd;
+    if (cmd.kind === "key.add") return this.addKey(r, m.id, cmd, sent);
+    const ref = parseSessionRef(cmd.session);
+    const kp = kindPath(cmd.kind, ref.harness);
     if (typeof kp === "object") return this.finish(r, m.id, { outcome: "unsupported", detail: kp.unsupported });
     try {
-      if (kp === "start") return await this.startSession(r, m.id, cmd2, sent);
-      let place = this.place(cmd2.session);
-      const starting = kp === "prompt" ? this.startsPending.get(cmd2.session) : void 0;
+      if (kp === "start") return await this.startSession(r, m.id, cmd, sent);
+      let place = this.place(cmd.session);
+      const starting = kp === "prompt" ? this.startsPending.get(cmd.session) : void 0;
       if ("refused" in place && (starting || this.ownRuns.has(ref.id))) {
         this.finish(r, m.id, { outcome: "taken" });
         await starting;
         await this.serial(ref.id, async () => {
         });
-        place = this.place(cmd2.session);
+        place = this.place(cmd.session);
       }
       if ("refused" in place)
         return this.finish(r, m.id, { outcome: "refused", code: place.refused, detail: place.why });
-      if (kp === "permission") return this.permission(r, m.id, cmd2, sent);
-      if (kp === "cancel") return await this.cancel(r, m.id, cmd2, sent);
-      return await this.serial(`deliver:${cmd2.session}`, async () => {
-        const now = this.place(cmd2.session);
+      if (kp === "permission") return this.permission(r, m.id, cmd, sent);
+      if (kp === "cancel") return await this.cancel(r, m.id, cmd, sent);
+      return await this.serial(`deliver:${cmd.session}`, async () => {
+        const now = this.place(cmd.session);
         if ("refused" in now) return this.finish(r, m.id, { outcome: "refused", code: now.refused, detail: now.why });
-        return this.prompt(r, m.id, cmd2, now, sent);
+        return this.prompt(r, m.id, cmd, now, sent);
       });
     } catch (e) {
       this.finish(r, m.id, { outcome: "failed", detail: String(e?.message || e) });
@@ -5712,7 +6774,8 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     if (ref.harness === "claude-code") {
       const target = this.state.copies[ref.id] ?? ref.id;
       const t = findTranscript2(target, this.deps.claudeDirs()) ?? findTranscript2(ref.id, this.deps.claudeDirs());
-      if (!t) return { refused: "no_session", why: `no Claude Code session ${ref.id.slice(0, 8)} on this machine` };
+      if (!t)
+        return { refused: "no_session", why: `no Claude Code session ${shortId(ref.harness, ref.id)} on this machine` };
       const folder = sessionFolder2(t);
       const ok2 = folder && this.allowed(folder);
       if (!ok2) return { refused: "folder", why: "that session's folder isn't one this machine allows" };
@@ -5733,13 +6796,14 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     let file = null;
     if (ref.harness === "codex") {
       file = isUuid2(target) ? codex_control_exports.findRollout(target, this.deps.env ?? process.env) : null;
-      if (!a && !file) return { refused: "no_session", why: `no Codex session ${ref.id.slice(0, 8)} on this machine` };
+      if (!a && !file)
+        return { refused: "no_session", why: `no Codex session ${shortId(ref.harness, ref.id)} on this machine` };
       cwd ||= file ? codex_control_exports.codexFacts(file).cwd : void 0;
     } else cwd ||= this.live.get(session)?.cwd || this.factsCwd(ref.harness, ref.id);
     if (!cwd)
       return {
         refused: "no_session",
-        why: `no folder known for ${ref.harness === "codex" ? "Codex" : "Antigravity"} session ${ref.id.slice(0, 8)}`
+        why: `no folder known for ${ref.harness === "codex" ? "Codex" : "Antigravity"} session ${shortId(ref.harness, ref.id)}`
       };
     const ok = this.allowed(cwd);
     if (!ok) return { refused: "folder", why: "that session's folder isn't one this machine allows" };
@@ -5748,9 +6812,9 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
   /** The folder the worker recorded for a session from its hooks (run.ts, facts). */
   factsCwd(harness, id) {
     try {
-      const f = path23.join(path23.dirname(this.dir), "facts", safeId(harness), `${safeId(id)}.json`);
-      const cwd = JSON.parse(readFileSync13(f, "utf8")).cwd;
-      return typeof cwd === "string" && path23.isAbsolute(cwd) ? cwd : void 0;
+      const f = path26.join(path26.dirname(this.dir), "facts", safeId(harness), `${safeId(id)}.json`);
+      const cwd = JSON.parse(readFileSync15(f, "utf8")).cwd;
+      return typeof cwd === "string" && path26.isAbsolute(cwd) ? cwd : void 0;
     } catch {
       return void 0;
     }
@@ -5769,7 +6833,10 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       writeAliases(aliasFile(this.dir), this.aliases);
     } catch (e) {
       this.deps.log(
-        `couldn't record ${harness}:${id.slice(0, 8)} \u2192 ${real.slice(0, 8)}: ${String(e?.message || e)}`
+        `couldn't record ${harness}:${id.slice(0, 8)} \u2192 ${real.slice(0, 8)}: ${String(
+          /* v8 ignore next -- writeAliases throws fs Errors */
+          e?.message || e
+        )}`
       );
     }
   }
@@ -5802,6 +6869,14 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       };
     return null;
   }
+  /** Who is signed in here, for hello. A bad .claude.json names nobody, never fails a hello. */
+  accounts() {
+    try {
+      return this.deps.accounts ? this.deps.accounts() : claudeAccounts(this.deps.claudeDirs());
+    } catch {
+      return [];
+    }
+  }
   /** The harnesses this machine can run a message in, for hello. */
   harnesses() {
     if (this.deps.harnesses) return this.deps.harnesses();
@@ -5812,10 +6887,10 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     ];
   }
   allowed(dir) {
-    if (!path23.isAbsolute(dir)) return null;
+    if (!path26.isAbsolute(dir)) return null;
     let r;
     try {
-      r = realpathSync4.native(dir);
+      r = realpathSync5.native(dir);
       if (!statSync9(r).isDirectory()) return null;
     } catch {
       return null;
@@ -5823,18 +6898,18 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     for (const f of this.cfg.folders) {
       let rf = f;
       try {
-        rf = realpathSync4.native(f);
+        rf = realpathSync5.native(f);
       } catch {
       }
-      if (r === rf || r.startsWith(rf.endsWith(path23.sep) ? rf : rf + path23.sep)) return r;
+      if (r === rf || r.startsWith(rf.endsWith(path26.sep) ? rf : rf + path26.sep)) return r;
     }
     return null;
   }
-  permission(r, id, cmd2, sent) {
-    const l = this.live.get(cmd2.session);
-    const hook = l?.attentions.get(cmd2.for);
+  permission(r, id, cmd, sent) {
+    const l = this.live.get(cmd.session);
+    const hook = l?.attentions.get(cmd.for);
     if (!hook) {
-      if (cmd2.decision === "allow")
+      if (cmd.decision === "allow")
         return this.finish(r, id, {
           outcome: "refused",
           code: "no_attention",
@@ -5843,17 +6918,17 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       this.finish(r, id, { outcome: "expired", detail: "the prompt was already answered or closed" });
       return;
     }
-    l.attentions.delete(cmd2.for);
+    l.attentions.delete(cmd.for);
     this.reply(hook, {
       op: "decision",
-      behavior: cmd2.decision,
-      ...cmd2.note ? { message: cmd2.note } : {},
+      behavior: cmd.decision,
+      ...cmd.note ? { message: cmd.note } : {},
       id
     });
     this.finish(r, id, { outcome: "delivered", mode: "turn" }, sent);
   }
-  async cancel(r, id, cmd2, sent) {
-    const ref = parseSessionRef(cmd2.session);
+  async cancel(r, id, cmd, sent) {
+    const ref = parseSessionRef(cmd.session);
     const held = this.sdkSessions.get(ref.id);
     if (!held)
       return this.finish(r, id, {
@@ -5880,7 +6955,10 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       };
     }
     const transcript = place.transcript;
-    const claude = ref.harness === "claude-code" ? this.deps.claude() : null;
+    const claude = ref.harness === "claude-code" ? this.deps.claude() : (
+      /* v8 ignore next -- every other harness returned above */
+      null
+    );
     const target = this.state.copies[ref.id] ?? ref.id;
     const t = transcript;
     const live = !this.ownRuns.has(target) && !!t && (liveProcess2(target, t.configDir) || recentlyWritten2(t.file, this.lastEnd.get(target), this.deps.now()));
@@ -5895,25 +6973,25 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       api: false
     };
   }
-  async prompt(r, id, cmd2, place, sent) {
-    const route = routePrompt(this.view(cmd2.session, place));
+  async prompt(r, id, cmd, place, sent) {
+    const route = routePrompt(this.view(cmd.session, place));
     if ("unsupported" in route) return this.finish(r, id, { outcome: "unsupported", detail: route.unsupported });
     if ("refused" in route) return this.finish(r, id, { outcome: "refused", code: route.refused });
-    const ref = parseSessionRef(cmd2.session);
-    const text = cmd2.text;
+    const ref = parseSessionRef(cmd.session);
+    const text = cmd.text;
     switch (route.mode) {
       case "waiter": {
-        const l = this.live.get(cmd2.session);
+        const l = this.live.get(cmd.session);
         const w = l.waiter;
         l.waiter = null;
-        const from = this.answerFrom(cmd2.session);
+        const from = this.answerFrom(cmd.session);
         this.reply(w, { op: "message", text: frame(text, r.url), id });
         this.scheduleHello();
-        return this.followAnswer(r, id, "waiter", cmd2.session, from, sent);
+        return this.followAnswer(r, id, "waiter", cmd.session, from, sent);
       }
       case "turn": {
-        const l = this.liveOf(cmd2.session);
-        const p = { receiver: r, msgId: id, text, session: cmd2.session, queuedAt: sent };
+        const l = this.liveOf(cmd.session);
+        const p = { receiver: r, msgId: id, text, session: cmd.session, queuedAt: sent };
         l.turnQueue.push(p);
         this.finish(r, id, { outcome: "taken" });
         const t = setTimeout(() => {
@@ -5938,7 +7016,8 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       }
       case "resume":
       case "fork":
-        return this.headless(r, id, cmd2, place, route.mode, sent);
+        return this.headless(r, id, cmd, place, route.mode, sent);
+      /* v8 ignore next -- no harness has an input API wired yet (view() says api: false) */
       case "api":
         return this.finish(r, id, { outcome: "unsupported", detail: "no input API wired for this harness" });
     }
@@ -5949,10 +7028,10 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     l.midTurn = false;
     const place = this.place(p.session);
     if ("refused" in place) return this.finish(p.receiver, p.msgId, { outcome: "refused", code: place.refused });
-    const cmd2 = { kind: "prompt", session: p.session, text: p.text };
+    const cmd = { kind: "prompt", session: p.session, text: p.text };
     this.inflight.delete(p.msgId);
     this.inflight.add(p.msgId);
-    await this.prompt(p.receiver, p.msgId, cmd2, place, p.queuedAt).catch(
+    await this.prompt(p.receiver, p.msgId, cmd, place, p.queuedAt).catch(
       (e) => this.finish(p.receiver, p.msgId, { outcome: "failed", detail: String(e?.message || e) })
     );
   }
@@ -5994,14 +7073,19 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     const login = drv.login;
     if (login && !await this.signedIn(`${drv.cmd}:`, () => login(bin))) {
       this.deps.log(`${drv.cmd} isn't signed in as the daemon sees it`);
-      return { failed: drv.loginHint ?? `${drv.label} isn't signed in on this machine` };
+      return {
+        failed: (
+          /* v8 ignore next -- only Codex has a login check, and it has a hint */
+          drv.loginHint ?? `${drv.label} isn't signed in on this machine`
+        )
+      };
     }
     return { bin };
   }
   /** A Codex or Antigravity session's next message: a headless turn resumed under the
    *  harness's own id, after any run of the daemon's own that holds it. */
-  async resumeDriven(r, id, cmd2, place, sent) {
-    const ref = parseSessionRef(cmd2.session);
+  async resumeDriven(r, id, cmd, place, sent) {
+    const ref = parseSessionRef(cmd.session);
     const drv = this.driver(ref.harness);
     const ready = await this.drivenProblem(drv);
     if ("failed" in ready) return this.finish(r, id, { outcome: "failed", detail: ready.failed });
@@ -6010,7 +7094,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       const target = this.aliasOf(ref.harness, ref.id)?.id ?? place.target ?? ref.id;
       const args2 = drv.args({
         mode: this.cfg.mode,
-        prompt: frame(cmd2.text, r.url),
+        prompt: frame(cmd.text, r.url),
         cwd: place.folder,
         resume: target
       });
@@ -6062,8 +7146,8 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
 (${drv.label} didn't find that session on this machine, so this ran in a new one; later messages continue there.)` : "";
     this.finish(r, id, { outcome: "delivered", mode: "resume", reply: out2.reply + moved }, sent);
   }
-  async headless(r, id, cmd2, place, mode, sent) {
-    if (parseSessionRef(cmd2.session)?.harness !== "claude-code") return this.resumeDriven(r, id, cmd2, place, sent);
+  async headless(r, id, cmd, place, mode, sent) {
+    if (parseSessionRef(cmd.session)?.harness !== "claude-code") return this.resumeDriven(r, id, cmd, place, sent);
     const claude = this.deps.claude();
     if (!claude)
       return this.finish(r, id, { outcome: "failed", detail: "Claude Code isn't installed on this machine" });
@@ -6071,7 +7155,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     if ("error" in mf) return this.finish(r, id, { outcome: "refused", code: "mode", detail: mf.error });
     const signedOut = await this.loginProblem(place.transcript?.configDir);
     if (signedOut) return this.finish(r, id, { outcome: "failed", detail: signedOut });
-    const ref = parseSessionRef(cmd2.session);
+    const ref = parseSessionRef(cmd.session);
     this.finish(r, id, { outcome: "taken" });
     await this.serial(ref.id, async () => {
       const target = this.state.copies[ref.id] ?? ref.id;
@@ -6083,7 +7167,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
         ...mf.args,
         ...allow.length ? [`--allowedTools=${allow.join(",")}`] : [],
         ...resume,
-        frame(cmd2.text, r.url)
+        frame(cmd.text, r.url)
       ];
       this.deps.log(`${id.slice(-8)}: claude -p ${[...mf.args, ...resume].join(" ")} in ${place.folder}`);
       const stream = this.answerStream(r, id);
@@ -6105,7 +7189,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       const ran = isUuid2(out2.session) ? out2.session : target;
       if (mode === "fork" && ran !== target) {
         this.state.copies[ref.id] = ran;
-        writeState(path23.join(this.dir, "state.json"), this.state);
+        writeState(path26.join(this.dir, "state.json"), this.state);
         this.lastEnd.set(ran, this.deps.now());
       }
       this.finish(
@@ -6134,9 +7218,9 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     const text = typeof j.result === "string" && j.result.trim() ? j.result : "(Claude Code finished without a written reply.)";
     return { reply: text + tail2, ...typeof j.session_id === "string" ? { session: j.session_id } : {} };
   }
-  addKey(r, id, cmd2, sent) {
-    const k = cmd2.key;
-    const name = typeof cmd2.name === "string" ? cmd2.name.trim().slice(0, 80) : void 0;
+  addKey(r, id, cmd, sent) {
+    const k = cmd.key;
+    const name = typeof cmd.name === "string" ? cmd.name.trim().slice(0, 80) : void 0;
     const rec = this.cfg.receivers.find((x) => x.control === r.control && x.machine === r.machine) ?? r;
     if (rec.keys.some((x) => x.id === k.id))
       return this.finish(r, id, { outcome: "delivered", detail: "that device was already trusted" }, sent);
@@ -6153,7 +7237,10 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       rec.keys = rec.keys.filter((x) => x.id !== k.id);
       return this.finish(r, id, {
         outcome: "failed",
-        detail: `couldn't save the key: ${String(e?.message || e)}`
+        detail: `couldn't save the key: ${String(
+          /* v8 ignore next -- writeControl throws fs Errors */
+          e?.message || e
+        )}`
       });
     }
     this.deps.log(
@@ -6184,7 +7271,16 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       }) : null;
       stream.close();
       this.finish(r, id, { outcome: "delivered", mode, ...answer ? { reply: answer } : {} }, sent);
-    })().catch((e) => this.finish(r, id, { outcome: "delivered", mode, detail: String(e?.message || e) }));
+    })().catch(
+      (e) => this.finish(r, id, {
+        outcome: "delivered",
+        mode,
+        detail: String(
+          /* v8 ignore next -- awaitAnswer throws fs Errors */
+          e?.message || e
+        )
+      })
+    );
   }
   /** The answer so far, sent as a `progress` ack: whole, with a rising seq, at most
    *  one in flight. Fire-and-forget — the final ack carries everything. */
@@ -6238,7 +7334,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       this.procWaiters.shift()?.();
     }
   }
-  async startSession(r, id, cmd2, sent) {
+  async startSession(r, id, cmd, sent) {
     const lim = this.limits();
     const now = this.deps.now();
     this.startTimes = this.startTimes.filter((t) => now - t < 36e5);
@@ -6249,23 +7345,23 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     }
     this.startsRunning++;
     this.startTimes.push(now);
-    const sid = parseSessionRef(cmd2.session).id;
+    const sid = parseSessionRef(cmd.session).id;
     try {
-      await this.serial(sid, () => this.owning(sid, () => this.startOne(r, id, cmd2, sent)));
+      await this.serial(sid, () => this.owning(sid, () => this.startOne(r, id, cmd, sent)));
     } finally {
       this.startsRunning--;
     }
   }
-  async startOne(r, id, cmd2, sent) {
-    const ref = parseSessionRef(cmd2.session);
-    const cwd = this.allowed(cmd2.cwd);
+  async startOne(r, id, cmd, sent) {
+    const ref = parseSessionRef(cmd.session);
+    const cwd = this.allowed(cmd.cwd);
     if (!cwd)
       return this.finish(r, id, {
         outcome: "refused",
         code: "folder",
         detail: "that folder isn't one this machine allows"
       });
-    if (ref.harness !== "claude-code") return this.startDriven(r, id, cmd2, ref, cwd, sent);
+    if (ref.harness !== "claude-code") return this.startDriven(r, id, cmd, ref, cwd, sent);
     if (findTranscript2(ref.id, this.deps.claudeDirs()) || this.sdkSessions.has(ref.id))
       return this.finish(r, id, {
         outcome: "refused",
@@ -6275,12 +7371,14 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     const signedOut = await this.loginProblem(this.deps.env?.CLAUDE_CONFIG_DIR);
     if (signedOut) return this.finish(r, id, { outcome: "failed", detail: signedOut });
     this.finish(r, id, { outcome: "taken" });
+    const text = await this.attached(r, id, cmd, ref, cwd);
+    if (text === null) return;
     if (this.deps.sdk) {
       const sdk = this.deps.sdk;
       const out3 = await this.slot(async () => {
         const s = sdk.start({ session: ref.id, cwd, mode: this.cfg.mode, allowedTools: this.allowedFor(r) });
         this.sdkSessions.set(ref.id, s);
-        return s.send(frameStart(cmd2.text, r.url));
+        return s.send(frameStart(text, r.url));
       });
       return this.finish(
         r,
@@ -6305,7 +7403,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
           ...this.allowedFor(r).length ? [`--allowedTools=${this.allowedFor(r).join(",")}`] : [],
           "--session-id",
           ref.id,
-          frameStart(cmd2.text, r.url)
+          frameStart(text, r.url)
         ],
         {
           cwd,
@@ -6323,10 +7421,10 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
   }
   /** A new Codex or Antigravity session: the harness picks its id, and the start's id
    *  becomes its name (aliases.ts) as soon as the run says what it picked. */
-  async startDriven(r, id, cmd2, ref, cwd, sent) {
+  async startDriven(r, id, cmd, ref, cwd, sent) {
     const drv = this.driver(ref.harness);
     const env = this.deps.env ?? process.env;
-    if (this.aliasOf(ref.harness, ref.id) || this.live.get(cmd2.session)?.cwd || ref.harness === "codex" && isUuid2(ref.id) && codex_control_exports.findRollout(ref.id, env))
+    if (this.aliasOf(ref.harness, ref.id) || this.live.get(cmd.session)?.cwd || ref.harness === "codex" && isUuid2(ref.id) && codex_control_exports.findRollout(ref.id, env))
       return this.finish(r, id, {
         outcome: "refused",
         code: "bad_session",
@@ -6335,10 +7433,38 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     const ready = await this.drivenProblem(drv);
     if ("failed" in ready) return this.finish(r, id, { outcome: "failed", detail: ready.failed });
     this.finish(r, id, { outcome: "taken" });
-    const args2 = drv.args({ mode: this.cfg.mode, prompt: frameStart(cmd2.text, r.url), cwd });
-    this.deps.log(`${id.slice(-8)}: ${drv.cmd} new session for ${ref.id.slice(0, 8)} (${this.cfg.mode}) in ${cwd}`);
+    const text = await this.attached(r, id, cmd, ref, cwd);
+    if (text === null) return;
+    const args2 = drv.args({ mode: this.cfg.mode, prompt: frameStart(text, r.url), cwd });
+    this.deps.log(
+      `${id.slice(-8)}: ${drv.cmd} new session for ${shortId(ref.harness, ref.id)} (${this.cfg.mode}) in ${cwd}`
+    );
     await this.drive(r, id, ref, drv, ready.bin, args2, cwd, sent, null);
   }
+  /** A start's text, with its files (CONTROL.md §6) fetched, checked and written under
+   *  `cwd` first — every check in §5 passed and the nonce is recorded by now, so the
+   *  `taken` ack is out and the download may take its time. Null when a file failed:
+   *  the command is acked `failed` with code `file`, nothing is kept, no session starts. */
+  async attached(r, id, cmd, ref, cwd) {
+    const text = cmd.text;
+    if (!cmd.files) return text;
+    try {
+      const got = await fetchFiles(cmd.files, {
+        control: r.control,
+        token: r.token,
+        fetch: this.deps.fetch,
+        timeoutMs: this.deps.fileTimeoutMs
+      });
+      const rel = writeFiles(cwd, ref.id, got);
+      this.deps.log(`${id.slice(-8)}: ${got.length} file(s) saved in ${cwd}/.sessionpipe/files/${ref.id}`);
+      return withFiles(text, got, rel);
+    } catch (e) {
+      const detail = e.message;
+      this.deps.log(`${id.slice(-8)}: file \u2014 ${detail}`);
+      this.finish(r, id, { outcome: "failed", code: "file", detail });
+      return null;
+    }
+  }
   closeIdleSdk() {
     const idle = this.deps.sdkIdleMs ?? 10 * 6e4;
     for (const [id, s] of this.sdkSessions)
@@ -6362,12 +7488,13 @@ function socketId(p) {
 }
 
 // src/control/pair.ts
-import { execFileSync as execFileSync6 } from "node:child_process";
+import { execFileSync as execFileSync7 } from "node:child_process";
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync11, unlinkSync as unlinkSync6, writeFileSync as writeFileSync9 } from "node:fs";
-import os8 from "node:os";
-import path24 from "node:path";
-var VERSION3 = true ? "0.7.0" : "0.0.0";
+import { existsSync as existsSync15, mkdirSync as mkdirSync13, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "node:fs";
+import os9 from "node:os";
+import path27 from "node:path";
+var VERSION3 = true ? "0.9.0" : "0.0.0";
+var RENEW_FOR_MS = 60 * 6e4;
 async function json(r) {
   try {
     return await r.json();
@@ -6402,55 +7529,89 @@ async function pair(o) {
   const cfg = readControl(o.env) ?? { name: o.name, folders: [], mode: o.mode, receivers: [] };
   cfg.name = o.name || cfg.name;
   cfg.mode = o.mode;
-  cfg.folders = [.../* @__PURE__ */ new Set([...cfg.folders, ...o.folders.map((d) => path24.resolve(d))])];
+  cfg.folders = [.../* @__PURE__ */ new Set([...cfg.folders, ...o.folders.map((d) => path27.resolve(d))])];
   const existing = cfg.receivers.find((r) => r.control === control);
+  let accounts = o.accounts;
+  if (!accounts)
+    try {
+      const e = o.env ?? process.env;
+      accounts = claudeAccounts(claudeDirs(e), e.HOME);
+    } catch {
+      accounts = [];
+    }
   const auth = { authorization: `Bearer ${o.token ?? pollKey}`, "content-type": "application/json" };
-  const started = await f(`${control}/pair`, {
-    method: "POST",
-    headers: o.token ? auth : { "content-type": "application/json" },
-    body: JSON.stringify({
-      ...pollKey ? { poll_key: pollKey } : {},
-      ...existing ? { machine: existing.machine } : {},
-      name: cfg.name,
-      harnesses: o.harnesses ?? drivableHarnesses(o.env ?? process.env),
-      modes: ["waiter", "turn", "resume", "fork"],
-      version: VERSION3,
-      folders: cfg.folders,
-      mode: cfg.mode
-    })
-  });
-  const s = await json(started);
-  if (started.status !== 201 && started.status !== 200)
-    throw new Error(
-      `the receiver refused to start pairing (HTTP ${started.status}${s.reason ? `: ${String(s.reason)}` : ""})`
-    );
-  const machine = String(s.machine);
-  const code = String(s.code);
-  o.out("");
-  const digits = String(s.check);
-  const spaced = /^\d{6}$/.test(digits) ? `${digits.slice(0, 3)} ${digits.slice(3)}` : digits;
+  const hello = {
+    ...pollKey ? { poll_key: pollKey } : {},
+    name: cfg.name,
+    harnesses: o.harnesses ?? drivableHarnesses(o.env ?? process.env),
+    modes: ["waiter", "turn", "resume", "fork"],
+    version: VERSION3,
+    folders: cfg.folders,
+    mode: cfg.mode,
+    ...accounts.length ? { accounts } : {},
+    // This daemon takes `files` on a start (an older one would start without them).
+    files: true
+  };
+  const start = async (machine) => {
+    const started = await f(`${control}/pair`, {
+      method: "POST",
+      headers: o.token ? auth : { "content-type": "application/json" },
+      body: JSON.stringify({ ...hello, ...machine ? { machine } : {} })
+    });
+    const s = await json(started);
+    if (started.status !== 201 && started.status !== 200)
+      throw new Error(
+        `the receiver refused to start pairing (HTTP ${started.status}${s.reason ? `: ${String(s.reason)}` : ""})`
+      );
+    return {
+      machine: String(s.machine),
+      code: String(s.code),
+      url: String(s.url),
+      check: String(s.check),
+      until: Date.parse(String(s.expires_at)) || Date.now() + 10 * 6e4
+    };
+  };
   const host = new URL(o.url).host;
-  o.out(`  On any phone or computer where you're signed in to ${host} (it doesn't have to be this one),`);
-  if (pollKey) {
-    o.out(`  open ${String(s.url)} and enter:  ${spaced}`);
-    o.out("  then approve with that device's passkey (Touch ID, Face ID, a security key).");
-    o.out("  Pairing several machines? Run this on each one: every machine shows its own digits.");
-  } else {
-    o.out("  open this link and approve with that device's passkey (Touch ID, Face ID, a security key):");
-    o.out(`    ${String(s.url)}`);
-    o.out(`  The page shows these digits too: ${digits}`);
-  }
-  o.out("");
-  const until = Date.parse(String(s.expires_at)) || Date.now() + 10 * 6e4;
+  const announce = (p) => {
+    const spaced = /^\d{6}$/.test(p.check) ? `${p.check.slice(0, 3)} ${p.check.slice(3)}` : p.check;
+    o.out("");
+    o.out(`  On any phone or computer where you're signed in to ${host} (it doesn't have to be this one),`);
+    if (pollKey) {
+      o.out(`  open ${p.url} and enter:  ${spaced}`);
+      o.out("  then approve with that device's passkey (Touch ID, Face ID, a security key).");
+      o.out("  Pairing several machines? Run this on each one: every machine shows its own digits.");
+    } else {
+      o.out("  open this link and approve with that device's passkey (Touch ID, Face ID, a security key):");
+      o.out(`    ${p.url}`);
+      o.out(`  The page shows these digits too: ${p.check}`);
+    }
+    const mins = Math.max(1, Math.round((p.until - Date.now()) / 6e4));
+    o.out(`  This code is good for ${mins} minute${mins === 1 ? "" : "s"}; if it runs out, a fresh one appears here.`);
+    o.out("");
+  };
+  const renewUntil = Date.now() + (o.renewFor ?? RENEW_FOR_MS);
+  let cur = await start(existing?.machine);
+  announce(cur);
   for (; ; ) {
-    if (Date.now() > until) throw new Error("the pairing link expired; run `sessionpipe control pair` again");
     await sleep3(2e3);
-    const r = await f(`${control}/pair?code=${encodeURIComponent(code)}`, { headers: auth }).catch(() => null);
-    if (!r) continue;
-    if (r.status === 404) throw new Error("the receiver lost the pairing; run `sessionpipe control pair` again");
-    const p = await json(r);
-    if (p.status === "expired") throw new Error("the pairing link expired; run `sessionpipe control pair` again");
-    if (p.status !== "paired") continue;
+    let p = {};
+    let expired = Date.now() > cur.until;
+    if (!expired) {
+      const r = await f(`${control}/pair?code=${encodeURIComponent(cur.code)}`, { headers: auth }).catch(() => null);
+      if (!r) continue;
+      if (r.status === 404) throw new Error("the receiver lost the pairing; run `sessionpipe control pair` again");
+      p = await json(r);
+      if (p.status === "expired") expired = true;
+      else if (p.status !== "paired") continue;
+    }
+    if (expired) {
+      if (Date.now() >= renewUntil) throw new Error("the pairing link expired; run `sessionpipe control pair` again");
+      cur = await start(o.token ? cur.machine : existing?.machine);
+      o.out("  Nobody approved that code before it expired. Here is a fresh one; the old digits no longer work.");
+      announce(cur);
+      continue;
+    }
+    const { machine, code } = cur;
     const key = p.key;
     const proof = p.proof;
     const v = await verifyEnrollment({ machine, code, key, proof, rpId });
@@ -6470,6 +7631,9 @@ async function pair(o) {
     if (!existing) cfg.receivers.push(rec);
     writeControl(cfg, o.env);
     o.out(`  \u2713 Paired with ${rec.url} as ${machine} \xB7 ${rec.keys.length} key(s) trusted on this machine`);
+    const named = accounts.flatMap((a) => a.email ? [a.email] : []);
+    if (named.length)
+      o.out(`  Its session board names your Claude Code account${named.length > 1 ? "s" : ""}: ${named.join(", ")}`);
     if (typeof p.account === "string")
       o.out(`  Approved by ${p.account}. If that isn't you, run \`sessionpipe control off\` now.`);
     if (typeof p.sink_token === "string" && o.addSink) o.addSink(p.sink_token);
@@ -6505,7 +7669,7 @@ function removeKey(id, env) {
 var LABEL4 = "org.sessionpipe.control";
 var UNIT2 = "sessionpipe-control.service";
 function serviceFiles(o) {
-  const home = o.home ?? os8.homedir();
+  const home = o.home ?? os9.homedir();
   const xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -6518,8 +7682,8 @@ function serviceFiles(o) {
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
   <key>ProcessType</key><string>Background</string>
-  <key>StandardOutPath</key><string>${xml(path24.join(o.logDir, "daemon.log"))}</string>
-  <key>StandardErrorPath</key><string>${xml(path24.join(o.logDir, "daemon.log"))}</string>
+  <key>StandardOutPath</key><string>${xml(path27.join(o.logDir, "daemon.log"))}</string>
+  <key>StandardErrorPath</key><string>${xml(path27.join(o.logDir, "daemon.log"))}</string>
 </dict>
 </plist>
 `;
@@ -6539,11 +7703,11 @@ RestartSec=5
 WantedBy=default.target
 `;
   return {
-    plist: { file: path24.join(home, "Library", "LaunchAgents", `${LABEL4}.plist`), body: plist },
-    unit: { file: path24.join(home, ".config", "systemd", "user", UNIT2), body: unit }
+    plist: { file: path27.join(home, "Library", "LaunchAgents", `${LABEL4}.plist`), body: plist },
+    unit: { file: path27.join(home, ".config", "systemd", "user", UNIT2), body: unit }
   };
 }
-var execQuiet = (cmd2, args2) => execFileSync6(cmd2, args2, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 });
+var execQuiet = (cmd, args2) => execFileSync7(cmd, args2, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 });
 function ensureLinger(user, exec = execQuiet) {
   const lingering = () => {
     try {
@@ -6565,13 +7729,13 @@ function ensureLinger(user, exec = execQuiet) {
 }
 function installService(o) {
   const logDir = controlState(o.env);
-  mkdirSync11(logDir, { recursive: true, mode: 448 });
+  mkdirSync13(logDir, { recursive: true, mode: 448 });
   const f = serviceFiles({ node: o.node, cli: o.cli, logDir });
   const run = o.exec ?? execQuiet;
   const platform = o.platform ?? process.platform;
   if (platform === "darwin") {
-    mkdirSync11(path24.dirname(f.plist.file), { recursive: true });
-    writeFileSync9(f.plist.file, f.plist.body);
+    mkdirSync13(path27.dirname(f.plist.file), { recursive: true });
+    writeFileSync11(f.plist.file, f.plist.body);
     const uid = String(process.getuid?.() ?? "");
     for (const d of ["gui", "user"])
       try {
@@ -6580,40 +7744,40 @@ function installService(o) {
       }
     try {
       run("launchctl", ["bootstrap", `gui/${uid}`, f.plist.file]);
-      return `launchd agent ${LABEL4} (log: ${path24.join(logDir, "daemon.log")})`;
+      return `launchd agent ${LABEL4} (log: ${path27.join(logDir, "daemon.log")})`;
     } catch {
     }
     run("launchctl", ["bootstrap", `user/${uid}`, f.plist.file]);
-    return `launchd agent ${LABEL4} in the background domain, since nobody is logged in at this Mac's screen; after a restart it starts again when someone logs in there (log: ${path24.join(logDir, "daemon.log")})`;
+    return `launchd agent ${LABEL4} in the background domain, since nobody is logged in at this Mac's screen; after a restart it starts again when someone logs in there (log: ${path27.join(logDir, "daemon.log")})`;
   }
   if (platform === "linux") {
-    mkdirSync11(path24.dirname(f.unit.file), { recursive: true });
-    writeFileSync9(f.unit.file, f.unit.body);
+    mkdirSync13(path27.dirname(f.unit.file), { recursive: true });
+    writeFileSync11(f.unit.file, f.unit.body);
     try {
       run("systemctl", ["--user", "daemon-reload"]);
       run("systemctl", ["--user", "enable", "--now", UNIT2]);
     } catch {
       return `wrote ${f.unit.file}, but systemd --user isn't reachable here; run \`sessionpipe control run\` yourself (tmux, screen)`;
     }
-    const linger = ensureLinger(os8.userInfo().username, run);
+    const linger = ensureLinger(os9.userInfo().username, run);
     return `systemd user unit ${UNIT2}; ${linger.note} (journalctl --user -u ${UNIT2})`;
   }
   return "no service manager for this platform yet; run `sessionpipe control run` yourself";
 }
 function uninstallService(env) {
   const f = serviceFiles({ node: "", cli: "", logDir: controlState(env) });
-  const run = (cmd2, args2) => {
+  const run = (cmd, args2) => {
     try {
-      execFileSync6(cmd2, args2, { stdio: "ignore", timeout: 15e3 });
+      execFileSync7(cmd, args2, { stdio: "ignore", timeout: 15e3 });
     } catch {
     }
   };
-  if (process.platform === "darwin" && existsSync12(f.plist.file)) {
+  if (process.platform === "darwin" && existsSync15(f.plist.file)) {
     run("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/${LABEL4}`]);
     run("launchctl", ["bootout", `user/${process.getuid?.() ?? ""}/${LABEL4}`]);
     unlinkSync6(f.plist.file);
   }
-  if (process.platform === "linux" && existsSync12(f.unit.file)) {
+  if (process.platform === "linux" && existsSync15(f.unit.file)) {
     run("systemctl", ["--user", "disable", "--now", UNIT2]);
     unlinkSync6(f.unit.file);
     run("systemctl", ["--user", "daemon-reload"]);
@@ -6733,9 +7897,10 @@ ${RE_ARM}`;
 }
 
 // src/control/cli.ts
-var { claudeLogin: claudeLogin2, detectCaps: detectCaps2, findClaude: findClaude2, runClaude: runClaude2 } = claude_code_control_exports;
+var { claudeLogin: claudeLogin3, detectCaps: detectCaps2, findClaude: findClaude2, runClaude: runClaude2 } = claude_code_control_exports;
 var CONTROL_HELP = `  sessionpipe control pair <receiver> [--folder DIR]\u2026 [--mode safe|auto] [--tier 0-3] [--token T] [--name N] [--no-service]
   sessionpipe control mode auto|safe                (how sessions run when you message them)
+  sessionpipe control folders [add|remove DIR\u2026]     (where sessions you message may run)
   sessionpipe control status | keys [remove <id>] | off [<receiver>] | run
   sessionpipe wait [--session <harness>:<id>]      (a session runs this in the background)`;
 var MODE_TEXT = `  auto  Claude Code's auto mode: the session reads, edits and runs commands, and Claude Code's
@@ -6765,6 +7930,42 @@ async function askMode(out2) {
     rl.close();
   }
 }
+function changeFolders(folders, op, dirs, home = os10.homedir()) {
+  const real = (d) => {
+    try {
+      return realpathSync6.native(d);
+    } catch {
+      return path28.resolve(d);
+    }
+  };
+  const next = [...folders];
+  const said = [];
+  for (const d of dirs) {
+    const abs = path28.resolve(d);
+    const at = next.findIndex((f) => real(f) === real(abs));
+    if (op === "remove") {
+      if (at < 0) said.push(`  \xB7 ${abs} wasn't allowed`);
+      else said.push(`  \u2713 No longer allowed: ${next.splice(at, 1)[0]}`);
+      continue;
+    }
+    let dir = false;
+    try {
+      dir = statSync10(abs).isDirectory();
+    } catch {
+    }
+    if (!dir) said.push(`  \u2717 ${abs} isn't a folder on this machine`);
+    else if (isBroad(abs, home))
+      said.push(
+        `  \u2717 Not allowing all of ${abs}: name a project folder inside it, so a message can't run anywhere you own`
+      );
+    else if (at >= 0) said.push(`  \xB7 ${abs} is already allowed`);
+    else {
+      next.push(abs);
+      said.push(`  \u2713 Allowed ${abs}`);
+    }
+  }
+  return { folders: next, said };
+}
 async function controlMain(argv, out2, distDir2) {
   const flag2 = (n) => {
     const i = argv.indexOf(n);
@@ -6789,7 +7990,7 @@ ${CONTROL_HELP}`);
       const folders = flags("--folder");
       const existing = readControl();
       if (!folders.length && !existing?.folders.length) {
-        if (!isBroad(process.cwd(), os9.homedir())) folders.push(process.cwd());
+        if (!isBroad(process.cwd(), os10.homedir())) folders.push(process.cwd());
         else
           out2(
             `  ! Not allowing all of ${process.cwd()}: sessions you message may run only in folders you name. Pass --folder <project>, or run this from inside one.`
@@ -6811,7 +8012,7 @@ ${CONTROL_HELP}`);
         },
         folders,
         mode,
-        name: flag2("--name") ?? existing?.name ?? cfg.machine ?? os9.hostname(),
+        name: flag2("--name") ?? existing?.name ?? machineName(cfg, os10.hostname()),
         out: out2
       });
       const c = readControl();
@@ -6819,9 +8020,9 @@ ${CONTROL_HELP}`);
       out2(
         `  Mode: ${c.mode} (${c.mode === "safe" ? "nothing that needs approval runs unattended" : "Claude Code's auto mode"})`
       );
-      let cli = path25.join(distDir2, "cli.js");
+      let cli = path28.join(distDir2, "cli.js");
       try {
-        cli = realpathSync5(cli);
+        cli = realpathSync6(cli);
       } catch {
       }
       if (argv.includes("--no-service"))
@@ -6845,6 +8046,28 @@ ${MODE_TEXT}`);
         `  \u2713 Sessions you message now run in ${want} mode${want === "auto" ? " (Claude Code's auto mode decides what's safe)" : " (only what each folder's settings already allow)"}.`
       );
     }
+    case "folders": {
+      const op = argv[2];
+      const usage = "  usage: sessionpipe control folders [add|remove <folder>\u2026]";
+      if (op !== void 0 && op !== "add" && op !== "remove") return out2(usage);
+      const c = readControl();
+      if (!c) return out2("  control isn't set up on this machine: run `sessionpipe control pair <receiver>` first");
+      if (op) {
+        const dirs = argv.slice(3);
+        if (!dirs.length) return out2(usage);
+        const r = changeFolders(c.folders, op, dirs);
+        for (const l of r.said) out2(l);
+        if (r.folders.join("\n") !== c.folders.join("\n")) {
+          c.folders = r.folders;
+          writeControl(c);
+          out2("  The control daemon uses the new list within seconds.");
+        }
+      }
+      return out2(
+        c.folders.length ? `  Sessions you message may run in:
+${c.folders.map((f) => `    ${f}`).join("\n")}` : "  No folder is allowed: a message to a session here is refused until you add one."
+      );
+    }
     case "keys": {
       const c = readControl();
       if (argv[2] === "remove" && argv[3]) {
@@ -6890,7 +8113,7 @@ async function runDaemon(out2, distDir2) {
   const claudeNow = () => {
     const bin = findClaude2();
     if (!bin) return null;
-    const sig = `${bin}:${existsSync13(bin) ? realpathSync5(bin) : ""}`;
+    const sig = `${bin}:${existsSync16(bin) ? realpathSync6(bin) : ""}`;
     if (claude?.sig !== sig) claude = { bin, caps: detectCaps2(bin), sig };
     return claude;
   };
@@ -6910,7 +8133,7 @@ async function runDaemon(out2, distDir2) {
     sdk,
     login: async (configDir) => {
       const c = claudeNow();
-      return c ? claudeLogin2(c.bin, configDir) : { loggedIn: null };
+      return c ? claudeLogin3(c.bin, configDir) : { loggedIn: null };
     },
     token: (r) => r.token_in ? secretGet(r.token_in, controlAccount(r.machine)) : null,
     onRestart: () => updater?.restartWhenIdle() ?? false,
@@ -6925,12 +8148,12 @@ async function runDaemon(out2, distDir2) {
     log2(`${e.message}; this one exits`);
     process.exit(0);
   }
-  const drain = setInterval(() => {
-    const sinks = readConfig().sinks.filter((s) => s.token_in && !s.paused);
-    if (sinks.length) void flush(stateDir(), sinks, new Outbox(stateDir())).catch(() => {
+  const drainTimer = setInterval(() => {
+    const sinks = readConfig().sinks.filter((s) => !s.paused);
+    if (sinks.length) void drain(stateDir(), sinks, new Outbox(stateDir())).catch(() => {
     });
   }, 6e4);
-  drain.unref();
+  drainTimer.unref();
   watchFile(controlFile(), { interval: 5e3 }, () => {
     const next = readControl();
     if (next) d.reload(next);
@@ -6948,7 +8171,7 @@ async function runDaemon(out2, distDir2) {
   const restart = async (_from, to) => {
     stopping = true;
     updater?.stop();
-    clearInterval(drain);
+    clearInterval(drainTimer);
     unwatchFile(controlFile());
     for (const sig of signals) process.off(sig, bye);
     await d.stop();
@@ -6957,9 +8180,9 @@ async function runDaemon(out2, distDir2) {
       log2(`exiting ${UPDATE_EXIT} so ${via === "supervisor" ? "the supervising sessionpipe" : via} starts ${to}`);
       process.exit(UPDATE_EXIT);
     }
-    let cli = path25.join(distDir2, "cli.js");
+    let cli = path28.join(distDir2, "cli.js");
     try {
-      cli = realpathSync5(cli);
+      cli = realpathSync6(cli);
     } catch {
     }
     log2(`no service manager restarts this daemon: pid ${process.pid} now runs ${to} as its child`);
@@ -7001,126 +8224,96 @@ function adoptSinkToken(url, token, tier, file) {
   return same ? "filled" : "added";
 }
 
-// src/launcher.ts
-import { accessSync as accessSync3, chmodSync as chmodSync4, constants as constants3, mkdirSync as mkdirSync12, readFileSync as readFileSync14, renameSync as renameSync5, rmSync, writeFileSync as writeFileSync10 } from "node:fs";
-import os10 from "node:os";
-import path26 from "node:path";
-var LAUNCHER = "sessionpipe-hook";
-var COPIED = ["worker.js", "hook.js"];
-function dataDir(env = process.env) {
-  if (env.SESSIONPIPE_DATA) return path26.resolve(env.SESSIONPIPE_DATA);
-  return path26.join(env.XDG_DATA_HOME || path26.join(os10.homedir(), ".local", "share"), "sessionpipe");
-}
-var launcherPath = (env = process.env) => path26.join(dataDir(env), LAUNCHER);
-var usesLauncher = (platform = process.platform) => platform !== "win32";
-var sq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-function launcherScript(node, hook, version) {
-  return `#!/bin/sh
-# sessionpipe ${version} hook launcher, written by \`sessionpipe install\`. Harnesses run
-# this; it runs hook.js beside it with the node sessionpipe was installed with, or with
-# any node on PATH once that one is gone (an nvm uninstall, a Homebrew upgrade).
-n=${sq(node)}
-[ -x "$n" ] || n=$(command -v node) || { [ "$1" = antigravity ] && if [ "$2" = PreToolUse ]; then echo ${sq(AG_STALE_PRETOOL.trim())}; else echo '{}'; fi; exit 0; }
-exec "$n" ${sq(hook)} "$@"
-`;
-}
-function writeIfChanged(file, body, mode) {
-  try {
-    const cur = readFileSync14(file);
-    if (cur.equals(Buffer.isBuffer(body) ? body : Buffer.from(body))) {
-      chmodSync4(file, mode);
-      return false;
-    }
-  } catch {
-  }
-  const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync10(tmp, body, { mode });
-  renameSync5(tmp, file);
-  chmodSync4(file, mode);
-  return true;
-}
-function installLauncher(o) {
-  const dir = dataDir(o.env);
-  mkdirSync12(dir, { recursive: true, mode: 493 });
-  let changed = false;
-  for (const f of COPIED)
-    changed = writeIfChanged(path26.join(dir, f), readFileSync14(path26.join(o.distDir, f)), 420) || changed;
-  const launcher = path26.join(dir, LAUNCHER);
-  changed = writeIfChanged(launcher, launcherScript(o.node, path26.join(dir, "hook.js"), o.version), 493) || changed;
-  return { launcher, changed };
-}
-function removeLauncher(env = process.env) {
-  for (const f of [LAUNCHER, ...COPIED]) rmSync(path26.join(dataDir(env), f), { force: true });
+// src/help.ts
+function usageTable(harnesses) {
+  return {
+    connect: "connect <receiver> [--machine NAME] [--rename-machine] [--allow-downgrade] [--tier 0-3] [--mode safe|auto] [--folder DIR]\u2026 [--no-service]",
+    install: `install [${harnesses.map((h) => `--${h}`).join(" ")}] [--machine NAME] [--rename-machine] [--allow-downgrade] [--backfill DAYS] [--sink URL --tier N]`,
+    sink: "sink add|list|remove|test (use --help after a subcommand for its options)",
+    "sink add": "sink add <url|file:PATH|stdout> [--tier 0-3] [--token T] [--secret S] [--pii] [--name N]",
+    "sink list": "sink list",
+    "sink remove": "sink remove <name>",
+    "sink test": "sink test <name>",
+    secrets: "secrets [move keychain|secret-service|file]",
+    "secrets move": "secrets move keychain|secret-service|file",
+    status: "status [--json]",
+    doctor: "doctor [--json]",
+    tail: "tail [--session ID] [--tier 0-3] [--harness NAME] [--all] [--json]",
+    backfill: `backfill [--days 30] [${harnesses.map((h) => `--${h}`).join(" ")}]`,
+    forget: "forget <harness> <session>",
+    replay: "replay [--sink NAME] [--from-start]",
+    update: "update [off|on] (install the latest now; off/on: the daemon's daily update)",
+    "update off": "update off",
+    "update on": "update on",
+    control: "control pair|mode|status|keys|off|run (use --help after a subcommand for its options)",
+    "control pair": "control pair <receiver> [--folder DIR]\u2026 [--mode safe|auto] [--tier 0-3] [--token T] [--name N] [--no-service]",
+    "control mode": "control mode auto|safe",
+    "control status": "control status",
+    "control keys": "control keys [remove <id>]",
+    "control keys remove": "control keys remove <id>",
+    "control off": "control off [<receiver>]",
+    "control run": "control run",
+    wait: "wait [--session <harness>:<id>]",
+    worker: "worker <job-file> (internal: process one queued job)",
+    hook: "hook (internal: harnesses run dist/hook.js directly)",
+    version: "version (print the installed version)",
+    "--version": "--version (print the installed version)",
+    "-v": "-v (print the installed version)"
+  };
 }
-function launcherState(version, env = process.env) {
-  const file = launcherPath(env);
-  let text = "";
-  try {
-    text = readFileSync14(file, "utf8");
-  } catch {
-    return {
-      file,
-      present: false,
-      node: null,
-      nodeOk: false,
-      version: null,
-      problems: ["the hook launcher is missing; run `sessionpipe install` again"]
-    };
-  }
-  const node = /^n='((?:[^']|'\\'')*)'$/m.exec(text)?.[1]?.replace(/'\\''/g, "'") ?? null;
-  const v = /^# sessionpipe (\S+) hook launcher/m.exec(text)?.[1] ?? null;
-  let nodeOk = false;
-  try {
-    if (node) {
-      accessSync3(node, constants3.X_OK);
-      nodeOk = true;
-    }
-  } catch {
+function commandHelp(args2, harnesses) {
+  const usage = usageTable(harnesses);
+  for (let n = Math.min(args2.length, 3); n > 0; n--) {
+    const line = usage[args2.slice(0, n).join(" ")];
+    if (line) return `Usage: sessionpipe ${line}
+
+  -h, --help  Show help without running the command.`;
   }
-  const problems = [];
-  if (!nodeOk)
-    problems.push(
-      `the node the hook launcher names (${node ?? "?"}) is gone; it falls back to the node on PATH. \`sessionpipe install\` points it at this one.`
-    );
-  for (const f of COPIED)
-    try {
-      accessSync3(path26.join(path26.dirname(file), f), constants3.R_OK);
-    } catch {
-      problems.push(`${f} is missing beside the hook launcher; run \`sessionpipe install\` again`);
-    }
-  if (v && v !== version)
-    problems.push(
-      `the hooks run sessionpipe ${v}, this is ${version}; run \`sessionpipe install\` to bring them up to date`
-    );
-  return { file, present: true, node, nodeOk, version: v, problems };
+  return void 0;
 }
 
 // src/cli.ts
-process.stdout.on("error", (e) => {
-  if (e.code === "EPIPE") process.exit(0);
-});
-var args = process.argv.slice(2);
-var cmd = args[0] ?? "help";
+var print = (s = "") => {
+  process.stdout.write(`${s}
+`);
+};
+var args = [];
+var out = print;
+var state = "";
 var flag = (name) => {
   const i = args.indexOf(name);
   return i >= 0 ? args[i + 1] : void 0;
 };
 var has = (name) => args.includes(name);
-var out = (s = "") => {
-  process.stdout.write(`${s}
+var distDir = path29.dirname(fileURLToPath(import.meta.url));
+async function main(argv, io = { out: print, err: (s) => void process.stderr.write(s), exit: (c) => process.exit(c) }) {
+  args = argv;
+  out = io.out;
+  state = stateDir();
+  try {
+    await command(args[0] ?? "help");
+  } catch (e) {
+    io.err(`sessionpipe: ${e.message}
 `);
-};
-var state = stateDir();
-var distDir = path27.dirname(fileURLToPath(import.meta.url));
+    io.exit(1);
+  }
+}
+function isEntrypoint(argv1, url) {
+  try {
+    return !!argv1 && realpathSync7(argv1) === fileURLToPath(url);
+  } catch {
+    return false;
+  }
+}
 function hookCommand() {
   if (usesLauncher()) {
     const l = launcherPath();
     return (a) => ({ argv: [l, ...a], command: `${JSON.stringify(l)} ${a.join(" ")}` });
   }
   const node = stableNode(process.execPath);
-  let script = path27.join(distDir, "hook.js");
+  let script = path29.join(distDir, "hook.js");
   try {
-    script = realpathSync6(script);
+    script = realpathSync7(script);
   } catch {
   }
   return (a) => ({
@@ -7133,7 +8326,14 @@ function selectedAdapters() {
   if (named.length) return named;
   return ADAPTERS.filter((a) => a.detect());
 }
-async function main() {
+async function command(cmd) {
+  if (has("--help") || has("-h")) {
+    const usage = commandHelp(
+      args,
+      ADAPTERS.map((a) => a.name)
+    );
+    return usage ? out(usage) : help();
+  }
   switch (cmd) {
     case "connect":
       return connect();
@@ -7180,14 +8380,15 @@ async function main() {
 function help() {
   out(`sessionpipe ${VERSION} \u2014 an open protocol for what your coding agents are doing
 
-  sessionpipe connect <receiver> [--machine NAME] [--tier 0-3] [--mode safe|auto] [--folder DIR]\u2026
+Usage:
+  sessionpipe connect <receiver> [--machine NAME] [--rename-machine] [--allow-downgrade] [--tier 0-3] [--mode safe|auto] [--folder DIR]\u2026
                                   (everything, in one go: hooks, a sink, signed messages, keys)
-  sessionpipe install [--claude-code --codex --gemini-cli --antigravity] [--machine NAME] [--backfill DAYS] [--sink URL --tier N]
-  sessionpipe uninstall [--keep-state]
+  sessionpipe install [--claude-code --codex --gemini-cli --antigravity --devin] [--machine NAME] [--rename-machine] [--allow-downgrade] [--backfill DAYS] [--sink URL --tier N]
+  sessionpipe uninstall [--claude-code --codex --gemini-cli --antigravity --devin | --all] [--keep-state]
   sessionpipe sink add <url|file:PATH|stdout> [--tier 0-3] [--token T] [--pii] [--name N]
   sessionpipe sink list | remove <name> | test <name>
   sessionpipe secrets [move keychain|secret-service|file]   (where the machine's keys live)
-  sessionpipe status | doctor [--json]
+  sessionpipe status [--json] | doctor [--json]
   sessionpipe tail [--session ID] [--tier N] [--harness NAME]
   sessionpipe backfill [--days 30] | forget <harness> <session> | replay --sink NAME
   sessionpipe update [off|on]       (install the latest now; off/on: the daemon's daily update)
@@ -7195,17 +8396,41 @@ ${CONTROL_HELP}
 
 Docs: https://sessionpipe.org \xB7 nothing leaves this machine until you add a sink.`);
 }
-async function install() {
-  if (viaNpx(distDir)) return rerunGlobally(args, out);
+function setupConfig() {
   const cfg = readConfig();
-  const machine = flag("--machine");
-  if (machine) cfg.machine = machine.slice(0, 80);
+  const requested = flag("--machine");
+  if ((has("--machine") || has("--rename-machine")) && (!requested || requested.startsWith("-")))
+    throw new Error("--machine NAME is required when naming or renaming a machine");
+  const machine = requested?.slice(0, 80);
+  const control = readControl();
+  const hooksName = existsSync17(configFile()) ? machineName(cfg, os11.hostname()) : void 0;
+  const pairedName = control && hooksName && machineName({}, control.name) === hooksName ? hooksName : control?.name;
+  const current = cfg.machine || pairedName || hooksName;
+  if (current && machine && machine !== current && !has("--rename-machine")) {
+    out(
+      `  Keeping configured machine name ${current}; ignoring --machine ${machine}. Use --rename-machine with --machine NAME for an explicit rename.`
+    );
+    cfg.machine = current;
+  } else {
+    const name = machine || current || machineName(cfg, os11.hostname());
+    if (control && control.name !== name && (machine || name === pairedName)) {
+      writeControl({ ...control, name });
+      out(`  Renamed the control daemon ${control.name} \u2192 ${name}; its next hello tells each receiver.`);
+    }
+    cfg.machine = name;
+  }
+  return cfg;
+}
+async function install() {
+  const cfg = setupConfig();
+  if (viaNpx(distDir)) return rerunGlobally(args, out, { allowDowngrade: has("--allow-downgrade") });
+  assertSetupVersion(has("--allow-downgrade"));
   const sinkUrl = flag("--sink");
   if (sinkUrl) await sinkAdd(sinkUrl, cfg);
   const adapters = selectedAdapters();
   if (!adapters.length) {
     out(
-      "  No supported harness found on this machine (Claude Code, Codex, Gemini CLI, Antigravity). Pass --<harness> to force one."
+      "  No supported harness found on this machine (Claude Code, Codex, Gemini CLI, Antigravity, Devin). Pass --<harness> to force one."
     );
     return;
   }
@@ -7253,6 +8478,10 @@ function installHarnesses(adapters, cfg, lean) {
     cfg.harnesses[a.name] = { enabled: true, ...created.size ? { created: [...created] } : {} };
     if (a.name === "gemini-cli")
       out("    note: Gemini CLI's own telemetry defaults logPrompts on; that is Google's setting, not sessionpipe's.");
+    if (a.name === "devin" && !reports.some((r) => r.skipped))
+      out(
+        "    note: Devin ignores a hooks file whole if it holds one event name it doesn't know; run `/hooks` in `devin` to see what loaded."
+      );
     if (a.name === "codex" && !reports.some((r) => r.skipped))
       out(
         "    note: Codex runs non-managed hooks only after you approve them: start `codex` and accept the hook review. The notify fallback reports turn ends meanwhile."
@@ -7263,14 +8492,13 @@ async function connect() {
   const raw = args[1];
   if (!raw || raw.startsWith("-"))
     return out(
-      "usage: sessionpipe connect <receiver> [--machine NAME] [--tier 0-3] [--mode safe|auto] [--folder DIR]\u2026 [--no-service]"
+      "usage: sessionpipe connect <receiver> [--machine NAME] [--rename-machine] [--allow-downgrade] [--tier 0-3] [--mode safe|auto] [--folder DIR]\u2026 [--no-service]"
     );
-  if (viaNpx(distDir)) return rerunGlobally(args, out);
+  const cfg = setupConfig();
+  if (viaNpx(distDir)) return rerunGlobally(args, out, { allowDowngrade: has("--allow-downgrade") });
+  assertSetupVersion(has("--allow-downgrade"));
   const url = (/^https?:\/\//.test(raw) ? raw : `https://${raw}`).replace(/\/$/, "");
   const host = new URL(url).host;
-  const cfg = readConfig();
-  const machine = flag("--machine");
-  if (machine) cfg.machine = machine.slice(0, 80);
   const name = machineName(cfg, os11.hostname());
   const before = cfg.sinks.find((x) => x.url.replace(/\/$/, "") === url);
   const tier = connectTier(flag("--tier"), before?.tier);
@@ -7278,19 +8506,19 @@ async function connect() {
   const adapters = ADAPTERS.filter((a) => a.detect());
   if (!adapters.length)
     out(
-      "  ! No coding agent here yet (Claude Code, Codex, Gemini CLI, Antigravity): run `sessionpipe install` once you have one."
+      "  ! No coding agent here yet (Claude Code, Codex, Gemini CLI, Antigravity, Devin): run `sessionpipe install` once you have one."
     );
   else installHarnesses(adapters, cfg, tier < 1);
   writeConfig(cfg);
   await reportClaudeAccounts();
-  const rows = collectRows(adapters, 30);
+  const rows2 = collectRows(adapters, 30);
   const control = readControl();
   const paired = control?.receivers.find((r) => r.url === url);
   const sinkNow = readConfig().sinks.find((x) => x.url.replace(/\/$/, "") === url);
   if (paired && sinkNow && (sinkNow.token || sinkNow.token_in)) {
     out(`  \u2713 Already paired with ${host} as ${paired.machine}: nothing to approve.`);
   } else {
-    const recent = rows.slice().sort((a, b) => b.row.last_at - a.row.last_at).map((r) => r.row.session.cwd ?? "");
+    const recent = rows2.slice().sort((a, b) => b.row.last_at - a.row.last_at).map((r) => r.row.session.cwd ?? "");
     const choice = connectFolders({
       cwd: process.cwd(),
       home: os11.homedir(),
@@ -7299,7 +8527,7 @@ async function connect() {
       recent,
       exists: (d) => {
         try {
-          return statSync10(d).isDirectory();
+          return statSync11(d).isDirectory();
         } catch {
           return false;
         }
@@ -7352,9 +8580,9 @@ async function connect() {
     out(`  \u2713 Keys: in ${storeLabel(store)}${kept.length ? ` (left in the file: ${kept.join(", ")})` : ""}`);
   } else
     out(
-      `  Keys: in ${tilde(path27.dirname(configFile()))} at 0600 \u2014 no unlocked keychain in this session${process.env.SSH_CONNECTION ? " (an ssh shell)" : ""}`
+      `  Keys: in ${tilde(path29.dirname(configFile()))} at 0600 \u2014 no unlocked keychain in this session${process.env.SSH_CONNECTION ? " (an ssh shell)" : ""}`
     );
-  if (rows.length) queueBackfill(rows, 30, readConfig());
+  if (rows2.length) queueBackfill(rows2, 30, readConfig());
   out("");
   out(`  Done: ${name} reports to ${host} and takes messages you sign on a device it trusts.`);
   out("  Run this again any time; it only fixes what's missing. `sessionpipe doctor` checks everything.");
@@ -7408,9 +8636,37 @@ function secrets() {
   if (!cfg.sinks.length && !readControl()?.receivers.length) out("  no keys on this machine");
   out(`  best store from this session: ${storeLabel(bestStore())}`);
 }
+var AWAY_FROM_HOME = {
+  "claude-code": "CLAUDE_CONFIG_DIR",
+  codex: "CODEX_HOME",
+  "gemini-cli": "GEMINI_CLI_HOME",
+  antigravity: "GEMINI_CLI_HOME",
+  devin: "XDG_CONFIG_HOME"
+};
+function unisolated() {
+  if (!process.env.SESSIONPIPE_CONFIG && !process.env.SESSIONPIPE_STATE) return [];
+  return ADAPTERS.filter((a) => {
+    const v = AWAY_FROM_HOME[a.name];
+    return v === null || typeof v === "string" && !process.env[v];
+  }).map((a) => a.name);
+}
 function uninstall() {
+  const named = ADAPTERS.filter((a) => has(`--${a.name}`));
+  const all = !named.length;
+  if (all && !has("--all")) {
+    const exposed = unisolated();
+    if (exposed.length) {
+      out(
+        `  ! Refusing an uninstall of every harness: SESSIONPIPE_CONFIG/SESSIONPIPE_STATE point away from this machine, but ${exposed.join(", ")} still resolve from ${tilde(os11.homedir())}.`
+      );
+      out(`  Nothing was changed. Name what to remove (${exposed.map((n) => `--${n}`).join(" ")}),`);
+      out("  pass --all if you do mean every harness on this machine, or unset SESSIONPIPE_CONFIG/SESSIONPIPE_STATE.");
+      process.exitCode = 2;
+      return;
+    }
+  }
   const cfg = readConfig();
-  for (const a of ADAPTERS) {
+  for (const a of all ? ADAPTERS : named) {
     const created = cfg.harnesses[a.name]?.created ?? [];
     for (const r of a.uninstall(process.env, { created }))
       if (r.changed) out(`  \u2713 ${a.name}: ${r.note ?? `hooks removed from ${tilde(r.file)}`}`);
@@ -7418,7 +8674,11 @@ function uninstall() {
     delete cfg.harnesses[a.name];
   }
   writeConfig(cfg);
-  if (usesLauncher()) removeLauncher();
+  if (all && usesLauncher()) removeLauncher();
+  if (!all) {
+    out(`  Still installed: ${Object.keys(cfg.harnesses).join(", ") || "nothing"}.`);
+    return;
+  }
   if (!has("--keep-state"))
     out(
       `  Outbox and state kept under ${tilde(state)} (delete it yourself, or pass nothing: it prunes after ${readConfig().keep_days ?? 30} days).`
@@ -7518,23 +8778,23 @@ var TIER_TEXT = {
 };
 function collectRows(adapters, days) {
   const since = Date.now() - days * 864e5;
-  const rows = [];
+  const rows2 = [];
   for (const a of adapters) {
     try {
-      for (const row of a.backfill(since)) rows.push({ harness: a.name, row });
+      for (const row of a.backfill(since)) rows2.push({ harness: a.name, row });
     } catch {
     }
   }
-  return rows;
+  return rows2;
 }
 function backfillRows(adapters, days, cfg) {
   queueBackfill(collectRows(adapters, days), days, cfg);
 }
-function queueBackfill(rows, days, cfg) {
+function queueBackfill(rows2, days, cfg) {
   const outbox = new Outbox(state);
   let n = 0;
   const machine = machineName(cfg, os11.hostname());
-  for (const { harness, row } of rows) {
+  for (const { harness, row } of rows2) {
     const ref = { harness, session: row.session.id };
     const facts = factsState(state).get(harness, row.session.id);
     if (facts.backfilled) continue;
@@ -7560,7 +8820,7 @@ function queueBackfill(rows, days, cfg) {
     n++;
   }
   out(`  \u2713 Backfill: ${n} session${n === 1 ? "" : "s"} from the last ${days} days queued as session.backfill`);
-  void flush(state, cfg.sinks, outbox);
+  void drain(state, cfg.sinks, outbox);
 }
 function backfill() {
   backfillRows(selectedAdapters(), Number(flag("--days") ?? 30), readConfig());
@@ -7594,21 +8854,65 @@ async function replay() {
   for (const s of sinks) {
     if (has("--from-start")) new Cursors(state, s.name).write({});
   }
-  const d = await flush(state, sinks, new Outbox(state));
+  const d = await flush(state, sinks, new Outbox(state), void 0, { force: true });
   for (const [k, v] of Object.entries(d)) out(`  ${k}: ${v} event${v === 1 ? "" : "s"} delivered`);
 }
-function status() {
+async function controlHealth() {
+  if (!pairedCount()) return null;
+  const reply = await ask(socketPath(state), { op: "status" }, 1500);
+  if (reply?.op !== "status") return { running: false, receivers: [] };
+  const status2 = reply.status;
+  return {
+    running: true,
+    receivers: status2.receivers.map((r) => ({
+      url: r.url,
+      polling: r.polling,
+      last_poll: r.last_poll,
+      last_error: r.last_error,
+      // An older daemon has no age field. Its last_poll still exposes a loop
+      // that stopped long ago, and polling=false catches the terminal 401.
+      last_poll_age_ms: r.last_poll_age_ms ?? (r.last_poll === null ? null : Math.max(0, Date.now() - r.last_poll))
+    }))
+  };
+}
+function controlLines(control) {
+  if (!control) {
+    out("  control:  not paired");
+    return;
+  }
+  if (!control.running) {
+    out("  control:  daemon not running or not responding; polling: no");
+    return;
+  }
+  for (const r of control.receivers) {
+    const age = r.last_poll_age_ms === null ? "unknown" : `${Math.floor(r.last_poll_age_ms / 6e4)} minutes`;
+    out(
+      `  control:  ${r.url} \xB7 polling: ${r.polling ? "yes" : "no"} \xB7 last successful poll: ${r.last_poll === null ? `never (${age} since start)` : `${age} ago`} \xB7 last error: ${r.last_error ?? "none"}`
+    );
+  }
+}
+async function status() {
   const cfg = readConfig();
   const hc = hookCommand();
-  out(`  machine:  ${machineName(cfg, os11.hostname())}   sessionpipe ${VERSION}   state ${tilde(state)}`);
+  const json2 = has("--json");
+  const harnesses = {};
+  const sinks = [];
+  if (!json2) out(`  machine:  ${machineName(cfg, os11.hostname())}   sessionpipe ${VERSION}   state ${tilde(state)}`);
   for (const a of ADAPTERS) {
     if (!a.detect() && !cfg.harnesses[a.name]) continue;
-    for (const r of a.installed(hc, process.env, { lean: isLean(cfg) }))
-      out(
-        `  ${a.name.padEnd(12)} ${tilde(r.file).padEnd(44)} ${r.state}${r.state !== "current" && r.note ? ` \u2014 ${r.note}` : ""}`
-      );
+    const installed = a.installed(hc, process.env, { lean: isLean(cfg) });
+    harnesses[a.name] = installed.map((r) => ({
+      file: tilde(r.file),
+      state: r.state,
+      ...r.note ? { note: r.note } : {}
+    }));
+    if (!json2)
+      for (const r of installed)
+        out(
+          `  ${a.name.padEnd(12)} ${tilde(r.file).padEnd(44)} ${r.state}${r.state !== "current" && r.note ? ` \u2014 ${r.note}` : ""}`
+        );
   }
-  if (!cfg.sinks.length) out("  sinks:    none (events stay in the local outbox)");
+  if (!json2 && !cfg.sinks.length) out("  sinks:    none (events stay in the local outbox)");
   for (const s of cfg.sinks) {
     const c = new Cursors(state, s.name).read();
     const outbox = new Outbox(state);
@@ -7616,34 +8920,67 @@ function status() {
     for (const ref of outbox.sessions()) {
       const f = outbox.file(ref);
       try {
-        pending += Math.max(0, statSync10(f).size - (c[`${ref.harness}/${ref.session}`] ?? 0)) > 0 ? 1 : 0;
+        pending += Math.max(0, statSync11(f).size - (c[`${ref.harness}/${ref.session}`] ?? 0)) > 0 ? 1 : 0;
       } catch {
       }
     }
-    out(
-      `  sink      ${s.name.padEnd(16)} tier ${Math.min(s.tier, s.max_tier ?? 3)}  ${s.paused ? `PAUSED ${s.paused}` : pending ? `${pending} session file(s) with undelivered events` : "up to date"}`
-    );
+    sinks.push({
+      name: s.name,
+      url: s.url,
+      tier: s.tier,
+      max_tier: s.max_tier ?? null,
+      pii: !!s.pii,
+      control: !!s.control,
+      paused: s.paused ?? null,
+      pending_sessions: pending
+    });
+    if (!json2)
+      out(
+        `  sink      ${s.name.padEnd(16)} tier ${Math.min(s.tier, s.max_tier ?? 3)}  ${s.paused ? `PAUSED ${s.paused}` : pending ? `${pending} session file(s) with undelivered events` : "up to date"}`
+      );
   }
-  out(`  update:   ${updateLine(updateState(cfg), Date.now())}`);
+  const control = await controlHealth();
+  if (!json2) controlLines(control);
+  const update2 = updateState(cfg);
+  if (!json2) out(`  update:   ${updateLine(update2, Date.now())}`);
   const t = timing();
-  if (t)
+  if (!json2 && t)
     out(
       `  hook:     in-process p50 ${t.p50} ms over ${t.n} runs (\`sessionpipe doctor\` measures the wall clock the harness waits)`
     );
-  const jobs = jobsDir(state);
+  let jobs = 0;
   try {
-    const n = readdirSync8(jobs).length;
-    if (n) out(`  jobs:     ${n} waiting`);
+    jobs = readdirSync8(jobsDir(state)).filter((n) => n.endsWith(".json")).length;
   } catch {
   }
+  if (json2)
+    out(
+      JSON.stringify(
+        {
+          version: VERSION,
+          machine: machineName(cfg, os11.hostname()),
+          state,
+          config: configFile(),
+          harnesses,
+          sinks,
+          timing: t,
+          control,
+          update: update2,
+          jobs
+        },
+        null,
+        2
+      )
+    );
+  else if (jobs) out(`  jobs:     ${jobs} waiting`);
 }
 function hookWall(runs = 8) {
-  const hook = path27.join(distDir, "hook.js");
-  const tmp = mkdtempSync(path27.join(os11.tmpdir(), "sessionpipe-doctor-"));
+  const hook = path29.join(distDir, "hook.js");
+  const tmp = mkdtempSync(path29.join(os11.tmpdir(), "sessionpipe-doctor-"));
   const env = {
     ...process.env,
     SESSIONPIPE_STATE: tmp,
-    SESSIONPIPE_CONFIG: path27.join(tmp, "config.json"),
+    SESSIONPIPE_CONFIG: path29.join(tmp, "config.json"),
     SESSIONPIPE_NO_WORKER: "1"
   };
   const input = JSON.stringify({
@@ -7663,18 +9000,24 @@ function hookWall(runs = 8) {
   } catch {
     return null;
   } finally {
-    rmSync2(tmp, { recursive: true, force: true });
+    rmSync3(tmp, { recursive: true, force: true });
   }
   times.sort((a, b) => a - b);
-  const q = (p) => Math.round(times[Math.min(times.length - 1, Math.floor(p * times.length))] ?? 0);
+  const q = (p) => Math.round(
+    /* v8 ignore next */
+    times[Math.min(times.length - 1, Math.floor(p * times.length))] ?? 0
+  );
   return { n: times.length, p50: q(0.5), p95: q(0.95) };
 }
 function timing() {
   try {
-    const lines = readFileSync15(path27.join(state, "timing.jsonl"), "utf8").trim().split("\n").slice(-100);
+    const lines = readFileSync16(path29.join(state, "timing.jsonl"), "utf8").trim().split("\n").slice(-100);
     const ms = lines.map((l) => JSON.parse(l).ms).filter((x) => x >= 0).sort((a, b) => a - b);
     if (!ms.length) return null;
-    const q = (p) => Math.round(ms[Math.min(ms.length - 1, Math.floor(p * ms.length))] ?? 0);
+    const q = (p) => Math.round(
+      /* v8 ignore next */
+      ms[Math.min(ms.length - 1, Math.floor(p * ms.length))] ?? 0
+    );
     return { n: ms.length, p50: q(0.5), p95: q(0.95) };
   } catch {
     return null;
@@ -7698,6 +9041,18 @@ async function doctor() {
     warnings: []
   };
   const warnings = report.warnings;
+  const health = await controlHealth();
+  report.control = health;
+  if (health && !health.running)
+    warnings.push("the control daemon is not running or not responding; polling is stopped");
+  for (const r of health?.receivers ?? []) {
+    if (!r.polling || r.last_poll_age_ms !== null && r.last_poll_age_ms >= 6e4) {
+      const age = r.last_poll_age_ms === null ? "never polled" : `not polled for ${Math.floor(r.last_poll_age_ms / 6e4)} minutes`;
+      warnings.push(
+        `${r.url}: the daemon has ${age}: ${r.last_error ?? (r.polling ? "no successful poll response" : "polling stopped")}`
+      );
+    }
+  }
   const upd = report.update;
   if (upd.failed)
     warnings.push(
@@ -7735,7 +9090,7 @@ async function doctor() {
     let linger = null;
     try {
       linger = /^Linger=yes/m.test(
-        execFileSync7("loginctl", ["show-user", os11.userInfo().username, "--property=Linger"], {
+        execFileSync8("loginctl", ["show-user", os11.userInfo().username, "--property=Linger"], {
           encoding: "utf8",
           timeout: 5e3,
           stdio: ["ignore", "pipe", "ignore"]
@@ -7803,6 +9158,7 @@ async function doctor() {
     out(
       `  sink ${s.name.padEnd(16)} tier ${s.tier}${s.max_tier !== null ? ` (receiver max ${s.max_tier})` : ""}${s.paused ? ` PAUSED ${s.paused}` : ""}`
     );
+  controlLines(health);
   const lr = report.launcher;
   if (lr)
     out(`  hooks run ${lr.file} \u2192 node ${lr.node ? tilde(lr.node) : "?"}${lr.node_ok ? "" : " (gone: PATH's node)"}`);
@@ -7858,6 +9214,9 @@ async function tail() {
       case "turn.transcript":
         detail = `#${d.turn} "${String(d.user).slice(0, 50).replace(/\s+/g, " ")}"`;
         break;
+      case "turn.progress":
+        detail = `#${d.turn} ${String(d.assistant ?? "").length} chars so far`;
+        break;
       case "session.backfill":
         detail = `${e.session.title ?? ""}`;
         break;
@@ -7869,7 +9228,7 @@ async function tail() {
   out(`sessionpipe tail \xB7 tier ${tier} \xB7 ${tilde(state)}/outbox (Ctrl-C to stop)`);
   for (const ref of outbox.sessions()) {
     try {
-      offsets.set(`${ref.harness}/${ref.session}`, has("--all") ? 0 : statSync10(outbox.file(ref)).size);
+      offsets.set(`${ref.harness}/${ref.session}`, has("--all") ? 0 : statSync11(outbox.file(ref)).size);
     } catch {
     }
   }
@@ -7892,7 +9251,7 @@ async function tail() {
 async function workerFromArgv() {
   const f = args[1];
   if (!f) return;
-  const job = JSON.parse(readFileSync15(f, "utf8"));
+  const job = JSON.parse(readFileSync16(f, "utf8"));
   try {
     unlinkSync7(f);
   } catch {
@@ -7954,9 +9313,14 @@ async function update() {
       `  The control daemon still runs ${running} and can't restart itself: ${process.platform === "darwin" ? `\`launchctl kickstart -k gui/${process.getuid?.() ?? "$(id -u)"}/org.sessionpipe.control\`` : process.platform === "linux" ? "`systemctl --user restart sessionpipe-control.service`" : "stop `sessionpipe control run` and start it again"} moves it (a run in progress stops).`
     );
 }
-main().catch((e) => {
-  process.stderr.write(`sessionpipe: ${e.message}
-`);
-  process.exit(1);
-});
+if (isEntrypoint(process.argv[1], import.meta.url)) {
+  process.stdout.on("error", (e) => {
+    if (e.code === "EPIPE") process.exit(0);
+  });
+  void main(process.argv.slice(2));
+}
+export {
+  isEntrypoint,
+  main
+};
 //# sourceMappingURL=cli.js.map