@zooid/transport-matrix 0.7.4 → 0.9.0

package/src/transport.test.ts

@@ -40,6 +40,7 @@ function fakeClient() {
   return {
     registerBot: vi.fn(async () => undefined),
     joinRoom: vi.fn(async () => undefined),
+    leaveRoom: vi.fn(async () => undefined),
     sendMessage: vi.fn(async () => ({ event_id: '$x' })),
     sendCustomEvent: vi.fn(async () => ({ event_id: '$x' })),
     setTyping: vi.fn(async () => {}),
@@ -66,6 +67,7 @@ function makeTransport(drain?: { drainQuietMs?: number; drainMaxMs?: number }) {
     client: client as never,
     bindings: baseAgents,
     hsToken: 'hs-secret',
+    botUserId: '@zooid:example.com',
     // Disable post-turn drain by default so settleTurn (microtasks) suffices.
     // Tests covering trailing-chunk behavior pass an explicit window.
     drainQuietMs: drain?.drainQuietMs ?? 0,
@@ -314,7 +316,7 @@ describe('matrix transport /transactions', () => {
     expect(call.content).not.toHaveProperty('format')
   })
 
-  it('emits eco.zoon.approval_request when an approval is registered', async () => {
+  it('emits dev.zooid.approval_request when an approval is registered', async () => {
     const { transport, approvals, client } = makeTransport()
     await postTxn(transport.app, {
       events: [
@@ -341,18 +343,18 @@ describe('matrix transport /transactions', () => {
     await new Promise((r) => setImmediate(r))
     expect(client.sendCustomEvent).toHaveBeenCalledWith(
       expect.objectContaining({
-        eventType: 'eco.zoon.approval_request',
+        eventType: 'dev.zooid.approval_request',
         content: expect.objectContaining({ approval_id: 'a1' }),
       }),
     )
   })
 
-  it('resolves an approval when an eco.zoon.approval_response event arrives', async () => {
+  it('resolves an approval when an dev.zooid.approval_response event arrives', async () => {
     const { transport, approvals } = makeTransport()
     await postTxn(transport.app, {
       events: [
         {
-          type: 'eco.zoon.approval_response',
+          type: 'dev.zooid.approval_response',
           event_id: '$resp',
           room_id: '!r:example.com',
           sender: '@alice:example.com',
@@ -535,13 +537,13 @@ describe('thread implicit triggers', () => {
   })
 })
 
-describe('eco.zoon.session_reset', () => {
+describe('dev.zooid.session_reset', () => {
   it('ends the thread-keyed session when sent inside a thread', async () => {
     const { transport, agents } = makeTransport()
     await postTxn(transport.app, {
       events: [
         {
-          type: 'eco.zoon.session_reset',
+          type: 'dev.zooid.session_reset',
           event_id: '$reset',
           room_id: '!r:example.com',
           sender: '@alice:example.com',
@@ -559,7 +561,7 @@ describe('eco.zoon.session_reset', () => {
     await postTxn(transport.app, {
       events: [
         {
-          type: 'eco.zoon.session_reset',
+          type: 'dev.zooid.session_reset',
           event_id: '$reset-room',
           room_id: '!r:example.com',
           sender: '@alice:example.com',
@@ -602,7 +604,7 @@ describe('eco.zoon.session_reset', () => {
     await postTxn(transport.app, {
       events: [
         {
-          type: 'eco.zoon.session_reset',
+          type: 'dev.zooid.session_reset',
           event_id: '$reset',
           room_id: '!r:example.com',
           sender: '@alice:example.com',
@@ -844,7 +846,7 @@ describe('tool-call and plan event bridging', () => {
     return { transport, agents, client, finishPrompt, sessionId: 'sess-$e6' }
   }
 
-  it('forwards tool_call as eco.zoon.tool_call in-room under the agent bot user', async () => {
+  it('forwards tool_call as dev.zooid.tool_call in-room under the agent bot user', async () => {
     const { agents, client, finishPrompt, sessionId } = await startTurnAndGetSession()
     await (agents.onEvent as (n: string, e: unknown) => unknown)('architect', {
       type: 'tool_call',
@@ -859,7 +861,7 @@ describe('tool-call and plan event bridging', () => {
       expect.objectContaining({
         roomId: '!r:example.com',
         asUserId: '@architect:example.com',
-        eventType: 'eco.zoon.tool_call',
+        eventType: 'dev.zooid.tool_call',
         content: expect.objectContaining({
           session_id: sessionId,
           tool_call_id: 'tc-1',
@@ -873,7 +875,7 @@ describe('tool-call and plan event bridging', () => {
     await settleTurn()
   })
 
-  it('forwards tool_call_update as eco.zoon.tool_call_update', async () => {
+  it('forwards tool_call_update as dev.zooid.tool_call_update', async () => {
     const { agents, client, finishPrompt, sessionId } = await startTurnAndGetSession()
     await (agents.onEvent as (n: string, e: unknown) => unknown)('architect', {
       type: 'tool_call_update',
@@ -883,14 +885,14 @@ describe('tool-call and plan event bridging', () => {
     })
     await settleTurn()
     const call = client.sendCustomEvent.mock.calls.find(
-      ([arg]) => (arg as { eventType: string }).eventType === 'eco.zoon.tool_call_update',
+      ([arg]) => (arg as { eventType: string }).eventType === 'dev.zooid.tool_call_update',
     )
     expect(call).toBeDefined()
     finishPrompt()
     await settleTurn()
   })
 
-  it('forwards plan as eco.zoon.plan', async () => {
+  it('forwards plan as dev.zooid.plan', async () => {
     const { agents, client, finishPrompt, sessionId } = await startTurnAndGetSession()
     await (agents.onEvent as (n: string, e: unknown) => unknown)('architect', {
       type: 'plan',
@@ -899,13 +901,61 @@ describe('tool-call and plan event bridging', () => {
     })
     await settleTurn()
     const call = client.sendCustomEvent.mock.calls.find(
-      ([arg]) => (arg as { eventType: string }).eventType === 'eco.zoon.plan',
+      ([arg]) => (arg as { eventType: string }).eventType === 'dev.zooid.plan',
     )
     expect(call).toBeDefined()
     finishPrompt()
     await settleTurn()
   })
 
+  it('replays available_commands advertised during ensureSession (before the session ctx exists)', async () => {
+    // Regression (ZOD040 ctx race): shims advertise commands during session
+    // load/new — i.e. inside ensureSession, BEFORE runTurn registers the ctx.
+    // Without buffer-and-replay the event hits onEvent with no ctx and is
+    // dropped, so the command palette never fills. available_commands is only
+    // ever emitted at session establishment, so this is its ONLY chance.
+    const { transport, agents, client, finishPrompt } = makeTransport()
+    agents.ensureSession.mockImplementation(async (_name: string, threadId: string) => {
+      const sessionId = `sess-${threadId}`
+      await (agents.onEvent as (n: string, e: unknown) => unknown)('architect', {
+        type: 'available_commands',
+        sessionId,
+        commands: [{ name: 'compact', description: 'Compact the context' }],
+      })
+      return sessionId
+    })
+
+    await postTxn(transport.app, {
+      events: [
+        {
+          type: 'm.room.message',
+          event_id: '$e7',
+          origin_server_ts: Date.now(),
+          room_id: '!r:example.com',
+          sender: '@user:example.com',
+          content: {
+            msgtype: 'm.text',
+            body: 'hi',
+            'm.mentions': { user_ids: ['@architect:example.com'] },
+          },
+        },
+      ],
+    })
+    await settleTurn()
+
+    const call = client.sendCustomEvent.mock.calls.find(
+      ([arg]) =>
+        (arg as { eventType: string }).eventType === 'dev.zooid.available_commands_update',
+    )
+    expect(call).toBeDefined()
+    expect((call![0] as { content: Record<string, unknown> }).content).toMatchObject({
+      session_id: 'sess-$e7',
+      available_commands: [{ name: 'compact', description: 'Compact the context' }],
+    })
+    finishPrompt()
+    await settleTurn()
+  })
+
   it('attaches m.relates_to thread when the originating message was in-thread', async () => {
     const { transport, agents, client, finishPrompt } = makeTransport()
     await postTxn(transport.app, {
@@ -935,7 +985,7 @@ describe('tool-call and plan event bridging', () => {
     })
     await settleTurn()
     const call = client.sendCustomEvent.mock.calls.find(
-      ([arg]) => (arg as { eventType: string }).eventType === 'eco.zoon.tool_call',
+      ([arg]) => (arg as { eventType: string }).eventType === 'dev.zooid.tool_call',
     )
     expect((call?.[0] as { content: Record<string, unknown> }).content['m.relates_to']).toEqual({
       rel_type: 'm.thread',
@@ -1034,17 +1084,23 @@ describe('agent_message_chunk message-boundary buffering', () => {
   const sentBody = (client: { sendMessage: { mock: { calls: unknown[][] } } }) =>
     (client.sendMessage.mock.calls[0]![0] as { content: { body: string } }).content.body
 
-  it('inserts a paragraph break when messageId changes between chunks (opencode run-on)', async () => {
-    // The exact production failure: opencode streams "…it." under one message id,
-    // then "Filed:" under a NEW id with no delimiter chunk. Without a break they
-    // weld into "it.Filed:".
+  const sentBodies = (client: { sendMessage: { mock: { calls: unknown[][] } } }) =>
+    client.sendMessage.mock.calls.map(
+      (c) => (c[0] as { content: { body: string } }).content.body,
+    )
+
+  it('flushes a separate Matrix message when messageId changes (opencode run-on)', async () => {
+    // opencode streams "…it." under one message id, then "Filed:" under a NEW
+    // id with no delimiter chunk. Each id is a distinct assistant message, so
+    // each lands as its own Matrix message rather than welding into "it.Filed:"
+    // (or being buffered into a single turn-end blob).
     const { agents, client, finishPrompt, sessionId } = await startTurn('$mid1')
     await emit(agents, sessionId, 'Let me file it.', 'msg_aaa')
     await emit(agents, sessionId, 'Filed: done', 'msg_bbb')
     finishPrompt()
     await settleTurn()
-    expect(client.sendMessage).toHaveBeenCalledTimes(1)
-    expect(sentBody(client)).toBe('Let me file it.\n\nFiled: done')
+    expect(client.sendMessage).toHaveBeenCalledTimes(2)
+    expect(sentBodies(client)).toEqual(['Let me file it.', 'Filed: done'])
   })
 
   it('does NOT break between chunks sharing a messageId (token streaming stays intact)', async () => {
@@ -1059,14 +1115,15 @@ describe('agent_message_chunk message-boundary buffering', () => {
     expect(sentBody(client)).toBe('Hello world.')
   })
 
-  it('breaks only once across a three-message run', async () => {
+  it('flushes each message of a three-message run separately', async () => {
     const { agents, client, finishPrompt, sessionId } = await startTurn('$mid3')
     await emit(agents, sessionId, 'one.', 'msg_a')
     await emit(agents, sessionId, 'two.', 'msg_b')
     await emit(agents, sessionId, 'three.', 'msg_c')
     finishPrompt()
     await settleTurn()
-    expect(sentBody(client)).toBe('one.\n\ntwo.\n\nthree.')
+    expect(client.sendMessage).toHaveBeenCalledTimes(3)
+    expect(sentBodies(client)).toEqual(['one.', 'two.', 'three.'])
   })
 
   it('still breaks on an empty delimiter chunk (agents that signal that way)', async () => {
@@ -1087,9 +1144,37 @@ describe('agent_message_chunk message-boundary buffering', () => {
     await settleTurn()
     expect(sentBody(client)).toBe('Hello there')
   })
+
+  it('flushes buffered text before a following plan event (interleaving)', async () => {
+    // A turn that alternates prose and plan updates: each prose message must
+    // land on the wire before the plan event that follows it, not be deferred
+    // to turn end (the bug — everything buffered, then one blob after N plans).
+    const { agents, client, finishPrompt, sessionId } = await startTurn('$mid6')
+    await emit(agents, sessionId, 'Sure, making a list.', 'msg_a')
+    await (agents.onEvent as (n: string, e: unknown) => unknown)('architect', {
+      type: 'plan',
+      sessionId,
+      entries: [{ content: 'Buy milk', status: 'pending' }],
+    })
+    await emit(agents, sessionId, 'Working through them.', 'msg_b')
+    finishPrompt()
+    await settleTurn()
+
+    expect(sentBodies(client)).toEqual(['Sure, making a list.', 'Working through them.'])
+    const planIdx = client.sendCustomEvent.mock.calls.findIndex(
+      ([arg]) => (arg as { eventType: string }).eventType === 'dev.zooid.plan',
+    )
+    expect(planIdx).toBeGreaterThanOrEqual(0)
+    // Order across both mocks: msg1 → plan → msg2.
+    const msg1 = client.sendMessage.mock.invocationCallOrder[0]!
+    const msg2 = client.sendMessage.mock.invocationCallOrder[1]!
+    const plan = client.sendCustomEvent.mock.invocationCallOrder[planIdx]!
+    expect(msg1).toBeLessThan(plan)
+    expect(plan).toBeLessThan(msg2)
+  })
 })
 
-describe('eco.zoon.interrupt handling', () => {
+describe('dev.zooid.interrupt handling', () => {
   it('dispatches cancelSession(agent.name, sessionId) for an interrupt that targets a tracked session', async () => {
     const { transport, agents, finishPrompt } = makeTransport()
     await postTxn(transport.app, {
@@ -1109,7 +1194,7 @@ describe('eco.zoon.interrupt handling', () => {
     await postTxn(transport.app, {
       events: [
         {
-          type: 'eco.zoon.interrupt',
+          type: 'dev.zooid.interrupt',
           event_id: '$int',
           origin_server_ts: Date.now(),
           room_id: '!r:example.com',
@@ -1141,7 +1226,7 @@ describe('eco.zoon.interrupt handling', () => {
     await postTxn(transport.app, {
       events: [
         {
-          type: 'eco.zoon.interrupt',
+          type: 'dev.zooid.interrupt',
           event_id: '$int2',
           origin_server_ts: Date.now(),
           room_id: '!r:example.com',
@@ -1160,7 +1245,7 @@ describe('eco.zoon.interrupt handling', () => {
     await postTxn(transport.app, {
       events: [
         {
-          type: 'eco.zoon.interrupt',
+          type: 'dev.zooid.interrupt',
           event_id: '$int3',
           origin_server_ts: Date.now(),
           room_id: '!r:example.com',
@@ -1191,7 +1276,7 @@ describe('eco.zoon.interrupt handling', () => {
     await postTxn(transport.app, {
       events: [
         {
-          type: 'eco.zoon.interrupt',
+          type: 'dev.zooid.interrupt',
           event_id: '$intT',
           origin_server_ts: Date.now(),
           room_id: '!r:example.com',
@@ -1226,7 +1311,7 @@ describe('eco.zoon.interrupt handling', () => {
     const interrupt = (id: string) => ({
       events: [
         {
-          type: 'eco.zoon.interrupt',
+          type: 'dev.zooid.interrupt',
           event_id: id,
           origin_server_ts: Date.now(),
           room_id: '!r:example.com',
@@ -1249,7 +1334,7 @@ describe('eco.zoon.interrupt handling', () => {
       {
         events: [
           {
-            type: 'eco.zoon.interrupt',
+            type: 'dev.zooid.interrupt',
             event_id: '$bad',
             origin_server_ts: Date.now(),
             room_id: '!r:example.com',
@@ -1312,3 +1397,289 @@ describe('full loop integration', () => {
     )
   })
 })
+
+// ─── Media pipeline tests ────────────────────────────────────────────────────
+
+const TINY_PNG_B64 =
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=='
+const TINY_PNG = Buffer.from(TINY_PNG_B64, 'base64')
+
+function fakeMedia() {
+  return {
+    download: vi.fn(async () => ({ data: new Uint8Array(TINY_PNG), contentType: 'image/png' })),
+    upload: vi.fn(async () => ({ content_uri: 'mxc://localhost/up1' })),
+  }
+}
+
+const workspaceBinding = {
+  ...baseAgents[0],
+  workspaceDir: '/tmp/ws',
+  agentWorkspacePath: '/workspace',
+}
+
+function makeMediaTransport(opts: {
+  media?: ReturnType<typeof fakeMedia>
+  writeAttachmentFn?: unknown
+} = {}) {
+  const { reg, finishPrompt } = fakeRegistry()
+  const approvals = fakeApprovals()
+  const client = fakeClient()
+  const transport = createMatrixTransport({
+    agents: reg as never,
+    approvals: approvals as never,
+    client: client as never,
+    bindings: [workspaceBinding],
+    hsToken: 'hs-secret',
+    drainQuietMs: 0,
+    media: opts.media as never,
+    writeAttachmentFn: opts.writeAttachmentFn as never,
+  })
+  return { transport, agents: reg, client, finishPrompt }
+}
+
+function imageEvent(over: {
+  size?: number
+  mimetype?: string
+  msgtype?: string
+  body?: string
+  eventId?: string
+} = {}) {
+  return {
+    type: 'm.room.message',
+    event_id: over.eventId ?? '$media1',
+    room_id: '!r:example.com',
+    sender: '@alice:example.com',
+    content: {
+      msgtype: over.msgtype ?? 'm.image',
+      body: over.body ?? 'dog.png',
+      url: 'mxc://localhost/abc',
+      info: { mimetype: over.mimetype ?? 'image/png', size: over.size ?? 67 },
+    },
+  }
+}
+
+function mentionMsg(body: string, eventId = '$text1') {
+  return {
+    type: 'm.room.message',
+    event_id: eventId,
+    room_id: '!r:example.com',
+    sender: '@alice:example.com',
+    content: {
+      msgtype: 'm.text',
+      body: `@architect ${body}`,
+      'm.mentions': { user_ids: ['@architect:example.com'] },
+    },
+  }
+}
+
+describe('inbound media', () => {
+  it('media events do not trigger a turn; m.text from the same sender drains them inline', async () => {
+    const media = fakeMedia()
+    const { transport, agents } = makeMediaTransport({ media })
+
+    // Image event: no turn fired
+    await postTxn(transport.app, { events: [imageEvent()] })
+    await settleTurn()
+    expect(agents.prompt).not.toHaveBeenCalled()
+
+    // m.text mention from same sender: turn fires, image block prepended
+    agents.prompt.mockImplementation(async (_name: string, p: { content: unknown[] }) => {
+      agents.onEvent('architect', {
+        type: 'agent_message_chunk',
+        sessionId: 'sess-$text1',
+        content: { type: 'text', text: 'got it' },
+      })
+      return { stopReason: 'end_turn' as const }
+    })
+    await postTxn(transport.app, { events: [mentionMsg('look at this')] })
+    await settleTurn()
+
+    expect(agents.prompt).toHaveBeenCalledOnce()
+    const content = (agents.prompt.mock.calls[0][1] as { content: unknown[] }).content
+    expect(content[0]).toMatchObject({ type: 'image', data: TINY_PNG_B64, mimeType: 'image/png' })
+    expect((content[1] as { type: string; text: string }).type).toBe('text')
+    expect(media.download).toHaveBeenCalledOnce()
+  })
+
+  it('routes an oversized image to the file path with a resource_link block and prose line', async () => {
+    const media = fakeMedia()
+    const writeAttachmentFn = vi.fn(() => ({
+      hostPath: '/tmp/ws/.zooid/attachments/media1/dog.png',
+      agentPath: '/workspace/.zooid/attachments/media1/dog.png',
+    }))
+    const { transport, agents } = makeMediaTransport({ media, writeAttachmentFn })
+
+    agents.prompt.mockResolvedValue({ stopReason: 'end_turn' as const })
+    await postTxn(transport.app, { events: [imageEvent({ size: 600_000 })] }) // > MAX_INLINE_IMAGE_BYTES
+    await postTxn(transport.app, { events: [mentionMsg('summarize')] })
+    await settleTurn()
+
+    const content = (agents.prompt.mock.calls[0][1] as { content: unknown[] }).content
+    expect(content[0]).toMatchObject({
+      type: 'resource_link',
+      uri: 'file:///workspace/.zooid/attachments/media1/dog.png',
+      name: 'dog.png',
+    })
+    expect((content[1] as { text: string }).text).toContain(
+      '/workspace/.zooid/attachments/media1/dog.png',
+    )
+  })
+
+  it('routes m.file to the workspace regardless of size', async () => {
+    const media = fakeMedia()
+    const writeAttachmentFn = vi.fn(() => ({
+      hostPath: '/tmp/ws/.zooid/attachments/media1/report.pdf',
+      agentPath: '/workspace/.zooid/attachments/media1/report.pdf',
+    }))
+    const { transport, agents } = makeMediaTransport({ media, writeAttachmentFn })
+
+    agents.prompt.mockResolvedValue({ stopReason: 'end_turn' as const })
+    await postTxn(transport.app, {
+      events: [imageEvent({ msgtype: 'm.file', body: 'report.pdf', mimetype: 'application/pdf' })],
+    })
+    await postTxn(transport.app, { events: [mentionMsg('read it')] })
+    await settleTurn()
+
+    expect(writeAttachmentFn).toHaveBeenCalledOnce()
+    const content = (agents.prompt.mock.calls[0][1] as { content: unknown[] }).content
+    expect((content[0] as { type: string }).type).toBe('resource_link')
+  })
+
+  it('emits dev.zooid.error (code media_failed) when download fails, still runs the turn text-only', async () => {
+    const media = fakeMedia()
+    media.download.mockRejectedValueOnce(new Error('download boom'))
+    const { transport, agents, client } = makeMediaTransport({ media })
+
+    agents.prompt.mockImplementation(async () => {
+      agents.onEvent('architect', {
+        type: 'agent_message_chunk',
+        sessionId: 'sess-$text1',
+        content: { type: 'text', text: 'ok' },
+      })
+      return { stopReason: 'end_turn' as const }
+    })
+    await postTxn(transport.app, { events: [imageEvent()] })
+    await postTxn(transport.app, { events: [mentionMsg('look')] })
+    await settleTurn()
+
+    expect(client.sendCustomEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        eventType: 'dev.zooid.error',
+        content: expect.objectContaining({ code: 'media_failed' }),
+      }),
+    )
+    const content = (agents.prompt.mock.calls[0][1] as { content: unknown[] }).content
+    expect(content).toHaveLength(1)
+    expect((content[0] as { type: string }).type).toBe('text')
+  })
+})
+
+describe('outbound agent images', () => {
+  it('uploads an image chunk and sends a threaded m.image as the agent user', async () => {
+    const media = fakeMedia()
+    const { transport, agents, client } = makeMediaTransport({ media })
+
+    agents.prompt.mockImplementation(async () => {
+      // Emit image block during prompt
+      agents.onEvent('architect', {
+        type: 'agent_message_chunk',
+        sessionId: 'sess-$text1',
+        content: { type: 'image', data: TINY_PNG_B64, mimeType: 'image/png' },
+      })
+      // Also emit text block so the turn isn't empty
+      agents.onEvent('architect', {
+        type: 'agent_message_chunk',
+        sessionId: 'sess-$text1',
+        content: { type: 'text', text: 'here is the image' },
+      })
+      return { stopReason: 'end_turn' as const }
+    })
+
+    await postTxn(transport.app, { events: [mentionMsg('show me an image')] })
+    await settleTurn()
+    // Give async upload/send a moment to settle
+    await new Promise((r) => setTimeout(r, 10))
+
+    expect(media.upload).toHaveBeenCalledWith(
+      expect.objectContaining({ contentType: 'image/png', asUserId: '@architect:example.com' }),
+    )
+    expect(client.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        asUserId: '@architect:example.com',
+        content: expect.objectContaining({
+          msgtype: 'm.image',
+          url: 'mxc://localhost/up1',
+          info: expect.objectContaining({ mimetype: 'image/png', size: TINY_PNG.length }),
+        }),
+      }),
+    )
+  })
+
+  it('does not throw when an audio block arrives (non-goal — warn and drop)', async () => {
+    const media = fakeMedia()
+    const { transport, agents } = makeMediaTransport({ media })
+
+    agents.prompt.mockImplementation(async () => {
+      agents.onEvent('architect', {
+        type: 'agent_message_chunk',
+        sessionId: 'sess-$text1',
+        content: { type: 'audio', data: 'AAAA', mimeType: 'audio/wav' },
+      })
+      agents.onEvent('architect', {
+        type: 'agent_message_chunk',
+        sessionId: 'sess-$text1',
+        content: { type: 'text', text: 'ok' },
+      })
+      return { stopReason: 'end_turn' as const }
+    })
+
+    await expect(
+      postTxn(transport.app, { events: [mentionMsg('test audio')] }),
+    ).resolves.not.toThrow()
+    await settleTurn()
+  })
+})
+
+describe('ad-hoc bot invite declines', () => {
+  let n = 0
+  const invite = (stateKey: string, sender: string) => ({
+    type: 'm.room.member',
+    event_id: `$inv${++n}`,
+    room_id: '!r:example.com',
+    sender,
+    state_key: stateKey,
+    content: { membership: 'invite' },
+  })
+
+  it('declines an invite to the AS bot from a human, with a reason', async () => {
+    const { transport, client } = makeTransport()
+    await postTxn(transport.app, { events: [invite('@zooid:example.com', '@zongshan:example.com')] })
+    expect(client.leaveRoom).toHaveBeenCalledWith(
+      '!r:example.com',
+      '@zooid:example.com',
+      { reason: expect.stringContaining('zooid.yaml') },
+    )
+  })
+
+  it('declines an invite to an agent from a human', async () => {
+    const { transport, client } = makeTransport()
+    await postTxn(transport.app, { events: [invite('@architect:example.com', '@zongshan:example.com')] })
+    expect(client.leaveRoom).toHaveBeenCalledWith(
+      '!r:example.com',
+      '@architect:example.com',
+      expect.objectContaining({ reason: expect.any(String) }),
+    )
+  })
+
+  it('does NOT decline a provisioning invite (inviter is our AS bot)', async () => {
+    const { transport, client } = makeTransport()
+    await postTxn(transport.app, { events: [invite('@architect:example.com', '@zooid:example.com')] })
+    expect(client.leaveRoom).not.toHaveBeenCalled()
+  })
+
+  it('ignores an invite to a human (not one of our bots)', async () => {
+    const { transport, client } = makeTransport()
+    await postTxn(transport.app, { events: [invite('@dave:example.com', '@zongshan:example.com')] })
+    expect(client.leaveRoom).not.toHaveBeenCalled()
+  })
+})