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

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" ||

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();

package/dist/src/ws-client.js

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import { AckTimeoutError, AuthError, EVENT, MessageSendError, ProtocolError, StateError, TransportError, isBusinessDispatchEvent, } from "./protocol-types.js";
+import { AckTimeoutError, AuthError, EVENT, MessageSendError, ProtocolError, StateError, TERMINAL_CHAT_CODES, TransportError, isBusinessDispatchEvent, } from "./protocol-types.js";
 export function createWebSocketTransport(WebSocketCtor = globalThis.WebSocket) {
     let currentState = "closed";
     let socket;
@@ -103,6 +103,45 @@ export function buildConnectCapabilities() {
 }
 /** Bounded FIFO of conversations known to be dissolved. */
 export const DEAD_CHATS_MAX = 512;
+/**
+ * How long a server rejection keeps gating uplinks for a conversation.
+ *
+ * A rejection is a fact with a shelf life, NOT a permanent verdict: the server
+ * soft-deletes conversations and can revive one in place under the SAME `cnv_`
+ * id — which is exactly the path an agent takes when it is re-paired. A
+ * permanent mark would leave a re-paired agent silently mute forever.
+ *
+ * 10 minutes: an order of magnitude above the server's own 30s negative cache
+ * for unresolvable chats (so a post-TTL retry lands after the server has
+ * re-resolved rather than on a stale negative entry), while still bounding the
+ * waste to at most one frame per dead conversation per 10 minutes. Two faster
+ * clears (`noteChatAlive`) handle the common cases; this is only the backstop.
+ *
+ * MUST stay identical to the hermes plugin's value — cross-plugin parity is
+ * pinned by src/parity.test.ts.
+ */
+export const SERVER_REJECTION_TTL_MS = 600_000;
+/**
+ * Every ClawChat conversation id is minted by member-backend with this prefix,
+ * and msghub resolves a chat_id only through member-backend. Anything else — a
+ * `usr_…` user idcode, a host-composed `direct:{self}:{peer}` key, a bare
+ * adapter name, a placeholder — is refused upstream with
+ * `code=400: invalid conversation id`.
+ *
+ * MUST stay identical to the hermes plugin's `CHAT_ID_PREFIX`.
+ */
+export const CHAT_ID_PREFIX = "cnv_";
+/**
+ * Whether `chatId` can name a ClawChat conversation at all.
+ *
+ * A purely *static* check: it says nothing about whether the conversation
+ * exists, is alive, or admits this sender. Those are server-side questions
+ * answered by `message.error`; this one is answerable locally, and a frame that
+ * fails it is always wrong to put on the wire.
+ */
+export function isValidChatId(chatId) {
+    return typeof chatId === "string" && chatId.startsWith(CHAT_ID_PREFIX);
+}
 export class ClawChatClient extends EventEmitter {
     opts;
     currentState = "idle";
@@ -118,7 +157,12 @@ export class ClawChatClient extends EventEmitter {
     pending = new Map();
     handledMessageErrorTraces = new Set();
     sendQueue = [];
-    deadChats = new Set();
+    // Tier 1 — inferred from `conversation.dissolved`. Gates typing only.
+    dissolvedBySignal = new Set();
+    // Tier 2 — server-CONFIRMED rejection → expiry timestamp. Gates sends.
+    // Disjoint storage from tier 1: neither write path touches the other set.
+    serverRejectedChats = new Map();
+    ownerDirectChatResolver;
     constructor(opts) {
         super();
         this.opts = opts;
@@ -160,39 +204,131 @@ export class ClawChatClient extends EventEmitter {
         this.opts.transport.close(1000, "client close");
     }
     /**
-     * Record a conversation as dissolved so no further uplink is sent for it.
+     * Record a conversation as dead so no further uplink is sent for it.
      * Only `cnv_`-prefixed ids are accepted: a bad entity_id must never mute a
      * live conversation. Returns whether the id was accepted (and thus actually
-     * evicted) so callers can log/act on rejection distinctly from acceptance.
+     * recorded) so callers can log/act on rejection distinctly from acceptance.
      *
-     * Eviction is FIFO by first-mark order, not LRU: `Set` iteration order is
-     * insertion order, and the `has()` early-return above means re-marking an
-     * already-dead id does NOT refresh its position. A chat marked dead long ago
-     * is evicted from the set before one marked dead a moment ago, even if the
-     * former has been re-signaled dissolved more recently.
+     * `source` selects WHICH STORE is written — see {@link DeadChatSource}. The
+     * two stores are disjoint; a signal never writes the server tier and a server
+     * rejection never writes the signal tier.
+     *
+     * Signal tier eviction is FIFO by first-mark order, not LRU: `Set` iteration
+     * order is insertion order and the `has()` early-return means re-marking does
+     * NOT refresh position. The server tier deliberately does the opposite — a
+     * re-rejection re-arms the TTL *and* moves the id to the tail — because its
+     * whole point is "how long since the server last said no".
      */
-    markChatDead(chatId) {
-        if (typeof chatId !== "string" || !chatId.startsWith("cnv_"))
+    markChatDead(chatId, source = "signal") {
+        if (!isValidChatId(chatId))
             return false;
-        if (this.deadChats.has(chatId))
+        if (source === "server") {
+            // Delete-then-set so the re-insert also moves the id to the FIFO tail.
+            this.serverRejectedChats.delete(chatId);
+            this.serverRejectedChats.set(chatId, this.opts.now() + SERVER_REJECTION_TTL_MS);
+            while (this.serverRejectedChats.size > DEAD_CHATS_MAX) {
+                const oldest = this.serverRejectedChats.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                this.serverRejectedChats.delete(oldest);
+            }
+            return true;
+        }
+        if (this.dissolvedBySignal.has(chatId))
             return true;
-        this.deadChats.add(chatId);
-        while (this.deadChats.size > DEAD_CHATS_MAX) {
-            const oldest = this.deadChats.values().next().value;
+        this.dissolvedBySignal.add(chatId);
+        while (this.dissolvedBySignal.size > DEAD_CHATS_MAX) {
+            const oldest = this.dissolvedBySignal.values().next().value;
             if (oldest === undefined)
                 break;
-            this.deadChats.delete(oldest);
+            this.dissolvedBySignal.delete(oldest);
         }
         return true;
     }
+    /**
+     * True for a chat dead by EITHER tier — a derived union, not a third store.
+     * Gates `typing.update` only. Never gate message delivery on this.
+     */
     isChatDead(chatId) {
-        return this.deadChats.has(chatId);
+        return this.dissolvedBySignal.has(chatId) || this.isChatRejectedByServer(chatId);
+    }
+    /**
+     * True only for a chat the SERVER rejected with a terminal code, and only
+     * while that rejection is still fresh. Expiry is lazy: the entry is dropped
+     * on the first read past its deadline, so there is no timer to leak.
+     */
+    isChatRejectedByServer(chatId) {
+        const expiresAt = this.serverRejectedChats.get(chatId);
+        if (expiresAt === undefined)
+            return false;
+        if (this.opts.now() >= expiresAt) {
+            this.serverRejectedChats.delete(chatId);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * The ONLY predicate allowed to gate an outbound `message.send` /
+     * `message.reply` / `message.reaction`. Narrower than `isChatRejectedByServer`
+     * by one exemption: the owner's direct conversation is never blocked, because
+     * it is the only channel through which the agent can explain why it went
+     * dark. The rejection is still RECORDED for the owner chat — the exemption
+     * decides whether to send, not whether to remember.
+     */
+    isSendBlocked(chatId) {
+        if (!this.isChatRejectedByServer(chatId))
+            return false;
+        const ownerChatId = this.ownerDirectChatResolver?.();
+        return !(ownerChatId && ownerChatId === chatId);
+    }
+    /** Injected by the runtime once the owner's direct conversation is known. */
+    setOwnerDirectChatResolver(resolver) {
+        this.ownerDirectChatResolver = resolver;
+    }
+    /**
+     * Evidence that a conversation is reachable again — drop any server-rejection
+     * record for it. Called from the inbound path; see `dispatchInbound`.
+     *
+     * Only the SERVER tier is cleared. The signal tier is deliberately left
+     * alone: `conversation.dissolved` gates nothing but the cosmetic typing
+     * indicator, and un-muting it on a replayed frame would be churn with no
+     * user-visible benefit.
+     */
+    noteChatAlive(chatId) {
+        if (typeof chatId !== "string" || !chatId)
+            return;
+        this.serverRejectedChats.delete(chatId);
+    }
+    /**
+     * `conversation.*` signals other than `dissolved` mean the server still has
+     * this conversation (created / updated / membership changed) — clear any
+     * stale rejection. `conversation.dissolved` is the opposite signal and must
+     * not clear anything.
+     */
+    noteConversationSignalAlive(env) {
+        const payload = env.payload && typeof env.payload === "object"
+            ? env.payload
+            : undefined;
+        const type = typeof payload?.type === "string" ? payload.type : "";
+        if (!type.startsWith("conversation.") || type === "conversation.dissolved")
+            return;
+        const entityId = typeof payload?.entity_id === "string" ? payload.entity_id : "";
+        if (entityId)
+            this.noteChatAlive(entityId);
     }
     /**
-     * The ONLY dead-chat guard in this client. `sendAckableEnvelope` (backing
-     * `message.send` / `message.reply`) is deliberately left unguarded: a
-     * false-positive dead-mark must never block message delivery, only the
-     * cosmetic `typing.update` indicator. Do not extend the guard there.
+     * Gated on `isChatDead` — BOTH tiers. `sendAckableEnvelope` (backing
+     * `message.send` / `message.reply`) is deliberately left unguarded against
+     * this predicate: a false-positive SIGNAL-derived dead-mark must never block
+     * message delivery, only the cosmetic `typing.update` indicator. The
+     * protocol states this explicitly for `conversation.dissolved` — "agents …
+     * stop sending typing.update for that chat_id; message.send MUST NOT be
+     * gated on this". Do not extend `isChatDead` to the send path.
+     *
+     * The send path IS gated, but on the narrower `isSendBlocked` (see
+     * src/outbound.ts) — a chat the server itself rejected is fact, not
+     * inference, so the false-positive argument above does not apply to it.
+     * That fact expires; this one does not.
      */
     typing(chatId, isTyping = true) {
         if (this.isChatDead(chatId))
@@ -227,10 +363,27 @@ export class ClawChatClient extends EventEmitter {
         this.opts.transport.send(wire);
     }
     sendRawEnvelope(env) {
+        // Static addressing check. A frame carrying a chat_id that cannot name a
+        // conversation is refused by msghub with `invalid conversation id`, so it
+        // never had a recipient; dropping it here costs the caller nothing and
+        // keeps the error out of msghub's logs.
+        //
+        // Unlike the dead-chat gate — a revocable server state a queued frame can
+        // fall into, which is why `shouldDropQueuedWire` re-checks on replay — a
+        // malformed chat_id is wrong at construction time and can never become
+        // valid. Rejecting at this entry point is therefore sufficient: the frame
+        // never reaches the reconnect queue, so no replay path can resurrect it.
+        //
+        // Frames with no chat_id (connect / ping / pong) are untouched.
+        if (env.chat_id !== undefined && !isValidChatId(env.chat_id))
+            return;
         this.sendWire(JSON.stringify(env), { bypassReconnectQueue: env.event === EVENT.CONNECT });
     }
-    // Deliberately does NOT consult `deadChats` — see the comment on `typing()`.
-    // Message delivery must never be gated by the dead-chat guard.
+    // Deliberately does NOT consult the dead-chat state — see the comment on
+    // `typing()`. Signal-inferred death must never gate message delivery. (The
+    // narrower `isSendBlocked` gate lives on the aligned path in src/outbound.ts,
+    // which is what the reply dispatcher actually uses; this legacy ackable path
+    // is kept ungated so the two tiers stay distinguishable.)
     async sendAckableEnvelope(params) {
         const traceId = this.nextTraceId();
         const env = {
@@ -332,6 +485,13 @@ export class ClawChatClient extends EventEmitter {
         this.dispatchInbound(env);
     }
     dispatchInbound(env) {
+        // A frame the server routed to us for this chat proves the chat is
+        // reachable again — a deleted conversation can be revived in place under
+        // the same id. `message.error` is excluded: it IS the rejection, not
+        // evidence of life.
+        if (typeof env.chat_id === "string" && env.event !== EVENT.MESSAGE_ERROR) {
+            this.noteChatAlive(env.chat_id);
+        }
         if (env.event === EVENT.CONNECT_CHALLENGE)
             return this.onChallenge(env);
         if (env.event === EVENT.HELLO_OK)
@@ -360,6 +520,8 @@ export class ClawChatClient extends EventEmitter {
             this.emit("typing", env);
         if (env.event === EVENT.CHAT_METADATA_INVALIDATED)
             this.emit("metadata:invalidated", env);
+        if (env.event === EVENT.NOTIFY_SIGNAL)
+            this.noteConversationSignalAlive(env);
         if (env.event === EVENT.NOTIFY_SIGNAL)
             this.emit("notify:signal", env);
         if (env.event === EVENT.REPLAY_DONE)
@@ -510,6 +672,20 @@ export class ClawChatClient extends EventEmitter {
         entry.resolve(env);
     }
     onMessageError(env) {
+        const payload = env.payload && typeof env.payload === "object"
+            ? env.payload
+            : undefined;
+        const code = typeof payload?.code === "string" && payload.code ? payload.code : "unknown";
+        // Mark BEFORE the pending-ack lookup: an unmatched error frame still
+        // carries an authoritative `chat_id` + `code` and must participate in the
+        // dead-chat decision. Unmatched is the NORMAL case here — the aligned queue
+        // owns its own ack matching (markMessageErrorHandled makes the branch below
+        // return silently) and a reconnect drops pending entries. Deferring the
+        // mark until after the lookup would make tier-2 feeding random.
+        // Parity: hermes notifies its dead-chat state at the same point.
+        if (typeof env.chat_id === "string" && TERMINAL_CHAT_CODES.has(code)) {
+            this.markChatDead(env.chat_id, "server");
+        }
         const entry = this.pending.get(env.trace_id);
         if (!entry) {
             if (this.handledMessageErrorTraces.delete(env.trace_id))
@@ -519,10 +695,6 @@ export class ClawChatClient extends EventEmitter {
         }
         clearTimeout(entry.timer);
         this.pending.delete(env.trace_id);
-        const payload = env.payload && typeof env.payload === "object"
-            ? env.payload
-            : undefined;
-        const code = typeof payload?.code === "string" && payload.code ? payload.code : "unknown";
         // §14.3: the human-readable hint is `reason` (fall back to legacy `message`).
         const hint = typeof payload?.reason === "string" && payload.reason
             ? payload.reason
@@ -644,14 +816,22 @@ export class ClawChatClient extends EventEmitter {
     }
     flushSendQueue() {
         while (this.sendQueue.length > 0) {
-            const wire = this.sendQueue.shift();
-            try {
-                this.sendWire(wire);
-            }
-            catch (err) {
-                this.sendQueue.unshift(wire);
-                throw err;
+            const wire = this.sendQueue[0];
+            // Re-check the dead-chat gates at replay time: a conversation can be
+            // rejected AFTER a frame was buffered here, and this path bypasses every
+            // caller-side guard.
+            if (shouldDropQueuedWire(wire, {
+                isChatDead: (chatId) => this.isChatDead(chatId),
+                isSendBlocked: (chatId) => this.isSendBlocked(chatId),
+            })) {
+                this.sendQueue.shift();
+                continue;
             }
+            // Read the head first and shift only after a successful write, so a
+            // failure leaves the frame at the head (same as the previous
+            // shift/unshift pair; `onHelloOk`'s catch closes and reconnects).
+            this.sendWire(wire);
+            this.sendQueue.shift();
         }
     }
     isHandshaking() {
@@ -667,6 +847,37 @@ export class ClawChatClient extends EventEmitter {
         return null;
     }
 }
+/**
+ * Decide whether a wire string sitting in the transport-level reconnect queue
+ * must be dropped instead of replayed.
+ *
+ * This queue holds ALREADY-SERIALIZED frames, so the only way to see the
+ * `chat_id` is to parse. That is acceptable here and nowhere else: the queue
+ * fills only during a reconnect window and is drained exactly once per
+ * successful handshake — unlike `sendWire`, which is the hot path.
+ *
+ * Asymmetry mirrors the live path: `typing.update` is gated on EITHER tier
+ * (`isChatDead`), everything else only on a server-confirmed, non-owner
+ * rejection (`isSendBlocked`). Unparseable or chat-less frames are always kept:
+ * `connect` / `ping` / `pong` must never be dropped.
+ *
+ * Exported for direct unit testing; `flushSendQueue` is the only producer.
+ */
+export function shouldDropQueuedWire(wire, gates) {
+    let env;
+    try {
+        env = JSON.parse(wire);
+    }
+    catch {
+        return false;
+    }
+    const chatId = typeof env.chat_id === "string" ? env.chat_id : "";
+    if (!chatId)
+        return false;
+    if (env.event === EVENT.TYPING_UPDATE)
+        return gates.isChatDead(chatId);
+    return gates.isSendBlocked(chatId);
+}
 export function createClawChatClient(options) {
     return new ClawChatClient({
         ...options,
@@ -689,5 +900,6 @@ export function createClawChatClient(options) {
             timeout: options.ack?.timeout ?? 15000,
             autoResendOnTimeout: options.ack?.autoResendOnTimeout ?? false,
         },
+        now: options.now ?? (() => Date.now()),
     });
 }

package/openclaw.plugin.json

@@ -48,6 +48,7 @@
       "clawchat_get_conversation",
       "clawchat_leave_group",
       "clawchat_list_moments",
+      "clawchat_get_moment",
       "clawchat_create_moment",
       "clawchat_delete_moment",
       "clawchat_toggle_moment_reaction",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.7.29-3",
+  "version": "2026.8.2-1",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",