@clawling/clawchat-plugin-openclaw 2026.8.5-2 → 2026.8.14-1

package/dist/src/inbound.js

@@ -1,4 +1,4 @@
-import { EVENT, } from "./protocol-types.js";
+import { EVENT, MENTION_ALL_USER_ID, } from "./protocol-types.js";
 import { extractMediaFragments, fragmentsToText } from "./message-mapper.js";
 import { hasRenderableText, isInboundMessagePayload } from "./protocol.js";
 function normalizeSender(sender) {
@@ -73,11 +73,16 @@ function mentionedUserIds(mentions) {
 /**
  * Exported for direct unit testing. Direct chats always count as addressed;
  * group chats require a mention unless config opts into all group messages.
+ *
+ * `MENTION_ALL_USER_ID` ("all") is the `@everyone` sentinel — it addresses
+ * every member of the room, this agent included, so it counts as a mention
+ * even though it never equals our own user id.
  */
 export function detectMention(params) {
     if (params.chatType === "direct")
         return true;
-    return mentionedUserIds(normalizeMentionUsers(params.mentions)).includes(params.userId);
+    const ids = mentionedUserIds(normalizeMentionUsers(params.mentions));
+    return ids.includes(params.userId) || ids.includes(MENTION_ALL_USER_ID);
 }
 export async function dispatchOpenclawClawlingInbound(params) {
     const { envelope, account, log } = params;

package/dist/src/protocol-types.js

@@ -22,6 +22,14 @@ export const EVENT = {
     PING: "ping",
     PONG: "pong",
 };
+/**
+ * The `user_id` an `@everyone` mention carries on the wire — a reserved
+ * sentinel, not a real user id. The server never expands it into one mention
+ * per member, so every reader must decide for itself that it includes them.
+ * It can appear both as a `mention` fragment and as a `context.mentions`
+ * element. See `docs/client-integration.md` §10.2.
+ */
+export const MENTION_ALL_USER_ID = "all";
 export class AuthError extends Error {
     name = "AuthError";
 }

package/dist/src/runtime.js

@@ -13,6 +13,7 @@ import { ClawlingApiError } from "./api-types.js";
 import { RefreshManager } from "./refresh-manager.js";
 import { runOpenclawClawlingLogin, } from "./login.runtime.js";
 import { CHANNEL_ID, effectiveOutputVisibility, effectiveGroupCommandMode, effectiveGroupMode, hasOpenclawClawlingConnectCredentials, resolveOpenclawClawlingAccount, } from "./config.js";
+import { isValidChatId } from "./ws-client.js";
 import { dispatchOpenclawClawlingInbound } from "./inbound.js";
 import { PendingConsentStore, cleanupTombstonedManagedSkills, handleOwnerConsentReply, managedSkillExists, readLocalSkillState, resolveBundledSkillsDir, resolveManagedSkillsDir, runSkillUpdateCheck, } from "./skill-update.js";
 import { fetchInboundMedia } from "./media-runtime.js";
@@ -321,6 +322,22 @@ function withClawChatSessionScope(cfg) {
         },
     };
 }
+/**
+ * Synthetic envelope builder for the post-activation greeting turn.
+ *
+ * The fourth synthetic INBOUND envelope carrying a chat_id, alongside
+ * `buildPermissionResultEnvelope`, `buildAwarenessNoteEnvelope` and the
+ * reply-dispatcher's owner-direct path — and it carries the same invariant.
+ *
+ * `conversationId` MUST be a conversation idcode (`cnv_…`, `isValidChatId`),
+ * the one recorded at activation from `agents/connect`'s `conversation.id`.
+ * The agent's in-turn reply INHERITS this envelope's chat_id
+ * (src/inbound.ts → runtime.dispatch → src/reply-dispatcher.ts), and msghub
+ * resolves a chat_id only through member-backend — anything else comes back
+ * "invalid conversation id", so the greeting is refused at the outbound
+ * boundary after a full LLM turn has already been spent. Callers must check at
+ * the source and skip rather than hand an unroutable id down here.
+ */
 function buildActivationBootstrapEnvelope(params) {
     const text = buildActivationBootstrapText();
     const now = Date.now();
@@ -2845,6 +2862,18 @@ export async function startOpenclawClawlingGateway(params) {
                 return;
             }
             const claimedBootstrap = bootstrap;
+            // The claimed id is about to become the chat_id of a synthetic INBOUND
+            // envelope, and the agent's in-turn reply inherits it. A statically
+            // invalid one can never be delivered — and unlike a dead chat it can
+            // never become valid either — so skip it here instead of buying a full
+            // LLM turn whose answer the outbound boundary will refuse. Release the
+            // claim (a later re-login can record a real conversation id) but do NOT
+            // arm a retry: retrying an unroutable id would just loop.
+            if (!isValidChatId(claimedBootstrap.conversationId)) {
+                log?.error?.(`[${accountId}] clawchat-plugin-openclaw activation bootstrap skipped: chat_id="${claimedBootstrap.conversationId}" reason=invalid_chat_id`);
+                releaseBootstrap();
+                return;
+            }
             claimedInFlight = true;
             incrementActivationBootstrapInFlight(accountId);
             bootstrapGreetingDelivered = false;

package/dist/src/ws-client.js

@@ -131,6 +131,28 @@ export const SERVER_REJECTION_TTL_MS = 600_000;
  * MUST stay identical to the hermes plugin's `CHAT_ID_PREFIX`.
  */
 export const CHAT_ID_PREFIX = "cnv_";
+/**
+ * Total length of a conversation id: 3-char prefix + `_` + 26-char body.
+ *
+ * member-backend mints every id as `<prefix>_<26 Crockford base32 chars of a
+ * UUID v7>` and its validator refuses anything of another length outright, so
+ * the length is part of the contract, not a coincidence.
+ */
+const CHAT_ID_LENGTH = 30;
+/**
+ * Crockford base32 — the alphabet member-backend encodes the 128-bit id body
+ * with. `I`, `L`, `O` and `U` are deliberately absent (they read as `1`, `1`,
+ * `0` and `V`), and member-backend's decoder does NOT fold them in: it fails.
+ *
+ * Decoding is case-insensitive there, so both cases are accepted here. The
+ * 3-char prefix is NOT: it must be lowercase `a`..`z`, which `CHAT_ID_PREFIX`
+ * already pins.
+ */
+const CROCKFORD_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const CROCKFORD_SYMBOLS = new Set([
+    ...CROCKFORD_ALPHABET,
+    ...CROCKFORD_ALPHABET.toLowerCase(),
+]);
 /**
  * Whether `chatId` can name a ClawChat conversation at all.
  *
@@ -138,9 +160,30 @@ export const CHAT_ID_PREFIX = "cnv_";
  * exists, is alive, or admits this sender. Those are server-side questions
  * answered by `message.error`; this one is answerable locally, and a frame that
  * fails it is always wrong to put on the wire.
+ *
+ * Mirrors member-backend's own id validator, which is the only authority on the
+ * shape. The prefix alone is NOT the rule: `cnv_…:thr_1`, a bare `cnv_`, and a
+ * `cnv_`-prefixed display name all pass a prefix test and are still answered
+ * with `code=400: invalid conversation id`.
+ *
+ * MUST stay equivalent to the hermes plugin's validator; the shared fixture
+ * `src/__fixtures__/permission-events/invalid-chat-id-outbound.json` pins the
+ * rule and the samples for both.
  */
 export function isValidChatId(chatId) {
-    return typeof chatId === "string" && chatId.startsWith(CHAT_ID_PREFIX);
+    if (typeof chatId !== "string")
+        return false;
+    // Pins bytes 0-2 (the lowercase `cnv` prefix) and byte 3 (the `_`
+    // separator) in one check; the length pins the 26-char body.
+    if (chatId.length !== CHAT_ID_LENGTH)
+        return false;
+    if (!chatId.startsWith(CHAT_ID_PREFIX))
+        return false;
+    for (let i = CHAT_ID_PREFIX.length; i < CHAT_ID_LENGTH; i++) {
+        if (!CROCKFORD_SYMBOLS.has(chatId[i]))
+            return false;
+    }
+    return true;
 }
 export class ClawChatClient extends EventEmitter {
     opts;
@@ -374,7 +417,14 @@ export class ClawChatClient extends EventEmitter {
         // valid. Rejecting at this entry point is therefore sufficient: the frame
         // never reaches the reconnect queue, so no replay path can resurrect it.
         //
-        // Frames with no chat_id (connect / ping / pong) are untouched.
+        // Frames with no chat_id (connect / ping / pong) are untouched. The test is
+        // `!== undefined`, NOT a truthiness check, and that asymmetry is the
+        // contract: a chat_id that is ABSENT means "this event has no conversation"
+        // and passes, while one that is PRESENT-but-unusable — explicit `null`,
+        // `""`, a malformed id — is a frame that meant to address a conversation
+        // and named none, so it is dropped. msghub agrees: it decodes a JSON null
+        // into the empty string and every business event requires a non-empty
+        // chat_id.
         if (env.chat_id !== undefined && !isValidChatId(env.chat_id))
             return;
         this.sendWire(JSON.stringify(env), { bypassReconnectQueue: env.event === EVENT.CONNECT });

package/package.json

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

package/prompts/default-group-bio.md

@@ -1,19 +1,28 @@
-## What Kind Of Group This Is
+## What kind of group this is
 
-- Until more specific guidance is available, treat this as an ordinary social group in the owner's circle.
-- Group members may chat naturally, share updates, discuss ideas, coordinate timing, or move small plans forward.
-- Infer the group's tone from how members speak to each other instead of assuming it is a meeting, ticket queue, or task space.
+- Until you know otherwise, treat this as an ordinary social group in the
+  owner's circle.
+- Members may chat, share news, kick ideas around, or make small plans together.
+- Read the group's tone from how members actually talk to each other. Do not
+  assume it is a meeting, a ticket queue, or a task board.
 
-## How The Agent Should Participate
+## How to take part
 
-- Reply briefly and directly when mentioned, explicitly asked, or when you can add useful information.
-- Answer clear factual, background, or option-setting questions when you can.
-- When a multi-person discussion becomes scattered, lightly summarize the current topic, agreements, or open questions.
-- Otherwise, prefer listening; the default reply density for this group is low, and most messages do not need you.
+- Reply briefly and directly when you are mentioned, asked a question outright,
+  or can add something the group does not already have.
+- Answer factual or background questions, and help weigh options, when you can
+  do it clearly.
+- When a discussion has scattered, a short recap of the topic, what has been
+  agreed, and what is still open can help. Offer it once; do not chair the
+  conversation.
+- Otherwise, listen. Most messages here do not need you.
 
-## What To Be Especially Careful About
+## What to be careful about here
 
-- Do not bring private details from direct chats, other groups, or owner memory about a member into this group.
-- Do not reply to other bots or agents in the group, even if they mention you.
-- Do not take public-facing action for the owner in or about this group unless the owner explicitly agrees.
-- Do not force casual conversation into task tracking or take over a topic when members have not asked for that.
+- Do not bring private detail about a member into this group — not from a direct
+  chat, not from another group, not from the owner's memory.
+- Do not reply to other bots or agents here, even when they mention you.
+- Do not act publicly for the owner in or about this group unless they clearly
+  agreed.
+- Do not turn casual conversation into task tracking, and do not take over a
+  topic nobody asked you to run.

package/prompts/default-owner-behavior.md

@@ -1,27 +1,31 @@
-## What You Should Aim For
+## How to be here
 
-- Be present in conversation with warmth and attention.
-- Treat people in the owner's circle as specific people, not as tasks to process:
-  - Pick up on what mattered to them last time.
-  - Continue relationships that have already been established.
-  - Avoid making every interaction feel like it starts from zero.
-- Remember preferences the owner has already expressed, and follow them without making the owner repeat the same request.
+- Be present with warmth and attention. These are specific people, not tasks to
+  process: pick up what mattered to them last time, continue the relationship
+  that already exists, and do not act as if every conversation starts from zero.
+- Remember what the owner has already told you and act on it, rather than making
+  them say it again.
 
-## Where You Have Room To Act
+## Where you can act on your own
 
-- In the current direct chat, respond naturally and maintain relationship context without asking the owner about every small step.
-- When someone asks a factual, contextual, option-setting, or organizing question, help clearly and concisely.
-- In group chats, listen by default; speak when addressed, explicitly asked, or when you can materially help move the discussion forward.
-- Build and maintain social memory for the people you meet while using that memory only in the appropriate context.
+- In a direct chat, respond naturally and keep the relationship going without
+  checking in about every small thing.
+- When someone asks for facts, background, or help weighing options, answer
+  clearly and briefly.
+- In a group, listen by default. Speak when you are mentioned, asked directly,
+  or can genuinely move the discussion forward.
+- Build up what you know about the people you meet — and use it only where it
+  belongs.
 
-## What You Should Avoid
+## What to avoid
 
-- Do not take outward-facing action for the owner unless the owner explicitly agrees, for example:
-  - Making promises or commitments.
-  - Inviting people or adding them to groups.
-  - Contacting someone.
-  - Publishing something publicly.
-  - Changing profile information.
-  - Sending important messages.
-- Do not pretend to be the owner; when you do not know what the owner would think, say you are unsure or ask the person to wait for owner confirmation.
-- Do not bring private details from direct chats, other groups, or owner memory into contexts where they do not belong.
+- Do not take outward-facing action on the owner's behalf unless they clearly
+  agreed: making promises or accepting arrangements, inviting people, joining or
+  adding people to groups, contacting someone, publishing publicly, changing
+  profile information, sending a message that matters.
+- Do not pretend to know what the owner would think. When you are unsure, say
+  so, or ask the other person to wait for the owner.
+- **Do not carry private detail across contexts.** What you learned in a direct
+  chat does not belong in a group; what one group said does not belong in
+  another; what is in the owner's memory does not belong in front of their
+  friends. This is the one mistake here that cannot be taken back.

package/src/inbound.ts

@@ -1,5 +1,6 @@
 import {
   EVENT,
+  MENTION_ALL_USER_ID,
   type ChatType,
   type Envelope,
 } from "./protocol-types.ts";
@@ -180,6 +181,10 @@ function mentionedUserIds(mentions: MentionedUser[]): string[] {
 /**
  * Exported for direct unit testing. Direct chats always count as addressed;
  * group chats require a mention unless config opts into all group messages.
+ *
+ * `MENTION_ALL_USER_ID` ("all") is the `@everyone` sentinel — it addresses
+ * every member of the room, this agent included, so it counts as a mention
+ * even though it never equals our own user id.
  */
 export function detectMention(params: {
   mentions: unknown[];
@@ -187,7 +192,8 @@ export function detectMention(params: {
   userId: string;
 }): boolean {
   if (params.chatType === "direct") return true;
-  return mentionedUserIds(normalizeMentionUsers(params.mentions)).includes(params.userId);
+  const ids = mentionedUserIds(normalizeMentionUsers(params.mentions));
+  return ids.includes(params.userId) || ids.includes(MENTION_ALL_USER_ID);
 }
 
 export async function dispatchOpenclawClawlingInbound(

package/src/protocol-types.ts

@@ -23,6 +23,15 @@ export const EVENT = {
   PONG: "pong",
 } as const;
 
+/**
+ * The `user_id` an `@everyone` mention carries on the wire — a reserved
+ * sentinel, not a real user id. The server never expands it into one mention
+ * per member, so every reader must decide for itself that it includes them.
+ * It can appear both as a `mention` fragment and as a `context.mentions`
+ * element. See `docs/client-integration.md` §10.2.
+ */
+export const MENTION_ALL_USER_ID = "all";
+
 export type KnownEventName = typeof EVENT[keyof typeof EVENT];
 export type EventName = KnownEventName | string;
 export type ChatType = "direct" | "group";

package/src/runtime.ts

@@ -40,7 +40,7 @@ import {
   resolveOpenclawClawlingAccount,
   type ResolvedOpenclawClawlingAccount,
 } from "./config.ts";
-import type { ClawlingChatClient } from "./ws-client.ts";
+import { isValidChatId, type ClawlingChatClient } from "./ws-client.ts";
 import { dispatchOpenclawClawlingInbound, type IngestTurnParams } from "./inbound.ts";
 import {
   PendingConsentStore,
@@ -479,6 +479,22 @@ function withClawChatSessionScope(cfg: OpenClawConfig): OpenClawConfig {
   };
 }
 
+/**
+ * Synthetic envelope builder for the post-activation greeting turn.
+ *
+ * The fourth synthetic INBOUND envelope carrying a chat_id, alongside
+ * `buildPermissionResultEnvelope`, `buildAwarenessNoteEnvelope` and the
+ * reply-dispatcher's owner-direct path — and it carries the same invariant.
+ *
+ * `conversationId` MUST be a conversation idcode (`cnv_…`, `isValidChatId`),
+ * the one recorded at activation from `agents/connect`'s `conversation.id`.
+ * The agent's in-turn reply INHERITS this envelope's chat_id
+ * (src/inbound.ts → runtime.dispatch → src/reply-dispatcher.ts), and msghub
+ * resolves a chat_id only through member-backend — anything else comes back
+ * "invalid conversation id", so the greeting is refused at the outbound
+ * boundary after a full LLM turn has already been spent. Callers must check at
+ * the source and skip rather than hand an unroutable id down here.
+ */
 function buildActivationBootstrapEnvelope(params: {
   account: ResolvedOpenclawClawlingAccount;
   conversationId: string;
@@ -3379,6 +3395,20 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         return;
       }
       const claimedBootstrap = bootstrap;
+      // The claimed id is about to become the chat_id of a synthetic INBOUND
+      // envelope, and the agent's in-turn reply inherits it. A statically
+      // invalid one can never be delivered — and unlike a dead chat it can
+      // never become valid either — so skip it here instead of buying a full
+      // LLM turn whose answer the outbound boundary will refuse. Release the
+      // claim (a later re-login can record a real conversation id) but do NOT
+      // arm a retry: retrying an unroutable id would just loop.
+      if (!isValidChatId(claimedBootstrap.conversationId)) {
+        log?.error?.(
+          `[${accountId}] clawchat-plugin-openclaw activation bootstrap skipped: chat_id="${claimedBootstrap.conversationId}" reason=invalid_chat_id`,
+        );
+        releaseBootstrap();
+        return;
+      }
       claimedInFlight = true;
       incrementActivationBootstrapInFlight(accountId);
       bootstrapGreetingDelivered = false;

package/src/ws-client.ts

@@ -202,6 +202,30 @@ export const SERVER_REJECTION_TTL_MS = 600_000;
  */
 export const CHAT_ID_PREFIX = "cnv_";
 
+/**
+ * Total length of a conversation id: 3-char prefix + `_` + 26-char body.
+ *
+ * member-backend mints every id as `<prefix>_<26 Crockford base32 chars of a
+ * UUID v7>` and its validator refuses anything of another length outright, so
+ * the length is part of the contract, not a coincidence.
+ */
+const CHAT_ID_LENGTH = 30;
+
+/**
+ * Crockford base32 — the alphabet member-backend encodes the 128-bit id body
+ * with. `I`, `L`, `O` and `U` are deliberately absent (they read as `1`, `1`,
+ * `0` and `V`), and member-backend's decoder does NOT fold them in: it fails.
+ *
+ * Decoding is case-insensitive there, so both cases are accepted here. The
+ * 3-char prefix is NOT: it must be lowercase `a`..`z`, which `CHAT_ID_PREFIX`
+ * already pins.
+ */
+const CROCKFORD_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const CROCKFORD_SYMBOLS: ReadonlySet<string> = new Set([
+  ...CROCKFORD_ALPHABET,
+  ...CROCKFORD_ALPHABET.toLowerCase(),
+]);
+
 /**
  * Whether `chatId` can name a ClawChat conversation at all.
  *
@@ -209,9 +233,26 @@ export const CHAT_ID_PREFIX = "cnv_";
  * exists, is alive, or admits this sender. Those are server-side questions
  * answered by `message.error`; this one is answerable locally, and a frame that
  * fails it is always wrong to put on the wire.
+ *
+ * Mirrors member-backend's own id validator, which is the only authority on the
+ * shape. The prefix alone is NOT the rule: `cnv_…:thr_1`, a bare `cnv_`, and a
+ * `cnv_`-prefixed display name all pass a prefix test and are still answered
+ * with `code=400: invalid conversation id`.
+ *
+ * MUST stay equivalent to the hermes plugin's validator; the shared fixture
+ * `src/__fixtures__/permission-events/invalid-chat-id-outbound.json` pins the
+ * rule and the samples for both.
  */
 export function isValidChatId(chatId: unknown): chatId is string {
-  return typeof chatId === "string" && chatId.startsWith(CHAT_ID_PREFIX);
+  if (typeof chatId !== "string") return false;
+  // Pins bytes 0-2 (the lowercase `cnv` prefix) and byte 3 (the `_`
+  // separator) in one check; the length pins the 26-char body.
+  if (chatId.length !== CHAT_ID_LENGTH) return false;
+  if (!chatId.startsWith(CHAT_ID_PREFIX)) return false;
+  for (let i = CHAT_ID_PREFIX.length; i < CHAT_ID_LENGTH; i++) {
+    if (!CROCKFORD_SYMBOLS.has(chatId[i]!)) return false;
+  }
+  return true;
 }
 
 /**
@@ -468,7 +509,14 @@ export class ClawChatClient extends EventEmitter {
     // valid. Rejecting at this entry point is therefore sufficient: the frame
     // never reaches the reconnect queue, so no replay path can resurrect it.
     //
-    // Frames with no chat_id (connect / ping / pong) are untouched.
+    // Frames with no chat_id (connect / ping / pong) are untouched. The test is
+    // `!== undefined`, NOT a truthiness check, and that asymmetry is the
+    // contract: a chat_id that is ABSENT means "this event has no conversation"
+    // and passes, while one that is PRESENT-but-unusable — explicit `null`,
+    // `""`, a malformed id — is a frame that meant to address a conversation
+    // and named none, so it is dropped. msghub agrees: it decodes a JSON null
+    // into the empty string and every business event requires a non-empty
+    // chat_id.
     if (env.chat_id !== undefined && !isValidChatId(env.chat_id)) return;
     this.sendWire(JSON.stringify(env), { bypassReconnectQueue: env.event === EVENT.CONNECT });
   }