@clawling/clawchat-plugin-openclaw 2026.6.30-4 → 2026.7.1

package/dist/src/api-client.js

@@ -196,6 +196,7 @@ export function createOpenclawClawlingApiClient(opts) {
                     code,
                     status: res.status,
                     path,
+                    ...(env.data !== undefined ? { data: env.data } : {}),
                 });
             }
             return env.data;
@@ -516,5 +517,17 @@ export function createOpenclawClawlingApiClient(opts) {
             }
             return { authoritative: true, rows };
         },
+        async getMyPermissions() {
+            const data = await call("GET", "/v1/agents/me/permissions");
+            const byOperation = {};
+            let momentVisibility = [];
+            for (const [k, v] of Object.entries(data ?? {})) {
+                if (k === "moment.visibility")
+                    momentVisibility = v ?? [];
+                else
+                    byOperation[k] = v;
+            }
+            return { byOperation, momentVisibility };
+        },
     };
 }

package/dist/src/config.js

@@ -81,6 +81,7 @@ export const openclawClawlingConfigSchema = {
         forwardThinking: { type: "boolean" },
         forwardToolCalls: { type: "boolean" },
         richInteractions: { type: "boolean" },
+        awarenessNote: { type: "boolean" },
         reconnect: {
             type: "object",
             additionalProperties: false,
@@ -328,6 +329,7 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
     const forwardThinking = typeof channel.forwardThinking === "boolean" ? channel.forwardThinking : true;
     const forwardToolCalls = typeof channel.forwardToolCalls === "boolean" ? channel.forwardToolCalls : false;
     const richInteractions = typeof channel.richInteractions === "boolean" ? channel.richInteractions : false;
+    const awarenessNote = typeof channel.awarenessNote === "boolean" ? channel.awarenessNote : false;
     return {
         accountId: DEFAULT_ACCOUNT_ID,
         name: CHANNEL_ID,
@@ -353,6 +355,7 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
         forwardThinking,
         forwardToolCalls,
         richInteractions,
+        awarenessNote,
         allowFrom: [],
         reconnect: readReconnect(channel.reconnect),
         heartbeat: readHeartbeat(channel.heartbeat),

package/dist/src/friend-request-turn.js

@@ -0,0 +1,73 @@
+/**
+ * Synthetic reasoning-turn builder for `friend.request` notify.signal events.
+ *
+ * When the server fires a `friend.request` signal the runtime dispatches one
+ * deduped synthetic `message.send` envelope so the agent can reason about the
+ * pending request. The prompt text varies by the current "friend.add" permission
+ * policy state: a deny policy yields a decline/inform prompt; ask or allow
+ * yields a prompt that instructs the agent to review the request via the
+ * `clawchat_list_friend_requests` tool.
+ */
+import { EVENT } from "./protocol-types.js";
+/**
+ * Returns canned prompt text for a friend-request reasoning turn based on the
+ * current "friend.add" permission policy state.
+ *
+ * - `deny`  → inform the agent it should decline; no accept instruction.
+ * - `ask` / `allow` → instruct the agent to review the pending request.
+ */
+export function friendRequestPromptFor(state) {
+    if (state === "deny") {
+        return [
+            "A new friend request has arrived.",
+            "Your current friend-add policy is set to deny.",
+            "Do not add this contact.",
+            "You may inform the requester that you cannot add them at this time.",
+        ].join(" ");
+    }
+    return [
+        "A new friend request has arrived.",
+        "Please review the pending request by calling `clawchat_list_friend_requests`",
+        "and decide whether to accept it.",
+    ].join(" ");
+}
+/**
+ * Builds a synthetic `message.send` envelope that triggers one agent reasoning
+ * turn for a pending friend request. The envelope shape mirrors the
+ * activation-bootstrap envelope; it targets the owner's direct conversation so
+ * the agent has context about who it is reasoning for.
+ */
+export function buildFriendRequestEnvelope(params) {
+    const { account, state, entityId } = params;
+    const text = friendRequestPromptFor(state);
+    const now = Date.now();
+    return {
+        version: "2",
+        event: EVENT.MESSAGE_SEND,
+        trace_id: `clawchat-plugin-openclaw-friend-request-${entityId}-${now}`,
+        emitted_at: now,
+        chat_id: account.ownerUserId,
+        chat_type: "direct",
+        to: { id: account.userId, type: "direct" },
+        sender: {
+            id: "clawchat-friend-request",
+            type: "direct",
+            nick_name: "ClawChat",
+        },
+        payload: {
+            message_id: `clawchat-plugin-openclaw-friend-request-${entityId}-${now}`,
+            message_mode: "normal",
+            message: {
+                body: { fragments: [{ kind: "text", text }] },
+                context: { mentions: [], reply: null },
+                streaming: {
+                    status: "static",
+                    sequence: 0,
+                    mutation_policy: "sealed",
+                    started_at: null,
+                    completed_at: null,
+                },
+            },
+        },
+    };
+}

package/dist/src/gate-outcome.js

@@ -0,0 +1,26 @@
+/**
+ * Maps backend owner-approval gate codes to structured tool outcomes.
+ *
+ * Backend gate codes (confirmed live contract):
+ *   21001 — pending owner approval (payload: { request_id, operation, expires_at })
+ *   21003 — policy forbidden       (payload: { operation })
+ *
+ * Returns null for any other code so callers can fall through to normal handling.
+ */
+export function mapGateOutcome(code, data) {
+    if (code === 21001) {
+        return {
+            status: "pending_owner_approval",
+            request_id: typeof data.request_id === "string" ? data.request_id : "",
+            operation: typeof data.operation === "string" ? data.operation : "",
+            expires_at: typeof data.expires_at === "number" ? data.expires_at : 0,
+        };
+    }
+    if (code === 21003) {
+        return {
+            status: "forbidden_by_owner",
+            operation: typeof data.operation === "string" ? data.operation : "",
+        };
+    }
+    return null;
+}

package/dist/src/inbound.js

@@ -115,6 +115,17 @@ export async function dispatchOpenclawClawlingInbound(params) {
         return;
     }
     if (sender.id === "system") {
+        // Intercept `permission_result` receipts before the generic system-message
+        // drop. The discriminator is `payload.metadata.kind === "permission_result"`;
+        // all other system messages (group-join notifications, etc.) still drop.
+        const rawPayload = envelope.payload;
+        const meta = rawPayload.metadata;
+        if (params.consumePermissionResult &&
+            meta != null &&
+            meta.kind === "permission_result") {
+            await params.consumePermissionResult(meta);
+            return;
+        }
         log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw skip system message msg=${payload.message_id}`);
         return;
     }

package/dist/src/permission-result.js

@@ -0,0 +1,107 @@
+/**
+ * Consumer for `permission_result` system-message receipts.
+ *
+ * When the backend delivers a `permission_result` outcome as a
+ * `message.send` system frame (`sender.id="system"`, `payload.metadata.kind
+ * ="permission_result"`), this module deduplicates by `request_id` and
+ * produces a synthetic context-note turn so the agent can close the loop
+ * on the original permission request.
+ *
+ * Wire shape (authoritative):
+ * ```
+ * payload.metadata = {
+ *   kind: "permission_result",
+ *   operation: "friend.add",
+ *   outcome: "approved" | "denied" | "expired" | "failed",
+ *   reason: "owner_allowed" | …,
+ *   request_id: "prq_…",
+ * }
+ * ```
+ * The discriminator is `payload.metadata.kind === "permission_result"`.
+ */
+import { EVENT } from "./protocol-types.js";
+// Module-level dedup set — `request_id` values are stable backend identifiers.
+// A duplicate receipt (e.g. from WS replay on reconnect) must not re-trigger
+// an agent turn.
+const _seenRequestIds = new Set();
+/**
+ * @internal Test helper — reset the dedup set between isolated test runs.
+ * Never call this in production code.
+ */
+export function _resetPermissionResultDedup() {
+    _seenRequestIds.clear();
+}
+function buildOutcomeNote(metadata) {
+    const { operation, outcome, reason } = metadata;
+    const outcomeLabel = outcome === "approved"
+        ? "approved"
+        : outcome === "denied"
+            ? "denied"
+            : outcome === "expired"
+                ? "expired"
+                : "failed";
+    const resolution = outcome === "approved"
+        ? "The requested action has been completed."
+        : "No further action was taken.";
+    return [
+        `Permission request for operation "${operation}" has been ${outcomeLabel}.`,
+        `Reason: ${reason}.`,
+        resolution,
+    ].join(" ");
+}
+/**
+ * Builds a synthetic `message.send` envelope that delivers a
+ * `permission_result` context note to the agent.
+ *
+ * Mirrors the `buildFriendRequestEnvelope` pattern: a synthetic inbound
+ * `message.send` targeting the owner's direct conversation, routed through
+ * `handleInboundEnvelope` so the agent can reason about the outcome.
+ */
+export function buildPermissionResultEnvelope(params) {
+    const { account, metadata } = params;
+    const text = buildOutcomeNote(metadata);
+    const now = Date.now();
+    return {
+        version: "2",
+        event: EVENT.MESSAGE_SEND,
+        trace_id: `clawchat-plugin-openclaw-permission-result-${metadata.request_id}-${now}`,
+        emitted_at: now,
+        chat_id: account.ownerUserId,
+        chat_type: "direct",
+        to: { id: account.userId, type: "direct" },
+        sender: {
+            id: "clawchat-permission-result",
+            type: "direct",
+            nick_name: "ClawChat",
+        },
+        payload: {
+            message_id: `clawchat-plugin-openclaw-permission-result-${metadata.request_id}-${now}`,
+            message_mode: "normal",
+            message: {
+                body: { fragments: [{ kind: "text", text }] },
+                context: { mentions: [], reply: null },
+                streaming: {
+                    status: "static",
+                    sequence: 0,
+                    mutation_policy: "sealed",
+                    started_at: null,
+                    completed_at: null,
+                },
+            },
+        },
+    };
+}
+/**
+ * Handles a `permission_result` receipt. Deduplicates by `request_id`
+ * (idempotent — WS replay on reconnect may deliver the same receipt again).
+ *
+ * Returns a synthetic context-note {@link Envelope} on a fresh receipt so
+ * the caller can feed it to `handleInboundEnvelope`; returns `null` when
+ * the `request_id` has already been processed.
+ */
+export function handlePermissionResult(metadata, account) {
+    if (_seenRequestIds.has(metadata.request_id))
+        return null;
+    _seenRequestIds.add(metadata.request_id);
+    return buildPermissionResultEnvelope({ account, metadata });
+}

package/dist/src/permissions.js

@@ -0,0 +1,6 @@
+export class PermissionCache {
+    p = { byOperation: {}, momentVisibility: [] };
+    get() { return this.p; }
+    set(p) { this.p = p; }
+    stateOf(op) { return this.p.byOperation[op] ?? "ask"; }
+}

package/dist/src/runtime.js

@@ -28,6 +28,9 @@ import { clearClawChatPromptInjectionForSession, stageClawChatPromptInjection, }
 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 { buildFriendRequestEnvelope } from "./friend-request-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();
@@ -1381,6 +1384,7 @@ export async function startOpenclawClawlingGateway(params) {
         context: wsLogContext,
     });
     const groupSettingsCache = new GroupSettingsCache();
+    const permissionCache = new PermissionCache();
     // Findings 2 & 3 — gate group dispatch on the IN-FLIGHT settings pull, not just
     // the first one. The pull is fire-and-forget, so replayed/live group messages
     // could otherwise enter the governance gate against a stale/empty cache
@@ -1454,6 +1458,25 @@ export async function startOpenclawClawlingGateway(params) {
             }
         })();
     };
+    // Best-effort pull of the agent's permission policy from the backend.
+    // Called at startup (bypassRefresh: true, mirrors pullGroupSettings startup)
+    // and on every successful (re)connect after hello-ok. On failure, logs and
+    // keeps the stale cache — never throws, never blocks message handling.
+    const pullPermissions = (opts) => {
+        void (async () => {
+            try {
+                const policy = opts?.bypassRefresh
+                    ? await (conversationApiClient ??= buildConversationApiClient()).getMyPermissions()
+                    : await getConversationApiClient().getMyPermissions();
+                permissionCache.set(policy);
+                log?.info?.(`[${accountId}] clawchat-plugin-openclaw permissions pull ok ops=${Object.keys(policy.byOperation).length}`);
+            }
+            catch (err) {
+                log?.error?.(`[${accountId}] clawchat-plugin-openclaw permissions pull failed: ${err instanceof Error ? err.message : String(err)}`);
+                // Keep stale cache; never throw.
+            }
+        })();
+    };
     const logAuthFailure = (reason) => {
         if (authFailureLogged)
             return;
@@ -1585,6 +1608,8 @@ export async function startOpenclawClawlingGateway(params) {
             // Re-pull per-group agent settings on every successful (re)connect so the
             // cache stays current after a network interruption or token refresh.
             pullGroupSettings();
+            // Re-pull permission policy alongside group settings on every (re)connect.
+            pullPermissions();
             // §A.1 — arm the proactive refresh timer from the live token's `exp`
             // every time a connection becomes ready (re-armed after every refresh via
             // the gateway re-enter).
@@ -1796,6 +1821,10 @@ export async function startOpenclawClawlingGateway(params) {
             },
         });
     };
+    // Debounce flag for lighter-awareness consolidated notes.
+    // A single queueMicrotask coalesces all awareness signals that arrive in
+    // the same synchronous turn into exactly one handleInboundEnvelope call.
+    let pendingAwarenessNote = false;
     client.on("notify:signal", (env) => {
         // §9.4 reliable system notification. The plugin holds no friend/roster
         // cache (friends are fetched on demand via REST tools), so there is nothing
@@ -1807,10 +1836,15 @@ export async function startOpenclawClawlingGateway(params) {
                 ? env.payload
                 : undefined;
             const type = typeof payload?.type === "string" ? payload.type : "";
+            const entityId = typeof payload?.entity_id === "string" ? payload.entity_id : "";
             if (type === "agent.config.changed") {
                 log?.info?.(`[${accountId}] clawchat-plugin-openclaw agent.config.changed signal received; re-pulling group settings`);
                 pullGroupSettings();
             }
+            else if (type === "agent.permission.changed") {
+                log?.info?.(`[${accountId}] clawchat-plugin-openclaw agent.permission.changed signal received; re-pulling permissions`);
+                pullPermissions();
+            }
             else if (type === "clawchat.skill.update.check") {
                 // Content-free trigger: check the official skill source in code and, if
                 // there is an update, ask the owner in chat for consent. The atomic
@@ -1820,6 +1854,62 @@ 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 === "friend.request") {
+                // Dedup is already applied above by notifySignalObserver.observe (the live
+                // frame and its reliable-inbox replay share the same event_id and collapse
+                // to one observation). Build one synthetic reasoning turn so the agent can
+                // act on the pending request; the prompt text varies by policy state.
+                const state = permissionCache.stateOf("friend.add");
+                log?.info?.(`[${accountId}] clawchat-plugin-openclaw friend.request signal received; dispatching reasoning turn entity_id=${entityId} policy=${state}`);
+                void handleInboundEnvelope(buildFriendRequestEnvelope({ account, state, entityId }));
+            }
+            else if (type === "friend.added" ||
+                type === "friend.removed" ||
+                type === "friend.profile_updated" ||
+                type.startsWith("conversation.")) {
+                // Lighter-awareness: log + optional single consolidated note. Never
+                // injects a full reasoning turn per event (unlike friend.request).
+                log?.info?.(`[${accountId}] clawchat-plugin-openclaw ${type} signal received; lighter-awareness handling`);
+                if (account.awarenessNote && !pendingAwarenessNote) {
+                    pendingAwarenessNote = true;
+                    queueMicrotask(() => {
+                        pendingAwarenessNote = false;
+                        const now = Date.now();
+                        void handleInboundEnvelope({
+                            version: "2",
+                            event: EVENT.MESSAGE_SEND,
+                            trace_id: `clawchat-plugin-openclaw-awareness-${now}`,
+                            emitted_at: now,
+                            chat_id: account.ownerUserId,
+                            chat_type: "direct",
+                            to: { id: account.userId, type: "direct" },
+                            sender: { id: "clawchat-awareness", type: "direct", nick_name: "ClawChat" },
+                            payload: {
+                                message_id: `clawchat-plugin-openclaw-awareness-${now}`,
+                                message_mode: "normal",
+                                message: {
+                                    body: {
+                                        fragments: [
+                                            {
+                                                kind: "text",
+                                                text: "ClawChat awareness: your contacts or conversations have been updated.",
+                                            },
+                                        ],
+                                    },
+                                    context: { mentions: [], reply: null },
+                                    streaming: {
+                                        status: "static",
+                                        sequence: 0,
+                                        mutation_policy: "sealed",
+                                        started_at: null,
+                                        completed_at: null,
+                                    },
+                                },
+                            },
+                        });
+                    });
+                }
+            }
         }
     });
     client.on("replay:done", (env) => {
@@ -2439,6 +2529,16 @@ export async function startOpenclawClawlingGateway(params) {
                 account,
                 log,
                 consumeOwnerConsent: consumeOwnerSkillConsent,
+                consumePermissionResult: async (metadata) => {
+                    // A permission_result receipt closes the loop on an earlier request.
+                    // Dedup by request_id; on a fresh receipt feed the synthetic context
+                    // note back to the agent so it can react to the outcome.
+                    const note = handlePermissionResult(metadata, account);
+                    if (note) {
+                        log?.info?.(`[${accountId}] clawchat-plugin-openclaw permission_result receipt op=${metadata.operation} outcome=${metadata.outcome} request_id=${metadata.request_id}; dispatching context note`);
+                        void handleInboundEnvelope(note);
+                    }
+                },
                 ingest: async (turn) => {
                     ingestResult = await ingestTurn(turn);
                 },
@@ -2525,6 +2625,9 @@ export async function startOpenclawClawlingGateway(params) {
     // rotating `account.token` out from under the already-constructed WS client.
     // Settling this releases the Finding-2 group-dispatch gate.
     pullGroupSettings({ bypassRefresh: true });
+    // Initial pull of permission policy at startup (best-effort; errors logged,
+    // stale cache kept). Uses bypassRefresh for the same reason as pullGroupSettings.
+    pullPermissions({ bypassRefresh: true });
     // Safety: never strand a held group message if the runtime is torn down while a
     // pull is in flight. `waitWithTimeout` already releases group waiters on abort,
     // but force the gate open too so any later `wait()` resolves immediately.

package/dist/src/tools.js

@@ -4,6 +4,7 @@ import { execFile } from "node:child_process";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
 import { resolveLivewarePath } from "./liveware-cli.js";
 import { ClawlingApiError, } from "./api-types.js";
+import { mapGateOutcome } from "./gate-outcome.js";
 import { resolveOpenclawClawlingAccount } from "./config.js";
 import { clawChatDbPathForStateDir, getClawChatStore, } from "./storage.js";
 import { sendOpenclawClawlingMentionMessage } from "./outbound.js";
@@ -272,6 +273,38 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             }
         })();
     }
+    /**
+     * Like withClient, but maps gate codes (21001/21003) to structured outcomes
+     * via mapGateOutcome so the agent sees a clear pending/forbidden status
+     * instead of a generic error. Used for friend and moment mutation tools.
+     */
+    function withGatedClient(fn) {
+        return (async () => {
+            const built = buildClient();
+            if (!built.ok)
+                return built.error;
+            try {
+                const data = await fn(built.client);
+                return jsonResponse(data);
+            }
+            catch (err) {
+                if (err instanceof ClawlingApiError) {
+                    const code = typeof err.meta?.code === "number" ? err.meta.code : null;
+                    if (code !== null) {
+                        const rawData = err.meta?.data;
+                        const gateData = rawData !== null && rawData !== undefined && typeof rawData === "object"
+                            ? rawData
+                            : {};
+                        const outcome = mapGateOutcome(code, gateData);
+                        if (outcome !== null)
+                            return jsonResponse(outcome);
+                    }
+                    return apiError(err);
+                }
+                return genericError(err);
+            }
+        })();
+    }
     function workspaceRoot(ctx) {
         const root = typeof ctx.workspaceDir === "string" ? ctx.workspaceDir.trim() : "";
         return root || null;
@@ -640,7 +673,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
         async execute(_callId, params) {
             return await recordClawchatToolCall("clawchat_send_friend_request", params, async () => {
                 const p = params;
-                return await withClient((c) => c.sendFriendRequest(p));
+                return await withGatedClient((c) => c.sendFriendRequest(p));
             });
         },
     }, { name: "clawchat_send_friend_request" });
@@ -668,7 +701,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
         async execute(_callId, params) {
             return await recordClawchatToolCall("clawchat_accept_friend_request", params, async () => {
                 const p = params;
-                return await withClient((c) => c.acceptFriendRequest(p.requestId));
+                return await withGatedClient((c) => c.acceptFriendRequest(p.requestId));
             });
         },
     }, { name: "clawchat_accept_friend_request" });
@@ -682,7 +715,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
         async execute(_callId, params) {
             return await recordClawchatToolCall("clawchat_reject_friend_request", params, async () => {
                 const p = params;
-                return await withClient((c) => c.rejectFriendRequest(p.requestId));
+                return await withGatedClient((c) => c.rejectFriendRequest(p.requestId));
             });
         },
     }, { name: "clawchat_reject_friend_request" });
@@ -696,7 +729,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
         async execute(_callId, params) {
             return await recordClawchatToolCall("clawchat_remove_friend", params, async () => {
                 const p = params;
-                return await withClient((c) => c.removeFriend(p.friendUserId));
+                return await withGatedClient((c) => c.removeFriend(p.friendUserId));
             });
         },
     }, { name: "clawchat_remove_friend" });
@@ -841,7 +874,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                 if (!text && (!images || images.length === 0)) {
                     return validationError("clawchat-plugin-openclaw: at least one of text or images is required");
                 }
-                return await withClient((c) => c.createMoment({
+                return await withGatedClient((c) => c.createMoment({
                     ...(text !== undefined ? { text } : {}),
                     ...(images !== undefined ? { images } : {}),
                 }));
@@ -858,7 +891,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
         async execute(_callId, params) {
             return await recordClawchatToolCall("clawchat_delete_moment", params, async () => {
                 const p = params;
-                return await withClient((c) => c.deleteMoment(p.momentId));
+                return await withGatedClient((c) => c.deleteMoment(p.momentId));
             });
         },
     }, { name: "clawchat_delete_moment" });
@@ -875,7 +908,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                 if (!p.emoji?.trim()) {
                     return validationError("clawchat-plugin-openclaw: emoji is required");
                 }
-                return await withClient((c) => c.toggleMomentReaction({ momentId: p.momentId, emoji: p.emoji }));
+                return await withGatedClient((c) => c.toggleMomentReaction({ momentId: p.momentId, emoji: p.emoji }));
             });
         },
     }, { name: "clawchat_toggle_moment_reaction" });
@@ -892,7 +925,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                 if (!p.text?.trim()) {
                     return validationError("clawchat-plugin-openclaw: text is required");
                 }
-                return await withClient((c) => c.createMomentComment({ momentId: p.momentId, text: p.text }));
+                return await withGatedClient((c) => c.createMomentComment({ momentId: p.momentId, text: p.text }));
             });
         },
     }, { name: "clawchat_create_moment_comment" });
@@ -909,7 +942,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                 if (!p.text?.trim()) {
                     return validationError("clawchat-plugin-openclaw: text is required");
                 }
-                return await withClient((c) => c.replyMomentComment({
+                return await withGatedClient((c) => c.replyMomentComment({
                     momentId: p.momentId,
                     replyToCommentId: p.replyToCommentId,
                     text: p.text,
@@ -927,7 +960,7 @@ export function registerOpenclawClawlingTools(api, options = {}) {
         async execute(_callId, params) {
             return await recordClawchatToolCall("clawchat_delete_moment_comment", params, async () => {
                 const p = params;
-                return await withClient((c) => c.deleteMomentComment({ momentId: p.momentId, commentId: p.commentId }));
+                return await withGatedClient((c) => c.deleteMomentComment({ momentId: p.momentId, commentId: p.commentId }));
             });
         },
     }, { name: "clawchat_delete_moment_comment" });

package/dist/src/ws-client.js

@@ -84,6 +84,23 @@ export function createWebSocketTransport(WebSocketCtor = globalThis.WebSocket) {
         },
     };
 }
+/**
+ * Returns the capability set advertised in the connect handshake.
+ * Exported so tests can assert on the exact fields without a full WS setup.
+ *
+ * permission_events: forward-compat: advertises readiness for a future native
+ * `permission.receipt` wire frame; today the permission-decision receipt is
+ * delivered as a system message until msghub emits the native frame.
+ */
+export function buildConnectCapabilities() {
+    return {
+        multi_device: false,
+        device_replay: true,
+        chat_meta_events: true,
+        notify_signals: true,
+        permission_events: true,
+    };
+}
 export class ClawChatClient extends EventEmitter {
     opts;
     currentState = "idle";
@@ -333,12 +350,8 @@ export class ClawChatClient extends EventEmitter {
             // *send* history.transit, which a single-device agent never does, and we
             // do not handle inbound history.transit — advertising it would invite
             // frames we cannot process. This is a deliberate, spec-legal omission.
-            capabilities: {
-                multi_device: false,
-                device_replay: true,
-                chat_meta_events: true,
-                notify_signals: true,
-            },
+            // permission_events: forward-compat; see buildConnectCapabilities().
+            capabilities: buildConnectCapabilities(),
         };
         const traceId = this.nextTraceId();
         this.expectedConnectTraceId = traceId;

package/openclaw.plugin.json

@@ -107,6 +107,7 @@
       "forwardThinking": { "type": "boolean" },
       "forwardToolCalls": { "type": "boolean" },
       "richInteractions": { "type": "boolean" },
+      "awarenessNote": { "type": "boolean" },
       "reconnect": {
         "type": "object",
         "additionalProperties": false,
@@ -180,6 +181,7 @@
           "forwardThinking": { "type": "boolean" },
           "forwardToolCalls": { "type": "boolean" },
           "richInteractions": { "type": "boolean" },
+          "awarenessNote": { "type": "boolean" },
           "reconnect": {
             "type": "object",
             "additionalProperties": false,

package/package.json

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