0agent 1.0.76 → 1.0.78

package/dist/daemon.mjs

@@ -1978,6 +1978,13 @@ var init_LLMExecutor = __esm({
       constructor(config) {
         this.config = config;
       }
+      /**
+       * Create a new LLMExecutor with a different model but same provider/key.
+       * Used by SmartModelRouter to switch to a fast model for simple messages.
+       */
+      withModel(model) {
+        return new _LLMExecutor({ ...this.config, model });
+      }
       get isConfigured() {
         if (this.config.provider === "ollama") return true;
         return !!this.config.api_key?.trim();
@@ -5043,6 +5050,88 @@ ${lines.join("\n")}`,
   }
 });
 
+// packages/daemon/src/capabilities/SessionSearchCapability.ts
+var SessionSearchCapability;
+var init_SessionSearchCapability = __esm({
+  "packages/daemon/src/capabilities/SessionSearchCapability.ts"() {
+    "use strict";
+    SessionSearchCapability = class {
+      name = "session_search";
+      description = "Search across past conversation history to recall previous interactions and decisions.";
+      toolDefinition = {
+        name: "session_search",
+        description: "Search across all past conversations for relevant context. Use this when the user references something from a previous session, or when you need to recall past decisions, outcomes, or context. Returns matching conversation excerpts with timestamps.",
+        input_schema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query \u2014 keywords, phrases, or natural language question" },
+            max_results: { type: "string", description: "Maximum results to return (default 5)" }
+          },
+          required: ["query"]
+        }
+      };
+      getDbPath;
+      constructor(getDbPath) {
+        this.getDbPath = getDbPath;
+      }
+      async execute(input) {
+        const start = Date.now();
+        const query = String(input.query ?? "").trim();
+        const maxResults = Number(input.max_results ?? 5);
+        if (!query) return { success: false, output: "query is required", duration_ms: 0 };
+        try {
+          const Database2 = (await import("better-sqlite3")).default;
+          const db = new Database2(this.getDbPath());
+          const keywords = query.split(/\s+/).filter((w) => w.length > 2);
+          const likeClause = keywords.map(() => `content LIKE ?`).join(" OR ");
+          const likeParams = keywords.map((k) => `%${k}%`);
+          const rows = db.prepare(`
+        SELECT session_id, role, content, created_at
+        FROM conversations
+        WHERE ${likeClause || "1=1"}
+        ORDER BY created_at DESC
+        LIMIT ?
+      `).all(...likeParams, maxResults * 3);
+          db.close();
+          if (!rows.length) {
+            return {
+              success: true,
+              output: `No past conversations found matching "${query}".`,
+              duration_ms: Date.now() - start
+            };
+          }
+          const sessions = /* @__PURE__ */ new Map();
+          for (const row of rows) {
+            if (!sessions.has(row.session_id)) sessions.set(row.session_id, []);
+            sessions.get(row.session_id).push(row);
+          }
+          const results = [];
+          let count = 0;
+          for (const [sessionId, msgs] of sessions) {
+            if (count >= maxResults) break;
+            const date = new Date(msgs[0].created_at).toISOString().split("T")[0];
+            const excerpt = msgs.slice(0, 4).map((m) => `  ${m.role}: ${m.content.slice(0, 200)}${m.content.length > 200 ? "\u2026" : ""}`).join("\n");
+            results.push(`[${date}] Session ${sessionId.slice(0, 8)}:
+${excerpt}`);
+            count++;
+          }
+          return {
+            success: true,
+            output: `Found ${sessions.size} matching session(s):
+
+${results.join("\n\n")}`,
+            structured: { sessions: sessions.size, total_messages: rows.length },
+            duration_ms: Date.now() - start
+          };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { success: false, output: `Session search failed: ${msg}`, duration_ms: Date.now() - start, error: msg };
+        }
+      }
+    };
+  }
+});
+
 // packages/daemon/src/capabilities/CodespaceBrowserCapability.ts
 var CodespaceBrowserCapability_exports = {};
 __export(CodespaceBrowserCapability_exports, {
@@ -5135,6 +5224,7 @@ var init_CapabilityRegistry = __esm({
     init_OCRExtractCapability();
     init_CredentialVaultCapability();
     init_MonitorWatchCapability();
+    init_SessionSearchCapability();
     CapabilityRegistry = class {
       capabilities = /* @__PURE__ */ new Map();
       /**
@@ -5147,7 +5237,7 @@ var init_CapabilityRegistry = __esm({
        * task_type: browser_task). The main agent does NOT have direct access
        * to browser_open without going through a subagent spawn.
        */
-      constructor(codespaceManager, graph, onMemoryWrite) {
+      constructor(codespaceManager, graph, onMemoryWrite, dbPath) {
         this.register(new WebSearchCapability());
         if (codespaceManager) {
           try {
@@ -5169,6 +5259,9 @@ var init_CapabilityRegistry = __esm({
         this.register(new OCRExtractCapability());
         this.register(new CredentialVaultCapability());
         this.register(new MonitorWatchCapability());
+        if (dbPath) {
+          this.register(new SessionSearchCapability(() => dbPath));
+        }
         if (graph) {
           this.register(new MemoryCapability(graph, onMemoryWrite));
         }
@@ -5199,6 +5292,7 @@ var init_CapabilityRegistry = __esm({
         const lower = task.toLowerCase();
         const active = /* @__PURE__ */ new Set(["shell_exec", "file_op", "surge_publish"]);
         if (this.capabilities.has("memory_write")) active.add("memory_write");
+        if (this.capabilities.has("session_search")) active.add("session_search");
         if (/search|web|browse|scrape|research|website|url|http|google|fetch|crawl|find.*online/i.test(lower)) {
           active.add("web_search");
           active.add("scrape_url");
@@ -5254,6 +5348,150 @@ var init_capabilities = __esm({
     init_OCRExtractCapability();
     init_CredentialVaultCapability();
     init_MonitorWatchCapability();
+    init_SessionSearchCapability();
+  }
+});
+
+// packages/daemon/src/IterationBudget.ts
+var IterationBudget;
+var init_IterationBudget = __esm({
+  "packages/daemon/src/IterationBudget.ts"() {
+    "use strict";
+    IterationBudget = class _IterationBudget {
+      constructor(maxIterations, parent, childAllocation) {
+        this.maxIterations = maxIterations;
+        this.parent = parent ?? null;
+        this.childAllocation = childAllocation ?? maxIterations;
+      }
+      used = 0;
+      parent;
+      childAllocation;
+      /**
+       * Consume N iterations. Returns true if budget remains, false if exhausted.
+       * Also consumes from parent budget if this is a child.
+       */
+      consume(n = 1) {
+        this.used += n;
+        if (this.parent) {
+          return this.parent.consume(n) && this.used <= this.maxIterations;
+        }
+        return this.used <= this.maxIterations;
+      }
+      /**
+       * Refund N iterations (e.g., for execute_code calls that don't count).
+       */
+      refund(n = 1) {
+        this.used = Math.max(0, this.used - n);
+        this.parent?.refund(n);
+      }
+      remaining() {
+        const local = this.maxIterations - this.used;
+        if (this.parent) {
+          return Math.min(local, this.parent.remaining());
+        }
+        return local;
+      }
+      exhausted() {
+        return this.remaining() <= 0;
+      }
+      /**
+       * Fork a child budget that draws from this parent's remaining pool.
+       * The child has its own max but also decrements the parent on each consume.
+       */
+      fork(childMax) {
+        const max = childMax ?? Math.min(30, this.remaining());
+        return new _IterationBudget(max, this, max);
+      }
+      /**
+       * Get a budget pressure message if running low.
+       * Returns null if budget is healthy.
+       */
+      pressureWarning() {
+        const rem = this.remaining();
+        const pct = rem / this.maxIterations;
+        if (pct <= 0) {
+          return "BUDGET EXHAUSTED: You have used all available iterations. Wrap up immediately.";
+        }
+        if (pct <= 0.1) {
+          return `BUDGET CRITICAL: Only ${rem} iteration(s) remaining. Finish the current task NOW.`;
+        }
+        if (pct <= 0.25) {
+          return `Budget warning: ${rem} iterations remaining (${Math.round(pct * 100)}%). Start wrapping up.`;
+        }
+        return null;
+      }
+      stats() {
+        return {
+          used: this.used,
+          max: this.maxIterations,
+          remaining: this.maxIterations - this.used,
+          ...this.parent ? { parentRemaining: this.parent.remaining() } : {}
+        };
+      }
+    };
+  }
+});
+
+// packages/daemon/src/PromptInjectionScanner.ts
+function scanForInjection(content, source) {
+  const warnings = [];
+  let sanitized = content;
+  const invisibleMatches = content.match(INVISIBLE_CHARS);
+  if (invisibleMatches && invisibleMatches.length > 0) {
+    warnings.push(`${source || "content"}: ${invisibleMatches.length} invisible Unicode chars detected and stripped`);
+    sanitized = sanitized.replace(INVISIBLE_CHARS, "");
+  }
+  let hasBlock = false;
+  for (const { pattern, severity, label } of INJECTION_PATTERNS) {
+    if (pattern.test(content)) {
+      const msg = `${source || "content"}: ${label} detected (${severity})`;
+      warnings.push(msg);
+      if (severity === "block") hasBlock = true;
+    }
+  }
+  const lines = content.split("\n");
+  const uniqueLines = new Set(lines.map((l) => l.trim()).filter((l) => l.length > 10));
+  if (lines.length > 20 && uniqueLines.size < lines.length * 0.3) {
+    warnings.push(`${source || "content"}: suspicious repetition (${uniqueLines.size} unique of ${lines.length} lines)`);
+  }
+  return {
+    safe: !hasBlock,
+    warnings,
+    sanitized: hasBlock ? `[BLOCKED: Prompt injection detected in ${source || "content"}. Content excluded for safety.]` : sanitized
+  };
+}
+function sanitizeContextFile(content, filePath, log) {
+  const result = scanForInjection(content, filePath);
+  for (const w of result.warnings) {
+    log?.(`[injection-scan] ${w}`);
+  }
+  return result.sanitized;
+}
+var INJECTION_PATTERNS, INVISIBLE_CHARS;
+var init_PromptInjectionScanner = __esm({
+  "packages/daemon/src/PromptInjectionScanner.ts"() {
+    "use strict";
+    INJECTION_PATTERNS = [
+      // Direct instruction override
+      { pattern: /ignore\s+(all\s+)?(previous|prior|above|earlier)\s+(instructions?|context|rules?|prompts?)/i, severity: "block", label: "instruction override" },
+      { pattern: /disregard\s+(all\s+)?(previous|prior|above)\s+(instructions?|context)/i, severity: "block", label: "instruction override" },
+      { pattern: /forget\s+(everything|all|what)\s+(you|I)\s+(told|said|instructed)/i, severity: "block", label: "instruction override" },
+      { pattern: /new\s+instructions?\s*:/i, severity: "block", label: "instruction injection" },
+      { pattern: /\bsystem\s*:\s*you\s+are\b/i, severity: "block", label: "role hijack" },
+      // Role impersonation
+      { pattern: /you\s+are\s+now\s+(a|an|the)\s+/i, severity: "warn", label: "role impersonation" },
+      { pattern: /act\s+as\s+(if|though)\s+you\s+are/i, severity: "warn", label: "role impersonation" },
+      { pattern: /pretend\s+(you'?re?|to\s+be)\s+/i, severity: "warn", label: "role impersonation" },
+      // Credential/data exfiltration
+      { pattern: /send\s+(the|your|all)\s+(api\s*key|token|password|secret|credential)/i, severity: "block", label: "credential exfil" },
+      { pattern: /output\s+(the|your)\s+system\s+prompt/i, severity: "block", label: "prompt extraction" },
+      { pattern: /reveal\s+(the|your)\s+(system|initial)\s+(prompt|instructions)/i, severity: "block", label: "prompt extraction" },
+      { pattern: /what\s+(is|are)\s+your\s+(system\s+)?instructions/i, severity: "warn", label: "prompt extraction attempt" },
+      // Encoded/obfuscated injection
+      { pattern: /base64\s*decode|atob\s*\(/i, severity: "warn", label: "encoded payload" },
+      { pattern: /eval\s*\(|Function\s*\(/i, severity: "warn", label: "code execution attempt" }
+    ];
+    INVISIBLE_CHARS = /[\u200B\u200C\u200D\u200E\u200F\u202A-\u202E\u2060\u2061\u2062\u2063\u2064\u2066-\u2069\uFEFF\u00AD]/g;
   }
 });
 
@@ -5268,6 +5506,8 @@ var init_AgentExecutor = __esm({
     "use strict";
     init_LLMExecutor();
     init_capabilities();
+    init_IterationBudget();
+    init_PromptInjectionScanner();
     SELF_MOD_PATTERN = /\b(yourself|the agent|this agent|this cli|0agent|your code|your source|agent cli|improve.*agent|update.*agent|add.*to.*agent|fix.*agent|self.?improv)\b/i;
     AgentExecutor = class {
       constructor(llm, config, onStep, onToken) {
@@ -5299,9 +5539,17 @@ var init_AgentExecutor = __esm({
         const systemPrompt = this.buildSystemPrompt(systemContext, task);
         const activeTools = this.registry.getToolDefinitionsFor(task);
         let toolSet = activeTools;
+        const budget = new IterationBudget(this.maxIterations);
         const messages = [
           { role: "user", content: task }
         ];
+        const isJustdo = /book|file.*itr|tax.*file|irctc|train.*ticket|flight|passport|appointment|login.*portal|pan.*card|aadhaar|monitor.*watch|price.*drop|slot.*available|justdo/i.test(task);
+        if (isJustdo) {
+          messages.push(
+            { role: "assistant", content: "I can help with that. Let me start collecting the information I need." },
+            { role: "user", content: "Yes, go ahead." }
+          );
+        }
         const contextLimit = LLMExecutor.getContextWindowTokens(this.llm["config"]?.model ?? "claude-sonnet-4-6");
         if (isSelfMod) {
           this.maxIterations = Math.max(this.maxIterations, 50);
@@ -5313,6 +5561,15 @@ var init_AgentExecutor = __esm({
             finalOutput = "Cancelled.";
             break;
           }
+          if (budget.exhausted()) {
+            this.onStep("Iteration budget exhausted \u2014 wrapping up.");
+            break;
+          }
+          budget.consume(1);
+          const pressureMsg = budget.pressureWarning();
+          if (pressureMsg && messages.length > 2) {
+            messages.push({ role: "user", content: `[SYSTEM] ${pressureMsg}` });
+          }
           this.onStep(i === 0 ? "Thinking\u2026" : "Continuing\u2026");
           const estimatedTokens = this._estimateTokens(messages);
           if (estimatedTokens > contextLimit - 16384) {
@@ -5383,35 +5640,23 @@ var init_AgentExecutor = __esm({
             content: response.content,
             tool_calls: response.tool_calls
           });
-          for (const tc of response.tool_calls) {
-            this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)})`);
-            let result;
-            try {
-              const capResult = await this.registry.execute(tc.name, tc.input, this.cwd, signal);
-              result = capResult.output;
-              const MAX_TOOL_OUTPUT = 4e3;
-              if (result.length > MAX_TOOL_OUTPUT) {
-                result = result.slice(0, MAX_TOOL_OUTPUT) + `
-[...${result.length - MAX_TOOL_OUTPUT} chars truncated]`;
-              }
-              if (capResult.fallback_used) {
-                this.onStep(`  (used fallback: ${capResult.fallback_used})`);
-              }
-              if (tc.name === "file_op" && tc.input.op === "write" && tc.input.path) {
-                filesWritten.push(String(tc.input.path));
-              }
-              if (tc.name === "shell_exec" && tc.input.command) {
-                commandsRun.push(String(tc.input.command));
-              }
-            } catch (err) {
-              result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+          const toolCalls = response.tool_calls;
+          const { parallel, serial } = this._partitionToolCalls(toolCalls);
+          if (parallel.length > 0) {
+            const results = await Promise.all(parallel.map(async (tc) => {
+              this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)}) [parallel]`);
+              return { tc, result: await this._executeSingleTool(tc, signal, filesWritten, commandsRun) };
+            }));
+            for (const { tc, result } of results) {
+              this.onStep(`  \u21B3 ${result.slice(0, 120)}${result.length > 120 ? "\u2026" : ""}`);
+              messages.push({ role: "tool", content: result, tool_call_id: tc.id });
             }
+          }
+          for (const tc of serial) {
+            this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)})`);
+            const result = await this._executeSingleTool(tc, signal, filesWritten, commandsRun);
             this.onStep(`  \u21B3 ${result.slice(0, 120)}${result.length > 120 ? "\u2026" : ""}`);
-            messages.push({
-              role: "tool",
-              content: result,
-              tool_call_id: tc.id
-            });
+            messages.push({ role: "tool", content: result, tool_call_id: tc.id });
           }
         }
         return {
@@ -5727,7 +5972,8 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
             if (existsSync5(f)) {
               const content = readFileSync4(f, "utf8").trim();
               if (content && content.length < 4e3) {
-                lines.push(``, `Project instructions:`, content);
+                const sanitized = sanitizeContextFile(content, f);
+                lines.push(``, `Project instructions:`, sanitized);
                 break;
               }
             }
@@ -5832,6 +6078,75 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
         if (toolName === "scrape_url") return `"${String(input.url ?? "").slice(0, 60)}" mode=${input.mode ?? "text"}`;
         return JSON.stringify(input).slice(0, 60);
       }
+      /**
+       * Execute a single tool call. Returns the result string.
+       */
+      async _executeSingleTool(tc, signal, filesWritten, commandsRun) {
+        let result;
+        try {
+          const capResult = await this.registry.execute(tc.name, tc.input, this.cwd, signal);
+          result = capResult.output;
+          const MAX_TOOL_OUTPUT = 4e3;
+          if (result.length > MAX_TOOL_OUTPUT) {
+            result = result.slice(0, MAX_TOOL_OUTPUT) + `
+[...${result.length - MAX_TOOL_OUTPUT} chars truncated]`;
+          }
+          if (capResult.fallback_used) {
+            this.onStep(`  (used fallback: ${capResult.fallback_used})`);
+          }
+          if (tc.name === "file_op" && tc.input.op === "write" && tc.input.path) {
+            filesWritten.push(String(tc.input.path));
+          }
+          if (tc.name === "shell_exec" && tc.input.command) {
+            commandsRun.push(String(tc.input.command));
+          }
+        } catch (err) {
+          result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+        return result;
+      }
+      /**
+       * Partition tool calls into parallelisable and serial groups.
+       * Inspired by Hermes Agent's path-overlap analysis.
+       *
+       * Tools are safe to parallelize when they don't share file paths
+       * and aren't in the never-parallel set (shell_exec, browser_execute).
+       */
+      _partitionToolCalls(calls) {
+        if (calls.length <= 1) return { parallel: [], serial: calls };
+        const NEVER_PARALLEL = /* @__PURE__ */ new Set(["shell_exec", "browser_execute", "credential_vault", "monitor_watch"]);
+        const parallel = [];
+        const serial = [];
+        const usedPaths = /* @__PURE__ */ new Set();
+        for (const tc of calls) {
+          if (NEVER_PARALLEL.has(tc.name)) {
+            serial.push(tc);
+            continue;
+          }
+          const paths = this._extractPaths(tc);
+          let hasOverlap = false;
+          for (const p of paths) {
+            if (usedPaths.has(p)) {
+              hasOverlap = true;
+              break;
+            }
+          }
+          if (hasOverlap) {
+            serial.push(tc);
+          } else {
+            parallel.push(tc);
+            for (const p of paths) usedPaths.add(p);
+          }
+        }
+        return { parallel, serial };
+      }
+      _extractPaths(tc) {
+        const paths = [];
+        if (tc.input.path) paths.push(String(tc.input.path));
+        if (tc.input.image_path) paths.push(String(tc.input.image_path));
+        if (tc.input.url) paths.push(String(tc.input.url));
+        return paths;
+      }
     };
   }
 });
@@ -7002,6 +7317,76 @@ var ConversationStore = class {
   }
 };
 
+// packages/daemon/src/SmartModelRouter.ts
+var COMPLEX_PATTERNS = [
+  // Code-related
+  /\b(implement|build|write|fix|refactor|debug|test|deploy|compile|lint|bundle|migrate)\b/i,
+  /\b(function|class|interface|module|component|endpoint|schema|type|hook|middleware)\b/i,
+  /\b(error|bug|crash|fail|broken|issue|stack\s*trace|exception|undefined|null)\b/i,
+  // Tool-heavy tasks
+  /\b(search|scrape|browse|download|install|create\s+file|delete|execute|run|shell|command)\b/i,
+  /\b(git|npm|pip|docker|kubectl|terraform|aws|gcp|azure)\b/i,
+  // Justdo / web tasks
+  /\b(book|file.*itr|irctc|train|ticket|flight|passport|appointment|monitor|watch|login|portal)\b/i,
+  // Long or detailed requests
+  /\b(explain|analyze|review|compare|design|plan|architect|optimise|optimize|improve)\b/i,
+  // URLs, code blocks, file paths
+  /https?:\/\//,
+  /```/,
+  /\/[\w\-]+\.[\w]+/,
+  // file paths like /foo/bar.ts
+  // Self-modification
+  /\b(yourself|agent|0agent|daemon|capability|skill)\b/i
+  // Multi-step or long messages (>200 chars likely complex)
+];
+var SIMPLE_PATTERNS = [
+  /^(hey|hi|hello|sup|yo|hola|namaste|what'?s?\s*up|how\s+are\s+you)[!?.\s,]*$/i,
+  /^(thanks|thank\s+you|thx|ok|okay|cool|great|nice|perfect|got\s+it|sure|yep|yeah|yes|no|nah)[!?.\s,]*$/i,
+  /^(bye|goodbye|see\s+ya|later|good\s*(morning|evening|afternoon|night))[!?.\s,]*$/i,
+  /^(what\s+is|who\s+is|when\s+was|where\s+is|how\s+do\s+you|what\s+does|can\s+you)\b.{0,80}$/i,
+  /^(tell\s+me\s+about|summarize|summarise|tldr|tl;dr)\b.{0,80}$/i
+];
+function routeMessage(task) {
+  const trimmed = task.trim();
+  if (trimmed.length < 5) {
+    return { decision: "skip", reason: "too short, likely noise" };
+  }
+  for (const p of SIMPLE_PATTERNS) {
+    if (p.test(trimmed)) {
+      return { decision: "fast", reason: `matches simple pattern: ${p.source.slice(0, 30)}` };
+    }
+  }
+  for (const p of COMPLEX_PATTERNS) {
+    if (p.test(trimmed)) {
+      return { decision: "primary", reason: `matches complex pattern: ${p.source.slice(0, 30)}` };
+    }
+  }
+  if (trimmed.length > 200) {
+    return { decision: "primary", reason: "long message (>200 chars)" };
+  }
+  const sentences = trimmed.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+  if (sentences.length > 2) {
+    return { decision: "primary", reason: "multi-sentence request" };
+  }
+  return { decision: "fast", reason: "short message, no complex indicators" };
+}
+function getFastModelId(provider, _currentModel) {
+  switch (provider) {
+    case "anthropic":
+      return "claude-haiku-4-5-20251001";
+    case "openai":
+      return "gpt-4o-mini";
+    case "gemini":
+      return "gemini-2.0-flash";
+    case "xai":
+      return "grok-3-mini";
+    case "groq":
+      return "llama-3.1-8b-instant";
+    default:
+      return null;
+  }
+}
+
 // packages/daemon/src/SessionManager.ts
 import { readFileSync as readFileSync7, existsSync as existsSync9 } from "node:fs";
 import { resolve as resolve8 } from "node:path";
@@ -7241,14 +7626,21 @@ var SessionManager = class {
       const activeLLM = this.getFreshLLM();
       if (activeLLM?.isConfigured) {
         const userEntityId = enrichedReq.entity_id ?? this.identity?.entity_node_id;
-        const isConversational = /^(hey|hi|hello|sup|yo|what'?s up|how are you|thanks|ok|cool|bye|good\s+(morning|evening|afternoon)|lol|nice)[!?.\s,]*$/i.test(enrichedReq.task.trim());
-        if (isConversational) {
-          const resp = await activeLLM.complete(
+        const routing = routeMessage(enrichedReq.task);
+        if (routing.decision === "skip") {
+          this.completeSession(sessionId, { output: "", files_written: [], commands_run: [], tokens_used: 0, model: "skip" });
+          return this.sessions.get(sessionId);
+        }
+        if (routing.decision === "fast") {
+          const provider = activeLLM["config"]?.provider ?? "anthropic";
+          const fastModel = getFastModelId(provider);
+          const llmToUse = fastModel ? activeLLM.withModel(fastModel) : activeLLM;
+          const resp = await llmToUse.complete(
             [{ role: "user", content: enrichedReq.task }],
-            "You are a helpful assistant."
+            this.identity ? `You are 0agent, a helpful AI assistant. You are talking to ${this.identity.name}. Be concise and friendly.` : "You are 0agent, a helpful AI assistant. Be concise and friendly."
           );
           this.emit({ type: "session.token", session_id: sessionId, token: resp.content });
-          this.addStep(sessionId, `Done (${resp.tokens_used} tokens, 1 LLM turns)`);
+          this.addStep(sessionId, `Done (${resp.tokens_used} tokens, fast model, reason: ${routing.reason})`);
           this.completeSession(sessionId, {
             output: resp.content,
             files_written: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0agent",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",