@clawling/clawchat-plugin-openclaw 2026.10.7-2 → 2026.10.8-2

package/src/runtime.ts

@@ -93,6 +93,8 @@ import {
   renderClawChatProfilePrompt,
   resolveSenderRelation,
 } from "./profile-prompt.ts";
+import { buildNoteMemorySection } from "./note-injection.ts";
+import { buildGroupCatchUp, CATCH_UP_FETCH_ROWS, DeliveredGroupMessages } from "./group-catch-up.ts";
 import { refreshGroupProfile, syncFirstSeenClawChatProfiles } from "./profile-sync.ts";
 import { pullGroupMetadata, pullOwnerMetadata } from "./clawchat-metadata.ts";
 import { deleteClawChatMemoryFile, readClawChatMemoryFile } from "./clawchat-memory.ts";
@@ -101,7 +103,7 @@ import {
   clearClawChatPromptInjectionForSession,
   stageClawChatPromptInjection,
 } from "./prompt-injection.ts";
-import { createGroupMessageCoalescer } from "./group-message-coalescer.ts";
+import { createGroupMessageCoalescer, relabelCoalescedGroupBody } from "./group-message-coalescer.ts";
 import { openclawLlmContextDebug } from "./llm-context-debug.ts";
 import { GroupSettingsCache } from "./group-settings.ts";
 import { PermissionCache } from "./permissions.ts";
@@ -198,7 +200,6 @@ function activationBootstrapInFlightCount(accountId: string): number {
 // hermes plugin's GROUP_SETTINGS_READY_TIMEOUT_SECONDS (5s).
 const GROUP_SETTINGS_READY_TIMEOUT_MS = 5_000;
 /** Number of recent group messages to prepend as context when the agent is @-mentioned. */
-const MENTION_CONTEXT_N = 10;
 const CLAWCHAT_MEMORY_ROOT_UNAVAILABLE =
   "ClawChat memory root unavailable: OpenClaw workspaceDir could not be resolved";
 const OPENCLAW_CONFIRM_SLASH_COMMANDS = new Set([
@@ -2968,12 +2969,27 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           ownerMetadata: promptMetadata.ownerMetadata,
         })
       : [];
+    const noteMemorySection = await buildNoteMemorySection({
+      memoryRoot,
+      chatType: promptChatType,
+      chatId: turn.peer.id,
+      senderId: turn.senderId,
+      senderIsOwner: senderRelation === "owner",
+      selfId: account.userId,
+      speakers: turn.peer.kind === "group"
+        ? (turn.groupMessages && turn.groupMessages.length > 0
+            ? turn.groupMessages.map((message) => ({ id: message.senderId, name: message.senderName }))
+            : [{ id: turn.senderId, name: turn.senderNickName }])
+        : [],
+      caps: { user: account.noteCapUser, group: account.noteCapGroup, turn: account.noteCapTurn },
+    });
     return renderClawChatProfilePrompt({
       basePrompt: turn.peer.kind === "group" ? getClawChatGroupPrompt() : getClawChatUserPrompt(),
       ...promptMetadata,
       ownerIdFallback: account.ownerUserId,
       currentAgentIdFallback: account.userId,
       groupParticipants,
+      noteMemorySection,
       turn: {
         chatType: promptChatType,
         chatId: turn.peer.id,
@@ -3017,6 +3033,96 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   // coalesced batch's transcript ("Alice:" rather than "usr_…:") without
   // touching disk.
   const knownNicknames = new Map<string, string>();
+  // Group message ids already handed to the agent, per chat (see group-catch-up.ts).
+  const deliveredGroupMessages = new DeliveredGroupMessages();
+  // One catch-up line: `Name (usr_…): text`, the name from the stored frame's
+  // nick_name unless that is just the id, else the cached nickname.
+  const formatCatchUpLine = (row: MessageRow): string => {
+    const text = (row.text ?? "").trim() || "(empty message)";
+    let senderId = "";
+    let nickName = "";
+    try {
+      const frame = row.raw_json ? (JSON.parse(row.raw_json) as { sender?: { id?: unknown; nick_name?: unknown } }) : null;
+      senderId = typeof frame?.sender?.id === "string" ? frame.sender.id : "";
+      nickName = typeof frame?.sender?.nick_name === "string" ? frame.sender.nick_name : "";
+    } catch {
+      // A malformed stored frame still yields its text.
+    }
+    if (!senderId) return text;
+    const name = (nickName && nickName !== senderId ? nickName : knownNicknames.get(senderId)) ?? "";
+    return name ? `${name} (${senderId}): ${text}` : `${senderId}: ${text}`;
+  };
+
+  // The sender id of a stored row whose frame carried no real nickname (its
+  // nick_name is missing or just the id), else "".
+  const bareSenderIdOfRow = (row: MessageRow): string => {
+    try {
+      const frame = row.raw_json
+        ? (JSON.parse(row.raw_json) as { sender?: { id?: unknown; nick_name?: unknown } })
+        : null;
+      const id = typeof frame?.sender?.id === "string" ? frame.sender.id : "";
+      const nick = typeof frame?.sender?.nick_name === "string" ? frame.sender.nick_name : "";
+      return id && (!nick || nick === id) ? id : "";
+    } catch {
+      return "";
+    }
+  };
+  // Last group-metadata pull made only to resolve names, per chat: a sender who
+  // can never be resolved (deleted account) must not refetch on every batch.
+  const nicknameRefreshAt = new Map<string, number>();
+  const NICKNAME_REFRESH_COOLDOWN_MS = 60_000;
+  const NICKNAME_REFRESH_TIMEOUT_MS = 3_000;
+  // Fill knownNicknames for `ids` from ClawChat memory; if some are still
+  // missing in a group, pull the group's participants once (bounded, with a
+  // cooldown) and read again. Never throws: a name is a nicety, the turn is not.
+  const warmGroupNicknames = async (
+    peer: { kind: "direct" | "group"; id: string },
+    ids: Iterable<string>,
+  ): Promise<void> => {
+    if (peer.kind !== "group") return;
+    try {
+      const memoryRoot = resolveMemoryRootForPeer(peer);
+      if (!memoryRoot) return;
+      const wanted = Array.from(new Set(Array.from(ids).filter((id) => id && id !== account.userId)));
+      const missing = () => wanted.filter((id) => !knownNicknames.has(id));
+      const readCached = async () => {
+        for (const id of missing()) {
+          const nickname = await cachedNicknameFor(memoryRoot, id);
+          if (nickname && nickname !== id) knownNicknames.set(id, nickname);
+        }
+      };
+      await readCached();
+      if (missing().length === 0) return;
+      const now = Date.now();
+      const last = nicknameRefreshAt.get(peer.id);
+      if (last !== undefined && now - last < NICKNAME_REFRESH_COOLDOWN_MS) return;
+      nicknameRefreshAt.set(peer.id, now);
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      await Promise.race([
+        refreshGroupProfile({
+          platform: "openclaw",
+          accountId,
+          accountUserId: account.userId,
+          accountOwnerUserId: account.ownerUserId,
+          conversationId: peer.id,
+          api: getConversationApiClient(),
+          store: {},
+          memoryRoot,
+          log: { error: (message) => log?.error?.(`[${accountId}] ${message}`) },
+        }),
+        new Promise<void>((resolve) => {
+          timer = setTimeout(resolve, NICKNAME_REFRESH_TIMEOUT_MS);
+        }),
+      ]).finally(() => {
+        if (timer) clearTimeout(timer);
+      });
+      await readCached();
+    } catch (err) {
+      log?.error?.(
+        `[${accountId}] clawchat-plugin-openclaw group sender name lookup failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  };
 
   const withCachedGroupSenderNames = async <T extends IngestTurnParams>(
     turn: T,
@@ -3048,12 +3154,36 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     const senderNickName = isBareId(turn.senderNickName, turn.senderId)
       ? (await lookup(turn.senderId)) ?? turn.senderNickName
       : turn.senderNickName;
+    // The wire carries no sender type, so a batch message from another agent
+    // (Hermes, a second OpenClaw…) would read as a person. users/<id>.md holds
+    // the backend's user type; this agent is always an agent.
+    const typeCache = new Map<string, string | null>();
+    const lookupProfileType = async (userId: string): Promise<string | null> => {
+      if (userId === account.userId) return "agent";
+      if (!typeCache.has(userId)) {
+        let profileType: string | null = null;
+        try {
+          const userFile = await readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: userId });
+          profileType = userFile.exists && userFile.metadata.profile_type ? userFile.metadata.profile_type : null;
+        } catch {
+          profileType = null;
+        }
+        typeCache.set(userId, profileType);
+      }
+      return typeCache.get(userId) ?? null;
+    };
     const groupMessages = turn.groupMessages
-      ? await Promise.all(turn.groupMessages.map(async (message) =>
-          isBareId(message.senderName, message.senderId)
+      ? await Promise.all(turn.groupMessages.map(async (message) => {
+          const named = isBareId(message.senderName, message.senderId)
             ? { ...message, senderName: (await lookup(message.senderId)) ?? message.senderName }
-            : message
-        ))
+            : message;
+          const profileType = await lookupProfileType(message.senderId);
+          if (!profileType || profileType === named.senderProfileType) return named;
+          const senderRelation = profileType === "agent" && named.senderRelation === "peer_user"
+            ? "peer_agent" as const
+            : named.senderRelation;
+          return { ...named, senderProfileType: profileType, senderRelation };
+        }))
       : turn.groupMessages;
     return { ...turn, senderNickName, ...(groupMessages ? { groupMessages } : {}) };
   };
@@ -3440,38 +3570,55 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         );
         return;
       }
+      const chatId = turn.peer.id;
+      const batchIds = new Set(turn.allMessageIds ?? [turn.messageId]);
+      const catchUpRows = turn.wasMentioned && store?.listRecentGroupMessages
+        ? store.listRecentGroupMessages("openclaw", accountId, chatId, CATCH_UP_FETCH_ROWS + batchIds.size) ?? []
+        : [];
+      // Ingest labels a batch from the in-memory nickname map, which is empty
+      // after a restart, and catch-up lines read the same map: resolve every
+      // sender named here before the turn goes out.
+      await warmGroupNicknames(turn.peer, [
+        ...(turn.groupMessages ?? [])
+          .filter((message) => !message.senderName || message.senderName === message.senderId)
+          .map((message) => message.senderId),
+        ...(!turn.senderNickName || turn.senderNickName === turn.senderId ? [turn.senderId] : []),
+        ...catchUpRows.map(bareSenderIdOfRow),
+      ]);
+      if (turn.groupMessages?.length) {
+        turn = {
+          ...turn,
+          rawBody: relabelCoalescedGroupBody(turn.rawBody, turn.groupMessages, (id) => knownNicknames.get(id)),
+          groupMessages: turn.groupMessages.map((message) => {
+            const known = message.senderName === message.senderId ? knownNicknames.get(message.senderId) : undefined;
+            return known ? { ...message, senderName: known } : message;
+          }),
+        };
+      }
+      if (turn.senderNickName === turn.senderId && knownNicknames.has(turn.senderId)) {
+        turn = { ...turn, senderNickName: knownNicknames.get(turn.senderId)! };
+      }
+      // An @-mention adds the group messages this session has not been given
+      // since its last turn (e.g. ones a mention-only group held back), within
+      // delta-budget-chars. Every batch handed to the agent is recorded as
+      // delivered, so nothing it already has comes back. See group-catch-up.ts.
+      let catchUp: string | null = null;
       if (turn.wasMentioned && store?.listRecentGroupMessages) {
-        const chatId = turn.peer.id;
-        // Dedupe: exclude rows whose message_id belongs to the current batch/turn.
-        // For a coalesced multi-message turn this covers every constituent ID,
-        // not just the latest one (turn.messageId), so none of the batched
-        // messages appear twice — once in the coalesced body and once in the
-        // prepended "Prior group context" block.
-        const batchIds = new Set(turn.allMessageIds ?? [turn.messageId]);
-        // Overfetch so the batch's own just-stored messages don't crowd out the
-        // MENTION_CONTEXT_N prior rows: fetch batch-size extra rows, drop the
-        // batch members, then keep the most recent MENTION_CONTEXT_N survivors.
-        const priorRows =
-          store.listRecentGroupMessages(
-            "openclaw",
-            accountId,
-            chatId,
-            MENTION_CONTEXT_N + batchIds.size,
-          ) ?? [];
-        const contextRows = priorRows
-          .filter((row) => row.message_id != null && !batchIds.has(row.message_id))
-          .slice(-MENTION_CONTEXT_N);
-        if (contextRows.length > 0) {
-          const priorContextBody = [
-            "Prior group context:",
-            ...contextRows.map((row, i) => `[prior ${i + 1}] ${row.text ?? "(empty)"}`),
-          ].join("\n");
-          await dispatchTurnToAgent({
-            ...turn,
-            rawBody: `${priorContextBody}\n${turn.rawBody}`,
-          });
-          return;
-        }
+        const fetchLimit = CATCH_UP_FETCH_ROWS + batchIds.size;
+        catchUp = buildGroupCatchUp({
+          chatId,
+          rows: catchUpRows,
+          fetchLimit,
+          batchIds,
+          delivered: deliveredGroupMessages,
+          budgetChars: account.deltaBudgetChars,
+          formatLine: formatCatchUpLine,
+        });
+      }
+      deliveredGroupMessages.remember(chatId, batchIds);
+      if (catchUp) {
+        await dispatchTurnToAgent({ ...turn, rawBody: `${catchUp}\n${turn.rawBody}` });
+        return;
       }
       await dispatchTurnToAgent(turn);
     },
@@ -3796,8 +3943,8 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   });
 
   // `message.recall` — the sender withdrew a message. Erase our own ledger row
-  // so the "Prior group context" block above (MENTION_CONTEXT_N rows, no time
-  // predicate, no retention) can never read it back into a turn.
+  // so the mention catch-up above (unseen group messages, no time predicate,
+  // no retention) can never read it back into a turn.
   //
   // Ids only: the frame carries no content, and `payload.message_id` is the
   // server's `rcl:<target>` slot — the id to delete is `target_message_id`.

package/src/storage.ts

@@ -833,8 +833,8 @@ export class ClawChatStore {
    *
    * **The only DELETE in this store, and deliberately so.** There is no prune
    * and no retention on `clawchat_messages`: without this, a message recalled
-   * ninety seconds after it was sent stays one @-mention away from being read
-   * back aloud under "Prior group context" for as long as the group is quiet.
+   * ninety seconds after it was sent, before the agent was given it, stays
+   * one @-mention away from being read back in the mention catch-up.
    *
    * Scoped to `(platform, account_id)` so one account's recall cannot reach
    * another's rows, and matched on `message_id`, which seeks via the