sessionpipe 0.5.0 → 0.6.1

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// sessionpipe 0.5.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe 0.6.1 · Apache-2.0 · https://sessionpipe.org
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -7,10 +7,10 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { execFileSync as execFileSync7, spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
-import { mkdtempSync, readdirSync as readdirSync8, readFileSync as readFileSync12, realpathSync as realpathSync5, rmSync as rmSync2, statSync as statSync9, unlinkSync as unlinkSync7 } from "node:fs";
+import { execFileSync as execFileSync7, spawnSync as spawnSync2 } from "node:child_process";
+import { mkdtempSync, readdirSync as readdirSync8, readFileSync as readFileSync13, realpathSync as realpathSync6, rmSync as rmSync2, statSync as statSync9, unlinkSync as unlinkSync7 } from "node:fs";
 import os9 from "node:os";
-import path21 from "node:path";
+import path23 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../core/src/adapters/antigravity.ts
@@ -381,20 +381,19 @@ function installedClaudeShaped(file, harness, events, cmd2, o) {
 // ../core/src/adapters/antigravity.ts
 var NAME = "antigravity";
 var HOOK_NAME = "sessionpipe";
-var AG_EVENTS = ["PreInvocation", "PostInvocation", "PreToolUse", "PostToolUse", "Stop"];
+var AG_EVENTS = ["PreInvocation", "PostInvocation", "PostToolUse", "Stop"];
+var AG_STALE_PRETOOL = '{"decision":"ask","reason":"sessionpipe: an outdated PreToolUse hook is still loaded. Restart this conversation (or run sessionpipe install) to drop it."}\n';
+var antigravityAnswer = (event) => event === "PreToolUse" ? AG_STALE_PRETOOL : "{}\n";
 var gemini = (env) => env.GEMINI_CLI_HOME || path4.join(HOME, ".gemini");
 var hooksFile = (env) => path4.join(gemini(env), "config", "hooks.json");
 var projectsDir = (env) => path4.join(gemini(env), "config", "projects");
 var dataDirs = (env) => ["antigravity", "antigravity-cli", "antigravity-ide"].map((d) => path4.join(gemini(env), d));
 var ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 var validTool = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
-function entry(cmd2, lean) {
+function entry(cmd2) {
   const handler = (e) => ({ type: "command", command: cmd2([NAME, e]).command, timeout: 5 });
   const out2 = { enabled: true };
-  for (const e of AG_EVENTS) {
-    if (lean && e === "PreToolUse") continue;
-    out2[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
-  }
+  for (const e of AG_EVENTS) out2[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
   return out2;
 }
 var antigravity = {
@@ -402,12 +401,12 @@ var antigravity = {
   events: AG_EVENTS,
   detect: (env = process.env) => existsSync2(path4.join(gemini(env), "config")) || dataDirs(env).some((d) => existsSync2(d)),
   configFiles: (env = process.env) => [hooksFile(env)],
-  install(cmd2, env = process.env, opts = {}) {
+  install(cmd2, env = process.env) {
     const file = hooksFile(env);
     const f = readJsonFile(file);
     if (!f.ok) return [{ file, changed: false, skipped: true, note: `${f.reason}; not touched` }];
     const hooks = f.value;
-    const e = entry(cmd2, opts.lean);
+    const e = entry(cmd2);
     if (JSON.stringify(hooks[HOOK_NAME]) === JSON.stringify(e)) return [{ file, changed: false }];
     hooks[HOOK_NAME] = e;
     mkdirSync2(path4.dirname(file), { recursive: true });
@@ -436,14 +435,14 @@ var antigravity = {
     writeFileSync2(file, formatJson(hooks, f));
     return [{ file, changed: true }];
   },
-  installed(cmd2, env = process.env, opts = {}) {
+  installed(cmd2, env = process.env) {
     const file = hooksFile(env);
     const f = readJsonFile(file);
     const have = f.ok ? f.value[HOOK_NAME] : void 0;
     return [
       {
         file,
-        state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd2, opts.lean)) ? "current" : "stale"
+        state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd2)) ? "current" : "stale"
       }
     ];
   },
@@ -455,7 +454,8 @@ var antigravity = {
     } catch {
     }
     const id = s.conversationId ?? s.session_id ?? s.sessionId;
-    if (!id) return { session: { id: "" }, events: [], stdout: "{}\n" };
+    const stdout = antigravityAnswer(event);
+    if (!id) return { session: { id: "" }, events: [], stdout };
     const workspaces = agWorkspaces(s.workspacePaths);
     const session = { id: String(id), cwd: workspaces[0] ?? input.cwd };
     if (typeof s.modelName === "string" && s.modelName !== "auto") session.model = s.modelName;
@@ -476,7 +476,8 @@ var antigravity = {
         if (tool) events.push(ev("tool.started", { tool, input: toolCall?.args }));
         break;
       case "PostToolUse":
-        if (tool)
+        if (!tool) events.push(ev("session.heartbeat", {}));
+        else
           events.push(
             ev("tool.ended", {
               tool,
@@ -490,9 +491,9 @@ var antigravity = {
         events.push(ev("turn.ended", { reason: s.error ? "error" : "stop" }));
         break;
       default:
-        return { session, events: [], stdout: "{}\n" };
+        return { session, events: [], stdout };
     }
-    const r = { session, events, stdout: "{}\n", hints: { workspaces } };
+    const r = { session, events, stdout, hints: { workspaces } };
     if (typeof s.transcriptPath === "string") r.transcript = s.transcriptPath;
     return r;
   },
@@ -2942,10 +2943,21 @@ function connectTier(flag2, current) {
   return Math.max(2, Math.min(3, current ?? 0));
 }
 
-// src/control/cli.ts
-import { existsSync as existsSync12, realpathSync as realpathSync4, watchFile } from "node:fs";
-import os7 from "node:os";
-import path19 from "node:path";
+// src/control/autoupdate.ts
+import { spawn as spawn3 } from "node:child_process";
+import { readFileSync as readFileSync11 } from "node:fs";
+import path18 from "node:path";
+
+// src/update.ts
+import { spawn as spawn2 } from "node:child_process";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync9, realpathSync as realpathSync3 } from "node:fs";
+import path16 from "node:path";
+
+// src/runtime.ts
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { realpathSync as realpathSync2 } from "node:fs";
+import os5 from "node:os";
+import path15 from "node:path";
 
 // src/run.ts
 import {
@@ -3218,7 +3230,7 @@ async function tellDaemon(state2, job, session, transcript) {
     300
   );
 }
-var VERSION = true ? "0.5.0" : "0.0.0";
+var VERSION = true ? "0.6.1" : "0.0.0";
 function enqueueJob(state2, job) {
   const jobs = jobsDir(state2);
   mkdirSync7(jobs, { recursive: true, mode: 448 });
@@ -3457,10 +3469,6 @@ function applySinkVerdict(name, res) {
 var jobsDir = (state2) => path14.join(state2, "jobs");
 
 // src/runtime.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
-import { realpathSync as realpathSync2 } from "node:fs";
-import os5 from "node:os";
-import path15 from "node:path";
 function stableNode(exe) {
   const m = /^(.*)\/Cellar\/(node(?:@\d+)?)\/[^/]+\/bin\/node$/.exec(exe);
   if (!m) return exe;
@@ -3514,9 +3522,171 @@ function rerunGlobally(argv, out2) {
   }
 }
 
-// src/control/daemon.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync9, realpathSync as realpathSync3, statSync as statSync8, unlinkSync as unlinkSync5 } from "node:fs";
-import net2 from "node:net";
+// src/update.ts
+var REGISTRY_LATEST = "https://registry.npmjs.org/sessionpipe/latest";
+var VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parse2(v) {
+  const m = VERSION_RE.exec(String(v).trim());
+  if (!m) return null;
+  return { n: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ?? null };
+}
+function compareVersions(a, b) {
+  const x = parse2(a);
+  const y = parse2(b);
+  if (!x || !y) return null;
+  for (let i = 0; i < 3; i++) if (x.n[i] !== y.n[i]) return x.n[i] - y.n[i];
+  if (x.pre === y.pre) return 0;
+  if (x.pre === null) return 1;
+  if (y.pre === null) return -1;
+  return x.pre.localeCompare(y.pre, "en", { numeric: true });
+}
+function isNewer(a, b) {
+  const x = parse2(a);
+  if (!x || x.pre !== null) return false;
+  const c = compareVersions(a, b);
+  return c !== null && c > 0;
+}
+async function latestVersion(f = fetch, timeoutMs = 8e3) {
+  const r = await f(REGISTRY_LATEST, {
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: { accept: "application/json" }
+  });
+  if (!r.ok) throw new Error(`the npm registry answered HTTP ${r.status}`);
+  const j = await r.json();
+  if (typeof j.version !== "string" || !parse2(j.version)) throw new Error("the npm registry named no version");
+  return j.version;
+}
+function prefixOf(distDir2, platform = process.platform) {
+  const re = platform === "win32" ? /^(.*?)[\\/]node_modules[\\/]sessionpipe[\\/]/ : /^(.*)\/lib\/node_modules\/sessionpipe\//;
+  return re.exec(`${distDir2}/`)?.[1] ?? null;
+}
+function globalPrefix(distDir2, platform = process.platform) {
+  if (viaNpx(distDir2)) return null;
+  const prefix = prefixOf(distDir2, platform);
+  if (!prefix) return null;
+  const bin = platform === "win32" ? path16.join(prefix, "sessionpipe.cmd") : path16.join(prefix, "bin", "sessionpipe");
+  return existsSync9(bin) ? prefix : null;
+}
+function unwritable(prefix, platform = process.platform) {
+  const dir = platform === "win32" ? path16.join(prefix, "node_modules") : path16.join(prefix, "lib", "node_modules");
+  try {
+    accessSync2(dir, constants2.W_OK);
+    return null;
+  } catch {
+    return `${dir} isn't writable by this user (installed with sudo?)`;
+  }
+}
+function npmArgv(node, platform = process.platform) {
+  const dir = path16.dirname(node);
+  const candidates = platform === "win32" ? [path16.join(dir, "node_modules", "npm", "bin", "npm-cli.js")] : [path16.join(dir, "npm"), path16.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")];
+  for (const c of candidates) {
+    try {
+      const real = realpathSync3(c);
+      if (real.endsWith(".js")) return [node, real];
+    } catch {
+    }
+  }
+  return [platform === "win32" ? "npm.cmd" : "npm"];
+}
+var execCapture = (argv, o) => new Promise((resolve) => {
+  const [cmd2, ...rest] = argv;
+  let stdout = "";
+  let stderr = "";
+  const keep = (s, b) => (s + b.toString("utf8")).slice(-16e3);
+  let child;
+  try {
+    child = spawn2(cmd2, rest, {
+      env: o.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      shell: process.platform === "win32" && cmd2.endsWith(".cmd")
+    });
+  } catch (e) {
+    resolve({ code: null, stdout, stderr, error: e.message });
+    return;
+  }
+  const t = setTimeout(() => child.kill("SIGTERM"), o.timeoutMs);
+  child.stdout?.on("data", (b) => {
+    stdout = keep(stdout, b);
+  });
+  child.stderr?.on("data", (b) => {
+    stderr = keep(stderr, b);
+  });
+  child.on("error", (e) => {
+    clearTimeout(t);
+    resolve({ code: null, stdout, stderr, error: e.message });
+  });
+  child.on("close", (code) => {
+    clearTimeout(t);
+    resolve({ code, stdout, stderr });
+  });
+});
+var lastLine = (r) => (r.error || r.stderr.trim().split("\n").filter(Boolean).slice(-2).join(" ") || `exit ${r.code}`).slice(0, 300);
+async function installedVersion(o) {
+  const r = await (o.exec ?? execCapture)([o.node, path16.join(o.distDir, "cli.js"), "--version"], {
+    env: o.env ?? process.env,
+    timeoutMs: 3e4
+  });
+  const v = r.stdout.trim();
+  return r.code === 0 && parse2(v) ? v : null;
+}
+async function installVersion(version, o) {
+  const t0 = Date.now();
+  const platform = o.platform ?? process.platform;
+  const exec = o.exec ?? execCapture;
+  const base = o.env ?? process.env;
+  const env = { ...base, PATH: [path16.dirname(o.node), base.PATH].filter(Boolean).join(path16.delimiter) };
+  const prefix = globalPrefix(o.distDir, platform);
+  if (!prefix)
+    return { ok: false, ms: Date.now() - t0, stage: "prefix", error: "this copy isn't a global npm install" };
+  const npm = npmArgv(o.node, platform);
+  const r = await exec(
+    [
+      ...npm,
+      "install",
+      "--global",
+      "--prefix",
+      prefix,
+      "--ignore-scripts",
+      "--no-audit",
+      "--no-fund",
+      `sessionpipe@${version}`
+    ],
+    { env, timeoutMs: 5 * 6e4 }
+  );
+  if (r.code !== 0) return { ok: false, ms: Date.now() - t0, stage: "npm", error: `npm install: ${lastLine(r)}` };
+  const now = await installedVersion({ node: o.node, distDir: o.distDir, env, exec });
+  if (now !== version)
+    return {
+      ok: false,
+      ms: Date.now() - t0,
+      stage: "verify",
+      error: `npm finished, but the copy in ${prefix} says ${now ?? "nothing"}, not ${version}`
+    };
+  let hooks = "no harness set up here; nothing to re-arm";
+  if (o.harnesses.length) {
+    const h = await exec(
+      [o.node, path16.join(o.distDir, "cli.js"), "install", "--backfill", "0", ...o.harnesses.map((n) => `--${n}`)],
+      { env, timeoutMs: 2 * 6e4 }
+    );
+    hooks = h.code === 0 ? `hooks re-armed for ${o.harnesses.join(", ")}` : `re-arming the hooks failed (${lastLine(h)}); \`sessionpipe install\` does it`;
+  }
+  return { ok: true, ms: Date.now() - t0, hooks };
+}
+
+// src/control/store.ts
+import {
+  appendFileSync as appendFileSync4,
+  chmodSync as chmodSync2,
+  closeSync as closeSync4,
+  existsSync as existsSync10,
+  fsyncSync,
+  mkdirSync as mkdirSync8,
+  openSync as openSync4,
+  readFileSync as readFileSync10,
+  renameSync as renameSync3,
+  writeFileSync as writeFileSync7
+} from "node:fs";
 import path17 from "node:path";
 
 // ../core/src/control/verify.ts
@@ -3853,122 +4023,11 @@ async function checkGrantPath(s, c, o) {
   return { ok: true, key: key.id };
 }
 
-// src/control/reply.ts
-import { closeSync as closeSync4, openSync as openSync4, readSync as readSync4, statSync as statSync7 } from "node:fs";
-function transcriptEnd(file) {
-  try {
-    return statSync7(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;
-      if (a.text) o.onText?.(a.text);
-    }
-    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 appendFileSync4,
-  chmodSync as chmodSync2,
-  closeSync as closeSync5,
-  existsSync as existsSync9,
-  fsyncSync,
-  mkdirSync as mkdirSync8,
-  openSync as openSync5,
-  readFileSync as readFileSync10,
-  renameSync as renameSync3,
-  writeFileSync as writeFileSync7
-} from "node:fs";
-import path16 from "node:path";
-var controlFile = (env = process.env) => path16.join(path16.dirname(configFile(env)), "control.json");
-var controlState = (env = process.env) => path16.join(stateDir(env), "control");
+var controlFile = (env = process.env) => path17.join(path17.dirname(configFile(env)), "control.json");
+var controlState = (env = process.env) => path17.join(stateDir(env), "control");
 function writePrivate(file, value) {
-  mkdirSync8(path16.dirname(file), { recursive: true, mode: 448 });
+  mkdirSync8(path17.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
   writeFileSync7(tmp, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
@@ -3995,6 +4054,14 @@ function readControl(env = process.env, run = defaultRunner) {
     return null;
   }
 }
+function pairedCount(env = process.env) {
+  try {
+    const j = JSON.parse(readFileSync10(controlFile(env), "utf8"));
+    return Array.isArray(j.receivers) ? j.receivers.length : 0;
+  } catch {
+    return 0;
+  }
+}
 var writeControl = (c, env = process.env) => writePrivate(controlFile(env), {
   ...c,
   receivers: c.receivers.map((r) => {
@@ -4060,14 +4127,14 @@ var NonceStore = class {
     const t = this.seenAt.get(nonce);
     if (t !== void 0 && t > this.now() - NONCE_TTL_MS) return true;
     const at = this.now();
-    mkdirSync8(path16.dirname(this.file), { recursive: true, mode: 448 });
-    const fd = openSync5(this.file, "a", 384);
+    mkdirSync8(path17.dirname(this.file), { recursive: true, mode: 448 });
+    const fd = openSync4(this.file, "a", 384);
     try {
       appendFileSync4(fd, `${JSON.stringify({ n: nonce, t: at })}
 `);
       fsyncSync(fd);
     } finally {
-      closeSync5(fd);
+      closeSync4(fd);
     }
     this.seenAt.set(nonce, at);
     return false;
@@ -4076,9 +4143,9 @@ var NonceStore = class {
   compact() {
     const cut = this.now() - NONCE_TTL_MS;
     for (const [n, t] of this.seenAt) if (t <= cut) this.seenAt.delete(n);
-    if (!existsSync9(this.file) && !this.seenAt.size) return;
+    if (!existsSync10(this.file) && !this.seenAt.size) return;
     const body = [...this.seenAt].map(([n, t]) => JSON.stringify({ n, t })).join("\n");
-    mkdirSync8(path16.dirname(this.file), { recursive: true, mode: 448 });
+    mkdirSync8(path17.dirname(this.file), { recursive: true, mode: 448 });
     writeFileSync7(`${this.file}.tmp`, body ? `${body}
 ` : "", { mode: 384 });
     renameSync3(`${this.file}.tmp`, this.file);
@@ -4100,12 +4167,12 @@ var AckOutbox = class {
     }
   }
   add(a) {
-    mkdirSync8(path16.dirname(this.file), { recursive: true, mode: 448 });
+    mkdirSync8(path17.dirname(this.file), { recursive: true, mode: 448 });
     appendFileSync4(this.file, `${JSON.stringify(a)}
 `, { mode: 384 });
   }
   keep(left) {
-    mkdirSync8(path16.dirname(this.file), { recursive: true, mode: 448 });
+    mkdirSync8(path17.dirname(this.file), { recursive: true, mode: 448 });
     writeFileSync7(`${this.file}.tmp`, left.map((a) => JSON.stringify(a)).join("\n") + (left.length ? "\n" : ""), {
       mode: 384
     });
@@ -4122,6 +4189,424 @@ function readState(file) {
 }
 var writeState = (file, s) => writePrivate(file, s);
 
+// src/control/autoupdate.ts
+var UPDATE_EXIT = 75;
+var DAY_MS = 24 * 36e5;
+var LABEL = "org.sessionpipe.control";
+var UNIT = "sessionpipe-control.service";
+var updateFile = (env = process.env) => path18.join(controlState(env), "update.json");
+function readUpdate(file) {
+  try {
+    const j = JSON.parse(readFileSync11(file, "utf8"));
+    return j && typeof j === "object" ? j : {};
+  } catch {
+    return {};
+  }
+}
+function isDue(rec, now) {
+  const t = Date.parse(rec.checked_at ?? "");
+  if (!Number.isFinite(t)) return true;
+  if (t > now + 5 * 6e4) return true;
+  return now - t >= DAY_MS;
+}
+function autoUpdateOff(o) {
+  if (o.env.SESSIONPIPE_NO_UPDATE_CHECK) return "SESSIONPIPE_NO_UPDATE_CHECK is set";
+  if (o.config.update_check === false) return "update_check is false in config.json (`sessionpipe update on`)";
+  const prefix = globalPrefix(o.distDir, o.platform);
+  if (!prefix) return "this copy isn't a global npm install (npx, a checkout or a dev build)";
+  return unwritable(prefix, o.platform);
+}
+function updateSummary(o) {
+  const daemonEnv = o.rec.off?.startsWith("SESSIONPIPE_NO_UPDATE_CHECK") ? "SESSIONPIPE_NO_UPDATE_CHECK is set in the daemon's environment" : null;
+  const off2 = o.off ?? (o.paired ? daemonEnv : "it runs in the control daemon, which isn't set up here (`sessionpipe connect`)");
+  return {
+    auto: !off2,
+    off: off2,
+    last_check: o.rec.checked_at ?? null,
+    latest: o.rec.latest ?? null,
+    last_error: o.rec.error ?? null,
+    pending: o.rec.pending ?? null,
+    updated: o.rec.updated ?? null,
+    failed: o.rec.failed ?? null
+  };
+}
+function ago(iso, now) {
+  const ms = now - Date.parse(iso);
+  if (!Number.isFinite(ms)) return "at an unreadable time";
+  if (ms < 9e4) return "just now";
+  if (ms < 90 * 6e4) return `${Math.round(ms / 6e4)} min ago`;
+  if (ms < 36 * 36e5) return `${Math.round(ms / 36e5)} h ago`;
+  return `${Math.round(ms / DAY_MS)} days ago`;
+}
+function updateLine(s, now) {
+  const parts = [
+    s.auto ? "automatic (the control daemon checks npm once a day and installs when idle; `sessionpipe update off` stops it)" : `not automatic: ${s.off}`
+  ];
+  if (s.last_check)
+    parts.push(
+      s.last_error ? `last check ${ago(s.last_check, now)} failed: ${s.last_error}` : `last check ${ago(s.last_check, now)}: latest ${s.latest ?? "?"}`
+    );
+  else if (s.auto) parts.push("not checked yet (a minute after the daemon starts)");
+  if (s.pending) parts.push(`${s.pending} waits for the daemon to be idle`);
+  if (s.failed) parts.push(`installing ${s.failed.version} failed ${ago(s.failed.at, now)}: ${s.failed.error}`);
+  else if (s.updated) parts.push(`updated ${s.updated.from} \u2192 ${s.updated.to} ${ago(s.updated.at, now)}`);
+  return parts.join(" \xB7 ");
+}
+function restartVia(o) {
+  const s = o.env.SESSIONPIPE_SERVICE ?? "";
+  if (s.startsWith("supervisor:") && s === `supervisor:${o.ppid}`) return "supervisor";
+  if (o.platform === "darwin" && o.ppid === 1 && (s === "launchd" || o.env.XPC_SERVICE_NAME === LABEL))
+    return "launchd";
+  if (o.platform === "linux") {
+    let cg = "";
+    try {
+      cg = (o.cgroup ?? (() => readFileSync11("/proc/self/cgroup", "utf8")))();
+    } catch {
+    }
+    const inUnit = cg.split("\n").some((l) => l.endsWith(`/${UNIT}`) || l.includes(`/${UNIT}/`));
+    const mainPid = !o.env.SYSTEMD_EXEC_PID || o.env.SYSTEMD_EXEC_PID === String(o.pid);
+    if (inUnit && mainPid) return "systemd";
+  }
+  return null;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms).unref?.());
+var AutoUpdater = class {
+  constructor(d) {
+    this.d = d;
+  }
+  d;
+  first = null;
+  every = null;
+  stopped = false;
+  busyWith = null;
+  lastOff = void 0;
+  start() {
+    if (this.record().pending) this.save({ pending: null });
+    this.first = setTimeout(() => void this.tick(), this.d.firstCheckMs ?? 6e4);
+    this.first.unref?.();
+    this.every = setInterval(() => void this.tick(), this.d.tickMs ?? 10 * 6e4);
+    this.every.unref?.();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.first) clearTimeout(this.first);
+    if (this.every) clearInterval(this.every);
+  }
+  record() {
+    return readUpdate(this.d.file);
+  }
+  save(patch) {
+    try {
+      writePrivate(this.d.file, { ...readUpdate(this.d.file), ...patch });
+    } catch {
+    }
+  }
+  /** One look at the clock: check when a check is due and nothing is under way. */
+  async tick() {
+    if (this.stopped || this.busyWith) return;
+    const off2 = this.d.off();
+    if (off2 !== this.lastOff) {
+      if (off2) this.d.log(`auto-update off: ${off2}`);
+      else if (this.lastOff) this.d.log("auto-update on");
+      this.lastOff = off2;
+      this.save({ off: off2 });
+    }
+    if (off2) return;
+    const rec = this.record();
+    if (isDue(rec, this.d.now())) return this.check();
+    const known = rec.latest;
+    if (known && isNewer(known, this.d.version) && rec.failed?.version !== known)
+      return this.guard(() => this.apply(known));
+  }
+  /** One update job at a time; whatever it throws is logged, never left unhandled. */
+  guard(job) {
+    if (this.busyWith) return this.busyWith;
+    this.busyWith = job().catch((e) => {
+      if (!this.stopped) this.d.log(`update: ${String(e?.message || e)}`);
+    }).finally(() => {
+      this.busyWith = null;
+    });
+    return this.busyWith;
+  }
+  /** Ask npm now; when it has a newer release, install it once idle and restart. */
+  check() {
+    return this.guard(async () => {
+      const t0 = this.d.now();
+      let latest;
+      try {
+        latest = await this.d.latest();
+      } catch (e) {
+        const error = String(e?.message || e).slice(0, 200);
+        this.save({ checked_at: new Date(t0).toISOString(), latest: null, error, running: this.d.version });
+        this.d.log(`update check: failed after ${this.d.now() - t0} ms: ${error}`);
+        return;
+      }
+      const ms = this.d.now() - t0;
+      this.save({ checked_at: new Date(t0).toISOString(), latest, error: null, running: this.d.version });
+      if (!isNewer(latest, this.d.version)) {
+        this.save({ pending: null });
+        this.d.log(`update check: ${this.d.version} is current (npm latest ${latest}, ${ms} ms)`);
+        return;
+      }
+      this.d.log(`update check: ${latest} is out (running ${this.d.version}, ${ms} ms); updating once idle`);
+      await this.apply(latest);
+    });
+  }
+  /** Restart onto the copy on disk once idle (`sessionpipe update` installed it). */
+  restartWhenIdle() {
+    if (this.stopped) return false;
+    if (this.busyWith) return true;
+    void this.guard(async () => {
+      const onDisk = await this.d.installed();
+      if (!onDisk || onDisk === this.d.version) {
+        this.d.log(`restart asked: the copy on disk is ${onDisk ?? "unreadable"}, the one running; staying`);
+        return;
+      }
+      await this.quiesce(onDisk, false);
+      await this.resumeOnError(async () => {
+        this.d.log(`restart: ${this.d.version} \u2192 ${onDisk} (installed by hand)`);
+        this.save({ updated: { from: this.d.version, to: onDisk, at: new Date(this.d.now()).toISOString(), ms: 0 } });
+        await this.d.restart(this.d.version, onDisk);
+      });
+    });
+    return true;
+  }
+  /** Wait until the daemon has nothing in hand, then stop its intake. A message that
+   *  slipped in between is let through and waited for. An automatic update turned off
+   *  meanwhile (`sessionpipe update off`) stops waiting. */
+  async quiesce(target, auto = true) {
+    let said = false;
+    for (; ; ) {
+      let why = this.d.daemon.busy();
+      while (why) {
+        if (this.stopped) throw new Error("stopped");
+        const off2 = auto ? this.d.off() : null;
+        if (off2) {
+          this.save({ pending: null });
+          throw new Error(`${target} not installed: auto-update was turned off (${off2})`);
+        }
+        if (!said) {
+          this.d.log(`update: ${target} waits until the daemon is idle (${why})`);
+          said = true;
+        }
+        await sleep(this.d.idlePollMs ?? 15e3);
+        why = this.d.daemon.busy();
+      }
+      this.d.daemon.pauseIntake();
+      if (!this.d.daemon.busy()) return;
+      this.d.daemon.resumeIntake();
+    }
+  }
+  /** Intake is paused from quiesce() on: whatever goes wrong after it lets it go. */
+  async resumeOnError(fn) {
+    try {
+      await fn();
+    } catch (e) {
+      this.d.daemon.resumeIntake();
+      throw e;
+    }
+  }
+  async apply(target) {
+    this.save({ pending: target });
+    await this.quiesce(target);
+    await this.resumeOnError(() => this.installAndRestart(target));
+  }
+  async installAndRestart(target) {
+    const from = this.d.version;
+    const t0 = this.d.now();
+    const onDisk = await this.d.installed();
+    let note = "";
+    const c = onDisk ? compareVersions(onDisk, target) : null;
+    if (onDisk && c !== null && c >= 0) {
+      target = onDisk;
+      note = " (already on disk)";
+    } else {
+      const r = await this.d.install(target);
+      if (!r.ok) {
+        this.d.daemon.resumeIntake();
+        const ms2 = this.d.now() - t0;
+        this.save({
+          pending: null,
+          failed: { version: target, at: new Date(this.d.now()).toISOString(), error: r.error }
+        });
+        this.d.log(`update: ${from} \u2192 ${target} failed after ${ms2} ms: ${r.error}; still running ${from}`);
+        return;
+      }
+      if (r.hooks) note = `; ${r.hooks}`;
+    }
+    const ms = this.d.now() - t0;
+    if (this.d.daemon.busy()) {
+      this.d.daemon.resumeIntake();
+      await this.quiesce(target, false);
+    }
+    this.save({
+      pending: null,
+      failed: null,
+      updated: { from, to: target, at: new Date(this.d.now()).toISOString(), ms }
+    });
+    this.d.log(`update: ${from} \u2192 ${target} in ${ms} ms${note}; restarting`);
+    await this.d.restart(from, target);
+  }
+};
+function supervise(o) {
+  const run = o.spawn ?? spawn3;
+  const exit = o.exit ?? ((c) => process.exit(c));
+  const env = { ...o.env, SESSIONPIPE_SERVICE: `supervisor:${process.pid}` };
+  let child = null;
+  let stopping = false;
+  let later = null;
+  const start = () => {
+    later = null;
+    const c = run(o.node, o.args, { env, stdio: "inherit", windowsHide: true });
+    child = c;
+    let done = false;
+    const ended = (code, signal) => {
+      if (done) return;
+      done = true;
+      child = null;
+      if (stopping) return exit(code ?? 0);
+      if (code === UPDATE_EXIT) {
+        o.log("the daemon is restarting onto its new version");
+        return start();
+      }
+      if (code === 0) return exit(0);
+      o.log(`the daemon exited (${signal ?? `code ${code}`}); starting it again in 5 s`);
+      later = setTimeout(start, o.failDelayMs ?? 5e3);
+    };
+    c.on("exit", ended);
+    c.on("error", (e) => {
+      o.log(`couldn't start the daemon: ${e.message}`);
+      ended(1, null);
+    });
+  };
+  const stop = (sig = "SIGTERM") => {
+    stopping = true;
+    if (later) clearTimeout(later);
+    if (child) child.kill(sig);
+    else exit(0);
+  };
+  start();
+  return { stop };
+}
+
+// src/control/cli.ts
+import { existsSync as existsSync13, realpathSync as realpathSync5, unwatchFile, watchFile } from "node:fs";
+import os7 from "node:os";
+import path21 from "node:path";
+
+// src/control/daemon.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync9, realpathSync as realpathSync4, statSync as statSync8, unlinkSync as unlinkSync5 } from "node:fs";
+import net2 from "node:net";
+import path19 from "node:path";
+
+// src/control/reply.ts
+import { closeSync as closeSync5, openSync as openSync5, readSync as readSync4, statSync as statSync7 } from "node:fs";
+function transcriptEnd(file) {
+  try {
+    return statSync7(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 sleep3 = 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 = openSync5(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 {
+        closeSync5(fd);
+      }
+      const a = answerIn(lines);
+      if (a.done) return a.text || null;
+      if (a.text) o.onText?.(a.text);
+    }
+    await sleep3(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}`;
+}
+function frameStart(text, receiver) {
+  let host = receiver;
+  try {
+    host = new URL(receiver).host;
+  } catch {
+  }
+  return `${text}
+
+(Sent via ${host} with sessionpipe control, signed on the sender's device.)`;
+}
+
 // src/control/stream.ts
 function streamJsonPiece(line) {
   let j;
@@ -4212,7 +4697,7 @@ var {
   recentlyWritten: recentlyWritten2,
   sessionFolder: sessionFolder2
 } = claude_code_control_exports;
-var VERSION2 = true ? "0.5.0" : "0.0.0";
+var VERSION2 = true ? "0.6.1" : "0.0.0";
 var MAX_REPLY = 2e4;
 var HELLO_EVERY_MS = 10 * 6e4;
 var TURN_FALLBACK_MS = 30 * 6e4;
@@ -4226,6 +4711,15 @@ var CLOSES_ATTENTION = /* @__PURE__ */ new Set([
   "UserPromptSubmit",
   "SessionEnd"
 ]);
+var DaemonRunning = class extends Error {
+  constructor(other) {
+    super(
+      `another control daemon already serves this machine (${other.pid ? `pid ${other.pid}, ` : ""}sessionpipe ${other.version ?? "?"})`
+    );
+    this.other = other;
+  }
+  other;
+};
 function sessionToolsFrom(v) {
   if (!Array.isArray(v)) return [];
   return [
@@ -4239,9 +4733,9 @@ var ControlDaemon = class {
     this.dir = dir;
     this.sock = sock;
     this.deps = deps;
-    this.nonces = new NonceStore(path17.join(dir, "nonces.jsonl"), deps.now);
-    this.acks = new AckOutbox(path17.join(dir, "acks.jsonl"));
-    this.state = readState(path17.join(dir, "state.json"));
+    this.nonces = new NonceStore(path19.join(dir, "nonces.jsonl"), deps.now);
+    this.acks = new AckOutbox(path19.join(dir, "acks.jsonl"));
+    this.state = readState(path19.join(dir, "state.json"));
   }
   cfg;
   dir;
@@ -4276,6 +4770,17 @@ var ControlDaemon = class {
   procWaiters = [];
   /** configDir → the last login answer and when (a yes is kept 10 minutes, a no 30 s). */
   logins = /* @__PURE__ */ new Map();
+  /** Intake paused for an update: the long-polls end and wait for this. */
+  paused = null;
+  /** Poll answers whose messages are being read and handed out. */
+  receiving = 0;
+  /** The socket file this daemon created (dev:ino): stop() removes only that one, and a
+   *  different file at the path means another daemon took over. */
+  sockId = null;
+  ownTimer = null;
+  /** Every open local connection: stop() ends them, or the server's close would wait
+   *  on a client that never says anything. */
+  conns = /* @__PURE__ */ new Set();
   // --- lifecycle ------------------------------------------------------------------
   async start() {
     this.running = true;
@@ -4288,24 +4793,97 @@ var ControlDaemon = class {
     void this.flushAcks();
     const idle = setInterval(() => this.closeIdleSdk(), 6e4);
     idle.unref();
-    this.deps.log(`control daemon ${VERSION2} up \xB7 ${this.cfg.receivers.length} receiver(s) \xB7 socket ${this.sock}`);
+    if (this.sockId) {
+      this.ownTimer = setInterval(() => void this.checkSocket(), 1e4);
+      this.ownTimer.unref();
+    }
+    this.deps.log(
+      `control daemon ${VERSION2} up \xB7 pid ${process.pid} \xB7 ${this.cfg.receivers.length} receiver(s) \xB7 socket ${this.sock}`
+    );
   }
-  async stop() {
+  /** `leaveSocket`: the socket path is another daemon's now. Closing a Unix-socket
+   *  server makes Node unlink its path whoever holds it, so this one's server is left
+   *  open for the process's exit to drop. */
+  async stop(o = {}) {
     this.running = false;
+    this.paused?.go();
     for (const a of this.aborts) a.abort();
     if (this.helloTimer) clearInterval(this.helloTimer);
     if (this.helloSoon) clearTimeout(this.helloSoon);
+    if (this.ownTimer) clearInterval(this.ownTimer);
     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();
     }
+    for (const c of this.conns) c.destroy();
+    if (o.leaveSocket) {
+      this.sockId = null;
+      return;
+    }
     await new Promise((r) => this.server ? this.server.close(() => r()) : r());
-    if (process.platform !== "win32")
+    this.server = null;
+    if (process.platform !== "win32" && this.sockId && socketId(this.sock) === this.sockId)
       try {
         unlinkSync5(this.sock);
       } catch {
       }
+    this.sockId = null;
+  }
+  /** Null when nothing is in hand, so a restart would interrupt nothing; otherwise what
+   *  is. Parked waiters don't count: a waiter reconnects in silence (CONTROL.md §8). A
+   *  session someone is working in mid-turn does (a restart forgets it is mid-turn, so a
+   *  message to it would fork rather than wait for its Stop), unless it has been silent
+   *  for ten minutes: a session killed mid-turn never sends its Stop. */
+  busy() {
+    if (this.inflight.size) return `${this.inflight.size} message(s) in hand`;
+    if (this.procs || this.ownRuns.size) return "a headless Claude Code run";
+    if (this.startsRunning) return "a session starting";
+    for (const s of this.sdkSessions.values()) if (s.busy) return "an Agent SDK session mid-turn";
+    for (const l of this.live.values()) if (l.attentions.size) return "a permission prompt waiting for an answer";
+    const now = this.deps.now();
+    for (const l of this.live.values())
+      if (l.midTurn && now - l.lastEvent < 10 * 6e4) return "a session on this machine mid-turn";
+    if (this.receiving) return "messages just received";
+    if (this.flushing) return "acks being sent";
+    return null;
+  }
+  /** Stop taking messages: every long-poll ends now and waits for resumeIntake(). The
+   *  receiver keeps what arrives meanwhile; the local socket keeps answering. */
+  pauseIntake() {
+    if (this.paused) return;
+    let go;
+    const until = new Promise((r) => {
+      go = r;
+    });
+    this.paused = { until, go };
+    for (const a of this.aborts) a.abort();
+  }
+  resumeIntake() {
+    const p = this.paused;
+    this.paused = null;
+    p?.go();
+  }
+  /** The socket path still holds this daemon's file. Gone: listen again. Replaced:
+   *  another daemon took over (two started at once), so this one steps aside. */
+  async checkSocket() {
+    if (!this.running || !this.sockId) return;
+    const now = socketId(this.sock);
+    if (now === this.sockId) return;
+    if (now === null) {
+      this.deps.log(`the socket ${this.sock} vanished; listening again`);
+      this.server?.unref();
+      this.server = null;
+      try {
+        await this.listen();
+      } catch (e) {
+        this.deps.log(`couldn't listen again: ${String(e?.message || e)}`);
+      }
+      return;
+    }
+    this.deps.log("another control daemon took over the socket; this one stops");
+    await this.stop({ leaveSocket: true });
+    this.deps.onLostSocket?.();
   }
   reload(cfg) {
     const known = new Set(this.cfg.receivers.map((r) => r.control + r.machine));
@@ -4315,6 +4893,7 @@ var ControlDaemon = class {
   status() {
     return {
       version: VERSION2,
+      pid: process.pid,
       name: this.cfg.name,
       receivers: this.cfg.receivers.map((r) => {
         const p = this.polling.get(r.control + r.machine);
@@ -4333,26 +4912,35 @@ var ControlDaemon = class {
       sdk: [...this.sdkSessions.keys()],
       nonces: this.nonces.size,
       acks_pending: this.acks.all().length,
-      delivered: { ...this.delivered }
+      delivered: { ...this.delivered },
+      busy: this.busy(),
+      ...this.deps.updateStatus ? { update: this.deps.updateStatus() } : {}
     };
   }
   // --- the local socket -----------------------------------------------------------
-  listen() {
+  /** One daemon per machine: a daemon that answers on the socket keeps it, and this
+   *  one doesn't start. A socket file nobody answers on is a dead daemon's; it goes. */
+  async listen() {
+    const other = await ask(this.sock, { op: "status" }, 1500);
+    if (other?.op === "status") throw new DaemonRunning(other.status ?? {});
     if (process.platform !== "win32") {
       try {
-        if (existsSync10(this.sock)) unlinkSync5(this.sock);
+        if (existsSync11(this.sock)) unlinkSync5(this.sock);
       } catch {
       }
     }
     this.server = net2.createServer((s) => this.onConn(s));
-    return new Promise((resolve, reject) => {
+    await new Promise((resolve, reject) => {
       this.server.once("error", reject);
       this.server.listen(this.sock, () => resolve());
     });
+    if (process.platform !== "win32") this.sockId = socketId(this.sock);
   }
   onConn(s) {
     let buf = "";
     let handled = false;
+    this.conns.add(s);
+    s.on("close", () => this.conns.delete(s));
     s.on("error", () => {
     });
     s.on("data", (d) => {
@@ -4445,6 +5033,11 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
         this.onEvent(req);
         this.reply(s, { op: "ok" });
         return;
+      case "restart":
+        this.reply(s, this.deps.onRestart?.() ? { op: "ok" } : { op: "none" });
+        return;
+      default:
+        s.destroy();
     }
   }
   /** A queued turn message that hasn't expired. */
@@ -4492,6 +5085,10 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     for (; ; ) {
       const r = this.cfg.receivers.find((x) => x.control + x.machine === key);
       if (!this.running || !r) break;
+      if (this.paused) {
+        await this.paused.until;
+        continue;
+      }
       if (!r.token) {
         const t2 = this.deps.token?.(r) ?? null;
         if (t2) {
@@ -4525,16 +5122,21 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
           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)}`)
-            );
+          this.receiving++;
+          try {
+            const body = await res.json();
+            const cur = this.cfg.receivers.find((x) => x.control + x.machine === key) ?? r;
+            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)}`)
+              );
+            }
+          } finally {
+            this.receiving--;
           }
-          if (!fresh) await sleep(2e3);
+          if (!fresh) await sleep2(2e3);
           st.error = null;
           backoff = 0;
         } else if (res.status === 204) {
@@ -4543,13 +5145,14 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
         } else {
           st.error = `HTTP ${res.status}`;
           downSince ||= this.deps.now();
-          await sleep(pause(backoff++));
+          await sleep2(pause(backoff++));
         }
       } catch (e) {
         if (!this.running) break;
+        if (this.paused) continue;
         st.error = String(e?.message || e).slice(0, 120);
         downSince ||= this.deps.now();
-        await sleep(pause(backoff++));
+        await sleep2(pause(backoff++));
       } finally {
         clearTimeout(t);
         this.aborts.delete(ctl);
@@ -4657,7 +5260,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
         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));
+        if (left.length) await sleep2(2e3 * (round + 1));
       }
     } finally {
       this.flushing = false;
@@ -4730,10 +5333,10 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     return { folder: ok, transcript: null };
   }
   allowed(dir) {
-    if (!path17.isAbsolute(dir)) return null;
+    if (!path19.isAbsolute(dir)) return null;
     let r;
     try {
-      r = realpathSync3.native(dir);
+      r = realpathSync4.native(dir);
       if (!statSync8(r).isDirectory()) return null;
     } catch {
       return null;
@@ -4741,10 +5344,10 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
     for (const f of this.cfg.folders) {
       let rf = f;
       try {
-        rf = realpathSync3.native(f);
+        rf = realpathSync4.native(f);
       } catch {
       }
-      if (r === rf || r.startsWith(rf.endsWith(path17.sep) ? rf : rf + path17.sep)) return r;
+      if (r === rf || r.startsWith(rf.endsWith(path19.sep) ? rf : rf + path19.sep)) return r;
     }
     return null;
   }
@@ -4929,7 +5532,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       const ran = isUuid2(out2.session) ? out2.session : target;
       if (mode === "fork" && ran !== target) {
         this.state.copies[ref.id] = ran;
-        writeState(path17.join(this.dir, "state.json"), this.state);
+        writeState(path19.join(this.dir, "state.json"), this.state);
         this.lastEnd.set(ran, this.deps.now());
       }
       this.finish(
@@ -5105,7 +5708,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       const out3 = await this.slot(async () => {
         const s = sdk.start({ session: ref.id, cwd, mode: this.cfg.mode, allowedTools: this.allowedFor(r) });
         this.sdkSessions.set(ref.id, s);
-        return s.send(frame(cmd2.text, r.url));
+        return s.send(frameStart(cmd2.text, r.url));
       });
       return this.finish(
         r,
@@ -5130,7 +5733,7 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
           ...this.allowedFor(r).length ? [`--allowedTools=${this.allowedFor(r).join(",")}`] : [],
           "--session-id",
           ref.id,
-          frame(cmd2.text, r.url)
+          frameStart(cmd2.text, r.url)
         ],
         {
           cwd,
@@ -5158,15 +5761,23 @@ ${IN_PLACE_ANSWER}`, id: p.msgId });
       }
   }
 };
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms).unref?.());
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms).unref?.());
+function socketId(p) {
+  try {
+    const st = statSync8(p);
+    return `${st.dev}:${st.ino}`;
+  } catch {
+    return null;
+  }
+}
 
 // src/control/pair.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync10, unlinkSync as unlinkSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync10, unlinkSync as unlinkSync6, writeFileSync as writeFileSync8 } from "node:fs";
 import os6 from "node:os";
-import path18 from "node:path";
-var VERSION3 = true ? "0.5.0" : "0.0.0";
+import path20 from "node:path";
+var VERSION3 = true ? "0.6.1" : "0.0.0";
 async function json(r) {
   try {
     return await r.json();
@@ -5191,7 +5802,7 @@ async function discover(url, f) {
 }
 async function pair(o) {
   const f = o.fetch ?? fetch;
-  const sleep2 = o.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const sleep3 = o.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const { control, rpId, open } = await discover(o.url, f);
   if (!o.token && !open)
     throw new Error(
@@ -5201,7 +5812,7 @@ async function pair(o) {
   const cfg = readControl(o.env) ?? { name: o.name, folders: [], mode: o.mode, receivers: [] };
   cfg.name = o.name || cfg.name;
   cfg.mode = o.mode;
-  cfg.folders = [.../* @__PURE__ */ new Set([...cfg.folders, ...o.folders.map((d) => path18.resolve(d))])];
+  cfg.folders = [.../* @__PURE__ */ new Set([...cfg.folders, ...o.folders.map((d) => path20.resolve(d))])];
   const existing = cfg.receivers.find((r) => r.control === control);
   const auth = { authorization: `Bearer ${o.token ?? pollKey}`, "content-type": "application/json" };
   const started = await f(`${control}/pair`, {
@@ -5243,7 +5854,7 @@ async function pair(o) {
   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);
+    await sleep3(2e3);
     const r = await f(`${control}/pair?code=${encodeURIComponent(code)}`, { headers: auth }).catch(() => null);
     if (!r) continue;
     if (r.status === 404) throw new Error("the receiver lost the pairing; run `sessionpipe control pair` again");
@@ -5301,8 +5912,8 @@ function removeKey(id, env) {
   writeControl(cfg, env);
   return n;
 }
-var LABEL = "org.sessionpipe.control";
-var UNIT = "sessionpipe-control.service";
+var LABEL2 = "org.sessionpipe.control";
+var UNIT2 = "sessionpipe-control.service";
 function serviceFiles(o) {
   const home = o.home ?? os6.homedir();
   const xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -5310,14 +5921,15 @@ function serviceFiles(o) {
 <!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>Label</key><string>${LABEL2}</string>
   <key>ProgramArguments</key>
   <array><string>${xml(o.node)}</string><string>${xml(o.cli)}</string><string>control</string><string>run</string></array>
+  <key>EnvironmentVariables</key><dict><key>SESSIONPIPE_SERVICE</key><string>launchd</string></dict>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
   <key>ProcessType</key><string>Background</string>
-  <key>StandardOutPath</key><string>${xml(path18.join(o.logDir, "daemon.log"))}</string>
-  <key>StandardErrorPath</key><string>${xml(path18.join(o.logDir, "daemon.log"))}</string>
+  <key>StandardOutPath</key><string>${xml(path20.join(o.logDir, "daemon.log"))}</string>
+  <key>StandardErrorPath</key><string>${xml(path20.join(o.logDir, "daemon.log"))}</string>
 </dict>
 </plist>
 `;
@@ -5328,15 +5940,17 @@ After=network-online.target
 
 [Service]
 ExecStart=${q(o.node)} ${q(o.cli)} control run
+Environment=SESSIONPIPE_SERVICE=systemd
 Restart=on-failure
+RestartForceExitStatus=75
 RestartSec=5
 
 [Install]
 WantedBy=default.target
 `;
   return {
-    plist: { file: path18.join(home, "Library", "LaunchAgents", `${LABEL}.plist`), body: plist },
-    unit: { file: path18.join(home, ".config", "systemd", "user", UNIT), body: unit }
+    plist: { file: path20.join(home, "Library", "LaunchAgents", `${LABEL2}.plist`), body: plist },
+    unit: { file: path20.join(home, ".config", "systemd", "user", UNIT2), body: unit }
   };
 }
 var execQuiet = (cmd2, args2) => execFileSync6(cmd2, args2, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 });
@@ -5366,33 +5980,33 @@ function installService(o) {
   const run = o.exec ?? execQuiet;
   const platform = o.platform ?? process.platform;
   if (platform === "darwin") {
-    mkdirSync10(path18.dirname(f.plist.file), { recursive: true });
+    mkdirSync10(path20.dirname(f.plist.file), { recursive: true });
     writeFileSync8(f.plist.file, f.plist.body);
     const uid = String(process.getuid?.() ?? "");
     for (const d of ["gui", "user"])
       try {
-        run("launchctl", ["bootout", `${d}/${uid}/${LABEL}`]);
+        run("launchctl", ["bootout", `${d}/${uid}/${LABEL2}`]);
       } catch {
       }
     try {
       run("launchctl", ["bootstrap", `gui/${uid}`, f.plist.file]);
-      return `launchd agent ${LABEL} (log: ${path18.join(logDir, "daemon.log")})`;
+      return `launchd agent ${LABEL2} (log: ${path20.join(logDir, "daemon.log")})`;
     } catch {
     }
     run("launchctl", ["bootstrap", `user/${uid}`, f.plist.file]);
-    return `launchd agent ${LABEL} in the background domain, since nobody is logged in at this Mac's screen; after a restart it starts again when someone logs in there (log: ${path18.join(logDir, "daemon.log")})`;
+    return `launchd agent ${LABEL2} in the background domain, since nobody is logged in at this Mac's screen; after a restart it starts again when someone logs in there (log: ${path20.join(logDir, "daemon.log")})`;
   }
   if (platform === "linux") {
-    mkdirSync10(path18.dirname(f.unit.file), { recursive: true });
+    mkdirSync10(path20.dirname(f.unit.file), { recursive: true });
     writeFileSync8(f.unit.file, f.unit.body);
     try {
       run("systemctl", ["--user", "daemon-reload"]);
-      run("systemctl", ["--user", "enable", "--now", UNIT]);
+      run("systemctl", ["--user", "enable", "--now", UNIT2]);
     } catch {
       return `wrote ${f.unit.file}, but systemd --user isn't reachable here; run \`sessionpipe control run\` yourself (tmux, screen)`;
     }
     const linger = ensureLinger(os6.userInfo().username, run);
-    return `systemd user unit ${UNIT}; ${linger.note} (journalctl --user -u ${UNIT})`;
+    return `systemd user unit ${UNIT2}; ${linger.note} (journalctl --user -u ${UNIT2})`;
   }
   return "no service manager for this platform yet; run `sessionpipe control run` yourself";
 }
@@ -5404,13 +6018,13 @@ function uninstallService(env) {
     } catch {
     }
   };
-  if (process.platform === "darwin" && existsSync11(f.plist.file)) {
-    run("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/${LABEL}`]);
-    run("launchctl", ["bootout", `user/${process.getuid?.() ?? ""}/${LABEL}`]);
+  if (process.platform === "darwin" && existsSync12(f.plist.file)) {
+    run("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/${LABEL2}`]);
+    run("launchctl", ["bootout", `user/${process.getuid?.() ?? ""}/${LABEL2}`]);
     unlinkSync6(f.plist.file);
   }
-  if (process.platform === "linux" && existsSync11(f.unit.file)) {
-    run("systemctl", ["--user", "disable", "--now", UNIT]);
+  if (process.platform === "linux" && existsSync12(f.unit.file)) {
+    run("systemctl", ["--user", "disable", "--now", UNIT2]);
     unlinkSync6(f.unit.file);
     run("systemctl", ["--user", "daemon-reload"]);
   }
@@ -5613,9 +6227,9 @@ ${CONTROL_HELP}`);
       out2(
         `  Mode: ${c.mode} (${c.mode === "safe" ? "nothing that needs approval runs unattended" : "Claude Code's auto mode"})`
       );
-      let cli = path19.join(distDir2, "cli.js");
+      let cli = path21.join(distDir2, "cli.js");
       try {
-        cli = realpathSync4(cli);
+        cli = realpathSync5(cli);
       } catch {
       }
       if (argv.includes("--no-service"))
@@ -5665,12 +6279,15 @@ ${MODE_TEXT}`);
       return out2(JSON.stringify(r.status, null, 2));
     }
     case "run":
-      return runDaemon(out2);
+      return runDaemon(out2, distDir2);
     default:
       return out2(CONTROL_HELP);
   }
 }
-async function runDaemon(out2) {
+function enabledHarnesses(harnesses) {
+  return Object.entries(harnesses).filter(([, h]) => h?.enabled !== false).map(([n]) => n).filter((n) => /^[a-z][a-z0-9-]{0,40}$/.test(n));
+}
+async function runDaemon(out2, distDir2) {
   const cfg = readControl();
   if (!cfg?.receivers.length) {
     out2("control isn't paired on this machine; nothing to do (`sessionpipe control pair <receiver>`)");
@@ -5681,11 +6298,12 @@ async function runDaemon(out2) {
   const claudeNow = () => {
     const bin = findClaude2();
     if (!bin) return null;
-    const sig = `${bin}:${existsSync12(bin) ? realpathSync4(bin) : ""}`;
+    const sig = `${bin}:${existsSync13(bin) ? realpathSync5(bin) : ""}`;
     if (claude?.sig !== sig) claude = { bin, caps: detectCaps2(bin), sig };
     return claude;
   };
   const sdk = await loadSdk({ claudeBin: findClaude2(), env: process.env, log: log2 });
+  let updater = null;
   const d = new ControlDaemon(cfg, controlState(), socketPath(stateDir()), {
     now: Date.now,
     fetch,
@@ -5698,9 +6316,19 @@ async function runDaemon(out2) {
       const c = claudeNow();
       return c ? claudeLogin2(c.bin, configDir) : { loggedIn: null };
     },
-    token: (r) => r.token_in ? secretGet(r.token_in, controlAccount(r.machine)) : null
+    token: (r) => r.token_in ? secretGet(r.token_in, controlAccount(r.machine)) : null,
+    onRestart: () => updater?.restartWhenIdle() ?? false,
+    updateStatus: () => updater ? updater.record() : null,
+    // Two daemons started at once and the other one holds the socket: leave it to it.
+    onLostSocket: () => process.exit(0)
   });
-  await d.start();
+  try {
+    await d.start();
+  } catch (e) {
+    if (!(e instanceof DaemonRunning)) throw e;
+    log2(`${e.message}; this one exits`);
+    process.exit(0);
+  }
   const drain = setInterval(() => {
     const sinks = readConfig().sinks.filter((s) => s.token_in && !s.paused);
     if (sinks.length) void flush(stateDir(), sinks, new Outbox(stateDir())).catch(() => {
@@ -5711,12 +6339,50 @@ async function runDaemon(out2) {
     const next = readControl();
     if (next) d.reload(next);
   });
+  let stopping = false;
   const bye = async () => {
+    if (stopping) return;
+    stopping = true;
+    updater?.stop();
     await d.stop();
     process.exit(0);
   };
-  process.on("SIGTERM", bye);
-  process.on("SIGINT", bye);
+  const signals = ["SIGTERM", "SIGINT"];
+  for (const sig of signals) process.on(sig, bye);
+  const restart = async (_from, to) => {
+    stopping = true;
+    updater?.stop();
+    clearInterval(drain);
+    unwatchFile(controlFile());
+    for (const sig of signals) process.off(sig, bye);
+    await d.stop();
+    const via = restartVia({ env: process.env, platform: process.platform, pid: process.pid, ppid: process.ppid });
+    if (via) {
+      log2(`exiting ${UPDATE_EXIT} so ${via === "supervisor" ? "the supervising sessionpipe" : via} starts ${to}`);
+      process.exit(UPDATE_EXIT);
+    }
+    let cli = path21.join(distDir2, "cli.js");
+    try {
+      cli = realpathSync5(cli);
+    } catch {
+    }
+    log2(`no service manager restarts this daemon: pid ${process.pid} now runs ${to} as its child`);
+    const sup = supervise({ node: process.execPath, args: [cli, "control", "run"], env: process.env, log: log2 });
+    for (const sig of [...signals, "SIGHUP"]) process.on(sig, () => sup.stop(sig));
+  };
+  updater = new AutoUpdater({
+    now: Date.now,
+    log: log2,
+    version: VERSION,
+    file: updateFile(),
+    off: () => autoUpdateOff({ env: process.env, config: readConfig(), distDir: distDir2 }),
+    latest: () => latestVersion(fetch),
+    installed: () => installedVersion({ node: process.execPath, distDir: distDir2 }),
+    install: (v) => installVersion(v, { node: process.execPath, distDir: distDir2, harnesses: enabledHarnesses(readConfig().harnesses) }),
+    daemon: d,
+    restart
+  });
+  updater.start();
 }
 async function waitMain(argv, out2) {
   const i = argv.indexOf("--session");
@@ -5740,16 +6406,16 @@ function adoptSinkToken(url, token, tier, file) {
 }
 
 // src/launcher.ts
-import { accessSync as accessSync2, chmodSync as chmodSync3, constants as constants2, mkdirSync as mkdirSync11, readFileSync as readFileSync11, renameSync as renameSync4, rmSync, writeFileSync as writeFileSync9 } from "node:fs";
+import { accessSync as accessSync3, chmodSync as chmodSync3, constants as constants3, mkdirSync as mkdirSync11, readFileSync as readFileSync12, renameSync as renameSync4, rmSync, writeFileSync as writeFileSync9 } from "node:fs";
 import os8 from "node:os";
-import path20 from "node:path";
+import path22 from "node:path";
 var LAUNCHER = "sessionpipe-hook";
 var COPIED = ["worker.js", "hook.js"];
 function dataDir(env = process.env) {
-  if (env.SESSIONPIPE_DATA) return path20.resolve(env.SESSIONPIPE_DATA);
-  return path20.join(env.XDG_DATA_HOME || path20.join(os8.homedir(), ".local", "share"), "sessionpipe");
+  if (env.SESSIONPIPE_DATA) return path22.resolve(env.SESSIONPIPE_DATA);
+  return path22.join(env.XDG_DATA_HOME || path22.join(os8.homedir(), ".local", "share"), "sessionpipe");
 }
-var launcherPath = (env = process.env) => path20.join(dataDir(env), LAUNCHER);
+var launcherPath = (env = process.env) => path22.join(dataDir(env), LAUNCHER);
 var usesLauncher = (platform = process.platform) => platform !== "win32";
 var sq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
 function launcherScript(node, hook, version) {
@@ -5758,13 +6424,13 @@ function launcherScript(node, hook, version) {
 # this; it runs hook.js beside it with the node sessionpipe was installed with, or with
 # any node on PATH once that one is gone (an nvm uninstall, a Homebrew upgrade).
 n=${sq(node)}
-[ -x "$n" ] || n=$(command -v node) || { [ "$1" = antigravity ] && echo '{}'; exit 0; }
+[ -x "$n" ] || n=$(command -v node) || { [ "$1" = antigravity ] && if [ "$2" = PreToolUse ]; then echo ${sq(AG_STALE_PRETOOL.trim())}; else echo '{}'; fi; exit 0; }
 exec "$n" ${sq(hook)} "$@"
 `;
 }
 function writeIfChanged(file, body, mode) {
   try {
-    const cur = readFileSync11(file);
+    const cur = readFileSync12(file);
     if (cur.equals(Buffer.isBuffer(body) ? body : Buffer.from(body))) {
       chmodSync3(file, mode);
       return false;
@@ -5782,19 +6448,19 @@ function installLauncher(o) {
   mkdirSync11(dir, { recursive: true, mode: 493 });
   let changed = false;
   for (const f of COPIED)
-    changed = writeIfChanged(path20.join(dir, f), readFileSync11(path20.join(o.distDir, f)), 420) || changed;
-  const launcher = path20.join(dir, LAUNCHER);
-  changed = writeIfChanged(launcher, launcherScript(o.node, path20.join(dir, "hook.js"), o.version), 493) || changed;
+    changed = writeIfChanged(path22.join(dir, f), readFileSync12(path22.join(o.distDir, f)), 420) || changed;
+  const launcher = path22.join(dir, LAUNCHER);
+  changed = writeIfChanged(launcher, launcherScript(o.node, path22.join(dir, "hook.js"), o.version), 493) || changed;
   return { launcher, changed };
 }
 function removeLauncher(env = process.env) {
-  for (const f of [LAUNCHER, ...COPIED]) rmSync(path20.join(dataDir(env), f), { force: true });
+  for (const f of [LAUNCHER, ...COPIED]) rmSync(path22.join(dataDir(env), f), { force: true });
 }
 function launcherState(version, env = process.env) {
   const file = launcherPath(env);
   let text = "";
   try {
-    text = readFileSync11(file, "utf8");
+    text = readFileSync12(file, "utf8");
   } catch {
     return {
       file,
@@ -5810,7 +6476,7 @@ function launcherState(version, env = process.env) {
   let nodeOk = false;
   try {
     if (node) {
-      accessSync2(node, constants2.X_OK);
+      accessSync3(node, constants3.X_OK);
       nodeOk = true;
     }
   } catch {
@@ -5822,7 +6488,7 @@ function launcherState(version, env = process.env) {
     );
   for (const f of COPIED)
     try {
-      accessSync2(path20.join(path20.dirname(file), f), constants2.R_OK);
+      accessSync3(path22.join(path22.dirname(file), f), constants3.R_OK);
     } catch {
       problems.push(`${f} is missing beside the hook launcher; run \`sessionpipe install\` again`);
     }
@@ -5849,16 +6515,16 @@ var out = (s = "") => {
 `);
 };
 var state = stateDir();
-var distDir = path21.dirname(fileURLToPath(import.meta.url));
+var distDir = path23.dirname(fileURLToPath(import.meta.url));
 function hookCommand() {
   if (usesLauncher()) {
     const l = launcherPath();
     return (a) => ({ argv: [l, ...a], command: `${JSON.stringify(l)} ${a.join(" ")}` });
   }
   const node = stableNode(process.execPath);
-  let script = path21.join(distDir, "hook.js");
+  let script = path23.join(distDir, "hook.js");
   try {
-    script = realpathSync5(script);
+    script = realpathSync6(script);
   } catch {
   }
   return (a) => ({
@@ -5928,7 +6594,7 @@ function help() {
   sessionpipe status | doctor [--json]
   sessionpipe tail [--session ID] [--tier N] [--harness NAME]
   sessionpipe backfill [--days 30] | forget <harness> <session> | replay --sink NAME
-  sessionpipe update
+  sessionpipe update [off|on]       (install the latest now; off/on: the daemon's daily update)
 ${CONTROL_HELP}
 
 Docs: https://sessionpipe.org \xB7 nothing leaves this machine until you add a sink.`);
@@ -6090,7 +6756,7 @@ async function connect() {
     out(`  \u2713 Keys: in ${storeLabel(store)}${kept.length ? ` (left in the file: ${kept.join(", ")})` : ""}`);
   } else
     out(
-      `  Keys: in ${tilde(path21.dirname(configFile()))} at 0600 \u2014 no unlocked keychain in this session${process.env.SSH_CONNECTION ? " (an ssh shell)" : ""}`
+      `  Keys: in ${tilde(path23.dirname(configFile()))} at 0600 \u2014 no unlocked keychain in this session${process.env.SSH_CONNECTION ? " (an ssh shell)" : ""}`
     );
   if (rows.length) queueBackfill(rows, 30, readConfig());
   out("");
@@ -6362,6 +7028,7 @@ function status() {
       `  sink      ${s.name.padEnd(16)} tier ${Math.min(s.tier, s.max_tier ?? 3)}  ${s.paused ? `PAUSED ${s.paused}` : pending ? `${pending} session file(s) with undelivered events` : "up to date"}`
     );
   }
+  out(`  update:   ${updateLine(updateState(cfg), Date.now())}`);
   const t = timing();
   if (t)
     out(
@@ -6375,12 +7042,12 @@ function status() {
   }
 }
 function hookWall(runs = 8) {
-  const hook = path21.join(distDir, "hook.js");
-  const tmp = mkdtempSync(path21.join(os9.tmpdir(), "sessionpipe-doctor-"));
+  const hook = path23.join(distDir, "hook.js");
+  const tmp = mkdtempSync(path23.join(os9.tmpdir(), "sessionpipe-doctor-"));
   const env = {
     ...process.env,
     SESSIONPIPE_STATE: tmp,
-    SESSIONPIPE_CONFIG: path21.join(tmp, "config.json"),
+    SESSIONPIPE_CONFIG: path23.join(tmp, "config.json"),
     SESSIONPIPE_NO_WORKER: "1"
   };
   const input = JSON.stringify({
@@ -6408,7 +7075,7 @@ function hookWall(runs = 8) {
 }
 function timing() {
   try {
-    const lines = readFileSync12(path21.join(state, "timing.jsonl"), "utf8").trim().split("\n").slice(-100);
+    const lines = readFileSync13(path23.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);
@@ -6431,9 +7098,15 @@ async function doctor() {
     sinks: [],
     timing: timing(),
     hook_wall_ms: hookWall(),
+    update: updateState(cfg),
     warnings: []
   };
   const warnings = report.warnings;
+  const upd = report.update;
+  if (upd.failed)
+    warnings.push(
+      `the control daemon couldn't install sessionpipe ${upd.failed.version}: ${upd.failed.error}. It tries again tomorrow; \`sessionpipe update\` tries now.`
+    );
   if (usesLauncher()) {
     const l = launcherState(VERSION);
     report.launcher = { file: tilde(l.file), node: l.node, node_ok: l.nodeOk, version: l.version };
@@ -6543,6 +7216,7 @@ async function doctor() {
     out(
       `  claude ${a.dir.padEnd(26)} ${a.signed_in === true ? "signed in" : a.signed_in === false ? "NOT signed in from here" : "can't tell"}`
     );
+  out(`  update ${updateLine(upd, Date.now())}`);
   const t = report.timing;
   out(
     w ? `  hook wall clock (what the harness waits): p50 ${w.p50} ms \xB7 p95 ${w.p95} ms over ${w.n} spawns` : "  hook wall clock: could not spawn dist/hook.js"
@@ -6622,37 +7296,67 @@ async function tail() {
 async function workerFromArgv() {
   const f = args[1];
   if (!f) return;
-  const job = JSON.parse(readFileSync12(f, "utf8"));
+  const job = JSON.parse(readFileSync13(f, "utf8"));
   try {
     unlinkSync7(f);
   } catch {
   }
   await runJob(job);
 }
+function updateState(cfg) {
+  return updateSummary({
+    // The shell's own SESSIONPIPE_NO_UPDATE_CHECK says nothing about the daemon's
+    // environment; the daemon records that one itself.
+    off: autoUpdateOff({ env: {}, config: cfg, distDir }),
+    paired: pairedCount() > 0,
+    rec: readUpdate(updateFile())
+  });
+}
 async function update() {
+  const sub = args[1];
+  if (sub === "off" || sub === "on") {
+    const cfg = readConfig();
+    cfg.update_check = sub === "on";
+    writeConfig(cfg);
+    return out(
+      sub === "off" ? "  \u2713 The control daemon no longer checks npm or updates itself. `sessionpipe update` still updates by hand; `sessionpipe update on` undoes this." : "  \u2713 The control daemon checks npm once a day and installs a new release when it's idle."
+    );
+  }
   if (process.env.SESSIONPIPE_NO_UPDATE_CHECK) return out("  update check is off (SESSIONPIPE_NO_UPDATE_CHECK)");
+  let latest;
   try {
-    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`);
-    const prefix = prefixOf(distDir);
-    execFileSync7("npm", ["install", "-g", `sessionpipe@${j.version}`, ...prefix ? ["--prefix", prefix] : []], {
-      stdio: "inherit"
-    });
-    out("  re-arming hooks\u2026");
-    const bin = prefix ? path21.join(prefix, "bin", "sessionpipe") : "sessionpipe";
-    const p = spawn2(bin, ["install", "--backfill", "0"], { stdio: "inherit" });
-    await new Promise((r2) => p.on("exit", r2));
+    latest = await latestVersion();
   } catch (e) {
-    out(`  couldn't check npm: ${e.message}`);
+    return out(`  couldn't check npm: ${e.message}`);
   }
-}
-function prefixOf(p) {
-  const re = process.platform === "win32" ? /^(.*?)[\\/]node_modules[\\/]sessionpipe[\\/]/ : /^(.*)\/lib\/node_modules\/sessionpipe\//;
-  const m = re.exec(p);
-  return m?.[1] ?? null;
+  if (!isNewer(latest, VERSION)) return out(`  sessionpipe ${VERSION} is current (npm latest: ${latest})`);
+  const prefix = globalPrefix(distDir);
+  if (!prefix)
+    return out(
+      `  ${latest} is available (you run ${VERSION}), but this copy isn't a global npm install (npx, a checkout or a dev build): \`npm install -g sessionpipe@${latest}\` installs one.`
+    );
+  out(`  ${latest} is available (you run ${VERSION}); installing into ${tilde(prefix)}\u2026`);
+  const r = await installVersion(latest, {
+    node: process.execPath,
+    distDir,
+    harnesses: enabledHarnesses(readConfig().harnesses)
+  });
+  if (!r.ok) {
+    process.exitCode = 1;
+    return out(`  \u2717 ${r.error}`);
+  }
+  out(`  \u2713 sessionpipe ${latest} installed in ${(r.ms / 1e3).toFixed(1)} s; ${r.hooks}`);
+  const sock = socketPath(state);
+  const st = await ask(sock, { op: "status" }, 2e3);
+  if (st?.op !== "status") return;
+  const running = st.status.version ?? "?";
+  if (running === latest) return;
+  const r2 = await ask(sock, { op: "restart" }, 2e3);
+  if (r2?.op === "ok") out(`  The control daemon (${running}) restarts onto ${latest} as soon as nothing is in hand.`);
+  else
+    out(
+      `  The control daemon still runs ${running} and can't restart itself: ${process.platform === "darwin" ? `\`launchctl kickstart -k gui/${process.getuid?.() ?? "$(id -u)"}/org.sessionpipe.control\`` : process.platform === "linux" ? "`systemctl --user restart sessionpipe-control.service`" : "stop `sessionpipe control run` and start it again"} moves it (a run in progress stops).`
+    );
 }
 main().catch((e) => {
   process.stderr.write(`sessionpipe: ${e.message}