@tellescope/sdk 2.0.0-beta.1 → 2.0.0-beta.3

package/src/tests/api_tests/load_team_chat.test.ts

@@ -25,12 +25,19 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     lname: 'TestPatient',
   })
 
+  // load_team_chat orders and keyset-pages on recentMessageSentAt, and a room that has never had a
+  // message (no recentMessageSentAt) is not returned at all — so every fixture room below sets one.
+  // Distinct, descending values make the ordering and pagination assertions deterministic.
+  const SENT_AT_BASE = Date.now()
+  const sent_at = (secondsAgo: number) => SENT_AT_BASE - secondsAgo * 1000
+
   // Create various team chat rooms for testing
   // Room 1: Non-admin is in userIds
   const roomWithUserInIds = await sdk.api.chat_rooms.createOne({
     type: 'internal',
     userIds: [sdkNonAdmin.userInfo.id],
     title: 'Room with user in userIds',
+    recentMessageSentAt: sent_at(1),
   })
 
   // Room 2: Non-admin is creator
@@ -38,6 +45,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'internal',
     userIds: [],
     title: 'Room where user is creator',
+    recentMessageSentAt: sent_at(2),
   })
 
   // Room 3: aboutEnduserId with care team access
@@ -46,6 +54,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [],
     aboutEnduserId: enduserForCareTeam.id,
     title: 'Room with care team access',
+    recentMessageSentAt: sent_at(3),
   })
 
   // Room 4: No access for non-admin (different creator, not in userIds, no care team)
@@ -53,6 +62,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'internal',
     userIds: [],
     title: 'Room with no access for non-admin',
+    recentMessageSentAt: sent_at(4),
   })
 
   // Room 4b: No access for admin (non-admin is creator, admin not in userIds, not on care team)
@@ -60,6 +70,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'internal',
     userIds: [],
     title: 'Room with no access for admin',
+    recentMessageSentAt: sent_at(5),
   })
 
   // Room 5: aboutEnduserId but non-admin NOT on care team
@@ -68,6 +79,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [],
     aboutEnduserId: enduserNotOnCareTeam.id,
     title: 'Room without care team access',
+    recentMessageSentAt: sent_at(6),
   })
 
   // Room 6: Closed room (has endedAt)
@@ -75,6 +87,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'internal',
     userIds: [sdkNonAdmin.userInfo.id],
     title: 'Closed room',
+    recentMessageSentAt: sent_at(7),
     endedAt: new Date(),
   })
 
@@ -83,6 +96,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     type: 'external',
     userIds: [sdkNonAdmin.userInfo.id],
     title: 'External room',
+    recentMessageSentAt: sent_at(8),
   })
 
   // Room 8: Room with enduserIds (should be excluded - not a team chat)
@@ -91,6 +105,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [sdkNonAdmin.userInfo.id],
     enduserIds: [enduserForCareTeam.id],
     title: 'Room with endusers',
+    recentMessageSentAt: sent_at(9),
   })
 
   // Room 9: Room with empty string aboutEnduserId (should not crash, user in userIds can see it)
@@ -99,6 +114,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [sdkNonAdmin.userInfo.id],
     aboutEnduserId: '' as any, // Empty string should be handled gracefully
     title: 'Room with empty aboutEnduserId',
+    recentMessageSentAt: sent_at(10),
   })
 
   // Wait for timestamps to settle
@@ -228,7 +244,8 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     const lastRoom = firstBatch.chat_rooms[firstBatch.chat_rooms.length - 1]
     await async_test(
       "Pagination with lastUpdatedAt returns older rooms",
-      () => sdk.api.chat_rooms.load_team_chat({ lastUpdatedAt: new Date(lastRoom.updatedAt!) }),
+      // the cursor parameter keeps its name and Date type, but now carries recentMessageSentAt
+      () => sdk.api.chat_rooms.load_team_chat({ lastUpdatedAt: new Date(lastRoom.recentMessageSentAt!) }),
       {
         onResult: r => {
           // Should not contain any rooms from first batch
@@ -239,22 +256,59 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     )
   }
 
-  // Test 14: Sorted by updatedAt descending
+  // Test 14: Sorted by recentMessageSentAt descending
   await async_test(
-    "Results sorted by updatedAt descending",
+    "Results sorted by recentMessageSentAt descending",
     () => sdk.api.chat_rooms.load_team_chat({}),
     {
       onResult: r => {
+        if (r.chat_rooms.length === 0) return false
+        for (const room of r.chat_rooms) {
+          if (room.recentMessageSentAt === undefined) return false // never-messaged rooms are excluded
+        }
         for (let i = 1; i < r.chat_rooms.length; i++) {
-          const prev = new Date(r.chat_rooms[i - 1].updatedAt!).getTime()
-          const curr = new Date(r.chat_rooms[i].updatedAt!).getTime()
-          if (prev < curr) return false
+          if (r.chat_rooms[i - 1].recentMessageSentAt! < r.chat_rooms[i].recentMessageSentAt!) return false
         }
         return true
       }
     }
   )
 
+  // Test 14b: a write that is not a message must not re-order a room. updatedAt is bumped by any
+  // write (it was the old sort key); recentMessageSentAt is not.
+  const FIXTURE_ROOM_IDS = [
+    roomWithUserInIds.id, roomWithCareTeamAccess.id, roomNoAccessForNonAdmin.id,
+    roomNoCareTeamAccess.id, roomWithEmptyAboutEnduserId.id,
+  ]
+  const fixture_order = (rooms: { id: string }[]) => (
+    rooms.map(room => room.id).filter(id => FIXTURE_ROOM_IDS.includes(id)).join(',')
+  )
+
+  const orderBeforeRename = fixture_order((await sdk.api.chat_rooms.load_team_chat({})).chat_rooms)
+  const renamedTitle = 'Room with empty aboutEnduserId (renamed)'
+  // the oldest fixture room by recentMessageSentAt: before this change, the rename put it first
+  await sdk.api.chat_rooms.updateOne(roomWithEmptyAboutEnduserId.id, { title: renamedTitle })
+  await wait(undefined, 500)
+
+  await async_test(
+    "A non-message update does not re-order a room",
+    () => sdk.api.chat_rooms.load_team_chat({}),
+    {
+      onResult: r => {
+        const renamed = r.chat_rooms.find(room => room.id === roomWithEmptyAboutEnduserId.id)
+        const orderAfterRename = fixture_order(r.chat_rooms)
+        return (
+          renamed?.title === renamedTitle // the write did land
+          && renamed?.recentMessageSentAt === sent_at(10) // and left the sort key alone
+          && orderAfterRename === orderBeforeRename
+          // still last of the fixture rooms, not first
+          && r.chat_rooms.map(room => room.id).indexOf(roomWithEmptyAboutEnduserId.id)
+             > r.chat_rooms.map(room => room.id).indexOf(roomWithUserInIds.id)
+        )
+      }
+    }
+  )
+
   // ============================================
   // Enduser Access Control Tests
   // ============================================
@@ -297,6 +351,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [enduserAccessTestUser.id],
     aboutEnduserId: enduserNotAssignedToTestUser.id,
     title: 'Room with unassigned enduser',
+    recentMessageSentAt: sent_at(11),
   })
 
   await wait(undefined, 500)
@@ -425,6 +480,7 @@ export const load_team_chat_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session,
     userIds: [accessTagTestUser.id],
     aboutEnduserId: enduserWithAccessTag.id,
     title: 'Room with access tag enduser',
+    recentMessageSentAt: sent_at(12),
   })
 
   await wait(undefined, 2000) // role change triggers logout

package/src/tests/api_tests/load_threads_autobuild.test.ts

@@ -1,29 +1,60 @@
-import { Session } from "../../sdk"
-import { assert, log_header, wait } from "@tellescope/testing"
-import { setup_tests } from "../setup"
-
-export const load_threads_autobuild_tests = async ({
-  sdk,
-  sdkNonAdmin
-}: {
-  sdk: Session,
-  sdkNonAdmin: Session
-}) => {
-  log_header("Load Threads with Autobuild Tests")
-
+require('source-map-support').install();
+
+import { wait } from "@tellescope/testing"
+import {
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Coverage for `inbox_threads.load_threads({ autobuild: true })`: bootstrap from no threads,
+ * idempotency, the enduserIds / phoneNumber filters, returnCount, backwards paging and draft
+ * inclusion.
+ *
+ * Provisions its own throwaway tenant rather than running on the shared fixture: the suite calls
+ * `reset_threads()` (scoped to `req.session.businessId`, so on the shared org it wiped and rebuilt
+ * every other inbox suite's threads) and then asserts EXACT thread counts, which only hold when
+ * nothing else is writing messages into the same organization.
+ *
+ * Two users are provisioned because check 7 drives the non-admin session: `tenant.sdkNonAdmin` is an
+ * unauthenticated `Session` unless `users[1]` is asked for.
+ *
+ * Ordering matters and is unchanged: autobuild bootstraps a two-week window and `build_threads`
+ * matches SMS by `_id` time range (see concurrent_build_threads.test.ts), so records are created
+ * before the `load_threads` call that must see them, both `reset_threads()` calls are kept, and the
+ * 2s wait before the draft check stays.
+ */
+export const load_threads_autobuild_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
   let testEnduser: any
   let testUser: any
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `Load threads autobuild ${RAND()}`,
+      // a non-admin session is required by check 7; reset_threads is adminOnly and uses users[0]
+      users: [{ isAdmin: true }, { roles: ['Non-Admin'] }],
+    })
+    const { sdk, sdkNonAdmin } = tenant
+
     // Setup test data
     testEnduser = await sdk.api.endusers.createOne({
-      email: `autobuild-test-${Date.now()}@test.com`,
+      email: `autobuild-test-${Date.now()}-${RAND()}@test.com`,
       fname: "Autobuild",
       lname: "Test"
     })
 
     testUser = await sdk.api.users.createOne({
-      email: `autobuild-user-${Date.now()}@test.com`,
+      email: `autobuild-user-${Date.now()}-${RAND()}@test.com`,
       fname: "Test",
       lname: "User"
     })
@@ -32,8 +63,7 @@ export const load_threads_autobuild_tests = async ({
     await sdk.api.inbox_threads.reset_threads()
 
     // Test 1: Autobuild with no existing threads (bootstrap case)
-    log_header("Test 1: Basic autobuild from scratch (bootstrap)")
-    const sms1 = await sdk.api.sms_messages.createOne({
+    await sdk.api.sms_messages.createOne({
       message: "Test message for autobuild",
       enduserId: testEnduser.id,
       userId: testUser.id,
@@ -47,26 +77,36 @@ export const load_threads_autobuild_tests = async ({
       autobuild: true
     })
 
-    assert(result1.threads.length === 1, "Should load 1 thread after autobuild")
-    assert(result1.threads[0].type === 'SMS', "Thread should be SMS type")
+    record(
+      '1: autobuild from scratch loads exactly 1 thread',
+      result1.threads.length === 1,
+      `loaded ${result1.threads.length} thread(s)`,
+    )
+    record(
+      '1b: the bootstrapped thread is of type SMS',
+      result1.threads[0]?.type === 'SMS',
+      `type=${JSON.stringify(result1.threads[0]?.type)}`,
+    )
 
     // Test 2: Idempotency - calling autobuild again doesn't duplicate
-    log_header("Test 2: Autobuild idempotency")
     const result2 = await sdk.api.inbox_threads.load_threads({
       autobuild: true
     })
 
-    assert(result2.threads.length === 1, "Should still have 1 thread (no duplicates)")
+    record(
+      '2: repeating autobuild still yields 1 thread (no duplicates)',
+      result2.threads.length === 1,
+      `loaded ${result2.threads.length} thread(s)`,
+    )
 
     // Test 3: Autobuild with filters
-    log_header("Test 3: Autobuild combined with enduserIds filter")
     const testEnduser2 = await sdk.api.endusers.createOne({
-      email: `autobuild-test2-${Date.now()}@test.com`,
+      email: `autobuild-test2-${Date.now()}-${RAND()}@test.com`,
       fname: "Autobuild2",
       lname: "Test2"
     })
 
-    const sms2 = await sdk.api.sms_messages.createOne({
+    await sdk.api.sms_messages.createOne({
       message: "Second test message",
       enduserId: testEnduser2.id,
       userId: testUser.id,
@@ -81,31 +121,52 @@ export const load_threads_autobuild_tests = async ({
       enduserIds: [testEnduser.id]
     })
 
-    assert(result3.threads.length === 1, "Should filter to only 1 enduser's thread")
-    assert(result3.threads[0].enduserIds.includes(testEnduser.id), "Should be first enduser's thread")
+    record(
+      '3: autobuild with an enduserIds filter returns only that enduser\'s 1 thread',
+      result3.threads.length === 1,
+      `loaded ${result3.threads.length} thread(s)`,
+    )
+    record(
+      '3b: the filtered thread belongs to the first enduser',
+      !!result3.threads[0]?.enduserIds?.includes(testEnduser.id),
+      `enduserIds=${JSON.stringify(result3.threads[0]?.enduserIds)}`,
+    )
 
     // Test 4: Autobuild with phoneNumber filter
-    log_header("Test 4: Autobuild with phoneNumber filter")
     const result4 = await sdk.api.inbox_threads.load_threads({
       autobuild: true,
       phoneNumber: "+15555555555"
     })
 
-    assert(result4.threads.length === 1, "Should filter by phone number")
-    assert(result4.threads[0].phoneNumber === '+15555555555', "Should match phone number")
+    record(
+      '4: autobuild with a phoneNumber filter returns 1 thread',
+      result4.threads.length === 1,
+      `loaded ${result4.threads.length} thread(s)`,
+    )
+    record(
+      '4b: the filtered thread matches the phone number',
+      result4.threads[0]?.phoneNumber === '+15555555555',
+      `phoneNumber=${JSON.stringify(result4.threads[0]?.phoneNumber)}`,
+    )
 
     // Test 5: Autobuild with returnCount
-    log_header("Test 5: Autobuild with returnCount")
     const result5 = await sdk.api.inbox_threads.load_threads({
       autobuild: true,
       returnCount: true
     })
 
-    assert(result5.count === 2, "Should return count of 2 threads")
-    assert(!result5.threads || result5.threads.length === 0, "Should not return threads when returnCount=true")
+    record(
+      '5: autobuild with returnCount returns a count of 2',
+      result5.count === 2,
+      `count=${JSON.stringify(result5.count)}`,
+    )
+    record(
+      '5b: autobuild with returnCount returns no threads',
+      !result5.threads || result5.threads.length === 0,
+      `threads=${result5.threads ? result5.threads.length : '(none)'}`,
+    )
 
     // Test 6: Autobuild with pagination (backwards paging)
-    log_header("Test 6: Autobuild with pagination (paging backwards)")
 
     // Get the oldest thread's timestamp
     const allThreads = await sdk.api.inbox_threads.load_threads({
@@ -113,35 +174,53 @@ export const load_threads_autobuild_tests = async ({
     })
     const oldestThread = allThreads.threads[allThreads.threads.length - 1]
 
-    // Load threads with lastTimestamp to simulate paging backwards
-    const result6 = await sdk.api.inbox_threads.load_threads({
-      autobuild: true,
-      lastTimestamp: oldestThread.timestamp
-    })
-
-    // Should still return threads (may include older ones if any exist)
-    assert(Array.isArray(result6.threads), "Should return threads when paging backwards")
+    // Guarded rather than dereferenced: with no thread to page from, a TypeError here would escape
+    // `run` and, per run_isolated_in_parallel, fail the whole run instead of this one check.
+    if (!oldestThread) {
+      record(
+        '6: autobuild paging backwards with lastTimestamp returns a threads array',
+        false,
+        'no thread to page back from — load_threads({ autobuild: false }) returned none',
+      )
+    } else {
+      // Load threads with lastTimestamp to simulate paging backwards
+      const result6 = await sdk.api.inbox_threads.load_threads({
+        autobuild: true,
+        lastTimestamp: oldestThread.timestamp
+      })
+
+      // Should still return threads (may include older ones if any exist)
+      record(
+        '6: autobuild paging backwards with lastTimestamp returns a threads array',
+        Array.isArray(result6.threads),
+        `threads=${JSON.stringify(result6.threads?.length)}`,
+      )
+    }
 
     // Test 6b: Autobuild without lastTimestamp (loading current/newer data)
-    log_header("Test 6b: Autobuild loads newer data when no lastTimestamp")
     const result6b = await sdk.api.inbox_threads.load_threads({
       autobuild: true
     })
 
-    assert(result6b.threads.length >= 2, "Should load current threads")
+    record(
+      '6b: autobuild without lastTimestamp loads the current threads (>= 2)',
+      result6b.threads.length >= 2,
+      `loaded ${result6b.threads.length} thread(s)`,
+    )
 
     // Test 7: Non-admin user can use autobuild but sees filtered threads
-    log_header("Test 7: Non-admin autobuild with access control")
     const result7 = await sdkNonAdmin.api.inbox_threads.load_threads({
       autobuild: true
     })
 
     // Non-admin should only see threads they have access to
-    // (Exact assertion depends on role setup in setup_tests)
-    assert(Array.isArray(result7.threads), "Non-admin should get threads array")
+    record(
+      '7: a non-admin session can autobuild and receives a threads array',
+      Array.isArray(result7.threads),
+      `threads=${JSON.stringify(result7.threads?.length)}`,
+    )
 
     // Test 8: Autobuild with draft and scheduled messages
-    log_header("Test 8: Autobuild includes draft messages")
     const draftSms = await sdk.api.sms_messages.createOne({
       message: "Draft message",
       enduserId: testEnduser.id,
@@ -164,34 +243,51 @@ export const load_threads_autobuild_tests = async ({
     const threadWithDraft = result8.threads.find(t =>
       t.phoneNumber === '+15555555555' && t.enduserPhoneNumber === '+15555555556'
     )
-    assert(!!threadWithDraft, "Should find thread with draft")
-    assert(!!threadWithDraft?.draftMessageIds?.includes(draftSms.id), "Should include draft message ID")
-
-    console.log("✅ All autobuild tests passed!")
+    record(
+      '8: autobuild finds the thread holding the draft message',
+      !!threadWithDraft,
+      threadWithDraft
+        ? `threadId=${threadWithDraft.id}`
+        : `no thread for +15555555555/+15555555556 among ${result8.threads.length}`,
+    )
+    record(
+      '8b: the thread includes the draft message id',
+      !!threadWithDraft?.draftMessageIds?.includes(draftSms.id),
+      `draftMessageIds=${JSON.stringify(threadWithDraft?.draftMessageIds)}, draftSms=${draftSms.id}`,
+    )
 
     // Cleanup
-    await sdk.api.endusers.deleteOne(testEnduser2.id)
-
+    await sdk.api.endusers.deleteOne(testEnduser2.id).catch(console.error)
   } finally {
-    // Cleanup
-    if (testEnduser) await sdk.api.endusers.deleteOne(testEnduser.id).catch(console.error)
-    if (testUser) await sdk.api.users.deleteOne(testUser.id).catch(console.error)
-    await sdk.api.inbox_threads.reset_threads().catch(console.error)
+    if (tenant) {
+      const { sdk } = tenant
+      // Cleanup
+      if (testEnduser) await sdk.api.endusers.deleteOne(testEnduser.id).catch(console.error)
+      if (testUser) await sdk.api.users.deleteOne(testUser.id).catch(console.error)
+      await sdk.api.inbox_threads.reset_threads().catch(console.error)
+      // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+      try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) }
+    }
   }
+
+  return checks
 }
 
-// Allow running this test independently
-if (require.main === module) {
-  const host = process.env.API_URL || 'http://localhost:8080'
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+/** Asserting wrapper, for standalone runs. */
+export const load_threads_autobuild_tests = async () => {
+  assert_checks('Load threads autobuild', await load_threads_autobuild_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await load_threads_autobuild_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Load threads autobuild',
+  run: load_threads_autobuild_checks,
+}
 
-  runTests()
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  load_threads_autobuild_tests()
     .then(() => {
       console.log("✅ Load threads autobuild test suite completed successfully")
       process.exit(0)

package/src/tests/api_tests/load_threads_care_team.test.ts

@@ -4,6 +4,7 @@ import {
   assert_checks,
   Check,
   setup_isolated_tenant,
+  IsolatedSuite,
 } from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
@@ -36,6 +37,12 @@ const RAND = () => Math.random().toString(36).slice(2, 10)
  * `userIds: []`, so that session sees a thread only through the assigned-enduser branch. 7c fails
  * if the care-team clause is ever pushed into the access `$or` instead of `filter.$and`, i.e. if
  * the parameter could be used to WIDEN what a session can see.
+ *
+ * Checks 8 onward cover the same resolution exposed as the `careTeamUserIds` pseudo-field inside
+ * `mdbFilter`, which the server expands in place so it composes with other clauses under
+ * `$and`/`$or`. 11 is the one that separates "dropped" from "broken" for an empty care team under
+ * `$or`, 15 and 16 pin the explicit operator list and the per-request cap, and 18 is 7c's twin for
+ * the pseudo-field.
  */
 export const load_threads_care_team_checks = async (): Promise<Check[]> => {
   const checks: Check[] = []
@@ -182,6 +189,103 @@ export const load_threads_care_team_checks = async (): Promise<Check[]> => {
       `got ${describe(naForeignCareTeam)} (want [] — T2 matches U2\'s care team but is outside this`
       + ` session's access; a non-empty result means the clause was pushed into the access $or)`,
     )
+
+    /* ===== 8+: careTeamUserIds as a pseudo-field inside mdbFilter ===== */
+
+    const viaFilter = await load({ mdbFilter: { careTeamUserIds: { $in: [U1.id] } } })
+    record(
+      '8: mdbFilter { careTeamUserIds: { $in: [U1] } } returns exactly [T1], same as the parameter',
+      same_set(viaFilter, [T1.id]),
+      `got ${describe(viaFilter)} (want [T1])`,
+    )
+
+    const orUnion = await load({ mdbFilter: { $or: [{ careTeamUserIds: U1.id }, { enduserIds: { $in: [E2.id] } }] } })
+    record(
+      '9: { $or: [{ careTeamUserIds: U1 }, { enduserIds: [E2] }] } returns the union [T1, T2]',
+      same_set(orUnion, [T1.id, T2.id]),
+      `got ${describe(orUnion)} (want [T1, T2] — the bare-string clause composes under $or)`,
+    )
+
+    const nested = await load({
+      mdbFilter: { $and: [{ $or: [{ careTeamUserIds: { $eq: U2.id } }, { enduserIds: { $in: [E3.id] } }] }, { type: 'SMS' }] },
+    })
+    record(
+      '10: a clause nested under $and > $or returns [T2, T3]',
+      same_set(nested, [T2.id, T3.id]),
+      `got ${describe(nested)} (want [T2, T3])`,
+    )
+
+    const emptyInOr = await load({ mdbFilter: { $or: [{ careTeamUserIds: { $in: [U3.id] } }, { enduserIds: { $in: [E3.id] } }] } })
+    record(
+      '11: an empty care team inside $or contributes nothing without collapsing the $or',
+      same_set(emptyInOr, [T3.id]),
+      `got ${describe(emptyInOr)} (want [T3] — everything means the clause was dropped, [] means the $or broke)`,
+    )
+
+    const twoConditions = await load({ mdbFilter: { $or: [{ careTeamUserIds: { $in: [U1.id] } }, { careTeamUserIds: { $in: [U2.id] } }] } })
+    record(
+      '12: two distinct conditions in one request each resolve, returning [T1, T2]',
+      same_set(twoConditions, [T1.id, T2.id]),
+      `got ${describe(twoConditions)} (want [T1, T2])`,
+    )
+
+    const allBoth = await load({ mdbFilter: { careTeamUserIds: { $all: [U1.id, NA] } } })
+    const allSplit = await load({ mdbFilter: { careTeamUserIds: { $all: [U1.id, U2.id] } } })
+    record(
+      '13: $all matches only an enduser whose care team holds every listed user',
+      same_set(allBoth, [T1.id]) && allSplit.length === 0,
+      `[U1, NA]=${describe(allBoth)} (want [T1]) [U1, U2]=${describe(allSplit)} (want [] — no single enduser has both)`,
+    )
+
+    const emptyIn = await load({ mdbFilter: { careTeamUserIds: { $in: [] } } })
+    record(
+      '14: { careTeamUserIds: { $in: [] } } returns nothing, like Mongo\'s $in: []',
+      emptyIn.length === 0,
+      `got ${describe(emptyIn)} (want [])`,
+    )
+
+    const error_for = async (mdbFilter: any): Promise<string> => {
+      try {
+        const threads = await load({ mdbFilter })
+        return `no error (returned ${describe(threads)})`
+      } catch (e: any) {
+        return String(e?.message ?? e)
+      }
+    }
+    const ninError = await error_for({ careTeamUserIds: { $nin: [U1.id] } })
+    const regexError = await error_for({ $or: [{ careTeamUserIds: { $regex: 'x' } }] })
+    const nonIdError = await error_for({ careTeamUserIds: { $in: ['not-an-id'] } })
+    record(
+      '15: $nin, $regex and a non-id value are each rejected with an error naming the problem',
+      ninError.includes('$nin') && regexError.includes('$regex') && nonIdError.includes('Mongo id'),
+      `nin="${ninError}" regex="${regexError}" nonId="${nonIdError}"`,
+    )
+
+    const capError = await error_for({ $or: [U1, U2, U3].flatMap(u => [
+      { careTeamUserIds: { $in: [u.id] } }, { careTeamUserIds: { $all: [u.id] } },
+    ]) })
+    record(
+      '16: six distinct conditions in one request are rejected by the per-request cap',
+      capError.includes('at most 5'),
+      `got "${capError}" (want an error mentioning the cap of 5)`,
+    )
+
+    const { count: orCount } = await sdk.api.inbox_threads.load_threads({
+      mdbFilter: { $or: [{ careTeamUserIds: U1.id }, { enduserIds: { $in: [E2.id] } }] },
+      returnCount: true,
+    })
+    record(
+      '17: returnCount applies the substituted mdbFilter too',
+      orCount === 2,
+      `count=${orCount} (want 2 — 3 means the count path skipped the pseudo-field)`,
+    )
+
+    const naWiden = await load({ mdbFilter: { $or: [{ careTeamUserIds: { $in: [U2.id] } }, { enduserIds: { $in: [E1.id] } }] } }, sdkNonAdmin)
+    record(
+      '18: the pseudo-field cannot widen a non-admin\'s access, even under $or',
+      same_set(naWiden, [T1.id]),
+      `got ${describe(naWiden)} (want [T1] — T2 matches U2\'s care team but is outside this session\'s access)`,
+    )
   } finally {
     // Teardown BEFORE anything asserts — assert calls process.exit, which would strand the tenant.
     if (tenant) { try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) } }
@@ -195,6 +299,9 @@ export const load_threads_care_team_tests = async () => {
   assert_checks('Load threads care team', await load_threads_care_team_checks())
 }
 
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Load threads care team', run: load_threads_care_team_checks }
+
 // Allow running this test file independently
 if (require.main === module) {
   console.log(`🌐 Using API URL: ${host}`)