@clawling/clawchat-plugin-openclaw 2026.7.29-1 → 2026.8.2-1

package/dist/src/permission-result.js

@@ -64,9 +64,16 @@ function buildOutcomeNote(metadata) {
  * Mirrors the `buildAwarenessNoteEnvelope` pattern: a synthetic inbound
  * `message.send` targeting the owner's direct conversation, routed through
  * `handleInboundEnvelope` so the agent can reason about the outcome.
+ *
+ * `ownerConversationId` MUST be the owner's direct conversation id (`cnv_…`)
+ * recorded at activation, never `account.ownerUserId`. The agent's in-turn
+ * reply inherits this note's `chat_id`, and msghub resolves chat_id through
+ * member-backend — a `usr_…` there comes back "invalid conversation id", so the
+ * reply is dropped and the sender never learns. Hence the required non-null
+ * parameter: there is no safe value to fall back to.
  */
 export function buildPermissionResultEnvelope(params) {
-    const { account, metadata } = params;
+    const { account, metadata, ownerConversationId } = params;
     const text = buildOutcomeNote(metadata);
     const now = Date.now();
     return {
@@ -74,7 +81,7 @@ export function buildPermissionResultEnvelope(params) {
         event: EVENT.MESSAGE_SEND,
         trace_id: `clawchat-plugin-openclaw-permission-result-${metadata.request_id}-${now}`,
         emitted_at: now,
-        chat_id: account.ownerUserId,
+        chat_id: ownerConversationId,
         chat_type: "direct",
         to: { id: account.userId, type: "direct" },
         sender: {
@@ -109,12 +116,20 @@ export function buildPermissionResultEnvelope(params) {
  *
  * Returns a synthetic context-note {@link Envelope} on a fresh receipt so
  * the caller can feed it to `handleInboundEnvelope`; returns `null` when
- * the `request_id` has already been processed.
+ * the `request_id` has already been processed, or when `ownerConversationId`
+ * is absent.
+ *
+ * A null `ownerConversationId` (activation has not recorded the owner's direct
+ * conversation yet) is checked BEFORE the dedup mark on purpose: the receipt
+ * cannot be routed anywhere, so burning its dedup slot would permanently
+ * swallow it — the replayed copy must still render once the id is known.
  */
-export function handlePermissionResult(metadata, account) {
+export function handlePermissionResult(metadata, account, ownerConversationId) {
+    if (!ownerConversationId)
+        return null;
     if (metadata.request_id && _seenRequestIds.has(metadata.request_id))
         return null;
     if (metadata.request_id)
         _seenRequestIds.add(metadata.request_id);
-    return buildPermissionResultEnvelope({ account, metadata });
+    return buildPermissionResultEnvelope({ account, metadata, ownerConversationId });
 }

package/dist/src/protocol-types.js

@@ -58,6 +58,24 @@ export class MessageSendError extends Error {
         this.chatId = chatId;
     }
 }
+/**
+ * `message.error` codes that PROVE the target conversation is unreachable for
+ * this sender right now (docs/client-integration.md §14.3). Both are documented
+ * as terminal for the affected uplink.
+ *
+ * Deliberately excludes `capability_missing` and `unsupported_version`: those
+ * are terminal too, but they indict THIS CLIENT's handshake/envelope, not the
+ * conversation — muting the chat on them would be a false positive.
+ *
+ * NOTE: "terminal for this uplink" is NOT "terminal forever". A deleted
+ * conversation can be revived in place under the same `cnv_` id (that is the
+ * path an agent re-pairing takes), so anything derived from these codes must
+ * be recoverable — see SERVER_REJECTION_TTL_MS in ws-client.ts.
+ */
+export const TERMINAL_CHAT_CODES = new Set([
+    "chat_not_found",
+    "not_member",
+]);
 export class StateError extends Error {
     name = "StateError";
 }

package/dist/src/reply-dispatcher.js

@@ -256,14 +256,23 @@ function formatApprovalSummary(payload) {
  * as separate ClawChat messages.
  */
 export function createOpenclawClawlingReplyDispatcher(options) {
-    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, store, log, } = options;
+    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, store, resolveOwnerConversationId, log, } = options;
     const isGroupTarget = target.chatType === "group";
     const outputVisibility = effectiveOutputVisibility(account, target.chatId, target.chatType);
     const splitFullOutput = outputVisibility === "full";
     const splitNormalBlockOutput = outputVisibility === "normal";
+    // The escalation target is the owner's ACTIVATION CONVERSATION id, never the
+    // owner's usr_… id: chat_id is resolved by msghub through member-backend, and
+    // a usr_… comes back "invalid conversation id" — the frame is dropped with no
+    // negative ack to this client, so the owner silently never gets the approval
+    // request. Both ids are required: ownerUserId gates whether an owner exists at
+    // all, the conversation id is where a frame can actually be delivered.
     const ownerDirectTarget = () => {
         const ownerUserId = account.ownerUserId?.trim();
-        return ownerUserId ? { chatId: ownerUserId, chatType: "direct" } : null;
+        if (!ownerUserId)
+            return null;
+        const conversationId = resolveOwnerConversationId?.()?.trim();
+        return conversationId ? { chatId: conversationId, chatType: "direct" } : null;
     };
     const humanDelay = runtime.channel.reply.resolveHumanDelayConfig(cfg, account.userId);
     const buildApiClient = () => {
@@ -448,7 +457,10 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     const sendOwnerAttention = async (fallbackText, richFragment = null) => {
         const ownerTarget = ownerDirectTarget();
         if (!ownerTarget) {
-            log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw group owner attention suppressed reason=missing_owner_user_id group=${target.chatId}`);
+            const reason = account.ownerUserId?.trim()
+                ? "missing_owner_conversation"
+                : "missing_owner_user_id";
+            log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw group owner attention suppressed reason=${reason} group=${target.chatId}`);
             return;
         }
         await sendOpenclawClawlingText({

package/dist/src/runtime.js

@@ -8,7 +8,7 @@ import { buildActivationBootstrapText } from "./activation-greeting.js";
 import { reportPluginVersionSafe, resolvePluginVersion } from "./plugin-report.js";
 import path from "node:path";
 import { ensureLivewareCli, resolveLivewarePath } from "./liveware-cli.js";
-import { LivewareSampleSupervisor } from "./liveware-sample.js";
+import { LivewareSampleSupervisor, } from "./liveware-sample.js";
 import { ClawlingApiError } from "./api-types.js";
 import { RefreshManager } from "./refresh-manager.js";
 import { runOpenclawClawlingLogin, } from "./login.runtime.js";
@@ -32,11 +32,20 @@ import { createGroupMessageCoalescer } from "./group-message-coalescer.js";
 import { openclawLlmContextDebug } from "./llm-context-debug.js";
 import { GroupSettingsCache } from "./group-settings.js";
 import { PermissionCache } from "./permissions.js";
-import { buildAwarenessNoteEnvelope } from "./awareness-note-turn.js";
+import { buildAwarenessNoteEnvelope, buildMomentCommentNoteEnvelope } from "./awareness-note-turn.js";
 import { handlePermissionResult } from "./permission-result.js";
 const { setRuntime: setOpenclawClawlingRuntime, getRuntime: getOpenclawClawlingRuntime } = createPluginRuntimeStore("clawchat-plugin-openclaw runtime not initialized");
 export { setOpenclawClawlingRuntime, getOpenclawClawlingRuntime };
 const activeClients = new Map();
+// Live liveware-sample supervisors, keyed by the gateway's abortSignal and then by
+// `platform:accountId`. startOpenclawClawlingGateway re-enters ITSELF (token-refresh
+// reconnect, transport backoff, post-auth-failed re-activation) carrying the same
+// `...params` — so the same abortSignal — and a per-call `new LivewareSampleSupervisor`
+// left the previous one running: both then raced the bootstrap "account has zero apps"
+// gate and each minted its own liveware app, leaving a duplicate app tile that no
+// SQLite row tracks (the single-row PK means the loser is orphaned forever). Keyed by
+// signal so an entry cannot outlive the channel it belongs to.
+const livewareSampleSupervisors = new WeakMap();
 const CLAWCHAT_PLUGIN_SLASH_COMMANDS = new Set(["clawchat-activate", "clawchat-output"]);
 const ACTIVATION_CREDENTIAL_POLL_INTERVAL_MS = 2_000;
 // Activation-bootstrap retry on the live connection. The bootstrap greeting is
@@ -791,7 +800,7 @@ export async function startOpenclawClawlingGateway(params) {
     let livewareSampleNotify = async () => false;
     if (store) {
         const stateDirForSample = runtime.state?.resolveStateDir?.();
-        const livewareSampleSupervisor = new LivewareSampleSupervisor({
+        const livewareSampleDeps = {
             platform: "openclaw",
             accountId,
             enabled: account.livewareSample,
@@ -819,9 +828,29 @@ export async function startOpenclawClawlingGateway(params) {
                 debug: (m) => log?.debug?.(m),
                 error: (m) => log?.error?.(m),
             },
-        });
-        abortSignal.addEventListener("abort", () => livewareSampleSupervisor.stop());
-        void livewareSampleSupervisor.start();
+        };
+        const supervisorsForSignal = livewareSampleSupervisors.get(abortSignal) ?? new Map();
+        livewareSampleSupervisors.set(abortSignal, supervisorsForSignal);
+        const supervisorKey = `openclaw:${accountId}`;
+        const runningSupervisor = supervisorsForSignal.get(supervisorKey);
+        if (runningSupervisor) {
+            // A gateway re-entry (refresh/backoff reconnect), not a fresh channel start:
+            // hand the live supervisor this closure's token + REST client + notify path
+            // instead of constructing a second one that would register a duplicate app.
+            log?.debug?.(`[${accountId}] clawchat-plugin-openclaw liveware-sample supervisor already live; re-pointing it at the re-entered gateway`);
+            runningSupervisor.adoptDeps(livewareSampleDeps);
+        }
+        else {
+            const livewareSampleSupervisor = new LivewareSampleSupervisor(livewareSampleDeps);
+            supervisorsForSignal.set(supervisorKey, livewareSampleSupervisor);
+            abortSignal.addEventListener("abort", () => {
+                livewareSampleSupervisor.stop();
+                if (supervisorsForSignal.get(supervisorKey) === livewareSampleSupervisor) {
+                    supervisorsForSignal.delete(supervisorKey);
+                }
+            });
+            void livewareSampleSupervisor.start();
+        }
     }
     const resolveMutateConfigFile = () => {
         if (params.mutateConfigFile)
@@ -1840,6 +1869,30 @@ export async function startOpenclawClawlingGateway(params) {
                     ],
                 }));
             }
+            else if (env.event === "message.error") {
+                // Never fold this into `inbound_ignored`: `code` + `chat_id` are the
+                // only in-plugin evidence that an uplink was refused, and the
+                // 2026-07-19 incident needed a server-log dig purely because this line
+                // did not exist. `action=message_error` marks it as semantically seen.
+                const current = wsLogContext();
+                const errorPayload = env.payload && typeof env.payload === "object"
+                    ? env.payload
+                    : undefined;
+                log?.info?.(formatWsLog({
+                    event: "inbound_control",
+                    accountId,
+                    attempt: current.attempt,
+                    reconnectCount: current.reconnectCount,
+                    state: "ready",
+                    action: "message_error",
+                    fields: [
+                        ["event_name", env.event],
+                        ["trace_id", env.trace_id],
+                        ["chat_id", env.chat_id],
+                        ["code", typeof errorPayload?.code === "string" ? errorPayload.code : "-"],
+                    ],
+                }));
+            }
             else if (env.event !== "ping" && env.event !== "pong") {
                 const current = wsLogContext();
                 log?.info?.(formatWsLog({
@@ -1909,6 +1962,12 @@ export async function startOpenclawClawlingGateway(params) {
             ?.conversationId?.trim();
         return conversationId || null;
     };
+    // R3: the owner's direct conversation is never gated by the dead-chat send
+    // guard. If it were, the very message explaining why the agent went dark
+    // (skill-update notices, auth/logout notices, group owner-attention
+    // forwards) would be unreachable. Registered lazily — the activation
+    // conversation may be recorded after the client is constructed.
+    client.setOwnerDirectChatResolver(resolveOwnerDirectConversationId);
     const sendOwnerSkillMessage = async (text) => {
         const conversationId = resolveOwnerDirectConversationId();
         if (!conversationId) {
@@ -1996,7 +2055,11 @@ export async function startOpenclawClawlingGateway(params) {
                 // The conversation is gone. Evict it so no further uplink is emitted
                 // for it. Falls through to the awareness branch so the owner is told.
                 const entityId = typeof payload?.entity_id === "string" ? payload.entity_id : "";
-                const evicted = client.markChatDead(entityId);
+                // "signal" tier: this gates typing only. The protocol forbids gating
+                // message.send on a dissolved signal — only a server rejection
+                // (message.error, see src/outbound.ts) may do that, and unlike this
+                // one that rejection expires.
+                const evicted = client.markChatDead(entityId, "signal");
                 log?.info?.(evicted
                     ? `[${accountId}] clawchat-plugin-openclaw conversation.dissolved signal received; evicting ${entityId}`
                     : `[${accountId}] clawchat-plugin-openclaw conversation.dissolved signal received with missing/invalid entity_id; no eviction performed`);
@@ -2018,6 +2081,32 @@ export async function startOpenclawClawlingGateway(params) {
                     log?.error?.(`[${accountId}] clawchat-plugin-openclaw skill-update check failed: ${err instanceof Error ? err.message : String(err)}`);
                 });
             }
+            else if (type === "moment.comment.created" || type === "moment.comment.replied") {
+                // Content-free trigger: the note carries only the scenario + moment id
+                // and points the agent at the get_moment tool — never the comment
+                // text. Not gated behind account.awarenessNote and not debounced:
+                // each moment-comment signal yields its own note (msghub already
+                // coalesces multiple comments on one moment by entity_id).
+                const momentId = typeof payload?.entity_id === "string" ? payload.entity_id : "";
+                // No activation conversation ⇒ no routable chat_id. Skip the note
+                // rather than address it to the owner's usr_… id, which
+                // member-backend rejects as "invalid conversation id" (the agent's
+                // in-turn replies are then dropped with no negative ack). Resolve
+                // this FIRST, mirroring the friend.*/conversation.* awareness
+                // branch's guard below.
+                const ownerConversationId = resolveOwnerDirectConversationId();
+                if (!ownerConversationId) {
+                    log?.info?.(`[${accountId}] clawchat-plugin-openclaw ${type} signal received but no owner conversation resolved; skipping moment awareness note (moment ${momentId})`);
+                    return;
+                }
+                log?.info?.(`[${accountId}] clawchat-plugin-openclaw ${type} signal received; synthesizing moment awareness note (moment ${momentId})`);
+                void handleInboundEnvelope(buildMomentCommentNoteEnvelope({
+                    account,
+                    ownerConversationId,
+                    momentId,
+                    replied: type === "moment.comment.replied",
+                }));
+            }
             else if (type === "friend.added" ||
                 type === "friend.removed" ||
                 type === "friend.profile_updated" ||
@@ -2028,10 +2117,16 @@ export async function startOpenclawClawlingGateway(params) {
                     pendingAwarenessNote = true;
                     queueMicrotask(() => {
                         pendingAwarenessNote = false;
-                        void handleInboundEnvelope(buildAwarenessNoteEnvelope({
-                            account,
-                            ownerConversationId: resolveOwnerDirectConversationId(),
-                        }));
+                        // No activation conversation ⇒ no routable chat_id. Skip the note
+                        // rather than address it to the owner's usr_… id, which
+                        // member-backend rejects as "invalid conversation id" (the agent's
+                        // in-turn replies are then dropped with no negative ack).
+                        const ownerConversationId = resolveOwnerDirectConversationId();
+                        if (!ownerConversationId) {
+                            log?.info?.(`[${accountId}] clawchat-plugin-openclaw awareness note skipped: no activation conversation recorded`);
+                            return;
+                        }
+                        void handleInboundEnvelope(buildAwarenessNoteEnvelope({ account, ownerConversationId }));
                     });
                 }
             }
@@ -2405,6 +2500,10 @@ export async function startOpenclawClawlingGateway(params) {
                         updateMessageByIdentity: (input) => store.updateMessageByIdentity?.(input),
                     }
                     : null,
+                // Group owner-attention escalations address the owner's activation
+                // conversation, not `ownerUserId` (a usr_… chat_id is rejected by
+                // member-backend). Passed as a thunk so it is resolved at send time.
+                resolveOwnerConversationId: resolveOwnerDirectConversationId,
                 log,
             });
             const agentsConfigured = Object.keys(cfg.agents ?? {});
@@ -2658,7 +2757,21 @@ export async function startOpenclawClawlingGateway(params) {
                     // A permission_result receipt closes the loop on an earlier request.
                     // Dedup by request_id; on a fresh receipt feed the synthetic context
                     // note back to the agent so it can react to the outcome.
-                    const note = handlePermissionResult(metadata, account);
+                    //
+                    // The note is addressed to the owner's ACTIVATION CONVERSATION id
+                    // (cnv_…), never `account.ownerUserId`: the agent's in-turn reply
+                    // inherits this chat_id, and member-backend rejects a usr_… with
+                    // "invalid conversation id" — the reply is then dropped server-side
+                    // with no negative ack, so the outcome silently never reaches the
+                    // owner. With no conversation on record the receipt is skipped
+                    // outright (see handlePermissionResult — the dedup slot is preserved
+                    // so a replay after activation still renders).
+                    const ownerConversationId = resolveOwnerDirectConversationId();
+                    if (!ownerConversationId) {
+                        log?.info?.(`[${accountId}] clawchat-plugin-openclaw permission_result receipt op=${metadata.operation} outcome=${metadata.outcome} request_id=${metadata.request_id} skipped: no activation conversation recorded`);
+                        return;
+                    }
+                    const note = handlePermissionResult(metadata, account, ownerConversationId);
                     if (note) {
                         log?.info?.(`[${accountId}] clawchat-plugin-openclaw permission_result receipt op=${metadata.operation} outcome=${metadata.outcome} request_id=${metadata.request_id}; dispatching context note`);
                         void handleInboundEnvelope(note);

package/dist/src/tools-schema.js

@@ -198,6 +198,9 @@ export const ClawchatDeleteMomentSchema = Type.Object({
         description: "Concrete ClawChat moment id to delete",
     }),
 });
+export const ClawchatGetMomentSchema = Type.Object({
+    momentId: Type.Integer({ minimum: 1, description: "Concrete ClawChat moment id to fetch (with its visible comments)" }),
+});
 export const ClawchatToggleMomentReactionSchema = Type.Object({
     momentId: Type.Integer({
         minimum: 1,

package/dist/src/tools.js

@@ -12,7 +12,7 @@ import { getOpenclawClawlingClient, } from "./runtime.js";
 import { markTerminalClawChatSend, getCurrentTerminalSendScope } from "./terminal-send.js";
 import { editClawChatMemoryBody, readClawChatMemoryFile, resolveClawChatMemoryPath, searchClawChatMemory, writeClawChatMemoryBody, } from "./clawchat-memory.js";
 import { pullGroupMetadata, pullOwnerMetadata, pullUserMetadata, pushMetadata, updateMetadata, } from "./clawchat-metadata.js";
-import { ClawchatGetAccountProfileSchema, ClawchatGetConversationSchema, ClawchatGetUserProfileSchema, ClawchatLeaveGroupSchema, ClawchatAcceptFriendRequestSchema, ClawchatMemoryEditSchema, ClawchatMemoryReadSchema, ClawchatMemorySearchSchema, ClawchatMemoryWriteSchema, ClawchatMetadataSyncSchema, ClawchatMetadataUpdateSchema, ClawchatCreateMomentCommentSchema, ClawchatCreateMomentSchema, ClawchatDeleteMomentCommentSchema, ClawchatDeleteMomentSchema, ClawchatListAccountFriendsSchema, ClawchatListFriendRequestsSchema, ClawchatListMomentsSchema, ClawchatMentionMessageSchema, ClawchatReactMessageSchema, ClawchatReplyMomentCommentSchema, ClawchatRejectFriendRequestSchema, ClawchatRemoveFriendSchema, ClawchatSearchUsersSchema, ClawchatSendFriendRequestSchema, ClawchatToggleMomentReactionSchema, ClawchatUpdateAccountProfileSchema, ClawchatUploadAvatarImageSchema, ClawchatRegisterAppSchema, ClawchatListAppsSchema, ClawchatUnregisterAppSchema, ClawchatLivewareLoginSchema, } from "./tools-schema.js";
+import { ClawchatGetAccountProfileSchema, ClawchatGetConversationSchema, ClawchatGetMomentSchema, ClawchatGetUserProfileSchema, ClawchatLeaveGroupSchema, ClawchatAcceptFriendRequestSchema, ClawchatMemoryEditSchema, ClawchatMemoryReadSchema, ClawchatMemorySearchSchema, ClawchatMemoryWriteSchema, ClawchatMetadataSyncSchema, ClawchatMetadataUpdateSchema, ClawchatCreateMomentCommentSchema, ClawchatCreateMomentSchema, ClawchatDeleteMomentCommentSchema, ClawchatDeleteMomentSchema, ClawchatListAccountFriendsSchema, ClawchatListFriendRequestsSchema, ClawchatListMomentsSchema, ClawchatMentionMessageSchema, ClawchatReactMessageSchema, ClawchatReplyMomentCommentSchema, ClawchatRejectFriendRequestSchema, ClawchatRemoveFriendSchema, ClawchatSearchUsersSchema, ClawchatSendFriendRequestSchema, ClawchatToggleMomentReactionSchema, ClawchatUpdateAccountProfileSchema, ClawchatUploadAvatarImageSchema, ClawchatRegisterAppSchema, ClawchatListAppsSchema, ClawchatUnregisterAppSchema, ClawchatLivewareLoginSchema, } from "./tools-schema.js";
 const MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
 // Owner-approval gate business codes (must match the ClawChat backend's owner-approval codes).
 const CODE_PENDING_APPROVAL = 21001;
@@ -935,6 +935,18 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             });
         },
     }, { name: "clawchat_list_moments" });
+    api.registerTool({
+        name: "clawchat_get_moment",
+        label: "Get ClawChat Moment",
+        description: toolDescription("Fetch a single ClawChat moment by id together with the comments visible to this agent. TRIGGER - after a moment.comment.created / moment.comment.replied awareness note, call this with the moment id to read the new comment before deciding whether to reply."),
+        parameters: ClawchatGetMomentSchema,
+        async execute(_callId, params) {
+            return await recordClawchatToolCall("clawchat_get_moment", params, async () => {
+                const p = (params ?? {});
+                return await withClient((c) => c.getMoment(p.momentId));
+            });
+        },
+    }, { name: "clawchat_get_moment" });
     api.registerTool({
         name: "clawchat_create_moment",
         label: "Create ClawChat Moment",
@@ -1196,5 +1208,5 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             });
         },
     }, { name: "clawchat_liveware_login" });
-    api.logger.debug?.("clawchat-plugin-openclaw: registered 30 clawchat_* tools (get_account_profile, get_user_profile, list_account_friends, send_friend_request, list_friend_requests, accept_friend_request, reject_friend_request, remove_friend, search_users, get_conversation, mention_message, list_moments, create_moment, delete_moment, toggle_moment_reaction, create_moment_comment, reply_moment_comment, delete_moment_comment, update_account_profile, upload_avatar_image, memory_search, memory_read, memory_write, memory_edit, metadata_sync, metadata_update, register_app, list_apps, unregister_app, liveware_login)");
+    api.logger.debug?.("clawchat-plugin-openclaw: registered 31 clawchat_* tools (get_account_profile, get_user_profile, list_account_friends, send_friend_request, list_friend_requests, accept_friend_request, reject_friend_request, remove_friend, search_users, get_conversation, mention_message, list_moments, get_moment, create_moment, delete_moment, toggle_moment_reaction, create_moment_comment, reply_moment_comment, delete_moment_comment, update_account_profile, upload_avatar_image, memory_search, memory_read, memory_write, memory_edit, metadata_sync, metadata_update, register_app, list_apps, unregister_app, liveware_login)");
 }

package/dist/src/ws-alignment.js

@@ -40,9 +40,26 @@ export function createAlignedWsQueue(options) {
             queue.push(item);
             logFrame("send_queued", "queue", item, [["queue_size", queue.length]]);
         },
-        flush(write) {
+        /**
+         * Drain the queue. `isBlocked` is consulted PER ITEM at write time, not at
+         * enqueue time: a conversation can be rejected by the server *after* a
+         * frame was queued, and this replay path never re-enters the send function
+         * that guards the live path. Without this hook the outbound gate is
+         * bypassable by any reconnect (and by any batch flush that happens to carry
+         * a live chat's frame).
+         */
+        flush(write, options = {}) {
             while (queue.length > 0) {
                 const item = queue[0];
+                if (options.isBlocked?.(item)) {
+                    queue.shift();
+                    logFrame("send_blocked", "drop", item, [
+                        ["reason", "chat_rejected_by_server"],
+                        ["remaining", queue.length],
+                    ]);
+                    item.onBlock?.();
+                    continue;
+                }
                 try {
                     write(item.wire);
                     queue.shift();