@agentvault/grok-bridge 0.4.11 → 0.4.13

package/dist/bridge.d.ts

@@ -163,6 +163,23 @@ export declare function attachLifecycle(channel: LifecycleChannel, opts?: {
  * unmarked turn already reads as a DM, which is what the model assumes.
  */
 export declare function roomTurnPrefix(roomId: string, senderName: string, roomName?: string): string;
+/**
+ * Does this agent owe a reply to this room message? (#1107)
+ *
+ * This bridge used to answer with `e.senderIsAgent === false` — "reply to any
+ * human". That was a THIRD implementation of the room reply rule, alongside the
+ * OpenClaw plugin and hermes, and #1107 shipped to the other two only. Under the
+ * old rule this agent would still have answered every un-mentioned message while
+ * wren, cortina, smartcode and smartcoder2 stayed quiet: the cascade, half-fixed,
+ * in the half most likely to be read as "the protocol doesn't work".
+ *
+ * Now it defers to the ONE shared implementation exported by
+ * `@agentvault/agentvault`. The message is still pushed into the session either
+ * way — the agent reads the whole room and only the reply obligation changes.
+ */
+export declare function _makeOwesReply(agentName: string | undefined, channel: {
+    ownDisplayName?: string;
+}, log: (msg: string) => void): (e: RoomMessage) => boolean;
 export declare function wireBridge(channel: RoomChannel, session: RoomSession, target: ActiveTarget, opts?: {
     /**
      * #1107: this agent's own name, used to recognise its own @mention. Threaded

package/dist/index.js

@@ -1115,6 +1115,58 @@ var init_mls_commit_classify = __esm2({
     "use strict";
   }
 });
+function parseMentions(text) {
+  const mentions = [];
+  const re2 = new RegExp(MENTION_RE.source, MENTION_RE.flags);
+  let match;
+  while ((match = re2.exec(text)) !== null) {
+    mentions.push(match[1].toLowerCase());
+  }
+  return mentions;
+}
+function resolveOwn(mention, names) {
+  if (names.has(mention)) return mention;
+  const parts = mention.split("-");
+  for (let i2 = parts.length - 1; i2 > 0; i2--) {
+    const candidate = parts.slice(0, i2).join("-");
+    if (names.has(candidate)) return candidate;
+  }
+  return null;
+}
+function owesRoomReply(plaintext, agentName, accountId, senderIsAgent, roomDisplayName, ownDisplayName, selfResolved = true) {
+  const mentions = parseMentions(plaintext);
+  if (mentions.length === 0) return false;
+  const ownNames = ownRoomNames(agentName, accountId, roomDisplayName, ownDisplayName);
+  if (mentions.some((m2) => resolveOwn(m2, ownNames) !== null)) return true;
+  if (mentions.some((m2) => resolveOwn(m2, BROADCAST_NAMES) !== null)) {
+    return senderIsAgent !== true;
+  }
+  if (!selfResolved) return true;
+  return false;
+}
+function ownRoomNames(agentName, accountId, roomDisplayName, ownDisplayName) {
+  const names = /* @__PURE__ */ new Set();
+  const add4 = (n2) => {
+    if (!n2) return;
+    const lower = n2.toLowerCase();
+    names.add(lower);
+    names.add(lower.split(/[\s(]/)[0]);
+  };
+  add4(agentName);
+  add4(accountId);
+  add4(roomDisplayName);
+  add4(ownDisplayName);
+  return names;
+}
+var MENTION_RE;
+var BROADCAST_NAMES;
+var init_room_protocol = __esm2({
+  "src/room-protocol.ts"() {
+    "use strict";
+    MENTION_RE = /@([\w-]+)/gi;
+    BROADCAST_NAMES = /* @__PURE__ */ new Set(["all", "everyone"]);
+  }
+});
 var __filename;
 var __dirname;
 var url2;
@@ -64017,10 +64069,10 @@ var init_mls_group = __esm2({
         const commits = [];
         if (leavesToRemove.length > 0) {
           const { commit } = await this.removeMembers(leavesToRemove);
-          commits.push({ commit, epoch: this.epoch });
+          commits.push({ commit, epoch: this.epoch, state: this.exportState() });
         }
         const added = await this.addMembers(toAdd);
-        commits.push({ commit: added.commit, epoch: this.epoch });
+        commits.push({ commit: added.commit, epoch: this.epoch, state: this.exportState() });
         return { commits, welcome: added.welcome };
       }
       async removeMembers(memberIndices) {
@@ -64605,11 +64657,11 @@ var init_mls_kp_pool = __esm2({
   }
 });
 function ownIdentity() {
-  const v2 = true ? "0.23.38" : FALLBACK;
+  const v2 = true ? "0.23.40" : FALLBACK;
   return `${PACKAGE}@${v2}`;
 }
 function buildSha() {
-  const raw = true ? "a6ce360-dirty" : "";
+  const raw = true ? "dbac15d-dirty" : "";
   const cleaned = (raw ?? "").trim();
   return !cleaned || cleaned === "unknown" ? null : cleaned;
 }
@@ -65531,6 +65583,7 @@ var init_channel = __esm2({
     "use strict";
     init_abstention();
     init_mls_commit_classify();
+    init_room_protocol();
     await init_libsodium_wrappers();
     await init_dist();
     await init_dist();
@@ -65712,6 +65765,56 @@ var init_channel = __esm2({
        * this process (GH #366). Cleared on (re)join so the next first message
        * re-fetches the authoritative roster. Prevents per-message refetch storms. */
       _roomRosterRefreshed = /* @__PURE__ */ new Set();
+      /**
+       * #1181: the last attachment saved per room, so the NEXT room turn can name
+       * it. wren saved an un-mentioned file (no reply, #1107), was asked "@wren can
+       * you read this file?" 14 s later, and answered "I don't see a file
+       * attached" — the note lived only in the prior history line. Hermes defers
+       * un-mentioned attachments and fetches on the next addressed turn (#1162);
+       * this is the plugin's equivalent surface. In-memory: a restart forgets it,
+       * which is the right default for "this file".
+       */
+      _recentRoomAttachments = /* @__PURE__ */ new Map();
+      static RECENT_ROOM_ATTACHMENT_MS = 10 * 60 * 1e3;
+      /** #1181: prefix a room turn that carries no attachment with the one saved in this room recently. */
+      _withRecentRoomAttachmentNote(roomId, text) {
+        const recent = this._recentRoomAttachments.get(roomId);
+        if (!recent) return text;
+        const ageMs = Date.now() - recent.at;
+        if (ageMs > _SecureChannel.RECENT_ROOM_ATTACHMENT_MS) return text;
+        return `[Most recent file in this room: ${recent.filePath} (${recent.name}, received ${Math.round(ageMs / 1e3)}s ago). If this message refers to "the file" or "this file", it means that one \u2014 use your Read tool on it.]
+
+${text}`;
+      }
+      /**
+       * #1161: room attachments whose caption addressed nobody, NOT yet fetched.
+       * The reply gate lives in every consumer of `room_message` (openclaw-entry
+       * and the three native bridges), but its first clause is shared and needs no
+       * identity: a caption with no mention token owes nobody a reply (#1107), so
+       * nobody needs the file yet. Kept per room, newest last, and fetched on the
+       * room's next ADDRESSED turn — the owner attaches, then asks (#1159/#1181).
+       * Hermes does the same (`_defer_room_attachment`).
+       */
+      _deferredRoomAttachments = /* @__PURE__ */ new Map();
+      static DEFERRED_ROOM_ATTACHMENT_MAX = 5;
+      static DEFERRED_ROOM_ATTACHMENT_MS = 60 * 60 * 1e3;
+      _deferRoomAttachment(roomId, info) {
+        const list = this._deferredRoomAttachments.get(roomId) ?? [];
+        list.push({ info, at: Date.now() });
+        while (list.length > _SecureChannel.DEFERRED_ROOM_ATTACHMENT_MAX) list.shift();
+        this._deferredRoomAttachments.set(roomId, list);
+        console.log(
+          `[SecureChannel] room ${roomId.slice(0, 8)}: attachment ${String(info?.filename ?? "file")} deferred \u2014 caption addresses nobody, fetch on the next @-addressed turn (#1161)`
+        );
+      }
+      /** Drain the room's deferred attachments that are still fresh (oldest first). */
+      _takeDeferredRoomAttachments(roomId) {
+        const list = this._deferredRoomAttachments.get(roomId);
+        if (!list?.length) return [];
+        this._deferredRoomAttachments.delete(roomId);
+        const cutoff = Date.now() - _SecureChannel.DEFERRED_ROOM_ATTACHMENT_MS;
+        return list.filter((d2) => d2.at >= cutoff).map((d2) => d2.info);
+      }
       /** In-flight roster-refresh promises (per room) — dedup concurrent refreshes. */
       _roomRosterRefreshInFlight = /* @__PURE__ */ new Map();
       /** Dedup buffer for A2A message IDs (prevents double-delivery via direct + Redis) */
@@ -66807,7 +66910,7 @@ var init_channel = __esm2({
        */
       sendActivitySpan(spanData) {
         if (!this._ws || this._ws.readyState !== WebSocket.OPEN) return;
-        const pluginVersion = true ? "0.23.38" : "0.0.0-dev";
+        const pluginVersion = true ? "0.23.40" : "0.0.0-dev";
         const agentName = this.config.agentName ?? "Agent";
         const resource = {
           "service.name": "agentvault-agent",
@@ -68745,7 +68848,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.38" : "0.0.0-dev"
+                pluginVersion: true ? "0.23.40" : "0.0.0-dev"
               });
               this._telemetryReporter.startAutoFlush(3e4);
             }
@@ -69069,7 +69172,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.38" : "0.0.0-dev"
+                    pluginVersion: true ? "0.23.40" : "0.0.0-dev"
                   });
                   this._telemetryReporter.startAutoFlush(3e4);
                 }
@@ -69383,6 +69486,7 @@ var init_channel = __esm2({
                 `[deliver] delivery_result=REJECTED group=${rejectedGroup || "unknown"} detail=${detail}`
               );
               console.error(`[SecureChannel] Server error: ${detail}`);
+              this._noteCommitRefusal(data.data || data);
               await this._handleServerError(data.data || data);
               this.emit("error", new Error(`Server: ${detail}`));
             }
@@ -69684,7 +69788,7 @@ var init_channel = __esm2({
         try {
           const parsed = JSON.parse(plaintext);
           messageType = parsed.type || "message";
-          messageText = parsed.text || plaintext;
+          messageText = parsed.text ?? plaintext;
           if (parsed.attachment) {
             attachmentInfo = parsed.attachment;
           }
@@ -69842,12 +69946,13 @@ ${messageText}`;
        * Returns the text unchanged when there is no attachment or the fetch fails —
        * but a failure is LOGGED and announced in the text, never silent.
        */
-      async _augmentWithAttachment(attachmentInfo, baseText) {
+      async _augmentWithAttachment(attachmentInfo, baseText, roomId) {
         if (!attachmentInfo) return baseText;
         try {
           const { filePath, decrypted } = await this._downloadAndDecryptAttachment(attachmentInfo);
           const mime = String(attachmentInfo.mime ?? "application/octet-stream");
           const name = String(attachmentInfo.filename ?? "attachment");
+          if (roomId) this._recentRoomAttachments.set(roomId, { filePath, name, at: Date.now() });
           const textMimes = ["text/", "application/json", "application/xml", "application/csv"];
           if (textMimes.some((m2) => mime.startsWith(m2))) {
             const content = new TextDecoder().decode(decrypted);
@@ -70435,7 +70540,7 @@ ${baseText}`;
           try {
             const parsed = JSON.parse(rawPlaintext);
             messageType = parsed.type || "message";
-            messageText = parsed.text || rawPlaintext;
+            messageText = parsed.text ?? rawPlaintext;
             if (parsed.attachment) roomAttachment = parsed.attachment;
           } catch {
             messageType = "message";
@@ -70476,8 +70581,19 @@ ${baseText}`;
               await this._refreshRoomRoster(resolvedRoomId);
             }
           }
-          if (roomAttachment) {
-            messageText = await this._augmentWithAttachment(roomAttachment, messageText);
+          const addressed = parseMentions(messageText).length > 0;
+          if (roomAttachment && !addressed) {
+            this._deferRoomAttachment(resolvedRoomId, roomAttachment);
+          } else {
+            const deferred = addressed ? this._takeDeferredRoomAttachments(resolvedRoomId) : [];
+            for (const info of deferred) {
+              messageText = await this._augmentWithAttachment(info, messageText, resolvedRoomId);
+            }
+            if (roomAttachment) {
+              messageText = await this._augmentWithAttachment(roomAttachment, messageText, resolvedRoomId);
+            } else if (deferred.length === 0) {
+              messageText = this._withRecentRoomAttachmentNote(resolvedRoomId, messageText);
+            }
           }
           const roomMembers = this._persisted?.rooms?.[resolvedRoomId]?.members ?? [];
           const senderMember = roomMembers.find((m2) => m2.deviceId === senderDeviceId);
@@ -70601,6 +70717,12 @@ ${baseText}`;
         const groupId = data.group_id;
         const epoch = typeof data.epoch === "number" ? data.epoch : 0;
         this._noteGroupEpoch(groupId, data.epoch);
+        const held = this._commitInFlight.get(groupId);
+        if (held) {
+          held.frames.push(data);
+          console.log(`[SecureChannel] MLS commit for ${groupId.slice(0, 8)} held (epoch=${epoch}) \u2014 our own commit is awaiting confirmation (#1184)`);
+          return true;
+        }
         const target = this._resolveGroupFamily(groupId);
         if (target) {
           const { managerKey: groupKey, label } = target;
@@ -70843,73 +70965,146 @@ ${baseText}`;
           return 0;
         }
         const snapshot = mlsGroup.exportState();
-        let parent2 = await this._readGroupHeadDigest(mlsGroupId);
-        const { commits, welcome } = await mlsGroup.reAdmitMembers(targets.map((t2) => t2.keyPackage));
-        let sentCommits = 0;
-        for (const c2 of commits) {
-          const ok = await this._sendFrameConfirmed(
-            {
-              event: "mls_commit",
-              data: {
-                group_id: mlsGroupId,
-                // The epoch this commit PRODUCED. After two commits the manager
-                // only knows the last one, which is why the result carries them.
-                epoch: Number(c2.epoch),
-                payload: Buffer.from(c2.commit).toString("hex"),
-                ...parent2 ? { parent_digest: parent2 } : {}
-              }
-            },
-            `${label} commit ${sentCommits + 1}/${commits.length}`
-          );
-          if (!ok) break;
-          parent2 = this._commitDigest(c2.commit);
-          sentCommits++;
-        }
-        if (sentCommits === 0) {
-          mlsGroup.importState(snapshot);
+        const preHead = await this._readGroupHead(mlsGroupId);
+        if (preHead.ok && preHead.epoch !== Number(mlsGroup.epoch)) {
           console.warn(
-            `[SecureChannel] ${label}: commit was NOT written \u2014 rolled back to epoch ${Number(mlsGroup.epoch)}, nothing fulfilled, requests stay pending`
+            `[SecureChannel] ${label}: server head is at epoch ${preHead.epoch}, we are at ${Number(mlsGroup.epoch)} \u2014 NOT committing (it would be refused, #1184); ${targets.length} request(s) stay pending`
           );
           return 0;
         }
-        await saveMlsState(this.config.dataDir, mlsGroupId, JSON.stringify(mlsGroup.exportState()));
-        if (sentCommits < commits.length) {
-          console.warn(
-            `[SecureChannel] ${label}: only ${sentCommits}/${commits.length} commits reached the wire \u2014 requests stay PENDING for the next pull`
-          );
-          return 0;
-        }
-        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 t2 of targets) {
-          const sent = await this._sendFrameConfirmed(
-            {
-              event: "mls_welcome",
-              data: {
-                target_device_id: t2.deviceId,
-                group_id: mlsGroupId,
-                ...welcomeFields,
-                payload: Buffer.from(welcome).toString("hex")
-              }
-            },
-            `${label} welcome\u2192${t2.deviceId.slice(0, 8)}`
-          );
-          if (!sent) {
+        let parent2 = preHead.ok ? preHead.digest : void 0;
+        const inFlight = { frames: [], sent: [] };
+        this._commitInFlight.set(mlsGroupId, inFlight);
+        try {
+          const { commits, welcome } = await mlsGroup.reAdmitMembers(targets.map((t2) => t2.keyPackage));
+          let sentCommits = 0;
+          let refusedAt = -1;
+          let verdict = "confirmed";
+          for (const c2 of commits) {
+            const ours = this._commitDigest(c2.commit);
+            inFlight.sent.push({
+              epoch: Number(c2.epoch),
+              digest: ours,
+              verified: false,
+              stateBefore: sentCommits === 0 ? snapshot : commits[sentCommits - 1].state
+            });
+            const ok = await this._sendFrameConfirmed(
+              {
+                event: "mls_commit",
+                data: {
+                  group_id: mlsGroupId,
+                  // The epoch this commit PRODUCED. After two commits the manager
+                  // only knows the last one, which is why the result carries them.
+                  epoch: Number(c2.epoch),
+                  payload: Buffer.from(c2.commit).toString("hex"),
+                  ...parent2 ? { parent_digest: parent2 } : {}
+                }
+              },
+              `${label} commit ${sentCommits + 1}/${commits.length}`
+            );
+            if (!ok) {
+              verdict = "unsent";
+              inFlight.sent.pop();
+              break;
+            }
+            verdict = await this._confirmCommitAtHead(mlsGroupId, Number(c2.epoch), ours, inFlight, label);
+            if (verdict === "confirmed") {
+              inFlight.sent[sentCommits].verified = true;
+            } else if (verdict === "unverifiable") {
+              console.warn(
+                `[SecureChannel] ${label}: commit ${sentCommits + 1}/${commits.length} at epoch ${Number(c2.epoch)} could not be verified and was not refused \u2014 proceeding UNCHECKED (#1184)`
+              );
+            } else {
+              refusedAt = sentCommits;
+              break;
+            }
+            parent2 = ours;
+            sentCommits++;
+          }
+          const cutFromRefusal = () => {
+            const r2 = inFlight.refusal;
+            if (r2 === void 0) return refusedAt;
+            return refusedAt === -1 ? r2.from : Math.min(refusedAt, r2.from);
+          };
+          const rollBackTo = async (cut2, stage, persisted) => {
+            const why = inFlight.refusal?.detail ?? verdict.toUpperCase();
+            mlsGroup.importState(inFlight.sent[cut2].stateBefore);
+            sentCommits = cut2;
             console.warn(
-              `[SecureChannel] ${label}: Welcome for ${t2.deviceId.slice(0, 8)} was NOT written \u2014 leaving the request PENDING so the next pull retries it`
+              `[SecureChannel] ${label}: commit ${cut2 + 1}/${commits.length} ${stage} \u2014 "${why}" \u2014 rolled back to epoch ${Number(mlsGroup.epoch)}` + (cut2 === 0 ? ", nothing" : ` (after commit ${cut2}), only that`) + ` persisted, ${targets.length} request(s) stay pending`
             );
-            continue;
+            if (persisted) await saveMlsState(this.config.dataDir, mlsGroupId, JSON.stringify(mlsGroup.exportState()));
+          };
+          let cut = cutFromRefusal();
+          if (cut !== -1) {
+            await rollBackTo(cut, "was refused by the server", false);
+            if (sentCommits === 0) return 0;
+          }
+          if (sentCommits === 0) {
+            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()));
+          cut = cutFromRefusal();
+          if (cut !== -1 && cut < sentCommits) {
+            await rollBackTo(cut, "was refused by the server after the window (during persist)", true);
+            return 0;
+          }
+          if (sentCommits < commits.length) {
+            console.warn(
+              `[SecureChannel] ${label}: only ${sentCommits}/${commits.length} commits were confirmed \u2014 requests stay PENDING for the next pull`
+            );
+            return 0;
+          }
+          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 t2 of targets) {
+            const sent = await this._sendFrameConfirmed(
+              {
+                event: "mls_welcome",
+                data: {
+                  target_device_id: t2.deviceId,
+                  group_id: mlsGroupId,
+                  ...welcomeFields,
+                  payload: Buffer.from(welcome).toString("hex")
+                }
+              },
+              `${label} welcome\u2192${t2.deviceId.slice(0, 8)}`
+            );
+            if (!sent) {
+              console.warn(
+                `[SecureChannel] ${label}: Welcome for ${t2.deviceId.slice(0, 8)} was NOT written \u2014 leaving the request PENDING so the next pull retries it`
+              );
+              continue;
+            }
+            cut = cutFromRefusal();
+            if (cut !== -1 && cut < sentCommits) {
+              await rollBackTo(cut, "was refused by the server after the window (during the Welcome)", true);
+              return fulfilled;
+            }
+            if (await this._postFulfilWelcome(mlsGroupId, t2.requestId, `${label} ${t2.deviceId.slice(0, 8)}`)) {
+              fulfilled++;
+            }
           }
-          if (await this._postFulfilWelcome(mlsGroupId, t2.requestId, `${label} ${t2.deviceId.slice(0, 8)}`)) {
-            fulfilled++;
+          return fulfilled;
+        } finally {
+          this._commitInFlight.delete(mlsGroupId);
+          for (const frame of inFlight.frames) {
+            try {
+              await this._handleMlsCommit(frame);
+            } catch (err) {
+              console.error(`[SecureChannel] ${label}: replaying a held MLS commit failed:`, err);
+            }
           }
         }
-        return fulfilled;
       }
       /**
        * Resolve an MLS group id to the family that owns it.
@@ -70956,24 +71151,237 @@ ${baseText}`;
       /**
        * #1177: the digest of the commit at the server's head, or undefined.
        *
-       * Undefined covers "no head yet", "older backend", AND "could not read" —
-       * deliberately the same value. The commit is sent either way: the server
-       * skips the parent check for an ABSENT field and refuses a MALFORMED one,
-       * so a read failure must degrade to "unchecked", never to "blocked" (a
-       * rescue that cannot run is the 2026-09-04 lockout) and never to `null`.
+       * Undefined covers "no head yet" (a pruned group: epoch known, digest NULL —
+       * 29 in production) AND "could not read" — deliberately the same value. The
+       * commit is sent either way: the server skips the parent check for an
+       * ABSENT field and refuses a MALFORMED one, so a read failure must degrade
+       * to "unchecked", never to "blocked" (a rescue that cannot run is the
+       * 2026-09-04 lockout) and never to `null`.
        */
       async _readGroupHeadDigest(groupId) {
+        const head = await this._readGroupHead(groupId);
+        return head.ok ? head.digest : void 0;
+      }
+      /**
+       * #1184: the server's head — its `current_epoch` and the digest of the commit
+       * that produced it.
+       *
+       *   - `{ ok: true, epoch, digest? }`  the server described its head. `digest`
+       *                                     is absent on a pruned group (NULL
+       *                                     `last_commit_digest`).
+       *   - `{ ok: false, why }`            the read failed: a non-2xx (the 403
+       *                                     `assert_group_member` returns on an
+       *                                     EMPTY roster — 79 of 80 production
+       *                                     rooms — or a 5xx), a timeout, or a body
+       *                                     with no `current_epoch`. Callers may
+       *                                     retry; a failure is never a verdict.
+       *
+       * `current_epoch` is a required field of `MLSGroupResponse`, so "200 with
+       * no head" is not a shape any deployed backend produces; it is folded into
+       * `ok: false` rather than given a branch of its own (the first cut of #1184
+       * had one, and it was the only branch the suite exercised).
+       */
+      async _readGroupHead(groupId) {
         try {
           const res = await fetch(`${this.config.apiUrl}/api/v1/mls/groups/${groupId}`, {
-            headers: { Authorization: `Bearer ${this._deviceJwt}` }
+            headers: { Authorization: `Bearer ${this._deviceJwt}` },
+            // The confirm loop holds `_deliveryPulling`; a black-holed read must
+            // not hold it for undici's 300 s default. A timeout is a failed read.
+            signal: AbortSignal.timeout(_SecureChannel.HEAD_READ_TIMEOUT_MS)
           });
-          if (!res.ok) return void 0;
+          if (!res.ok) return { ok: false, why: `HTTP ${res.status}` };
           const head = await res.json();
-          const d2 = head?.last_commit_digest;
-          return typeof d2 === "string" && /^[0-9a-f]{64}$/.test(d2) ? d2 : void 0;
-        } catch {
-          return void 0;
+          if (typeof head?.current_epoch !== "number") return { ok: false, why: "no current_epoch in body" };
+          const d2 = head.last_commit_digest;
+          return { ok: true, epoch: head.current_epoch, digest: typeof d2 === "string" && /^[0-9a-f]{64}$/.test(d2) ? d2 : void 0 };
+        } catch (err) {
+          return { ok: false, why: err instanceof Error ? err.name : String(err) };
+        }
+      }
+      /**
+       * #1184: after each read of the head, how long to wait before the next.
+       * The web's schedule (`lib/mls-commit-confirm.ts`) plus one immediate read:
+       * five reads, ~3.75 s, no resend — an MLS commit cannot be regenerated. The
+       * immediate read catches the common case where the server stored the frame
+       * before the GET lands. Instance-level so tests can run the decision logic
+       * without the clock; an empty schedule still reads once (`_confirmCommitAtHead`).
+       */
+      _commitConfirmDelaysMs = [0, 250, 500, 1e3, 2e3];
+      static HEAD_READ_TIMEOUT_MS = 5e3;
+      /**
+       * #1184: groups with a commit of OURS between "built" and "confirmed or rolled
+       * back". Each record holds the `mls_commit` frames the socket delivered for
+       * that group meanwhile — before the confirm loop that window was
+       * microseconds; now it is up to ~3.75 s, and a commit applied to our
+       * unconfirmed local state would be lost by the rollback (in memory) after
+       * being persisted (on disk). Held frames are replayed, in order, once the
+       * group is back on a real state. The record also carries the server's
+       * REFUSAL, when one arrives on the socket (`_noteCommitRefusal`), and a
+       * `wake` the confirm loop installs so a refusal ends its wait at once.
+       */
+      _commitInFlight = /* @__PURE__ */ new Map();
+      /** #1184: a pull was requested while one was running — run once more after. */
+      _deliveryPullRequested = false;
+      /**
+       * #1184: an `error` frame naming a group we have a commit in flight for, with
+       * a `… commit rejected` detail, is the server's refusal of one of those
+       * commits — every rejection the `mls_commit` WS handler sends (malformed
+       * parent, PARENT_MISMATCH, EPOCH_CONFLICT, not-a-member, no-participants)
+       * ends with those words and carries `group_id` (pinned by
+       * `tests/test_1184_commit_reject_frame_contract.py`). It is sent on OUR
+       * socket after the server processed OUR frame, so it is deterministic in a
+       * way the head poll is not, and it is the only refusal signal on a group
+       * whose head we cannot read (403).
+       *
+       * WHICH commit, and what else the frame proves (re-review of #1227):
+       *   - EPOCH_CONFLICT carries `expected_epoch` (the epoch we claimed to build
+       *     on) and `current_epoch` (the server's); PARENT_MISMATCH carries
+       *     `current_epoch` (the head, which equalled our claim or the epoch check
+       *     would have fired first) and `head_digest`. The refused commit is the
+       *     one built on that epoch. A frame naming an epoch none of our in-flight
+       *     commits claimed is a refusal of some EARLIER attempt — ignored.
+       *   - the server's `current_epoch` bounds our earlier commits too: any of
+       *     ours ABOVE it did not land.
+       *   - `head_digest` at `current_epoch` is our commit at that epoch → that one
+       *     positively LANDED; someone else's → ours at that epoch did not.
+       *   - the un-numbered shapes refuse all of ours alike: the cut is the first
+       *     commit the head poll has not positively confirmed.
+       * Recorded as the index of the first commit shown not to hold; the fulfil
+       * path honours it whenever it arrives. A frame for a group with nothing in
+       * flight is somebody else's business.
+       */
+      _noteCommitRefusal(payload) {
+        const groupId = typeof payload?.group_id === "string" ? payload.group_id : void 0;
+        const detail = typeof payload?.detail === "string" ? payload.detail : "";
+        if (!groupId || !detail.endsWith("commit rejected")) return;
+        const inFlight = this._commitInFlight.get(groupId);
+        if (!inFlight) return;
+        const num = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? v2 : void 0;
+        const current = num(payload.current_epoch);
+        const claimed = num(payload.expected_epoch) ?? current;
+        const headDigest = typeof payload.head_digest === "string" ? payload.head_digest : void 0;
+        const sent = inFlight.sent;
+        const tag = `[SecureChannel] refusal for ${groupId.slice(0, 8)} ("${detail}")`;
+        let from = -1;
+        if (claimed !== void 0) {
+          from = sent.findIndex((c2) => c2.epoch === claimed + 1);
+          if (from === -1) {
+            console.warn(`${tag} names epoch ${claimed + 1}, which no commit in flight claimed \u2014 an earlier attempt's; ignored`);
+            return;
+          }
+        }
+        if (current !== void 0) {
+          const above = sent.findIndex((c2) => c2.epoch > current && !c2.verified);
+          if (above !== -1 && (from === -1 || above < from)) from = above;
+        }
+        if (headDigest !== void 0 && current !== void 0) {
+          const at = sent.findIndex((c2) => c2.epoch === current);
+          if (at !== -1) {
+            if (sent[at].digest === headDigest) {
+              sent[at].verified = true;
+            } else if (from === -1 || at < from) {
+              from = at;
+            }
+          }
+        }
+        if (from === -1) from = sent.findIndex((c2) => !c2.verified);
+        if (from === -1 || sent[from].verified) {
+          console.warn(`${tag} contradicts a head read that showed our commit \u2014 stale; ignored`);
+          return;
         }
+        if (inFlight.refusal !== void 0 && inFlight.refusal.from <= from) return;
+        inFlight.refusal = { detail, from };
+        inFlight.wake?.();
+      }
+      /**
+       * #1184: a commit is CONFIRMED when the server's head shows OUR digest at OUR
+       * epoch — never when the socket took the bytes (#1015 covers only that). The
+       * server sends no ack for a stored commit, so, like the web, we read the
+       * head back; but it DOES send a refusal on the socket (`_noteCommitRefusal`),
+       * and that is checked first, before every read and during every wait.
+       *
+       *   confirmed     head.epoch === ours && head.digest === ours
+       *   conflict      the server refused ours on the socket, OR the head is at
+       *                 our epoch with ANOTHER digest, OR already past us
+       *   unconfirmed   the head was READ (at least once) but never reached our
+       *                 epoch within the window — the server described its state
+       *                 and ours is not in it
+       *   unverifiable  the head could not be read on ANY try (403 on an empty
+       *                 roster, an outage) and no refusal arrived — or it is at
+       *                 our epoch but keeps no digest (a pruned group). Nothing
+       *                 can be decided on; the caller proceeds UNCHECKED (#1177's
+       *                 rule: a rescue that cannot run is the 2026-09-04 lockout)
+       *
+       * The first cut returned `unverifiable` only for a body with no
+       * `current_epoch`, which no deployed backend produces, and rolled back on
+       * every real read failure — the opposite of the rule it stated.
+       */
+      async _confirmCommitAtHead(groupId, epoch, ours, inFlight, label) {
+        const refused = () => {
+          if (inFlight.refusal === void 0) return void 0;
+          console.warn(`[SecureChannel] ${label}: server refused our commit at epoch ${epoch} \u2014 "${inFlight.refusal.detail}"`);
+          return "conflict";
+        };
+        let lastSeen;
+        let described = false;
+        let lastFailure = "";
+        const delays = this._commitConfirmDelaysMs.length > 0 ? this._commitConfirmDelaysMs : [0];
+        for (const delay of delays) {
+          if (delay > 0) {
+            await new Promise((resolve3) => {
+              const timer = setTimeout(() => {
+                inFlight.wake = void 0;
+                resolve3();
+              }, delay);
+              inFlight.wake = () => {
+                clearTimeout(timer);
+                inFlight.wake = void 0;
+                resolve3();
+              };
+            });
+          }
+          const early = refused();
+          if (early) return early;
+          const head = await this._readGroupHead(groupId);
+          const duringRead = refused();
+          if (duringRead) return duringRead;
+          if (!head.ok) {
+            lastFailure = head.why;
+            continue;
+          }
+          described = true;
+          lastSeen = head.epoch;
+          if (head.epoch === epoch) {
+            if (head.digest === ours) return "confirmed";
+            if (head.digest === void 0) return "unverifiable";
+            console.warn(
+              `[SecureChannel] ${label}: head at epoch ${epoch} is NOT our commit (${head.digest.slice(0, 12)}\u2026 vs ours ${ours.slice(0, 12)}\u2026) \u2014 ours was refused`
+            );
+            return "conflict";
+          }
+          if (head.epoch > epoch) {
+            console.warn(`[SecureChannel] ${label}: head already at epoch ${head.epoch}, past our ${epoch} \u2014 ours was refused`);
+            return "conflict";
+          }
+        }
+        const late2 = refused();
+        if (late2) return late2;
+        if (!described && !this._wsIsOpen()) {
+          console.warn(
+            `[SecureChannel] ${label}: the socket closed during the confirm window and the head could not be read \u2014 a refusal of commit at epoch ${epoch} may have been lost; treating as refused`
+          );
+          return "unconfirmed";
+        }
+        if (!described) {
+          console.warn(
+            `[SecureChannel] ${label}: could not read the head on any of ${delays.length} tries (last: ${lastFailure}) and the server sent no refusal \u2014 cannot verify commit at epoch ${epoch}`
+          );
+          return "unverifiable";
+        }
+        console.warn(
+          `[SecureChannel] ${label}: commit at epoch ${epoch} never appeared at the head (last seen ${lastSeen}) \u2014 treating as refused`
+        );
+        return "unconfirmed";
       }
       /**
        * #1015: write one frame and report whether the socket took it.
@@ -71495,7 +71903,11 @@ ${baseText}`;
        * Called on WS connect, on mls_delivery ping, and every 30s heartbeat.
        */
       async _pullDeliveryQueue() {
-        if (!this._deviceId || !this._deviceJwt || this._deliveryPulling) return;
+        if (!this._deviceId || !this._deviceJwt) return;
+        if (this._deliveryPulling) {
+          this._deliveryPullRequested = true;
+          return;
+        }
         this._deliveryPulling = true;
         try {
           const res = await fetch(
@@ -72057,6 +72469,10 @@ ${baseText}`;
           console.warn("[SecureChannel] Delivery pull error:", err);
         } finally {
           this._deliveryPulling = false;
+          if (this._deliveryPullRequested) {
+            this._deliveryPullRequested = false;
+            void this._pullDeliveryQueue().catch((err) => console.warn("[SecureChannel] Coalesced delivery pull error:", err));
+          }
         }
       }
       /**
@@ -72140,7 +72556,7 @@ ${baseText}`;
               try {
                 const parsed = JSON.parse(plaintext);
                 messageType = parsed.type || "message";
-                messageText = parsed.text || plaintext;
+                messageText = parsed.text ?? plaintext;
               } catch {
                 messageType = "message";
                 messageText = plaintext;
@@ -72489,7 +72905,7 @@ ${baseText}`;
                 try {
                   const parsed = JSON.parse(plaintext);
                   messageType = parsed.type || "message";
-                  messageText = parsed.text || plaintext;
+                  messageText = parsed.text ?? plaintext;
                 } catch {
                   messageType = "message";
                   messageText = plaintext;
@@ -72774,7 +73190,7 @@ ${baseText}`;
                 try {
                   const parsed = JSON.parse(plaintext);
                   messageType = parsed.type || "message";
-                  messageText = parsed.text || plaintext;
+                  messageText = parsed.text ?? plaintext;
                 } catch {
                   messageType = "message";
                   messageText = plaintext;
@@ -73374,58 +73790,6 @@ var init_gateway_send = __esm2({
     init_openclaw_compat();
   }
 });
-function parseMentions(text) {
-  const mentions = [];
-  const re2 = new RegExp(MENTION_RE.source, MENTION_RE.flags);
-  let match;
-  while ((match = re2.exec(text)) !== null) {
-    mentions.push(match[1].toLowerCase());
-  }
-  return mentions;
-}
-function resolveOwn(mention, names) {
-  if (names.has(mention)) return mention;
-  const parts = mention.split("-");
-  for (let i2 = parts.length - 1; i2 > 0; i2--) {
-    const candidate = parts.slice(0, i2).join("-");
-    if (names.has(candidate)) return candidate;
-  }
-  return null;
-}
-function owesRoomReply(plaintext, agentName, accountId, senderIsAgent, roomDisplayName, ownDisplayName, selfResolved = true) {
-  const mentions = parseMentions(plaintext);
-  if (mentions.length === 0) return false;
-  const ownNames = ownRoomNames(agentName, accountId, roomDisplayName, ownDisplayName);
-  if (mentions.some((m2) => resolveOwn(m2, ownNames) !== null)) return true;
-  if (mentions.some((m2) => resolveOwn(m2, BROADCAST_NAMES) !== null)) {
-    return senderIsAgent !== true;
-  }
-  if (!selfResolved) return true;
-  return false;
-}
-function ownRoomNames(agentName, accountId, roomDisplayName, ownDisplayName) {
-  const names = /* @__PURE__ */ new Set();
-  const add4 = (n2) => {
-    if (!n2) return;
-    const lower = n2.toLowerCase();
-    names.add(lower);
-    names.add(lower.split(/[\s(]/)[0]);
-  };
-  add4(agentName);
-  add4(accountId);
-  add4(roomDisplayName);
-  add4(ownDisplayName);
-  return names;
-}
-var MENTION_RE;
-var BROADCAST_NAMES;
-var init_room_protocol = __esm2({
-  "src/room-protocol.ts"() {
-    "use strict";
-    MENTION_RE = /@([\w-]+)/gi;
-    BROADCAST_NAMES = /* @__PURE__ */ new Set(["all", "everyone"]);
-  }
-});
 var init_llm_response_parser = __esm2({
   "src/llm-response-parser.ts"() {
     "use strict";
@@ -99519,7 +99883,7 @@ var init_index = __esm2({
     await init_skill_telemetry();
     await init_policy_enforcer();
     init_room_protocol();
-    VERSION = true ? "0.23.38" : "0.0.0-dev";
+    VERSION = true ? "0.23.40" : "0.0.0-dev";
   }
 });
 await init_index();
@@ -99570,7 +99934,12 @@ var GrokSession = class {
   saidThisTurn = false;
   drain = Promise.resolve();
   push(text, reply, opts) {
-    this.queue.push({ text, reply, autoReplyOnText: opts?.replyExpected ?? opts?.autoReplyOnText });
+    this.queue.push({
+      text,
+      reply,
+      autoReplyOnText: opts?.replyExpected ?? opts?.autoReplyOnText,
+      sayAllowed: opts?.replyExpected ?? true
+    });
     if (!this.running) this.drain = this.run();
   }
   /** Hand this to startRoomMcpServer({ onSay }). The behaviour is stable for
@@ -99584,6 +99953,12 @@ var GrokSession = class {
           this.log(`say arrived with no turn in flight; DROPPED: ${JSON.stringify(text.slice(0, 80))}`);
           return;
         }
+        if (!this.current.sayAllowed) {
+          this.log(
+            `say during a turn this agent does not owe (no @mention) \u2014 SUPPRESSED: ${JSON.stringify(text.slice(0, 80))}`
+          );
+          return;
+        }
         this.saidThisTurn = true;
         const sink = this.current.reply ?? this.opts.onSay;
         if (!sink) {
@@ -100445,7 +100820,7 @@ async function main() {
   const info = parseInfoFlags(process.argv.slice(2));
   if (info.showVersion || info.showHelp) {
     const version2 = buildClientVersion2(
-      true ? "0.4.11" : void 0
+      true ? "0.4.13" : void 0
     );
     if (info.showVersion) printLine(version2);
     if (info.showHelp) {
@@ -100498,7 +100873,7 @@ async function main() {
     agentName: cfg.agentName,
     platform: "node",
     clientVersion: buildClientVersion2(
-      true ? "0.4.11" : void 0
+      true ? "0.4.13" : void 0
     )
   });
   channelRef = channel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentvault/grok-bridge",
-  "version": "0.4.11",
+  "version": "0.4.13",
   "type": "module",
   "description": "AgentVault Grok Bridge — daemon bridging a Grok agent into E2E-encrypted AgentVault direct messages and rooms.",
   "main": "dist/index.js",