botinabox 2.4.2 → 2.5.0

package/dist/core/chat/chat-pipeline.js

@@ -1,395 +0,0 @@
-/**
- * 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 { createHash, randomUUID } from 'node:crypto';
-import { MessageStore } from './message-store.js';
-import { ChatResponder } from './chat-responder.js';
-import { MessageInterpreter } from './message-interpreter.js';
-import { TriageRouter } from './triage-router.js';
-const DEFAULT_DEDUP_WINDOW_MS = 5 * 60 * 1000;
-export class ChatPipeline {
-    db;
-    hooks;
-    messageStore;
-    responder;
-    interpreter;
-    router;
-    channel;
-    messageFilter;
-    capabilities;
-    dedupWindowMs;
-    tasks;
-    wakeups;
-    // In-memory thread → channel mapping for response routing
-    // (before thread_task_map exists)
-    threadChannelMap = new Map();
-    /** Last dispatch promise — exposed for testing. */
-    lastDispatch = Promise.resolve();
-    constructor(db, hooks, config) {
-        this.db = db;
-        this.hooks = hooks;
-        this.channel = config.channel ?? 'slack';
-        this.messageFilter = config.messageFilter;
-        this.capabilities = config.capabilities;
-        this.dedupWindowMs = config.dedupWindowMs ?? DEFAULT_DEDUP_WINDOW_MS;
-        this.tasks = config.tasks;
-        this.wakeups = config.wakeups;
-        this.messageStore = new MessageStore(db, hooks);
-        this.responder = new ChatResponder(db, hooks, this.messageStore, {
-            llmCall: config.llmCall,
-            model: config.model ?? 'fast',
-            systemPrompt: config.systemPrompt,
-        });
-        this.interpreter = new MessageInterpreter(db, hooks, {
-            llmCall: config.llmCall,
-            model: config.model ?? 'fast',
-            extractors: config.extractors,
-        });
-        this.router = new TriageRouter(db, hooks, {
-            rules: config.routingRules,
-            fallbackAgent: config.fallbackAgent,
-            llmFallback: config.llmRouting ?? false,
-            persist: true,
-        });
-        this.registerHandlers();
-    }
-    /**
-     * Resolve the Slack channel ID for a thread (for response delivery).
-     */
-    resolveChannel(threadId, taskId) {
-        return this.resolveChannelId(threadId, taskId);
-    }
-    /**
-     * Register the 6-layer pipeline on the HookBus.
-     */
-    registerHandlers() {
-        // Layer 1-5: Inbound message handler
-        this.hooks.register('message.inbound', async (ctx) => {
-            const msg = ctx;
-            if (msg.channel !== this.channel)
-                return;
-            // Optional message filter
-            if (this.messageFilter && !this.messageFilter(msg))
-                return;
-            // Dedup check
-            if (await this.isDuplicate(msg))
-                return;
-            // Resolve thread ID:
-            // - If in a Slack thread: use threadId (the parent message ts)
-            // - If in a DM (no thread): use the channel ID as a stable "thread"
-            //   so all messages in the same DM share context
-            const rawTs = msg.raw?.ts;
-            const channelId = msg.account ?? '';
-            const threadTs = msg.threadId ?? channelId ?? rawTs ?? msg.id;
-            // Track thread → channel for response routing
-            if (threadTs && channelId) {
-                this.threadChannelMap.set(threadTs, channelId);
-            }
-            // ── Layer 1: Storage ───────────────────────────────────────
-            // Set threadId on message so all messages in the same DM share a thread
-            const msgWithThread = { ...msg, threadId: threadTs };
-            const { messageId } = await this.messageStore.storeInbound(msgWithThread);
-            // ── Layer 2: Fast Response ─────────────────────────────────
-            // Include recent user message history for channel-wide context
-            const userHistory = await this.messageStore.getUserHistory(msg.from, this.channel, 50);
-            const historyContext = userHistory
-                .map(m => {
-                const dir = m.direction === 'inbound' ? 'User' : 'Bot';
-                return `${dir}: ${m.body?.slice(0, 200) ?? ''}`;
-            })
-                .join('\n');
-            const ackResponse = await this.responder.respond({
-                messageBody: msg.body,
-                threadId: threadTs,
-                channel: this.channel,
-                capabilities: this.capabilities,
-                additionalContext: historyContext ? `\n\nRecent conversation history:\n${historyContext}` : undefined,
-            });
-            await this.responder.sendResponse({
-                text: ackResponse,
-                channel: this.channel,
-                threadId: threadTs,
-                source: 'responder',
-                skipFilter: true,
-                skipRedundancyCheck: true,
-            });
-            // ── Layer 3-5: Interpretation + guaranteed task dispatch ────
-            // ALWAYS create a task programmatically. Interpretation enriches
-            // it with classification, but task creation is not LLM-dependent.
-            const dispatchPromise = this.interpretAndDispatch(messageId, msg, threadTs, channelId);
-            this.lastDispatch = dispatchPromise;
-            void dispatchPromise;
-        });
-        // Layer 6: Task execution response + file attachments
-        this.hooks.register('run.completed', async (ctx) => {
-            const taskId = ctx.taskId;
-            if (!taskId)
-                return;
-            const task = await this.db.get('tasks', { id: taskId });
-            const output = task?.result;
-            if (!output)
-                return;
-            const mappings = await this.db.query('thread_task_map', {
-                where: { task_id: taskId },
-            });
-            if (mappings.length === 0)
-                return;
-            const mapping = mappings[0];
-            const threadId = mapping.thread_ts;
-            // Send text response
-            await this.responder.sendResponse({
-                text: output,
-                channel: this.channel,
-                threadId,
-                agentId: ctx.agentId,
-                taskId,
-                source: 'agent',
-                skipRedundancyCheck: true,
-            });
-            // Check if the original message requested a file — look up in DB and emit attachment
-            const taskDesc = task.description ?? '';
-            try {
-                const files = await this.db.query('file');
-                for (const file of files) {
-                    const fileName = (file.name ?? '').toLowerCase();
-                    const descLower = taskDesc.toLowerCase();
-                    if (fileName && descLower.includes(fileName.split(' ')[0].toLowerCase()) &&
-                        descLower.includes(fileName.split(' ').pop().toLowerCase())) {
-                        // Fuzzy match — file name words appear in task description
-                        const filePath = file.file_path;
-                        if (filePath) {
-                            await this.hooks.emit('file.deliver', {
-                                filePath,
-                                fileName: file.name,
-                                channel: this.channel,
-                                threadId,
-                                taskId,
-                            });
-                        }
-                    }
-                }
-            }
-            catch {
-                // File lookup is best-effort
-            }
-        }, { priority: 90 });
-    }
-    /**
-     * Check and record message dedup (SHA256 hash, configurable window).
-     */
-    async isDuplicate(msg) {
-        const hash = createHash('sha256')
-            .update(`${msg.from}:${msg.body}`)
-            .digest('hex');
-        const cutoff = new Date(Date.now() - this.dedupWindowMs).toISOString();
-        const recent = await this.db.query('message_dedup', {
-            where: { content_hash: hash },
-        });
-        if (recent.some(r => r.created_at > cutoff)) {
-            return true;
-        }
-        await this.db.insert('message_dedup', {
-            content_hash: hash,
-            channel_id: msg.account ?? '',
-        });
-        return false;
-    }
-    /**
-     * 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.
-     */
-    async interpretAndDispatch(messageId, msg, threadTs, channelId) {
-        // Layer 5: ALWAYS create a task — this is programmatic, not LLM-dependent
-        await this.guaranteedTaskDispatch(msg, threadTs, channelId);
-        // Layer 3-4: Interpretation is best-effort enrichment (memories, user context)
-        try {
-            const result = await this.interpreter.interpret(messageId);
-            // Store any extracted memories (enrichment only — task already created above)
-            if (result.memories.length > 0 || result.userContext.length > 0) {
-                try {
-                    const parts = [];
-                    if (result.memories.length > 0) {
-                        parts.push(`Noted ${result.memories.length} thing${result.memories.length > 1 ? 's' : ''} to remember.`);
-                    }
-                    if (parts.length > 0) {
-                        await this.responder.sendResponse({
-                            text: parts.join(' '),
-                            channel: this.channel,
-                            threadId: threadTs,
-                            source: 'interpretation',
-                        });
-                    }
-                }
-                catch {
-                    // Non-fatal
-                }
-            }
-        }
-        catch (err) {
-            // Interpretation failure is non-fatal — task was already created above
-            const errMsg = err instanceof Error ? err.message : String(err);
-            await this.hooks.emit('interpretation.error', {
-                messageId,
-                error: errMsg,
-            });
-        }
-    }
-    /**
-     * Programmatic task creation — guaranteed, no LLM dependency.
-     */
-    async guaranteedTaskDispatch(msg, threadTs, channelId) {
-        // Route to best agent
-        const { agentSlug: targetSlug } = await this.router.route(msg);
-        if (!targetSlug)
-            return;
-        const agents = await this.db.query('agents', { where: { slug: targetSlug } });
-        const targetAgent = agents[0];
-        if (!targetAgent)
-            return;
-        const handlerAgentId = targetAgent.id;
-        // Follow-up in existing thread
-        if (threadTs) {
-            const existing = await this.db.query('thread_task_map', {
-                where: { thread_ts: threadTs, channel_id: channelId },
-            });
-            if (existing.length > 0) {
-                const taskId = existing[0].task_id;
-                const task = await this.tasks.get(taskId);
-                if (task && task.status !== 'done' && task.status !== 'cancelled') {
-                    const updatedDesc = `${task.description ?? ''}\n\n---\n**Follow-up (${new Date().toISOString()}):**\n${msg.body}`;
-                    await this.tasks.update(taskId, { description: updatedDesc });
-                    await this.wakeups.enqueue(handlerAgentId, 'chat_followup', { taskId });
-                    return;
-                }
-            }
-        }
-        // New task — programmatic, guaranteed
-        const description = `## Chat Message\n\n**Channel:** ${channelId}\n**Thread:** ${threadTs}\n**From:** ${msg.from}\n**Time:** ${msg.receivedAt}\n\n---\n\n${msg.body}`;
-        const taskId = randomUUID();
-        if (threadTs) {
-            // Upsert: update existing mapping if thread already mapped (task was done),
-            // otherwise insert new mapping
-            const existingMap = await this.db.query('thread_task_map', {
-                where: { thread_ts: threadTs, channel_id: channelId },
-            });
-            if (existingMap.length > 0) {
-                await this.db.update('thread_task_map', { id: existingMap[0].id }, {
-                    task_id: taskId,
-                });
-            }
-            else {
-                await this.db.insert('thread_task_map', {
-                    thread_ts: threadTs,
-                    channel_id: channelId,
-                    task_id: taskId,
-                });
-            }
-        }
-        await this.tasks.create({
-            id: taskId,
-            title: msg.body.slice(0, 120),
-            description,
-            assignee_id: handlerAgentId,
-            priority: 5,
-        });
-        await this.wakeups.enqueue(handlerAgentId, 'chat_dispatch', { taskId });
-    }
-    /**
-     * Route and dispatch extracted tasks.
-     */
-    async dispatchTasks(result, msg, threadTs, channelId) {
-        for (const extractedTask of result.tasks) {
-            const { agentSlug: targetSlug } = await this.router.route(msg);
-            if (!targetSlug)
-                continue;
-            const agents = await this.db.query('agents', { where: { slug: targetSlug } });
-            const targetAgent = agents[0];
-            if (!targetAgent)
-                continue;
-            const handlerAgentId = targetAgent.id;
-            // Follow-up in existing thread
-            if (threadTs) {
-                const existing = await this.db.query('thread_task_map', {
-                    where: { thread_ts: threadTs, channel_id: channelId },
-                });
-                if (existing.length > 0) {
-                    const taskId = existing[0].task_id;
-                    const task = await this.tasks.get(taskId);
-                    if (task && task.status !== 'done' && task.status !== 'cancelled') {
-                        const updatedDesc = `${task.description ?? ''}\n\n---\n**Follow-up (${new Date().toISOString()}):**\n${msg.body}`;
-                        await this.tasks.update(taskId, { description: updatedDesc });
-                        await this.wakeups.enqueue(handlerAgentId, 'chat_followup', { taskId });
-                        return;
-                    }
-                }
-            }
-            // New task
-            const description = `## Chat Message\n\n**Channel:** ${channelId}\n**Thread:** ${threadTs}\n**From:** ${msg.from}\n**Time:** ${msg.receivedAt}\n\n---\n\n${extractedTask.description ?? msg.body}`;
-            const taskId = randomUUID();
-            if (threadTs) {
-                await this.db.insert('thread_task_map', {
-                    thread_ts: threadTs,
-                    channel_id: channelId,
-                    task_id: taskId,
-                });
-            }
-            await this.tasks.create({
-                id: taskId,
-                title: extractedTask.title.slice(0, 120),
-                description,
-                assignee_id: handlerAgentId,
-                priority: extractedTask.priority ?? 5,
-            });
-            await this.wakeups.enqueue(handlerAgentId, 'chat_dispatch', { taskId });
-        }
-    }
-    /**
-     * Resolve Slack channel ID from thread_task_map or in-memory fallback.
-     */
-    async resolveChannelId(threadId, taskId) {
-        if (taskId) {
-            const mappings = await this.db.query('thread_task_map', {
-                where: { task_id: taskId },
-            });
-            if (mappings.length > 0)
-                return mappings[0].channel_id;
-        }
-        if (threadId) {
-            const mappings = await this.db.query('thread_task_map', {
-                where: { thread_ts: threadId },
-            });
-            if (mappings.length > 0)
-                return mappings[0].channel_id;
-        }
-        return this.threadChannelMap.get(threadId);
-    }
-    /**
-     * Build human-readable interpretation summary.
-     */
-    buildSummary(result) {
-        const parts = [];
-        if (result.tasks.length > 0) {
-            const names = result.tasks.map((t) => t.title).join(', ');
-            parts.push(`I've identified ${result.tasks.length} task${result.tasks.length > 1 ? 's' : ''}: ${names}. Working on ${result.tasks.length > 1 ? 'them' : 'it'} now.`);
-        }
-        if (result.memories.length > 0) {
-            parts.push(`Noted ${result.memories.length} thing${result.memories.length > 1 ? 's' : ''} to remember.`);
-        }
-        return parts.join(' ');
-    }
-}

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

@@ -1,90 +0,0 @@
-/**
- * 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.
-     */
-    private buildContextWindow;
-}

package/dist/core/chat/chat-responder.js

@@ -1,185 +0,0 @@
-/**
- * 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.
- */
-const DEFAULT_SYSTEM_PROMPT = `You are a helpful, enthusiastic AI digital assistant. Your job is to:
-- Acknowledge the user's message and relay what you understand
-- Let them know what will happen next (if a task is being worked on)
-- Answer conversational questions directly
-- Be honest when you need to look something up — say "let me find out"
-- Keep responses concise and friendly
-
-You are aware of tools and capabilities in the system but you do NOT execute anything.
-You cannot run code, search databases, or take actions. You are purely conversational.
-If the user asks you to DO something, acknowledge it and say it will be handled.`;
-const DEFAULT_CONTEXT_TOKENS = 4000;
-const DEFAULT_REDUNDANCY_WINDOW = 10;
-const APPROX_CHARS_PER_TOKEN = 4;
-export class ChatResponder {
-    db;
-    hooks;
-    messageStore;
-    systemPrompt;
-    contextWindowTokens;
-    redundancyWindow;
-    model;
-    llmCall;
-    constructor(db, hooks, messageStore, config) {
-        this.db = db;
-        this.hooks = hooks;
-        this.messageStore = messageStore;
-        this.systemPrompt = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-        this.contextWindowTokens = config.contextWindowTokens ?? DEFAULT_CONTEXT_TOKENS;
-        this.redundancyWindow = config.redundancyWindow ?? DEFAULT_REDUNDANCY_WINDOW;
-        this.model = config.model ?? 'fast';
-        this.llmCall = config.llmCall;
-    }
-    /**
-     * Generate a fast conversational response to an inbound message.
-     * Uses rolling context window from thread history.
-     */
-    async respond(opts) {
-        // Build context window from thread history
-        const history = await this.messageStore.getThreadHistory(opts.threadId, 50);
-        const messages = this.buildContextWindow(history, opts.messageBody);
-        // Build system prompt with optional capabilities awareness
-        let system = this.systemPrompt;
-        if (opts.capabilities) {
-            system += `\n\nSystem capabilities you are aware of:\n${opts.capabilities}`;
-        }
-        if (opts.userName) {
-            system += `\n\nYou are talking to: ${opts.userName}`;
-        }
-        if (opts.additionalContext) {
-            system += opts.additionalContext;
-        }
-        const result = await this.llmCall({
-            model: this.model,
-            messages,
-            system,
-            maxTokens: 500,
-        });
-        return result.content;
-    }
-    /**
-     * Filter any outbound message through the LLM for human readability.
-     * This is the single funnel ALL responses pass through.
-     */
-    async filterResponse(text, context) {
-        // Short messages don't need filtering
-        if (text.length < 100)
-            return text;
-        const result = await this.llmCall({
-            model: this.model,
-            messages: [
-                {
-                    role: 'user',
-                    content: `Rewrite this agent/system message to be human-friendly and conversational. Keep the substance, remove jargon, make it feel like a helpful assistant talking to a person. If it's already readable, return it as-is. Do not add preamble like "Here's the rewritten version". Just output the rewritten text.\n\n---\n${text}`,
-                },
-            ],
-            maxTokens: 1000,
-        });
-        return result.content;
-    }
-    /**
-     * Check if a candidate outbound message is redundant with recent messages.
-     * Returns true if the message should be suppressed.
-     */
-    async isRedundant(text, threadId) {
-        const recent = await this.messageStore.getRecentOutbound(threadId, this.redundancyWindow);
-        if (recent.length === 0)
-            return false;
-        const recentTexts = recent
-            .map(m => m['body'] ?? '')
-            .filter(t => t.length > 0)
-            .slice(-5) // last 5 outbound messages
-            .join('\n---\n');
-        const result = await this.llmCall({
-            model: this.model,
-            messages: [
-                {
-                    role: 'user',
-                    content: `Does this NEW message duplicate or substantially overlap the RECENT messages already sent? Answer with just "redundant" or "not redundant". If the new message has meaningful new information or updates, it is NOT redundant.\n\nRECENT MESSAGES:\n${recentTexts}\n\nNEW MESSAGE:\n${text}`,
-                },
-            ],
-            maxTokens: 10,
-        });
-        return result.content.toLowerCase().includes('redundant') &&
-            !result.content.toLowerCase().includes('not redundant');
-    }
-    /**
-     * Full send pipeline: check redundancy → filter → store → deliver.
-     * Returns the message ID, or undefined if suppressed as redundant.
-     */
-    async sendResponse(opts) {
-        // 1. Redundancy check
-        if (!opts.skipRedundancyCheck) {
-            const redundant = await this.isRedundant(opts.text, opts.threadId);
-            if (redundant) {
-                await this.hooks.emit('response.suppressed', {
-                    channel: opts.channel,
-                    threadId: opts.threadId,
-                    reason: 'redundant',
-                });
-                return undefined;
-            }
-        }
-        // 2. Filter for readability
-        const filtered = opts.skipFilter
-            ? opts.text
-            : await this.filterResponse(opts.text, {
-                channel: opts.channel,
-                threadId: opts.threadId,
-                source: opts.source,
-            });
-        // 3. Store outbound message
-        const messageId = await this.messageStore.storeOutbound({
-            channel: opts.channel,
-            text: filtered,
-            threadId: opts.threadId,
-            agentId: opts.agentId,
-            agentSlug: opts.agentSlug,
-            taskId: opts.taskId,
-        });
-        // 4. Emit for delivery (NotificationQueue listens)
-        await this.hooks.emit('response.ready', {
-            messageId,
-            channel: opts.channel,
-            threadId: opts.threadId,
-            text: filtered,
-            taskId: opts.taskId,
-        });
-        return messageId;
-    }
-    /**
-     * Build a context window from thread history, trimmed to token limit.
-     */
-    buildContextWindow(history, currentMessage) {
-        const maxChars = this.contextWindowTokens * APPROX_CHARS_PER_TOKEN;
-        let charCount = currentMessage.length;
-        const messages = [];
-        // Walk backwards through history, adding messages until we hit the limit
-        for (let i = history.length - 1; i >= 0; i--) {
-            const msg = history[i];
-            const body = msg['body'] ?? '';
-            const direction = msg['direction'];
-            if (charCount + body.length > maxChars)
-                break;
-            messages.unshift({
-                role: direction === 'inbound' ? 'user' : 'assistant',
-                content: body,
-            });
-            charCount += body.length;
-        }
-        // Add current message
-        messages.push({ role: 'user', content: currentMessage });
-        return messages;
-    }
-}

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

@@ -1,11 +0,0 @@
-/**
- * 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;