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

package/dist/src/clawchat-metadata.js

@@ -202,12 +202,20 @@ export async function pullGroupMetadata(params) {
                 targetType: "user",
                 targetId: mapped.userId,
             });
-            if (existing.exists)
+            // A cached file is kept as is, except that one without profile_type
+            // (written before types were recorded) gets just that field filled in:
+            // without it the prompt lists a peer agent as a person.
+            if (existing.exists && existing.metadata.profile_type)
                 continue;
             if (!getUser)
                 throw new Error("ClawChat participant metadata pull requires getUserProfile");
             const profile = await getUser(mapped.userId);
-            const metadata = userMetadataFromProfile(profile, mapped.userId);
+            const fetched = userMetadataFromProfile(profile, mapped.userId);
+            if (existing.exists && !fetched.profile_type)
+                continue;
+            const metadata = existing.exists
+                ? { ...existing.metadata, profile_type: fetched.profile_type }
+                : fetched;
             await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: mapped.userId }, metadata);
             writes.push({ targetType: "user", targetId: mapped.userId });
         }

package/dist/src/reply-dispatcher.js

@@ -7,7 +7,7 @@ import { describeOutboundMediaShortfall, uploadOutboundMedia, } from "./media-ru
 import { mintMessageId, sendOpenclawClawlingText, } from "./outbound.js";
 import { isClawChatNoopResponseText } from "./profile-prompt.js";
 import { consumeTerminalClawChatSend } from "./terminal-send.js";
-import { createReplyStream } from "./reply-stream.js";
+import { createReplyStream, streamableText } from "./reply-stream.js";
 import { openclawLlmContextDebug } from "./llm-context-debug.js";
 /**
  * Re-send cadence for `typing.update {is_typing:true}` while a reply is in
@@ -345,7 +345,10 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     // send, or an idle run with nothing delivered fails it. Host partials are snapshots of
     // the current assistant message that may be rewritten, so a snapshot that no
     // longer extends the preview fails the old stream and starts a new one.
-    const streamEnabled = account.streamReplies === true;
+    // Direct chats only, same as Hermes. In a group the server's merged stream
+    // copy carries no @, and a receiver that dedupes by message_id keeps
+    // whichever copy lands first, so an @-only agent would never wake up.
+    const streamEnabled = account.streamReplies === true && !isGroupTarget;
     let replyStream = null;
     const failStream = (reason) => {
         replyStream?.fail(reason);
@@ -356,11 +359,19 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         replyStream = null;
         return id;
     };
+    // Latest host snapshot of the current assistant message, including any tail
+    // the add throttle held back, so a boundary can close the preview whole.
+    let streamPartialText = "";
+    // Texts already delivered as their own message at a message boundary; a
+    // final that only repeats one of them is not sent again.
+    const finalizedPreviewTexts = new Set();
     const onStreamPartial = (text) => {
         if (runDone || terminalReplySuppressed)
             return;
-        if (replyStream?.diverges(text))
-            failStream("superseded");
+        // A snapshot that no longer extends the preview without a message
+        // boundary is a host rewrite: the stream stops growing and the final
+        // replaces it in place (same id). It is never retracted.
+        streamPartialText = text;
         replyStream ??= createReplyStream({
             client,
             chatId: target.chatId,
@@ -556,6 +567,36 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             log,
         });
     };
+    // ----- Stream message boundary -----------------------------------------
+    //
+    // A new assistant message (after a tool call or a thinking block) means the
+    // previewed one is complete. Close it as its own message — `message.done` +
+    // `message.reply` under the same id — instead of letting the next snapshot
+    // supersede it, so text the recipient already saw stays. A preview still
+    // held back (never shown) is just dropped.
+    const finalizeStreamAtBoundary = async (reason) => {
+        if (!replyStream)
+            return;
+        if (!replyStream.isOpen()) {
+            replyStream = null;
+            streamPartialText = "";
+            return;
+        }
+        const decision = streamableText(streamPartialText);
+        const text = decision.kind === "ok"
+            ? decision.text
+            : decision.kind === "poisoned"
+                ? streamPartialText
+                : replyStream.shownText();
+        streamPartialText = "";
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw stream boundary reason=${reason} text_len=${text.length} to=${target.chatId}`);
+        const result = await sendStatic(text, [], [], { recordMessage: true });
+        if (result)
+            finalizedPreviewTexts.add(text.trim());
+        // Whatever sendStatic did (sent, suppressed as no-reply, skipped after a
+        // terminal tool send), the stream is closed now.
+        replyStream = null;
+    };
     // ----- Static send ------------------------------------------------------
     const sendStatic = async (text, mediaFragments = [], richFragments = [], options = {}) => {
         const messageMode = options.messageMode ?? "normal";
@@ -772,6 +813,13 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     failStream("no-reply");
                     return;
                 }
+                if (!replyStream?.isOpen() &&
+                    finalizedPreviewTexts.has(finalText.trim()) &&
+                    !richFragment &&
+                    finalUrls.length === 0) {
+                    log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final skipped: already delivered at a message boundary`);
+                    return;
+                }
                 const mediaFragments = await uploadMediaUrls(finalUrls);
                 const result = await sendStatic(finalText, mediaFragments, richFragment && account.richInteractions ? [richFragment] : [], { recordMessage: true });
                 if (result?.messageId)
@@ -796,16 +844,31 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     return;
                 const fallbackText = bufferedOutputText.trim();
                 const fallbackUrls = bufferedOutputUrls.slice();
-                if (!fallbackText && fallbackUrls.length === 0)
+                if (!fallbackText && fallbackUrls.length === 0) {
+                    // No final came, but a preview was shown: keep it as the reply
+                    // rather than retracting text the recipient already read.
+                    if (replyStream?.isOpen())
+                        await finalizeStreamAtBoundary("idle");
                     return;
+                }
                 const mediaFragments = await uploadMediaUrls(fallbackUrls);
                 const result = await sendStatic(fallbackText, mediaFragments, [], { recordMessage: true });
                 if (result?.messageId)
                     recordThinkingIfLinked(result.messageId);
             }
             finally {
-                // A preview nothing materialized must not linger as an open stream.
-                failStream("undelivered");
+                // Safety net: nothing above claimed or closed an open stream (e.g. the
+                // finalize send threw). It must not linger open, and text already
+                // shown must not vanish: close it with what was shown (the server
+                // materializes that from message.done). Only a preview whose snapshot
+                // turned out to be a no-reply is retracted.
+                if (replyStream?.isOpen()) {
+                    if (streamableText(streamPartialText).kind === "poisoned")
+                        failStream("no-reply");
+                    else
+                        claimStreamMessageId(replyStream.shownText());
+                }
+                replyStream = null;
             }
         },
         onCleanup: () => {
@@ -840,13 +903,22 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                         reasoningText = reasoningText ? `${reasoningText}\n${trimmed}` : trimmed;
                 }
                 : undefined,
-            onToolStart: splitFullOutput
+            onToolStart: splitFullOutput || streamEnabled
                 ? async (payload) => {
+                    if (streamEnabled)
+                        await finalizeStreamAtBoundary("tool-start");
+                    if (!splitFullOutput)
+                        return;
                     if (consumeTerminalSend("tool-start"))
                         return;
                     await emitProcessSegment(formatToolStartSummary(payload));
                 }
                 : undefined,
+            onAssistantMessageStart: streamEnabled
+                ? async () => {
+                    await finalizeStreamAtBoundary("assistant-message-start");
+                }
+                : undefined,
             onToolResult: splitFullOutput
                 ? async (payload) => {
                     if (consumeTerminalSend("tool-result"))

package/dist/src/reply-stream.js

@@ -11,12 +11,13 @@
  * and the server materializes its merged reply from the stream. `finish`
  * therefore takes the final text, sends whatever tail of it the throttle held
  * back as one last add, and closes with the whole text. A final that does not
- * extend what was shown cannot be appended (§8.2) — the stream is failed and
- * the final goes out under its own id.
+ * extend what was shown cannot be appended (§8.2): `message.done` then closes
+ * with the shown text and the final reply, under the same id, replaces it in
+ * place, so text the recipient already saw never vanishes.
  *
- * or, when the reply turns out not to be sendable (no-reply token, run
- * aborted, nothing delivered): message.created(M) → … → message.failed(M),
- * which aborts the stream without materializing anything.
+ * or, when the preview must not stay (a no-reply, or the reply went out
+ * through a ClawChat tool instead): message.created(M) → … → message.failed(M),
+ * which retracts the preview — the recipient keeps nothing of it.
  *
  * Streaming frames get no ack (§8.5) and no server-side mention repair, so the
  * stream only ever carries plain text; mentions, media and rich fragments ride
@@ -184,23 +185,24 @@ export function createReplyStream(options) {
                 return null;
             }
             // Trailing whitespace a partial carried may be trimmed off the final.
-            if (!finalText.startsWith(sent.trimEnd())) {
-                fail("superseded");
-                return null;
-            }
-            if (finalText.length > sent.length && finalText.startsWith(sent)) {
+            const extendsShown = finalText.startsWith(sent.trimEnd());
+            if (extendsShown && finalText.length > sent.length && finalText.startsWith(sent)) {
                 // Past the throttle: this is the last frame before done.
                 sendAdd(finalText, now());
             }
+            // A final that rewrites the preview cannot be appended (§8.2), but the
+            // shown text must not vanish: close the stream with what was shown and
+            // let the final reply under this same id replace it in place.
+            const doneText = extendsShown ? finalText : sent;
             closed = true;
             const at = now();
             emit(EVENT.MESSAGE_DONE, {
                 message_id: messageId,
-                fragments: [{ kind: "text", text: finalText }],
+                fragments: [{ kind: "text", text: doneText }],
                 streaming: streamingState("done", at),
                 completed_at: at,
             });
-            options.log?.info?.(`${prefix} stream done msg=${messageId} text_len=${finalText.length}`);
+            options.log?.info?.(`${prefix} stream done msg=${messageId} text_len=${finalText.length}${extendsShown ? "" : " replaced_in_place=true"}`);
             return messageId;
         },
         fail,

package/dist/src/runtime.js

@@ -2552,10 +2552,39 @@ export async function startOpenclawClawlingGateway(params) {
         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();
+        const lookupProfileType = async (userId) => {
+            if (userId === account.userId)
+                return "agent";
+            if (!typeCache.has(userId)) {
+                let profileType = 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)
-                ? { ...message, senderName: (await lookup(message.senderId)) ?? message.senderName }
-                : message))
+            ? await Promise.all(turn.groupMessages.map(async (message) => {
+                const named = isBareId(message.senderName, message.senderId)
+                    ? { ...message, senderName: (await lookup(message.senderId)) ?? message.senderName }
+                    : message;
+                const profileType = await lookupProfileType(message.senderId);
+                if (!profileType || profileType === named.senderProfileType)
+                    return named;
+                const senderRelation = profileType === "agent" && named.senderRelation === "peer_user"
+                    ? "peer_agent"
+                    : named.senderRelation;
+                return { ...named, senderProfileType: profileType, senderRelation };
+            }))
             : turn.groupMessages;
         return { ...turn, senderNickName, ...(groupMessages ? { groupMessages } : {}) };
     };

package/package.json

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

package/src/clawchat-metadata.ts

@@ -293,10 +293,17 @@ export async function pullGroupMetadata(params: {
         targetType: "user",
         targetId: mapped.userId,
       });
-      if (existing.exists) continue;
+      // A cached file is kept as is, except that one without profile_type
+      // (written before types were recorded) gets just that field filled in:
+      // without it the prompt lists a peer agent as a person.
+      if (existing.exists && existing.metadata.profile_type) continue;
       if (!getUser) throw new Error("ClawChat participant metadata pull requires getUserProfile");
       const profile = await getUser(mapped.userId);
-      const metadata = userMetadataFromProfile(profile, mapped.userId);
+      const fetched = userMetadataFromProfile(profile, mapped.userId);
+      if (existing.exists && !fetched.profile_type) continue;
+      const metadata = existing.exists
+        ? { ...existing.metadata, profile_type: fetched.profile_type! }
+        : fetched;
       await writeClawChatMetadata(
         params.memoryRoot,
         { targetType: "user", targetId: mapped.userId },

package/src/reply-dispatcher.ts

@@ -37,7 +37,7 @@ import {
 import { isClawChatNoopResponseText } from "./profile-prompt.ts";
 import type { ClawChatStore } from "./storage.ts";
 import { consumeTerminalClawChatSend } from "./terminal-send.ts";
-import { createReplyStream, type ReplyStream } from "./reply-stream.ts";
+import { createReplyStream, streamableText, type ReplyStream } from "./reply-stream.ts";
 import { openclawLlmContextDebug } from "./llm-context-debug.ts";
 
 export interface ReplyDispatcherOptions {
@@ -112,6 +112,8 @@ type ClawChatReplyOptions = TypedReplyDispatcherResult["replyOptions"] &
       detailMode?: "explain" | "raw";
     }) => void | Promise<void>;
     onToolResult?: (payload: ReplyPayload) => void | Promise<void>;
+    /** Newer hosts: a new assistant message starts (after a tool call or thinking block). */
+    onAssistantMessageStart?: () => void | Promise<void>;
     onItemEvent?: (payload: Record<string, unknown>) => void | Promise<void>;
     onPlanUpdate?: (payload: Record<string, unknown>) => void | Promise<void>;
     onCommandOutput?: (payload: Record<string, unknown>) => void | Promise<void>;
@@ -514,7 +516,10 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
   // send, or an idle run with nothing delivered fails it. Host partials are snapshots of
   // the current assistant message that may be rewritten, so a snapshot that no
   // longer extends the preview fails the old stream and starts a new one.
-  const streamEnabled = account.streamReplies === true;
+  // Direct chats only, same as Hermes. In a group the server's merged stream
+  // copy carries no @, and a receiver that dedupes by message_id keeps
+  // whichever copy lands first, so an @-only agent would never wake up.
+  const streamEnabled = account.streamReplies === true && !isGroupTarget;
   let replyStream: ReplyStream | null = null;
   const failStream = (reason: string) => {
     replyStream?.fail(reason);
@@ -525,9 +530,18 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     replyStream = null;
     return id;
   };
+  // Latest host snapshot of the current assistant message, including any tail
+  // the add throttle held back, so a boundary can close the preview whole.
+  let streamPartialText = "";
+  // Texts already delivered as their own message at a message boundary; a
+  // final that only repeats one of them is not sent again.
+  const finalizedPreviewTexts = new Set<string>();
   const onStreamPartial = (text: string) => {
     if (runDone || terminalReplySuppressed) return;
-    if (replyStream?.diverges(text)) failStream("superseded");
+    // A snapshot that no longer extends the preview without a message
+    // boundary is a host rewrite: the stream stops growing and the final
+    // replaces it in place (same id). It is never retracted.
+    streamPartialText = text;
     replyStream ??= createReplyStream({
       client,
       chatId: target.chatId,
@@ -725,6 +739,37 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     });
   };
 
+  // ----- Stream message boundary -----------------------------------------
+  //
+  // A new assistant message (after a tool call or a thinking block) means the
+  // previewed one is complete. Close it as its own message — `message.done` +
+  // `message.reply` under the same id — instead of letting the next snapshot
+  // supersede it, so text the recipient already saw stays. A preview still
+  // held back (never shown) is just dropped.
+  const finalizeStreamAtBoundary = async (reason: string): Promise<void> => {
+    if (!replyStream) return;
+    if (!replyStream.isOpen()) {
+      replyStream = null;
+      streamPartialText = "";
+      return;
+    }
+    const decision = streamableText(streamPartialText);
+    const text = decision.kind === "ok"
+      ? decision.text
+      : decision.kind === "poisoned"
+        ? streamPartialText
+        : replyStream.shownText();
+    streamPartialText = "";
+    log?.info?.(
+      `[${account.accountId}] clawchat-plugin-openclaw stream boundary reason=${reason} text_len=${text.length} to=${target.chatId}`,
+    );
+    const result = await sendStatic(text, [], [], { recordMessage: true });
+    if (result) finalizedPreviewTexts.add(text.trim());
+    // Whatever sendStatic did (sent, suppressed as no-reply, skipped after a
+    // terminal tool send), the stream is closed now.
+    replyStream = null;
+  };
+
   // ----- Static send ------------------------------------------------------
 
   const sendStatic = async (
@@ -967,6 +1012,15 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
           failStream("no-reply");
           return;
         }
+        if (
+          !replyStream?.isOpen() &&
+          finalizedPreviewTexts.has(finalText.trim()) &&
+          !richFragment &&
+          finalUrls.length === 0
+        ) {
+          log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final skipped: already delivered at a message boundary`);
+          return;
+        }
         const mediaFragments = await uploadMediaUrls(finalUrls);
         const result = await sendStatic(
           finalText,
@@ -995,13 +1049,26 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
         if (finalDeliverySeen) return;
         const fallbackText = bufferedOutputText.trim();
         const fallbackUrls = bufferedOutputUrls.slice();
-        if (!fallbackText && fallbackUrls.length === 0) return;
+        if (!fallbackText && fallbackUrls.length === 0) {
+          // No final came, but a preview was shown: keep it as the reply
+          // rather than retracting text the recipient already read.
+          if (replyStream?.isOpen()) await finalizeStreamAtBoundary("idle");
+          return;
+        }
         const mediaFragments = await uploadMediaUrls(fallbackUrls);
         const result = await sendStatic(fallbackText, mediaFragments, [], { recordMessage: true });
         if (result?.messageId) recordThinkingIfLinked(result.messageId);
       } finally {
-        // A preview nothing materialized must not linger as an open stream.
-        failStream("undelivered");
+        // Safety net: nothing above claimed or closed an open stream (e.g. the
+        // finalize send threw). It must not linger open, and text already
+        // shown must not vanish: close it with what was shown (the server
+        // materializes that from message.done). Only a preview whose snapshot
+        // turned out to be a no-reply is retracted.
+        if (replyStream?.isOpen()) {
+          if (streamableText(streamPartialText).kind === "poisoned") failStream("no-reply");
+          else claimStreamMessageId(replyStream.shownText());
+        }
+        replyStream = null;
       }
     },
     onCleanup: () => {
@@ -1035,12 +1102,19 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
             if (trimmed) reasoningText = reasoningText ? `${reasoningText}\n${trimmed}` : trimmed;
           }
         : undefined,
-      onToolStart: splitFullOutput
+      onToolStart: splitFullOutput || streamEnabled
         ? async (payload) => {
+            if (streamEnabled) await finalizeStreamAtBoundary("tool-start");
+            if (!splitFullOutput) return;
             if (consumeTerminalSend("tool-start")) return;
             await emitProcessSegment(formatToolStartSummary(payload));
           }
         : undefined,
+      onAssistantMessageStart: streamEnabled
+        ? async () => {
+            await finalizeStreamAtBoundary("assistant-message-start");
+          }
+        : undefined,
       onToolResult: splitFullOutput
         ? async (payload: ReplyPayload) => {
             if (consumeTerminalSend("tool-result")) return;

package/src/reply-stream.ts

@@ -11,12 +11,13 @@
  * and the server materializes its merged reply from the stream. `finish`
  * therefore takes the final text, sends whatever tail of it the throttle held
  * back as one last add, and closes with the whole text. A final that does not
- * extend what was shown cannot be appended (§8.2) — the stream is failed and
- * the final goes out under its own id.
+ * extend what was shown cannot be appended (§8.2): `message.done` then closes
+ * with the shown text and the final reply, under the same id, replaces it in
+ * place, so text the recipient already saw never vanishes.
  *
- * or, when the reply turns out not to be sendable (no-reply token, run
- * aborted, nothing delivered): message.created(M) → … → message.failed(M),
- * which aborts the stream without materializing anything.
+ * or, when the preview must not stay (a no-reply, or the reply went out
+ * through a ClawChat tool instead): message.created(M) → … → message.failed(M),
+ * which retracts the preview — the recipient keeps nothing of it.
  *
  * Streaming frames get no ack (§8.5) and no server-side mention repair, so the
  * stream only ever carries plain text; mentions, media and rich fragments ride
@@ -94,9 +95,10 @@ export interface ReplyStream {
    * Close the stream with the final reply text: an unthrottled last
    * `message.add` for any tail not yet shown, then `message.done` carrying
    * `finalText`. Returns the message_id for the final materialized message to
-   * reuse. Returns null — the final then uses a fresh id — when no stream is
-   * open, or when `finalText` does not extend the shown text (or is a no-reply),
-   * in which case the stream is failed instead.
+   * reuse. When `finalText` does not extend the shown text, `message.done`
+   * carries the shown text and the final, reusing the id, replaces it in place.
+   * Returns null — the final then uses a fresh id — when no stream is open, or
+   * when `finalText` is a no-reply, in which case the stream is failed.
    */
   finish(finalText: string): string | null;
   /** Abort an open stream with `message.failed`. No-op when nothing is open. */
@@ -220,23 +222,26 @@ export function createReplyStream(options: ReplyStreamOptions): ReplyStream {
         return null;
       }
       // Trailing whitespace a partial carried may be trimmed off the final.
-      if (!finalText.startsWith(sent.trimEnd())) {
-        fail("superseded");
-        return null;
-      }
-      if (finalText.length > sent.length && finalText.startsWith(sent)) {
+      const extendsShown = finalText.startsWith(sent.trimEnd());
+      if (extendsShown && finalText.length > sent.length && finalText.startsWith(sent)) {
         // Past the throttle: this is the last frame before done.
         sendAdd(finalText, now());
       }
+      // A final that rewrites the preview cannot be appended (§8.2), but the
+      // shown text must not vanish: close the stream with what was shown and
+      // let the final reply under this same id replace it in place.
+      const doneText = extendsShown ? finalText : sent;
       closed = true;
       const at = now();
       emit(EVENT.MESSAGE_DONE, {
         message_id: messageId,
-        fragments: [{ kind: "text", text: finalText }],
+        fragments: [{ kind: "text", text: doneText }],
         streaming: streamingState("done", at),
         completed_at: at,
       });
-      options.log?.info?.(`${prefix} stream done msg=${messageId} text_len=${finalText.length}`);
+      options.log?.info?.(
+        `${prefix} stream done msg=${messageId} text_len=${finalText.length}${extendsShown ? "" : " replaced_in_place=true"}`,
+      );
       return messageId;
     },
     fail,

package/src/runtime.ts

@@ -3048,12 +3048,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 } : {}) };
   };