cross-agent-teams-mcp 0.2.0

package/src/mcp/register-codex-self.ts

@@ -0,0 +1,276 @@
+import { RegisterAgentService } from './register-agent.js'
+import {
+  JsonRpcSocketClient,
+  defaultWebSocketFactory,
+  describeError,
+  resolveAuthToken,
+  safeClose,
+  type CodexWebSocketFactory,
+  type JsonRpcResponse,
+} from './codex-appserver-rpc.js'
+
+export interface RegisterCodexSelfInput {
+  connection_id: string
+  name: string
+  model?: string
+  role?: string
+  team?: string
+  project_dir?: string
+  ws_url?: string
+  auth_token_ref?: string
+  thread_id?: string
+  tmux_pane_id?: string
+  cwd?: string
+  tty?: string
+  title_contains?: string
+}
+
+export type RegisterCodexSelfResult =
+  | {
+      agent_id: string
+      team: string
+      thread_id: string
+      ws_url: string
+    }
+  | { error: 'agent_id_collision' }
+  | { error: 'invalid_delivery'; reason: string }
+  | { error: 'claude_ui_pid_requires_channel_proxy' }
+  | { error: 'missing_auth_token'; detail: { ref: string } }
+  | { error: 'unsupported_client'; detail: { expected: 'codex'; reason: 'codex_appserver_unreachable' | 'codex_protocol_unavailable'; ws_url: string; cause?: unknown } }
+  | { error: 'codex_connect_failed'; detail?: unknown }
+  | { error: 'codex_initialize_failed'; detail?: unknown }
+  | { error: 'codex_loaded_list_failed'; detail?: unknown }
+  | { error: 'no_loaded_threads'; detail?: unknown }
+  | { error: 'thread_id_required'; detail: { ws_url: string; thread_ids: string[] } }
+  | { error: 'codex_resume_failed'; detail?: unknown }
+
+export interface RegisterCodexSelfDeps {
+  env?: NodeJS.ProcessEnv
+  webSocketFactory?: CodexWebSocketFactory
+}
+
+type RpcErrorCode =
+  | 'codex_initialize_failed'
+  | 'codex_loaded_list_failed'
+  | 'codex_resume_failed'
+
+const DEFAULT_CODEX_WS_URL = 'ws://127.0.0.1:8799'
+
+async function requestStep(
+  client: JsonRpcSocketClient,
+  method: string,
+  params: unknown,
+  errorCode: RpcErrorCode
+): Promise<{ ok: JsonRpcResponse } | { error: RpcErrorCode; detail: unknown }> {
+  try {
+    const response = await client.request(method, params)
+    if (response.error) return { error: errorCode, detail: response.error }
+    return { ok: response }
+  } catch (error) {
+    return { error: errorCode, detail: describeError(error) }
+  }
+}
+
+function resolveWsUrl(
+  input: RegisterCodexSelfInput,
+  env: NodeJS.ProcessEnv
+): string {
+  const explicit = input.ws_url?.trim()
+  if (explicit) return explicit
+  const fromEnv = env.CROSS_AGENT_TEAMS_CODEX_WS_URL?.trim()
+  if (fromEnv) return fromEnv
+  return DEFAULT_CODEX_WS_URL
+}
+
+function extractThreadIds(response: JsonRpcResponse): string[] {
+  const result = response.result as { data?: unknown } | undefined
+  if (!result || !Array.isArray(result.data)) return []
+  return result.data.filter((value): value is string => typeof value === 'string')
+}
+
+function trimToUndefined(value: string | undefined): string | undefined {
+  const trimmed = value?.trim()
+  return trimmed ? trimmed : undefined
+}
+
+export class RegisterCodexSelfService {
+  constructor(
+    private readonly registerSvc: RegisterAgentService,
+    private readonly deps: RegisterCodexSelfDeps = {}
+  ) {}
+
+  async register(
+    input: RegisterCodexSelfInput
+  ): Promise<RegisterCodexSelfResult> {
+    const env = this.deps.env ?? process.env
+    const wsUrl = resolveWsUrl(input, env)
+    const token = resolveAuthToken(input.auth_token_ref, env)
+    if ('error' in token) return token
+    const headers = token.ok === undefined
+      ? undefined
+      : { Authorization: `Bearer ${token.ok}` }
+
+    let ws
+    try {
+      ws = (this.deps.webSocketFactory ?? defaultWebSocketFactory)({
+        url: wsUrl,
+        headers,
+      })
+    } catch (error) {
+      return {
+        error: 'unsupported_client',
+        detail: {
+          expected: 'codex',
+          reason: 'codex_appserver_unreachable',
+          ws_url: wsUrl,
+          cause: describeError(error),
+        },
+      }
+    }
+
+    const client = new JsonRpcSocketClient(ws)
+    try {
+      await client.waitForOpen()
+
+      const init = await requestStep(
+        client,
+        'initialize',
+        {
+          clientInfo: {
+            name: 'cross-agent-teams-mcp',
+            title: null,
+            version: '0.1.0',
+          },
+          capabilities: {
+            experimentalApi: true,
+            optOutNotificationMethods: null,
+          },
+        },
+        'codex_initialize_failed'
+      )
+      if ('error' in init) {
+        return {
+          error: 'unsupported_client',
+          detail: {
+            expected: 'codex',
+            reason: 'codex_protocol_unavailable',
+            ws_url: wsUrl,
+            cause: init.detail,
+          },
+        }
+      }
+
+      client.notify('initialized')
+
+      const explicitThreadId = trimToUndefined(input.thread_id)
+      let threadId = explicitThreadId
+
+      if (!threadId) {
+        const list = await requestStep(
+          client,
+          'thread/loaded/list',
+          { cursor: null, limit: 20 },
+          'codex_loaded_list_failed'
+        )
+        if ('error' in list) return list
+
+        const threadIds = extractThreadIds(list.ok)
+        if (threadIds.length === 0) {
+          return {
+            error: 'no_loaded_threads',
+            detail: { ws_url: wsUrl },
+          }
+        }
+
+        const liveThreadIds: string[] = []
+        const failures: Array<{ thread_id: string; detail: unknown }> = []
+        for (const candidateThreadId of threadIds) {
+          const resume = await requestStep(
+            client,
+            'thread/resume',
+            {
+              threadId: candidateThreadId,
+              persistExtendedHistory: false,
+            },
+            'codex_resume_failed'
+          )
+          if ('error' in resume) {
+            failures.push({ thread_id: candidateThreadId, detail: resume.detail })
+            continue
+          }
+          liveThreadIds.push(candidateThreadId)
+        }
+
+        if (liveThreadIds.length === 0) {
+          return {
+            error: 'codex_resume_failed',
+            detail: failures,
+          }
+        }
+
+        return {
+          error: 'thread_id_required',
+          detail: {
+            ws_url: wsUrl,
+            thread_ids: liveThreadIds,
+          },
+        }
+      }
+
+      const resume = await requestStep(
+        client,
+        'thread/resume',
+        {
+          threadId,
+          persistExtendedHistory: false,
+        },
+        'codex_resume_failed'
+      )
+      if ('error' in resume) {
+        return {
+          error: 'codex_resume_failed',
+          detail: { thread_id: threadId, cause: resume.detail },
+        }
+      }
+
+      const tmuxPaneId = trimToUndefined(input.tmux_pane_id)
+
+      const result = this.registerSvc.register({
+        connection_id: input.connection_id,
+        client: 'codex',
+        model: input.model ?? 'codex',
+        name: input.name,
+        role: input.role,
+        team: input.team,
+        project_dir: input.project_dir,
+        tmux_pane_id: tmuxPaneId,
+        delivery: {
+          kind: 'codex-appserver',
+          thread_id: threadId,
+          ws_url: wsUrl,
+          ...(input.auth_token_ref === undefined
+            ? {}
+            : { auth_token_ref: input.auth_token_ref }),
+        },
+      })
+      if ('error' in result) return result
+      return {
+        ...result,
+        thread_id: threadId,
+        ws_url: wsUrl,
+      }
+    } catch (error) {
+      return {
+        error: 'unsupported_client',
+        detail: {
+          expected: 'codex',
+          reason: 'codex_appserver_unreachable',
+          ws_url: wsUrl,
+          cause: describeError(error),
+        },
+      }
+    } finally {
+      safeClose(ws)
+    }
+  }
+}

package/src/mcp/register-contract.ts

@@ -0,0 +1,60 @@
+import type Database from 'better-sqlite3'
+import type { AgentsRepo } from '../storage/agents-repo.js'
+import type { EventsOutbox } from '../storage/events-outbox.js'
+import { diffSchema, type ContractDiff } from '../lib/schema-diff.js'
+
+export interface RegisterContractMeta {
+  team: string
+  event_id: number
+  diff: ContractDiff | null
+}
+
+export type RegisterContractResult =
+  | { name: string; version: number; diff?: ContractDiff; _meta?: RegisterContractMeta }
+  | { error: 'unknown_agent' | 'invalid_format' }
+
+export class RegisterContractService {
+  constructor(
+    private db: Database.Database,
+    private agents: AgentsRepo,
+    private events: EventsOutbox
+  ) {}
+
+  register(args: {
+    caller: string; name: string; schema: Record<string, unknown>;
+    format?: 'jsonschema'; note?: string
+  }): RegisterContractResult {
+    const caller = this.agents.findById(args.caller)
+    if (!caller) return { error: 'unknown_agent' }
+    const format = args.format ?? 'jsonschema'
+    if (format !== 'jsonschema') return { error: 'invalid_format' }
+
+    // better-sqlite3's .transaction() wraps BEGIN DEFERRED by default. We need IMMEDIATE
+    // so multiple writers serialize cleanly. Use a raw BEGIN IMMEDIATE.
+    const txFn = this.db.transaction((): RegisterContractResult => {
+      const prev = this.db.prepare(
+        `SELECT schema, version FROM contracts WHERE team=? AND name=? ORDER BY version DESC LIMIT 1`
+      ).get(caller.team, args.name) as { schema: string; version: number } | undefined
+      const version = prev ? prev.version + 1 : 1
+      const now = new Date().toISOString()
+      this.db.prepare(
+        `INSERT INTO contracts (team, name, version, format, schema, note, registered_by, registered_at)
+         VALUES (?,?,?,?,?,?,?,?)`
+      ).run(caller.team, args.name, version, format, JSON.stringify(args.schema), args.note ?? null, args.caller, now)
+      let diff: ContractDiff | undefined
+      if (prev) diff = diffSchema(JSON.parse(prev.schema), args.schema as any)
+      const event_id = this.events.append({
+        from_team: caller.team,
+        to_team: caller.team,
+        event_type: 'contract_registered',
+        actor_agent_id: args.caller,
+        payload: { name: args.name, version, diff: diff ?? null }
+      })
+      const meta: RegisterContractMeta = { team: caller.team, event_id, diff: diff ?? null }
+      return prev
+        ? { name: args.name, version, diff: diff!, _meta: meta }
+        : { name: args.name, version, _meta: meta }
+    })
+    return txFn.immediate()
+  }
+}

package/src/mcp/send-message.ts

@@ -0,0 +1,159 @@
+import type Database from 'better-sqlite3'
+import { randomUUID } from 'node:crypto'
+import type { AgentsRepo } from '../storage/agents-repo.js'
+import type { EventsOutbox } from '../storage/events-outbox.js'
+import type { AutoPokeSkipReason, FanoutDeps } from './auto-poke-fanout.js'
+import { parseDeliveryRow, type DeliverySpec } from '../lib/delivery-spec.js'
+import { runFanoutWithRetry } from './fanout-with-retry.js'
+import { recordInitialDeliveryStatuses } from './delivery-status.js'
+
+export type { AutoPokeFn, AutoPokeSkipReason } from './auto-poke-fanout.js'
+
+export type SendMessageDeps = FanoutDeps
+
+export interface SendInput {
+  from: string
+  to_agent_id?: string
+  to_agent_name?: string
+  to_team?: string
+  subject?: string
+  body: string
+  auto_poke?: boolean
+  need_reply?: boolean
+}
+
+interface SuccessResult {
+  message_id: string
+  event_id: number
+  recipients: string[]
+  poked: boolean
+  poke_skip_reasons?: Array<{ agent_id: string; reason: AutoPokeSkipReason }>
+  retry_scheduled: boolean
+  retry_delays_s?: number[]
+}
+
+export type SendResult =
+  | SuccessResult
+  | { error: 'unknown_recipient' }
+  | { error: 'ambiguous_recipient' }
+  | { error: 'missing_recipient' }
+
+interface RecipientPokeRow {
+  agent_id: string
+  tmux_pane_id: string | null
+  delivery: DeliverySpec
+}
+
+interface RecipientLookupRow {
+  agent_id: string
+  team: string
+  tmux_pane_id: string | null
+  delivery_kind: string
+  delivery_payload: string | null
+}
+
+export class SendMessageService {
+  constructor(
+    private db: Database.Database,
+    private agents: AgentsRepo,
+    private events: EventsOutbox,
+    private deps: SendMessageDeps = {}
+  ) {}
+
+  async send(input: SendInput): Promise<SendResult> {
+    const hasId = typeof input.to_agent_id === 'string' && input.to_agent_id.length > 0
+    const hasName = typeof input.to_agent_name === 'string' && input.to_agent_name.length > 0
+    if (!hasId && !hasName) return { error: 'missing_recipient' }
+    if (hasId && hasName) return { error: 'ambiguous_recipient' }
+    const fromRow = this.agents.findById(input.from)
+    if (!fromRow) return { error: 'unknown_recipient' }
+    const fromTeam = fromRow.team
+    const toTeam = input.to_team ?? fromTeam
+
+    let resolvedId: string
+    if (hasId) {
+      resolvedId = input.to_agent_id!
+    } else {
+      const hit = this.agents.findByIdentity({ team: toTeam, name: input.to_agent_name! })
+      if (!hit) return { error: 'unknown_recipient' }
+      resolvedId = hit.agent_id
+    }
+
+    const rcpt = this.db.prepare(
+      `SELECT
+         agent_id,
+         team,
+         tmux_pane_id,
+         delivery_kind,
+         delivery_payload
+       FROM agents
+       WHERE agent_id=?`
+    )
+      .get(resolvedId) as RecipientLookupRow | undefined
+    if (!rcpt || rcpt.team !== toTeam) return { error: 'unknown_recipient' }
+    const recipientRow: RecipientPokeRow = {
+      agent_id: rcpt.agent_id,
+      tmux_pane_id: rcpt.tmux_pane_id,
+      delivery: parseDeliveryRow(rcpt),
+    }
+
+    const baseResult = this.insert({ fromTeam, toTeam, from: input.from, toAgentId: rcpt.agent_id, input })
+
+    const autoPokeEnabled = input.auto_poke !== false
+    if (!autoPokeEnabled) {
+      recordInitialDeliveryStatuses(this.db, {
+        messageId: baseResult.message_id,
+        recipients: [rcpt.agent_id],
+        delivered: new Set(),
+        skipped: [],
+        autoPokeDisabled: true,
+      })
+      return { ...baseResult, poked: false, retry_scheduled: false }
+    }
+
+    const envelope = await runFanoutWithRetry({
+      db: this.db,
+      team: toTeam,
+      fromAgentId: input.from,
+      recipients: [recipientRow],
+      body: input.body,
+      deps: this.deps,
+      messageId: baseResult.message_id,
+      sentAt: baseResult.sent_at
+    })
+    return {
+      message_id: baseResult.message_id,
+      event_id: baseResult.event_id,
+      recipients: baseResult.recipients,
+      ...envelope
+    }
+  }
+
+  private insert(args: {
+    fromTeam: string; toTeam: string; from: string; toAgentId: string; input: SendInput
+  }): { message_id: string; event_id: number; recipients: string[]; sent_at: string } {
+    const tx = this.db.transaction(() => {
+      const needReply = args.input.need_reply !== false ? 1 : 0
+      const event_id = this.events.append({
+        from_team: args.fromTeam, to_team: args.toTeam,
+        event_type: 'message_sent', actor_agent_id: args.from,
+        payload: {
+          recipients: [args.toAgentId],
+          subject: args.input.subject ?? null,
+          need_reply: needReply === 1,
+        }
+      })
+      const sent_at = new Date().toISOString()
+      const id = randomUUID()
+      this.db.prepare(
+        `INSERT INTO messages (id, event_id, from_team, to_team, from_agent_id, to_agent_id, to_role, subject, body, need_reply, sent_at)
+         VALUES (?,?,?,?,?,?,?,?,?,?,?)`
+      ).run(id, event_id, args.fromTeam, args.toTeam, args.from,
+        args.toAgentId,
+        null, args.input.subject ?? null, args.input.body, needReply, sent_at)
+      return { message_id: id, event_id, sent_at }
+    })
+    const { message_id, event_id, sent_at } = tx()
+    return { message_id, event_id, recipients: [args.toAgentId], sent_at }
+  }
+}

package/src/mcp/subscribe-channel-wake.ts

@@ -0,0 +1,31 @@
+import type Database from 'better-sqlite3'
+import type { ChannelWakeFanout, ChannelWakeSink } from '../daemon/channel-wake-fanout.js'
+
+export const CHANNEL_PROXY_ROLE = '__channel_proxy__'
+
+export interface SubscribeInput {
+  callerAgentId: string
+  channel_session_id: string
+  sessionId: string
+  sink: ChannelWakeSink
+}
+
+export type SubscribeResult =
+  | { ok: true }
+  | { error: 'unknown_agent' | 'forbidden_role' | 'invalid_channel_session_id' }
+
+export class SubscribeChannelWakeService {
+  constructor(private readonly db: Database.Database, private readonly fanout: ChannelWakeFanout) {}
+
+  subscribe(input: SubscribeInput): SubscribeResult {
+    const csid = input.channel_session_id?.trim()
+    if (!csid) return { error: 'invalid_channel_session_id' }
+    const row = this.db
+      .prepare(`SELECT role FROM agents WHERE agent_id=?`)
+      .get(input.callerAgentId) as { role: string } | undefined
+    if (!row) return { error: 'unknown_agent' }
+    if (row.role !== CHANNEL_PROXY_ROLE) return { error: 'forbidden_role' }
+    this.fanout.attach(csid, input.sink, input.sessionId)
+    return { ok: true }
+  }
+}

package/src/mcp/subscribe-contract.ts

@@ -0,0 +1,24 @@
+import type Database from 'better-sqlite3'
+import type { AgentsRepo } from '../storage/agents-repo.js'
+
+export type SubscribeResult =
+  | { ok: true; current_version: number | null }
+  | { error: 'unknown_agent' }
+
+export class SubscribeContractService {
+  constructor(private db: Database.Database, private agents: AgentsRepo) {}
+
+  subscribe(args: { caller: string; name: string }): SubscribeResult {
+    const caller = this.agents.findById(args.caller)
+    if (!caller) return { error: 'unknown_agent' }
+    this.db.prepare(
+      `INSERT INTO contract_subscriptions (agent_id, team, contract_name, subscribed_at)
+       VALUES (?,?,?,?)
+       ON CONFLICT(agent_id, team, contract_name) DO UPDATE SET subscribed_at=excluded.subscribed_at`
+    ).run(args.caller, caller.team, args.name, new Date().toISOString())
+    const latest = this.db.prepare(
+      'SELECT MAX(version) AS v FROM contracts WHERE team=? AND name=?'
+    ).get(caller.team, args.name) as { v: number | null }
+    return { ok: true, current_version: latest.v ?? null }
+  }
+}

package/src/mcp/task-add.ts

@@ -0,0 +1,37 @@
+import type Database from 'better-sqlite3'
+import { randomUUID } from 'node:crypto'
+import type { AgentsRepo } from '../storage/agents-repo.js'
+import type { EventsOutbox } from '../storage/events-outbox.js'
+
+export type AddResult = { task_id: string } | { error: 'unknown_agent' }
+
+export class TaskAddService {
+  constructor(
+    private db: Database.Database,
+    private agents: AgentsRepo,
+    private events: EventsOutbox
+  ) {}
+
+  add(args: { caller: string; title: string; description?: string; depends_on?: string[] }): AddResult {
+    const caller = this.agents.findById(args.caller)
+    if (!caller) return { error: 'unknown_agent' }
+    const id = randomUUID()
+    const depends_on = JSON.stringify(args.depends_on ?? [])
+    const created_at = new Date().toISOString()
+    const tx = this.db.transaction(() => {
+      this.db.prepare(
+        `INSERT INTO tasks (id, team, title, description, status, depends_on, created_at)
+         VALUES (?,?,?,?, 'pending', ?, ?)`
+      ).run(id, caller.team, args.title, args.description ?? null, depends_on, created_at)
+      this.events.append({
+        from_team: caller.team,
+        to_team: caller.team,
+        event_type: 'task_added',
+        actor_agent_id: args.caller,
+        payload: { task_id: id, title: args.title }
+      })
+    })
+    tx()
+    return { task_id: id }
+  }
+}

package/src/mcp/task-claim.ts

@@ -0,0 +1,54 @@
+import type Database from 'better-sqlite3'
+import type { AgentsRepo } from '../storage/agents-repo.js'
+import type { EventsOutbox } from '../storage/events-outbox.js'
+
+export type ClaimResult =
+  | { ok: true }
+  | { error: 'already_claimed'; owner: string }
+  | { error: 'dependencies_pending' }
+  | { error: 'unknown_task' }
+  | { error: 'unknown_agent' }
+
+export class TaskClaimService {
+  constructor(
+    private db: Database.Database,
+    private agents: AgentsRepo,
+    private events: EventsOutbox
+  ) {}
+
+  claim(args: { caller: string; task_id: string }): ClaimResult {
+    const caller = this.agents.findById(args.caller)
+    if (!caller) return { error: 'unknown_agent' }
+    const row = this.db.prepare(
+      `SELECT status, claimed_by, depends_on FROM tasks WHERE id=? AND team=?`
+    ).get(args.task_id, caller.team) as
+      { status: string; claimed_by: string | null; depends_on: string } | undefined
+    if (!row) return { error: 'unknown_task' }
+    if (row.status !== 'pending') {
+      if (row.claimed_by) return { error: 'already_claimed', owner: row.claimed_by }
+      return { error: 'already_claimed', owner: '' }
+    }
+    const deps = JSON.parse(row.depends_on) as string[]
+    if (deps.length > 0) {
+      const pending = this.db.prepare(
+        `SELECT COUNT(*) as c FROM tasks WHERE id IN (${deps.map(() => '?').join(',')}) AND team=? AND status != 'completed'`
+      ).get(...deps, caller.team) as { c: number }
+      if (pending.c > 0) return { error: 'dependencies_pending' }
+    }
+    const upd = this.db.prepare(
+      `UPDATE tasks SET status='in_progress', claimed_by=?, claimed_at=?
+        WHERE id=? AND team=? AND status='pending'`
+    ).run(args.caller, new Date().toISOString(), args.task_id, caller.team)
+    if (upd.changes !== 1) {
+      const post = this.db.prepare(`SELECT claimed_by FROM tasks WHERE id=?`).get(args.task_id) as
+        { claimed_by: string | null } | undefined
+      return { error: 'already_claimed', owner: post?.claimed_by ?? '' }
+    }
+    this.events.append({
+      from_team: caller.team, to_team: caller.team,
+      event_type: 'task_claimed', actor_agent_id: args.caller,
+      payload: { task_id: args.task_id }
+    })
+    return { ok: true }
+  }
+}

package/src/mcp/task-complete.ts

@@ -0,0 +1,36 @@
+import type Database from 'better-sqlite3'
+import type { AgentsRepo } from '../storage/agents-repo.js'
+import type { EventsOutbox } from '../storage/events-outbox.js'
+
+export type CompleteResult =
+  | { ok: true }
+  | { error: 'not_owner' | 'invalid_status' | 'unknown_task' | 'unknown_agent' }
+
+export class TaskCompleteService {
+  constructor(
+    private db: Database.Database,
+    private agents: AgentsRepo,
+    private events: EventsOutbox
+  ) {}
+
+  complete(args: { caller: string; task_id: string; result?: string }): CompleteResult {
+    const caller = this.agents.findById(args.caller)
+    if (!caller) return { error: 'unknown_agent' }
+    const row = this.db.prepare(`SELECT status, claimed_by FROM tasks WHERE id=? AND team=?`)
+      .get(args.task_id, caller.team) as { status: string; claimed_by: string | null } | undefined
+    if (!row) return { error: 'unknown_task' }
+    if (row.status !== 'in_progress') return { error: 'invalid_status' }
+    if (row.claimed_by !== args.caller) return { error: 'not_owner' }
+    const upd = this.db.prepare(
+      `UPDATE tasks SET status='completed', completed_at=?, result=?
+        WHERE id=? AND team=? AND claimed_by=? AND status='in_progress'`
+    ).run(new Date().toISOString(), args.result ?? null, args.task_id, caller.team, args.caller)
+    if (upd.changes !== 1) return { error: 'invalid_status' }
+    this.events.append({
+      from_team: caller.team, to_team: caller.team,
+      event_type: 'task_completed', actor_agent_id: args.caller,
+      payload: { task_id: args.task_id, result: args.result ?? null }
+    })
+    return { ok: true }
+  }
+}