@primusclaw/connector 0.1.5 → 0.1.6

package/dist/cli.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 
+// src/cli.ts
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
 // src/commands.ts
-import fs18 from "node:fs";
-import os7 from "node:os";
-import path19 from "node:path";
+import fs19 from "node:fs";
+import os9 from "node:os";
+import path21 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -563,11 +566,11 @@ var RevokedError = class extends Error {
   }
 };
 var HttpError = class extends Error {
-  constructor(status2, code, path20) {
-    super(`${path20} answered ${status2} ${code}`);
+  constructor(status2, code, path22) {
+    super(`${path22} answered ${status2} ${code}`);
     this.status = status2;
     this.code = code;
-    this.path = path20;
+    this.path = path22;
   }
   status;
   code;
@@ -591,8 +594,8 @@ var ClawClient = class {
       ...extra
     };
   }
-  async send(method, path20, body, signal) {
-    const url = this.o.server + path20;
+  async send(method, path22, body, signal) {
+    const url = this.o.server + path22;
     for (let attempt = 0; ; attempt++) {
       const headers = await this.headers(body === void 0 ? {} : { "content-type": "application/json" });
       let res;
@@ -604,7 +607,7 @@ var ClawClient = class {
           signal: signal ?? AbortSignal.timeout(this.o.requestTimeoutMs ?? 2e4)
         });
       } catch (e) {
-        throw new TransportError(`${method} ${path20}: ${errMessage(e)}`);
+        throw new TransportError(`${method} ${path22}: ${errMessage(e)}`);
       }
       if (res.status !== 401) return res;
       const err = await errorCode(res);
@@ -613,12 +616,12 @@ var ClawClient = class {
         this.o.tokens.invalidate();
         continue;
       }
-      throw new HttpError(401, err, path20);
+      throw new HttpError(401, err, path22);
     }
   }
-  async json(method, path20, body) {
-    const res = await this.send(method, path20, body);
-    if (!res.ok) throw new HttpError(res.status, await errorCode(res), path20);
+  async json(method, path22, body) {
+    const res = await this.send(method, path22, body);
+    if (!res.ok) throw new HttpError(res.status, await errorCode(res), path22);
     const parsed = await res.json().catch(() => null);
     return isObject(parsed) && isObject(parsed.data) ? parsed.data : {};
   }
@@ -667,21 +670,21 @@ var ClawClient = class {
     };
     try {
       arm();
-      const path20 = `/v1/remote-agents/connectors/${cid}/commands`;
+      const path22 = `/v1/remote-agents/connectors/${cid}/commands`;
       const headers = await this.headers({ accept: "text/event-stream", ...opts.lastEventId ? { "last-event-id": String(opts.lastEventId) } : {} });
       let res;
       try {
-        res = await this.f(this.o.server + path20, { headers, signal: stop.signal });
+        res = await this.f(this.o.server + path22, { headers, signal: stop.signal });
       } catch (e) {
-        throw new TransportError(timedOut ? `no response for ${opts.watchdogMs} ms` : `GET ${path20}: ${errMessage(e)}`);
+        throw new TransportError(timedOut ? `no response for ${opts.watchdogMs} ms` : `GET ${path22}: ${errMessage(e)}`);
       }
       if (res.status === 401) {
         const err = await errorCode(res);
         if (err === "revoked") throw new RevokedError();
         this.o.tokens.invalidate();
-        throw new HttpError(401, err, path20);
+        throw new HttpError(401, err, path22);
       }
-      if (!res.ok || !res.body) throw new HttpError(res.status, await errorCode(res), path20);
+      if (!res.ok || !res.body) throw new HttpError(res.status, await errorCode(res), path22);
       try {
         for await (const frame of readSse(res.body, arm)) yield frame;
       } catch (e) {
@@ -701,59 +704,10 @@ async function errorCode(res) {
 }
 
 // src/config.ts
-import fs5 from "node:fs";
-import os from "node:os";
-import path5 from "node:path";
-import { parse as parseToml } from "smol-toml";
-
-// src/roots.ts
 import fs4 from "node:fs";
+import os from "node:os";
 import path4 from "node:path";
-function realRoot(root) {
-  try {
-    return fs4.realpathSync.native(root);
-  } catch {
-    return null;
-  }
-}
-var inside = (child, root) => child === root || child.startsWith(root.endsWith(path4.sep) ? root : root + path4.sep);
-function checkCwd(cwd, roots) {
-  if (typeof cwd !== "string" || cwd === "" || cwd.includes("\0")) return { ok: false, reason: "invalid_cwd" };
-  if (!path4.isAbsolute(cwd)) return { ok: false, reason: "cwd_not_absolute" };
-  let real;
-  try {
-    real = fs4.realpathSync.native(cwd);
-  } catch {
-    return { ok: false, reason: "cwd_not_found" };
-  }
-  try {
-    if (!fs4.statSync(real).isDirectory()) return { ok: false, reason: "cwd_not_directory" };
-  } catch {
-    return { ok: false, reason: "cwd_not_found" };
-  }
-  for (const root of roots) {
-    const r = realRoot(root);
-    if (r && inside(real, r)) return { ok: true, real };
-  }
-  return { ok: false, reason: "cwd_outside_roots" };
-}
-function relativeInside(p, cwd) {
-  const abs = path4.resolve(cwd, p);
-  let real;
-  try {
-    real = fs4.realpathSync.native(abs);
-  } catch {
-    try {
-      real = path4.join(fs4.realpathSync.native(path4.dirname(abs)), path4.basename(abs));
-    } catch {
-      return null;
-    }
-  }
-  if (!inside(real, cwd)) return null;
-  return path4.relative(cwd, real).split(path4.sep).join("/");
-}
-
-// src/config.ts
+import { parse as parseToml } from "smol-toml";
 var ConfigError = class extends Error {
   constructor(problems) {
     super(`agents.toml: ${problems.join("; ")}`);
@@ -769,7 +723,8 @@ var PRESETS = {
     args: ["-y", "@agentclientprotocol/claude-agent-acp@0.99.0"],
     askMode: "default",
     safeModes: ["default", "plan"],
-    unattended: { askMode: "bypassPermissions" }
+    unattended: { askMode: "bypassPermissions" },
+    readOnly: ["plan"]
   },
   // Existing Claude Code sessions, taken over from the phone. The kind is the opaque label a chat client picks an icon
   // from; it says what the entry is for, not which product serves it. Same adapter and same ask mode as `claude`.
@@ -781,7 +736,8 @@ var PRESETS = {
     askMode: "default",
     safeModes: ["default", "plan"],
     attach: true,
-    unattended: { askMode: "bypassPermissions" }
+    unattended: { askMode: "bypassPermissions" },
+    readOnly: ["plan"]
   },
   codex: {
     kind: "codex",
@@ -799,7 +755,8 @@ var PRESETS = {
     args: ["acp"],
     askMode: "ask",
     safeModes: ["ask", "plan"],
-    unattended: { askMode: "agent", args: ["--force", "acp"] }
+    unattended: { askMode: "agent", args: ["--force", "acp"] },
+    readOnly: ["ask", "plan"]
   }
 };
 var ID_RE = /^[A-Za-z0-9._-]{1,64}$/;
@@ -813,7 +770,7 @@ var strList = (v, what, problems) => {
   }
   return v;
 };
-var expandHome = (p) => p === "~" ? os.homedir() : p.startsWith("~/") ? path5.join(os.homedir(), p.slice(2)) : p;
+var expandHome = (p) => p === "~" ? os.homedir() : p.startsWith("~/") ? path4.join(os.homedir(), p.slice(2)) : p;
 function parseConfig(text, defaults = {}) {
   const problems = [];
   let doc;
@@ -880,11 +837,10 @@ function parseConfig(text, defaults = {}) {
       } else asking.add(askMode);
     }
     if (asking.has(askMode) && !safeModes.includes(askMode)) safeModes.push(askMode);
-    const roots = strList(raw.roots, `${label}.roots`, problems).map((r) => path5.resolve(expandHome(r)));
+    const roots = strList(raw.roots, `${label}.roots`, problems).map((r) => path4.resolve(expandHome(r)));
     if (roots.length === 0) problems.push(`${label}: roots is required (an agent with no allowed directory is never offered)`);
     for (const r of roots) {
-      if (r === path5.parse(r).root) problems.push(`${label}: a root may not be the filesystem root`);
-      else if (!realRoot(r)) problems.push(`${label}: root ${r} does not exist`);
+      if (r === path4.parse(r).root) problems.push(`${label}: a root may not be the filesystem root`);
     }
     const env = {};
     if (raw.env !== void 0) {
@@ -920,6 +876,8 @@ function parseConfig(text, defaults = {}) {
       askingModes: [...asking],
       allowUnsafeModes: allowUnsafe,
       unattended: !asking.has(askMode),
+      // What the preset measured; a custom agent declares nothing here.
+      readOnlyModes: [...preset?.readOnly ?? []],
       autoAllow: [...globalAllow, ...own],
       attach
     });
@@ -931,7 +889,7 @@ function parseConfig(text, defaults = {}) {
 var EXISTING_SESSIONS_SUFFIX = "-sessions";
 function existingSessionAgents(rawAgents, agents, problems) {
   const out = [];
-  const configDir = (a) => path5.resolve(expandHome(a.env.CLAUDE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? path5.join(os.homedir(), ".claude")));
+  const configDir = (a) => path4.resolve(expandHome(a.env.CLAUDE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? path4.join(os.homedir(), ".claude")));
   const ids = new Set(agents.map((a) => a.id));
   for (const raw of rawAgents) {
     if (!isObject(raw) || typeof raw.id !== "string") continue;
@@ -979,7 +937,7 @@ function parseAutoAllow(raw, at, problems) {
     if (!isObject(r) || typeof r.kind !== "string" || typeof r.path_glob !== "string" || !r.kind || !r.path_glob) {
       return void problems.push(`${at}[${i}] needs a kind and a path_glob`);
     }
-    if (path5.isAbsolute(r.path_glob) || r.path_glob.split("/").includes("..")) {
+    if (path4.isAbsolute(r.path_glob) || r.path_glob.split("/").includes("..")) {
       return void problems.push(`${at}[${i}].path_glob must be relative to the working directory and may not contain ..`);
     }
     rules.push({ kind: r.kind, pathGlob: r.path_glob });
@@ -989,7 +947,7 @@ function parseAutoAllow(raw, at, problems) {
 function loadConfig(file, defaults = {}) {
   let text;
   try {
-    text = fs5.readFileSync(file, "utf8");
+    text = fs4.readFileSync(file, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") throw new ConfigError([`${file} does not exist; run "claw-connector init" to create one`]);
     throw e;
@@ -1003,7 +961,9 @@ function sampleApprovals(approval) {
   return { unattended: never.filter((id) => SAMPLE_ACTIVE.includes(id)), parked: never.filter((id) => !SAMPLE_ACTIVE.includes(id)) };
 }
 var SAMPLE_NOTES = {
-  "claude-attach": "# Take over a Claude Code conversation that already exists on this machine (exit it in the terminal first)."
+  "claude-attach": "# Take over a Claude Code conversation that already exists on this machine (exit it in the terminal first).",
+  cursor: `# Cursor asks before it runs a command but cannot ask before it edits a file, so with approval "ask" its sessions are
+# read-only (ask and plan modes): they answer questions and change nothing. To let it write code, set approval = "never".`
 };
 var NEVER_NOTE = `# No per-step approval: this agent runs like it does in your terminal. A phone session writes files and runs
 # commands without asking, and the phone shows it as unattended. To go back to asking, set it to "ask".`;
@@ -1036,8 +996,8 @@ ${SAMPLE_AGENTS.map(agent).join("\n\n")}
 var SAMPLE_CONFIG = sampleConfig();
 
 // src/credentials.ts
-import fs6 from "node:fs";
-import path6 from "node:path";
+import fs5 from "node:fs";
+import path5 from "node:path";
 var DEFAULT_CLIENT_ID = "claw-connector";
 var CONNECTOR_SCOPE = "claw.connector";
 var CredentialsError = class extends Error {
@@ -1052,20 +1012,20 @@ var TransientAuthError = class extends Error {
 function loadCredentials(file) {
   let fd;
   try {
-    fd = fs6.openSync(file, "r");
+    fd = fs5.openSync(file, "r");
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw e;
   }
   let text;
   try {
-    const st = fs6.fstatSync(fd);
+    const st = fs5.fstatSync(fd);
     if (process.platform !== "win32" && (st.mode & 63) !== 0) {
       throw new CredentialsError(`${file} is readable by other users (mode ${(st.mode & 511).toString(8)}); run: chmod 600 ${file}`);
     }
-    text = fs6.readFileSync(fd, "utf8");
+    text = fs5.readFileSync(fd, "utf8");
   } finally {
-    fs6.closeSync(fd);
+    fs5.closeSync(fd);
   }
   let raw;
   try {
@@ -1079,11 +1039,11 @@ function loadCredentials(file) {
   return raw;
 }
 function saveCredentials(file, creds) {
-  fs6.mkdirSync(path6.dirname(file), { recursive: true, mode: 448 });
+  fs5.mkdirSync(path5.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs6.writeFileSync(tmp, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
-  fs6.chmodSync(tmp, 384);
-  fs6.renameSync(tmp, file);
+  fs5.writeFileSync(tmp, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+  fs5.chmodSync(tmp, 384);
+  fs5.renameSync(tmp, file);
 }
 var KeyTokenProvider = class {
   constructor(key) {
@@ -1273,9 +1233,9 @@ async function deviceLogin(o) {
 }
 
 // src/claude-mode.ts
-import fs7 from "node:fs";
+import fs6 from "node:fs";
 import os2 from "node:os";
-import path7 from "node:path";
+import path6 from "node:path";
 function managedSettingsFile(platform = process.platform) {
   if (platform === "darwin") return "/Library/Application Support/ClaudeCode/managed-settings.json";
   if (platform === "win32") return "C:\\Program Files\\ClaudeCode\\managed-settings.json";
@@ -1284,7 +1244,7 @@ function managedSettingsFile(platform = process.platform) {
 function readSettings(file, unreadable) {
   let text;
   try {
-    text = fs7.readFileSync(file, "utf8");
+    text = fs6.readFileSync(file, "utf8");
   } catch (e) {
     if (e.code !== "ENOENT") unreadable.push(file);
     return null;
@@ -1320,9 +1280,9 @@ function bypassUnavailableWarnings(agents, env, opts = {}) {
       continue;
     }
     const home = merged.HOME?.trim() || os2.homedir();
-    const configDir = merged.CLAUDE_CONFIG_DIR?.trim() || path7.join(home, ".claude");
+    const configDir = merged.CLAUDE_CONFIG_DIR?.trim() || path6.join(home, ".claude");
     const unreadable = [];
-    for (const file of [path7.join(configDir, "settings.json"), opts.managedFile ?? managedSettingsFile()]) {
+    for (const file of [path6.join(configDir, "settings.json"), opts.managedFile ?? managedSettingsFile()]) {
       const s = readSettings(file, unreadable);
       const perms = s && isObject(s.permissions) ? s.permissions : null;
       if (perms?.disableBypassPermissionsMode === "disable") {
@@ -1339,21 +1299,21 @@ function claudeSessionMeta(a) {
 }
 
 // src/hooks.ts
-import fs9 from "node:fs";
-import path9 from "node:path";
-
-// src/terminals.ts
 import fs8 from "node:fs";
 import path8 from "node:path";
+
+// src/terminals.ts
+import fs7 from "node:fs";
+import path7 from "node:path";
 var SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var TERMINALS_DIR = "claw-connector-terminals";
-var terminalsDir = (configDir) => path8.join(configDir, TERMINALS_DIR);
+var terminalsDir = (configDir) => path7.join(configDir, TERMINALS_DIR);
 var UNREADABLE_GRACE_MS = 6e4;
 var MAX_STDIN = 1 << 20;
 function localPidDomain() {
   if (process.platform !== "linux") return null;
   try {
-    return `linux:${fs8.readFileSync("/etc/machine-id", "utf8").trim()}:${fs8.readlinkSync("/proc/self/ns/pid")}`;
+    return `linux:${fs7.readFileSync("/etc/machine-id", "utf8").trim()}:${fs7.readlinkSync("/proc/self/ns/pid")}`;
   } catch {
     return null;
   }
@@ -1384,7 +1344,7 @@ function readTerminals(configDir, localDomain, now = Date.now()) {
   const dir = terminalsDir(configDir);
   let names;
   try {
-    names = fs8.readdirSync(dir);
+    names = fs7.readdirSync(dir);
   } catch (e) {
     if (e.code === "ENOENT") return [];
     throw e;
@@ -1392,15 +1352,15 @@ function readTerminals(configDir, localDomain, now = Date.now()) {
   const out = [];
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const file = path8.join(dir, name);
+    const file = path7.join(dir, name);
     let doc;
     try {
-      doc = JSON.parse(fs8.readFileSync(file, "utf8"));
+      doc = JSON.parse(fs7.readFileSync(file, "utf8"));
     } catch (e) {
       if (e.code === "ENOENT") continue;
       let age = Infinity;
       try {
-        age = now - fs8.statSync(file).mtimeMs;
+        age = now - fs7.statSync(file).mtimeMs;
       } catch {
       }
       if (age < UNREADABLE_GRACE_MS) throw new Error(`${file} is unreadable (${e.message.split("\n")[0]})`);
@@ -1427,19 +1387,19 @@ var shellQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
 function hookCommand(node, script, arg, configDir) {
   return `${shellQuote(node)} ${shellQuote(script)} ${arg} --dir ${shellQuote(configDir)} ${MANAGED_MARK}`;
 }
-var settingsFile = (configDir) => path9.join(configDir, "settings.json");
+var settingsFile = (configDir) => path8.join(configDir, "settings.json");
 var isObject3 = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
 var isOurs = (h) => isObject3(h) && h.type === "command" && typeof h.command === "string" && h.command.endsWith(` ${MANAGED_MARK}`) && OURS_RE.test(h.command);
 function load(configDir) {
   const given = settingsFile(configDir);
   let file = given;
   try {
-    file = fs9.realpathSync(given);
+    file = fs8.realpathSync(given);
   } catch {
   }
   let text;
   try {
-    text = fs9.readFileSync(file, "utf8");
+    text = fs8.readFileSync(file, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") return { doc: {}, text: null, file };
     throw new HooksError(`cannot read ${given}: ${e.message}`);
@@ -1457,18 +1417,18 @@ function load(configDir) {
 function save(l, doc) {
   const indent = l.text?.match(/^([ \t]+)"/m)?.[1] ?? "  ";
   const body = JSON.stringify(doc, null, indent) + "\n";
-  fs9.mkdirSync(path9.dirname(l.file), { recursive: true, mode: 448 });
+  fs8.mkdirSync(path8.dirname(l.file), { recursive: true, mode: 448 });
   let mode = 384;
   try {
-    mode = fs9.statSync(l.file).mode & 511;
+    mode = fs8.statSync(l.file).mode & 511;
   } catch {
   }
   const tmp = `${l.file}.claw-connector.${process.pid}.tmp`;
-  fs9.writeFileSync(tmp, body, { mode });
+  fs8.writeFileSync(tmp, body, { mode });
   try {
-    fs9.renameSync(tmp, l.file);
+    fs8.renameSync(tmp, l.file);
   } catch (e) {
-    fs9.rmSync(tmp, { force: true });
+    fs8.rmSync(tmp, { force: true });
     throw e;
   }
 }
@@ -1548,7 +1508,7 @@ function uninstallHooks(configDir) {
     if (touchedAny && Object.keys(hooks).length === 0) delete doc.hooks;
   }
   if (touchedAny) save(l, doc);
-  fs9.rmSync(terminalsDir(configDir), { recursive: true, force: true });
+  fs8.rmSync(terminalsDir(configDir), { recursive: true, force: true });
   return { changed: touchedAny, file: l.file };
 }
 function hooksStatus(configDir) {
@@ -1571,7 +1531,7 @@ function hooksStatus(configDir) {
       const m = /^'((?:[^']|'\\'')*)' '((?:[^']|'\\'')*)' /.exec(String(x.command));
       if (!m) continue;
       for (const f of [m[1], m[2]].map((s) => s.replace(/'\\''/g, "'"))) {
-        if (!fs9.existsSync(f)) {
+        if (!fs8.existsSync(f)) {
           healthy = false;
           problem ??= `${f} (named by the ${h.event} hook) does not exist; run: claw-connector hooks install`;
         }
@@ -1582,7 +1542,7 @@ function hooksStatus(configDir) {
 }
 
 // src/connector.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/attach.ts
@@ -1594,10 +1554,11 @@ import { StringDecoder } from "node:string_decoder";
 
 // src/adapter.ts
 import { spawn as spawn2 } from "node:child_process";
-import fs10 from "node:fs";
-import path10 from "node:path";
+import fs9 from "node:fs";
+import path9 from "node:path";
 import { Readable, Writable } from "node:stream";
 import * as acp from "@agentclientprotocol/sdk";
+var AUTH_STATUS_METHOD = "_auth/status_update";
 var AdapterProcess = class _AdapterProcess {
   constructor(child, pid, registry) {
     this.child = child;
@@ -1608,13 +1569,18 @@ var AdapterProcess = class _AdapterProcess {
   pid;
   registry;
   caps = {};
+  /** The ways to sign in the adapter offered at `initialize` (`authMethods`), for `authenticate`. */
+  authMethods = [];
+  /** The last sign-in it reported, if it reports one; see {@link waitAuthStatus}. */
+  authStatus = null;
   exited = false;
   conn;
+  authWaiters = [];
   static async start(o) {
-    fs10.mkdirSync(path10.dirname(o.logFile), { recursive: true, mode: 448 });
+    fs9.mkdirSync(path9.dirname(o.logFile), { recursive: true, mode: 448 });
     const env = { ...process.env, ...o.cfg.env };
     const run2 = await adapterStore()?.launch(o.cfg, o.cwd, env) ?? { command: o.cfg.command, args: o.cfg.args, cwd: o.cwd };
-    const log = fs10.openSync(o.logFile, "a", 384);
+    const log = fs9.openSync(o.logFile, "a", 384);
     const child = spawn2(run2.command, run2.args, {
       cwd: run2.cwd,
       env,
@@ -1626,7 +1592,7 @@ var AdapterProcess = class _AdapterProcess {
       child.once("spawn", () => resolve());
       child.once("error", (e) => reject(new Error(`could not start ${run2.command}: ${errMessage(e)}`)));
     }).catch((e) => {
-      fs10.closeSync(log);
+      fs9.closeSync(log);
       throw e;
     });
     const pid = child.pid;
@@ -1636,7 +1602,7 @@ var AdapterProcess = class _AdapterProcess {
     const flushLine = (line) => {
       const text = redactText(line).text;
       try {
-        fs10.writeSync(log, text + "\n");
+        fs9.writeSync(log, text + "\n");
       } catch {
       }
       try {
@@ -1662,7 +1628,7 @@ var AdapterProcess = class _AdapterProcess {
         tail = "";
       }
       try {
-        fs10.closeSync(log);
+        fs9.closeSync(log);
       } catch {
       }
     });
@@ -1680,7 +1646,12 @@ var AdapterProcess = class _AdapterProcess {
       if (ctx.method.startsWith("cursor/")) return await o.hooks.onExtension(ctx.method, ctx.params ?? {});
       throw acp.RequestError.methodNotFound(ctx.method);
     }).onNotification("*", async (ctx) => {
-      o.hooks.onNotification(ctx.method, ctx.params ?? {});
+      const params = ctx.params ?? {};
+      if (ctx.method === AUTH_STATUS_METHOD && params.authStatus && typeof params.authStatus.kind === "string") {
+        a.authStatus = { kind: params.authStatus.kind, ...typeof params.authStatus.label === "string" ? { label: params.authStatus.label } : {} };
+        for (const w of a.authWaiters.splice(0)) w();
+      }
+      o.hooks.onNotification(ctx.method, params);
     });
     a.conn = app.connect(acp.ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout)));
     try {
@@ -1690,12 +1661,46 @@ var AdapterProcess = class _AdapterProcess {
         "initialize"
       );
       a.caps = init.agentCapabilities ?? {};
+      const methods2 = init.authMethods;
+      a.authMethods = Array.isArray(methods2) ? methods2.filter((m) => typeof m === "object" && m !== null) : [];
     } catch (e) {
       await a.kill();
       throw e;
     }
     return a;
   }
+  /** Whether the adapter says it reports its sign-in (`agentCapabilities._meta.authStatus`). */
+  get reportsAuth() {
+    const meta = this.caps._meta;
+    return !!meta && typeof meta === "object" && meta.authStatus !== void 0;
+  }
+  /**
+   * The sign-in the adapter reports, waiting up to `ms` for its first report (claude-agent-acp sends it shortly after
+   * `initialize`, and again for each new session). Null when it reports nothing in that time: not known, not "none".
+   */
+  async waitAuthStatus(ms) {
+    if (this.authStatus || !this.reportsAuth || ms <= 0) return this.authStatus;
+    await new Promise((resolve) => {
+      const done = () => {
+        clearTimeout(t);
+        const i = this.authWaiters.indexOf(done);
+        if (i >= 0) this.authWaiters.splice(i, 1);
+        resolve();
+      };
+      const t = setTimeout(done, ms);
+      t.unref?.();
+      this.authWaiters.push(done);
+    });
+    return this.authStatus;
+  }
+  /** The id of an `authenticate` method that signs in with an API key the adapter reads from its own environment. */
+  apiKeyMethod() {
+    for (const m of this.authMethods) {
+      const id = typeof m.id === "string" ? m.id : typeof m.methodId === "string" ? m.methodId : null;
+      if (id === "api-key") return id;
+    }
+    return null;
+  }
   request(method, params, timeoutMs = 6e4) {
     return withTimeout(this.conn.agent.request(method, params), timeoutMs, method);
   }
@@ -1771,6 +1776,155 @@ function isRemoteCommandType(v) {
   return typeof v === "string" && REMOTE_COMMAND_TYPES.includes(v);
 }
 
+// src/roots.ts
+import fs10 from "node:fs";
+import path10 from "node:path";
+function realRoot(root) {
+  try {
+    return fs10.realpathSync.native(root);
+  } catch {
+    return null;
+  }
+}
+var inside = (child, root) => child === root || child.startsWith(root.endsWith(path10.sep) ? root : root + path10.sep);
+function checkCwd(cwd, roots) {
+  if (typeof cwd !== "string" || cwd === "" || cwd.includes("\0")) return { ok: false, reason: "invalid_cwd" };
+  if (!path10.isAbsolute(cwd)) return { ok: false, reason: "cwd_not_absolute" };
+  let real;
+  try {
+    real = fs10.realpathSync.native(cwd);
+  } catch {
+    return { ok: false, reason: "cwd_not_found" };
+  }
+  try {
+    if (!fs10.statSync(real).isDirectory()) return { ok: false, reason: "cwd_not_directory" };
+  } catch {
+    return { ok: false, reason: "cwd_not_found" };
+  }
+  for (const root of roots) {
+    const r = realRoot(root);
+    if (r && inside(real, r)) return { ok: true, real };
+  }
+  return { ok: false, reason: "cwd_outside_roots" };
+}
+var stalled = /* @__PURE__ */ new Set();
+var Stalled = class extends Error {
+};
+async function bounded(what, f, ms) {
+  if (stalled.has(what)) throw new Stalled(what);
+  let timer;
+  const call = f();
+  const late = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Stalled(what)), ms);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([call, late]);
+  } catch (e) {
+    if (e instanceof Stalled) {
+      stalled.add(what);
+      void call.then(() => stalled.delete(what), () => stalled.delete(what));
+    }
+    throw e;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var realpathOf = (p, ms, f = fs10.promises) => bounded(p, () => f.realpath(p), ms);
+var isDir = async (p, ms, f = fs10.promises) => {
+  try {
+    return (await bounded(`stat:${p}`, () => f.stat(p), ms)).isDirectory();
+  } catch (e) {
+    if (e instanceof Stalled) throw e;
+    return false;
+  }
+};
+async function resolveCwd(cwd, roots, o) {
+  const ms = o.timeoutMs ?? 1e4;
+  if (typeof cwd !== "string" || cwd.trim() === "" || cwd.includes("\0")) return { ok: false, reason: "invalid_cwd" };
+  const typed = cwd.trim();
+  let candidates;
+  if (typed === "~" || typed.startsWith("~/")) candidates = [path10.join(o.home, typed.slice(2))];
+  else if (path10.isAbsolute(typed)) candidates = [typed];
+  else if (typed.startsWith("~")) return { ok: false, reason: "cwd_not_absolute" };
+  else {
+    const clean = path10.normalize(typed).replace(/\/+$/, "");
+    if (clean === ".." || clean.startsWith("../")) return { ok: false, reason: "cwd_outside_roots" };
+    candidates = [.../* @__PURE__ */ new Set([
+      ...roots.map((r) => path10.join(r, clean)),
+      ...roots.filter((r) => path10.basename(r) === clean)
+    ])];
+  }
+  const realRoots = [];
+  const down = [];
+  await Promise.all(roots.map(async (r) => {
+    try {
+      realRoots.push(await realpathOf(r, ms, o.fs));
+    } catch {
+      down.push(path10.resolve(r));
+    }
+  }));
+  const underDown = (p) => down.some((r) => inside(path10.resolve(p), r));
+  const hits = /* @__PURE__ */ new Map();
+  let unavailable = false;
+  for (const c of candidates) {
+    if (underDown(c)) {
+      unavailable = true;
+      continue;
+    }
+    let real;
+    try {
+      real = await realpathOf(c, ms, o.fs);
+    } catch (e) {
+      if (e instanceof Stalled) unavailable = true;
+      continue;
+    }
+    let dir;
+    try {
+      dir = await isDir(real, ms, o.fs);
+    } catch {
+      unavailable = true;
+      continue;
+    }
+    if (!dir) {
+      if (candidates.length === 1) return { ok: false, reason: "cwd_not_directory" };
+      continue;
+    }
+    if (realRoots.some((r) => inside(real, r))) hits.set(real, true);
+    else if (candidates.length === 1) return { ok: false, reason: "cwd_outside_roots" };
+  }
+  if (hits.size > 1) return { ok: false, reason: "cwd_ambiguous" };
+  if (hits.size === 1) return { ok: true, real: [...hits.keys()][0] };
+  return { ok: false, reason: unavailable ? "root_unavailable" : "cwd_not_found" };
+}
+async function rootProblems(agents, timeoutMs = 1e4) {
+  const out = [];
+  await Promise.all(agents.flatMap((a) => a.roots.map(async (r) => {
+    try {
+      const real = await realpathOf(r, timeoutMs);
+      if (!await isDir(real, timeoutMs)) out.push(`${a.id}: root ${r} is not a directory; sessions there are refused`);
+    } catch (e) {
+      out.push(e instanceof Stalled ? `${a.id}: root ${r} does not answer (a stalled network mount?); its sessions are refused (root_unavailable) until it does` : `${a.id}: root ${r} does not exist (yet); its sessions are refused until it does (create it, or fix roots in agents.toml)`);
+    }
+  })));
+  return out.sort();
+}
+function relativeInside(p, cwd) {
+  const abs = path10.resolve(cwd, p);
+  let real;
+  try {
+    real = fs10.realpathSync.native(abs);
+  } catch {
+    try {
+      real = path10.join(fs10.realpathSync.native(path10.dirname(abs)), path10.basename(abs));
+    } catch {
+      return null;
+    }
+  }
+  if (!inside(real, cwd)) return null;
+  return path10.relative(cwd, real).split(path10.sep).join("/");
+}
+
 // src/attach.ts
 var TwinCheckError = class extends Error {
 };
@@ -1850,6 +2004,14 @@ var AttachSupport = class {
     });
     return this.refreshing;
   }
+  /** Where the listing adapter starts: the first root that is there now (a root may be missing), else the home directory. */
+  async listingDir() {
+    for (const r of this.agent.roots) {
+      const v = await resolveCwd(r, [r], { home: os3.homedir(), timeoutMs: 5e3 });
+      if (v.ok) return v.real;
+    }
+    return os3.homedir();
+  }
   async doRefresh() {
     let adapter = null;
     this.noteHooks();
@@ -1858,7 +2020,7 @@ var AttachSupport = class {
         cfg: this.agent,
         registry: this.d.registry,
         sessionId: `list-${this.agent.id}`,
-        cwd: this.agent.roots[0] ?? os3.homedir(),
+        cwd: await this.listingDir(),
         hooks: NO_HOOKS,
         logFile: path11.join(this.d.logDir, `adapter-${this.agent.id}.log`),
         version: this.d.version,
@@ -1872,7 +2034,8 @@ var AttachSupport = class {
         const res = await adapter.request("session/list", cursor ? { cursor } : {}, 3e4);
         for (const s of Array.isArray(res.sessions) ? res.sessions : []) {
           if (!isObject(s) || typeof s.sessionId !== "string" || !SESSION_REF_RE.test(s.sessionId) || typeof s.cwd !== "string") continue;
-          const where = checkCwd(s.cwd, this.agent.roots);
+          if (!path11.isAbsolute(s.cwd)) continue;
+          const where = await resolveCwd(s.cwd, this.agent.roots, { home: os3.homedir(), timeoutMs: 5e3 });
           if (!where.ok) continue;
           const at = typeof s.updatedAt === "string" ? Date.parse(s.updatedAt) : NaN;
           found.set(s.sessionId.toLowerCase(), {
@@ -2432,13 +2595,15 @@ import os4 from "node:os";
 import path12 from "node:path";
 function resolveDirs(env = process.env, home = os4.homedir()) {
   const one = env.CLAW_CONNECTOR_HOME?.trim();
-  if (one) return { config: path12.join(one, "config"), state: path12.join(one, "state") };
+  const own = env.CLAW_CONNECTOR_CONFIG_DIR?.trim();
+  if (one) return { config: own ? path12.resolve(own) : path12.join(one, "config"), state: path12.join(one, "state") };
   const cfg = env.XDG_CONFIG_HOME?.trim() || path12.join(home, ".config");
   const st = env.XDG_STATE_HOME?.trim() || path12.join(home, ".local", "state");
-  return { config: path12.join(cfg, "claw-connector"), state: path12.join(st, "claw-connector") };
+  return { config: own ? path12.resolve(own) : path12.join(cfg, "claw-connector"), state: path12.join(st, "claw-connector") };
 }
 var configFile = (d) => path12.join(d.config, "agents.toml");
 var credentialsFile = (d) => path12.join(d.config, "credentials.json");
+var serviceEnvFile = (d) => path12.join(d.config, "service-env.json");
 var identityFile = (d) => path12.join(d.state, "connector.json");
 var sessionsFile = (d) => path12.join(d.state, "sessions.json");
 var childrenFile = (d) => path12.join(d.state, "children.json");
@@ -2454,6 +2619,8 @@ var supervisorPidFile = (d) => path12.join(d.state, "supervisor.pid");
 var runLogFile = (d) => path12.join(d.state, "run.log");
 var keepaliveFile = (d) => path12.join(d.state, "keepalive.sh");
 var serviceFile = (d) => path12.join(d.state, "service.json");
+var doctorFile = (d) => path12.join(d.state, "doctor.json");
+var keepaliveStampFile = (d) => path12.join(d.state, "keepalive-last");
 
 // src/health.ts
 var MAX_BYTES = 128 * 1024;
@@ -2523,7 +2690,70 @@ function clearNeedsLogin(dirs) {
 }
 
 // src/session.ts
+import path15 from "node:path";
+
+// src/hints.ts
 import path14 from "node:path";
+function agentFamily(a) {
+  const words = [a.command, ...a.args].map((s) => path14.basename(s));
+  if (words.some((s) => s.includes("claude-agent-acp") || s.includes("claude-code-acp"))) return "claude";
+  if (words.some((s) => s.includes("codex-acp"))) return "codex";
+  const cmd = path14.basename(a.command);
+  if (cmd === "agent" || cmd === "cursor-agent") return "cursor";
+  if (a.kind === "claude" || a.kind === "attach") return "claude";
+  if (a.kind === "codex" || a.kind === "cursor") return a.kind;
+  return "other";
+}
+var SIGN_IN = {
+  claude: `Claude Code is not signed in on that machine: run "claude" there and sign in with /login, or set ANTHROPIC_API_KEY (or your gateway's ANTHROPIC_AUTH_TOKEN) for this agent in agents.toml under [agents.env]; a service installed from a shell that has the variable keeps it too`,
+  codex: `Codex is not signed in on that machine: run "codex login" there (or "codex login --with-api-key"), or set OPENAI_API_KEY for this agent in agents.toml under [agents.env]`,
+  cursor: `Cursor is not signed in on that machine: run "agent login" there, or set CURSOR_API_KEY for this agent in agents.toml under [agents.env]`,
+  other: `the agent is not signed in on that machine: sign it in there, then try again`
+};
+var DOCTOR = `run "claw-connector doctor" on that machine; it names the fix`;
+var HINTS = {
+  invalid_cwd: "give the folder to work in: a full path, ~/path, or the name of a folder inside one of this agent's roots",
+  cwd_not_absolute: "give the folder as a full path, as ~/path, or as the name of a folder inside one of this agent's roots",
+  cwd_not_found: "that folder does not exist on that machine: pick an existing folder inside one of this agent's roots, or create it there first",
+  cwd_not_directory: "that is a file, not a folder: pick a folder inside one of this agent's roots",
+  cwd_ambiguous: "more than one of this agent's roots has a folder by that name: give its full path",
+  cwd_outside_roots: "this agent may only work inside its roots (agents.toml on that machine): pick a folder inside one of them, or add the folder to roots there and restart the connector",
+  cwd_mismatch: "that conversation belongs to another folder: take it over without naming a folder, or name the one it was started in",
+  root_unavailable: "the folder's disk is not answering on that machine (a network mount that is down or not mounted yet): try again in a minute, or check the mount there",
+  unknown_agent: "that machine no longer offers this agent: check agents.toml there, then restart the connector",
+  too_many_sessions: "that machine already runs the most sessions it allows at once (10): close one, then try again",
+  mode_not_allowed: `that mode does not ask before each step, and this agent may use such a mode only with approval = "never" in agents.toml on that machine`,
+  mode_unavailable: `the agent does not offer the mode this machine requires for it: ${DOCTOR}`,
+  mode_not_enforced: `the agent would not run in a mode that asks before each step (often because Claude's own settings default to bypassPermissions): ${DOCTOR}, or set approval = "never" for this agent there`,
+  mode_not_confirmed: `the agent did not confirm the mode this machine requires: ${DOCTOR}`,
+  mode_mismatch: `the agent switched to a mode other than the one this machine requires: ${DOCTOR}`,
+  adapter_start_failed: `the agent's program could not start on that machine (not installed, not on the service's PATH, or the download failed): ${DOCTOR}`,
+  adapter_error: `the agent failed while opening the session: ${DOCTOR}; the adapter's log is in the connector's logs directory there`,
+  adapter_protocol: `the agent answered in a way the connector does not understand: ${DOCTOR}, and update the agent's adapter`,
+  adapter_cannot_resume: "this agent cannot reopen an earlier session: start a new one",
+  adapter_gone: "the agent stopped while the session was opening: try again",
+  resume_not_supported: "this agent starts new conversations only: start a new session instead of continuing one",
+  resume_ref_required: "this agent only takes over conversations that already exist on that machine: pick one from its list, or use the agent that starts new ones",
+  invalid_resume_ref: "that is not a conversation this machine lists: pick one from its list",
+  attach_unavailable: "taking over conversations is not available for this agent on that machine: start a new session instead",
+  already_attached: "that conversation is already open from the chat: use that session",
+  unknown_session: "that machine no longer has this conversation (or it is outside the agent's roots): pick another one from its list",
+  catalog_unavailable: `that machine could not list its conversations just now: try again; if it keeps failing, ${DOCTOR}`,
+  session_live: "that conversation is open in a terminal on that machine: exit it there (/exit), then try again",
+  recently_written: "that conversation was written to a moment ago: wait a few seconds, then try again",
+  twin_check_failed: "the connector could not check whether a terminal holds that conversation open: try again in a moment",
+  too_many_queued_prompts: "five messages are already waiting for this session: wait for the agent to finish one",
+  text_required: "the message was empty",
+  session_closed: "the session has already ended: start a new one"
+};
+function hintFor(reason, agent) {
+  if (reason === "agent_auth_required") return SIGN_IN[agent ? agentFamily(agent) : "other"];
+  return HINTS[reason] ?? null;
+}
+function withHint(data, agent) {
+  const hint = hintFor(data.reason, agent);
+  return hint ? { ...data, hint } : data;
+}
 
 // src/permissions.ts
 import { randomUUID } from "node:crypto";
@@ -2657,7 +2887,9 @@ var DEFAULT_SESSION_TIMING = {
   modeConfirmMs: 3e3,
   twinWatchMs: 1e3,
   spectateMs: 1e3,
-  spectateCheckMs: 5e3
+  spectateCheckMs: 5e3,
+  rootCheckMs: 1e4,
+  authWaitMs: 3e3
 };
 var READ_ONLY_REASON = "read_only_live_session";
 var SessionRefusal = class extends Error {
@@ -2722,6 +2954,13 @@ var Session = class {
    */
   twinSeen = false;
   turnRunning = false;
+  /**
+   * The connector is going away (stopped, or restarted by its supervisor) and will come back. What this process cannot
+   * finish is left recorded for the next run instead of being ended here: the running turn (no `turn_end`), its waiting
+   * permission requests (still pending), and the prompts queued behind it (not counted as handled, so Claw delivers them
+   * again). See {@link SessionManager.recover}.
+   */
+  stopping = false;
   queue = [];
   launching = null;
   idle;
@@ -2763,7 +3002,7 @@ var Session = class {
     return this.noAskWarning || this.currentMode !== null && !this.agent.askingModes.includes(this.currentMode);
   }
   shownModes() {
-    return this.modes.filter((m) => this.modeAllowed(m.id)).map((m) => ({ ...m, unattended: !this.agent.askingModes.includes(m.id) }));
+    return this.modes.filter((m) => this.modeAllowed(m.id)).map((m) => ({ ...m, unattended: !this.agent.askingModes.includes(m.id), ...this.agent.readOnlyModes.includes(m.id) ? { read_only: true } : {} }));
   }
   // --- starting ----------------------------------------------------------------
   /** `session.new`: start the adapter, create the ACP session, lock the mode. A refusal closes the session with a reason. */
@@ -2971,7 +3210,7 @@ var Session = class {
       sessionId: this.id,
       cwd: this.cwd,
       hooks: this.hooks(),
-      logFile: path14.join(this.env.logDir, `adapter-${this.agent.id}.log`),
+      logFile: path15.join(this.env.logDir, `adapter-${this.agent.id}.log`),
       version: this.env.version
     }).catch((e) => {
       throw new SessionRefusal("adapter_start_failed", errMessage(e));
@@ -2984,19 +3223,20 @@ var Session = class {
     this.modeSeen = [];
     try {
       if (how === "new") {
-        const res = await adapter.request("session/new", { cwd: this.cwd, mcpServers: [], ...claudeSessionMeta(this.agent) });
+        const res = await this.signedIn(adapter, () => adapter.request("session/new", { cwd: this.cwd, mcpServers: [], ...claudeSessionMeta(this.agent) }));
         if (typeof res.sessionId !== "string") throw new SessionRefusal("adapter_protocol", "session/new returned no session id");
         this.acpId = res.sessionId;
         this.absorb(res);
+        await this.refuseSignedOut(adapter);
       } else {
         if (!this.acpId) throw new SessionRefusal("adapter_cannot_resume", "no adapter session to resume");
         const caps = adapter.caps.sessionCapabilities;
         if (caps?.resume) {
-          this.absorb(await adapter.request("session/resume", { sessionId: this.acpId, cwd: this.cwd, mcpServers: [], ...claudeSessionMeta(this.agent) }));
+          this.absorb(await this.signedIn(adapter, () => adapter.request("session/resume", { sessionId: this.acpId, cwd: this.cwd, mcpServers: [], ...claudeSessionMeta(this.agent) })));
         } else if (adapter.caps.loadSession) {
           this.replaying = true;
           try {
-            this.absorb(await adapter.requestUnbounded("session/load", { sessionId: this.acpId, cwd: this.cwd, mcpServers: [], ...claudeSessionMeta(this.agent) }));
+            this.absorb(await this.signedIn(adapter, () => adapter.requestUnbounded("session/load", { sessionId: this.acpId, cwd: this.cwd, mcpServers: [], ...claudeSessionMeta(this.agent) })));
           } finally {
             this.replaying = false;
           }
@@ -3011,6 +3251,43 @@ var Session = class {
       throw e instanceof SessionRefusal ? e : mapAdapterError(e);
     }
   }
+  /**
+   * `open` (a `session/new`), signing the adapter in first when it needs that and can do it by itself: an adapter that
+   * answers "Authentication required" and offers an `api-key` method, while its environment holds a key it reads
+   * (codex-acp: OPENAI_API_KEY or CODEX_API_KEY), is told to `authenticate` with it and asked once more. Without this a
+   * Codex agent set up with only an API key never opened a session. The key itself is never sent: the adapter reads
+   * its own environment. (codex-acp then keeps the key in its auth.json, as `codex login --with-api-key` does.)
+   */
+  async signedIn(adapter, open) {
+    try {
+      return await open();
+    } catch (e) {
+      const method = adapter.apiKeyMethod();
+      if (mapAdapterError(e).reason !== "agent_auth_required" || !method || !this.hasApiKey()) throw e;
+      this.audit("agent_authenticate", { method });
+      try {
+        await adapter.request("authenticate", { methodId: method });
+      } catch (ae) {
+        throw new SessionRefusal("agent_auth_required", `authenticate ${method} failed: ${errMessage(ae)}`);
+      }
+      return await open();
+    }
+  }
+  /** Whether the adapter's environment (the connector's, with the agent's `[agents.env]` over it) holds an OpenAI/Codex key. */
+  hasApiKey() {
+    const env = { ...process.env, ...this.agent.env };
+    return ["CODEX_API_KEY", "OPENAI_API_KEY"].some((k) => typeof env[k] === "string" && env[k].trim() !== "");
+  }
+  /**
+   * An adapter that reports its sign-in (claude-agent-acp) and says there is none: the session would open, say it is
+   * ready and fail at its first message with "Authentication required". A new session is refused now instead, with the
+   * fix. A session that already exists (resumed after an idle recycle or a restart) is not: its prompts say why and it
+   * stays, so it carries on once someone signs in on the machine.
+   */
+  async refuseSignedOut(adapter) {
+    const st = await adapter.waitAuthStatus(this.env.timing.authWaitMs);
+    if (st?.kind === "none") throw new SessionRefusal("agent_auth_required", `the agent reports that it is not signed in${st.label ? ` (${st.label})` : ""}`);
+  }
   /** Take the modes and the mode config option out of a `session/new|resume|load` answer. */
   absorb(res) {
     const modes = res.modes;
@@ -3146,7 +3423,7 @@ var Session = class {
     this.adapter = null;
     const hadTurn = this.turnRunning;
     const cancelled = this.book.cancelAll();
-    for (const actionId of cancelled) this.emit("permission_resolved", { actionId, optionId: null, outcome: "cancelled", by: "adapter_exit" });
+    if (!this.stopping) for (const actionId of cancelled) this.emit("permission_resolved", { actionId, optionId: null, outcome: "cancelled", by: "adapter_exit" });
     if (!this.closed) this.audit("adapter_exited", { code: info.code, signal: info.signal, during_turn: hadTurn });
   }
   onUpdate(update, params) {
@@ -3195,16 +3472,20 @@ var Session = class {
       kind: str(toolCall.kind, 64),
       input: boundedInput(toolCall.rawInput),
       toolCallId: str(toolCall.toolCallId, 128)
-    }, (optionId) => optionId === null ? { outcome: { outcome: "cancelled" } } : { outcome: { outcome: "selected", optionId } });
+    }, (optionId) => optionId === null ? { outcome: { outcome: "cancelled" } } : { outcome: { outcome: "selected", optionId } }, true);
   }
   /** Put a question on the phone and wait for the answer, a cancel or the timeout. `shape` turns the answer into what the adapter expects. */
-  askPerson(options, info, shape) {
+  askPerson(options, info, shape, permission = false) {
     return new Promise((resolve) => {
       const p = this.book.open(options, (actionId) => redactDeep({ actionId, ...info, options, timeout_ms: this.book.ttl }), (optionId) => {
-        this.env.store.removePending(this.id, p.actionId);
+        if (!this.stopping) {
+          this.env.store.removePending(this.id, p.actionId);
+          if (this.book.size === 0) this.env.store.markWaiting(this.id, false);
+        }
         resolve(shape(optionId));
       });
       this.env.store.addPending(this.id, p.actionId);
+      this.env.store.markWaiting(this.id, true, permission);
       this.audit("permission_requested", { action_id: p.actionId, tool: info.tool, tool_kind: info.kind, options: options.map((o) => o.optionId) });
       this.emit("permissionRequest", p.payload);
     });
@@ -3286,11 +3567,16 @@ var Session = class {
     this.queue.push({ text, cmdId, cmdSeq, started });
     if (!this.turnRunning) void this.pump();
   }
-  /** Prompts that will now never run (the process is being stopped): they count as handled. */
-  dropQueued() {
+  /** Prompts that will now never run here: they count as handled, unless (`keep`) the connector is only restarting and the next run should get them again. */
+  dropQueued(keep = false) {
     const q = this.queue;
     this.queue = [];
-    for (const item of q) item.started();
+    if (!keep) for (const item of q) item.started();
+  }
+  /** The connector is about to stop its adapters and will come back: see {@link stopping}. */
+  shutdown() {
+    this.stopping = true;
+    this.dropQueued(true);
   }
   async pump() {
     if (this.turnRunning) return;
@@ -3314,6 +3600,7 @@ var Session = class {
         this.audit("prompt_refused", { reason: refused.reason, detail: refused.detail.slice(0, 300) });
         this.rejectCommand("prompt", cmdId, refused.reason, cmdSeq);
         this.emit("turn_end", { stopReason: "error", error: refused.reason, cmd_id: cmdId, cmd_seq: cmdSeq });
+        this.env.store.endTurn(this.id);
         return;
       }
     }
@@ -3321,7 +3608,11 @@ var Session = class {
       await this.ensureAdapter();
     } catch (e) {
       started();
-      this.emit("turn_end", { stopReason: "error", error: e instanceof SessionRefusal ? e.reason : "adapter_unavailable", cmd_id: cmdId, cmd_seq: cmdSeq });
+      const reason = e instanceof SessionRefusal ? e.reason : "adapter_unavailable";
+      const hint = hintFor(reason, this.agent);
+      this.emit("turn_end", { stopReason: "error", error: reason, ...hint ? { hint } : {}, cmd_id: cmdId, cmd_seq: cmdSeq });
+      this.env.store.endTurn(this.id);
+      if (reason === "agent_auth_required") return;
       return this.refuse(e);
     }
     const a = this.adapter;
@@ -3330,13 +3621,22 @@ var Session = class {
     const watch = support ? this.watchTwins(support, this.acpId) : null;
     try {
       const reply = a.requestUnbounded("session/prompt", { sessionId: this.acpId, prompt: [{ type: "text", text }] });
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      this.env.store.beginTurn({ session_id: this.id, cmd_id: cmdId, cmd_seq: cmdSeq, started_at: now });
+      this.env.store.patch(this.id, { used_at: now });
       started();
       const res = await reply;
       const usage = isObject(res.usage) ? res.usage : void 0;
-      this.emit("turn_end", { stopReason: typeof res.stopReason === "string" ? res.stopReason : "end_turn", ...usage ? { usage } : {}, cmd_id: cmdId, cmd_seq: cmdSeq });
+      this.endTurn({ stopReason: typeof res.stopReason === "string" ? res.stopReason : "end_turn", ...usage ? { usage } : {}, cmd_id: cmdId, cmd_seq: cmdSeq });
     } catch (e) {
-      this.audit("turn_failed", { error: errMessage(e) });
-      this.emit("turn_end", { stopReason: "error", error: errMessage(e).slice(0, 300), cmd_id: cmdId, cmd_seq: cmdSeq });
+      if (!this.stopping) this.audit("turn_failed", { error: errMessage(e) });
+      const r = mapAdapterError(e);
+      if (r.reason === "agent_auth_required") {
+        this.endTurn({ stopReason: "error", error: r.reason, message: errMessage(e).slice(0, 300), hint: hintFor(r.reason, this.agent), cmd_id: cmdId, cmd_seq: cmdSeq });
+        if (this.adapter === a) await this.dropAdapter();
+      } else {
+        this.endTurn({ stopReason: "error", error: errMessage(e).slice(0, 300), cmd_id: cmdId, cmd_seq: cmdSeq });
+      }
     } finally {
       this.markTranscript();
       if (watch) {
@@ -3381,6 +3681,12 @@ var Session = class {
     }
     return null;
   }
+  /** The turn is over: say so and forget it. Not while the connector is going away: the next run ends or continues it. */
+  endTurn(data) {
+    if (this.stopping) return;
+    this.emit("turn_end", data);
+    this.env.store.endTurn(this.id);
+  }
   /** What size the transcript is as this connector leaves it: after it starts the session and after every turn. */
   markTranscript() {
     if (this.agent.attach && this.acpId) this.transcriptMark = this.env.attach.get(this.agent.id)?.transcriptSize(this.acpId) ?? null;
@@ -3403,6 +3709,7 @@ var Session = class {
       if (this.adapter && !this.adapter.exited) await this.enforceMode(this.targetMode);
       else await this.launch("resume");
     } catch (e) {
+      if (e instanceof SessionRefusal && e.reason === "agent_auth_required") return this.rejectCommand("resume", cmdId, e.reason);
       return this.refuse(e);
     }
     this.audit("session_resumed", { mode: this.currentMode, unattended: this.unattended });
@@ -3449,7 +3756,7 @@ var Session = class {
     await this.dropAdapter();
     this.env.store.patch(this.id, { status: "closed" });
     this.audit("session_closed", { reason });
-    this.emit("session_closed", { reason });
+    this.emit("session_closed", withHint({ reason }, this.agent));
   }
   /** A session that cannot be opened (or kept safe) is closed with the reason, never left half-open. */
   async refuse(e) {
@@ -3461,7 +3768,7 @@ var Session = class {
   /** A command refused; a prompt's refusal names it by `cmd_seq` too, as its turn_end would. */
   rejectCommand(type, cmdId, reason, cmdSeq = null) {
     this.audit("command_rejected", { type, cmd_id: cmdId, reason });
-    this.emit("command_rejected", { type, cmd_id: cmdId, reason, ...cmdSeq !== null ? { cmd_seq: cmdSeq } : {} });
+    this.emit("command_rejected", withHint({ type, cmd_id: cmdId, reason, ...cmdSeq !== null ? { cmd_seq: cmdSeq } : {} }, this.agent));
   }
 };
 function mapAdapterError(e) {
@@ -3486,7 +3793,10 @@ function limitStrings(value, max) {
 }
 
 // src/manager.ts
+import os5 from "node:os";
 var MAX_ACTIVE_SESSIONS = 10;
+var RECOVER_NOTICE_MS = 4 * 36e5;
+var CONTINUE_PROMPT = "[claw-connector] The connector on this machine restarted while you were waiting for my permission, so that request was cancelled. Continue the task from where you left off, and ask again for anything that still needs my permission.";
 var cmdSeqOf = (cmd) => Number.isSafeInteger(cmd.cmd_seq) ? cmd.cmd_seq : null;
 var SessionManager = class {
   constructor(env) {
@@ -3500,6 +3810,15 @@ var SessionManager = class {
   agent(id) {
     return typeof id === "string" ? this.env.config.agents.find((a) => a.id === id) : void 0;
   }
+  /** The folder a phone asked for, as this agent would see it: `~` is the home its adapter runs with. */
+  where(cwd, agent) {
+    return resolveCwd(typeof cwd === "string" ? cwd : "", agent.roots, { home: agent.env.HOME?.trim() || os5.homedir(), timeoutMs: this.env.timing.rootCheckMs });
+  }
+  /** A session refused before it had a process: audited, and closed with its reason and what to do about it. */
+  refuseNew(sid, reason, agent, extra = {}) {
+    this.env.audit.record("session_refused", { session_id: sid, ...agent ? { agent_id: agent.id } : {}, reason, ...extra });
+    this.env.emit(sid, "session_closed", withHint({ reason }, agent));
+  }
   /**
    * Commands of one session run one after another; sessions run side by side.
    * `handled` is called exactly once, when the command counts as carried out: for most that is when the
@@ -3549,8 +3868,20 @@ var SessionManager = class {
       return false;
     }
     const s = await this.lookup(sid);
-    if (!s) {
-      this.env.emit(sid, "session_closed", { reason: "unknown_session" });
+    if (s === null) {
+      this.env.emit(sid, "session_closed", { reason: "unknown_session", hint: "the session has already ended on that machine: start a new one" });
+      return false;
+    }
+    if (!(s instanceof Session)) {
+      if (type === "close") {
+        this.env.store.patch(sid, { status: "closed" });
+        this.env.audit.record("session_closed", { session_id: sid, reason: "closed" });
+        this.env.emit(sid, "session_closed", { reason: "closed" });
+        return false;
+      }
+      const seq = cmdSeqOf(cmd);
+      this.env.audit.record("command_rejected", { type, cmd_id: cmdId, reason: s.unavailable });
+      this.env.emit(sid, "command_rejected", withHint({ type, cmd_id: cmdId, reason: s.unavailable, ...seq !== null ? { cmd_seq: seq } : {} }, s.agent));
       return false;
     }
     switch (type) {
@@ -3589,30 +3920,15 @@ var SessionManager = class {
       return;
     }
     const agent = this.agent(cmd.agent_id);
-    if (!agent) {
-      this.env.audit.record("session_refused", { session_id: sid, reason: "unknown_agent", agent_id: String(cmd.agent_id).slice(0, 64) });
-      this.env.emit(sid, "session_closed", { reason: "unknown_agent" });
-      return;
-    }
+    if (!agent) return this.refuseNew(sid, "unknown_agent", null, { agent_id: String(cmd.agent_id).slice(0, 64) });
     const ref = cmd.resume_ref;
     if (agent.attach) return this.attachNew(cmd, agent);
-    if (ref !== void 0 && ref !== null) {
-      this.env.audit.record("session_refused", { session_id: sid, agent_id: agent.id, reason: "resume_not_supported" });
-      this.env.emit(sid, "session_closed", { reason: "resume_not_supported" });
-      return;
-    }
-    const verdict = checkCwd(typeof cmd.cwd === "string" ? cmd.cwd : "", agent.roots);
-    if (!verdict.ok) {
-      this.env.audit.record("session_refused", { session_id: sid, agent_id: agent.id, reason: verdict.reason, cwd: String(cmd.cwd).slice(0, 300) });
-      this.env.emit(sid, "session_closed", { reason: verdict.reason });
-      return;
-    }
+    if (ref !== void 0 && ref !== null) return this.refuseNew(sid, "resume_not_supported", agent);
+    const verdict = await this.where(cmd.cwd, agent);
+    if (!verdict.ok) return this.refuseNew(sid, verdict.reason, agent, { cwd: String(cmd.cwd).slice(0, 300) });
+    if (this.sessions.has(sid)) return;
     const active = [...this.sessions.values()].filter((s2) => !s2.closed).length;
-    if (active >= MAX_ACTIVE_SESSIONS) {
-      this.env.audit.record("session_refused", { session_id: sid, agent_id: agent.id, reason: "too_many_sessions" });
-      this.env.emit(sid, "session_closed", { reason: "too_many_sessions" });
-      return;
-    }
+    if (active >= MAX_ACTIVE_SESSIONS) return this.refuseNew(sid, "too_many_sessions", agent);
     const s = new Session(sid, agent, verdict.real, this.env);
     this.sessions.set(sid, s);
     await s.create(typeof cmd.mode === "string" ? cmd.mode : null);
@@ -3624,10 +3940,7 @@ var SessionManager = class {
    */
   async attachNew(cmd, agent) {
     const sid = cmd.session_id;
-    const refuse = (reason, extra = {}) => {
-      this.env.audit.record("session_refused", { session_id: sid, agent_id: agent.id, reason, ...extra });
-      this.env.emit(sid, "session_closed", { reason });
-    };
+    const refuse = (reason, extra = {}) => this.refuseNew(sid, reason, agent, extra);
     const ref = typeof cmd.resume_ref === "string" ? cmd.resume_ref : "";
     if (!ref) return refuse("resume_ref_required");
     if (!SESSION_REF_RE.test(ref)) return refuse("invalid_resume_ref");
@@ -3641,7 +3954,7 @@ var SessionManager = class {
     try {
       const found = await support.resolve(want);
       if (!found.ok) return refuse(found.reason);
-      const asked = checkCwd(typeof cmd.cwd === "string" ? cmd.cwd : "", agent.roots);
+      const asked = await this.where(cmd.cwd, agent);
       if (!asked.ok) return refuse(asked.reason, { cwd: String(cmd.cwd).slice(0, 300) });
       if (asked.real !== found.item.cwd) return refuse("cwd_mismatch", { cwd: String(cmd.cwd).slice(0, 300) });
       const s = new Session(sid, agent, found.item.cwd, this.env, found.item.ref);
@@ -3658,20 +3971,25 @@ var SessionManager = class {
     for (const s of this.sessions.values()) if (!s.closed && !s.readOnly && s.agent.id === agentId && s.acpId) out.add(s.acpId.toLowerCase());
     return out;
   }
-  /** A session this process knows, or one it made earlier (before a restart) and can bring back. */
+  /**
+   * A session this process knows, or one it made earlier (before a restart) and can bring back; `unavailable` when its
+   * folder's disk does not answer now (the session is kept for later).
+   */
   async lookup(sid) {
     const have = this.sessions.get(sid);
     if (have) return have;
     const rec = this.env.store.get(sid);
     if (!rec || rec.status !== "active") return null;
     const agent = this.agent(rec.agent_id);
-    const verdict = agent ? checkCwd(rec.cwd, agent.roots) : null;
+    const verdict = agent ? await this.where(rec.cwd, agent) : null;
     if (!agent || !verdict?.ok) {
+      if (agent && verdict && !verdict.ok && verdict.reason === "root_unavailable") return { unavailable: verdict.reason, agent };
       this.env.store.patch(sid, { status: "closed" });
-      this.env.audit.record("session_refused", { session_id: sid, reason: agent ? "cwd_outside_roots" : "unknown_agent" });
-      this.env.emit(sid, "session_closed", { reason: agent ? "cwd_outside_roots" : "unknown_agent" });
+      this.refuseNew(sid, agent ? verdict && !verdict.ok ? verdict.reason : "cwd_outside_roots" : "unknown_agent", agent ?? null);
       return null;
     }
+    const raced = this.sessions.get(sid);
+    if (raced) return raced;
     const s = new Session(sid, agent, verdict.real, this.env, rec.acp_session_id, rec.mode);
     this.sessions.set(sid, s);
     if (rec.read_only) s.restoreSpectate();
@@ -3691,11 +4009,61 @@ var SessionManager = class {
   get pendingPermissions() {
     return [...this.sessions.values()].reduce((n, s) => n + s.pendingCount, 0);
   }
-  /** The kill switch: every adapter process, now. Sessions stay recorded and can be resumed. */
-  async killAll(reason) {
+  /**
+   * After a restart (a crash, a kill, a supervisor's restart, an upgrade): every turn the previous run left running is
+   * ended or carried on, and every session used lately is told it is back (`session_recovered`), once.
+   *
+   * A turn whose agent was waiting for a person's permission for a tool call, cut off no longer ago than a card lives, in a
+   * session of an agent that always asks, goes on with {@link CONTINUE_PROMPT} under the same prompt (`cmd_id`,
+   * `cmd_seq`): the agent asks again, so the card comes back, and the prompt's own `turn_end` still ends it. Not while
+   * the kill switch is on (`mayContinue`). Any other turn ends with `turn_end` `error: "connector_restarted"`, naming its
+   * prompt, so the phone stops waiting for it; whether the agent finished what it was doing is in the conversation, which
+   * the next message resumes.
+   */
+  recover(o) {
+    const now = o.now ?? Date.now();
+    const told = /* @__PURE__ */ new Set();
+    for (const t of this.env.store.listTurns()) {
+      const sid = t.session_id;
+      const rec = this.env.store.get(sid);
+      const active = rec?.status === "active";
+      const agent = rec ? this.agent(rec.agent_id) : void 0;
+      const asks = agent !== void 0 && !agent.allowUnsafeModes && rec?.mode !== null && rec?.mode !== void 0 && agent.askingModes.includes(rec.mode);
+      const waiting = Boolean(t.waiting_permission);
+      const recent = o.downForMs !== null && o.downForMs <= this.env.timing.permissionTtlMs;
+      if (o.mayContinue && active && asks && waiting && recent) {
+        this.env.audit.record("turn_continued", { session_id: sid, cmd_id: t.cmd_id, cmd_seq: t.cmd_seq, down_ms: o.downForMs });
+        this.env.emit(sid, "session_recovered", { reason: "connector_restart", interrupted: true, continuing: true, cmd_id: t.cmd_id, cmd_seq: t.cmd_seq });
+        void this.handle({ cmd_id: t.cmd_id ?? `continue-${t.cmd_seq ?? sid}`, type: "prompt", session_id: sid, text: CONTINUE_PROMPT, ...t.cmd_seq !== null ? { cmd_seq: t.cmd_seq } : {} }, () => {
+          if (this.env.store.turn(sid)?.started_at === t.started_at) this.env.store.endTurn(sid);
+        });
+      } else {
+        this.env.audit.record("turn_interrupted", { session_id: sid, cmd_id: t.cmd_id, cmd_seq: t.cmd_seq, waiting, down_ms: o.downForMs });
+        if (active) this.env.emit(sid, "session_recovered", { reason: "connector_restart", interrupted: true, continuing: false, cmd_id: t.cmd_id, cmd_seq: t.cmd_seq });
+        this.env.emit(sid, "turn_end", { stopReason: "error", error: "connector_restarted", cmd_id: t.cmd_id, cmd_seq: t.cmd_seq });
+        this.env.store.endTurn(sid);
+      }
+      told.add(sid);
+    }
+    for (const sid of this.env.store.ids()) {
+      const rec = this.env.store.get(sid);
+      if (told.has(sid) || rec?.status !== "active" || !rec.used_at) continue;
+      const used = Date.parse(rec.used_at);
+      if (!Number.isFinite(used) || now - used > RECOVER_NOTICE_MS) continue;
+      this.env.emit(sid, "session_recovered", { reason: "connector_restart", interrupted: false, continuing: false });
+    }
+  }
+  /**
+   * Every adapter process, now. Sessions stay recorded and can be resumed. `restarting`: the connector is only going away
+   * for a while (stopped, or restarted by its supervisor); what is in flight is left for the next run ({@link recover})
+   * instead of being ended, and queued prompts are delivered again. Otherwise (the kill switch: revoked, paused) every
+   * turn ends here and queued prompts count as handled.
+   */
+  async killAll(reason, restarting = false) {
     for (const s of this.sessions.values()) {
       this.env.audit.record("session_killed", { session_id: s.id, reason });
-      s.dropQueued();
+      if (restarting) s.shutdown();
+      else s.dropQueued();
       s.stopTail();
     }
     await this.env.registry.killAll();
@@ -3705,7 +4073,7 @@ var SessionManager = class {
 
 // src/outbox.ts
 import fs13 from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 var DROPPABLE_TYPES = /* @__PURE__ */ new Set([
   "agent_message_chunk",
   "agent_thought_chunk",
@@ -3735,8 +4103,8 @@ var Outbox = class {
     fs13.mkdirSync(this.dir, { recursive: true, mode: 448 });
     this.load();
   }
-  eventsFile = (sid) => path15.join(this.dir, `${safeName(sid)}.jsonl`);
-  metaFile = (sid) => path15.join(this.dir, `${safeName(sid)}.meta.json`);
+  eventsFile = (sid) => path16.join(this.dir, `${safeName(sid)}.jsonl`);
+  metaFile = (sid) => path16.join(this.dir, `${safeName(sid)}.meta.json`);
   writeMeta(sid) {
     const tmp = this.metaFile(sid) + ".tmp";
     fs13.writeFileSync(tmp, JSON.stringify(this.meta.get(sid)), { mode: 384 });
@@ -3753,11 +4121,11 @@ var Outbox = class {
     for (const base of bases) {
       let meta = { lastSeq: 0, acked: 0 };
       try {
-        meta = JSON.parse(fs13.readFileSync(path15.join(this.dir, `${base}.meta.json`), "utf8"));
+        meta = JSON.parse(fs13.readFileSync(path16.join(this.dir, `${base}.meta.json`), "utf8"));
       } catch {
       }
       let sid = null;
-      const file = path15.join(this.dir, `${base}.jsonl`);
+      const file = path16.join(this.dir, `${base}.jsonl`);
       let text = "";
       try {
         text = fs13.readFileSync(file, "utf8");
@@ -3778,8 +4146,8 @@ var Outbox = class {
       if (sid === null) {
         sid = base;
         try {
-          if (this.now() - fs13.statSync(path15.join(this.dir, `${base}.meta.json`)).mtimeMs > TOMBSTONE_MS) {
-            for (const f of [`${base}.meta.json`, `${base}.jsonl`]) fs13.rmSync(path15.join(this.dir, f), { force: true });
+          if (this.now() - fs13.statSync(path16.join(this.dir, `${base}.meta.json`)).mtimeMs > TOMBSTONE_MS) {
+            for (const f of [`${base}.meta.json`, `${base}.jsonl`]) fs13.rmSync(path16.join(this.dir, f), { force: true });
             continue;
           }
         } catch {
@@ -3897,11 +4265,19 @@ var Outbox = class {
 
 // src/session-store.ts
 import fs14 from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 var SessionStore = class {
   constructor(file) {
     this.file = file;
     this.pendingFile = `${file}.pending`;
+    this.turnsFile = `${file}.turns`;
+    try {
+      const raw = JSON.parse(fs14.readFileSync(this.turnsFile, "utf8"));
+      if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        for (const [k, t] of Object.entries(raw)) if (t && typeof t.session_id === "string") this.turns[k] = t;
+      }
+    } catch {
+    }
     try {
       const raw = JSON.parse(fs14.readFileSync(this.pendingFile, "utf8"));
       if (Array.isArray(raw)) this.pending = raw.filter((p) => p && typeof p.session_id === "string" && typeof p.action_id === "string");
@@ -3917,6 +4293,8 @@ var SessionStore = class {
   recs = {};
   pending = [];
   pendingFile;
+  turns = {};
+  turnsFile;
   get(id) {
     return this.recs[id];
   }
@@ -3951,50 +4329,527 @@ var SessionStore = class {
     return out;
   }
   savePending() {
-    fs14.mkdirSync(path16.dirname(this.pendingFile), { recursive: true, mode: 448 });
+    fs14.mkdirSync(path17.dirname(this.pendingFile), { recursive: true, mode: 448 });
     const tmp = `${this.pendingFile}.${process.pid}.tmp`;
     fs14.writeFileSync(tmp, JSON.stringify(this.pending), { mode: 384 });
     fs14.renameSync(tmp, this.pendingFile);
   }
+  /**
+   * The turn a session's agent is running. It lives in the adapter's memory, so a connector that dies (or is stopped)
+   * mid-turn would leave the prompt open for ever: the next run reads these and ends or continues each one.
+   */
+  beginTurn(t) {
+    this.turns[t.session_id] = t;
+    this.saveTurns();
+  }
+  /** The turn's agent is waiting for a person (`true`; `permission`: a tool call's permission request), or no longer (`false`). */
+  markWaiting(sessionId, waiting, permission = false) {
+    const t = this.turns[sessionId];
+    if (!t) return;
+    const next = { ...t, waiting, waiting_permission: waiting && (permission || Boolean(t.waiting_permission)) };
+    if (Boolean(t.waiting) === next.waiting && Boolean(t.waiting_permission) === next.waiting_permission) return;
+    this.turns[sessionId] = next;
+    this.saveTurns();
+  }
+  turn(sessionId) {
+    return this.turns[sessionId];
+  }
+  endTurn(sessionId) {
+    if (!(sessionId in this.turns)) return;
+    delete this.turns[sessionId];
+    this.saveTurns();
+  }
+  /** The turns recorded as running. Each stays until it is ended ({@link endTurn}) or a new turn of its session replaces it. */
+  listTurns() {
+    return Object.values(this.turns).map((t) => ({ ...t }));
+  }
+  saveTurns() {
+    fs14.mkdirSync(path17.dirname(this.turnsFile), { recursive: true, mode: 448 });
+    const tmp = `${this.turnsFile}.${process.pid}.tmp`;
+    fs14.writeFileSync(tmp, JSON.stringify(this.turns), { mode: 384 });
+    fs14.renameSync(tmp, this.turnsFile);
+  }
   ids() {
     return Object.keys(this.recs);
   }
   save() {
-    fs14.mkdirSync(path16.dirname(this.file), { recursive: true, mode: 448 });
+    fs14.mkdirSync(path17.dirname(this.file), { recursive: true, mode: 448 });
     const tmp = `${this.file}.${process.pid}.tmp`;
     fs14.writeFileSync(tmp, JSON.stringify(this.recs), { mode: 384 });
     fs14.renameSync(tmp, this.file);
   }
 };
 
-// src/connector.ts
-var RESTART_RECONNECT_GAP_MS = 5e3;
-var DEFAULT_TIMING = {
-  ...DEFAULT_SESSION_TIMING,
-  heartbeatMs: REMOTE_AGENT_TIMING.heartbeatMs,
-  watchdogMs: REMOTE_AGENT_TIMING.watchdogMs,
-  batchMs: 150,
-  batchMax: 20,
-  backoffMinMs: 1e3,
-  backoffMaxMs: 6e4,
-  pausePollMs: 1e3,
-  catalogMs: 12e4,
-  sessionsWatchMs: 1e4,
-  attachCliMs: 8e3,
-  recentWriteMs: 1e4,
-  authFailLimit: 4,
-  authFailWindowMs: 12e4
-};
-var CommandLedger = class {
-  inflight = /* @__PURE__ */ new Set();
-  inflightIds = /* @__PURE__ */ new Set();
-  ids;
-  highest = 0;
-  floor;
-  constructor(cursor = 0, handled = []) {
-    this.floor = cursor;
-    this.highest = cursor;
-    this.ids = [...handled];
+// src/doctor.ts
+import { spawn as spawn3 } from "node:child_process";
+import fs15 from "node:fs";
+import fsp from "node:fs/promises";
+import os6 from "node:os";
+import path18 from "node:path";
+import { parse as parseToml2 } from "smol-toml";
+var FS_TIMEOUT_MS = 5e3;
+async function within2(p, ms = FS_TIMEOUT_MS) {
+  let t;
+  const late = new Promise((resolve) => {
+    t = setTimeout(() => resolve(null), ms);
+    t.unref?.();
+  });
+  p.catch(() => void 0);
+  try {
+    return await Promise.race([p, late]);
+  } finally {
+    clearTimeout(t);
+  }
+}
+var errnoOf = async (p) => within2(p.then(() => "", (e) => e.code ?? "EIO"));
+var fileExists = async (f) => await errnoOf(fsp.access(f)) === "";
+async function readText(f) {
+  return within2(fsp.readFile(f, "utf8").catch(() => null));
+}
+async function readJson(file) {
+  const t = await readText(file);
+  if (t === null) return null;
+  try {
+    const v = JSON.parse(t);
+    return isObject(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+var NODE_MIN_MAJOR = 22;
+var RECHECK_MS = 15 * 6e4;
+var KEEPALIVE_STALE_MS = 15 * 6e4;
+var PROBE_TIMEOUT_MS = 15e3;
+var PIPE_GRACE_MS = 500;
+var MAX_REPORTED2 = 6;
+function runProbe(cmd, args, env, signal, timeoutMs = PROBE_TIMEOUT_MS, input, ownGroup = true) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve({ code: null, out: "stopped" });
+    let out = "";
+    let child;
+    try {
+      child = spawn3(cmd, args, { env, cwd: os6.homedir(), detached: ownGroup, stdio: [input === void 0 ? "ignore" : "pipe", "pipe", "pipe"], windowsHide: true });
+    } catch (e) {
+      return resolve({ code: null, out: errMessage(e) });
+    }
+    if (input !== void 0) {
+      child.stdin?.on("error", () => void 0);
+      child.stdin?.end(input);
+    }
+    const take = (b) => {
+      if (out.length < 256 * 1024) out += b.toString("utf8");
+    };
+    child.stdout?.on("data", take);
+    child.stderr?.on("data", take);
+    const killGroup = () => {
+      try {
+        if (child.pid) process.kill(ownGroup ? -child.pid : child.pid, "SIGKILL");
+      } catch {
+      }
+    };
+    let settled = false;
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      killGroup();
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve({ code, out: out.trim() });
+    };
+    const onAbort = () => finish(null);
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.once("error", (e) => {
+      out = errMessage(e);
+      finish(null);
+    });
+    const ended = (st) => new Promise((res) => {
+      if (!st || st.readableEnded) res();
+      else {
+        st.once("end", () => res());
+        st.once("close", () => res());
+      }
+    });
+    const drained = Promise.all([ended(child.stdout), ended(child.stderr)]);
+    child.once("exit", (code) => {
+      const grace = setTimeout(() => finish(code), PIPE_GRACE_MS);
+      void drained.then(() => {
+        clearTimeout(grace);
+        finish(code);
+      });
+    });
+  });
+}
+function defaultDeps(env, over = {}) {
+  const signal = over.signal;
+  const ownGroup = over.ownGroup ?? true;
+  const run2 = (cmd, args, e) => runProbe(cmd, args, e, signal, PROBE_TIMEOUT_MS, void 0, ownGroup);
+  return {
+    env,
+    platform: process.platform,
+    home: os6.homedir(),
+    user: env.USER || (() => {
+      try {
+        return os6.userInfo().username;
+      } catch {
+        return "";
+      }
+    })(),
+    nodeVersion: process.versions.node,
+    uid: process.getuid?.() ?? null,
+    now: () => Date.now(),
+    probe: run2,
+    crontab: async () => {
+      const r = await run2("crontab", ["-l"], env);
+      return r.code === 0 ? r.out : null;
+    },
+    exec: (cmd, args) => run2(cmd, args, env),
+    writable: async (dir) => {
+      const code = await errnoOf(fsp.access(dir, fs15.constants.W_OK));
+      return code === "" ? null : code ?? "ETIMEDOUT";
+    },
+    get: async (url) => {
+      try {
+        const r = await fetch(url, { signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(8e3)]) : AbortSignal.timeout(8e3), redirect: "manual" });
+        await r.body?.cancel().catch(() => void 0);
+        return { status: r.status };
+      } catch (e) {
+        const cause = e.cause;
+        return { error: cause instanceof Error ? `${errMessage(e)} (${cause.message})` : errMessage(e) };
+      }
+    },
+    ...over
+  };
+}
+async function which(cmd, pathVar) {
+  const executable = async (p) => await within2(fsp.stat(p).then(async (st) => st.isFile() && await fsp.access(p, fs15.constants.X_OK).then(() => true, () => false), () => false)) === true;
+  if (cmd.includes("/")) return await executable(cmd) ? cmd : null;
+  for (const dir of (pathVar ?? "").split(path18.delimiter)) {
+    if (!dir) continue;
+    const p = path18.join(dir, cmd);
+    if (await executable(p)) return p;
+  }
+  return null;
+}
+var agentEnv = (env, a) => ({ ...env, ...a.env });
+function familyOf(a) {
+  const words = [a.command, ...a.args].map((s) => path18.basename(s));
+  if (words.some((s) => s.includes("claude-agent-acp") || s.includes("claude-code-acp"))) return "claude";
+  if (words.some((s) => s.includes("codex-acp"))) return "codex";
+  if (path18.basename(a.command) === "agent" || path18.basename(a.command) === "cursor-agent") return "cursor";
+  return "other";
+}
+var LOGIN_FIX = {
+  claude: "claude auth login",
+  codex: "codex login",
+  cursor: "agent login"
+};
+function installFix(cmd, family) {
+  const base = path18.basename(cmd);
+  if (base === "npx" || base === "node") return "install Node.js 22 or newer (it brings npx): https://nodejs.org";
+  if (family === "cursor") return "install the Cursor CLI: curl https://cursor.com/install -fsS | bash";
+  return `install ${base}, or set this agent's command in agents.toml to its full path`;
+}
+var set = (env, name) => typeof env[name] === "string" && env[name] !== "";
+async function claudeSignedIn(env, d) {
+  const keys = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", "CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX", "CLAUDE_CODE_USE_FOUNDRY"];
+  if (keys.some((k) => set(env, k))) return true;
+  const dir = env.CLAUDE_CONFIG_DIR?.trim() || path18.join(d.home, ".claude");
+  const settings = await readJson(path18.join(dir, "settings.json"));
+  if (settings && (typeof settings.apiKeyHelper === "string" || isObject(settings.env) && keys.some((k) => typeof settings.env[k] === "string"))) return true;
+  const claude = await which("claude", env.PATH);
+  if (claude) {
+    const r = await d.probe(claude, ["auth", "status", "--json"], env);
+    try {
+      const v = JSON.parse(r.out.slice(r.out.indexOf("{")));
+      if (isObject(v) && typeof v.loggedIn === "boolean") return v.loggedIn;
+    } catch {
+    }
+  }
+  if (await fileExists(path18.join(dir, ".credentials.json"))) return true;
+  if (d.platform === "darwin") return null;
+  return false;
+}
+async function codexAuth(env, d) {
+  const home = env.CODEX_HOME?.trim() || path18.join(d.home, ".codex");
+  let cfg = {};
+  try {
+    const t = await readText(path18.join(home, "config.toml"));
+    if (t !== null) cfg = parseToml2(t);
+  } catch {
+  }
+  const name = typeof cfg.model_provider === "string" ? cfg.model_provider : "openai";
+  const providers = isObject(cfg.model_providers) ? cfg.model_providers : {};
+  const provider = isObject(providers[name]) ? providers[name] : null;
+  if (name !== "openai" && provider && provider.requires_openai_auth !== true) {
+    const key = typeof provider.env_key === "string" ? provider.env_key : null;
+    if (!key || set(env, key)) return { ok: true };
+    if (!/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(key)) return { ok: false, detail: `Codex's model provider "${name.slice(0, 64)}" has an env_key that is not a variable name`, fix: `set env_key in ${path18.join(home, "config.toml")} to the NAME of the variable that holds the key` };
+    return { ok: false, detail: `Codex uses the model provider "${name}", which reads ${key}, and ${key} is not set where the connector runs`, fix: `set ${key} for this agent: add it to the agent's env in agents.toml, or export it before starting the connector` };
+  }
+  if (set(env, "OPENAI_API_KEY")) return { ok: true };
+  const codex = await which("codex", env.PATH);
+  if (codex) {
+    const r = await d.probe(codex, ["login", "status"], env);
+    if (r.code === 0 && !/not logged in/i.test(r.out)) return { ok: true };
+    if (/not logged in/i.test(r.out)) return { ok: false, detail: "Codex is not signed in on this machine", fix: LOGIN_FIX.codex };
+  }
+  if (await fileExists(path18.join(home, "auth.json"))) return { ok: true };
+  if (codex || typeof cfg.cli_auth_credentials_store === "string" && cfg.cli_auth_credentials_store !== "file") return null;
+  return { ok: false, detail: "Codex is not signed in on this machine", fix: "npm install -g @openai/codex, then: codex login" };
+}
+async function checkAll(input, d) {
+  const ok = [];
+  const problems = [...input.before ?? []];
+  const add = (p) => problems.push(p);
+  const major = Number(d.nodeVersion.split(".")[0]);
+  if (!Number.isFinite(major) || major < NODE_MIN_MAJOR) {
+    add({ code: "node_too_old", severity: "fail", detail: `Node.js ${d.nodeVersion} is older than ${NODE_MIN_MAJOR}`, fix: `install Node.js ${NODE_MIN_MAJOR} or newer (https://nodejs.org), then: npm install -g @primusclaw/connector` });
+  } else ok.push(`Node.js ${d.nodeVersion}`);
+  const servicePath = input.by === "doctor" ? await installedServicePath(input.dirs) : null;
+  const same = (x, y) => x.length === y.length && x.every((v, i) => v === y[i]);
+  const checked = input.agents.filter((a) => !(a.attach && input.agents.some((b) => !b.attach && b.command === a.command && same(b.args, a.args) && same(b.roots, a.roots))));
+  const perAgent = await Promise.all(checked.map(async (a) => {
+    const env = agentEnv(d.env, a);
+    const family = familyOf(a);
+    const out = { ok: [], problems: [] };
+    const found = await which(a.command, env.PATH);
+    if (!found) {
+      out.problems.push({ code: "agent_cli_missing", severity: "fail", agent: a.id, detail: `${a.command} (the program agent ${a.id} runs) is not on PATH`, fix: installFix(a.command, family) });
+    } else {
+      out.ok.push(`${a.id}: ${a.command} is ${found}`);
+      if (servicePath !== null && a.env.PATH === void 0 && !await which(a.command, servicePath)) {
+        out.problems.push({ code: "service_path_missing", severity: "fail", agent: a.id, detail: `the installed service's PATH does not find ${a.command}, so the service cannot start agent ${a.id}`, fix: "claw-connector service install  (run it again from this shell: it carries this shell's PATH into the service)" });
+      }
+    }
+    if (family === "claude") {
+      const signed = await claudeSignedIn(env, d);
+      if (signed === false) out.problems.push({ code: "agent_not_signed_in", severity: "fail", agent: a.id, detail: "Claude Code is not signed in on this machine", fix: LOGIN_FIX.claude });
+      else if (signed) out.ok.push(`${a.id}: Claude Code is signed in`);
+    } else if (family === "codex") {
+      const auth = await codexAuth(env, d);
+      if (auth && !auth.ok) out.problems.push({ code: "agent_not_signed_in", severity: "fail", agent: a.id, detail: auth.detail, fix: auth.fix });
+      else if (auth?.ok) out.ok.push(`${a.id}: Codex can sign in`);
+    }
+    for (const root of a.roots) {
+      const why = await within2(Promise.resolve(d.writable(root)), d.fsTimeoutMs) ?? "ETIMEDOUT";
+      if (why === "ETIMEDOUT") continue;
+      if (why === null) out.ok.push(`${a.id}: ${root} is writable`);
+      else {
+        out.problems.push(why === "ENOENT" ? { code: "root_missing", severity: "fail", agent: a.id, detail: `${root} (a root of agent ${a.id}) does not exist`, fix: `mkdir -p ${shq(root)}  (or change roots in agents.toml)` } : { code: "root_not_writable", severity: "fail", agent: a.id, detail: `${root} (a root of agent ${a.id}) is not writable by ${d.user || "this user"}${why === "EROFS" ? " (a read-only file system)" : ""}`, fix: await rootFix(root, why, d) });
+      }
+    }
+    return out;
+  }));
+  for (const r of perAgent) {
+    ok.push(...r.ok);
+    problems.push(...r.problems);
+  }
+  for (const [upper, lower] of [["HTTPS_PROXY", "https_proxy"], ["HTTP_PROXY", "http_proxy"], ["NO_PROXY", "no_proxy"]]) {
+    const u = d.env[upper];
+    const l = d.env[lower];
+    if (u !== void 0 && l !== void 0 && u !== l) {
+      add({ code: "proxy_mismatch", severity: "warn", detail: `${upper} and ${lower} are set to different values${l === "" || u === "" ? " (one of them is empty)" : ""}; agents that read ${lower} (git, curl) take ${l === "" ? "no proxy" : "the other one"}`, fix: `export ${lower}="$${upper}"  (or unset the one you do not mean)` });
+    }
+  }
+  for (const name of ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"]) {
+    const v = d.env[name];
+    if (!v) continue;
+    try {
+      new URL(v);
+    } catch {
+      add({ code: "proxy_invalid", severity: "warn", detail: `${name} is not a URL`, fix: `export ${name}=http://HOST:PORT  (or unset it)` });
+    }
+  }
+  await checkSupervisor(input, d, ok, add);
+  if (input.by === "doctor" && input.server) {
+    const r = await d.get(`${input.server.replace(/\/+$/, "")}/health`);
+    const shown = withoutUserinfo(input.server);
+    if ("status" in r && r.status < 500) ok.push(`Claw answers at ${shown}`);
+    else {
+      const why = "status" in r ? `HTTP ${r.status}` : r.error;
+      const proxied = ["HTTPS_PROXY", "https_proxy"].some((k) => set(d.env, k));
+      const untrusted = /certificate|self[- ]signed|UNABLE_TO_GET_ISSUER|CERT_/i.test(why);
+      if (untrusted) {
+        add({
+          code: "claw_tls_untrusted",
+          severity: "fail",
+          detail: `Node.js does not trust the certificate of ${shown} (${why.split(input.server).join(shown)})`,
+          fix: "export NODE_USE_SYSTEM_CA=1  (Node.js then trusts the CAs this machine trusts; or NODE_EXTRA_CA_CERTS=/path/to/ca.pem), then run the connector again; an installed service: claw-connector service install again so it carries it"
+        });
+      } else add({
+        code: "claw_unreachable",
+        severity: "fail",
+        detail: `${shown} does not answer (${why.split(input.server).join(shown)})`,
+        fix: proxied && !set(d.env, "NODE_USE_ENV_PROXY") ? "export NODE_USE_ENV_PROXY=1  (Node.js only uses HTTPS_PROXY when it is set; needs Node 22.21+ or 24+), then run the connector again" : `check that this machine reaches it: curl -sS ${shown.replace(/\/+$/, "")}/health`
+      });
+    }
+  }
+  return { checked_at: new Date(d.now()).toISOString(), by: input.by, ok, problems: dedupe(problems) };
+}
+function withoutUserinfo(v) {
+  try {
+    const u = new URL(v);
+    return `${u.protocol}//${u.host}${u.pathname === "/" && !v.endsWith("/") ? "" : u.pathname}`;
+  } catch {
+    return v.replace(/\/\/[^/@]*@/, "//").replace(/[?#].*$/, "");
+  }
+}
+function dedupe(ps) {
+  const seen = /* @__PURE__ */ new Set();
+  return ps.filter((p) => {
+    const k = `${p.code}\0${p.detail}`;
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+async function rootFix(root, why, d) {
+  if (why === "EROFS") return "pick a root on a writable disk in agents.toml";
+  const owner = await within2(fsp.stat(root).then((st) => st.uid, () => null));
+  if (owner !== null && d.uid !== null && owner !== d.uid) return `pick a root you own in agents.toml (${root} belongs to uid ${owner})`;
+  return `chmod u+w ${shq(root)}  (or pick a root you own in agents.toml)`;
+}
+var shq = (s) => /^[A-Za-z0-9_./~:@%+-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+async function installedSupervisorOf(dirs) {
+  const v = await readJson(serviceFile(dirs));
+  return v && typeof v.supervisor === "string" ? v.supervisor : null;
+}
+async function checkSupervisor(input, d, ok, add) {
+  const sup = await installedSupervisorOf(input.dirs);
+  if (sup === null) {
+    add({ code: "no_service", severity: "warn", detail: "the connector is not installed as a service: nothing starts it again after it dies or the machine restarts", fix: "claw-connector service install" });
+    return;
+  }
+  if (sup === "systemd") {
+    if (d.platform !== "linux") return;
+    const linger = await d.exec("loginctl", ["show-user", d.user, "-p", "Linger", "--value"]);
+    if (linger.code === 0 && linger.out.trim() !== "yes") {
+      add({ code: "linger_off", severity: "warn", detail: "the systemd user service stops when you log out and does not start at boot", fix: `loginctl enable-linger ${d.user}` });
+    } else ok.push("service: systemd --user");
+    return;
+  }
+  if (sup === "script") {
+    const last = await within2(fsp.stat(keepaliveStampFile(input.dirs)).then((st) => st.mtimeMs, () => 0)) ?? 0;
+    if (d.now() - last <= KEEPALIVE_STALE_MS) {
+      ok.push("service: keep-alive script, called recently");
+      return;
+    }
+    const script = keepaliveFile(input.dirs);
+    const tab = await d.crontab();
+    if (tab !== null && tab.split("\n").some((l) => !l.trim().startsWith("#") && l.includes(script))) {
+      ok.push("service: keep-alive script in crontab");
+      return;
+    }
+    add({
+      code: "keepalive_not_scheduled",
+      severity: "warn",
+      detail: `nothing has run ${script} in the last ${KEEPALIVE_STALE_MS / 6e4} minutes: after a restart the connector stays offline`,
+      fix: `add to crontab -e (or the container's startup hook): */5 * * * * sh ${script}`
+    });
+    return;
+  }
+  ok.push(`service: ${sup}`);
+}
+async function installedServicePath(dirs, home = os6.homedir(), xdgConfig) {
+  const v = await readJson(serviceFile(dirs));
+  if (!v) return null;
+  if (typeof v.path === "string") return v.path;
+  if (v.supervisor === "script") {
+    const m = (await readText(keepaliveFile(dirs)))?.match(/^export PATH='((?:[^']|'\\'')*)'$/m);
+    return m ? m[1].replace(/'\\''/g, "'") : null;
+  }
+  if (v.supervisor === "systemd") {
+    const unit = await readText(path18.join(xdgConfig?.trim() || path18.join(home, ".config"), "systemd", "user", "claw-connector.service"));
+    const m = unit?.match(/^Environment="PATH=((?:[^"\\]|\\.)*)"$/m);
+    return m ? m[1].replace(/\\(.)/g, "$1").replace(/%%/g, "%") : null;
+  }
+  if (v.supervisor === "launchd") {
+    const plist = await readText(path18.join(home, "Library", "LaunchAgents", "com.primusclaw.connector.plist"));
+    const m = plist?.match(/<key>PATH<\/key><string>([^<]*)<\/string>/);
+    return m ? m[1].replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&") : null;
+  }
+  return null;
+}
+function agentHealth(report, agentId) {
+  const cut = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+  const mine = report.problems.filter((p) => p.agent === void 0 || p.agent === agentId);
+  mine.sort((a, b) => a.severity === b.severity ? 0 : a.severity === "fail" ? -1 : 1);
+  return {
+    checked_at: report.checked_at,
+    problems: mine.slice(0, MAX_REPORTED2).map((p) => ({ code: p.code, severity: p.severity, scope: p.agent === void 0 ? "machine" : "agent", detail: cut(p.detail, 200), fix: cut(p.fix, 200) }))
+  };
+}
+function writeReport(dirs, report) {
+  try {
+    fs15.mkdirSync(dirs.state, { recursive: true, mode: 448 });
+    const file = doctorFile(dirs);
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs15.writeFileSync(tmp, JSON.stringify(report, null, 2) + "\n", { mode: 384 });
+    fs15.renameSync(tmp, file);
+  } catch {
+  }
+}
+function formatReport(r) {
+  const lines = r.ok.map((l) => `ok    ${l}`);
+  for (const p of r.problems) {
+    lines.push(`${p.severity === "fail" ? "FAIL" : "warn"}  ${p.agent ? `${p.agent}: ` : ""}${p.detail}`);
+    lines.push(`      fix: ${p.fix}`);
+  }
+  const fails = r.problems.filter((p) => p.severity === "fail").length;
+  const warns = r.problems.length - fails;
+  lines.push("");
+  lines.push(r.problems.length === 0 ? "No problems found." : `${fails} problem${fails === 1 ? " that stops" : "s that stop"} sessions, ${warns} warning${warns === 1 ? "" : "s"}.`);
+  return lines;
+}
+
+// src/connector.ts
+function withHealth(base, health, limit = REMOTE_AGENT_LIMITS.maxCapabilitiesBytes / 2) {
+  if (!health) return base;
+  const size = (c) => new TextEncoder().encode(JSON.stringify(c)).length;
+  const problems = [...health.problems];
+  for (; ; ) {
+    const caps = { ...base, health: { ...health, problems } };
+    if (size(caps) <= limit) return caps;
+    if (problems.length === 0) return base;
+    problems.pop();
+  }
+}
+var RESTART_RECONNECT_GAP_MS = 5e3;
+var READ_ONLY_HINT = `sessions of this agent start read-only: it answers and plans but changes no file. To let phone sessions write code, set approval = "never" for this agent in agents.toml on that machine and restart the connector`;
+var DEFAULT_TIMING = {
+  ...DEFAULT_SESSION_TIMING,
+  heartbeatMs: REMOTE_AGENT_TIMING.heartbeatMs,
+  watchdogMs: REMOTE_AGENT_TIMING.watchdogMs,
+  batchMs: 150,
+  batchMax: 20,
+  backoffMinMs: 1e3,
+  backoffMaxMs: 6e4,
+  pausePollMs: 1e3,
+  catalogMs: 12e4,
+  sessionsWatchMs: 1e4,
+  attachCliMs: 8e3,
+  recentWriteMs: 1e4,
+  authFailLimit: 4,
+  authFailWindowMs: 12e4,
+  healthMs: RECHECK_MS,
+  healthMinGapMs: 5e3,
+  limitRetryMs: 10 * 6e4
+};
+var CONNECTOR_LIMIT_HINT = "Claw already holds the most connectors one person may have, so it will not register this machine: remove machines you no longer use (in the chat: /agents, or claw-connector logout on that machine). This connector tries again every 10 minutes by itself.";
+var isConnectorLimit = (e) => e instanceof HttpError && e.status === 409 && e.code === "connector_limit_reached";
+var CommandLedger = class {
+  inflight = /* @__PURE__ */ new Set();
+  inflightIds = /* @__PURE__ */ new Set();
+  ids;
+  highest = 0;
+  floor;
+  constructor(cursor = 0, handled = []) {
+    this.floor = cursor;
+    this.highest = cursor;
+    this.ids = [...handled];
   }
   /** Whether this command was already carried out (or is being carried out now). */
   seen(seq, cmdId) {
@@ -4085,6 +4940,11 @@ var Connector = class {
   lastFrame = "";
   wakeSender = null;
   wakeHeartbeat = null;
+  /** The last health report (null until the first check finishes, or when none is configured). */
+  healthReport = null;
+  wakeHealth = null;
+  healthAsked = false;
+  lastHealthAsk = 0;
   streamCtl = null;
   ctl = new AbortController();
   /** Every event leaves through here: scrubbed of credential shapes, numbered, written to disk, then posted. */
@@ -4106,16 +4966,19 @@ var Connector = class {
   }
   async descriptors() {
     return Promise.all(this.d.config.agents.map(async (a) => {
+      const readOnly = a.readOnlyModes.includes(a.askMode);
       const support = this.attach.get(a.id);
-      const base = {
+      const base = withHealth({
         ask_mode: a.askMode,
         modes: a.safeModes,
         roots: a.roots.slice(0, 8),
         protocol: 1,
         unattended: a.unattended,
         unattended_allowed: a.allowUnsafeModes,
-        ...support ? { watch_live: true } : {}
-      };
+        ...support ? { watch_live: true } : {},
+        ...a.readOnlyModes.length ? { read_only_modes: a.readOnlyModes } : {},
+        ...readOnly ? { edits: false, edits_hint: READ_ONLY_HINT } : {}
+      }, this.healthReport ? agentHealth(this.healthReport, a.id) : null);
       const capabilities = support ? fitResumable(base, await support.resumable()) : base;
       return { agent_id: a.id, kind: a.kind, name: a.name, capabilities };
     }));
@@ -4123,7 +4986,7 @@ var Connector = class {
   // --- identity -------------------------------------------------------------------
   readIdentity() {
     try {
-      const raw = JSON.parse(fs15.readFileSync(identityFile(this.d.dirs), "utf8"));
+      const raw = JSON.parse(fs16.readFileSync(identityFile(this.d.dirs), "utf8"));
       if (isObject(raw) && raw.server === this.d.server && typeof raw.connector_id === "string") {
         return { server: raw.server, connector_id: raw.connector_id, cursor: typeof raw.cursor === "number" ? raw.cursor : 0, handled: Array.isArray(raw.handled) ? raw.handled.filter((x) => typeof x === "string") : [] };
       }
@@ -4134,9 +4997,9 @@ var Connector = class {
   writeIdentity() {
     const st = { server: this.d.server, connector_id: this.cid, cursor: this.ledger.cursor, handled: this.ledger.recentIds, ...this.rowRevoked ? { revoked: true } : {} };
     const file = identityFile(this.d.dirs);
-    fs15.mkdirSync(this.d.dirs.state, { recursive: true, mode: 448 });
-    fs15.writeFileSync(`${file}.tmp`, JSON.stringify(st), { mode: 384 });
-    fs15.renameSync(`${file}.tmp`, file);
+    fs16.mkdirSync(this.d.dirs.state, { recursive: true, mode: 448 });
+    fs16.writeFileSync(`${file}.tmp`, JSON.stringify(st), { mode: 384 });
+    fs16.renameSync(`${file}.tmp`, file);
   }
   /** Use the connector id this machine already has, or register a new one. */
   async identify(forceNew = false) {
@@ -4178,6 +5041,7 @@ var Connector = class {
    * fix and ends the run with its message.
    */
   async startup() {
+    let atLimit = false;
     for (let attempt = 0; !this.ctl.signal.aborted; attempt++) {
       try {
         await this.identify();
@@ -4188,6 +5052,17 @@ var Connector = class {
           await this.onRevoked(e);
           return "revoked";
         }
+        if (isConnectorLimit(e)) {
+          if (!atLimit) {
+            atLimit = true;
+            this.d.log.error(CONNECTOR_LIMIT_HINT, { error: errMessage(e) });
+            this.d.audit.record("connector_limit_reached", {});
+            recordDisconnect(this.d.dirs, { reason: "connector_limit_reached", detail: CONNECTOR_LIMIT_HINT });
+          }
+          await sleep(this.timing.limitRetryMs, this.ctl.signal);
+          while (!this.ctl.signal.aborted && fs16.existsSync(pauseFile(this.d.dirs))) await sleep(this.timing.pausePollMs, this.ctl.signal);
+          continue;
+        }
         if (!isTransient(e)) throw e;
         this.d.log.warn("cannot reach Claw yet; will retry", { error: errMessage(e), attempt });
         await sleep(backoffMs(attempt, this.timing.backoffMinMs, this.timing.backoffMaxMs), this.ctl.signal);
@@ -4243,7 +5118,7 @@ var Connector = class {
   }
   async pauseWatcher() {
     while (!this.ctl.signal.aborted) {
-      const want = fs15.existsSync(pauseFile(this.d.dirs));
+      const want = fs16.existsSync(pauseFile(this.d.dirs));
       if (want && !this.paused) {
         this.paused = true;
         this.d.audit.record("paused");
@@ -4258,6 +5133,63 @@ var Connector = class {
       await sleep(this.timing.pausePollMs, this.ctl.signal);
     }
   }
+  /**
+   * Check the machine at start, every `healthMs`, and when asked (`recheckHealth`: `claw-connector doctor` signals a running
+   * connector after it ran). A changed result is sent with an early heartbeat. A check that throws keeps the last report, and
+   * a stop never waits for one: it must never take the connection down. Nothing here touches the file system itself (the
+   * checks run in a child process: see commands.ts `runHealth`), so a stalled disk cannot reach this process.
+   */
+  async healthWatcher() {
+    const check = this.d.health;
+    if (!check) return;
+    while (!this.ctl.signal.aborted) {
+      this.healthAsked = false;
+      try {
+        const before = this.healthReport ? JSON.stringify(this.healthReport.problems) : null;
+        let onAbort = () => {
+        };
+        const stopped = new Promise((resolve) => {
+          onAbort = () => resolve(null);
+          if (this.ctl.signal.aborted) resolve(null);
+          else this.ctl.signal.addEventListener("abort", onAbort, { once: true });
+        });
+        let report;
+        try {
+          report = await Promise.race([check(this.ctl.signal), stopped]);
+        } finally {
+          this.ctl.signal.removeEventListener("abort", onAbort);
+        }
+        if (report === null) break;
+        this.healthReport = report;
+        if (JSON.stringify(this.healthReport.problems) !== before) {
+          this.d.log.info("health", { problems: this.healthReport.problems.map((p) => `${p.agent ?? "machine"}:${p.code}`) });
+          this.wakeHeartbeat?.();
+        }
+      } catch (e) {
+        this.d.log.warn("health check failed", { error: errMessage(e) });
+      }
+      if (this.healthAsked) continue;
+      await new Promise((resolve) => {
+        const done = () => {
+          clearTimeout(t);
+          this.wakeHealth = null;
+          this.ctl.signal.removeEventListener("abort", done);
+          resolve();
+        };
+        const t = setTimeout(done, this.timing.healthMs);
+        this.wakeHealth = done;
+        this.ctl.signal.addEventListener("abort", done, { once: true });
+      });
+    }
+  }
+  /** Check the machine again now (a `doctor` run asks; at most once per `healthMinGapMs`, so a burst of asks is one check). */
+  recheckHealth() {
+    const now = Date.now();
+    if (now - this.lastHealthAsk < this.timing.healthMinGapMs) return;
+    this.lastHealthAsk = now;
+    this.healthAsked = true;
+    this.wakeHealth?.();
+  }
   // --- the loops -----------------------------------------------------------------------
   /** Post events in batches, one request at a time and in order, until everything is acknowledged. */
   async sender() {
@@ -4438,51 +5370,57 @@ var Connector = class {
   }
   /** Run until stopped or revoked. Always leaves no adapter process behind. */
   async run() {
-    fs15.mkdirSync(this.d.dirs.state, { recursive: true, mode: 448 });
+    fs16.mkdirSync(this.d.dirs.state, { recursive: true, mode: 448 });
     await this.registry.killAll();
     for (const p of this.store.takePending()) {
       this.d.audit.record("permission_orphaned", { session_id: p.session_id, action_id: p.action_id });
       this.emit(p.session_id, "permission_resolved", { actionId: p.action_id, optionId: null, outcome: "cancelled", by: "connector_restart" });
     }
+    let downForMs = null;
+    try {
+      downForMs = Math.max(0, Date.now() - fs16.statSync(identityFile(this.d.dirs)).mtimeMs);
+    } catch {
+    }
     const pidf = pidFile(this.d.dirs);
     let leftover = false;
     try {
-      fs15.readFileSync(pidf);
+      fs16.readFileSync(pidf);
       leftover = true;
     } catch {
     }
     if (leftover) {
       let last;
       try {
-        last = fs15.statSync(identityFile(this.d.dirs)).mtime.toISOString();
+        last = fs16.statSync(identityFile(this.d.dirs)).mtime.toISOString();
       } catch {
       }
       recordDisconnect(this.d.dirs, { reason: "process_died", detail: `the previous run ended without shutting down (killed, crashed, or the machine restarted)${last ? `; last heartbeat ${last}` : ""}`, ...last ? { at: last } : {} });
     }
-    fs15.writeFileSync(pidf, JSON.stringify({ pid: process.pid, start: processStart(process.pid) ?? "" }), { mode: 384 });
-    this.paused = fs15.existsSync(pauseFile(this.d.dirs));
+    fs16.writeFileSync(pidf, JSON.stringify({ pid: process.pid, start: processStart(process.pid) ?? "" }), { mode: 384 });
+    this.paused = fs16.existsSync(pauseFile(this.d.dirs));
     let result = "stopped";
     let failure = "";
     try {
       const up = await this.startup();
       if (up !== "ok") return result = up;
       await this.manager.restoreReadOnly();
+      this.manager.recover({ downForMs, mayContinue: !this.paused && !fs16.existsSync(pauseFile(this.d.dirs)) });
       this.d.audit.record("connector_online", {
         connector_id: this.cid,
         agents: this.d.config.agents.map((a) => a.id),
         paused: this.paused,
         unattended_agents: this.d.config.agents.filter((a) => a.unattended).map((a) => a.id)
       });
-      await Promise.all([this.sender(), this.heartbeater(), this.streamLoop(), this.pauseWatcher(), this.sessionsWatcher()]);
+      await Promise.all([this.sender(), this.heartbeater(), this.streamLoop(), this.pauseWatcher(), this.sessionsWatcher(), this.healthWatcher()]);
       result = this.revoked ? "revoked" : this.authFailed ? "auth_failed" : "stopped";
     } catch (e) {
       failure = errMessage(e);
       throw e;
     } finally {
-      await this.manager.killAll(this.revoked ? "revoked" : "stopped").catch(() => void 0);
+      await this.manager.killAll(this.revoked ? "revoked" : "stopped", !this.revoked && !this.authFailed).catch(() => void 0);
       const reason = this.revoked ? "revoked" : this.authFailed ? "auth_failed" : failure ? "failed" : this.paused ? "stopped_while_paused" : result;
       recordDisconnect(this.d.dirs, { reason, detail: this.authWhy || failure || void 0 });
-      fs15.rmSync(pidf, { force: true });
+      fs16.rmSync(pidf, { force: true });
     }
     return result;
   }
@@ -4498,12 +5436,13 @@ var Connector = class {
 };
 
 // src/service.ts
-import { spawn as spawn3, spawnSync } from "node:child_process";
-import fs16 from "node:fs";
-import os5 from "node:os";
-import path17 from "node:path";
+import { spawn as spawn4, spawnSync } from "node:child_process";
+import fs17 from "node:fs";
+import os7 from "node:os";
+import path19 from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
+import { parse as parseToml3 } from "smol-toml";
 var SUPERVISORS = ["systemd", "launchd", "script"];
 var UNIT = "claw-connector.service";
 var LABEL = "com.primusclaw.connector";
@@ -4512,11 +5451,14 @@ var NEEDS_PERSON = 78;
 var CARRIED_ENV = [
   "PATH",
   "CLAW_CONNECTOR_HOME",
+  "CLAW_CONNECTOR_CONFIG_DIR",
   "XDG_CONFIG_HOME",
   "XDG_STATE_HOME",
   "CLAUDE_CONFIG_DIR",
   "CODEX_HOME",
   "NODE_EXTRA_CA_CERTS",
+  "NODE_USE_SYSTEM_CA",
+  "NODE_USE_ENV_PROXY",
   "SSL_CERT_FILE",
   "HTTPS_PROXY",
   "https_proxy",
@@ -4524,27 +5466,97 @@ var CARRIED_ENV = [
   "http_proxy",
   "NO_PROXY",
   "no_proxy",
-  "LANG"
+  "LANG",
+  "IS_SANDBOX",
+  "npm_config_registry",
+  "NPM_CONFIG_REGISTRY",
+  "npm_config_proxy",
+  "npm_config_https_proxy",
+  "AWS_REGION",
+  "AWS_PROFILE",
+  "CLOUD_ML_REGION",
+  "GOOGLE_APPLICATION_CREDENTIALS"
+];
+var AGENT_SETTING = /^(?:ANTHROPIC|CLAUDE_CODE|OPENAI|CODEX|CURSOR)_/;
+var TERMINAL_SESSION = /^(?:CLAUDE_CODE_(?:ENTRYPOINT|SSE_PORT|SESSION|CHILD_SESSION|MESSAGING|EXECPATH|IDE|GIT_BASH)|CODEX_(?:SANDBOX|THREAD|SESSION|MANAGED|INTERNAL|CI))/;
+var SECRET_NAME = /KEY|TOKEN(?!S)|SECRET|PASSWORD|CREDENTIAL/i;
+var AGENT_SECRETS = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "ANTHROPIC_CUSTOM_HEADERS",
+  "OPENAI_API_KEY",
+  "CODEX_API_KEY",
+  "CURSOR_API_KEY",
+  "AWS_ACCESS_KEY_ID",
+  "AWS_SECRET_ACCESS_KEY",
+  "AWS_SESSION_TOKEN"
 ];
-var SECRET_NAME = /KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL/i;
+var NEVER_CARRIED = /* @__PURE__ */ new Set(["CLAW_CONNECTOR_KEY"]);
+function accountName(env, uid, userInfo = os7.userInfo) {
+  if (env.USER) return env.USER;
+  if (env.LOGNAME) return env.LOGNAME;
+  try {
+    return userInfo().username;
+  } catch {
+    return String(uid);
+  }
+}
+function cronDaemonRunning(proc = "/proc") {
+  let self;
+  let pids;
+  try {
+    self = fs17.readlinkSync(`${proc}/self/ns/mnt`);
+    pids = fs17.readdirSync(proc).filter((n) => /^\d+$/.test(n));
+  } catch {
+    return false;
+  }
+  for (const pid of pids) {
+    try {
+      if (!/^(?:cron|crond|busybox)$/.test(fs17.readFileSync(`${proc}/${pid}/comm`, "utf8").trim())) continue;
+      if (!/cron/.test(fs17.readFileSync(`${proc}/${pid}/cmdline`, "utf8"))) continue;
+      if (fs17.readlinkSync(`${proc}/${pid}/ns/mnt`) === self) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function systemCrontab() {
+  return {
+    readCrontab: () => {
+      if (!cronDaemonRunning()) return null;
+      const r = spawnSync("crontab", ["-l"], { encoding: "utf8", timeout: 1e4, stdio: ["ignore", "pipe", "pipe"] });
+      if (r.error) return null;
+      return r.status === 0 ? r.stdout : /no crontab/i.test(r.stderr ?? "") ? "" : null;
+    },
+    writeCrontab: (text) => {
+      const r = spawnSync("crontab", ["-"], { input: text, encoding: "utf8", timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] });
+      return !r.error && r.status === 0;
+    }
+  };
+}
 function deps(ctx) {
   const d = ctx.service ?? {};
+  const uid = d.uid ?? (process.getuid?.() ?? 0);
+  const cron = d.readCrontab && d.writeCrontab ? null : systemCrontab();
   return {
     platform: d.platform ?? process.platform,
-    home: d.home ?? os5.homedir(),
-    uid: d.uid ?? (process.getuid?.() ?? 0),
-    user: d.user ?? (ctx.env.USER || os5.userInfo().username),
+    home: d.home ?? os7.homedir(),
+    uid,
+    user: d.user ?? accountName(ctx.env, uid),
+    readCrontab: d.readCrontab ?? cron.readCrontab,
+    writeCrontab: d.writeCrontab ?? cron.writeCrontab,
     exec: d.exec ?? ((cmd, args) => {
       const r = spawnSync(cmd, args, { encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"] });
       return { code: r.error ? null : r.status, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
     }),
     node: d.node ?? ctx.node ?? process.execPath,
     cli: d.cli ?? fileURLToPath(import.meta.url),
-    systemdBooted: d.systemdBooted ?? (() => fs16.existsSync("/run/systemd/system"))
+    systemdBooted: d.systemdBooted ?? (() => fs17.existsSync("/run/systemd/system"))
   };
 }
-var systemdUnitPath = (ctx, d) => path17.join(ctx.env.XDG_CONFIG_HOME?.trim() || path17.join(d.home, ".config"), "systemd", "user", UNIT);
-var launchdPlistPath = (d) => path17.join(d.home, "Library", "LaunchAgents", `${LABEL}.plist`);
+var systemdUnitPath = (ctx, d) => path19.join(ctx.env.XDG_CONFIG_HOME?.trim() || path19.join(d.home, ".config"), "systemd", "user", UNIT);
+var launchdPlistPath = (d) => path19.join(d.home, "Library", "LaunchAgents", `${LABEL}.plist`);
 function detectSupervisor(d) {
   if (d.platform === "darwin") return "launchd";
   if (!d.systemdBooted()) return "script";
@@ -4554,29 +5566,71 @@ function detectSupervisor(d) {
 var hasUserinfo = (v) => {
   try {
     const u = new URL(v);
-    return u.username !== "" || u.password !== "";
+    if (u.username !== "" || u.password !== "") return true;
   } catch {
-    return /\/\/[^/]*@/.test(v);
   }
+  return /\/\/[^/\s]*@/.test(v);
 };
-function carriedEnv(env, extra = []) {
+function codexEnvKeys(env, home) {
+  const dir = env.CODEX_HOME?.trim() || path19.join(home, ".codex");
+  try {
+    const doc = parseToml3(fs17.readFileSync(path19.join(dir, "config.toml"), "utf8"));
+    const providers = isObject(doc.model_providers) ? doc.model_providers : {};
+    return Object.values(providers).flatMap((p) => isObject(p) && typeof p.env_key === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(p.env_key) ? [p.env_key] : []);
+  } catch {
+    return [];
+  }
+}
+function carriedEnv(env, extra = [], secretNames = AGENT_SECRETS) {
   const vars = [];
+  const secrets = [];
   const refused = [];
   const withheld = [];
-  for (const name of /* @__PURE__ */ new Set([...CARRIED_ENV, ...extra])) {
-    if (!CARRIED_ENV.includes(name) && SECRET_NAME.test(name)) {
-      refused.push(name);
+  const settings = Object.keys(env).filter((k) => AGENT_SETTING.test(k) && !TERMINAL_SESSION.test(k)).sort();
+  for (const name of /* @__PURE__ */ new Set([...CARRIED_ENV, ...settings, ...secretNames, ...extra])) {
+    if (NEVER_CARRIED.has(name)) {
+      if (extra.includes(name)) refused.push(name);
       continue;
     }
     const v = env[name];
     if (v === void 0 || v === "") continue;
-    if (/proxy$/i.test(name) && hasUserinfo(v) && !extra.includes(name)) {
+    const proxy = /proxy$/i.test(name);
+    const secret = !CARRIED_ENV.includes(name) && (SECRET_NAME.test(name) || secretNames.includes(name)) || !proxy && hasUserinfo(v);
+    if (secret) {
+      secrets.push([name, v]);
+      continue;
+    }
+    if (proxy && hasUserinfo(v) && !extra.includes(name)) {
+      withheld.push(name);
+      continue;
+    }
+    if (/[\r\n]/.test(v)) {
       withheld.push(name);
       continue;
     }
     vars.push([name, v]);
   }
-  return { vars, refused, withheld };
+  return { vars, secrets, refused, withheld };
+}
+function applyServiceEnv(agents, kept, env) {
+  const used = /* @__PURE__ */ new Set();
+  for (const a of agents) {
+    for (const [k, v] of Object.entries(kept)) {
+      if (env[k] !== void 0 || Object.hasOwn(a.env, k)) continue;
+      a.env = { ...a.env, [k]: v };
+      used.add(k);
+    }
+  }
+  return [...used].sort();
+}
+function loadServiceEnv(file) {
+  try {
+    const raw = JSON.parse(fs17.readFileSync(file, "utf8"));
+    if (!isObject(raw)) return {};
+    return Object.fromEntries(Object.entries(raw).filter((e) => typeof e[1] === "string" && !NEVER_CARRIED.has(e[0])));
+  } catch {
+    return {};
+  }
 }
 var sdEnv = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%")}"`;
 var sdQuote = (s) => sdEnv(s).replace(/\$/g, "$$$$");
@@ -4645,7 +5699,7 @@ exec ${sh(d.node)} ${sh(d.cli)} service ensure
 }
 function readPidRec(file) {
   try {
-    const raw = JSON.parse(fs16.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs17.readFileSync(file, "utf8"));
     if (isObject(raw) && typeof raw.pid === "number" && typeof raw.start === "string" && raw.start !== "") return { pid: raw.pid, start: raw.start };
   } catch {
   }
@@ -4665,8 +5719,8 @@ async function supervise(ctx, o = {}) {
     ctx.err(`a supervisor is already running (pid ${other})`);
     return 1;
   }
-  fs16.mkdirSync(ctx.dirs.state, { recursive: true, mode: 448 });
-  fs16.writeFileSync(pidf, JSON.stringify({ pid: process.pid, start: processStart(process.pid) ?? "" }), { mode: 384 });
+  fs17.mkdirSync(ctx.dirs.state, { recursive: true, mode: 448 });
+  fs17.writeFileSync(pidf, JSON.stringify({ pid: process.pid, start: processStart(process.pid) ?? "" }), { mode: 384 });
   let stopping2 = false;
   let child = null;
   const wake = new AbortController();
@@ -4681,7 +5735,7 @@ async function supervise(ctx, o = {}) {
   o.signal?.addEventListener("abort", () => onSig("SIGTERM"), { once: true });
   try {
     for (let round = 0; !stopping2; round++) {
-      child = spawn3(cmd, args, { stdio: ["ignore", "inherit", "inherit"], env: ctx.env });
+      child = spawn4(cmd, args, { stdio: ["ignore", "inherit", "inherit"], env: ctx.env });
       const c = child;
       const { code, signal } = await new Promise((resolve) => {
         c.once("exit", (code2, signal2) => resolve({ code: code2, signal: signal2 }));
@@ -4710,13 +5764,14 @@ async function supervise(ctx, o = {}) {
   } finally {
     for (const [s, h] of handlers) process.off(s, h);
     const rec = readPidRec(pidf);
-    if (rec?.pid === process.pid) fs16.rmSync(pidf, { force: true });
+    if (rec?.pid === process.pid) fs17.rmSync(pidf, { force: true });
   }
 }
 async function cmdSupervise(_args, ctx) {
   return supervise(ctx);
 }
-async function ensure(ctx, d, h) {
+async function ensure(ctx, d, h, o = {}) {
+  if (!o.byInstall) stampKeepalive(ctx);
   const sup = supervisorPid(ctx);
   if (sup !== null) {
     ctx.out(`supervisor running (pid ${sup})`);
@@ -4732,17 +5787,24 @@ async function ensure(ctx, d, h) {
     ctx.out(`the connector is running (pid ${run2}) without the supervisor; leaving it`);
     return 0;
   }
-  fs16.mkdirSync(ctx.dirs.state, { recursive: true, mode: 448 });
-  const log = fs16.openSync(runLogFile(ctx.dirs), "a", 384);
+  fs17.mkdirSync(ctx.dirs.state, { recursive: true, mode: 448 });
+  const log = fs17.openSync(runLogFile(ctx.dirs), "a", 384);
   try {
-    const p = spawn3(d.node, [d.cli, "supervise"], { detached: true, cwd: d.home, stdio: ["ignore", log, log], env: ctx.env });
+    const p = spawn4(d.node, [d.cli, "supervise"], { detached: true, cwd: d.home, stdio: ["ignore", log, log], env: ctx.env });
     p.unref();
     ctx.out(`started the supervisor (pid ${p.pid}); log: ${runLogFile(ctx.dirs)}`);
   } finally {
-    fs16.closeSync(log);
+    fs17.closeSync(log);
   }
   return 0;
 }
+function stampKeepalive(ctx) {
+  try {
+    fs17.mkdirSync(ctx.dirs.state, { recursive: true, mode: 448 });
+    fs17.writeFileSync(keepaliveStampFile(ctx.dirs), (/* @__PURE__ */ new Date()).toISOString() + "\n", { mode: 384 });
+  } catch {
+  }
+}
 async function cmdService(args, ctx, h) {
   const [sub, ...rest] = args;
   const usage = "usage: claw-connector service install|uninstall|status [--supervisor systemd|launchd|script] [--env NAME ...]";
@@ -4769,7 +5831,7 @@ async function cmdService(args, ctx, h) {
 }
 function installedSupervisor(ctx) {
   try {
-    const raw = JSON.parse(fs16.readFileSync(serviceFile(ctx.dirs), "utf8"));
+    const raw = JSON.parse(fs17.readFileSync(serviceFile(ctx.dirs), "utf8"));
     if (isObject(raw) && typeof raw.supervisor === "string" && SUPERVISORS.includes(raw.supervisor)) return raw.supervisor;
   } catch {
   }
@@ -4789,11 +5851,67 @@ function startAfterLogin(ctx, h) {
   }
   ctx.out(r.code === 0 ? `started the ${sup} service again` : `could not start the ${sup} service (${r.out || `exit ${r.code}`}); run: claw-connector service install`);
 }
+var UnsafeDirError = class extends Error {
+};
+function writeSecretFile(file, body) {
+  const dir = path19.dirname(file);
+  fs17.mkdirSync(dir, { recursive: true, mode: 448 });
+  let dfd;
+  try {
+    dfd = fs17.openSync(dir, fs17.constants.O_RDONLY | (fs17.constants.O_DIRECTORY ?? 0) | (fs17.constants.O_NOFOLLOW ?? 0));
+  } catch (e) {
+    throw new UnsafeDirError(`${dir} cannot be opened as a directory of its own (${e.code ?? errMessage(e)}; a link is not followed): the agents' sign-in variables are not written there (set CLAW_CONNECTOR_CONFIG_DIR to a directory of your own)`);
+  }
+  try {
+    const st = fs17.fstatSync(dfd);
+    const uid = process.getuid?.();
+    if (!st.isDirectory() || uid !== void 0 && st.uid !== uid) {
+      throw new UnsafeDirError(`${dir} is ${!st.isDirectory() ? "not a directory" : "owned by another account"}: the agents' sign-in variables are not written there (set CLAW_CONNECTOR_CONFIG_DIR to a directory of your own)`);
+    }
+    if ((st.mode & 63) !== 0) fs17.fchmodSync(dfd, 448);
+    let anchored;
+    if (fs17.existsSync(`/proc/self/fd/${dfd}`)) anchored = `/proc/self/fd/${dfd}`;
+    else {
+      const real = fs17.realpathSync(dir);
+      const rs = fs17.statSync(real);
+      if (rs.dev !== st.dev || rs.ino !== st.ino) throw new UnsafeDirError(`${dir} changed while it was being checked; the agents' sign-in variables are not written there`);
+      const weak = renamableAncestor(real);
+      if (weak) throw new UnsafeDirError(`${weak} can be changed by other accounts, so ${dir} could be swapped while the agents' sign-in variables are written; they are not written there (set CLAW_CONNECTOR_CONFIG_DIR to a directory of your own)`);
+      anchored = real;
+    }
+    const tmp = path19.join(anchored, `${path19.basename(file)}.${process.pid}.${Date.now()}.tmp`);
+    const fd = fs17.openSync(tmp, fs17.constants.O_WRONLY | fs17.constants.O_CREAT | fs17.constants.O_EXCL | (fs17.constants.O_NOFOLLOW ?? 0), 384);
+    try {
+      fs17.writeSync(fd, body);
+      fs17.fchmodSync(fd, 384);
+    } finally {
+      fs17.closeSync(fd);
+    }
+    fs17.renameSync(tmp, path19.join(anchored, path19.basename(file)));
+  } finally {
+    fs17.closeSync(dfd);
+  }
+}
+function renamableAncestor(dir, uid = process.getuid?.()) {
+  for (let p = path19.dirname(path19.resolve(dir)); ; p = path19.dirname(p)) {
+    let st;
+    try {
+      st = fs17.lstatSync(p);
+    } catch {
+      return p;
+    }
+    if (!st.isDirectory()) return p;
+    const owner = st.uid === 0 || uid === void 0 || st.uid === uid;
+    const sticky = (st.mode & 512) !== 0;
+    if (!owner || (st.mode & 18) !== 0 && !sticky) return p;
+    if (p === path19.dirname(p)) return null;
+  }
+}
 function writeFile600(file, body, mode = 384) {
-  fs16.mkdirSync(path17.dirname(file), { recursive: true, mode: 448 });
+  fs17.mkdirSync(path19.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs16.writeFileSync(tmp, body, { mode });
-  fs16.renameSync(tmp, file);
+  fs17.writeFileSync(tmp, body, { mode });
+  fs17.renameSync(tmp, file);
 }
 async function install(ctx, d, h, sup, extra) {
   const problem = h.preflight(ctx);
@@ -4801,13 +5919,22 @@ async function install(ctx, d, h, sup, extra) {
     ctx.err(`cannot install the service yet: ${problem}`);
     return NEEDS_PERSON;
   }
-  if (!fs16.existsSync(d.cli)) {
+  if (!fs17.existsSync(d.cli)) {
     ctx.err(`${d.cli} does not exist (a source checkout needs "npm run build" first)`);
     return 1;
   }
-  const { vars, refused, withheld } = carriedEnv(ctx.env, extra);
-  for (const r of refused) ctx.err(`--env ${r}: not carried into the service (it looks like a credential)`);
-  for (const w of withheld) ctx.err(`${w}: not carried into the service because it holds a password; if the connector needs it, install again with --env ${w} (it is then written into the 0600 unit file)`);
+  const { vars, secrets, refused, withheld } = carriedEnv(ctx.env, extra, [...AGENT_SECRETS, ...codexEnvKeys(ctx.env, d.home)]);
+  for (const r of refused) ctx.err(`--env ${r}: not carried into the service (it is the connector's own key, kept in credentials.json)`);
+  for (const w of withheld) {
+    ctx.err(/[\r\n]/.test(ctx.env[w] ?? "") ? `${w}: not carried into the service because its value spans several lines` : `${w}: not carried into the service because it holds a password; if the connector needs it, install again with --env ${w} (it is then written into the 0600 unit file)`);
+  }
+  try {
+    saveServiceEnv(ctx, secrets);
+  } catch (e) {
+    if (!(e instanceof UnsafeDirError)) throw e;
+    ctx.err(`cannot install the service: ${e.message}`);
+    return 1;
+  }
   const manual = h.runningPid(ctx);
   if (manual !== null && supervisorPid(ctx) === null) {
     await h.stop(ctx);
@@ -4817,7 +5944,7 @@ async function install(ctx, d, h, sup, extra) {
   if (sup === "systemd") {
     const unit = systemdUnitPath(ctx, d);
     writeFile600(unit, systemdUnit(d, vars));
-    recordInstalled(ctx, "systemd");
+    recordInstalled(ctx, "systemd", vars);
     if (!d.systemdBooted()) {
       ctx.err("systemd is not this machine's init (no /run/systemd/system): use --supervisor script");
       return 1;
@@ -4840,7 +5967,7 @@ async function install(ctx, d, h, sup, extra) {
   } else if (sup === "launchd") {
     const plist = launchdPlistPath(d);
     writeFile600(plist, launchdPlist(d, vars, runLogFile(ctx.dirs)));
-    recordInstalled(ctx, "launchd");
+    recordInstalled(ctx, "launchd", vars);
     d.exec("launchctl", ["bootout", `gui/${d.uid}/${LABEL}`]);
     const r = d.exec("launchctl", ["bootstrap", `gui/${d.uid}`, plist]);
     if (r.code !== 0) {
@@ -4851,33 +5978,126 @@ async function install(ctx, d, h, sup, extra) {
   } else {
     const script = keepaliveFile(ctx.dirs);
     writeFile600(script, keepaliveScript(d, vars), 448);
-    recordInstalled(ctx, "script");
-    const code = await ensure(ctx, d, h);
+    recordInstalled(ctx, "script", vars);
+    const code = await ensure(ctx, d, h, { byInstall: true });
     if (code !== 0) return code;
-    ctx.out(`wrote ${script}. This machine has no systemd: the supervisor restarts the connector 5 s after it dies, but`);
-    ctx.out("nothing starts the supervisor after a reboot or a container restart. Add both of these (crontab -e, or your container's startup hook):");
-    ctx.out(`  @reboot sh ${script}`);
-    ctx.out(`  */5 * * * * sh ${script}`);
+    ctx.out(`wrote ${script}. This machine has no systemd: the supervisor restarts the connector 5 s after it dies.`);
+    scheduleKeepalive(ctx, d, script);
   }
   return 0;
 }
-function recordInstalled(ctx, sup) {
-  writeFile600(serviceFile(ctx.dirs), JSON.stringify({ supervisor: sup, installed_at: (/* @__PURE__ */ new Date()).toISOString() }));
+var cronLines = (script) => [`@reboot sh ${sh(script)} >/dev/null 2>&1`, `*/5 * * * * sh ${sh(script)} >/dev/null 2>&1`];
+function scheduleKeepalive(ctx, d, script) {
+  const tab = d.readCrontab();
+  const want = cronLines(script);
+  if (tab !== null) {
+    const lines = tab.split("\n");
+    if (lines[lines.length - 1] === "") lines.pop();
+    const kept = lines.filter((l) => !want.includes(l.trim()));
+    if (d.writeCrontab([...kept, ...want].join("\n") + "\n")) {
+      ctx.out(`added to your crontab, so it comes back after a reboot and within 5 minutes of the supervisor dying:`);
+      for (const l of want) ctx.out(`  ${l}`);
+      return;
+    }
+    ctx.err("could not write your crontab (crontab -); add the lines below by hand");
+  }
+  ctx.out("No cron daemon runs here: after a reboot or a container restart NOTHING starts the connector again.");
+  ctx.out("Run this from the container's startup command (it does nothing while the connector is up; ~/.bashrc works too, then it");
+  ctx.out("comes back when you next open a shell):");
+  ctx.out(`  sh ${sh(script)} >/dev/null 2>&1`);
+  const where = ephemeralWhere(ctx.dirs.config);
+  if (where) ctx.out(`Note: ${where}`);
+}
+function withoutOurCron(d, script) {
+  const tab = d.readCrontab();
+  if (tab === null) return null;
+  const ours = cronLines(script);
+  const lines = tab.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const kept = lines.filter((l) => !ours.includes(l.trim()));
+  return { tab: kept.length ? kept.join("\n") + "\n" : "", removed: lines.length - kept.length };
+}
+var EPHEMERAL_FS = /* @__PURE__ */ new Set(["overlay", "overlayfs", "aufs", "tmpfs"]);
+var PERSISTENT_FS = /^(?:ceph|nfs|nfs4|lustre|wekafs|gpfs|beegfs|cifs|smb3|fuse\.(?:ceph|juicefs|s3fs|gcsfuse|sshfs|rclone))$/;
+function readMounts(text) {
+  let raw = text;
+  if (raw === void 0) {
+    try {
+      raw = fs17.readFileSync("/proc/self/mountinfo", "utf8");
+    } catch {
+      return [];
+    }
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const dash = line.indexOf(" - ");
+    if (dash < 0) continue;
+    const fields = line.slice(0, dash).split(" ");
+    const point = fields[4]?.replace(/\\([0-7]{3})/g, (_m, o) => String.fromCharCode(parseInt(o, 8)));
+    const fstype = line.slice(dash + 3).split(" ")[0];
+    if (point && fstype) out.push({ point, fstype });
+  }
+  return out;
+}
+function mountOf(p, mounts) {
+  let best = null;
+  for (const m of mounts) {
+    const inside2 = p === m.point || p.startsWith(m.point.endsWith("/") ? m.point : `${m.point}/`);
+    if (inside2 && (!best || m.point.length >= best.point.length)) best = m;
+  }
+  return best;
+}
+function ephemeralWhere(configDir, mounts = readMounts()) {
+  let real = configDir;
+  for (let p = configDir; ; p = path19.dirname(p)) {
+    try {
+      real = path19.join(fs17.realpathSync(p), path19.relative(p, configDir));
+      break;
+    } catch {
+      if (p === path19.dirname(p)) break;
+    }
+  }
+  const m = mountOf(real, mounts);
+  if (!m || !EPHEMERAL_FS.has(m.fstype)) return null;
+  const persistent = [...new Set(mounts.filter((x) => PERSISTENT_FS.test(x.fstype) && !x.point.startsWith("/proc") && !x.point.startsWith("/sys")).map((x) => x.point))].filter((pt) => {
+    try {
+      fs17.accessSync(pt, fs17.constants.W_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }).slice(0, 3);
+  return `agents.toml and the sign-in are in ${configDir}, on the container's own file system (${m.fstype}), which is lost when the container is recreated. Keep them on storage that outlives it: export CLAW_CONNECTOR_CONFIG_DIR=<a directory of yours on ${persistent.length ? persistent.join(" or ") : "a persistent volume"}>/claw-connector in your shell profile and the container's startup command, then run init and login again (the state directory, with its pid and lock files, stays where it is).`;
+}
+function saveServiceEnv(ctx, secrets) {
+  const file = serviceEnvFile(ctx.dirs);
+  const before = loadServiceEnv(file);
+  const merged = { ...before, ...Object.fromEntries(secrets) };
+  const names = Object.keys(merged).sort();
+  if (names.length === 0) return;
+  writeSecretFile(file, JSON.stringify(merged, null, 2) + "\n");
+  const fresh = secrets.map(([k]) => k);
+  const kept = names.filter((n) => !fresh.includes(n));
+  ctx.out(`the agents' sign-in for the service (in ${file}, mode 0600, never in a unit): ${[...fresh, ...kept.map((k) => `${k} (kept from before)`)].join(", ")}`);
+}
+function recordInstalled(ctx, sup, vars) {
+  const p = vars.find(([k]) => k === "PATH")?.[1];
+  writeFile600(serviceFile(ctx.dirs), JSON.stringify({ supervisor: sup, installed_at: (/* @__PURE__ */ new Date()).toISOString(), ...p !== void 0 ? { path: p } : {} }));
 }
 async function uninstall(ctx, d, sup) {
-  fs16.rmSync(serviceFile(ctx.dirs), { force: true });
+  fs17.rmSync(serviceFile(ctx.dirs), { force: true });
   if (sup === "systemd") {
     const unit = systemdUnitPath(ctx, d);
     d.exec("systemctl", ["--user", "disable", "--now", UNIT]);
-    const had = fs16.existsSync(unit);
-    fs16.rmSync(unit, { force: true });
+    const had = fs17.existsSync(unit);
+    fs17.rmSync(unit, { force: true });
     d.exec("systemctl", ["--user", "daemon-reload"]);
     ctx.out(had ? `stopped and removed ${unit}` : `no unit at ${unit}`);
   } else if (sup === "launchd") {
     const plist = launchdPlistPath(d);
     d.exec("launchctl", ["bootout", `gui/${d.uid}/${LABEL}`]);
-    const had = fs16.existsSync(plist);
-    fs16.rmSync(plist, { force: true });
+    const had = fs17.existsSync(plist);
+    fs17.rmSync(plist, { force: true });
     ctx.out(had ? `stopped and removed ${plist}` : `no LaunchAgent at ${plist}`);
   } else {
     const pid = supervisorPid(ctx);
@@ -4887,9 +6107,15 @@ async function uninstall(ctx, d, sup) {
       while (Date.now() < end && isAlive(pid) && processStart(pid) !== null) await sleep(100);
     }
     const script = keepaliveFile(ctx.dirs);
-    const had = fs16.existsSync(script);
-    fs16.rmSync(script, { force: true });
-    ctx.out(`${pid !== null ? `stopped the supervisor (pid ${pid}) and the connector; ` : ""}${had ? `removed ${script}` : "no keep-alive script"}. Remove the @reboot and */5 lines that call it.`);
+    const had = fs17.existsSync(script);
+    fs17.rmSync(script, { force: true });
+    const cron = withoutOurCron(d, script);
+    const cronGone = cron !== null && cron.removed > 0 && d.writeCrontab(cron.tab);
+    ctx.out(`${pid !== null ? `stopped the supervisor (pid ${pid}) and the connector; ` : ""}${had ? `removed ${script}` : "no keep-alive script"}${cronGone ? " and its crontab lines" : ". Remove any startup-hook or cron line that calls it."}`);
+  }
+  if (fs17.existsSync(serviceEnvFile(ctx.dirs))) {
+    fs17.rmSync(serviceEnvFile(ctx.dirs), { force: true });
+    ctx.out(`removed ${serviceEnvFile(ctx.dirs)} (the agents' sign-in variables kept for the service)`);
   }
   return 0;
 }
@@ -4905,6 +6131,8 @@ function status(ctx, d, h, json) {
   const st = {
     installed: sup,
     active,
+    /** The names (never the values) of the agents' sign-in variables the service keeps. */
+    agent_env: Object.keys(loadServiceEnv(serviceEnvFile(ctx.dirs))).sort(),
     running: h.runningPid(ctx),
     needs_login: needsLogin(ctx.dirs),
     recent_disconnects: recentDisconnects(ctx.dirs, 5)
@@ -4915,18 +6143,19 @@ function status(ctx, d, h, json) {
   }
   ctx.out(`service:    ${sup ? `${sup} (${active})` : "not installed; run: claw-connector service install"}`);
   ctx.out(`connector:  ${st.running !== null ? `running (pid ${st.running})` : "not running"}`);
+  if (st.agent_env.length) ctx.out(`agent env:  ${st.agent_env.join(", ")} (from ${serviceEnvFile(ctx.dirs)})`);
   if (st.needs_login) ctx.out(`problem:    needs a new sign-in: ${st.needs_login.reason}; run: claw-connector login`);
   for (const x of st.recent_disconnects) ctx.out(`down:       ${x.at} ${x.reason}${x.detail ? ` (${x.detail})` : ""}`);
   return 0;
 }
 
 // src/version.ts
-var VERSION = "0.1.5";
+var VERSION = "0.1.6";
 
 // src/probe.ts
-import fs17 from "node:fs";
-import os6 from "node:os";
-import path18 from "node:path";
+import fs18 from "node:fs";
+import os8 from "node:os";
+import path20 from "node:path";
 var BYPASS_FIX = `Claude Code offers bypassPermissions to root only with IS_SANDBOX set (the connector sets it for an agent with approval = "never" unless its env names IS_SANDBOX), and never when permissions.disableBypassPermissionsMode is "disable" in its settings; fix that, or set approval = "ask" on this agent`;
 function modesOf(res) {
   const m = isObject(res.modes) ? res.modes : null;
@@ -4937,17 +6166,17 @@ function modesOf(res) {
 }
 var probeDir = (a) => a.roots.find((r) => {
   try {
-    return fs17.statSync(r).isDirectory();
+    return fs18.statSync(r).isDirectory();
   } catch {
     return false;
   }
-}) ?? os6.homedir();
+}) ?? os8.homedir();
 async function probeAgent(a, o) {
   const cwd = probeDir(a);
   const out = { agent: a.id, cwd, ok: false, modes: null, problems: [], notes: [] };
   if (!a.roots.includes(cwd)) out.notes.push(`no root of this agent exists yet (${a.roots.join(", ")}); probed in ${cwd}`);
-  const tmp = fs17.mkdtempSync(path18.join(os6.tmpdir(), "claw-probe-"));
-  const registry = new ChildRegistry(path18.join(tmp, "children.json"));
+  const tmp = fs18.mkdtempSync(path20.join(os8.tmpdir(), "claw-probe-"));
+  const registry = new ChildRegistry(path20.join(tmp, "children.json"));
   const timeoutMs = o.timeoutMs ?? 12e4;
   let adapter = null;
   try {
@@ -4956,7 +6185,7 @@ async function probeAgent(a, o) {
       registry,
       sessionId: `probe-${a.id}`,
       cwd,
-      logFile: path18.join(o.logDir, `adapter-${a.id}.log`),
+      logFile: path20.join(o.logDir, `adapter-${a.id}.log`),
       version: o.version,
       initTimeoutMs: timeoutMs,
       hooks: {
@@ -4987,10 +6216,10 @@ async function probeAgent(a, o) {
     if (missing.length) out.notes.push(`safe_modes lists ${missing.join(", ")}, which the adapter does not offer here; a phone that picks one is refused`);
     out.ok = out.problems.length === 0;
   } catch (e) {
-    out.problems.push(`the adapter did not open a session: ${errMessage(e)} (its log: ${path18.join(o.logDir, `adapter-${a.id}.log`)})`);
+    out.problems.push(`the adapter did not open a session: ${errMessage(e)} (its log: ${path20.join(o.logDir, `adapter-${a.id}.log`)})`);
   } finally {
     await adapter?.kill().catch(() => void 0);
-    fs17.rmSync(tmp, { recursive: true, force: true });
+    fs18.rmSync(tmp, { recursive: true, force: true });
   }
   return out;
 }
@@ -5031,11 +6260,18 @@ Usage: claw-connector <command> [options]
   service install|uninstall|status [--supervisor systemd|launchd|script] [--env NAME ...]
                            keep "run" up: started at login/boot, restarted 5 s after it dies, never restarted
                            after exit 78. systemd --user on Linux, launchd on macOS; "script" (containers without
-                           systemd) writes a keep-alive script for a startup hook and a 5-minute cron line
+                           systemd) writes a keep-alive script and adds it to crontab, or says what must call it.
+                           The agents' settings in this shell (PATH, proxies, ANTHROPIC_BASE_URL...) go into the
+                           service; their sign-in variables (ANTHROPIC_API_KEY, OPENAI_API_KEY...) and any --env
+                           named like a credential go into service-env.json (0600), never into the unit
   status [--json]          what is running, signed in, paused, the last disconnect and why
   doctor [--agent ID] [--json]
-                           start each agent's adapter, open a session (no prompt) and check that it offers the
-                           modes agents.toml needs, so a phone session is not refused; init runs it too
+                           check this machine before a phone session fails on it, one fix per problem: Node, each
+                           agent's program on PATH (and on the installed service's PATH), Claude Code / Codex signed
+                           in, the roots writable, the proxy variables, Claw's certificate, the service and Claw
+                           itself; then start each agent's adapter, open a session (no prompt) and check that it
+                           offers the modes agents.toml needs. Exit 1 when something stops sessions. A running
+                           connector repeats the machine checks and shows them in the chat; init runs the adapter check
   pause                    stop every agent now and stay offline until "resume"
   resume                   undo "pause"
   stop                     stop the running connector and every agent it started
@@ -5043,10 +6279,12 @@ Usage: claw-connector <command> [options]
   --version, --help
 
 Files: ${"$"}XDG_CONFIG_HOME/claw-connector (agents.toml, credentials.json) and ${"$"}XDG_STATE_HOME/claw-connector
-(audit.jsonl, logs, outbox); set CLAW_CONNECTOR_HOME to keep everything under one directory.
+(audit.jsonl, logs, outbox); set CLAW_CONNECTOR_HOME to keep everything under one directory, and
+CLAW_CONNECTOR_CONFIG_DIR to keep only the configuration and sign-in elsewhere (storage that outlives a container).
 `;
 function loadCfg(ctx, notes = []) {
-  const cfg = loadConfig(configFile(ctx.dirs), { hostname: ctx.hostname ?? os7.hostname() });
+  const cfg = loadConfig(configFile(ctx.dirs), { hostname: ctx.hostname ?? os9.hostname() });
+  applyServiceEnv(cfg.agents, loadServiceEnv(serviceEnvFile(ctx.dirs)), ctx.env);
   notes.push(...applyRootSandbox(cfg.agents, ctx.env, { euid: ctx.euid }));
   return cfg;
 }
@@ -5090,6 +6328,8 @@ async function main(argv, ctx) {
         return cmdStatus(rest, ctx);
       case "doctor":
         return await cmdDoctor(rest, ctx);
+      case "health-check":
+        return await cmdHealthCheck(ctx, ctx.stdin ?? readStdin);
       case "pause":
         return await cmdPause(ctx);
       case "resume":
@@ -5136,9 +6376,9 @@ async function cmdInit(args, ctx) {
     return EXIT.usage;
   }
   const file = configFile(ctx.dirs);
-  fs18.mkdirSync(path19.dirname(file), { recursive: true, mode: 448 });
+  fs19.mkdirSync(path21.dirname(file), { recursive: true, mode: 448 });
   try {
-    fs18.writeFileSync(file, sampleConfig(approval), { mode: 384, flag: "wx" });
+    fs19.writeFileSync(file, sampleConfig(approval), { mode: 384, flag: "wx" });
     ctx.out(`wrote ${file}: edit the roots (the directories an agent may work in), then run: claw-connector login`);
     const { unattended, parked } = sampleApprovals(approval);
     ctx.out(unattended.length ? `no per-step approval for: ${unattended.join(", ")}. Those agents write files and run commands without asking; the phone shows such a session as unattended. To go back, set approval = "ask" on the agent.` : `every agent in this file asks before it writes a file or runs a command. To let phone sessions run like your terminal instead: claw-connector init --approval never (on a new file), or set approval = "never" on an agent.`);
@@ -5147,9 +6387,11 @@ async function cmdInit(args, ctx) {
     if (e.code !== "EEXIST") throw e;
     ctx.out(`${file} already exists; left alone${values.approval?.length ? ` (to change an agent's approval, set approval = "ask" or "never" in its [[agents]] table)` : ""}`);
   }
+  const where = ephemeralWhere(ctx.dirs.config);
+  if (where) ctx.out(`note: ${where}`);
   if (!values["no-hooks"]) {
     const dir = defaultClaudeDir(ctx);
-    if (!fs18.existsSync(dir)) ctx.out(`no Claude Code directory at ${dir}; once you use Claude Code, run: claw-connector hooks install`);
+    if (!fs19.existsSync(dir)) ctx.out(`no Claude Code directory at ${dir}; once you use Claude Code, run: claw-connector hooks install`);
     else installForInit(ctx, dir);
   }
   await installAdapters(ctx, true);
@@ -5164,27 +6406,6 @@ async function cmdInit(args, ctx) {
   }
   return EXIT.ok;
 }
-async function cmdDoctor(args, ctx) {
-  const { values } = parseArgs2({ args, strict: true, options: { agent: { type: "string" }, json: { type: "boolean" } } });
-  const notes = [];
-  const cfg = loadCfg(ctx, notes);
-  const agents = values.agent ? cfg.agents.filter((a) => a.id === values.agent) : cfg.agents;
-  if (agents.length === 0) {
-    ctx.err(values.agent ? `no agent ${JSON.stringify(values.agent)} in agents.toml` : "agents.toml defines no agents; add an [[agents]] table");
-    return EXIT.failure;
-  }
-  const warnings = noAsk(ctx, { ...cfg, agents });
-  const results = await (ctx.probe ?? probeAgents)(agents, { logDir: logDir(ctx.dirs), version: VERSION });
-  const ok = results.every((r) => r.ok);
-  if (values.json) {
-    ctx.out(JSON.stringify({ version: VERSION, ok, notes, warnings, agents: results }, null, 2));
-  } else {
-    for (const n of notes) ctx.out(`note: ${n}`);
-    for (const w of warnings) ctx.out(`warning: ${w}`);
-    for (const l of probeLines(results)) ctx.out(l);
-  }
-  return ok ? EXIT.ok : EXIT.failure;
-}
 async function installAdapters(ctx, initFallback) {
   const store2 = adapterStore();
   if (!store2 || !ctx.installAdapters) return;
@@ -5204,19 +6425,19 @@ function installForInit(ctx, dir) {
     ctx.err(`hooks: ${errMessage(e)} (everything else is set up; fix it and run: claw-connector hooks install)`);
   }
 }
-var defaultClaudeDir = (ctx) => path19.resolve(ctx.env.CLAUDE_CONFIG_DIR?.trim() || path19.join(os7.homedir(), ".claude"));
+var defaultClaudeDir = (ctx) => path21.resolve(ctx.env.CLAUDE_CONFIG_DIR?.trim() || path21.join(os9.homedir(), ".claude"));
 function claudeDirs(ctx, flag) {
-  if (flag !== void 0) return [path19.resolve(flag)];
+  if (flag !== void 0) return [path21.resolve(flag)];
   let dirs = [];
   try {
-    dirs = loadCfg(ctx).agents.filter((a) => a.attach).map((a) => path19.resolve(a.env.CLAUDE_CONFIG_DIR ?? ctx.env.CLAUDE_CONFIG_DIR?.trim() ?? path19.join(os7.homedir(), ".claude")));
+    dirs = loadCfg(ctx).agents.filter((a) => a.attach).map((a) => path21.resolve(a.env.CLAUDE_CONFIG_DIR ?? ctx.env.CLAUDE_CONFIG_DIR?.trim() ?? path21.join(os9.homedir(), ".claude")));
   } catch {
   }
   return dirs.length ? [...new Set(dirs)] : [defaultClaudeDir(ctx)];
 }
 function hookScript(ctx) {
   const script = ctx.hookScript ?? fileURLToPath2(new URL("./terminal-hook.js", import.meta.url));
-  if (!fs18.existsSync(script)) throw new HooksError(`${script} does not exist (a source checkout needs "npm run build" first)`);
+  if (!fs19.existsSync(script)) throw new HooksError(`${script} does not exist (a source checkout needs "npm run build" first)`);
   return script;
 }
 function installOne(ctx, dir) {
@@ -5236,7 +6457,7 @@ function cmdHooks(args, ctx) {
   for (const dir of dirs) {
     try {
       if (sub === "install") {
-        if (values["config-dir"] === void 0 && !fs18.existsSync(dir)) {
+        if (values["config-dir"] === void 0 && !fs19.existsSync(dir)) {
           ctx.err(`no Claude Code directory at ${dir}; pass --config-dir to name one`);
           code = EXIT.failure;
           continue;
@@ -5261,11 +6482,11 @@ function forgetRevokedIdentity(ctx) {
   const file = identityFile(ctx.dirs);
   let revoked = false;
   try {
-    const raw = JSON.parse(fs18.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs19.readFileSync(file, "utf8"));
     revoked = isObject(raw) && raw.revoked === true;
   } catch {
   }
-  if (revoked) fs18.rmSync(file, { force: true });
+  if (revoked) fs19.rmSync(file, { force: true });
 }
 async function cmdLogin(args, ctx) {
   const { values } = parseArgs2({
@@ -5300,7 +6521,7 @@ async function cmdLogin(args, ctx) {
     ctx.err("login needs --identity-url <identity service URL> (or CLAW_IDENTITY_URL, or identity_url = in agents.toml)");
     return EXIT.usage;
   }
-  const deviceName = values.name ?? cfg?.name ?? ctx.hostname ?? os7.hostname();
+  const deviceName = values.name ?? cfg?.name ?? ctx.hostname ?? os9.hostname();
   const tok = await deviceLogin({ identityUrl, deviceName, fetch: ctx.fetch, print: ctx.out });
   saveCredentials(file, {
     v: 1,
@@ -5320,7 +6541,7 @@ async function cmdLogin(args, ctx) {
 }
 function runningPid(ctx) {
   try {
-    const raw = JSON.parse(fs18.readFileSync(pidFile(ctx.dirs), "utf8"));
+    const raw = JSON.parse(fs19.readFileSync(pidFile(ctx.dirs), "utf8"));
     if (isObject(raw) && typeof raw.pid === "number" && typeof raw.start === "string" && raw.start !== "" && processStart(raw.pid) === raw.start) return raw.pid;
   } catch {
   }
@@ -5366,12 +6587,16 @@ async function cmdRun(args, ctx) {
   const client2 = new ClawClient({ server, tokens, fetch: ctx.fetch });
   const log = stderrLogger();
   const audit = fileAudit(auditFile(ctx.dirs));
-  const connector2 = new Connector({ config: cfg, dirs: ctx.dirs, client: client2, server, audit, log, version: VERSION, timing: ctx.timing });
+  const connector2 = new Connector({ config: cfg, dirs: ctx.dirs, client: client2, server, audit, log, version: VERSION, timing: ctx.timing, health: runHealth(ctx, cfg) });
   if (ctx.installAdapters) for (const { pkg, env } of pinnedOf(cfg.agents, ctx.env)) void adapterStore()?.install(pkg, env, (l) => ctx.out(`adapters: ${l}`));
   ctx.onConnector?.(connector2);
   ctx.out(`connecting ${cfg.agents.map((a) => a.unattended ? `${a.id} (no per-step approval)` : a.id).join(", ")} to ${server} as "${cfg.name}"`);
   for (const n of notes) ctx.out(`note: ${n}`);
   for (const w of noAsk(ctx, cfg)) ctx.out(`warning: ${w}`);
+  for (const a of cfg.agents) if (a.readOnlyModes.includes(a.askMode)) ctx.out(`note: ${a.id}: its sessions start read-only (${a.askMode} mode changes no file); to let phone sessions write code, set approval = "never" on it in agents.toml`);
+  void rootProblems(cfg.agents).then((ps) => {
+    for (const p of ps) ctx.out(`warning: ${p}`);
+  }, () => void 0);
   try {
     const result = await connector2.run();
     if (result === "revoked") {
@@ -5402,6 +6627,94 @@ async function cmdRun(args, ctx) {
     throw e;
   }
 }
+async function cmdDoctor(args, ctx) {
+  const { values } = parseArgs2({ args, strict: true, options: { agent: { type: "string" }, json: { type: "boolean" } } });
+  const before = [];
+  const notes = [];
+  let cfg = null;
+  let creds = null;
+  try {
+    cfg = loadCfg(ctx, notes);
+  } catch (e) {
+    const missing = !fs19.existsSync(configFile(ctx.dirs));
+    const roots = e instanceof ConfigError ? e.problems.map((p) => /^agent (\S+): root (.+) does not exist$/.exec(p)) : [];
+    if (roots.length && roots.every((m) => m !== null)) {
+      for (const m of roots) before.push({ code: "root_missing", severity: "fail", agent: m[1], detail: `${m[2]} (a root of agent ${m[1]}) does not exist`, fix: `mkdir -p ${shq(m[2])}  (or change roots in ${configFile(ctx.dirs)})` });
+    } else before.push({ code: "config_invalid", severity: "fail", detail: errMessage(e), fix: missing ? "claw-connector init" : `edit ${configFile(ctx.dirs)}` });
+  }
+  const agents = cfg ? values.agent ? cfg.agents.filter((a) => a.id === values.agent) : cfg.agents : [];
+  if (cfg && agents.length === 0) {
+    if (values.agent) {
+      ctx.err(`no agent ${JSON.stringify(values.agent)} in agents.toml`);
+      return EXIT.failure;
+    }
+    before.push({ code: "config_invalid", severity: "fail", detail: "agents.toml defines no agents", fix: `add an [[agents]] table to ${configFile(ctx.dirs)}  (claw-connector init writes a sample)` });
+  }
+  try {
+    creds = loadCredentials(credentialsFile(ctx.dirs));
+  } catch (e) {
+    before.push({ code: "not_signed_in", severity: "fail", detail: errMessage(e), fix: "claw-connector login" });
+  }
+  if (!creds && !before.some((p) => p.code === "not_signed_in")) before.push({ code: "not_signed_in", severity: "fail", detail: "this connector is not signed in to Claw", fix: "claw-connector login" });
+  const nl = needsLogin(ctx.dirs);
+  if (nl) before.push({ code: "needs_login", severity: "fail", detail: `needs a new sign-in: ${nl.reason}`, fix: "claw-connector login" });
+  let server = null;
+  try {
+    server = serverUrl(ctx, void 0, cfg, creds);
+  } catch {
+  }
+  const report = await checkAll({ dirs: ctx.dirs, agents, by: "doctor", server, before }, ctx.doctor ?? defaultDeps(ctx.env));
+  writeReport(ctx.dirs, report);
+  const warnings = cfg ? noAsk(ctx, { ...cfg, agents }) : [];
+  const results = agents.length ? redactDeep(await (ctx.probe ?? probeAgents)(agents, { logDir: logDir(ctx.dirs), version: VERSION })) : [];
+  const adaptersOk = results.every((r) => r.ok);
+  const machineOk = !report.problems.some((p) => p.severity === "fail");
+  if (values.json) {
+    ctx.out(JSON.stringify({ version: VERSION, ok: adaptersOk, machine_ok: machineOk, notes, warnings, agents: results, environment: report }, null, 2));
+  } else {
+    ctx.out(`claw-connector ${VERSION} doctor${cfg ? ` (${cfg.name})` : ""}`);
+    for (const l of formatReport(report)) ctx.out(l);
+    if (results.length) {
+      ctx.out("");
+      ctx.out("each agent's adapter (a session opened without a prompt):");
+      for (const n of notes) ctx.out(`note: ${n}`);
+      for (const w of warnings) ctx.out(`warning: ${w}`);
+      for (const l of probeLines(results)) ctx.out(l);
+    }
+  }
+  const running = runningPid(ctx);
+  if (running !== null) {
+    try {
+      (ctx.askRecheck ?? ((pid) => process.kill(pid, "SIGWINCH")))(running);
+      if (!values.json) ctx.out("The running connector checks the machine again now and shows the result in the chat.");
+    } catch {
+    }
+  }
+  return adaptersOk && machineOk ? EXIT.ok : EXIT.failure;
+}
+var HEALTH_CHILD_MS = 6e4;
+function runHealth(ctx, cfg) {
+  if (ctx.doctor) return () => checkAll({ dirs: ctx.dirs, agents: cfg.agents, by: "run" }, ctx.doctor);
+  const cli = ctx.cli ?? ctx.service?.cli ?? fileURLToPath2(import.meta.url);
+  const node = ctx.node ?? process.execPath;
+  return async (signal) => {
+    const r = await runProbe(node, [cli, "health-check"], ctx.env, signal, HEALTH_CHILD_MS, JSON.stringify({ agents: cfg.agents }));
+    const v = JSON.parse(r.out.slice(r.out.indexOf("{")));
+    if (!isObject(v) || typeof v.checked_at !== "string" || !Array.isArray(v.problems)) throw new Error(`health-check answered ${r.code === null ? "nothing in time" : `exit ${r.code}`}`);
+    return v;
+  };
+}
+async function cmdHealthCheck(ctx, stdin) {
+  const v = JSON.parse(await stdin());
+  const agents = isObject(v) && Array.isArray(v.agents) ? v.agents : [];
+  ctx.out(JSON.stringify(await checkAll({ dirs: ctx.dirs, agents, by: "run" }, defaultDeps(ctx.env, { ownGroup: false }))));
+  return EXIT.ok;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  return Buffer.concat(chunks).toString("utf8");
+}
 function cmdStatus(args, ctx) {
   const { values } = parseArgs2({ args, strict: true, options: { json: { type: "boolean" } } });
   let creds = null;
@@ -5425,7 +6738,7 @@ function cmdStatus(args, ctx) {
   }
   let connectorId = null;
   try {
-    const raw = JSON.parse(fs18.readFileSync(identityFile(ctx.dirs), "utf8"));
+    const raw = JSON.parse(fs19.readFileSync(identityFile(ctx.dirs), "utf8"));
     if (isObject(raw) && typeof raw.connector_id === "string") connectorId = raw.connector_id;
   } catch {
   }
@@ -5433,7 +6746,7 @@ function cmdStatus(args, ctx) {
   const status2 = {
     version: VERSION,
     running: runningPid(ctx),
-    paused: fs18.existsSync(pauseFile(ctx.dirs)),
+    paused: fs19.existsSync(pauseFile(ctx.dirs)),
     signed_in: creds ? { kind: creds.kind, server: creds.server, device_name: creds.device_name ?? null } : null,
     connector_id: connectorId,
     agents,
@@ -5445,7 +6758,9 @@ function cmdStatus(args, ctx) {
     warnings,
     /** Why the connection last went down, and whether only a new sign-in can bring it back. */
     last_disconnect: recentDisconnects(ctx.dirs, 1)[0] ?? null,
-    needs_login: needsLogin(ctx.dirs)
+    needs_login: needsLogin(ctx.dirs),
+    /** The last `doctor` report's problems (null: doctor never ran). */
+    doctor: lastDoctor(ctx)
   };
   if (values.json) {
     ctx.out(JSON.stringify(status2, null, 2));
@@ -5459,11 +6774,22 @@ function cmdStatus(args, ctx) {
   if (status2.needs_login) ctx.out(`problem:    needs a new sign-in: ${status2.needs_login.reason}; run: claw-connector login`);
   for (const p of status2.problems) ctx.out(`problem:    ${p}`);
   for (const w of status2.warnings) ctx.out(`warning:    ${w}`);
+  if (status2.doctor) ctx.out(`doctor:     ${status2.doctor.problems.length ? `${status2.doctor.problems.length} problem(s) at ${status2.doctor.checked_at}; run: claw-connector doctor` : `no problems at ${status2.doctor.checked_at}`}`);
+  else ctx.out("doctor:     never run; run: claw-connector doctor");
   return EXIT.ok;
 }
+function lastDoctor(ctx) {
+  try {
+    const raw = JSON.parse(fs19.readFileSync(doctorFile(ctx.dirs), "utf8"));
+    if (!isObject(raw) || typeof raw.checked_at !== "string" || !Array.isArray(raw.problems)) return null;
+    return { checked_at: raw.checked_at, problems: raw.problems.filter(isObject).map((p) => ({ code: String(p.code), ...typeof p.agent === "string" ? { agent: p.agent } : {}, fix: String(p.fix) })) };
+  } catch {
+    return null;
+  }
+}
 async function cmdPause(ctx) {
-  fs18.mkdirSync(ctx.dirs.state, { recursive: true, mode: 448 });
-  fs18.writeFileSync(pauseFile(ctx.dirs), (/* @__PURE__ */ new Date()).toISOString() + "\n", { mode: 384 });
+  fs19.mkdirSync(ctx.dirs.state, { recursive: true, mode: 448 });
+  fs19.writeFileSync(pauseFile(ctx.dirs), (/* @__PURE__ */ new Date()).toISOString() + "\n", { mode: 384 });
   if (runningPid(ctx) === null) {
     const left = await new ChildRegistry(childrenFile(ctx.dirs)).killAll();
     ctx.out(`paused (the connector is not running${left.killed.length ? `; stopped ${left.killed.length} leftover agent process group(s)` : ""})`);
@@ -5473,15 +6799,15 @@ async function cmdPause(ctx) {
   return EXIT.ok;
 }
 function cmdResume(ctx) {
-  fs18.rmSync(pauseFile(ctx.dirs), { force: true });
+  fs19.rmSync(pauseFile(ctx.dirs), { force: true });
   ctx.out(runningPid(ctx) === null ? "resumed; start it with: claw-connector run" : "resumed: the running connector reconnects now");
   return EXIT.ok;
 }
 async function cmdStop(ctx, quiet = false) {
   const pid = runningPid(ctx);
   if (pid !== null) {
-    fs18.mkdirSync(ctx.dirs.state, { recursive: true, mode: 448 });
-    fs18.writeFileSync(stopRequestFile(ctx.dirs), JSON.stringify({ pid, start: processStart(pid) ?? "", at: (/* @__PURE__ */ new Date()).toISOString() }), { mode: 384 });
+    fs19.mkdirSync(ctx.dirs.state, { recursive: true, mode: 448 });
+    fs19.writeFileSync(stopRequestFile(ctx.dirs), JSON.stringify({ pid, start: processStart(pid) ?? "", at: (/* @__PURE__ */ new Date()).toISOString() }), { mode: 384 });
     process.kill(pid, "SIGTERM");
     const deadline = Date.now() + 15e3;
     while (Date.now() < deadline && isAlive(pid) && processStart(pid) !== null) await sleep(100);
@@ -5489,7 +6815,7 @@ async function cmdStop(ctx, quiet = false) {
       process.kill(pid, "SIGKILL");
       if (!quiet) ctx.out(`the connector (pid ${pid}) did not stop in 15 s and was killed`);
     }
-    fs18.rmSync(stopRequestFile(ctx.dirs), { force: true });
+    fs19.rmSync(stopRequestFile(ctx.dirs), { force: true });
   }
   const left = await new ChildRegistry(childrenFile(ctx.dirs)).killAll();
   if (!quiet) ctx.out(pid === null ? `no connector running${left.killed.length ? `; stopped ${left.killed.length} leftover agent process group(s)` : ""}` : `stopped the connector${left.killed.length ? ` and ${left.killed.length} leftover agent process group(s)` : ""}`);
@@ -5499,17 +6825,17 @@ function takeStopRequest(ctx) {
   const file = stopRequestFile(ctx.dirs);
   let mine = false;
   try {
-    const raw = JSON.parse(fs18.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs19.readFileSync(file, "utf8"));
     mine = isObject(raw) && raw.pid === process.pid && raw.start === (processStart(process.pid) ?? "");
   } catch {
     return false;
   }
-  if (mine) fs18.rmSync(file, { force: true });
+  if (mine) fs19.rmSync(file, { force: true });
   return mine;
 }
 function storedConnector(ctx) {
   try {
-    const raw = JSON.parse(fs18.readFileSync(identityFile(ctx.dirs), "utf8"));
+    const raw = JSON.parse(fs19.readFileSync(identityFile(ctx.dirs), "utf8"));
     if (isObject(raw) && typeof raw.server === "string" && typeof raw.connector_id === "string") {
       return { server: raw.server, connector_id: raw.connector_id, revoked: raw.revoked === true };
     }
@@ -5581,8 +6907,8 @@ async function cmdLogout(ctx) {
       ctx.err(`could not revoke the sign-in at the identity service (${errMessage(e)}); it was removed from this machine`);
     }
   }
-  fs18.rmSync(file, { force: true });
-  if (rowGone) fs18.rmSync(identityFile(ctx.dirs), { force: true });
+  fs19.rmSync(file, { force: true });
+  if (rowGone) fs19.rmSync(identityFile(ctx.dirs), { force: true });
   else forgetRevokedIdentity(ctx);
   if (row && notRevoked !== null) {
     ctx.err(`signed out on this machine, but connector ${row.connector_id} was NOT revoked at Claw (${notRevoked}).`);
@@ -5620,6 +6946,7 @@ var onSignal = () => {
 };
 main(process.argv.slice(2), {
   dirs: resolveDirs(),
+  cli: fileURLToPath3(import.meta.url),
   env: process.env,
   out: (l) => process.stdout.write(l + "\n"),
   err: (l) => process.stderr.write(l + "\n"),
@@ -5628,6 +6955,7 @@ main(process.argv.slice(2), {
   onConnector: (c) => {
     connector = c;
     for (const sig of ["SIGTERM", "SIGINT", "SIGHUP"]) process.on(sig, onSignal);
+    process.on("SIGWINCH", () => c.recheckHealth());
   }
 }).then((code) => process.exit(code), (e) => {
   process.stderr.write(`fatal: ${e instanceof Error ? e.stack : String(e)}