botinabox 2.9.0 → 2.9.2

package/dist/core/chat/chat-pipeline-v2.d.ts

@@ -0,0 +1,138 @@
+/**
+ * ChatPipelineV2 — Primary Agent Architecture.
+ *
+ * Replaces the 6-layer "dumb ack + headless execution" pattern with a
+ * 3-phase "conversational brain + tool delegation" pattern:
+ *
+ *   Phase 1: RECEIVE — Store message, build history, emit typing indicator
+ *   Phase 2: THINK  — Call primary agent LLM with history + tools in a loop
+ *   Phase 3: RESPOND — Deliver agent's text, run async memory extraction
+ *
+ * The primary agent is the conversational hub. It has full conversation
+ * context and uses tools to answer directly (single-agent) or delegate
+ * work (multi-agent). One response per message — no separate ack.
+ */
+import type { DataStore } from '../data/data-store.js';
+import type { HookBus } from '../hooks/hook-bus.js';
+import type { InboundMessage } from './types.js';
+import type { ToolDefinition, ToolHandler } from '../orchestrator/execution-engine.js';
+import type { SystemContextOptions } from '../data/context-builder.js';
+import type { Extractor } from './message-interpreter.js';
+import { MessageStore } from './message-store.js';
+import { ChatResponder } from './chat-responder.js';
+import { MessageInterpreter } from './message-interpreter.js';
+type ContentBlock = {
+    type: string;
+    text?: string;
+    id?: string;
+    name?: string;
+    input?: unknown;
+    source?: unknown;
+};
+type MessageParam = {
+    role: string;
+    content: string | ContentBlock[];
+};
+export interface ChatPipelineV2Config {
+    /** Primary agent LLM call — supports tool use */
+    llmCall: (params: {
+        model: string;
+        messages: MessageParam[];
+        system?: string;
+        maxTokens?: number;
+        tools?: ToolDefinition[];
+        tool_choice?: {
+            type: string;
+        };
+    }) => Promise<{
+        content: ContentBlock[];
+        stop_reason: string;
+        usage?: {
+            input_tokens: number;
+            output_tokens: number;
+        };
+    }>;
+    /** System prompt for the primary agent */
+    systemPrompt: string;
+    /** Tools available to the primary agent */
+    tools?: Array<{
+        definition: ToolDefinition;
+        handler: ToolHandler;
+    }>;
+    /** Model (default: 'claude-sonnet-4-6') */
+    model?: string;
+    /** Max tool loop iterations (default: 5) */
+    maxIterations?: number;
+    /** Max tokens for response (default: 4096) */
+    maxTokens?: number;
+    /** Optional message filter */
+    messageFilter?: (msg: InboundMessage) => boolean;
+    /** Channel (default: 'slack') */
+    channel?: string;
+    /** Dedup window ms (default: 300_000) */
+    dedupWindowMs?: number;
+    /** Conversation history config */
+    history?: {
+        maxMessages?: number;
+        maxAgeDays?: number;
+        includeAssistant?: boolean;
+    };
+    /** Include system context from DB (default: true) */
+    includeSystemContext?: boolean;
+    /** Options for buildSystemContext */
+    systemContextOptions?: SystemContextOptions;
+    /** TaskQueue for dispatch_task and sub-agent result delivery */
+    tasks: {
+        create(task: Record<string, unknown>): Promise<string>;
+        update(id: string, changes: Record<string, unknown>): Promise<void>;
+        get(id: string): Promise<Record<string, unknown> | undefined>;
+    };
+    /** WakeupQueue for agent wakeup */
+    wakeups: {
+        enqueue(agentId: string, source: string, context?: Record<string, unknown>): Promise<string>;
+    };
+    /** Custom extractors for async memory extraction */
+    extractors?: Extractor[];
+    /** Sub-agent result handling (default: 'passthrough') */
+    subAgentResultMode?: 'passthrough' | 'synthesize';
+    /** Resolve file paths from DB-relative to absolute */
+    resolveFilePath?: (path: string) => string;
+}
+export declare class ChatPipelineV2 {
+    private db;
+    private hooks;
+    private config;
+    readonly messageStore: MessageStore;
+    readonly responder: ChatResponder;
+    readonly interpreter: MessageInterpreter;
+    private readonly channel;
+    private readonly messageFilter?;
+    private readonly dedupWindowMs;
+    private readonly threadChannelMap;
+    private readonly toolDefs;
+    private readonly toolHandlers;
+    constructor(db: DataStore, hooks: HookBus, config: ChatPipelineV2Config);
+    /**
+     * Resolve the channel ID for a thread (for response delivery).
+     */
+    resolveChannel(threadId: string, taskId?: string): Promise<string | undefined>;
+    private registerHandlers;
+    /**
+     * Primary agent tool loop — adapted from ExecutionEngine pattern.
+     */
+    private think;
+    /**
+     * Build conversation history from channel messages.
+     * Includes BOTH user and assistant messages (unlike v1 which excluded bot messages).
+     */
+    private buildHistory;
+    /**
+     * Dedup check (same as v1).
+     */
+    private isDuplicate;
+    /**
+     * Async memory extraction (non-blocking, non-fatal).
+     */
+    private extractAsync;
+}
+export {};

package/dist/core/chat/chat-pipeline.d.ts

@@ -0,0 +1,116 @@
+/**
+ * ChatPipeline — configurable 6-layer chat orchestration.
+ * Story 7.4
+ *
+ * Replaces duplicated handler code across apps with a single configurable
+ * pipeline. Apps provide: system prompt, routing rules, LLM call function,
+ * and optional message filter. Everything else is framework-level.
+ *
+ * Layers:
+ *   1. Dedup + Storage (MessageStore)
+ *   2. Fast Response (ChatResponder)
+ *   3. Interpretation (MessageInterpreter)
+ *   4. Post-Interpretation Response
+ *   5. Task Dispatch (TriageRouter)
+ *   6. Task Execution Response
+ */
+import type { DataStore } from '../data/data-store.js';
+import type { HookBus } from '../hooks/hook-bus.js';
+import type { InboundMessage } from './types.js';
+import { MessageStore } from './message-store.js';
+import { ChatResponder } from './chat-responder.js';
+import type { ChatResponderConfig } from './chat-responder.js';
+import { MessageInterpreter } from './message-interpreter.js';
+import type { Extractor } from './message-interpreter.js';
+import { TriageRouter } from './triage-router.js';
+import type { RoutingRule } from './triage-router.js';
+export interface ChatPipelineConfig {
+    /** LLM call function for chat responses and interpretation */
+    llmCall: ChatResponderConfig['llmCall'];
+    /** System prompt for the conversational responder */
+    systemPrompt: string;
+    /** Agent routing rules for task dispatch */
+    routingRules: RoutingRule[];
+    /** Default agent when no rule matches */
+    fallbackAgent: string;
+    /** Optional message filter — return false to ignore a message */
+    messageFilter?: (msg: InboundMessage) => boolean;
+    /** Optional capabilities description for the responder */
+    capabilities?: string;
+    /** Channel this pipeline handles (default: 'slack') */
+    channel?: string;
+    /** Custom extractors for MessageInterpreter */
+    extractors?: Extractor[];
+    /** Dedup window in ms (default: 300_000 = 5 min) */
+    dedupWindowMs?: number;
+    /** Model for fast responses (default: 'fast') */
+    model?: string;
+    /** Enable LLM fallback routing (default: false) */
+    llmRouting?: boolean;
+    /** Skip the ack layer — no fast response before task dispatch (default: false) */
+    skipAck?: boolean;
+    /** TaskQueue instance — required for task dispatch */
+    tasks: {
+        create(task: Record<string, unknown>): Promise<string>;
+        update(id: string, changes: Record<string, unknown>): Promise<void>;
+        get(id: string): Promise<Record<string, unknown> | undefined>;
+    };
+    /** WakeupQueue instance — required for agent waking */
+    wakeups: {
+        enqueue(agentId: string, source: string, context?: Record<string, unknown>): Promise<string>;
+    };
+}
+export declare class ChatPipeline {
+    private db;
+    private hooks;
+    readonly messageStore: MessageStore;
+    readonly responder: ChatResponder;
+    readonly interpreter: MessageInterpreter;
+    readonly router: TriageRouter;
+    private readonly channel;
+    private readonly messageFilter?;
+    private readonly capabilities?;
+    private readonly dedupWindowMs;
+    private readonly tasks;
+    private readonly wakeups;
+    private readonly skipAck;
+    private readonly threadChannelMap;
+    /** Last dispatch promise — exposed for testing. */
+    lastDispatch: Promise<void>;
+    constructor(db: DataStore, hooks: HookBus, config: ChatPipelineConfig);
+    /**
+     * Resolve the Slack channel ID for a thread (for response delivery).
+     */
+    resolveChannel(threadId: string, taskId?: string): Promise<string | undefined>;
+    /**
+     * Register the 6-layer pipeline on the HookBus.
+     */
+    private registerHandlers;
+    /**
+     * Check and record message dedup (SHA256 hash, configurable window).
+     */
+    private isDuplicate;
+    /**
+     * Async interpretation + task dispatch (Layers 3-5).
+     *
+     * ALWAYS creates a task programmatically — task creation does not depend
+     * on LLM classification. Interpretation enriches but never gates dispatch.
+     */
+    private interpretAndDispatch;
+    /**
+     * Programmatic task creation — guaranteed, no LLM dependency.
+     */
+    private guaranteedTaskDispatch;
+    /**
+     * Route and dispatch extracted tasks.
+     */
+    private dispatchTasks;
+    /**
+     * Resolve Slack channel ID from thread_task_map or in-memory fallback.
+     */
+    private resolveChannelId;
+    /**
+     * Build human-readable interpretation summary.
+     */
+    private buildSummary;
+}

package/dist/core/chat/chat-responder.d.ts

@@ -0,0 +1,94 @@
+/**
+ * ChatResponder — fast conversational layer with LLM-filtered responses.
+ * Story 7.2
+ *
+ * Provides rapid (<2s) conversational responses using a cheap LLM (Haiku).
+ * The responder has awareness of tools and capabilities but does NOT execute
+ * anything — it keeps the conversation going while work happens async.
+ *
+ * All outbound messages (direct, post-interpretation, task execution) are
+ * filtered through this layer for human readability and redundancy checking.
+ */
+import type { DataStore } from '../data/data-store.js';
+import type { HookBus } from '../hooks/hook-bus.js';
+import type { ChatMessage } from '../../shared/index.js';
+import type { MessageStore } from './message-store.js';
+export interface ChatResponderConfig {
+    /** System prompt for the conversational responder */
+    systemPrompt?: string;
+    /** Max tokens for context window. Default: 4000 */
+    contextWindowTokens?: number;
+    /** Max recent outbound messages to check for redundancy. Default: 10 */
+    redundancyWindow?: number;
+    /** Model to use for responses. Default: 'fast' (resolved via ModelRouter) */
+    model?: string;
+    /** Caller-provided LLM call function */
+    llmCall: (params: {
+        model: string;
+        messages: ChatMessage[];
+        system?: string;
+        maxTokens?: number;
+    }) => Promise<{
+        content: string;
+    }>;
+}
+export declare class ChatResponder {
+    private db;
+    private hooks;
+    private messageStore;
+    private readonly systemPrompt;
+    private readonly contextWindowTokens;
+    private readonly redundancyWindow;
+    private readonly model;
+    private readonly llmCall;
+    constructor(db: DataStore, hooks: HookBus, messageStore: MessageStore, config: ChatResponderConfig);
+    /**
+     * Generate a fast conversational response to an inbound message.
+     * Uses rolling context window from thread history.
+     */
+    respond(opts: {
+        messageBody: string;
+        threadId: string;
+        channel: string;
+        userName?: string;
+        capabilities?: string;
+        additionalContext?: string;
+    }): Promise<string>;
+    /**
+     * Filter any outbound message through the LLM for human readability.
+     * This is the single funnel ALL responses pass through.
+     */
+    filterResponse(text: string, context?: {
+        channel?: string;
+        threadId?: string;
+        source?: string;
+    }): Promise<string>;
+    /**
+     * Check if a candidate outbound message is redundant with recent messages.
+     * Returns true if the message should be suppressed.
+     */
+    isRedundant(text: string, threadId: string): Promise<boolean>;
+    /**
+     * Full send pipeline: check redundancy → filter → store → deliver.
+     * Returns the message ID, or undefined if suppressed as redundant.
+     */
+    sendResponse(opts: {
+        text: string;
+        channel: string;
+        threadId: string;
+        agentId?: string;
+        agentSlug?: string;
+        taskId?: string;
+        source?: string;
+        skipRedundancyCheck?: boolean;
+        skipFilter?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Build a context window from thread history, trimmed to token limit.
+     *
+     * Only includes inbound (user) messages. Outbound (bot) messages are
+     * excluded to prevent the ack layer from mimicking prior verbose responses,
+     * which caused hallucinated system state and walls of text.
+     */
+    private buildContextWindow;
+}

package/dist/core/chat/formatter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Text formatter — converts markdown to channel-specific formats.
+ * Story 4.4
+ */
+/**
+ * Format text for the given mode:
+ * - 'mrkdwn': Slack's mrkdwn format (**bold** → *bold*, _italic_ preserved, `code` preserved)
+ * - 'html': basic markdown → HTML (strong, em, code, pre)
+ * - 'plain': strip markdown markers
+ */
+export declare function formatText(text: string, mode: "mrkdwn" | "html" | "plain"): string;

package/dist/core/chat/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Chat layer exports — Stories 4.1–4.4
+ */
+export { ChannelRegistry, ChannelRegistryError } from "./channel-registry.js";
+export { discoverChannels } from "./auto-discovery.js";
+export { MessagePipeline } from "./pipeline.js";
+export { buildAgentBindings } from "./routing.js";
+export { TriageRouter } from "./triage-router.js";
+export type { RoutingRule, RoutingDecision, TriageRouterConfig } from "./triage-router.js";
+export { checkAllowlist, checkMentionGate } from "./policies.js";
+export { SessionKey } from "./session-key.js";
+export { ChatSessionManager } from "./session-manager.js";
+export { NotificationQueue } from "./notification-queue.js";
+export { MessageStore } from "./message-store.js";
+export type { StoredAttachment, StoreResult } from "./message-store.js";
+export { ChatResponder } from "./chat-responder.js";
+export type { ChatResponderConfig } from "./chat-responder.js";
+export { MessageInterpreter } from "./message-interpreter.js";
+export type { Extractor, ExtractedTask, ExtractedMemory, ExtractedFile, ExtractedUserContext, InterpretationResult, MessageInterpreterConfig, LLMCallFn, } from "./message-interpreter.js";
+export { ChatPipeline } from "./chat-pipeline.js";
+export type { ChatPipelineConfig } from "./chat-pipeline.js";
+export { ChatPipelineV2 } from "./chat-pipeline-v2.js";
+export type { ChatPipelineV2Config } from "./chat-pipeline-v2.js";
+export { chunkText } from "./text-chunker.js";
+export { formatText } from "./formatter.js";
+export type { ChatType, FormattingMode, ChannelCapabilities, ChannelMeta, InboundMessage, Attachment, OutboundPayload, SendResult, HealthStatus, ChannelConfig, ChannelAdapter, } from "./types.js";

package/dist/core/chat/message-interpreter.d.ts

@@ -0,0 +1,91 @@
+/**
+ * MessageInterpreter — async structured extraction from messages.
+ * Story 7.3
+ *
+ * After every message is stored, the interpreter runs async to extract
+ * structured data types: tasks, memories, files, user context, and custom types.
+ *
+ * Uses a cheap LLM (Haiku) for classification and extraction.
+ * Pluggable extractors allow apps to add custom data types.
+ */
+import type { DataStore } from '../data/data-store.js';
+import type { HookBus } from '../hooks/hook-bus.js';
+import type { ChatMessage } from '../../shared/index.js';
+export interface ExtractedTask {
+    title: string;
+    description?: string;
+    dueDate?: string;
+    scheduled?: boolean;
+    priority?: number;
+}
+export interface ExtractedMemory {
+    summary: string;
+    contents: string;
+    tags?: string[];
+    category?: string;
+}
+export interface ExtractedFile {
+    filename: string;
+    fileType: string;
+    contents: string;
+    summary: string;
+}
+export interface ExtractedUserContext {
+    trait: string;
+    value: string;
+}
+export interface InterpretationResult {
+    messageId: string;
+    tasks: ExtractedTask[];
+    memories: ExtractedMemory[];
+    files: ExtractedFile[];
+    userContext: ExtractedUserContext[];
+    custom: Record<string, unknown[]>;
+    isTaskRequest: boolean;
+}
+export type LLMCallFn = (params: {
+    model: string;
+    messages: ChatMessage[];
+    system?: string;
+    maxTokens?: number;
+}) => Promise<{
+    content: string;
+}>;
+/**
+ * Pluggable extractor interface for custom data types.
+ */
+export interface Extractor {
+    readonly type: string;
+    extract(message: {
+        body: string;
+        attachments?: Array<Record<string, unknown>>;
+    }, llmCall: LLMCallFn): Promise<unknown[]>;
+}
+export interface MessageInterpreterConfig {
+    /** Additional custom extractors beyond built-in ones */
+    extractors?: Extractor[];
+    /** Model for interpretation LLM calls. Default: 'fast' */
+    model?: string;
+    /** LLM call function */
+    llmCall: LLMCallFn;
+    /** Auto-create tasks from extracted tasks. Default: false */
+    autoCreateTasks?: boolean;
+}
+export declare class MessageInterpreter {
+    private db;
+    private hooks;
+    private readonly extractors;
+    private readonly model;
+    private readonly llmCall;
+    private readonly autoCreateTasks;
+    constructor(db: DataStore, hooks: HookBus, config: MessageInterpreterConfig);
+    /**
+     * Interpret a stored message asynchronously.
+     * Extracts tasks, memories, files, user context, and custom types.
+     */
+    interpret(messageId: string): Promise<InterpretationResult>;
+    /**
+     * Extract structured data from message text using LLM.
+     */
+    private extractWithLLM;
+}

package/dist/core/chat/message-store.d.ts

@@ -0,0 +1,71 @@
+/**
+ * MessageStore — store-before-respond guarantee for all chat interactions.
+ * Story 7.1
+ *
+ * Every inbound message (with attachments) is stored BEFORE the bot responds.
+ * Every outbound message is stored BEFORE it is sent to the user.
+ * Storage confirmation is required before any response flows.
+ */
+import type { DataStore } from '../data/data-store.js';
+import type { HookBus } from '../hooks/hook-bus.js';
+import type { InboundMessage } from './types.js';
+export interface StoredAttachment {
+    fileType: string;
+    filename?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    contents?: string;
+    summary?: string;
+    url?: string;
+}
+export interface StoreResult {
+    messageId: string;
+    attachmentIds: string[];
+}
+export declare class MessageStore {
+    private db;
+    private hooks;
+    constructor(db: DataStore, hooks: HookBus);
+    /**
+     * Store an inbound message and its attachments.
+     * Must complete successfully before any bot response is generated.
+     */
+    storeInbound(msg: InboundMessage): Promise<StoreResult>;
+    /**
+     * Store an outbound message BEFORE sending it.
+     * Returns the message ID for confirmation tracking.
+     */
+    storeOutbound(opts: {
+        channel: string;
+        text: string;
+        threadId?: string;
+        agentId?: string;
+        agentSlug?: string;
+        taskId?: string;
+    }): Promise<string>;
+    /**
+     * Store an attachment linked to a message.
+     */
+    storeAttachment(messageId: string, att: StoredAttachment): Promise<string>;
+    /**
+     * Get recent messages in a thread for context building.
+     */
+    getThreadHistory(threadId: string, limit?: number): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Get recent outbound messages in a thread for redundancy checking.
+     */
+    getRecentOutbound(threadId: string, limit?: number): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Get recent messages in a channel (all threads combined).
+     * More reliable than getThreadHistory for DMs where thread_ids are inconsistent.
+     */
+    getChannelHistory(channel: string, limit?: number): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Get recent messages from a specific user across all threads.
+     */
+    getUserHistory(userId: string, channel: string, limit?: number): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Get attachments for a message.
+     */
+    getAttachments(messageId: string): Promise<Array<Record<string, unknown>>>;
+}

package/dist/core/chat/notification-queue.d.ts

@@ -0,0 +1,34 @@
+/**
+ * NotificationQueue — persistent outbound notification queue with retry.
+ * Story 4.4
+ */
+import type { DataStore } from "../data/data-store.js";
+import type { HookBus } from "../hooks/hook-bus.js";
+import type { ChannelRegistry } from "./channel-registry.js";
+export interface NotificationQueueOpts {
+    maxRetries?: number;
+    pollIntervalMs?: number;
+}
+export declare class NotificationQueue {
+    private readonly db;
+    private readonly hooks;
+    private readonly channelRegistry;
+    private readonly maxRetries;
+    private readonly pollIntervalMs;
+    private timer;
+    constructor(db: DataStore, hooks: HookBus, channelRegistry: ChannelRegistry, opts?: NotificationQueueOpts);
+    /**
+     * Enqueue a notification for delivery.
+     * Returns the notification ID.
+     */
+    enqueue(channel: string, recipient: string, payload: {
+        text: string;
+        threadId?: string;
+        [key: string]: unknown;
+    }): Promise<string>;
+    /** Start the background worker polling for pending notifications. */
+    startWorker(): void;
+    /** Stop the background worker. */
+    stopWorker(): void;
+    private processNext;
+}

package/dist/core/chat/pipeline.d.ts

@@ -0,0 +1,38 @@
+/**
+ * MessagePipeline — routes inbound messages to the task queue.
+ * Story 4.2
+ */
+import type { HookBus } from "../hooks/hook-bus.js";
+import type { AgentRegistry } from "../orchestrator/agent-registry.js";
+import type { TaskQueue } from "../orchestrator/task-queue.js";
+import type { UserRegistry } from "../orchestrator/user-registry.js";
+import type { BotConfig } from "../../shared/index.js";
+import type { InboundMessage } from "./types.js";
+export declare class MessagePipeline {
+    private readonly hooks;
+    private readonly agentRegistry;
+    private readonly taskQueue;
+    private readonly config;
+    private readonly agentBindings;
+    private readonly userRegistry?;
+    constructor(hooks: HookBus, agentRegistry: AgentRegistry, taskQueue: TaskQueue, config: BotConfig, userRegistry?: UserRegistry);
+    /**
+     * Process an inbound message end-to-end.
+     * 1. Emit 'message.inbound'
+     * 2. Resolve agent
+     * 3. Check policy (allowlist / mention gate)
+     * 4. Create task
+     * 5. Emit 'message.processed'
+     */
+    processInbound(msg: InboundMessage): Promise<void>;
+    /**
+     * Resolve the best agent for a given inbound message.
+     * Returns agentId (slug) or undefined if no match.
+     */
+    resolveAgent(msg: InboundMessage): string | undefined;
+    /**
+     * Evaluate messaging policy for the given agent.
+     * Returns false if the message is blocked.
+     */
+    evaluatePolicy(msg: InboundMessage, agentId: string): boolean;
+}

package/dist/core/chat/policies.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Chat policy helpers — allowlist and mention gate checks.
+ * Story 4.2
+ */
+import type { InboundMessage } from "./types.js";
+/**
+ * Returns true if the sender is in the allowlist.
+ * If allowFrom is empty, all senders are allowed.
+ */
+export declare function checkAllowlist(allowFrom: string[], senderId: string): boolean;
+/**
+ * Returns true if the message passes the mention gate.
+ * In group/channel contexts, the bot must be mentioned (body contains @botId or similar).
+ * In direct contexts, always passes.
+ */
+export declare function checkMentionGate(msg: InboundMessage, botId: string): boolean;

package/dist/core/chat/routing.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Chat routing — maps channel/scope to agentId.
+ * Story 4.2
+ *
+ * @deprecated Use TriageRouter for content-aware routing with keyword/regex
+ * matching and LLM fallback. This static channel→agent binding is kept for
+ * backward compatibility only. See `./triage-router.ts`.
+ */
+import type { AgentConfig } from "../../shared/index.js";
+/**
+ * Build a map from channel identifier to agentId.
+ * Each agent may have a config.channel or config.channels binding.
+ *
+ * @deprecated Use TriageRouter instead — it supports keyword, regex,
+ * and LLM-based routing with ownership chain logging.
+ */
+export declare function buildAgentBindings(agents: AgentConfig[]): Map<string, string>;