@botcord/daemon 0.1.1 → 0.2.2

package/src/__tests__/system-context.test.ts

@@ -288,6 +288,41 @@ describe("createDaemonSystemContextBuilder", () => {
     expect(out).toBeUndefined();
   });
 
+  it("appends loopRiskBuilder output at the end of the system context", async () => {
+    const builder = createDaemonSystemContextBuilder({
+      agentId: "ag_me",
+      roomContextBuilder: async () => null,
+      loopRiskBuilder: () => "[BotCord loop-risk check]\nObserved signals:\n- x",
+    });
+    const out = await builder(
+      makeMessage({ conversation: { id: "rm_team", kind: "group" } }),
+    );
+    expect(typeof out).toBe("string");
+    expect(out).toContain("[BotCord loop-risk check]");
+  });
+
+  it("also injects loopRiskBuilder in the sync (no roomContextBuilder) branch", () => {
+    const builder = createDaemonSystemContextBuilder({
+      agentId: "ag_me",
+      loopRiskBuilder: () => "[BotCord loop-risk check]\nObserved signals:\n- y",
+    });
+    const out = builder(makeMessage()) as string | undefined;
+    expect(typeof out).toBe("string");
+    expect(out).toContain("[BotCord loop-risk check]");
+  });
+
+  it("skips loopRiskBuilder gracefully when it throws", async () => {
+    const builder = createDaemonSystemContextBuilder({
+      agentId: "ag_me",
+      roomContextBuilder: async () => null,
+      loopRiskBuilder: () => {
+        throw new Error("oops");
+      },
+    });
+    const out = await builder(makeMessage());
+    expect(out).toBeUndefined();
+  });
+
   it("translates GatewayInboundMessage.conversation.id → old `room_id` for the digest exclude key", () => {
     const tracker = new ActivityTracker({
       filePath: path.join(tmpDir, "activity.json"),

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

@@ -99,6 +99,149 @@ describe("composeBotCordUserTurn", () => {
     expect(out).toBe("");
   });
 
+  it("appends the contact-request notify-owner hint when envelope.type is contact_request", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        text: "Hi, please add me",
+        sender: { id: "ag_stranger", kind: "agent" },
+        conversation: { id: "rm_dm_x", kind: "direct" },
+        raw: { envelope: { type: "contact_request" } },
+      }),
+    );
+    expect(out).toContain("contact request from ag_stranger");
+    expect(out).toContain("botcord_notify tool");
+    // Base direct-chat hint should still appear above the contact-request hint.
+    expect(out).toContain("naturally concluded");
+    const baseIdx = out.indexOf("naturally concluded");
+    const crIdx = out.indexOf("contact request from");
+    expect(crIdx).toBeGreaterThan(baseIdx);
+  });
+
+  it("does NOT append the contact-request hint for a plain message envelope", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        raw: { envelope: { type: "message" } },
+      }),
+    );
+    expect(out).not.toContain("contact request from");
+  });
+
+  it("does NOT append the contact-request hint when msg.raw has no envelope", () => {
+    const out = composeBotCordUserTurn(makeMessage({ raw: {} }));
+    expect(out).not.toContain("contact request from");
+  });
+
+  it("renders a multi-message batch as [BotCord Messages (N new)] with one block per sender", () => {
+    const batch = [
+      {
+        hub_msg_id: "m1",
+        text: "first message",
+        envelope: { from: "ag_alice", type: "message" },
+      },
+      {
+        hub_msg_id: "m2",
+        text: "second message",
+        envelope: { from: "ag_bob", type: "message" },
+        mentioned: true,
+      },
+    ];
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        text: "second message",
+        sender: { id: "ag_bob", kind: "agent" },
+        conversation: { id: "rm_team", kind: "group", title: "Ouraca" },
+        mentioned: true,
+        raw: { batch, envelope: { type: "message", from: "ag_bob" } },
+      }),
+    );
+    expect(out).toContain("[BotCord Messages (2 new)]");
+    expect(out).toContain("room: Ouraca");
+    expect(out).toContain("mentioned: true");
+    expect(out).toContain('<agent-message sender="ag_alice" sender_kind="agent">');
+    expect(out).toContain("first message");
+    expect(out).toContain('<agent-message sender="ag_bob" sender_kind="agent">');
+    expect(out).toContain("second message");
+    // Single-message header must NOT appear in batch mode.
+    expect(out).not.toContain("[BotCord Message]");
+    // Group hint still appears after the blocks.
+    expect(out).toContain("do NOT reply unless");
+  });
+
+  it("batched path tags dashboard_human_room senders as human-message", () => {
+    const batch = [
+      {
+        hub_msg_id: "m1",
+        text: "hi bot",
+        envelope: { from: "ag_me", type: "message" },
+        source_type: "dashboard_human_room",
+        source_user_name: "Alice",
+      },
+      {
+        hub_msg_id: "m2",
+        text: "你好",
+        envelope: { from: "ag_peer", type: "message" },
+      },
+    ];
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        text: "你好",
+        sender: { id: "ag_peer", kind: "agent" },
+        conversation: { id: "rm_team", kind: "group" },
+        raw: { batch, envelope: { type: "message", from: "ag_peer" } },
+      }),
+    );
+    expect(out).toContain('<human-message sender="Alice" sender_kind="human">');
+    expect(out).toContain("hi bot");
+    expect(out).toContain('<agent-message sender="ag_peer" sender_kind="agent">');
+  });
+
+  it("batched path appends a single notify-owner hint listing every contact_request sender", () => {
+    const batch = [
+      {
+        hub_msg_id: "m1",
+        text: "please add me",
+        envelope: { from: "ag_stranger_a", type: "contact_request" },
+      },
+      {
+        hub_msg_id: "m2",
+        text: "add me too",
+        envelope: { from: "ag_stranger_b", type: "contact_request" },
+      },
+      {
+        hub_msg_id: "m3",
+        text: "normal reply",
+        envelope: { from: "ag_old_friend", type: "message" },
+      },
+    ];
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        text: "normal reply",
+        sender: { id: "ag_old_friend", kind: "agent" },
+        conversation: { id: "rm_dm_x", kind: "direct" },
+        raw: { batch, envelope: { type: "message", from: "ag_old_friend" } },
+      }),
+    );
+    expect(out).toContain("contact request from ag_stranger_a, ag_stranger_b");
+    // Direct hint (not group) for a DM room.
+    expect(out).toContain("naturally concluded");
+  });
+
+  it("falls back to the single-message path when raw.batch has only one entry", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        raw: {
+          batch: [
+            { hub_msg_id: "m1", text: "solo", envelope: { from: "ag_x", type: "message" } },
+          ],
+          envelope: { type: "message", from: "ag_x" },
+        },
+      }),
+    );
+    // batch length 1 → readBatch returns null → single-message header.
+    expect(out).toContain("[BotCord Message]");
+    expect(out).not.toContain("[BotCord Messages (");
+  });
+
   it("sanitizes room names so newline-based injection can't reshape the header", () => {
     const out = composeBotCordUserTurn(
       makeMessage({

package/src/daemon-config-map.ts

@@ -150,9 +150,10 @@ export function toGatewayConfig(
 
   // Synthesize a per-agent route for every bound agent and hand it to the
   // gateway via the managed-routes bucket (plan §10.1). User-authored
-  // `cfg.routes[]` stay untouched so an explicit operator override still
-  // wins on conflict — the gateway matches `routes[] → managedRoutes →
-  // defaultRoute` in that order.
+  // `cfg.routes[]` stay untouched. Match priority (see router.ts):
+  // `routes[] with explicit accountId → managedRoutes → other routes[] →
+  // defaultRoute`. Broad prefix/kind rules no longer clobber the agent's
+  // chosen runtime — only routes that name the agent by `accountId` do.
   const managedMap = buildManagedRoutes(
     agentIds,
     opts.agentRuntimes ?? {},

package/src/daemon.ts

@@ -6,6 +6,7 @@ import {
   type ChannelAdapter,
   type GatewayChannelConfig,
   type GatewayInboundMessage,
+  type GatewayOutboundMessage,
   type GatewayLogger,
   type GatewayRuntimeSnapshot,
 } from "./gateway/index.js";
@@ -22,6 +23,12 @@ import { SnapshotWriter } from "./snapshot-writer.js";
 import { createDaemonSystemContextBuilder } from "./system-context.js";
 import { createRoomStaticContextBuilder } from "./room-context.js";
 import { createRoomContextFetcher } from "./room-context-fetcher.js";
+import {
+  buildLoopRiskPrompt,
+  loopRiskSessionKey,
+  recordInboundText as recordLoopRiskInbound,
+  recordOutboundText as recordLoopRiskOutbound,
+} from "./loop-risk.js";
 import { composeBotCordUserTurn } from "./turn-text.js";
 import { UserAuthManager } from "./user-auth.js";
 
@@ -245,6 +252,14 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     msg: GatewayInboundMessage,
   ) => Promise<string | undefined> | string | undefined;
   const scBuilders = new Map<string, PerAgentBuilder>();
+  const loopRiskBuilder = (msg: GatewayInboundMessage): string | null =>
+    buildLoopRiskPrompt({
+      sessionKey: loopRiskSessionKey({
+        accountId: msg.accountId,
+        conversationId: msg.conversation.id,
+        threadId: msg.conversation.threadId ?? null,
+      }),
+    });
   for (const aid of agentIds) {
     scBuilders.set(
       aid,
@@ -252,6 +267,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
         agentId: aid,
         activityTracker,
         roomContextBuilder,
+        loopRiskBuilder,
       }),
     );
   }
@@ -274,10 +290,34 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
   // outside the system-context builder (option A) means the builder stays
   // pure — a cleaner contract the gateway can also expose to non-daemon
   // callers in the future.
-  const onInbound = createActivityRecorder({
+  const recordActivity = createActivityRecorder({
     activityTracker,
     ...(agentIds[0] ? { fallbackAgentId: agentIds[0] } : {}),
   });
+  const onInbound = (msg: GatewayInboundMessage): void => {
+    recordActivity(msg);
+    // Feed the loop-risk tracker with the sanitized inbound text so
+    // detectShortAckTail + detectHighTurnRate have a timeline.
+    recordLoopRiskInbound({
+      sessionKey: loopRiskSessionKey({
+        accountId: msg.accountId,
+        conversationId: msg.conversation.id,
+        threadId: msg.conversation.threadId ?? null,
+      }),
+      text: msg.text,
+      timestamp: msg.receivedAt,
+    });
+  };
+  const onOutbound = (out: GatewayOutboundMessage): void => {
+    recordLoopRiskOutbound({
+      sessionKey: loopRiskSessionKey({
+        accountId: out.accountId,
+        conversationId: out.conversationId,
+        threadId: out.threadId ?? null,
+      }),
+      text: out.text,
+    });
+  };
 
   const gateway = new Gateway({
     config: gwConfig,
@@ -298,6 +338,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     turnTimeoutMs: DEFAULT_TURN_TIMEOUT_MS,
     buildSystemContext,
     onInbound,
+    onOutbound,
     composeUserTurn: composeBotCordUserTurn,
   });
 

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

@@ -255,6 +255,95 @@ describe("createBotCordChannel — inbox normalization", () => {
     }
   });
 
+  it("lets contact_request envelopes through so the composer can add the notify-owner hint", async () => {
+    const { emits, server } = await startWithInbox([
+      makeInbox({
+        hub_msg_id: "m_cr",
+        room_id: "rm_dm_peer",
+        text: "Hi, please add me",
+        envelope: {
+          type: "contact_request",
+          from: "ag_stranger",
+          payload: { text: "Hi, please add me" },
+        } as unknown as InboxMessage["envelope"],
+      }),
+    ]);
+    try {
+      expect(emits).toHaveLength(1);
+      const env = emits[0].message;
+      expect(env.sender.id).toBe("ag_stranger");
+      expect(env.text).toBe("Hi, please add me");
+      // Raw preserves envelope so turn-text can detect the type.
+      const raw = env.raw as { envelope?: { type?: string } };
+      expect(raw?.envelope?.type).toBe("contact_request");
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("groups two messages in the same room/topic into one batched envelope", async () => {
+    const server = await startAuthOkServer();
+    try {
+      const polled = [
+        makeInbox({
+          hub_msg_id: "m_b1",
+          room_id: "rm_team",
+          room_name: "Team",
+          text: "hi all",
+          envelope: { from: "ag_alice" } as InboxMessage["envelope"],
+        }),
+        makeInbox({
+          hub_msg_id: "m_b2",
+          room_id: "rm_team",
+          room_name: "Team",
+          text: "yeah",
+          envelope: { from: "ag_bob" } as InboxMessage["envelope"],
+          mentioned: true,
+        }),
+      ];
+      const client = makeClient({
+        pollInbox: vi.fn().mockResolvedValue({ messages: polled, count: 2, has_more: false }),
+        getHubUrl: vi.fn().mockReturnValue(server.url),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: server.url,
+      });
+      const abort = new AbortController();
+      const emits: GatewayInboundEnvelope[] = [];
+      const startP = channel.start({
+        config: stubConfig,
+        accountId: "ag_self",
+        abortSignal: abort.signal,
+        log: silentLog,
+        emit: async (env) => {
+          emits.push(env);
+        },
+        setStatus: () => {},
+      });
+      await vi.waitFor(() => expect(emits).toHaveLength(1));
+      const env = emits[0]!.message;
+      // Last sender wins for representative metadata; mentioned is sticky.
+      expect(env.sender.id).toBe("ag_bob");
+      expect(env.mentioned).toBe(true);
+      const raw = env.raw as { batch?: Array<{ hub_msg_id: string }> };
+      expect(Array.isArray(raw.batch)).toBe(true);
+      expect(raw.batch!.map((m) => m.hub_msg_id)).toEqual(["m_b1", "m_b2"]);
+
+      // One accept() call acks BOTH hub ids together.
+      await emits[0]!.ack!.accept();
+      expect(client.ackMessages).toHaveBeenCalledWith(["m_b1", "m_b2"]);
+
+      abort.abort();
+      await startP;
+    } finally {
+      await server.close();
+    }
+  });
+
   it("sanitizes prompt-injection markers in untrusted text but not in owner-chat", async () => {
     const { emits, server } = await startWithInbox([
       makeInbox({

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

@@ -350,6 +350,46 @@ describe("Dispatcher", () => {
     expect(runtime.calls[0].text).toBe("hello");
   });
 
+  it("fires onOutbound after a reply is dispatched", async () => {
+    const runtime = new FakeRuntime({ reply: "hello back", newSessionId: "sid-1" });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const outbound: string[] = [];
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels: new Map<string, ChannelAdapter>([[channel.id, channel]]),
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      onOutbound: (msg) => {
+        outbound.push(msg.text);
+      },
+    });
+    await dispatcher.handle(makeEnvelope({ id: "msg_1", text: "hi" }));
+    expect(outbound).toEqual(["hello back"]);
+  });
+
+  it("does not crash when onOutbound throws", async () => {
+    const runtime = new FakeRuntime({ reply: "hello back", newSessionId: "sid-1" });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels: new Map<string, ChannelAdapter>([[channel.id, channel]]),
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      onOutbound: () => {
+        throw new Error("boom");
+      },
+    });
+    await dispatcher.handle(makeEnvelope({ id: "msg_1", text: "hi" }));
+    // Reply still went out; no assertion needed beyond the absence of a throw.
+    expect(channel.sends.length).toBe(1);
+  });
+
   it("does not crash when an errored turn has no prior session entry", async () => {
     const runtime = new FakeRuntime({ newSessionId: "", errorText: "boom" });
     const { dispatcher, store } = await scaffold({ runtimeFactory: () => runtime });

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

@@ -78,13 +78,39 @@ describe("resolveRoute", () => {
   });
 
   describe("managedRoutes", () => {
-    it("user cfg.routes match wins over managed for same accountId", () => {
+    it("user route with explicit accountId wins over managed for same agent", () => {
       const user = makeRoute({ runtime: "user", match: { accountId: "ag_1" } });
       const managed = makeRoute({ runtime: "managed", match: { accountId: "ag_1" } });
       const msg = makeMessage({ accountId: "ag_1" });
       expect(resolveRoute(msg, { defaultRoute, routes: [user] }, [managed])).toBe(user);
     });
 
+    it("broad user route (no accountId) does NOT override managed per-agent route", () => {
+      const broad = makeRoute({
+        runtime: "broad",
+        match: { conversationPrefix: "rm_oc_" },
+      });
+      const managed = makeRoute({ runtime: "managed", match: { accountId: "ag_1" } });
+      const msg = makeMessage({
+        accountId: "ag_1",
+        conversation: { id: "rm_oc_abc", kind: "group" },
+      });
+      expect(resolveRoute(msg, { defaultRoute, routes: [broad] }, [managed])).toBe(managed);
+    });
+
+    it("broad user route applies when no managed route matches the agent", () => {
+      const broad = makeRoute({
+        runtime: "broad",
+        match: { conversationPrefix: "rm_oc_" },
+      });
+      const managed = makeRoute({ runtime: "managed", match: { accountId: "ag_other" } });
+      const msg = makeMessage({
+        accountId: "ag_1",
+        conversation: { id: "rm_oc_abc", kind: "group" },
+      });
+      expect(resolveRoute(msg, { defaultRoute, routes: [broad] }, [managed])).toBe(broad);
+    });
+
     it("no user match + managed match → managed wins", () => {
       const managed = makeRoute({ runtime: "managed", match: { accountId: "ag_1" } });
       const msg = makeMessage({ accountId: "ag_1" });

package/src/gateway/channels/botcord.ts

@@ -147,7 +147,13 @@ function normalizeInbox(
 ): GatewayInboundMessage | null {
   const env = msg.envelope;
   if (!env) return null;
-  if (env.type !== "message") return null;
+  // `message` is the normal conversational envelope; `contact_request` is
+  // a lightweight inbound asking the agent to notify its owner (the
+  // composer appends the notify-owner hint). All other envelope types
+  // (notification, system, contact_added/removed, …) are still filtered
+  // out here — they belong in a separate push-notification path that
+  // daemon does not yet implement.
+  if (env.type !== "message" && env.type !== "contact_request") return null;
   if (!msg.room_id) return null;
 
   const rawText =
@@ -190,6 +196,66 @@ function normalizeInbox(
   };
 }
 
+/**
+ * Shape of the `raw` field when the channel batches multiple messages into
+ * one envelope. Keeps the latest message's InboxMessage fields at top level
+ * so existing accesses (`raw.envelope.type`, `raw.source_type`, …) still
+ * work, and exposes the full list via `raw.batch`. `composeBotCordUserTurn`
+ * reads `raw.batch` to build one `<agent-message>` / `<human-message>` block
+ * per entry.
+ */
+export interface BatchedInboxRaw extends InboxMessage {
+  batch: InboxMessage[];
+}
+
+/**
+ * Normalize a group of InboxMessages for the same `(room, topic)` into a
+ * single `GatewayInboundMessage`. The envelope carries the latest msg's
+ * metadata (routing, session key, trace) and a `raw.batch` array the
+ * composer uses to render per-sender blocks.
+ *
+ * `mentioned` is sticky: true if ANY message in the group is a mention.
+ * Returns null if no message in the group is normalizable on its own.
+ */
+function normalizeInboxBatch(
+  msgs: InboxMessage[],
+  options: { channelId: string; accountId: string },
+): GatewayInboundMessage | null {
+  if (msgs.length === 0) return null;
+  if (msgs.length === 1) return normalizeInbox(msgs[0]!, options);
+
+  const latest = msgs[msgs.length - 1]!;
+  const base = normalizeInbox(latest, options);
+  if (!base) return null;
+
+  // Fold sibling metadata into the base envelope. `text` is kept non-empty
+  // when at least one batched member has a body, so the dispatcher's empty-
+  // text skip rule doesn't drop the whole batch just because the latest
+  // envelope was e.g. a zero-payload contact_request.
+  const anyMentioned = msgs.some((m) => m.mentioned === true);
+  let representativeText = base.text ?? "";
+  if (!representativeText.trim()) {
+    for (let i = msgs.length - 1; i >= 0; i--) {
+      const m = msgs[i]!;
+      const candidate =
+        m.text ??
+        (typeof m.envelope?.payload?.text === "string"
+          ? (m.envelope.payload.text as string)
+          : "");
+      if (candidate && candidate.trim()) {
+        representativeText = candidate;
+        break;
+      }
+    }
+  }
+  return {
+    ...base,
+    text: representativeText,
+    mentioned: anyMentioned,
+    raw: { ...latest, batch: msgs } satisfies BatchedInboxRaw,
+  };
+}
+
 /**
  * Construct a BotCord channel adapter.
  *
@@ -244,9 +310,14 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
     log.info("botcord inbox drained", { count: msgs.length });
     if (msgs.length === 0) return;
 
+    // First pass: ack duplicates/skipped messages so Hub stops requeueing,
+    // and collect eligible messages preserving poll order. Grouping by
+    // `(room_id, topic)` mirrors plugin's `handleInboxMessageBatch` — the
+    // same conversation thread folds into one turn so the agent sees all
+    // new messages at once instead of running N turns back-to-back.
+    const eligible: InboxMessage[] = [];
     for (const msg of msgs) {
       if (!rememberSeen(msg.hub_msg_id)) {
-        // Already emitted; ack again so Hub stops requeueing.
         try {
           await client.ackMessages([msg.hub_msg_id]);
         } catch (err) {
@@ -259,7 +330,6 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
         accountId: options.accountId,
       });
       if (!normalized) {
-        // Not eligible (wrong type, missing room, etc.) — ack so it drops.
         try {
           await client.ackMessages([msg.hub_msg_id]);
         } catch (err) {
@@ -267,15 +337,41 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
         }
         continue;
       }
+      eligible.push(msg);
+    }
+
+    if (eligible.length === 0) return;
+
+    // Group by `(room_id, topic)`. Insertion order is the poll order, so
+    // iterating the map yields groups with the same external chronology.
+    const groups = new Map<string, InboxMessage[]>();
+    for (const msg of eligible) {
+      const topic = msg.topic_id ?? msg.topic ?? "";
+      const key = `${msg.room_id ?? ""}:${topic}`;
+      const list = groups.get(key);
+      if (list) list.push(msg);
+      else groups.set(key, [msg]);
+    }
+
+    for (const group of groups.values()) {
+      const normalized = normalizeInboxBatch(group, {
+        channelId: options.id,
+        accountId: options.accountId,
+      });
+      if (!normalized) continue;
+
+      const hubIds = group.map((m) => m.hub_msg_id);
       const envelope: GatewayInboundEnvelope = {
         message: normalized,
         ack: {
           accept: async () => {
             try {
-              await client.ackMessages([msg.hub_msg_id]);
+              // Ack the entire batch together so Hub never re-delivers any
+              // member of this turn if the agent succeeds on the group.
+              await client.ackMessages(hubIds);
             } catch (err) {
               log.warn("botcord ack failed — relying on seen-cache dedup", {
-                hubMsgId: msg.hub_msg_id,
+                hubMsgIds: hubIds,
                 err: String(err),
               });
             }
@@ -286,7 +382,7 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
         await emit(envelope);
       } catch (err) {
         log.error("botcord emit threw", {
-          hubMsgId: msg.hub_msg_id,
+          hubMsgIds: hubIds,
           err: String(err),
         });
       }