@clawling/clawchat-plugin-openclaw 2026.7.8-2 → 2026.7.8-3

package/dist/src/awareness-note-turn.js

@@ -0,0 +1,47 @@
+/**
+ * Synthetic envelope builder for the lighter-awareness consolidated note
+ * (friend.added / friend.removed / friend.profile_updated / conversation.*).
+ *
+ * Like the friend-request turn, the note runs in the owner's direct
+ * conversation and must be addressed to the conversation id (cnv_…) recorded
+ * at activation. A usr_… id is not a valid chat_id — member-backend rejects it
+ * with "invalid conversation id" and msghub silently drops the agent's
+ * in-turn replies.
+ */
+import { EVENT } from "./protocol-types.js";
+export function buildAwarenessNoteEnvelope(params) {
+    const { account, ownerConversationId } = params;
+    const now = Date.now();
+    return {
+        version: "2",
+        event: EVENT.MESSAGE_SEND,
+        trace_id: `clawchat-plugin-openclaw-awareness-${now}`,
+        emitted_at: now,
+        chat_id: ownerConversationId ?? 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,
+                },
+            },
+        },
+    };
+}

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

@@ -15,18 +15,24 @@ import { EVENT } from "./protocol-types.js";
  *
  * - `deny`  → inform the agent it should decline; no accept instruction.
  * - `ask` / `allow` → instruct the agent to review the pending request.
+ *
+ * The requester's user id is embedded so the agent does not go looking up the
+ * synthetic sender ("clawchat-friend-request" is not a real user).
  */
-export function friendRequestPromptFor(state) {
+export function friendRequestPromptFor(state, requesterUserId) {
+    const arrived = requesterUserId
+        ? `A new friend request has arrived from user ${requesterUserId}.`
+        : "A new friend request has arrived.";
     if (state === "deny") {
         return [
-            "A new friend request has arrived.",
+            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.",
+        arrived,
         "Please review the pending request by calling `clawchat_list_friend_requests`",
         "and decide whether to accept it.",
     ].join(" ");
@@ -38,15 +44,19 @@ export function friendRequestPromptFor(state) {
  * the agent has context about who it is reasoning for.
  */
 export function buildFriendRequestEnvelope(params) {
-    const { account, state, entityId } = params;
-    const text = friendRequestPromptFor(state);
+    const { account, state, entityId, ownerConversationId } = params;
+    const text = friendRequestPromptFor(state, entityId);
     const now = Date.now();
+    // Fall back to ownerUserId only when no activation conversation is recorded:
+    // the turn still runs (the agent can act via tools, e.g. accept the request),
+    // but its in-chat replies will not be deliverable until activation records
+    // the owner conversation.
     return {
         version: "2",
         event: EVENT.MESSAGE_SEND,
         trace_id: `clawchat-plugin-openclaw-friend-request-${entityId}-${now}`,
         emitted_at: now,
-        chat_id: account.ownerUserId,
+        chat_id: ownerConversationId ?? account.ownerUserId,
         chat_type: "direct",
         to: { id: account.userId, type: "direct" },
         sender: {

package/dist/src/runtime.js

@@ -33,6 +33,7 @@ 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 { buildAwarenessNoteEnvelope } 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 };
@@ -2008,8 +2009,15 @@ export async function startOpenclawClawlingGateway(params) {
                 // 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");
+                // Address the turn to the activation-recorded owner conversation
+                // (cnv_…) — a usr_… chat_id is rejected by member-backend, so the
+                // agent's in-turn replies would be silently dropped by msghub.
+                const ownerConversationId = resolveOwnerDirectConversationId();
+                if (!ownerConversationId) {
+                    log?.info?.(`[${accountId}] clawchat-plugin-openclaw friend.request turn has no activation conversation on record; in-turn replies will not be deliverable`);
+                }
                 log?.info?.(`[${accountId}] clawchat-plugin-openclaw friend.request signal received; dispatching reasoning turn entity_id=${entityId} policy=${state}`);
-                void handleInboundEnvelope(buildFriendRequestEnvelope({ account, state, entityId }));
+                void handleInboundEnvelope(buildFriendRequestEnvelope({ account, state, entityId, ownerConversationId }));
             }
             else if (type === "friend.added" ||
                 type === "friend.removed" ||
@@ -2022,39 +2030,10 @@ export async function startOpenclawClawlingGateway(params) {
                     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,
-                                    },
-                                },
-                            },
-                        });
+                        void handleInboundEnvelope(buildAwarenessNoteEnvelope({
+                            account,
+                            ownerConversationId: resolveOwnerDirectConversationId(),
+                        }));
                     });
                 }
             }

package/package.json

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

package/src/awareness-note-turn.ts

@@ -0,0 +1,61 @@
+/**
+ * Synthetic envelope builder for the lighter-awareness consolidated note
+ * (friend.added / friend.removed / friend.profile_updated / conversation.*).
+ *
+ * Like the friend-request turn, the note runs in the owner's direct
+ * conversation and must be addressed to the conversation id (cnv_…) recorded
+ * at activation. A usr_… id is not a valid chat_id — member-backend rejects it
+ * with "invalid conversation id" and msghub silently drops the agent's
+ * in-turn replies.
+ */
+import { EVENT, type Envelope } from "./protocol-types.ts";
+import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
+
+export interface BuildAwarenessNoteEnvelopeParams {
+  account: ResolvedOpenclawClawlingAccount;
+  /**
+   * The owner's direct conversation id (cnv_…) recorded at activation, or
+   * null when none is recorded (the note still runs, but replies will not be
+   * deliverable until activation records the owner conversation).
+   */
+  ownerConversationId: string | null;
+}
+
+export function buildAwarenessNoteEnvelope(
+  params: BuildAwarenessNoteEnvelopeParams,
+): Envelope {
+  const { account, ownerConversationId } = params;
+  const now = Date.now();
+  return {
+    version: "2",
+    event: EVENT.MESSAGE_SEND,
+    trace_id: `clawchat-plugin-openclaw-awareness-${now}`,
+    emitted_at: now,
+    chat_id: ownerConversationId ?? 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,
+        },
+      },
+    },
+  } as unknown as Envelope;
+}

package/src/friend-request-turn.ts

@@ -18,18 +18,24 @@ import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
  *
  * - `deny`  → inform the agent it should decline; no accept instruction.
  * - `ask` / `allow` → instruct the agent to review the pending request.
+ *
+ * The requester's user id is embedded so the agent does not go looking up the
+ * synthetic sender ("clawchat-friend-request" is not a real user).
  */
-export function friendRequestPromptFor(state: PermState): string {
+export function friendRequestPromptFor(state: PermState, requesterUserId?: string): string {
+  const arrived = requesterUserId
+    ? `A new friend request has arrived from user ${requesterUserId}.`
+    : "A new friend request has arrived.";
   if (state === "deny") {
     return [
-      "A new friend request has arrived.",
+      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.",
+    arrived,
     "Please review the pending request by calling `clawchat_list_friend_requests`",
     "and decide whether to accept it.",
   ].join(" ");
@@ -41,6 +47,13 @@ export interface BuildFriendRequestEnvelopeParams {
   state: PermState;
   /** entity_id from the notify.signal payload (the requesting user). */
   entityId: string;
+  /**
+   * The owner's direct conversation id (cnv_…) recorded at activation, or null
+   * when none is recorded. A usr_… id is not a valid chat_id — member-backend
+   * rejects it with "invalid conversation id" and the agent's in-turn replies
+   * are silently dropped by msghub — so the envelope must target this id.
+   */
+  ownerConversationId: string | null;
 }
 
 /**
@@ -52,15 +65,19 @@ export interface BuildFriendRequestEnvelopeParams {
 export function buildFriendRequestEnvelope(
   params: BuildFriendRequestEnvelopeParams,
 ): Envelope {
-  const { account, state, entityId } = params;
-  const text = friendRequestPromptFor(state);
+  const { account, state, entityId, ownerConversationId } = params;
+  const text = friendRequestPromptFor(state, entityId);
   const now = Date.now();
+  // Fall back to ownerUserId only when no activation conversation is recorded:
+  // the turn still runs (the agent can act via tools, e.g. accept the request),
+  // but its in-chat replies will not be deliverable until activation records
+  // the owner conversation.
   return {
     version: "2",
     event: EVENT.MESSAGE_SEND,
     trace_id: `clawchat-plugin-openclaw-friend-request-${entityId}-${now}`,
     emitted_at: now,
-    chat_id: account.ownerUserId,
+    chat_id: ownerConversationId ?? account.ownerUserId,
     chat_type: "direct",
     to: { id: account.userId, type: "direct" },
     sender: {

package/src/runtime.ts

@@ -85,6 +85,7 @@ import { openclawLlmContextDebug } from "./llm-context-debug.ts";
 import { GroupSettingsCache } from "./group-settings.ts";
 import { PermissionCache } from "./permissions.ts";
 import { buildFriendRequestEnvelope } from "./friend-request-turn.ts";
+import { buildAwarenessNoteEnvelope } from "./awareness-note-turn.ts";
 import { handlePermissionResult } from "./permission-result.ts";
 
 type Log = { debug?: (m: string) => void; info?: (m: string) => void; error?: (m: string) => void };
@@ -2422,10 +2423,21 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         // 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");
+        // Address the turn to the activation-recorded owner conversation
+        // (cnv_…) — a usr_… chat_id is rejected by member-backend, so the
+        // agent's in-turn replies would be silently dropped by msghub.
+        const ownerConversationId = resolveOwnerDirectConversationId();
+        if (!ownerConversationId) {
+          log?.info?.(
+            `[${accountId}] clawchat-plugin-openclaw friend.request turn has no activation conversation on record; in-turn replies will not be deliverable`,
+          );
+        }
         log?.info?.(
           `[${accountId}] clawchat-plugin-openclaw friend.request signal received; dispatching reasoning turn entity_id=${entityId} policy=${state}`,
         );
-        void handleInboundEnvelope(buildFriendRequestEnvelope({ account, state, entityId }));
+        void handleInboundEnvelope(
+          buildFriendRequestEnvelope({ account, state, entityId, ownerConversationId }),
+        );
       } else if (
         type === "friend.added" ||
         type === "friend.removed" ||
@@ -2441,39 +2453,12 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           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,
-                  },
-                },
-              },
-            } as unknown as Envelope);
+            void handleInboundEnvelope(
+              buildAwarenessNoteEnvelope({
+                account,
+                ownerConversationId: resolveOwnerDirectConversationId(),
+              }),
+            );
           });
         }
       }