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

package/dist/src/outbound.js

@@ -1,5 +1,6 @@
 import { randomInt } from "node:crypto";
-import { EVENT, MessageSendError } from "./protocol-types.js";
+import { EVENT, MessageSendError, TERMINAL_CHAT_CODES } from "./protocol-types.js";
+import { CHAT_ID_PREFIX, isValidChatId } from "./ws-client.js";
 import { createAttachedChannelResultAdapter, } from "openclaw/plugin-sdk/channel-send-result";
 import { chunkMarkdownText } from "openclaw/plugin-sdk/reply-runtime";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
@@ -115,14 +116,71 @@ function getAlignedMessageErrorTracker(client, account, log) {
 export function setAlignedOutboundLogContext(client, context) {
     alignedOutboundContexts.set(client, context);
 }
+/**
+ * The single outbound gate predicate. Narrow by design: only a SERVER-confirmed
+ * rejection blocks, never a `conversation.dissolved` inference, and never the
+ * owner's direct chat (the client applies that exemption inside isSendBlocked).
+ * Optional-call form because outbound tests hand-roll a client mock.
+ */
+function isOutboundBlocked(client, chatId) {
+    if (!chatId)
+        return false;
+    return client.isSendBlocked?.(chatId) === true;
+}
 export function flushAlignedOutboundQueue(client) {
     const queue = alignedOutboundQueues.get(client);
-    queue?.flush((wire) => client.sendWire(wire));
+    // Re-check the gate at write time: this replay path (called on every
+    // `connected` edge) does not re-enter sendAlignedAckableEnvelope.
+    queue?.flush((wire) => client.sendWire(wire), { isBlocked: (item) => isOutboundBlocked(client, item.chatId) });
 }
 export function getAlignedOutboundQueueSize(client) {
     return alignedOutboundQueues.get(client)?.snapshot().length ?? 0;
 }
 async function sendAlignedAckableEnvelope(params) {
+    // Static addressing check, before any server state is consulted: this one is
+    // decidable locally and is never revocable, so it is not a "gate" that can
+    // later clear. msghub refuses such a frame with `invalid conversation id`.
+    if (!isValidChatId(params.chatId)) {
+        params.log?.info?.(formatWsLog({
+            event: "send_blocked",
+            accountId: params.account.accountId,
+            ...(alignedOutboundContexts.get(params.client)?.() ?? {
+                attempt: 1,
+                reconnectCount: 0,
+                state: params.client.transportState === "open" ? "ready" : "reconnecting",
+            }),
+            action: "drop",
+            fields: [
+                ["event_name", params.eventName],
+                ["chat_id", params.chatId],
+                ["reason", "invalid_chat_id"],
+            ],
+        }));
+        throw new MessageSendError("-", "invalid_chat_id", `"${params.chatId}" is not a ClawChat conversation id (expected ${CHAT_ID_PREFIX}…); refusing to send`, params.chatId);
+    }
+    // The server has already rejected this conversation with a terminal code and
+    // that rejection has not expired. Stop here: every further frame would be
+    // refused the same way. Gated on the narrow server-confirmed tier ONLY — a
+    // `conversation.dissolved` signal must never reach this branch, and the
+    // owner's direct chat is exempt (see ClawChatClient.isSendBlocked).
+    if (isOutboundBlocked(params.client, params.chatId)) {
+        params.log?.info?.(formatWsLog({
+            event: "send_blocked",
+            accountId: params.account.accountId,
+            ...(alignedOutboundContexts.get(params.client)?.() ?? {
+                attempt: 1,
+                reconnectCount: 0,
+                state: params.client.transportState === "open" ? "ready" : "reconnecting",
+            }),
+            action: "drop",
+            fields: [
+                ["event_name", params.eventName],
+                ["chat_id", params.chatId],
+                ["reason", "chat_rejected_by_server"],
+            ],
+        }));
+        throw new MessageSendError("-", "chat_rejected_local", "conversation was rejected by the server; refusing to send", params.chatId);
+    }
     const traceId = params.client.nextTraceId();
     const env = {
         version: "2",
@@ -206,6 +264,15 @@ async function sendAlignedAckableEnvelope(params) {
                     : typeof payload.message === "string" && payload.message
                         ? payload.message
                         : "message send failed";
+                // A terminal refusal proves the conversation is unreachable for this
+                // sender right now. Record it on the SERVER tier so the gates below
+                // stop subsequent frames — this is fact, not the inference that
+                // `conversation.dissolved` gives us. It expires; see the client.
+                if (TERMINAL_CHAT_CODES.has(code)
+                    && typeof ack.chat_id === "string"
+                    && ack.chat_id) {
+                    params.client.markChatDead?.(ack.chat_id, "server");
+                }
                 fail(new MessageSendError(traceId, code, hint, ack.chat_id));
                 return;
             }
@@ -242,6 +309,9 @@ async function sendAlignedAckableEnvelope(params) {
             onDrop: () => {
                 fail(new Error(`send queue full; dropped ${params.eventName} before write for trace_id=${traceId}`));
             },
+            onBlock: () => {
+                fail(new MessageSendError("-", "chat_rejected_local", "conversation was rejected by the server while this frame was queued", params.chatId));
+            },
         };
         function isTerminalClose(close) {
             return close?.code === 1000 || close?.reason === "client close" || close?.reason === "auth failed";
@@ -280,7 +350,7 @@ async function sendAlignedAckableEnvelope(params) {
         }
         try {
             queue.enqueue(item);
-            queue.flush((queuedWire) => params.client.sendWire(queuedWire));
+            queue.flush((queuedWire) => params.client.sendWire(queuedWire), { isBlocked: (queued) => isOutboundBlocked(params.client, queued.chatId) });
         }
         catch {
             // The queue keeps the failed frame at the head for reconnect retry, so
@@ -494,6 +564,14 @@ export async function sendOpenclawClawlingMedia(params) {
  * path used for message.send/reply does not apply). Matches the mobile client.
  */
 export function sendOpenclawClawlingReaction(params) {
+    if (!isValidChatId(params.chatId)) {
+        params.log?.info?.(`clawchat reaction blocked chat_id=${params.chatId} reason=invalid_chat_id`);
+        return;
+    }
+    if (isOutboundBlocked(params.client, params.chatId)) {
+        params.log?.info?.(`clawchat reaction blocked chat_id=${params.chatId} reason=chat_rejected_by_server`);
+        return;
+    }
     const payload = {
         target_message_id: params.targetMessageId,
         emoji: params.emoji,

package/dist/src/protocol-types.js

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

package/dist/src/runtime.js

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

package/dist/src/tools-schema.js

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

package/dist/src/tools.js

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

package/dist/src/ws-alignment.js

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