@zooid/transport-matrix 0.9.1 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zooid/transport-matrix",
-  "version": "0.9.1",
+  "version": "0.10.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.9.1",
-    "@zooid/core": "^0.9.1"
+    "@zooid/acp-client": "^0.10.0",
+    "@zooid/core": "^0.10.0"
   },
   "devDependencies": {
     "@hono/node-server": "^1.13.0",

package/src/bot-pool.test.ts

@@ -107,6 +107,129 @@ describe('BotPool.bootstrap — create-if-missing rooms', () => {
     ])
   })
 
+  it('joins the existing room when createRoom loses a race (alias taken)', async () => {
+    // Another agent/process created the room first: the alias didn't resolve at
+    // first check, createRoom then fails (alias in use), and a re-resolve finds
+    // it. We must join that room — not leave an orphan.
+    const calls: string[] = []
+    let resolveCount = 0
+    const client = {
+      registerBot: async () => {},
+      setDisplayName: async () => {},
+      resolveAlias: async (a: string) => {
+        resolveCount++
+        // First check: not found (we'll try to create). After the failed
+        // create, the re-resolve finds the room the concurrent creator made.
+        const r = resolveCount === 1 ? null : '!raced:localhost'
+        calls.push(`resolve:${a}->${r ?? 'null'}`)
+        return r
+      },
+      createRoom: async () => {
+        calls.push('create:THROWS(alias in use)')
+        throw new Error('createRoom(welcome) failed: 409 M_ROOM_IN_USE')
+      },
+      joinRoom: async (room: string, asUser: string) => {
+        calls.push(`join:${asUser}->${room}`)
+      },
+    }
+    const pool = new BotPool(client as never, [
+      {
+        name: 'echo',
+        userId: '@echo:localhost',
+        rooms: [{ alias: '#welcome:localhost' }],
+        trigger: 'mention',
+      },
+    ])
+    await pool.bootstrap({ adminUserId: '@admin:localhost' })
+    expect(calls).toEqual([
+      'resolve:#welcome:localhost->null',
+      'create:THROWS(alias in use)',
+      'resolve:#welcome:localhost->!raced:localhost',
+      'join:@echo:localhost->!raced:localhost',
+    ])
+  })
+
+  it('two pools racing the same room → exactly one room, both join it, no orphans', async () => {
+    // Models the real bug: two agents in *separate* daemon processes bootstrap
+    // the same workforce concurrently. They share one stateful homeserver where
+    // an alias can be claimed exactly once. Each pool's first directory read is
+    // stale (returns null — it read before anyone claimed), so both proceed to
+    // createRoom; the second create loses (alias in use) and must recover by
+    // re-resolving and joining, not orphaning.
+    const aliasToRoom = new Map<string, string>()
+    let roomsCreated = 0
+    let n = 0
+    const makeClient = () => {
+      let staleRead = true
+      const joins: string[] = []
+      return {
+        joins,
+        registerBot: async () => {},
+        setDisplayName: async () => {},
+        invite: async () => {},
+        sendStateEvent: async () => ({ event_id: '$x' }),
+        resolveAlias: async (a: string) => {
+          if (staleRead) {
+            staleRead = false
+            return null
+          }
+          return aliasToRoom.get(a) ?? null
+        },
+        createRoom: async (o: { roomAliasName: string }) => {
+          const alias = `#${o.roomAliasName}:s`
+          if (aliasToRoom.has(alias)) throw new Error('createRoom(shared) failed: 409 M_ROOM_IN_USE')
+          const id = `!room${++n}:s`
+          aliasToRoom.set(alias, id)
+          roomsCreated++
+          return id
+        },
+        joinRoom: async (room: string, user: string) => {
+          joins.push(`${user}->${room}`)
+        },
+      }
+    }
+    const a = makeClient()
+    const b = makeClient()
+    const poolA = new BotPool(a as never, [
+      { name: 'a', userId: '@a:s', rooms: [{ alias: '#shared:s' }], trigger: 'mention' },
+    ])
+    const poolB = new BotPool(b as never, [
+      { name: 'b', userId: '@b:s', rooms: [{ alias: '#shared:s' }], trigger: 'mention' },
+    ])
+    await poolA.bootstrap({ adminUserId: '@admin:s' })
+    await poolB.bootstrap({ adminUserId: '@admin:s' })
+
+    // Exactly one room exists — the loser recovered instead of orphaning.
+    expect(roomsCreated).toBe(1)
+    const theRoom = aliasToRoom.get('#shared:s')
+    // Both agents joined that one room.
+    expect(a.joins).toEqual([`@a:s->${theRoom}`])
+    expect(b.joins).toEqual([`@b:s->${theRoom}`])
+  })
+
+  it('rethrows when createRoom fails and the alias still does not resolve', async () => {
+    const client = {
+      registerBot: async () => {},
+      setDisplayName: async () => {},
+      resolveAlias: async () => null, // never resolves — genuine creation failure
+      createRoom: async () => {
+        throw new Error('createRoom(welcome) failed: 500 boom')
+      },
+      joinRoom: vi.fn(async () => undefined),
+    }
+    const pool = new BotPool(client as never, [
+      {
+        name: 'echo',
+        userId: '@echo:localhost',
+        rooms: [{ alias: '#welcome:localhost' }],
+        trigger: 'mention',
+      },
+    ])
+    // bootstrap swallows per-room errors (logs); the room is never joined.
+    await pool.bootstrap({ adminUserId: '@admin:localhost' })
+    expect(client.joinRoom).not.toHaveBeenCalled()
+  })
+
   it('skips create when the alias already resolves', async () => {
     const calls: string[] = []
     const client = {

package/src/bot-pool.ts

@@ -95,14 +95,26 @@ export class BotPool {
                   this.agents,
                   room,
                 )
-                resolved = await this.client.createRoom({
-                  roomAliasName: aliasLocalpart,
-                  invite: opts.adminUserId ? [opts.adminUserId] : [],
-                  senderUserId: sender,
-                  name: aliasLocalpart,
-                  ...(opts.spaceRoomId ? { restrictedToSpaceId: opts.spaceRoomId } : {}),
-                  ...(userPowerLevels ? { userPowerLevels } : {}),
-                })
+                try {
+                  resolved = await this.client.createRoom({
+                    roomAliasName: aliasLocalpart,
+                    invite: opts.adminUserId ? [opts.adminUserId] : [],
+                    senderUserId: sender,
+                    name: aliasLocalpart,
+                    ...(opts.spaceRoomId ? { restrictedToSpaceId: opts.spaceRoomId } : {}),
+                    ...(userPowerLevels ? { userPowerLevels } : {}),
+                  })
+                } catch (err) {
+                  // Another agent — or another daemon process bootstrapping the
+                  // same workforce — may have created this room concurrently, so
+                  // its alias is now taken (createRoom fails with the alias in
+                  // use). Re-resolve and join the existing room rather than
+                  // leaving an orphan. Only rethrow if the alias still doesn't
+                  // resolve (a genuine creation failure).
+                  const raced = await this.client.resolveAlias(room)
+                  if (!raced) throw err
+                  resolved = raced
+                }
               }
               aliasToId.set(room, resolved)
             }

package/src/matrix-client.test.ts

@@ -160,6 +160,49 @@ describe('MatrixClient', () => {
     })
   })
 
+  it('createRoom keeps the creator at PL 100 when a power-level override omits them', async () => {
+    // power_level_content_override.users REPLACES the default { creator: 100 }
+    // map; if the creator is left out they drop to 0 and can't claim the alias.
+    const fetch = fakeFetch(async ({ init }) => {
+      const body = JSON.parse(init.body as string)
+      expect(body.power_level_content_override.users).toEqual({
+        '@zooid:localhost': 100,
+        '@creator:localhost': 100,
+      })
+      return new Response(JSON.stringify({ room_id: '!new:localhost' }), { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await client.createRoom({
+      roomAliasName: 'welcome',
+      invite: [],
+      senderUserId: '@creator:localhost',
+      userPowerLevels: { '@zooid:localhost': 100 },
+    })
+  })
+
+  it('createRoom does not override an explicit power level already set for the creator', async () => {
+    const fetch = fakeFetch(async ({ init }) => {
+      const body = JSON.parse(init.body as string)
+      expect(body.power_level_content_override.users['@creator:localhost']).toBe(50)
+      return new Response(JSON.stringify({ room_id: '!new:localhost' }), { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await client.createRoom({
+      roomAliasName: 'welcome',
+      invite: [],
+      senderUserId: '@creator:localhost',
+      userPowerLevels: { '@creator:localhost': 50 },
+    })
+  })
+
   it('setDisplayName PUTs the displayname endpoint impersonating the user', async () => {
     const fetch = fakeFetch(async ({ url, init }) => {
       expect(url).toBe(

package/src/matrix-client.ts

@@ -115,7 +115,14 @@ export class MatrixClient {
       ]
     }
     if (opts.userPowerLevels && Object.keys(opts.userPowerLevels).length > 0) {
-      body.power_level_content_override = { users: opts.userPowerLevels }
+      // `power_level_content_override.users` REPLACES the default `{ creator: 100 }`
+      // map rather than merging into it. If the creator (senderUserId) is omitted
+      // here they drop to `users_default` (0) and can't set `m.room.canonical_alias`
+      // (PL 50) during creation — the createRoom call then 403s and leaves an
+      // aliasless orphan room. Always keep the creator at admin power.
+      const users = { ...opts.userPowerLevels }
+      if (users[opts.senderUserId] === undefined) users[opts.senderUserId] = 100
+      body.power_level_content_override = { users }
     }
     const r = await this.fetch(
       `${this.homeserver}/_matrix/client/v3/createRoom?user_id=${encodeURIComponent(opts.senderUserId)}`,

package/src/router.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { route, isMediaMsgtype, type AgentBinding } from './router.js'
+import { route, isMediaMsgtype, type AgentBinding, type ThreadState } from './router.js'
 
 const agents: AgentBinding[] = [
   {
@@ -109,3 +109,119 @@ describe('media events', () => {
     expect(matches).toEqual([])
   })
 })
+
+describe('directional thread continuation (agent-to-agent handoffs)', () => {
+  const parent: AgentBinding = {
+    name: 'parent',
+    userId: '@parent:example.com',
+    rooms: [{ alias: '!room1:example.com' }],
+    trigger: 'mention',
+  }
+  const sub: AgentBinding = {
+    name: 'sub',
+    userId: '@sub:example.com',
+    rooms: [{ alias: '!room1:example.com' }],
+    trigger: 'mention',
+  }
+  const pair = [parent, sub]
+
+  // A bare (or mentioning) reply inside the thread rooted at $root.
+  function threadMsg(o: { sender: string; mentions?: string[] }) {
+    return {
+      type: 'm.room.message',
+      room_id: '!room1:example.com',
+      sender: o.sender,
+      event_id: '$evt',
+      content: {
+        msgtype: 'm.text',
+        body: 'reply',
+        'm.relates_to': { rel_type: 'm.thread', event_id: '$root' },
+        ...(o.mentions ? { 'm.mentions': { user_ids: o.mentions } } : {}),
+      },
+    }
+  }
+
+  function states(s: Partial<ThreadState>): Map<string, ThreadState> {
+    return new Map([['$root', { participants: [], rootMentions: [], callers: {}, ...s }]])
+  }
+
+  it("routes a sub's bare reply up to its caller (parent notified)", () => {
+    const matches = route(
+      threadMsg({ sender: '@sub:example.com' }),
+      pair,
+      states({ participants: ['parent'], callers: { sub: 'parent' } }),
+    )
+    expect(matches.map((m) => m.name)).toEqual(['parent'])
+  })
+
+  it('does NOT re-trigger a callee when its parent posts a bare reply (loop guard)', () => {
+    // parent is the sender; sub is its callee. parent has no caller of its own,
+    // so its bare reply routes to nobody — the loop dies here.
+    const matches = route(
+      threadMsg({ sender: '@parent:example.com' }),
+      pair,
+      states({ participants: ['parent', 'sub'], callers: { sub: 'parent' } }),
+    )
+    expect(matches).toEqual([])
+  })
+
+  it('an explicit @mention still re-engages the sub (rule 1 wins)', () => {
+    const matches = route(
+      threadMsg({ sender: '@parent:example.com', mentions: ['@sub:example.com'] }),
+      pair,
+      states({ participants: ['parent', 'sub'], callers: { sub: 'parent' } }),
+    )
+    expect(matches.map((m) => m.name)).toEqual(['sub'])
+  })
+
+  it('dedupes: a sub reply that also @mentions its caller triggers the caller once', () => {
+    const matches = route(
+      threadMsg({ sender: '@sub:example.com', mentions: ['@parent:example.com'] }),
+      pair,
+      states({ participants: ['parent'], callers: { sub: 'parent' } }),
+    )
+    expect(matches.map((m) => m.name)).toEqual(['parent'])
+  })
+
+  it('bubbles a 3-level chain one hop at a time (grandchild → child, not parent)', () => {
+    const child: AgentBinding = {
+      name: 'child',
+      userId: '@child:example.com',
+      rooms: [{ alias: '!room1:example.com' }],
+      trigger: 'mention',
+    }
+    const grand: AgentBinding = {
+      name: 'grand',
+      userId: '@grand:example.com',
+      rooms: [{ alias: '!room1:example.com' }],
+      trigger: 'mention',
+    }
+    const matches = route(
+      threadMsg({ sender: '@grand:example.com' }),
+      [parent, child, grand],
+      states({
+        participants: ['parent', 'child'],
+        callers: { child: 'parent', grand: 'child' },
+      }),
+    )
+    expect(matches.map((m) => m.name)).toEqual(['child'])
+  })
+
+  it('a human bare reply still continues with the most-recent-posting agent (unchanged)', () => {
+    const matches = route(
+      threadMsg({ sender: '@alice:example.com' }),
+      pair,
+      states({ participants: ['parent', 'sub'], callers: { sub: 'parent' } }),
+    )
+    expect(matches.map((m) => m.name)).toEqual(['sub'])
+  })
+
+  it('an agent with no caller (human-initiated) returns to nobody', () => {
+    const matches = route(
+      threadMsg({ sender: '@parent:example.com' }),
+      pair,
+      states({ participants: ['parent'], callers: {} }),
+    )
+    expect(matches).toEqual([])
+  })
+})

package/src/router.ts

@@ -33,6 +33,14 @@ export interface ThreadState {
   participants: string[]
   /** Agent names @mentioned in the thread root event (or subsequently). */
   rootMentions: string[]
+  /**
+   * Agent-to-agent call edges: sub-agent name → the agent that @mentioned
+   * (called) it in this thread. A sub's bare reply bubbles up to its caller;
+   * a caller never implicitly re-triggers its callee. Makes agent↔agent
+   * acknowledgement loops structurally impossible. See [[ZOD039]] §
+   * Implicit triggers → Directional continuation.
+   */
+  callers: Record<string, string>
 }
 
 interface MaybeEvent {
@@ -77,14 +85,24 @@ export function route(
       matches.push(a)
       continue
     }
-    // Implicit trigger in a thread: most-recent-poster, or root-mention
-    // inheritance if no agent has posted yet.
+    // Implicit trigger in a thread.
     if (threadState) {
-      const lastPoster = threadState.participants.at(-1)
-      if (lastPoster) {
-        if (lastPoster === a.name) matches.push(a)
-      } else if (threadState.rootMentions.includes(a.name)) {
-        matches.push(a)
+      const senderAgent = agents.find((x) => x.userId === event.sender)
+      if (senderAgent) {
+        // Agent reply = a "return": route only to the agent that called the
+        // sender (its caller), never to a callee. Directional continuation
+        // keeps agent↔agent handoffs from looping — the call graph is a tree
+        // rooted at the human, so returns only ever walk up.
+        if (threadState.callers[senderAgent.name] === a.name) matches.push(a)
+      } else {
+        // Human (or non-agent) follow-up: continue with the most-recent-posting
+        // agent, or inherit the root mention if no agent has posted yet.
+        const lastPoster = threadState.participants.at(-1)
+        if (lastPoster) {
+          if (lastPoster === a.name) matches.push(a)
+        } else if (threadState.rootMentions.includes(a.name)) {
+          matches.push(a)
+        }
       }
     }
   }

package/src/transport.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest'
 import { EventEmitter } from 'node:events'
-import { createMatrixTransport } from './transport.js'
+import { createMatrixTransport, rebuildThreadState } from './transport.js'
 
 function fakeRegistry() {
   let resolvePrompt: (() => void) | undefined
@@ -1683,3 +1683,109 @@ describe('ad-hoc bot invite declines', () => {
     expect(client.leaveRoom).not.toHaveBeenCalled()
   })
 })
+
+describe('directional agent-to-agent handoffs', () => {
+  const parentSub = [
+    {
+      name: 'parent',
+      userId: '@parent:example.com',
+      rooms: [{ alias: '!r:example.com' }],
+      trigger: 'mention' as const,
+    },
+    {
+      name: 'sub',
+      userId: '@sub:example.com',
+      rooms: [{ alias: '!r:example.com' }],
+      trigger: 'mention' as const,
+    },
+  ]
+
+  function makePairTransport() {
+    const { reg } = fakeRegistry()
+    const approvals = fakeApprovals()
+    const client = fakeClient()
+    // Resolve prompts immediately so runTurn completes and `participants` append.
+    reg.prompt.mockImplementation(async () => ({ stopReason: 'end_turn' as const }))
+    const transport = createMatrixTransport({
+      agents: reg as never,
+      approvals: approvals as never,
+      client: client as never,
+      bindings: parentSub,
+      hsToken: 'hs-secret',
+      botUserId: '@zooid:example.com',
+      drainQuietMs: 0,
+    })
+    return { transport, agents: reg, client }
+  }
+
+  // Post one m.room.message. Top-level unless `root` is given (then it's a
+  // thread reply on that root). `mentions` sets m.mentions.user_ids.
+  function post(
+    transport: ReturnType<typeof makePairTransport>['transport'],
+    o: { id: string; sender: string; root?: string; mentions?: string[] },
+  ) {
+    const content: Record<string, unknown> = { msgtype: 'm.text', body: 'x' }
+    if (o.mentions) content['m.mentions'] = { user_ids: o.mentions }
+    if (o.root) content['m.relates_to'] = { rel_type: 'm.thread', event_id: o.root }
+    return postTxn(transport.app, {
+      events: [
+        { type: 'm.room.message', event_id: o.id, room_id: '!r:example.com', sender: o.sender, content },
+      ],
+    })
+  }
+
+  it("a parent's ack does not re-trigger the sub, but the sub's reply notifies the parent", async () => {
+    const { transport, agents } = makePairTransport()
+
+    // 1. Human @mentions parent (top-level) → thread root is $root.
+    await post(transport, { id: '$root', sender: '@alice:example.com', mentions: ['@parent:example.com'] })
+    await settleTurn()
+
+    // 2. Parent replies in-thread @mentioning sub → sub is called; caller[sub]=parent.
+    await post(transport, { id: '$p1', sender: '@parent:example.com', root: '$root', mentions: ['@sub:example.com'] })
+    await settleTurn()
+    expect(agents.ensureSession).toHaveBeenCalledWith('sub', '$root', '!r:example.com')
+
+    agents.ensureSession.mockClear()
+
+    // 3. Sub replies bare → bubbles UP to its caller (parent), nobody else.
+    await post(transport, { id: '$s1', sender: '@sub:example.com', root: '$root' })
+    await settleTurn()
+    expect(agents.ensureSession).toHaveBeenCalledWith('parent', '$root', '!r:example.com')
+    expect(agents.ensureSession).not.toHaveBeenCalledWith('sub', '$root', '!r:example.com')
+
+    agents.ensureSession.mockClear()
+
+    // 4. Parent replies bare (the "ack") → parent has no caller → routes to NOBODY.
+    //    This is the loop guard: sub is NOT re-triggered.
+    await post(transport, { id: '$p2', sender: '@parent:example.com', root: '$root' })
+    await settleTurn()
+    expect(agents.ensureSession).not.toHaveBeenCalled()
+  })
+
+  it('rebuildThreadState reconstructs caller[] from the timeline after a restart', async () => {
+    const client = {
+      // root: human @mentions parent (no caller — human sender).
+      fetchEvent: vi.fn(async () => ({
+        type: 'm.room.message',
+        sender: '@alice:example.com',
+        content: { 'm.mentions': { user_ids: ['@parent:example.com'] } },
+      })),
+      // thread: parent @mentions sub (caller[sub]=parent), then sub replies bare.
+      fetchThreadRelations: vi.fn(async () => ({
+        chunk: [
+          {
+            type: 'm.room.message',
+            sender: '@parent:example.com',
+            content: { 'm.mentions': { user_ids: ['@sub:example.com'] } },
+          },
+          { type: 'm.room.message', sender: '@sub:example.com', content: { body: 'ack' } },
+        ],
+      })),
+    }
+    const state = await rebuildThreadState(client as never, '!r:example.com', '$root', parentSub)
+    expect(state.callers).toEqual({ sub: 'parent' })
+    expect(state.rootMentions).toEqual(['parent', 'sub'])
+    expect(state.participants).toEqual(['parent', 'sub'])
+  })
+})

package/src/transport.ts

@@ -670,14 +670,16 @@ export function createMatrixTransport(opts: CreateMatrixTransportOptions) {
     if (matches.length > 0 && promotedRoot) {
       let st = threadStates.get(promotedRoot)
       if (!st) {
-        st = { participants: [], rootMentions: [] }
+        st = { participants: [], rootMentions: [], callers: {} }
         threadStates.set(promotedRoot, st)
       }
       const msgMentions = new Set(extractMentions(evt as never))
+      const senderAgent = bindings.find((b) => b.userId === evt.sender)
       for (const a of bindings) {
-        if (msgMentions.has(a.userId) && !st.rootMentions.includes(a.name)) {
-          st.rootMentions.push(a.name)
-        }
+        if (!msgMentions.has(a.userId)) continue
+        if (!st.rootMentions.includes(a.name)) st.rootMentions.push(a.name)
+        // Call edge: the (agent) sender is the caller of every agent it @mentions.
+        if (senderAgent && a.name !== senderAgent.name) st.callers[a.name] = senderAgent.name
       }
     }
     for (const a of matches) {
@@ -687,7 +689,7 @@ export function createMatrixTransport(opts: CreateMatrixTransportOptions) {
           if (!promotedRoot) return
           let st = threadStates.get(promotedRoot)
           if (!st) {
-            st = { participants: [], rootMentions: [] }
+            st = { participants: [], rootMentions: [], callers: {} }
             threadStates.set(promotedRoot, st)
           }
           if (st.participants.at(-1) !== a.name) st.participants.push(a.name)
@@ -932,7 +934,7 @@ export async function rebuildThreadState(
   rootEventId: string,
   bindings: AgentBinding[],
 ): Promise<ThreadState> {
-  const state: ThreadState = { participants: [], rootMentions: [] }
+  const state: ThreadState = { participants: [], rootMentions: [], callers: {} }
   // Impersonate an agent that's actually a member of this room (AS reads
   // require room membership). Falling through to the first binding would
   // 403 if that agent never joined the target room.
@@ -942,10 +944,12 @@ export async function rebuildThreadState(
   const root = await client.fetchEvent(roomId, rootEventId, asUser)
   if (root) {
     const rootMentions = new Set(extractMentions(root as never))
+    const rootSender = (root as { sender?: string }).sender
+    const rootSenderAgent = rootSender ? bindings.find((b) => b.userId === rootSender) : undefined
     for (const a of bindings) {
-      if (rootMentions.has(a.userId) && !state.rootMentions.includes(a.name)) {
-        state.rootMentions.push(a.name)
-      }
+      if (!rootMentions.has(a.userId)) continue
+      if (!state.rootMentions.includes(a.name)) state.rootMentions.push(a.name)
+      if (rootSenderAgent && a.name !== rootSenderAgent.name) state.callers[a.name] = rootSenderAgent.name
     }
   }
 
@@ -957,15 +961,16 @@ export async function rebuildThreadState(
   // Also seed root-mentions from any subsequent agent @mentions in the thread.
   for (const ev of thread) {
     const mentions = new Set(extractMentions(ev as never))
+    const evSender = (ev as { sender?: string }).sender
+    const evSenderAgent = evSender ? bindings.find((b) => b.userId === evSender) : undefined
     for (const a of bindings) {
-      if (mentions.has(a.userId) && !state.rootMentions.includes(a.name)) {
-        state.rootMentions.push(a.name)
-      }
+      if (!mentions.has(a.userId)) continue
+      if (!state.rootMentions.includes(a.name)) state.rootMentions.push(a.name)
+      if (evSenderAgent && a.name !== evSenderAgent.name) state.callers[a.name] = evSenderAgent.name
     }
-    const sender = (ev as { sender?: string }).sender
     const type = (ev as { type?: string }).type
-    if (type === 'm.room.message' && sender) {
-      const a = bindings.find((b) => b.userId === sender)
+    if (type === 'm.room.message' && evSender) {
+      const a = bindings.find((b) => b.userId === evSender)
       if (a && state.participants.at(-1) !== a.name) state.participants.push(a.name)
     }
   }