@botcord/daemon 0.2.69 → 0.2.71

package/src/__tests__/loop-risk.test.ts

@@ -28,6 +28,8 @@ describe("stripBotCordPromptScaffolding", () => {
       "",
       "When a message matches an active monitoring rule, automation goal, working-memory task, keyword, sender rule, or owner-approved workflow, perform the required action even if you do not reply to the group.",
       "",
+      "Before replying NO_REPLY in a non-owner group room, consider whether this message could match a memory-backed monitoring rule, automation goal, pending task, keyword, sender rule, or owner-approved workflow. If needed, use the botcord_memory skill to retrieve or update working memory.",
+      "",
       'If no group reply and no background action is needed, reply exactly "NO_REPLY".]',
     ].join("\n");
     expect(stripBotCordPromptScaffolding(wrapped)).toBe("hello world");

package/src/__tests__/provision.test.ts

@@ -265,6 +265,8 @@ describe("wake_agent handler", () => {
         message: "【BotCord 自主任务】执行本轮工作目标。",
         run_id: "sr_test",
         schedule_id: "sch_test",
+        scheduled_for: "2026-05-19T01:30:00+00:00",
+        dispatched_at: "2026-05-19T01:30:02+00:00",
         dedupe_key: "sch_test:1:auto",
       },
     });
@@ -279,6 +281,14 @@ describe("wake_agent handler", () => {
     expect(msg.sender.kind).toBe("system");
     expect(msg.text).toContain("BotCord 自主任务");
     expect(msg.conversation.threadId).toBe("sch_test");
+    expect(msg.raw).toMatchObject({
+      source_type: "botcord_schedule",
+      schedule_id: "sch_test",
+      scheduled_for: "2026-05-19T01:30:00+00:00",
+      dispatched_at: "2026-05-19T01:30:02+00:00",
+      run_id: "sr_test",
+      dedupe_key: "sch_test:1:auto",
+    });
   });
 
   it("rejects wake_agent for an unloaded agent", async () => {

package/src/__tests__/turn-text.test.ts

@@ -37,6 +37,8 @@ describe("composeBotCordUserTurn", () => {
     expect(out).toContain("do not send a message back to the current group room");
     expect(out).toContain("owner-approved or policy-approved background actions");
     expect(out).toContain("active monitoring rule");
+    expect(out).toContain("botcord_memory");
+    expect(out).toContain("retrieve or update working memory");
     expect(out).toContain('"NO_REPLY"');
   });
 
@@ -97,6 +99,31 @@ describe("composeBotCordUserTurn", () => {
     expect(out).not.toContain("do NOT reply unless");
   });
 
+  it("renders schedule timing metadata for proactive schedule turns", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        conversation: { id: "rm_schedule_ag_me", kind: "direct", title: "BotCord Scheduler", threadId: "sch_daily" },
+        sender: { id: "hub", name: "BotCord Scheduler", kind: "system" },
+        text: "daily brief",
+        mentioned: true,
+        raw: {
+          source_type: "botcord_schedule",
+          schedule_id: "sch_daily",
+          scheduled_for: "2026-05-19T01:30:00+00:00",
+          dispatched_at: "2026-05-19T01:30:02+00:00",
+          run_id: "sr_daily",
+        },
+      }),
+    );
+    expect(out).toContain("[BotCord Schedule]");
+    expect(out).toContain("This turn was triggered by a proactive schedule.");
+    expect(out).toContain("schedule_id: sch_daily");
+    expect(out).toContain("scheduled_for: 2026-05-19T01:30:00+00:00");
+    expect(out).toContain("dispatched_at: 2026-05-19T01:30:02+00:00");
+    expect(out).toContain("run_id: sr_daily");
+    expect(out.indexOf("[BotCord Schedule]")).toBeLessThan(out.indexOf("<agent-message"));
+  });
+
   it("keeps the botcord_send delivery hint for non-owner BotCord rooms", () => {
     const out = composeBotCordUserTurn(
       makeMessage({

package/src/agent-workspace.ts

@@ -32,6 +32,7 @@ import {
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 
 const require = createRequire(import.meta.url);
 
@@ -397,9 +398,23 @@ export function ensureAgentHermesWorkspace(
  * Seeded fresh per `ensureAgent*` call (force-overwrite) so daemon
  * upgrades propagate.
  */
-const BUNDLED_SKILLS = ["botcord", "botcord-user-guide"] as const;
+const BUNDLED_SKILLS = ["botcord", "botcord-user-guide", "botcord_memory"] as const;
+
+function resolveRepoCliSkillsRoot(): string | null {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i += 1) {
+    const candidate = path.join(dir, "cli", "skills");
+    if (existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
 
 function resolveBundledCliSkillsRoot(): string | null {
+  const repoRoot = resolveRepoCliSkillsRoot();
+  if (repoRoot) return repoRoot;
   try {
     const pkgJsonPath = require.resolve("@botcord/cli/package.json");
     const root = path.join(path.dirname(pkgJsonPath), "skills");

package/src/gateway/__tests__/dispatcher.test.ts

@@ -293,6 +293,30 @@ describe("Dispatcher", () => {
     expect(store.all()[0].threadId).toBe("t_1");
   });
 
+  it("sends replies to the provider reply id when it differs from the internal message id", async () => {
+    const runtime = new FakeRuntime({ reply: "ok" });
+    const feishuChannel = new FakeChannel({ id: "gw_feishu_1", type: "feishu" });
+    const { dispatcher, channel } = await scaffold({
+      runtimeFactory: () => runtime,
+      channel: feishuChannel,
+      config: baseConfig({
+        channels: [{ id: "gw_feishu_1", type: "feishu", accountId: "ag_me" }],
+      }),
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({
+        id: "feishu:om_internal_wrapped",
+        replyTo: "om_provider_raw",
+        channel: "gw_feishu_1",
+        conversation: { id: "feishu:user:oc_chat", kind: "direct" },
+      }),
+    );
+
+    expect(channel.sends.length).toBe(1);
+    expect(channel.sends[0].message.replyTo).toBe("om_provider_raw");
+  });
+
   it("reuses session id on second message with same queue key", async () => {
     const seen: Array<string | null> = [];
     const runtime = new FakeRuntime({
@@ -2009,7 +2033,8 @@ describe("Dispatcher", () => {
     });
     await dispatcher.handle(
       makeEnvelope({
-        id: "m_err",
+        id: "feishu:om_internal_err",
+        replyTo: "om_provider_err",
         conversation: { id: "rm_g_other", kind: "group" },
       }),
     );
@@ -2017,7 +2042,7 @@ describe("Dispatcher", () => {
     expect(channel.sends[0].message.type).toBe("error");
     expect(channel.sends[0].message.text).toContain("Runtime error: boom");
     expect(channel.sends[0].message.conversationId).toBe("rm_g_other");
-    expect(channel.sends[0].message.replyTo).toBe("m_err");
+    expect(channel.sends[0].message.replyTo).toBe("om_provider_err");
   });
 
   // ─────────────────────────────────────────────────────────────────────

package/src/gateway/__tests__/feishu-channel.test.ts

@@ -255,27 +255,80 @@ describe("createFeishuChannel", () => {
     expect(JSON.parse(send.data.content as string)).toEqual({ file_key: "file_v2_uploaded" });
   });
 
-  it("exposes typing as a safe no-op because Feishu has no bot typing API", async () => {
-    const debug = vi.fn();
+  it("adds a Typing reaction for typing and removes it when replying", async () => {
     const adapter = createFeishuChannel({
       id: "gw_fs",
       accountId: "ag_self",
       appId: "cli_a",
       appSecret: "sec",
     });
+    larkMock.responses.push(
+      { code: 0, data: { reaction_id: "react_typing_1" } },
+      { code: 0, data: { message_id: "om_reply" } },
+      { code: 0, data: {} },
+    );
 
     await adapter.typing?.({
       traceId: "feishu:om_1",
       accountId: "ag_self",
       conversationId: "feishu:chat:oc_chat",
-      log: { ...SILENT_LOG, debug },
+      log: SILENT_LOG,
     });
 
-    expect(larkMock.requests).toHaveLength(0);
-    expect(debug).toHaveBeenCalledWith(
-      "feishu typing ignored: no native bot typing API",
-      expect.objectContaining({ channel: "gw_fs" }),
-    );
+    expect(larkMock.requests).toHaveLength(1);
+    expect(larkMock.requests[0]).toEqual({
+      method: "POST",
+      url: "/open-apis/im/v1/messages/om_1/reactions",
+      data: { reaction_type: { emoji_type: "Typing" } },
+    });
+
+    await adapter.send({
+      message: {
+        channel: "gw_fs",
+        accountId: "ag_self",
+        conversationId: "feishu:chat:oc_chat",
+        text: "reply",
+        replyTo: "om_1",
+      },
+      log: SILENT_LOG,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(larkMock.requests).toHaveLength(3);
+    expect(larkMock.requests[2]).toEqual({
+      method: "DELETE",
+      url: "/open-apis/im/v1/messages/om_1/reactions/react_typing_1",
+    });
+  });
+
+  it("refreshes an existing Feishu typing reaction without creating duplicates", async () => {
+    const adapter = createFeishuChannel({
+      id: "gw_fs",
+      accountId: "ag_self",
+      appId: "cli_a",
+      appSecret: "sec",
+    });
+    larkMock.responses.push({ code: 0, data: { reaction_id: "react_typing_1" } });
+
+    await adapter.typing?.({
+      traceId: "feishu:om_1",
+      accountId: "ag_self",
+      conversationId: "feishu:chat:oc_chat",
+      log: SILENT_LOG,
+    });
+    await adapter.typing?.({
+      traceId: "feishu:om_1",
+      accountId: "ag_self",
+      conversationId: "feishu:chat:oc_chat",
+      log: SILENT_LOG,
+    });
+
+    expect(larkMock.requests).toHaveLength(1);
+    expect(larkMock.requests[0]).toEqual({
+      method: "POST",
+      url: "/open-apis/im/v1/messages/om_1/reactions",
+      data: { reaction_type: { emoji_type: "Typing" } },
+    });
   });
 
   it("surfaces websocket start failures in channel status", async () => {

package/src/gateway/channels/feishu.ts

@@ -21,6 +21,8 @@ import type { FeishuDomain } from "./feishu-registration.js";
 const FEISHU_PROVIDER = "feishu" as const;
 const DEFAULT_SPLIT_AT = 4000;
 const MAX_SEEN_MESSAGES = 2048;
+const TYPING_EMOJI = "Typing";
+const TYPING_REACTION_TTL_MS = 20_000;
 
 export interface FeishuChannelOptions {
   id: string;
@@ -80,6 +82,10 @@ interface FeishuApiResponse {
 }
 
 type FeishuClient = { request(args: unknown): Promise<unknown> };
+type TypingReactionState = {
+  reactionId: string | null;
+  timer: ReturnType<typeof setTimeout> | null;
+};
 
 function sdkDomain(domain: FeishuDomain | undefined): unknown {
   const sdk = Lark as unknown as {
@@ -137,6 +143,7 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
   let botOpenId: string | undefined;
   let botName: string | undefined;
   let liveSetStatus: ((patch: Partial<ChannelStatusSnapshot>) => void) | null = null;
+  const activeTypingReactions = new Map<string, TypingReactionState>();
 
   let statusSnapshot: ChannelStatusSnapshot = {
     channel: opts.id,
@@ -387,6 +394,44 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
     );
   }
 
+  function resultReactionId(res: FeishuApiResponse): string | null {
+    return (
+      (typeof res.data?.reaction_id === "string" ? res.data.reaction_id : undefined) ??
+      (typeof res.reaction_id === "string" ? res.reaction_id : undefined) ??
+      null
+    );
+  }
+
+  function messageIdFromTrace(traceId: string): string | null {
+    if (!traceId.startsWith("feishu:")) return null;
+    const messageId = traceId.slice("feishu:".length).trim();
+    return messageId.length > 0 ? messageId : null;
+  }
+
+  async function removeTypingReaction(messageId: string): Promise<void> {
+    const state = activeTypingReactions.get(messageId);
+    if (!state) return;
+    activeTypingReactions.delete(messageId);
+    if (state.timer) clearTimeout(state.timer);
+    if (!state.reactionId) return;
+    try {
+      await callFeishu({
+        method: "DELETE",
+        url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(state.reactionId)}`,
+      });
+    } catch (err) {
+      statusSnapshot.lastError = err instanceof Error ? err.message : String(err);
+    }
+  }
+
+  function scheduleTypingCleanup(messageId: string, state: TypingReactionState): void {
+    if (state.timer) clearTimeout(state.timer);
+    state.timer = setTimeout(() => {
+      void removeTypingReaction(messageId);
+    }, TYPING_REACTION_TTL_MS);
+    if (typeof state.timer.unref === "function") state.timer.unref();
+  }
+
   function resultResourceKey(res: FeishuApiResponse, key: "image_key" | "file_key"): string {
     const direct = res[key];
     if (typeof direct === "string") return direct;
@@ -516,15 +561,61 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
         replyInThread: Boolean(ctx.message.threadId),
       }) ?? providerMessageId;
     }
+    if (ctx.message.replyTo) {
+      void removeTypingReaction(ctx.message.replyTo);
+    }
+    if (ctx.message.threadId && ctx.message.threadId !== ctx.message.replyTo) {
+      void removeTypingReaction(ctx.message.threadId);
+    }
     markStatus({ lastSendAt: Date.now() });
     return { providerMessageId };
   }
 
   async function typing(ctx: ChannelTypingContext): Promise<void> {
-    ctx.log.debug("feishu typing ignored: no native bot typing API", {
-      channel: opts.id,
-      conversationId: ctx.conversationId,
-    });
+    const messageId = messageIdFromTrace(ctx.traceId);
+    if (!messageId) {
+      ctx.log.debug("feishu typing skipped: trace id has no message id", {
+        channel: opts.id,
+        conversationId: ctx.conversationId,
+        traceId: ctx.traceId,
+      });
+      return;
+    }
+    const existing = activeTypingReactions.get(messageId);
+    if (existing) {
+      scheduleTypingCleanup(messageId, existing);
+      return;
+    }
+
+    const state: TypingReactionState = { reactionId: null, timer: null };
+    activeTypingReactions.set(messageId, state);
+    scheduleTypingCleanup(messageId, state);
+    try {
+      const res = await callFeishu({
+        method: "POST",
+        url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions`,
+        data: { reaction_type: { emoji_type: TYPING_EMOJI } },
+      });
+      const reactionId = resultReactionId(res);
+      if (activeTypingReactions.get(messageId) !== state) {
+        if (reactionId) {
+          await callFeishu({
+            method: "DELETE",
+            url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(reactionId)}`,
+          });
+        }
+        return;
+      }
+      state.reactionId = reactionId;
+    } catch (err) {
+      activeTypingReactions.delete(messageId);
+      if (state.timer) clearTimeout(state.timer);
+      ctx.log.warn("feishu typing reaction failed", {
+        channel: opts.id,
+        conversationId: ctx.conversationId,
+        err: err instanceof Error ? err.message : String(err),
+      });
+    }
   }
 
   async function stop(_ctx: ChannelStopContext): Promise<void> {
@@ -534,6 +625,7 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
       // best effort
     }
     wsClient = null;
+    await Promise.allSettled(Array.from(activeTypingReactions.keys()).map(removeTypingReaction));
     try {
       stateStore?.close();
     } catch {

package/src/gateway/dispatcher.ts

@@ -1343,7 +1343,7 @@ export class Dispatcher {
             threadId: msg.conversation.threadId ?? null,
             type: "error",
             text: `⚠️ Runtime timeout after ${Math.round(this.turnTimeoutMs / 60000)} minute(s); aborted`,
-            replyTo: msg.id,
+            replyTo: this.providerReplyTo(msg),
             traceId: msg.trace?.id ?? null,
           }, turnId);
         } else {
@@ -1389,7 +1389,7 @@ export class Dispatcher {
             threadId: msg.conversation.threadId ?? null,
             type: "error",
             text: `⚠️ Runtime error: ${truncate(errMsg, 500)}`,
-            replyTo: msg.id,
+            replyTo: this.providerReplyTo(msg),
             traceId: msg.trace?.id ?? null,
           }, turnId);
         } else {
@@ -1494,7 +1494,7 @@ export class Dispatcher {
               threadId: msg.conversation.threadId ?? null,
               type: "error",
               text: `⚠️ Runtime error: ${truncate(result.error, 500)}`,
-              replyTo: msg.id,
+              replyTo: this.providerReplyTo(msg),
               traceId: msg.trace?.id ?? null,
             }, turnId);
             this.emitOutbound({
@@ -1571,7 +1571,7 @@ export class Dispatcher {
         conversationId: msg.conversation.id,
         threadId: msg.conversation.threadId ?? null,
         text: replyText,
-        replyTo: msg.id,
+        replyTo: this.providerReplyTo(msg),
         traceId: msg.trace?.id ?? null,
       }, turnId);
       this.emitOutbound({
@@ -1638,6 +1638,10 @@ export class Dispatcher {
     return { ok: true };
   }
 
+  private providerReplyTo(msg: GatewayInboundMessage): string {
+    return msg.replyTo ?? msg.id;
+  }
+
   private emitInbound(turnId: string, msg: GatewayInboundEnvelope["message"]): void {
     if (!this.transcript.enabled) return;
     const rawText = typeof msg.text === "string" ? msg.text : "";

package/src/gateway/gateway.ts

@@ -13,6 +13,7 @@ import type {
   GatewayChannelConfig,
   GatewayConfig,
   GatewayInboundMessage,
+  GatewayOutboundMessage,
   GatewayRoute,
   GatewayRuntimeSnapshot,
   InboundObserver,
@@ -271,4 +272,17 @@ export class Gateway {
   async injectInbound(message: GatewayInboundMessage): Promise<void> {
     await this.dispatcher.handle({ message });
   }
+
+  /**
+   * Send a daemon-control initiated outbound message through a registered
+   * channel. Used by proactive third-party gateway sends where the runtime
+   * explicitly targets an external provider conversation.
+   */
+  async sendOutbound(message: GatewayOutboundMessage): Promise<{ providerMessageId?: string | null }> {
+    const channel = this.channelMap.get(message.channel);
+    if (!channel) {
+      throw new Error(`channel "${message.channel}" is not registered`);
+    }
+    return channel.send({ message, log: this.log });
+  }
 }

package/src/gateway-control.ts

@@ -176,6 +176,20 @@ interface GatewayRecentSendersResult {
   senders: GatewayRecentSender[];
 }
 
+interface GatewaySendParams {
+  agentId: string;
+  gatewayId: string;
+  conversationId: string;
+  text: string;
+  idempotencyKey?: string;
+}
+
+interface GatewaySendResult {
+  gatewayId: string;
+  conversationId: string;
+  providerMessageId?: string | null;
+}
+
 export type { FetchLike };
 
 export interface GatewayControlContext {
@@ -927,6 +941,80 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     }
   }
 
+  // --- gateway_send -------------------------------------------------------
+  async function handleSend(params: GatewaySendParams): Promise<AckBody> {
+    if (!params.agentId || typeof params.agentId !== "string") {
+      return badParams("gateway_send: agentId is required");
+    }
+    if (!params.gatewayId || typeof params.gatewayId !== "string") {
+      return badParams("gateway_send: gatewayId is required");
+    }
+    if (!params.conversationId || typeof params.conversationId !== "string") {
+      return badParams("gateway_send: conversationId is required");
+    }
+    if (typeof params.text !== "string" || params.text.length === 0) {
+      return badParams("gateway_send: text is required");
+    }
+
+    const cfg = cfgIO.load();
+    const profile = (cfg.thirdPartyGateways ?? []).find((g) => g.id === params.gatewayId);
+    if (!profile) {
+      return {
+        ok: false,
+        error: { code: "unknown_gateway", message: `no gateway with id "${params.gatewayId}"` },
+      };
+    }
+    if (profile.accountId !== params.agentId) {
+      return {
+        ok: false,
+        error: { code: "account_mismatch", message: "gateway is bound to a different agent" },
+      };
+    }
+    if (profile.enabled === false) {
+      return {
+        ok: false,
+        error: { code: "gateway_disabled", message: "gateway is disabled" },
+      };
+    }
+    if (profile.type === "wechat") {
+      return {
+        ok: false,
+        error: { code: "unsupported_provider", message: "wechat gateway_send requires an inbound context_token and is not supported" },
+      };
+    }
+
+    const conversationErr = validateOutboundConversation(profile, params.conversationId);
+    if (conversationErr) return conversationErr;
+
+    try {
+      const sendResult = await ctx.gateway.sendOutbound({
+        channel: params.gatewayId,
+        accountId: params.agentId,
+        conversationId: params.conversationId,
+        text: params.text,
+        traceId: `gateway-send:${params.idempotencyKey ?? Date.now()}`,
+      });
+      const result: GatewaySendResult = {
+        gatewayId: params.gatewayId,
+        conversationId: params.conversationId,
+        providerMessageId: sendResult.providerMessageId ?? null,
+      };
+      return { ok: true, result };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      daemonLog.warn("gateway_send failed", {
+        gatewayId: params.gatewayId,
+        accountId: params.agentId,
+        conversationId: params.conversationId,
+        error: message,
+      });
+      return {
+        ok: false,
+        error: { code: "send_failed", message },
+      };
+    }
+  }
+
   return {
     handleList,
     handleUpsert,
@@ -935,6 +1023,7 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     handleLoginStart,
     handleLoginStatus,
     handleRecentSenders,
+    handleSend,
     /** Exposed for tests — direct access to the in-memory session map. */
     _sessions: sessions,
   };
@@ -959,6 +1048,55 @@ function validateUpsertParams(p: UpsertGatewayParams): string | null {
   return null;
 }
 
+function validateOutboundConversation(
+  profile: ThirdPartyGatewayProfile,
+  conversationId: string,
+): AckBody | null {
+  const chatId = chatIdFromConversation(profile.type, conversationId);
+  if (!chatId) {
+    return {
+      ok: false,
+      error: {
+        code: "bad_conversation",
+        message: `conversationId "${conversationId}" is not valid for ${profile.type}`,
+      },
+    };
+  }
+  const allowed = new Set((profile.allowedChatIds ?? []).map(String));
+  if (!allowed.has(chatId)) {
+    return {
+      ok: false,
+      error: {
+        code: "conversation_not_allowed",
+        message: "conversation is not in the gateway allowedChatIds list",
+      },
+    };
+  }
+  return null;
+}
+
+function chatIdFromConversation(provider: ThirdPartyGatewayProfile["type"], conversationId: string): string | null {
+  if (provider === "telegram") {
+    if (conversationId.startsWith("telegram:user:")) {
+      return conversationId.slice("telegram:user:".length);
+    }
+    if (conversationId.startsWith("telegram:group:")) {
+      return conversationId.slice("telegram:group:".length);
+    }
+    return null;
+  }
+  if (provider === "feishu") {
+    if (conversationId.startsWith("feishu:user:")) {
+      return conversationId.slice("feishu:user:".length);
+    }
+    if (conversationId.startsWith("feishu:chat:")) {
+      return conversationId.slice("feishu:chat:".length);
+    }
+    return null;
+  }
+  return null;
+}
+
 function annotateProfile(
   p: ThirdPartyGatewayProfile,
   status: import("./gateway/index.js").ChannelStatusSnapshot | undefined,

package/src/loop-risk.ts

@@ -90,6 +90,9 @@ export function stripBotCordPromptScaffolding(text: string): string {
       if (line.startsWith("When a message matches an active monitoring rule")) return false;
       if (line.startsWith("keyword, sender rule")) return false;
       if (line.startsWith("you do not reply to the group")) return false;
+      if (line.startsWith("Before replying NO_REPLY in a non-owner group room")) return false;
+      if (line.startsWith("match a memory-backed monitoring rule")) return false;
+      if (line.startsWith("or owner-approved workflow. If needed")) return false;
       if (line.startsWith("[If the conversation has naturally concluded")) return false;
       if (line.startsWith("[You received a contact request")) return false;
       if (line.includes("no background action is needed")) return false;