zooid 0.14.1 → 0.15.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   buildAcpRegistry
-} from "./chunk-R5S26T7B.js";
+} from "./chunk-35IKQPC5.js";
 export {
   buildAcpRegistry
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zooid",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "An open-source, self-hostable chat app for collaborating with AI agents alongside your team. Any model, any CLI.",
   "type": "module",
   "license": "MIT",
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "zooid": {
-    "webVersion": "0.12.0"
+    "webVersion": "0.12.1"
   },
   "engines": {
     "node": ">=22"
@@ -43,14 +43,14 @@
     "tar": "^7.5.16",
     "web-push": "^3.6.7",
     "yaml": "^2.5.0",
-    "@zooid/context-mcp": "^0.14.1",
-    "@zooid/acp-client": "^0.14.1",
-    "@zooid/transport-matrix": "^0.14.1",
-    "@zooid/runtime-docker": "^0.14.1",
-    "@zooid/core": "^0.14.1",
-    "@zooid/runtime-local": "^0.14.1",
-    "@zooid/transport-http": "^0.14.1",
-    "@zooid/pi-extension": "^0.13.1"
+    "@zooid/acp-client": "^0.15.0",
+    "@zooid/core": "^0.15.0",
+    "@zooid/context-mcp": "^0.15.0",
+    "@zooid/runtime-docker": "^0.15.0",
+    "@zooid/pi-extension": "^0.13.2",
+    "@zooid/runtime-local": "^0.15.0",
+    "@zooid/transport-matrix": "^0.15.0",
+    "@zooid/transport-http": "^0.15.0"
   },
   "devDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",

package/src/daemon/start-daemon.ts

@@ -322,6 +322,7 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
           resolveRoom,
           ensureBot,
           sendMessage: (m) => client.sendMessage(m),
+          getJoinedMembers: (roomId, asUserId) => client.getJoinedMembers(roomId, asUserId),
         })
         for (const [name] of webhookTriggers) {
           console.log(`[webhook] POST ${WEBHOOK_ROUTE_PREFIX}/${name}`)
@@ -383,6 +384,7 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
         resolveRoom,
         ensureBot,
         sendMessage: (m) => client.sendMessage(m),
+        getJoinedMembers: (roomId, asUserId) => client.getJoinedMembers(roomId, asUserId),
       })
       const scheduled = Object.values(config.triggers).filter((t) => t.schedule).length
       if (scheduled > 0) console.log(`[trigger] scheduled ${scheduled} trigger(s)`)
@@ -424,6 +426,7 @@ export async function startDaemon(opts: StartDaemonOpts = {}): Promise<DaemonHan
           spaceRoomId,
           asUserId,
           getAgents: () => bindings,
+          stateKey: matrix.transport.workstation ?? '',
         })
         console.log(`[matrix] published dev.zooid.workforce (${bindings.length} agents)`)
         void publisher

package/src/daemon/trigger-runner.mxid.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi } from 'vitest'
+import { fireTrigger } from './trigger-runner.js'
+
+const deps = (mention: string, agentUserIds: Record<string, string>) => {
+  const sendMessage = vi.fn(async () => ({ event_id: '$1' }))
+  return {
+    sendMessage,
+    call: () =>
+      fireTrigger({
+        name: 'standup',
+        as: '@cloud.cron:zooid.zoon.eco',
+        message: { room: '#product:zooid.zoon.eco', mention, text: 'Morning standup.' },
+        agentUserIds,
+        resolveRoom: async () => '!room:zooid.zoon.eco',
+        ensureBot: async () => {},
+        sendMessage,
+      }),
+  }
+}
+
+describe('fireTrigger addressing', () => {
+  it('uses an MXID mention verbatim, with no local lookup', async () => {
+    const { call, sendMessage } = deps('@ori-macbook.cpo:zooid.zoon.eco', {})
+    await call()
+    expect(sendMessage.mock.calls[0]![0].content['m.mentions']).toEqual({
+      user_ids: ['@ori-macbook.cpo:zooid.zoon.eco'],
+    })
+  })
+
+  it('resolves a bare name through the local agent map', async () => {
+    const { call, sendMessage } = deps('scout', { scout: '@cloud.scout:zooid.zoon.eco' })
+    await call()
+    expect(sendMessage.mock.calls[0]![0].content['m.mentions']).toEqual({
+      user_ids: ['@cloud.scout:zooid.zoon.eco'],
+    })
+  })
+
+  it('stamps dev.zooid.trigger with the trigger name and firing time', async () => {
+    const { call, sendMessage } = deps('@ori-macbook.cpo:zooid.zoon.eco', {})
+    const before = Date.now()
+    await call()
+    const stamp = sendMessage.mock.calls[0]![0].content['dev.zooid.trigger'] as {
+      name: string
+      fired_at: number
+      ttl_ms?: number
+    }
+    expect(stamp.name).toBe('standup')
+    expect(stamp.fired_at).toBeGreaterThanOrEqual(before)
+  })
+
+  it('skips a bare name with no local binding rather than posting', async () => {
+    const { call, sendMessage } = deps('scout', {})
+    await call()
+    expect(sendMessage).not.toHaveBeenCalled()
+  })
+})
+
+describe('fireTrigger mention rendering', () => {
+  it('leads the body with the MXID so the room can see who was addressed', async () => {
+    const { call, sendMessage } = deps('@ori-macbook.cpo:zooid.zoon.eco', {})
+    await call()
+    expect(sendMessage.mock.calls[0]![0].content.body).toBe(
+      '@ori-macbook.cpo:zooid.zoon.eco Morning standup.',
+    )
+  })
+
+  it('sends no HTML — the client pills a bare MXID, and markup would need escaping', async () => {
+    const { call, sendMessage } = deps('@ori-macbook.cpo:zooid.zoon.eco', {})
+    await call()
+    const c = sendMessage.mock.calls[0]![0].content
+    expect(c.format).toBeUndefined()
+    expect(c.formatted_body).toBeUndefined()
+  })
+
+  it('warns when the addressed user is not in the room', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const sendMessage = vi.fn(async () => ({ event_id: '$1' }))
+    await fireTrigger({
+      name: 'standup',
+      as: '@cloud.cron:zooid.zoon.eco',
+      message: {
+        room: '#product:zooid.zoon.eco',
+        mention: '@ori-macbook.cpo:zooid.zoon.eco',
+        text: 'Morning standup.',
+      },
+      agentUserIds: {},
+      resolveRoom: async () => '!p:zooid.zoon.eco',
+      ensureBot: async () => {},
+      sendMessage,
+      getJoinedMembers: async () => ({ joined: { '@cloud.product:zooid.zoon.eco': {} } }),
+    })
+    // posted anyway — the agent may join before it expires
+    expect(sendMessage).toHaveBeenCalledTimes(1)
+    expect(warn).toHaveBeenCalledWith(expect.stringMatching(/not in .*#product/))
+    warn.mockRestore()
+  })
+
+  it('warns only once across repeated fires at the same absent target', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const getJoinedMembers = vi.fn(async () => ({ joined: {} }))
+    // A distinct trigger name from the previous test: `warnedTargets` is
+    // module-level (dedup lasts the daemon's process lifetime, per spec), so
+    // reusing "standup" here would find the key already warned and this
+    // test's own two calls would produce zero fresh warnings.
+    const fire = () =>
+      fireTrigger({
+        name: 'standup-repeat',
+        as: '@cloud.cron:zooid.zoon.eco',
+        message: {
+          room: '#product:zooid.zoon.eco',
+          mention: '@ori-macbook.cpo:zooid.zoon.eco',
+          text: 'Morning standup.',
+        },
+        agentUserIds: {},
+        resolveRoom: async () => '!p:zooid.zoon.eco',
+        ensureBot: async () => {},
+        sendMessage: async () => ({ event_id: '$1' }),
+        getJoinedMembers,
+      })
+    await fire()
+    await fire()
+    expect(warn).toHaveBeenCalledTimes(1)
+    warn.mockRestore()
+  })
+
+  it('leaves interpolated webhook text verbatim in the body', async () => {
+    const sendMessage = vi.fn(async () => ({ event_id: '$1' }))
+    await fireTrigger({
+      name: 'triage',
+      as: '@cloud.hook:zooid.zoon.eco',
+      message: {
+        room: '#product:zooid.zoon.eco',
+        mention: '@cloud.product:zooid.zoon.eco',
+        text: 'Triage "<img src=x> & more".',
+      },
+      agentUserIds: {},
+      resolveRoom: async () => '!r:zooid.zoon.eco',
+      ensureBot: async () => {},
+      sendMessage,
+    })
+    const c = sendMessage.mock.calls[0]![0].content
+    expect(c.body).toBe('@cloud.product:zooid.zoon.eco Triage "<img src=x> & more".')
+    expect(c.formatted_body).toBeUndefined()
+  })
+})

package/src/daemon/trigger-runner.test.ts

@@ -12,7 +12,7 @@ const deps = (over: Record<string, unknown> = {}) => ({
   name: 'image-currency',
   as: '@cron:example.org',
   message,
-  agentUserId: '@architect:example.org',
+  agentUserIds: { architect: '@architect:example.org' },
   resolveRoom: vi.fn(async () => '!room:example.org'),
   ensureBot: vi.fn(async () => {}),
   sendMessage: vi.fn(async () => ({ event_id: '$1' })),
@@ -20,14 +20,14 @@ const deps = (over: Record<string, unknown> = {}) => ({
 })
 
 describe('fireTrigger', () => {
-  it('posts text verbatim as the trigger bot user', async () => {
+  it('posts text as the trigger bot user, led by a visible mention', async () => {
     const d = deps()
     await fireTrigger(d as never)
     expect(d.sendMessage).toHaveBeenCalledTimes(1)
     const call = (d.sendMessage as ReturnType<typeof vi.fn>).mock.calls[0][0]
     expect(call.roomId).toBe('!room:example.org')
     expect(call.asUserId).toBe('@cron:example.org')
-    expect(call.content.body).toBe('Check the pinned agent CLI versions.')
+    expect(call.content.body).toBe('@architect:example.org Check the pinned agent CLI versions.')
     expect(call.content.msgtype).toBe('m.text')
   })
 
@@ -36,7 +36,6 @@ describe('fireTrigger', () => {
     await fireTrigger(d as never)
     const content = (d.sendMessage as ReturnType<typeof vi.fn>).mock.calls[0][0].content
     expect(content['m.mentions']).toEqual({ user_ids: ['@architect:example.org'] })
-    expect(content.body).not.toContain('@architect')
   })
 
   it('posts at the top level, never into a thread — runTurn makes each firing a new root', async () => {

package/src/daemon/trigger-runner.ts

@@ -1,10 +1,12 @@
 import type { TriggerMessage } from '@zooid/core'
+import { buildMentionContent } from '@zooid/transport-matrix'
 
 export interface FireTriggerDeps {
   name: string
   as: string
   message: TriggerMessage
-  agentUserId: string
+  /** Local agent name → MXID. A `mention:` that is already an MXID bypasses this. */
+  agentUserIds: Record<string, string>
   resolveRoom: (room: string) => Promise<string | null>
   ensureBot: (asUserId: string, roomId: string) => Promise<void>
   sendMessage: (input: {
@@ -12,11 +14,29 @@ export interface FireTriggerDeps {
     asUserId: string
     content: { msgtype: string; body: string; [k: string]: unknown }
   }) => Promise<{ event_id: string }>
+  /**
+   * Optional: enables the [[ZOD081]] §Design 6 "nobody is listening" warning.
+   * Omitted in tests that don't care about it — the check is then skipped
+   * silently, never a hard requirement to fire.
+   */
+  getJoinedMembers?: (roomId: string, asUserId: string) => Promise<{ joined: Record<string, unknown> }>
 }
 
+// Module-level so a daily trigger against an off laptop logs once per daemon
+// run, not once a day. Keyed by trigger name + target so distinct triggers
+// (or targets) each get their own first warning.
+const warnedTargets = new Set<string>()
+
 export async function fireTrigger(deps: FireTriggerDeps): Promise<void> {
-  const { name, as, message, agentUserId, resolveRoom, ensureBot, sendMessage } = deps
+  const { name, as, message, agentUserIds, resolveRoom, ensureBot, sendMessage, getJoinedMembers } = deps
   try {
+    const target = message.mention.startsWith('@')
+      ? message.mention
+      : agentUserIds[message.mention]
+    if (!target) {
+      console.warn(`[trigger:${name}] unknown agent "${message.mention}" — skipping`)
+      return
+    }
     const roomId = await resolveRoom(message.room)
     if (!roomId) {
       console.warn(`[trigger:${name}] cannot resolve room ${message.room} — skipping`)
@@ -27,13 +47,31 @@ export async function fireTrigger(deps: FireTriggerDeps): Promise<void> {
       roomId,
       asUserId: as,
       content: {
-        msgtype: 'm.text',
-        body: message.text,
-        // Structural mention: routes deterministically AND disarms the raw-body
-        // fallback in extractMentions, which only fires when nothing matched.
-        'm.mentions': { user_ids: [agentUserId] },
+        ...buildMentionContent({ userId: target, text: message.text, msgtype: 'm.text' }),
+        'dev.zooid.trigger': {
+          name,
+          fired_at: Date.now(),
+          ...(message.ttlMs !== undefined ? { ttl_ms: message.ttlMs } : {}),
+        },
       },
     })
+
+    // Post first, warn second: an absent target isn't a lost message —
+    // catch-up may still deliver it if that agent joins before it expires.
+    // Membership, not registration: router.ts routes only to agents joined
+    // to the room, so an agent that exists but isn't in the room misses the
+    // firing exactly as an unregistered one does.
+    if (getJoinedMembers) {
+      const { joined } = await getJoinedMembers(roomId, as)
+      const key = `${name}|${target}`
+      if (!(target in joined) && !warnedTargets.has(key)) {
+        warnedTargets.add(key)
+        console.warn(
+          `[trigger:${name}] ${target} is not in ${message.room} — nothing will handle this ` +
+            `unless that agent joins before the message expires`,
+        )
+      }
+    }
   } catch (err) {
     // Never throw: one bad firing must not take down the scheduler.
     console.warn(`[trigger:${name}] failed:`, (err as Error).message)

package/src/daemon/trigger-scheduler.ts

@@ -8,6 +8,7 @@ export interface StartTriggerSchedulerDeps {
   resolveRoom: FireTriggerDeps['resolveRoom']
   ensureBot: FireTriggerDeps['ensureBot']
   sendMessage: FireTriggerDeps['sendMessage']
+  getJoinedMembers?: FireTriggerDeps['getJoinedMembers']
 }
 
 export interface TriggerSchedulerHandle {
@@ -29,19 +30,23 @@ export function validateCron(name: string, expr: string): void {
 }
 
 export function startTriggerScheduler(deps: StartTriggerSchedulerDeps): TriggerSchedulerHandle {
-  const { triggers, agentUserIds, resolveRoom, ensureBot, sendMessage } = deps
+  const { triggers, agentUserIds, resolveRoom, ensureBot, sendMessage, getJoinedMembers } = deps
   const jobs: Cron[] = []
 
   for (const [name, trigger] of Object.entries(triggers)) {
     if (!trigger.schedule) continue
     const job = new Cron(trigger.schedule, () => {
       for (const message of trigger.messages) {
-        const agentUserId = agentUserIds[message.mention]
-        if (!agentUserId) {
-          console.warn(`[trigger:${name}] unknown agent "${message.mention}" — skipping`)
-          continue
-        }
-        void fireTrigger({ name, as: trigger.as, message, agentUserId, resolveRoom, ensureBot, sendMessage })
+        void fireTrigger({
+          name,
+          as: trigger.as,
+          message,
+          agentUserIds,
+          resolveRoom,
+          ensureBot,
+          sendMessage,
+          getJoinedMembers,
+        })
       }
     })
     jobs.push(job)

package/src/daemon/webhook-routes.ts

@@ -84,6 +84,7 @@ export interface WebhookDeps {
   resolveRoom: FireTriggerDeps['resolveRoom']
   ensureBot: FireTriggerDeps['ensureBot']
   sendMessage: FireTriggerDeps['sendMessage']
+  getJoinedMembers?: FireTriggerDeps['getJoinedMembers']
 }
 
 /**
@@ -166,20 +167,15 @@ async function handleDelivery(
     for (const message of trigger.messages) {
       if (message.match !== undefined && !evaluateMatch(message.match, ctx)) continue
 
-      const agentUserId = deps.agentUserIds[message.mention]
-      if (!agentUserId) {
-        console.warn(`[webhook:${name}] unknown agent "${message.mention}" — skipping`)
-        continue
-      }
-
       await fireTrigger({
         name,
         as: trigger.as,
         message: { ...message, text: renderTemplate(message.text, ctx) },
-        agentUserId,
+        agentUserIds: deps.agentUserIds,
         resolveRoom: deps.resolveRoom,
         ensureBot: deps.ensureBot,
         sendMessage: deps.sendMessage,
+        getJoinedMembers: deps.getJoinedMembers,
       })
     }
   } catch (err) {