diff --git a/.agentworkforce/agents/factory-feature-guardian/persona.json b/.agentworkforce/agents/factory-feature-guardian/persona.json
index cecd2f0d..3f59d72a 100644
--- a/.agentworkforce/agents/factory-feature-guardian/persona.json
+++ b/.agentworkforce/agents/factory-feature-guardian/persona.json
@@ -3,6 +3,16 @@
   "intent": "relay-orchestrator",
   "tags": ["factory", "verification", "proactive", "health", "release-safety", "durability"],
   "description": "Traverses the Factory feature catalog hourly to exercise the manifest/model/state chain with log-only healthy evidence, without claiming per-feature E2E verification; genuine run failures surface through deployment monitoring, while scoped Slack response events retain exact-revision incident handling.",
+  "skills": [
+    {
+      "id": "factory-feature-verification",
+      "source": ".agentworkforce/features/verify/procedures.md",
+      "description": "Verify Factory features against their named end-to-end procedures and supported safety boundaries."
+    }
+  ],
+  "relay": {
+    "agentName": "factory-feature-guardian"
+  },
   "cloud": true,
   "harness": "opencode",
   "model": "deepseek-v4-flash-free",
diff --git a/README.md b/README.md
index 93f99dfe..05ce6c9c 100644
--- a/README.md
+++ b/README.md
@@ -526,6 +526,15 @@ The definition reads its node config from `./factory.node.json` (or
 mapped repo is advertised as a `repo:<label>` tag so placement can route
 repo-scoped spawns to it. Spawns for unadvertised paths are refused on the node.
 
+The default `@agent-relay/factory/node` export is a generic worker-machine
+definition; it does not host a persona and therefore does not publish an agent
+card. An application that intentionally couples a persona to a Factory node
+uses the exported `createFactoryNodeDefinition({ persona })` and
+`startFactoryNode({ cardPublisher })` runtime. `startFactoryNode` owns the
+online-registration edge and publishes the canonical card there; cloud personas
+such as the checked-in `factory-feature-guardian` continue to use the Agent
+Workforce cloud-persona deployment path described above.
+
 ### Tailnet live previews
 
 Factory can attach an issue-lifetime [Tailscale Serve](https://tailscale.com/docs/features/tailscale-serve)
diff --git a/package-lock.json b/package-lock.json
index 4bbc6cb4..343ee7be 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -15,8 +15,11 @@
         "@agent-relay/integration-prompts": "^11.6.9",
         "@agent-relay/sdk": "^11.6.9",
         "@agentworkforce/delivery": "^4.1.23",
+        "@agentworkforce/persona-kit": "^4.1.43",
         "@agentworkforce/review-kit": "^4.1.34",
         "@agentworkforce/runtime": "^4.1.23",
+        "@modelcontextprotocol/sdk": "1.29.0",
+        "@relaycast/a2a": "^6.2.0",
         "@relayfile/relay-helpers": "^0.4.6",
         "@relayfile/sdk": "0.10.34",
         "@relayflows/core": "^1.0.3",
@@ -29,7 +32,6 @@
         "factory": "bin/factory.mjs"
       },
       "devDependencies": {
-        "@agentworkforce/persona-kit": "^4.1.23",
         "@types/node": "^22.10.2",
         "@types/proper-lockfile": "^4.1.4",
         "esbuild": "^0.28.1",
@@ -39,7 +41,7 @@
         "vitest": "^4.1.8"
       },
       "engines": {
-        "node": ">=20.18.1"
+        "node": ">=22.0.0"
       }
     },
     "node_modules/@agent-assistant/connectivity": {
@@ -622,10 +624,11 @@
       }
     },
     "node_modules/@agentworkforce/persona-kit": {
-      "version": "4.1.34",
-      "resolved": "https://registry.npmjs.org/@agentworkforce/persona-kit/-/persona-kit-4.1.34.tgz",
-      "integrity": "sha512-CXdDI3vIgS6GJn0wp8aB7+Hnl7Mh1dKMWvUK2qCmuwsRRC8qH3Pu6b/1CHMy6Esk+E7z5qgX20x8W3C55tRuqg==",
+      "version": "4.1.43",
+      "resolved": "https://registry.npmjs.org/@agentworkforce/persona-kit/-/persona-kit-4.1.43.tgz",
+      "integrity": "sha512-cx8GKVxUkREuuMvD6Ja8U20zotfzLpY4Rub4NFV1Gtx8oME8Nmh32EB5xLcLmvKkPzL4HKBWz+5Iv6fLQaZ5Qg==",
       "dependencies": {
+        "@relaycast/a2a": "^6.2.0",
         "@relayfile/adapter-core": "^0.5.1",
         "@relayfile/local-mount": "^0.10.23"
       }
@@ -639,6 +642,15 @@
         "@agentworkforce/runtime": "4.1.34"
       }
     },
+    "node_modules/@agentworkforce/review-kit/node_modules/@agentworkforce/persona-kit": {
+      "version": "4.1.34",
+      "resolved": "https://registry.npmjs.org/@agentworkforce/persona-kit/-/persona-kit-4.1.34.tgz",
+      "integrity": "sha512-CXdDI3vIgS6GJn0wp8aB7+Hnl7Mh1dKMWvUK2qCmuwsRRC8qH3Pu6b/1CHMy6Esk+E7z5qgX20x8W3C55tRuqg==",
+      "dependencies": {
+        "@relayfile/adapter-core": "^0.5.1",
+        "@relayfile/local-mount": "^0.10.23"
+      }
+    },
     "node_modules/@agentworkforce/runtime": {
       "version": "4.1.34",
       "resolved": "https://registry.npmjs.org/@agentworkforce/runtime/-/runtime-4.1.34.tgz",
@@ -653,6 +665,15 @@
         "agent-trajectories": "^0.5.3"
       }
     },
+    "node_modules/@agentworkforce/runtime/node_modules/@agentworkforce/persona-kit": {
+      "version": "4.1.34",
+      "resolved": "https://registry.npmjs.org/@agentworkforce/persona-kit/-/persona-kit-4.1.34.tgz",
+      "integrity": "sha512-CXdDI3vIgS6GJn0wp8aB7+Hnl7Mh1dKMWvUK2qCmuwsRRC8qH3Pu6b/1CHMy6Esk+E7z5qgX20x8W3C55tRuqg==",
+      "dependencies": {
+        "@relayfile/adapter-core": "^0.5.1",
+        "@relayfile/local-mount": "^0.10.23"
+      }
+    },
     "node_modules/@agentworkforce/runtime/node_modules/agent-trajectories": {
       "version": "0.5.9",
       "resolved": "https://registry.npmjs.org/agent-trajectories/-/agent-trajectories-0.5.9.tgz",
@@ -1605,7 +1626,6 @@
       "version": "0.79.10",
       "resolved": "https://registry.npmjs.org/@earendil-works/pi-coding-agent/-/pi-coding-agent-0.79.10.tgz",
       "integrity": "sha512-YxaRhmgyDTvLDdGVbe7YzTHV80oL5mX5odg6EhGHz3w5Wu1Ix8DCw7bhtiOBLGQNFRcknia0zPmVWIj30XP1EA==",
-      "hasShrinkwrap": true,
       "license": "MIT",
       "dependencies": {
         "@earendil-works/pi-agent-core": "^0.79.10",
@@ -4778,6 +4798,23 @@
       "integrity": "sha512-b1UQwcEZ4yCnMCD8DAL1VlbvBJE9/IX4FTIp7BG1xYpf29SLazLSrqUkj4w7Y5y7cCVP6E5tcqqcI0xemPkHug==",
       "license": "BSD-3-Clause"
     },
+    "node_modules/@relaycast/a2a": {
+      "version": "6.3.2",
+      "resolved": "https://registry.npmjs.org/@relaycast/a2a/-/a2a-6.3.2.tgz",
+      "integrity": "sha512-FpajSYqN0sn6+waAmQuHYRr2YR2nMTIRe+epadCDsSm7CiUZxVncY+0CRa1LxCTm79+VTnXfb5TmiFMQcv9+xA==",
+      "dependencies": {
+        "zod": "^4.3.6"
+      }
+    },
+    "node_modules/@relaycast/a2a/node_modules/zod": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
     "node_modules/@relaycast/sdk": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@relaycast/sdk/-/sdk-1.2.0.tgz",
diff --git a/package.json b/package.json
index e6bc2f9d..a8283f6d 100644
--- a/package.json
+++ b/package.json
@@ -102,9 +102,12 @@
     "@agent-relay/harness-driver": "^11.6.9",
     "@agent-relay/integration-prompts": "^11.6.9",
     "@agent-relay/sdk": "^11.6.9",
+    "@modelcontextprotocol/sdk": "1.29.0",
     "@agentworkforce/delivery": "^4.1.23",
+    "@agentworkforce/persona-kit": "^4.1.43",
     "@agentworkforce/review-kit": "^4.1.34",
     "@agentworkforce/runtime": "^4.1.23",
+    "@relaycast/a2a": "^6.2.0",
     "@relayfile/relay-helpers": "^0.4.6",
     "@relayfile/sdk": "0.10.34",
     "@relayflows/core": "^1.0.3",
@@ -118,7 +121,6 @@
     "listr2": "9.0.5"
   },
   "devDependencies": {
-    "@agentworkforce/persona-kit": "^4.1.23",
     "@types/node": "^22.10.2",
     "@types/proper-lockfile": "^4.1.4",
     "esbuild": "^0.28.1",
diff --git a/src/cli/fleet.ts b/src/cli/fleet.ts
index 9b4290dc..1e5fd70e 100644
--- a/src/cli/fleet.ts
+++ b/src/cli/fleet.ts
@@ -2875,6 +2875,11 @@ async function readFactoryVersion(): Promise<string> {
 }
 
 export async function main(argv = process.argv.slice(2)): Promise<void> {
+  if (argv[0] === 'teammate-mcp') {
+    const { startFactoryTeammateMcpStdio } = await import('./teammate-mcp')
+    await startFactoryTeammateMcpStdio()
+    return
+  }
   const code = await runFleetCli(argv)
   process.exitCode = code
 }
diff --git a/src/cli/teammate-mcp.test.ts b/src/cli/teammate-mcp.test.ts
new file mode 100644
index 00000000..0a19d6ce
--- /dev/null
+++ b/src/cli/teammate-mcp.test.ts
@@ -0,0 +1,87 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
+import { describe, expect, it } from 'vitest'
+
+import { FakeFleetClient } from '../testing/fakes'
+import { createFactoryTeammateMcpServer } from './teammate-mcp'
+
+describe('Factory teammate MCP', () => {
+  it('exposes discover and bounded ask to the spawned worker through its injected MCP server', async () => {
+    const fleet = new FakeFleetClient()
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      description: 'Infrastructure specialist',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: ['operations'],
+      kind: 'native',
+      url: 'relay://infra-agent',
+    })
+    fleet.waitForInjected = async (input) => {
+      fleet.messages.push(input)
+      queueMicrotask(() => fleet.emitAgentMessage({
+        from: input.to,
+        target: 'ar-139-impl-factory',
+        body: 'The deployment heartbeat is frozen.',
+      }))
+      return { eventId: 'event-1', targets: [input.to] }
+    }
+
+    const { server } = createFactoryTeammateMcpServer({
+      skipBootstrap: true,
+      agentName: 'ar-139-impl-factory',
+      agentToken: 'at_live_test',
+    }, { fleet })
+    const client = new Client({ name: 'factory-teammate-test', version: '1.0.0' })
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+    await Promise.all([server.connect(serverTransport), client.connect(clientTransport)])
+
+    try {
+      const listed = await client.listTools()
+      expect(listed.tools.map((tool) => tool.name)).toEqual(expect.arrayContaining([
+        'discover_teammates',
+        'ask_teammate',
+        // Positive control: Factory extends rather than replaces Agent Relay.
+        'send_dm',
+      ]))
+
+      const discovered = await client.callTool({
+        name: 'discover_teammates',
+        arguments: { skill: 'infra-watch' },
+      })
+      expect(toolJson(discovered)).toEqual([expect.objectContaining({ name: 'infra-agent' })])
+
+      const asked = await client.callTool({
+        name: 'ask_teammate',
+        arguments: {
+          skill: 'infra-watch',
+          question: 'Why is the deployment stuck?',
+          timeoutMs: 1_000,
+        },
+      })
+      expect(toolJson(asked)).toMatchObject({
+        teammate: { name: 'infra-agent' },
+        reply: {
+          from: 'infra-agent',
+          target: 'ar-139-impl-factory',
+          body: 'The deployment heartbeat is frozen.',
+        },
+      })
+      expect(fleet.messages).toEqual([expect.objectContaining({
+        from: 'ar-139-impl-factory',
+        to: 'infra-agent',
+        text: 'Why is the deployment stuck?',
+      })])
+    } finally {
+      await client.close()
+      await server.close()
+    }
+  })
+})
+
+function toolJson(result: { content?: unknown }): unknown {
+  const content = result.content as Array<{ type: string; text?: string }> | undefined
+  const text = content?.find((entry) => entry.type === 'text')?.text
+  if (!text) throw new Error('tool returned no text content')
+  return JSON.parse(text)
+}
diff --git a/src/cli/teammate-mcp.ts b/src/cli/teammate-mcp.ts
new file mode 100644
index 00000000..723a187d
--- /dev/null
+++ b/src/cli/teammate-mcp.ts
@@ -0,0 +1,125 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import {
+  createAgentRelayMcpServer,
+  optionsFromEnv,
+  resolveStdioBootstrapOptions,
+  type AgentRelayMcpServerOptions,
+} from 'agent-relay/mcp'
+import { z } from 'zod'
+
+import type { FleetClient, TeammateAgent } from '../ports/fleet'
+import { RelayFleetClient } from '../fleet/relay-fleet-client'
+import { askTeammate } from '../fleet/teammates'
+
+export interface FactoryTeammateMcpDependencies {
+  fleet?: FleetClient
+}
+
+/**
+ * Extend the same Agent Relay MCP server already injected into Factory workers
+ * with directory-backed, bounded teammate tools. Keeping one server preserves
+ * every existing Relay tool and identity setting while making #139 reachable
+ * from the spawned worker rather than only from Factory's library API.
+ */
+export function createFactoryTeammateMcpServer(
+  options: AgentRelayMcpServerOptions,
+  dependencies: FactoryTeammateMcpDependencies = {},
+): { server: McpServer; fleet: FleetClient } {
+  const server = createAgentRelayMcpServer(options)
+  const fleet = dependencies.fleet ?? new RelayFleetClient({
+    workspaceKey: options.workspaceKey ?? options.apiKey,
+    agentToken: options.agentToken,
+    agentName: options.agentName,
+    baseUrl: options.baseUrl,
+    env: {},
+    registerLifecycleAction: false,
+  })
+
+  server.registerTool('discover_teammates', {
+    title: 'Discover Teammates',
+    description: 'Find Relaycast agents by exact skill/tag or free-text card query before asking one for help.',
+    inputSchema: {
+      skill: z.string().trim().min(1).optional(),
+      tag: z.string().trim().min(1).optional(),
+      q: z.string().trim().min(1).optional(),
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+    },
+  }, async ({ skill, tag, q }) => {
+    if (!skill && !tag && !q) {
+      throw new Error('discover_teammates requires skill, tag, or q')
+    }
+    return jsonToolResult(await fleet.discoverTeammates({ skill, tag, q }))
+  })
+
+  server.registerTool('ask_teammate', {
+    title: 'Ask a Teammate',
+    description: 'Discover or address one teammate, send a question over Relay, and wait for its reply within a bounded deadline.',
+    inputSchema: {
+      question: z.string().trim().min(1),
+      to: z.string().trim().min(1).optional(),
+      skill: z.string().trim().min(1).optional(),
+      tag: z.string().trim().min(1).optional(),
+      q: z.string().trim().min(1).optional(),
+      timeoutMs: z.number().int().positive().max(120_000).optional(),
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true,
+    },
+  }, async ({ question, to, skill, tag, q, timeoutMs }) => {
+    if (!to && !skill && !tag && !q) {
+      throw new Error('ask_teammate requires to, skill, tag, or q')
+    }
+    const from = requiredAgentName(options.agentName)
+    const result = await askTeammate(fleet, {
+      from,
+      question,
+      ...(to ? { teammate: directTeammate(to) } : { skill, tag, q }),
+      timeoutMs,
+    })
+    return jsonToolResult(result)
+  })
+
+  return { server, fleet }
+}
+
+/** Start the worker-facing Factory + Agent Relay MCP server on stdio. */
+export async function startFactoryTeammateMcpStdio(
+  options: AgentRelayMcpServerOptions = optionsFromEnv(),
+): Promise<void> {
+  const resolved = await resolveStdioBootstrapOptions(options)
+  const { server } = createFactoryTeammateMcpServer(resolved)
+  await server.connect(new StdioServerTransport())
+}
+
+function directTeammate(address: string): TeammateAgent {
+  return {
+    name: address,
+    address,
+    description: 'Direct Relay teammate target supplied by the worker.',
+    skills: [],
+    tags: [],
+    kind: 'native',
+    url: `relay://${encodeURIComponent(address)}`,
+  }
+}
+
+function requiredAgentName(value: string | undefined): string {
+  const name = value?.trim()
+  if (!name) throw new Error('ask_teammate requires the spawned worker identity (RELAY_AGENT_NAME)')
+  return name
+}
+
+function jsonToolResult(value: unknown) {
+  return {
+    content: [{ type: 'text' as const, text: JSON.stringify(value, null, 2) }],
+  }
+}
diff --git a/src/fleet/create-fleet.test.ts b/src/fleet/create-fleet.test.ts
index 7af7427b..8a6292c8 100644
--- a/src/fleet/create-fleet.test.ts
+++ b/src/fleet/create-fleet.test.ts
@@ -40,6 +40,16 @@ describe('createFleet', () => {
     expect(createFleet({ backend: 'internal' }, { harnessClient: fakeHarness })).toBeInstanceOf(InternalFleetClient)
   })
 
+  it('forwards a proven injected message-stream scope to the internal backend', async () => {
+    const scope = {}
+    const fleet = createFleet(
+      { backend: 'internal' },
+      { harnessClient: { ...fakeHarness }, messageStreamScope: scope },
+    )
+
+    await expect(fleet.messageStreamIdentity()).resolves.toBe(scope)
+  })
+
   it('forwards the owned-broker agent exit timeout to the internal client', async () => {
     vi.useFakeTimers()
     try {
diff --git a/src/fleet/create-fleet.ts b/src/fleet/create-fleet.ts
index a4a97b48..30b6cb54 100644
--- a/src/fleet/create-fleet.ts
+++ b/src/fleet/create-fleet.ts
@@ -30,6 +30,8 @@ export interface CreateFleetOptions {
 
 export interface CreateFleetDeps {
   harnessClient?: HarnessDriverClientLike
+  /** Proven inbound-stream identity for an injected Harness Driver client. */
+  messageStreamScope?: string | object
   // True when harnessClient owns a broker we spawned, so the fleet shuts it down
   // on dispose instead of leaving it running.
   ownsBroker?: boolean
@@ -80,6 +82,7 @@ export function createFleet(options: CreateFleetOptions = {}, deps: CreateFleetD
 
   return new InternalFleetClient({
     client: deps.harnessClient,
+    messageStreamScope: deps.messageStreamScope,
     ownsBroker: deps.ownsBroker,
     ownedBrokerAgentExitTimeoutMs: resolveOwnedBrokerAgentExitTimeoutMs(deps.ownedBrokerAgentExitTimeoutMs),
     workspaceKey: deps.workspaceKey,
diff --git a/src/fleet/internal-fleet-client.reconnect.test.ts b/src/fleet/internal-fleet-client.reconnect.test.ts
index 9da9cff1..7c0422ba 100644
--- a/src/fleet/internal-fleet-client.reconnect.test.ts
+++ b/src/fleet/internal-fleet-client.reconnect.test.ts
@@ -418,6 +418,7 @@ describe('InternalFleetClient broker rebind recovery', () => {
 
     const fleet = new InternalFleetClient({ connectionPath })
     cleanup.push(() => fleet.dispose())
+    const streamIdentityBeforeRebind = await fleet.messageStreamIdentity()
     await fleet.sendMessage({ to: 'worker', text: 'hello' })
 
     await first.stop()
@@ -432,5 +433,6 @@ describe('InternalFleetClient broker rebind recovery', () => {
 
     await fleet.sendMessage({ to: 'worker', text: 'hello' })
     expect(second.requests.map((request) => request.path)).toEqual(['/api/send'])
+    await expect(fleet.messageStreamIdentity()).resolves.toBe(streamIdentityBeforeRebind)
   })
 })
diff --git a/src/fleet/internal-fleet-client.test.ts b/src/fleet/internal-fleet-client.test.ts
index 547dff43..546d54d6 100644
--- a/src/fleet/internal-fleet-client.test.ts
+++ b/src/fleet/internal-fleet-client.test.ts
@@ -1,4 +1,7 @@
 import { describe, expect, it, vi } from 'vitest'
+import { mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
 import type { BrokerEvent, SendMessageInput, SpawnPtyInput } from '@agent-relay/harness-driver'
 
@@ -298,7 +301,7 @@ describe('InternalFleetClient', () => {
     })).rejects.toThrow(/identity proof cannot be installed/)
   })
 
-  it('resolves the default agent-relay CLI mcp command from node_modules', async () => {
+  it('resolves the Factory-extended Agent Relay MCP command from the packed entrypoint', async () => {
     const harness = new FakeHarnessDriverClient()
     const fleet = new InternalFleetClient({ client: harness, cwd: '/worktree' })
 
@@ -313,8 +316,8 @@ describe('InternalFleetClient', () => {
     if (config?.runtime !== 'pty') throw new Error('expected pty harness config')
     const args = config.args
     expect(args).toContain(`mcp_servers.agent-relay.command=${JSON.stringify(process.execPath)}`)
-    expect(args.join('\n')).toContain('node_modules/agent-relay/dist/cli/index.js')
-    expect(args.join('\n')).toContain('"mcp"')
+    expect(args.join('\n')).toContain('bin/factory.mjs')
+    expect(args.join('\n')).toContain('"teammate-mcp"')
   })
 
   it('resolves an agent PID from the broker roster', async () => {
@@ -914,7 +917,11 @@ describe('InternalFleetClient', () => {
         event_id: 'event-2',
       })
 
-      await expect(injected).resolves.toEqual({ eventId: 'event-2', targets: ['ar-1-impl'] })
+      await expect(injected).resolves.toEqual({
+        eventId: 'event-2',
+        targets: ['ar-1-impl'],
+        duplicateDeliveryPossible: true,
+      })
     } finally {
       vi.useRealTimers()
     }
@@ -1218,7 +1225,11 @@ describe('InternalFleetClient', () => {
       event_id: 'event-2',
     })
 
-    await expect(injected).resolves.toEqual({ eventId: 'event-2', targets: ['ar-1-impl'] })
+    await expect(injected).resolves.toEqual({
+      eventId: 'event-2',
+      targets: ['ar-1-impl'],
+      duplicateDeliveryPossible: true,
+    })
   })
 
   it('re-sends an unconfirmed injection when the matching worker becomes ready', async () => {
@@ -1251,7 +1262,10 @@ describe('InternalFleetClient', () => {
       event_id: 'event-2',
     })
 
-    await expect(injected).resolves.toEqual({ eventId: 'event-2', targets: ['ar-1-impl'] })
+    await expect(injected).resolves.toEqual({
+      eventId: 'event-2',
+      targets: ['ar-1-impl'],
+    })
     expect(harness.sent).toEqual([
       { to: 'ar-1-impl', text: 'do work', from: undefined, data: undefined },
       { to: 'ar-1-impl', text: 'do work', from: undefined, data: undefined },
@@ -1281,7 +1295,11 @@ describe('InternalFleetClient', () => {
       event_id: 'event-2',
     })
 
-    await expect(injected).resolves.toEqual({ eventId: 'event-2', targets: ['ar-1-impl'] })
+    await expect(injected).resolves.toEqual({
+      eventId: 'event-2',
+      targets: ['ar-1-impl'],
+      duplicateDeliveryPossible: true,
+    })
   })
 
   it('re-sends when delivery failure races initial waiter installation for a ready worker', async () => {
@@ -1359,6 +1377,50 @@ describe('InternalFleetClient', () => {
     await expect(injected).resolves.toEqual({ eventId: 'event-2', targets: ['ar-1-impl'] })
   })
 
+  it('keeps a confirmed injection pending until its readiness re-send returns', async () => {
+    class BlockingResendHarnessDriverClient extends FakeHarnessDriverClient {
+      resolveResend?: (result: { event_id: string; targets: string[] }) => void
+
+      override async sendMessage(input: SendMessageInput): Promise<{ event_id: string; targets: string[] }> {
+        this.sent.push(input)
+        if (this.sent.length === 1) {
+          return { event_id: 'event-1', targets: [input.to] }
+        }
+        return await new Promise((resolve) => {
+          this.resolveResend = resolve
+        })
+      }
+    }
+    const harness = new BlockingResendHarnessDriverClient()
+    const fleet = new InternalFleetClient({ client: harness })
+
+    const injected = fleet.waitForInjected({ to: 'ar-1-impl', text: 'do work' }, { timeoutMs: 1000 })
+    await vi.waitFor(() => expect(harness.sent).toHaveLength(1))
+    harness.emit({ kind: 'worker_ready', name: 'ar-1-impl', runtime: 'pty' })
+    await vi.waitFor(() => expect(harness.sent).toHaveLength(2))
+
+    let settled = false
+    void injected.finally(() => {
+      settled = true
+    })
+    harness.emit({
+      kind: 'delivery_injected',
+      name: 'ar-1-impl',
+      delivery_id: 'delivery-1',
+      event_id: 'event-1',
+    })
+    await Promise.resolve()
+    expect(settled).toBe(false)
+
+    harness.resolveResend?.({ event_id: 'event-2', targets: ['ar-1-impl'] })
+    await expect(injected).resolves.toEqual({
+      eventId: 'event-1',
+      targets: ['ar-1-impl'],
+      duplicateDeliveryPossible: true,
+    })
+    expect(settled).toBe(true)
+  })
+
   it('disposes a logical waiter while its readiness re-send response is blocked', async () => {
     class BlockingResendHarnessDriverClient extends FakeHarnessDriverClient {
       resolveResend?: (result: { event_id: string; targets: string[] }) => void
@@ -1442,7 +1504,11 @@ describe('InternalFleetClient', () => {
       event_id: 'event-1',
     })
 
-    await expect(injected).resolves.toEqual({ eventId: 'event-1', targets: ['ar-1-impl'] })
+    await expect(injected).resolves.toEqual({
+      eventId: 'event-1',
+      targets: ['ar-1-impl'],
+      duplicateDeliveryPossible: true,
+    })
   })
 
   it('keeps the ready-before-injection fast path to one send when the first send is acknowledged', async () => {
@@ -1491,7 +1557,11 @@ describe('InternalFleetClient', () => {
         event_id: 'event-2',
       })
 
-      await expect(injected).resolves.toEqual({ eventId: 'event-2', targets: ['ar-1-impl'] })
+      await expect(injected).resolves.toEqual({
+        eventId: 'event-2',
+        targets: ['ar-1-impl'],
+        duplicateDeliveryPossible: true,
+      })
     } finally {
       vi.useRealTimers()
     }
@@ -1692,6 +1762,145 @@ describe('InternalFleetClient', () => {
     }])
   })
 
+  it('shares teammate claim identity across wrappers on one injected broker client', async () => {
+    const harness = new FakeHarnessDriverClient()
+    const one = new InternalFleetClient({ client: harness })
+    const two = new InternalFleetClient({ client: harness })
+
+    const oneIdentity = await one.messageStreamIdentity()
+    const twoIdentity = await two.messageStreamIdentity()
+
+    expect(twoIdentity).toBe(oneIdentity)
+  })
+
+  it('conservatively shares teammate claim identity across unknown injected clients', async () => {
+    const one = new InternalFleetClient({ client: new FakeHarnessDriverClient() })
+    const two = new InternalFleetClient({ client: new FakeHarnessDriverClient() })
+
+    await expect(one.messageStreamIdentity()).resolves.toBe(await two.messageStreamIdentity())
+  })
+
+  it('shares teammate claim identity across separate clients on one broker URL', async () => {
+    const oneHarness = Object.assign(new FakeHarnessDriverClient(), { baseUrl: 'http://127.0.0.1:6789' })
+    const twoHarness = Object.assign(new FakeHarnessDriverClient(), { baseUrl: 'http://127.0.0.1:6789/' })
+    const one = new InternalFleetClient({ client: oneHarness })
+    const two = new InternalFleetClient({ client: twoHarness })
+
+    const identity = await one.messageStreamIdentity()
+    expect(identity).toMatch(/^internal-broker:/u)
+    await expect(two.messageStreamIdentity()).resolves.toBe(identity)
+  })
+
+  it('keeps explicitly proven injected broker streams independent', async () => {
+    const oneScope = {}
+    const twoScope = {}
+    const one = new InternalFleetClient({
+      client: new FakeHarnessDriverClient(),
+      messageStreamScope: oneScope,
+    })
+    const two = new InternalFleetClient({
+      client: new FakeHarnessDriverClient(),
+      messageStreamScope: twoScope,
+    })
+
+    await expect(one.messageStreamIdentity()).resolves.toBe(oneScope)
+    await expect(two.messageStreamIdentity()).resolves.toBe(twoScope)
+  })
+
+  it('honors a proven injected stream scope before derived working-directory paths', async () => {
+    const sharedScope = {}
+    const one = new InternalFleetClient({
+      client: new FakeHarnessDriverClient(),
+      cwd: '/work/one',
+      messageStreamScope: sharedScope,
+    })
+    const two = new InternalFleetClient({
+      client: new FakeHarnessDriverClient(),
+      cwd: '/work/two',
+      messageStreamScope: sharedScope,
+    })
+
+    await expect(one.messageStreamIdentity()).resolves.toBe(sharedScope)
+    await expect(two.messageStreamIdentity()).resolves.toBe(sharedScope)
+  })
+
+  it('shares teammate claim identity across separate clients bound by one connection file', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'factory-internal-stream-identity-'))
+    const connectionPath = join(root, 'connection.json')
+    try {
+      await writeFile(connectionPath, JSON.stringify({
+        url: 'http://127.0.0.1:6789',
+        api_key: 'broker-key',
+        pid: 6789,
+      }))
+      const one = new InternalFleetClient({
+        client: new FakeHarnessDriverClient(),
+        connectionPath,
+      })
+      const two = new InternalFleetClient({
+        client: new FakeHarnessDriverClient(),
+        connectionPath,
+      })
+
+      const identity = await one.messageStreamIdentity()
+      expect(identity).toMatch(/^internal-broker:/u)
+      await expect(two.messageStreamIdentity()).resolves.toBe(identity)
+      expect(String(identity)).not.toContain('broker-key')
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it('shares teammate claim identity across real and symlinked connection paths', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'factory-internal-stream-symlink-'))
+    const connectionPath = join(root, 'connection.json')
+    const symlinkPath = join(root, 'connection-link.json')
+    try {
+      await writeFile(connectionPath, JSON.stringify({
+        url: 'http://127.0.0.1:6789',
+        api_key: 'broker-key',
+        pid: 6789,
+      }))
+      await symlink(connectionPath, symlinkPath)
+      const direct = new InternalFleetClient({
+        client: new FakeHarnessDriverClient(),
+        connectionPath,
+      })
+      const throughSymlink = new InternalFleetClient({
+        client: new FakeHarnessDriverClient(),
+        connectionPath: symlinkPath,
+      })
+
+      const identity = await direct.messageStreamIdentity()
+      await expect(throughSymlink.messageStreamIdentity()).resolves.toBe(identity)
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it('shares teammate claim identity through a symlinked parent before the connection file exists', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'factory-internal-stream-missing-symlink-'))
+    const realDirectory = join(root, 'real-relay')
+    const symlinkDirectory = join(root, 'relay-link')
+    try {
+      await mkdir(realDirectory)
+      await symlink(realDirectory, symlinkDirectory)
+      const direct = new InternalFleetClient({
+        client: new FakeHarnessDriverClient(),
+        connectionPath: join(realDirectory, 'connection.json'),
+      })
+      const throughSymlink = new InternalFleetClient({
+        client: new FakeHarnessDriverClient(),
+        connectionPath: join(symlinkDirectory, 'connection.json'),
+      })
+
+      const identity = await direct.messageStreamIdentity()
+      await expect(throughSymlink.messageStreamIdentity()).resolves.toBe(identity)
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
   it('latches one agent death by name across lagged exit callbacks', () => {
     vi.useFakeTimers()
     vi.setSystemTime(new Date('2026-06-11T00:00:00.000Z'))
diff --git a/src/fleet/internal-fleet-client.ts b/src/fleet/internal-fleet-client.ts
index 4b87e7d2..88d5ae27 100644
--- a/src/fleet/internal-fleet-client.ts
+++ b/src/fleet/internal-fleet-client.ts
@@ -1,20 +1,21 @@
 import { HarnessDriverClient } from '@agent-relay/harness-driver'
 import { AgentRelay } from '@agent-relay/sdk'
-import { accessSync, constants, readFileSync } from 'node:fs'
-import { createRequire } from 'node:module'
+import { createHash } from 'node:crypto'
+import { accessSync, constants, readFileSync, realpathSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
+import { basename, dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 import type { BrokerEvent, ListAgent, SendMessageInput, SpawnPtyInput } from '@agent-relay/harness-driver'
 
 import type { PreviewConfig } from '../config/schema'
-import type { AgentMessage, AgentPidResolution, AgentUsage, Capability, FleetClient, FleetTrackedAgent, PreviewReference, PreviewStartInput, PreviewSweepInput, PreviewSweepResult, RosterEntry, SendInput, SpawnInput, SpawnResult } from '../ports/fleet'
+import type { AgentMessage, AgentPidResolution, AgentUsage, Capability, FleetClient, FleetTrackedAgent, PreviewReference, PreviewStartInput, PreviewSweepInput, PreviewSweepResult, RosterEntry, SendInput, SpawnInput, SpawnResult, TeammateAgent, TeammateQuery } from '../ports/fleet'
+import { FleetDeliveryRejectedError } from '../ports/fleet'
 import type { Logger } from '../ports/system'
 import { normalizeLogger } from '../logging'
 import { TailscalePreviewManager, type PreviewManager } from '../node/tailscale-preview'
 import { resolveRelayWorkspaceKey } from './relay-workspace-key'
-
-const requireForResolve = createRequire(import.meta.url)
+import { RelaycastTeammateDirectory, type TeammateDirectory } from './teammates'
 
 type SpawnedHandleLike = { name: string; sessionId?: string; session_ref?: string; sessionRef?: string; pid?: number }
 type HarnessEventListener = (event: BrokerEvent) => void
@@ -48,6 +49,13 @@ export interface HarnessDriverClientLike {
 
 export interface InternalFleetClientOptions {
   client?: HarnessDriverClientLike
+  /**
+   * Stable identity for an injected client's inbound broker stream when the
+   * caller can prove that boundary. Omit to derive it from connection.json or
+   * the client base URL; clients with no such evidence share a conservative
+   * unknown-stream scope.
+   */
+  messageStreamScope?: string | object
   // True when the injected client owns a broker we spawned, so dispose() shuts it
   // down instead of merely disconnecting (which would leave it running).
   ownsBroker?: boolean
@@ -64,6 +72,11 @@ export interface InternalFleetClientOptions {
    */
   connect?: (options: { cwd?: string; connectionPath?: string }) => HarnessDriverClientLike
   workspaceKey?: string
+  /** Card-aware directory seam; useful with a local broker plus mock directory. */
+  teammateDirectory?: TeammateDirectory
+  directoryBaseUrl?: string
+  directoryFetch?: typeof globalThis.fetch
+  directoryTimeoutMs?: number
   /** Canonical cloud liveness lookup. Injected by tests; derived from workspaceKey in production. */
   listCanonicalOnlineAgentNames?: () => Promise<readonly string[]>
   /** Local process-liveness probe used to preserve workers that intentionally run without Relay MCP presence. */
@@ -86,11 +99,13 @@ type PendingInjectedWait = {
   currentEventId: string
   targets: string[]
   timeout: ReturnType<typeof setTimeout>
-  resolve: (result: { eventId: string; targets: string[] }) => void
+  resolve: (result: { eventId: string; targets: string[]; duplicateDeliveryPossible?: true }) => void
   reject: (error: Error) => void
   resendTimer?: ReturnType<typeof setTimeout>
   resendInFlight: boolean
   resendTriggered: boolean
+  duplicateDeliveryPossible: boolean
+  confirmed?: { eventId: string; targets: string[]; duplicateDeliveryPossible?: true }
   settled: boolean
 }
 
@@ -114,6 +129,39 @@ const OWNED_BROKER_AGENT_EXIT_TIMEOUT_MS = 30 * 60 * 1_000
 const RELEASE_RETRY_MAX_ATTEMPTS = 3
 const RELEASE_RETRY_BACKOFF_MS = 250
 const CANONICAL_PRESENCE_REGISTRATION_GRACE_MS = 60_000
+const UNKNOWN_INJECTED_BROKER_STREAM = Object.freeze({})
+const internalBrokerStreamIdentity = (receipt: string): string =>
+  `internal-broker:${createHash('sha256').update(receipt).digest('base64url')}`
+const canonicalizeConnectionPath = (absolutePath: string): string => {
+  let candidate = absolutePath
+  const missingSegments: string[] = []
+  for (;;) {
+    try {
+      return join(realpathSync.native(candidate), ...missingSegments.reverse())
+    } catch {
+      const parent = dirname(candidate)
+      if (parent === candidate) return absolutePath
+      missingSegments.push(basename(candidate))
+      candidate = parent
+    }
+  }
+}
+const connectionFileStreamIdentity = (path: string): string => {
+  const absolutePath = resolve(path)
+  // The connection file may not exist while the broker is starting. Resolve
+  // its nearest existing ancestor so paths through a symlinked parent still
+  // identify the same future receipt without making construction depend on
+  // the leaf already being present.
+  const canonicalPath = canonicalizeConnectionPath(absolutePath)
+  return internalBrokerStreamIdentity(`connection-file:${canonicalPath}`)
+}
+const canonicalBrokerUrl = (value: string): string => {
+  try {
+    return new URL(value).href
+  } catch {
+    return value
+  }
+}
 
 export class InternalFleetClient implements FleetClient {
   readonly placementLocality = 'local' as const
@@ -128,7 +176,10 @@ export class InternalFleetClient implements FleetClient {
   readonly #ownedBrokerAgentExitTimeoutMs: number
   readonly #cwd?: string
   readonly #connectionPath?: string
+  readonly #connectionStreamScope?: string
   readonly #workspaceKey?: string
+  readonly #messageStreamScope?: string | object
+  readonly #teammateDirectory?: TeammateDirectory
   readonly #listCanonicalOnlineAgentNames?: () => Promise<readonly string[]>
   readonly #isProcessAlive: (pid: number) => boolean
   readonly #now: () => number
@@ -167,7 +218,21 @@ export class InternalFleetClient implements FleetClient {
   constructor(options: InternalFleetClientOptions = {}) {
     this.#cwd = options.cwd
     this.#connectionPath = options.connectionPath
+    const connectionPath = options.connectionPath ?? connectionPathForCwd(options.cwd)
+    this.#connectionStreamScope = connectionPath
+      ? connectionFileStreamIdentity(connectionPath)
+      : undefined
     this.#workspaceKey = options.workspaceKey
+    this.#messageStreamScope = options.messageStreamScope
+    const directoryToken = resolveRelayWorkspaceKey({ workspaceKey: options.workspaceKey })
+    this.#teammateDirectory = options.teammateDirectory ?? (directoryToken
+      ? new RelaycastTeammateDirectory({
+          baseUrl: options.directoryBaseUrl ?? process.env.RELAY_BASE_URL,
+          token: directoryToken,
+          fetch: options.directoryFetch,
+          timeoutMs: options.directoryTimeoutMs,
+        })
+      : undefined)
     if (options.listCanonicalOnlineAgentNames) {
       this.#listCanonicalOnlineAgentNames = options.listCanonicalOnlineAgentNames
     } else if (options.workspaceKey) {
@@ -389,6 +454,32 @@ export class InternalFleetClient implements FleetClient {
     }
   }
 
+  async discoverTeammates(query: TeammateQuery): Promise<TeammateAgent[]> {
+    if (!this.#teammateDirectory) {
+      throw new Error('InternalFleetClient teammate discovery requires a directory or Relay workspace key')
+    }
+    return await this.#teammateDirectory.discover(query)
+  }
+
+  /**
+   * Identify the broker event stream rather than this wrapper instance.
+   * Separate InternalFleetClient wrappers connected through one connection
+   * file receive the same relay_inbound events and must share uncorrelated
+   * teammate claims. That file is the durable stream boundary: its broker
+   * fingerprint may change during a rebind while existing listeners move to
+   * the replacement, so the claim scope must not change with it. Separately
+   * injected clients can still be the same stream, so a
+   * caller-supplied scope or the actual broker URL is used next. When neither
+   * exists, all unknown injected clients share one conservative scope rather
+   * than unsafely claiming independence from wrapper-object identity.
+   */
+  async messageStreamIdentity(): Promise<string | object> {
+    if (this.#messageStreamScope !== undefined) return this.#messageStreamScope
+    if (this.#connectionStreamScope) return this.#connectionStreamScope
+    if (this.#client.baseUrl) return internalBrokerStreamIdentity(canonicalBrokerUrl(this.#client.baseUrl))
+    return UNKNOWN_INJECTED_BROKER_STREAM
+  }
+
   async createPreview(input: PreviewStartInput): Promise<PreviewReference> {
     assertSelfNode(input.node)
     if (!this.#previewManager) throw new Error('Tailscale preview provider is not configured')
@@ -632,7 +723,11 @@ export class InternalFleetClient implements FleetClient {
     await this.#callBroker('sendMessage', (client) => client.sendMessage(messageInputFrom(input)))
   }
 
-  async waitForInjected(input: SendInput, opts?: { timeoutMs?: number }): Promise<{ eventId: string; targets: string[] }> {
+  async waitForInjected(input: SendInput, opts?: { timeoutMs?: number }): Promise<{
+    eventId: string
+    targets: string[]
+    duplicateDeliveryPossible?: true
+  }> {
     this.#ensureEventSubscription()
     const targetWasReady = this.#readyAgentNames.has(input.to)
     const injectedSequenceAtSendStart = this.#injectedByAgent.get(input.to)?.sequence ?? 0
@@ -674,6 +769,7 @@ export class InternalFleetClient implements FleetClient {
         reject,
         resendInFlight: false,
         resendTriggered: false,
+        duplicateDeliveryPossible: false,
         settled: false,
       }
       this.#pendingInjected.set(eventId, pending)
@@ -944,6 +1040,31 @@ export class InternalFleetClient implements FleetClient {
   }
 
   #resolvePendingInjected(pending: PendingInjectedWait, eventId: string): void {
+    if (pending.settled) return
+    const confirmation = {
+      eventId,
+      targets: pending.targets,
+      ...(pending.duplicateDeliveryPossible ? { duplicateDeliveryPossible: true as const } : {}),
+    }
+    if (pending.resendInFlight) {
+      // A readiness-triggered resend has already left the process. Keep this
+      // logical delivery pending until that send returns so callers cannot
+      // release their correlation claim while the duplicate is still being
+      // issued. The positive acknowledgement makes the delivery timeout
+      // irrelevant; a blocked resend must retain the claim rather than turn a
+      // confirmed delivery into an ambiguous timeout.
+      pending.confirmed ??= confirmation
+      clearTimeout(pending.timeout)
+      if (pending.resendTimer) clearTimeout(pending.resendTimer)
+      return
+    }
+    this.#settlePendingInjected(pending, confirmation)
+  }
+
+  #settlePendingInjected(
+    pending: PendingInjectedWait,
+    confirmation: { eventId: string; targets: string[]; duplicateDeliveryPossible?: true },
+  ): void {
     if (pending.settled) return
     pending.settled = true
     this.#activeInjectedWaits.delete(pending)
@@ -952,7 +1073,7 @@ export class InternalFleetClient implements FleetClient {
     for (const pendingEventId of pending.eventIds) {
       this.#pendingInjected.delete(pendingEventId)
     }
-    pending.resolve({ eventId, targets: pending.targets })
+    pending.resolve(confirmation)
   }
 
   #rejectPendingInjected(pending: PendingInjectedWait, error: Error): void {
@@ -978,8 +1099,19 @@ export class InternalFleetClient implements FleetClient {
   async #resendPendingInjected(pending: PendingInjectedWait): Promise<void> {
     try {
       const result = await this.#callBroker('sendMessage', (client) => client.sendMessage(messageInputFrom(pending.input)))
+      // Every still-viable event id predates this resend response. Once the
+      // resend is accepted, either that earlier send or the resend can deliver
+      // the same uncorrelated question, so callers must quarantine the pair.
+      pending.duplicateDeliveryPossible ||= pending.eventIds.size > 0
       pending.resendInFlight = false
       if (pending.settled) return
+      if (pending.confirmed) {
+        this.#settlePendingInjected(pending, {
+          ...pending.confirmed,
+          ...(pending.duplicateDeliveryPossible ? { duplicateDeliveryPossible: true } : {}),
+        })
+        return
+      }
 
       const eventId = result.event_id
       pending.currentEventId = eventId
@@ -996,7 +1128,20 @@ export class InternalFleetClient implements FleetClient {
         this.#failPendingInjectedEvent(pending, eventId, priorFailure)
       }
     } catch (error) {
+      // A transport failure can follow provider acceptance. Preserve the same
+      // conservative duplicate signal whenever an earlier send is still live.
+      pending.duplicateDeliveryPossible ||= pending.eventIds.size > 0
       pending.resendInFlight = false
+      if (pending.settled) return
+      if (pending.confirmed) {
+        // A transport rejection can follow provider acceptance. Once a resend
+        // left this process, conservatively assume it may still deliver.
+        this.#settlePendingInjected(pending, {
+          ...pending.confirmed,
+          ...(pending.duplicateDeliveryPossible ? { duplicateDeliveryPossible: true } : {}),
+        })
+        return
+      }
       if (pending.eventIds.size === 0) {
         this.#rejectPendingInjected(pending, error instanceof Error ? error : new Error(String(error)))
       } else {
@@ -1009,7 +1154,9 @@ export class InternalFleetClient implements FleetClient {
   }
 
   #rejectInjected(eventId: string, reason?: string): void {
-    const error = new Error(reason ? `Delivery failed for ${eventId}: ${reason}` : `Delivery failed for ${eventId}`)
+    const error = new FleetDeliveryRejectedError(
+      reason ? `Delivery failed for ${eventId}: ${reason}` : `Delivery failed for ${eventId}`,
+    )
     this.#failedDeliveries.set(eventId, error)
     this.#failedDeliveryIds.push(eventId)
     if (this.#failedDeliveryIds.length > 500) {
@@ -1350,10 +1497,12 @@ function spawnResultFrom(handle: SpawnedHandleLike, resolvedPid = handle.pid): S
 
 export function resolveAgentRelayMcpCommand(): AgentRelayMcpCommand | undefined {
   try {
-    const packageJsonPath = requireForResolve.resolve('agent-relay/package.json')
-    const cliPath = join(dirname(packageJsonPath), 'dist', 'cli', 'index.js')
+    // Use Factory's wrapper around the Agent Relay MCP server. It preserves all
+    // existing Relay tools and adds the worker-facing discover/ask tools from
+    // #139. This path exists in both a source checkout and the packed package.
+    const cliPath = fileURLToPath(new URL('../../bin/factory.mjs', import.meta.url))
     accessSync(cliPath, constants.R_OK)
-    return { command: process.execPath, args: [cliPath, 'mcp'] }
+    return { command: process.execPath, args: [cliPath, 'teammate-mcp'] }
   } catch {
     return undefined
   }
diff --git a/src/fleet/relay-fleet-client.test.ts b/src/fleet/relay-fleet-client.test.ts
index 9de22526..73a336b7 100644
--- a/src/fleet/relay-fleet-client.test.ts
+++ b/src/fleet/relay-fleet-client.test.ts
@@ -45,6 +45,9 @@ class FakeMessaging {
   readonly agentListFilters: unknown[] = []
   agentPresenceCalls = 0
   meName = 'relay-controller'
+  workspaceId = 'workspace-test'
+  workspaceInfoCalls = 0
+  workspaceInfoError: Error | undefined
 
   readonly agents = {
     list: async (filter: unknown) => {
@@ -66,6 +69,14 @@ class FakeMessaging {
     list: async () => this.nodeRows as RelayNode[],
   }
 
+  readonly workspace = {
+    info: async () => {
+      this.workspaceInfoCalls += 1
+      if (this.workspaceInfoError) throw this.workspaceInfoError
+      return { id: this.workspaceId }
+    },
+  }
+
   readonly messages = {
     send: async (input: { channel: string; text: string; mode?: 'wait' | 'steer' }) => {
       this.channelSends.push(input)
@@ -815,6 +826,50 @@ describe('RelayFleetClient', () => {
     expect(messaging.channelSends).toEqual([{ channel: 'wf-factory', text: 'update', mode: 'steer' }])
   })
 
+  it('identifies message streams by Relay workspace rather than client wrapper', async () => {
+    const messagingOne = new FakeMessaging()
+    const messagingTwo = new FakeMessaging()
+    const messagingOther = new FakeMessaging()
+    messagingOne.workspaceId = 'shared-workspace'
+    messagingTwo.workspaceId = 'shared-workspace'
+    messagingOther.workspaceId = 'other-workspace'
+
+    const one = createClient(messagingOne)
+    const two = createClient(messagingTwo)
+    const other = createClient(messagingOther)
+
+    const oneIdentity = await one.messageStreamIdentity()
+    await expect(two.messageStreamIdentity()).resolves.toBe(oneIdentity)
+    await expect(other.messageStreamIdentity()).resolves.not.toBe(await one.messageStreamIdentity())
+    expect(messagingOne.workspaceInfoCalls).toBe(1)
+  })
+
+  it('shares a conservative fallback across unidentified injected wrappers', async () => {
+    const messagingOne = new FakeMessaging()
+    const messagingTwo = new FakeMessaging()
+    messagingOne.workspaceInfoError = new Error('workspace.info unavailable')
+    messagingTwo.workspaceInfoError = new Error('workspace.info unavailable')
+
+    const one = createClient(messagingOne)
+    const two = createClient(messagingTwo)
+
+    await expect(one.messageStreamIdentity()).resolves.toBe(await two.messageStreamIdentity())
+  })
+
+  it('preserves known-distinct injected streams through explicit scopes', async () => {
+    const messagingOne = new FakeMessaging()
+    const messagingTwo = new FakeMessaging()
+    messagingOne.workspaceInfoError = new Error('workspace.info unavailable')
+    messagingTwo.workspaceInfoError = new Error('workspace.info unavailable')
+
+    const one = createClient(messagingOne, { messageStreamScope: 'workspace-one' })
+    const two = createClient(messagingTwo, { messageStreamScope: 'workspace-two' })
+
+    await expect(one.messageStreamIdentity()).resolves.not.toBe(await two.messageStreamIdentity())
+    expect(messagingOne.workspaceInfoCalls).toBe(0)
+    expect(messagingTwo.workspaceInfoCalls).toBe(0)
+  })
+
   it('confirms injected tasks with the sent message id', async () => {
     const messaging = new FakeMessaging()
     const fleet = createClient(messaging)
@@ -876,6 +931,50 @@ describe('RelayFleetClient', () => {
     expect(fleet.trackedAgents().has('ar-1-impl')).toBe(false)
   })
 
+  it('lets a worker-side teammate client observe replies without claiming the Factory lifecycle action', async () => {
+    const messaging = new FakeMessaging()
+    messaging.connectEvent = { type: 'connected' }
+    const fleet = createClient(messaging, { registerLifecycleAction: false })
+    const messages: Array<{ from: string; target: string; body: string }> = []
+    fleet.onAgentMessage((message) => messages.push(message))
+
+    await fleet.whenMessagesObservable()
+    expect(messaging.connected).toBe(1)
+    expect(messaging.commandRegistrations).toEqual([])
+
+    messaging.emit('any', {
+      type: 'dmReceived',
+      message: relayMessage({
+        text: 'answer',
+        from: { name: 'infra-agent' },
+        target: { kind: 'agent', agentName: 'factory-worker' },
+      }),
+    })
+    expect(messages).toEqual([expect.objectContaining({
+      from: 'infra-agent',
+      target: 'factory-worker',
+      body: 'answer',
+    })])
+  })
+
+  it('does not report teammate replies observable until the socket handshake is confirmed', async () => {
+    const messaging = new FakeMessaging()
+    const fleet = createClient(messaging, { registerLifecycleAction: false })
+    const ready = fleet.whenMessagesObservable()
+    let settled = false
+    void ready.then(() => { settled = true })
+
+    await flush()
+    expect(messaging.connected).toBe(1)
+    expect(fleet.fleetConnectStatus().state).toBe('dialed')
+    expect(settled).toBe(false)
+
+    messaging.emit('any', { type: 'connected' })
+    await ready
+    expect(settled).toBe(true)
+    expect(fleet.fleetConnectStatus().state).toBe('connected')
+  })
+
   it('routes durable lifecycle actions through the authenticated identity when factory and broker are absent', async () => {
     const messaging = new FakeMessaging()
     messaging.meName = 'relay-controller-7'
diff --git a/src/fleet/relay-fleet-client.ts b/src/fleet/relay-fleet-client.ts
index 1e61302d..bb93b27a 100644
--- a/src/fleet/relay-fleet-client.ts
+++ b/src/fleet/relay-fleet-client.ts
@@ -1,9 +1,12 @@
+import { createHash } from 'node:crypto'
+
 import { AgentRelay } from '@agent-relay/sdk'
 
 import { describeControlPlaneError } from './control-plane-circuit'
 import { resolveRelayAgentToken, resolveRelayWorkspaceKey } from './relay-workspace-key'
 
-import type { AgentLifecycleSignal, AgentMessage, AgentUsage, Capability, FleetClient, FleetConnectStatus, NodeCapability, PreviewReference, PreviewStartInput, PreviewSweepInput, PreviewSweepResult, RosterEntry, SendInput, SpawnInput, SpawnResult } from '../ports/fleet'
+import type { AgentLifecycleSignal, AgentMessage, AgentUsage, Capability, FleetClient, FleetConnectStatus, NodeCapability, PreviewReference, PreviewStartInput, PreviewSweepInput, PreviewSweepResult, RosterEntry, SendInput, SpawnInput, SpawnResult, TeammateAgent, TeammateQuery } from '../ports/fleet'
+import { RelaycastTeammateDirectory, type TeammateDirectory } from './teammates'
 import type {
   RelayActionInvocation,
   RelayActionInvocationAck,
@@ -41,6 +44,12 @@ export interface RelayClientFactoryOptions {
 export interface RelayFleetClientOptions {
   /** Agent-scoped messaging surface. When provided, identity bootstrap is skipped. */
   messaging?: RelayMessaging
+  /**
+   * Stable identity for an injected inbound message stream when the messaging
+   * surface cannot report its Relay workspace. Reuse it across wrappers for
+   * the same stream; use distinct values only for known-distinct streams.
+   */
+  messageStreamScope?: string | object
   workspaceKey?: string
   agentToken?: string
   /** Workspace agent identity the factory registers/rotates for itself. */
@@ -51,8 +60,14 @@ export interface RelayFleetClientOptions {
   fetch?: typeof globalThis.fetch
   /** Stable workspace action used for durable agent lifecycle reports. */
   lifecycleActionName?: string
+  /** Worker-side teammate clients observe DMs but do not own Factory's lifecycle action. */
+  registerLifecycleAction?: boolean
   /** Engine base URL override. Absent means the SDK default (cast.agentrelay.com). */
   baseUrl?: string
+  /** Card-aware directory seam. Defaults to Relaycast GET /v1/a2a/directory. */
+  teammateDirectory?: TeammateDirectory
+  directoryFetch?: typeof globalThis.fetch
+  directoryTimeoutMs?: number
   /** Timeout for a spawn/release invocation to reach a terminal ack status. */
   spawnAckTimeoutMs?: number
   pollIntervalMs?: number
@@ -213,10 +228,16 @@ export class RelayFleetClient implements FleetClient {
   // therefore createFleet({ backend: 'relay' })) never throws merely because no
   // token is configured.
   #messaging: RelayMessaging | undefined
+  #teammateDirectory: TeammateDirectory | undefined
   #messagingReady: Promise<RelayMessaging> | undefined
+  #messageStreamIdentityReady: Promise<string | object> | undefined
   #lifecycleActionReady: Promise<void> | undefined
   #authenticatedAgentName: string
   #eventsStarted = false
+  #eventSubscriptionReady?: Promise<void>
+  #messageObservabilityReady?: Promise<void>
+  #resolveMessageObservability?: () => void
+  #rejectMessageObservability?: (error: Error) => void
   #disposed = false
   /**
    * The fleet socket's own status.
@@ -258,6 +279,7 @@ export class RelayFleetClient implements FleetClient {
     this.#log = options.log ?? (() => {})
     this.#readOnly = options.readOnly ?? false
     this.#messaging = options.messaging
+    this.#teammateDirectory = options.teammateDirectory
   }
 
   /** Agents spawned through this client that have not exited or been released. */
@@ -552,8 +574,87 @@ export class RelayFleetClient implements FleetClient {
     }
   }
 
+  async discoverTeammates(query: TeammateQuery): Promise<TeammateAgent[]> {
+    this.#teammateDirectory ??= this.#createTeammateDirectory()
+    return await this.#teammateDirectory.discover(query)
+  }
+
   // `from`/`data` are not representable on the agent-scoped messaging surface:
   // every send is authored by the factory's own agent identity.
+  //
+  // That identity is also the `target` stamped on every inbound message (see
+  // `#emitAgentMessage`), so a reply waiter must match against it rather than
+  // against the `from` its caller asked to send as.
+  //
+  // `#authenticatedAgentName` starts life as the CONFIGURED `agentName` and is
+  // only replaced with the server's answer once something has called
+  // `agents.me()`. Returning it synchronously would hand out that pre-auth
+  // guess, which is wrong whenever an injected `messaging` or an existing
+  // `agentToken` authenticates as a different name. Resolve it for real.
+  async effectiveSender(): Promise<string | undefined> {
+    const messaging = await this.#ensureMessaging()
+    const identity = await messaging.agents.me()
+    const resolved = identity.name?.trim()
+    if (resolved) this.#authenticatedAgentName = resolved
+    return this.#authenticatedAgentName
+  }
+
+  /**
+   * Identify the actual Relay workspace stream rather than this wrapper.
+   * Multiple clients authenticated to one workspace receive the same direct
+   * messages, so their uncorrelated ask/reply claims must contend.
+   */
+  async messageStreamIdentity(): Promise<string | object | undefined> {
+    this.#messageStreamIdentityReady ??= (async () => {
+      const messaging = await this.#ensureMessaging()
+      const baseUrl = canonicalRelayBaseUrl(this.#options.baseUrl)
+
+      const explicitScope = this.#options.messageStreamScope
+      if (this.#options.messaging && explicitScope !== undefined) {
+        if (typeof explicitScope === 'string') {
+          const fingerprint = createHash('sha256').update(explicitScope).digest('base64url')
+          return `relay:${baseUrl}:explicit:${fingerprint}`
+        }
+        return explicitScope
+      }
+
+      try {
+        const workspace = await messaging.workspace.info()
+        const workspaceId = typeof workspace.id === 'string' ? workspace.id.trim() : ''
+        if (workspaceId) return `relay:${baseUrl}:workspace:${workspaceId}`
+      } catch (error) {
+        // Older/injected messaging surfaces may not expose workspace.info(). A
+        // credential fingerprint or the injected object below still preserves
+        // a stable boundary without failing an otherwise usable message path.
+        this.#log(`Unable to resolve Relay workspace identity for teammate claims: ${errorMessage(error)}`)
+      }
+
+      // Separate injected wrappers are not evidence of separate streams. If
+      // the surface cannot identify its workspace and the caller supplied no
+      // explicit scope, fail closed by sharing one endpoint-scoped registry.
+      // This may conservatively serialize identical participants in two legacy
+      // workspaces, but it cannot admit two waiters for one unknown stream.
+      if (this.#options.messaging) return `relay:${baseUrl}:injected:unknown`
+
+      const env = this.#options.env
+      const agentToken = resolveRelayAgentToken({
+        agentToken: this.#registeredAgentToken ?? this.#options.agentToken,
+        ...(env ? { env } : {}),
+      })
+      const workspaceKey = resolveRelayWorkspaceKey({
+        workspaceKey: this.#options.workspaceKey,
+        ...(env ? { env, activeWorkspaceKey: () => undefined } : {}),
+      })
+      const credential = agentToken ?? workspaceKey
+      if (credential) {
+        const fingerprint = createHash('sha256').update(credential).digest('base64url')
+        return `relay:${baseUrl}:credential:${fingerprint}`
+      }
+      return messaging
+    })()
+    return await this.#messageStreamIdentityReady
+  }
+
   async sendMessage(input: SendInput): Promise<void> {
     await this.#send(input)
   }
@@ -630,6 +731,7 @@ export class RelayFleetClient implements FleetClient {
     }
 
     this.#disposed = true
+    this.#settleMessageObservability(new Error('Relay fleet client disposed before its event stream connected'))
     if (this.#watchTimer) {
       clearInterval(this.#watchTimer)
       this.#watchTimer = undefined
@@ -674,6 +776,26 @@ export class RelayFleetClient implements FleetClient {
     }
   }
 
+  #createTeammateDirectory(): TeammateDirectory {
+    const env = this.#options.env
+    const token = resolveRelayWorkspaceKey({
+      workspaceKey: this.#options.workspaceKey,
+      ...(env ? { env, activeWorkspaceKey: () => undefined } : {}),
+    }) ?? resolveRelayAgentToken({
+      agentToken: this.#options.agentToken,
+      ...(env ? { env } : {}),
+    })
+    if (!token) {
+      throw new Error('RelayFleetClient teammate discovery requires a workspace key or agent token')
+    }
+    return new RelaycastTeammateDirectory({
+      baseUrl: this.#options.baseUrl,
+      token,
+      fetch: this.#options.directoryFetch,
+      timeoutMs: this.#options.directoryTimeoutMs,
+    })
+  }
+
   #ensureMessaging(): Promise<RelayMessaging> {
     if (this.#messaging) return Promise.resolve(this.#messaging)
     this.#messagingReady ??= this.#bootstrapMessaging().catch((error) => {
@@ -1223,8 +1345,9 @@ export class RelayFleetClient implements FleetClient {
       attempts: this.#fleetConnect.attempts + 1,
       lastAttemptAtMs: this.#now(),
     }
-    void this.#subscribeEvents().catch((error) => {
+    this.#eventSubscriptionReady = this.#subscribeEvents().catch((error) => {
       this.#eventsStarted = false
+      this.#eventSubscriptionReady = undefined
       // The rejection now lands in a field a health surface can publish. It kept
       // going only to `#log` before, which is why a fleet client that never
       // connected was indistinguishable from a healthy one everywhere.
@@ -1235,7 +1358,51 @@ export class RelayFleetClient implements FleetClient {
         lastError: describeControlPlaneError(error),
       }
       this.#log(`relay fleet event subscription failed: ${errorMessage(error)}`)
+      throw error
     })
+    // Nothing here awaits it -- callers that must not miss an inbound message
+    // use `whenMessagesObservable()`. The rejection is re-thrown for them and
+    // swallowed here so a background subscription failure stays non-fatal.
+    void this.#eventSubscriptionReady.catch(() => {})
+  }
+
+  // `onAgentMessage` returns as soon as the listener is in the local set, but
+  // the SDK handler behind it is installed by an async chain (messaging
+  // bootstrap, then lifecycle registration, then `events.connect()`). A caller
+  // that registers a listener and immediately sends can therefore lose a fast
+  // reply that lands before the transport is actually listening. Await this
+  // between the two.
+  async whenMessagesObservable(): Promise<void> {
+    this.#ensureEventSubscription()
+    await this.#eventSubscriptionReady
+    if (this.#fleetConnect.state === 'connected') return
+    await this.#messageObservabilityPromise()
+  }
+
+  #messageObservabilityPromise(): Promise<void> {
+    if (this.#fleetConnect.state === 'connected') return Promise.resolve()
+    if (!this.#messageObservabilityReady) {
+      const pending = new Promise<void>((resolve, reject) => {
+        this.#resolveMessageObservability = resolve
+        this.#rejectMessageObservability = reject
+      })
+      this.#messageObservabilityReady = pending
+      // The ask-level deadline may stop awaiting this shared handshake first.
+      // Retain the waiter for another caller, but never surface its later
+      // transport rejection as an unhandled promise.
+      void pending.catch(() => {})
+    }
+    return this.#messageObservabilityReady
+  }
+
+  #settleMessageObservability(error?: Error): void {
+    const resolve = this.#resolveMessageObservability
+    const reject = this.#rejectMessageObservability
+    this.#messageObservabilityReady = undefined
+    this.#resolveMessageObservability = undefined
+    this.#rejectMessageObservability = undefined
+    if (error) reject?.(error)
+    else resolve?.()
   }
 
   fleetConnectStatus(): FleetConnectStatus {
@@ -1244,7 +1411,9 @@ export class RelayFleetClient implements FleetClient {
 
   async #subscribeEvents(): Promise<void> {
     const messaging = await this.#ensureMessaging()
-    await this.#ensureLifecycleAction(messaging)
+    if (this.#options.registerLifecycleAction !== false) {
+      await this.#ensureLifecycleAction(messaging)
+    }
     if (this.#disposed) return
     // Listen before dialing so a synchronous lifecycle event cannot race past
     // the observer. `connect()` is void: returning only proves the SDK accepted
@@ -1301,6 +1470,7 @@ export class RelayFleetClient implements FleetClient {
           lastFailureAtMs: now,
           lastError: 'RelayEventStreamDisconnected',
         }
+        this.#settleMessageObservability(new Error('Relay event stream disconnected before becoming observable'))
         return
       case 'error':
         this.#fleetConnect = {
@@ -1309,6 +1479,7 @@ export class RelayFleetClient implements FleetClient {
           lastFailureAtMs: now,
           lastError: 'RelayEventStreamError',
         }
+        this.#settleMessageObservability(new Error('Relay event stream failed before becoming observable'))
         return
       case 'reconnecting':
         this.#fleetConnect = { ...this.#fleetConnect, state: 'connecting' }
@@ -1323,6 +1494,7 @@ export class RelayFleetClient implements FleetClient {
           ...(this.#fleetConnect.state !== 'connected' ? { lastConnectedAtMs: now } : {}),
           lastError: undefined,
         }
+        this.#settleMessageObservability()
     }
   }
 
@@ -1719,6 +1891,15 @@ function isIdentityMovedError(error: unknown): boolean {
   return /agent_identity_conflict|no longer has expected id/i.test(errorMessage(error))
 }
 
+function canonicalRelayBaseUrl(value: string | undefined): string {
+  const candidate = value ?? DEFAULT_RELAY_BASE_URL
+  try {
+    return new URL(candidate).toString().replace(/\/$/u, '')
+  } catch {
+    return candidate.replace(/\/$/u, '')
+  }
+}
+
 function isUnknownRecipientError(error: unknown): boolean {
   const message = errorMessage(error)
   return /not[ _]found|unknown (agent|recipient)|no such (agent|recipient)|unregistered/i.test(message)
diff --git a/src/fleet/teammates.test.ts b/src/fleet/teammates.test.ts
new file mode 100644
index 00000000..04426c85
--- /dev/null
+++ b/src/fleet/teammates.test.ts
@@ -0,0 +1,743 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { FleetDeliveryRejectedError } from '../index'
+import { FakeFleetClient } from '../testing/fakes'
+import { askTeammate, RelaycastTeammateDirectory } from './teammates'
+
+const directoryRows = [{
+  name: 'infra-agent',
+  address: 'infra-agent',
+  skills: [{ id: 'infra-watch', name: 'Infra Watch', tags: ['operations'] }],
+  tags: ['on-call'],
+  url: 'https://relay.example/a2a/rpc',
+  kind: 'native',
+  status: 'online',
+}, {
+  name: 'review-agent',
+  address: 'review-agent',
+  skills: [{ id: 'code-review', name: 'Code Review' }],
+  tags: ['quality'],
+  url: 'https://review.example/a2a/rpc',
+  kind: 'a2a',
+  status: 'active',
+}]
+
+describe('RelaycastTeammateDirectory', () => {
+  it('sends skill/tag filters and rejects unfiltered server rows client-side', async () => {
+    const fetch = vi.fn<typeof globalThis.fetch>(async (input) => {
+      const url = new URL(String(input))
+      return new Response(JSON.stringify({
+        ok: true,
+        // Relaycast may match a registered card alias that is not repeated in
+        // the returned row. Preserve that server match for free-text queries.
+        data: url.searchParams.has('q') ? [directoryRows[1]] : directoryRows,
+      }), { status: 200 })
+    })
+    const directory = new RelaycastTeammateDirectory({
+      baseUrl: 'https://relay.example/',
+      token: 'rk_live_test',
+      fetch,
+    })
+
+    await expect(directory.discover({ skill: 'infra-watch' })).resolves.toEqual([
+      expect.objectContaining({ name: 'infra-agent', address: 'infra-agent', kind: 'native' }),
+    ])
+    await expect(directory.discover({ skill: 'missing' })).resolves.toEqual([])
+    await expect(directory.discover({ tag: 'quality' })).resolves.toEqual([
+      expect.objectContaining({ name: 'review-agent', kind: 'a2a' }),
+    ])
+    await expect(directory.discover({ q: 'private-card-alias' })).resolves.toEqual([
+      expect.objectContaining({ name: 'review-agent' }),
+    ])
+
+    const firstUrl = fetch.mock.calls[0]?.[0]
+    expect(String(firstUrl)).toBe('https://relay.example/v1/a2a/directory?skill=infra-watch')
+    expect(fetch.mock.calls[0]?.[1]).toMatchObject({
+      headers: expect.objectContaining({ authorization: 'Bearer rk_live_test' }),
+    })
+    expect(String(fetch.mock.calls[3]?.[0])).toBe('https://relay.example/v1/a2a/directory?q=private-card-alias')
+  })
+})
+
+describe('askTeammate', () => {
+  it('discovers a target, sends the question, and resolves only its reply', async () => {
+    const fleet = new FakeFleetClient()
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+
+    const asked = askTeammate(fleet, {
+      from: 'factory-worker',
+      question: 'Is the deploy healthy?',
+      skill: 'infra-watch',
+      timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    fleet.emitAgentMessage({ from: 'someone-else', target: 'factory-worker', body: 'wrong' })
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'different-worker', body: 'also wrong' })
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'All systems green.' })
+
+    await expect(asked).resolves.toMatchObject({
+      teammate: { name: 'infra-agent' },
+      reply: { from: 'infra-agent', body: 'All systems green.' },
+    })
+    expect(fleet.messages[0]).toMatchObject({
+      to: 'infra-agent',
+      from: 'factory-worker',
+      text: 'Is the deploy healthy?',
+      mode: 'wait',
+      data: { factoryCapability: 'ask-a-teammate', requester: 'factory-worker' },
+    })
+  })
+
+  it('returns a bounded timeout when the teammate never replies', async () => {
+    vi.useFakeTimers()
+    try {
+      const fleet = new FakeFleetClient()
+      fleet.teammates.push({
+        name: 'silent-agent',
+        address: 'silent-agent',
+        skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+        tags: [],
+        url: 'https://relay.example/a2a/rpc',
+        kind: 'native',
+      })
+      const asked = askTeammate(fleet, {
+        from: 'factory-worker',
+        question: 'Hello?',
+        skill: 'infra-watch',
+        timeoutMs: 50,
+      })
+      const rejected = expect(asked).rejects.toThrow('Timed out waiting for a reply from a teammate after 50ms')
+      await vi.advanceTimersByTimeAsync(50)
+      await rejected
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('refuses to choose an arbitrary teammate without a target or discovery query', async () => {
+    const fleet = new FakeFleetClient()
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker',
+      question: 'Whoever is first, please answer.',
+    })).rejects.toThrow('requires a discovered teammate or a skill/tag/query')
+  })
+
+  // A backend that cannot represent `SendInput.from` authors every send as its
+  // own identity, so the teammate replies to THAT name and the reply arrives
+  // addressed to it -- never to the worker that asked. Matching on the caller's
+  // `from` would discard every valid reply and time out. (#178 review, codex P1)
+  const relayLike = () => {
+    const fleet = new FakeFleetClient()
+    Object.assign(fleet, { effectiveSender: async () => 'factory-app' })
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+    return fleet
+  }
+
+  it('matches the reply against the identity the backend actually sends as', async () => {
+    const fleet = relayLike()
+
+    const asked = askTeammate(fleet, {
+      from: 'factory-worker',
+      question: 'Is the deploy healthy?',
+      teammate: fleet.teammates[0],
+      timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    // Addressed to the authenticated sender, which is what this backend receives.
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-app', body: 'All systems green.' })
+
+    await expect(asked).resolves.toMatchObject({
+      reply: { from: 'infra-agent', target: 'factory-app', body: 'All systems green.' },
+    })
+  })
+
+  it('rejects a second unanswered question to one teammate when replies cannot be correlated', async () => {
+    const fleet = relayLike()
+    const first = askTeammate(fleet, {
+      from: 'factory-worker',
+      question: 'Is the deploy healthy?',
+      teammate: fleet.teammates[0],
+      timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+
+    // `data` is dropped by such a backend, so `requestId` never reaches the
+    // teammate and a reply cannot be attributed to one of two open questions.
+    // Refusing beats resolving the wrong waiter. (#178 review, codex P2)
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker',
+      question: 'And the database?',
+      teammate: fleet.teammates[0],
+      timeoutMs: 1_000,
+    })).rejects.toThrow(/already has an unanswered question to "infra-agent" as "factory-app"/u)
+
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-app', body: 'All systems green.' })
+    await expect(first).resolves.toMatchObject({ reply: { body: 'All systems green.' } })
+
+    // The refused ask never sent, so this is only the second message on the
+    // wire -- and the claim is released once the first settles, so the pair is
+    // reusable rather than poisoned for the rest of the process.
+    const third = askTeammate(fleet, {
+      from: 'factory-worker',
+      question: 'And the database?',
+      teammate: fleet.teammates[0],
+      timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(2))
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-app', body: 'Healthy.' })
+    await expect(third).resolves.toMatchObject({ reply: { body: 'Healthy.' } })
+  })
+
+  it('canonicalizes @ aliases when claiming a requester-teammate pair', async () => {
+    const fleet = new FakeFleetClient()
+    const teammate = {
+      name: 'infra-agent',
+      address: '@infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native' as const,
+    }
+    fleet.teammates.push(teammate)
+
+    const first = askTeammate(fleet, {
+      from: '@factory-worker', question: 'q1', teammate, timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker',
+      question: 'q2',
+      teammate: { ...teammate, address: 'infra-agent' },
+      timeoutMs: 1_000,
+    })).rejects.toThrow(/already has an unanswered question to "infra-agent"/u)
+
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'answer-1' })
+    await expect(first).resolves.toMatchObject({ reply: { body: 'answer-1' } })
+  })
+
+  it('shares one claim across discovery kinds for the same reply address', async () => {
+    const fleet = new FakeFleetClient()
+    const discovered = {
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'a2a' as const,
+    }
+    const direct = { ...discovered, kind: 'native' as const }
+    fleet.teammates.push(discovered)
+
+    const first = askTeammate(fleet, {
+      from: 'factory-worker', question: 'q1', teammate: discovered, timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker', question: 'q2', teammate: direct, timeoutMs: 1_000,
+    })).rejects.toThrow(/already has an unanswered question to "infra-agent"/u)
+
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'answer-1' })
+    await expect(first).resolves.toMatchObject({ reply: { body: 'answer-1' } })
+  })
+
+  it('claims a discovered external address and its accepted name alias atomically', async () => {
+    const fleet = new FakeFleetClient()
+    const discovered = {
+      name: 'infra-agent',
+      address: 'ext-infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'a2a' as const,
+    }
+    const direct = { ...discovered, address: 'infra-agent', kind: 'native' as const }
+    fleet.teammates.push(discovered)
+
+    const first = askTeammate(fleet, {
+      from: 'factory-worker', question: 'q1', teammate: discovered, timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker', question: 'q2', teammate: direct, timeoutMs: 1_000,
+    })).rejects.toThrow(/already has an unanswered question to "infra-agent"/u)
+
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'answer-1' })
+    await expect(first).resolves.toMatchObject({ reply: { body: 'answer-1' } })
+  })
+
+  it('keeps distinct requesters to one teammate independent', async () => {
+    // Different reply targets are separate keys, so these must not contend.
+    const fleet = new FakeFleetClient()
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+    const a = askTeammate(fleet, {
+      from: 'worker-a', question: 'q1', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })
+    const b = askTeammate(fleet, {
+      from: 'worker-b', question: 'q2', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(2))
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'worker-a', body: 'answer-a' })
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'worker-b', body: 'answer-b' })
+    await expect(a).resolves.toMatchObject({ reply: { body: 'answer-a' } })
+    await expect(b).resolves.toMatchObject({ reply: { body: 'answer-b' } })
+  })
+
+  // `AgentMessage` echoes no request field on ANY backend, so the SAME
+  // requester asking one teammate twice is ambiguous even where `from` is
+  // carried faithfully. An earlier version of this guard exempted such
+  // backends; the exemption was wrong. (#178 review, codex P2 second pass)
+  it('refuses a same-requester overlap even on a backend that carries `from`', async () => {
+    const fleet = new FakeFleetClient()
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+    const first = askTeammate(fleet, {
+      from: 'factory-worker', question: 'q1', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker', question: 'q2', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })).rejects.toThrow(/already has an unanswered question to "infra-agent"/u)
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'answer-1' })
+    await expect(first).resolves.toMatchObject({ reply: { body: 'answer-1' } })
+  })
+
+  // Two callers passing the same query resolve to the same teammate, so the
+  // claim has to be taken against the RESOLVED target, not against a
+  // caller-supplied one. (#178 review, codex P2 second pass)
+  it('claims a discovered teammate, so query-based asks contend too', async () => {
+    const fleet = new FakeFleetClient()
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+    const first = askTeammate(fleet, {
+      from: 'factory-worker', question: 'q1', skill: 'infra-watch', timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker', question: 'q2', skill: 'infra-watch', timeoutMs: 1_000,
+    })).rejects.toThrow(/already has an unanswered question to "infra-agent"/u)
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'answer-1' })
+    await expect(first).resolves.toMatchObject({ reply: { body: 'answer-1' } })
+  })
+
+  // `onAgentMessage` can return before the transport is really listening, so a
+  // reply that lands between registration and connection is lost. The wait
+  // must happen before the send. (#178 review, codex P1 third pass)
+  it('waits for the message transport to be observable before sending', async () => {
+    const fleet = new FakeFleetClient()
+    let openTransport = () => {}
+    const observable = new Promise<void>((r) => { openTransport = r })
+    Object.assign(fleet, { whenMessagesObservable: () => observable })
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+    const asked = askTeammate(fleet, {
+      from: 'factory-worker', question: 'q', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })
+    // Give the async body every chance to run ahead of the gate.
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(fleet.messages).toHaveLength(0)
+    openTransport()
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'answered' })
+    await expect(asked).resolves.toMatchObject({ reply: { body: 'answered' } })
+  })
+
+  it('ignores matching messages that arrive before the question is sent', async () => {
+    const fleet = new FakeFleetClient()
+    let openTransport = () => {}
+    const observable = new Promise<void>((resolve) => { openTransport = resolve })
+    Object.assign(fleet, { whenMessagesObservable: () => observable })
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+    const asked = askTeammate(fleet, {
+      from: 'factory-worker', question: 'q', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })
+    await Promise.resolve()
+    await Promise.resolve()
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'proactive before send' })
+    openTransport()
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'answer after send' })
+    await expect(asked).resolves.toMatchObject({ reply: { body: 'answer after send' } })
+  })
+
+  it('retains the pair claim after an early reply until delivery retries have stopped', async () => {
+    let resolveFirstDelivery!: (value: { eventId: string; targets: string[] }) => void
+    let firstDelivery = true
+    class PendingDeliveryFleetClient extends FakeFleetClient {
+      override async waitForInjected(
+        input: Parameters<FakeFleetClient['waitForInjected']>[0],
+      ): Promise<{ eventId: string; targets: string[] }> {
+        if (!firstDelivery) return await super.waitForInjected(input)
+        firstDelivery = false
+        this.messages.push(input)
+        return await new Promise((resolve) => { resolveFirstDelivery = resolve })
+      }
+    }
+    const fleet = new PendingDeliveryFleetClient()
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+    const first = askTeammate(fleet, {
+      from: 'factory-worker', question: 'q1', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'early answer to q1' })
+    await expect(first).resolves.toMatchObject({ reply: { body: 'early answer to q1' } })
+
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker', question: 'q2', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })).rejects.toThrow(/already has an unanswered question/u)
+
+    resolveFirstDelivery({ eventId: 'event-1', targets: ['infra-agent'] })
+    await Promise.resolve()
+    await Promise.resolve()
+    const second = askTeammate(fleet, {
+      from: 'factory-worker', question: 'q2', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(2))
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'answer to q2' })
+    await expect(second).resolves.toMatchObject({ reply: { body: 'answer to q2' } })
+  })
+
+  it('quarantines the pair after an accepted resend can produce a duplicate reply', async () => {
+    let resolveFirstDelivery!: (value: {
+      eventId: string
+      targets: string[]
+      duplicateDeliveryPossible?: true
+    }) => void
+    let firstDelivery = true
+    class DuplicateDeliveryFleetClient extends FakeFleetClient {
+      override async waitForInjected(
+        input: Parameters<FakeFleetClient['waitForInjected']>[0],
+      ): Promise<{ eventId: string; targets: string[]; duplicateDeliveryPossible?: true }> {
+        if (!firstDelivery) return await super.waitForInjected(input)
+        firstDelivery = false
+        this.messages.push(input)
+        return await new Promise((resolve) => { resolveFirstDelivery = resolve })
+      }
+    }
+    const fleet = new DuplicateDeliveryFleetClient()
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+    const first = askTeammate(fleet, {
+      from: 'factory-worker', question: 'q1', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'first answer to q1' })
+    await expect(first).resolves.toMatchObject({ reply: { body: 'first answer to q1' } })
+
+    resolveFirstDelivery({
+      eventId: 'event-1',
+      targets: ['infra-agent'],
+      duplicateDeliveryPossible: true,
+    })
+    await Promise.resolve()
+    await Promise.resolve()
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker', question: 'q2', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })).rejects.toThrow(/after a duplicate delivery was accepted/u)
+
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'duplicate answer to q1' })
+    await expect(askTeammate(fleet, {
+      from: 'factory-worker', question: 'q3', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })).rejects.toThrow(/after a duplicate delivery was accepted/u)
+    expect(fleet.messages).toHaveLength(1)
+  })
+
+  // A reply to an abandoned question is indistinguishable from a reply to a
+  // fresh one, and an unrelated DM cannot prove which message is the old
+  // answer. A confirmed timed-out send therefore stays quarantined for this
+  // client until the protocol supplies correlation.
+  // (#178 review, codex P2 third pass)
+  it('keeps a confirmed timed-out pair quarantined across time and unrelated messages', async () => {
+    vi.useFakeTimers()
+    try {
+      const fleet = new FakeFleetClient()
+      fleet.teammates.push({
+        name: 'infra-agent',
+        address: 'infra-agent',
+        skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+        tags: [],
+        url: 'https://relay.example/a2a/rpc',
+        kind: 'native',
+      })
+      const first = askTeammate(fleet, {
+        from: 'factory-worker', question: 'q1', teammate: fleet.teammates[0], timeoutMs: 20,
+      })
+      const rejected = expect(first).rejects.toThrow(/Timed out waiting for a reply/u)
+      await Promise.resolve()
+      await Promise.resolve()
+      await Promise.resolve()
+      expect(fleet.messages).toHaveLength(1)
+      await vi.advanceTimersByTimeAsync(20)
+      await rejected
+
+      // Moving far beyond the former 2 * timeout window MUST NOT reopen the
+      // pair while the abandoned response is still outstanding.
+      await vi.advanceTimersByTimeAsync(2_000)
+      await expect(askTeammate(fleet, {
+        from: 'factory-worker', question: 'q2', teammate: fleet.teammates[0], timeoutMs: 20,
+      })).rejects.toThrow(/quarantining "infra-agent" for "factory-worker" after a timed-out question/u)
+
+      fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'unrelated proactive DM' })
+      await expect(askTeammate(fleet, {
+        from: 'factory-worker', question: 'q3', teammate: fleet.teammates[0], timeoutMs: 20,
+      })).rejects.toThrow(/quarantining "infra-agent" for "factory-worker" after a timed-out question/u)
+
+      fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'late answer to q1' })
+      await expect(askTeammate(fleet, {
+        from: 'factory-worker', question: 'q4', teammate: fleet.teammates[0], timeoutMs: 20,
+      })).rejects.toThrow(/quarantining "infra-agent" for "factory-worker" after a timed-out question/u)
+      expect(fleet.messages).toHaveLength(1)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('releases a timed-out quarantine after the pending delivery definitively fails', async () => {
+    vi.useFakeTimers()
+    try {
+      let rejectFirstDelivery = (_error: Error) => {}
+      let firstDelivery = true
+      class LateFailingFleetClient extends FakeFleetClient {
+        override async waitForInjected(input: Parameters<FakeFleetClient['waitForInjected']>[0]): Promise<{ eventId: string; targets: string[] }> {
+          if (!firstDelivery) return await super.waitForInjected(input)
+          firstDelivery = false
+          this.messages.push(input)
+          return await new Promise((_, reject) => { rejectFirstDelivery = reject })
+        }
+      }
+      const fleet = new LateFailingFleetClient()
+      fleet.teammates.push({
+        name: 'infra-agent',
+        address: 'infra-agent',
+        skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+        tags: [],
+        url: 'https://relay.example/a2a/rpc',
+        kind: 'native',
+      })
+      const first = askTeammate(fleet, {
+        from: 'factory-worker', question: 'q1', teammate: fleet.teammates[0], timeoutMs: 20,
+      })
+      const rejected = expect(first).rejects.toThrow(/Timed out waiting for a reply/u)
+      await Promise.resolve()
+      await Promise.resolve()
+      await Promise.resolve()
+      expect(fleet.messages).toHaveLength(1)
+      await vi.advanceTimersByTimeAsync(20)
+      await rejected
+
+      await expect(askTeammate(fleet, {
+        from: 'factory-worker', question: 'q2', teammate: fleet.teammates[0], timeoutMs: 1_000,
+      })).rejects.toThrow(/quarantining "infra-agent"/u)
+
+      rejectFirstDelivery(new FleetDeliveryRejectedError('delivery definitively rejected'))
+      await Promise.resolve()
+      await Promise.resolve()
+
+      const retry = askTeammate(fleet, {
+        from: 'factory-worker', question: 'q3', teammate: fleet.teammates[0], timeoutMs: 1_000,
+      })
+      await Promise.resolve()
+      await Promise.resolve()
+      await Promise.resolve()
+      expect(fleet.messages).toHaveLength(2)
+      fleet.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'answer to q3' })
+      await expect(retry).resolves.toMatchObject({ reply: { body: 'answer to q3' } })
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('keeps quarantine when pending delivery confirmation times out ambiguously', async () => {
+    vi.useFakeTimers()
+    try {
+      let rejectConfirmation = (_error: Error) => {}
+      class AmbiguousFleetClient extends FakeFleetClient {
+        override async waitForInjected(input: Parameters<FakeFleetClient['waitForInjected']>[0]): Promise<{ eventId: string; targets: string[] }> {
+          this.messages.push(input)
+          return await new Promise((_, reject) => { rejectConfirmation = reject })
+        }
+      }
+      const fleet = new AmbiguousFleetClient()
+      fleet.teammates.push({
+        name: 'infra-agent',
+        address: 'infra-agent',
+        skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+        tags: [],
+        url: 'https://relay.example/a2a/rpc',
+        kind: 'native',
+      })
+      const first = askTeammate(fleet, {
+        from: 'factory-worker', question: 'q1', teammate: fleet.teammates[0], timeoutMs: 20,
+      })
+      const rejected = expect(first).rejects.toThrow(/Timed out waiting for a reply/u)
+      await Promise.resolve()
+      await Promise.resolve()
+      await Promise.resolve()
+      await vi.advanceTimersByTimeAsync(20)
+      await rejected
+
+      rejectConfirmation(new Error('Timed out waiting for delivery_injected for event-1'))
+      await Promise.resolve()
+      await Promise.resolve()
+
+      await expect(askTeammate(fleet, {
+        from: 'factory-worker', question: 'q2', teammate: fleet.teammates[0], timeoutMs: 1_000,
+      })).rejects.toThrow(/quarantining "infra-agent"/u)
+      expect(fleet.messages).toHaveLength(1)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  // Two clients authenticated to the same message stream receive the same
+  // replies. Their wrapper-object identities must not admit two waiters.
+  it('shares claims across fleet clients for one message stream', async () => {
+    const teammate = {
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native' as const,
+    }
+    const one = new FakeFleetClient()
+    const two = new FakeFleetClient()
+    const sharedStream = async () => 'relay:https://relay.example:workspace:shared'
+    Object.assign(one, { effectiveSender: async () => 'factory-app', messageStreamIdentity: sharedStream })
+    Object.assign(two, { effectiveSender: async () => 'factory-app', messageStreamIdentity: sharedStream })
+
+    const first = askTeammate(one, {
+      from: 'worker-one', question: 'q1', teammate, timeoutMs: 1_000,
+    })
+    await vi.waitFor(() => expect(one.messages).toHaveLength(1))
+    await expect(askTeammate(two, {
+      from: 'worker-two', question: 'q2', teammate, timeoutMs: 1_000,
+    })).rejects.toThrow(/already has an unanswered question to "infra-agent" as "factory-app"/u)
+    expect(two.messages).toHaveLength(0)
+
+    one.emitAgentMessage({ from: 'infra-agent', target: 'factory-app', body: 'answer-1' })
+    await expect(first).resolves.toMatchObject({ reply: { body: 'answer-1' } })
+  })
+
+  // Identical participant names in genuinely distinct message streams cannot
+  // collide and must remain independent. (#178 review, codex P2)
+  it('keeps claims independent across distinct message streams', async () => {
+    const teammate = {
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native' as const,
+    }
+    const one = new FakeFleetClient()
+    const two = new FakeFleetClient()
+    Object.assign(one, { messageStreamIdentity: async () => 'relay:https://relay.example:workspace:one' })
+    Object.assign(two, { messageStreamIdentity: async () => 'relay:https://relay.example:workspace:two' })
+    one.teammates.push(teammate)
+    two.teammates.push(teammate)
+
+    const a = askTeammate(one, { from: 'factory-worker', question: 'q', teammate, timeoutMs: 1_000 })
+    await vi.waitFor(() => expect(one.messages).toHaveLength(1))
+    // Same requester, same teammate name, different backend: must be allowed.
+    const b = askTeammate(two, { from: 'factory-worker', question: 'q', teammate, timeoutMs: 1_000 })
+    await vi.waitFor(() => expect(two.messages).toHaveLength(1))
+
+    one.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'from-one' })
+    two.emitAgentMessage({ from: 'infra-agent', target: 'factory-worker', body: 'from-two' })
+    await expect(a).resolves.toMatchObject({ reply: { body: 'from-one' } })
+    await expect(b).resolves.toMatchObject({ reply: { body: 'from-two' } })
+  })
+
+  // A backend whose authenticated identity is only knowable after a round trip
+  // must be awaited; matching on a pre-auth guess rejects every reply.
+  // (#178 review, codex P1 second pass)
+  it('awaits an asynchronously resolved sender before matching replies', async () => {
+    const fleet = new FakeFleetClient()
+    let resolveIdentity = () => {}
+    const identityKnown = new Promise<void>((r) => { resolveIdentity = r })
+    Object.assign(fleet, {
+      effectiveSender: async () => {
+        await identityKnown
+        return 'authenticated-name'
+      },
+    })
+    fleet.teammates.push({
+      name: 'infra-agent',
+      address: 'infra-agent',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: [],
+      url: 'https://relay.example/a2a/rpc',
+      kind: 'native',
+    })
+    const asked = askTeammate(fleet, {
+      from: 'configured-guess', question: 'q', teammate: fleet.teammates[0], timeoutMs: 1_000,
+    })
+    // Nothing may be sent until the real identity is known.
+    expect(fleet.messages).toHaveLength(0)
+    resolveIdentity()
+    await vi.waitFor(() => expect(fleet.messages).toHaveLength(1))
+    fleet.emitAgentMessage({ from: 'infra-agent', target: 'authenticated-name', body: 'answered' })
+    await expect(asked).resolves.toMatchObject({ reply: { body: 'answered' } })
+  })
+})
diff --git a/src/fleet/teammates.ts b/src/fleet/teammates.ts
new file mode 100644
index 00000000..8eb3169c
--- /dev/null
+++ b/src/fleet/teammates.ts
@@ -0,0 +1,479 @@
+import { randomUUID } from 'node:crypto'
+
+import { A2aSkillSchema } from '@relaycast/a2a'
+
+import { FleetDeliveryRejectedError, type AgentMessage, type FleetClient, type TeammateAgent, type TeammateQuery } from '../ports/fleet'
+
+export const DEFAULT_RELAYCAST_BASE_URL = 'https://cast.agentrelay.com'
+export const DEFAULT_TEAMMATE_DIRECTORY_TIMEOUT_MS = 10_000
+export const DEFAULT_ASK_TEAMMATE_TIMEOUT_MS = 30_000
+
+export interface TeammateDirectory {
+  discover(query: TeammateQuery): Promise<TeammateAgent[]>
+}
+
+export interface RelaycastTeammateDirectoryOptions {
+  baseUrl?: string
+  token?: string
+  fetch?: typeof globalThis.fetch
+  timeoutMs?: number
+}
+
+/** Relaycast-backed, card-aware teammate discovery. */
+export class RelaycastTeammateDirectory implements TeammateDirectory {
+  readonly #baseUrl: string
+  readonly #token?: string
+  readonly #fetch: typeof globalThis.fetch
+  readonly #timeoutMs: number
+
+  constructor(options: RelaycastTeammateDirectoryOptions = {}) {
+    this.#baseUrl = normalizeBaseUrl(options.baseUrl ?? DEFAULT_RELAYCAST_BASE_URL)
+    this.#token = nonEmpty(options.token)
+    this.#fetch = options.fetch ?? globalThis.fetch
+    this.#timeoutMs = positiveTimeout(options.timeoutMs, DEFAULT_TEAMMATE_DIRECTORY_TIMEOUT_MS)
+  }
+
+  async discover(query: TeammateQuery): Promise<TeammateAgent[]> {
+    const normalized = normalizeQuery(query)
+    const url = new URL('/v1/a2a/directory', `${this.#baseUrl}/`)
+    if (normalized.skill) url.searchParams.set('skill', normalized.skill)
+    if (normalized.tag) url.searchParams.set('tag', normalized.tag)
+    if (normalized.q) url.searchParams.set('q', normalized.q)
+
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), this.#timeoutMs)
+    try {
+      const response = await this.#fetch(url, {
+        method: 'GET',
+        headers: {
+          accept: 'application/json',
+          ...(this.#token ? { authorization: `Bearer ${this.#token}` } : {}),
+        },
+        signal: controller.signal,
+      })
+      const payload = await readJson(response)
+      if (!response.ok) {
+        throw new Error(`Relaycast teammate directory returned ${response.status}: ${errorDetail(payload)}`)
+      }
+
+      const rows = directoryRows(payload)
+        .map(parseDirectoryEntry)
+        .filter((entry): entry is TeammateAgent => Boolean(entry))
+        // Keep the client honest even if a server version ignores a filter. This
+        // also makes an unknown exact skill/tag deterministically return [].
+        .filter((entry) => matchesQuery(entry, normalized))
+
+      const unique = new Map<string, TeammateAgent>()
+      for (const entry of rows) unique.set(`${entry.kind}:${entry.address}`, entry)
+      return [...unique.values()]
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw new Error(`Timed out querying the Relaycast teammate directory after ${this.#timeoutMs}ms`, { cause: error })
+      }
+      throw error
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+}
+
+export interface AskTeammateInput {
+  /** Worker identity that is asking the question. */
+  from: string
+  question: string
+  /** Use an already-discovered target, or provide a query to resolve one. */
+  teammate?: TeammateAgent
+  skill?: string
+  tag?: string
+  q?: string
+  timeoutMs?: number
+}
+
+export interface AskTeammateResult {
+  requestId: string
+  teammate: TeammateAgent
+  reply: AgentMessage
+}
+
+/**
+ * Claimed teammate pairs per inbound message stream.
+ *
+ * `AgentMessage` carries no echoed request field on ANY backend -- there is no
+ * reply-to, and `SendInput.data` is not reflected back -- so a reply can never
+ * be attributed to one of two questions to the same teammate. Two devices
+ * follow from that:
+ *
+ * - While an ask is waiting, the pair is claimed. A second ask
+ *   is refused rather than resolved with an answer that may not be its own.
+ *   The claim set uses every sender identity accepted for the RESOLVED
+ *   teammate and is taken after discovery, so aliases and direct asks contend.
+ * - After a TIMEOUT a confirmed send stays quarantined for this stream. There
+ *   is no safe time- or message-based release: the transport places no upper
+ *   bound on a late answer, and an unrelated DM cannot be distinguished from
+ *   that answer. Only a definitive late delivery failure frees the pair. When
+ *   `AgentMessage` grows an observable correlation field, this registry can be
+ *   replaced by a requestId check.
+ *
+ * `FleetClient.messageStreamIdentity()` lets distinct client wrappers that
+ * observe one authenticated stream share a registry while keeping genuinely
+ * separate workspaces independent. Backends that do not expose a stream
+ * identity fall back to their client object.
+ */
+type AskClaim = 'waiting' | 'timed-out-uncorrelated' | 'duplicate-uncorrelated'
+type AskClaimScope = string | object
+
+const objectScopedAsks = new WeakMap<object, Map<string, AskClaim>>()
+const namedScopedAsks = new Map<string, Map<string, AskClaim>>()
+
+function claimsFor(scope: AskClaimScope): Map<string, AskClaim> {
+  if (typeof scope === 'string') {
+    let claims = namedScopedAsks.get(scope)
+    if (!claims) {
+      claims = new Map()
+      namedScopedAsks.set(scope, claims)
+    }
+    return claims
+  }
+
+  let claims = objectScopedAsks.get(scope)
+  if (!claims) {
+    claims = new Map()
+    objectScopedAsks.set(scope, claims)
+  }
+  return claims
+}
+
+function deleteClaims(scope: AskClaimScope | undefined, claims: Map<string, AskClaim> | undefined, keys: string[]): void {
+  if (!claims) return
+  for (const key of keys) claims.delete(key)
+  if (typeof scope === 'string' && claims.size === 0 && namedScopedAsks.get(scope) === claims) {
+    namedScopedAsks.delete(scope)
+  }
+}
+
+/**
+ * Resolve a teammate (when needed), deliver a relay DM, and wait for that
+ * teammate's reply. The listener is armed before sending so fast replies cannot
+ * race the waiter; the whole operation has one bounded deadline.
+ *
+ * Replies are matched against the identity the backend actually authors as --
+ * see `FleetClient.effectiveSender` -- because a backend that cannot represent
+ * `from` receives the teammate's reply under its own identity instead.
+ */
+export async function askTeammate(fleet: FleetClient, input: AskTeammateInput): Promise<AskTeammateResult> {
+  const timeoutMs = positiveTimeout(input.timeoutMs, DEFAULT_ASK_TEAMMATE_TIMEOUT_MS)
+  const requestId = randomUUID()
+  const from = requiredText(input.from, 'askTeammate.from')
+  const question = requiredText(input.question, 'askTeammate.question')
+  const query = normalizeQuery({ skill: input.skill, tag: input.tag, q: input.q })
+  if (!input.teammate && !query.skill && !query.tag && !query.q) {
+    throw new Error('askTeammate requires a discovered teammate or a skill/tag/query')
+  }
+  const deadline = Date.now() + timeoutMs
+
+  return await new Promise<AskTeammateResult>((resolve, reject) => {
+    let settled = false
+    let deliveryState: 'not-started' | 'pending' | 'confirmed' = 'not-started'
+    let unsubscribe = () => {}
+    let claimScope: AskClaimScope | undefined
+    let claimRegistry: Map<string, AskClaim> | undefined
+    let claimed: string[] = []
+    let timedOutClaim: string[] = []
+    let deliveryOperationSettled = false
+    let duplicateDeliveryPossible = false
+    const release = () => {
+      deleteClaims(claimScope, claimRegistry, claimed)
+      claimed = []
+    }
+    const quarantine = () => {
+      if (claimRegistry) {
+        for (const key of claimed) claimRegistry.set(key, 'timed-out-uncorrelated')
+      }
+      timedOutClaim = claimed
+      claimed = []
+    }
+    const quarantineDuplicate = () => {
+      if (claimRegistry) {
+        for (const key of claimed) claimRegistry.set(key, 'duplicate-uncorrelated')
+      }
+      claimed = []
+    }
+    const releaseTimedOutClaim = () => {
+      deleteClaims(claimScope, claimRegistry, timedOutClaim)
+      timedOutClaim = []
+    }
+    const finish = (result: AskTeammateResult) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timeout)
+      unsubscribe()
+      // A reply can race ahead of waitForInjected's delivery receipt. Keep the
+      // uncorrelated pair claimed until that waiter has stopped, because its
+      // readiness path may still resend this first question in the meantime.
+      if (deliveryOperationSettled) {
+        if (duplicateDeliveryPossible) quarantineDuplicate()
+        else release()
+      }
+      resolve(result)
+    }
+    const fail = (error: unknown) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timeout)
+      unsubscribe()
+      release()
+      reject(error)
+    }
+    const timeout = setTimeout(() => {
+      if (settled) return
+      settled = true
+      unsubscribe()
+      if (deliveryState === 'not-started') release()
+      else quarantine()
+      reject(new Error(`Timed out waiting for a reply from a teammate after ${timeoutMs}ms`))
+    }, timeoutMs)
+
+    void (async () => {
+      // Whoever the teammate will actually reply to. Resolved before the
+      // listener is armed, and awaited because a backend may need an auth round
+      // trip to know its own name. Falls back to `from` on a backend that
+      // carries the requested sender faithfully.
+      const replyTarget = (await fleet.effectiveSender?.()) ?? from
+      const teammate = input.teammate ?? (await fleet.discoverTeammates(query))[0]
+      if (settled) return
+      if (!teammate) {
+        throw new Error('No teammate matched the requested skill/tag/query')
+      }
+      if (!fleet.onAgentMessage) {
+        throw new Error('This fleet backend cannot observe teammate replies')
+      }
+      // Client-object identity is not necessarily the message-stream identity:
+      // two Relay clients may authenticate to one workspace/agent and observe
+      // the same DMs. Scope the uncorrelated claim to the shared stream when a
+      // backend can identify it, with the client object as the safe fallback.
+      claimScope = (await fleet.messageStreamIdentity?.()) ?? fleet
+      if (settled) return
+      // Claimed against the RESOLVED teammate, so a discovery-based ask
+      // contends with an explicit one for the same target. Taken before the
+      // listener is armed so two waiters can never both accept one reply.
+      const askKeys = teammateClaimKeys(replyTarget, teammate)
+      claimRegistry = claimsFor(claimScope)
+      const existingClaim = askKeys.map((key) => claimRegistry?.get(key)).find((claim) => claim !== undefined)
+      if (existingClaim !== undefined) {
+        throw new Error(
+          existingClaim === 'waiting'
+            ? `askTeammate already has an unanswered question to "${teammate.name}" as "${replyTarget}". ` +
+              'A reply carries no correlation id, so it cannot be attributed to one of two open ' +
+              'questions; await the first before asking again.'
+            : existingClaim === 'timed-out-uncorrelated'
+              ? `askTeammate is quarantining "${teammate.name}" for "${replyTarget}" after a timed-out ` +
+                'question. Replies carry no correlation id and have no maximum delay, so retry is ' +
+                'unsafe for this message stream until the protocol supplies correlation.'
+              : `askTeammate is quarantining "${teammate.name}" for "${replyTarget}" after a duplicate ` +
+                'delivery was accepted. Its later reply cannot be distinguished from a fresh answer, so ' +
+                'retry is unsafe for this message stream until the protocol supplies correlation.',
+        )
+      }
+      for (const key of askKeys) claimRegistry.set(key, 'waiting')
+      claimed = askKeys
+      // `onAgentMessage` can return before the transport is really listening,
+      // so wait for observability BEFORE sending -- otherwise a fast reply
+      // lands in the gap and is lost.
+      unsubscribe = fleet.onAgentMessage((message) => {
+        // The listener is armed before transport observability, but nothing
+        // received before the send starts can answer this question.
+        if (deliveryState === 'not-started') return
+        if (!sameAgent(message.from, teammate.address) && !sameAgent(message.from, teammate.name)) return
+        if (!sameAgent(message.target, replyTarget)) return
+        finish({ requestId, teammate, reply: message })
+      })
+      const send = {
+        to: teammate.address,
+        from,
+        text: question,
+        mode: 'wait' as const,
+        data: {
+          factoryCapability: 'ask-a-teammate',
+          requestId,
+          requester: from,
+        },
+      }
+      await fleet.whenMessagesObservable?.()
+      if (settled) return
+      deliveryState = 'pending'
+      try {
+        if (fleet.waitForInjected) {
+          const receipt = await fleet.waitForInjected(send, { timeoutMs: Math.max(1, deadline - Date.now()) })
+          duplicateDeliveryPossible = receipt.duplicateDeliveryPossible === true
+        } else {
+          await fleet.sendMessage(send)
+        }
+        deliveryState = 'confirmed'
+      } catch (error) {
+        // The timeout may win while delivery confirmation is still pending.
+        // Only positive, correlated transport rejection proves no answer can
+        // arrive. An ordinary waitForInjected timeout is ambiguous: the send
+        // may already have landed, so its uncorrelated pair stays quarantined.
+        if (settled && timedOutClaim.length > 0 && error instanceof FleetDeliveryRejectedError) {
+          releaseTimedOutClaim()
+          return
+        }
+        throw error
+      } finally {
+        deliveryOperationSettled = true
+        // A timed-out confirmed/ambiguous send moved the keys into quarantine;
+        // only an early successful reply still owns `claimed` here.
+        if (settled && timedOutClaim.length === 0) {
+          if (duplicateDeliveryPossible) quarantineDuplicate()
+          else release()
+        }
+      }
+    })().catch(fail)
+  })
+}
+
+function normalizeQuery(query: TeammateQuery): TeammateQuery {
+  return {
+    skill: nonEmpty(query.skill),
+    tag: nonEmpty(query.tag),
+    q: nonEmpty(query.q),
+  }
+}
+
+function matchesQuery(entry: TeammateAgent, query: TeammateQuery): boolean {
+  const skill = normalizedComparable(query.skill)
+  if (skill && !entry.skills.some((candidate) =>
+    normalizedComparable(candidate.id) === skill || normalizedComparable(candidate.name) === skill)) return false
+
+  const tag = normalizedComparable(query.tag)
+  if (tag) {
+    const tags = [...entry.tags, ...entry.skills.flatMap((candidate) => candidate.tags ?? [])]
+    if (!tags.some((candidate) => normalizedComparable(candidate) === tag)) return false
+  }
+
+  // Relaycast also searches aliases that are intentionally not exposed in a
+  // directory row (for example, an A2A card name behind its derived ext-* relay
+  // identity). Re-applying q here would discard those valid server matches.
+  // Exact skill/tag filters are fully represented by the row, so those remain
+  // enforced client-side to protect callers from an older unfiltered server.
+  return true
+}
+
+function parseDirectoryEntry(value: unknown): TeammateAgent | undefined {
+  const record = asRecord(value)
+  const name = readString(record, 'name')
+  const url = readString(record, 'url', 'endpoint_url', 'endpointUrl')
+  const kind = readString(record, 'kind')
+  if (!name || !url || (kind !== 'native' && kind !== 'a2a')) return undefined
+  try {
+    new URL(url)
+  } catch {
+    return undefined
+  }
+
+  const rawSkills = Array.isArray(record?.skills) ? record.skills : []
+  const skills = rawSkills.flatMap((value) => {
+    const candidate = typeof value === 'string'
+      ? { id: value, name: value }
+      : value
+    const parsed = A2aSkillSchema.safeParse(candidate)
+    return parsed.success ? [parsed.data] : []
+  })
+  const tags = readStrings(record, 'tags')
+  const address = readString(record, 'address', 'relay_name', 'relayName', 'target') ?? name
+  return {
+    name,
+    ...(readString(record, 'description') ? { description: readString(record, 'description') } : {}),
+    skills,
+    url,
+    kind,
+    address,
+    tags,
+    ...(readString(record, 'status') ? { status: readString(record, 'status') } : {}),
+    ...(readString(record, 'certification') ? { certification: readString(record, 'certification') } : {}),
+  }
+}
+
+function directoryRows(payload: unknown): unknown[] {
+  if (Array.isArray(payload)) return payload
+  const record = asRecord(payload)
+  return Array.isArray(record?.data) ? record.data : []
+}
+
+async function readJson(response: Response): Promise<unknown> {
+  const text = await response.text()
+  if (!text) return undefined
+  try {
+    return JSON.parse(text) as unknown
+  } catch (error) {
+    throw new Error('Relaycast teammate directory returned invalid JSON', { cause: error })
+  }
+}
+
+function errorDetail(payload: unknown): string {
+  const record = asRecord(payload)
+  const error = asRecord(record?.error)
+  return readString(error, 'message') ?? readString(record, 'message') ?? 'request failed'
+}
+
+function positiveTimeout(value: number | undefined, fallback: number): number {
+  return Number.isFinite(value) && (value ?? 0) > 0 ? Math.floor(value as number) : fallback
+}
+
+function normalizeBaseUrl(value: string): string {
+  return value.replace(/\/+$/u, '')
+}
+
+function teammateClaimKeys(replyTarget: string, teammate: TeammateAgent): string[] {
+  const target = agentKey(replyTarget)
+  // Claim every sender identity the listener below accepts. Directory kind is
+  // not reply identity, and an external address plus its public name alias can
+  // overlap a direct ask even though their primary addresses differ.
+  return [...new Set([teammate.address, teammate.name].map(agentKey))]
+    .map((sender) => `${target}\u0000${sender}`)
+}
+
+function sameAgent(left: string, right: string): boolean {
+  return agentKey(left) === agentKey(right)
+}
+
+function agentKey(value: string): string {
+  return value.replace(/^@/u, '').toLowerCase()
+}
+
+function normalizedComparable(value: string | undefined): string {
+  return value?.trim().toLowerCase() ?? ''
+}
+
+function nonEmpty(value: string | undefined): string | undefined {
+  const trimmed = value?.trim()
+  return trimmed || undefined
+}
+
+function requiredText(value: string, label: string): string {
+  const normalized = nonEmpty(value)
+  if (!normalized) throw new Error(`${label} must be a non-empty string`)
+  return normalized
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined
+}
+
+function readString(record: Record<string, unknown> | undefined, ...keys: string[]): string | undefined {
+  if (!record) return undefined
+  for (const key of keys) {
+    const value = record[key]
+    if (typeof value === 'string' && value.trim()) return value.trim()
+  }
+  return undefined
+}
+
+function readStrings(record: Record<string, unknown> | undefined, key: string): string[] {
+  const value = record?.[key]
+  return Array.isArray(value)
+    ? [...new Set(value.filter((entry): entry is string => typeof entry === 'string' && Boolean(entry.trim())).map((entry) => entry.trim()))]
+    : []
+}
diff --git a/src/index.ts b/src/index.ts
index 3e5b7861..fc63f40f 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -7,6 +7,7 @@ export { DocumentStateStore, FileStateStore, githubWatchStatePath } from './stat
 export type { DocumentStateStoreOptions, FileStateStoreOptions } from './state/file-state-store.js'
 export { WatchStateDocumentConflictError } from './state/document-store.js'
 export { parseWatchStateDocument } from './state/watch-state-document.js'
+export { FleetDeliveryRejectedError } from './ports'
 export type {
   PersistedWorkspaceState,
   WatchStateDocument,
@@ -94,6 +95,19 @@ export type {
   InternalFleetClientOptions,
 } from './fleet/internal-fleet-client'
 export { RelayFleetClient } from './fleet/relay-fleet-client'
+export {
+  askTeammate,
+  DEFAULT_ASK_TEAMMATE_TIMEOUT_MS,
+  DEFAULT_RELAYCAST_BASE_URL,
+  DEFAULT_TEAMMATE_DIRECTORY_TIMEOUT_MS,
+  RelaycastTeammateDirectory,
+} from './fleet/teammates'
+export type {
+  AskTeammateInput,
+  AskTeammateResult,
+  RelaycastTeammateDirectoryOptions,
+  TeammateDirectory,
+} from './fleet/teammates'
 export {
   RelayfileCloudMountClient,
   resolveFactoryWorkspace,
@@ -233,6 +247,11 @@ export {
   resolveFactoryNodeConfigPath,
   runRelayflowsWorkflow,
 } from './node/factory-node'
+export {
+  deriveFactoryPersonaCard,
+  RelaycastAgentCardPublisher,
+} from './node/factory-persona-card'
+export { startFactoryNode } from './node/factory-node-runtime'
 export { TailscalePreviewManager } from './node/tailscale-preview'
 export type {
   PreviewCommandRunner,
@@ -242,12 +261,23 @@ export type {
 } from './node/tailscale-preview'
 export type {
   FactoryNodeDefinitionOptions,
+  FactoryNodeDefinition,
   FactoryNodeInventoryAgent,
   FactoryNodeInventorySync,
   WorkflowRunner,
   WorkflowRunnerInput,
   WorkflowRunnerResult,
 } from './node/factory-node'
+export type {
+  AgentCardPublisher,
+  FactoryPersonaCardInput,
+  PublishedAgentCard,
+  RelaycastAgentCardPublisherOptions,
+} from './node/factory-persona-card'
+export type {
+  RunningFactoryNode,
+  StartFactoryNodeOptions,
+} from './node/factory-node-runtime'
 export {
   assertInFactoryScope,
   factoryScopeSafety,
@@ -314,6 +344,7 @@ export type {
   ResourceSubscriptionsSdkClientOptions,
 } from './subscriptions'
 export type {
+  A2aSkill,
   Capability,
   Environment,
   EnvironmentProvider,
@@ -353,6 +384,8 @@ export type {
   SpawnInput,
   SpawnResult,
   AgentUsage,
+  TeammateAgent,
+  TeammateQuery,
   GithubRead,
   GithubIssueStatus,
   GithubWriteback,
diff --git a/src/node/factory-node-runtime.ts b/src/node/factory-node-runtime.ts
new file mode 100644
index 00000000..0413caee
--- /dev/null
+++ b/src/node/factory-node-runtime.ts
@@ -0,0 +1,120 @@
+import { startServeNode } from '@agent-relay/fleet'
+
+import type { FleetNodeInfo, RunningNode, ServeNodeOptions } from '@agent-relay/fleet'
+
+import type { AgentCardPublisher, PublishedAgentCard } from './factory-persona-card'
+import type { FactoryNodeDefinition } from './factory-node'
+
+export interface StartFactoryNodeOptions extends Omit<ServeNodeOptions, 'definition' | 'onRegistered'> {
+  definition: FactoryNodeDefinition
+  cardPublisher?: AgentCardPublisher
+  onRegistered?: (info: FleetNodeInfo) => void
+  /** Test seam; production uses @agent-relay/fleet startServeNode. */
+  serve?: (options: ServeNodeOptions) => RunningNode
+}
+
+export interface RunningFactoryNode extends RunningNode {
+  /** Settles only after the online registration hook publishes the persona card. */
+  cardPublished: Promise<PublishedAgentCard | undefined>
+}
+
+/** Start a Factory node and publish its persona card on the node-online edge. */
+export function startFactoryNode(options: StartFactoryNodeOptions): RunningFactoryNode {
+  let resolvePublication!: (value: PublishedAgentCard | undefined) => void
+  let rejectPublication!: (reason: unknown) => void
+  const cardPublished = new Promise<PublishedAgentCard | undefined>((resolve, reject) => {
+    resolvePublication = resolve
+    rejectPublication = reject
+  })
+  let publicationCompleted = false
+  let publicationInFlight = false
+  let publicationRetryRequested = false
+  let publicationTerminal = false
+  let nodeTerminated = false
+  let nodeTerminationReason: unknown
+  const rejectTerminalPublication = (reason: unknown) => {
+    if (publicationCompleted || publicationTerminal) return
+    publicationTerminal = true
+    rejectPublication(reason)
+  }
+  const markNodeTerminated = (reason: unknown) => {
+    if (publicationCompleted || publicationTerminal || nodeTerminated) return
+    nodeTerminated = true
+    nodeTerminationReason = reason
+    if (!publicationInFlight) rejectTerminalPublication(reason)
+  }
+  const serve = options.serve ?? startServeNode
+  const publishCard = () => {
+    const card = options.definition.agentCard
+    if (!card || !options.cardPublisher || publicationCompleted || publicationInFlight || publicationTerminal) return
+    publicationInFlight = true
+    void options.cardPublisher.publishAgentCard(card).then((published) => {
+      publicationInFlight = false
+      publicationRetryRequested = false
+      publicationCompleted = true
+      resolvePublication(published)
+    }, (error) => {
+      publicationInFlight = false
+      if (nodeTerminated) {
+        rejectTerminalPublication(nodeTerminationReason)
+        return
+      }
+      options.warn?.(
+        `Factory persona card publication failed; ${
+          publicationRetryRequested ? 'a registration arrived during publication, retrying now' : 'the next node registration will retry'
+        }: ${error instanceof Error ? error.message : String(error)}`,
+      )
+      if (publicationRetryRequested) {
+        publicationRetryRequested = false
+        publishCard()
+      }
+    })
+  }
+  const running = serve({
+    definition: options.definition,
+    connection: options.connection,
+    ...(options.providerName ? { providerName: options.providerName } : {}),
+    ...(options.triggers ? { triggers: options.triggers } : {}),
+    ...(options.nameOverride ? { nameOverride: options.nameOverride } : {}),
+    ...(options.maxAgentsOverride !== undefined ? { maxAgentsOverride: options.maxAgentsOverride } : {}),
+    ...(options.reconnect !== undefined ? { reconnect: options.reconnect } : {}),
+    ...(options.signal ? { signal: options.signal } : {}),
+    ...(options.logger ? { logger: options.logger } : {}),
+    ...(options.log ? { log: options.log } : {}),
+    ...(options.warn ? { warn: options.warn } : {}),
+    onRegistered(info) {
+      options.onRegistered?.(info)
+      if (publicationCompleted || publicationTerminal) return
+      if (publicationInFlight) {
+        // A reconnect can finish while the previous registration's HTTP write
+        // is still pending. Preserve that edge so a later failure retries
+        // immediately instead of waiting for a third registration.
+        publicationRetryRequested = true
+        return
+      }
+      const card = options.definition.agentCard
+      if (!card) {
+        publicationCompleted = true
+        resolvePublication(undefined)
+        return
+      }
+      if (!options.cardPublisher) {
+        rejectTerminalPublication(new Error('Factory persona node came online without an AgentCardPublisher'))
+        return
+      }
+      publishCard()
+    },
+  })
+  void running.done.then(
+    () => markNodeTerminated(new Error('Factory node stopped before persona card publication completed')),
+    (error) => markNodeTerminated(error),
+  )
+  return {
+    stop: () => {
+      markNodeTerminated(new Error('Factory node was stopped before persona card publication completed'))
+      return running.stop()
+    },
+    done: running.done,
+    cardPublished,
+  }
+}
diff --git a/src/node/factory-node.test.ts b/src/node/factory-node.test.ts
index fd2088b7..591a1668 100644
--- a/src/node/factory-node.test.ts
+++ b/src/node/factory-node.test.ts
@@ -112,6 +112,7 @@ describe('factory node definition', () => {
     const definition = createFactoryNodeDefinition({
       config: nodeConfig(),
       name: 'factory-node',
+      workspaceKey: 'rk_live_node_worker',
       resolveAgentRelayMcpCommand: () => ({ command: '/usr/local/bin/node', args: ['/repo/agent-relay.js', 'mcp'] }),
     })
 
@@ -156,6 +157,8 @@ describe('factory node definition', () => {
           cwd: '/work/factory',
           env: expect.objectContaining({
             RELAY_AGENT_IDENTITY_KEY: 'factory:dispatch:v1:github:agentworkforce/factory#13:implementer',
+            RELAY_WORKSPACE_KEY: 'rk_live_node_worker',
+            RELAY_API_KEY: 'rk_live_node_worker',
           }),
           metadata: {
             factoryRelayMcp: true,
@@ -170,7 +173,9 @@ describe('factory node definition', () => {
     expect(spawns[0].agent.harness_config.env?.RELAY_AGENT_IDENTITY_KEY).toBe(
       'factory:dispatch:v1:github:agentworkforce/factory#13:implementer',
     )
+    expect(spawns[0].agent.harness_config.env?.RELAY_WORKSPACE_KEY).toBe('rk_live_node_worker')
     expect(spawns[0].agent.harness_config.args.join('\n')).toContain('mcp_servers.agent-relay.command="/usr/local/bin/node"')
+    expect(spawns[0].agent.harness_config.args.join('\n')).toContain('"RELAY_WORKSPACE_KEY" = "rk_live_node_worker"')
   })
 
   it('runs workflow:run through the Relayflows SDK in the mapped checkout', async () => {
@@ -439,6 +444,7 @@ describe('factory node definition', () => {
     const pkg = await import('../index')
     expect(typeof pkg.createFactoryNodeDefinition).toBe('function')
     expect(typeof pkg.readFactoryNodeConfigSync).toBe('function')
+    expect(typeof pkg.startFactoryNode).toBe('function')
 
     const definition = pkg.createFactoryNodeDefinition({
       config: nodeConfig({ capabilities: ['spawn:claude', 'workflow:run'] }),
diff --git a/src/node/factory-node.ts b/src/node/factory-node.ts
index c4a10ad4..a0a1bb81 100644
--- a/src/node/factory-node.ts
+++ b/src/node/factory-node.ts
@@ -7,6 +7,7 @@ import type { JsonValue, RestartPolicy, SpawnMode } from '@agent-relay/harness-d
 import type { SpawnPtyInput } from '@agent-relay/harness-driver'
 import { runScriptWorkflow, runWorkflow } from '@relayflows/core'
 import type { WorkflowRunRow } from '@relayflows/core'
+import type { A2aAgentCard } from '@relaycast/a2a'
 import { z } from 'zod'
 
 import { loadFactoryConfig, NodeConfigSchema, type NodeConfig } from '../config/schema'
@@ -17,7 +18,9 @@ import {
   type AgentRelayMcpCommand,
 } from '../fleet/internal-fleet-client'
 import type { Capability, PreviewReference } from '../ports/fleet'
+import { resolveRelayWorkspaceKey } from '../fleet/relay-workspace-key'
 import { TailscalePreviewManager, type PreviewManager } from './tailscale-preview'
+import { deriveFactoryPersonaCard, type FactoryPersonaCardInput } from './factory-persona-card'
 
 export const FACTORY_NODE_CONFIG_ENV = 'FACTORY_NODE_CONFIG'
 export const AGENT_RELAY_FACTORY_NODE_CONFIG_ENV = 'AGENT_RELAY_FACTORY_NODE_CONFIG'
@@ -171,6 +174,14 @@ export interface FactoryNodeDefinitionOptions {
   workflowRunner?: WorkflowRunner
   resolveAgentRelayMcpCommand?: () => AgentRelayMcpCommand | undefined
   previewManager?: PreviewManager
+  /** Relay workspace credential inherited by worker MCP processes. */
+  workspaceKey?: string
+  /** Persona hosted by this node; its canonical A2A card is attached for online publication. */
+  persona?: FactoryPersonaCardInput
+}
+
+export interface FactoryNodeDefinition extends FleetNodeDefinition {
+  readonly agentCard?: A2aAgentCard
 }
 
 export interface WorkflowRunnerInput {
@@ -205,8 +216,13 @@ export interface FactoryNodeInventorySync {
   agents: FactoryNodeInventoryAgent[]
 }
 
-export function createFactoryNodeDefinition(options: FactoryNodeDefinitionOptions): FleetNodeDefinition {
+export function createFactoryNodeDefinition(options: FactoryNodeDefinitionOptions): FactoryNodeDefinition {
   const config = options.config
+  // `agent-relay node up` normalizes flag, env, project-pin, and active-store
+  // selection into RELAY_WORKSPACE_KEY before it imports this definition.
+  // Capture it in the node closure so every worker gets authenticated teammate
+  // tools even when the caller did not pass an explicit credential.
+  const workspaceKey = options.workspaceKey ?? resolveRelayWorkspaceKey()
   const capabilities = normalizeCapabilities([
     ...config.capabilities,
     ...(config.preview ? ['preview:tailscale-serve'] : []),
@@ -244,17 +260,21 @@ export function createFactoryNodeDefinition(options: FactoryNodeDefinitionOption
       metadata: { ...metadata, handler: 'harness', cli: capabilityCli[capability] },
     }, async (input, ctx) => runSpawnCapability(capability, input, ctx, {
       config,
+      workspaceKey,
       resolveAgentRelayMcpCommand: options.resolveAgentRelayMcpCommand ?? resolveAgentRelayMcpCommand,
     })) as unknown as FleetCapabilityValue
   }
 
-  return defineNode({
+  const definition = defineNode({
     name: options.name ?? defaultFactoryNodeName(),
     ...(options.maxAgents !== undefined ? { maxAgents: options.maxAgents } : {}),
     capabilities: handlers,
     tags: options.tags ?? defaultFactoryNodeTags(config),
     version: options.version ?? 'factory-node-v1',
   })
+  return options.persona
+    ? { ...definition, agentCard: deriveFactoryPersonaCard(options.persona) }
+    : definition
 }
 
 async function runPreviewCapability(
@@ -350,7 +370,7 @@ async function runSpawnCapability(
   capability: Extract<FactoryNodeCapability, 'spawn:claude' | 'spawn:codex'>,
   input: SpawnCapabilityInput,
   ctx: FleetActionContext,
-  deps: Pick<FactoryNodeDefinitionOptions, 'config' | 'resolveAgentRelayMcpCommand'>,
+  deps: Pick<FactoryNodeDefinitionOptions, 'config' | 'workspaceKey' | 'resolveAgentRelayMcpCommand'>,
 ): Promise<unknown> {
   if (!input.name) {
     throw new Error(`${capability} requires name or agent`)
@@ -377,7 +397,7 @@ async function runSpawnCapability(
     ? buildRelayMcpHarnessConfig(
         spawnInput,
         command,
-        undefined,
+        deps.workspaceKey,
         input.identityKey,
       ) as FleetSpawnAgentInput['agent']['harness_config']
     : undefined
diff --git a/src/node/factory-persona-card.test.ts b/src/node/factory-persona-card.test.ts
new file mode 100644
index 00000000..ffdb8832
--- /dev/null
+++ b/src/node/factory-persona-card.test.ts
@@ -0,0 +1,292 @@
+import { readFileSync } from 'node:fs'
+
+import { A2aAgentCardSchema } from '@relaycast/a2a'
+import { describe, expect, it, vi } from 'vitest'
+
+import { createFactoryNodeDefinition, parseFactoryNodeConfig } from './factory-node'
+import { deriveFactoryPersonaCard, RelaycastAgentCardPublisher } from './factory-persona-card'
+import { startFactoryNode } from './factory-node-runtime'
+
+const persona = JSON.parse(readFileSync(
+  new URL('../../.agentworkforce/agents/factory-feature-guardian/persona.json', import.meta.url),
+  'utf8',
+)) as unknown
+
+describe('Factory persona cards', () => {
+  it('matches the canonical mapper for runtime flags and an intent fallback skill', () => {
+    const cardWithRuntimeFlags = deriveFactoryPersonaCard({
+      persona: {
+        ...(persona as Record<string, unknown>),
+        skills: [],
+        capabilities: {
+          streaming: true,
+          pushNotifications: { enabled: true },
+        },
+      },
+      baseUrl: 'https://agent.example',
+      version: '1.2.3',
+    })
+
+    expect(cardWithRuntimeFlags).toMatchObject({
+      skills: [{
+        id: 'relay-orchestrator',
+        name: 'Relay Orchestrator',
+      }],
+      capabilities: {
+        streaming: true,
+        pushNotifications: true,
+      },
+    })
+
+    const cardWithoutDeclaredSkills = deriveFactoryPersonaCard({
+      persona: {
+        ...(persona as Record<string, unknown>),
+        skills: [],
+        capabilities: {},
+      },
+      baseUrl: 'https://agent.example',
+      version: '1.2.3',
+    })
+    expect(cardWithoutDeclaredSkills.skills).toEqual([expect.objectContaining({
+      id: 'relay-orchestrator',
+      name: 'Relay Orchestrator',
+    })])
+  })
+
+  it('derives a shared-schema card and publishes it on the node-online edge', async () => {
+    const published: unknown[] = []
+    const fetch = vi.fn<typeof globalThis.fetch>(async (_url, init) => {
+      published.push(JSON.parse(String(init?.body)))
+      return new Response(JSON.stringify({
+        ok: true,
+        data: { relay_name: 'ext-factory-feature-guardian-a1b2c3d4', certification: 'level_1' },
+      }), { status: 201 })
+    })
+    const definition = createFactoryNodeDefinition({
+      config: parseFactoryNodeConfig({
+        workspaceId: 'workspace-1',
+        capabilities: ['spawn:codex'],
+        clonePaths: { 'AgentWorkforce/factory': '/work/factory' },
+        dryRun: false,
+      }),
+      name: 'factory-persona-node',
+      persona: {
+        persona,
+        baseUrl: 'https://relay.example',
+        version: '1.0.0',
+      },
+    })
+    expect(() => A2aAgentCardSchema.parse(definition.agentCard)).not.toThrow()
+    expect(definition.agentCard).toMatchObject({
+      name: 'factory-feature-guardian',
+      skills: [expect.objectContaining({ id: 'factory-feature-verification' })],
+    })
+
+    const publisher = new RelaycastAgentCardPublisher({
+      baseUrl: 'https://relay.example',
+      token: 'rk_live_test',
+      fetch,
+    })
+    const running = startFactoryNode({
+      definition,
+      connection: { nodeId: 'node-1', nodeToken: 'nt_live_test' },
+      cardPublisher: publisher,
+      serve(options) {
+        queueMicrotask(() => options.onRegistered?.({
+          name: definition.name,
+          capabilities: Object.keys(definition.capabilities),
+        }))
+        return { stop: async () => {}, done: new Promise(() => {}) }
+      },
+    })
+
+    await expect(running.cardPublished).resolves.toEqual({
+      name: 'factory-feature-guardian',
+      address: 'ext-factory-feature-guardian-a1b2c3d4',
+      certification: 'level_1',
+    })
+    expect(published).toEqual([{ agent_card: definition.agentCard }])
+  })
+
+  it('retries a transient card-publication failure on the next registration edge', async () => {
+    const definition = createFactoryNodeDefinition({
+      config: parseFactoryNodeConfig({
+        workspaceId: 'workspace-1',
+        capabilities: ['spawn:codex'],
+        clonePaths: { 'AgentWorkforce/factory': '/work/factory' },
+        dryRun: false,
+      }),
+      name: 'factory-persona-node',
+      persona: {
+        persona,
+        baseUrl: 'https://relay.example',
+        version: '1.0.0',
+      },
+    })
+    let registration: ((info: { name: string; capabilities: string[] }) => void) | undefined
+    let attempts = 0
+    const warn = vi.fn()
+    const running = startFactoryNode({
+      definition,
+      connection: { nodeId: 'node-1', nodeToken: 'nt_live_test' },
+      cardPublisher: {
+        async publishAgentCard() {
+          attempts += 1
+          if (attempts === 1) throw new Error('temporary directory outage')
+          return { name: 'factory-feature-guardian', address: 'ext-factory-feature-guardian-retry' }
+        },
+      },
+      warn,
+      serve(options) {
+        registration = options.onRegistered
+        return { stop: async () => {}, done: new Promise(() => {}) }
+      },
+    })
+    const info = { name: definition.name, capabilities: Object.keys(definition.capabilities) }
+
+    registration?.(info)
+    await vi.waitFor(() => expect(attempts).toBe(1))
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('next node registration will retry'))
+
+    registration?.(info)
+    await expect(running.cardPublished).resolves.toEqual({
+      name: 'factory-feature-guardian',
+      address: 'ext-factory-feature-guardian-retry',
+    })
+    expect(attempts).toBe(2)
+
+    // A later reconnect after success must not publish a duplicate card.
+    registration?.(info)
+    await Promise.resolve()
+    expect(attempts).toBe(2)
+  })
+
+  it('preserves a registration edge that arrives while publication is in flight', async () => {
+    const definition = createFactoryNodeDefinition({
+      config: parseFactoryNodeConfig({ capabilities: ['spawn:codex'] }),
+      persona: { persona, baseUrl: 'https://relay.example', version: '1.0.0' },
+    })
+    let registration: ((info: { name: string; capabilities: string[] }) => void) | undefined
+    let rejectFirst!: (reason: unknown) => void
+    let attempts = 0
+    const running = startFactoryNode({
+      definition,
+      connection: { nodeId: 'node-1', nodeToken: 'nt_live_test' },
+      cardPublisher: {
+        publishAgentCard() {
+          attempts += 1
+          if (attempts === 1) {
+            return new Promise((_resolve, reject) => { rejectFirst = reject })
+          }
+          return Promise.resolve({
+            name: 'factory-feature-guardian',
+            address: 'ext-factory-feature-guardian-overlap',
+          })
+        },
+      },
+      serve(options) {
+        registration = options.onRegistered
+        return { stop: async () => {}, done: new Promise(() => {}) }
+      },
+    })
+    const info = { name: definition.name, capabilities: Object.keys(definition.capabilities) }
+
+    registration?.(info)
+    await vi.waitFor(() => expect(attempts).toBe(1))
+    registration?.(info)
+    rejectFirst(new Error('first registration lost its connection'))
+
+    await expect(running.cardPublished).resolves.toEqual({
+      name: 'factory-feature-guardian',
+      address: 'ext-factory-feature-guardian-overlap',
+    })
+    expect(attempts).toBe(2)
+  })
+
+  it('rejects card publication when node startup terminates before registration', async () => {
+    const definition = createFactoryNodeDefinition({
+      config: parseFactoryNodeConfig({ capabilities: ['spawn:codex'] }),
+      persona: { persona, baseUrl: 'https://relay.example', version: '1.0.0' },
+    })
+    let rejectDone!: (reason: unknown) => void
+    const done = new Promise<void>((_resolve, reject) => { rejectDone = reject })
+    const running = startFactoryNode({
+      definition,
+      connection: { nodeId: 'node-1', nodeToken: 'nt_live_test' },
+      cardPublisher: { publishAgentCard: vi.fn() },
+      serve() {
+        return { stop: async () => {}, done }
+      },
+    })
+    const startupError = new Error('registration credentials rejected')
+
+    rejectDone(startupError)
+
+    await expect(running.cardPublished).rejects.toBe(startupError)
+  })
+
+  it('rejects card publication on a pre-registration stop even if done has not settled', async () => {
+    const definition = createFactoryNodeDefinition({
+      config: parseFactoryNodeConfig({ capabilities: ['spawn:codex'] }),
+      persona: { persona, baseUrl: 'https://relay.example', version: '1.0.0' },
+    })
+    const running = startFactoryNode({
+      definition,
+      connection: { nodeId: 'node-1', nodeToken: 'nt_live_test' },
+      cardPublisher: { publishAgentCard: vi.fn() },
+      serve() {
+        return { stop: async () => {}, done: new Promise(() => {}) }
+      },
+    })
+
+    await running.stop()
+
+    await expect(running.cardPublished).rejects.toThrow(/stopped before persona card publication/)
+  })
+
+  it('verifies an idempotent registration conflict and returns the existing relay address', async () => {
+    const definition = createFactoryNodeDefinition({
+      config: parseFactoryNodeConfig({
+        workspaceId: 'workspace-1',
+        capabilities: ['spawn:codex'],
+        clonePaths: { 'AgentWorkforce/factory': '/work/factory' },
+        dryRun: false,
+      }),
+      persona: {
+        persona,
+        baseUrl: 'https://agent.example',
+        version: '1.0.0',
+      },
+    })
+    const fetch = vi.fn<typeof globalThis.fetch>(async (_url, init) => {
+      if (init?.method === 'POST') {
+        return new Response(JSON.stringify({
+          ok: false,
+          error: { code: 'a2a_agent_already_exists', message: 'already exists' },
+        }), { status: 409 })
+      }
+      return new Response(JSON.stringify({
+        ok: true,
+        data: [{
+          relay_name: 'ext-factory-feature-guardian-a1b2c3d4',
+          agent_card: definition.agentCard,
+        }],
+      }), { status: 200 })
+    })
+    const publisher = new RelaycastAgentCardPublisher({
+      baseUrl: 'https://relay.example',
+      token: 'rk_live_test',
+      fetch,
+    })
+
+    await expect(publisher.publishAgentCard(definition.agentCard!)).resolves.toEqual({
+      name: 'factory-feature-guardian',
+      address: 'ext-factory-feature-guardian-a1b2c3d4',
+      alreadyPublished: true,
+    })
+    expect(fetch.mock.calls.map(([url]) => String(url))).toEqual([
+      'https://relay.example/v1/a2a/register',
+      'https://relay.example/v1/a2a/agents',
+    ])
+  })
+})
diff --git a/src/node/factory-persona-card.ts b/src/node/factory-persona-card.ts
new file mode 100644
index 00000000..15365f75
--- /dev/null
+++ b/src/node/factory-persona-card.ts
@@ -0,0 +1,209 @@
+import { isDeepStrictEqual } from 'node:util'
+
+import { A2aAgentCardSchema, type A2aAgentCard } from '@relaycast/a2a'
+import {
+  deriveAgentCard,
+  isIntent,
+  parsePersonaSpec,
+  type DeriveAgentCardOptions,
+  type PersonaIntent,
+  type PersonaSpec,
+} from '@agentworkforce/persona-kit/spec'
+
+export interface FactoryPersonaCardInput {
+  /** Raw persona.json data or an already parsed PersonaSpec. */
+  persona: unknown
+  /** Deployed agent origin; A2A RPC is available at `<baseUrl>/a2a/rpc`. */
+  baseUrl: string
+  version: string
+  documentationUrl?: string
+  inputModes?: string[]
+  outputModes?: string[]
+}
+
+export interface AgentCardPublisher {
+  publishAgentCard(card: A2aAgentCard): Promise<PublishedAgentCard>
+}
+
+export interface PublishedAgentCard {
+  name: string
+  address: string
+  alreadyPublished?: boolean
+  certification?: string
+}
+
+export interface RelaycastAgentCardPublisherOptions {
+  baseUrl: string
+  token: string
+  fetch?: typeof globalThis.fetch
+  timeoutMs?: number
+}
+
+/**
+ * Derive the card with persona-kit's canonical mapper, then validate it against
+ * the shared Relaycast schema before attaching it to a Factory-hosted persona.
+ */
+export function deriveFactoryPersonaCard(input: FactoryPersonaCardInput): A2aAgentCard {
+  const persona = parsePersona(input.persona)
+  const options: DeriveAgentCardOptions = {
+    baseUrl: input.baseUrl,
+    version: input.version,
+    ...(input.documentationUrl ? { documentationUrl: input.documentationUrl } : {}),
+    ...(input.inputModes ? { inputModes: input.inputModes } : {}),
+    ...(input.outputModes ? { outputModes: input.outputModes } : {}),
+  }
+  return A2aAgentCardSchema.parse(deriveAgentCard(persona, options))
+}
+
+/** Publish an inline canonical card through Relaycast's A2A registration seam. */
+export class RelaycastAgentCardPublisher implements AgentCardPublisher {
+  readonly #baseUrl: string
+  readonly #token: string
+  readonly #fetch: typeof globalThis.fetch
+  readonly #timeoutMs: number
+
+  constructor(options: RelaycastAgentCardPublisherOptions) {
+    this.#baseUrl = options.baseUrl.replace(/\/+$/u, '')
+    this.#token = requiredText(options.token, 'RelaycastAgentCardPublisher token')
+    this.#fetch = options.fetch ?? globalThis.fetch
+    this.#timeoutMs = positiveTimeout(options.timeoutMs, 10_000)
+  }
+
+  async publishAgentCard(card: A2aAgentCard): Promise<PublishedAgentCard> {
+    const canonical = A2aAgentCardSchema.parse(card)
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), this.#timeoutMs)
+    try {
+      const response = await this.#fetch(new URL('/v1/a2a/register', `${this.#baseUrl}/`), {
+        method: 'POST',
+        headers: {
+          accept: 'application/json',
+          authorization: `Bearer ${this.#token}`,
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify({ agent_card: canonical }),
+        signal: controller.signal,
+      })
+      const payload = await readJson(response)
+      if (response.status === 409) {
+        return await this.#resolveExistingCard(canonical, controller.signal)
+      }
+      if (!response.ok) {
+        throw new Error(`Relaycast rejected Factory persona card (${response.status}): ${errorDetail(payload)}`)
+      }
+      const data = asRecord(asRecord(payload)?.data)
+      const address = readString(data, 'relay_name', 'relayName', 'address')
+      if (!address) {
+        throw new Error('Relaycast accepted the Factory persona card without returning its relay address')
+      }
+      return {
+        name: canonical.name,
+        address,
+        ...(readString(data, 'certification') ? { certification: readString(data, 'certification') } : {}),
+      }
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw new Error(`Timed out publishing Factory persona card after ${this.#timeoutMs}ms`, { cause: error })
+      }
+      throw error
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+
+  async #resolveExistingCard(
+    canonical: A2aAgentCard,
+    signal: AbortSignal,
+  ): Promise<PublishedAgentCard> {
+    const response = await this.#fetch(new URL('/v1/a2a/agents', `${this.#baseUrl}/`), {
+      method: 'GET',
+      headers: {
+        accept: 'application/json',
+        authorization: `Bearer ${this.#token}`,
+      },
+      signal,
+    })
+    const payload = await readJson(response)
+    if (!response.ok) {
+      throw new Error(
+        `Relaycast reported an existing Factory persona card but its record could not be verified ` +
+        `(${response.status}): ${errorDetail(payload)}`,
+      )
+    }
+
+    const records = directoryRows(payload)
+    let sameName = false
+    for (const value of records) {
+      const record = asRecord(value)
+      const parsed = A2aAgentCardSchema.safeParse(record?.agent_card ?? record?.agentCard)
+      if (!parsed.success || parsed.data.name !== canonical.name) continue
+      sameName = true
+      if (!isDeepStrictEqual(parsed.data, canonical)) continue
+      const address = readString(record, 'relay_name', 'relayName', 'address')
+      if (!address) {
+        throw new Error('Relaycast returned the existing Factory persona card without its relay address')
+      }
+      return { name: canonical.name, address, alreadyPublished: true }
+    }
+
+    throw new Error(sameName
+      ? `Relaycast already has a different card for Factory persona "${canonical.name}"`
+      : `Relaycast reported a conflict but no card for Factory persona "${canonical.name}" was found`)
+  }
+}
+
+function parsePersona(value: unknown): PersonaSpec {
+  const record = asRecord(value)
+  const intent = readString(record, 'intent')
+  if (!intent || !isIntent(intent)) {
+    throw new Error('Factory-hosted persona must declare a valid persona-kit intent')
+  }
+  return parsePersonaSpec(value, intent as PersonaIntent)
+}
+
+async function readJson(response: Response): Promise<unknown> {
+  const text = await response.text()
+  if (!text) return undefined
+  try {
+    return JSON.parse(text) as unknown
+  } catch (error) {
+    throw new Error('Relaycast card publication returned invalid JSON', { cause: error })
+  }
+}
+
+function errorDetail(payload: unknown): string {
+  const record = asRecord(payload)
+  const error = asRecord(record?.error)
+  return readString(error, 'message') ?? readString(record, 'message') ?? 'request failed'
+}
+
+function directoryRows(payload: unknown): unknown[] {
+  if (Array.isArray(payload)) return payload
+  const record = asRecord(payload)
+  return Array.isArray(record?.data) ? record.data : []
+}
+
+function positiveTimeout(value: number | undefined, fallback: number): number {
+  return Number.isFinite(value) && (value ?? 0) > 0 ? Math.floor(value as number) : fallback
+}
+
+function requiredText(value: string, label: string): string {
+  const normalized = value.trim()
+  if (!normalized) throw new Error(`${label} must be a non-empty string`)
+  return normalized
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined
+}
+
+function readString(record: Record<string, unknown> | undefined, ...keys: string[]): string | undefined {
+  if (!record) return undefined
+  for (const key of keys) {
+    const value = record[key]
+    if (typeof value === 'string' && value.trim()) return value.trim()
+  }
+  return undefined
+}
diff --git a/src/ports/fleet.ts b/src/ports/fleet.ts
index 47df3e84..eee9795b 100644
--- a/src/ports/fleet.ts
+++ b/src/ports/fleet.ts
@@ -5,6 +5,7 @@ export type Capability = 'spawn:codex' | 'spawn:claude' | 'workflow:run'
 export type PreviewCapability = 'preview:tailscale-serve'
 export type NodeCapability = Capability | PreviewCapability
 export type RestartPolicy = import('@agent-relay/harness-driver').SpawnPtyInput['restartPolicy']
+export type A2aSkill = import('@relaycast/a2a').A2aSkill
 
 export type PreviewReference = {
   id: string
@@ -99,6 +100,32 @@ export interface RosterEntry {
   nodes: Array<{ name: string; capabilities: NodeCapability[]; live: boolean }>
 }
 
+export interface TeammateQuery {
+  /** Exact A2A skill id/name to match. */
+  skill?: string
+  /** Exact agent- or skill-level tag to match. */
+  tag?: string
+  /** Free-text directory query. */
+  q?: string
+}
+
+export interface TeammateAgent {
+  /** Directory identity shown to workers. */
+  name: string
+  /** Human-readable card description, when the directory provides one. */
+  description?: string
+  /** Canonical A2A skill records from the agent card. */
+  skills: A2aSkill[]
+  /** A2A endpoint advertised by the directory. */
+  url: string
+  kind: 'native' | 'a2a'
+  /** Relay/A2A target used for the discover -> engage hop. */
+  address: string
+  tags: string[]
+  status?: string
+  certification?: string
+}
+
 export type AgentPidResolution =
   | { status: 'found'; pid: number }
   | { status: 'missing' }
@@ -111,6 +138,18 @@ export type SendInput = {
   data?: Record<string, unknown>
   mode?: 'wait' | 'steer'
 }
+
+/**
+ * Positive transport evidence that a correlated message cannot be delivered.
+ * Unlike a delivery-confirmation timeout, this makes an uncorrelated retry safe.
+ */
+export class FleetDeliveryRejectedError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'FleetDeliveryRejectedError'
+  }
+}
+
 export type AgentMessage = { from: string; target: string; body: string; threadId?: string; eventId?: string }
 export type AgentLifecycleSignal = {
   name: string
@@ -191,6 +230,8 @@ export interface FleetClient {
   }): Promise<SpawnResult>
   release(name: string, reason?: string): Promise<void>
   roster(): Promise<RosterEntry>
+  /** Find addressable teammate agents by their published A2A cards. */
+  discoverTeammates(query: TeammateQuery): Promise<TeammateAgent[]>
   /**
    * Whether this backend's event socket is connected, and why not when it is not.
    * Optional: backends with no socket (the internal fleet) simply omit it, and an
@@ -200,11 +241,46 @@ export interface FleetClient {
   resolveAgentPid?(name: string): Promise<AgentPidResolution>
   protectedPids?(): Promise<number[]>
   sendMessage(input: SendInput): Promise<void>
-  waitForInjected?(input: SendInput, opts?: { timeoutMs?: number }): Promise<{ eventId: string; targets: string[] }>
+  /**
+   * Identity this backend actually authors sends as, when it cannot honour
+   * `SendInput.from`. A teammate replies to that identity, not to the caller's
+   * requested `from`, so a reply waiter must match against this instead.
+   * Backends that faithfully carry `from` leave it undefined.
+   *
+   * Async because the real identity may only be knowable after an
+   * authentication round trip: a configured name can differ from the one the
+   * server actually authenticated, and matching on the pre-auth guess would
+   * reject every reply.
+   */
+  effectiveSender?(): Promise<string | undefined>
+  /**
+   * Stable, opaque identity of the inbound message stream used by this backend.
+   * Distinct client objects that receive the same messages must return the
+   * same identity so uncorrelated reply claims are shared across them. Clients
+   * for genuinely separate streams must return different identities.
+   *
+   * The result must remain referentially/string-equal across calls. Backends
+   * that omit this method are conservatively scoped to the client object.
+   */
+  messageStreamIdentity?(): Promise<string | object | undefined>
+  waitForInjected?(input: SendInput, opts?: { timeoutMs?: number }): Promise<{
+    eventId: string
+    targets: string[]
+    /** A separately accepted resend can still produce an uncorrelated duplicate reply. */
+    duplicateDeliveryPossible?: true
+  }>
   sendInput?(name: string, data: string): Promise<void>
   markAgentTerminal?(name: string, reason?: string): void
   onDeliveryFailed?(listener: (info: { to: string; msgId?: string; reason?: string }) => void): () => void
   onAgentMessage?(listener: (message: AgentMessage) => void): () => void
+  /**
+   * Resolves once the inbound-message transport is genuinely listening.
+   * `onAgentMessage` may return before that is true on a backend whose
+   * subscription is established asynchronously, so a caller that registers a
+   * listener and then sends must await this in between or risk losing a reply
+   * that arrives first.
+   */
+  whenMessagesObservable?(): Promise<void>
   onAgentLifecycleSignal?(listener: (signal: AgentLifecycleSignal) => void | Promise<void>): () => void
   onAgentUsage?(listener: (usage: AgentUsage) => void | Promise<void>): () => void
   onAgentExit(listener: (name: string, reason?: string) => void): () => void
diff --git a/src/ports/index.ts b/src/ports/index.ts
index 2ecd4727..d99a8fc0 100644
--- a/src/ports/index.ts
+++ b/src/ports/index.ts
@@ -19,7 +19,9 @@ export type {
   SubscribeOptions,
   Subscription,
 } from './mount'
+export { FleetDeliveryRejectedError } from './fleet'
 export type {
+  A2aSkill,
   AgentLifecycleSignal,
   AgentMessage,
   AgentPidResolution,
@@ -40,6 +42,8 @@ export type {
   SendInput,
   SpawnInput,
   SpawnResult,
+  TeammateAgent,
+  TeammateQuery,
 } from './fleet'
 export type {
   GithubRead,
diff --git a/src/testing/fakes.ts b/src/testing/fakes.ts
index 4fdde641..bc8fd515 100644
--- a/src/testing/fakes.ts
+++ b/src/testing/fakes.ts
@@ -11,6 +11,8 @@ import type {
   SendInput,
   SpawnInput,
   SpawnResult,
+  TeammateAgent,
+  TeammateQuery,
   SubscribeOptions,
   Subscription,
   Capability,
@@ -214,6 +216,7 @@ export class FakeFleetClient implements FleetClient {
   readonly previewStarts: PreviewStartInput[] = []
   readonly previewRemovals: PreviewReference[] = []
   readonly previewSweeps: PreviewSweepInput[] = []
+  readonly teammates: TeammateAgent[] = []
 
   #agents = new Set<string>()
   #tracked = new Map<string, { invocationId?: string; node?: string }>()
@@ -256,6 +259,20 @@ export class FakeFleetClient implements FleetClient {
     this.#tracked.delete(name)
   }
 
+  async discoverTeammates(query: TeammateQuery): Promise<TeammateAgent[]> {
+    const skill = query.skill?.trim().toLowerCase()
+    const tag = query.tag?.trim().toLowerCase()
+    const q = query.q?.trim().toLowerCase()
+    return this.teammates.filter((teammate) => {
+      if (skill && !teammate.skills.some((candidate) =>
+        candidate.id?.toLowerCase() === skill || candidate.name.toLowerCase() === skill)) return false
+      if (tag && ![...teammate.tags, ...teammate.skills.flatMap((candidate) => candidate.tags ?? [])]
+        .some((candidate) => candidate.toLowerCase() === tag)) return false
+      if (q && !JSON.stringify(teammate).toLowerCase().includes(q)) return false
+      return true
+    })
+  }
+
   async createPreview(input: PreviewStartInput): Promise<PreviewReference> {
     this.previewStarts.push(structuredClone(input))
     const httpsPort = input.preferredHttpsPort ?? 10_000 + this.previewStarts.length - 1
diff --git a/test/e2e/ask-a-teammate.test.ts b/test/e2e/ask-a-teammate.test.ts
new file mode 100644
index 00000000..495d329a
--- /dev/null
+++ b/test/e2e/ask-a-teammate.test.ts
@@ -0,0 +1,306 @@
+import { readFileSync } from 'node:fs'
+import { createServer, type Server } from 'node:http'
+
+import { A2aAgentCardSchema } from '@relaycast/a2a'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import type { BrokerEvent, SendMessageInput, SpawnPtyInput } from '@agent-relay/harness-driver'
+
+import { ensureRelayBroker } from '../../src/fleet/ensure-relay-broker'
+import { InternalFleetClient, type HarnessDriverClientLike } from '../../src/fleet/internal-fleet-client'
+import { RelayFleetClient } from '../../src/fleet/relay-fleet-client'
+import { askTeammate, RelaycastTeammateDirectory } from '../../src/fleet/teammates'
+import { createFactoryNodeDefinition, parseFactoryNodeConfig } from '../../src/node/factory-node'
+import { RelaycastAgentCardPublisher } from '../../src/node/factory-persona-card'
+import { startFactoryNode } from '../../src/node/factory-node-runtime'
+
+type DirectoryRow = {
+  name: string
+  description?: string
+  skills: Array<{ id?: string; name: string; description?: string; tags?: string[] }>
+  tags: string[]
+  url: string
+  kind: 'native' | 'a2a'
+  status: string
+}
+
+const openServers: Server[] = []
+afterEach(async () => {
+  await Promise.all(openServers.splice(0).map((server) => new Promise<void>((resolve, reject) => {
+    server.close((error) => error ? reject(error) : resolve())
+  })))
+})
+
+describe('discover -> ask -> reply', () => {
+  it('discovers one skilled teammate, completes a relay round trip, and publishes a hosted persona card', async () => {
+    const directoryRows: DirectoryRow[] = [{
+      name: 'infra-agent',
+      description: 'Watches production infrastructure.',
+      skills: [{ id: 'infra-watch', name: 'Infra Watch' }],
+      tags: ['operations'],
+      url: 'http://relay.local/v1/dm',
+      kind: 'native',
+      status: 'online',
+    }, {
+      name: 'review-agent',
+      description: 'Reviews code changes.',
+      skills: [{ id: 'code-review', name: 'Code Review' }],
+      tags: ['quality'],
+      url: 'http://relay.local/v1/dm',
+      kind: 'native',
+      status: 'online',
+    }]
+    const directoryRequests: URL[] = []
+    const server = createServer(async (request, response) => {
+      const origin = `http://${request.headers.host}`
+      const url = new URL(request.url ?? '/', origin)
+      if (request.method === 'GET' && url.pathname === '/v1/a2a/directory') {
+        directoryRequests.push(url)
+        // Deliberately return every row. Factory must enforce exact skill/tag
+        // filtering too, otherwise this E2E returns both cards and fails.
+        json(response, 200, { ok: true, data: directoryRows })
+        return
+      }
+      if (request.method === 'POST' && url.pathname === '/v1/a2a/register') {
+        const body = JSON.parse(await requestBody(request)) as { agent_card?: unknown }
+        const card = A2aAgentCardSchema.parse(body.agent_card)
+        const relayName = `ext-${card.name}-a1b2c3d4`
+        directoryRows.push({
+          // Relaycast exposes the derived relay proxy identity as `name`; it
+          // does not add a separate address field to directory rows.
+          name: relayName,
+          skills: card.skills,
+          tags: Array.isArray(card.provider?.tags)
+            ? card.provider.tags.filter((value): value is string => typeof value === 'string')
+            : [],
+          url: `${origin}/a2a/rpc`,
+          kind: 'a2a',
+          status: 'active',
+        })
+        json(response, 201, {
+          ok: true,
+          data: { relay_name: relayName, certification: 'level_1' },
+        })
+        return
+      }
+      json(response, 404, { ok: false })
+    })
+    openServers.push(server)
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+    const address = server.address()
+    if (!address || typeof address === 'string') throw new Error('mock directory did not bind')
+    const baseUrl = `http://127.0.0.1:${address.port}`
+
+    const discoveryFleet = new RelayFleetClient({
+      baseUrl,
+      workspaceKey: 'rk_live_test',
+      directoryFetch: fetch,
+    })
+    const infra = await discoveryFleet.discoverTeammates({ skill: 'infra-watch' })
+    expect(infra).toEqual([expect.objectContaining({
+      name: 'infra-agent',
+      description: 'Watches production infrastructure.',
+      address: 'infra-agent',
+      url: 'http://relay.local/v1/dm',
+      kind: 'native',
+      skills: [expect.objectContaining({ id: 'infra-watch' })],
+    })])
+    await expect(discoveryFleet.discoverTeammates({ skill: 'unknown-skill' })).resolves.toEqual([])
+    expect(directoryRequests[0]?.searchParams.get('skill')).toBe('infra-watch')
+
+    const broker = new InProcessRelayBroker(['factory-worker', 'infra-agent'])
+    const brokerHandle = await ensureRelayBroker({
+      connect: () => { throw new Error('no existing broker') },
+      spawn: async () => broker,
+      env: {},
+      resolveWorkspaceKey: () => undefined,
+    })
+    expect(brokerHandle.started).toBe(true)
+    const workerFleet = new InternalFleetClient({
+      client: brokerHandle.client,
+      ownsBroker: brokerHandle.started,
+      teammateDirectory: new RelaycastTeammateDirectory({
+        baseUrl,
+        token: 'rk_live_test',
+      }),
+    })
+    const teammateFleet = new InternalFleetClient({
+      client: brokerHandle.client,
+    })
+    const cannedReply = 'The deploy is healthy; no intervention is needed.'
+    const questions: string[] = []
+    const stopStub = teammateFleet.onAgentMessage((message) => {
+      if (message.from !== 'factory-worker' || message.target !== 'infra-agent') return
+      questions.push(message.body)
+      void teammateFleet.sendMessage({
+        from: 'infra-agent',
+        to: 'factory-worker',
+        text: cannedReply,
+      })
+    })
+
+    const roundTrip = await askTeammate(workerFleet, {
+      from: 'factory-worker',
+      question: 'Is the deploy healthy?',
+      skill: 'infra-watch',
+      timeoutMs: 1_000,
+    })
+    expect(questions).toEqual(['Is the deploy healthy?'])
+    expect(roundTrip.teammate.name).toBe('infra-agent')
+    expect(roundTrip.reply).toMatchObject({
+      from: 'infra-agent',
+      target: 'factory-worker',
+      body: cannedReply,
+    })
+
+    const persona = JSON.parse(readFileSync(
+      new URL('../../.agentworkforce/agents/factory-feature-guardian/persona.json', import.meta.url),
+      'utf8',
+    )) as unknown
+    const definition = createFactoryNodeDefinition({
+      config: parseFactoryNodeConfig({
+        workspaceId: 'workspace-test',
+        capabilities: ['spawn:codex'],
+        clonePaths: { 'AgentWorkforce/factory': '/work/factory' },
+        dryRun: false,
+      }),
+      name: 'factory-persona-node',
+      persona: {
+        persona,
+        baseUrl,
+        version: 'e2e',
+      },
+    })
+    expect(() => A2aAgentCardSchema.parse(definition.agentCard)).not.toThrow()
+    const running = startFactoryNode({
+      definition,
+      connection: { nodeId: 'node-test', nodeToken: 'nt_live_test' },
+      cardPublisher: new RelaycastAgentCardPublisher({
+        baseUrl,
+        token: 'rk_live_test',
+      }),
+      serve(options) {
+        queueMicrotask(() => options.onRegistered?.({
+          name: definition.name,
+          capabilities: Object.keys(definition.capabilities),
+        }))
+        return { stop: async () => {}, done: Promise.resolve() }
+      },
+    })
+    await expect(running.cardPublished).resolves.toMatchObject({
+      name: 'factory-feature-guardian',
+    })
+    await expect(discoveryFleet.discoverTeammates({
+      skill: 'factory-feature-verification',
+    })).resolves.toEqual([expect.objectContaining({
+      name: 'ext-factory-feature-guardian-a1b2c3d4',
+      address: 'ext-factory-feature-guardian-a1b2c3d4',
+      kind: 'a2a',
+      url: `${baseUrl}/a2a/rpc`,
+    })])
+
+    stopStub()
+    await teammateFleet.dispose()
+    await workerFleet.dispose()
+    expect(broker.shutdownCalls).toBe(1)
+    await discoveryFleet.dispose()
+  })
+})
+
+class InProcessRelayBroker implements HarnessDriverClientLike {
+  readonly brokerPid = process.pid
+  readonly #agents: Array<{ name: string; cli?: string; pid?: number }>
+  readonly #events = new Set<(event: BrokerEvent) => void>()
+  readonly #deliveryEvents = new Set<(event: BrokerEvent) => void>()
+  readonly #exitEvents = new Set<(agent: { name: string; sessionId?: string }) => void>()
+  #sequence = 0
+  shutdownCalls = 0
+
+  constructor(agentNames: string[]) {
+    this.#agents = agentNames.map((name) => ({ name, cli: 'stub', pid: process.pid }))
+  }
+
+  async spawnPty(input: SpawnPtyInput) {
+    this.#agents.push({ name: input.name, cli: input.cli, pid: process.pid })
+    return { name: input.name, session_ref: `session-${input.name}`, pid: process.pid }
+  }
+
+  async release(name: string): Promise<{ name: string }> {
+    const index = this.#agents.findIndex((agent) => agent.name === name)
+    if (index >= 0) this.#agents.splice(index, 1)
+    return { name }
+  }
+
+  async listAgents() {
+    return this.#agents.map((agent) => ({ ...agent }))
+  }
+
+  async sendMessage(input: SendMessageInput): Promise<{ event_id: string; targets: string[] }> {
+    if (!this.#agents.some((agent) => agent.name === input.to)) {
+      throw new Error(`unknown recipient ${input.to}`)
+    }
+    const eventId = `event-${++this.#sequence}`
+    queueMicrotask(() => {
+      this.#emit({
+        kind: 'delivery_injected',
+        name: input.to,
+        delivery_id: `delivery-${this.#sequence}`,
+        event_id: eventId,
+      })
+      this.#emit({
+        kind: 'relay_inbound',
+        event_id: `inbound-${this.#sequence}`,
+        from: input.from ?? 'factory',
+        target: input.to,
+        body: input.text,
+      })
+    })
+    return { event_id: eventId, targets: [input.to] }
+  }
+
+  async sendInput(): Promise<void> {}
+  connectEvents(): void {}
+  disconnect(): void {}
+  async shutdown(): Promise<void> { this.shutdownCalls += 1 }
+
+  onEvent(listener: (event: BrokerEvent) => void): () => void {
+    this.#events.add(listener)
+    return () => this.#events.delete(listener)
+  }
+
+  addListener(event: 'agentExited', listener: (agent: { name: string; sessionId?: string }) => void): () => void
+  addListener(event: 'deliveryUpdate', listener: (event: BrokerEvent) => void): () => void
+  addListener(
+    event: 'agentExited' | 'deliveryUpdate',
+    listener: ((agent: { name: string; sessionId?: string }) => void) | ((event: BrokerEvent) => void),
+  ): () => void {
+    if (event === 'agentExited') {
+      const exitListener = listener as (agent: { name: string; sessionId?: string }) => void
+      this.#exitEvents.add(exitListener)
+      return () => this.#exitEvents.delete(exitListener)
+    }
+    const deliveryListener = listener as (event: BrokerEvent) => void
+    this.#deliveryEvents.add(deliveryListener)
+    return () => this.#deliveryEvents.delete(deliveryListener)
+  }
+
+  #emit(event: BrokerEvent): void {
+    for (const listener of this.#events) listener(event)
+    for (const listener of this.#deliveryEvents) listener(event)
+  }
+}
+
+function requestBody(request: import('node:http').IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let body = ''
+    request.setEncoding('utf8')
+    request.on('data', (chunk) => { body += chunk })
+    request.on('end', () => resolve(body))
+    request.on('error', reject)
+  })
+}
+
+function json(response: import('node:http').ServerResponse, status: number, body: unknown): void {
+  response.writeHead(status, { 'content-type': 'application/json' })
+  response.end(JSON.stringify(body))
+}
diff --git a/vitest.config.ts b/vitest.config.ts
index 2e4fbe6f..4f23cb16 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -6,6 +6,7 @@ export default defineConfig({
       'src/**/*.test.ts',
       'benchmark/**/*.test.ts',
       '.agentworkforce/agents/**/*.test.ts',
+      'test/e2e/ask-a-teammate.test.ts',
       'test/e2e/dispatch-identity-real-broker.test.ts',
       'test/e2e/run-cost-accounting.test.ts',
     ],