feat: do not send moderator report to Zoom chat in hybrid events

hybrid events may involve projection of zoom mtg where sensitive reports could be viewed, use NS mod
view only

Author: jencompgeek

src/conversations/eventAssistant.ts

@@ -235,6 +235,7 @@ const eventAssistant: ConversationType = {
     { name: 'image-gen' }
   ],
   adapters: {
+    // Fully remote: Zoom only — moderator DMs sent via Zoom
     zoom: {
       type: 'zoom',
       config: {
@@ -265,6 +266,33 @@ const eventAssistant: ConversationType = {
         }
       ]
     },
+    // Hybrid: Zoom + NextSpace — moderator DMs handled by NextSpace, not Zoom
+    'nextspace,zoom': {
+      type: 'zoom',
+      config: {
+        meetingUrl: '{{{properties.zoomMeetingUrl}}}',
+        botName: '{{properties.botName}}'
+      },
+      dmChannels: [
+        {
+          direct: true,
+          agent: 'eventAssistant',
+          direction: Direction.BOTH
+        }
+      ],
+      chatChannels: [
+        {
+          name: 'chat',
+          direction: Direction.BOTH
+        }
+      ],
+      audioChannels: [
+        {
+          name: 'transcript',
+          direction: Direction.INCOMING
+        }
+      ]
+    },
     default: {
       // Zoom transcription only - assume DMs are coming through web or websocket APIs
       type: 'zoom',

src/conversations/resolver.ts

@@ -232,10 +232,14 @@ export default function resolveConversationType(
   for (const { name, config, enabled } of features) if (enabled) workingProperties[name] = config ?? true
 
   const adapterDefs = conversationType.adapters || {}
-  const matched = (platforms || []).map((p) => adapterDefs[p]).filter(Boolean)
+  const sortedKey = (platforms || []).slice().sort().join(',')
+  const exactMatch = adapterDefs[sortedKey]
+  const perPlatform = (platforms || []).map((p) => adapterDefs[p]).filter(Boolean)
   let adapters: unknown[] = []
-  if (matched.length > 0) {
-    adapters = matched.map((a) => resolvePropertyReferences(a, workingProperties))
+  if (exactMatch) {
+    adapters = [resolvePropertyReferences(exactMatch, workingProperties)]
+  } else if (perPlatform.length > 0) {
+    adapters = perPlatform.map((a) => resolvePropertyReferences(a, workingProperties))
   } else if (adapterDefs.default) {
     adapters = [resolvePropertyReferences(adapterDefs.default, workingProperties)]
   }

tests/conversations/resolver.test.ts

@@ -296,6 +296,51 @@ describe('resolveConversationType', () => {
       const result = resolveConversationType({ platforms: ['web'] }, type)
       expect(result.adapters).toHaveLength(0)
     })
+
+    test('matches composite platform key over individual keys', () => {
+      const type: ConversationType = {
+        ...baseType,
+        properties: [],
+        adapters: {
+          zoom: { type: 'zoom', config: { variant: 'zoom-only' } },
+          'nextspace,zoom': { type: 'zoom', config: { variant: 'hybrid' } },
+          default: { type: 'web' }
+        }
+      }
+      const result = resolveConversationType({ platforms: ['zoom', 'nextspace'] }, type)
+      expect(result.adapters).toHaveLength(1)
+      expect(result.adapters[0]).toMatchObject({ config: { variant: 'hybrid' } })
+    })
+
+    test('composite key matches regardless of platform order', () => {
+      const type: ConversationType = {
+        ...baseType,
+        properties: [],
+        adapters: {
+          'nextspace,zoom': { type: 'zoom', config: { variant: 'hybrid' } },
+          default: { type: 'web' }
+        }
+      }
+      const result = resolveConversationType({ platforms: ['nextspace', 'zoom'] }, type)
+      expect(result.adapters).toHaveLength(1)
+      expect(result.adapters[0]).toMatchObject({ config: { variant: 'hybrid' } })
+    })
+
+    test('falls back to per-platform adapters when no composite key matches', () => {
+      const type: ConversationType = {
+        ...baseType,
+        properties: [],
+        adapters: {
+          zoom: { type: 'zoom' },
+          'nextspace,zoom': { type: 'zoom', config: { variant: 'hybrid' } }
+        }
+      }
+      // Only zoom platform — matches single 'zoom' key, not composite
+      const result = resolveConversationType({ platforms: ['zoom'] }, type)
+      expect(result.adapters).toHaveLength(1)
+      expect(result.adapters[0]).toMatchObject({ type: 'zoom' })
+      expect((result.adapters[0] as { config?: { variant?: string } }).config?.variant).toBeUndefined()
+    })
   })
 
   describe('passthrough fields', () => {