@clawling/clawchat-plugin-openclaw 2026.7.23-1 → 2026.7.26-1

package/dist/src/channel.setup.js

@@ -79,7 +79,7 @@ export const openclawClawlingSetupPlugin = {
     capabilities: {
         chatTypes: ["direct", "group"],
         media: true,
-        reactions: false,
+        reactions: true,
         threads: false,
         polls: false,
         blockStreaming: true,

package/dist/src/login.runtime.js

@@ -14,6 +14,13 @@ export const AGENTS_CONNECT_PLATFORM = "openclaw";
  * always a bot; humans don't log in through this flow.
  */
 export const AGENTS_CONNECT_TYPE = "clawbot";
+/**
+ * `/v1/agents/connect` envelope code for "the supplied user_id matches no
+ * agent". Servers that predate the server-side stale-user_id fallback return
+ * this instead of degrading to a fresh pairing, so the client sheds the id and
+ * retries once.
+ */
+export const AGENT_NOT_FOUND_CODE = 16001;
 /**
  * Prompt the operator for an invite code.
  *
@@ -140,8 +147,8 @@ export async function runOpenclawClawlingLogin(params) {
     });
     runtime.log("Verifying invite code …");
     let result;
+    const existingUserId = account.userId.trim();
     try {
-        const existingUserId = account.userId.trim();
         result = await apiClient.agentsConnect({
             code: inviteCode,
             platform: AGENTS_CONNECT_PLATFORM,
@@ -151,9 +158,37 @@ export async function runOpenclawClawlingLogin(params) {
     }
     catch (err) {
         if (err instanceof ClawlingApiError) {
-            throw new Error(`agents/connect failed (${err.kind}): ${err.message}`);
+            // The stored userId is a re-pair hint, not a credential — the invite
+            // code alone decides ownership. AGENT_NOT_FOUND means it names an agent
+            // this server has never had (owner account deleted, or the config was
+            // repointed at another deployment), so replaying it would fail
+            // identically for every future invite code. A 16001 leaves the code
+            // `pending` server-side, so shedding the id and retrying once cannot
+            // double-spend it. Nothing else is retried: an owner mismatch is a real
+            // rejection, and a request that sent no id has no stale state to shed.
+            if (existingUserId && err.meta?.code === AGENT_NOT_FOUND_CODE) {
+                runtime.log(`Stored userId ${existingUserId} no longer exists on this server — retrying as a fresh pairing …`);
+                try {
+                    result = await apiClient.agentsConnect({
+                        code: inviteCode,
+                        platform: AGENTS_CONNECT_PLATFORM,
+                        type: AGENTS_CONNECT_TYPE,
+                    });
+                }
+                catch (retryErr) {
+                    if (retryErr instanceof ClawlingApiError) {
+                        throw new Error(`agents/connect failed (${retryErr.kind}): ${retryErr.message}`);
+                    }
+                    throw retryErr;
+                }
+            }
+            else {
+                throw new Error(`agents/connect failed (${err.kind}): ${err.message}`);
+            }
+        }
+        else {
+            throw err;
         }
-        throw err;
     }
     const accessToken = requireConnectString(result?.access_token, "access_token");
     const agentUserId = requireConnectString(result?.agent?.user_id, "agent.user_id");

package/dist/src/outbound.js

@@ -1,5 +1,5 @@
 import { randomInt } from "node:crypto";
-import { MessageSendError } from "./protocol-types.js";
+import { EVENT, MessageSendError } from "./protocol-types.js";
 import { createAttachedChannelResultAdapter, } from "openclaw/plugin-sdk/channel-send-result";
 import { chunkMarkdownText } from "openclaw/plugin-sdk/reply-runtime";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
@@ -485,6 +485,28 @@ export async function sendOpenclawClawlingMedia(params) {
         ...(params.log ? { log: params.log } : {}),
     });
 }
+/**
+ * Emit a Protocol-v2 `message.reaction`. Fire-and-forget: reactions are NOT
+ * ack-aligned (the server mints the slot-key message_id, so the ack-by-trace_id
+ * path used for message.send/reply does not apply). Matches the mobile client.
+ */
+export function sendOpenclawClawlingReaction(params) {
+    const payload = {
+        target_message_id: params.targetMessageId,
+        emoji: params.emoji,
+        removed: params.removed,
+    };
+    const env = {
+        version: "2",
+        event: EVENT.MESSAGE_REACTION,
+        trace_id: params.client.nextTraceId(),
+        emitted_at: Date.now(),
+        chat_id: params.chatId,
+        payload,
+    };
+    params.client.sendWire(JSON.stringify(env));
+    params.log?.info?.(`clawchat reaction sent chat_id=${params.chatId} target=${params.targetMessageId} emoji=${params.emoji} removed=${params.removed}`);
+}
 // Crockford base32 alphabet (ULID spec).
 const ULID_ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 /**

package/dist/src/protocol-types.js

@@ -7,6 +7,7 @@ export const EVENT = {
     MESSAGE_ACK: "message.ack",
     MESSAGE_ERROR: "message.error",
     MESSAGE_REPLY: "message.reply",
+    MESSAGE_REACTION: "message.reaction",
     MESSAGE_CREATED: "message.created",
     MESSAGE_ADD: "message.add",
     MESSAGE_DONE: "message.done",

package/dist/src/runtime.js

@@ -1992,6 +1992,15 @@ export async function startOpenclawClawlingGateway(params) {
                 ? env.payload
                 : undefined;
             const type = typeof payload?.type === "string" ? payload.type : "";
+            if (type === "conversation.dissolved") {
+                // 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);
+                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`);
+            }
             if (type === "agent.config.changed") {
                 log?.info?.(`[${accountId}] clawchat-plugin-openclaw agent.config.changed signal received; re-pulling group settings`);
                 pullGroupSettings();

package/dist/src/terminal-send.js

@@ -34,3 +34,20 @@ export function consumeTerminalClawChatSend(params) {
 export function clearTerminalClawChatSendsForTest() {
     terminalSends.clear();
 }
+/**
+ * Read the current turn's ambient send scope (accountId\0chatId\0messageId).
+ * Returns null when not inside a dispatch scope, or when the scope id is not
+ * the tripartite form (e.g. a test-only opaque scope id).
+ */
+export function getCurrentTerminalSendScope() {
+    const store = terminalSendScope.getStore();
+    if (!store)
+        return null;
+    const parts = store.split("\0");
+    if (parts.length !== 3)
+        return null;
+    const [accountId, chatId, messageId] = parts;
+    if (!accountId || !chatId || !messageId)
+        return null;
+    return { accountId, chatId, messageId };
+}

package/dist/src/tools-schema.js

@@ -156,6 +156,23 @@ export const ClawchatMentionMessageSchema = Type.Object({
         description: "Optional ClawChat message id to reply to.",
     })),
 });
+export const ClawchatReactMessageSchema = Type.Object({
+    emoji: Type.String({
+        minLength: 1,
+        description: "A single emoji to react with. Prefer the ClawChat quick set 👍 ❤️ 😂 😮 😢 🙏 🎉 👏 🔥 😍 🤔 so it renders in the client's quick-reaction row.",
+    }),
+    targetMessageId: Type.Optional(Type.String({
+        minLength: 1,
+        description: "ClawChat message id to react to. Omit to react to the message that triggered the current turn.",
+    })),
+    chatId: Type.Optional(Type.String({
+        minLength: 1,
+        description: "ClawChat conversation id. Omit to use the current turn's chat.",
+    })),
+    remove: Type.Optional(Type.Boolean({
+        description: "Set true to remove your existing reaction on the target message. Omit or false to add/overwrite.",
+    })),
+});
 export const ClawchatListMomentsSchema = Type.Object({
     before: Type.Optional(Type.Integer({
         minimum: 1,

package/dist/src/tools.js

@@ -7,12 +7,12 @@ import { ClawlingApiError, } from "./api-types.js";
 import { mapGateOutcome } from "./gate-outcome.js";
 import { resolveOpenclawClawlingAccount } from "./config.js";
 import { clawChatDbPathForStateDir, getClawChatStore, makeOwnerProfilePersister, } from "./storage.js";
-import { sendOpenclawClawlingMentionMessage } from "./outbound.js";
+import { sendOpenclawClawlingMentionMessage, sendOpenclawClawlingReaction } from "./outbound.js";
 import { getOpenclawClawlingClient, } from "./runtime.js";
-import { markTerminalClawChatSend } from "./terminal-send.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, ClawchatReplyMomentCommentSchema, ClawchatRejectFriendRequestSchema, ClawchatRemoveFriendSchema, ClawchatSearchUsersSchema, ClawchatSendFriendRequestSchema, ClawchatToggleMomentReactionSchema, ClawchatUpdateAccountProfileSchema, ClawchatUploadAvatarImageSchema, ClawchatRegisterAppSchema, ClawchatListAppsSchema, ClawchatUnregisterAppSchema, ClawchatLivewareLoginSchema, } from "./tools-schema.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";
 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;
@@ -873,6 +873,51 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             });
         },
     }, { name: "clawchat_mention_message" });
+    api.registerTool({
+        name: "clawchat_react_message",
+        label: "React to ClawChat Message",
+        description: toolDescription("React to a ClawChat message with a single quick emoji (the bubble long-press reaction), instead of sending a text message. " +
+            "TRIGGER - invoke when a short acknowledgement or emotional beat (agreement, thanks, laughter, celebration, sympathy) reads more naturally as an emoji on the message than as a sentence, e.g. a simple 👍 to \"done\" or ❤️ to good news. " +
+            "Omit targetMessageId and chatId to react to the message that triggered the current turn; pass targetMessageId to react to an earlier message. " +
+            "Set remove:true to take back your reaction. " +
+            "Prefer the quick set 👍 ❤️ 😂 😮 😢 🙏 🎉 👏 🔥 😍 🤔. " +
+            "When a reaction is all you want to send, do not also send a normal text reply."),
+        parameters: ClawchatReactMessageSchema,
+        async execute(_callId, params) {
+            return await recordClawchatToolCall("clawchat_react_message", params, async () => {
+                const p = params;
+                if (!p.emoji?.trim()) {
+                    return validationError("clawchat-plugin-openclaw: emoji is required");
+                }
+                const account = resolveCurrent();
+                if (!account.configured) {
+                    return configError("clawchat-plugin-openclaw: account is not configured");
+                }
+                const scope = getCurrentTerminalSendScope();
+                const chatId = p.chatId?.trim() || scope?.chatId;
+                const targetMessageId = p.targetMessageId?.trim() || scope?.messageId;
+                if (!chatId) {
+                    return validationError("clawchat-plugin-openclaw: chatId is required (no current-turn chat to default from)");
+                }
+                if (!targetMessageId) {
+                    return validationError("clawchat-plugin-openclaw: targetMessageId is required (no current-turn message to default from)");
+                }
+                const client = getOpenclawClawlingClient(account.accountId);
+                if (!client) {
+                    return configError("ClawChat websocket client is not ready");
+                }
+                const emoji = p.emoji.trim();
+                const removed = p.remove === true;
+                try {
+                    sendOpenclawClawlingReaction({ client, chatId, targetMessageId, emoji, removed, log: api.logger });
+                    return jsonResponse({ reacted: true, targetMessageId, emoji, removed });
+                }
+                catch (err) {
+                    return genericError(err);
+                }
+            });
+        },
+    }, { name: "clawchat_react_message" });
     api.registerTool({
         name: "clawchat_list_moments",
         label: "List ClawChat Moments",

package/dist/src/ws-client.js

@@ -101,6 +101,8 @@ export function buildConnectCapabilities() {
         permission_events: true,
     };
 }
+/** Bounded FIFO of conversations known to be dissolved. */
+export const DEAD_CHATS_MAX = 512;
 export class ClawChatClient extends EventEmitter {
     opts;
     currentState = "idle";
@@ -116,6 +118,7 @@ export class ClawChatClient extends EventEmitter {
     pending = new Map();
     handledMessageErrorTraces = new Set();
     sendQueue = [];
+    deadChats = new Set();
     constructor(opts) {
         super();
         this.opts = opts;
@@ -156,7 +159,44 @@ 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.
+     * 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.
+     *
+     * 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.
+     */
+    markChatDead(chatId) {
+        if (typeof chatId !== "string" || !chatId.startsWith("cnv_"))
+            return false;
+        if (this.deadChats.has(chatId))
+            return true;
+        this.deadChats.add(chatId);
+        while (this.deadChats.size > DEAD_CHATS_MAX) {
+            const oldest = this.deadChats.values().next().value;
+            if (oldest === undefined)
+                break;
+            this.deadChats.delete(oldest);
+        }
+        return true;
+    }
+    isChatDead(chatId) {
+        return this.deadChats.has(chatId);
+    }
+    /**
+     * 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.
+     */
     typing(chatId, isTyping = true) {
+        if (this.isChatDead(chatId))
+            return;
         this.sendRawEnvelope({
             version: "2",
             event: EVENT.TYPING_UPDATE,
@@ -189,6 +229,8 @@ export class ClawChatClient extends EventEmitter {
     sendRawEnvelope(env) {
         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.
     async sendAckableEnvelope(params) {
         const traceId = this.nextTraceId();
         const env = {

package/openclaw.plugin.json

@@ -44,6 +44,7 @@
       "clawchat_remove_friend",
       "clawchat_search_users",
       "clawchat_mention_message",
+      "clawchat_react_message",
       "clawchat_get_conversation",
       "clawchat_leave_group",
       "clawchat_list_moments",

package/package.json

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

package/src/channel.setup.ts

@@ -106,7 +106,7 @@ export const openclawClawlingSetupPlugin: OpenclawClawlingSetupPlugin = {
   capabilities: {
     chatTypes: ["direct", "group"],
     media: true,
-    reactions: false,
+    reactions: true,
     threads: false,
     polls: false,
     blockStreaming: true,

package/src/login.runtime.ts

@@ -21,6 +21,13 @@ export const AGENTS_CONNECT_PLATFORM = "openclaw" as const;
  * always a bot; humans don't log in through this flow.
  */
 export const AGENTS_CONNECT_TYPE = "clawbot" as const;
+/**
+ * `/v1/agents/connect` envelope code for "the supplied user_id matches no
+ * agent". Servers that predate the server-side stale-user_id fallback return
+ * this instead of degrading to a fresh pairing, so the client sheds the id and
+ * retries once.
+ */
+export const AGENT_NOT_FOUND_CODE = 16001 as const;
 
 export type OpenclawClawchatMutateConfigFile = <T = void>(params: {
   afterWrite: { mode: "auto" } | { mode: "none" | "restart"; reason: string };
@@ -203,8 +210,8 @@ export async function runOpenclawClawlingLogin(params: LoginParams): Promise<voi
 
   runtime.log("Verifying invite code …");
   let result;
+  const existingUserId = account.userId.trim();
   try {
-    const existingUserId = account.userId.trim();
     result = await apiClient.agentsConnect({
       code: inviteCode,
       platform: AGENTS_CONNECT_PLATFORM,
@@ -213,9 +220,36 @@ export async function runOpenclawClawlingLogin(params: LoginParams): Promise<voi
     });
   } catch (err) {
     if (err instanceof ClawlingApiError) {
-      throw new Error(`agents/connect failed (${err.kind}): ${err.message}`);
+      // The stored userId is a re-pair hint, not a credential — the invite
+      // code alone decides ownership. AGENT_NOT_FOUND means it names an agent
+      // this server has never had (owner account deleted, or the config was
+      // repointed at another deployment), so replaying it would fail
+      // identically for every future invite code. A 16001 leaves the code
+      // `pending` server-side, so shedding the id and retrying once cannot
+      // double-spend it. Nothing else is retried: an owner mismatch is a real
+      // rejection, and a request that sent no id has no stale state to shed.
+      if (existingUserId && err.meta?.code === AGENT_NOT_FOUND_CODE) {
+        runtime.log(
+          `Stored userId ${existingUserId} no longer exists on this server — retrying as a fresh pairing …`,
+        );
+        try {
+          result = await apiClient.agentsConnect({
+            code: inviteCode,
+            platform: AGENTS_CONNECT_PLATFORM,
+            type: AGENTS_CONNECT_TYPE,
+          });
+        } catch (retryErr) {
+          if (retryErr instanceof ClawlingApiError) {
+            throw new Error(`agents/connect failed (${retryErr.kind}): ${retryErr.message}`);
+          }
+          throw retryErr;
+        }
+      } else {
+        throw new Error(`agents/connect failed (${err.kind}): ${err.message}`);
+      }
+    } else {
+      throw err;
     }
-    throw err;
   }
 
   const accessToken = requireConnectString(result?.access_token, "access_token");

package/src/outbound.ts

@@ -1,5 +1,5 @@
 import { randomInt } from "node:crypto";
-import { MessageSendError, type Envelope, type Fragment, type MentionFragment, type MessageAckPayload, type MessageErrorPayload } from "./protocol-types.ts";
+import { EVENT, MessageSendError, type Envelope, type Fragment, type MentionFragment, type MessageAckPayload, type MessageErrorPayload, type MessageReactionPayload } from "./protocol-types.ts";
 import type { ClawlingChatClient } from "./ws-client.ts";
 import {
   createAttachedChannelResultAdapter,
@@ -647,6 +647,40 @@ export async function sendOpenclawClawlingMedia(
   });
 }
 
+export interface SendReactionParams {
+  client: ClawlingChatClient;
+  chatId: string;
+  targetMessageId: string;
+  emoji: string;
+  removed: boolean;
+  log?: LogSink;
+}
+
+/**
+ * Emit a Protocol-v2 `message.reaction`. Fire-and-forget: reactions are NOT
+ * ack-aligned (the server mints the slot-key message_id, so the ack-by-trace_id
+ * path used for message.send/reply does not apply). Matches the mobile client.
+ */
+export function sendOpenclawClawlingReaction(params: SendReactionParams): void {
+  const payload: MessageReactionPayload = {
+    target_message_id: params.targetMessageId,
+    emoji: params.emoji,
+    removed: params.removed,
+  };
+  const env: Envelope<MessageReactionPayload> = {
+    version: "2",
+    event: EVENT.MESSAGE_REACTION,
+    trace_id: params.client.nextTraceId(),
+    emitted_at: Date.now(),
+    chat_id: params.chatId,
+    payload,
+  };
+  params.client.sendWire(JSON.stringify(env));
+  params.log?.info?.(
+    `clawchat reaction sent chat_id=${params.chatId} target=${params.targetMessageId} emoji=${params.emoji} removed=${params.removed}`,
+  );
+}
+
 type OutboundClaimStore = Pick<ClawChatStore, "claimMessageOnce" | "markMessageAcknowledged">;
 
 // Crockford base32 alphabet (ULID spec).

package/src/protocol-types.ts

@@ -7,6 +7,7 @@ export const EVENT = {
   MESSAGE_ACK: "message.ack",
   MESSAGE_ERROR: "message.error",
   MESSAGE_REPLY: "message.reply",
+  MESSAGE_REACTION: "message.reaction",
   MESSAGE_CREATED: "message.created",
   MESSAGE_ADD: "message.add",
   MESSAGE_DONE: "message.done",
@@ -200,6 +201,12 @@ export interface MessagePayload {
   };
 }
 
+export interface MessageReactionPayload {
+  target_message_id: string;
+  emoji: string;
+  removed: boolean;
+}
+
 export interface MessageAckPayload {
   message_id: string;
   accepted_at: number;

package/src/runtime.ts

@@ -2401,6 +2401,18 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         ? (env.payload as Record<string, unknown>)
         : undefined;
       const type = typeof payload?.type === "string" ? payload.type : "";
+      if (type === "conversation.dissolved") {
+        // 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);
+        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`,
+        );
+      }
       if (type === "agent.config.changed") {
         log?.info?.(
           `[${accountId}] clawchat-plugin-openclaw agent.config.changed signal received; re-pulling group settings`,

package/src/terminal-send.ts

@@ -54,3 +54,24 @@ export function consumeTerminalClawChatSend(params: {
 export function clearTerminalClawChatSendsForTest(): void {
   terminalSends.clear();
 }
+
+export interface TerminalSendScope {
+  accountId: string;
+  chatId: string;
+  messageId: string;
+}
+
+/**
+ * Read the current turn's ambient send scope (accountId\0chatId\0messageId).
+ * Returns null when not inside a dispatch scope, or when the scope id is not
+ * the tripartite form (e.g. a test-only opaque scope id).
+ */
+export function getCurrentTerminalSendScope(): TerminalSendScope | null {
+  const store = terminalSendScope.getStore();
+  if (!store) return null;
+  const parts = store.split("\0");
+  if (parts.length !== 3) return null;
+  const [accountId, chatId, messageId] = parts;
+  if (!accountId || !chatId || !messageId) return null;
+  return { accountId, chatId, messageId };
+}

package/src/tools-schema.ts

@@ -254,6 +254,34 @@ export const ClawchatMentionMessageSchema = Type.Object({
 });
 export type ClawchatMentionMessageParams = Static<typeof ClawchatMentionMessageSchema>;
 
+export const ClawchatReactMessageSchema = Type.Object({
+  emoji: Type.String({
+    minLength: 1,
+    description:
+      "A single emoji to react with. Prefer the ClawChat quick set 👍 ❤️ 😂 😮 😢 🙏 🎉 👏 🔥 😍 🤔 so it renders in the client's quick-reaction row.",
+  }),
+  targetMessageId: Type.Optional(
+    Type.String({
+      minLength: 1,
+      description:
+        "ClawChat message id to react to. Omit to react to the message that triggered the current turn.",
+    }),
+  ),
+  chatId: Type.Optional(
+    Type.String({
+      minLength: 1,
+      description: "ClawChat conversation id. Omit to use the current turn's chat.",
+    }),
+  ),
+  remove: Type.Optional(
+    Type.Boolean({
+      description:
+        "Set true to remove your existing reaction on the target message. Omit or false to add/overwrite.",
+    }),
+  ),
+});
+export type ClawchatReactMessageParams = Static<typeof ClawchatReactMessageSchema>;
+
 export const ClawchatListMomentsSchema = Type.Object({
   before: Type.Optional(
     Type.Integer({

package/src/tools.ts

@@ -17,11 +17,11 @@ import {
   makeOwnerProfilePersister,
   type ClawChatStore,
 } from "./storage.ts";
-import { sendOpenclawClawlingMentionMessage } from "./outbound.ts";
+import { sendOpenclawClawlingMentionMessage, sendOpenclawClawlingReaction } from "./outbound.ts";
 import {
   getOpenclawClawlingClient,
 } from "./runtime.ts";
-import { markTerminalClawChatSend } from "./terminal-send.ts";
+import { markTerminalClawChatSend, getCurrentTerminalSendScope } from "./terminal-send.ts";
 import {
   editClawChatMemoryBody,
   readClawChatMemoryFile,
@@ -57,6 +57,7 @@ import {
   ClawchatListFriendRequestsSchema,
   ClawchatListMomentsSchema,
   ClawchatMentionMessageSchema,
+  ClawchatReactMessageSchema,
   ClawchatReplyMomentCommentSchema,
   ClawchatRejectFriendRequestSchema,
   ClawchatRemoveFriendSchema,
@@ -86,6 +87,7 @@ import {
   type ClawchatListFriendRequestsParams,
   type ClawchatListMomentsParams,
   type ClawchatMentionMessageParams,
+  type ClawchatReactMessageParams,
   type ClawchatReplyMomentCommentParams,
   type ClawchatRejectFriendRequestParams,
   type ClawchatRemoveFriendParams,
@@ -1113,6 +1115,60 @@ export function registerOpenclawClawlingTools(
     { name: "clawchat_mention_message" },
   );
 
+  api.registerTool(
+    {
+      name: "clawchat_react_message",
+      label: "React to ClawChat Message",
+      description: toolDescription(
+        "React to a ClawChat message with a single quick emoji (the bubble long-press reaction), instead of sending a text message. " +
+          "TRIGGER - invoke when a short acknowledgement or emotional beat (agreement, thanks, laughter, celebration, sympathy) reads more naturally as an emoji on the message than as a sentence, e.g. a simple 👍 to \"done\" or ❤️ to good news. " +
+          "Omit targetMessageId and chatId to react to the message that triggered the current turn; pass targetMessageId to react to an earlier message. " +
+          "Set remove:true to take back your reaction. " +
+          "Prefer the quick set 👍 ❤️ 😂 😮 😢 🙏 🎉 👏 🔥 😍 🤔. " +
+          "When a reaction is all you want to send, do not also send a normal text reply.",
+      ),
+      parameters: ClawchatReactMessageSchema,
+      async execute(_callId, params) {
+        return await recordClawchatToolCall("clawchat_react_message", params, async () => {
+          const p = params as ClawchatReactMessageParams;
+          if (!p.emoji?.trim()) {
+            return validationError("clawchat-plugin-openclaw: emoji is required");
+          }
+          const account = resolveCurrent();
+          if (!account.configured) {
+            return configError("clawchat-plugin-openclaw: account is not configured");
+          }
+          const scope = getCurrentTerminalSendScope();
+          const chatId = p.chatId?.trim() || scope?.chatId;
+          const targetMessageId = p.targetMessageId?.trim() || scope?.messageId;
+          if (!chatId) {
+            return validationError(
+              "clawchat-plugin-openclaw: chatId is required (no current-turn chat to default from)",
+            );
+          }
+          if (!targetMessageId) {
+            return validationError(
+              "clawchat-plugin-openclaw: targetMessageId is required (no current-turn message to default from)",
+            );
+          }
+          const client = getOpenclawClawlingClient(account.accountId);
+          if (!client) {
+            return configError("ClawChat websocket client is not ready");
+          }
+          const emoji = p.emoji.trim();
+          const removed = p.remove === true;
+          try {
+            sendOpenclawClawlingReaction({ client, chatId, targetMessageId, emoji, removed, log: api.logger });
+            return jsonResponse({ reacted: true, targetMessageId, emoji, removed });
+          } catch (err) {
+            return genericError(err);
+          }
+        });
+      },
+    },
+    { name: "clawchat_react_message" },
+  );
+
   api.registerTool(
     {
       name: "clawchat_list_moments",

package/src/ws-client.ts

@@ -165,6 +165,9 @@ export function buildConnectCapabilities(): ConnectCapabilities {
   };
 }
 
+/** Bounded FIFO of conversations known to be dissolved. */
+export const DEAD_CHATS_MAX = 512;
+
 export class ClawChatClient extends EventEmitter {
   private currentState: ConnState = "idle";
   private connectResolve?: () => void;
@@ -179,6 +182,7 @@ export class ClawChatClient extends EventEmitter {
   private readonly pending = new Map<string, PendingAck>();
   private readonly handledMessageErrorTraces = new Set<string>();
   private readonly sendQueue: string[] = [];
+  private readonly deadChats = new Set<string>();
 
   constructor(private readonly opts: NormalizedClawChatClientOptions) {
     super();
@@ -227,7 +231,42 @@ 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.
+   * 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.
+   *
+   * 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.
+   */
+  markChatDead(chatId: string): boolean {
+    if (typeof chatId !== "string" || !chatId.startsWith("cnv_")) return false;
+    if (this.deadChats.has(chatId)) return true;
+    this.deadChats.add(chatId);
+    while (this.deadChats.size > DEAD_CHATS_MAX) {
+      const oldest = this.deadChats.values().next().value as string | undefined;
+      if (oldest === undefined) break;
+      this.deadChats.delete(oldest);
+    }
+    return true;
+  }
+
+  isChatDead(chatId: string): boolean {
+    return this.deadChats.has(chatId);
+  }
+
+  /**
+   * 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.
+   */
   typing(chatId: string, isTyping = true): void {
+    if (this.isChatDead(chatId)) return;
     this.sendRawEnvelope({
       version: "2",
       event: EVENT.TYPING_UPDATE,
@@ -264,6 +303,8 @@ export class ClawChatClient extends EventEmitter {
     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.
   async sendAckableEnvelope(params: {
     eventName: "message.send" | "message.reply";
     chatId: string;