botinabox 1.8.3 → 1.8.5

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

@@ -72,6 +72,8 @@ export declare class ChatPipeline {
     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).
@@ -87,8 +89,15 @@ export declare class ChatPipeline {
     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.
      */

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

@@ -36,6 +36,8 @@ export class ChatPipeline {
     // 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;
@@ -119,8 +121,12 @@ export class ChatPipeline {
                 skipFilter: true,
                 skipRedundancyCheck: true,
             });
-            // ── Layer 3-5: Async interpretation + dispatch ─────────────
-            void this.interpretAndDispatch(messageId, msg, threadTs, channelId);
+            // ── 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
         this.hooks.register('run.completed', async (ctx) => {
@@ -144,6 +150,7 @@ export class ChatPipeline {
                 agentId: ctx.agentId,
                 taskId,
                 source: 'agent',
+                skipRedundancyCheck: true, // Task results are always delivered
             });
         }, { priority: 90 });
     }
@@ -169,32 +176,93 @@ export class ChatPipeline {
     }
     /**
      * 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);
-            // Layer 4: Post-Interpretation Response
-            if (result.tasks.length > 0 || result.memories.length > 0) {
-                const summary = this.buildSummary(result);
-                await this.responder.sendResponse({
-                    text: summary,
-                    channel: this.channel,
-                    threadId: threadTs,
-                    source: 'interpretation',
-                });
-            }
-            // Layer 5: Task Dispatch — always dispatch, execution layer decides if action needed
-            if (result.tasks.length > 0) {
-                await this.dispatchTasks(result, msg, threadTs, channelId);
+            // 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 — ack was already sent
+            // 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: err instanceof Error ? err.message : String(err),
+                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) {
+            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.

package/dist/core/chat/message-interpreter.js

@@ -131,7 +131,9 @@ export class MessageInterpreter {
                 system: INTERPRET_SYSTEM,
                 maxTokens: 1000,
             });
-            const parsed = JSON.parse(result.content);
+            // Strip markdown fences if present (LLMs often wrap JSON in ```json...```)
+            const raw = result.content.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '').trim();
+            const parsed = JSON.parse(raw);
             return {
                 tasks: (parsed.tasks ?? []).map(t => ({
                     title: t.title,

package/dist/index.d.ts

@@ -1360,8 +1360,15 @@ declare class ChatPipeline {
     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.
      */

package/dist/index.js

@@ -1576,7 +1576,8 @@ var MessageInterpreter = class {
         system: INTERPRET_SYSTEM,
         maxTokens: 1e3
       });
-      const parsed = JSON.parse(result.content);
+      const raw = result.content.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+      const parsed = JSON.parse(raw);
       return {
         tasks: (parsed.tasks ?? []).map((t) => ({
           title: t.title,
@@ -1671,12 +1672,13 @@ var ChatPipeline = class {
       if (this.messageFilter && !this.messageFilter(msg)) return;
       if (await this.isDuplicate(msg)) return;
       const rawTs = msg.raw?.ts;
-      const threadTs = msg.threadId ?? rawTs ?? msg.id;
       const channelId = msg.account ?? "";
+      const threadTs = msg.threadId ?? channelId ?? rawTs ?? msg.id;
       if (threadTs && channelId) {
         this.threadChannelMap.set(threadTs, channelId);
       }
-      const { messageId } = await this.messageStore.storeInbound(msg);
+      const msgWithThread = { ...msg, threadId: threadTs };
+      const { messageId } = await this.messageStore.storeInbound(msgWithThread);
       const userHistory = await this.messageStore.getUserHistory(
         msg.from,
         this.channel,
@@ -1725,7 +1727,9 @@ ${historyContext}` : void 0
         threadId: mapping.thread_ts,
         agentId: ctx.agentId,
         taskId,
-        source: "agent"
+        source: "agent",
+        skipRedundancyCheck: true
+        // Task results are always delivered
       });
     }, { priority: 90 });
   }
@@ -1749,25 +1753,31 @@ ${historyContext}` : void 0
   }
   /**
    * 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) {
+    await this.guaranteedTaskDispatch(msg, threadTs, channelId);
     try {
       const result = await this.interpreter.interpret(messageId);
-      if (result.tasks.length > 0 || result.memories.length > 0) {
+      if (result.memories.length > 0 || result.userContext.length > 0) {
         try {
-          const summary = this.buildSummary(result);
-          await this.responder.sendResponse({
-            text: summary,
-            channel: this.channel,
-            threadId: threadTs,
-            source: "interpretation"
-          });
+          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 {
         }
       }
-      if (result.tasks.length > 0) {
-        await this.dispatchTasks(result, msg, threadTs, channelId);
-      }
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
       await this.hooks.emit("interpretation.error", {
@@ -1776,6 +1786,62 @@ ${historyContext}` : void 0
       });
     }
   }
+  /**
+   * Programmatic task creation — guaranteed, no LLM dependency.
+   */
+  async guaranteedTaskDispatch(msg, threadTs, channelId) {
+    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;
+    if (threadTs) {
+      const existing = await this.db.query("thread_task_map", {
+        where: { thread_ts: threadTs, channel_id: channelId }
+      });
+      if (existing.length > 0) {
+        const taskId2 = existing[0].task_id;
+        const task = await this.tasks.get(taskId2);
+        if (task && task.status !== "done" && task.status !== "cancelled") {
+          const updatedDesc = `${task.description ?? ""}
+
+---
+**Follow-up (${(/* @__PURE__ */ new Date()).toISOString()}):**
+${msg.body}`;
+          await this.tasks.update(taskId2, { description: updatedDesc });
+          await this.wakeups.enqueue(handlerAgentId, "chat_followup", { taskId: taskId2 });
+          return;
+        }
+      }
+    }
+    const description = `## Chat Message
+
+**Channel:** ${channelId}
+**Thread:** ${threadTs}
+**From:** ${msg.from}
+**Time:** ${msg.receivedAt}
+
+---
+
+${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: msg.body.slice(0, 120),
+      description,
+      assignee_id: handlerAgentId,
+      priority: 5
+    });
+    await this.wakeups.enqueue(handlerAgentId, "chat_dispatch", { taskId });
+  }
   /**
    * Route and dispatch extracted tasks.
    */

package/package.json

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