@swarmclawai/swarmclaw 0.9.3 → 0.9.4

package/src/lib/server/connectors/manager.test.ts

@@ -592,9 +592,9 @@ describe('sanitizeConnectorOutboundContent', () => {
       storage.saveSessions({
         session_1: {
           id: 'session_1',
-          name: 'Molly',
+          name: 'connector:whatsapp:gran',
           cwd: process.env.WORKSPACE_DIR,
-          user: 'default',
+          user: 'connector',
           provider: 'anthropic',
           model: 'claude-test',
           claudeSessionId: null,
@@ -720,7 +720,357 @@ describe('sanitizeConnectorOutboundContent', () => {
     assert.equal(output.health.some((entry: { event?: string }) => entry.event === 'disconnected'), true)
   })
 
-  it('blocks ambiguous connector sends when a thread references multiple people on the same connector', () => {
+  it('does not persist connector routing state onto a non-direct session during outbound sends', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage')
+      const managerMod = await import('./src/lib/server/connectors/manager')
+      const pluginsMod = await import('./src/lib/server/plugins')
+      const storage = storageMod.default || storageMod
+      const manager = managerMod.default || managerMod
+      const plugins = pluginsMod.default || pluginsMod
+
+      const sent = []
+      const now = Date.now()
+      plugins.getPluginManager().registerBuiltin('test-send-plugin', {
+        name: 'Test Send Plugin',
+        connectors: [{
+          id: 'test-send',
+          name: 'Test Send',
+          description: 'Outbound send capture',
+          startListener: async () => async () => {},
+          sendMessage: async (channelId, text, options) => {
+            sent.push({ channelId, text, options })
+            return { messageId: 'out-1' }
+          },
+        }],
+      })
+
+      storage.saveSettings({})
+      storage.saveConnectors({
+        conn_1: {
+          id: 'conn_1',
+          name: 'Test Send Connector',
+          platform: 'test-send',
+          agentId: 'agent_1',
+          credentialId: null,
+          config: { botToken: 'test-token' },
+          isEnabled: true,
+          status: 'stopped',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveSessions({
+        main_thread: {
+          id: 'main_thread',
+          name: 'Molly',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'default',
+          provider: 'anthropic',
+          model: 'claude-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'agent_1',
+          plugins: [],
+        },
+      })
+
+      try {
+        await manager.startConnector('conn_1')
+        const result = await manager.sendConnectorMessage({
+          connectorId: 'conn_1',
+          channelId: '15550001111@s.whatsapp.net',
+          text: 'hello',
+          sessionId: 'main_thread',
+        })
+        const session = storage.loadSessions().main_thread
+        console.log(JSON.stringify({ result, session, sent }))
+      } finally {
+        await manager.stopConnector('conn_1')
+      }
+    `)
+
+    assert.equal(output.result.messageId, 'out-1')
+    assert.equal(output.sent.length, 1)
+    assert.equal(output.session.connectorContext || null, null)
+  })
+
+  it('does not auto-send a second connector reply from a non-direct main-thread heartbeat after a direct connector reply', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage')
+      const managerMod = await import('./src/lib/server/connectors/manager')
+      const chatExecMod = await import('./src/lib/server/chat-execution/chat-execution')
+      const providersMod = await import('./src/lib/providers/index')
+      const pluginsMod = await import('./src/lib/server/plugins')
+      const storage = storageMod.default || storageMod
+      const manager = managerMod.default || managerMod
+      const chatExec = chatExecMod.default || chatExecMod
+      const providers = providersMod.default || providersMod
+      const plugins = pluginsMod.default || pluginsMod
+
+      const sent = []
+      const now = Date.now()
+      plugins.getPluginManager().registerBuiltin('test-dup-heartbeat-plugin', {
+        name: 'Test Dup Heartbeat Plugin',
+        connectors: [{
+          id: 'test-dup-heartbeat',
+          name: 'Test Dup Heartbeat',
+          description: 'Captures outbound sends for duplication regressions',
+          startListener: async () => async () => {},
+          sendMessage: async (channelId, text, options) => {
+            sent.push({ channelId, text, options })
+            return { messageId: 'out-' + sent.length }
+          },
+        }],
+      })
+
+      providers.PROVIDERS['test-provider'] = {
+        id: 'test-provider',
+        name: 'Test Provider',
+        models: ['test-model'],
+        requiresApiKey: false,
+        requiresEndpoint: false,
+        handler: {
+          streamChat: async (opts) => {
+            const message = String(opts.message || '')
+            const text = message.includes('AGENT_HEARTBEAT')
+              ? 'Sent the ferry status to your WhatsApp.'
+              : 'Direct connector reply'
+            opts.write('data: ' + JSON.stringify({ t: 'r', text }) + '\\n')
+            return ''
+          },
+        },
+      }
+
+      storage.saveSettings({})
+      storage.saveAgents({
+        agent_1: {
+          id: 'agent_1',
+          name: 'Hal2k',
+          provider: 'test-provider',
+          model: 'test-model',
+          plugins: [],
+          heartbeatEnabled: true,
+          heartbeatIntervalSec: 60,
+          threadSessionId: 'agent_thread',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveConnectors({
+        conn_1: {
+          id: 'conn_1',
+          name: 'WhatsApp',
+          platform: 'test-dup-heartbeat',
+          agentId: 'agent_1',
+          credentialId: null,
+          config: { inboundDebounceMs: 0, botToken: 'test-token' },
+          isEnabled: true,
+          status: 'stopped',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveSessions({
+        agent_thread: {
+          id: 'agent_thread',
+          name: 'Hal2k',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'default',
+          provider: 'test-provider',
+          model: 'test-model',
+          claudeSessionId: null,
+          codexThreadId: null,
+          opencodeSessionId: null,
+          delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'agent_1',
+          shortcutForAgentId: 'agent_1',
+          plugins: [],
+          connectorContext: {
+            connectorId: 'conn_1',
+            channelId: 'poisoned-main-thread',
+            senderId: 'wrong-user',
+          },
+        },
+      })
+
+      try {
+        await manager.startConnector('conn_1')
+        const connector = storage.loadConnectors().conn_1
+        const directResponse = await manager.routeConnectorMessageForTest(connector, {
+          platform: 'whatsapp',
+          channelId: '15550001111@s.whatsapp.net',
+          senderId: '15550001111@s.whatsapp.net',
+          senderName: 'Alice',
+          text: 'Did you get this?',
+          messageId: 'in-1',
+          isGroup: false,
+        })
+
+        await chatExec.executeSessionChatTurn({
+          sessionId: 'agent_thread',
+          message: 'AGENT_HEARTBEAT_TICK\\nConnector follow-up sweep',
+          internal: true,
+          source: 'heartbeat',
+          runId: 'run-main-heartbeat',
+          heartbeatConfig: {
+            ackMaxChars: 300,
+            showOk: false,
+            showAlerts: true,
+            target: null,
+          },
+        })
+
+        const sessions = storage.loadSessions()
+        const directSession = Object.values(sessions).find((entry) =>
+          entry.id !== 'agent_thread' && String(entry.name || '').startsWith('connector:')
+        )
+        console.log(JSON.stringify({
+          directResponse,
+          sent,
+          mainThread: sessions.agent_thread,
+          directSessionId: directSession?.id || null,
+        }))
+      } finally {
+        await manager.stopConnector('conn_1')
+      }
+    `)
+
+    assert.equal(output.directResponse, 'Direct connector reply')
+    assert.equal(output.sent.length, 0)
+    assert.ok(output.directSessionId)
+    assert.equal(output.mainThread.connectorContext || null, null)
+  })
+
+  it('suppresses replies when a matched sender boundary memory says not to answer unless directly addressed', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage')
+      const managerMod = await import('./src/lib/server/connectors/manager')
+      const providersMod = await import('./src/lib/providers/index')
+      const pluginsMod = await import('./src/lib/server/plugins')
+      const memoryDbMod = await import('./src/lib/server/memory/memory-db')
+      const storage = storageMod.default || storageMod
+      const manager = managerMod.default || managerMod
+      const providers = providersMod.default || providersMod
+      const plugins = pluginsMod.default || pluginsMod
+      const memoryDbApi = memoryDbMod.default || memoryDbMod
+      const memoryDb = memoryDbApi.getMemoryDb()
+
+      let providerCalls = 0
+      const now = Date.now()
+      providers.PROVIDERS['test-provider'] = {
+        id: 'test-provider',
+        name: 'Test Provider',
+        models: ['test-model'],
+        requiresApiKey: false,
+        requiresEndpoint: false,
+        handler: {
+          streamChat: async () => {
+            providerCalls += 1
+            return 'should not be sent'
+          },
+        },
+      }
+
+      plugins.getPluginManager().registerBuiltin('test-quiet-boundary-connector-plugin', {
+        name: 'Test Quiet Boundary Connector Plugin',
+        connectors: [{
+          id: 'test-quiet',
+          name: 'Test Quiet',
+          description: 'Quiet boundary test connector',
+          startListener: async () => async () => {},
+          sendMessage: async () => ({ messageId: 'unused' }),
+        }],
+      })
+
+      storage.saveSettings({})
+      storage.saveAgents({
+        agent_1: {
+          id: 'agent_1',
+          name: 'Hal',
+          provider: 'test-provider',
+          model: 'test-model',
+          plugins: [],
+          threadSessionId: 'agent_thread',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveConnectors({
+        conn_1: {
+          id: 'conn_1',
+          name: 'WhatsApp',
+          platform: 'test-quiet',
+          agentId: 'agent_1',
+          credentialId: null,
+          config: { inboundDebounceMs: 0 },
+          isEnabled: true,
+          status: 'stopped',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveSessions({
+        agent_thread: {
+          id: 'agent_thread',
+          name: 'Hal',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'default',
+          provider: 'test-provider',
+          model: 'test-model',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'agent_1',
+          plugins: [],
+        },
+      })
+
+      memoryDb.add({
+        agentId: 'agent_1',
+        sessionId: null,
+        category: 'identity/preferences',
+        title: 'Wife communication rule',
+        content: 'Wayde\\'s wife (+44 7958 047282): Do NOT respond unless she addresses Hal directly or mentions Hal directly. If unsure, verify whether the message is for Wayde or Hal before responding.',
+      })
+
+      const connector = storage.loadConnectors().conn_1
+      const response = await manager.routeConnectorMessageForTest(connector, {
+        platform: 'whatsapp',
+        channelId: '447958047282@s.whatsapp.net',
+        senderId: '447958047282@s.whatsapp.net',
+        senderName: 'Wayde Wife',
+        text: 'Dinner is ready for Wayde.',
+        messageId: 'in-quiet-1',
+        isGroup: false,
+      })
+
+      const sessions = storage.loadSessions()
+      const directSession = Object.values(sessions).find((entry) => entry.id !== 'agent_thread')
+      console.log(JSON.stringify({
+        response,
+        providerCalls,
+        directSessionMessageCount: directSession?.messages?.length || 0,
+        mainThreadMessageCount: sessions.agent_thread?.messages?.length || 0,
+      }))
+    `)
+
+    assert.equal(output.response, 'NO_MESSAGE')
+    assert.equal(output.providerCalls, 0)
+    assert.equal(output.directSessionMessageCount, 0)
+    assert.equal(output.mainThreadMessageCount, 0)
+  })
+
+  it('requires an explicit target when a shared thread only has mirrored connector history', () => {
     const output = runWithTempDataDir(`
       const fs = await import('node:fs')
       const path = await import('node:path')
@@ -841,9 +1191,7 @@ describe('sanitizeConnectorOutboundContent', () => {
       }
     `)
 
-    assert.match(output.raw, /multiple connector recipients/)
-    assert.match(output.raw, /Alice/)
-    assert.match(output.raw, /Gran/)
+    assert.match(output.raw, /no target recipient configured/)
   })
 
   it('keeps direct connector sessions isolated across four inbound senders for the same agent and mirrors their metadata into the main thread', () => {
@@ -978,13 +1326,15 @@ describe('sanitizeConnectorOutboundContent', () => {
   it('excludes mirrored connector transcript entries from direct agent-thread history', () => {
     const output = runWithTempDataDir(`
       const storageMod = await import('./src/lib/server/storage')
-      const managerMod = await import('./src/lib/server/connectors/manager')
       const chatExecMod = await import('@/lib/server/chat-execution/chat-execution')
+      const streamChatMod = await import('@/lib/server/chat-execution/stream-agent-chat')
       const providersMod = await import('./src/lib/providers/index')
       const storage = storageMod.default || storageMod
-      const manager = managerMod.default || managerMod
       const chatExec = chatExecMod.default || chatExecMod
+      const streamChat = streamChatMod.default || streamChatMod
       const providers = providersMod.default || providersMod
+      const managerMod = await import('./src/lib/server/connectors/manager')
+      const manager = managerMod.default || managerMod
 
       const now = Date.now()
       providers.PROVIDERS['test-provider'] = {
@@ -994,24 +1344,126 @@ describe('sanitizeConnectorOutboundContent', () => {
         requiresApiKey: false,
         requiresEndpoint: false,
         handler: {
-          streamChat: async (opts) => {
-            const history = typeof opts.loadHistory === 'function' ? opts.loadHistory(opts.session.id) : []
-            return JSON.stringify({
-              historyCount: history.length,
-              texts: history.map((entry) => entry.text),
-              senderNames: history.map((entry) => entry.source?.senderName || null),
-            })
-          },
+          streamChat: async () => '',
         },
       }
+      streamChat.setStreamAgentChatForTest(async (opts) => ({
+        fullText: JSON.stringify({
+          historyCount: opts.history.length,
+          texts: opts.history.map((entry) => entry.text),
+          senderNames: opts.history.map((entry) => entry.source?.senderName || null),
+        }),
+        finalResponse: JSON.stringify({
+          historyCount: opts.history.length,
+          texts: opts.history.map((entry) => entry.text),
+          senderNames: opts.history.map((entry) => entry.source?.senderName || null),
+        }),
+      }))
 
-      storage.saveSettings({})
+      try {
+        storage.saveSettings({})
+        storage.saveAgents({
+          agent_1: {
+            id: 'agent_1',
+            name: 'Molly',
+            provider: 'test-provider',
+            model: 'test-model',
+            plugins: [],
+            threadSessionId: 'agent_thread',
+            createdAt: now,
+            updatedAt: now,
+          },
+        })
+        storage.saveConnectors({
+          conn_1: {
+            id: 'conn_1',
+            name: 'WhatsApp',
+            platform: 'whatsapp',
+            agentId: 'agent_1',
+            credentialId: null,
+            config: { inboundDebounceMs: 0 },
+            isEnabled: true,
+            status: 'running',
+            createdAt: now,
+            updatedAt: now,
+          },
+        })
+        storage.saveSessions({
+          agent_thread: {
+            id: 'agent_thread',
+            name: 'Molly',
+            cwd: process.env.WORKSPACE_DIR,
+            user: 'default',
+            provider: 'test-provider',
+            model: 'test-model',
+            claudeSessionId: null,
+            messages: [],
+            createdAt: now,
+            lastActiveAt: now,
+            sessionType: 'human',
+            agentId: 'agent_1',
+            plugins: [],
+          },
+        })
+
+        const connector = storage.loadConnectors().conn_1
+        await manager.routeConnectorMessageForTest(connector, {
+          platform: 'whatsapp',
+          channelId: '15550001111@s.whatsapp.net',
+          senderId: '15550001111@s.whatsapp.net',
+          senderName: 'Alice',
+          text: 'Hello from Alice',
+          messageId: 'in-a',
+          isGroup: false,
+        })
+        await manager.routeConnectorMessageForTest(connector, {
+          platform: 'whatsapp',
+          channelId: '278200000001@s.whatsapp.net',
+          senderId: '278200000001@s.whatsapp.net',
+          senderName: 'Gran',
+          text: 'Hello from Gran',
+          messageId: 'in-g',
+          isGroup: false,
+        })
+
+        const result = await chatExec.executeSessionChatTurn({
+          sessionId: 'agent_thread',
+          message: 'This is Wayde in the app.',
+        })
+
+        const thread = storage.loadSessions().agent_thread
+        const replyText = String(result.text || '').replace(/\\n+\\*-- Sent via Sample UI Plugin --\\*\\s*$/, '')
+        console.log(JSON.stringify({
+          reply: JSON.parse(replyText),
+          threadMessages: thread.messages,
+        }))
+      } finally {
+        streamChat.setStreamAgentChatForTest(null)
+      }
+    `)
+
+    assert.equal(output.reply.senderNames.includes('Alice'), false)
+    assert.equal(output.reply.senderNames.includes('Gran'), false)
+    assert.equal(output.reply.texts.some((entry: any) => /Alice|Gran/.test(String(entry))), false)
+    assert.equal(output.reply.historyCount >= 1, true)
+    assert.equal(output.threadMessages.some((msg: any) => msg.historyExcluded === true && msg.source?.connectorId === 'conn_1'), true)
+  })
+
+  it('treats allowlist entries as the source of truth and does not create approval records for unknown senders', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage')
+      const managerMod = await import('./src/lib/server/connectors/manager')
+      const storage = storageMod.default || storageMod
+      const manager = managerMod.default || managerMod
+
+      const now = Date.now()
+      storage.saveSettings({ approvalsEnabled: true })
       storage.saveAgents({
         agent_1: {
           id: 'agent_1',
           name: 'Molly',
-          provider: 'test-provider',
-          model: 'test-model',
+          provider: 'openai',
+          model: 'gpt-4.1-mini',
           plugins: [],
           threadSessionId: 'agent_thread',
           createdAt: now,
@@ -1025,7 +1477,11 @@ describe('sanitizeConnectorOutboundContent', () => {
           platform: 'whatsapp',
           agentId: 'agent_1',
           credentialId: null,
-          config: { inboundDebounceMs: 0 },
+          config: {
+            inboundDebounceMs: 0,
+            dmPolicy: 'allowlist',
+            allowFrom: '15550001111',
+          },
           isEnabled: true,
           status: 'running',
           createdAt: now,
@@ -1038,8 +1494,8 @@ describe('sanitizeConnectorOutboundContent', () => {
           name: 'Molly',
           cwd: process.env.WORKSPACE_DIR,
           user: 'default',
-          provider: 'test-provider',
-          model: 'test-model',
+          provider: 'openai',
+          model: 'gpt-4.1-mini',
           claudeSessionId: null,
           messages: [],
           createdAt: now,
@@ -1051,54 +1507,32 @@ describe('sanitizeConnectorOutboundContent', () => {
       })
 
       const connector = storage.loadConnectors().conn_1
-      await manager.routeConnectorMessageForTest(connector, {
-        platform: 'whatsapp',
-        channelId: '15550001111@s.whatsapp.net',
-        senderId: '15550001111@s.whatsapp.net',
-        senderName: 'Alice',
-        text: 'Hello from Alice',
-        messageId: 'in-a',
-        isGroup: false,
-      })
-      await manager.routeConnectorMessageForTest(connector, {
+      const reply = await manager.routeConnectorMessageForTest(connector, {
         platform: 'whatsapp',
-        channelId: '278200000001@s.whatsapp.net',
-        senderId: '278200000001@s.whatsapp.net',
-        senderName: 'Gran',
-        text: 'Hello from Gran',
-        messageId: 'in-g',
+        channelId: '16660002222@s.whatsapp.net',
+        senderId: '16660002222@s.whatsapp.net',
+        senderName: 'Bob',
+        text: 'Hello from Bob',
+        messageId: 'in-b-allowlist',
         isGroup: false,
       })
-
-      const result = await chatExec.executeSessionChatTurn({
-        sessionId: 'agent_thread',
-        message: 'This is Wayde in the app.',
-      })
-
-      const thread = storage.loadSessions().agent_thread
-      console.log(JSON.stringify({
-        reply: JSON.parse(result.text),
-        threadMessages: thread.messages,
-      }))
+      const approvals = Object.values(storage.loadApprovals())
+      console.log(JSON.stringify({ reply, approvals }))
     `)
 
-    assert.equal(output.reply.senderNames.includes('Alice'), false)
-    assert.equal(output.reply.senderNames.includes('Gran'), false)
-    assert.equal(output.reply.texts.some((entry: any) => /Alice|Gran/.test(String(entry))), false)
-    assert.equal(output.reply.historyCount >= 1, true)
-    assert.equal(output.threadMessages.some((msg: any) => msg.historyExcluded === true && msg.source?.connectorId === 'conn_1'), true)
+    assert.match(output.reply, /not approved for this connector/i)
+    assert.match(output.reply, /no automatic approval queue is created/i)
+    assert.equal(output.approvals.length, 0)
   })
 
-  it('creates one reusable connector-sender approval for unknown allowlist senders and allows them after approval', () => {
+  it('creates one reusable pairing request for unknown senders and allows them after approval', () => {
     const output = runWithTempDataDir(`
       const storageMod = await import('./src/lib/server/storage')
       const managerMod = await import('./src/lib/server/connectors/manager')
-      const approvalsMod = await import('./src/lib/server/approvals')
       const pairingMod = await import('./src/lib/server/connectors/pairing')
       const providersMod = await import('./src/lib/providers/index')
       const storage = storageMod.default || storageMod
       const manager = managerMod.default || managerMod
-      const approvals = approvalsMod.default || approvalsMod
       const pairing = pairingMod.default || pairingMod
       const providers = providersMod.default || providersMod
 
@@ -1141,8 +1575,7 @@ describe('sanitizeConnectorOutboundContent', () => {
           credentialId: null,
           config: {
             inboundDebounceMs: 0,
-            dmPolicy: 'allowlist',
-            allowFrom: '15550001111',
+            dmPolicy: 'pairing',
           },
           isEnabled: true,
           status: 'running',
@@ -1181,39 +1614,37 @@ describe('sanitizeConnectorOutboundContent', () => {
 
       const first = await inbound('in-b1', 'Hello from Bob')
       const second = await inbound('in-b2', 'Following up before approval')
-      const pendingBefore = Object.values(storage.loadApprovals())
-      await approvals.submitDecision(pendingBefore[0].id, true)
+      const pendingBefore = pairing.listPendingPairingRequests('conn_1')
+      const approved = pairing.approvePairingCode('conn_1', pendingBefore[0].code)
       const allowed = pairing.listStoredAllowedSenders('conn_1')
       const third = await inbound('in-b3', 'Hello after approval')
-      const approvalsAfter = Object.values(storage.loadApprovals())
+      const pendingAfter = pairing.listPendingPairingRequests('conn_1')
       const sessions = storage.loadSessions()
       const thread = sessions.agent_thread
       console.log(JSON.stringify({
         first,
         second,
         pendingBefore: pendingBefore.map((entry) => ({
-          id: entry.id,
-          category: entry.category,
-          status: entry.status,
-          title: entry.title,
-          data: entry.data,
+          code: entry.code,
+          senderId: entry.senderId,
+          senderName: entry.senderName,
         })),
+        approved,
         allowed,
         third,
-        approvalsAfter: approvalsAfter.map((entry) => ({ id: entry.id, status: entry.status })),
+        pendingAfter,
         threadMessages: thread.messages,
       }))
     `)
 
-    assert.match(output.first, /pending approval/i)
-    assert.match(output.second, /pending approval/i)
+    assert.match(output.first, /pending pairing/i)
+    assert.match(output.second, /pending pairing/i)
     assert.equal(output.pendingBefore.length, 1)
-    assert.equal(output.pendingBefore[0].category, 'connector_sender')
-    assert.equal(output.pendingBefore[0].data.senderId, '16660002222@s.whatsapp.net')
+    assert.equal(output.pendingBefore[0].senderId, '16660002222@s.whatsapp.net')
+    assert.equal(output.approved.ok, true)
     assert.deepEqual(output.allowed, ['16660002222@s.whatsapp.net'])
     assert.equal(output.third, 'Approved hello to Bob')
-    assert.equal(output.approvalsAfter.length, 1)
-    assert.equal(output.approvalsAfter[0].status, 'approved')
+    assert.equal(output.pendingAfter.length, 0)
     assert.equal(output.threadMessages.some((msg: any) => msg.source?.senderName === 'Bob' && msg.historyExcluded === true), true)
   })