fix: preserve slack mention source metadata

zeus1959 · zeus1959 · commit d6783d5b975b · 2026-05-07T22:48:37.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -9,6 +9,7 @@ Docs: https://docs.openclaw.ai
 - Telegram: preserve the channel-specific 10-option poll cap in the unified outbound adapter so over-limit polls are rejected before send. (#78762) Thanks @obviyus.
 - Runtime/install: raise the supported Node 22 floor to `22.16+` so native SQLite query handling can rely on the `node:sqlite` statement metadata API while continuing to recommend Node 24. (#78921)
 - Discord/voice: stream ElevenLabs TTS directly into Discord playback and send ElevenLabs latency optimization as the documented query parameter so spoken replies can start sooner.
+- Slack: preserve explicit Slack mention targets, user-group ids, implicit thread wake reasons, and mention source metadata in inbound prompt context, and nudge implicit thread wakes without direct bot mentions to stay quiet unless they add specific value while keeping existing mention-gating behavior unchanged. Fixes #79025. Thanks @bek91.
 - Discord/voice: keep TTS playback running when another user starts speaking, ignore new capture during playback to avoid feedback loops, and downgrade expected receive-stream aborts to verbose diagnostics.
 - Telegram: treat successful same-chat `message` tool outbound sends during an inbound telegram turn as delivered when deciding whether to emit the rewritten silent reply fallback (#78685). Thanks @neeravmakwana.
 - Gateway/tasks: reconcile stale CLI run-context tasks whose live run context disappeared even when a child session row remains, and apply the default bounded reload deferral timeout to channel hot reloads so stale task records cannot block Discord/Slack/Telegram reloads forever.
diff --git a/docs/channels/slack.md b/docs/channels/slack.md
@@ -907,6 +907,8 @@ Current Slack message actions include `send`, `upload-file`, `download-file`, `r
     - mention regex patterns (`agents.list[].groupChat.mentionPatterns`, fallback `messages.groupChat.mentionPatterns`)
     - implicit reply-to-bot thread behavior (disabled when `thread.requireExplicitMention` is `true`)
 
+    Slack prompt metadata preserves the collapsed wake decision (`was_mentioned`) and the provider-native mention detail for that turn, including `explicitly_mentioned_bot`, `mentioned_user_ids`, `mentioned_subteam_ids`, `implicit_mention_kinds`, and `mention_source`. This lets agents distinguish an explicit mention of another Slack user inside an implicitly waking thread from a direct bot mention. When a turn wakes from implicit thread participation without an explicit bot mention, OpenClaw also nudges the agent to reply only when it has specific additive value, such as correcting an important mistake or adding requested context.
+
     Per-channel controls (`channels.slack.channels.<id>`; names only via startup resolution or `dangerouslyAllowNameMatching`):
 
     - `requireMention`
diff --git a/extensions/canvas/src/host/a2ui/.bundle.hash b/extensions/canvas/src/host/a2ui/.bundle.hash
@@ -1 +1 @@
-6980bbdd2836edf693dc24ee59253feadc5843cad3cde6efbef3bd1ffc8acf24
+30bca8f93a8c52894fc94636b0a3561dce212fbb72a30d45276ab063486c857f
diff --git a/extensions/slack/src/monitor/message-handler/prepare.test.ts b/extensions/slack/src/monitor/message-handler/prepare.test.ts
@@ -1388,6 +1388,43 @@ describe("slack prepareSlackMessage inbound contract", () => {
     expect(new Set([root!.ctxPayload.SessionKey, followUp!.ctxPayload.SessionKey]).size).toBe(1);
   });
 
+  it("preserves explicit Slack mention targets when an implicit thread wake mentions someone else", async () => {
+    const { storePath } = storeFixture.makeTmpStorePath();
+    const slackCtx = createInboundSlackCtx({
+      cfg: {
+        session: { store: storePath },
+        channels: { slack: { enabled: true, replyToMode: "all", groupPolicy: "open" } },
+      } as OpenClawConfig,
+      defaultRequireMention: true,
+      replyToMode: "all",
+    });
+    slackCtx.resolveChannelName = async () => ({ name: "proj-openclaw", type: "channel" });
+    slackCtx.resolveUserName = async () => ({ name: "Bek" });
+
+    const prepared = await prepareSlackMessage({
+      ctx: slackCtx,
+      account: createSlackAccount({ replyToMode: "all" }),
+      message: {
+        type: "message",
+        channel: "C0AHZFCAS1K",
+        channel_type: "channel",
+        user: "U_BEK",
+        text: "<@UOTHER> can you check this?",
+        ts: "1777244714.000100",
+        thread_ts: "1777244692.409919",
+        parent_user_id: "B1",
+      } as SlackMessageEvent,
+      opts: { source: "message" },
+    });
+
+    expect(prepared).toBeTruthy();
+    expect(prepared!.ctxPayload.WasMentioned).toBe(true);
+    expect(prepared!.ctxPayload.ExplicitlyMentionedBot).toBe(false);
+    expect(prepared!.ctxPayload.MentionedUserIds).toEqual(["UOTHER"]);
+    expect(prepared!.ctxPayload.ImplicitMentionKinds).toEqual(["reply_to_bot"]);
+    expect(prepared!.ctxPayload.MentionSource).toBe("implicit_thread");
+  });
+
   it("treats Slack user-group mentions as explicit mentions when the bot is a member", async () => {
     const usergroupsUsersList = vi.fn().mockResolvedValue({
       ok: true,
@@ -1431,6 +1468,9 @@ describe("slack prepareSlackMessage inbound contract", () => {
     });
     expect(prepared).toBeTruthy();
     expect(prepared!.ctxPayload.WasMentioned).toBe(true);
+    expect(prepared!.ctxPayload.ExplicitlyMentionedBot).toBe(true);
+    expect(prepared!.ctxPayload.MentionedSubteamIds).toEqual(["S0AGENTS"]);
+    expect(prepared!.ctxPayload.MentionSource).toBe("subteam");
   });
 
   it("drops Slack user-group mentions when the bot is not a member", async () => {
diff --git a/extensions/slack/src/monitor/message-handler/prepare.ts b/extensions/slack/src/monitor/message-handler/prepare.ts
@@ -68,6 +68,8 @@ import type { PreparedSlackMessage } from "./types.js";
 
 const mentionRegexCache = new WeakMap<SlackMonitorContext, Map<string, RegExp[]>>();
 const SLACK_ANY_MENTION_RE = /<@[^>]+>|<!subteam\^[^>]+>/;
+const SLACK_USER_MENTION_RE = /<@([A-Z0-9]+)(?:\|[^>]+)?>/gi;
+const SLACK_SUBTEAM_MENTION_RE = /<!subteam\^([A-Z0-9]+)(?:\|[^>]+)?>/gi;
 const SLACK_SUBTEAM_MENTION_MARKER = "<!subteam^";
 
 function resolveCachedMentionRegexes(
@@ -112,6 +114,43 @@ type SlackAuthorizationContext = {
   allowFromLower: string[];
 };
 
+function collectUniqueSlackMentionIds(text: string, regex: RegExp): string[] {
+  const ids: string[] = [];
+  regex.lastIndex = 0;
+  for (const match of text.matchAll(regex)) {
+    const id = normalizeOptionalString(match[1]);
+    if (id && !ids.includes(id)) {
+      ids.push(id);
+    }
+  }
+  return ids;
+}
+
+function resolveSlackMentionSource(params: {
+  explicitBotMention: boolean;
+  explicitSubteamMention: boolean;
+  matchedImplicitMentionKinds: readonly string[];
+  shouldBypassMention: boolean;
+  wasMentioned: boolean;
+}): NonNullable<FinalizedMsgContext["MentionSource"]> {
+  if (params.explicitBotMention) {
+    return "explicit_bot";
+  }
+  if (params.explicitSubteamMention) {
+    return "subteam";
+  }
+  if (params.matchedImplicitMentionKinds.length > 0) {
+    return "implicit_thread";
+  }
+  if (params.shouldBypassMention) {
+    return "command_bypass";
+  }
+  if (params.wasMentioned) {
+    return "mention_pattern";
+  }
+  return "none";
+}
+
 async function resolveSlackConversationContext(params: {
   ctx: SlackMonitorContext;
   account: ResolvedSlackAccount;
@@ -289,20 +328,24 @@ export async function prepareSlackMessage(params: {
   }
   const { senderId, allowFromLower } = authorization;
   const messageText = message.text ?? "";
+  const mentionedUserIds = collectUniqueSlackMentionIds(messageText, SLACK_USER_MENTION_RE);
+  const mentionedSubteamIds = collectUniqueSlackMentionIds(messageText, SLACK_SUBTEAM_MENTION_RE);
   const hasAnyMention = SLACK_ANY_MENTION_RE.test(messageText);
   const hasSubteamMention = messageText.includes(SLACK_SUBTEAM_MENTION_MARKER);
-  const explicitlyMentioned = Boolean(
-    ctx.botUserId &&
-    (messageText.includes(`<@${ctx.botUserId}>`) ||
-      (hasSubteamMention &&
-        (await isSlackSubteamMentionForBot({
-          client: ctx.app.client,
-          text: messageText,
-          botUserId: ctx.botUserId,
-          teamId: ctx.teamId,
-          log: logVerbose,
-        })))),
+  const explicitlyMentionedBotUser = Boolean(
+    ctx.botUserId && mentionedUserIds.includes(ctx.botUserId),
   );
+  const explicitlyMentionedBotSubteam =
+    Boolean(ctx.botUserId && hasSubteamMention) &&
+    (await isSlackSubteamMentionForBot({
+      client: ctx.app.client,
+      text: messageText,
+      botUserId: ctx.botUserId,
+      teamId: ctx.teamId,
+      log: logVerbose,
+    }));
+  const explicitlyMentioned =
+    explicitlyMentionedBotUser || explicitlyMentionedBotSubteam || opts.source === "app_mention";
   const seedTopLevelRoomThreadBySource =
     opts.source === "app_mention" || opts.wasMentioned === true || explicitlyMentioned;
   let routing = resolveSlackRoutingContext({
@@ -524,6 +567,14 @@ export async function prepareSlackMessage(params: {
     },
   });
   const effectiveWasMentioned = mentionDecision.effectiveWasMentioned;
+  const matchedImplicitMentionKinds = mentionDecision.matchedImplicitMentionKinds;
+  const mentionSource = resolveSlackMentionSource({
+    explicitBotMention: explicitlyMentionedBotUser || opts.source === "app_mention",
+    explicitSubteamMention: explicitlyMentionedBotSubteam,
+    matchedImplicitMentionKinds,
+    shouldBypassMention: mentionDecision.shouldBypassMention,
+    wasMentioned,
+  });
   if (isRoom && shouldRequireMention && mentionDecision.shouldSkip) {
     ctx.logger.info({ channel: message.channel, reason: "no-mention" }, "skipping channel message");
     const pendingText = (message.text ?? "").trim();
@@ -792,6 +843,13 @@ export async function prepareSlackMessage(params: {
     ThreadLabel: threadLabel,
     Timestamp: message.ts ? Math.round(Number(message.ts) * 1000) : undefined,
     WasMentioned: isRoomish ? effectiveWasMentioned : undefined,
+    ExplicitlyMentionedBot: isRoomish ? explicitlyMentioned : undefined,
+    MentionedUserIds: isRoomish && mentionedUserIds.length > 0 ? mentionedUserIds : undefined,
+    MentionedSubteamIds:
+      isRoomish && mentionedSubteamIds.length > 0 ? mentionedSubteamIds : undefined,
+    ImplicitMentionKinds:
+      isRoomish && matchedImplicitMentionKinds.length > 0 ? matchedImplicitMentionKinds : undefined,
+    MentionSource: isRoomish ? mentionSource : undefined,
     MediaPath: firstMedia?.path,
     MediaType: firstMedia?.contentType,
     MediaUrl: firstMedia?.path,
diff --git a/src/auto-reply/reply/inbound-meta.test.ts b/src/auto-reply/reply/inbound-meta.test.ts
@@ -494,6 +494,11 @@ describe("buildInboundUserContextPrefix", () => {
     const text = buildInboundUserContextPrefix({
       ChatType: "group",
       WasMentioned: true,
+      ExplicitlyMentionedBot: false,
+      MentionedUserIds: [" U_OTHER ", "", "U_HELPER"],
+      MentionedSubteamIds: [" S_ONCALL "],
+      ImplicitMentionKinds: ["bot_thread_participant"],
+      MentionSource: "implicit_thread",
       ReplyToBody: "quoted",
       ForwardedFrom: "sender",
       ThreadStarterBody: "starter",
@@ -503,12 +508,44 @@ describe("buildInboundUserContextPrefix", () => {
     const conversationInfo = parseConversationInfoPayload(text);
     expect(conversationInfo["is_group_chat"]).toBe(true);
     expect(conversationInfo["was_mentioned"]).toBe(true);
+    expect(conversationInfo["explicitly_mentioned_bot"]).toBe(false);
+    expect(conversationInfo["mentioned_user_ids"]).toEqual(["U_OTHER", "U_HELPER"]);
+    expect(conversationInfo["mentioned_subteam_ids"]).toEqual(["S_ONCALL"]);
+    expect(conversationInfo["implicit_mention_kinds"]).toEqual(["bot_thread_participant"]);
+    expect(conversationInfo["mention_source"]).toBe("implicit_thread");
     expect(conversationInfo["has_reply_context"]).toBe(true);
     expect(conversationInfo["has_forwarded_context"]).toBe(true);
     expect(conversationInfo["has_thread_starter"]).toBe(true);
     expect(conversationInfo["history_count"]).toBe(1);
   });
 
+  it("nudges implicit thread wakes without explicit bot mentions to stay selective", () => {
+    const text = buildInboundUserContextPrefix({
+      ChatType: "group",
+      WasMentioned: true,
+      ExplicitlyMentionedBot: false,
+      MentionedUserIds: ["UOTHER"],
+      ImplicitMentionKinds: ["reply_to_bot"],
+      MentionSource: "implicit_thread",
+    } as TemplateContext);
+
+    expect(text).toContain("This turn woke from implicit thread participation");
+    expect(text).toContain("reply only when you have a specific useful addition");
+    expect(text).toContain("otherwise use the current chat's no-response behavior");
+  });
+
+  it("does not add selective reply guidance for explicit bot mentions", () => {
+    const text = buildInboundUserContextPrefix({
+      ChatType: "group",
+      WasMentioned: true,
+      ExplicitlyMentionedBot: true,
+      MentionedUserIds: ["B1"],
+      MentionSource: "explicit_bot",
+    } as TemplateContext);
+
+    expect(text).not.toContain("This turn woke from implicit thread participation");
+  });
+
   it("trims sender_id in conversation info", () => {
     const text = buildInboundUserContextPrefix({
       ChatType: "group",
diff --git a/src/auto-reply/reply/inbound-meta.ts b/src/auto-reply/reply/inbound-meta.ts
@@ -25,6 +25,16 @@ function normalizePromptMetadataString(value: unknown): string | undefined {
   return sanitized || undefined;
 }
 
+function normalizePromptMetadataStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  const normalized = value
+    .map((entry) => normalizePromptMetadataString(entry))
+    .filter((entry): entry is string => Boolean(entry));
+  return normalized.length > 0 ? normalized : undefined;
+}
+
 function sanitizePromptBody(value: unknown): string | undefined {
   if (typeof value !== "string") {
     return undefined;
@@ -75,6 +85,21 @@ function formatUntrustedJsonBlock(label: string, payload: unknown): string {
   ].join("\n");
 }
 
+function buildMentionReplyGuidance(ctx: TemplateContext, isDirect: boolean): string | undefined {
+  if (
+    isDirect ||
+    normalizePromptMetadataString(ctx.MentionSource) !== "implicit_thread" ||
+    ctx.ExplicitlyMentionedBot !== false
+  ) {
+    return undefined;
+  }
+  return [
+    "OpenClaw reply guidance:",
+    "This turn woke from implicit thread participation, not a direct bot mention.",
+    "If the message is addressed to someone else, reply only when you have a specific useful addition, such as correcting an important mistake or adding requested context; otherwise use the current chat's no-response behavior.",
+  ].join(" ");
+}
+
 function buildLocationContextPayload(ctx: TemplateContext): Record<string, unknown> | undefined {
   const payload = {
     latitude: typeof ctx.LocationLat === "number" ? ctx.LocationLat : undefined,
@@ -227,6 +252,12 @@ export function buildInboundUserContextPrefix(
     is_forum: ctx.IsForum === true ? true : undefined,
     is_group_chat: !isDirect ? true : undefined,
     was_mentioned: ctx.WasMentioned === true ? true : undefined,
+    explicitly_mentioned_bot:
+      typeof ctx.ExplicitlyMentionedBot === "boolean" ? ctx.ExplicitlyMentionedBot : undefined,
+    mentioned_user_ids: normalizePromptMetadataStringArray(ctx.MentionedUserIds),
+    mentioned_subteam_ids: normalizePromptMetadataStringArray(ctx.MentionedSubteamIds),
+    implicit_mention_kinds: normalizePromptMetadataStringArray(ctx.ImplicitMentionKinds),
+    mention_source: normalizePromptMetadataString(ctx.MentionSource),
     has_reply_context: sanitizePromptBody(ctx.ReplyToBody) ? true : undefined,
     has_forwarded_context: normalizePromptMetadataString(ctx.ForwardedFrom) ? true : undefined,
     has_thread_starter: sanitizePromptBody(ctx.ThreadStarterBody) ? true : undefined,
@@ -238,6 +269,10 @@ export function buildInboundUserContextPrefix(
       formatUntrustedJsonBlock("Conversation info (untrusted metadata):", conversationInfo),
     );
   }
+  const mentionReplyGuidance = buildMentionReplyGuidance(ctx, isDirect);
+  if (mentionReplyGuidance) {
+    blocks.push(mentionReplyGuidance);
+  }
 
   const senderInfo = {
     label: resolveSenderLabel({
diff --git a/src/auto-reply/templating.ts b/src/auto-reply/templating.ts
@@ -188,6 +188,22 @@ export type MsgContext = {
   /** Platform bot username when command mentions should be normalized. */
   BotUsername?: string;
   WasMentioned?: boolean;
+  /** True when this turn explicitly mentioned the current bot target. */
+  ExplicitlyMentionedBot?: boolean;
+  /** Provider-native explicit user mention ids present on this turn. */
+  MentionedUserIds?: string[];
+  /** Provider-native explicit user-group/subteam mention ids present on this turn. */
+  MentionedSubteamIds?: string[];
+  /** Provider-native implicit mention wake reasons present on this turn. */
+  ImplicitMentionKinds?: string[];
+  /** Provider-native source that caused the current mention decision. */
+  MentionSource?:
+    | "explicit_bot"
+    | "subteam"
+    | "mention_pattern"
+    | "implicit_thread"
+    | "command_bypass"
+    | "none";
   CommandAuthorized?: boolean;
   CommandSource?: "text" | "native";
   CommandTargetSessionKey?: string;

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-6980bbdd2836edf693dc24ee59253feadc5843cad3cde6efbef3bd1ffc8acf24`
	`1`	`+30bca8f93a8c52894fc94636b0a3561dce212fbb72a30d45276ab063486c857f`