fix(gateway): honor group/thread session isolation precedence in is_shared_multi_user_session

docs/session-lifecycle.md

@@ -269,18 +269,31 @@ or each get their own private session.
 def is_shared_multi_user_session(source, *, group_sessions_per_user, thread_sessions_per_user):
     if source.chat_type == "dm":
         return False  # DMs are always private
-    if source.thread_id:
-        return not thread_sessions_per_user  # Threads: shared unless per-user
-    return not group_sessions_per_user       # Groups: isolated unless shared
+    # Mirror build_session_key()'s precedence: start from the group isolation
+    # setting, then relax it inside a thread unless thread_sessions_per_user is
+    # set. A thread is isolated only when BOTH flags are True.
+    isolate_user = group_sessions_per_user
+    if source.thread_id and not thread_sessions_per_user:
+        isolate_user = False
+    return not isolate_user
 ```
 
+This tracks `build_session_key()`'s group/thread isolation **precedence** — not
+its full key string (`gateway/session.py`): the group setting is the base, and a
+thread only stays per-user isolated when both `group_sessions_per_user` and
+`thread_sessions_per_user` are enabled. The helper deliberately stays
+configuration-scoped: when no `user_id_alt`/`user_id` is present,
+`build_session_key()` omits the per-user identifier it would otherwise append
+and the key is shared by construction, so the helper reports that configuration
+decision rather than reconstructing the literal key.
+
 ### Summary
 
 | Chat Type | Default | Config Control |
 |---|---|---|
 | DM | Private (never shared) | N/A |
 | Group/Channel | Per-user isolation | `group_sessions_per_user` (default: True) |
-| Thread (forum, discord) | Shared (all participants see same context) | `thread_sessions_per_user` (default: False) |
+| Thread (forum, discord) | Shared (all participants see same context) | Isolated only when `group_sessions_per_user` **and** `thread_sessions_per_user` (default: False) |
 
 ### Impact on System Prompt
 

gateway/session.py

@@ -995,15 +995,19 @@ def is_shared_multi_user_session(
 
     Mirrors the isolation rules in :func:`build_session_key`:
       - DMs are never shared.
-      - Threads are shared unless ``thread_sessions_per_user`` is True.
       - Non-thread group/channel sessions are shared unless
         ``group_sessions_per_user`` is True (default: True = isolated).
+      - Threads follow the same group/thread isolation as
+        ``build_session_key``: a thread is isolated only when BOTH
+        ``group_sessions_per_user`` and ``thread_sessions_per_user`` are
+        True; otherwise it is shared.
     """
     if source.chat_type == "dm":
         return False
-    if source.thread_id:
-        return not thread_sessions_per_user
-    return not group_sessions_per_user
+    isolate_user = group_sessions_per_user
+    if source.thread_id and not thread_sessions_per_user:
+        isolate_user = False
+    return not isolate_user
 
 
 def _session_key_namespace(profile: Optional[str]) -> str:

tests/gateway/test_session.py

@@ -16,6 +16,7 @@
     build_session_context_prompt,
     build_session_key,
     canonical_whatsapp_identifier,
+    is_shared_multi_user_session,
     neutralize_untrusted_inline_text,
 )
 
@@ -728,6 +729,44 @@ def test_discord_thread_sessions_shared_by_default(self):
         assert build_session_key(alice) == build_session_key(bob)
         assert "alice" not in build_session_key(alice)
         assert "bob" not in build_session_key(bob)
+    def test_shared_helper_matches_build_session_key_group_thread(self):
+        """is_shared_multi_user_session must mirror build_session_key's
+        isolation precedence — not its full key string.
+
+        The helper tracks the isolation *decision* (whether build_session_key
+        would append a per-user participant_id), which stays configuration-
+        scoped: when no participant ID is present the key is shared by
+        construction, so the helper deliberately reports shared rather than
+        reconstructing the literal key. In the group_sessions_per_user=False +
+        thread_sessions_per_user=True combo, build_session_key emits a SHARED
+        thread key (no participant_id), so the helper must report the session
+        shared. Regression: the old thread branch dropped the group factor and
+        wrongly reported isolated, making the resume IDOR gate deny a
+        legitimate co-member.
+        """
+        source = SessionSource(
+            platform=Platform.DISCORD,
+            chat_id="guild-123",
+            chat_type="group",
+            thread_id="thread-9",
+            user_id="alice",
+            user_name="Alice",
+        )
+        key = build_session_key(
+            source,
+            group_sessions_per_user=False,
+            thread_sessions_per_user=True,
+        )
+        shared = is_shared_multi_user_session(
+            source,
+            group_sessions_per_user=False,
+            thread_sessions_per_user=True,
+        )
+        # The key carries no participant_id, so the session is genuinely shared.
+        assert "alice" not in key
+        assert shared is True
+        # Tie the helper to the actual key: shared iff participant absent.
+        assert shared == ("alice" not in key)
 
 
 class TestSlackWorkspaceSessionKeys: