@ljwei-stak/dsh-model-route-bot 0.66.4 → 0.67.0

package/packages/orchestration/src/team-assignment-store.mjs

@@ -0,0 +1,120 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { TEAM_CODES } from './team-tool-contract.mjs'
+
+const fail = code => { throw Object.assign(new Error(code), { code }) }
+const hash = value => createHash('sha256').update(value).digest('hex')
+const alive = pid => { try { process.kill(pid, 0); return true } catch (error) { return error.code !== 'ESRCH' } }
+const terminal = row => ['settled', 'cancelled', 'unknown'].includes(row.state)
+export const computeBriefHash = (mode, message, doneWhen, consult) => hash(JSON.stringify([mode, message, doneWhen ?? null, consult === true]))
+export const standingThreadKey = (parent, target, origin = '') => `standing-${hash(JSON.stringify([parent, target, origin])).slice(0, 40)}`
+export const workThreadConversationKey = (target, thread) => hash(JSON.stringify([target, thread])).slice(0, 48)
+export const assertNoCycle = (lineage, target) => { if (lineage.includes(target)) fail(TEAM_CODES.CYCLE) }
+// Upstream's depth is the number of delegation edges, not the root Bot itself.
+export const assertDepth = (lineage, maxDepth) => { if (!Number.isSafeInteger(maxDepth) || maxDepth < 1) fail('TEAM_DEPTH_LIMIT_INVALID'); if (lineage.length > maxDepth) fail(TEAM_CODES.TOO_DEEP) }
+
+/** Durable outbox, with one live Host owner. State writes never prove execution.
+ * The exact target request receipt is the only way to settle a dispatched row.
+ * A new schema leaves the original, unreleased Step journal intact for inspection.
+ */
+export function createTeamAssignmentStore({ Database, file, now = Date.now, maxRows = 65536, isProcessAlive = alive, ownerId = randomUUID() } = {}) {
+  if (typeof Database !== 'function' || typeof file !== 'string' || !file) fail('TEAM_STORE_HOST_REQUIRED')
+  if (!Number.isSafeInteger(maxRows) || maxRows < 1) fail('TEAM_STORE_INVALID_LIMIT')
+  if (file !== ':memory:') mkdirSync(dirname(file), { recursive: true })
+  const db = new Database(file)
+  let closed = false
+  try {
+    db.pragma('busy_timeout=5000'); db.pragma('synchronous=FULL')
+    if (file !== ':memory:' && db.pragma('journal_mode=WAL', { simple: true }) !== 'wal') fail('TEAM_STORE_WAL_REQUIRED')
+    db.exec(`CREATE TABLE IF NOT EXISTS bot_team_owner_v2 (slot INTEGER PRIMARY KEY CHECK(slot=1), token TEXT, pid INTEGER, active INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS bot_team_rows_v2 (id TEXT PRIMARY KEY, parent TEXT NOT NULL, origin TEXT NOT NULL, state TEXT NOT NULL, created INTEGER NOT NULL, data TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS bot_team_rows_parent_v2 ON bot_team_rows_v2(parent,origin,created);
+      CREATE TABLE IF NOT EXISTS bot_team_batches_v2 (parent TEXT NOT NULL, origin TEXT NOT NULL, request TEXT NOT NULL, hash TEXT NOT NULL, ids TEXT NOT NULL, PRIMARY KEY(parent,origin,request));`)
+    if (db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='bot_team_assignments'").get() && db.prepare('SELECT count(*) n FROM bot_team_assignments').get().n) fail('TEAM_LEGACY_JOURNAL_RECONCILIATION_REQUIRED')
+    db.transaction(() => {
+      const owner = db.prepare('SELECT * FROM bot_team_owner_v2 WHERE slot=1').get()
+      if (owner?.active && isProcessAlive(owner.pid)) fail('TEAM_STORE_ALREADY_OWNED')
+      db.prepare('INSERT OR REPLACE INTO bot_team_owner_v2(slot,token,pid,active) VALUES(1,?,?,1)').run(ownerId, process.pid)
+    }).immediate()
+  } catch (error) { db.close(); throw error }
+  const assertOpen = () => {
+    if (closed) fail('TEAM_STORE_CLOSED')
+    if (db.prepare('SELECT token FROM bot_team_owner_v2 WHERE slot=1 AND active=1').get()?.token !== ownerId) fail('TEAM_STORE_OWNER_LOST')
+  }
+  const read = id => { const row = db.prepare('SELECT data FROM bot_team_rows_v2 WHERE id=?').get(id); return row ? JSON.parse(row.data) : null }
+  const all = () => { assertOpen(); return db.prepare('SELECT data FROM bot_team_rows_v2 ORDER BY created,id').all().map(row => JSON.parse(row.data)) }
+  const save = row => db.prepare('INSERT OR REPLACE INTO bot_team_rows_v2(id,parent,origin,state,created,data) VALUES(?,?,?,?,?,?)').run(row.assignmentId, row.parentBot, row.originKey, row.state, row.createdAt, JSON.stringify(row))
+  const mutate = (id, predicate, change) => {
+    assertOpen()
+    return db.transaction(() => { assertOpen(); const row = read(id); if (!row || !predicate(row)) return null; change(row); row.updatedAt = now(); save(row); return row }).immediate()
+  }
+  const createBatch = (specs, { parentBot = specs[0]?.parentBot, originKey = specs[0]?.originKey ?? '', requestKey, payloadHash } = {}) => {
+    assertOpen()
+    if (!Array.isArray(specs) || !specs.length || specs.length > 4 || !requestKey) fail(TEAM_CODES.INVALID_ARGS)
+    const identity = payloadHash ?? hash(JSON.stringify(specs.map(({ workThreadKey, ...spec }) => ({ ...spec, thread: spec.requestedThread ?? workThreadKey }))))
+    return db.transaction(() => {
+      assertOpen()
+      const batch = db.prepare('SELECT * FROM bot_team_batches_v2 WHERE parent=? AND origin=? AND request=?').get(parentBot, originKey, requestKey)
+      if (batch) return batch.hash === identity ? { status: 'replayed', assignments: JSON.parse(batch.ids).map(read) } : { status: 'conflict' }
+      if (db.prepare('SELECT count(*) n FROM bot_team_rows_v2').get().n + specs.length > maxRows) fail('TEAM_STORE_ROW_LIMIT')
+      const rows = all()
+      const decisions = specs.map(spec => {
+        const match = rows.slice().reverse().find(row => row.parentBot === parentBot && row.originKey === originKey && row.targetBot === spec.targetBot && row.workThreadKey === spec.workThreadKey && row.mode === spec.mode && (spec.rework || row.briefHash === spec.briefHash && (row.parentAssignmentId ?? row.createdByTurn) === (spec.parentAssignmentId ?? spec.createdByTurn)))
+        if (match && spec.rework && !terminal(match) && !match.outcome) fail(TEAM_CODES.REWORK_NOT_TERMINAL)
+        if (match && !spec.rework) return { row: match, duplicate: true }
+        const timestamp = now()
+        const assignmentId = `assign_${randomUUID()}`
+        return { row: { ...spec, requestKey, originKey, assignmentId, rootAssignmentId: spec.rootAssignmentId ?? assignmentId, reworkOf: match?.assignmentId ?? null, state: 'queued', outcome: null, resultText: null, resultCode: null, targetRef: null, targetRequestId: null, resumeState: spec.reply === 'none' ? 'none' : 'waiting', cancelRequestedAt: null, createdAt: timestamp, updatedAt: timestamp } }
+      })
+      // All decisions, including rework validity, are complete before the first insert.
+      for (const { row, duplicate } of decisions) if (!duplicate) save(row)
+      db.prepare('INSERT INTO bot_team_batches_v2(parent,origin,request,hash,ids) VALUES(?,?,?,?,?)').run(parentBot, originKey, requestKey, identity, JSON.stringify(decisions.map(({ row }) => row.assignmentId)))
+      return { status: 'created', assignments: decisions.map(({ row, duplicate }) => ({ ...row, ...(duplicate ? { duplicate: true } : {}) })) }
+    }).immediate()
+  }
+  const create = spec => { const result = createBatch([spec], { requestKey: spec.requestKey }); return { status: result.status, assignment: result.assignments?.[0] } }
+  return Object.freeze({
+    ready: true, create, createBatch,
+    get(id) { assertOpen(); return read(id) },
+    byRequestKey(parent, request, origin = '') { assertOpen(); const batch = db.prepare('SELECT ids FROM bot_team_batches_v2 WHERE parent=? AND origin=? AND request=?').get(parent, origin, request); return batch ? read(JSON.parse(batch.ids)[0]) : null },
+    listByParent: (parent, { includeTerminal = false, originKey } = {}) => all().filter(row => row.parentBot === parent && (originKey === undefined || row.originKey === originKey) && (includeTerminal || !terminal(row))),
+    threadsByParent(parent, originKey) { const seen = new Map(); for (const row of all().reverse().filter(row => row.parentBot === parent && (originKey === undefined || row.originKey === originKey))) if (!seen.has(row.workThreadKey)) seen.set(row.workThreadKey, row); return [...seen.values()] },
+    activeFor(botId, origin) {
+      const rows = all(), matches = ref => origin.sessionId ? ref?.sessionId === origin.sessionId : ref?.conversationId === origin.conversationId
+      const running = rows.find(row => row.state === 'running' && row.targetBot === botId && matches(row.targetRef))
+      if (running) return running
+      const uncertain = rows.find(row => row.targetActive === true && row.targetBot === botId && matches(row.targetRef))
+      if (uncertain) return uncertain
+      // A child result resumes its caller's old work request, even if that
+      // request already settled. This frame is durable across awaits and is
+      // independent of delivery state: a stop must not erase the execution gate.
+      const resume = rows.find(row => row.parentBot === botId && row.resumeActive === true && matches(row.origin))
+      if (!resume) return null
+      const parent = resume.parentAssignmentId ? read(resume.parentAssignmentId) : null
+      return { ...(parent ?? { targetBot: botId, parentBot: botId, lineage: [botId], rootBot: botId, depth: 0, mode: 'work', origin: resume.origin }),
+        resumeAssignmentId: resume.assignmentId, cancelRequestedAt: resume.cancelRequestedAt ?? parent?.cancelRequestedAt ?? null }
+    },
+    dispatchable: () => all().filter(row => row.state === 'queued'),
+    rowsForReconcile: () => all().filter(row => row.state === 'running'),
+    resumeDue: () => all().filter(row => row.state === 'waiting' && row.resumeState === 'waiting' && row.cancelRequestedAt === null),
+    all,
+    admit: id => mutate(id, row => row.state === 'queued', row => { row.state = 'admitting' }),
+    beginDispatch: (id, ref, requestId) => mutate(id, row => row.state === 'admitting' && !row.cancelRequestedAt, row => { row.state = 'running'; row.targetRef = ref; row.targetRequestId = requestId; row.targetActive = true }),
+    settle: (id, { outcome, resultText = null, resultCode = null }) => mutate(id, row => row.state === 'running', row => { row.state = row.reply === 'none' || row.cancelRequestedAt !== null ? 'settled' : 'waiting'; row.outcome = outcome; row.resultText = resultText; row.resultCode = resultCode; row.targetActive = false; if (row.cancelRequestedAt !== null) row.resumeState = 'withheld' }),
+    markResumeSending: id => Boolean(mutate(id, row => row.state === 'waiting' && row.resumeState === 'waiting' && row.cancelRequestedAt === null, row => { row.resumeState = 'sending'; row.resumeActive = true })),
+    completeResume: (id, state, { executionFinished = true } = {}) => mutate(id, row => row.state === 'waiting' && row.resumeActive === true, row => {
+      row.state = 'settled'; row.resumeState = row.cancelRequestedAt !== null ? 'withheld' : state
+      row.resumeActive = !executionFinished
+      if (!executionFinished) row.cancelRequestedAt ??= now()
+    }),
+    rewarmResume: id => Boolean(mutate(id, row => row.state === 'waiting' && row.resumeState === 'sending' && row.cancelRequestedAt === null, row => { row.resumeState = 'waiting'; row.resumeActive = false })),
+    rewarm: id => mutate(id, row => row.state === 'running' && row.cancelRequestedAt === null, row => { row.state = 'queued'; row.targetRequestId = null; row.targetRef = null; row.targetActive = false }),
+    cancel: (id, { resultCode = null } = {}) => mutate(id, row => ['queued', 'admitting'].includes(row.state), row => { row.state = 'cancelled'; row.outcome = 'cancelled'; row.resultCode = resultCode; row.resumeState = 'withheld' }),
+    requestCancel: id => mutate(id, row => !terminal(row), row => { row.cancelRequestedAt ??= now(); if (['queued', 'admitting'].includes(row.state)) { row.state = 'cancelled'; row.outcome = 'cancelled' }; row.resumeState = 'withheld' }),
+    fenceUnknown: (id, code, { executionFinished = false } = {}) => mutate(id, row => ['admitting', 'running'].includes(row.state), row => { row.state = 'unknown'; row.outcome = 'unknown'; row.resultCode = code ?? TEAM_CODES.OUTCOME_UNKNOWN; row.resumeState = 'withheld'; row.targetActive = row.targetActive === true && !executionFinished; if (row.targetActive) row.cancelRequestedAt ??= now() }),
+    recover() { let fenced = 0; for (const row of all()) { if (row.state === 'admitting') { this.fenceUnknown(row.assignmentId, 'TEAM_ADMISSION_INTERRUPTED'); fenced++ } else if (row.resumeActive === true) { mutate(row.assignmentId, () => true, current => { current.resumeActive = false; if (current.state === 'waiting') { current.state = 'settled'; current.resumeState = current.cancelRequestedAt !== null ? 'withheld' : 'uncertain' } }); fenced++ } }; return { fenced } },
+    close() { if (closed) return; try { db.prepare('UPDATE bot_team_owner_v2 SET active=0 WHERE slot=1 AND token=?').run(ownerId) } finally { closed = true; db.close() } },
+  })
+}
+export { STATE_UNKNOWN as TEAM_STATE_UNKNOWN } from './team-tool-contract.mjs'

package/packages/orchestration/src/team-bridge.mjs

@@ -0,0 +1,282 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import { TEAM_CODES, parseTeamToolArgs, projectCoordinateArgs } from './team-tool-contract.mjs'
+import { createTeamAssignmentStore, computeBriefHash, standingThreadKey, workThreadConversationKey, assertNoCycle, assertDepth } from './team-assignment-store.mjs'
+import { createTeamScheduler } from './team-scheduler.mjs'
+
+const fail = (code, extra = {}) => { throw Object.assign(new Error(code), { code, ...extra }) }
+const digest = value => createHash('sha256').update(JSON.stringify(value)).digest('hex')
+const textOf = content => Array.isArray(content) ? content.filter(block => block.type === 'text').map(block => block.text ?? '').join('\n') : ''
+const composeBrief = row => `[Team assignment from ${row.parentBot}; mode ${row.mode}]\n${row.doneWhen ? `Done when: ${row.doneWhen}\n` : ''}${row.brief}`
+const composeResult = row => `[Team result from ${row.targetBot}; assignment ${row.assignmentId}; ${row.outcome}${row.resultCode ? ` (${row.resultCode})` : ''}]\n${row.resultText || '(no result text)'}`
+const unknown = code => ({ outcome: 'unknown', code })
+
+/** Fold installed SDK events, requiring the exact identified user message in one
+ * balanced turn. A later assignment, an injected extra user, or an unterminated
+ * request cannot supply this request's answer.
+ */
+export function teamReceiptFromEvents(events, requestId, role = 'assign-task') {
+  let turn = null, active = false, mixed = false, text = '', result = null, matches = 0
+  for (const event of events) {
+    if (event.type === 'turn/start') { turn = event.data?.turn; active = false; mixed = false; text = '' }
+    if (event.type === 'user/message') {
+      const source = event.data?.source
+      if (source?.kind === 'bot' && source.role === role && source.exchangeId === requestId) { matches++; active = true }
+      else if (active && !['snapshot', 'recall'].includes(source?.form)) mixed = true
+    }
+    if (event.type === 'assistant/message' && active) {
+      const content = event.data?.message?.content
+      if (!content?.some(block => block.type === 'tool-call')) text = textOf(content)
+    }
+    if (event.type === 'turn/end' && active && event.data?.turn === turn) {
+      const reason = event.data.reason
+      result = mixed ? unknown('TEAM_TARGET_MIXED_INPUT') : reason?.kind === 'completed' ? { outcome: 'succeeded', text } : reason?.kind === 'aborted' ? { outcome: 'cancelled', code: 'TEAM_TARGET_CANCELLED' } : { outcome: 'failed', code: 'TEAM_TARGET_FAILED' }
+      active = false
+    }
+  }
+  return matches === 1 && result ? result : unknown(matches > 1 ? 'TEAM_TARGET_DUPLICATE_REQUEST' : 'TEAM_TARGET_NOT_TERMINAL')
+}
+
+export function createIntegratedTeamBridge({ rt, directory, authority, lifecycle, flush, threadHost = () => null, cancelWaitMs = 10000 } = {}) {
+  if (!rt || !directory || !authority || !lifecycle || typeof flush !== 'function') throw new TypeError('TEAM_BRIDGE_DEPENDENCIES_REQUIRED')
+  if (!Number.isSafeInteger(cancelWaitMs) || cancelWaitMs < 10 || cancelWaitMs > 60000) throw new TypeError('TEAM_CANCEL_WAIT_INVALID')
+  const subjectBot = agent => authority.describe(directory.forAgent(agent)).botId
+  const eventsFor = async (sessionId, signal) => {
+    if (typeof rt.eventsBackwards !== 'function') fail('TEAM_TARGET_HISTORY_UNAVAILABLE')
+    const events = []
+    for await (const event of rt.eventsBackwards(sessionId, signal)) { events.push(event); if (events.length > 16384) fail('TEAM_TARGET_HISTORY_LIMIT') }
+    return events.reverse()
+  }
+  const owns = (botId, sessionId) => {
+    const bot = lifecycle.committedBot(botId)
+    if (!bot) return false
+    if ((bot.sessionId ?? bot.id) === sessionId) return true
+    if (bot.threads?.some(thread => thread.sessionId === sessionId && !thread.archivedAt) !== true) return false
+    const host = threadHost()
+    if (host) {
+      try {
+        const found = host.service.threadBySession(sessionId)
+        const gate = found?.botId === botId ? host.service.probeSendable({ botId, threadId: found.threadId }) : null
+        return gate?.ok === true && gate.sessionId === sessionId
+      } catch { return false }
+    }
+    return true
+  }
+  const readTarget = async row => {
+    if (!row.targetRef?.sessionId || !row.requestId && !row.targetRequestId || !owns(row.targetBot, row.targetRef.sessionId)) return unknown('TEAM_TARGET_REFERENCE_UNCONFIRMED')
+    try { return teamReceiptFromEvents(await eventsFor(row.targetRef.sessionId, row.signal), row.requestId ?? row.targetRequestId) }
+    catch { return unknown('TEAM_TARGET_HISTORY_UNCONFIRMED') }
+  }
+  const resolve = async (botId, sessionId) => {
+    await rt.load(); await rt.ensureCapabilities?.(sessionId)
+    if (!owns(botId, sessionId)) fail('TEAM_SESSION_RETIRED', { started: false, retired: true })
+    const agent = await rt.resolveAgent(sessionId)
+    if (subjectBot(agent) !== botId) fail('TEAM_TARGET_SUBJECT_MISMATCH', { started: false })
+    if (typeof agent.whenIdle !== 'function') fail('TEAM_AGENT_API_UNAVAILABLE', { started: false })
+    return agent
+  }
+  const submit = async (row, sessionId, role, requestId, text) => {
+    // Followup is the actual public SDK admission. No owner RPC, fake Agent or
+    // arbitrary two-second completion timer. whenIdle is followed by a flush and
+    // exact request scan; quiescence alone is not a receipt.
+    let off = () => {}, agent, submitted = false, finished = false, receipt = null, failure = null
+    try {
+      agent = await resolve(role === 'assign-task' ? row.targetBot : row.parentBot, sessionId)
+      row.validate?.(); row.signal?.throwIfAborted()
+      if (agent.status !== 'idle' || rt.live?.get(sessionId)?.turn !== undefined) return { started: false, code: TEAM_CODES.TARGET_BUSY }
+      const prior = await eventsFor(sessionId, row.signal)
+      const existing = prior.some(event => event.type === 'user/message' && event.data?.source?.kind === 'bot' && event.data.source.exchangeId === requestId && event.data.source.role === role)
+      if (existing) return role === 'assign-task' ? { started: true, ...teamReceiptFromEvents(prior, requestId, role), executionFinished: true } : { resumed: true, replayed: true, executionFinished: true }
+      row.validate?.(); row.signal?.throwIfAborted()
+      const message = createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'bot', form: 'relay', role, exchangeId: requestId, senderName: 'Team coordinator' } })
+      const aborted = new Promise(resolve => {
+        const stop = () => { try { agent.cancel({ kind: 'hook', reason: 'team-assignment-cancelled' }) } catch {}; resolve('aborted') }
+        row.signal?.addEventListener('abort', stop, { once: true }); off = () => row.signal?.removeEventListener('abort', stop)
+      })
+      submitted = true // conservative if public followup throws after acceptance
+      agent.followup(message)
+      if (await flush(agent.session) === false) fail('TEAM_SESSION_DURABILITY_UNAVAILABLE')
+      const state = await Promise.race([agent.whenIdle().then(() => 'idle'), aborted])
+      finished = state === 'idle'
+      if (await flush(agent.session) === false) fail('TEAM_SESSION_DURABILITY_UNAVAILABLE')
+      receipt = role === 'assign-result' ? { resumed: true, executionFinished: finished } : { started: true, ...(finished ? await readTarget({ ...row, requestId }) : unknown('TEAM_TARGET_STOP_UNCONFIRMED')), executionFinished: finished }
+      return receipt
+    } catch (error) { failure = error; if (!submitted) error.started = false; error.executionFinished = !submitted || finished; throw error }
+    finally {
+      // A result keeps its durable ancestry frame for the real resumed turn.
+      // Cancellation has a bounded convergence wait; a missing idle receipt
+      // preserves an uncertain execution fence instead of freeing that frame.
+      if (submitted && !finished) {
+        try { agent.cancel({ kind: 'hook', reason: 'team-assignment-cancelled' }) } catch {}
+        let timer
+        try { finished = await Promise.race([agent.whenIdle().then(() => true, () => false), new Promise(resolve => { timer = setTimeout(() => resolve(false), cancelWaitMs) })]) }
+        finally { clearTimeout(timer) }
+      }
+      if (receipt) receipt.executionFinished = finished
+      if (failure) failure.executionFinished = !submitted || finished
+      off()
+    }
+  }
+  return Object.freeze({
+    hooks: { createSession: typeof rt.createSession === 'function', addThreadSession: typeof rt.addThreadSession === 'function' },
+    async resolveTargetRef(row) {
+      const bot = lifecycle.committedBot(row.targetBot)
+      if (!bot) fail(TEAM_CODES.TARGET_NOT_COMMITTED)
+      const host = threadHost()
+      if (host?.service?.create && host?.service?.ensureSession) {
+        const { thread } = host.service.create({ botId: row.targetBot, name: `Team: ${row.parentBot} → ${row.targetBot}`, requestKey: `team-${digest(row.workThreadKey).slice(0, 64)}` })
+        await host.service.ensureSession({ botId: row.targetBot, threadId: thread.threadId })
+        const gate = await host.sendGate({ botId: row.targetBot, threadId: thread.threadId })
+        if (!gate?.ok || !owns(row.targetBot, gate.sessionId)) fail(gate?.code ?? 'TEAM_SESSION_COMMIT_UNCONFIRMED')
+        return { mode: 'integration', sessionId: gate.sessionId, workThreadKey: row.workThreadKey, catalogThreadId: thread.threadId }
+      }
+      const prior = bot.threads?.find(thread => thread.threadId === row.workThreadKey && !thread.archivedAt)
+      if (prior) return { mode: 'integration', sessionId: prior.sessionId, workThreadKey: row.workThreadKey }
+      if (!rt.createSession || !rt.addThreadSession) fail('TEAM_SESSION_FACTORY_REQUIRED')
+      const title = `Team: ${row.parentBot} → ${row.targetBot}`
+      const sessionId = await rt.createSession(title, { dir: bot.workDir })
+      await rt.addThreadSession(row.targetBot, row.workThreadKey, sessionId, { name: title })
+      if (!owns(row.targetBot, sessionId)) fail('TEAM_SESSION_COMMIT_UNCONFIRMED')
+      return { mode: 'integration', sessionId, workThreadKey: row.workThreadKey }
+    },
+    dispatchTarget: row => submit(row, row.targetRef.sessionId, 'assign-task', row.requestId, composeBrief(row)),
+    readTarget,
+    captureOrigin({ callerBotId, sessionId }) { if (!owns(callerBotId, sessionId)) fail('TEAM_ORIGIN_UNCONFIRMED'); return { mode: 'integration', sessionId } },
+    originCurrent: (botId, origin) => origin.mode === 'integration' && owns(botId, origin.sessionId),
+    resumeSender(row) { if (!owns(row.parentBot, row.origin?.sessionId)) return { started: false, retired: true }; return submit(row, row.origin.sessionId, 'assign-result', `team-result-${row.assignmentId}`, composeResult(row)) },
+    async cancelTarget(row) { if (row.targetRef?.sessionId) { const agent = await resolve(row.targetBot, row.targetRef.sessionId); agent.cancel({ kind: 'hook', reason: 'team-assignment-cancelled' }) } },
+    isBusy: botId => rt.live?.get(rt.chatOf(botId))?.turn !== undefined,
+  })
+}
+
+export function createIndependentTeamBridge({ runtime } = {}) {
+  if (typeof runtime !== 'function') throw new TypeError('TEAM_BRIDGE_REQUIRES_RUNTIME')
+  const api = () => { const adapter = runtime(); if (!adapter?.workThreadTurn || !adapter?.resumeTeamTurn) fail('TEAM_WORKTHREAD_UNAVAILABLE'); return adapter }
+  const readTarget = row => {
+    const receipt = api().workThreadRead(row.targetBot, row.targetRef.workThreadKey, row.requestId ?? row.targetRequestId)
+    return receipt.hasConfirmedAnswer ? { outcome: 'succeeded', text: receipt.answer } : unknown(receipt.hasBrief ? 'TEAM_TARGET_ANSWER_UNCONFIRMED' : 'TEAM_TARGET_REQUEST_UNCONFIRMED')
+  }
+  return Object.freeze({
+    resolveTargetRef: row => ({ mode: 'independent', workThreadKey: row.workThreadKey, conversationId: `teamwt-${workThreadConversationKey(row.targetBot, row.workThreadKey)}` }),
+    async dispatchTarget(row) {
+      row.validate?.()
+      try { const result = await api().workThreadTurn({ botId: row.targetBot, workThreadId: row.targetRef.workThreadKey, conversationId: row.targetRef.conversationId, input: composeBrief(row), requestId: row.requestId, signal: row.signal, consult: row.mode === 'consult', validate: row.validate }); return { started: true, outcome: 'succeeded', text: result.answer } }
+      catch (error) { if (error.code === 'BOT_BUSY') return { started: false, code: TEAM_CODES.TARGET_BUSY }; return { started: true, ...readTarget(row), executionFinished: true } }
+    },
+    readTarget,
+    captureOrigin: row => api().captureTeamOrigin({ botId: row.callerBotId, conversationId: row.conversationId, workThreadId: row.workThreadId }),
+    originCurrent: (botId, origin) => api().teamOriginCurrent(botId, origin),
+    async resumeSender(row) {
+      try { return { ...await api().resumeTeamTurn({ botId: row.parentBot, origin: row.origin, requestId: `team-result-${row.assignmentId}`, input: composeResult(row), signal: row.signal, validate: row.validate }), executionFinished: true } }
+      catch (error) { error.executionFinished = true; throw error }
+    },
+    cancelTarget() {},
+    isBusy: botId => api().busyBots?.().includes(botId) === true,
+  })
+}
+
+export function createTeamBridge({ integrated, independent, serving }) {
+  const forBot = botId => { const bridge = serving.readMode(botId) === 'integration' ? integrated : serving.readMode(botId) === 'independent' ? independent : null; if (!bridge) fail('TEAM_BRIDGE_UNAVAILABLE'); return bridge }
+  // Recovery uses the recorded mode: moving a Bot cannot reinterpret an old receipt.
+  const forRef = ref => ref?.mode === 'integration' ? integrated : ref?.mode === 'independent' ? independent : null
+  return Object.freeze({
+    resolveTargetRef: row => forBot(row.targetBot).resolveTargetRef(row),
+    dispatchTarget: row => forRef(row.targetRef).dispatchTarget(row),
+    readTarget: row => forRef(row.targetRef)?.readTarget(row) ?? unknown('TEAM_BRIDGE_UNAVAILABLE'),
+    resumeSender: row => forRef(row.origin).resumeSender(row),
+    cancelTarget: row => forRef(row.targetRef)?.cancelTarget(row),
+    captureOrigin: row => forBot(row.callerBotId).captureOrigin(row),
+    originCurrent: (botId, origin) => serving.readMode(botId) === origin?.mode && forRef(origin)?.originCurrent(botId, origin) === true,
+    isBusy: botId => typeof serving.busy === 'function' ? serving.busy(botId) : forBot(botId).isBusy(botId),
+  })
+}
+
+/** Both doors supply Host-resolved origin/turn/call metadata, never model args. */
+export function createTeamCoordination({ Database, file, rt = null, directory, authority, lifecycle, serving, runtime = () => null, policy = null, sessionEvents = null, flush = null, integrated = null, independent = null, threadHost = () => null, now = Date.now, limits = {} } = {}) {
+  const maxDepth = limits.maxDepth ?? 4
+  const store = createTeamAssignmentStore({ Database, file, now })
+  const bridge = createTeamBridge({ integrated: integrated ?? (rt && flush ? createIntegratedTeamBridge({ rt, directory, authority, lifecycle, sessionEvents, flush, threadHost }) : null), independent: independent ?? createIndependentTeamBridge({ runtime }), serving })
+  const isMain = id => lifecycle.committedMainBotIds().includes(id)
+  const canUse = id => { try { if (!lifecycle.committedBot(id)) return false; authority.assertTool(directory.forBot(id), 'tool/team'); return true } catch { return false } }
+  const requireCaller = id => { if (!lifecycle.committedBot(id)) fail(TEAM_CODES.CALLER_NOT_COMMITTED); if (!canUse(id)) fail(TEAM_CODES.CALLER_NOT_AUTHORIZED) }
+  const reachable = (fromId, targetId) => {
+    const from = lifecycle.committedBot(fromId), target = lifecycle.committedBot(targetId)
+    if (!from || !target || fromId === targetId) return false
+    if (isMain(fromId)) return true
+    if (target.hidden || target.private || target.archivedAt || target.visibility !== undefined && target.visibility !== null && target.visibility !== 'everyone') return false
+    if (from.peers !== undefined && (!Array.isArray(from.peers) || !from.peers.includes(targetId))) return false
+    // A restricted sender may not disclose its brief into a broader audience.
+    if (from.visibility !== undefined && from.visibility !== null && from.visibility !== 'everyone') return false
+    return true
+  }
+  const accessAllowed = row => {
+    if (!canUse(row.parentBot) || !reachable(row.parentBot, row.targetBot)) return false
+    if (row.parentAssignmentId) { const parent = store.get(row.parentAssignmentId); if (!parent || parent.cancelRequestedAt !== null || parent.state === 'cancelled') return false }
+    try { authority.assertTool(directory.forBot(row.targetBot), 'model/infer'); return true } catch { return false }
+  }
+  const assertCanAct = (botId, { sessionId = null, conversationId = null } = {}) => {
+    const active = store.activeFor(botId, { sessionId, conversationId })
+    if (active?.mode === 'consult') fail('TEAM_CONSULT_READ_ONLY')
+    const resumed = active?.resumeAssignmentId ? store.get(active.resumeAssignmentId) : null
+    if (active && (active.cancelRequestedAt !== null || active.assignmentId && !accessAllowed(active) || resumed && !accessAllowed(resumed))) fail('TEAM_ACCESS_CHANGED')
+  }
+  const scheduler = createTeamScheduler({ store, bridge, checks: { committedBot: id => lifecycle.committedBot(id), accessAllowed, originAllowed: row => bridge.originCurrent(row.parentBot, row.origin) }, policy })
+  const scope = input => {
+    requireCaller(input.callerBotId)
+    const active = store.activeFor(input.callerBotId, { sessionId: input.sessionId, conversationId: input.conversationId })
+    const origin = bridge.captureOrigin({ ...input, workThreadId: active?.targetRef?.workThreadKey })
+    return { origin, originKey: digest(origin), active }
+  }
+  const shape = row => ({ assignmentId: row.assignmentId, requestKey: row.requestKey, targetBot: row.targetBot, workThreadKey: row.workThreadKey, threadId: row.workThreadKey, mode: row.mode, reply: row.reply, state: row.state, outcome: row.outcome, resultCode: row.resultCode, result: row.outcome === 'succeeded' ? row.resultText : null, resumeState: row.resumeState, reworkOf: row.reworkOf, depth: row.depth, cancelRequested: row.cancelRequestedAt !== null, ...(row.duplicate ? { duplicate: true } : {}) })
+  const coordinateBots = input => {
+    const { callerBotId, turnId, callId } = input
+    const { origin, originKey, active } = scope(input)
+    assertCanAct(callerBotId, input)
+    if (!turnId || !callId) fail('TEAM_HOST_TURN_REQUIRED')
+    const args = input.args
+    // Re-validate at the service door too; callers cannot bypass the shared parser.
+    parseTeamToolArgs('coordinate_bots', { bot_ids: args.targets, message: args.message, thread: args.thread ?? 'standing', reply: args.reply ?? 'resume', consult: args.consult ?? false, rework: args.rework ?? false, ...(args.doneWhen !== undefined && args.doneWhen !== null ? { done_when: args.doneWhen } : {}), ...(args.requestKey !== undefined ? { request_key: args.requestKey } : {}) })
+    const requestKey = args.requestKey ?? `call-${digest([turnId, callId]).slice(0, 60)}`
+    const mode = args.consult ? 'consult' : args.reply === 'none' ? 'notice' : 'work'
+    const lineage = active?.lineage ?? [callerBotId]
+    assertDepth(lineage, maxDepth)
+    const specs = args.targets.map(targetBot => {
+      if (targetBot === callerBotId) fail(TEAM_CODES.SELF_TARGET)
+      // A missing/private target produces the same refusal, without a name leak.
+      if (!reachable(callerBotId, targetBot)) fail(TEAM_CODES.CALLER_NOT_AUTHORIZED)
+      assertNoCycle(lineage, targetBot)
+      const requestedThread = args.thread ?? 'standing'
+      const workThreadKey = requestedThread === 'standing' ? standingThreadKey(callerBotId, targetBot, originKey) : requestedThread === 'new' ? `wt-${randomUUID()}` : requestedThread
+      if (!['new', 'standing'].includes(requestedThread) && !store.listByParent(callerBotId, { includeTerminal: true, originKey }).some(row => row.targetBot === targetBot && row.workThreadKey === workThreadKey)) fail(TEAM_CODES.THREAD_NOT_OWNED)
+      const spec = { parentBot: callerBotId, targetBot, requestedThread, workThreadKey, origin, originKey, mode, reply: args.reply ?? 'resume', brief: args.message, doneWhen: args.doneWhen ?? null, briefHash: computeBriefHash(mode, args.message, args.doneWhen, args.consult), rework: args.rework === true, lineage: [...lineage, targetBot], depth: lineage.length, rootBot: active?.rootBot ?? callerBotId, rootAssignmentId: active?.rootAssignmentId ?? active?.assignmentId ?? null, parentAssignmentId: active?.assignmentId ?? null, parentRequestId: active?.targetRequestId ?? null, createdByTurn: turnId, createdByCall: callId }
+      if (!accessAllowed(spec)) fail(TEAM_CODES.ACCESS_CHANGED)
+      return spec
+    })
+    const decision = store.createBatch(specs, { parentBot: callerBotId, originKey, requestKey, payloadHash: digest([args.targets, args.message, args.thread ?? 'standing', args.reply ?? 'resume', args.consult ?? false, args.rework ?? false, args.doneWhen ?? null]) })
+    if (decision.status === 'conflict') fail(TEAM_CODES.REQUEST_CONFLICT)
+    return { assignments: decision.assignments.map(row => ({ ...shape(row), ...(decision.status === 'replayed' ? { replayed: true } : {}) })) }
+  }
+  const rowsFor = input => { const scoped = scope(input); return store.listByParent(input.callerBotId, { includeTerminal: true, originKey: scoped.originKey }).filter(accessAllowed) }
+  return Object.freeze({
+    ready: true, canUse, assertCanAct, coordinateBots,
+    validateResult(input, value) {
+      requireCaller(input.callerBotId)
+      if (input.sessionId || input.conversationId) scope(input)
+      const targets = [...(value.assignments ?? []), ...(value.assignment ? [value.assignment] : []), ...(value.threads ?? [])].map(row => row.targetBot)
+      targets.push(...(value.bots ?? []).map(row => row.id))
+      if (targets.some(id => !reachable(input.callerBotId, id))) fail(TEAM_CODES.ACCESS_CHANGED)
+    },
+    assignmentStatus(input) {
+      const rows = rowsFor(input), args = input.args ?? {}
+      if (rows.some(row => row.createdByTurn === input.turnId)) fail('TEAM_STATUS_SAME_TURN')
+      if (args.id) { const row = rows.find(row => row.assignmentId === args.id); if (!row) fail(TEAM_CODES.ASSIGNMENT_NOT_FOUND); return { assignment: shape(row) } }
+      return { assignments: rows.filter(row => !['settled', 'unknown', 'cancelled'].includes(row.state)).map(shape) }
+    },
+    listBots({ callerBotId }) { requireCaller(callerBotId); return { bots: lifecycle.committedBots().filter(bot => reachable(callerBotId, bot.id)).map(bot => ({ id: bot.id, name: bot.name ?? bot.id, main: isMain(bot.id), model: bot.model ?? null, mode: serving.readMode(bot.id) })).sort((a, b) => a.id.localeCompare(b.id)) } },
+    listThreads(input) { const rows = rowsFor(input), seen = new Set(); return { threads: rows.reverse().filter(row => { if (seen.has(row.workThreadKey)) return false; seen.add(row.workThreadKey); return true }).map(row => ({ threadId: row.workThreadKey, targetBot: row.targetBot, title: row.brief.slice(0, 80), state: row.state, assignmentId: row.assignmentId, updatedAt: row.updatedAt })) } },
+    stop: botId => scheduler.stop(botId), store, scheduler,
+    start(options) { scheduler.start(options); return this }, tick: () => scheduler.tick(), whenIdle: () => scheduler.whenIdle(),
+    async drain(rounds = 24) { for (let index = 0; index < rounds; index++) { scheduler.tick(); await scheduler.whenIdle(); if (!store.dispatchable().length && !store.rowsForReconcile().length && !store.resumeDue().length) break }; return this },
+    close() { scheduler.close(); store.close() },
+  })
+}

package/packages/orchestration/src/team-scheduler.mjs

@@ -0,0 +1,83 @@
+import { randomUUID } from 'node:crypto'
+
+const safeCode = error => /^[A-Z][A-Z0-9_:-]{0,95}$/.test(error?.code ?? '') ? error.code : 'TEAM_OUTCOME_UNKNOWN'
+const known = receipt => ['succeeded', 'failed', 'cancelled'].includes(receipt?.outcome)
+
+/** Persist intent before effects. Running requests are read, never dispatched again.
+ * Sending resumes that lack a durable transport receipt are uncertain, never resent.
+ */
+export function createTeamScheduler({ store, bridge, checks, policy = null, pollMs = 200 } = {}) {
+  if (!store?.dispatchable || !bridge?.dispatchTarget || !checks?.accessAllowed) throw new TypeError('TEAM_SCHEDULER_DEPENDENCIES_REQUIRED')
+  if (!Number.isSafeInteger(pollMs) || pollMs < 5) throw new TypeError('TEAM_SCHEDULER_POLL_INVALID')
+  const inflight = new Map(), pending = new Set()
+  let closed = false, timer = null
+  const detached = operation => policy ? policy.runDetached(operation) : operation()
+  const allowed = row => !closed && row.cancelRequestedAt === null && checks.committedBot(row.parentBot) && checks.committedBot(row.targetBot) && checks.accessAllowed(row)
+  const launch = (row, kind, operation) => {
+    if (inflight.has(row.assignmentId) || closed) return
+    const controller = new AbortController()
+    inflight.set(row.assignmentId, { controller, kind })
+    const task = Promise.resolve().then(() => operation(controller.signal)).catch(() => {}).finally(() => { inflight.delete(row.assignmentId); pending.delete(task) })
+    pending.add(task)
+  }
+  const settle = (row, receipt) => {
+    if (closed) return
+    if (!known(receipt)) store.fenceUnknown(row.assignmentId, receipt?.code ?? 'TEAM_OUTCOME_UNKNOWN', { executionFinished: receipt?.executionFinished === true })
+    else store.settle(row.assignmentId, { outcome: receipt.outcome, resultText: receipt.text ?? null, resultCode: receipt.code ?? null })
+  }
+  const dispatch = async (row, signal) => {
+    if (!allowed(row)) { store.cancel(row.assignmentId, { resultCode: 'TEAM_ACCESS_CHANGED' }); return }
+    if (bridge.isBusy(row.targetBot)) return
+    if (!store.admit(row.assignmentId)) return
+    try {
+      const targetRef = await detached(() => bridge.resolveTargetRef(row))
+      const current = store.get(row.assignmentId)
+      if (signal.aborted || !allowed(current)) { store.cancel(row.assignmentId, { resultCode: 'TEAM_ACCESS_CHANGED' }); return }
+      const requestId = `teamreq_${randomUUID()}`
+      if (!store.beginDispatch(row.assignmentId, targetRef, requestId)) return
+      const receipt = await detached(() => bridge.dispatchTarget({ ...row, targetRef, requestId, signal, validate: () => { const current = store.get(row.assignmentId); if (signal.aborted || !allowed(current)) throw Object.assign(new Error('TEAM_ACCESS_CHANGED'), { code: 'TEAM_ACCESS_CHANGED' }) } }))
+      if (closed) return
+      if (receipt?.started === false) {
+        if (store.get(row.assignmentId).cancelRequestedAt === null) store.rewarm(row.assignmentId)
+        else store.fenceUnknown(row.assignmentId, 'TEAM_STOP_BEFORE_DISPATCH')
+      } else settle(row, receipt)
+    } catch (error) { if (!closed) store.fenceUnknown(row.assignmentId, safeCode(error), { executionFinished: error?.executionFinished === true }) }
+  }
+  const reconcile = async row => {
+    try { settle(row, await detached(() => bridge.readTarget({ ...row, requestId: row.targetRequestId }))) }
+    catch (error) { if (!closed) store.fenceUnknown(row.assignmentId, safeCode(error)) }
+  }
+  const resume = async (row, signal) => {
+    if (!allowed(row) || checks.originAllowed?.(row) === false) return
+    if (bridge.isBusy(row.parentBot) || !store.markResumeSending(row.assignmentId)) return
+    try {
+      const result = await detached(() => bridge.resumeSender({ ...row, signal, validate: () => { if (signal.aborted || !allowed(store.get(row.assignmentId)) || checks.originAllowed?.(row) === false) throw Object.assign(new Error('TEAM_ACCESS_CHANGED'), { code: 'TEAM_ACCESS_CHANGED', started: false, retired: true }) } }))
+      if (closed) return
+      if (result?.started === false) {
+        if (result.retired) store.completeResume(row.assignmentId, 'withheld')
+        else store.rewarmResume(row.assignmentId)
+      } else store.completeResume(row.assignmentId, result?.executionFinished === false ? 'uncertain' : 'delivered', { executionFinished: result?.executionFinished !== false })
+    } catch (error) {
+      if (closed) return
+      if (error?.started === false && !error.retired) store.rewarmResume(row.assignmentId)
+      else store.completeResume(row.assignmentId, error?.retired ? 'withheld' : 'uncertain', { executionFinished: error?.executionFinished === true || error?.started === false })
+    }
+  }
+  const tick = () => {
+    if (closed) return
+    for (const row of store.rowsForReconcile()) launch(row, 'reconcile', () => reconcile(row))
+    for (const row of store.dispatchable()) launch(row, 'dispatch', signal => dispatch(row, signal))
+    for (const row of store.resumeDue()) launch(row, 'resume', signal => resume(row, signal))
+  }
+  return Object.freeze({
+    tick,
+    async whenIdle() { while (pending.size) await Promise.allSettled([...pending]) },
+    stop(botId) {
+      const rows = store.all().filter(row => !['settled', 'unknown', 'cancelled'].includes(row.state) && (row.lineage.includes(botId) || row.parentBot === botId))
+      for (const row of rows) { store.requestCancel(row.assignmentId); inflight.get(row.assignmentId)?.controller.abort(Object.assign(new Error('TEAM_SUBTREE_STOPPED'), { code: 'TEAM_SUBTREE_STOPPED' })); if (row.targetRef) Promise.resolve(detached(() => bridge.cancelTarget(row))).catch(() => {}) }
+      return { stopped: rows.map(row => row.assignmentId) }
+    },
+    start({ auto = true } = {}) { store.recover(); tick(); if (auto && !closed && !timer) { timer = setInterval(tick, pollMs); timer.unref?.() }; return this },
+    close() { if (closed) return; closed = true; clearInterval(timer); for (const { controller } of inflight.values()) controller.abort(Object.assign(new Error('TEAM_SCHEDULER_CLOSED'), { code: 'TEAM_SCHEDULER_CLOSED' })) },
+  })
+}

package/packages/orchestration/src/team-sdk-tools.mjs

@@ -0,0 +1,84 @@
+/**
+ * The SDK (integrated Harness) door for the four teammate-coordination tools.
+ *
+ * Registered through `ctx.tools.register` exactly as the data tools are
+ * (bot-data-tools.mjs), reading names, descriptions and the SDK parameter map from the
+ * ONE shared contract (team-tool-contract.mjs) so the SDK and native doors cannot drift.
+ *
+ * Authority: the calling Bot comes from the live session through the injected
+ * `botIdFor(exec)` — never from an argument, which parseTeamToolArgs has already refused
+ * any `botId`/`owner`/route/session key in. The sender's Harness Session id is read from
+ * the live agent so a result returns into THIS conversation and resumes it; the target's
+ * own model, tools, permissions and funding are re-derived inside the target's frame, so
+ * nothing here lends the caller's authority to the target.
+ *
+ * Note for the parent: `list_bots` already exists in the vendored roster for integrated
+ * Bots. Register the NEW team tools (`coordinate_bots`, `assignment_status`,
+ * `list_threads`) here and keep the vendor `list_bots`; register `list_bots` from this
+ * family only on the native (independent) door, which has no roster tool of its own.
+ */
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import { TEAM_TOOL_ENTRIES, TEAM_CODES, parseTeamToolArgs, projectCoordinateArgs } from './team-tool-contract.mjs'
+import { redactNativeToolValue } from './native-conversation-tools.mjs'
+
+const JSON_OUTPUT = { schema: { type: 'json' }, render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }] }
+const safeCode = code => /^[A-Z][A-Z0-9_:-]{0,95}$/.test(code ?? '') ? code : 'TEAM_CALL_FAILED'
+// Installed SDK author DSL does not support array cardinality/uniqueness. The
+// shared parser enforces these bounds before any service effect; MCP keeps them.
+const sdkParameters = parameters => Object.fromEntries(Object.entries(parameters).map(([key, spec]) => {
+  const { minItems, maxItems, uniqueItems, minLength, maxLength, ...supported } = spec
+  return [key, supported]
+}))
+
+/**
+ * @param {object} ctx Host tool registry ({ tools: { register } }).
+ * @param {{ service: object, botIdFor: (exec: object) => string | null, names?: string[] }} source
+ * @returns {() => void} release
+ */
+export function registerTeamTools(ctx, { service, botIdFor, names = ['coordinate_bots', 'assignment_status', 'list_threads'], redact = text => text } = {}) {
+  if (!service || typeof service.coordinateBots !== 'function') throw new TypeError('TEAM_TOOLS_REQUIRE_SERVICE')
+  if (typeof botIdFor !== 'function') throw new TypeError('TEAM_TOOLS_REQUIRE_BOT_ID_FOR')
+  if (!ctx || typeof ctx.tools?.register !== 'function') throw new TypeError('TEAM_TOOLS_REQUIRE_CTX')
+  const offered = new Set(Array.isArray(names) ? names : TEAM_TOOL_ENTRIES.map(entry => entry.name))
+
+  const asBot = async (exec, run) => {
+    let botId = null
+    try { botId = botIdFor(exec) ?? null } catch (error) {
+      return { error: { code: safeCode(error?.code), message: redact(String(error?.message ?? error)) } }
+    }
+    if (typeof botId !== 'string' || botId === '') return { error: { code: 'unknown_subject', message: 'The calling Bot could not be identified from the live session.' } }
+    const sessionId = exec?.agent?.session?.id ?? null
+    try {
+      exec.signal.throwIfAborted()
+      if (!service.canUse(botId)) throw Object.assign(new Error('TEAM_CALLER_NOT_AUTHORIZED'), { code: 'TEAM_CALLER_NOT_AUTHORIZED' })
+      const boundary = (exec.agent.ctx?.sessionProjections ?? ctx.sessionProjections)?.stateOf(exec.agent.session, 'turnBoundary')
+      if (boundary?.openTurnStartSeq === null || boundary?.openTurnStartSeq === undefined || !exec.callId) throw Object.assign(new Error('TEAM_HOST_TURN_REQUIRED'), { code: 'TEAM_HOST_TURN_REQUIRED' })
+      const request = { callerBotId: botId, sessionId, turnId: `sdk-${sessionId}-${boundary.openTurnStartSeq}`, callId: exec.callId, signal: exec.signal }
+      const value = await run(request)
+      exec.signal.throwIfAborted()
+      if (botIdFor(exec) !== botId || !service.canUse(botId)) throw Object.assign(new Error('TEAM_ACCESS_CHANGED'), { code: 'TEAM_ACCESS_CHANGED' })
+      service.validateResult?.(request, value)
+      return redactNativeToolValue(value, redact)
+    } catch (error) { return { error: { code: safeCode(error?.code), message: redact(String(error?.message ?? error)) } } }
+  }
+
+  const tools = TEAM_TOOL_ENTRIES.filter(entry => offered.has(entry.name)).map(entry => defineTool({
+    name: entry.name,
+    description: entry.description,
+    parameters: sdkParameters(entry.parameters),
+    output: JSON_OUTPUT,
+    execute: (args, exec) => asBot(exec, async request => {
+      const parsed = parseTeamToolArgs(entry.name, args)
+      if (entry.method === 'coordinateBots') { const value = await service.coordinateBots({ ...request, args: projectCoordinateArgs(parsed) }); exec.concludeTurn?.(); return value }
+      if (entry.method === 'assignmentStatus') return service.assignmentStatus({ ...request, args: parsed })
+      if (entry.method === 'listBots') return service.listBots(request)
+      return service.listThreads(request)
+    }),
+  }))
+
+  const releases = tools.map(tool => ctx.tools.register(tool))
+  return () => { for (const release of releases.reverse()) release() }
+}
+
+export { TEAM_CODES }