botinabox 1.9.2 → 1.10.0

package/dist/channels/discord/index.js

@@ -1,6 +1,7 @@
 import {
   parseDiscordEvent
 } from "../../chunk-DLJKZD3Q.js";
+import "../../chunk-3RG5ZIWI.js";
 
 // src/channels/discord/outbound.ts
 var DISCORD_MAX_LENGTH = 2e3;
@@ -80,7 +81,7 @@ var DiscordAdapter = class {
   /** Simulate receiving an inbound message (for testing/webhooks). */
   async receive(event) {
     if (this.onMessage) {
-      const { parseDiscordEvent: parseDiscordEvent2 } = await import("../../inbound-SNEMBLGA.js");
+      const { parseDiscordEvent: parseDiscordEvent2 } = await import("../../inbound-WU7X2HGA.js");
       const msg = parseDiscordEvent2(event);
       await this.onMessage(msg);
     }

package/dist/channels/slack/index.d.ts

@@ -1,5 +1,5 @@
 import { C as ChannelAdapter, c as ChannelMeta, a as ChannelCapabilities, I as InboundMessage, b as ChannelConfig, H as HealthStatus, O as OutboundPayload, S as SendResult } from '../../channel-06G0vbIn.js';
-import { H as HookBus, a as ChatPipeline } from '../../chat-pipeline-DisuC8SB.js';
+import { H as HookBus, a as ChatPipeline } from '../../chat-pipeline-C-XlLGNl.js';
 import 'better-sqlite3';
 import '../../provider-DLGUfnNx.js';
 

package/dist/channels/slack/index.js

@@ -8,6 +8,7 @@ import {
 import {
   chunkText
 } from "../../chunk-ZTZFPTOQ.js";
+import "../../chunk-3RG5ZIWI.js";
 
 // src/channels/slack/outbound.ts
 function formatForSlack(text) {
@@ -70,8 +71,8 @@ var SlackAdapter = class {
   /** Simulate receiving an inbound message (for testing/webhooks). */
   async receive(event) {
     if (this.onMessage) {
-      const { parseSlackEvent: parseSlackEvent2 } = await import("../../inbound-ZJHAYVMF.js");
-      const { enrichVoiceMessage: enrichVoiceMessage2 } = await import("../../inbound-ZJHAYVMF.js");
+      const { parseSlackEvent: parseSlackEvent2 } = await import("../../inbound-IBKXBFZF.js");
+      const { enrichVoiceMessage: enrichVoiceMessage2 } = await import("../../inbound-IBKXBFZF.js");
       let msg = parseSlackEvent2(event);
       if (msg.body.includes("[Voice message") && this.config?.botToken) {
         msg = await enrichVoiceMessage2(msg, this.config.botToken);
@@ -94,7 +95,7 @@ var SlackBoltAdapter = class {
   async start() {
     const boltModule = "@slack/bolt";
     const bolt = await import(boltModule);
-    const { enrichVoiceMessage: enrichVoiceMessage2 } = await import("../../inbound-ZJHAYVMF.js");
+    const { enrichVoiceMessage: enrichVoiceMessage2 } = await import("../../inbound-IBKXBFZF.js");
     const boltApp = new bolt.App({
       token: this.config.botToken,
       appToken: this.config.appToken,

package/dist/channels/webhook/index.js

@@ -1,3 +1,5 @@
+import "../../chunk-3RG5ZIWI.js";
+
 // src/channels/webhook/server.ts
 import { createServer } from "http";
 

package/dist/chat-pipeline-C-XlLGNl.d.ts

@@ -0,0 +1,648 @@
+import * as better_sqlite3 from 'better-sqlite3';
+import { I as InboundMessage } from './channel-06G0vbIn.js';
+import { C as ChatMessage } from './provider-DLGUfnNx.js';
+
+type HookHandler = (context: Record<string, unknown>) => Promise<void> | void;
+type Unsubscribe = () => void;
+interface HookOptions {
+    /** 0–100, default 50. Lower = runs first. */
+    priority?: number;
+    /** Auto-unsubscribe after first invocation. */
+    once?: boolean;
+    /** Only fire if context matches all filter key/value pairs. */
+    filter?: Record<string, unknown>;
+}
+interface HookRegistration {
+    event: string;
+    handler: HookHandler;
+    priority: number;
+    once: boolean;
+    filter?: Record<string, unknown>;
+    /** Internal auto-increment for stable sort within same priority */
+    id: number;
+}
+
+/**
+ * Priority-ordered event bus for decoupled inter-layer communication.
+ * Story 1.1 — handlers run in priority order, errors are isolated,
+ * and registrations are unsubscribable.
+ */
+declare class HookBus {
+    private readonly registrations;
+    private nextId;
+    register(event: string, handler: HookHandler, opts?: HookOptions): Unsubscribe;
+    emit(event: string, context: Record<string, unknown>): Promise<void>;
+    /** Emit synchronously (use only when async is not needed) */
+    emitSync(event: string, context: Record<string, unknown>): void;
+    hasListeners(event: string): boolean;
+    listRegistered(): string[];
+    /** Remove all handlers for an event, or all handlers if no event given */
+    clear(event?: string): void;
+}
+
+interface TableDefinition {
+    columns: Record<string, string>;
+    primaryKey?: string | string[];
+    tableConstraints?: string[];
+    relations?: Record<string, RelationDef>;
+    render?: string | ((rows: Row[]) => string);
+    outputFile?: string;
+    filter?: (rows: Row[]) => Row[];
+}
+interface RelationDef {
+    type: 'belongsTo' | 'hasMany';
+    table: string;
+    foreignKey: string;
+    references?: string;
+}
+interface EntityContextDef {
+    table: string;
+    directory: string;
+    slugColumn: string;
+    files: Record<string, EntityFileSpec>;
+    indexFile?: string;
+    /** Custom index render function. If omitted, a default listing is generated. */
+    indexRender?: (rows: Row[]) => string;
+    protectedFiles?: string[];
+    /** When true, this entity's data is never rendered into other entities' context files. */
+    protected?: boolean;
+    /** Enable at-rest encryption. Requires encryptionKey in Lattice options. */
+    encrypted?: boolean | {
+        columns: string[];
+    };
+}
+interface EntityFileSpec {
+    source: EntitySource;
+    render: string | ((rows: Row[]) => string);
+    junctionColumns?: string[];
+    omitIfEmpty?: boolean;
+}
+type EntitySource = {
+    type: 'self';
+} | {
+    type: 'hasMany';
+    table: string;
+    foreignKey: string;
+    filters?: Filter[];
+    softDelete?: boolean;
+    orderBy?: string;
+    limit?: number;
+} | {
+    type: 'manyToMany';
+    junctionTable: string;
+    localKey: string;
+    remoteKey: string;
+    remoteTable: string;
+    filters?: Filter[];
+    softDelete?: boolean;
+    orderBy?: string;
+    limit?: number;
+} | {
+    type: 'belongsTo';
+    table: string;
+    foreignKey: string;
+} | {
+    type: 'enriched';
+    include: Record<string, EntitySource>;
+} | {
+    type: 'custom';
+    resolve: (row: Row, adapter: SqliteAdapter) => Row[];
+};
+interface Filter {
+    col: string;
+    op: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'in' | 'isNull' | 'isNotNull';
+    val?: unknown;
+}
+interface QueryOptions {
+    where?: Record<string, unknown>;
+    filters?: Filter[];
+    orderBy?: string | Array<{
+        col: string;
+        dir: 'asc' | 'desc';
+    }>;
+    orderDir?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+}
+type Row = Record<string, unknown>;
+type PkLookup = string | Record<string, unknown>;
+interface SqliteAdapter {
+    run(sql: string, params?: unknown[]): better_sqlite3.RunResult;
+    get<T = Row>(sql: string, params?: unknown[]): T | undefined;
+    all<T = Row>(sql: string, params?: unknown[]): T[];
+    tableInfo(table: string): TableInfoRow[];
+    invalidateTableCache(table: string): void;
+}
+interface TableInfoRow {
+    cid: number;
+    name: string;
+    type: string;
+    notnull: number;
+    dflt_value: unknown;
+    pk: number;
+}
+interface SeedItem {
+    table: string;
+    rows: Row[];
+    naturalKey?: string | string[];
+    junctions?: Array<{
+        table: string;
+        items: Array<Row>;
+    }>;
+    softDeleteMissing?: boolean;
+}
+
+declare class DataStoreError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thin wrapper around Lattice that provides the botinabox DataStore API.
+ *
+ * Delegates all data operations to the latticesql package. Application-level
+ * events (task.created, run.completed, etc.) remain on the HookBus — they are
+ * emitted by orchestrator modules, not the data layer.
+ */
+declare class DataStore {
+    private lattice;
+    private readonly hooks;
+    private readonly outputDir;
+    private _initialized;
+    private readonly deferredStatements;
+    constructor(opts: {
+        dbPath: string;
+        outputDir?: string;
+        wal?: boolean;
+        hooks?: HookBus;
+    });
+    /**
+     * Register a table definition. Must be called before init().
+     *
+     * tableConstraints may contain both inline constraints (FOREIGN KEY, UNIQUE)
+     * and standalone SQL statements (CREATE INDEX). Standalone statements are
+     * deferred and executed after init() creates the tables.
+     */
+    define(name: string, def: TableDefinition): void;
+    /**
+     * Register an entity context definition for per-entity file rendering.
+     */
+    defineEntityContext(name: string, def: EntityContextDef): void;
+    init(opts?: {
+        migrations?: Array<{
+            version: string;
+            sql: string;
+        }>;
+    }): Promise<void>;
+    private assertInitialized;
+    insert(table: string, row: Row): Promise<Row>;
+    upsert(table: string, row: Row): Promise<Row>;
+    update(table: string, pk: PkLookup, changes: Row): Promise<Row>;
+    delete(table: string, pk: PkLookup): Promise<void>;
+    /**
+     * Get a single row by primary key.
+     * Returns undefined if not found (Lattice returns null).
+     */
+    get(table: string, pk: PkLookup): Promise<Row | undefined>;
+    query(table: string, opts?: QueryOptions): Promise<Row[]>;
+    count(table: string, opts?: QueryOptions): Promise<number>;
+    link(junctionTable: string, row: Row): Promise<void>;
+    unlink(junctionTable: string, row: Row): Promise<void>;
+    migrate(migrations: Array<{
+        version: string;
+        sql: string;
+    }>): Promise<void>;
+    seed(items: SeedItem[]): Promise<void>;
+    render(): Promise<void>;
+    reconcile(): Promise<void>;
+    tableInfo(table: string): TableInfoRow[];
+    close(): void;
+    on(event: string, handler: (context: Record<string, unknown>) => void): void;
+}
+
+/**
+ * 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.
+ */
+
+interface StoredAttachment {
+    fileType: string;
+    filename?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    contents?: string;
+    summary?: string;
+    url?: string;
+}
+interface StoreResult {
+    messageId: string;
+    attachmentIds: string[];
+}
+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>>>;
+}
+
+/**
+ * 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.
+ */
+
+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;
+    }>;
+}
+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.
+     */
+    private buildContextWindow;
+}
+
+/**
+ * TriageRouter — content-based routing with deterministic-first resolution.
+ * Story 6.3
+ *
+ * Replaces the simple channel→agent binding with intelligent routing:
+ * 1. Keyword/regex rules evaluated first (deterministic, ~4ms)
+ * 2. LLM classification only for ambiguous messages (async, ~2-4s)
+ * 3. Ownership chain logged for every routing decision
+ *
+ * Key constraint: specialists return to triage, never to another specialist.
+ */
+
+interface RoutingRule {
+    /** Target agent slug */
+    agentSlug: string;
+    /** Keywords that trigger this rule (case-insensitive) */
+    keywords?: string[];
+    /** Regex patterns that trigger this rule */
+    patterns?: string[];
+    /** Priority — lower number wins ties. Default: 50 */
+    priority?: number;
+}
+interface RoutingDecision {
+    timestamp: string;
+    source: string;
+    target: string;
+    reason: string;
+    method: 'deterministic' | 'llm';
+    messageId?: string;
+    channel?: string;
+}
+interface TriageRouterConfig {
+    /** Static routing rules evaluated deterministically */
+    rules: RoutingRule[];
+    /** Fallback agent if no rule matches and LLM is unavailable */
+    fallbackAgent?: string;
+    /** Whether to use LLM for ambiguous messages. Default: true */
+    llmFallback?: boolean;
+    /** Log decisions to the database. Default: true */
+    persist?: boolean;
+}
+declare class TriageRouter {
+    private db;
+    private hooks;
+    private readonly rules;
+    private readonly fallbackAgent?;
+    private readonly llmFallback;
+    private readonly persist;
+    private readonly compiledRules;
+    constructor(db: DataStore, hooks: HookBus, config: TriageRouterConfig);
+    /**
+     * Route an inbound message to the best agent.
+     * Returns the agent slug and the routing decision.
+     */
+    route(msg: InboundMessage): Promise<{
+        agentSlug: string | undefined;
+        decision: RoutingDecision;
+    }>;
+    /**
+     * Query the ownership chain for a given message or channel.
+     */
+    getDecisionHistory(filter?: {
+        channel?: string;
+        limit?: number;
+    }): Promise<RoutingDecision[]>;
+    /**
+     * LLM classification — emits a hook for external LLM integration.
+     * Returns agent slug + reason, or undefined if LLM is unavailable.
+     */
+    private classifyWithLLM;
+    private buildDecision;
+    private logDecision;
+}
+
+/**
+ * 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.
+ */
+
+interface ExtractedTask {
+    title: string;
+    description?: string;
+    dueDate?: string;
+    scheduled?: boolean;
+    priority?: number;
+}
+interface ExtractedMemory {
+    summary: string;
+    contents: string;
+    tags?: string[];
+    category?: string;
+}
+interface ExtractedFile {
+    filename: string;
+    fileType: string;
+    contents: string;
+    summary: string;
+}
+interface ExtractedUserContext {
+    trait: string;
+    value: string;
+}
+interface InterpretationResult {
+    messageId: string;
+    tasks: ExtractedTask[];
+    memories: ExtractedMemory[];
+    files: ExtractedFile[];
+    userContext: ExtractedUserContext[];
+    custom: Record<string, unknown[]>;
+    isTaskRequest: boolean;
+}
+type LLMCallFn = (params: {
+    model: string;
+    messages: ChatMessage[];
+    system?: string;
+    maxTokens?: number;
+}) => Promise<{
+    content: string;
+}>;
+/**
+ * Pluggable extractor interface for custom data types.
+ */
+interface Extractor {
+    readonly type: string;
+    extract(message: {
+        body: string;
+        attachments?: Array<Record<string, unknown>>;
+    }, llmCall: LLMCallFn): Promise<unknown[]>;
+}
+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;
+}
+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;
+}
+
+/**
+ * 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
+ */
+
+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;
+    /** 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>;
+    };
+}
+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 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;
+}
+
+export { type ChatResponderConfig as C, DataStore as D, type EntityContextDef as E, type Filter as F, HookBus as H, type InterpretationResult as I, type LLMCallFn as L, MessageInterpreter as M, type PkLookup as P, type QueryOptions as Q, type RelationDef as R, type SeedItem as S, type TableDefinition as T, type Unsubscribe as U, ChatPipeline as a, type ChatPipelineConfig as b, ChatResponder as c, DataStoreError as d, type EntityFileSpec as e, type EntitySource as f, type ExtractedFile as g, type ExtractedMemory as h, type ExtractedTask as i, type ExtractedUserContext as j, type Extractor as k, type HookHandler as l, type HookOptions as m, type HookRegistration as n, type MessageInterpreterConfig as o, MessageStore as p, type RoutingDecision as q, type RoutingRule as r, type Row as s, type SqliteAdapter as t, type StoreResult as u, type StoredAttachment as v, type TableInfoRow as w, TriageRouter as x, type TriageRouterConfig as y };

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-3RG5ZIWI.js";
 
 // src/cli.ts
 import * as readline from "readline";
@@ -178,7 +179,7 @@ async function authGoogle(args) {
       });
     }
   };
-  const { GoogleGmailConnector } = await import("./gmail-connector-ULSMN6X2.js");
+  const { GoogleGmailConnector } = await import("./gmail-connector-Z7SO6VOS.js");
   const connector = new GoogleGmailConnector({ tokenLoader, tokenSaver });
   connector.config = {
     account,

package/dist/connectors/google/index.js

@@ -8,6 +8,7 @@ import {
   refreshIfNeeded,
   saveTokens
 } from "../../chunk-XYF5PSB2.js";
+import "../../chunk-3RG5ZIWI.js";
 
 // src/connectors/google/calendar-connector.ts
 var GoogleCalendarConnector = class {

package/dist/gmail-connector-Z7SO6VOS.js

@@ -0,0 +1,7 @@
+import {
+  GoogleGmailConnector
+} from "./chunk-XYF5PSB2.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  GoogleGmailConnector
+};

package/dist/inbound-IBKXBFZF.js

@@ -0,0 +1,11 @@
+import {
+  enrichVoiceMessage,
+  extractVoiceTranscript,
+  parseSlackEvent
+} from "./chunk-NNPCKR6G.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  enrichVoiceMessage,
+  extractVoiceTranscript,
+  parseSlackEvent
+};

package/dist/inbound-WU7X2HGA.js

@@ -0,0 +1,7 @@
+import {
+  parseDiscordEvent
+} from "./chunk-DLJKZD3Q.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  parseDiscordEvent
+};

package/dist/index.d.ts

@@ -4,8 +4,8 @@ import { T as TokenUsage, L as LLMProvider, M as ModelInfo, R as ResolvedModel,
 export { a as ChatParams, b as ChatResult, c as ContentBlock, d as ToolUse } from './provider-DLGUfnNx.js';
 import { C as ConnectorConfig } from './connector-B4Mj0P1b.js';
 export { A as AuthResult, a as Connector, b as ConnectorMeta, P as PushResult, S as SyncOptions, c as SyncResult } from './connector-B4Mj0P1b.js';
-import { C as ChatResponderConfig, D as DataStore, H as HookBus } from './chat-pipeline-DisuC8SB.js';
-export { a as ChatPipeline, b as ChatPipelineConfig, c as ChatResponder, d as DataStoreError, E as EntityContextDef, e as EntityFileSpec, f as EntitySource, g as ExtractedFile, h as ExtractedMemory, i as ExtractedTask, j as ExtractedUserContext, k as Extractor, F as Filter, l as HookHandler, m as HookOptions, n as HookRegistration, I as InterpretationResult, L as LLMCallFn, M as MessageInterpreter, o as MessageInterpreterConfig, p as MessageStore, P as PkLookup, Q as QueryOptions, R as RelationDef, q as RoutingDecision, r as RoutingRule, s as Row, S as SeedItem, t as SqliteAdapter, u as StoreResult, v as StoredAttachment, T as TableDefinition, w as TableInfoRow, x as TriageRouter, y as TriageRouterConfig, U as Unsubscribe } from './chat-pipeline-DisuC8SB.js';
+import { C as ChatResponderConfig, D as DataStore, H as HookBus } from './chat-pipeline-C-XlLGNl.js';
+export { a as ChatPipeline, b as ChatPipelineConfig, c as ChatResponder, d as DataStoreError, E as EntityContextDef, e as EntityFileSpec, f as EntitySource, g as ExtractedFile, h as ExtractedMemory, i as ExtractedTask, j as ExtractedUserContext, k as Extractor, F as Filter, l as HookHandler, m as HookOptions, n as HookRegistration, I as InterpretationResult, L as LLMCallFn, M as MessageInterpreter, o as MessageInterpreterConfig, p as MessageStore, P as PkLookup, Q as QueryOptions, R as RelationDef, q as RoutingDecision, r as RoutingRule, s as Row, S as SeedItem, t as SqliteAdapter, u as StoreResult, v as StoredAttachment, T as TableDefinition, w as TableInfoRow, x as TriageRouter, y as TriageRouterConfig, U as Unsubscribe } from './chat-pipeline-C-XlLGNl.js';
 import 'better-sqlite3';
 
 /** Execution adapter types — Story 1.5 / 3.4 / 3.5 */
@@ -1835,6 +1835,8 @@ type ToolHandler = (input: Record<string, unknown>, context: {
     taskId: string;
     agentId: string;
     hooks: HookBus;
+    /** Resolve a relative file path to an absolute path (environment-aware). */
+    resolveFilePath?: (path: string) => string;
 }) => Promise<string>;
 interface ExecutionEngineConfig {
     /** Anthropic client instance */
@@ -1869,6 +1871,8 @@ interface ExecutionEngineConfig {
     systemPromptSuffix?: string;
     /** Include system context (users, files, etc). Default: true */
     includeSystemContext?: boolean;
+    /** Resolve file paths from DB-relative to absolute (for cross-environment support). */
+    resolveFilePath?: (path: string) => string;
 }
 declare function registerExecutionEngine(opts: {
     db: DataStore;
@@ -1877,6 +1881,16 @@ declare function registerExecutionEngine(opts: {
     config: ExecutionEngineConfig;
 }): Promise<void>;
 
+declare const sendFileTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+
+declare const readFileTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+
 interface SecretInput {
     name: string;
     type?: string;
@@ -1965,4 +1979,4 @@ declare function isLoginRequired(stdout: string): boolean;
 /** Rewrite local image paths to prevent CLI auto-embedding as vision content. */
 declare function deactivateLocalImagePaths(prompt: string): string;
 
-export { AGENT_STATUSES, type AgentConfig, type AgentDefinition, type AgentFilter, type AgentRecord, AgentRegistry, type AgentStatus, ApiExecutionAdapter, type ApprovalResponse, type ApprovalStatus, AuditEmitter, type AuditEvent, BackupManager, type BotConfig, BreakerState, type BudgetCheck, type BudgetConfig, BudgetController, CORE_MIGRATIONS, ChannelAdapter, ChannelRegistry, ChannelRegistryError, ChatMessage, ChatResponderConfig, ChatSessionManager, CircuitBreaker, type CircuitBreakerConfig, CliExecutionAdapter, type ColumnValidator, ColumnValidatorImpl, type ConfigLoadError, type ConfigLoadResult, ConnectorConfig, DEFAULTS, DEFAULT_CONFIG, type DataConfig, DataStore, type DefaultLLMCallConfig, DeterministicAdapter, type DeterministicConfig, type DomainEntityContextOptions, type DomainSchemaOptions, DriftGate, EVENTS, type EntityColumnDef, type EntityConfig, type ExecutionAdapter, type ExecutionEngineConfig, type FeedbackEntry, type GateFinding, type GateInput, type GateResult, GateRunner, type GateVerdict, GovernanceGate, HealthStatus, HookBus, InboundMessage, LLMProvider, LearningPipeline, type LearningPipelineConfig, type LoopDetection, LoopDetector, type LoopDetectorConfig, LoopType, MAX_CHAIN_DEPTH, MessagePipeline, type ModelConfig, ModelInfo, ModelRouter, NdjsonLogger, NotificationQueue, type PackageMigration, type PackageUpdate, type ParsedStream, type PermissionPrompt, type PermissionProvider, PermissionRelay, type PermissionRelayConfig, type PlaybookEntry, ProviderRegistry, QAGate, QualityGate, RUN_STATUSES, type RenderConfig, ResolvedModel, type RetryPolicy, type RunContext, RunManager, type RunResult, type RunStatus, type SanitizerOptions, type Schedule, type ScheduleDef, Scheduler, type SchemaError, type SecretInput, type SecretMeta, SecretStore, type SecurityConfig, SessionKey, SessionManager, type SkillEntry, type StepRef, type SystemContextOptions, TASK_STATUSES, type TaskDefinition, TaskQueue, type TaskRecord, type TaskStatus, TokenUsage, type ToolDefinition, type ToolHandler, UpdateChecker, type UpdateConfig, UpdateManager, type UpdateManifest, type UsageSummary, type User, type UserInput, UserRegistry, WakeupQueue, type WorkflowConfigEntry, type WorkflowDefinition$1 as WorkflowDefinition, WorkflowEngine, type WorkflowRunRecord, type WorkflowRunStatus, type WorkflowStep$1 as WorkflowStep, type WorkflowStepConfig, type WorkflowTrigger, _resetConfig, areDependenciesMet, autoUpdate, buildAgentBindings, buildChainOrigin, buildProcessEnv, buildSystemContext, checkAllowlist, checkChainDepth, checkMentionGate, chunkText, classifyUpdate, compareVersions, createConfigRevision, createDefaultLLMCall, deactivateLocalImagePaths, defineCoreEntityContexts, defineCoreTables, defineDomainEntityContexts, defineDomainTables, detectCycle, discoverChannels, discoverProviders, formatText, getConfig, initConfig, interpolate, interpolateEnv, isLoginRequired, isMaxTurns, loadConfig, parseClaudeStream, parseVersion, registerExecutionEngine, runPackageMigrations, sanitize, topologicalSort, truncateAtWord, validateConfig };
+export { AGENT_STATUSES, type AgentConfig, type AgentDefinition, type AgentFilter, type AgentRecord, AgentRegistry, type AgentStatus, ApiExecutionAdapter, type ApprovalResponse, type ApprovalStatus, AuditEmitter, type AuditEvent, BackupManager, type BotConfig, BreakerState, type BudgetCheck, type BudgetConfig, BudgetController, CORE_MIGRATIONS, ChannelAdapter, ChannelRegistry, ChannelRegistryError, ChatMessage, ChatResponderConfig, ChatSessionManager, CircuitBreaker, type CircuitBreakerConfig, CliExecutionAdapter, type ColumnValidator, ColumnValidatorImpl, type ConfigLoadError, type ConfigLoadResult, ConnectorConfig, DEFAULTS, DEFAULT_CONFIG, type DataConfig, DataStore, type DefaultLLMCallConfig, DeterministicAdapter, type DeterministicConfig, type DomainEntityContextOptions, type DomainSchemaOptions, DriftGate, EVENTS, type EntityColumnDef, type EntityConfig, type ExecutionAdapter, type ExecutionEngineConfig, type FeedbackEntry, type GateFinding, type GateInput, type GateResult, GateRunner, type GateVerdict, GovernanceGate, HealthStatus, HookBus, InboundMessage, LLMProvider, LearningPipeline, type LearningPipelineConfig, type LoopDetection, LoopDetector, type LoopDetectorConfig, LoopType, MAX_CHAIN_DEPTH, MessagePipeline, type ModelConfig, ModelInfo, ModelRouter, NdjsonLogger, NotificationQueue, type PackageMigration, type PackageUpdate, type ParsedStream, type PermissionPrompt, type PermissionProvider, PermissionRelay, type PermissionRelayConfig, type PlaybookEntry, ProviderRegistry, QAGate, QualityGate, RUN_STATUSES, type RenderConfig, ResolvedModel, type RetryPolicy, type RunContext, RunManager, type RunResult, type RunStatus, type SanitizerOptions, type Schedule, type ScheduleDef, Scheduler, type SchemaError, type SecretInput, type SecretMeta, SecretStore, type SecurityConfig, SessionKey, SessionManager, type SkillEntry, type StepRef, type SystemContextOptions, TASK_STATUSES, type TaskDefinition, TaskQueue, type TaskRecord, type TaskStatus, TokenUsage, type ToolDefinition, type ToolHandler, UpdateChecker, type UpdateConfig, UpdateManager, type UpdateManifest, type UsageSummary, type User, type UserInput, UserRegistry, WakeupQueue, type WorkflowConfigEntry, type WorkflowDefinition$1 as WorkflowDefinition, WorkflowEngine, type WorkflowRunRecord, type WorkflowRunStatus, type WorkflowStep$1 as WorkflowStep, type WorkflowStepConfig, type WorkflowTrigger, _resetConfig, areDependenciesMet, autoUpdate, buildAgentBindings, buildChainOrigin, buildProcessEnv, buildSystemContext, checkAllowlist, checkChainDepth, checkMentionGate, chunkText, classifyUpdate, compareVersions, createConfigRevision, createDefaultLLMCall, deactivateLocalImagePaths, defineCoreEntityContexts, defineCoreTables, defineDomainEntityContexts, defineDomainTables, detectCycle, discoverChannels, discoverProviders, formatText, getConfig, initConfig, interpolate, interpolateEnv, isLoginRequired, isMaxTurns, loadConfig, parseClaudeStream, parseVersion, readFileTool, registerExecutionEngine, runPackageMigrations, sanitize, sendFileTool, topologicalSort, truncateAtWord, validateConfig };

package/dist/index.js

@@ -1,6 +1,9 @@
 import {
   chunkText
 } from "./chunk-ZTZFPTOQ.js";
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
 
 // src/shared/constants.ts
 var EVENTS = {
@@ -1287,6 +1290,17 @@ var MessageStore = class {
     });
     return messages;
   }
+  /**
+   * Get recent messages in a channel (all threads combined).
+   * More reliable than getThreadHistory for DMs where thread_ids are inconsistent.
+   */
+  async getChannelHistory(channel, limit = 50) {
+    return this.db.query("messages", {
+      where: { channel },
+      orderBy: "created_at",
+      limit
+    });
+  }
   /**
    * Get recent messages from a specific user across all threads.
    */
@@ -1345,10 +1359,9 @@ var ChatResponder = class {
    * Uses rolling context window from thread history.
    */
   async respond(opts) {
-    const history = await this.messageStore.getThreadHistory(
-      opts.threadId,
+    const history = await this.messageStore.getChannelHistory(
+      opts.channel,
       50
-      // get more, trim by tokens
     );
     const messages = this.buildContextWindow(history, opts.messageBody);
     let system = this.systemPrompt;
@@ -6113,7 +6126,7 @@ ${systemContext}` : "",
             try {
               const result = await handler(
                 toolUse.input,
-                { taskId, agentId: assigneeId, hooks }
+                { taskId, agentId: assigneeId, hooks, resolveFilePath: config.resolveFilePath }
               );
               toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: result });
             } catch (err) {
@@ -6142,6 +6155,102 @@ ${systemContext}` : "",
   });
 }
 
+// src/core/orchestrator/tools/send-file.ts
+import { existsSync as existsSync3 } from "fs";
+import { basename } from "path";
+var sendFileTool = {
+  definition: {
+    name: "send_file",
+    description: "Send/deliver/attach a file to the user on Slack. Use this when the user asks for a document, contract, report, or any file. The file_path is in the Files section of your system context.",
+    input_schema: {
+      type: "object",
+      properties: {
+        file_path: { type: "string", description: "Path to the file (from system context)" }
+      },
+      required: ["file_path"]
+    }
+  },
+  handler: async (input, context) => {
+    const rawPath = input.file_path;
+    const filePath = context.resolveFilePath?.(rawPath) ?? rawPath;
+    if (!existsSync3(filePath)) return `Error: file not found at ${filePath}`;
+    await context.hooks.emit("file.deliver", {
+      filePath,
+      fileName: basename(filePath),
+      taskId: context.taskId
+    });
+    return `File "${basename(filePath)}" sent to user.`;
+  }
+};
+
+// src/core/orchestrator/tools/read-file.ts
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+var readFileTool = {
+  definition: {
+    name: "read_file",
+    description: "Read/review the contents of a file. Use this when the user asks about what a document contains, wants you to review a contract, check terms, summarize a report, etc. Supports .docx (Word), .txt, .md, .json, .csv. The file_path is in the Files section of your system context.",
+    input_schema: {
+      type: "object",
+      properties: {
+        file_path: { type: "string", description: "Path to the file (from system context)" }
+      },
+      required: ["file_path"]
+    }
+  },
+  handler: async (input, context) => {
+    const rawPath = input.file_path;
+    const filePath = context.resolveFilePath?.(rawPath) ?? rawPath;
+    if (!existsSync4(filePath)) return `Error: file not found at ${filePath}`;
+    try {
+      if (filePath.endsWith(".docx")) {
+        return extractDocxText(filePath);
+      }
+      return readFileSync6(filePath, "utf8").slice(0, 8e3);
+    } catch (err) {
+      return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+};
+function extractDocxText(filePath) {
+  const data = readFileSync6(filePath);
+  try {
+    const zip = parseZipEntries(data);
+    const docEntry = zip.find((e) => e.name === "word/document.xml");
+    if (!docEntry) return "Error: could not find document.xml in docx";
+    const xml = docEntry.data.toString("utf8");
+    return xml.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().slice(0, 8e3);
+  } catch {
+    return "Error: could not parse docx file";
+  }
+}
+function parseZipEntries(buf) {
+  const entries = [];
+  let offset = 0;
+  while (offset < buf.length - 4) {
+    if (buf[offset] !== 80 || buf[offset + 1] !== 75 || buf[offset + 2] !== 3 || buf[offset + 3] !== 4) {
+      break;
+    }
+    const compressionMethod = buf.readUInt16LE(offset + 8);
+    const compressedSize = buf.readUInt32LE(offset + 18);
+    const nameLen = buf.readUInt16LE(offset + 26);
+    const extraLen = buf.readUInt16LE(offset + 28);
+    const name = buf.slice(offset + 30, offset + 30 + nameLen).toString("utf8");
+    const dataStart = offset + 30 + nameLen + extraLen;
+    if (compressionMethod === 0) {
+      entries.push({ name, data: buf.slice(dataStart, dataStart + compressedSize) });
+    } else if (compressionMethod === 8) {
+      try {
+        const { inflateRawSync } = __require("zlib");
+        const inflated = inflateRawSync(buf.slice(dataStart, dataStart + compressedSize));
+        entries.push({ name, data: inflated });
+      } catch {
+      }
+    }
+    offset = dataStart + compressedSize;
+  }
+  return entries;
+}
+
 // src/core/orchestrator/user-registry.ts
 import { v4 as uuidv4 } from "uuid";
 var UserRegistry = class {
@@ -6555,9 +6664,11 @@ export {
   loadConfig,
   parseClaudeStream,
   parseVersion,
+  readFileTool,
   registerExecutionEngine,
   runPackageMigrations,
   sanitize,
+  sendFileTool,
   topologicalSort,
   truncateAtWord,
   validateConfig

package/dist/providers/anthropic/index.js

@@ -1,3 +1,5 @@
+import "../../chunk-3RG5ZIWI.js";
+
 // src/providers/anthropic/provider.ts
 import Anthropic from "@anthropic-ai/sdk";
 

package/dist/providers/ollama/index.js

@@ -1,3 +1,5 @@
+import "../../chunk-3RG5ZIWI.js";
+
 // src/providers/ollama/provider.ts
 var OllamaProvider = class {
   id = "ollama";

package/dist/providers/openai/index.js

@@ -1,3 +1,5 @@
+import "../../chunk-3RG5ZIWI.js";
+
 // src/providers/openai/provider.ts
 import OpenAI from "openai";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botinabox",
-  "version": "1.9.2",
+  "version": "1.10.0",
   "description": "Bot in a Box — framework for building multi-agent bots",
   "type": "module",
   "main": "./dist/index.js",