daemora 1.0.3 → 1.0.5

package/src/core/AgentLoop.js

@@ -1,5 +1,5 @@
 import { generateObject } from "ai";
-import { getModelWithFallback } from "../models/ModelRouter.js";
+import { getModelWithFallback, resolveThinkingConfig } from "../models/ModelRouter.js";
 import { compactIfNeeded, estimateTokens } from "./Compaction.js";
 import { config } from "../config/default.js";
 import eventBus from "./EventBus.js";
@@ -45,6 +45,10 @@ export async function runAgentLoop({
   const selectedModelId = modelId || config.defaultModel;
   const { model, meta, modelId: resolvedModelId } = getModelWithFallback(selectedModelId, apiKeys);
 
+  // Resolve thinking level config
+  const thinkingConfig = resolveThinkingConfig(resolvedModelId, config.thinkingLevel);
+  const thinkingParams = thinkingConfig?.thinkingParams || {};
+
   // Build set of known secret values to redact from tool outputs (dynamic - catches tenant keys)
   const _knownSecrets = new Set([
     ...Object.values(apiKeys),
@@ -63,17 +67,16 @@ export async function runAgentLoop({
 
   let messages = [systemPrompt, ...msgs];
   let stepCount = 0;
-  let writeToolUsed = false;  // Track if model actually modified anything
   let loopCount = 0;
   let lastToolCall = null;
   let repeatCount = 0;
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
   let consecutiveErrors = 0;
+  const toolCallLog = [];  // Track tool calls for task history
 
   const WRITE_TOOLS = new Set(["writeFile", "editFile", "applyPatch", "executeCommand", "sendEmail", "createDocument", "browserAction", "messageChannel"]);
   let gitSnapshotDone = false; // Only snapshot once per task
-  const ACTION_WORDS = /\b(fixed|updated|created|added|modified|changed|removed|deleted|wrote|edited|replaced|refactored|implemented|styled|applied)\b/i;
 
   console.log(`\n--- AGENT LOOP STARTED ---`);
   console.log(`Model: ${resolvedModelId}`);
@@ -90,6 +93,7 @@ export async function runAgentLoop({
         text: "Agent was stopped by the supervisor.",
         messages: messages.slice(1),
         cost: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, estimatedCost: 0, modelCalls: loopCount, model: resolvedModelId },
+        toolCalls: toolCallLog,
       };
     }
 
@@ -100,6 +104,7 @@ export async function runAgentLoop({
         text: "Task was stopped by the safety supervisor due to excessive tool usage or a dangerous pattern.",
         messages: messages.slice(1),
         cost: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, estimatedCost: 0, modelCalls: loopCount, model: resolvedModelId },
+        toolCalls: toolCallLog,
       };
     }
 
@@ -122,6 +127,17 @@ export async function runAgentLoop({
       }
     }
 
+    if (loopCount > config.maxLoops + 3) {
+      // Hard exit — agent ignored the soft stop message
+      console.log(`[FATAL] Agent exceeded hard limit (${config.maxLoops + 3}). Forcing exit.`);
+      return {
+        text: "Task stopped: exceeded maximum iterations. Here is what was accomplished before stopping.",
+        messages: messages.slice(1),
+        cost: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, estimatedCost: 0, modelCalls: loopCount, model: resolvedModelId },
+        toolCalls: toolCallLog,
+      };
+    }
+
     if (loopCount > config.maxLoops) {
       console.log(`[WARN] Hit max loop limit (${config.maxLoops}). Forcing agent to stop.`);
       messages.push({
@@ -130,8 +146,8 @@ export async function runAgentLoop({
       });
     }
 
-    // Compaction check before model call
-    messages = await compactIfNeeded(messages, meta, taskId);
+    // Compaction check before model call (pass tools for pre-compaction memory flush)
+    messages = await compactIfNeeded(messages, meta, taskId, tools);
 
     console.log(`\n[Loop ${loopCount}] Sending ${messages.length} messages (~${estimateTokens(messages)} tokens) to ${resolvedModelId}...`);
 
@@ -142,25 +158,34 @@ export async function runAgentLoop({
         model,
         schema: outputSchema,
         messages,
-        maxTokens: 4096,
+        maxTokens: 8192,
         abortSignal: signal || undefined,
+        ...thinkingParams,
       });
 
       const elapsed = Date.now() - startTime;
       consecutiveErrors = 0; // Reset on success
 
-      // Track token usage
-      if (response.usage) {
-        totalInputTokens += response.usage.promptTokens || 0;
-        totalOutputTokens += response.usage.completionTokens || 0;
+      // Track token usage (Vercel AI SDK uses inputTokens/outputTokens)
+      const usage = response.usage;
+      if (usage && (usage.inputTokens || usage.outputTokens || usage.promptTokens || usage.completionTokens)) {
+        totalInputTokens += usage.inputTokens || usage.promptTokens || 0;
+        totalOutputTokens += usage.outputTokens || usage.completionTokens || 0;
+      } else {
+        // Fallback: estimate from message sizes if usage not available
+        console.log(`[Loop ${loopCount}] WARNING: No token usage returned. response.usage = ${JSON.stringify(usage)}`);
+        const inputChars = messages.reduce((sum, m) => sum + (typeof m.content === "string" ? m.content.length : 0), 0);
+        const outputChars = JSON.stringify(response.object).length;
+        totalInputTokens += Math.ceil(inputChars / 4);
+        totalOutputTokens += Math.ceil(outputChars / 4);
       }
 
       eventBus.emitEvent("model:called", {
         modelId: resolvedModelId,
         loopCount,
         elapsed,
-        inputTokens: response.usage?.promptTokens || 0,
-        outputTokens: response.usage?.completionTokens || 0,
+        inputTokens: usage?.inputTokens || usage?.promptTokens || 0,
+        outputTokens: usage?.outputTokens || usage?.completionTokens || 0,
       });
 
       const parsedOutput = response.object;
@@ -274,14 +299,19 @@ export async function runAgentLoop({
             const outputStr = typeof toolOutput === "string" ? toolOutput : JSON.stringify(toolOutput);
             const preview = outputStr.slice(0, 300) + (outputStr.length > 300 ? "..." : "");
 
-            // Track if a write tool was successfully used
-            if (WRITE_TOOLS.has(tool_name)) {
-              writeToolUsed = true;
-            }
-
             console.log(`[Step ${stepCount}] Done in ${toolElapsed}ms`);
             console.log(`[Step ${stepCount}] Output: ${preview}`);
 
+            // Record tool call in log
+            toolCallLog.push({
+              tool: tool_name,
+              params,
+              duration: toolElapsed,
+              output_preview: outputStr.slice(0, 500),
+              status: "success",
+              step: stepCount,
+            });
+
             eventBus.emitEvent("tool:after", {
               tool_name,
               params,
@@ -311,6 +341,16 @@ export async function runAgentLoop({
           } catch (error) {
             console.log(`[Step ${stepCount}] FAILED: ${error.message}`);
 
+            // Record failed tool call in log
+            toolCallLog.push({
+              tool: tool_name,
+              params,
+              duration: 0,
+              output_preview: `Error: ${error.message}`,
+              status: "error",
+              step: stepCount,
+            });
+
             // Record failure for circuit breaker
             circuitBreaker.recordToolFailure(tool_name);
 
@@ -356,33 +396,6 @@ export async function runAgentLoop({
           continue;
         }
 
-        // --- Lazy model safeguard ---
-        // SAFEGUARD 1: Model claimed done but used ZERO tools
-        // If the user's message is a real request (not just "ok"/"yes"), force tool use.
-        if (stepCount === 0 && loopCount <= 2) {
-          const lastUserMsg = msgs[msgs.length - 1]?.content?.toLowerCase() || "";
-          const isAck = /^(ok|okay|yes|yeah|sure|thanks|thank you|no|nah|k|yep|yup|got it|cool|nice|great|good|alright|👍)\.?$/i.test(lastUserMsg.trim());
-          if (!isAck && lastUserMsg.length > 5) {
-            console.log(`[Loop ${loopCount}] LAZY MODEL DETECTED - claimed done but used 0 tools. Forcing tool use.`);
-            messages.push({
-              role: "user",
-              content: `You responded without using any tools. You MUST actually use tools (readFile, editFile, writeFile, executeCommand, etc.) to complete the task. Do NOT claim you fixed or changed something without actually doing it. Use your tools NOW to fulfill the request.`,
-            });
-            continue;
-          }
-        }
-
-        // SAFEGUARD 2: Model used only READ tools but claims it modified/fixed something
-        // If the response contains action words but no write tool was ever called, push back.
-        if (!writeToolUsed && stepCount > 0 && loopCount <= 4 && ACTION_WORDS.test(parsedOutput.text_content)) {
-          console.log(`[Loop ${loopCount}] PHANTOM WRITE DETECTED - model claims "${parsedOutput.text_content.slice(0, 80)}..." but only used read tools. Forcing actual writes.`);
-          messages.push({
-            role: "user",
-            content: `You claim to have made changes but you only used read tools - you never called writeFile or editFile to actually modify any file. The files are UNCHANGED. You must use writeFile or editFile to actually make the changes. Do it now.`,
-          });
-          continue;
-        }
-
         const cost = {
           inputTokens: totalInputTokens,
           outputTokens: totalOutputTokens,
@@ -403,7 +416,7 @@ export async function runAgentLoop({
         messages.push({ role: "assistant", content: parsedOutput.text_content });
 
         const conversationMessages = messages.slice(1);
-        return { text: parsedOutput.text_content, messages: conversationMessages, cost };
+        return { text: parsedOutput.text_content, messages: conversationMessages, cost, toolCalls: toolCallLog };
       }
     } catch (error) {
       // Abort signal fires as an error - exit cleanly
@@ -413,15 +426,16 @@ export async function runAgentLoop({
           text: "Agent was stopped by the supervisor.",
           messages: messages.slice(1),
           cost: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens, estimatedCost: 0, modelCalls: loopCount, model: resolvedModelId },
+          toolCalls: toolCallLog,
         };
       }
 
       consecutiveErrors++;
-      console.log(`[Loop ${loopCount}] Model call failed (${consecutiveErrors}/3): ${error.message}`);
+      console.log(`[Loop ${loopCount}] Model call failed (${consecutiveErrors}/5): ${error.message}`);
 
-      // Give up after 3 consecutive failures
-      if (consecutiveErrors >= 3) {
-        console.log(`[FATAL] 3 consecutive model failures. Stopping.`);
+      // Give up after 5 consecutive failures
+      if (consecutiveErrors >= 5) {
+        console.log(`[FATAL] 5 consecutive model failures. Stopping.`);
         return {
           text: `I encountered an error while processing your request: ${error.message}`,
           messages: messages.slice(1),
@@ -432,13 +446,19 @@ export async function runAgentLoop({
             modelCalls: loopCount,
             model: resolvedModelId,
           },
+          toolCalls: toolCallLog,
         };
       }
 
+      // Exponential backoff: 1s, 2s, 4s, 8s, 16s
+      const backoffMs = Math.min(1000 * Math.pow(2, consecutiveErrors - 1), 16000);
+      console.log(`[Loop ${loopCount}] Retrying in ${backoffMs}ms...`);
+      await new Promise(resolve => setTimeout(resolve, backoffMs));
+
       // Retry with a user-role nudge (compatible with all providers)
       messages.push({
         role: "user",
-        content: `[System: previous call failed: ${error.message}] Please provide your final answer. Set type to "text" and finalResponse to true.`,
+        content: `[System: previous call failed: ${error.message}] Try again with the same approach, or provide your final answer. Set type to "text" and finalResponse to true.`,
       });
       continue;
     }

package/src/core/Compaction.js

@@ -1,8 +1,9 @@
-import { generateText } from "ai";
+import { generateText, generateObject } from "ai";
 import { getCheapModel } from "../models/ModelRouter.js";
 import { writeFileSync, mkdirSync } from "fs";
 import { config } from "../config/default.js";
 import eventBus from "./EventBus.js";
+import outputSchema from "../services/models/outputSchema.js";
 
 /**
  * Context compaction system.
@@ -55,15 +56,93 @@ function persistLargeOutput(content, taskId, stepIndex) {
   return `[Output saved to disk: ${filePath} - ${content.length} chars]`;
 }
 
+/**
+ * Run a mini agent loop before compaction so the agent can save important context
+ * to memory files. Only uses memory tools. Max 3 turns.
+ */
+async function runPreCompactionFlush(messages, tools = {}) {
+  try {
+    const memoryToolNames = ["readMemory", "writeMemory", "writeDailyLog", "readDailyLog"];
+    const memoryTools = {};
+    for (const name of memoryToolNames) {
+      if (tools[name]) memoryTools[name] = tools[name];
+    }
+    if (Object.keys(memoryTools).length === 0) {
+      console.log("[Compaction] No memory tools available — skipping pre-compaction flush");
+      return;
+    }
+
+    const { model } = getCheapModel();
+
+    // Build a summary of recent context for the flush agent
+    const recentMessages = messages.slice(-10);
+    const contextSummary = recentMessages
+      .map(m => `[${m.role}]: ${(typeof m.content === "string" ? m.content : JSON.stringify(m.content)).slice(0, 500)}`)
+      .join("\n");
+
+    const flushPrompt = `Pre-compaction memory flush. The conversation is about to be compacted (older messages summarized).
+
+Recent conversation context:
+${contextSummary}
+
+If there are important details worth preserving (decisions, file paths, user preferences, task progress), save them now using writeMemory or writeDailyLog.
+If nothing important to save, respond with finalResponse: true immediately.
+
+Available tools: ${Object.keys(memoryTools).join(", ")}`;
+
+    let flushMessages = [
+      { role: "system", content: "You are a memory-flush agent. Save important context from the conversation to long-term memory before it gets compacted. Be brief." },
+      { role: "user", content: flushPrompt },
+    ];
+
+    for (let turn = 0; turn < 3; turn++) {
+      const response = await generateObject({
+        model,
+        schema: outputSchema,
+        messages: flushMessages,
+        maxTokens: 2048,
+      });
+
+      const parsed = response.object;
+      if (parsed.finalResponse || parsed.type === "text") {
+        console.log("[Compaction] Pre-flush complete" + (turn === 0 ? " (nothing to save)" : ` (${turn} tool calls)`));
+        return;
+      }
+
+      if (parsed.type === "tool_call" && parsed.tool_call) {
+        const { tool_name, params } = parsed.tool_call;
+        flushMessages.push({ role: "assistant", content: JSON.stringify(parsed) });
+
+        if (memoryTools[tool_name]) {
+          try {
+            const output = await Promise.resolve(memoryTools[tool_name](...params));
+            const outputStr = typeof output === "string" ? output : JSON.stringify(output);
+            console.log(`[Compaction] Pre-flush: ${tool_name} → ${outputStr.slice(0, 100)}`);
+            flushMessages.push({ role: "user", content: JSON.stringify({ tool_name, params, output: outputStr }) });
+          } catch (e) {
+            flushMessages.push({ role: "user", content: JSON.stringify({ tool_name, params, output: `Error: ${e.message}` }) });
+          }
+        } else {
+          flushMessages.push({ role: "user", content: JSON.stringify({ tool_name, params, output: `Unknown tool. Available: ${Object.keys(memoryTools).join(", ")}` }) });
+        }
+      }
+    }
+    console.log("[Compaction] Pre-flush hit max turns (3)");
+  } catch (error) {
+    console.log(`[Compaction] Pre-flush failed (non-blocking): ${error.message}`);
+  }
+}
+
 /**
  * Check if compaction is needed and perform it.
  *
  * @param {Array} messages - Current message history
  * @param {object} modelMeta - Model metadata (from models.js) with compactAt threshold
  * @param {string} taskId - Current task ID for file persistence
+ * @param {object} [tools] - Available tool functions (used for pre-compaction flush)
  * @returns {Array} Possibly compacted messages
  */
-export async function compactIfNeeded(messages, modelMeta, taskId = null) {
+export async function compactIfNeeded(messages, modelMeta, taskId = null, tools = {}) {
   const tokenCount = estimateTokens(messages);
 
   if (tokenCount < modelMeta.compactAt) {
@@ -75,6 +154,9 @@ export async function compactIfNeeded(messages, modelMeta, taskId = null) {
   );
   eventBus.emitEvent("compact:triggered", { tokenCount, threshold: modelMeta.compactAt });
 
+  // Pre-compaction memory flush — let agent save important context before we compact
+  await runPreCompactionFlush(messages, tools);
+
   // Step 1: Identify protected messages (system prompt + last 3 exchanges)
   const systemMsg = messages[0]; // always protect system prompt
   const recentCount = 6; // last 3 user+assistant pairs

package/src/core/MessageQueue.js

@@ -0,0 +1,90 @@
+/**
+ * Inbound message debouncer — batches rapid-fire messages from the same session
+ * into a single task instead of spawning separate agent loops for each.
+ *
+ * When messages arrive within the debounce window (default 1.5s), they're
+ * concatenated into a single task input:
+ *   [Queued messages]
+ *   ---
+ *   Message 1: first message
+ *   ---
+ *   Message 2: second message
+ */
+
+import { config } from "../config/default.js";
+
+class InboundDebouncer {
+  constructor() {
+    // sessionId → { messages: string[], timer: NodeJS.Timeout, resolve: Function }
+    this._pending = new Map();
+    this._debounceMs = parseInt(process.env.DEBOUNCE_MS || "1500", 10);
+  }
+
+  /**
+   * Add a message to the debounce queue for a session.
+   * Returns a Promise that resolves with the batched message(s) when the debounce window closes.
+   *
+   * @param {string} sessionId
+   * @param {string} message
+   * @returns {Promise<string>} Batched message (may be single or multi)
+   */
+  debounce(sessionId, message) {
+    return new Promise((resolve) => {
+      const existing = this._pending.get(sessionId);
+
+      if (existing) {
+        // Add to existing batch, reset timer
+        existing.messages.push(message);
+        clearTimeout(existing.timer);
+        // Only the first caller's resolve gets used; subsequent callers get null
+        existing.resolvers.push(resolve);
+        existing.timer = setTimeout(() => this._flush(sessionId), this._debounceMs);
+      } else {
+        // New batch
+        const entry = {
+          messages: [message],
+          resolvers: [resolve],
+          timer: setTimeout(() => this._flush(sessionId), this._debounceMs),
+        };
+        this._pending.set(sessionId, entry);
+      }
+    });
+  }
+
+  _flush(sessionId) {
+    const entry = this._pending.get(sessionId);
+    if (!entry) return;
+    this._pending.delete(sessionId);
+
+    let batched;
+    if (entry.messages.length === 1) {
+      batched = entry.messages[0];
+    } else {
+      const lines = entry.messages.map((m, i) => `Message ${i + 1}: ${m}`);
+      batched = `[Queued messages]\n---\n${lines.join("\n---\n")}`;
+    }
+
+    // First resolver gets the batched message; others get null (they won't create tasks)
+    entry.resolvers[0](batched);
+    for (let i = 1; i < entry.resolvers.length; i++) {
+      entry.resolvers[i](null);
+    }
+  }
+
+  /**
+   * Check if a session has pending debounced messages.
+   */
+  hasPending(sessionId) {
+    return this._pending.has(sessionId);
+  }
+
+  /**
+   * Get debounce window in ms.
+   */
+  get debounceMs() {
+    return this._debounceMs;
+  }
+}
+
+const debouncer = new InboundDebouncer();
+export default debouncer;

package/src/core/Task.js

@@ -16,10 +16,20 @@ export function createTask({
   model = null,
   maxCost = null,
   approvalMode = "auto",
+  // ── Task system fields ──────────────────────────────────────────────────
+  type = "chat",            // "chat" (from user message) | "task" (agent-created)
+  title = null,             // short descriptive title (agent-created tasks)
+  description = null,       // detailed task description
+  parentTaskId = null,      // ID of parent task (for hierarchy)
+  agentId = null,           // which agent/sub-agent is executing
+  agentCreated = false,     // whether the agent created this task vs system
 }) {
   return {
     id: uuidv4(),
     status: "pending",
+    type,                 // chat | task
+    title,                // short title for agent-created tasks
+    description,          // detailed description
     input,                // user's message text
     channel,              // http | telegram | whatsapp | email | a2a
     channelMeta,          // channel-specific metadata (chat_id, phone, email, etc.)
@@ -28,6 +38,9 @@ export function createTask({
     model,                // explicit model override or null (use default)
     maxCost,              // per-task cost budget or null (use global)
     approvalMode,         // auto | dangerous-only | every-tool | milestones
+    parentTaskId,         // parent task ID (for hierarchy)
+    agentId,              // executing agent/sub-agent ID
+    agentCreated,         // true if created by agent via taskManager tool
     result: null,         // final response text
     error: null,          // error message if failed
     cost: {

package/src/core/TaskQueue.js

@@ -102,7 +102,7 @@ class TaskQueue {
     saveTask(task);
     this.active.delete(taskId);
 
-    eventBus.emitEvent("task:completed", { taskId: task.id, cost: task.cost });
+    eventBus.emitEvent("task:completed", { taskId: task.id, cost: task.cost, result: task.result });
 
     // Resolve any sync waiters (normal flow - channel is waiting for completion)
     const waiter = this.waiters.get(taskId);

package/src/core/TaskRunner.js

@@ -8,6 +8,41 @@ import { config } from "../config/default.js";
 import tenantManager from "../tenants/TenantManager.js";
 import tenantContext from "../tenants/TenantContext.js";
 import inputSanitizer from "../safety/InputSanitizer.js";
+import eventBus from "./EventBus.js";
+
+/**
+ * Filter out internal tool call/result JSON from messages before saving to session.
+ * Keeps only clean user text and assistant text that users should see.
+ */
+function filterCleanMessages(messages) {
+  return messages.filter(msg => {
+    if (!msg.content || typeof msg.content !== "string") return false;
+
+    const trimmed = msg.content.trimStart();
+    if (trimmed.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        // Assistant tool_call messages
+        if (parsed.type === "tool_call" || parsed.tool_call) return false;
+        // User tool_result messages
+        if (parsed.tool_name) return false;
+        // Structured finalResponse wrappers (the actual text is saved separately)
+        if (parsed.type === "text" && parsed.finalResponse !== undefined) return false;
+      } catch {
+        // Not valid JSON - keep it (probably natural language that starts with {)
+      }
+    }
+
+    // Filter out system injection messages
+    if (msg.role === "user" && msg.content.startsWith("[Supervisor instruction]:")) return false;
+    if (msg.role === "user" && msg.content.startsWith("[System:")) return false;
+    if (msg.role === "user" && msg.content.includes("You have used") && msg.content.includes("iterations")) return false;
+    if (msg.role === "user" && msg.content.includes("You are calling") && msg.content.includes("same params repeatedly")) return false;
+    if (msg.role === "user" && msg.content.includes("Provide a text summary of what you did")) return false;
+
+    return true;
+  });
+}
 
 /**
  * Task runner - worker loop that picks tasks from the queue and executes them.
@@ -176,7 +211,7 @@ class TaskRunner {
       // Wrap entire task execution in tenant context (AsyncLocalStorage).
       // This allows FilesystemGuard, memory tools, and other tools to read per-tenant config
       // without any race conditions across concurrent tasks.
-      await tenantContext.run({ tenant, resolvedConfig, resolvedModel, apiKeys }, async () => {
+      await tenantContext.run({ tenant, resolvedConfig, resolvedModel, apiKeys, sessionId: task.sessionId, channelMeta: task.channelMeta || null, directReplySent: false, currentTaskId: task.id, agentId: "main" }, async () => {
         // Get or create session
         let session = task.sessionId ? getSession(task.sessionId) : null;
         if (!session) {
@@ -185,7 +220,10 @@ class TaskRunner {
         }
 
         // Build system prompt (SOUL.md + MEMORY.md + semantic recall + daily log + matched skills)
-        const systemPrompt = await buildSystemPrompt(task.input);
+        const systemPrompt = await buildSystemPrompt(task.input, "full", {
+          model: resolvedModel,
+          agentId: "main",
+        });
 
         // Build message history
         const previousMessages = session.messages.map((m) => ({
@@ -194,6 +232,31 @@ class TaskRunner {
         }));
         const messages = [...previousMessages, { role: "user", content: task.input }];
 
+        // Track sub-agents spawned during this task
+        const subAgents = [];
+        const onSpawn = (evt) => {
+          if (evt.parentTaskId === task.id) {
+            subAgents.push({ agentId: evt.agentId, taskId: evt.taskId, description: evt.taskDescription, depth: evt.depth, status: "running", startedAt: new Date().toISOString() });
+          }
+        };
+        const onFinish = (evt) => {
+          if (evt.parentTaskId === task.id) {
+            const sa = subAgents.find(s => s.agentId === evt.agentId);
+            if (sa) {
+              sa.status = evt.error ? "failed" : (evt.killed ? "killed" : "completed");
+              sa.cost = evt.cost || null;
+              sa.error = evt.error || null;
+              sa.toolCalls = evt.toolCalls || [];
+              sa.resultPreview = evt.resultPreview || null;
+              sa.model = evt.model || null;
+              sa.role = evt.role || null;
+              sa.completedAt = new Date().toISOString();
+            }
+          }
+        };
+        eventBus.on("agent:spawned", onSpawn);
+        eventBus.on("agent:finished", onFinish);
+
         // Run agent loop with resolved model, cost limits, and per-tenant API keys.
         // steerQueue lets follow-up messages from the same user be injected live
         // between tool calls instead of spawning a competing agent loop.
@@ -210,11 +273,17 @@ class TaskRunner {
           steerQueue,
         });
 
-        // Update session with conversation
-        setMessages(session.sessionId, result.messages);
+        // Clean up event listeners
+        eventBus.removeListener("agent:spawned", onSpawn);
+        eventBus.removeListener("agent:finished", onFinish);
 
-        // Update task cost info
+        // Update session with CLEAN conversation only (strip internal tool JSON)
+        setMessages(session.sessionId, filterCleanMessages(result.messages));
+
+        // Update task cost info and tool calls
         task.cost = result.cost;
+        task.toolCalls = result.toolCalls || [];
+        if (subAgents.length > 0) task.subAgents = subAgents;
 
         // Record cost against tenant lifetime totals
         const estimatedCost = result.cost?.estimatedCost || 0;
@@ -222,6 +291,12 @@ class TaskRunner {
           tenantManager.recordCost(tenant.id, estimatedCost);
         }
 
+        // If agent already replied directly (via replyWithFile), mark task so channel skips text reply
+        const store = tenantContext.getStore();
+        if (store?.directReplySent) {
+          task.directReplySent = true;
+        }
+
         // Complete the task
         taskQueue.complete(task.id, result.text);
         const costStr = estimatedCost ? ` cost: $${estimatedCost.toFixed(4)}` : "";