@clawling/clawchat-plugin-openclaw 2026.10.9-3 → 2026.10.9-4

package/dist/src/tools.js

@@ -8,12 +8,13 @@ import { ClawlingApiError, } from "./api-types.js";
 import { mapGateOutcome } from "./gate-outcome.js";
 import { CHANNEL_ID, normalizeOpenclawClawlingAccountId, resolveOpenclawClawlingAccount, } from "./config.js";
 import { clawChatDbPathForStateDir, getClawChatStore, makeOwnerProfilePersister, } from "./storage.js";
-import { sendOpenclawClawlingMentionMessage, sendOpenclawClawlingReaction } from "./outbound.js";
+import { isPlausibleMessageId, sendOpenclawClawlingMentionMessage, sendOpenclawClawlingReaction } from "./outbound.js";
+import { isValidChatId } from "./ws-client.js";
 import { getOpenclawClawlingClient, } from "./runtime.js";
 import { markTerminalClawChatSend, getCurrentTerminalSendScope } from "./terminal-send.js";
 import { editClawChatMemoryBody, readClawChatMemoryFile, resolveClawChatMemoryPath, searchClawChatMemory, writeClawChatMemoryBody, } from "./clawchat-memory.js";
 import { canReadMemory, memoryScopeNote, memoryScopeRefusal, resolveMemoryScope, } from "./memory-scope.js";
-import { clawChatSessionAccountId, NON_OWNER_TOOL_ALLOWLIST } from "./turn-boundary.js";
+import { clawChatSessionAccountId, NON_OWNER_TOOL_ALLOWLIST, normalizeToolChatId } from "./turn-boundary.js";
 import { pullGroupMetadata, pullOwnerMetadata, pullUserMetadata, pushMetadata, updateMetadata, } from "./clawchat-metadata.js";
 import { ClawchatGetAccountProfileSchema, ClawchatGetConversationSchema, ClawchatGetDirectConversationSchema, ClawchatGetMomentSchema, ClawchatGetUserProfileSchema, ClawchatLeaveGroupSchema, ClawchatAddGroupMemberSchema, 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, ClawchatOrchListAgentsSchema, ClawchatOrchGetAgentSchema, ClawchatOrchSetAgentBehaviorSchema, ClawchatOrchListGroupsSchema, ClawchatOrchGetGroupSchema, ClawchatOrchSetGroupPromptSchema, ClawchatOrchCreateGroupSchema, ClawchatOrchGroupMemberSchema, ClawchatOrchSetGroupAgentSettingsSchema, ClawchatOrchCreateConnectCodeSchema, ClawchatOrchGetConnectCodeSchema, } from "./tools-schema.js";
 const MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
@@ -91,6 +92,15 @@ export function apiError(err) {
 function validationError(message) {
     return jsonResponse({ error: "validation", message });
 }
+function reactionBlockedError(chatId, reason) {
+    return jsonResponse({
+        error: "send_blocked",
+        reason,
+        message: reason === "invalid_chat_id"
+            ? `clawchat-plugin-openclaw: "${chatId}" is not a ClawChat chat id (expected cnv_…); the reaction was not sent`
+            : "clawchat-plugin-openclaw: this chat was rejected by the server; the reaction was not sent",
+    });
+}
 function genericError(err) {
     return jsonResponse({
         error: "unknown",
@@ -173,12 +183,18 @@ function planMomentImages(images) {
     }
     return { ok: true, entries };
 }
+const MESSAGE_ID_ECHO_LIMIT = 64;
+function notAMessageIdMessage(field, value) {
+    const shown = value.length > MESSAGE_ID_ECHO_LIMIT ? `${value.slice(0, MESSAGE_ID_ECHO_LIMIT)}…` : value;
+    return `clawchat-plugin-openclaw: ${field} "${shown}" is not a message in this chat; use the real message id from this chat's message metadata (e.g. msg-…), or omit it`;
+}
 function validateMentionMessageParams(params) {
     if (!params || typeof params !== "object") {
         return { ok: false, message: "clawchat-plugin-openclaw: params are required" };
     }
     const p = params;
-    if (typeof p.chatId !== "string" || !p.chatId.trim()) {
+    const chatId = normalizeToolChatId(p.chatId);
+    if (!chatId) {
         return { ok: false, message: "clawchat-plugin-openclaw: chatId is required" };
     }
     if (p.chatType !== undefined && p.chatType !== "group" && p.chatType !== "direct") {
@@ -214,11 +230,12 @@ function validateMentionMessageParams(params) {
             ok: true,
             params: {
                 ...p,
+                chatId,
                 replyToMessageId,
             },
         };
     }
-    return { ok: true, params: p };
+    return { ok: true, params: { ...p, chatId } };
 }
 /**
  * Account a tool call belongs to, or `null` when the call carries no ClawChat
@@ -244,6 +261,17 @@ export function resolveOpenclawClawlingToolAccountId(ctx) {
     }
     return null;
 }
+/**
+ * True when the host says this tool call's run is a ClawChat run: every
+ * channel the trusted ctx names (`deliveryContext.channel`, `messageChannel`)
+ * is this channel, and at least one is present. Missing or foreign → false.
+ */
+export function isClawChatToolRun(ctx) {
+    const channels = [ctx.deliveryContext?.channel, ctx.messageChannel]
+        .map((channel) => (typeof channel === "string" ? channel.trim().toLowerCase() : ""))
+        .filter(Boolean);
+    return channels.length > 0 && channels.every((channel) => channel === CHANNEL_ID);
+}
 // Names this plugin registered through its wrapper below. The host-tool guard
 // lets an allowlisted `clawchat_*` name through only when it is in this set,
 // so another plugin's tool under a lookalike name is not trusted by prefix.
@@ -306,6 +334,90 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             return null;
         }
     }
+    let warnedMessageIdStore = false;
+    /**
+     * An explicit message id (react target, mention reply) must be one the
+     * plugin has stored for this chat; the stored chat id and message id (their
+     * real case) are what gets sent. When the store cannot answer, fall back to
+     * the message-id shape check rather than block every call, keep the ids as
+     * given, and warn once without ids or arguments.
+     */
+    function resolveExplicitMessageId(input) {
+        let seen = null;
+        try {
+            const store = resolveStore();
+            seen = store?.findSeenMessageInChat
+                ? store.findSeenMessageInChat({
+                    platform: "openclaw",
+                    accountId: input.accountId,
+                    chatId: input.chatId,
+                    messageId: input.value,
+                })
+                : null;
+        }
+        catch {
+            seen = null;
+        }
+        if (seen)
+            return { ok: true, chatId: seen.chatId, messageId: seen.messageId };
+        if (seen === null) {
+            if (!warnedMessageIdStore) {
+                warnedMessageIdStore = true;
+                api.logger.warn("clawchat-plugin-openclaw: message-id store check unavailable; falling back to the message-id shape check");
+            }
+            if (isPlausibleMessageId(input.value))
+                return { ok: true, chatId: input.chatId, messageId: input.value };
+        }
+        return { ok: false, error: validationError(notAMessageIdMessage(input.field, input.value)) };
+    }
+    /**
+     * The chat id in the case the ledger already stores for it, so a send, its
+     * terminal marker and its ledger row all name the chat as the inbound path
+     * does (a second case splits the chat for memory scope). The id as given
+     * when the ledger has no row for the chat or cannot answer.
+     */
+    function storedChatIdCase(accountId, chatId) {
+        try {
+            const stored = resolveStore()?.findStoredChatId?.({ platform: "openclaw", accountId, chatId });
+            return typeof stored === "string" && stored ? stored : chatId;
+        }
+        catch {
+            return chatId;
+        }
+    }
+    /**
+     * Best-effort ledger row for a sent mention, so its id can be reacted to or
+     * quoted later. Written after the ack; a store failure never affects the send.
+     */
+    function recordMentionSent(input) {
+        try {
+            const store = resolveStore();
+            const claimed = store?.claimMessageOnce?.({
+                platform: "openclaw",
+                accountId: input.accountId,
+                kind: "message",
+                direction: "outbound",
+                eventType: "message.send",
+                chatId: input.chatId,
+                messageId: input.messageId,
+                text: input.text,
+                raw: { mode: "tool-mention" },
+            });
+            if (claimed !== true)
+                return;
+            store?.markMessageAcknowledged?.({
+                accountId: input.accountId,
+                kind: "message",
+                direction: "outbound",
+                messageId: input.messageId,
+                protocolMessageId: input.messageId,
+                ackedAt: input.acceptedAt ?? Date.now(),
+            });
+        }
+        catch {
+            // Diagnostics only; the mention has already been sent.
+        }
+    }
     function detailsError(details) {
         if (!details || typeof details !== "object")
             return null;
@@ -1001,7 +1113,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                     if (!built.ok)
                         return built.error;
                     try {
-                        const data = await built.client.getConversation(p.conversationId);
+                        const data = await built.client.getConversation(normalizeToolChatId(p.conversationId));
                         return jsonResponse(data);
                     }
                     catch (err) {
@@ -1063,7 +1175,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                     if (!built.ok)
                         return built.error;
                     try {
-                        const data = await built.client.leaveConversation(p.conversationId);
+                        const data = await built.client.leaveConversation(normalizeToolChatId(p.conversationId));
                         return jsonResponse(data);
                     }
                     catch (err) {
@@ -1094,7 +1206,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                     if (!built.ok)
                         return built.error;
                     try {
-                        const data = await built.client.addConversationMember(p.conversationId, p.userId);
+                        const data = await built.client.addConversationMember(normalizeToolChatId(p.conversationId), p.userId);
                         return jsonResponse(data);
                     }
                     catch (err) {
@@ -1131,6 +1243,20 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                     }
                     try {
                         const p = validated.params;
+                        let chatId = isValidChatId(p.chatId) ? storedChatIdCase(account.accountId, p.chatId) : p.chatId;
+                        let replyToMessageId = p.replyToMessageId;
+                        if (replyToMessageId) {
+                            const resolved = resolveExplicitMessageId({
+                                field: "replyToMessageId",
+                                value: replyToMessageId,
+                                accountId: account.accountId,
+                                chatId,
+                            });
+                            if (!resolved.ok)
+                                return resolved.error;
+                            chatId = resolved.chatId;
+                            replyToMessageId = resolved.messageId;
+                        }
                         const client = getOpenclawClawlingClient(account.accountId);
                         if (!client) {
                             return configError("ClawChat websocket client is not ready");
@@ -1139,15 +1265,15 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                             client,
                             account,
                             to: {
-                                chatId: p.chatId.trim(),
+                                chatId,
                                 chatType: p.chatType ?? "group",
                             },
                             ...(p.text !== undefined ? { text: p.text } : {}),
                             mentions: p.mentions,
-                            ...(p.replyToMessageId
+                            ...(replyToMessageId
                                 ? {
                                     replyCtx: {
-                                        replyToMessageId: p.replyToMessageId,
+                                        replyToMessageId,
                                     },
                                 }
                                 : {}),
@@ -1155,11 +1281,23 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                         });
                         if (!result)
                             return jsonResponse(result);
-                        markTerminalClawChatSend({
+                        recordMentionSent({
                             accountId: account.accountId,
-                            chatId: p.chatId.trim(),
+                            chatId,
                             messageId: result.messageId,
+                            text: p.text ?? "",
+                            ...(result.acceptedAt !== undefined ? { acceptedAt: result.acceptedAt } : {}),
                         });
+                        // Same trust rule as the react defaults: only a ClawChat run's
+                        // turn may have its follow-up reply suppressed.
+                        if (isClawChatToolRun(ctx)) {
+                            markTerminalClawChatSend({
+                                accountId: account.accountId,
+                                chatId,
+                                messageId: result.messageId,
+                                sessionKey: ctx.sessionKey,
+                            });
+                        }
                         return jsonResponse({
                             sent: true,
                             terminal: true,
@@ -1197,15 +1335,55 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                     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;
+                    // Defaults come only from this call's own turn: the open turn in
+                    // its async context registered for the same session key as the
+                    // trusted tool ctx (see terminal-send.ts). Anything else fails as
+                    // a validation error asking for explicit ids.
+                    // The run must also be a ClawChat run: under a session key shared
+                    // with another channel, that channel's turns never register or
+                    // supersede a ClawChat turn, so its calls get no defaults.
+                    const scope = isClawChatToolRun(ctx)
+                        ? getCurrentTerminalSendScope({ sessionKey: ctx.sessionKey })
+                        : null;
+                    // Only a missing or blank chatId defaults. A given one that strips
+                    // to nothing (`clawchat-plugin-openclaw:`, `group:`) stays as given
+                    // so outbound refuses it as invalid_chat_id instead of it silently
+                    // reaching the current turn's chat.
+                    const rawChatId = typeof p.chatId === "string" ? p.chatId.trim() : "";
+                    let chatId = rawChatId ? normalizeToolChatId(rawChatId) || rawChatId : scope?.chatId;
+                    const explicitTargetMessageId = typeof p.targetMessageId === "string" ? p.targetMessageId.trim() : "";
+                    // The default target is the current turn's message, so it applies
+                    // only to that turn's chat: chatId omitted, or naming the scope's
+                    // chat (any case, host target form). The send then goes to the
+                    // scope's chat id. In any other chat that id names no message.
+                    const defaultsToScopeChat = Boolean(scope)
+                        && (!rawChatId || (chatId ?? "").toLowerCase() === scope.chatId.toLowerCase());
+                    let targetMessageId = explicitTargetMessageId || (defaultsToScopeChat ? scope.messageId : undefined);
+                    if (!explicitTargetMessageId && defaultsToScopeChat)
+                        chatId = scope.chatId;
                     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)");
                     }
+                    // Only an explicit id is checked; the current-turn default is the
+                    // triggering message's own id. A chat id outbound would refuse is
+                    // reported as that refusal first.
+                    if (explicitTargetMessageId) {
+                        if (!isValidChatId(chatId))
+                            return reactionBlockedError(chatId, "invalid_chat_id");
+                        const resolved = resolveExplicitMessageId({
+                            field: "targetMessageId",
+                            value: explicitTargetMessageId,
+                            accountId: account.accountId,
+                            chatId,
+                        });
+                        if (!resolved.ok)
+                            return resolved.error;
+                        chatId = resolved.chatId;
+                        targetMessageId = resolved.messageId;
+                    }
                     const client = getOpenclawClawlingClient(account.accountId);
                     if (!client) {
                         return configError("ClawChat websocket client is not ready");
@@ -1213,7 +1391,11 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                     const emoji = p.emoji.trim();
                     const removed = p.remove === true;
                     try {
-                        sendOpenclawClawlingReaction({ client, chatId, targetMessageId, emoji, removed, log: api.logger });
+                        const sent = sendOpenclawClawlingReaction({ client, chatId, targetMessageId, emoji, removed, log: api.logger });
+                        // A locally refused reaction never left the plugin: report the
+                        // refusal so the model does not tell the user it reacted.
+                        if (!sent.sent)
+                            return reactionBlockedError(chatId, sent.reason);
                         return jsonResponse({ reacted: true, targetMessageId, emoji, removed });
                     }
                     catch (err) {
@@ -1682,7 +1864,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             async execute(_callId, params) {
                 return await recordClawchatToolCall(accountId, "clawchat_orchestrate_get_group", params, async () => {
                     const p = params;
-                    return await withClient(accountId, (c) => c.orchGetGroup(p.conversationId));
+                    return await withClient(accountId, (c) => c.orchGetGroup(normalizeToolChatId(p.conversationId)));
                 });
             },
         };
@@ -1705,7 +1887,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             async execute(_callId, params) {
                 return await recordClawchatToolCall(accountId, "clawchat_orchestrate_set_group_prompt", params, async () => {
                     const p = params;
-                    return await withClient(accountId, (c) => c.orchSetGroupPrompt(p.conversationId, p.description));
+                    return await withClient(accountId, (c) => c.orchSetGroupPrompt(normalizeToolChatId(p.conversationId), p.description));
                 });
             },
         };
@@ -1738,7 +1920,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             async execute(_callId, params) {
                 return await recordClawchatToolCall(accountId, "clawchat_orchestrate_add_group_member", params, async () => {
                     const p = params;
-                    return await withClient(accountId, (c) => c.orchAddGroupMember(p.conversationId, p.agentId));
+                    return await withClient(accountId, (c) => c.orchAddGroupMember(normalizeToolChatId(p.conversationId), p.agentId));
                 });
             },
         };
@@ -1754,7 +1936,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             async execute(_callId, params) {
                 return await recordClawchatToolCall(accountId, "clawchat_orchestrate_remove_group_member", params, async () => {
                     const p = params;
-                    return await withClient(accountId, (c) => c.orchRemoveGroupMember(p.conversationId, p.agentId));
+                    return await withClient(accountId, (c) => c.orchRemoveGroupMember(normalizeToolChatId(p.conversationId), p.agentId));
                 });
             },
         };
@@ -1772,7 +1954,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             async execute(_callId, params) {
                 return await recordClawchatToolCall(accountId, "clawchat_orchestrate_set_group_agent_settings", params, async () => {
                     const p = params;
-                    return await withClient(accountId, (c) => c.orchSetGroupAgentSettings(p.conversationId, p.agentId, {
+                    return await withClient(accountId, (c) => c.orchSetGroupAgentSettings(normalizeToolChatId(p.conversationId), p.agentId, {
                         muted: p.muted,
                         replyMode: p.replyMode,
                         batchDelaySeconds: p.batchDelaySeconds,

package/dist/src/turn-boundary.js

@@ -10,6 +10,23 @@ export const NON_OWNER_TOOL_ALLOWLIST = Object.freeze([
     "web_search",
 ]);
 const norm = (v) => (typeof v === "string" ? v.trim().toLowerCase() : "");
+// `<channel>:` then `direct:`/`group:`, each optional and stripped at most once.
+const TOOL_CHAT_ID_TARGET_PREFIX = new RegExp(`^(?:${CHANNEL_ID}:)?(?:(?:direct|group):)?`, "i");
+/**
+ * The bare ClawChat chat id a tool argument names. The host shows the model
+ * this chat's `chat_id` as the channel-prefixed origin target
+ * (`clawchat-plugin-openclaw:cnv_…` / `clawchat-plugin-openclaw:group:cnv_…`)
+ * and a group's label as `group:cnv_…`; models copy either form into tool
+ * arguments. Only that form is stripped; case is kept, and whatever remains is
+ * still validated by the send path (`isValidChatId`) or the server. Every tool
+ * that takes a ClawChat chat id, and the non-owner current-chat check, use
+ * this one helper so they agree on which chat an argument names.
+ */
+export function normalizeToolChatId(value) {
+    if (typeof value !== "string")
+        return "";
+    return value.trim().replace(TOOL_CHAT_ID_TARGET_PREFIX, "").trim();
+}
 /**
  * Host session keys (dmScope per-account-channel-peer):
  *   agent:<agent>:<channel>:<account>:direct:<chat>

package/package.json

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

package/src/host-tools-guard.ts

@@ -10,6 +10,7 @@ import {
   classifyChat,
   clawChatSessionAccountId,
   NON_OWNER_TOOL_ALLOWLIST,
+  normalizeToolChatId,
   parseClawChatSessionKey,
 } from "./turn-boundary.ts";
 import { clawChatDbPathForStateDir, getClawChatStore } from "./storage.ts";
@@ -76,8 +77,10 @@ export function decideHostToolCall(input: HostToolInput): HostToolDecision {
   if (HOST_TOOL_SEARCH_CONTROLS.includes(input.toolName)) return undefined;
   if (ACCOUNT_SCOPED_TOOLS.includes(input.toolName)) {
     // D9: a non-owner turn may only act on its own chat, named explicitly.
-    const target = input.params.chatId;
-    if (typeof target !== "string" || !target.trim() || target.trim().toLowerCase() !== parsed.chatId) {
+    // The tool resolves the same argument with the same helper, so the chat
+    // checked here is the chat the call reaches.
+    const target = normalizeToolChatId(input.params.chatId).toLowerCase();
+    if (!target || target !== parsed.chatId) {
       return {
         block: true,
         blockReason: input.toolName === "clawchat_react_message"

package/src/outbound.ts

@@ -814,23 +814,33 @@ export interface SendReactionParams {
   log?: LogSink;
 }
 
+/**
+ * Outcome of {@link sendOpenclawClawlingReaction}. `sent: false` means the
+ * frame never left the plugin; callers that report to the model must surface
+ * it as a failure, never as a reaction.
+ */
+export type SendReactionResult =
+  | { sent: true }
+  | { sent: false; reason: "invalid_chat_id" | "chat_rejected_by_server" };
+
 /**
  * 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.
+ * Local refusals are returned, not thrown; a transport failure still throws.
  */
-export function sendOpenclawClawlingReaction(params: SendReactionParams): void {
+export function sendOpenclawClawlingReaction(params: SendReactionParams): SendReactionResult {
   if (!isValidChatId(params.chatId)) {
     params.log?.info?.(
       `clawchat reaction blocked chat_id=${params.chatId} reason=invalid_chat_id`,
     );
-    return;
+    return { sent: false, reason: "invalid_chat_id" };
   }
   if (isOutboundBlocked(params.client, params.chatId)) {
     params.log?.info?.(
       `clawchat reaction blocked chat_id=${params.chatId} reason=chat_rejected_by_server`,
     );
-    return;
+    return { sent: false, reason: "chat_rejected_by_server" };
   }
   const payload: MessageReactionPayload = {
     target_message_id: params.targetMessageId,
@@ -849,6 +859,7 @@ export function sendOpenclawClawlingReaction(params: SendReactionParams): void {
   params.log?.info?.(
     `clawchat reaction sent chat_id=${params.chatId} target=${params.targetMessageId} emoji=${params.emoji} removed=${params.removed}`,
   );
+  return { sent: true };
 }
 
 type OutboundClaimStore = Pick<ClawChatStore, "claimMessageOnce" | "markMessageAcknowledged">;
@@ -875,6 +886,31 @@ function ulid(now: number = Date.now()): string {
   return out.join("");
 }
 
+// Every message id shape a ClawChat message can carry. The server preserves a
+// client-supplied id verbatim and never parses it, so this is deliberately a
+// plausibility check, not the mint contract:
+//   - `msg-<ULID>`: clients (this plugin, mobile, hermes) and the server's own
+//     fallback mint; `msg_…` / short `msg-…` forms are kept for older ids;
+//   - `sys-<ULID>` / `sys-<request_id>`: server system injections;
+//   - a bare ULID: the server's user-message publisher;
+//   - `clawchat-plugin-openclaw-…`: this plugin's synthetic turn ids.
+// UUIDs are not accepted: no ClawChat message id the model sees has that
+// shape, while host transcript ids (e.g. from `sessions_search`) do.
+const PREFIXED_MESSAGE_ID = /^(?:msg[-_]|sys-|clawchat-plugin-openclaw-)\S+$/i;
+const BARE_ULID = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+
+/**
+ * Whether `id` can be a real ClawChat message id. Rejects what a model makes
+ * up when it has no id (a label like `B`, `msg`, prose); the server only checks
+ * that a reaction target is non-empty, so such a value would "succeed" on no
+ * message. Callers trim first. Tools use this only as the fallback when the
+ * plugin store cannot answer whether it has seen the id in the chat.
+ */
+export function isPlausibleMessageId(id: unknown): id is string {
+  if (typeof id !== "string") return false;
+  return PREFIXED_MESSAGE_ID.test(id) || BARE_ULID.test(id);
+}
+
 /** Client-minted message id: `msg-` + ULID (protocol §7.6 format contract). */
 export function mintMessageId(): string {
   return `msg-${ulid()}`;

package/src/runtime.ts

@@ -3574,7 +3574,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           dispatcher,
           onSettled: () => markDispatchIdle(),
           run: () =>
-            runWithTerminalClawChatSendScope(terminalSendScopeId, () =>
+            runWithTerminalClawChatSendScope({ scopeId: terminalSendScopeId, sessionKey: resolvedSessionKey }, () =>
               rt.reply.dispatchReplyFromConfig({
                 ctx: ctxPayload,
                 cfg: dispatchCfg,