@clawling/clawchat-plugin-openclaw 2026.7.21-1 → 2026.7.25-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/liveware-cli.js

@@ -10,12 +10,22 @@ export function livewareDir(stateDir) {
     const root = stateDir ?? resolveStateDir();
     return path.join(root, "clawchat", "liveware");
 }
+/** Local filename for the downloaded binary; Windows needs a .exe suffix. */
+export function livewareBinaryName(plat = process.platform) {
+    return plat === "win32" ? "liveware.exe" : "liveware";
+}
 /** Map host platform/arch to the liveware asset filename, or null if unsupported. */
 export function platformAssets(plat = process.platform, arch = process.arch) {
-    const os = plat === "darwin" ? "darwin" : plat === "linux" ? "linux" : null;
+    const os = plat === "darwin" ? "darwin" : plat === "linux" ? "linux" : plat === "win32" ? "windows" : null;
     const cpu = arch === "x64" ? "amd64" : arch === "arm64" ? "arm64" : null;
     if (!os || !cpu)
         return null;
+    // Windows only ships an amd64 build, published with a .exe suffix.
+    if (os === "windows") {
+        if (cpu !== "amd64")
+            return null;
+        return { liveware: "liveware-windows-amd64.exe" };
+    }
     return { liveware: `liveware-${os}-${cpu}` };
 }
 function findOnPath(name) {
@@ -41,9 +51,10 @@ function findOnPath(name) {
  *  3. otherwise      → null
  */
 export function resolveLivewarePath(stateDir) {
-    if (findOnPath("liveware"))
-        return "liveware";
-    const local = path.join(livewareDir(stateDir), "liveware");
+    const name = livewareBinaryName();
+    if (findOnPath(name))
+        return name;
+    const local = path.join(livewareDir(stateDir), name);
     try {
         fs.accessSync(local, fs.constants.X_OK);
         return local;
@@ -71,10 +82,11 @@ async function downloadTo(url, dest) {
 export async function ensureLivewareCli(opts = {}) {
     const { stateDir, log } = opts;
     try {
-        if (findOnPath("liveware"))
+        const name = livewareBinaryName();
+        if (findOnPath(name))
             return; // PATH wins
         const dir = livewareDir(stateDir);
-        const target = path.join(dir, "liveware");
+        const target = path.join(dir, name);
         if (fs.existsSync(target))
             return;
         const assets = platformAssets();
@@ -83,7 +95,7 @@ export async function ensureLivewareCli(opts = {}) {
             return;
         }
         await fs.promises.mkdir(dir, { recursive: true });
-        await downloadTo(LIVEWARE_BASE_URL + assets.liveware, path.join(dir, "liveware"));
+        await downloadTo(LIVEWARE_BASE_URL + assets.liveware, path.join(dir, name));
         log?.debug?.(`clawchat-plugin-openclaw: liveware CLI downloaded to ${dir}`);
     }
     catch (err) {

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.21-1",
+  "version": "2026.7.25-1",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/skills/clawchat-core/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: clawchat-core
-version: 1.0.0
-description: Use when a request involves ClawChat profile, friends, user search, moments/dynamics, comments, reactions, avatar, media, memory, output visibility, read-only conversation lookup, or plugin install/update/activation.
+version: 1.1.0
+description: Use when a request involves ClawChat profile, friends, user search, moments/dynamics, comments, reactions, avatar, media, memory, output visibility, read-only conversation lookup, sending an image, file, or voice/audio clip into a conversation, or plugin install/update/activation.
 ---
 
 # ClawChat
@@ -16,6 +16,16 @@ This skill guides agent behavior for ClawChat-aware tasks. Use the registered Cl
 - If a requested ClawChat tool is unavailable or returns a config error, report that result and stop instead of bypassing the plugin.
 - Use the `/clawchat-output` slash command when the user asks to change how much ClawChat runtime output is shown in the current conversation.
 
+## Sending an Image, File, or Voice Message
+
+To deliver an image, file, or voice/audio clip into the current ClawChat conversation, use the OpenClaw **message tool** with `action='send'` and `media` set to a local file path or an HTTPS URL. This is a host message-tool capability, not a `clawchat_*` tool — the `clawchat_upload_avatar_image` / moment-image tools are a separate avatar/moments surface and do not post into a conversation.
+
+- ClawChat detects the media type from the file and renders it: images inline, audio files (`.mp3`, `.m4a`, `.wav`, `.ogg`, `.aac`, …) as **playable voice messages**, everything else as a downloadable file. There is no separate voice tool or `voice` kind — a voice message is just audio media, so sending a genuine audio file is how you "send a voice message".
+- Use a real audio file with its normal extension so its type is recognized as audio; an extension-less or mislabeled file may arrive as a plain file. The clip length is shown on the recipient side automatically — you do not set a duration.
+- Send several assets by passing multiple URLs; any accompanying reply text becomes the caption. For web images, pass a suitable HTTPS URL directly as `media` — do not download it first.
+- Omit `target` to reply to the current chat. For another chat use `target="cc:{chat_id}"` (direct) or `target="cc:group:{chat_id}"` (group).
+- Do not paste a file's contents into the message or claim you cannot send attachments as a substitute; attach it this way and report any delivery failure.
+
 ## OpenClaw CLI
 
 Use CLI commands only for installing, updating, activating, or refreshing the OpenClaw ClawChat plugin. Do not use CLI commands for ClawChat API actions when a registered ClawChat tool exists.

package/skills/clawchat-liveware/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clawchat-liveware
-version: 1.0.0
+version: 1.1.0
 description: Use when the user wants to expose this agent's local web service to the public internet via the liveware CLI and make it appear as an app in their ClawChat chat with this agent. Covers logging in to liveware with the ClawChat account, creating a liveware app, binding a tunnel to a local port, and registering the public URL to ClawChat.
 ---
 
@@ -55,9 +55,30 @@ ClawChat so it shows as an app tile in the owner's chat with this agent.
 - To remove one: `clawchat_unregister_app(appId="<app id>")` (this only removes it from
   ClawChat; tear down the liveware tunnel/app with liveware's own commands separately).
 
+## Identifying the viewing user (server-side)
+
+When a ClawChat user opens the liveware, the ClawChat liveware tunnel authenticates the
+request and forwards the viewer's ClawChat `user_id` to your web service as a request header.
+On the **server side** of your web service, read the `user_id` from either header (both carry
+the same value):
+
+- `X-User-Id`
+- `X-Clawchat-User-Id`
+
+Caveats:
+
+- This is **server-side only** — read the incoming request headers in your web service. Do
+  NOT try to obtain the viewer's identity from client-side page JavaScript.
+- The headers are injected by the ClawChat liveware tunnel, so they are present only for
+  requests that arrive through it. A page opened directly in an ordinary browser (outside
+  ClawChat) carries neither header — treat the user as anonymous when both are absent, and
+  never trust a client-supplied value for these header names.
+
 ## Notes
 
 - Apps can be created up to liveware's account limit; surface its error rather than working
   around it.
-- The registered web app opens in a sandboxed in-app browser on mobile with no ClawChat
-  login injected — do not assume the page can read the user's ClawChat identity.
+- The registered web app runs inside a sandboxed container (mobile in-app webview / desktop
+  container window). Page JavaScript cannot read the viewer's ClawChat identity — the
+  viewer's `user_id` arrives as the `X-User-Id` / `X-Clawchat-User-Id` request header,
+  readable server-side only (see "Identifying the viewing user").

package/skills/manifest.json

@@ -3,16 +3,16 @@
   "skills": {
     "openclaw": {
       "clawchat-core": {
-        "version": "1.0.0",
+        "version": "1.1.0",
         "path": "openclaw/clawchat-core/SKILL.md",
-        "sha256": "9b911a33640a6ba79f6323755a8541a366fddb9a74282d3d21512e0defda3fbc",
-        "bytes": 7307
+        "sha256": "f5a25e584ddf62c2a6880a85a7bd93765d05809f7612791b73600ca830445116",
+        "bytes": 8909
       },
       "clawchat-liveware": {
-        "version": "1.0.0",
+        "version": "1.1.0",
         "path": "shared/clawchat-liveware/SKILL.md",
-        "sha256": "d88ae5520590b46d1827b261bcc37d3621e252f419cc4f28e7f47ae79b237780",
-        "bytes": 3579
+        "sha256": "c59a8156f8283f9f2a71231813322ce2162a50c5f0c9ad3d828be43eb9ae967a",
+        "bytes": 4634
       },
       "clawchat-set-greeting": {
         "version": "1.0.0",
@@ -29,16 +29,16 @@
     },
     "hermes": {
       "clawchat-core": {
-        "version": "1.0.0",
+        "version": "1.2.0",
         "path": "hermes/clawchat-core/SKILL.md",
-        "sha256": "9c286e63f52f0d2436b95a13cda12b154e180f7127cd70b31cc3d1c56b331649",
-        "bytes": 8671
+        "sha256": "4a73379ff38f089b3120160f09a7eb1b7c617ec0bd23b9c905fb4b2184d6e239",
+        "bytes": 11106
       },
       "clawchat-liveware": {
-        "version": "1.0.0",
+        "version": "1.1.0",
         "path": "shared/clawchat-liveware/SKILL.md",
-        "sha256": "d88ae5520590b46d1827b261bcc37d3621e252f419cc4f28e7f47ae79b237780",
-        "bytes": 3579
+        "sha256": "c59a8156f8283f9f2a71231813322ce2162a50c5f0c9ad3d828be43eb9ae967a",
+        "bytes": 4634
       },
       "clawchat-set-greeting": {
         "version": "1.0.0",

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/liveware-cli.ts

@@ -20,14 +20,25 @@ export function livewareDir(stateDir?: string): string {
   return path.join(root, "clawchat", "liveware");
 }
 
+/** Local filename for the downloaded binary; Windows needs a .exe suffix. */
+export function livewareBinaryName(plat: string = process.platform): string {
+  return plat === "win32" ? "liveware.exe" : "liveware";
+}
+
 /** Map host platform/arch to the liveware asset filename, or null if unsupported. */
 export function platformAssets(
   plat: string = process.platform,
   arch: string = process.arch,
 ): { liveware: string } | null {
-  const os = plat === "darwin" ? "darwin" : plat === "linux" ? "linux" : null;
+  const os =
+    plat === "darwin" ? "darwin" : plat === "linux" ? "linux" : plat === "win32" ? "windows" : null;
   const cpu = arch === "x64" ? "amd64" : arch === "arm64" ? "arm64" : null;
   if (!os || !cpu) return null;
+  // Windows only ships an amd64 build, published with a .exe suffix.
+  if (os === "windows") {
+    if (cpu !== "amd64") return null;
+    return { liveware: "liveware-windows-amd64.exe" };
+  }
   return { liveware: `liveware-${os}-${cpu}` };
 }
 
@@ -53,8 +64,9 @@ function findOnPath(name: string): string | null {
  *  3. otherwise      → null
  */
 export function resolveLivewarePath(stateDir?: string): string | null {
-  if (findOnPath("liveware")) return "liveware";
-  const local = path.join(livewareDir(stateDir), "liveware");
+  const name = livewareBinaryName();
+  if (findOnPath(name)) return name;
+  const local = path.join(livewareDir(stateDir), name);
   try {
     fs.accessSync(local, fs.constants.X_OK);
     return local;
@@ -83,9 +95,10 @@ export async function ensureLivewareCli(
 ): Promise<void> {
   const { stateDir, log } = opts;
   try {
-    if (findOnPath("liveware")) return; // PATH wins
+    const name = livewareBinaryName();
+    if (findOnPath(name)) return; // PATH wins
     const dir = livewareDir(stateDir);
-    const target = path.join(dir, "liveware");
+    const target = path.join(dir, name);
     if (fs.existsSync(target)) return;
 
     const assets = platformAssets();
@@ -97,7 +110,7 @@ export async function ensureLivewareCli(
     }
 
     await fs.promises.mkdir(dir, { recursive: true });
-    await downloadTo(LIVEWARE_BASE_URL + assets.liveware, path.join(dir, "liveware"));
+    await downloadTo(LIVEWARE_BASE_URL + assets.liveware, path.join(dir, name));
     log?.debug?.(`clawchat-plugin-openclaw: liveware CLI downloaded to ${dir}`);
   } catch (err) {
     log?.warn?.(`clawchat-plugin-openclaw: liveware CLI download skipped: ${String(err)}`);

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;