@zooid/transport-matrix 0.8.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zooid/transport-matrix",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Matrix Application Service transport for zooid. Routes inbound Matrix messages to ACP agents and posts replies plus approval custom events back to threads.",
   "type": "module",
   "license": "MIT",
@@ -28,8 +28,8 @@
     "marked": "^18.0.4",
     "sanitize-html": "^2.17.4",
     "yaml": "^2.5.0",
-    "@zooid/acp-client": "^0.8.0",
-    "@zooid/core": "^0.8.0"
+    "@zooid/core": "^0.9.0",
+    "@zooid/acp-client": "^0.9.0"
   },
   "devDependencies": {
     "@hono/node-server": "^1.13.0",

package/src/bot-pool.ts

@@ -48,7 +48,7 @@ export class BotPool {
         console.warn(`[matrix] setDisplayName(${a.userId}) failed: ${(err as Error).message}`)
       }
       // Make each agent a member of the workforce space. That covers two
-      // things at once: the eco.zoon.workforce roster is now backed by
+      // things at once: the dev.zooid.workforce roster is now backed by
       // actual space membership (so the Zoon client's member autocomplete
       // works across rooms), and every restricted child room's allow rule
       // is satisfied without per-room invites.

package/src/context-provider.ts

@@ -43,7 +43,7 @@ export class MatrixContextProvider implements TransportContextProvider {
 
   async getRoomHistory(channelId: string, hopts: HistoryOptions): Promise<HistoryPage> {
     // Server-side filter: only `m.room.message` events. Without this we'd
-    // burn the page budget on reactions, `eco.zoon.*` custom events, typing
+    // burn the page budget on reactions, `dev.zooid.*` custom events, typing
     // notifications, etc., and routinely return empty pages with a stale
     // `has_more` cursor.
     const { chunk, end } = await this.opts.client.fetchRoomMessages({

package/src/event-encoders.test.ts

@@ -9,6 +9,7 @@ import {
   toUpdateBody,
   toPlanBody,
   toErrorBody,
+  toAvailableCommandsBody,
 } from './event-encoders.js'
 
 describe('toToolCallBody', () => {
@@ -124,6 +125,27 @@ describe('toPlanBody', () => {
   })
 })
 
+describe('toAvailableCommandsBody', () => {
+  it('encodes available_commands into the body ZNC021 decodes', () => {
+    expect(
+      toAvailableCommandsBody({
+        type: 'available_commands',
+        sessionId: 's-1',
+        commands: [
+          { name: 'plan', description: 'Switch to plan mode' },
+          { name: 'compact', description: 'Compact the context' },
+        ],
+      }),
+    ).toEqual({
+      session_id: 's-1',
+      available_commands: [
+        { name: 'plan', description: 'Switch to plan mode' },
+        { name: 'compact', description: 'Compact the context' },
+      ],
+    })
+  })
+})
+
 describe('toErrorBody', () => {
   const threadRoot = '$root-event-id'
 

package/src/event-encoders.ts

@@ -1,4 +1,5 @@
 import type {
+  AvailableCommandsEvent,
   PlanEvent,
   TapEvent,
   ToolCallEvent,
@@ -66,6 +67,18 @@ export function toPlanBody(evt: PlanEvent): Record<string, unknown> {
   }
 }
 
+export function toAvailableCommandsBody(
+  evt: AvailableCommandsEvent,
+): Record<string, unknown> {
+  return {
+    session_id: evt.sessionId,
+    available_commands: evt.commands.map((c) => ({
+      name: c.name,
+      description: c.description,
+    })),
+  }
+}
+
 const RECOVERY_URLS: Partial<Record<string, string>> = {
   auth_missing: 'https://zooid.dev/docs/guides/run-in-container#authentication-that-carries-over',
   auth_invalid: 'https://zooid.dev/docs/guides/run-in-container#authentication-that-carries-over',

package/src/matrix-client.test.ts

@@ -287,7 +287,7 @@ describe('MatrixClient', () => {
 
   it('sends a custom event type when content type is set', async () => {
     const fetch = fakeFetch(async ({ url, init }) => {
-      expect(url).toMatch(/\/send\/eco\.zoon\.approval_request\//)
+      expect(url).toMatch(/\/send\/dev\.zooid\.approval_request\//)
       const body = JSON.parse(init.body as string)
       expect(body.approval_id).toBe('a1')
       return new Response(JSON.stringify({ event_id: '$x' }), { status: 200 })
@@ -300,7 +300,7 @@ describe('MatrixClient', () => {
     await client.sendCustomEvent({
       roomId: '!r:example.com',
       asUserId: '@architect:example.com',
-      eventType: 'eco.zoon.approval_request',
+      eventType: 'dev.zooid.approval_request',
       content: { approval_id: 'a1', description: 'Run: git push' },
     })
   })
@@ -445,6 +445,39 @@ describe('MatrixClient.createRoom userPowerLevels', () => {
   })
 })
 
+describe('MatrixClient.leaveRoom', () => {
+  it('leaves (rejects) a room as the impersonated user, with a reason', async () => {
+    const fetch = fakeFetch(async ({ url, init }) => {
+      expect(url).toBe(
+        'https://hs.example.com/_matrix/client/v3/rooms/!r%3Aexample.com/leave' +
+          '?user_id=%40zooid%3Aexample.com',
+      )
+      expect(init.method).toBe('POST')
+      expect(JSON.parse(init.body as string)).toEqual({ reason: 'no thanks' })
+      return new Response('{}', { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await client.leaveRoom('!r:example.com', '@zooid:example.com', { reason: 'no thanks' })
+  })
+
+  it('sends an empty body when no reason is given', async () => {
+    const fetch = fakeFetch(async ({ init }) => {
+      expect(JSON.parse(init.body as string)).toEqual({})
+      return new Response('{}', { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await client.leaveRoom('!r:example.com', '@zooid:example.com')
+  })
+})
+
 describe('MatrixClient.createRoom restricted', () => {
   it('injects a restricted join rule referencing the space when restrictedToSpaceId is set', async () => {
     const fetch = fakeFetch(async ({ url, init }) => {

package/src/matrix-client.ts

@@ -222,6 +222,25 @@ export class MatrixClient {
     throw new Error(`invite(${opts.targetUserId}) failed: ${r.status}`)
   }
 
+  async leaveRoom(
+    roomId: string,
+    asUserId: string,
+    opts?: { reason?: string },
+  ): Promise<void> {
+    const url =
+      `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/leave` +
+      `?user_id=${encodeURIComponent(asUserId)}`
+    const r = await this.fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.asToken}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(opts?.reason ? { reason: opts.reason } : {}),
+    })
+    if (!r.ok) throw new Error(`leaveRoom(${roomId}, ${asUserId}) failed: ${r.status}`)
+  }
+
   async joinRoom(roomIdOrAlias: string, asUserId: string): Promise<void> {
     const url =
       `${this.homeserver}/_matrix/client/v3/join/${encodeURIComponent(roomIdOrAlias)}` +

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',
@@ -1460,7 +1545,7 @@ describe('inbound media', () => {
     expect((content[0] as { type: string }).type).toBe('resource_link')
   })
 
-  it('emits eco.zoon.error (code media_failed) when download fails, still runs the turn text-only', async () => {
+  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 })
@@ -1479,7 +1564,7 @@ describe('inbound media', () => {
 
     expect(client.sendCustomEvent).toHaveBeenCalledWith(
       expect.objectContaining({
-        eventType: 'eco.zoon.error',
+        eventType: 'dev.zooid.error',
         content: expect.objectContaining({ code: 'media_failed' }),
       }),
     )
@@ -1554,3 +1639,47 @@ describe('outbound agent images', () => {
     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()
+  })
+})