@newbase-clawchat/openclaw-clawchat 2026.5.12-2 → 2026.5.12-21

package/src/config.test.ts

@@ -5,6 +5,8 @@ import {
   DEFAULT_BASE_URL,
   DEFAULT_WEBSOCKET_URL,
   DEFAULT_STREAM,
+  effectiveGroupCommandMode,
+  effectiveGroupMode,
   mergeOpenclawClawchatToolAllow,
   resolveOpenclawClawlingAccount,
   listOpenclawClawlingAccountIds,
@@ -20,7 +22,9 @@ describe("openclaw-clawchat config", () => {
     expect(account.accountId).toBe(DEFAULT_ACCOUNT_ID);
     expect(account.enabled).toBe(true);
     expect(account.configured).toBe(false);
-    expect(account.replyMode).toBe("static");
+    expect(account.replyMode).toBe("stream");
+    expect(account.groupMode).toBe("all");
+    expect(account.groupCommandMode).toBe("owner");
     expect(account.forwardThinking).toBe(true);
     expect(account.forwardToolCalls).toBe(false);
     expect(account.richInteractions).toBe(false);
@@ -33,7 +37,9 @@ describe("openclaw-clawchat config", () => {
         "openclaw-clawchat": {
           websocketUrl: "wss://chat.example.com/ws",
           token: "secret",
+          agentId: "agt-1",
           userId: "agent-1",
+          ownerUserId: "owner-1",
           replyMode: "stream",
           forwardThinking: false,
           forwardToolCalls: true,
@@ -46,7 +52,9 @@ describe("openclaw-clawchat config", () => {
     expect(account.configured).toBe(true);
     expect(account.websocketUrl).toBe("wss://chat.example.com/ws");
     expect(account.token).toBe("secret");
+    expect(account.agentId).toBe("agt-1");
     expect(account.userId).toBe("agent-1");
+    expect(account.ownerUserId).toBe("owner-1");
     expect(account.replyMode).toBe("stream");
     expect(account.forwardThinking).toBe(false);
     expect(account.forwardToolCalls).toBe(true);
@@ -56,12 +64,29 @@ describe("openclaw-clawchat config", () => {
     expect(account.stream.maxBufferChars).toBe(3000);
   });
 
+  it("does not use userId as an ownerUserId fallback", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "openclaw-clawchat": {
+          token: "secret",
+          userId: "agent-user-id",
+        },
+      },
+    });
+
+    expect(account.userId).toBe("agent-user-id");
+    expect(account.ownerUserId).not.toBe("agent-user-id");
+    expect(account.configured).toBe(false);
+  });
+
   it("resolves credentials from ClawChat environment variables when config omits them", () => {
     const account = resolveOpenclawClawlingAccount(
       {},
       {
         CLAWCHAT_TOKEN: "env-token",
+        CLAWCHAT_AGENT_ID: "env-agent",
         CLAWCHAT_USER_ID: "env-user",
+        CLAWCHAT_OWNER_USER_ID: "env-owner",
         CLAWCHAT_BASE_URL: "https://api.env.example",
         CLAWCHAT_WEBSOCKET_URL: "wss://ws.env.example/ws",
       },
@@ -69,7 +94,9 @@ describe("openclaw-clawchat config", () => {
 
     expect(account.configured).toBe(true);
     expect(account.token).toBe("env-token");
+    expect(account.agentId).toBe("env-agent");
     expect(account.userId).toBe("env-user");
+    expect(account.ownerUserId).toBe("env-owner");
     expect(account.baseUrl).toBe("https://api.env.example");
     expect(account.websocketUrl).toBe("wss://ws.env.example/ws");
   });
@@ -80,7 +107,9 @@ describe("openclaw-clawchat config", () => {
         channels: {
           "openclaw-clawchat": {
             token: "config-token",
+            agentId: "config-agent",
             userId: "config-user",
+            ownerUserId: "config-owner",
             baseUrl: "https://api.config.example",
             websocketUrl: "wss://ws.config.example/ws",
           },
@@ -88,26 +117,160 @@ describe("openclaw-clawchat config", () => {
       },
       {
         CLAWCHAT_TOKEN: "env-token",
+        CLAWCHAT_AGENT_ID: "env-agent",
         CLAWCHAT_USER_ID: "env-user",
+        CLAWCHAT_OWNER_USER_ID: "env-owner",
         CLAWCHAT_BASE_URL: "https://api.env.example",
         CLAWCHAT_WEBSOCKET_URL: "wss://ws.env.example/ws",
       },
     );
 
     expect(account.token).toBe("config-token");
+    expect(account.agentId).toBe("config-agent");
     expect(account.userId).toBe("config-user");
+    expect(account.ownerUserId).toBe("config-owner");
     expect(account.baseUrl).toBe("https://api.config.example");
     expect(account.websocketUrl).toBe("wss://ws.config.example/ws");
   });
 
-  it("falls back to static replyMode for unknown values", () => {
+  it("falls back to stream replyMode for unknown values", () => {
     const cfg = {
       channels: {
-        "openclaw-clawchat": { websocketUrl: "w", token: "t", userId: "a", replyMode: "weird" },
+        "openclaw-clawchat": {
+          websocketUrl: "w",
+          token: "t",
+          userId: "a",
+          ownerUserId: "o",
+          replyMode: "weird",
+        },
       },
     };
     const account = resolveOpenclawClawlingAccount(cfg);
-    expect(account.replyMode).toBe("static");
+    expect(account.replyMode).toBe("stream");
+  });
+
+  it("preserves explicit mention groupMode", () => {
+    const cfg = {
+      channels: {
+        "openclaw-clawchat": {
+          websocketUrl: "w",
+          token: "t",
+          userId: "a",
+          ownerUserId: "o",
+          groupMode: "mention",
+        },
+      },
+    };
+    const account = resolveOpenclawClawlingAccount(cfg);
+    expect(account.groupMode).toBe("mention");
+  });
+
+  it("falls back to all groupMode for unknown values", () => {
+    const cfg = {
+      channels: {
+        "openclaw-clawchat": {
+          websocketUrl: "w",
+          token: "t",
+          userId: "a",
+          ownerUserId: "o",
+          groupMode: "weird",
+        },
+      },
+    };
+    const account = resolveOpenclawClawlingAccount(cfg);
+    expect(account.groupMode).toBe("all");
+  });
+
+  it("resolves per-group groupMode overrides", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "openclaw-clawchat": {
+          groups: {
+            "group-1": { groupMode: "mention" },
+            "*": { groupMode: "all" },
+          },
+        },
+      },
+    });
+
+    expect(account.groups).toEqual({
+      "group-1": { groupMode: "mention", groupCommandMode: "owner" },
+      "*": { groupMode: "all", groupCommandMode: "owner" },
+    });
+    expect(effectiveGroupMode(account, "group-1")).toBe("mention");
+    expect(effectiveGroupMode(account, "group-2")).toBe("all");
+  });
+
+  it("resolves groupCommandMode and per-group overrides", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "openclaw-clawchat": {
+          groupCommandMode: "off",
+          groups: {
+            "group-open": { groupCommandMode: "all" },
+            "*": { groupCommandMode: "owner" },
+          },
+        },
+      },
+    });
+
+    expect(account.groupCommandMode).toBe("off");
+    expect(account.groups).toEqual({
+      "group-open": { groupMode: "all", groupCommandMode: "all" },
+      "*": { groupMode: "all", groupCommandMode: "owner" },
+    });
+    expect(effectiveGroupCommandMode(account, "group-open")).toBe("all");
+    expect(effectiveGroupCommandMode(account, "group-other")).toBe("owner");
+  });
+
+  it("normalizes invalid groupCommandMode values to owner", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "openclaw-clawchat": {
+          groupCommandMode: "weird",
+          groups: {
+            "group-weird": { groupCommandMode: "weird" },
+          },
+        },
+      },
+    });
+
+    expect(account.groupCommandMode).toBe("owner");
+    expect(account.groups["group-weird"]?.groupCommandMode).toBe("owner");
+    expect(effectiveGroupCommandMode(account, "group-weird")).toBe("owner");
+  });
+
+  it("lets exact per-group groupMode win over wildcard and channel defaults", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "openclaw-clawchat": {
+          groupMode: "mention",
+          groups: {
+            "group-open": { groupMode: "all" },
+            "*": { groupMode: "mention" },
+          },
+        },
+      },
+    });
+
+    expect(effectiveGroupMode(account, "group-open")).toBe("all");
+    expect(effectiveGroupMode(account, "group-other")).toBe("mention");
+  });
+
+  it("normalizes invalid per-group groupMode values to all", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "openclaw-clawchat": {
+          groupMode: "mention",
+          groups: {
+            "group-weird": { groupMode: "weird" },
+          },
+        },
+      },
+    });
+
+    expect(account.groups["group-weird"]?.groupMode).toBe("all");
+    expect(effectiveGroupMode(account, "group-weird")).toBe("all");
   });
 
   it("lists the default account id", () => {
@@ -121,6 +284,7 @@ describe("openclaw-clawchat config", () => {
           websocketUrl: "wss://w",
           token: "t",
           userId: "u",
+          ownerUserId: "o",
           baseUrl: "https://api.example.com",
         },
       },
@@ -151,6 +315,7 @@ describe("openclaw-clawchat config", () => {
           websocketUrl: "wss://w",
           token: "t",
           userId: "u",
+          ownerUserId: "o",
           // no baseUrl — resolver uses default
         },
       },

package/src/config.ts

@@ -3,7 +3,9 @@ import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 
 export const CHANNEL_ID = "openclaw-clawchat" as const;
 export const CLAWCHAT_TOKEN_ENV = "CLAWCHAT_TOKEN" as const;
+export const CLAWCHAT_AGENT_ID_ENV = "CLAWCHAT_AGENT_ID" as const;
 export const CLAWCHAT_USER_ID_ENV = "CLAWCHAT_USER_ID" as const;
+export const CLAWCHAT_OWNER_USER_ID_ENV = "CLAWCHAT_OWNER_USER_ID" as const;
 export const CLAWCHAT_REFRESH_TOKEN_ENV = "CLAWCHAT_REFRESH_TOKEN" as const;
 export const CLAWCHAT_BASE_URL_ENV = "CLAWCHAT_BASE_URL" as const;
 export const CLAWCHAT_WEBSOCKET_URL_ENV = "CLAWCHAT_WEBSOCKET_URL" as const;
@@ -21,11 +23,12 @@ export type ReplyMode = "static" | "stream";
 
 /**
  * Group-chat trigger policy.
- * - "mention" (default): only trigger a reply when the inbound `context.mentions`
- *   list contains our `userId` (i.e. the sender @-mentioned us).
- * - "all": trigger on every group message regardless of mentions (open listen).
+ * - "all" (default): trigger on every group message regardless of mentions (open listen).
+ * - "mention": only trigger a reply when the inbound `context.mentions`
+ *   list includes our `userId` (i.e. the sender @-mentioned us).
  */
 export type GroupMode = "mention" | "all";
+export type GroupCommandMode = "owner" | "all" | "off";
 
 export const DEFAULT_STREAM = {
   flushIntervalMs: 250,
@@ -66,6 +69,11 @@ export type OpenclawClawlingStreamConfig = {
   maxBufferChars?: number;
 };
 
+export type OpenclawClawlingGroupConfig = {
+  groupMode: GroupMode;
+  groupCommandMode: GroupCommandMode;
+};
+
 export type OpenclawClawlingReconnectConfig = {
   initialDelay?: number;
   maxDelay?: number;
@@ -91,9 +99,14 @@ export type OpenclawClawlingConfig = {
   token?: string;
   /** Refresh token persisted by ClawChat activation/login (paired with `token`). */
   refreshToken?: string;
+  /** Server agent id used with `/v1/agents/{id}`. */
+  agentId?: string;
   userId?: string;
+  ownerUserId?: string;
   replyMode?: ReplyMode;
   groupMode?: GroupMode;
+  groupCommandMode?: GroupCommandMode;
+  groups?: Record<string, Partial<OpenclawClawlingGroupConfig>>;
   forwardThinking?: boolean;
   forwardToolCalls?: boolean;
   /** Emit approval/action rich fragments instead of plain fallback text. */
@@ -113,9 +126,23 @@ export const openclawClawlingConfigSchema = {
     baseUrl: { type: "string" },
     token: { type: "string" },
     refreshToken: { type: "string" },
+    agentId: { type: "string" },
     userId: { type: "string" },
+    ownerUserId: { type: "string" },
     replyMode: { type: "string", enum: ["static", "stream"] },
     groupMode: { type: "string", enum: ["mention", "all"] },
+    groupCommandMode: { type: "string", enum: ["owner", "all", "off"] },
+    groups: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          groupMode: { type: "string", enum: ["mention", "all"] },
+          groupCommandMode: { type: "string", enum: ["owner", "all", "off"] },
+        },
+      },
+    },
     forwardThinking: { type: "boolean" },
     forwardToolCalls: { type: "boolean" },
     richInteractions: { type: "boolean" },
@@ -238,9 +265,13 @@ export type ResolvedOpenclawClawlingAccount = {
   websocketUrl: string;
   baseUrl: string;
   token: string;
+  agentId: string;
   userId: string;
+  ownerUserId: string;
   replyMode: ReplyMode;
   groupMode: GroupMode;
+  groupCommandMode: GroupCommandMode;
+  groups: Record<string, OpenclawClawlingGroupConfig>;
   forwardThinking: boolean;
   forwardToolCalls: boolean;
   richInteractions: boolean;
@@ -266,11 +297,51 @@ function readEnvString(env: Record<string, string | undefined>, key: string): st
 }
 
 function readReplyMode(value: unknown): ReplyMode {
-  return value === "stream" ? "stream" : "static";
+  return value === "static" ? "static" : "stream";
 }
 
 function readGroupMode(value: unknown): GroupMode {
-  return value === "all" ? "all" : "mention";
+  return value === "mention" ? "mention" : "all";
+}
+
+function readGroupCommandMode(value: unknown): GroupCommandMode {
+  return value === "all" || value === "off" ? value : "owner";
+}
+
+function readGroups(value: unknown): Record<string, OpenclawClawlingGroupConfig> {
+  const rawGroups = value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+  const groups: Record<string, OpenclawClawlingGroupConfig> = {};
+  for (const [chatId, rawGroup] of Object.entries(rawGroups)) {
+    if (!chatId) continue;
+    const group = rawGroup && typeof rawGroup === "object" && !Array.isArray(rawGroup)
+      ? (rawGroup as Record<string, unknown>)
+      : {};
+    groups[chatId] = {
+      groupMode: readGroupMode(group.groupMode),
+      groupCommandMode: readGroupCommandMode(group.groupCommandMode),
+    };
+  }
+  return groups;
+}
+
+export function effectiveGroupMode(
+  account: Pick<ResolvedOpenclawClawlingAccount, "groupMode" | "groups">,
+  chatId: string,
+): GroupMode {
+  return account.groups[chatId]?.groupMode
+    ?? account.groups["*"]?.groupMode
+    ?? account.groupMode;
+}
+
+export function effectiveGroupCommandMode(
+  account: Pick<ResolvedOpenclawClawlingAccount, "groupCommandMode" | "groups">,
+  chatId: string,
+): GroupCommandMode {
+  return account.groups[chatId]?.groupCommandMode
+    ?? account.groups["*"]?.groupCommandMode
+    ?? account.groupCommandMode;
 }
 
 function readStream(raw: unknown): Required<OpenclawClawlingStreamConfig> {
@@ -333,10 +404,15 @@ export function resolveOpenclawClawlingAccount(
     readEnvString(env, CLAWCHAT_BASE_URL_ENV) ||
     DEFAULT_BASE_URL;
   const token = readOptionalString(channel.token) || readEnvString(env, CLAWCHAT_TOKEN_ENV);
+  const agentId = readOptionalString(channel.agentId) || readEnvString(env, CLAWCHAT_AGENT_ID_ENV);
   const userId = readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_ID_ENV);
+  const ownerUserId =
+    readOptionalString(channel.ownerUserId) || readEnvString(env, CLAWCHAT_OWNER_USER_ID_ENV);
   const enabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
   const replyMode = readReplyMode(channel.replyMode);
   const groupMode = readGroupMode(channel.groupMode);
+  const groupCommandMode = readGroupCommandMode(channel.groupCommandMode);
+  const groups = readGroups(channel.groups);
   const forwardThinking =
     typeof channel.forwardThinking === "boolean" ? channel.forwardThinking : true;
   const forwardToolCalls =
@@ -348,13 +424,17 @@ export function resolveOpenclawClawlingAccount(
     accountId: DEFAULT_ACCOUNT_ID,
     name: CHANNEL_ID,
     enabled,
-    configured: Boolean(websocketUrl && token && userId),
+    configured: Boolean(websocketUrl && token && userId && ownerUserId),
     websocketUrl,
     baseUrl,
     token,
+    agentId,
     userId,
+    ownerUserId,
     replyMode,
     groupMode,
+    groupCommandMode,
+    groups,
     forwardThinking,
     forwardToolCalls,
     richInteractions,

package/src/group-message-coalescer.test.ts

@@ -0,0 +1,223 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  createGroupMessageCoalescer,
+  formatCoalescedGroupBody,
+  type CoalescableGroupTurn,
+} from "./group-message-coalescer.ts";
+
+function turn(overrides: Partial<CoalescableGroupTurn> = {}): CoalescableGroupTurn {
+  return {
+    peer: { kind: "group", id: "room-1" },
+    senderId: "user-a",
+    senderNickName: "Alice",
+    rawBody: "hello",
+    messageId: "msg-1",
+    traceId: "trace-1",
+    timestamp: 1000,
+    wasMentioned: false,
+    mentionedUserIds: [],
+    mediaItems: [],
+    envelope: { event: "message.send", trace_id: "trace-1", emitted_at: 1000 },
+    ...overrides,
+  };
+}
+
+beforeEach(() => vi.useFakeTimers());
+afterEach(() => vi.useRealTimers());
+
+describe("group message coalescer", () => {
+  it("flushes after ten seconds of group inactivity", async () => {
+    const dispatched: CoalescableGroupTurn[] = [];
+    const coalescer = createGroupMessageCoalescer({
+      idleMs: 10000,
+      maxWaitMs: 30000,
+      dispatch: async (merged) => {
+        dispatched.push(merged);
+      },
+    });
+
+    coalescer.enqueue(turn({ messageId: "msg-1", rawBody: "one" }));
+    await vi.advanceTimersByTimeAsync(9999);
+
+    coalescer.enqueue(
+      turn({
+        messageId: "msg-2",
+        senderId: "user-b",
+        senderNickName: "Bob",
+        rawBody: "two",
+      }),
+    );
+
+    await vi.advanceTimersByTimeAsync(9999);
+    expect(dispatched).toEqual([]);
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(dispatched).toHaveLength(1);
+    expect(dispatched[0]?.messageId).toBe("msg-2");
+    expect(dispatched[0]?.rawBody).toContain("ClawChat group batch (2 messages, 10s idle, 30s max)");
+    expect(dispatched[0]?.rawBody).toContain("[message]\nsender_id: user-a\nsender_name: Alice\nsender_profile_type: user\nsender_is_owner: false\nmentions_current_agent: false\nmentioned_user_ids: -\ntext:\none");
+    expect(dispatched[0]?.rawBody).toContain("[message]\nsender_id: user-b\nsender_name: Bob\nsender_profile_type: user\nsender_is_owner: false\nmentions_current_agent: false\nmentioned_user_ids: -\ntext:\ntwo");
+    expect(dispatched[0]?.rawBody).not.toContain("sender_relation");
+    expect(dispatched[0]?.rawBody).not.toContain("[msg-");
+  });
+
+  it("flushes at thirty seconds even while group messages keep arriving", async () => {
+    const dispatched: CoalescableGroupTurn[] = [];
+    const coalescer = createGroupMessageCoalescer({
+      idleMs: 10000,
+      maxWaitMs: 30000,
+      dispatch: async (merged) => {
+        dispatched.push(merged);
+      },
+    });
+
+    coalescer.enqueue(turn({ messageId: "msg-1", rawBody: "one" }));
+    await vi.advanceTimersByTimeAsync(9000);
+    coalescer.enqueue(turn({ messageId: "msg-2", rawBody: "two" }));
+    await vi.advanceTimersByTimeAsync(9000);
+    coalescer.enqueue(turn({ messageId: "msg-3", rawBody: "three" }));
+    await vi.advanceTimersByTimeAsync(9000);
+    coalescer.enqueue(turn({ messageId: "msg-4", rawBody: "four" }));
+
+    await vi.advanceTimersByTimeAsync(2999);
+    expect(dispatched).toEqual([]);
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(dispatched).toHaveLength(1);
+    expect(dispatched[0]?.messageId).toBe("msg-4");
+    expect(dispatched[0]?.rawBody).toContain("ClawChat group batch (4 messages, 10s idle, 30s max)");
+    expect(dispatched[0]?.rawBody).toContain("[message]\nsender_id: user-a\nsender_name: Alice\nsender_profile_type: user\nsender_is_owner: false\nmentions_current_agent: false\nmentioned_user_ids: -\ntext:\nfour");
+    expect(dispatched[0]?.rawBody).not.toContain("[msg-");
+  });
+
+  it("flushes one merged turn per group after the idle window", async () => {
+    const dispatched: CoalescableGroupTurn[] = [];
+    const coalescer = createGroupMessageCoalescer({
+      idleMs: 10000,
+      maxWaitMs: 30000,
+      dispatch: async (merged) => {
+        dispatched.push(merged);
+      },
+    });
+
+    const latestEnvelope = { event: "message.send", trace_id: "trace-2", emitted_at: 2000 };
+
+    coalescer.enqueue(
+      turn({
+        messageId: "msg-1",
+        senderNickName: "Alice",
+        rawBody: "one",
+        mentionedUserIds: ["other-user"],
+      }),
+    );
+    coalescer.enqueue(
+      turn({
+        messageId: "msg-2",
+        senderId: "user-b",
+        senderNickName: "Bob",
+        rawBody: "two",
+        traceId: "trace-2",
+        timestamp: 2000,
+        envelope: latestEnvelope,
+      }),
+    );
+
+    await vi.advanceTimersByTimeAsync(9999);
+    expect(dispatched).toEqual([]);
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(dispatched).toHaveLength(1);
+    expect(dispatched[0]?.messageId).toBe("msg-2");
+    expect(dispatched[0]?.senderId).toBe("user-b");
+    expect(dispatched[0]?.traceId).toBe("trace-2");
+    expect(dispatched[0]?.timestamp).toBe(2000);
+    expect(dispatched[0]?.envelope).toBe(latestEnvelope);
+    expect(dispatched[0]?.mentionedUserIds).toEqual(["other-user"]);
+    expect(dispatched[0]?.rawBody).toContain("ClawChat group batch (2 messages, 10s idle, 30s max)");
+    expect(dispatched[0]?.rawBody).toContain("[message]\nsender_id: user-a\nsender_name: Alice\nsender_profile_type: user\nsender_is_owner: false\nmentions_current_agent: false\nmentioned_user_ids: other-user\ntext:\none");
+    expect(dispatched[0]?.rawBody).toContain("[message]\nsender_id: user-b\nsender_name: Bob\nsender_profile_type: user\nsender_is_owner: false\nmentions_current_agent: false\nmentioned_user_ids: -\ntext:\ntwo");
+    expect(dispatched[0]?.rawBody).not.toContain("[msg-");
+  });
+
+  it("keeps independent timers per group", async () => {
+    const dispatched: CoalescableGroupTurn[] = [];
+    const coalescer = createGroupMessageCoalescer({
+      idleMs: 10000,
+      maxWaitMs: 30000,
+      dispatch: async (merged) => dispatched.push(merged),
+    });
+
+    coalescer.enqueue(turn({ peer: { kind: "group", id: "room-1" }, messageId: "r1-a" }));
+    await vi.advanceTimersByTimeAsync(1000);
+
+    coalescer.enqueue(turn({ peer: { kind: "group", id: "room-2" }, messageId: "r2-a" }));
+
+    await vi.advanceTimersByTimeAsync(8999);
+    expect(dispatched).toEqual([]);
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(dispatched.map((item) => item.peer.id)).toEqual(["room-1"]);
+
+    await vi.advanceTimersByTimeAsync(999);
+    expect(dispatched.map((item) => item.peer.id)).toEqual(["room-1"]);
+
+    await vi.advanceTimersByTimeAsync(8001);
+    expect(dispatched.map((item) => item.peer.id)).toEqual(["room-1", "room-2"]);
+  });
+
+  it("drops pending batches on cancel without dispatching after shutdown", async () => {
+    const dispatched: CoalescableGroupTurn[] = [];
+    const coalescer = createGroupMessageCoalescer({
+      idleMs: 10000,
+      maxWaitMs: 30000,
+      dispatch: async (merged) => dispatched.push(merged),
+    });
+
+    coalescer.enqueue(turn());
+    coalescer.cancelAll();
+    await vi.advanceTimersByTimeAsync(30000);
+
+    expect(dispatched).toEqual([]);
+  });
+});
+
+describe("formatCoalescedGroupBody", () => {
+  it("keeps sender name and sender identity visible without message ids", () => {
+    expect(
+      formatCoalescedGroupBody([
+        turn({ messageId: "msg-1", senderId: "u1", senderNickName: "Ann", rawBody: "first" }),
+        turn({
+          messageId: "msg-2",
+          senderId: "u2",
+          senderNickName: "Ben",
+          senderIsOwner: true,
+          senderProfileType: "user",
+          rawBody: "second",
+        }),
+      ]),
+    ).toBe(
+      [
+        "ClawChat group batch (2 messages, 10s idle, 30s max):",
+        "[message]",
+        "sender_id: u1",
+        "sender_name: Ann",
+        "sender_profile_type: user",
+        "sender_is_owner: false",
+        "mentions_current_agent: false",
+        "mentioned_user_ids: -",
+        "text:",
+        "first",
+        "",
+        "[message]",
+        "sender_id: u2",
+        "sender_name: Ben",
+        "sender_profile_type: user",
+        "sender_is_owner: true",
+        "mentions_current_agent: false",
+        "mentioned_user_ids: -",
+        "text:",
+        "second",
+      ].join("\n"),
+    );
+  });
+});