sessionpipe 0.1.1 → 0.2.0

package/dist/cli.js

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
-// sessionpipe 0.1.1 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe 0.2.0 · Apache-2.0 · https://sessionpipe.org
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/cli.ts
-import { execFileSync as execFileSync4, spawn, spawnSync } from "node:child_process";
-import { mkdtempSync, readdirSync as readdirSync7, readFileSync as readFileSync9, realpathSync as realpathSync2, rmSync, statSync as statSync6, unlinkSync as unlinkSync5 } from "node:fs";
-import os3 from "node:os";
-import path12 from "node:path";
+import { execFileSync as execFileSync6, spawn as spawn2, spawnSync } from "node:child_process";
+import { mkdtempSync, readdirSync as readdirSync8, readFileSync as readFileSync11, realpathSync as realpathSync4, rmSync, statSync as statSync9, unlinkSync as unlinkSync7 } from "node:fs";
+import os7 from "node:os";
+import path18 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../core/src/adapters/antigravity.ts
@@ -286,7 +291,7 @@ function entryFor(event, harness, cmd2, o) {
   const matcher = o.matcherFor(event);
   return {
     ...matcher !== void 0 ? { matcher } : {},
-    hooks: [{ type: "command", command: cmd2([harness, event]).command, timeout: o.timeout }]
+    hooks: [{ type: "command", command: cmd2([harness, event]).command, timeout: o.timeoutFor?.(event) ?? o.timeout }]
   };
 }
 function installClaudeShaped(file, harness, events, cmd2, o) {
@@ -710,7 +715,13 @@ var CLAUDE_EVENTS = [
 ];
 var LEAN_SKIP = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUseFailure"]);
 var eventsFor = (lean) => lean ? CLAUDE_EVENTS.filter((e) => !LEAN_SKIP.has(e)) : [...CLAUDE_EVENTS];
-var OPTS = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
+var OPTS = {
+  matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0,
+  timeout: 5,
+  // The hook waits up to 125 s for a verified control answer, and only when control
+  // is paired on this machine; everywhere else it exits in milliseconds as before.
+  timeoutFor: (e) => e === "PermissionRequest" ? 130 : void 0
+};
 var DESKTOP_ID = /^local_[A-Za-z0-9-]{1,64}$/;
 function claudeDirs(env = process.env, home = HOME) {
   const out2 = [];
@@ -1154,9 +1165,9 @@ function claudeFacts(file, sessionId, hints, state2) {
   }
   const name = live?.name ? { title: live.name, source: live.name_source } : typeof mem.name === "string" ? { title: mem.name, source: mem.name_source } : null;
   const pick = name && name.source === "custom" && name || custom && { title: custom, source: "custom" } || name || ai && { title: ai, source: "harness" };
-  let ask = typeof mem.first_ask === "string" ? mem.first_ask : firstAsk(H);
-  if (!ask && size > 64 * 1024 && !mem.first_ask_none) {
-    ask = scanLines(file, (l) => {
+  let ask2 = typeof mem.first_ask === "string" ? mem.first_ask : firstAsk(H);
+  if (!ask2 && size > 64 * 1024 && !mem.first_ask_none) {
+    ask2 = scanLines(file, (l) => {
       try {
         const t = askText(JSON.parse(l));
         return t ? appTitle(t) : null;
@@ -1164,17 +1175,17 @@ function claudeFacts(file, sessionId, hints, state2) {
         return null;
       }
     });
-    if (!ask && size > 16 * 1024 * 1024) state2.save(NAME2, id, { first_ask_none: true });
+    if (!ask2 && size > 16 * 1024 * 1024) state2.save(NAME2, id, { first_ask_none: true });
   }
-  if (ask) {
-    out2.first_ask = ask;
-    if (!mem.first_ask) state2.save(NAME2, id, { first_ask: ask });
+  if (ask2) {
+    out2.first_ask = ask2;
+    if (!mem.first_ask) state2.save(NAME2, id, { first_ask: ask2 });
   }
   if (pick) {
     out2.title = String(pick.title).slice(0, 120);
     out2.title_source = pick.source;
-  } else if (ask) {
-    out2.title = ask;
+  } else if (ask2) {
+    out2.title = ask2;
     out2.title_source = "first-ask";
   }
   const acct = claudeAccount(dir);
@@ -1851,17 +1862,366 @@ function prune4(o) {
   return o;
 }
 
+// ../core/src/adapters/claude-code-control.ts
+var claude_code_control_exports = {};
+__export(claude_code_control_exports, {
+  JOB_TIMEOUT_MS: () => JOB_TIMEOUT_MS,
+  claudeEnv: () => claudeEnv,
+  detectCaps: () => detectCaps,
+  findClaude: () => findClaude,
+  findTranscript: () => findTranscript,
+  isUuid: () => isUuid,
+  liveProcess: () => liveProcess,
+  modeFlags: () => modeFlags,
+  parseCaps: () => parseCaps,
+  parseResult: () => parseResult,
+  recentlyWritten: () => recentlyWritten,
+  runClaude: () => runClaude,
+  sessionFolder: () => sessionFolder
+});
+import { execFileSync as execFileSync4, spawn } from "node:child_process";
+import { accessSync, closeSync as closeSync2, constants, openSync as openSync2, readdirSync as readdirSync5, readFileSync as readFileSync6, readSync as readSync2, statSync as statSync4 } from "node:fs";
+import os2 from "node:os";
+import path8 from "node:path";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var JOB_TIMEOUT_MS = 30 * 6e4;
+var OUT_CAP = 1024 * 1024;
+var LIVE_WRITE_MS = 9e4;
+function isExe(p) {
+  try {
+    if (!statSync4(p).isFile()) return false;
+    accessSync(p, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var cmpVersion = (a, b) => {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++)
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
+  return 0;
+};
+function findClaude(env = process.env, home = os2.homedir()) {
+  if (env.SESSIONPIPE_CLAUDE && isExe(env.SESSIONPIPE_CLAUDE)) return env.SESSIONPIPE_CLAUDE;
+  const names = process.platform === "win32" ? ["claude.exe", "claude.cmd"] : ["claude"];
+  for (const d of String(env.PATH || "").split(path8.delimiter)) {
+    if (!d || !path8.isAbsolute(d)) continue;
+    for (const n of names) if (isExe(path8.join(d, n))) return path8.join(d, n);
+  }
+  for (const p of [
+    path8.join(home, ".claude", "local", "claude"),
+    path8.join(home, ".local", "bin", "claude"),
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude"
+  ])
+    if (isExe(p)) return p;
+  const app = path8.join(home, "Library", "Application Support", "Claude", "claude-code");
+  let versions = [];
+  try {
+    versions = readdirSync5(app).filter((n) => /^\d+(\.\d+)*$/.test(n)).sort(cmpVersion).reverse();
+  } catch {
+  }
+  for (const v of versions) {
+    const p = path8.join(app, v, "claude.app", "Contents", "MacOS", "claude");
+    if (isExe(p)) return p;
+  }
+  return null;
+}
+function optionBlock(help2, flag2) {
+  const lines = help2.split("\n");
+  const re = new RegExp(`^\\s{0,4}(?:-\\w, )?${flag2.replace(/-/g, "\\-")}(?![\\w-])`);
+  const start = lines.findIndex((l) => re.test(l));
+  if (start < 0) return null;
+  const out2 = [lines[start]];
+  for (let i = start + 1; i < lines.length && lines[i]?.trim() && !/^\s{0,4}-/.test(lines[i]); i++)
+    out2.push(lines[i]);
+  return out2.join(" ");
+}
+function parseCaps(help2) {
+  const pm = optionBlock(help2, "--permission-mode");
+  const pp = optionBlock(help2, "--permission-prompts");
+  return {
+    hasMode: !!pm,
+    modes: pm ? [...pm.matchAll(/"([A-Za-z]+)"/g)].map((m) => m[1]) : [],
+    promptsNone: !!pp && /"none"/.test(pp),
+    fork: !!optionBlock(help2, "--fork-session")
+  };
+}
+function modeFlags(mode, caps) {
+  if (mode === "auto") {
+    if (!caps.modes.includes("auto"))
+      return { error: "this machine is in auto mode, but its Claude Code has no auto permission mode" };
+    return { args: ["--permission-mode", "auto"] };
+  }
+  if (caps.modes.includes("dontAsk")) return { args: ["--permission-mode", "dontAsk"] };
+  const args2 = [];
+  if (caps.hasMode)
+    args2.push(
+      "--permission-mode",
+      caps.modes.includes("manual") && !caps.modes.includes("default") ? "manual" : "default"
+    );
+  if (caps.promptsNone) args2.push("--permission-prompts", "none");
+  return { args: args2 };
+}
+function claudeEnv(configDir, env = process.env) {
+  const e = { ...env };
+  for (const k of [
+    "CLAUDECODE",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_HOST_SESSION_ID",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_SESSION_ATTENDED",
+    "CLAUDE_CODE_SSE_PORT"
+  ])
+    delete e[k];
+  e.SESSIONPIPE_CONTROL_JOB = "1";
+  if (configDir !== void 0) {
+    if (path8.resolve(configDir) === path8.resolve(os2.homedir(), ".claude")) delete e.CLAUDE_CONFIG_DIR;
+    else e.CLAUDE_CONFIG_DIR = configDir;
+  }
+  return e;
+}
+function detectCaps(bin) {
+  let help2 = "";
+  try {
+    help2 = execFileSync4(bin, ["--help"], {
+      encoding: "utf8",
+      timeout: 3e4,
+      env: claudeEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 4 * 1024 * 1024
+    });
+  } catch (e) {
+    help2 = String(e?.stdout || "");
+  }
+  return parseCaps(help2);
+}
+function findTranscript(session, dirs) {
+  if (!UUID_RE.test(session)) return null;
+  for (const dir of dirs) {
+    let projects = [];
+    try {
+      projects = readdirSync5(path8.join(dir, "projects"), { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const p of projects) {
+      if (!p.isDirectory()) continue;
+      const file = path8.join(dir, "projects", p.name, `${session}.jsonl`);
+      try {
+        if (statSync4(file).isFile()) return { file, configDir: dir, project: p.name };
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+var projectName = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, "-");
+function sessionFolder(t, cap2 = 8 * 1024 * 1024) {
+  let first = null;
+  let count = 0;
+  let fd;
+  const look = (line) => {
+    if (line.indexOf('"cwd"') < 0) return null;
+    let j;
+    try {
+      j = JSON.parse(line.toString("utf8"));
+    } catch {
+      return null;
+    }
+    if (!j || typeof j.cwd !== "string" || !path8.isAbsolute(j.cwd)) return null;
+    if (projectName(j.cwd) === t.project) return j.cwd;
+    first ??= j.cwd;
+    count++;
+    return null;
+  };
+  try {
+    fd = openSync2(t.file, "r");
+    const buf = Buffer.alloc(256 * 1024);
+    let pos = 0;
+    let rest = Buffer.alloc(0);
+    let skipping = false;
+    while (pos < cap2 && count < 50) {
+      const n = readSync2(fd, buf, 0, buf.length, pos);
+      if (!n) {
+        if (!skipping && rest.length) {
+          const hit = look(rest);
+          if (hit) return hit;
+        }
+        break;
+      }
+      pos += n;
+      let chunk = rest.length ? Buffer.concat([rest, buf.subarray(0, n)]) : buf.subarray(0, n);
+      let nl = chunk.indexOf(10);
+      while (nl >= 0) {
+        const line = chunk.subarray(0, nl);
+        chunk = chunk.subarray(nl + 1);
+        if (skipping) skipping = false;
+        else {
+          const hit = look(line);
+          if (hit) return hit;
+        }
+        nl = chunk.indexOf(10);
+      }
+      if (chunk.length > 2 * 1024 * 1024) {
+        skipping = true;
+        rest = Buffer.alloc(0);
+      } else rest = skipping ? Buffer.alloc(0) : Buffer.from(chunk);
+    }
+  } catch {
+  } finally {
+    if (fd !== void 0)
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+  }
+  return first;
+}
+function pidAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function liveProcess(session, configDir) {
+  let names = [];
+  try {
+    names = readdirSync5(path8.join(configDir, "sessions")).filter((n) => /^\d+\.json$/.test(n));
+  } catch {
+    return false;
+  }
+  for (const n of names) {
+    try {
+      const j = JSON.parse(readFileSync6(path8.join(configDir, "sessions", n), "utf8"));
+      if (String(j.sessionId) !== session) continue;
+      if (pidAlive(Number(j.pid ?? n.slice(0, -5)))) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function recentlyWritten(file, ourLastEnd, now = Date.now()) {
+  let m;
+  try {
+    m = statSync4(file).mtimeMs;
+  } catch {
+    return false;
+  }
+  if (now - m > LIVE_WRITE_MS) return false;
+  return !(ourLastEnd && m <= ourLastEnd + 2e3);
+}
+function runClaude(bin, args2, o) {
+  return new Promise((resolve) => {
+    let out2 = [];
+    let outLen = 0;
+    let tooBig = false;
+    let errTail = "";
+    let timedOut = false;
+    let settled = false;
+    let child;
+    try {
+      child = spawn(bin, args2, {
+        cwd: o.cwd,
+        env: o.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+        windowsHide: true
+      });
+    } catch (e) {
+      resolve({ error: e.message });
+      return;
+    }
+    const kill = (sig) => {
+      try {
+        if (process.platform !== "win32" && child.pid) process.kill(-child.pid, sig);
+        else child.kill(sig);
+      } catch {
+        try {
+          child.kill(sig);
+        } catch {
+        }
+      }
+    };
+    child.stdout?.on("data", (b) => {
+      if (tooBig) return;
+      if (outLen + b.length > OUT_CAP) {
+        tooBig = true;
+        out2 = [];
+        return;
+      }
+      out2.push(b);
+      outLen += b.length;
+    });
+    child.stderr?.on("data", (b) => {
+      errTail = (errTail + b.toString("utf8")).slice(-4e3);
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill("SIGTERM");
+      setTimeout(() => kill("SIGKILL"), 1e4).unref();
+    }, o.timeoutMs ?? JOB_TIMEOUT_MS);
+    const result = (code, signal) => ({
+      code,
+      signal,
+      stdout: tooBig ? null : Buffer.concat(out2).toString("utf8"),
+      tooBig,
+      stderr: errTail,
+      timedOut
+    });
+    const finish = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(r);
+    };
+    child.on("error", (e) => finish({ error: e.message }));
+    child.on("exit", (code, signal) => setTimeout(() => finish(result(code, signal)), 2e3).unref());
+    child.on("close", (code, signal) => finish(result(code, signal)));
+  });
+}
+function parseResult(stdout) {
+  const s = String(stdout || "").trim();
+  if (!s) return null;
+  const pick = (j) => {
+    if (Array.isArray(j)) {
+      for (let i = j.length - 1; i >= 0; i--) if (j[i]?.type === "result") return j[i];
+      return null;
+    }
+    return j && typeof j === "object" ? j : null;
+  };
+  try {
+    return pick(JSON.parse(s));
+  } catch {
+  }
+  const lines = s.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const j = pick(JSON.parse(lines[i]));
+      if (j && (j.type === "result" || "result" in j)) return j;
+    } catch {
+    }
+  }
+  return null;
+}
+var isUuid = (s) => typeof s === "string" && UUID_RE.test(s);
+
 // ../core/src/adapters/index.ts
 var ADAPTERS = [claudeCode, codex, geminiCli, antigravity];
 var adapterByName = (name) => ADAPTERS.find((a) => a.name === name);
 
 // ../core/src/config.ts
-import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import path8 from "node:path";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import path9 from "node:path";
 var DEFAULT_CONFIG = { sinks: [], harnesses: {}, update_check: true, keep_days: 30 };
 function readConfig(file = configFile()) {
   try {
-    const j = JSON.parse(readFileSync6(file, "utf8"));
+    const j = JSON.parse(readFileSync7(file, "utf8"));
     return {
       ...DEFAULT_CONFIG,
       ...j,
@@ -1873,7 +2233,7 @@ function readConfig(file = configFile()) {
   }
 }
 function writeConfig(c, file = configFile()) {
-  mkdirSync4(path8.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync4(path9.dirname(file), { recursive: true, mode: 448 });
   writeFileSync4(file, `${JSON.stringify(c, null, 2)}
 `, { mode: 384 });
   if (process.platform !== "win32" && existsSync6(file)) {
@@ -1941,32 +2301,32 @@ function makeEvent(a, ctx) {
 // ../core/src/outbox.ts
 import {
   appendFileSync,
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   existsSync as existsSync7,
   mkdirSync as mkdirSync5,
-  openSync as openSync2,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync7,
-  readSync as readSync2,
+  openSync as openSync3,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync8,
+  readSync as readSync3,
   renameSync,
-  statSync as statSync4,
+  statSync as statSync5,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 var Outbox = class {
   constructor(root) {
     this.root = root;
   }
   root;
   dir(harness) {
-    return path9.join(this.root, "outbox", safeId(harness));
+    return path10.join(this.root, "outbox", safeId(harness));
   }
   file(ref) {
-    return path9.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
+    return path10.join(this.dir(ref.harness), `${safeId(ref.session)}.jsonl`);
   }
   seqFile(ref) {
-    return path9.join(this.dir(ref.harness), `${safeId(ref.session)}.seq`);
+    return path10.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). */
@@ -1974,18 +2334,18 @@ var Outbox = class {
     const f = this.seqFile(ref);
     let n = 0;
     try {
-      n = Number(readFileSync7(f, "utf8")) || 0;
+      n = Number(readFileSync8(f, "utf8")) || 0;
     } catch {
       n = this.lastSeqInFile(ref) + 1;
     }
-    mkdirSync5(path9.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync5(path10.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;
-    const lines = readFileSync7(f, "utf8").trim().split("\n");
+    const lines = readFileSync8(f, "utf8").trim().split("\n");
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
         const j = JSON.parse(lines[i] ?? "");
@@ -2004,19 +2364,19 @@ var Outbox = class {
   /** Every session file, newest first. */
   sessions() {
     const out2 = [];
-    const base = path9.join(this.root, "outbox");
+    const base = path10.join(this.root, "outbox");
     if (!existsSync7(base)) return [];
-    for (const h of readdirSync5(base)) {
-      const d = path9.join(base, h);
+    for (const h of readdirSync6(base)) {
+      const d = path10.join(base, h);
       let names = [];
       try {
-        names = readdirSync5(d).filter((n) => n.endsWith(".jsonl"));
+        names = readdirSync6(d).filter((n) => n.endsWith(".jsonl"));
       } catch {
         continue;
       }
       for (const n of names) {
         try {
-          out2.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync4(path9.join(d, n)).mtimeMs });
+          out2.push({ ref: { harness: h, session: n.slice(0, -6) }, mtime: statSync5(path10.join(d, n)).mtimeMs });
         } catch {
         }
       }
@@ -2028,12 +2388,12 @@ var Outbox = class {
   read(ref, from, maxEvents = 500) {
     const f = this.file(ref);
     if (!existsSync7(f)) return { events: [], offset: from };
-    const size = statSync4(f).size;
+    const size = statSync5(f).size;
     if (from >= size) return { events: [], offset: from };
-    const fd = openSync2(f, "r");
+    const fd = openSync3(f, "r");
     try {
       const buf = Buffer.alloc(Math.min(size - from, 8 * 1024 * 1024));
-      const n = readSync2(fd, buf, 0, buf.length, from);
+      const n = readSync3(fd, buf, 0, buf.length, from);
       const text = buf.subarray(0, n).toString("utf8");
       const events = [];
       let offset = from;
@@ -2052,7 +2412,7 @@ var Outbox = class {
       }
       return { events, offset };
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
   }
   /** Files older than `days` are pruned; the cursor files with them. */
@@ -2062,7 +2422,7 @@ var Outbox = class {
     for (const ref of this.sessions()) {
       const f = this.file(ref);
       try {
-        if (statSync4(f).mtimeMs < cutoff) {
+        if (statSync5(f).mtimeMs < cutoff) {
           unlinkSync3(f);
           try {
             unlinkSync3(this.seqFile(ref));
@@ -2092,18 +2452,18 @@ var Cursors = class {
   root;
   sink;
   file() {
-    return path9.join(this.root, "cursors", `${safeId(this.sink)}.json`);
+    return path10.join(this.root, "cursors", `${safeId(this.sink)}.json`);
   }
   read() {
     try {
-      return JSON.parse(readFileSync7(this.file(), "utf8"));
+      return JSON.parse(readFileSync8(this.file(), "utf8"));
     } catch {
       return {};
     }
   }
   write(c) {
     const f = this.file();
-    mkdirSync5(path9.dirname(f), { recursive: true, mode: 448 });
+    mkdirSync5(path10.dirname(f), { recursive: true, mode: 448 });
     const tmp = `${f}.${process.pid}.tmp`;
     writeFileSync5(tmp, JSON.stringify(c), { mode: 384 });
     renameSync(tmp, f);
@@ -2113,11 +2473,11 @@ var Cursors = class {
   }
 };
 function takeLock(root, ref, staleMs = 5 * 6e4) {
-  const dir = path9.join(root, "locks");
+  const dir = path10.join(root, "locks");
   mkdirSync5(dir, { recursive: true, mode: 448 });
-  const f = path9.join(dir, `${safeId(ref.harness)}-${safeId(ref.session)}.lock`);
+  const f = path10.join(dir, `${safeId(ref.harness)}-${safeId(ref.session)}.lock`);
   try {
-    if (Date.now() - statSync4(f).mtimeMs > staleMs) unlinkSync3(f);
+    if (Date.now() - statSync5(f).mtimeMs > staleMs) unlinkSync3(f);
     else return null;
   } catch {
   }
@@ -2431,7 +2791,7 @@ function filterEvent(event, tier, pii, opts = {}) {
 
 // ../core/src/sinks/file.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 var FileSink = class {
   constructor(name, file, tier, pii) {
     this.name = name;
@@ -2445,7 +2805,7 @@ var FileSink = class {
   pii;
   async send(events) {
     try {
-      mkdirSync6(path10.dirname(this.file), { recursive: true });
+      mkdirSync6(path11.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: [] };
@@ -2474,134 +2834,1978 @@ var StdoutSink = class {
   }
 };
 
-// src/run.ts
-import {
-  appendFileSync as appendFileSync3,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync7,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync8,
-  renameSync as renameSync2,
-  statSync as statSync5,
-  unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync6
-} from "node:fs";
-import os2 from "node:os";
-import path11 from "node:path";
+// src/control/cli.ts
+import { existsSync as existsSync11, realpathSync as realpathSync3, watchFile } from "node:fs";
+import os5 from "node:os";
+import path16 from "node:path";
 
-// src/http-sink.ts
-import { createHmac, randomUUID } from "node:crypto";
-var TIMEOUT_MS = 15e3;
-var HttpSink = class {
-  constructor(cfg, tier) {
-    this.cfg = cfg;
-    this.tier = tier;
-    this.name = cfg.name;
-    this.pii = !!cfg.pii;
-    this.url = cfg.url.replace(/\/$/, "");
-  }
-  cfg;
-  tier;
-  name;
-  pii;
-  url;
-  eventsUrl() {
-    const ep = this.cfg.endpoints?.events ?? "/api/sessionpipe/v1/events";
-    return /^https?:\/\//.test(ep) ? ep : this.url + ep;
+// src/control/daemon.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync8, realpathSync as realpathSync2, statSync as statSync7, unlinkSync as unlinkSync4 } from "node:fs";
+import net from "node:net";
+import path13 from "node:path";
+
+// ../core/src/control/verify.ts
+var GRANT_MAX_MS = 24 * 36e5;
+var SKEW_MS = 5 * 6e4;
+var MACHINE_MAX_AGE_MS = 24 * 36e5;
+var RECEIVER_MAX_AGE_MS = 10 * 6e4;
+var NONCE_TTL_MS = 25 * 36e5;
+var CMD_MAX = 12e3;
+var TEXT_MAX = 4e3;
+var NOTE_MAX = 2e3;
+var GRANT_STR_MAX = 2e3;
+var COMMAND_TYPE = "sessionpipe.control";
+var GRANT_TYPE = "sessionpipe.grant";
+var CONTROL_KINDS = ["prompt", "permission.answer", "cancel", "start"];
+var ES256 = -7;
+var RS256 = -257;
+var NONCE_RE = /^[A-Za-z0-9_-]{22,64}$/;
+var MACHINE_RE = /^m_[A-Za-z0-9_-]{16,40}$/;
+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 UP = 1;
+var UV = 4;
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+function b64url(bytes) {
+  const u = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  let s = "";
+  for (const b of u) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromB64url(s) {
+  if (typeof s !== "string" || !B64URL_RE.test(s) || s.length % 4 === 1) return null;
+  try {
+    const bin = atob(s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4));
+    const out2 = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out2[i] = bin.charCodeAt(i);
+    return out2;
+  } catch {
+    return null;
   }
-  async send(events) {
-    const body = JSON.stringify({ events });
-    const headers = { "content-type": "application/json", "sessionpipe-protocol": "1" };
-    if (this.cfg.token) headers.authorization = `Bearer ${this.cfg.token}`;
-    if (this.cfg.secret?.startsWith("whsec_")) {
-      const id = `msg_${randomUUID()}`;
-      const ts = Math.floor(Date.now() / 1e3);
-      const key = Buffer.from(this.cfg.secret.slice(6), "base64");
-      const sig = createHmac("sha256", key).update(`${id}.${ts}.${body}`).digest("base64");
-      headers["webhook-id"] = id;
-      headers["webhook-timestamp"] = String(ts);
-      headers["webhook-signature"] = `v1,${sig}`;
-    }
-    const ctl = new AbortController();
-    const t = setTimeout(() => ctl.abort(), TIMEOUT_MS);
-    try {
-      const r = await fetch(this.eventsUrl(), { method: "POST", headers, body, signal: ctl.signal });
-      const text = await r.text();
-      let j = {};
-      try {
-        j = text ? JSON.parse(text) : {};
-      } catch {
-      }
-      if (r.status === 202 || r.status === 200) {
-        return {
-          ok: true,
-          acknowledged: events.length,
-          accepted: Number(j.accepted ?? events.length),
-          duplicates: Number(j.duplicates ?? 0),
-          rejected: Array.isArray(j.rejected) ? j.rejected : [],
-          ...typeof j.max_tier === "number" ? { max_tier: j.max_tier } : {},
-          status: r.status
-        };
-      }
-      const err = typeof j.reason === "string" ? j.reason : text.slice(0, 200);
-      if (r.status === 400) return { ok: false, acknowledged: 0, status: 400, error: err, action: "drop" };
-      if (r.status === 401) return { ok: false, acknowledged: 0, status: 401, error: err, action: "pause" };
-      if (r.status === 403)
-        return {
-          ok: false,
-          acknowledged: 0,
-          status: 403,
-          error: err,
-          action: "lower-tier",
-          ...typeof j.max_tier === "number" ? { max_tier: j.max_tier } : {}
-        };
-      if (r.status === 413) return { ok: false, acknowledged: 0, status: 413, error: err, action: "split" };
-      if (r.status === 429)
-        return {
-          ok: false,
-          acknowledged: 0,
-          status: 429,
-          error: err,
-          action: "retry",
-          retryAfterMs: Number(r.headers.get("retry-after") ?? 60) * 1e3
-        };
-      return { ok: false, acknowledged: 0, status: r.status, error: err, action: "retry" };
-    } catch (e) {
-      return { ok: false, acknowledged: 0, error: String(e.message ?? e), action: "retry" };
-    } finally {
-      clearTimeout(t);
+}
+async function sha256(data) {
+  const bytes = typeof data === "string" ? enc.encode(data) : data;
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+}
+function concat(a, b) {
+  const out2 = new Uint8Array(a.length + b.length);
+  out2.set(a, 0);
+  out2.set(b, a.length);
+  return out2;
+}
+function sameBytes(a, b) {
+  if (a.length !== b.length) return false;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) d |= a[i] ^ b[i];
+  return d === 0;
+}
+function derToRaw(der) {
+  if (der[0] !== 48 || der.length < 8 || der[1] !== der.length - 2) return null;
+  let i = 2;
+  const part = () => {
+    if (der[i] !== 2) return null;
+    const len = der[i + 1];
+    if (len < 1 || len > 33) return null;
+    let v = der.slice(i + 2, i + 2 + len);
+    if (v.length !== len) return null;
+    if (v[0] & 128) return null;
+    if (len > 1 && v[0] === 0 && !(v[1] & 128)) return null;
+    i += 2 + len;
+    while (v.length > 32 && v[0] === 0) v = v.slice(1);
+    if (v.length > 32) return null;
+    const out2 = new Uint8Array(32);
+    out2.set(v, 32 - v.length);
+    return out2;
+  };
+  const r = part();
+  const s = part();
+  return r && s && i === der.length ? concat(r, s) : null;
+}
+var u8 = (b) => b;
+async function importKey(key) {
+  const spki = fromB64url(key.spki);
+  if (!spki?.length) return null;
+  try {
+    if (key.alg === ES256)
+      return await crypto.subtle.importKey("spki", u8(spki), { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+    if (key.alg === RS256) {
+      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;
+      return bits >= 2048 ? k : null;
     }
+  } catch {
   }
-};
-
-// src/run.ts
-var VERSION = true ? "0.1.1" : "0.0.0";
-function enqueueJob(state2, job) {
-  const jobs = jobsDir(state2);
-  mkdirSync7(jobs, { recursive: true, mode: 448 });
-  const f = path11.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
-  writeFileSync6(f, JSON.stringify(job), { mode: 384 });
-  return f;
+  return null;
 }
-function log(state2, line) {
+async function keyUsable(key) {
+  return !!key && typeof key.id === "string" && /^[A-Za-z0-9_-]{16,1400}$/.test(key.id) && (key.alg === ES256 || key.alg === RS256) && !!await importKey(key);
+}
+function originAllowed(origin, rpId) {
+  if (typeof origin !== "string" || !rpId) return false;
+  let u;
   try {
-    mkdirSync7(state2, { recursive: true, mode: 448 });
-    const f = path11.join(state2, "log");
-    try {
-      if (statSync5(f).size > 1024 * 1024) renameSync2(f, `${f}.1`);
-    } catch {
-    }
-    appendFileSync3(f, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
-`);
+    u = new URL(origin);
   } catch {
+    return false;
   }
+  if (u.origin !== origin) return false;
+  if (u.hostname !== rpId && !u.hostname.endsWith(`.${rpId}`)) return false;
+  if (u.protocol === "https:") return true;
+  return u.protocol === "http:" && rpId === "localhost";
 }
-function factsState(state2) {
-  const file = (h, s) => path11.join(state2, "facts", safeId(h), `${safeId(s)}.json`);
+var no = (why) => ({ ok: false, why });
+async function verifyAssertion(challenge, a, key, rpId) {
+  if (!a || typeof a !== "object") return no("no passkey signature");
+  if (a.cred !== key.id) return no("signed with a key this machine doesn't trust");
+  const cdBytes = fromB64url(a.cd);
+  const ad = fromB64url(a.ad);
+  const sig = fromB64url(a.sig);
+  if (!cdBytes || !ad || !sig?.length) return no("the passkey signature is malformed");
+  let cd;
+  try {
+    cd = JSON.parse(dec.decode(cdBytes));
+  } catch {
+    return no("the passkey signature is malformed");
+  }
+  if (!cd || typeof cd !== "object") return no("the passkey signature is malformed");
+  if (cd.type !== "webauthn.get") return no("the passkey answered a different question");
+  if (cd.challenge !== b64url(challenge)) return no("the passkey signed something else");
+  if (!originAllowed(cd.origin, rpId)) return no(`the passkey was used on another site, not ${rpId}`);
+  if (cd.crossOrigin === true) return no("the passkey was used inside another site's frame");
+  if (ad.length < 37) return no("the passkey signature is malformed");
+  if (!sameBytes(ad.slice(0, 32), await sha256(rpId))) return no(`the passkey belongs to another site, not ${rpId}`);
+  const flags = ad[32];
+  if (!(flags & UP) || !(flags & UV)) return no("the passkey signed without verifying the person");
+  const pub = await importKey(key);
+  if (!pub) return no("a trusted key is unusable");
+  const signed = concat(ad, await sha256(cdBytes));
+  let good = false;
+  try {
+    if (key.alg === ES256) {
+      const raw = derToRaw(sig);
+      good = !!raw && await crypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, pub, u8(raw), u8(signed));
+    } else {
+      good = await crypto.subtle.verify({ name: "RSASSA-PKCS1-v1_5" }, pub, u8(sig), u8(signed));
+    }
+  } catch {
+    good = false;
+  }
+  return good ? { ok: true } : no("the passkey signature doesn't verify");
+}
+function pairChallenge(machine, code) {
+  return sha256(`sessionpipe.pair:${machine}:${code}`);
+}
+async function verifyEnrollment(o) {
+  if (!await keyUsable(o.key)) return no("the key is in a shape this machine can't use");
+  return verifyAssertion(await pairChallenge(o.machine, o.code), o.proof, o.key, o.rpId);
+}
+var bad = (code, why) => ({
+  ok: false,
+  code,
+  why
+});
+var isNum = (n) => typeof n === "number" && Number.isFinite(n);
+function sessionIdOk(harness, id) {
+  if (!SESSION_ID_RE.test(id)) return false;
+  if (harness === "claude-code") return UUID_RE2.test(id);
+  return true;
+}
+function parseSessionRef(ref) {
+  if (typeof ref !== "string") return null;
+  const i = ref.indexOf(":");
+  if (i <= 0) return null;
+  const harness = ref.slice(0, i);
+  const id = ref.slice(i + 1);
+  return HARNESS_RE.test(harness) && sessionIdOk(harness, id) ? { harness, id } : null;
+}
+function parseCommand(str) {
+  if (typeof str !== "string" || !str || str.length > CMD_MAX)
+    return bad("malformed", "the command is missing or too long");
+  let c;
+  try {
+    c = JSON.parse(str);
+  } catch {
+    return bad("malformed", "the command is not JSON");
+  }
+  if (!c || typeof c !== "object" || Array.isArray(c)) return bad("malformed", "the command is not an object");
+  if (c.v !== 1 || c.t !== COMMAND_TYPE) return bad("not_a_command", "not a sessionpipe control command");
+  if (typeof c.machine !== "string" || !MACHINE_RE.test(c.machine)) return bad("malformed", "which machine?");
+  if (!CONTROL_KINDS.includes(c.kind))
+    return bad("unknown_kind", "the command asks for something unknown");
+  const ref = parseSessionRef(c.session);
+  if (!ref) return bad("bad_session", "which session?");
+  if (typeof c.nonce !== "string" || !NONCE_RE.test(c.nonce))
+    return bad("bad_nonce", "the nonce is missing or malformed");
+  if (!isNum(c.iat) || !Number.isInteger(c.iat) || c.iat <= 0)
+    return bad("malformed", "the command has no signing time");
+  const has2 = (k) => c[k] !== void 0;
+  const text = () => typeof c.text === "string" && c.text.trim().length > 0 && c.text.length <= TEXT_MAX;
+  switch (c.kind) {
+    case "prompt":
+      if (!text()) return bad("bad_fields", `a prompt needs text, at most ${TEXT_MAX} characters`);
+      if (has2("for") || has2("decision") || has2("cwd")) return bad("bad_fields", "a prompt carries only text");
+      break;
+    case "start":
+      if (!text()) return bad("bad_fields", `a new session needs text, at most ${TEXT_MAX} characters`);
+      if (ref.harness !== "claude-code") return bad("bad_fields", "only Claude Code sessions can be started");
+      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");
+      break;
+    case "permission.answer":
+      if (typeof c.for !== "string" || !c.for || c.for.length > 128) return bad("bad_fields", "which attention?");
+      if (c.decision !== "allow" && c.decision !== "deny") return bad("bad_fields", "allow or deny?");
+      if (has2("text") || has2("cwd")) return bad("bad_fields", "a permission answer carries for, decision and note");
+      break;
+    case "cancel":
+      if (has2("text") || has2("for") || has2("decision") || has2("cwd"))
+        return bad("bad_fields", "a cancel carries nothing");
+      break;
+  }
+  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 isAbsolute(p) {
+  return p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p);
+}
+function parseGrant(str, rpId) {
+  if (typeof str !== "string" || !str || str.length > GRANT_STR_MAX)
+    return { ok: false, why: "the grant is missing or too long" };
+  let g;
+  try {
+    g = JSON.parse(str);
+  } catch {
+    return { ok: false, why: "the grant is not JSON" };
+  }
+  if (!g || typeof g !== "object" || Array.isArray(g)) return { ok: false, why: "the grant is not an object" };
+  if (g.v !== 1 || g.t !== GRANT_TYPE) return { ok: false, why: "not a sessionpipe grant" };
+  if (g.rp !== rpId) return { ok: false, why: `the grant is for another site, not ${rpId}` };
+  if (typeof g.pub !== "string" || !fromB64url(g.pub)?.length || !isNum(g.iat) || !isNum(g.exp))
+    return { ok: false, why: "the grant is missing parts" };
+  if (g.exp <= g.iat) return { ok: false, why: "the grant ends before it starts" };
+  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) {
+  const sig = fromB64url(csig);
+  const spki = fromB64url(pub);
+  if (sig?.length !== 64 || !spki) return false;
+  try {
+    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)));
+  } catch {
+    return false;
+  }
+}
+async function verifyCommand(s, o) {
+  if (!s || typeof s !== "object") return bad("malformed", "nothing to verify");
+  const p = parseCommand(s.cmd);
+  if (!p.ok) return p;
+  const c = p.cmd;
+  if (c.machine !== o.machine) return bad("wrong_machine", "the command is for another machine");
+  let via = null;
+  let keyId = "";
+  let refusal = null;
+  if (s.grant && s.csig) {
+    const r = await checkGrantPath(s, c, o);
+    if (r.ok) {
+      via = "grant";
+      keyId = r.key;
+    } else refusal = r;
+  }
+  if (!via && s.confirm) {
+    const key = o.trusted.find((k) => k && k.id === s.confirm?.cred);
+    if (!key) refusal = { code: "untrusted_key", why: "confirmed with a key this machine doesn't trust" };
+    else {
+      const a = await verifyAssertion(await sha256(s.cmd), s.confirm, key, o.rpId);
+      if (a.ok) {
+        via = "confirm";
+        keyId = key.id;
+      } else refusal = { code: "bad_assertion", why: a.why };
+    }
+  }
+  if (!via) {
+    if (refusal) return bad(refusal.code, refusal.why);
+    return bad("unsigned", "the command isn't signed");
+  }
+  if (c.iat > o.now + SKEW_MS) return bad("future", "the command is dated in the future (is this clock right?)");
+  if (o.now - c.iat > (o.maxAgeMs ?? MACHINE_MAX_AGE_MS)) return bad("too_old", "the command was signed too long ago");
+  if (o.seenNonce) {
+    let seen;
+    try {
+      seen = await o.seenNonce(c.nonce);
+    } catch {
+      return bad("nonce_store", "the nonce couldn't be recorded, so the command didn't run");
+    }
+    if (seen) return bad("replay", "this command was already used once");
+  }
+  return { ok: true, cmd: c, via, key: keyId };
+}
+async function checkGrantPath(s, c, o) {
+  const bundle = s.grant;
+  const g = parseGrant(bundle.str, o.rpId);
+  if (!g.ok) return bad("bad_grant", g.why);
+  const key = o.trusted.find((k) => k && k.id === bundle.cred);
+  if (!key) return bad("untrusted_key", "the grant was signed with a key this machine doesn't trust");
+  const a = await verifyAssertion(await sha256(bundle.str), bundle, key, o.rpId);
+  if (!a.ok) return bad("bad_assertion", a.why);
+  if (!await verifyCsig(s.cmd, s.csig, g.grant.pub))
+    return bad("bad_csig", "the command's signature doesn't verify \u2014 it was changed after it was signed");
+  if (c.iat < g.grant.iat - SKEW_MS || c.iat > g.grant.exp)
+    return bad("outside_grant", "the command was signed outside its grant's window");
+  return { ok: true, key: key.id };
+}
+
+// src/control/reply.ts
+import { closeSync as closeSync4, openSync as openSync4, readSync as readSync4, statSync as statSync6 } from "node:fs";
+function transcriptEnd(file) {
+  try {
+    return statSync6(file).size;
+  } catch {
+    return 0;
+  }
+}
+function answerIn(lines) {
+  const parts = [];
+  for (const line of lines) {
+    let j;
+    try {
+      j = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (j.type !== "assistant" || j.isSidechain) continue;
+    const content = j.message?.content;
+    if (Array.isArray(content)) {
+      for (const c of content)
+        if (c?.type === "text" && typeof c.text === "string" && c.text.trim()) parts.push(c.text.trim());
+    }
+    if (j.message?.stop_reason === "end_turn") return { done: true, text: parts.join("\n\n") };
+  }
+  return { done: false, text: parts.join("\n\n") };
+}
+async function awaitAnswer(file, from, o) {
+  const now = o.now ?? Date.now;
+  const sleep2 = o.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms).unref?.()));
+  const until = now() + o.timeoutMs;
+  let offset = from;
+  let partial = "";
+  const lines = [];
+  while (now() < until) {
+    const size = transcriptEnd(file);
+    if (size < offset) return null;
+    if (size > offset) {
+      const fd = openSync4(file, "r");
+      try {
+        const buf = Buffer.alloc(Math.min(size - offset, 4 * 1024 * 1024));
+        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));
+      } finally {
+        closeSync4(fd);
+      }
+      const a = answerIn(lines);
+      if (a.done) return a.text || null;
+    }
+    await sleep2(o.pollMs ?? 500);
+  }
+  return null;
+}
+
+// src/control/route.ts
+function routePrompt(s) {
+  if (s.sdk) return { mode: "sdk" };
+  if (s.waiter) return { mode: "waiter" };
+  if (s.midTurn) return { mode: "turn" };
+  if (s.api) return { mode: "api" };
+  if (s.harness !== "claude-code") return { unsupported: `no idle delivery for ${s.harness} yet` };
+  if (!s.known) return { refused: "no_session" };
+  if (!s.live) return { mode: "resume" };
+  if (s.canFork) return { mode: "fork" };
+  return { unsupported: "the session is open and this Claude Code can't copy it (no --fork-session)" };
+}
+function kindPath(kind, harness) {
+  switch (kind) {
+    case "prompt":
+      return "prompt";
+    case "permission.answer":
+      return harness === "gemini-cli" ? { unsupported: "Gemini CLI has no permission answer channel" } : "permission";
+    case "cancel":
+      return "cancel";
+    case "start":
+      return harness === "claude-code" ? "start" : { unsupported: `can't start a ${harness} session` };
+    default:
+      return { unsupported: `unknown kind ${String(kind)}` };
+  }
+}
+var IN_PLACE_ANSWER = "Answer it right here, as you would answer the person at the keyboard: your reply is sent back to them automatically. Don't run a command or call a tool just to send it.";
+function frame(text, receiver) {
+  let host = receiver;
+  try {
+    host = new URL(receiver).host;
+  } catch {
+  }
+  return `Message via ${host} (sessionpipe control, signed on the sender's device):
+
+${text}`;
+}
+
+// src/control/store.ts
+import {
+  appendFileSync as appendFileSync3,
+  chmodSync as chmodSync2,
+  closeSync as closeSync5,
+  existsSync as existsSync8,
+  fsyncSync,
+  mkdirSync as mkdirSync7,
+  openSync as openSync5,
+  readFileSync as readFileSync9,
+  renameSync as renameSync2,
+  writeFileSync as writeFileSync6
+} from "node:fs";
+import path12 from "node:path";
+var controlFile = (env = process.env) => path12.join(path12.dirname(configFile(env)), "control.json");
+var controlState = (env = process.env) => path12.join(stateDir(env), "control");
+function writePrivate(file, value) {
+  mkdirSync7(path12.dirname(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync6(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  renameSync2(tmp, file);
+  try {
+    chmodSync2(file, 384);
+  } catch {
+  }
+}
+function readControl(env = process.env) {
+  try {
+    const j = JSON.parse(readFileSync9(controlFile(env), "utf8"));
+    if (!j || !Array.isArray(j.receivers)) return null;
+    return {
+      name: j.name || "machine",
+      folders: j.folders ?? [],
+      mode: j.mode === "auto" ? "auto" : "safe",
+      receivers: j.receivers
+    };
+  } catch {
+    return null;
+  }
+}
+var writeControl = (c, env = process.env) => writePrivate(controlFile(env), c);
+var NonceStore = class {
+  constructor(file, now = Date.now) {
+    this.file = file;
+    this.now = now;
+    let raw = "";
+    try {
+      raw = readFileSync9(file, "utf8");
+    } catch {
+    }
+    const cut = 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);
+      } catch {
+      }
+    }
+    this.compact();
+  }
+  file;
+  now;
+  seenAt = /* @__PURE__ */ new Map();
+  seen = (nonce) => {
+    const t = this.seenAt.get(nonce);
+    if (t !== void 0 && t > this.now() - NONCE_TTL_MS) return true;
+    const at = this.now();
+    mkdirSync7(path12.dirname(this.file), { recursive: true, mode: 448 });
+    const fd = openSync5(this.file, "a", 384);
+    try {
+      appendFileSync3(fd, `${JSON.stringify({ n: nonce, t: at })}
+`);
+      fsyncSync(fd);
+    } finally {
+      closeSync5(fd);
+    }
+    this.seenAt.set(nonce, at);
+    return false;
+  };
+  /** 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 (!existsSync8(this.file) && !this.seenAt.size) return;
+    const body = [...this.seenAt].map(([n, t]) => JSON.stringify({ n, t })).join("\n");
+    mkdirSync7(path12.dirname(this.file), { recursive: true, mode: 448 });
+    writeFileSync6(`${this.file}.tmp`, body ? `${body}
+` : "", { mode: 384 });
+    renameSync2(`${this.file}.tmp`, this.file);
+  }
+  get size() {
+    return this.seenAt.size;
+  }
+};
+var AckOutbox = class {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  all() {
+    try {
+      return readFileSync9(this.file, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+    } catch {
+      return [];
+    }
+  }
+  add(a) {
+    mkdirSync7(path12.dirname(this.file), { recursive: true, mode: 448 });
+    appendFileSync3(this.file, `${JSON.stringify(a)}
+`, { mode: 384 });
+  }
+  keep(left) {
+    mkdirSync7(path12.dirname(this.file), { recursive: true, mode: 448 });
+    writeFileSync6(`${this.file}.tmp`, left.map((a) => JSON.stringify(a)).join("\n") + (left.length ? "\n" : ""), {
+      mode: 384
+    });
+    renameSync2(`${this.file}.tmp`, this.file);
+  }
+};
+function readState(file) {
+  try {
+    const j = JSON.parse(readFileSync9(file, "utf8"));
+    return { copies: j.copies && typeof j.copies === "object" ? j.copies : {} };
+  } catch {
+    return { copies: {} };
+  }
+}
+var writeState = (file, s) => writePrivate(file, s);
+
+// src/control/daemon.ts
+var {
+  claudeEnv: claudeEnv2,
+  findTranscript: findTranscript2,
+  isUuid: isUuid2,
+  JOB_TIMEOUT_MS: JOB_TIMEOUT_MS2,
+  liveProcess: liveProcess2,
+  modeFlags: modeFlags2,
+  parseResult: parseResult2,
+  recentlyWritten: recentlyWritten2,
+  sessionFolder: sessionFolder2
+} = claude_code_control_exports;
+var VERSION = true ? "0.2.0" : "0.0.0";
+var MAX_REPLY = 2e4;
+var HELLO_EVERY_MS = 10 * 6e4;
+var TURN_FALLBACK_MS = 30 * 6e4;
+var ANSWER_WAIT_MS = 30 * 6e4;
+var RECENT_ACKS_MS = 25 * 36e5;
+var CLOSES_ATTENTION = /* @__PURE__ */ new Set([
+  "PostToolUse",
+  "PostToolUseFailure",
+  "Stop",
+  "StopFailure",
+  "UserPromptSubmit",
+  "SessionEnd"
+]);
+var LIMITS = { startConcurrent: 2, startPerHour: 10, headless: 3 };
+var ControlDaemon = class {
+  constructor(cfg, dir, sock, deps) {
+    this.cfg = cfg;
+    this.dir = dir;
+    this.sock = sock;
+    this.deps = deps;
+    this.nonces = new NonceStore(path13.join(dir, "nonces.jsonl"), deps.now);
+    this.acks = new AckOutbox(path13.join(dir, "acks.jsonl"));
+    this.state = readState(path13.join(dir, "state.json"));
+  }
+  cfg;
+  dir;
+  sock;
+  deps;
+  server = null;
+  live = /* @__PURE__ */ new Map();
+  sdkSessions = /* @__PURE__ */ new Map();
+  nonces;
+  acks;
+  recentAcks = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Set();
+  queues = /* @__PURE__ */ new Map();
+  lastEnd = /* @__PURE__ */ new Map();
+  state;
+  running = false;
+  polling = /* @__PURE__ */ new Map();
+  delivered = {};
+  helloTimer = null;
+  helloSoon = null;
+  aborts = /* @__PURE__ */ new Set();
+  startsRunning = 0;
+  startTimes = [];
+  procs = 0;
+  procWaiters = [];
+  // --- lifecycle ------------------------------------------------------------------
+  async start() {
+    this.running = true;
+    mkdirSync8(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);
+    this.helloTimer.unref();
+    void this.helloAll();
+    void this.flushAcks();
+    const idle = setInterval(() => this.closeIdleSdk(), 6e4);
+    idle.unref();
+    this.deps.log(`control daemon ${VERSION} up \xB7 ${this.cfg.receivers.length} receiver(s) \xB7 socket ${this.sock}`);
+  }
+  async stop() {
+    this.running = false;
+    for (const a of this.aborts) a.abort();
+    if (this.helloTimer) clearInterval(this.helloTimer);
+    if (this.helloSoon) clearTimeout(this.helloSoon);
+    for (const s of this.sdkSessions.values()) s.close();
+    for (const l of this.live.values()) {
+      l.waiter?.destroy();
+      for (const a of l.attentions.values()) a.destroy();
+    }
+    await new Promise((r) => this.server ? this.server.close(() => r()) : r());
+    if (process.platform !== "win32")
+      try {
+        unlinkSync4(this.sock);
+      } catch {
+      }
+  }
+  reload(cfg) {
+    const known = new Set(this.cfg.receivers.map((r) => r.control + r.machine));
+    this.cfg = cfg;
+    for (const r of cfg.receivers) if (!known.has(r.control + r.machine)) void this.pollLoop(r);
+  }
+  status() {
+    return {
+      version: VERSION,
+      name: this.cfg.name,
+      receivers: this.cfg.receivers.map((r) => {
+        const p = this.polling.get(r.control + r.machine);
+        return {
+          url: r.url,
+          machine: r.machine,
+          keys: r.keys.length,
+          polling: !!p?.on,
+          last_poll: p?.last ?? null,
+          last_error: p?.error ?? null
+        };
+      }),
+      waiting: [...this.live].filter(([, l]) => l.waiter).map(([k]) => k),
+      mid_turn: [...this.live].filter(([, l]) => l.midTurn).map(([k]) => k),
+      attentions: [...this.live].flatMap(([k, l]) => [...l.attentions.keys()].map((id) => ({ session: k, id }))),
+      sdk: [...this.sdkSessions.keys()],
+      nonces: this.nonces.size,
+      acks_pending: this.acks.all().length,
+      delivered: { ...this.delivered }
+    };
+  }
+  // --- the local socket -----------------------------------------------------------
+  listen() {
+    if (process.platform !== "win32") {
+      try {
+        if (existsSync9(this.sock)) unlinkSync4(this.sock);
+      } catch {
+      }
+    }
+    this.server = net.createServer((s) => this.onConn(s));
+    return new Promise((resolve, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(this.sock, () => resolve());
+    });
+  }
+  onConn(s) {
+    let buf = "";
+    let handled = false;
+    s.on("error", () => {
+    });
+    s.on("data", (d) => {
+      if (handled) return;
+      buf += d.toString("utf8");
+      if (buf.length > 64 * 1024) return s.destroy();
+      const i = buf.indexOf("\n");
+      if (i < 0) return;
+      handled = true;
+      let req;
+      try {
+        req = JSON.parse(buf.slice(0, i));
+      } catch {
+        return s.destroy();
+      }
+      this.onRequest(req, s);
+    });
+  }
+  reply(s, r) {
+    try {
+      s.end(`${JSON.stringify(r)}
+`);
+    } catch {
+    }
+  }
+  liveOf(session) {
+    let l = this.live.get(session);
+    if (!l) {
+      l = {
+        midTurn: false,
+        continued: false,
+        waiter: null,
+        turnQueue: [],
+        attentions: /* @__PURE__ */ new Map(),
+        lastEvent: this.deps.now()
+      };
+      this.live.set(session, l);
+    }
+    return l;
+  }
+  onRequest(req, s) {
+    switch (req.op) {
+      case "status":
+        this.reply(s, { op: "status", status: this.status() });
+        return;
+      case "wait": {
+        if (!parseSessionRef(req.session)) {
+          this.reply(s, { op: "none" });
+          return;
+        }
+        const l = this.liveOf(req.session);
+        if (l.waiter && l.waiter !== s) this.reply(l.waiter, { op: "replaced" });
+        l.waiter = s;
+        s.on("close", () => {
+          if (l.waiter === s) {
+            l.waiter = null;
+            this.scheduleHello();
+          }
+        });
+        this.scheduleHello();
+        return;
+      }
+      case "stop": {
+        const l = this.liveOf(req.session);
+        l.lastEvent = this.deps.now();
+        const p = this.takeTurn(l);
+        if (!p) {
+          this.reply(s, { op: "none" });
+          return;
+        }
+        l.continued = true;
+        const from = this.answerFrom(req.session);
+        this.reply(s, { op: "block", reason: `${frame(p.text, p.receiver.url)}
+
+${IN_PLACE_ANSWER}`, id: p.msgId });
+        this.followAnswer(p.receiver, p.msgId, "turn", req.session, from, p.queuedAt);
+        return;
+      }
+      case "permission": {
+        const l = this.liveOf(req.session);
+        const prev = l.attentions.get(req.attention);
+        if (prev && prev !== s) this.reply(prev, { op: "none" });
+        l.attentions.set(req.attention, s);
+        s.on("close", () => {
+          if (l.attentions.get(req.attention) === s) l.attentions.delete(req.attention);
+        });
+        return;
+      }
+      case "event":
+        this.onEvent(req);
+        this.reply(s, { op: "ok" });
+        return;
+    }
+  }
+  /** A queued turn message that hasn't expired. */
+  takeTurn(l) {
+    while (l.turnQueue.length) {
+      const p = l.turnQueue.shift();
+      if (!this.inflight.has(p.msgId)) continue;
+      return p;
+    }
+    return null;
+  }
+  onEvent(e) {
+    const l = this.liveOf(e.session);
+    l.lastEvent = this.deps.now();
+    if (e.cwd) l.cwd = e.cwd;
+    if (e.transcript) l.transcript = e.transcript;
+    if (CLOSES_ATTENTION.has(e.event) && l.attentions.size) {
+      for (const s of l.attentions.values()) this.reply(s, { op: "none" });
+      l.attentions.clear();
+    }
+    if (e.event === "UserPromptSubmit" || e.event === "SessionStart") {
+      if (e.event === "UserPromptSubmit") l.midTurn = true;
+      return;
+    }
+    if (e.event === "Stop" && l.continued) {
+      l.continued = false;
+      return;
+    }
+    if (e.event === "Stop" || e.event === "StopFailure" || e.event === "SessionEnd") {
+      l.midTurn = false;
+      l.continued = false;
+      const left = l.turnQueue.splice(0);
+      for (const p of left) if (this.inflight.has(p.msgId)) void this.reroute(p);
+    }
+  }
+  // --- receivers ------------------------------------------------------------------
+  async pollLoop(first) {
+    const key = first.control + first.machine;
+    const st = { last: null, error: null, on: true };
+    this.polling.set(key, st);
+    let backoff = 0;
+    let downSince = 0;
+    const steps = [1e3, 2e3, 5e3, 1e4, 15e3];
+    const pause = (n) => steps[Math.min(n, steps.length - 1)] * (0.75 + Math.random() * 0.5);
+    for (; ; ) {
+      const r = this.cfg.receivers.find((x) => x.control + x.machine === key);
+      if (!this.running || !r) break;
+      const ctl = new AbortController();
+      this.aborts.add(ctl);
+      const t = setTimeout(() => ctl.abort(), 35e3);
+      try {
+        const u = new URL(r.control);
+        u.searchParams.set("machine", r.machine);
+        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) {
+          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;
+        }
+        if (res.status === 200) {
+          const body = await res.json();
+          const cur = this.cfg.receivers.find((x) => x.control + x.machine === key) ?? r;
+          let fresh = 0;
+          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)}`)
+            );
+          }
+          if (!fresh) await sleep(2e3);
+          st.error = null;
+          backoff = 0;
+        } else if (res.status === 204) {
+          st.error = null;
+          backoff = 0;
+        } else {
+          st.error = `HTTP ${res.status}`;
+          downSince ||= this.deps.now();
+          await sleep(pause(backoff++));
+        }
+      } catch (e) {
+        if (!this.running) break;
+        st.error = String(e?.message || e).slice(0, 120);
+        downSince ||= this.deps.now();
+        await sleep(pause(backoff++));
+      } finally {
+        clearTimeout(t);
+        this.aborts.delete(ctl);
+      }
+    }
+    st.on = false;
+  }
+  scheduleHello() {
+    if (this.helloSoon) return;
+    this.helloSoon = setTimeout(() => {
+      this.helloSoon = null;
+      void this.helloAll();
+    }, 1500);
+    this.helloSoon.unref();
+  }
+  async helloAll() {
+    const waiting = [...this.live].filter(([, l]) => l.waiter).map(([k]) => k);
+    const modes = ["waiter", "turn", "resume", "fork", ...this.deps.sdk ? ["sdk"] : []];
+    for (const r of this.cfg.receivers) {
+      const body = {
+        name: this.cfg.name,
+        harnesses: ["claude-code"],
+        modes,
+        keys: r.keys.map((k) => k.id),
+        version: VERSION,
+        waiting,
+        folders: this.cfg.folders,
+        mode: this.cfg.mode
+      };
+      await this.post(r, "/hello", body).catch(() => {
+      });
+    }
+  }
+  async post(r, sub, body) {
+    const ctl = new AbortController();
+    const t = setTimeout(() => ctl.abort(), 15e3);
+    try {
+      return await this.deps.fetch(`${r.control.replace(/\/$/, "")}${sub}`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${r.token}`, "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: ctl.signal
+      });
+    } finally {
+      clearTimeout(t);
+    }
+  }
+  // --- acks -----------------------------------------------------------------------
+  finish(r, id, a, since) {
+    const ack = { receiver: r.control + r.machine, id, at: new Date(this.deps.now()).toISOString(), ...a };
+    if (ack.reply) ack.reply = redactSecrets(ack.reply).slice(0, MAX_REPLY);
+    if (ack.detail) ack.detail = redactSecrets(ack.detail).slice(0, 500);
+    if (a.outcome !== "taken") {
+      this.inflight.delete(id);
+      this.recentAcks.set(id, { ack, at: this.deps.now() });
+      this.delivered[a.mode ?? a.outcome] = (this.delivered[a.mode ?? a.outcome] ?? 0) + 1;
+      this.deps.log(
+        `ack ${id.slice(-8)} ${a.outcome}${a.mode ? ` via ${a.mode}` : ""}${a.code ? ` (${a.code})` : ""}${since ? ` send\u2192${a.outcome} ${this.deps.now() - since} ms` : ""}`
+      );
+    }
+    this.acks.add(ack);
+    void this.flushAcks();
+  }
+  flushing = false;
+  async flushAcks() {
+    if (this.flushing) return;
+    this.flushing = true;
+    try {
+      for (let round = 0; round < 5; round++) {
+        const all = this.acks.all();
+        if (!all.length) return;
+        const left = [];
+        for (const r of this.cfg.receivers) {
+          const mine = all.filter((a) => a.receiver === r.control + r.machine);
+          if (!mine.length) continue;
+          const acks = mine.map(({ receiver: _r, ...a }) => a);
+          const ok = await this.post(r, "/ack", { acks }).then((res) => res.status >= 200 && res.status < 300).catch(() => false);
+          if (!ok) left.push(...mine);
+        }
+        const now = this.acks.all();
+        const added = now.slice(all.length);
+        this.acks.keep([...left, ...added]);
+        if (!left.length && !added.length) return;
+        if (left.length) await sleep(2e3 * (round + 1));
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  // --- one message ----------------------------------------------------------------
+  async handle(r, m) {
+    if (!m || typeof m.id !== "string") return;
+    if (this.inflight.has(m.id)) return;
+    const prior = this.recentAcks.get(m.id);
+    if (prior && this.deps.now() - prior.at < RECENT_ACKS_MS) {
+      this.acks.add(prior.ack);
+      void this.flushAcks();
+      return;
+    }
+    this.inflight.add(m.id);
+    const sent = Date.parse(m.at) || this.deps.now();
+    if (Date.parse(m.expires_at) <= this.deps.now()) return this.finish(r, m.id, { outcome: "expired" });
+    const v = await verifyCommand(
+      { cmd: m.cmd, csig: m.csig ?? null, grant: m.grant ?? null, confirm: m.confirm ?? null },
+      { machine: r.machine, rpId: r.rpId, trusted: r.keys, now: this.deps.now(), seenNonce: this.nonces.seen }
+    );
+    if (!v.ok) {
+      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;
+    const ref = parseSessionRef(cmd2.session);
+    const kp = kindPath(cmd2.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);
+      const place = this.place(cmd2.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 ("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);
+      });
+    } catch (e) {
+      this.finish(r, m.id, { outcome: "failed", detail: String(e?.message || e) });
+    }
+  }
+  /** Where the session lives, and whether its folder is allowed — read from the
+   *  session's own transcript (Claude Code) or the hooks' cwd, never the command. */
+  place(session) {
+    const ref = parseSessionRef(session);
+    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` };
+      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" };
+      return { folder: ok2, transcript: t };
+    }
+    const cwd = this.live.get(session)?.cwd;
+    const ok = cwd && this.allowed(cwd);
+    if (!ok) return { refused: cwd ? "folder" : "no_session", why: "no allowed folder known for that session" };
+    return { folder: ok, transcript: null };
+  }
+  allowed(dir) {
+    if (!path13.isAbsolute(dir)) return null;
+    let r;
+    try {
+      r = realpathSync2.native(dir);
+      if (!statSync7(r).isDirectory()) return null;
+    } catch {
+      return null;
+    }
+    for (const f of this.cfg.folders) {
+      let rf = f;
+      try {
+        rf = realpathSync2.native(f);
+      } catch {
+      }
+      if (r === rf || r.startsWith(rf.endsWith(path13.sep) ? rf : rf + path13.sep)) return r;
+    }
+    return null;
+  }
+  permission(r, id, cmd2, sent) {
+    const l = this.live.get(cmd2.session);
+    const hook = l?.attentions.get(cmd2.for);
+    if (!hook) {
+      if (cmd2.decision === "allow")
+        return this.finish(r, id, {
+          outcome: "refused",
+          code: "no_attention",
+          detail: "no permission prompt open for that id"
+        });
+      this.finish(r, id, { outcome: "expired", detail: "the prompt was already answered or closed" });
+      return;
+    }
+    l.attentions.delete(cmd2.for);
+    this.reply(hook, {
+      op: "decision",
+      behavior: cmd2.decision,
+      ...cmd2.note ? { message: cmd2.note } : {},
+      id
+    });
+    this.finish(r, id, { outcome: "delivered", mode: "turn" }, sent);
+  }
+  async cancel(r, id, cmd2, sent) {
+    const ref = parseSessionRef(cmd2.session);
+    const held = this.sdkSessions.get(ref.id);
+    if (!held)
+      return this.finish(r, id, {
+        outcome: "unsupported",
+        detail: "no cancel path for a session the daemon doesn't hold"
+      });
+    await held.interrupt();
+    this.finish(r, id, { outcome: "delivered", mode: "sdk" }, sent);
+  }
+  view(session, transcript) {
+    const ref = parseSessionRef(session);
+    const l = this.live.get(session);
+    const claude = ref.harness === "claude-code" ? this.deps.claude() : null;
+    const target = this.state.copies[ref.id] ?? ref.id;
+    const t = transcript;
+    const live = !!t && (liveProcess2(target, t.configDir) || recentlyWritten2(t.file, this.lastEnd.get(target), this.deps.now()));
+    return {
+      harness: ref.harness,
+      sdk: this.sdkSessions.has(ref.id),
+      waiter: !!l?.waiter && !l.waiter.destroyed,
+      midTurn: !!l?.midTurn,
+      live,
+      known: !!t,
+      canFork: !!claude?.caps.fork,
+      api: false
+    };
+  }
+  async prompt(r, id, cmd2, place, sent) {
+    const route = routePrompt(this.view(cmd2.session, place.transcript));
+    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;
+    switch (route.mode) {
+      case "waiter": {
+        const l = this.live.get(cmd2.session);
+        const w = l.waiter;
+        l.waiter = null;
+        const from = this.answerFrom(cmd2.session);
+        this.reply(w, { op: "message", text: frame(text, r.url), id });
+        this.scheduleHello();
+        return this.followAnswer(r, id, "waiter", cmd2.session, from, sent);
+      }
+      case "turn": {
+        const l = this.liveOf(cmd2.session);
+        const p = { receiver: r, msgId: id, text, session: cmd2.session, queuedAt: sent };
+        l.turnQueue.push(p);
+        this.finish(r, id, { outcome: "taken" });
+        const t = setTimeout(() => {
+          if (this.inflight.has(id) && l.turnQueue.includes(p)) {
+            l.turnQueue.splice(l.turnQueue.indexOf(p), 1);
+            void this.reroute(p);
+          }
+        }, TURN_FALLBACK_MS);
+        t.unref();
+        return;
+      }
+      case "sdk": {
+        const s = this.sdkSessions.get(ref.id);
+        this.finish(r, id, { outcome: "taken" });
+        const out2 = await s.send(frame(text, r.url));
+        return this.finish(
+          r,
+          id,
+          out2.error ? { outcome: "failed", detail: out2.error } : { outcome: "delivered", mode: "sdk", reply: out2.reply },
+          sent
+        );
+      }
+      case "resume":
+      case "fork":
+        return this.headless(r, id, cmd2, place, route.mode, sent);
+      case "api":
+        return this.finish(r, id, { outcome: "unsupported", detail: "no input API wired for this harness" });
+    }
+  }
+  /** A turn message whose Stop never took it: route again, now that it isn't mid-turn. */
+  async reroute(p) {
+    const l = this.liveOf(p.session);
+    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 };
+    this.inflight.delete(p.msgId);
+    this.inflight.add(p.msgId);
+    await this.prompt(p.receiver, p.msgId, cmd2, place, p.queuedAt).catch(
+      (e) => this.finish(p.receiver, p.msgId, { outcome: "failed", detail: String(e?.message || e) })
+    );
+  }
+  /** Jobs for one session (and its copy) run one at a time, in order. */
+  serial(key, task) {
+    const prev = this.queues.get(key) ?? Promise.resolve();
+    const next = prev.then(task, task);
+    this.queues.set(
+      key,
+      next.catch(() => {
+      })
+    );
+    return next;
+  }
+  async headless(r, id, cmd2, place, mode, sent) {
+    const claude = this.deps.claude();
+    if (!claude)
+      return this.finish(r, id, { outcome: "failed", detail: "Claude Code isn't installed on this machine" });
+    const mf = modeFlags2(this.cfg.mode, claude.caps);
+    if ("error" in mf) return this.finish(r, id, { outcome: "refused", code: "mode", detail: mf.error });
+    const ref = parseSessionRef(cmd2.session);
+    this.finish(r, id, { outcome: "taken" });
+    await this.serial(ref.id, async () => {
+      const target = this.state.copies[ref.id] ?? ref.id;
+      const resume = mode === "fork" ? ["--resume", target, "--fork-session"] : ["--resume", target];
+      const args2 = ["-p", "--output-format", "json", ...mf.args, ...resume, frame(cmd2.text, r.url)];
+      this.deps.log(`${id.slice(-8)}: claude -p ${[...mf.args, ...resume].join(" ")} in ${place.folder}`);
+      const res = await this.slot(
+        () => this.deps.run(claude.bin, args2, {
+          cwd: place.folder,
+          env: claudeEnv2(place.transcript?.configDir, this.deps.env),
+          timeoutMs: JOB_TIMEOUT_MS2
+        })
+      );
+      this.lastEnd.set(target, this.deps.now());
+      const out2 = this.outcome(res);
+      if ("failed" in out2) return this.finish(r, id, { outcome: "failed", detail: out2.failed });
+      const ran = isUuid2(out2.session) ? out2.session : target;
+      if (mode === "fork" && ran !== target) {
+        this.state.copies[ref.id] = ran;
+        writeState(path13.join(this.dir, "state.json"), this.state);
+        this.lastEnd.set(ran, this.deps.now());
+      }
+      this.finish(
+        r,
+        id,
+        { outcome: "delivered", mode, reply: out2.reply, ...ran !== ref.id ? { session: `claude-code:${ran}` } : {} },
+        sent
+      );
+    });
+  }
+  outcome(res) {
+    if (res.error) return { failed: `couldn't start Claude Code: ${res.error}` };
+    if (res.timedOut) return { failed: "Claude Code was still working after 30 minutes, so it was stopped" };
+    if (res.tooBig) return { failed: "Claude Code's answer was too large to read" };
+    const j = parseResult2(res.stdout);
+    if (!j) {
+      const why = String(res.stderr || "").trim().split("\n").slice(-3).join(" ");
+      return {
+        failed: `Claude Code exited (${res.signal || `code ${res.code}`}) without an answer${why ? `: ${why}` : ""}`
+      };
+    }
+    if (j.is_error) return { failed: String(j.result || j.subtype || "Claude Code reported an error") };
+    const denials = Array.isArray(j.permission_denials) ? j.permission_denials : [];
+    const names = [...new Set(denials.map((d) => d?.tool_name).filter((n) => typeof n === "string"))];
+    const tail2 = denials.length ? `
+
+(Not allowed on this machine, since nobody was there to approve: ${names.join(", ") || `${denials.length} action(s)`}.)` : "";
+    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 } : {} };
+  }
+  /** Where the session's transcript ends right now: its answer starts after this. */
+  answerFrom(session) {
+    const ref = parseSessionRef(session);
+    if (!ref || ref.harness !== "claude-code") return null;
+    const t = findTranscript2(this.state.copies[ref.id] ?? ref.id, this.deps.claudeDirs());
+    return t ? { file: t.file, offset: transcriptEnd(t.file) } : null;
+  }
+  /** A message handed to a live session (a waiter, a Stop block) is `taken` now; the
+   *  session answers in its own turn, which the daemon reads from the transcript and
+   *  sends back as the final ack's `reply` — so the person sees the answer where they
+   *  asked. A turn that doesn't end within ANSWER_WAIT_MS is acked delivered without. */
+  followAnswer(r, id, mode, session, from, sent) {
+    this.deps.log(`${id.slice(-8)}: in ${session.slice(0, 24)} via ${mode} ${this.deps.now() - sent} ms after send`);
+    this.finish(r, id, { outcome: "taken" });
+    void (async () => {
+      const answer = from ? await awaitAnswer(from.file, from.offset, {
+        timeoutMs: this.deps.answerWaitMs ?? ANSWER_WAIT_MS,
+        now: this.deps.now
+      }) : null;
+      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) }));
+  }
+  limits() {
+    const l = this.cfg.limits ?? {};
+    const n = (v, d) => typeof v === "number" && Number.isInteger(v) && v >= 0 ? v : d;
+    return {
+      startConcurrent: n(l.start_concurrent, LIMITS.startConcurrent),
+      startPerHour: n(l.start_per_hour, LIMITS.startPerHour),
+      headless: Math.max(1, n(l.headless, LIMITS.headless))
+    };
+  }
+  /** One headless Claude Code process at a time per slot; the rest wait in order. */
+  async slot(fn) {
+    while (this.procs >= this.limits().headless) await new Promise((r) => this.procWaiters.push(r));
+    this.procs++;
+    try {
+      return await fn();
+    } finally {
+      this.procs--;
+      this.procWaiters.shift()?.();
+    }
+  }
+  async startSession(r, id, cmd2, sent) {
+    const lim = this.limits();
+    const now = this.deps.now();
+    this.startTimes = this.startTimes.filter((t) => now - t < 36e5);
+    if (this.startsRunning >= lim.startConcurrent || this.startTimes.length >= lim.startPerHour) {
+      const detail = this.startsRunning >= lim.startConcurrent ? `this machine is already starting ${this.startsRunning} new session(s); it starts at most ${lim.startConcurrent} at once` : `this machine started ${this.startTimes.length} new sessions in the last hour, its limit`;
+      this.deps.log(`refused ${id.slice(-8)}: start_limit \u2014 ${detail}`);
+      return this.finish(r, id, { outcome: "refused", code: "start_limit", detail });
+    }
+    this.startsRunning++;
+    this.startTimes.push(now);
+    try {
+      await this.startOne(r, id, cmd2, sent);
+    } finally {
+      this.startsRunning--;
+    }
+  }
+  async startOne(r, id, cmd2, sent) {
+    const ref = parseSessionRef(cmd2.session);
+    const cwd = this.allowed(cmd2.cwd);
+    if (!cwd)
+      return this.finish(r, id, {
+        outcome: "refused",
+        code: "folder",
+        detail: "that folder isn't one this machine allows"
+      });
+    if (findTranscript2(ref.id, this.deps.claudeDirs()) || this.sdkSessions.has(ref.id))
+      return this.finish(r, id, {
+        outcome: "refused",
+        code: "bad_session",
+        detail: "that new session's id is already taken"
+      });
+    this.finish(r, id, { outcome: "taken" });
+    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 });
+        this.sdkSessions.set(ref.id, s);
+        return s.send(frame(cmd2.text, r.url));
+      });
+      return this.finish(
+        r,
+        id,
+        out3.error ? { outcome: "failed", detail: out3.error } : { outcome: "delivered", mode: "sdk", reply: out3.reply },
+        sent
+      );
+    }
+    const claude = this.deps.claude();
+    if (!claude)
+      return this.finish(r, id, { outcome: "failed", detail: "Claude Code isn't installed on this machine" });
+    const mf = modeFlags2(this.cfg.mode, claude.caps);
+    if ("error" in mf) return this.finish(r, id, { outcome: "refused", code: "mode", detail: mf.error });
+    const res = await this.slot(
+      () => this.deps.run(
+        claude.bin,
+        ["-p", "--output-format", "json", ...mf.args, "--session-id", ref.id, frame(cmd2.text, r.url)],
+        { cwd, env: claudeEnv2(void 0, this.deps.env), timeoutMs: JOB_TIMEOUT_MS2 }
+      )
+    );
+    this.lastEnd.set(ref.id, this.deps.now());
+    const out2 = this.outcome(res);
+    if ("failed" in out2) return this.finish(r, id, { outcome: "failed", detail: out2.failed });
+    this.finish(r, id, { outcome: "delivered", mode: "resume", reply: out2.reply }, sent);
+  }
+  closeIdleSdk() {
+    const idle = this.deps.sdkIdleMs ?? 10 * 6e4;
+    for (const [id, s] of this.sdkSessions)
+      if (!s.busy && this.deps.now() - s.lastUsed > idle) {
+        s.close();
+        this.sdkSessions.delete(id);
+        this.deps.log(
+          `sdk session ${id.slice(0, 8)} closed after ${Math.round(idle / 6e4)} min idle (it resumes on the next message)`
+        );
+      }
+  }
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms).unref?.());
+
+// src/control/local.ts
+import net2 from "node:net";
+import os3 from "node:os";
+import path14 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-${os3.userInfo().username}`;
+  return path14.join(state2, "control.sock");
+}
+function ask(sock, req, timeoutMs) {
+  return new Promise((resolve) => {
+    let buf = "";
+    let done = false;
+    const s = net2.connect(sock);
+    const finish = (r) => {
+      if (done) return;
+      done = true;
+      clearTimeout(t);
+      s.destroy();
+      resolve(r);
+    };
+    const t = setTimeout(() => finish(null), timeoutMs);
+    s.on("connect", () => s.write(`${JSON.stringify(req)}
+`));
+    s.on("data", (d) => {
+      buf += d.toString("utf8");
+      const i = buf.indexOf("\n");
+      if (i < 0) return;
+      try {
+        finish(JSON.parse(buf.slice(0, i)));
+      } catch {
+        finish(null);
+      }
+    });
+    s.on("error", () => finish(null));
+    s.on("close", () => finish(null));
+  });
+}
+
+// src/control/pair.ts
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { existsSync as existsSync10, mkdirSync as mkdirSync9, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import os4 from "node:os";
+import path15 from "node:path";
+var VERSION2 = true ? "0.2.0" : "0.0.0";
+async function json(r) {
+  try {
+    return await r.json();
+  } catch {
+    return {};
+  }
+}
+async function discover(url, f) {
+  const base = url.replace(/\/$/, "");
+  const r = await f(`${base}/.well-known/sessionpipe`);
+  if (!r.ok) throw new Error(`${base} has no sessionpipe well-known file (HTTP ${r.status})`);
+  const wk = await r.json();
+  if (!wk.capabilities?.includes("control") || !wk.endpoints?.control || !wk.control?.signing?.rp_id)
+    throw new Error(`${base} doesn't serve control yet (its well-known file lists no control.signing)`);
+  const ep = wk.endpoints.control;
+  return { control: /^https?:\/\//.test(ep) ? ep : base + ep, rpId: wk.control.signing.rp_id };
+}
+async function pair(o) {
+  const f = o.fetch ?? fetch;
+  const sleep2 = o.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const { control, rpId } = await discover(o.url, f);
+  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) => path15.resolve(d))])];
+  const existing = cfg.receivers.find((r) => r.control === control);
+  const auth = { authorization: `Bearer ${o.token}`, "content-type": "application/json" };
+  const started = await f(`${control}/pair`, {
+    method: "POST",
+    headers: auth,
+    body: JSON.stringify({
+      ...existing ? { machine: existing.machine } : {},
+      name: cfg.name,
+      harnesses: ["claude-code"],
+      modes: ["waiter", "turn", "resume", "fork"],
+      version: VERSION2,
+      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("");
+  o.out(`  Open this link and confirm with your passkey (Touch ID, Face ID, a security key):`);
+  o.out(`    ${String(s.url)}`);
+  o.out(`  The page shows these digits too: ${String(s.check)}`);
+  o.out("");
+  const until = Date.parse(String(s.expires_at)) || Date.now() + 10 * 6e4;
+  for (; ; ) {
+    if (Date.now() > until) throw new Error("the pairing link expired; run `sessionpipe control pair` again");
+    await sleep2(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;
+    const key = p.key;
+    const proof = p.proof;
+    const v = await verifyEnrollment({ machine, code, key, proof, rpId });
+    if (!v.ok) throw new Error(`the receiver's key didn't prove itself (${v.why}); nothing was trusted`);
+    const token = existing?.token ?? (typeof p.token === "string" ? p.token : "");
+    if (!token) throw new Error("the receiver didn't hand this machine its token");
+    const rec = existing ?? {
+      url: o.url.replace(/\/$/, ""),
+      control,
+      rpId,
+      machine,
+      token,
+      keys: [],
+      paired_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (!rec.keys.some((k) => k.id === key.id)) rec.keys.push({ ...key, added_at: (/* @__PURE__ */ new Date()).toISOString() });
+    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`);
+    return cfg;
+  }
+}
+async function off(o) {
+  const f = o.fetch ?? fetch;
+  const cfg = readControl(o.env);
+  if (!cfg) return o.out("  control isn't set up on this machine");
+  const gone = cfg.receivers.filter((r) => !o.url || r.url === o.url.replace(/\/$/, ""));
+  for (const r of gone) {
+    await f(`${r.control}/off`, { method: "POST", headers: { authorization: `Bearer ${r.token}` } }).catch(() => null);
+    o.out(`  removed ${r.url} (${r.machine}, ${r.keys.length} key(s))`);
+  }
+  cfg.receivers = cfg.receivers.filter((r) => !gone.includes(r));
+  writeControl(cfg, o.env);
+  return cfg;
+}
+function removeKey(id, env) {
+  const cfg = readControl(env);
+  if (!cfg) return 0;
+  let n = 0;
+  for (const r of cfg.receivers) {
+    const before = r.keys.length;
+    r.keys = r.keys.filter((k) => k.id !== id && !k.id.startsWith(id));
+    n += before - r.keys.length;
+  }
+  writeControl(cfg, env);
+  return n;
+}
+var LABEL = "org.sessionpipe.control";
+var UNIT = "sessionpipe-control.service";
+function serviceFiles(o) {
+  const home = o.home ?? os4.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">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array><string>${xml(o.node)}</string><string>${xml(o.cli)}</string><string>control</string><string>run</string></array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>${xml(path15.join(o.logDir, "daemon.log"))}</string>
+  <key>StandardErrorPath</key><string>${xml(path15.join(o.logDir, "daemon.log"))}</string>
+</dict>
+</plist>
+`;
+  const q = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%")}"`;
+  const unit = `[Unit]
+Description=sessionpipe control daemon (signed messages to your coding sessions)
+After=network-online.target
+
+[Service]
+ExecStart=${q(o.node)} ${q(o.cli)} control run
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+  return {
+    plist: { file: path15.join(home, "Library", "LaunchAgents", `${LABEL}.plist`), body: plist },
+    unit: { file: path15.join(home, ".config", "systemd", "user", UNIT), body: unit }
+  };
+}
+function installService(o) {
+  const logDir = controlState(o.env);
+  mkdirSync9(logDir, { recursive: true, mode: 448 });
+  const f = serviceFiles({ node: o.node, cli: o.cli, logDir });
+  const run = (cmd2, args2) => execFileSync5(cmd2, args2, { stdio: "ignore", timeout: 15e3 });
+  if (process.platform === "darwin") {
+    mkdirSync9(path15.dirname(f.plist.file), { recursive: true });
+    writeFileSync7(f.plist.file, f.plist.body);
+    const uid = String(process.getuid?.() ?? "");
+    try {
+      run("launchctl", ["bootout", `gui/${uid}/${LABEL}`]);
+    } catch {
+    }
+    run("launchctl", ["bootstrap", `gui/${uid}`, f.plist.file]);
+    return `launchd agent ${LABEL} (log: ${path15.join(logDir, "daemon.log")})`;
+  }
+  if (process.platform === "linux") {
+    mkdirSync9(path15.dirname(f.unit.file), { recursive: true });
+    writeFileSync7(f.unit.file, f.unit.body);
+    try {
+      run("systemctl", ["--user", "daemon-reload"]);
+      run("systemctl", ["--user", "enable", "--now", UNIT]);
+      return `systemd user unit ${UNIT} (journalctl --user -u ${UNIT})`;
+    } catch {
+      return `wrote ${f.unit.file}, but systemd --user isn't reachable here; run \`sessionpipe control run\` yourself (tmux, screen)`;
+    }
+  }
+  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) => {
+    try {
+      execFileSync5(cmd2, args2, { stdio: "ignore", timeout: 15e3 });
+    } catch {
+    }
+  };
+  if (process.platform === "darwin" && existsSync10(f.plist.file)) {
+    run("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/${LABEL}`]);
+    unlinkSync5(f.plist.file);
+  }
+  if (process.platform === "linux" && existsSync10(f.unit.file)) {
+    run("systemctl", ["--user", "disable", "--now", UNIT]);
+    unlinkSync5(f.unit.file);
+    run("systemctl", ["--user", "daemon-reload"]);
+  }
+}
+
+// src/control/sdk.ts
+async function loadSdk(o) {
+  const spec = o.env?.SESSIONPIPE_AGENT_SDK || "@anthropic-ai/claude-agent-sdk";
+  let query;
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      spec
+    );
+    if (typeof mod.query !== "function") return null;
+    query = mod.query;
+  } catch {
+    return null;
+  }
+  o.log(`Agent SDK found (${spec}): new sessions start in place`);
+  return {
+    start({
+      session,
+      cwd,
+      mode
+    }) {
+      const queue = [];
+      let wake = null;
+      let closed = false;
+      async function* input() {
+        while (!closed) {
+          while (queue.length) yield queue.shift();
+          await new Promise((r) => {
+            wake = r;
+          });
+        }
+      }
+      const q = query({
+        prompt: input(),
+        options: {
+          sessionId: session,
+          cwd,
+          permissionMode: mode === "auto" ? "auto" : "dontAsk",
+          ...o.claudeBin ? { pathToClaudeCodeExecutable: o.claudeBin } : {},
+          env: { ...o.env ?? process.env, SESSIONPIPE_CONTROL_JOB: "1" }
+        }
+      });
+      const waiting = [];
+      let busy = false;
+      let lastUsed = Date.now();
+      void (async () => {
+        try {
+          for await (const m of q) {
+            if (m.type !== "result") continue;
+            busy = waiting.length > 1;
+            lastUsed = Date.now();
+            const w = waiting.shift();
+            const text = typeof m.result === "string" && m.result.trim() ? m.result : "(finished without a written reply)";
+            w?.resolve(m.is_error ? { reply: "", error: text } : { reply: text });
+          }
+        } catch (e) {
+          for (const w of waiting.splice(0)) w.resolve({ reply: "", error: String(e?.message || e) });
+        }
+      })();
+      return {
+        send(text) {
+          busy = true;
+          lastUsed = Date.now();
+          return new Promise((resolve) => {
+            waiting.push({ resolve });
+            queue.push({ type: "user", message: { role: "user", content: text }, parent_tool_use_id: null });
+            wake?.();
+          });
+        },
+        interrupt: () => q.interrupt(),
+        close() {
+          closed = true;
+          wake?.();
+          try {
+            q.close();
+          } catch {
+          }
+        },
+        get busy() {
+          return busy;
+        },
+        get lastUsed() {
+          return lastUsed;
+        }
+      };
+    }
+  };
+}
+
+// src/control/wait.ts
+var RE_ARM = "(Answer it right here, as you would answer the person at the keyboard: your reply is sent back to them automatically, so don't run a command or call a tool just to send it. Then, without mentioning it, start `sessionpipe wait` again as a background command, with the longest timeout your harness allows, to keep receiving messages.)";
+function waitSession(flag2, env = process.env) {
+  if (flag2) return parseSessionRef(flag2) ? flag2 : null;
+  if (env.CLAUDE_CODE_SESSION_ID) return `claude-code:${env.CLAUDE_CODE_SESSION_ID}`;
+  if (env.CODEX_SESSION_ID) return `codex:${env.CODEX_SESSION_ID}`;
+  return null;
+}
+async function waitForMessage(session, o = {}) {
+  const sock = socketPath(stateDir(o.env), o.env);
+  for (; ; ) {
+    const r = await ask(sock, { op: "wait", session, pid: process.pid }, 2 ** 31 - 1);
+    if (r?.op === "message") return `${r.text}
+
+${RE_ARM}`;
+    if (r?.op === "replaced")
+      return "(Another `sessionpipe wait` for this session took over; this one stopped. Nothing to do.)";
+    await new Promise((res) => setTimeout(res, o.retryMs ?? 1e3));
+  }
+}
+
+// src/control/cli.ts
+var { detectCaps: detectCaps2, findClaude: findClaude2, runClaude: runClaude2 } = claude_code_control_exports;
+var CONTROL_HELP = `  sessionpipe control pair <receiver> [--folder DIR]\u2026 [--mode safe|auto] [--token T] [--name N] [--no-service]
+  sessionpipe control status | keys [remove <id>] | off [<receiver>] | run
+  sessionpipe wait [--session <harness>:<id>]      (a session runs this in the background)`;
+async function controlMain(argv, out2, distDir2) {
+  const flag2 = (n) => {
+    const i = argv.indexOf(n);
+    return i >= 0 ? argv[i + 1] : void 0;
+  };
+  const flags = (n) => argv.flatMap((a, i) => a === n && argv[i + 1] ? [argv[i + 1]] : []);
+  const sub = argv[1];
+  switch (sub) {
+    case "pair": {
+      const url = argv[2];
+      if (!url || !/^https?:\/\//.test(url)) return out2(`usage:
+${CONTROL_HELP}`);
+      const cfg = readConfig();
+      const sink2 = cfg.sinks.find((s) => s.url.replace(/\/$/, "") === url.replace(/\/$/, ""));
+      const token = flag2("--token") ?? sink2?.token;
+      if (!token)
+        return out2(
+          `  No token for ${url}: add it as a sink first (\`sessionpipe sink add ${url} --token \u2026\`) or pass --token.`
+        );
+      const folders = flags("--folder");
+      const existing = readControl();
+      if (!folders.length && !existing?.folders.length) folders.push(process.cwd());
+      await pair({
+        url,
+        token,
+        folders,
+        mode: flag2("--mode") === "auto" ? "auto" : existing?.mode ?? "safe",
+        name: flag2("--name") ?? existing?.name ?? cfg.machine ?? os5.hostname(),
+        out: out2
+      });
+      const c = readControl();
+      out2(`  Folders sessions may run in: ${c.folders.join(", ")}`);
+      out2(
+        `  Mode: ${c.mode} (${c.mode === "safe" ? "nothing that needs approval runs unattended" : "Claude Code's auto mode"})`
+      );
+      let cli = path16.join(distDir2, "cli.js");
+      try {
+        cli = realpathSync3(cli);
+      } catch {
+      }
+      if (argv.includes("--no-service"))
+        out2("  Daemon: not installed as a service (--no-service); run `sessionpipe control run` yourself");
+      else out2(`  Daemon: ${installService({ node: process.execPath, cli })}`);
+      return;
+    }
+    case "keys": {
+      const c = readControl();
+      if (argv[2] === "remove" && argv[3]) {
+        const n = removeKey(argv[3]);
+        return out2(n ? `  removed ${n} key(s)` : "  no such key");
+      }
+      if (!c?.receivers.length)
+        return out2("  control isn't paired on this machine (`sessionpipe control pair <receiver>`)");
+      for (const r of c.receivers) {
+        out2(`  ${r.url} \xB7 machine ${r.machine}`);
+        for (const k of r.keys)
+          out2(`    ${k.id.slice(0, 16)}\u2026  ${k.alg === -7 ? "ES256" : "RS256"}  added ${k.added_at.slice(0, 10)}`);
+      }
+      return;
+    }
+    case "off": {
+      const c = await off({ out: out2, ...argv[2] ? { url: argv[2] } : {} });
+      if (c && !c.receivers.length) uninstallService();
+      return;
+    }
+    case "status": {
+      const r = await ask(socketPath(stateDir()), { op: "status" }, 2e3);
+      if (r?.op !== "status") return out2("  the control daemon isn't running");
+      return out2(JSON.stringify(r.status, null, 2));
+    }
+    case "run":
+      return runDaemon(out2);
+    default:
+      return out2(CONTROL_HELP);
+  }
+}
+async function runDaemon(out2) {
+  const cfg = readControl();
+  if (!cfg?.receivers.length) {
+    out2("control isn't paired on this machine; nothing to do (`sessionpipe control pair <receiver>`)");
+    return;
+  }
+  const log2 = (s) => out2(`${(/* @__PURE__ */ new Date()).toISOString()} ${s}`);
+  let claude = null;
+  const claudeNow = () => {
+    const bin = findClaude2();
+    if (!bin) return null;
+    const sig = `${bin}:${existsSync11(bin) ? realpathSync3(bin) : ""}`;
+    if (claude?.sig !== sig) claude = { bin, caps: detectCaps2(bin), sig };
+    return claude;
+  };
+  const sdk = await loadSdk({ claudeBin: findClaude2(), env: process.env, log: log2 });
+  const d = new ControlDaemon(cfg, controlState(), socketPath(stateDir()), {
+    now: Date.now,
+    fetch,
+    log: log2,
+    claudeDirs: () => claudeDirs(),
+    claude: claudeNow,
+    run: runClaude2,
+    sdk
+  });
+  await d.start();
+  watchFile(controlFile(), { interval: 5e3 }, () => {
+    const next = readControl();
+    if (next) d.reload(next);
+  });
+  const bye = async () => {
+    await d.stop();
+    process.exit(0);
+  };
+  process.on("SIGTERM", bye);
+  process.on("SIGINT", bye);
+}
+async function waitMain(argv, out2) {
+  const i = argv.indexOf("--session");
+  const session = waitSession(i >= 0 ? argv[i + 1] : void 0);
+  if (!session) {
+    out2("sessionpipe wait: which session? Pass --session <harness>:<id> (Claude Code sets CLAUDE_CODE_SESSION_ID).");
+    process.exitCode = 2;
+    return;
+  }
+  out2(await waitForMessage(session));
+}
+
+// src/run.ts
+import {
+  appendFileSync as appendFileSync4,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync10,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync10,
+  renameSync as renameSync3,
+  statSync as statSync8,
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync8
+} from "node:fs";
+import os6 from "node:os";
+import path17 from "node:path";
+
+// src/http-sink.ts
+import { createHash as createHash3, 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)}`;
+}
+var HttpSink = class {
+  constructor(cfg, tier) {
+    this.cfg = cfg;
+    this.tier = tier;
+    this.name = cfg.name;
+    this.pii = !!cfg.pii;
+    this.url = cfg.url.replace(/\/$/, "");
+  }
+  cfg;
+  tier;
+  name;
+  pii;
+  url;
+  eventsUrl() {
+    const ep = this.cfg.endpoints?.events ?? "/api/sessionpipe/v1/events";
+    return /^https?:\/\//.test(ep) ? ep : this.url + ep;
+  }
+  async send(events) {
+    const body = JSON.stringify({ events });
+    const headers = { "content-type": "application/json", "sessionpipe-protocol": "1" };
+    if (this.cfg.token) headers.authorization = `Bearer ${this.cfg.token}`;
+    if (this.cfg.secret?.startsWith("whsec_")) {
+      const id = webhookId(events);
+      const ts = Math.floor(Date.now() / 1e3);
+      const key = Buffer.from(this.cfg.secret.slice(6), "base64");
+      const sig = createHmac("sha256", key).update(`${id}.${ts}.${body}`).digest("base64");
+      headers["webhook-id"] = id;
+      headers["webhook-timestamp"] = String(ts);
+      headers["webhook-signature"] = `v1,${sig}`;
+    }
+    const ctl = new AbortController();
+    const t = setTimeout(() => ctl.abort(), TIMEOUT_MS);
+    try {
+      const r = await fetch(this.eventsUrl(), { method: "POST", headers, body, signal: ctl.signal });
+      const text = await r.text();
+      let j = {};
+      try {
+        j = text ? JSON.parse(text) : {};
+      } catch {
+      }
+      if (r.status === 202 || r.status === 200) {
+        return {
+          ok: true,
+          acknowledged: events.length,
+          accepted: Number(j.accepted ?? events.length),
+          duplicates: Number(j.duplicates ?? 0),
+          rejected: Array.isArray(j.rejected) ? j.rejected : [],
+          ...typeof j.max_tier === "number" ? { max_tier: j.max_tier } : {},
+          status: r.status
+        };
+      }
+      const err = typeof j.reason === "string" ? j.reason : text.slice(0, 200);
+      if (r.status === 400) return { ok: false, acknowledged: 0, status: 400, error: err, action: "drop" };
+      if (r.status === 401) return { ok: false, acknowledged: 0, status: 401, error: err, action: "pause" };
+      if (r.status === 403)
+        return {
+          ok: false,
+          acknowledged: 0,
+          status: 403,
+          error: err,
+          action: "lower-tier",
+          ...typeof j.max_tier === "number" ? { max_tier: j.max_tier } : {}
+        };
+      if (r.status === 413) return { ok: false, acknowledged: 0, status: 413, error: err, action: "split" };
+      if (r.status === 429)
+        return {
+          ok: false,
+          acknowledged: 0,
+          status: 429,
+          error: err,
+          action: "retry",
+          retryAfterMs: Number(r.headers.get("retry-after") ?? 60) * 1e3
+        };
+      return { ok: false, acknowledged: 0, status: r.status, error: err, action: "retry" };
+    } catch (e) {
+      return { ok: false, acknowledged: 0, error: String(e.message ?? e), action: "retry" };
+    } finally {
+      clearTimeout(t);
+    }
+  }
+};
+
+// src/run.ts
+async function tellDaemon(state2, job, session, transcript) {
+  const sock = socketPath(state2);
+  if (process.platform !== "win32" && !existsSync12(sock)) return;
+  await ask(
+    sock,
+    {
+      op: "event",
+      session: `claude-code:${session}`,
+      event: job.event,
+      cwd: job.cwd,
+      ...transcript ? { transcript } : {}
+    },
+    300
+  );
+}
+var VERSION3 = true ? "0.2.0" : "0.0.0";
+function enqueueJob(state2, job) {
+  const jobs = jobsDir(state2);
+  mkdirSync10(jobs, { recursive: true, mode: 448 });
+  const f = path17.join(jobs, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
+  writeFileSync8(f, JSON.stringify(job), { mode: 384 });
+  return f;
+}
+function log(state2, line) {
+  try {
+    mkdirSync10(state2, { recursive: true, mode: 448 });
+    const f = path17.join(state2, "log");
+    try {
+      if (statSync8(f).size > 1024 * 1024) renameSync3(f, `${f}.1`);
+    } catch {
+    }
+    appendFileSync4(f, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+  } catch {
+  }
+}
+function factsState(state2) {
+  const file = (h, s) => path17.join(state2, "facts", safeId(h), `${safeId(s)}.json`);
   return {
     get(h, s) {
       try {
-        return JSON.parse(readFileSync8(file(h, s), "utf8"));
+        return JSON.parse(readFileSync10(file(h, s), "utf8"));
       } catch {
         return {};
       }
@@ -2610,8 +4814,8 @@ function factsState(state2) {
       const cur = this.get(h, s);
       const next = { ...cur, ...patch };
       if (JSON.stringify(next) === JSON.stringify(cur)) return;
-      mkdirSync7(path11.dirname(file(h, s)), { recursive: true, mode: 448 });
-      writeFileSync6(file(h, s), JSON.stringify(next), { mode: 384 });
+      mkdirSync10(path17.dirname(file(h, s)), { recursive: true, mode: 448 });
+      writeFileSync8(file(h, s), JSON.stringify(next), { mode: 384 });
     }
   };
 }
@@ -2622,7 +4826,7 @@ function buildSinks(sinks) {
     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(/^~(?=\/|$)/, os2.homedir()), tier, !!s.pii));
+      out2.push(new FileSink(s.name, s.url.slice(5).replace(/^~(?=\/|$)/, os6.homedir()), tier, !!s.pii));
     else if (/^https?:\/\//.test(s.url)) out2.push(new HttpSink(s, tier));
   }
   return out2;
@@ -2634,6 +4838,7 @@ async function runJob(job, opts = {}) {
   if (!adapter) 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: {} };
+  if (job.harness === "claude-code") await tellDaemon(state2, job, r.session.id, r.transcript);
   const outbox = new Outbox(state2);
   const ref = { harness: job.harness, session: r.session.id };
   let release = takeLock(state2, ref);
@@ -2668,7 +4873,7 @@ async function runJob(job, opts = {}) {
       ...learned.branch ? { branch: learned.branch } : {},
       id: r.session.id,
       seq: 0,
-      machine: machineName(cfg, os2.hostname()),
+      machine: machineName(cfg, os6.hostname()),
       ...cwdRaw ? { cwd: tilde(cwdRaw) } : {},
       ...r.session.model ? { model: r.session.model } : {}
     };
@@ -2771,7 +4976,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: os2.homedir() });
+          const f = filterEvent(e, sink2.tier, sink2.pii, { home: os6.homedir() });
           if (f) batch.push(f);
         }
         offset = next;
@@ -2803,7 +5008,7 @@ function applySinkVerdict(name, res) {
   } catch {
   }
 }
-var jobsDir = (state2) => path11.join(state2, "jobs");
+var jobsDir = (state2) => path17.join(state2, "jobs");
 
 // src/cli.ts
 process.stdout.on("error", (e) => {
@@ -2821,12 +5026,12 @@ var out = (s = "") => {
 `);
 };
 var state = stateDir();
-var distDir = path12.dirname(fileURLToPath(import.meta.url));
+var distDir = path18.dirname(fileURLToPath(import.meta.url));
 function hookCommand() {
   const node = stableNode(process.execPath);
-  let script = path12.join(distDir, "hook.js");
+  let script = path18.join(distDir, "hook.js");
   try {
-    script = realpathSync2(script);
+    script = realpathSync4(script);
   } catch {
   }
   return (a) => ({
@@ -2839,13 +5044,13 @@ function stableNode(exe) {
   if (!m) return exe;
   let real;
   try {
-    real = realpathSync2(exe);
+    real = realpathSync4(exe);
   } catch {
     return exe;
   }
   for (const c of [`${m[1]}/opt/${m[2]}/bin/node`, `${m[1]}/bin/node`]) {
     try {
-      if (realpathSync2(c) === real) return c;
+      if (realpathSync4(c) === real) return c;
     } catch {
     }
   }
@@ -2881,53 +5086,58 @@ async function main() {
       return update();
     case "worker":
       return workerFromArgv();
+    case "control":
+      return controlMain(args, out, distDir);
+    case "wait":
+      return waitMain(args, out);
     case "hook":
       out("sessionpipe hook is dist/hook.js; harnesses run it directly");
       return;
     case "--version":
     case "-v":
     case "version":
-      out(VERSION);
+      out(VERSION3);
       return;
     default:
       return help();
   }
 }
 function help() {
-  out(`sessionpipe ${VERSION} \u2014 an open protocol for what your coding agents are doing
+  out(`sessionpipe ${VERSION3} \u2014 an open protocol for what your coding agents are doing
 
   sessionpipe install [--claude-code --codex --gemini-cli --antigravity] [--machine NAME] [--backfill DAYS] [--sink URL --tier N]
   sessionpipe uninstall [--keep-state]
-  sessionpipe sink add <url|file:PATH|stdout> [--tier 0-3] [--token T] [--pii] [--control] [--name N]
+  sessionpipe sink add <url|file:PATH|stdout> [--tier 0-3] [--token T] [--pii] [--name N]
   sessionpipe sink list | remove <name> | test <name>
   sessionpipe status | doctor [--json]
   sessionpipe tail [--session ID] [--tier N] [--harness NAME]
   sessionpipe backfill [--days 30] | forget <harness> <session> | replay --sink NAME
   sessionpipe update
+${CONTROL_HELP}
 
 Docs: https://sessionpipe.org \xB7 nothing leaves this machine until you add a sink.`);
 }
 async function install() {
   if (viaNpx) {
-    out(`  Installing sessionpipe@${VERSION} globally, so the hooks start in milliseconds\u2026`);
+    out(`  Installing sessionpipe@${VERSION3} globally, so the hooks start in milliseconds\u2026`);
     try {
       let prefix = "";
       try {
-        prefix = execFileSync4("npm", ["prefix", "-g"], {
+        prefix = execFileSync6("npm", ["prefix", "-g"], {
           encoding: "utf8",
           timeout: 15e3,
           stdio: ["ignore", "pipe", "ignore"]
         }).trim();
       } catch {
       }
-      const target = /\/Cellar\/node(?:@\d+)?\/[^/]+/.test(prefix) ? path12.join(os3.homedir(), ".local") : prefix;
-      execFileSync4("npm", ["install", "-g", `sessionpipe@${VERSION}`, ...target ? ["--prefix", target] : []], {
+      const target = /\/Cellar\/node(?:@\d+)?\/[^/]+/.test(prefix) ? path18.join(os7.homedir(), ".local") : prefix;
+      execFileSync6("npm", ["install", "-g", `sessionpipe@${VERSION3}`, ...target ? ["--prefix", target] : []], {
         stdio: ["ignore", "ignore", "inherit"]
       });
-      const bin = process.platform === "win32" ? path12.join(target, "sessionpipe.cmd") : target ? path12.join(target, "bin", "sessionpipe") : "sessionpipe";
+      const bin = process.platform === "win32" ? path18.join(target, "sessionpipe.cmd") : target ? path18.join(target, "bin", "sessionpipe") : "sessionpipe";
       if (target && target !== prefix)
-        out(`  Installed into ${target}; make sure ${path12.join(target, "bin")} is on your PATH.`);
-      execFileSync4(bin, args, { stdio: "inherit", shell: process.platform === "win32" });
+        out(`  Installed into ${target}; make sure ${path18.join(target, "bin")} is on your PATH.`);
+      execFileSync6(bin, args, { stdio: "inherit", shell: process.platform === "win32" });
       return;
     } catch {
       out(
@@ -2948,7 +5158,7 @@ async function install() {
     );
     return;
   }
-  out(`  Machine: ${machineName(cfg, os3.hostname())}`);
+  out(`  Machine: ${machineName(cfg, os7.hostname())}`);
   const lean = isLean(cfg);
   if (lean)
     out(
@@ -3032,7 +5242,7 @@ async function sink() {
     if (!s) return out(`  no sink named ${args[2]}`);
     const [sk] = buildSinks([s]);
     if (!sk) return out("  sink type not supported yet");
-    const session = { id: `test-${Date.now()}`, machine: machineName(cfg, os3.hostname()) };
+    const session = { id: `test-${Date.now()}`, machine: machineName(cfg, os7.hostname()) };
     const mk = (type, seq) => makeEvent(
       { type, harnessEvent: "test", data: {} },
       { harness: { name: "sessionpipe" }, session: { ...session, seq } }
@@ -3047,13 +5257,15 @@ async function sink() {
     return;
   }
   out(
-    "usage: sessionpipe sink add <url|file:PATH|stdout> [--tier N] [--token T] [--pii] [--control] [--name N] | list | remove <name> | test <name>"
+    "usage: sessionpipe sink add <url|file:PATH|stdout> [--tier N] [--token T] [--pii] [--name N] | list | remove <name> | test <name>"
   );
 }
 async function sinkAdd(url, cfg) {
   const tier = Math.max(0, Math.min(3, Number(flag("--tier") ?? 0)));
   const name = flag("--name") ?? (url === "stdout" ? "stdout" : url.startsWith("file:") ? "file" : new URL(url).host);
-  const s = { name, url, tier, pii: has("--pii"), control: has("--control") };
+  if (has("--control"))
+    out("  --control is ignored: control is set up per machine (`sessionpipe control pair <url>`, spec/CONTROL.md)");
+  const s = { name, url, tier, pii: has("--pii") };
   const token = flag("--token");
   if (token) s.token = token;
   const secret = flag("--secret");
@@ -3070,10 +5282,6 @@ async function sinkAdd(url, cfg) {
       }
       if (wk.endpoints) s.endpoints = wk.endpoints;
       s.well_known_at = (/* @__PURE__ */ new Date()).toISOString();
-      if (s.control && !(wk.capabilities ?? []).includes("control")) {
-        out("  receiver does not list `control`; --control ignored");
-        s.control = false;
-      }
     } catch (e) {
       out(
         `  ! ${url} has no readable /.well-known/sessionpipe (${e.message}); added anyway, at tier ${tier}`
@@ -3082,9 +5290,7 @@ async function sinkAdd(url, cfg) {
   }
   cfg.sinks = cfg.sinks.filter((x) => x.name !== name).concat([s]);
   writeConfig(cfg);
-  out(
-    `  \u2713 sink ${name}: ${url} at tier ${Math.min(tier, s.max_tier ?? 3)}${s.pii ? ", pii" : ""}${s.control ? ", control" : ""}`
-  );
+  out(`  \u2713 sink ${name}: ${url} at tier ${Math.min(tier, s.max_tier ?? 3)}${s.pii ? ", pii" : ""}`);
   out(`    tier ${tier} sends: ${TIER_TEXT[Math.min(tier, s.max_tier ?? 3)]}`);
 }
 var TIER_TEXT = {
@@ -3097,7 +5303,7 @@ function backfillRows(adapters, days, cfg) {
   const since = Date.now() - days * 864e5;
   const outbox = new Outbox(state);
   let n = 0;
-  const machine = machineName(cfg, os3.hostname());
+  const machine = machineName(cfg, os7.hostname());
   for (const a of adapters) {
     for (const row of a.backfill(since)) {
       const ref = { harness: a.name, session: row.session.id };
@@ -3141,7 +5347,7 @@ async function forget() {
     { type: "session.forgotten", harnessEvent: "forget", data: {} },
     {
       harness: { name: harness },
-      session: { id: session, seq: outbox.nextSeq(ref), machine: machineName(cfg, os3.hostname()) }
+      session: { id: session, seq: outbox.nextSeq(ref), machine: machineName(cfg, os7.hostname()) }
     }
   );
   const sinks = buildSinks(cfg.sinks);
@@ -3166,7 +5372,7 @@ async function replay() {
 function status() {
   const cfg = readConfig();
   const hc = hookCommand();
-  out(`  machine:  ${machineName(cfg, os3.hostname())}   sessionpipe ${VERSION}   state ${tilde(state)}`);
+  out(`  machine:  ${machineName(cfg, os7.hostname())}   sessionpipe ${VERSION3}   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) }))
@@ -3182,7 +5388,7 @@ function status() {
     for (const ref of outbox.sessions()) {
       const f = outbox.file(ref);
       try {
-        pending += Math.max(0, statSync6(f).size - (c[`${ref.harness}/${ref.session}`] ?? 0)) > 0 ? 1 : 0;
+        pending += Math.max(0, statSync9(f).size - (c[`${ref.harness}/${ref.session}`] ?? 0)) > 0 ? 1 : 0;
       } catch {
       }
     }
@@ -3197,18 +5403,18 @@ function status() {
     );
   const jobs = jobsDir(state);
   try {
-    const n = readdirSync7(jobs).length;
+    const n = readdirSync8(jobs).length;
     if (n) out(`  jobs:     ${n} waiting`);
   } catch {
   }
 }
 function hookWall(runs = 8) {
-  const hook = path12.join(distDir, "hook.js");
-  const tmp = mkdtempSync(path12.join(os3.tmpdir(), "sessionpipe-doctor-"));
+  const hook = path18.join(distDir, "hook.js");
+  const tmp = mkdtempSync(path18.join(os7.tmpdir(), "sessionpipe-doctor-"));
   const env = {
     ...process.env,
     SESSIONPIPE_STATE: tmp,
-    SESSIONPIPE_CONFIG: path12.join(tmp, "config.json"),
+    SESSIONPIPE_CONFIG: path18.join(tmp, "config.json"),
     SESSIONPIPE_NO_WORKER: "1"
   };
   const input = JSON.stringify({
@@ -3236,7 +5442,7 @@ function hookWall(runs = 8) {
 }
 function timing() {
   try {
-    const lines = readFileSync9(path12.join(state, "timing.jsonl"), "utf8").trim().split("\n").slice(-100);
+    const lines = readFileSync11(path18.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);
@@ -3249,10 +5455,10 @@ function doctor() {
   const cfg = readConfig();
   const hc = hookCommand();
   const report = {
-    version: VERSION,
+    version: VERSION3,
     node: process.version,
     node_path: stableNode(process.execPath),
-    machine: machineName(cfg, os3.hostname()),
+    machine: machineName(cfg, os7.hostname()),
     state,
     config: configFile(),
     harnesses: {},
@@ -3308,7 +5514,7 @@ function doctor() {
     out(JSON.stringify(report, null, 2));
     return;
   }
-  out(`  sessionpipe ${VERSION} \xB7 node ${process.version} at ${report.node_path}`);
+  out(`  sessionpipe ${VERSION3} \xB7 node ${process.version} at ${report.node_path}`);
   out(`  config ${tilde(configFile())} \xB7 state ${tilde(state)}`);
   for (const [h, st] of Object.entries(report.harnesses))
     for (const r of st) out(`  ${h.padEnd(12)} ${r.file.padEnd(44)} ${r.state}`);
@@ -3372,7 +5578,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 : statSync6(outbox.file(ref)).size);
+      offsets.set(`${ref.harness}/${ref.session}`, has("--all") ? 0 : statSync9(outbox.file(ref)).size);
     } catch {
     }
   }
@@ -3395,9 +5601,9 @@ async function tail() {
 async function workerFromArgv() {
   const f = args[1];
   if (!f) return;
-  const job = JSON.parse(readFileSync9(f, "utf8"));
+  const job = JSON.parse(readFileSync11(f, "utf8"));
   try {
-    unlinkSync5(f);
+    unlinkSync7(f);
   } catch {
   }
   await runJob(job);
@@ -3408,15 +5614,15 @@ async function update() {
     const r = await fetch("https://registry.npmjs.org/sessionpipe/latest", { signal: AbortSignal.timeout(8e3) });
     const j = await r.json();
     if (!j.version) throw new Error("no version");
-    if (j.version === VERSION) return out(`  sessionpipe ${VERSION} is current`);
-    out(`  ${j.version} is available (you run ${VERSION}); installing into this copy's prefix\u2026`);
+    if (j.version === VERSION3) return out(`  sessionpipe ${VERSION3} is current`);
+    out(`  ${j.version} is available (you run ${VERSION3}); installing into this copy's prefix\u2026`);
     const prefix = prefixOf(distDir);
-    execFileSync4("npm", ["install", "-g", `sessionpipe@${j.version}`, ...prefix ? ["--prefix", prefix] : []], {
+    execFileSync6("npm", ["install", "-g", `sessionpipe@${j.version}`, ...prefix ? ["--prefix", prefix] : []], {
       stdio: "inherit"
     });
     out("  re-arming hooks\u2026");
-    const bin = prefix ? path12.join(prefix, "bin", "sessionpipe") : "sessionpipe";
-    const p = spawn(bin, ["install", "--backfill", "0"], { stdio: "inherit" });
+    const bin = prefix ? path18.join(prefix, "bin", "sessionpipe") : "sessionpipe";
+    const p = spawn2(bin, ["install", "--backfill", "0"], { stdio: "inherit" });
     await new Promise((r2) => p.on("exit", r2));
   } catch (e) {
     out(`  couldn't check npm: ${e.message}`);