@agentvault/claude-bridge 0.8.0 → 0.8.2

package/dist/index.js

@@ -1081,6 +1081,28 @@ var __toESM = (mod4, isNodeMode, target) => (target = mod4 != null ? __create(__
   isNodeMode || !mod4 || !mod4.__esModule ? __defProp2(target, "default", { value: mod4, enumerable: true }) : target,
   mod4
 ));
+function stripWrappers(s22) {
+  let start = 0;
+  let end = s22.length;
+  while (start < end && WRAPPERS.includes(s22[start])) start++;
+  while (end > start && WRAPPERS.includes(s22[end - 1])) end--;
+  return s22.slice(start, end);
+}
+function isAbstention(text) {
+  if (typeof text !== "string") return false;
+  return stripWrappers(text).toLowerCase().startsWith(SENTINEL);
+}
+var SENTINEL;
+var WRAPPERS;
+var INSTRUCTION;
+var init_abstention = __esm2({
+  "src/abstention.ts"() {
+    "use strict";
+    SENTINEL = "[[no-reply]]";
+    WRAPPERS = " 	\r\n`\"'*_";
+    INSTRUCTION = "not every message needs an answer from you: if this one is not addressed to you and asks nothing of you, reply with exactly " + SENTINEL + " and nothing else \u2014 that is discarded, not posted, and is how you stay quiet; never post a message SAYING that you are staying quiet";
+  }
+});
 function toEpoch(v22) {
   if (typeof v22 === "bigint") return v22;
   if (typeof v22 === "number") {
@@ -45906,6 +45928,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) {
@@ -45919,14 +45946,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,
@@ -45946,13 +45973,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);
@@ -45960,19 +45981,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;
@@ -63758,6 +63781,39 @@ var init_mls_group = __esm2({
         const s22 = this._requireState();
         return s22.groupContext.groupId;
       }
+      /**
+       * Proof that this client actually holds the group's keys at its current
+       * epoch. Throws if not initialized.
+       *
+       * RFC 9420 §8.2's `epoch_authenticator`, derived from the epoch secret. Two
+       * properties make it the thing this codebase has been missing:
+       *
+       *   * every member at the same epoch computes the SAME value, so it is
+       *     comparable across clients and can be checked by a server;
+       *   * it cannot be computed without the key schedule, so possessing it is
+       *     evidence of membership rather than a claim about it. RFC 9420 names
+       *     this as its purpose: "to authenticate the shared group state".
+       *
+       * It is safe to publish. It is a KDF output over the epoch secret, not the
+       * secret, and the RFC intends it to be shown to out-of-band verifiers.
+       *
+       * WHY THIS EXISTS. `mls_groups.member_device_ids` records membership; the
+       * ability to decrypt lives only in one browser's localStorage. Nothing
+       * compared the two, and nothing could — so a device in the roster holding no
+       * keys was indistinguishable from a healthy one, on every signal the server
+       * has. Measured on production 2026-08-26: one owner device carried the keys
+       * for 19 of the 21 owner leaves on the platform, and one 1:1 group had been
+       * unreadable by its owner's browser for two months while every status column
+       * read healthy.
+       *
+       * `epoch` alone cannot do this job: it is a number the client reports about
+       * itself, it collides across groups, and a client that has lost its state
+       * still remembers one.
+       */
+      get epochAuthenticator() {
+        const s22 = this._requireState();
+        return s22.keySchedule.epochAuthenticator;
+      }
       /** The cipher suite name in use. */
       get ciphersuiteName() {
         return this._ciphersuiteName;
@@ -63908,11 +63964,84 @@ var init_mls_group = __esm2({
         return { commit: commitBytes, welcome: welcomeBytes };
       }
       /**
-       * Remove a member from the group by leaf index.
+       * Admit N members with TWO commits total, replacing any stale leaf they hold.
+       *
+       * `addMembers` cannot do this alone: MLS rejects an Add for an identity
+       * already in the tree, so a member that lost its local state must be removed
+       * first. Doing that pair PER MEMBER is what the fulfiller did, and it is not
+       * merely slow — it is self-defeating.
+       *
+       * Live 2026-08-28 14:02:21-28Z: the owner sweep re-admitted 7 room members
+       * sequentially, each as its own removeMember + addMembers. Room 007 ran
+       * **epoch 71 -> 85 in seven seconds**, and the Welcome minted for member n
+       * named an epoch that member n+1's commit had already replaced — so six of
+       * seven were stale before they finished joining, and one (`smartcode`) could
+       * not replay forward afterwards at all.
+       *
+       * 🎯 A REPAIR THAT MOVES THE EPOCH ONCE PER MEMBER IS RACING ITSELF.
+       *
+       * ⚠️ **Why two commits and not one.** RFC 9420 §12.3 allows Remove and Add in
+       * a single commit, and ts-mls builds it happily — but with MORE THAN ONE of
+       * each, a REMAINING member fails to process it:
        *
-       * @param memberIndex - The leaf index of the member to remove.
-       * @returns The commit message to broadcast.
+       *     OpenError  at applyUpdatePathSecret (ts-mls/src/createCommit.ts:471)
+       *                at updatePrivateKeyPath  (processMessages.ts:397)
+       *
+       * One remove + one add in a single commit is fine; 2+2 is not. That is
+       * pinned by a test in `mls-group.test.ts` so this cannot be "optimised" back
+       * into one commit without the failure showing up first. Two commits still
+       * turns 7 members from 14 epochs into 2, and every joiner lands current.
+       *
+       * @param keyPackages - Fresh KeyPackages, one per member to admit. Members
+       *   already holding a leaf are removed by the first commit; members with no
+       *   leaf are plain adds. Duplicate identities keep the first KeyPackage.
+       * @returns Every commit to broadcast IN ORDER, and the Welcome to deliver to
+       *   EVERY member in the batch (each finds its own secrets inside it).
        */
+      async reAdmitMembers(keyPackages) {
+        this._requireState();
+        await this._ensureCiphersuite();
+        const seenIdentities = [];
+        const toAdd = [];
+        const leavesToRemove = [];
+        for (const kp of keyPackages) {
+          const identity = keyPackageIdentity(kp);
+          if (identity !== null) {
+            if (seenIdentities.some((id) => bytesEqual(id, identity)))
+              continue;
+            seenIdentities.push(identity);
+            const leaf = this.memberLeafIndex(identity);
+            if (leaf !== null)
+              leavesToRemove.push(leaf);
+          }
+          toAdd.push(kp);
+        }
+        if (toAdd.length === 0) {
+          throw new Error("reAdmitMembers: no members to admit");
+        }
+        const commits = [];
+        if (leavesToRemove.length > 0) {
+          const { commit } = await this.removeMembers(leavesToRemove);
+          commits.push({ commit, epoch: this.epoch });
+        }
+        const added = await this.addMembers(toAdd);
+        commits.push({ commit: added.commit, epoch: this.epoch });
+        return { commits, welcome: added.welcome };
+      }
+      async removeMembers(memberIndices) {
+        const s22 = this._requireState();
+        const cs = await this._ensureCiphersuite();
+        if (memberIndices.length === 0) {
+          throw new Error("removeMembers: no members to remove");
+        }
+        const extraProposals = memberIndices.map((removed) => ({
+          proposalType: "remove",
+          remove: { removed }
+        }));
+        const result = await createCommit({ state: s22, cipherSuite: cs, pskIndex: this._pskIndex }, { extraProposals });
+        this.state = result.newState;
+        return { commit: encodeMlsMessage(result.commit) };
+      }
       async removeMember(memberIndex) {
         const s22 = this._requireState();
         const cs = await this._ensureCiphersuite();
@@ -64146,6 +64275,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,
@@ -64215,7 +64361,9 @@ __export2(dist_exports, {
   hexTransportToEncryptedMessage: () => hexTransportToEncryptedMessage,
   issueCredential: () => issueCredential,
   multibaseToPublicKey: () => multibaseToPublicKey,
+  needsPreSendResync: () => needsPreSendResync,
   normalizeBackupCode: () => normalizeBackupCode,
+  noteObservedEpoch: () => noteObservedEpoch,
   orderDeliveryBatch: () => orderDeliveryBatch,
   parseTraceparent: () => parseTraceparent,
   performX3DH: () => performX3DH,
@@ -64255,6 +64403,7 @@ var init_dist = __esm2({
     init_mls_group();
     await init_owner_sync();
     init_mls_delivery_order();
+    init_mls_presend_epoch();
   }
 });
 async function ensureSecureDir(dir) {
@@ -64447,7 +64596,7 @@ var init_mls_kp_pool = __esm2({
   }
 });
 function ownIdentity() {
-  const v22 = true ? "0.23.23" : FALLBACK;
+  const v22 = true ? "0.23.29" : FALLBACK;
   return `${PACKAGE}@${v22}`;
 }
 function buildClientVersion(override) {
@@ -65359,10 +65508,12 @@ var SecureChannel;
 var init_channel = __esm2({
   async "src/channel.ts"() {
     "use strict";
+    init_abstention();
     init_mls_commit_classify();
     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();
@@ -65476,6 +65627,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). */
@@ -65513,6 +65675,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
@@ -65769,6 +65938,18 @@ var init_channel = __esm2({
       get ownHubAddress() {
         return this._persisted?.hubAddress ?? "";
       }
+      /** This agent's AgentVault hub_id. "" until enrolment persists it.
+       *
+       * Lives in the credential store, NOT in the channel config — which is where
+       * the memory-recall helper was reading it from. `channel.config.hubId` is
+       * unset for every agent enrolled through the normal flow, so
+       * `channel.config.hubId || ""` produced `/api/v1/agents//memory/search`, a
+       * 404 on every inbound message, swallowed by `if (!res.ok) return ""`.
+       * Memory recall was silently dead while the hub_id sat right here.
+       */
+      get ownHubId() {
+        return this._persisted?.hubId ?? "";
+      }
       /** Public best-effort trigger to (re)resolve this agent's display_name.
        * Called lazily from the 1:1 DM path when the name is still unknown, so a
        * resolve that failed at connect (or a fresh agent that hadn't registered
@@ -66157,6 +66338,7 @@ var init_channel = __esm2({
        * Each session gets the same plaintext encrypted independently.
        */
       async send(plaintext, options) {
+        if (isAbstention(plaintext)) return;
         if (this._state === "error" || this._state === "idle") {
           throw new Error("Channel is not ready");
         }
@@ -66197,16 +66379,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,
@@ -66228,8 +66438,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;
@@ -66249,7 +66463,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,
@@ -66344,7 +66565,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,
@@ -66370,13 +66598,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);
@@ -66426,7 +66667,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.29" : "0.0.0-dev";
         const agentName = this.config.agentName ?? "Agent";
         const resource = {
           "service.name": "agentvault-agent",
@@ -66620,6 +66861,7 @@ var init_channel = __esm2({
        * Uses MLS (preferred) or pairwise fan-out as fallback.
        */
       async sendToRoom(roomId, plaintext, opts) {
+        if (isAbstention(plaintext)) return;
         if (!this._persisted?.rooms?.[roomId]) {
           throw new Error(`Room ${roomId} not found`);
         }
@@ -66636,7 +66878,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({
@@ -66887,11 +67135,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 {
@@ -66905,9 +67159,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).
@@ -67815,7 +68069,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,
@@ -67863,7 +68123,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",
@@ -68309,6 +68575,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(
@@ -68336,7 +68605,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.29" : "0.0.0-dev"
               });
               this._telemetryReporter.startAutoFlush(3e4);
             }
@@ -68660,7 +68929,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.29" : "0.0.0-dev"
                   });
                   this._telemetryReporter.startAutoFlush(3e4);
                 }
@@ -69026,6 +69295,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;
@@ -69103,9 +69373,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({
@@ -69848,9 +70124,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 ?? {})) {
@@ -69864,7 +70167,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;
           }
         }
@@ -70052,63 +70357,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) {
@@ -70298,6 +70603,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;
@@ -70324,11 +70852,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}`
           );
@@ -70715,6 +71256,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);
@@ -70731,7 +71273,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,
@@ -70769,9 +71311,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);
@@ -70840,38 +71391,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);
                 }
@@ -70910,65 +71443,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);
                   }
                 }
               }
@@ -71000,38 +71506,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);
                 }
@@ -71212,12 +71700,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,
@@ -71225,7 +71714,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`,
@@ -71248,16 +71741,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)}`);
                 }
@@ -71431,12 +71923,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)`);
@@ -71448,6 +71940,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) {
@@ -72580,6 +73073,45 @@ var init_gateway_send = __esm2({
     init_openclaw_compat();
   }
 });
+function parseMentions(text) {
+  const mentions = [];
+  const re22 = /@(\w[\w]*)/gi;
+  let match;
+  while ((match = re22.exec(text)) !== null) {
+    mentions.push(match[1].toLowerCase());
+  }
+  return mentions;
+}
+function owesRoomReply(plaintext, agentName, accountId, senderIsAgent, roomDisplayName, ownDisplayName, selfResolved = true) {
+  const mentions = parseMentions(plaintext);
+  if (mentions.length === 0) return false;
+  if (mentions.includes("all") || mentions.includes("everyone")) {
+    return senderIsAgent !== true;
+  }
+  const ownNames = ownRoomNames(agentName, accountId, roomDisplayName, ownDisplayName);
+  if (mentions.some((m22) => ownNames.has(m22))) return true;
+  if (!selfResolved) return true;
+  return false;
+}
+function ownRoomNames(agentName, accountId, roomDisplayName, ownDisplayName) {
+  const names = /* @__PURE__ */ new Set();
+  const add4 = (n22) => {
+    if (!n22) return;
+    const lower = n22.toLowerCase();
+    names.add(lower);
+    names.add(lower.split(/[\s(]/)[0]);
+  };
+  add4(agentName);
+  add4(accountId);
+  add4(roomDisplayName);
+  add4(ownDisplayName);
+  return names;
+}
+var init_room_protocol = __esm2({
+  "src/room-protocol.ts"() {
+    "use strict";
+  }
+});
 var init_llm_response_parser = __esm2({
   "src/llm-response-parser.ts"() {
     "use strict";
@@ -72613,6 +73145,7 @@ var isUsingManagedRoutes;
 var init_openclaw_entry = __esm2({
   "src/openclaw-entry.ts"() {
     "use strict";
+    init_room_protocol();
     init_account_config();
     init_fetch_interceptor();
     init_http_handlers();
@@ -98671,7 +99204,8 @@ var init_index = __esm2({
     init_skill_invoker();
     await init_skill_telemetry();
     await init_policy_enforcer();
-    VERSION = true ? "0.23.23" : "0.0.0-dev";
+    init_room_protocol();
+    VERSION = true ? "0.23.29" : "0.0.0-dev";
   }
 });
 await init_index();
@@ -134839,9 +135373,32 @@ function roomTurnPrefix(roomId, senderName, roomName) {
   const room = roomName ? `"${roomName}"` : roomId.slice(0, 8);
   return `[room ${room} | ${senderName}]`;
 }
+function _makeOwesReply(agentName, channel, log) {
+  let warnedNoIdentity = false;
+  return (e7) => {
+    const own = agentName ?? "";
+    const hub = channel.ownDisplayName ?? "";
+    if (!own && !hub && !warnedNoIdentity) {
+      warnedNoIdentity = true;
+      log(
+        "WARNING: this bridge has no agentName and no hub display_name, so it cannot recognise its own @mention (#1107). It will answer @all and any @-addressed message (fail-open), but targeted replies will be unreliable. Set the agent name in the bridge config."
+      );
+    }
+    return owesRoomReply(
+      e7.plaintext,
+      own,
+      own,
+      e7.senderIsAgent,
+      void 0,
+      hub,
+      Boolean(own || hub)
+    );
+  };
+}
 function wireBridge(channel, session, target, opts = {}) {
   const log = opts.log ?? (() => {
   });
+  const _owesReply = _makeOwesReply(opts.agentName, channel, log);
   let workAllowed = false;
   const workAllowedGetter = () => workAllowed;
   opts.onWorkAllowed?.(workAllowedGetter);
@@ -134893,7 +135450,7 @@ function wireBridge(channel, session, target, opts = {}) {
     target.setRoom(e7.roomId);
     session.push(`${roomTurnPrefix(e7.roomId, e7.senderName, roomNames.get(e7.roomId))}: ${e7.plaintext}`, target.snapshotReply(channel, log), {
       autoReplyOnText: false,
-      replyExpected: e7.senderIsAgent === false,
+      replyExpected: _owesReply(e7),
       armed: () => arming.isArmed(e7.roomId)
     });
   });
@@ -135052,7 +135609,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.8.0" : "dev"}`);
+  logLine(`[bridge] version: ${true ? "0.8.2" : "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) {
@@ -135084,7 +135641,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.8.0" : "dev"}`
+    clientVersion: `@agentvault/claude-bridge@${true ? "0.8.2" : "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 = () => {
@@ -135164,6 +135721,9 @@ async function main() {
     {
       roomFilter: cfg.roomFilter,
       armRoom: cfg.armRoom,
+      // #1107: needed to recognise this agent's own @mention. Without it the
+      // agent can only answer @all.
+      agentName: cfg.agentName,
       log: (m6) => logLine("[bridge] " + m6),
       // Slice 2 Plan C (T11): live arm/disarm + local-approval poll + heartbeat.
       workspaceDir: cfg.workspaceDir,