fix(mattermost): key resolved group targets under group: namespace (#95646)

hansraj316 · hansraj316 · commit cab9efc6bbdf · 2026-06-21T21:42:22.000-07:00
A private channel / group DM is classified group by the inbound path
(mapMattermostChannelKind: P/G -&gt; group) but the outbound session route
flattened every non-user target to channel, splitting the same
conversation across group:&lt;id&gt; and a phantom channel:&lt;id&gt; session key.
Honor an authoritative resolved group kind so delivery keys match inbound.

A bare channel:&lt;id&gt; target with no resolved kind still resolves to
channel since the real channel type is not knowable from the target
string alone; full coverage of that path needs live Mattermost repro.
diff --git a/extensions/mattermost/src/session-route.test.ts b/extensions/mattermost/src/session-route.test.ts
@@ -43,6 +43,27 @@ describe("mattermost session route", () => {
     expect(channelRoute.sessionKey).toContain("thread456");
   });
 
+  it("keys a resolved group target under group:, matching inbound classification (#95646)", () => {
+    const route = resolveMattermostOutboundSessionRoute({
+      cfg: {},
+      agentId: "main",
+      accountId: "acct-1",
+      target: "mattermost:channel:priv123",
+      resolvedTarget: { kind: "group", to: "channel:priv123" },
+    });
+
+    const groupRoute = expectRoute(route);
+    expect(groupRoute.peer.kind).toBe("group");
+    expect(groupRoute.peer.id).toBe("priv123");
+    expect(groupRoute.chatType).toBe("group");
+    expect(groupRoute.from).toBe("mattermost:group:priv123");
+    // Delivery target string stays channel: — Mattermost addresses all channels
+    // (including private) by id; only the session namespace is type-aware.
+    expect(groupRoute.to).toBe("channel:priv123");
+    expect(groupRoute.baseSessionKey).toContain(":group:priv123");
+    expect(groupRoute.baseSessionKey).not.toContain(":channel:priv123");
+  });
+
   it("recovers channel thread routes from currentSessionKey", () => {
     const route = resolveMattermostOutboundSessionRoute({
       cfg: {},
diff --git a/extensions/mattermost/src/session-route.ts b/extensions/mattermost/src/session-route.ts
@@ -20,24 +20,33 @@ export function resolveMattermostOutboundSessionRoute(params: ChannelOutboundSes
     (resolvedKind !== "channel" &&
       resolvedKind !== "group" &&
       (lower.startsWith("user:") || trimmed.startsWith("@")));
+  // Honor an authoritative `group` kind (private channel / group DM, from the
+  // directory resolver) instead of flattening every non-user target to
+  // `channel`. The inbound path keys these under `group:<id>` via
+  // mapMattermostChannelKind (P/G -> group); a `channel:<id>` outbound route
+  // would split the same conversation across two session namespaces (#95646).
+  // A bare `channel:<id>` with no resolved kind stays `channel` since the real
+  // channel type is not knowable from the target string alone.
+  const isGroup = !isUser && resolvedKind === "group";
   if (trimmed.startsWith("@")) {
     trimmed = trimmed.slice(1).trim();
   }
   const rawId = stripTargetKindPrefix(trimmed);
   if (!rawId) {
     return null;
   }
+  const kind = isUser ? "direct" : isGroup ? "group" : "channel";
   const baseRoute = buildChannelOutboundSessionRoute({
     cfg: params.cfg,
     agentId: params.agentId,
     channel: "mattermost",
     accountId: params.accountId,
     peer: {
-      kind: isUser ? "direct" : "channel",
+      kind,
       id: rawId,
     },
-    chatType: isUser ? "direct" : "channel",
-    from: isUser ? `mattermost:${rawId}` : `mattermost:channel:${rawId}`,
+    chatType: kind,
+    from: isUser ? `mattermost:${rawId}` : `mattermost:${kind}:${rawId}`,
     to: isUser ? `user:${rawId}` : `channel:${rawId}`,
   });
   return buildThreadAwareOutboundSessionRoute({
