@agentvault/claude-bridge 0.7.16 → 0.8.1

package/dist/index.js

@@ -9,36 +9,138 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/pending-invite.ts
+import { existsSync, mkdirSync, chmodSync, readFileSync as readFileSync2, writeFileSync, rmSync } from "node:fs";
+import { join as join5 } from "node:path";
+function pendingInvitePath(dataDir) {
+  return join5(dataDir, PENDING_INVITE_FILE);
+}
+function writePendingInvite(dataDir, token) {
+  mkdirSync(dataDir, { recursive: true, mode: DIR_MODE2 });
+  chmodSync(dataDir, DIR_MODE2);
+  const p2 = pendingInvitePath(dataDir);
+  writeFileSync(p2, token, { mode: FILE_MODE2 });
+  chmodSync(p2, FILE_MODE2);
+}
+function readPendingInvite(dataDir) {
+  const p2 = pendingInvitePath(dataDir);
+  if (!existsSync(p2)) return void 0;
+  try {
+    const raw = readFileSync2(p2, "utf-8").trim();
+    return raw.length > 0 ? raw : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function clearPendingInvite(dataDir) {
+  try {
+    rmSync(pendingInvitePath(dataDir), { force: true });
+  } catch {
+  }
+}
+function clearPendingInviteIfConsumed(dataDir, credsExist) {
+  if (!existsSync(pendingInvitePath(dataDir))) return false;
+  if (!credsExist(dataDir)) return false;
+  clearPendingInvite(dataDir);
+  return true;
+}
+var DIR_MODE2, FILE_MODE2, PENDING_INVITE_FILE;
+var init_pending_invite = __esm({
+  "src/pending-invite.ts"() {
+    "use strict";
+    DIR_MODE2 = 448;
+    FILE_MODE2 = 384;
+    PENDING_INVITE_FILE = "pending-invite";
+  }
+});
+
+// src/log.ts
+import { format } from "node:util";
+function stamp(message) {
+  const ts2 = (/* @__PURE__ */ new Date()).toISOString();
+  return message.split("\n").map((line) => `${ts2} ${line}`).join("\n");
+}
+function logLine(...args) {
+  console.error(stamp(format(...args)));
+}
+function printLine(text) {
+  console.log(text);
+}
+var init_log = __esm({
+  "src/log.ts"() {
+    "use strict";
+  }
+});
+
 // src/config.ts
-import { existsSync, readFileSync as readFileSync2, mkdirSync, chmodSync } from "node:fs";
-import { join as join5, resolve as resolve2, sep, dirname } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "node:fs";
+import { join as join6, resolve as resolve2, sep, dirname } from "node:path";
+import { tmpdir } from "node:os";
+function isEphemeralEntrypoint(entrypoint) {
+  return entrypoint.includes("/_npx/") || entrypoint.includes("/dlx-") || entrypoint.includes("/.bun/install/cache/") || entrypoint.startsWith(tmpdir() + sep);
+}
+function assertInstallableEntrypoint(entrypoint) {
+  if (isEphemeralEntrypoint(entrypoint)) {
+    throw new Error(
+      `cannot install a background service from an ephemeral package cache (${entrypoint}) \u2014 it is deleted on cleanup and the service would silently die later. Install globally first:
+  npm i -g @agentvault/claude-bridge && agentvault-claude-bridge install`
+    );
+  }
+}
 function hasRecoverableBackup(dataDir) {
   try {
-    const parsed = JSON.parse(readFileSync2(join5(dataDir, BACKUP_FILE), "utf-8"));
+    const parsed = JSON.parse(readFileSync3(join6(dataDir, BACKUP_FILE), "utf-8"));
     return !!(parsed && parsed.deviceId && parsed.deviceJwt && parsed.sessions && Object.keys(parsed.sessions).length > 0);
   } catch {
     return false;
   }
 }
+function readPersistedDeviceId(dataDir) {
+  for (const f7 of [...CRED_FILES, BACKUP_FILE]) {
+    try {
+      const parsed = JSON.parse(readFileSync3(join6(dataDir, f7), "utf-8"));
+      const id = parsed?.deviceId;
+      if (typeof id === "string" && id) return id;
+    } catch {
+    }
+  }
+  return null;
+}
 function hasPersistedCreds(dataDir) {
-  if (CRED_FILES.some((f7) => existsSync(join5(dataDir, f7)))) return true;
+  if (CRED_FILES.some((f7) => existsSync2(join6(dataDir, f7)))) return true;
   return hasRecoverableBackup(dataDir);
 }
 function slugify2(name) {
   return name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
 }
 function resolveDataDir(env) {
-  if (env.AV_DATA_DIR) return { dataDir: env.AV_DATA_DIR, source: "explicit" };
-  const base = join5(env.HOME ?? "", ".agentvault", "claude-room-bridge");
-  const perAgent = join5(base, slugify2(env.AV_AGENT_NAME ?? "claude"));
-  if (hasPersistedCreds(perAgent)) return { dataDir: perAgent, source: "per-agent" };
-  if (hasPersistedCreds(base)) return { dataDir: base, source: "legacy" };
-  return { dataDir: perAgent, source: "per-agent" };
+  const supplied = env.AV_AGENT_NAME?.trim();
+  const agentName = supplied || LEGACY_DEFAULT_AGENT_NAME;
+  const agentNameSource = supplied ? "supplied" : "defaulted";
+  if (env.AV_DATA_DIR)
+    return { dataDir: env.AV_DATA_DIR, source: "explicit", agentName, agentNameSource };
+  const base = join6(env.HOME ?? "", ".agentvault", "claude-room-bridge");
+  const perAgent = join6(base, slugify2(agentName));
+  if (hasPersistedCreds(perAgent))
+    return { dataDir: perAgent, source: "per-agent", agentName, agentNameSource };
+  if (hasPersistedCreds(base))
+    return { dataDir: base, source: "legacy", agentName, agentNameSource };
+  if (!supplied) {
+    throw new Error(
+      `AV_AGENT_NAME is required \u2014 it names WHICH agent this bridge runs as, and therefore where its credentials live. No credentials were found at ${perAgent} or ${base}, so there is no existing install to infer a name from. Re-run with AV_AGENT_NAME=<agent-name> set.`
+    );
+  }
+  return { dataDir: perAgent, source: "per-agent", agentName, agentNameSource };
 }
 function loadConfig(env, argv = []) {
-  const { dataDir, source: dataDirSource } = resolveDataDir(env);
-  const inviteToken = (argv[0] && !argv[0].startsWith("-") ? argv[0] : "") || env.AV_INVITE_TOKEN || "";
-  const workspaceDir = env.AV_WORKSPACE_DIR || join5(dirname(dataDir), "workspaces", slugify2(env.AV_AGENT_NAME ?? "claude"));
+  const { dataDir, source: dataDirSource, agentName, agentNameSource } = resolveDataDir(env);
+  if (agentNameSource === "defaulted") {
+    logLine(
+      `[config] AV_AGENT_NAME was not set \u2014 running as "${agentName}" from the existing credentials at ${dataDir}. Set AV_AGENT_NAME to name this agent explicitly; a future install will require it.`
+    );
+  }
+  const inviteToken = (argv[0] && !argv[0].startsWith("-") ? argv[0] : "") || env.AV_INVITE_TOKEN || readPendingInvite(dataDir) || "";
+  const workspaceDir = env.AV_WORKSPACE_DIR || join6(dirname(dataDir), "workspaces", slugify2(agentName));
   const wsReal = resolve2(workspaceDir);
   const ddReal = resolve2(dataDir);
   if (wsReal === ddReal || wsReal.startsWith(ddReal + sep) || ddReal.startsWith(wsReal + sep)) {
@@ -47,8 +149,8 @@ function loadConfig(env, argv = []) {
     );
   }
   try {
-    mkdirSync(workspaceDir, { recursive: true, mode: 448 });
-    chmodSync(workspaceDir, 448);
+    mkdirSync2(workspaceDir, { recursive: true, mode: 448 });
+    chmodSync2(workspaceDir, 448);
   } catch (e7) {
     throw new Error(
       `Failed to create/secure the agent workspace at ${workspaceDir} (override with AV_WORKSPACE_DIR): ${e7.message}`
@@ -83,8 +185,10 @@ function loadConfig(env, argv = []) {
     apiUrl: env.AV_API_URL ?? "https://api.agentvault.chat",
     // Identity shown to the agent's own session. Set this to the agent's
     // AgentVault name via AV_AGENT_NAME (the native connect command passes it).
-    // The neutral default avoids impersonating any specific named agent when unset.
-    agentName: env.AV_AGENT_NAME ?? "Claude",
+    // Resolved in resolveDataDir so the name, the data dir and the workspace dir
+    // can never disagree about who this agent is (#921/#927).
+    agentName,
+    agentNameSource,
     roomFilter: env.AV_ROOM_ID || void 0,
     model: env.AV_CLAUDE_MODEL || void 0,
     systemPrompt: env.AV_SYSTEM_PROMPT || void 0,
@@ -94,12 +198,15 @@ function loadConfig(env, argv = []) {
     osIsolated
   };
 }
-var CRED_FILES, BACKUP_FILE;
+var CRED_FILES, BACKUP_FILE, LEGACY_DEFAULT_AGENT_NAME;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
+    init_pending_invite();
+    init_log();
     CRED_FILES = ["agentvault.json", "secure-channel.json"];
     BACKUP_FILE = "agentvault.json.bak";
+    LEGACY_DEFAULT_AGENT_NAME = "Claude";
   }
 });
 
@@ -227,6 +334,37 @@ ${envEntries}
 </plist>
 `;
 }
+function parsePlistEnv(xml) {
+  const out = {};
+  const keyIdx = xml.indexOf("<key>EnvironmentVariables</key>");
+  if (keyIdx < 0) return out;
+  const open = xml.indexOf("<dict>", keyIdx);
+  if (open < 0) return out;
+  let depth = 0;
+  let i2 = open;
+  let close = -1;
+  const tag = /<(\/?)dict>/g;
+  tag.lastIndex = open;
+  let m6;
+  while (m6 = tag.exec(xml)) {
+    depth += m6[1] ? -1 : 1;
+    if (depth === 0) {
+      close = m6.index;
+      break;
+    }
+    i2 = m6.index;
+  }
+  void i2;
+  if (close < 0) return out;
+  const body = xml.slice(open, close);
+  const pair = /<key>([\s\S]*?)<\/key>\s*<string>([\s\S]*?)<\/string>/g;
+  let p2;
+  while (p2 = pair.exec(body)) out[unesc(p2[1])] = unesc(p2[2]);
+  return out;
+}
+function unesc(s10) {
+  return s10.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
 var LaunchdBackend;
 var init_launchd = __esm({
   "src/service/launchd.ts"() {
@@ -281,6 +419,26 @@ var init_launchd = __esm({
         const r7 = this.deps.exec("launchctl", ["print", `${this.domain()}/${label}`]);
         return { loaded: r7.code === 0, detail: r7.stdout };
       }
+      /** #913 item 3 — every installed service whose label starts with `prefix`.
+       *
+       *  Reads the plist directory rather than `launchctl list`, because an ORPHAN
+       *  is typically installed-but-not-loaded: the revoked device exits 0 and
+       *  KeepAlive leaves it down. `launchctl list` would not show the very thing
+       *  doctor exists to find. */
+      list(prefix) {
+        const dir = join9(this.deps.home, "Library", "LaunchAgents");
+        const out = [];
+        for (const name of this.deps.readdir(dir)) {
+          if (!name.startsWith(prefix) || !name.endsWith(".plist")) continue;
+          const path2 = join9(dir, name);
+          out.push({
+            label: name.slice(0, -".plist".length),
+            path: path2,
+            env: parsePlistEnv(this.deps.readFile(path2))
+          });
+        }
+        return out.sort((a2, b5) => a2.label.localeCompare(b5.label));
+      }
     };
   }
 });
@@ -312,6 +470,24 @@ StandardError=append:${spec.logErr}
 WantedBy=default.target
 `;
 }
+function parseUnitEnv(text) {
+  const out = {};
+  for (const line of text.split("\n")) {
+    const m6 = /^Environment="([\s\S]*)"\s*$/.exec(line.trim());
+    if (!m6) continue;
+    const eq2 = unq(m6[1]);
+    const at = eq2.indexOf("=");
+    if (at <= 0) continue;
+    out[eq2.slice(0, at)] = eq2.slice(at + 1);
+  }
+  return out;
+}
+function unq(s10) {
+  return s10.replace(/%%/g, "%").replace(
+    /\\([\s\S])/g,
+    (_4, c4) => c4 === "n" ? "\n" : c4 === "r" ? "\r" : c4 === "t" ? "	" : c4
+  );
+}
 var SystemdBackend;
 var init_systemd = __esm({
   "src/service/systemd.ts"() {
@@ -353,13 +529,33 @@ var init_systemd = __esm({
         const active = this.deps.exec("systemctl", ["--user", "is-active", `${label}.service`]);
         return { loaded: enabled.code === 0, detail: `${enabled.stdout.trim() || "?"} / ${active.stdout.trim() || "?"}` };
       }
+      /** #913 item 3 — every installed unit whose label starts with `prefix`.
+       *
+       *  Reads the unit directory rather than `systemctl list-units`, because an
+       *  ORPHAN is installed-but-inactive: the revoked device exits 0, which
+       *  SuccessExitStatus=0 treats as success, so it is never restarted. A
+       *  running-units listing would not show the thing doctor exists to find. */
+      list(prefix) {
+        const dir = join10(this.deps.home, ".config", "systemd", "user");
+        const out = [];
+        for (const name of this.deps.readdir(dir)) {
+          if (!name.startsWith(prefix) || !name.endsWith(".service")) continue;
+          const path2 = join10(dir, name);
+          out.push({
+            label: name.slice(0, -".service".length),
+            path: path2,
+            env: parseUnitEnv(this.deps.readFile(path2))
+          });
+        }
+        return out.sort((a2, b5) => a2.label.localeCompare(b5.label));
+      }
     };
   }
 });
 
 // src/service/backend.ts
 import { spawnSync } from "node:child_process";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3, rmSync as rmSync4, existsSync as existsSync4, chmodSync as chmodSync3 } from "node:fs";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3, rmSync as rmSync4, existsSync as existsSync4, chmodSync as chmodSync4, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
 import { userInfo } from "node:os";
 function defaultDeps() {
   return {
@@ -372,9 +568,23 @@ function defaultDeps() {
     },
     writeFile: (p2, d10) => writeFileSync3(p2, d10),
     mkdir: (p2) => mkdirSync5(p2, { recursive: true }),
-    chmod: (p2, m6) => chmodSync3(p2, m6),
+    chmod: (p2, m6) => chmodSync4(p2, m6),
     rm: (p2) => rmSync4(p2, { force: true }),
-    exists: (p2) => existsSync4(p2)
+    exists: (p2) => existsSync4(p2),
+    readdir: (p2) => {
+      try {
+        return readdirSync3(p2);
+      } catch {
+        return [];
+      }
+    },
+    readFile: (p2) => {
+      try {
+        return readFileSync6(p2, "utf8");
+      } catch {
+        return "";
+      }
+    }
   };
 }
 function selectBackend(platform, deps) {
@@ -397,7 +607,8 @@ var init_backend = __esm({
 // src/service/subcommand.ts
 var subcommand_exports = {};
 __export(subcommand_exports, {
-  maybeRunServiceSubcommand: () => maybeRunServiceSubcommand
+  maybeRunServiceSubcommand: () => maybeRunServiceSubcommand,
+  resolveLabel: () => resolveLabel
 });
 function requireAgentName(env) {
   const name = env.AV_AGENT_NAME?.trim();
@@ -429,7 +640,9 @@ function maybeRunServiceSubcommand(argv, env, deps) {
     const looksLikeFlag = cmd.startsWith("-");
     if (!looksLikeToken && !looksLikeFlag) {
       throw new Error(
-        `unknown subcommand: ${cmd} \u2014 expected one of ${[...SERVICE_CMDS].join(", ")}, an invite token, or no argument at all`
+        // "doctor" is dispatched earlier, in index.ts, so it never reaches here.
+        // Named anyway: a customer who typed `doctr` should see it offered.
+        `unknown subcommand: ${cmd} \u2014 expected one of ${[...SERVICE_CMDS, "doctor"].join(", ")}, an invite token, or no argument at all`
       );
     }
     return false;
@@ -440,11 +653,11 @@ function maybeRunServiceSubcommand(argv, env, deps) {
   try {
     if (cmd === "install") {
       requireAgentName(env);
+      assertInstallableEntrypoint(entrypoint);
       const cfg = loadConfig(env, []);
-      if (!hasPersistedCreds(cfg.dataDir)) {
-        throw new Error(
-          "no credentials found \u2014 enroll first by running the bridge once (AV_INVITE_TOKEN=\u2026 npx @agentvault/claude-bridge), then re-run install"
-        );
+      const firstBoot = !hasPersistedCreds(cfg.dataDir) && !!cfg.inviteToken;
+      if (firstBoot) {
+        writePendingInvite(cfg.dataDir, cfg.inviteToken);
       }
       const spec = buildServiceSpec(cfg, {
         entrypoint,
@@ -455,7 +668,11 @@ function maybeRunServiceSubcommand(argv, env, deps) {
         path: env.PATH ?? ""
       });
       backend.install(spec);
-      log(`installed service ${spec.label} \u2014 logs: ${spec.logOut}`);
+      log(`installed service ${spec.label} \u2014 logs: ${spec.logErr}`);
+      if (firstBoot) {
+        log("now APPROVE the device in AgentVault \u2014 the service is waiting to enrol");
+        log("if it does not connect within a minute, the log above says why");
+      }
       log(
         `check it with: AV_AGENT_NAME=${cfg.agentName} agentvault-claude-bridge status`
       );
@@ -487,14 +704,324 @@ var init_subcommand = __esm({
     "use strict";
     init_config();
     init_spec();
+    init_pending_invite();
     init_backend();
     SERVICE_CMDS = /* @__PURE__ */ new Set(["install", "uninstall", "restart", "status", "logs"]);
   }
 });
 
+// src/service/doctor.ts
+import { basename as basename2 } from "node:path";
+async function buildDoctorReport(d10) {
+  const installed = d10.labelPrefixes.flatMap((p2) => d10.backend.list(p2));
+  const services = [];
+  for (const s10 of installed) services.push(await inspect(s10, d10));
+  const claimed = new Set(installed.map((s10) => s10.env.AV_DATA_DIR).filter(Boolean));
+  const unsupervised = [];
+  for (const dataDir of d10.credDirs()) {
+    if (claimed.has(dataDir)) continue;
+    unsupervised.push(await inspectUnsupervised(dataDir, d10));
+  }
+  return {
+    labelPrefixes: d10.labelPrefixes,
+    services,
+    unsupervised,
+    notChecked: d10.otherLabels()
+  };
+}
+async function inspect(s10, d10) {
+  const agentName = s10.env.AV_AGENT_NAME ?? "";
+  const dataDir = s10.env.AV_DATA_DIR ?? "";
+  let loaded = false;
+  try {
+    loaded = d10.backend.status(s10.label).loaded;
+  } catch {
+  }
+  const base = { label: s10.label, agentName, dataDir, loaded, deviceId: "" };
+  if (!dataDir) {
+    return {
+      ...base,
+      verdict: "WARN",
+      detail: "the service definition bakes no AV_DATA_DIR, so doctor cannot find its credentials and cannot check its device"
+    };
+  }
+  const creds = d10.readCreds(dataDir);
+  if (!creds?.deviceId) {
+    return {
+      ...base,
+      verdict: "WARN",
+      detail: `no credentials at ${dataDir} \u2014 installed, but this agent never enrolled`
+    };
+  }
+  const deviceId = creds.deviceId;
+  let probe;
+  try {
+    probe = await d10.fetchStatus(d10.apiUrl, deviceId);
+  } catch (e7) {
+    return { ...base, deviceId, verdict: "SKIP", detail: `could not check the device: ${e7.message}` };
+  }
+  if (probe.inconclusive) {
+    return { ...base, deviceId, verdict: "SKIP", detail: `could not check the device: ${probe.inconclusive}` };
+  }
+  if (probe.gone) {
+    return {
+      ...base,
+      deviceId,
+      verdict: "FAIL",
+      detail: "the device no longer exists \u2014 this service is an orphan",
+      fix: d10.uninstallCommand(agentName)
+    };
+  }
+  switch (probe.status) {
+    case "ACTIVE":
+      return { ...base, deviceId, verdict: "PASS", detail: "device ACTIVE" };
+    case "PENDING":
+      return {
+        ...base,
+        deviceId,
+        verdict: "WARN",
+        detail: "device PENDING \u2014 enrolled, but never approved in AgentVault"
+      };
+    case "REVOKED":
+      return {
+        ...base,
+        deviceId,
+        verdict: "FAIL",
+        detail: "the device was REVOKED \u2014 this service is an orphan",
+        fix: d10.uninstallCommand(agentName)
+      };
+    default:
+      return {
+        ...base,
+        deviceId,
+        verdict: "SKIP",
+        detail: `the server reported a status this build does not recognise (${probe.status || "none"})`
+      };
+  }
+}
+async function inspectUnsupervised(dataDir, d10) {
+  const agentName = basename2(dataDir);
+  const base = { dataDir, agentName, deviceId: "" };
+  const deviceId = d10.readCreds(dataDir)?.deviceId;
+  if (!deviceId) {
+    return { ...base, verdict: "WARN", detail: "credentials present but they hold no device id" };
+  }
+  let probe;
+  try {
+    probe = await d10.fetchStatus(d10.apiUrl, deviceId);
+  } catch (e7) {
+    return { ...base, deviceId, verdict: "SKIP", detail: `could not check the device: ${e7.message}` };
+  }
+  if (probe.inconclusive) {
+    return { ...base, deviceId, verdict: "SKIP", detail: `could not check the device: ${probe.inconclusive}` };
+  }
+  if (probe.gone) {
+    return {
+      ...base,
+      deviceId,
+      verdict: "WARN",
+      detail: "the device no longer exists \u2014 these are leftover credentials for a deleted agent"
+    };
+  }
+  if (probe.status === "ACTIVE") {
+    return {
+      ...base,
+      deviceId,
+      verdict: "WARN",
+      detail: "the device is ACTIVE but nothing supervises it \u2014 this agent is not running",
+      fix: d10.installCommand(agentName)
+    };
+  }
+  if (probe.status === "PENDING") {
+    return {
+      ...base,
+      deviceId,
+      verdict: "WARN",
+      detail: "device PENDING \u2014 enrolled, but never approved in AgentVault"
+    };
+  }
+  if (probe.status === "REVOKED") {
+    return {
+      ...base,
+      deviceId,
+      verdict: "WARN",
+      detail: "the device was REVOKED \u2014 these are leftover credentials"
+    };
+  }
+  return {
+    ...base,
+    deviceId,
+    verdict: "SKIP",
+    detail: `the server reported a status this build does not recognise (${probe.status || "none"})`
+  };
+}
+function formatDoctorReport(r7) {
+  const out = [];
+  out.push(`Services installed for this bridge (${r7.labelPrefixes.map((p2) => p2 + "*").join(", ")})`);
+  if (r7.services.length === 0) {
+    out.push(`  No services installed for this bridge on this machine.`);
+  }
+  for (const s10 of r7.services) {
+    out.push(
+      `  ${s10.verdict.padEnd(PAD)}${s10.label}  [${s10.agentName || "unnamed"}]  ${s10.loaded ? "loaded" : "not loaded"}  \u2014  ${s10.detail}`
+    );
+    if (s10.fix) out.push(`  ${"".padEnd(PAD)}fix: ${s10.fix}`);
+  }
+  if (r7.unsupervised.length) {
+    out.push("");
+    out.push("Credentials on disk that no installed service points at");
+    for (const u2 of r7.unsupervised) {
+      out.push(`  ${u2.verdict.padEnd(PAD)}${u2.agentName}  \u2014  ${u2.detail}`);
+      out.push(`  ${"".padEnd(PAD)}${u2.dataDir}`);
+      if (u2.fix) out.push(`  ${"".padEnd(PAD)}fix: ${u2.fix}`);
+    }
+  }
+  if (r7.notChecked.length) {
+    out.push("");
+    out.push("Found on this machine, NOT checked by this command");
+    for (const l10 of r7.notChecked) out.push(`  ${l10}`);
+    out.push(
+      "  These belong to other AgentVault agent families. This command can only read the credentials of its own, so it says nothing about their health."
+    );
+  }
+  const counts = { PASS: 0, WARN: 0, FAIL: 0, SKIP: 0 };
+  for (const s10 of r7.services) counts[s10.verdict]++;
+  for (const u2 of r7.unsupervised) counts[u2.verdict]++;
+  out.push("");
+  out.push(
+    `Summary: ${counts.PASS} PASS, ${counts.WARN} WARN, ${counts.FAIL} FAIL, ${counts.SKIP} SKIP` + (counts.SKIP ? " (SKIP = could not check, NOT a problem found)" : "")
+  );
+  if (counts.FAIL) {
+    out.push(
+      "`uninstall` removes the SERVICE only \u2014 your credentials stay on disk, so a mistake here costs a re-install, not an identity."
+    );
+  }
+  return out;
+}
+var PAD;
+var init_doctor = __esm({
+  "src/service/doctor.ts"() {
+    "use strict";
+    PAD = 6;
+  }
+});
+
+// src/service/doctor-cli.ts
+var doctor_cli_exports = {};
+__export(doctor_cli_exports, {
+  fetchDeviceStatus: () => fetchDeviceStatus,
+  maybeRunDoctorSubcommand: () => maybeRunDoctorSubcommand,
+  realDoctorDeps: () => realDoctorDeps
+});
+import { join as join12 } from "node:path";
+import { readdirSync as readdirSync5 } from "node:fs";
+async function fetchDeviceStatus(apiUrl, deviceId, doFetch = fetch) {
+  const res = await doFetch(`${apiUrl}/api/v1/devices/${deviceId}/status`, {
+    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+  });
+  if (res.status === 404) {
+    try {
+      await res.json();
+    } catch {
+      return {
+        inconclusive: `${apiUrl} answered 404 with a non-JSON body \u2014 check AV_API_URL points at the API`
+      };
+    }
+    return { gone: true };
+  }
+  if (res.status === 429) return { inconclusive: "rate limited by the API (429)" };
+  if (!res.ok) return { inconclusive: `the API answered ${res.status}` };
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return { inconclusive: `${apiUrl} answered 200 with a non-JSON body \u2014 check AV_API_URL` };
+  }
+  return { status: body?.status };
+}
+function listCredDirs(base) {
+  const out = [];
+  if (hasPersistedCreds(base)) out.push(base);
+  let names;
+  try {
+    names = readdirSync5(base);
+  } catch {
+    return out;
+  }
+  for (const name of names) {
+    const dir = join12(base, name);
+    if (hasPersistedCreds(dir)) out.push(dir);
+  }
+  return out;
+}
+function otherFamilyLabels(backend) {
+  const out = [];
+  for (const p2 of OTHER_FAMILY_PREFIXES) {
+    try {
+      for (const s10 of backend.list(p2)) out.push(s10.label);
+    } catch {
+    }
+  }
+  return out.sort();
+}
+function realDoctorDeps(env) {
+  const backend = selectBackend(process.platform);
+  const base = join12(env.HOME ?? "", ".agentvault", "claude-room-bridge");
+  return {
+    backend,
+    labelPrefixes: [LABEL_PREFIX, LEGACY_LABEL_PREFIX],
+    base,
+    // Same default as config.ts. Read from the env directly rather than through
+    // loadConfig, which now REFUSES without AV_AGENT_NAME (#921) — and doctor's
+    // whole job is to run when you do not know which agents exist.
+    apiUrl: env.AV_API_URL ?? "https://api.agentvault.chat",
+    uninstallCommand: (n10) => `AV_AGENT_NAME=${n10 || "<agent-name>"} agentvault-claude-bridge uninstall`,
+    installCommand: (n10) => `AV_AGENT_NAME=${n10 || "<agent-name>"} agentvault-claude-bridge install`,
+    readCreds: (dir) => {
+      const deviceId = readPersistedDeviceId(dir);
+      return deviceId ? { deviceId } : null;
+    },
+    credDirs: () => listCredDirs(base),
+    fetchStatus: (apiUrl, deviceId) => fetchDeviceStatus(apiUrl, deviceId),
+    otherLabels: () => otherFamilyLabels(backend)
+  };
+}
+async function maybeRunDoctorSubcommand(argv, opts = {}) {
+  if (argv[2] !== "doctor") return false;
+  const log = opts.log ?? printLine;
+  try {
+    const report = await buildDoctorReport(opts.deps ?? realDoctorDeps(opts.env ?? process.env));
+    for (const line of formatDoctorReport(report)) log(line);
+    if (report.services.some((s10) => s10.verdict === "FAIL")) process.exitCode = 1;
+  } catch (e7) {
+    log(`doctor could not run: ${e7.message}`);
+    process.exitCode = 1;
+  }
+  return true;
+}
+var LABEL_PREFIX, LEGACY_LABEL_PREFIX, OTHER_FAMILY_PREFIXES, PROBE_TIMEOUT_MS;
+var init_doctor_cli = __esm({
+  "src/service/doctor-cli.ts"() {
+    "use strict";
+    init_backend();
+    init_config();
+    init_log();
+    init_doctor();
+    LABEL_PREFIX = "dev.agentvault.bridge-";
+    LEGACY_LABEL_PREFIX = "com.agentvault.claude-bridge.";
+    OTHER_FAMILY_PREFIXES = [
+      "dev.agentvault.grok-",
+      // grok bridge
+      "ai.hermes.gateway"
+      // hermes, one service per profile
+    ];
+    PROBE_TIMEOUT_MS = 8e3;
+  }
+});
+
 // src/index.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join11 } from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join13 } from "node:path";
 
 // ../plugin/dist/index.js
 import * as nc from "node:crypto";
@@ -45379,6 +45906,11 @@ var init_ratchet = __esm2({
         return { header, headerSignature, ciphertext, nonce };
       }
       decrypt(message) {
+        if (this.state.peerIdentityPublicKey) {
+          if (!verifyHeaderSignature(message.header, message.headerSignature, this.state.peerIdentityPublicKey)) {
+            throw new Error("Header signature verification failed");
+          }
+        }
         const isV2 = message.envelopeVersion === "2.0.0" && message.encryptedHeader != null && message.headerNonce != null;
         const skippedResult = this.trySkippedKeys(message, isV2);
         if (skippedResult !== null) {
@@ -45392,14 +45924,14 @@ var init_ratchet = __esm2({
           if (message.header.messageNumber === 0) {
             try {
               const { messageKey: testKey, headerKey: testHeaderKey, nextChainKey: nextChainKey2 } = kdfChainKey(this.state.rootKey);
-              let ad2;
+              let ad;
               if (isV2) {
                 libsodium_wrappers_default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, message.encryptedHeader, null, message.headerNonce, testHeaderKey);
-                ad2 = message.encryptedHeader;
+                ad = message.encryptedHeader;
               } else {
-                ad2 = serializeHeader(message.header);
+                ad = serializeHeader(message.header);
               }
-              const ptBytes = libsodium_wrappers_default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, message.ciphertext, ad2, message.nonce, testKey);
+              const ptBytes = libsodium_wrappers_default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, message.ciphertext, ad, message.nonce, testKey);
               this.state.dhReceivingPublicKey = message.header.dhPublicKey;
               this.state.receivingChain = {
                 chainKey: nextChainKey2,
@@ -45419,13 +45951,7 @@ var init_ratchet = __esm2({
         this.skipMessages(this.state.receivingChain, message.header.messageNumber, message.header.dhPublicKey, isV2);
         const chain = this.state.receivingChain;
         const { nextChainKey, messageKey, headerKey } = kdfChainKey(chain.chainKey);
-        chain.chainKey = nextChainKey;
-        chain.messageNumber++;
-        if (this.state.peerIdentityPublicKey) {
-          if (!verifyHeaderSignature(message.header, message.headerSignature, this.state.peerIdentityPublicKey)) {
-            throw new Error("Header signature verification failed");
-          }
-        }
+        let plaintextBytes;
         if (isV2) {
           try {
             libsodium_wrappers_default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, message.encryptedHeader, null, message.headerNonce, headerKey);
@@ -45433,19 +45959,21 @@ var init_ratchet = __esm2({
             throw new Error("V2 header decryption failed");
           }
           try {
-            const plaintextBytes = libsodium_wrappers_default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, message.ciphertext, message.encryptedHeader, message.nonce, messageKey);
-            return libsodium_wrappers_default.to_string(plaintextBytes);
+            plaintextBytes = libsodium_wrappers_default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, message.ciphertext, message.encryptedHeader, message.nonce, messageKey);
           } catch {
             throw new Error("V2 decryption failed: ciphertext tampered or wrong key");
           }
+        } else {
+          const ad = serializeHeader(message.header);
+          try {
+            plaintextBytes = libsodium_wrappers_default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, message.ciphertext, ad, message.nonce, messageKey);
+          } catch {
+            throw new Error("Decryption failed: ciphertext tampered or wrong key");
+          }
         }
-        const ad = serializeHeader(message.header);
-        try {
-          const plaintextBytes = libsodium_wrappers_default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, message.ciphertext, ad, message.nonce, messageKey);
-          return libsodium_wrappers_default.to_string(plaintextBytes);
-        } catch {
-          throw new Error("Decryption failed: ciphertext tampered or wrong key");
-        }
+        chain.chainKey = nextChainKey;
+        chain.messageNumber++;
+        return libsodium_wrappers_default.to_string(plaintextBytes);
       }
       dhRatchetReceive(theirDhPublic) {
         this.state.previousSendingChainLength = this.state.sendingChain?.messageNumber ?? 0;
@@ -63619,6 +64147,23 @@ var init_mls_delivery_order = __esm2({
     "use strict";
   }
 });
+function noteObservedEpoch(current, seen) {
+  const n22 = Number(seen);
+  if (!Number.isInteger(n22) || n22 < 0)
+    return current;
+  return n22 > current ? n22 : current;
+}
+function needsPreSendResync(localEpoch, observedEpoch) {
+  if (!Number.isInteger(localEpoch) || !Number.isInteger(observedEpoch)) {
+    return false;
+  }
+  return observedEpoch > localEpoch;
+}
+var init_mls_presend_epoch = __esm2({
+  "../crypto/dist/mls-presend-epoch.js"() {
+    "use strict";
+  }
+});
 var dist_exports = {};
 __export2(dist_exports, {
   AV_CREDENTIAL_CONTEXT: () => AV_CREDENTIAL_CONTEXT,
@@ -63688,7 +64233,9 @@ __export2(dist_exports, {
   hexTransportToEncryptedMessage: () => hexTransportToEncryptedMessage,
   issueCredential: () => issueCredential,
   multibaseToPublicKey: () => multibaseToPublicKey,
+  needsPreSendResync: () => needsPreSendResync,
   normalizeBackupCode: () => normalizeBackupCode,
+  noteObservedEpoch: () => noteObservedEpoch,
   orderDeliveryBatch: () => orderDeliveryBatch,
   parseTraceparent: () => parseTraceparent,
   performX3DH: () => performX3DH,
@@ -63728,6 +64275,7 @@ var init_dist = __esm2({
     init_mls_group();
     await init_owner_sync();
     init_mls_delivery_order();
+    init_mls_presend_epoch();
   }
 });
 async function ensureSecureDir(dir) {
@@ -63920,7 +64468,7 @@ var init_mls_kp_pool = __esm2({
   }
 });
 function ownIdentity() {
-  const v22 = true ? "0.23.23" : FALLBACK;
+  const v22 = true ? "0.23.27" : FALLBACK;
   return `${PACKAGE}@${v22}`;
 }
 function buildClientVersion(override) {
@@ -64836,6 +65384,7 @@ var init_channel = __esm2({
     await init_libsodium_wrappers();
     await init_dist();
     await init_dist();
+    init_mls_presend_epoch();
     init_mls_state();
     await init_mls_kp_pool();
     init_client_version();
@@ -64949,6 +65498,17 @@ var init_channel = __esm2({
        *  self-heal rather than be logged and dropped. */
       _mlsCommitFailCounts = /* @__PURE__ */ new Map();
       static MAX_MLS_DECRYPT_FAILS = 3;
+      /**
+       * #1084: consecutive resyncs that found NOTHING to apply, per group.
+       *
+       * "No new commits" means the server holds no commit past our epoch — we are
+       * NOT BEHIND. Treating that as corruption and re-keying is what drove the
+       * epoch churn (see `_resyncOnDivergence`). But a state that is genuinely
+       * broken while its epoch counter happens to match must still recover, so the
+       * suppression is bounded rather than absolute.
+       */
+      _resyncNoOpStrikes = /* @__PURE__ */ new Map();
+      static MAX_RESYNC_NOOPS = 3;
       /** Cached MLS KeyPackage bundle for this device (regenerated on each connect). */
       _mlsKeyPackage = null;
       /** Pending KeyPackage bundle from request-Welcome flow (used by _handleMlsWelcome). */
@@ -64986,6 +65546,13 @@ var init_channel = __esm2({
       _kpPoolFilling = false;
       /** Buffer for MLS commits received before Welcome (keyed by groupId, sorted by epoch). */
       _pendingMlsCommits = /* @__PURE__ */ new Map();
+      /**
+       * #1013: the highest group epoch any inbound frame has reported, per MLS
+       * group id. Every inbound frame carries the epoch the group was at when it
+       * was produced, so each is a LOWER BOUND on the group's current epoch — the
+       * hint is monotonic and only ever rises.
+       */
+      _observedGroupEpochs = /* @__PURE__ */ new Map();
       /** In-memory credential store for renter-provided credentials (never persisted). */
       _credentialStore = new CredentialStore();
       /** Rooms whose roster has been refreshed from the backend at least once in
@@ -65670,16 +66237,44 @@ var init_channel = __esm2({
         const pendingWsSends = [];
         const sentSharedGroupIds = /* @__PURE__ */ new Set();
         const addressedMlsGroupIds = [];
+        if (!(this._persisted?.mlsGroups && this._state === "ready" && this._ws)) {
+          console.warn(
+            `[SecureChannel] send(): shared-MLS block SKIPPED \u2014 mlsGroups=${this._persisted?.mlsGroups ? Object.keys(this._persisted.mlsGroups).length : "none"} state=${this._state} ws=${this._ws ? "open" : "null"}`
+          );
+        }
         if (this._persisted?.mlsGroups && this._state === "ready" && this._ws) {
           const targetSharedGid = targetConvId ? this._sessionGroupIds?.get(targetConvId) : void 0;
+          console.log(
+            `[SecureChannel] send(): considering ${Object.keys(this._persisted.mlsGroups).length} shared group(s); targetConvId=${targetConvId ? targetConvId.slice(0, 8) : "(none \u2014 broadcast)"} targetSharedGid=${targetSharedGid ? targetSharedGid.slice(0, 8) : "(none)"}`
+          );
+          const skipped = [];
           for (const [gid, entry] of Object.entries(this._persisted.mlsGroups)) {
-            if (targetConvId && gid !== targetSharedGid) continue;
-            if (!entry.mlsGroupId) continue;
+            if (targetConvId && gid !== targetSharedGid) {
+              skipped.push(`${gid.slice(0, 8)}:not-target`);
+              continue;
+            }
+            if (!entry.mlsGroupId) {
+              skipped.push(`${gid.slice(0, 8)}:no-mlsGroupId`);
+              continue;
+            }
             const mlsGroup = this._mlsGroups.get(`1to1-group:${gid}`);
-            if (!mlsGroup?.isInitialized || Number(mlsGroup.epoch) <= 0) continue;
+            if (!mlsGroup?.isInitialized) {
+              skipped.push(`${gid.slice(0, 8)}:not-in-memory`);
+              continue;
+            }
+            if (Number(mlsGroup.epoch) <= 0) {
+              skipped.push(`${gid.slice(0, 8)}:epoch<=0`);
+              continue;
+            }
             try {
               const plaintextBytes = new TextEncoder().encode(plaintext);
-              const cipherBytes = await mlsGroup.encrypt(plaintextBytes);
+              const cipherBytes = await this._encryptWithCatchUp(
+                mlsGroup,
+                `1to1-group:${gid}`,
+                entry.mlsGroupId,
+                `1:1 group ${gid.slice(0, 8)}`,
+                plaintextBytes
+              );
               await saveMlsState(this.config.dataDir, entry.mlsGroupId, JSON.stringify(mlsGroup.exportState()));
               const payload = {
                 group_id: entry.mlsGroupId,
@@ -65701,8 +66296,12 @@ var init_channel = __esm2({
               console.log(`[SecureChannel] Shared MLS group send for group ${gid.slice(0, 8)} (${entry.mlsGroupId.slice(0, 8)})`);
             } catch (err) {
               console.error(`[SecureChannel] Shared MLS group send failed for ${gid.slice(0, 8)}:`, err);
+              skipped.push(`${gid.slice(0, 8)}:encrypt-threw`);
             }
           }
+          if (skipped.length > 0) {
+            console.log(`[SecureChannel] send(): skipped ${skipped.length} group(s) \u2014 ${skipped.join(", ")}`);
+          }
         }
         for (const [convId, session] of this._sessions) {
           if (!session.activated) continue;
@@ -65722,7 +66321,14 @@ var init_channel = __esm2({
             }
             if (mlsGroup?.isInitialized && mlsGroupId && Number(mlsGroup.epoch) > 0 && this._state === "ready" && this._ws) {
               const plaintextBytes = new TextEncoder().encode(plaintext);
-              const cipherBytes = await mlsGroup.encrypt(plaintextBytes);
+              const sessionGroupKey = convGroupId && this._mlsGroups.has(`1to1-group:${convGroupId}`) ? `1to1-group:${convGroupId}` : `conv:${convId}`;
+              const cipherBytes = await this._encryptWithCatchUp(
+                mlsGroup,
+                sessionGroupKey,
+                mlsGroupId,
+                `conversation ${convId.slice(0, 8)}`,
+                plaintextBytes
+              );
               await saveMlsState(this.config.dataDir, mlsGroupId, JSON.stringify(mlsGroup.exportState()));
               const payload = {
                 conversation_id: convId,
@@ -65817,7 +66423,14 @@ var init_channel = __esm2({
             }
             try {
               const plaintextBytes = new TextEncoder().encode(plaintext);
-              const cipherBytes = await mlsGroup.encrypt(plaintextBytes);
+              const mlsOnlyGroupKey = mlsOnlyConvGroupId && this._mlsGroups.has(`1to1-group:${mlsOnlyConvGroupId}`) ? `1to1-group:${mlsOnlyConvGroupId}` : `conv:${mlsConvId}`;
+              const cipherBytes = await this._encryptWithCatchUp(
+                mlsGroup,
+                mlsOnlyGroupKey,
+                resolvedMlsGroupId,
+                `conversation ${mlsConvId.slice(0, 8)}`,
+                plaintextBytes
+              );
               await saveMlsState(this.config.dataDir, resolvedMlsGroupId, JSON.stringify(mlsGroup.exportState()));
               const payload = {
                 conversation_id: mlsConvId,
@@ -65843,13 +66456,26 @@ var init_channel = __esm2({
             }
           }
         }
-        if (sentCount === 0 && this._sessions.size > 0) {
-          console.warn("[SecureChannel] send() delivered to 0 sessions (all skipped or failed)");
+        if (sentCount === 0) {
+          console.warn(
+            `[SecureChannel] send() delivered to 0 destinations \u2014 nothing was encrypted or queued (sessions=${this._sessions.size}, sharedGroups=${this._persisted?.mlsGroups ? Object.keys(this._persisted.mlsGroups).length : 0})`
+          );
         }
         await this._persistState();
+        const wsReady = this._ws?.readyState === 1;
+        if (pendingWsSends.length > 0 && !wsReady) {
+          console.warn(
+            `[SecureChannel] send(): ${pendingWsSends.length} frame(s) NOT written \u2014 socket readyState=${this._ws?.readyState ?? "null"} (1=OPEN)`
+          );
+        }
         for (const frame of pendingWsSends) {
           this._ws.send(frame);
         }
+        if (pendingWsSends.length > 0) {
+          console.log(
+            `[SecureChannel] send(): wrote ${pendingWsSends.length} frame(s) to the socket (sentCount=${sentCount}, readyState=${this._ws?.readyState ?? "null"})`
+          );
+        }
         if (!options?.isResend) {
           for (const mlsGroupId of addressedMlsGroupIds) {
             this._rememberRetryCandidate(mlsGroupId, plaintext, options);
@@ -65899,7 +66525,7 @@ var init_channel = __esm2({
        */
       sendActivitySpan(spanData) {
         if (!this._ws || this._ws.readyState !== WebSocket2.OPEN) return;
-        const pluginVersion = true ? "0.23.23" : "0.0.0-dev";
+        const pluginVersion = true ? "0.23.27" : "0.0.0-dev";
         const agentName = this.config.agentName ?? "Agent";
         const resource = {
           "service.name": "agentvault-agent",
@@ -66109,7 +66735,13 @@ var init_channel = __esm2({
           if (mlsGroup?.isInitialized) {
             try {
               const plaintextBytes = new TextEncoder().encode(plaintext);
-              const ciphertext = await mlsGroup.encrypt(plaintextBytes);
+              const ciphertext = await this._encryptWithCatchUp(
+                mlsGroup,
+                roomId,
+                room.mlsGroupId,
+                `room ${roomId.slice(0, 8)}`,
+                plaintextBytes
+              );
               await saveMlsState(this.config.dataDir, room.mlsGroupId, JSON.stringify(mlsGroup.exportState()));
               if (this._state === "ready" && this._ws) {
                 this._ws.send(JSON.stringify({
@@ -66360,11 +66992,17 @@ var init_channel = __esm2({
         const before = this._persisted.groupId;
         this._sessionGroupIds = new Map(mine.map((r22) => [r22.id, r22.group_id]));
         this._persisted.conversationGroupIds = Object.fromEntries(this._sessionGroupIds);
-        const primary = mine.find((r22) => r22.id === this._persisted.primaryConversationId) ?? mine[0];
+        const joined = mine.find((r22) => this._persisted.mlsGroups?.[r22.group_id]);
+        const primary = mine.find((r22) => r22.id === this._persisted.primaryConversationId) ?? joined ?? mine[0];
+        if (!mine.some((r22) => r22.id === this._persisted.primaryConversationId)) {
+          console.log(
+            `[SecureChannel] Adopting new primary conversation ${primary.id.slice(0, 8)} (group ${primary.group_id.slice(0, 8)}) \u2014 ${joined ? "we hold MLS state for it" : "no joined conversation found, first active row"}`
+          );
+        }
         this._persisted.groupId = primary.group_id;
         this._persisted.primaryConversationId = primary.id;
         const liveGroupIds = new Set(mine.map((r22) => r22.group_id));
-        if (!liveGroupIds.has(staleGid)) {
+        if (staleGid && staleMlsGroupId && !liveGroupIds.has(staleGid)) {
           try {
             await deleteMlsState(this.config.dataDir, staleMlsGroupId);
           } catch {
@@ -66378,9 +67016,9 @@ var init_channel = __esm2({
         }
         await this._persistState();
         console.log(
-          `[SecureChannel] Re-resolved conversation groups after 'unknown group' ${staleMlsGroupId.slice(0, 8)}: primary group ${String(before).slice(0, 8)} \u2192 ${this._persisted.groupId.slice(0, 8)} (${mine.length} active conversation(s))`
+          `[SecureChannel] Re-resolved conversation groups ${staleMlsGroupId ? `after 'unknown group' ${staleMlsGroupId.slice(0, 8)}` : "on connect (#1034)"}: primary group ${String(before).slice(0, 8)} \u2192 ${this._persisted.groupId.slice(0, 8)} (${mine.length} active conversation(s))`
         );
-        return this._persisted.groupId !== before && before === staleGid;
+        return staleGid !== void 0 && this._persisted.groupId !== before && before === staleGid;
       }
       /**
        * Resend the message that a now-reconciled `unknown group` refusal killed (#732).
@@ -67288,7 +67926,13 @@ var init_channel = __esm2({
           const mlsGroup = this._mlsGroups.get(`a2a:${channelEntry.channelId}`);
           if (mlsGroup?.isInitialized) {
             const plaintextBytes = new TextEncoder().encode(text);
-            const ciphertext = await mlsGroup.encrypt(plaintextBytes);
+            const ciphertext = await this._encryptWithCatchUp(
+              mlsGroup,
+              `a2a:${channelEntry.channelId}`,
+              channelEntry.mlsGroupId,
+              `A2A ${channelEntry.channelId.slice(0, 8)}`,
+              plaintextBytes
+            );
             await saveMlsState(
               this.config.dataDir,
               channelEntry.mlsGroupId,
@@ -67336,7 +67980,13 @@ var init_channel = __esm2({
           const mlsGroup = this._mlsGroups.get(`a2a:${channelId}`);
           if (mlsGroup?.isInitialized) {
             const plaintextBytes = new TextEncoder().encode(text);
-            const ciphertext = await mlsGroup.encrypt(plaintextBytes);
+            const ciphertext = await this._encryptWithCatchUp(
+              mlsGroup,
+              `a2a:${channelId}`,
+              entry.mlsGroupId,
+              `A2A ${channelId.slice(0, 8)}`,
+              plaintextBytes
+            );
             await saveMlsState(this.config.dataDir, entry.mlsGroupId, JSON.stringify(mlsGroup.exportState()));
             this._ws.send(JSON.stringify({
               event: "a2a_message_mls",
@@ -67782,6 +68432,9 @@ var init_channel = __esm2({
             await this._pullDrDeliveryQueue();
             await this._flushOutboundQueue();
             this._setState("ready");
+            void this._reconcileConversationGroups().catch((err) => {
+              console.warn("[SecureChannel] Conversation-group reconcile failed:", err);
+            });
             void this._reconcileRoomsWithServer().catch(
               (err) => console.warn(`[SecureChannel] room reconcile failed (ignored): ${err instanceof Error ? err.message : String(err)}`)
             ).then(() => this._quarantineOrphanedMlsGroups()).catch(
@@ -67809,7 +68462,7 @@ var init_channel = __esm2({
                 agentVersion: this.config.agentVersion ?? "0.0.0",
                 // __AV_VERSION__ is injected by esbuild from package.json at build time.
                 // Falls back to "0.0.0-dev" in non-bundled contexts (tests).
-                pluginVersion: true ? "0.23.23" : "0.0.0-dev"
+                pluginVersion: true ? "0.23.27" : "0.0.0-dev"
               });
               this._telemetryReporter.startAutoFlush(3e4);
             }
@@ -68133,7 +68786,7 @@ var init_channel = __esm2({
                     agentVersion: this.config.agentVersion ?? "0.0.0",
                     // __AV_VERSION__ is injected by esbuild from package.json at build time.
                     // Falls back to "0.0.0-dev" in non-bundled contexts (tests).
-                    pluginVersion: true ? "0.23.23" : "0.0.0-dev"
+                    pluginVersion: true ? "0.23.27" : "0.0.0-dev"
                   });
                   this._telemetryReporter.startAutoFlush(3e4);
                 }
@@ -68499,6 +69152,7 @@ var init_channel = __esm2({
         const convGroupId = data.conversation_group_id;
         const groupId = data.group_id;
         const senderDeviceId = data.sender_device_id;
+        this._noteGroupEpoch(groupId, data.epoch);
         if (senderDeviceId === this._deviceId) return;
         let mgr;
         let mgrKey;
@@ -68576,9 +69230,15 @@ var init_channel = __esm2({
                 })),
                 no_history: filtered.length === 0
               });
-              if (mgr && mlsGroupId) {
+              if (mgr && mgrKey && mlsGroupId) {
                 const responseBytes = new TextEncoder().encode(responsePayload);
-                const cipher = await mgr.encrypt(responseBytes);
+                const cipher = await this._encryptWithCatchUp(
+                  mgr,
+                  mgrKey,
+                  mlsGroupId,
+                  `history catch-up ${mlsGroupId.slice(0, 8)}`,
+                  responseBytes
+                );
                 await saveMlsState(this.config.dataDir, mlsGroupId, JSON.stringify(mgr.exportState()));
                 if (this._ws) {
                   this._ws.send(JSON.stringify({
@@ -69321,9 +69981,36 @@ ${messageText}`;
       // ---------------------------------------------------------------------------
       // MLS room message handlers
       // ---------------------------------------------------------------------------
+      /**
+       * #1014: hand a room-framed frame to the handler that owns its group family.
+       *
+       * Returns true when the frame was routed. Routing means "give it to the right
+       * handler" — NOT "decrypt it as a room message". Decrypting under the wrong
+       * group is how MLS state gets corrupted, so an unplaceable group is left for
+       * the caller to self-heal rather than guessed at.
+       */
+      async _routeNonRoomGroupMessage(data, groupId) {
+        const target = this._resolveGroupFamily(groupId);
+        if (!target || target.family === "room") return false;
+        console.log(
+          `[SecureChannel] Room-framed message belongs to ${target.label} \u2014 routing to the handler that owns it (#1014)`
+        );
+        switch (target.family) {
+          case "shared1to1":
+            await this._handleMessageMLS({ ...data, conversation_group_id: target.id });
+            return true;
+          case "conversation":
+            await this._handleMessageMLS({ ...data, conversation_id: target.id });
+            return true;
+          case "a2a":
+            await this._handleA2AMessageMLS({ ...data, a2a_channel_id: target.id });
+            return true;
+        }
+      }
       async _handleRoomMessageMLS(data) {
         const groupId = data.group_id;
         const senderDeviceId = data.sender_device_id;
+        this._noteGroupEpoch(groupId, data.epoch);
         if (senderDeviceId === this._deviceId) return;
         let roomId;
         for (const [rid, room] of Object.entries(this._persisted?.rooms ?? {})) {
@@ -69337,7 +70024,9 @@ ${messageText}`;
             roomId = data.room_id;
             console.log(`[SecureChannel] Room ${roomId.slice(0, 8)} matched by room_id (group_id ${groupId?.slice(0, 8)} mismatch)`);
           } else {
+            if (await this._routeNonRoomGroupMessage(data, groupId)) return;
             console.warn(`[SecureChannel] No room found for MLS group ${groupId?.slice(0, 8)}`);
+            if (groupId) void this._requestWelcomeSelfHeal(groupId);
             return;
           }
         }
@@ -69525,63 +70214,63 @@ ${messageText}`;
           console.warn(`[SecureChannel] Failed to send history catchup response:`, sendErr);
         }
       }
+      /**
+       * Apply an inbound MLS commit to whichever group it addresses.
+       *
+       * Returns TRUE when the commit was applied, buffered, or handed to the
+       * failure ladder — i.e. when this agent has taken responsibility for it and
+       * the delivery-queue row may safely be acked. Returns FALSE when the commit
+       * names a group we hold no state for at all, so the caller must NACK and let
+       * the row survive.
+       *
+       * #1012: this used to loop `rooms` then `a2aChannels` and then END. A shared
+       * 1:1 commit (`mlsGroups`) and a legacy per-conversation commit
+       * (`mlsConversations`) matched neither. The call fell off the bottom with no
+       * log, no buffer and no error — and because it did not THROW,
+       * `_pullDeliveryQueue` acked the row and the server deleted it. An MLS commit
+       * cannot be regenerated, so the agent stayed at epoch N while the group moved
+       * to N+1 and every later send() encrypted at an epoch nobody could decrypt.
+       *
+       * The families are enumerated in ONE list resolved by ONE loop, because two
+       * hand-copied loops are exactly how the 1:1 path fell two families behind.
+       */
       async _handleMlsCommit(data) {
         const groupId = data.group_id;
         const epoch = typeof data.epoch === "number" ? data.epoch : 0;
-        for (const [roomId, room] of Object.entries(this._persisted?.rooms ?? {})) {
-          if (room.mlsGroupId === groupId) {
-            const mlsGroup = this._mlsGroups.get(roomId);
-            if (mlsGroup?.isInitialized) {
-              try {
-                const commitBytes = new Uint8Array(Buffer.from(data.payload, "hex"));
-                await mlsGroup.processCommit(commitBytes);
-                await saveMlsState(this.config.dataDir, groupId, JSON.stringify(mlsGroup.exportState()));
-                console.log(`[SecureChannel] MLS commit processed for room ${roomId.slice(0, 8)} (epoch=${mlsGroup.epoch})`);
-                this._mlsCommitFailCounts.delete(roomId);
-              } catch (err) {
-                await this._onCommitFailure(
-                  roomId,
-                  groupId,
-                  err,
-                  `room ${roomId.slice(0, 8)}`,
-                  data.epoch,
-                  mlsGroup.epoch
-                );
-              }
-            } else {
-              this._bufferMlsCommit(groupId, epoch, data);
-              console.log(`[SecureChannel] Buffered MLS commit for room ${roomId.slice(0, 8)} (epoch=${epoch}, group not initialized)`);
-            }
-            return;
+        this._noteGroupEpoch(groupId, data.epoch);
+        const target = this._resolveGroupFamily(groupId);
+        if (target) {
+          const { managerKey: groupKey, label } = target;
+          const mlsGroup = this._mlsGroups.get(groupKey);
+          if (!mlsGroup?.isInitialized) {
+            this._bufferMlsCommit(groupId, epoch, data);
+            console.log(`[SecureChannel] Buffered MLS commit for ${label} (epoch=${epoch}, group not initialized)`);
+            return true;
           }
-        }
-        for (const [chId, chState] of Object.entries(this._persisted?.a2aChannels ?? {})) {
-          if (chState.mlsGroupId === groupId) {
-            const mlsGroup = this._mlsGroups.get(`a2a:${chId}`);
-            if (mlsGroup?.isInitialized) {
-              try {
-                const commitBytes = new Uint8Array(Buffer.from(data.payload, "hex"));
-                await mlsGroup.processCommit(commitBytes);
-                await saveMlsState(this.config.dataDir, groupId, JSON.stringify(mlsGroup.exportState()));
-                console.log(`[SecureChannel] MLS commit processed for A2A ${chId.slice(0, 8)} (epoch=${mlsGroup.epoch})`);
-                this._mlsCommitFailCounts.delete(`a2a:${chId}`);
-              } catch (err) {
-                await this._onCommitFailure(
-                  `a2a:${chId}`,
-                  groupId,
-                  err,
-                  `A2A ${chId.slice(0, 8)}`,
-                  data.epoch,
-                  mlsGroup.epoch
-                );
-              }
-            } else {
-              this._bufferMlsCommit(groupId, epoch, data);
-              console.log(`[SecureChannel] Buffered MLS commit for A2A ${chId.slice(0, 8)} (epoch=${epoch}, group not initialized)`);
-            }
-            return;
+          try {
+            const commitBytes = new Uint8Array(Buffer.from(data.payload, "hex"));
+            await mlsGroup.processCommit(commitBytes);
+            await saveMlsState(this.config.dataDir, groupId, JSON.stringify(mlsGroup.exportState()));
+            console.log(`[SecureChannel] MLS commit processed for ${label} (epoch=${mlsGroup.epoch})`);
+            this._mlsCommitFailCounts.delete(groupKey);
+          } catch (err) {
+            await this._onCommitFailure(
+              groupKey,
+              groupId,
+              err,
+              label,
+              data.epoch,
+              mlsGroup.epoch
+            );
           }
+          return true;
         }
+        this._bufferMlsCommit(groupId, epoch, data);
+        console.warn(
+          `[SecureChannel] MLS commit for UNKNOWN group ${String(groupId).slice(0, 8)} (epoch=${epoch}) \u2014 buffered, requesting a Welcome, NOT acked`
+        );
+        if (groupId) void this._requestWelcomeSelfHeal(groupId);
+        return false;
       }
       /** Buffer an MLS commit for replay after Welcome join. Max 50 per group. */
       _bufferMlsCommit(groupId, epoch, data) {
@@ -69771,6 +70460,229 @@ ${messageText}`;
        *   `1to1-group:<gid>`, `a2a:<channelId>`, …) — also the decrypt-fail-count key.
        * @param groupId  the server-side MLS group id used in the /sync URL.
        */
+      /**
+       * #1015 — the ONLY place this package fulfils a Welcome request.
+       *
+       * Add the members, transmit, and record `fulfilled` **only for the targets
+       * whose frames actually went out**. Every one of the five sites that used to
+       * do this by hand followed the same sequence and had the same three holes:
+       * `this._ws` null (both sends skipped by an `if`), a CLOSING socket (`send`
+       * returns without throwing), and a fulfil POST wrapped in `.catch(() => {})`.
+       *
+       * A fulfilled request is never re-requested. So a Welcome that evaporated
+       * left the requester locked out, the fulfiller at epoch N+1, everyone else at
+       * N, and the bridging commit untransmitted and impossible to regenerate — a
+       * permanently wedged group in which every signal read success.
+       *
+       * Returns the number of requests actually fulfilled.
+       */
+      async _fulfilWelcomeRequests(opts) {
+        const { mlsGroup, mlsGroupId, label, welcomeFields, targets } = opts;
+        if (targets.length === 0) return 0;
+        if (!this._wsIsOpen()) {
+          console.warn(
+            `[SecureChannel] ${label}: socket is not OPEN \u2014 NOT advancing the group; ${targets.length} request(s) stay pending for the next pull`
+          );
+          return 0;
+        }
+        const snapshot = mlsGroup.exportState();
+        const { commit, welcome } = await mlsGroup.addMembers(targets.map((t22) => t22.keyPackage));
+        const commitSent = await this._sendFrameConfirmed(
+          {
+            event: "mls_commit",
+            data: {
+              group_id: mlsGroupId,
+              epoch: Number(mlsGroup.epoch),
+              payload: Buffer.from(commit).toString("hex")
+            }
+          },
+          `${label} commit`
+        );
+        if (!commitSent) {
+          mlsGroup.importState(snapshot);
+          console.warn(
+            `[SecureChannel] ${label}: commit was NOT written \u2014 rolled back to epoch ${Number(mlsGroup.epoch)}, nothing fulfilled, requests stay pending`
+          );
+          return 0;
+        }
+        await saveMlsState(this.config.dataDir, mlsGroupId, JSON.stringify(mlsGroup.exportState()));
+        if (!welcome) {
+          console.warn(
+            `[SecureChannel] ${label}: addMembers produced NO Welcome \u2014 ${targets.length} request(s) left pending rather than marked fulfilled`
+          );
+          return 0;
+        }
+        let fulfilled = 0;
+        for (const t22 of targets) {
+          const sent = await this._sendFrameConfirmed(
+            {
+              event: "mls_welcome",
+              data: {
+                target_device_id: t22.deviceId,
+                group_id: mlsGroupId,
+                ...welcomeFields,
+                payload: Buffer.from(welcome).toString("hex")
+              }
+            },
+            `${label} welcome\u2192${t22.deviceId.slice(0, 8)}`
+          );
+          if (!sent) {
+            console.warn(
+              `[SecureChannel] ${label}: Welcome for ${t22.deviceId.slice(0, 8)} was NOT written \u2014 leaving the request PENDING so the next pull retries it`
+            );
+            continue;
+          }
+          if (await this._postFulfilWelcome(mlsGroupId, t22.requestId, `${label} ${t22.deviceId.slice(0, 8)}`)) {
+            fulfilled++;
+          }
+        }
+        return fulfilled;
+      }
+      /**
+       * Resolve an MLS group id to the family that owns it.
+       *
+       * There are four: rooms, A2A channels, shared 1:1 groups, and the legacy
+       * per-conversation groups. They all store the MLS group id under
+       * `mlsGroupId`; they differ only in the key their live `MLSGroupManager` sits
+       * under in `_mlsGroups`.
+       *
+       * ONE resolver, because hand-copying this enumeration is what produced
+       * #1012 (`_handleMlsCommit` handled two families of four), #1014 (a
+       * room-framed 1:1 replay matched nothing) and #1016 (a rejoin dropped only
+       * the room manager). Three bugs, one missing abstraction.
+       */
+      _resolveGroupFamily(mlsGroupId) {
+        if (!mlsGroupId) return null;
+        const families = [
+          { family: "room", entries: this._persisted?.rooms, managerKey: (id) => id, label: "room" },
+          { family: "a2a", entries: this._persisted?.a2aChannels, managerKey: (id) => `a2a:${id}`, label: "A2A" },
+          { family: "shared1to1", entries: this._persisted?.mlsGroups, managerKey: (id) => `1to1-group:${id}`, label: "1:1 group" },
+          { family: "conversation", entries: this._persisted?.mlsConversations, managerKey: (id) => `conv:${id}`, label: "conversation" }
+        ];
+        for (const f22 of families) {
+          for (const [id, entry] of Object.entries(f22.entries ?? {})) {
+            if (entry?.mlsGroupId !== mlsGroupId) continue;
+            return {
+              family: f22.family,
+              id,
+              managerKey: f22.managerKey(id),
+              label: `${f22.label} ${id.slice(0, 8)}`
+            };
+          }
+        }
+        return null;
+      }
+      /** #1015: is the socket in a state that can actually take a write? */
+      _wsIsOpen() {
+        return this._ws?.readyState === 1;
+      }
+      /**
+       * #1015: write one frame and report whether the socket took it.
+       *
+       * `ws.send()` on a CLOSING or CLOSED socket returns WITHOUT throwing — the
+       * error surfaces only through the callback, and every fulfilment site passed
+       * none. So a Welcome could be "sent" into a dead socket and the requester
+       * still marked `fulfilled`, which it never re-requests.
+       */
+      _sendFrameConfirmed(frame, label) {
+        const ws = this._ws;
+        if (!ws || ws.readyState !== 1) {
+          console.warn(
+            `[SecureChannel] ${label}: socket is not OPEN (readyState=${ws?.readyState ?? "null"}) \u2014 frame NOT written`
+          );
+          return Promise.resolve(false);
+        }
+        return new Promise((resolve32) => {
+          try {
+            ws.send(JSON.stringify(frame), (err) => {
+              if (err) {
+                console.error(`[SecureChannel] ${label}: socket refused the frame:`, err);
+                resolve32(false);
+              } else {
+                resolve32(true);
+              }
+            });
+          } catch (err) {
+            console.error(`[SecureChannel] ${label}: send threw:`, err);
+            resolve32(false);
+          }
+        });
+      }
+      /**
+       * #1015: record a Welcome as fulfilled — and say so when it fails.
+       *
+       * The batched shared-1:1 site posted this with `.catch(() => {})`, so an HTTP
+       * failure here was invisible on top of the sends being invisible.
+       */
+      async _postFulfilWelcome(mlsGroupId, requestId, label) {
+        try {
+          const res = await fetch(
+            `${this.config.apiUrl}/api/v1/mls/groups/${mlsGroupId}/fulfill-welcome`,
+            {
+              method: "POST",
+              headers: { Authorization: `Bearer ${this._deviceJwt}`, "Content-Type": "application/json" },
+              body: JSON.stringify({ request_id: requestId })
+            }
+          );
+          if (!res.ok) {
+            console.warn(`[SecureChannel] ${label}: fulfill-welcome returned ${res.status}`);
+            return false;
+          }
+          return true;
+        } catch (err) {
+          console.warn(`[SecureChannel] ${label}: fulfill-welcome failed:`, err);
+          return false;
+        }
+      }
+      /**
+       * #1013: fold an epoch seen on an inbound frame into the running hint.
+       *
+       * Anything unusable (missing, non-numeric, negative, fractional) is ignored
+       * rather than defaulted. A defaulted epoch here would be a guess, and a guess
+       * that reads LOW silently disables the check it exists to drive.
+       */
+      _noteGroupEpoch(mlsGroupId, epoch) {
+        if (typeof mlsGroupId !== "string" || !mlsGroupId) return;
+        const current = this._observedGroupEpochs.get(mlsGroupId) ?? 0;
+        const next = noteObservedEpoch(current, epoch);
+        if (next > current) this._observedGroupEpochs.set(mlsGroupId, next);
+      }
+      /**
+       * #1013 — the ONLY place this package encrypts an MLS application message.
+       *
+       * Catch up first when the group is known to have moved past us, then encrypt.
+       * Hermes has done this since #440 and the browser since #996; the plugin —
+       * the implementation that actually ships to customers — did not, so an agent
+       * that missed one commit encrypted every later message at an epoch nobody
+       * could read, while the server stored and relayed it and every signal read
+       * 200.
+       *
+       * Funnelling every sender through one method is the point. A guard applied at
+       * seven call sites decays to a guard applied at six: that is exactly how
+       * `_handleMlsCommit` ended up handling two group families out of four (#1012).
+       *
+       * Best-effort by design. A catch-up that cannot replay — or that throws — must
+       * NOT block the send; we fall through and encrypt at the local epoch, which is
+       * precisely today's behaviour, so the worst case is no regression.
+       */
+      async _encryptWithCatchUp(mlsGroup, groupKey, mlsGroupId, label, plaintextBytes) {
+        const observed = this._observedGroupEpochs.get(mlsGroupId);
+        if (observed !== void 0 && needsPreSendResync(Number(mlsGroup.epoch), observed)) {
+          console.warn(
+            `[SecureChannel] ${label}: local epoch ${Number(mlsGroup.epoch)} is behind the observed group epoch ${observed} \u2014 catching up before encrypt (#1013)`
+          );
+          try {
+            if (!await this._resyncOnDivergence(groupKey, mlsGroupId)) {
+              console.warn(
+                `[SecureChannel] ${label}: catch-up could not replay \u2014 sending at epoch ${Number(mlsGroup.epoch)}. Peers past this epoch will not read it.`
+              );
+            }
+          } catch (err) {
+            console.warn(`[SecureChannel] ${label}: catch-up failed:`, err);
+          }
+        }
+        return await mlsGroup.encrypt(plaintextBytes);
+      }
       async _resyncOnDivergence(groupKey, groupId) {
         const mgr = this._mlsGroups.get(groupKey);
         if (!mgr?.isInitialized) return false;
@@ -69797,11 +70709,24 @@ ${messageText}`;
             applied++;
           }
           if (applied === 0) {
-            console.log(`[SecureChannel] Resync for ${groupId.slice(0, 8)}: no new commits to apply (epoch=${mgr.epoch})`);
+            const strikes = (this._resyncNoOpStrikes.get(groupKey) ?? 0) + 1;
+            this._resyncNoOpStrikes.set(groupKey, strikes);
+            if (strikes < _SecureChannel.MAX_RESYNC_NOOPS) {
+              this._mlsDecryptFailCounts.delete(groupKey);
+              console.log(
+                `[SecureChannel] Resync for ${groupId.slice(0, 8)}: already current at epoch=${mgr.epoch} (strike ${strikes}/${_SecureChannel.MAX_RESYNC_NOOPS}) \u2014 NOT re-keying (#1084)`
+              );
+              return true;
+            }
+            this._resyncNoOpStrikes.delete(groupKey);
+            console.warn(
+              `[SecureChannel] Resync for ${groupId.slice(0, 8)}: still failing at epoch=${mgr.epoch} after ${_SecureChannel.MAX_RESYNC_NOOPS} no-op resyncs \u2014 escalating to re-key`
+            );
             return false;
           }
           await saveMlsState(this.config.dataDir, groupId, JSON.stringify(mgr.exportState()));
           this._mlsDecryptFailCounts.delete(groupKey);
+          this._resyncNoOpStrikes.delete(groupKey);
           console.log(
             `[SecureChannel] Resync-on-divergence: applied ${applied} missed commit(s) for ${groupId.slice(0, 8)}, now epoch=${mgr.epoch}`
           );
@@ -70188,6 +71113,7 @@ ${messageText}`;
             const ackedIds = [];
             const nackedIds = [];
             for (const msg of messages) {
+              let handled = true;
               try {
                 if (msg.sender_device_id === this._deviceId) {
                   ackedIds.push(msg.queue_id);
@@ -70204,7 +71130,7 @@ ${messageText}`;
                     a2a_channel_id: msg.a2a_channel_id
                   });
                 } else if (msg.message_type === "commit") {
-                  await this._handleMlsCommit({
+                  handled = await this._handleMlsCommit({
                     group_id: msg.group_id,
                     sender_device_id: msg.sender_device_id,
                     epoch: msg.epoch,
@@ -70242,9 +71168,18 @@ ${messageText}`;
                       conversation_group_id: msg.conversation_group_id,
                       created_at: msg.created_at
                     });
+                  } else {
+                    handled = false;
+                    console.warn(
+                      `[SecureChannel] Delivery application row ${String(msg.message_id).slice(0, 8)} names no room, A2A channel or conversation \u2014 NOT acked`
+                    );
                   }
                 }
-                ackedIds.push(msg.queue_id);
+                if (handled) {
+                  ackedIds.push(msg.queue_id);
+                } else {
+                  nackedIds.push(msg.queue_id);
+                }
               } catch (err) {
                 console.warn(`[SecureChannel] Delivery ${msg.message_type} processing failed:`, err);
                 nackedIds.push(msg.queue_id);
@@ -70313,38 +71248,20 @@ ${messageText}`;
                   if (!kpHex) continue;
                   const kpBytes = new Uint8Array(Buffer.from(kpHex, "hex"));
                   const memberKp = MLSGroupManager.deserializeKeyPackage(kpBytes);
-                  const { commit, welcome } = await mlsGroup.addMembers([memberKp]);
-                  if (this._ws) {
-                    this._ws.send(JSON.stringify({
-                      event: "mls_commit",
-                      data: {
-                        group_id: roomState.mlsGroupId,
-                        epoch: Number(mlsGroup.epoch),
-                        payload: Buffer.from(commit).toString("hex")
-                      }
-                    }));
-                  }
-                  if (welcome && this._ws) {
-                    this._ws.send(JSON.stringify({
-                      event: "mls_welcome",
-                      data: {
-                        target_device_id: req.requesting_device_id,
-                        group_id: roomState.mlsGroupId,
-                        room_id: roomId,
-                        payload: Buffer.from(welcome).toString("hex")
-                      }
-                    }));
+                  const done = await this._fulfilWelcomeRequests({
+                    mlsGroup,
+                    mlsGroupId: roomState.mlsGroupId,
+                    label: `room ${roomId.slice(0, 8)}`,
+                    welcomeFields: { room_id: roomId },
+                    targets: [{
+                      requestId: req.id,
+                      deviceId: req.requesting_device_id,
+                      keyPackage: memberKp
+                    }]
+                  });
+                  if (done > 0) {
+                    console.log(`[SecureChannel] Fulfilled Welcome for ${req.requesting_device_id.slice(0, 8)} in room ${roomId.slice(0, 8)}`);
                   }
-                  await fetch(
-                    `${this.config.apiUrl}/api/v1/mls/groups/${roomState.mlsGroupId}/fulfill-welcome`,
-                    {
-                      method: "POST",
-                      headers: { Authorization: `Bearer ${this._deviceJwt}`, "Content-Type": "application/json" },
-                      body: JSON.stringify({ request_id: req.id })
-                    }
-                  );
-                  await saveMlsState(this.config.dataDir, roomState.mlsGroupId, JSON.stringify(mlsGroup.exportState()));
-                  console.log(`[SecureChannel] Fulfilled Welcome for ${req.requesting_device_id.slice(0, 8)} in room ${roomId.slice(0, 8)}`);
                 } catch (fulfillErr) {
                   console.warn(`[SecureChannel] Welcome fulfill failed for ${req.requesting_device_id.slice(0, 8)}:`, fulfillErr);
                 }
@@ -70383,65 +71300,38 @@ ${messageText}`;
                 validReqs.push({ req, kp: MLSGroupManager.deserializeKeyPackage(kpBytes) });
               }
               if (validReqs.length === 0) continue;
+              const sharedTargets = validReqs.map((v22) => ({
+                requestId: v22.req.id,
+                deviceId: v22.req.requesting_device_id,
+                keyPackage: v22.kp
+              }));
               try {
-                const { commit, welcome } = await mlsGroup.addMembers(validReqs.map((v22) => v22.kp));
-                if (this._ws) {
-                  this._ws.send(JSON.stringify({
-                    event: "mls_commit",
-                    data: {
-                      group_id: entry.mlsGroupId,
-                      epoch: Number(mlsGroup.epoch),
-                      payload: Buffer.from(commit).toString("hex")
-                    }
-                  }));
-                }
-                if (welcome && this._ws) {
-                  for (const { req } of validReqs) {
-                    this._ws.send(JSON.stringify({
-                      event: "mls_welcome",
-                      data: {
-                        target_device_id: req.requesting_device_id,
-                        group_id: entry.mlsGroupId,
-                        conversation_group_id: gid,
-                        payload: Buffer.from(welcome).toString("hex")
-                      }
-                    }));
-                  }
-                }
-                for (const { req } of validReqs) {
-                  await fetch(
-                    `${this.config.apiUrl}/api/v1/mls/groups/${entry.mlsGroupId}/fulfill-welcome`,
-                    {
-                      method: "POST",
-                      headers: { Authorization: `Bearer ${this._deviceJwt}`, "Content-Type": "application/json" },
-                      body: JSON.stringify({ request_id: req.id })
-                    }
-                  ).catch(() => {
-                  });
+                const done = await this._fulfilWelcomeRequests({
+                  mlsGroup,
+                  mlsGroupId: entry.mlsGroupId,
+                  label: `shared group ${gid.slice(0, 8)}`,
+                  welcomeFields: { conversation_group_id: gid },
+                  targets: sharedTargets
+                });
+                if (done > 0) {
+                  console.log(`[SecureChannel] Batched Welcome for ${done}/${validReqs.length} devices in shared group ${gid.slice(0, 8)} (epoch=${mlsGroup.epoch})`);
                 }
-                await saveMlsState(this.config.dataDir, entry.mlsGroupId, JSON.stringify(mlsGroup.exportState()));
-                console.log(`[SecureChannel] Batched Welcome for ${validReqs.length} devices in shared group ${gid.slice(0, 8)} (epoch=${mlsGroup.epoch})`);
               } catch (batchErr) {
                 console.warn(`[SecureChannel] Batched Welcome failed for shared group ${gid.slice(0, 8)}, falling back to individual:`, batchErr);
-                for (const { req, kp } of validReqs) {
+                for (const target of sharedTargets) {
                   try {
-                    const { commit, welcome } = await mlsGroup.addMembers([kp]);
-                    if (this._ws) {
-                      this._ws.send(JSON.stringify({ event: "mls_commit", data: { group_id: entry.mlsGroupId, epoch: Number(mlsGroup.epoch), payload: Buffer.from(commit).toString("hex") } }));
-                    }
-                    if (welcome && this._ws) {
-                      this._ws.send(JSON.stringify({ event: "mls_welcome", data: { target_device_id: req.requesting_device_id, group_id: entry.mlsGroupId, conversation_group_id: gid, payload: Buffer.from(welcome).toString("hex") } }));
-                    }
-                    await fetch(`${this.config.apiUrl}/api/v1/mls/groups/${entry.mlsGroupId}/fulfill-welcome`, {
-                      method: "POST",
-                      headers: { Authorization: `Bearer ${this._deviceJwt}`, "Content-Type": "application/json" },
-                      body: JSON.stringify({ request_id: req.id })
-                    }).catch(() => {
+                    const done = await this._fulfilWelcomeRequests({
+                      mlsGroup,
+                      mlsGroupId: entry.mlsGroupId,
+                      label: `shared group ${gid.slice(0, 8)}`,
+                      welcomeFields: { conversation_group_id: gid },
+                      targets: [target]
                     });
-                    await saveMlsState(this.config.dataDir, entry.mlsGroupId, JSON.stringify(mlsGroup.exportState()));
-                    console.log(`[SecureChannel] Individual Welcome for ${req.requesting_device_id.slice(0, 8)} in shared group ${gid.slice(0, 8)}`);
+                    if (done > 0) {
+                      console.log(`[SecureChannel] Individual Welcome for ${target.deviceId.slice(0, 8)} in shared group ${gid.slice(0, 8)}`);
+                    }
                   } catch (indivErr) {
-                    console.warn(`[SecureChannel] Individual Welcome failed for ${req.requesting_device_id.slice(0, 8)}:`, indivErr);
+                    console.warn(`[SecureChannel] Individual Welcome failed for ${target.deviceId.slice(0, 8)}:`, indivErr);
                   }
                 }
               }
@@ -70473,38 +71363,20 @@ ${messageText}`;
                   if (!kpHex) continue;
                   const kpBytes = new Uint8Array(Buffer.from(kpHex, "hex"));
                   const memberKp = MLSGroupManager.deserializeKeyPackage(kpBytes);
-                  const { commit, welcome } = await mlsGroup.addMembers([memberKp]);
-                  if (this._ws) {
-                    this._ws.send(JSON.stringify({
-                      event: "mls_commit",
-                      data: {
-                        group_id: convEntry.mlsGroupId,
-                        epoch: Number(mlsGroup.epoch),
-                        payload: Buffer.from(commit).toString("hex")
-                      }
-                    }));
-                  }
-                  if (welcome && this._ws) {
-                    this._ws.send(JSON.stringify({
-                      event: "mls_welcome",
-                      data: {
-                        target_device_id: req.requesting_device_id,
-                        group_id: convEntry.mlsGroupId,
-                        conversation_id: convId,
-                        payload: Buffer.from(welcome).toString("hex")
-                      }
-                    }));
+                  const done = await this._fulfilWelcomeRequests({
+                    mlsGroup,
+                    mlsGroupId: convEntry.mlsGroupId,
+                    label: `conv ${convId.slice(0, 8)}`,
+                    welcomeFields: { conversation_id: convId },
+                    targets: [{
+                      requestId: req.id,
+                      deviceId: req.requesting_device_id,
+                      keyPackage: memberKp
+                    }]
+                  });
+                  if (done > 0) {
+                    console.log(`[SecureChannel] Fulfilled Welcome for ${req.requesting_device_id.slice(0, 8)} in conv ${convId.slice(0, 8)}`);
                   }
-                  await fetch(
-                    `${this.config.apiUrl}/api/v1/mls/groups/${convEntry.mlsGroupId}/fulfill-welcome`,
-                    {
-                      method: "POST",
-                      headers: { Authorization: `Bearer ${this._deviceJwt}`, "Content-Type": "application/json" },
-                      body: JSON.stringify({ request_id: req.id })
-                    }
-                  );
-                  await saveMlsState(this.config.dataDir, convEntry.mlsGroupId, JSON.stringify(mlsGroup.exportState()));
-                  console.log(`[SecureChannel] Fulfilled Welcome for ${req.requesting_device_id.slice(0, 8)} in conv ${convId.slice(0, 8)}`);
                 } catch (fulfillErr) {
                   console.warn(`[SecureChannel] Conv Welcome fulfill failed for ${req.requesting_device_id.slice(0, 8)}:`, fulfillErr);
                 }
@@ -70685,12 +71557,13 @@ ${messageText}`;
                   } catch (distErr) {
                     console.warn(`[SecureChannel] A2A distribute network error:`, distErr);
                   }
-                  if (!distributed && this._ws) {
-                    this._ws.send(JSON.stringify({
+                  if (!distributed && this._wsIsOpen()) {
+                    const a2aLabel = `A2A ${chId.slice(0, 8)}`;
+                    const commitSent = await this._sendFrameConfirmed({
                       event: "mls_commit",
                       data: { group_id: chState.mlsGroupId, epoch: Number(mlsGroup.epoch), payload: commitHex }
-                    }));
-                    this._ws.send(JSON.stringify({
+                    }, `${a2aLabel} commit`);
+                    const welcomeSent = commitSent && await this._sendFrameConfirmed({
                       event: "mls_welcome",
                       data: {
                         target_device_id: req.requesting_device_id,
@@ -70698,7 +71571,11 @@ ${messageText}`;
                         a2a_channel_id: chId,
                         payload: welcomeHex
                       }
-                    }));
+                    }, `${a2aLabel} welcome`);
+                    if (!welcomeSent) {
+                      console.warn(`[SecureChannel] ${a2aLabel}: Welcome frames were NOT written \u2014 leaving the request pending`);
+                      continue;
+                    }
                     try {
                       await fetch(
                         `${this.config.apiUrl}/api/v1/mls/groups/${chState.mlsGroupId}/distribute`,
@@ -70721,16 +71598,15 @@ ${messageText}`;
                     console.warn(`[SecureChannel] Cannot deliver Welcome \u2014 HTTP distribute and WS both unavailable`);
                     continue;
                   }
-                  await fetch(
-                    `${this.config.apiUrl}/api/v1/mls/groups/${chState.mlsGroupId}/fulfill-welcome`,
-                    {
-                      method: "POST",
-                      headers: { Authorization: `Bearer ${this._deviceJwt}`, "Content-Type": "application/json" },
-                      body: JSON.stringify({ request_id: req.id })
-                    }
+                  const a2aFulfilled = await this._postFulfilWelcome(
+                    chState.mlsGroupId,
+                    req.id,
+                    `A2A ${chId.slice(0, 8)}`
                   );
                   await saveMlsState(this.config.dataDir, chState.mlsGroupId, JSON.stringify(mlsGroup.exportState()));
-                  console.log(`[SecureChannel] Fulfilled A2A Welcome for ${req.requesting_device_id.slice(0, 8)} in channel ${chId.slice(0, 8)}`);
+                  if (a2aFulfilled) {
+                    console.log(`[SecureChannel] Fulfilled A2A Welcome for ${req.requesting_device_id.slice(0, 8)} in channel ${chId.slice(0, 8)}`);
+                  }
                 } catch (fulfillErr) {
                   console.log(`[SecureChannel] A2A Welcome fulfill failed: ${fulfillErr instanceof Error ? fulfillErr.message : String(fulfillErr)}`);
                 }
@@ -70904,12 +71780,12 @@ ${messageText}`;
           console.log(`[SecureChannel] MLS sync: re-join needed for group ${groupId?.slice(0, 8)}`);
           if (groupId) {
             await deleteMlsState(this.config.dataDir, groupId);
-            for (const [roomId, room] of Object.entries(this._persisted?.rooms ?? {})) {
-              if (room.mlsGroupId === groupId) {
-                this._mlsGroups.delete(roomId);
-                break;
-              }
+            const target = this._resolveGroupFamily(groupId);
+            if (target) {
+              this._mlsGroups.delete(target.managerKey);
+              console.log(`[SecureChannel] MLS sync rejoin: dropped local state for ${target.label}`);
             }
+            void this._requestWelcomeSelfHeal(groupId);
           }
         } else if (action === "replay_complete") {
           console.log(`[SecureChannel] MLS sync complete for group ${groupId?.slice(0, 8)} (${data.count} messages replayed)`);
@@ -70921,6 +71797,7 @@ ${messageText}`;
        */
       async _handleA2AMessageMLS(data) {
         const groupId = data.group_id;
+        this._noteGroupEpoch(groupId, data.epoch);
         const channelId = data.channel_id ?? data.a2a_channel_id;
         let a2aChannelId = channelId;
         if (!a2aChannelId) {
@@ -98144,13 +99021,14 @@ var init_index = __esm2({
     init_skill_invoker();
     await init_skill_telemetry();
     await init_policy_enforcer();
-    VERSION = true ? "0.23.23" : "0.0.0-dev";
+    VERSION = true ? "0.23.27" : "0.0.0-dev";
   }
 });
 await init_index();
 
 // src/index.ts
 init_config();
+init_pending_invite();
 
 // ../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as $S } from "node:module";
@@ -119451,18 +120329,18 @@ import { realpathSync as realpathSync2 } from "node:fs";
 import { resolve as resolve3, dirname as dirname2, basename, sep as sep2, isAbsolute } from "node:path";
 
 // src/host-trust.ts
-import { mkdirSync as mkdirSync3, writeFileSync, rmSync as rmSync2, readdirSync as readdirSync2, lstatSync as lstatSync2, readFileSync as readFileSync4, chmodSync as chmodSync2 } from "node:fs";
-import { join as join6 } from "node:path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync2, rmSync as rmSync3, readdirSync as readdirSync2, lstatSync as lstatSync2, readFileSync as readFileSync5, chmodSync as chmodSync3 } from "node:fs";
+import { join as join7 } from "node:path";
 import { homedir, hostname as hostname3 } from "node:os";
 var TRUST_SUBDIR = "host-trust";
-var DIR_MODE2 = 448;
-var FILE_MODE2 = 384;
+var DIR_MODE3 = 448;
+var FILE_MODE3 = 384;
 var ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 var IDENTITY_FILES = ["agentvault.json", "secure-channel.json", "agentvault.json.bak"];
 var HostTrustError = class extends Error {
 };
 function trustDir(root3) {
-  return join6(root3 ?? join6(homedir(), ".agentvault"), TRUST_SUBDIR);
+  return join7(root3 ?? join7(homedir(), ".agentvault"), TRUST_SUBDIR);
 }
 function sanitize(deviceId) {
   if (typeof deviceId !== "string" || !ID_RE.test(deviceId)) {
@@ -119473,7 +120351,7 @@ function sanitize(deviceId) {
 function isTrusted(deviceId, root3) {
   try {
     if (typeof deviceId !== "string" || !ID_RE.test(deviceId)) return false;
-    const p2 = join6(trustDir(root3), deviceId);
+    const p2 = join7(trustDir(root3), deviceId);
     return lstatSync2(p2).isFile();
   } catch {
     return false;
@@ -119482,26 +120360,26 @@ function isTrusted(deviceId, root3) {
 function grant(deviceId, root3) {
   const id = sanitize(deviceId);
   const dir = trustDir(root3);
-  const p2 = join6(dir, id);
-  mkdirSync3(dir, { recursive: true, mode: DIR_MODE2 });
-  writeFileSync(
+  const p2 = join7(dir, id);
+  mkdirSync4(dir, { recursive: true, mode: DIR_MODE3 });
+  writeFileSync2(
     p2,
     `granted_at=${(/* @__PURE__ */ new Date()).toISOString()} host=${hostname3()}
 `,
-    { mode: FILE_MODE2 }
+    { mode: FILE_MODE3 }
   );
-  chmodSync2(dir, DIR_MODE2);
-  chmodSync2(p2, FILE_MODE2);
+  chmodSync3(dir, DIR_MODE3);
+  chmodSync3(p2, FILE_MODE3);
 }
 function revoke(deviceId, root3) {
   const id = sanitize(deviceId);
-  const p2 = join6(trustDir(root3), id);
+  const p2 = join7(trustDir(root3), id);
   try {
     if (!lstatSync2(p2).isFile()) return false;
   } catch {
     return false;
   }
-  rmSync2(p2, { force: true });
+  rmSync3(p2, { force: true });
   return true;
 }
 function listTrusted(root3) {
@@ -119516,7 +120394,7 @@ function listTrusted(root3) {
 function readDeviceId(dataDir) {
   for (const f7 of IDENTITY_FILES) {
     try {
-      const parsed = JSON.parse(readFileSync4(join6(dataDir, f7), "utf-8"));
+      const parsed = JSON.parse(readFileSync5(join7(dataDir, f7), "utf-8"));
       if (parsed?.deviceId && ID_RE.test(parsed.deviceId)) return parsed.deviceId;
     } catch {
     }
@@ -119526,17 +120404,8 @@ function readDeviceId(dataDir) {
   );
 }
 
-// src/log.ts
-import { format } from "node:util";
-function stamp(message) {
-  const ts2 = (/* @__PURE__ */ new Date()).toISOString();
-  return message.split("\n").map((line) => `${ts2} ${line}`).join("\n");
-}
-function logLine(...args) {
-  console.error(stamp(format(...args)));
-}
-
 // src/worker-permission.ts
+init_log();
 var PATH_FIELDS = ["file_path", "path", "notebook_path"];
 function canonical(p2) {
   const abs = resolve3(p2);
@@ -133462,6 +134331,7 @@ function date7(params) {
 config2(en_default3());
 
 // src/session.ts
+init_log();
 function makeRoomSayTool(onSay) {
   return bs(
     "say",
@@ -134072,9 +134942,36 @@ var ArmingState = class {
   }
 };
 
+// src/service/self-uninstall.ts
+init_subcommand();
+init_backend();
+init_log();
+var DEVICE_IS_GONE = "device_revoked";
+function selfUninstallOnTerminal(reason, env, deps = {}) {
+  if (reason !== DEVICE_IS_GONE) return false;
+  const log = deps.log ?? ((m6) => logLine("[bridge] " + m6));
+  let label = "";
+  try {
+    if (!deps.backend && process.platform !== "darwin" && process.platform !== "linux") return false;
+    const backend = deps.backend ?? selectBackend(process.platform);
+    label = resolveLabel(backend, env);
+    if (!backend.status(label).loaded) return false;
+    backend.uninstall(label);
+    log(
+      `device was revoked \u2014 removed the supervised service ${label} so it does not sit installed on this machine pointing at an agent that no longer exists. Your credentials are still on disk and were NOT touched; re-install with a fresh invite token from AgentVault to reconnect.`
+    );
+    return true;
+  } catch (e7) {
+    log(
+      `device was revoked, but the supervised service ${label || "for this agent"} could not be removed: ${e7.message}. Remove it by hand with: AV_AGENT_NAME=<agent-name> agentvault-claude-bridge uninstall`
+    );
+    return false;
+  }
+}
+
 // src/approve-cli.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync2, readFileSync as readFileSync5, readdirSync as readdirSync3, rmSync as rmSync3, existsSync as existsSync3 } from "node:fs";
-import { join as join7 } from "node:path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync4, readFileSync as readFileSync7, readdirSync as readdirSync4, rmSync as rmSync5, existsSync as existsSync5 } from "node:fs";
+import { join as join11 } from "node:path";
 var APPROVALS_SUBDIR = "arm-approvals";
 var ID_RE2 = /^[A-Za-z0-9_-]{1,128}$/;
 var ApproveArmError = class extends Error {
@@ -134094,24 +134991,24 @@ function sanitizeRoomId(roomId) {
 function writeApproval(dataDir, requestId, roomId) {
   const id = sanitizeRequestId(requestId);
   const room = sanitizeRoomId(roomId);
-  const dir = join7(dataDir, APPROVALS_SUBDIR);
-  mkdirSync4(dir, { recursive: true });
-  writeFileSync2(join7(dir, id), room);
+  const dir = join11(dataDir, APPROVALS_SUBDIR);
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync4(join11(dir, id), room);
 }
 function drainApprovals(dataDir) {
-  const dir = join7(dataDir, APPROVALS_SUBDIR);
-  if (!existsSync3(dir)) return [];
+  const dir = join11(dataDir, APPROVALS_SUBDIR);
+  if (!existsSync5(dir)) return [];
   const out = [];
-  for (const name of readdirSync3(dir)) {
+  for (const name of readdirSync4(dir)) {
     if (!ID_RE2.test(name)) continue;
     let roomId = "";
     try {
-      roomId = readFileSync5(join7(dir, name), "utf8").trim();
+      roomId = readFileSync7(join11(dir, name), "utf8").trim();
     } catch {
     }
     out.push({ requestId: name, roomId: ID_RE2.test(roomId) ? roomId : "" });
     try {
-      rmSync3(join7(dir, name), { force: true, recursive: true });
+      rmSync5(join11(dir, name), { force: true, recursive: true });
     } catch {
     }
   }
@@ -134252,11 +135149,13 @@ var ActiveTarget = class {
 function attachLifecycle2(channel, opts = {}) {
   const log = opts.log ?? (() => {
   });
+  const selfUninstall = opts.selfUninstall ?? selfUninstallOnTerminal;
   const onTerminal = opts.onTerminal ?? ((_reason, o10) => process.exit(o10.restart ? 1 : 0));
   const terminal = (reason, restart) => {
     log(
       `terminal condition (${reason}) \u2014 ${restart ? "gave up reconnecting; supervisor may respawn" : "this device must re-enroll or another session has taken over"}. Re-run/re-install with a fresh invite token from AgentVault if this persists.`
     );
+    selfUninstall(reason, process.env);
     onTerminal(reason, { restart });
   };
   channel.on("auth_failed", (e7) => terminal(e7.reason, false));
@@ -134479,7 +135378,12 @@ function wireBridge(channel, session, target, opts = {}) {
 }
 
 // src/index.ts
+init_log();
 async function main() {
+  const { maybeRunDoctorSubcommand: maybeRunDoctorSubcommand2 } = await Promise.resolve().then(() => (init_doctor_cli(), doctor_cli_exports));
+  if (await maybeRunDoctorSubcommand2(process.argv)) {
+    process.exit(process.exitCode ?? 0);
+  }
   const { dataDir: dataDirForSubcommand } = resolveDataDir(process.env);
   if (maybeRunApproveArmSubcommand(process.argv, dataDirForSubcommand)) {
     process.exit(process.exitCode ?? 0);
@@ -134498,7 +135402,7 @@ async function main() {
       "[bridge] warning: passing the invite token on the command line is visible to other local users via 'ps'. Prefer: AV_INVITE_TOKEN=\u2026 npx @agentvault/claude-bridge"
     );
   }
-  logLine(`[bridge] version: ${true ? "0.7.16" : "dev"}`);
+  logLine(`[bridge] version: ${true ? "0.8.1" : "dev"}`);
   logLine(`[bridge] data dir: ${cfg.dataDir} (${cfg.dataDirSource})`);
   logLine(`[bridge] workspace: ${cfg.workspaceDir} \xB7 permissions: ${cfg.permissionMode} \xB7 enclave dir fenced`);
   if (cfg.armRoom) {
@@ -134530,7 +135434,7 @@ async function main() {
     // its default would render "@agentvault/agentvault@0.7.x" — the wrong
     // package name attached to the bridge's version number, which is worse
     // than either alone.
-    clientVersion: `@agentvault/claude-bridge@${true ? "0.7.16" : "dev"}`
+    clientVersion: `@agentvault/claude-bridge@${true ? "0.8.1" : "dev"}`
   });
   const agentSystemPrompt = cfg.systemPrompt ?? `You are ${cfg.agentName}, an AI agent on AgentVault. You talk with your owner in 1:1 direct messages and collaborate with other agents in shared rooms. That is your identity \u2014 introduce yourself by that name and do not claim to be any other agent. To speak, call the say tool. In a 1:1 with your owner, reply to what they say. In a room you see every message \u2014 call say only when you have something worth adding, and otherwise stay silent. Keep messages concise.`;
   const deviceJwt = () => {
@@ -134594,9 +135498,9 @@ async function main() {
         `[worker-trap] ${rec.at} ${rec.outcome} after ${rec.ranMs}ms (waited ${rec.waitedMs}ms behind ${rec.queueDepthAtEnqueue}, ${rec.queueDepthAtStart} still queued) replyExpected=${rec.replyExpected}` + (rec.session ? ` composed=${rec.session.composedChars} result=${rec.session.sawResult} said=${rec.session.said}` : "")
       );
       try {
-        const dir = join11(cfg.dataDir, "logs");
-        mkdirSync6(dir, { recursive: true });
-        appendFileSync2(join11(dir, "worker-incidents.jsonl"), JSON.stringify(rec) + "\n");
+        const dir = join13(cfg.dataDir, "logs");
+        mkdirSync7(dir, { recursive: true });
+        appendFileSync2(join13(dir, "worker-incidents.jsonl"), JSON.stringify(rec) + "\n");
       } catch (err) {
         logLine(`[worker-trap] could not persist incident: ${err.message}`);
       }
@@ -134628,6 +135532,11 @@ async function main() {
   attachLifecycle2(channel, {
     log: (m6) => logLine("[bridge] " + m6)
   });
+  channel.on("ready", () => {
+    if (clearPendingInviteIfConsumed(cfg.dataDir, hasPersistedCreds)) {
+      logLine("[bridge] enrolled \u2014 pending invite consumed and removed");
+    }
+  });
   channel.on("state", (s10) => logLine(`[bridge] channel state: ${JSON.stringify(s10)}`));
   channel.on(
     "room_joined",