apex-dev 3.4.0 → 3.6.0

package/dist/index.js

@@ -31679,6 +31679,8 @@ var require_config = __commonJS((exports, module2) => {
   var THINKER_MODEL = "z-ai/glm4.7";
   var COMMANDER_MODEL = "nvidia/llama-3.3-nemotron-70b-instruct";
   var CONTEXT_PRUNER_MODEL = "nvidia/llama-3.3-nemotron-70b-instruct";
+  var RESEARCHER_MODEL = "nvidia/llama-3.3-nemotron-70b-instruct";
+  var GENERAL_AGENT_MODEL = "z-ai/glm4.7";
   var MAX_TOOL_ITERATIONS = 50;
   var MAX_OUTPUT_LEN = 12000;
   var TOOL_TIMEOUT = 60000;
@@ -31777,6 +31779,30 @@ Output JSON only, no markdown fences:
   "reason": "Brief explanation of why this is the best",
   "improvements": "Any good ideas from other implementations to incorporate"
 }`;
+  var RESEARCHER_WEB_SYSTEM_PROMPT = `You are a web research specialist embedded in a coding assistant. You receive web search results and synthesize them into a clear, accurate answer.
+
+Rules:
+1. Extract the most relevant information from results. Cite sources with URLs.
+2. Be specific and actionable \u2014 code examples and exact details over generic advice.
+3. If results don't contain the answer, say so clearly and share what you know from training data.
+4. Prefer recent/authoritative sources. Note when information may be outdated.
+5. Keep answers concise but thorough \u2014 developers are your audience.`;
+  var RESEARCHER_DOCS_SYSTEM_PROMPT = `You are a documentation research specialist embedded in a coding assistant. You receive documentation search results and synthesize them into a precise, practical answer.
+
+Rules:
+1. Extract exact API signatures, parameter types, return values, and defaults.
+2. Include code examples that can be used directly \u2014 prefer showing code over describing it.
+3. Note version-specific behavior when relevant.
+4. Highlight common pitfalls, gotchas, and deprecation warnings.
+5. If the docs don't cover the question, say so and provide your best guidance from training data.`;
+  var GENERAL_AGENT_SYSTEM_PROMPT = `You are a general-purpose coding agent. You receive file contents and conversation context, then produce a thorough, actionable response.
+
+Your strengths:
+1. Deep analysis \u2014 read and reason about complex codebases, trace call chains, identify patterns.
+2. Problem solving \u2014 identify root causes, suggest fixes, plan multi-step implementations.
+3. Code generation \u2014 write complete, working code that matches existing project conventions.
+
+Be direct and comprehensive. Provide actual solutions, not descriptions of what to do. If you identify issues or risks, flag them clearly with severity.`;
   var nvidiaClient = new OpenAI({
     apiKey: process.env.NVIDIA_API_KEY || "",
     baseURL: "https://integrate.api.nvidia.com/v1"
@@ -31821,6 +31847,8 @@ Output JSON only, no markdown fences:
     THINKER_MODEL,
     COMMANDER_MODEL,
     CONTEXT_PRUNER_MODEL,
+    RESEARCHER_MODEL,
+    GENERAL_AGENT_MODEL,
     MAX_TOOL_ITERATIONS,
     MAX_OUTPUT_LEN,
     TOOL_TIMEOUT,
@@ -31832,6 +31860,9 @@ Output JSON only, no markdown fences:
     COMMANDER_SYSTEM_PROMPT,
     CONTEXT_PRUNER_SYSTEM_PROMPT,
     SELECTOR_SYSTEM_PROMPT,
+    RESEARCHER_WEB_SYSTEM_PROMPT,
+    RESEARCHER_DOCS_SYSTEM_PROMPT,
+    GENERAL_AGENT_SYSTEM_PROMPT,
     nvidiaClient,
     session,
     truncateOutput,
@@ -31879,15 +31910,16 @@ Scripts: ${Object.keys(pkg.scripts).join(", ")}`;
 
 # Core Mandates
 
-- **Tone:** Professional, direct, and concise. Suitable for a CLI environment.
 - **Understand first, act second:** Always gather context and read relevant files BEFORE editing. Use sub-agents (FilePickerMax, Grep, Read) to verify assumptions before implementing.
 - **Quality over speed:** Prioritize correctness over appearing productive. Fewer, well-informed sub-agent calls are better than many rushed ones.
+- **Tone:** Professional, direct, and concise. Suitable for a CLI environment.
 - **Validate assumptions:** Use FilePickerMax and Read to verify assumptions about libraries, APIs, and project structure before implementing.
 - **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
 - **Confirm ambiguity:** Do not take significant actions beyond the clear scope of the request without confirming. If asked *how* to do something, explain first, don't just do it.
 - **Do what the user asks:** If the user asks you to do something, even running a risky command, do it.
 - **If a tool fails, try again or try a different tool.** Don't give up after one attempt.
 - **Act on errors.** If the user pastes an error or stack trace, locate the source, identify root cause, and fix it. Never punt back with "try checking X."
+- **Use <think></think> tags for moderate reasoning.** Call the Thinker sub-agent for anything more complex.
 
 # Output Style
 - Default to short answers (\u22644 lines) unless the user asks for detail.
@@ -31896,7 +31928,6 @@ Scripts: ${Object.keys(pkg.scripts).join(", ")}`;
 - No emojis unless the user uses them first.
 - For casual conversation, greetings, or quick questions, respond naturally without tools.
 - NEVER say "I don't have any tool to call" \u2014 just respond with what you know.
-- Use <think></think> tags for moderate reasoning. Call the Thinker sub-agent for anything more complex.
 
 # Code Editing Mandates
 
@@ -31918,45 +31949,77 @@ Scripts: ${Object.keys(pkg.scripts).join(", ")}`;
 
 You have specialized sub-agents available as tools. **Your strong default should be to delegate to sub-agents** for anything beyond trivially simple operations. Sub-agents are specialists \u2014 they produce better, more thorough results than you chaining basic tools manually.
 
-**Available sub-agents:**
-- **FilePickerMax** \u2014 Scans the full codebase to find files relevant to a prompt. Use instead of manually chaining Glob/Grep/ListDir. Always specify the exact type of files needed \u2014 NEVER send generic prompts.
+## Available Sub-Agents
+
+**Context Gathering:**
+- **FilePickerMax** \u2014 Scans the full codebase to find files relevant to a prompt. Use instead of manually chaining Glob/Grep/ListDir. Always specify the exact type of files needed \u2014 NEVER send generic prompts. Spawn 2-5 of these in parallel for different aspects of the codebase.
+- **ResearcherWeb** \u2014 Searches the web and synthesizes results with an LLM. Use when you need up-to-date information, best practices, or answers that may not be in your training data. Falls back to LLM knowledge if web search is unavailable.
+- **ResearcherDocs** \u2014 Searches technical documentation for a library/framework and synthesizes a precise answer. Use when you need to verify API signatures, find usage patterns, or check library behavior.
+
+**Reasoning & Planning:**
 - **Thinker** \u2014 Deep reasoning and planning. Call before implementing anything non-trivial to get a structured plan.
-- **ThinkerBestOfN** \u2014 Multiple parallel reasoning passes, selects the best. Use for critical decisions.
+- **ThinkerBestOfN** \u2014 Multiple parallel reasoning passes, selects the best. Use for critical decisions that benefit from diverse perspectives.
+- **GeneralAgent** \u2014 Independent agent that reads specified files and solves problems. More powerful than Thinker because it receives actual file contents. Use when you need deep independent analysis, complex reasoning with full file context, or a second opinion.
+
+**Implementation:**
+- **EditorMultiPrompt** \u2014 Tries multiple implementation strategies in parallel, selects the best, and **auto-applies the changes**. Use for important code changes where you want to explore multiple approaches.
 - **Commander** \u2014 Terminal command specialist. Plans and executes shell commands for a goal. Use instead of calling Bash directly for multi-step operations.
-- **EditorMultiPrompt** \u2014 Tries multiple implementation strategies in parallel, selects the best.
-- **CodeReview** \u2014 Reviews code changes for bugs, security, edge cases. Runs automatically after edits.
-- **CodeReviewMulti** \u2014 Multiple reviewers analyze from different perspectives.
+
+**Review & Maintenance:**
+- **CodeReview** / **CodeReviewMulti** \u2014 Reviews code changes for bugs, security, edge cases. CodeReviewMulti runs automatically after edits.
 - **ContextPruner** \u2014 Summarizes conversation history to free context space.
 
-**How to orchestrate (use your judgment):**
-1. Spawn context-gathering sub-agents first (FilePickerMax, Read) to understand the codebase before making edits.
-2. For complex problems, call Thinker to reason and plan before implementing.
-3. Call Commander for shell operations (builds, tests, installs, git) instead of Bash directly.
-4. After implementing changes, validate by running tests/builds/lints via Commander.
-5. A code reviewer runs automatically after edits (skipped in lite mode, multi-perspective in max mode).
-6. If a sub-agent fails, fall back to doing the work yourself with basic tools (Read, Edit, Bash, Grep, etc.).
-7. Bundle independent sub-agent calls in the same turn for parallel execution.
+## How to Orchestrate (use your judgment)
 
-**When to skip sub-agents and act directly:**
+**Phase 1 \u2014 Context Gathering:**
+- Spawn multiple FilePickerMax in parallel for different aspects of the codebase (e.g. one for "entry points and routing", one for "authentication files", one for "test files").
+- Use Read to read all relevant files. For complex tasks, read 12-20 files to build a thorough understanding.
+- Use ResearcherWeb/ResearcherDocs when you need external information about libraries or APIs.
+- Bundle independent context-gathering calls in the same turn for parallel execution.
+
+**Phase 2 \u2014 Planning:**
+- For tasks requiring 3+ steps, use TodoList to write out a step-by-step plan.
+- Call Thinker (or ThinkerBestOfN for critical decisions) to reason about the approach.
+- Call GeneralAgent when you need independent deep analysis with file context.
+
+**Phase 3 \u2014 Implementation:**
+- Use EditorMultiPrompt for non-trivial code changes \u2014 it tries multiple strategies and auto-applies the best result.
+- For trivially simple edits on already-read files, use Edit or Patch directly.
+- Use Write only for creating new files.
+
+**Phase 4 \u2014 Validation:**
+- After code changes, run the most relevant checks: tests, lint, typecheck, or build.
+- Use Commander for multi-step validation. Use Bash for single commands.
+- If checks fail, fix and re-run. If blocked, clearly state what's failing.
+
+**Phase 5 \u2014 Review:**
+- CodeReviewMulti runs automatically after edits \u2014 don't duplicate its work.
+- If the review finds issues, fix them and re-validate.
+
+## When to Skip Sub-Agents and Act Directly
 - Reading a single known file path (just use Read)
 - A single targeted grep for a known pattern (just use Grep)
 - A quick one-line bash command (just use Bash)
 - Answering a question from memory/context (just respond)
 - Trivially simple edits where the file is already read and understood
 
+## Parallel Execution Rules
+- Bundle independent tool calls in the same turn \u2014 this is critical for speed.
+- Spawn multiple FilePickerMax simultaneously for different aspects of the codebase.
+- Run independent Read calls in parallel.
+- **Don't spawn dependent agents in parallel** \u2014 e.g. don't spawn EditorMultiPrompt at the same time as FilePickerMax, since editing depends on context.
+- After implementation, run tests AND typechecks in parallel.
+
 # Tool Usage (basic tools)
-- Use Read to understand files before modifying them.
+- Use Read to understand files before modifying them. NEVER modify a file you haven't read.
 - Use Edit for surgical changes to existing files (preferred over Write).
 - Use Patch for multiple edits to the same file.
 - Use Write only for creating new files.
 - Use Bash for simple, single commands. Use Commander for multi-step operations.
 - Use Grep/Glob/ListDir for quick, targeted lookups. Use FilePickerMax for broad codebase discovery.
+- Use TodoList to track multi-step plans.
 - Don't ask for permission to use tools \u2014 just use them.
 
-# Validation
-- After code changes, run the most relevant checks: tests, lint, typecheck, or build. Prefer Commander or scripts from package.json.
-- If checks fail, fix and re-run. If blocked, clearly state what's failing and why.
-
 # Environment
 Working directory: ${PROJECT_ROOT}
 OS: ${process.platform}
@@ -32297,6 +32360,59 @@ var require_tools = __commonJS((exports, module2) => {
           required: []
         }
       }
+    },
+    {
+      type: "function",
+      function: {
+        name: "ResearcherWeb",
+        description: "Search the web and synthesize results into a clear answer using an LLM. Use when you need up-to-date information, best practices, or answers that may not be in your training data. Falls back to LLM knowledge if web search is unavailable.",
+        parameters: {
+          type: "object",
+          properties: {
+            prompt: { type: "string", description: "The question to research. Be specific for better results." },
+            domains: {
+              type: "array",
+              description: 'Optional list of domains to restrict search to (e.g. ["stackoverflow.com", "github.com"]).',
+              items: { type: "string" }
+            }
+          },
+          required: ["prompt"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "ResearcherDocs",
+        description: "Search technical documentation for a library or framework and synthesize a precise answer with API details and code examples. Use when you need to verify API signatures, find usage patterns, or check library behavior.",
+        parameters: {
+          type: "object",
+          properties: {
+            prompt: { type: "string", description: "The documentation question. Include the library/framework name and version if relevant." },
+            library: { type: "string", description: 'The library or framework name (e.g. "React", "Express", "Prisma").' }
+          },
+          required: ["prompt"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "GeneralAgent",
+        description: "Spawn an independent general-purpose agent that reads specified files and solves a problem. Use when you need deep independent analysis, complex reasoning with full file context, or a second opinion. More powerful than Thinker because it receives actual file contents.",
+        parameters: {
+          type: "object",
+          properties: {
+            prompt: { type: "string", description: "The problem to solve. Be specific about what analysis or output you need." },
+            filePaths: {
+              type: "array",
+              description: "File paths to read and provide as context. The agent will analyze these files to solve the problem.",
+              items: { type: "string" }
+            }
+          },
+          required: ["prompt"]
+        }
+      }
     }
   ];
   module2.exports = { toolDefs };
@@ -32322,6 +32438,11 @@ var require_toolExecutors = __commonJS((exports, module2) => {
     CONTEXT_PRUNER_MODEL,
     CONTEXT_PRUNER_SYSTEM_PROMPT,
     SELECTOR_SYSTEM_PROMPT,
+    RESEARCHER_MODEL,
+    GENERAL_AGENT_MODEL,
+    RESEARCHER_WEB_SYSTEM_PROMPT,
+    RESEARCHER_DOCS_SYSTEM_PROMPT,
+    GENERAL_AGENT_SYSTEM_PROMPT,
     NVIDIA_MODEL,
     nvidiaClient,
     session,
@@ -32361,6 +32482,35 @@ var require_toolExecutors = __commonJS((exports, module2) => {
       }
     }
   }
+  function parseEditorOps(text) {
+    const ops = [];
+    const editRe = /---\s*EDIT:\s*(.+?)\s*---[\s\S]*?OLD:\s*\n```[^\n]*\n([\s\S]*?)\n```[\s\S]*?NEW:\s*\n```[^\n]*\n([\s\S]*?)\n```/g;
+    let m2;
+    while ((m2 = editRe.exec(text)) !== null) {
+      ops.push({ type: "edit", path: m2[1].trim(), old_str: m2[2], new_str: m2[3] });
+    }
+    const createRe = /---\s*CREATE:\s*(.+?)\s*---\s*\n```[^\n]*\n([\s\S]*?)\n```/g;
+    while ((m2 = createRe.exec(text)) !== null) {
+      const p = m2[1].trim();
+      if (!ops.some((o) => o.path === p && o.type === "edit")) {
+        ops.push({ type: "create", path: p, content: m2[2] });
+      }
+    }
+    return ops;
+  }
+  async function applyEditorOps(ops, executeFn) {
+    const results = [];
+    for (const op of ops) {
+      if (op.type === "edit") {
+        const r = await executeFn("Edit", { path: op.path, old_str: op.old_str, new_str: op.new_str });
+        results.push(r.startsWith("Error") ? `\u2717 Edit ${op.path}: ${r}` : `\u2713 Edit ${op.path}`);
+      } else if (op.type === "create") {
+        const r = await executeFn("Write", { path: op.path, content: op.content });
+        results.push(r.startsWith("Error") ? `\u2717 Create ${op.path}: ${r}` : `\u2713 Create ${op.path}`);
+      }
+    }
+    return results;
+  }
   async function executeTool(name, args, onStream) {
     try {
       switch (name) {
@@ -33049,17 +33199,37 @@ Reason: ${reason}`;
             if (improvements)
               result += `
 Improvements to consider: ${improvements}`;
-            result += `
+            const ops = parseEditorOps(winning.result);
+            if (ops.length > 0) {
+              if (onStream)
+                onStream(truncateOutput(result + `
+
+Applying ${ops.length} change(s)...`));
+              const applyResults = await applyEditorOps(ops, executeTool);
+              result += `
+
+--- Applied Changes ---
+${applyResults.join(`
+`)}`;
+            } else {
+              result += `
 
 ${winning.result}`;
+            }
             if (onStream)
               onStream(truncateOutput(result));
             return truncateOutput(result);
           } catch (apiErr) {
-            const result = `${header}Selector failed, using Implementation A:
+            const fallbackOps = parseEditorOps(implementations[0].result);
+            if (fallbackOps.length > 0) {
+              const applyResults = await applyEditorOps(fallbackOps, executeTool);
+              return truncateOutput(`${header}Selector failed, applied Implementation A:
+${applyResults.join(`
+`)}`);
+            }
+            return truncateOutput(`${header}Selector failed, using Implementation A:
 
-${implementations[0].result}`;
-            return truncateOutput(result);
+${implementations[0].result}`);
           }
         }
         case "CodeReviewMulti": {
@@ -33242,6 +33412,187 @@ ${summary}`;
             return `Error: Context pruning failed \u2014 ${apiErr.message}`;
           }
         }
+        case "ResearcherWeb": {
+          const header = `Web Research (${RESEARCHER_MODEL})
+${"\u2500".repeat(40)}
+`;
+          if (onStream)
+            onStream(header + "Searching the web...");
+          let searchResults = "";
+          const searchArgs = { query: args.prompt, num_results: 5 };
+          if (args.domains && args.domains.length)
+            searchArgs.include_domains = args.domains;
+          try {
+            searchResults = await executeTool("WebSearch", searchArgs);
+          } catch {
+            searchResults = "(Web search unavailable \u2014 answering from knowledge)";
+          }
+          if (searchResults.startsWith("Error")) {
+            searchResults = `(Web search failed: ${searchResults.slice(0, 200)})
+
+Please answer from your training data.`;
+          }
+          try {
+            const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
+            const result = await streamCompletion({
+              model: RESEARCHER_MODEL,
+              messages: [
+                { role: "system", content: RESEARCHER_WEB_SYSTEM_PROMPT },
+                { role: "user", content: `# Question
+${args.prompt}
+
+# Web Search Results
+${searchResults}` }
+              ],
+              max_tokens: 4096,
+              temperature: 0.3
+            }, streamCb) || "(No response from researcher)";
+            return truncateOutput(header + result);
+          } catch (apiErr) {
+            return `Error: ResearcherWeb failed \u2014 ${apiErr.message}`;
+          }
+        }
+        case "ResearcherDocs": {
+          const header = `Docs Research (${RESEARCHER_MODEL})
+${"\u2500".repeat(40)}
+`;
+          if (onStream)
+            onStream(header + "Searching documentation...");
+          const docDomains = [
+            "developer.mozilla.org",
+            "react.dev",
+            "nodejs.org",
+            "docs.python.org",
+            "doc.rust-lang.org",
+            "pkg.go.dev",
+            "learn.microsoft.com",
+            "typescriptlang.org",
+            "expressjs.com",
+            "nextjs.org",
+            "vuejs.org",
+            "angular.io",
+            "svelte.dev",
+            "docs.rs",
+            "rubydoc.info",
+            "docs.oracle.com",
+            "npmjs.com"
+          ];
+          const query = args.library ? `${args.library} ${args.prompt}` : args.prompt;
+          let searchResults = "";
+          try {
+            searchResults = await executeTool("WebSearch", {
+              query: `${query} documentation`,
+              num_results: 8,
+              include_domains: docDomains
+            });
+          } catch {
+            searchResults = "";
+          }
+          if (!searchResults || searchResults === "No results found.") {
+            try {
+              searchResults = await executeTool("WebSearch", {
+                query: `${query} documentation API reference`,
+                num_results: 5
+              });
+            } catch {
+              searchResults = "(Documentation search unavailable \u2014 answering from knowledge)";
+            }
+          }
+          if (!searchResults || searchResults.startsWith("Error")) {
+            searchResults = "(No documentation results found \u2014 answering from knowledge)";
+          }
+          try {
+            const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
+            const result = await streamCompletion({
+              model: RESEARCHER_MODEL,
+              messages: [
+                { role: "system", content: RESEARCHER_DOCS_SYSTEM_PROMPT },
+                {
+                  role: "user",
+                  content: `# Question
+${args.prompt}${args.library ? `
+Library: ${args.library}` : ""}
+
+# Documentation Search Results
+${searchResults}`
+                }
+              ],
+              max_tokens: 4096,
+              temperature: 0.2
+            }, streamCb) || "(No response from researcher)";
+            return truncateOutput(header + result);
+          } catch (apiErr) {
+            return `Error: ResearcherDocs failed \u2014 ${apiErr.message}`;
+          }
+        }
+        case "GeneralAgent": {
+          const header = `General Agent (${GENERAL_AGENT_MODEL})
+${"\u2500".repeat(40)}
+`;
+          if (onStream)
+            onStream(header + "Reading files and analyzing...");
+          const MAX_TOTAL_CHARS = 50000;
+          let totalChars = 0;
+          const fileContents = [];
+          for (const fp of args.filePaths || []) {
+            const absPath = resolvePath(fp);
+            const stat = fs2.statSync(absPath, { throwIfNoEntry: false });
+            if (!stat || stat.isDirectory()) {
+              fileContents.push(`--- ${fp} ---
+[Not found or is a directory]`);
+              continue;
+            }
+            if (stat.size > 256 * 1024) {
+              fileContents.push(`--- ${fp} ---
+[File too large: ${(stat.size / 1024).toFixed(0)}KB \u2014 skipped]`);
+              continue;
+            }
+            const content = fs2.readFileSync(absPath, "utf-8");
+            if (totalChars + content.length > MAX_TOTAL_CHARS) {
+              const remaining = MAX_TOTAL_CHARS - totalChars;
+              if (remaining > 500) {
+                fileContents.push(`--- ${fp} ---
+${content.slice(0, remaining)}
+[Truncated \u2014 context limit reached]`);
+              }
+              totalChars = MAX_TOTAL_CHARS;
+              break;
+            }
+            fileContents.push(`--- ${fp} ---
+${content}`);
+            totalChars += content.length;
+          }
+          const historyCtx = session.conversationHistory.slice(-8).map((m2) => `[${m2.role}]: ${(m2.content || "").slice(0, 400)}`).join(`
+`);
+          const userContent = [
+            `# Task
+${args.prompt}`,
+            fileContents.length > 0 ? `
+# Files (${fileContents.length})
+${fileContents.join(`
+
+`)}` : "",
+            historyCtx ? `
+# Recent conversation
+${historyCtx}` : ""
+          ].filter(Boolean).join(`
+`);
+          try {
+            const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
+            const result = await streamCompletion({
+              model: GENERAL_AGENT_MODEL,
+              messages: [
+                { role: "system", content: GENERAL_AGENT_SYSTEM_PROMPT },
+                { role: "user", content: userContent }
+              ],
+              max_tokens: 4096,
+              temperature: 0.4
+            }, streamCb) || "(No response from agent)";
+            return truncateOutput(header + result);
+          } catch (apiErr) {
+            return `Error: GeneralAgent failed \u2014 ${apiErr.message}`;
+          }
+        }
         default:
           return `Unknown tool: ${name}`;
       }
@@ -33298,6 +33649,16 @@ var require_utils3 = __commonJS((exports, module2) => {
         return args.prompt ? args.prompt.slice(0, 40) : "running commands";
       case "ContextPruner":
         return "pruning context";
+      case "ResearcherWeb":
+        return args.prompt ? args.prompt.slice(0, 40) : "web research";
+      case "ResearcherDocs":
+        return args.prompt ? `${args.library ? args.library + ": " : ""}${args.prompt.slice(0, 30)}` : "docs research";
+      case "GeneralAgent":
+        return args.prompt ? args.prompt.slice(0, 40) : "analyzing";
+      case "WebSearch":
+        return args.query ? args.query.slice(0, 40) : "searching";
+      case "TodoList":
+        return args.action || "";
       default:
         return JSON.stringify(args).slice(0, 60);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apex-dev",
-  "version": "3.4.0",
+  "version": "3.6.0",
   "description": "Apex AI - a friendly agentic coding assistant for the terminal",
   "main": "dist/index.js",
   "bin": {