tachibot-mcp 2.19.2 → 2.21.0

package/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to TachiBot MCP will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.19.3] - 2026-03-21
+
+### Fixed
+- **Section header regex** — now matches mixed case + optional dashes (works across all providers, not just Gemini)
+- **Planner 5/1 bug** — `parsePlanSteps` now matches `### Task [T-ID]:` format (was only matching `### Step N:`)
+- **Planner mismatch warning** — surfaces parse failures instead of masking with `Math.max`
+
 ## [2.19.2] - 2026-03-21
 
 ### Added

package/dist/src/collaborative-orchestrator.js

@@ -4,6 +4,7 @@ import { sessionLogger } from "./session/session-logger.js";
 import { sessionManager } from "./session/session-manager.js";
 import { ToolRouter } from "./tools/tool-router.js";
 import { getMemoryManager } from "./memory/index.js";
+import { GROK_MODELS } from "./config/model-constants.js";
 import { VisualizationService } from "./orchestrators/collaborative/services/visualization/VisualizationService.js";
 import { ToolExecutionService } from "./orchestrators/collaborative/services/tool-execution/ToolExecutionService.js";
 export class CollaborativeOrchestrator {
@@ -229,12 +230,11 @@ export class CollaborativeOrchestrator {
         this.modelPreferences = { ...this.modelPreferences, ...preferences };
     }
     /**
-     * Use Grok 4 Heavy for all Grok operations
+     * Use Grok 4.20 Multi-Agent for all Grok operations
      */
     useGrok4Heavy() {
-        // Use GROK_4_0709 as the "heavy" model (reasoning model)
-        this.modelPreferences['grok'] = 'grok-4-0709';
-        this.modelPreferences['grok-4'] = 'grok-4-0709';
+        this.modelPreferences['grok'] = GROK_MODELS._4_20_MULTI_AGENT;
+        this.modelPreferences['grok-4'] = GROK_MODELS._4_20_MULTI_AGENT;
     }
     /**
      * Generate session ID

package/dist/src/config/model-constants.js

@@ -59,10 +59,14 @@ export const PERPLEXITY_MODELS = {
     SONAR_PRO: "sonar-pro", // Advanced search
     SONAR_REASONING: "sonar-reasoning-pro", // Reasoning model (expensive - avoid)
 };
-// Grok Models (xAI) - Updated 2025-11-22 with correct API model names
+// Grok Models (xAI) - Updated 2026-04-10 with Grok 4.20 (Mar 2026)
 export const GROK_MODELS = {
-    // Grok 4.1 models (Nov 2025) - LATEST & BEST
-    _4_1_FAST_REASONING: "grok-4-1-fast-reasoning", // Latest: 2M context, $0.20/$0.50, enhanced reasoning
+    // Grok 4.20 models (Mar 10, 2026) - FLAGSHIP
+    _4_20_REASONING: "grok-4.20-0309-reasoning", // Flagship: 2M context, $2/$6, low hallucination
+    _4_20_NON_REASONING: "grok-4.20-0309-non-reasoning", // Standard: 2M context, $2/$6
+    _4_20_MULTI_AGENT: "grok-4.20-multi-agent-0309", // Multi-agent: 4-16 agents via reasoning.effort, $2/$6
+    // Grok 4.1 fast models (Nov 2025) - BEST VALUE (10x cheaper)
+    _4_1_FAST_REASONING: "grok-4-1-fast-reasoning", // Fast reasoning: 2M context, $0.20/$0.50
     _4_1_FAST_NON_REASONING: "grok-4-1-fast-non-reasoning", // Tool-calling optimized: 2M context, $0.20/$0.50
     // Grok 4 fast models (2025) - Still good
     CODE_FAST: "grok-code-fast-1", // Coding specialist: 256K→2M, $0.20/$1.50, 92 tok/sec
@@ -153,12 +157,12 @@ export const CURRENT_MODELS = {
         premium: OPENAI_MODELS.PRO, // Expert mode (gpt-5.4-pro - higher compute)
     },
     grok: {
-        reason: GROK_MODELS._4_1_FAST_REASONING,
-        code: GROK_MODELS._4_1_FAST_NON_REASONING,
-        debug: GROK_MODELS._4_1_FAST_NON_REASONING,
-        brainstorm: GROK_MODELS._4_1_FAST_REASONING,
-        search: GROK_MODELS._4_1_FAST_REASONING,
-        architect: GROK_MODELS._4_1_FAST_REASONING,
+        reason: GROK_MODELS._4_20_REASONING, // grok-4.20-0309-reasoning (flagship, low hallucination)
+        code: GROK_MODELS._4_20_NON_REASONING, // grok-4.20 non-reasoning (flagship quality, tool-calling)
+        debug: GROK_MODELS._4_20_NON_REASONING, // grok-4.20 non-reasoning (low hallucination for debugging)
+        brainstorm: GROK_MODELS._4_20_NON_REASONING, // grok-4.20-0309-non-reasoning (2M context)
+        search: GROK_MODELS._4_20_REASONING, // grok-4.20 LOW HALLUCINATION - critical for search
+        architect: GROK_MODELS._4_20_MULTI_AGENT, // grok-4.20-multi-agent-0309 (4-16 agent swarm)
     },
     gemini: {
         default: GEMINI_MODELS.GEMINI_3_PRO,
@@ -331,6 +335,9 @@ export const MODEL_DISPLAY_NAMES = {
     "gemini-3-flash-preview": "gemini-3-flash",
     "gemini-3.1-flash-lite": "gemini-3.1-flash-lite",
     // Grok (xAI)
+    "grok-4.20-0309-reasoning": "grok-4.20",
+    "grok-4.20-0309-non-reasoning": "grok-4.20-fast",
+    "grok-4.20-multi-agent-0309": "grok-4.20-multi",
     "grok-4-1-fast-reasoning": "grok-4.1",
     "grok-4-1-fast-non-reasoning": "grok-4.1-fast",
     "grok-4-fast-reasoning": "grok-4",
@@ -370,7 +377,10 @@ export const MODEL_PRICING = {
     "gemini-3.1-pro-preview": 0.007, // ($2 + $12) / 2 / 1000
     "gemini-3-flash-preview": 0.00175, // ($0.50 + $3) / 2 / 1000
     "gemini-3.1-flash-lite": 0.001, // Cheapest/fastest in 3.1 series (Mar 2026)
-    // Grok - all cheap!
+    // Grok
+    "grok-4.20-0309-reasoning": 0.004, // ($2 + $6) / 2 / 1000
+    "grok-4.20-0309-non-reasoning": 0.004, // ($2 + $6) / 2 / 1000
+    "grok-4.20-multi-agent-0309": 0.004, // ($2 + $6) / 2 / 1000
     "grok-4-1-fast-reasoning": 0.00035,
     "grok-4-1-fast-non-reasoning": 0.00035,
     "grok-4-fast-reasoning": 0.00035,

package/dist/src/config/model-defaults.js

@@ -21,7 +21,7 @@ const MODELS = {
     OPENAI: OPENAI_MODELS.THINKING, // gpt-5.4 (default - most capable)
     OPENAI_REASON: OPENAI_MODELS.THINKING, // gpt-5.4 (deep reasoning)
     // xAI Grok
-    GROK: GROK_MODELS._4_1_FAST_REASONING, // grok-4-1-fast-reasoning
+    GROK: GROK_MODELS._4_20_REASONING, // grok-4.20-0309-reasoning
     // Perplexity
     PERPLEXITY: PERPLEXITY_MODELS.SONAR, // sonar (cheapest)
     PERPLEXITY_REASON: PERPLEXITY_MODELS.SONAR_REASONING, // sonar-reasoning-pro ($2/$8 per M)

package/dist/src/config/timeout-config.js

@@ -112,12 +112,12 @@ export const SMART_TIMEOUT_DEFAULTS = {
             max: 90000 // 90 seconds
         },
         grok: {
-            base: 30000, // 30 seconds
-            max: 90000 // 90 seconds
+            base: 30000, // 30 seconds - 4.1 fast models are quick
+            max: 120000 // 2 minutes - 4.20 reasoning models need more
         },
         openai: {
-            base: 20000, // 20 seconds
-            max: 60000 // 60 seconds
+            base: 60000, // 60 seconds - GPT-5.4 reasoning needs more time
+            max: 180000 // 3 minutes - high/xhigh reasoning effort
         },
         anthropic: {
             base: 20000, // 20 seconds

package/dist/src/config.js

@@ -128,7 +128,7 @@ export function getAvailableModels(config) {
         models.push('sonar-pro', 'sonar-reasoning-pro', 'sonar-deep-research');
     }
     if (config.apiKeys.grok) {
-        models.push('grok-3', 'grok-3-fast', 'grok-4-0709');
+        models.push('grok-3', 'grok-4.20-0309-reasoning', 'grok-4.20-multi-agent-0309');
     }
     if (config.apiKeys.openrouter) {
         models.push('qwen3-coder', 'qwq-32b', 'qwen3-32b');

package/dist/src/modes/architect.js

@@ -17,8 +17,8 @@ export class Architect {
             },
             specialized_verification: {
                 models: {
-                    'syntax_error': 'gpt-4-mini',
-                    'type_error': 'gpt-4-mini',
+                    'syntax_error': 'gpt-5.4-mini',
+                    'type_error': 'gpt-5.4-mini',
                     'algorithmic_complexity': 'qwq-32b',
                     'performance_issue': 'qwq-32b',
                     'architectural_smell': 'claude-opus-4.1',
@@ -28,7 +28,7 @@ export class Architect {
                     'design_pattern_violation': 'claude-opus-4.1',
                     'memory_leak': 'qwq-32b',
                     'race_condition': 'claude-opus-4.1',
-                    'code_duplication': 'gpt-4-mini',
+                    'code_duplication': 'gpt-5.4-mini',
                     'circular_dependency': 'claude-opus-4.1'
                 },
                 dynamicTokens: {
@@ -269,7 +269,7 @@ export class Architect {
             'claude-opus-4.1': 10,
             'qwq-32b': 8,
             'perplexity-reasoning': 7,
-            'gpt-4-mini': 5
+            'gpt-5.4-mini': 5
         };
         return priorities[model] || 5;
     }

package/dist/src/modes/scout.js

@@ -1,5 +1,6 @@
 import { ModelRouter } from '../workflows/model-router.js';
 import { getScoutModels, getDefaultModels } from '../config/model-defaults.js';
+import { GROK_MODELS } from '../config/model-constants.js';
 import { getGrokApiKey } from '../utils/api-keys.js';
 import { createProgressStream } from '../utils/progress-stream.js';
 import { providerRouter } from '../utils/provider-router.js';
@@ -530,7 +531,7 @@ export class Scout {
             const { callGrokEnhanced } = await import('../tools/grok-enhanced.js');
             const messages = [{ role: 'user', content: query }];
             const result = await callGrokEnhanced(messages, {
-                model: 'grok-4-0709',
+                model: GROK_MODELS._4_20_REASONING,
                 maxTokens,
                 enableLiveSearch: options?.enableLiveSearch ?? true,
                 searchSources: options?.maxSources ?? 100,

package/dist/src/optimization/cost-monitor.js

@@ -56,7 +56,7 @@ export class CostMonitor extends EventEmitter {
                 "claude-3.5-sonnet",
                 { model: "claude-3.5-sonnet", inputCost: 0.003, outputCost: 0.015 },
             ],
-            ["grok-4", { model: "grok-4", inputCost: 0.005, outputCost: 0.015 }],
+            ["grok-4.20-0309-reasoning", { model: "grok-4.20-0309-reasoning", inputCost: 0.002, outputCost: 0.006 }],
         ]);
         // Clean up old records periodically
         setInterval(() => this.cleanupOldRecords(), 60 * 60 * 1000); // Every hour

package/dist/src/orchestrators/collaborative/registries/ModelProviderRegistry.js

@@ -82,7 +82,7 @@ modelProviderRegistry.registerMany([
     { modelName: "qwq", toolName: "qwq_reason", provider: "openrouter" },
     // Grok models
     { modelName: "grok", toolName: "grok_reason", provider: "x.ai" },
-    { modelName: "grok-4", toolName: "grok_reason", provider: "x.ai", aliases: ["grok-4-0709"] },
+    { modelName: "grok-4.20", toolName: "grok_reason", provider: "x.ai", aliases: ["grok-4.20-0309-reasoning", "grok-4.20-multi-agent-0309"] },
     // Claude models
     { modelName: "claude", toolName: "think", provider: "anthropic", aliases: ["claude-code", "reasoning", "analysis"] },
     // Gemini models (all use gemini-3.1-pro-preview for RAW POWER)

package/dist/src/server.js

@@ -75,6 +75,7 @@ import { isGeminiAvailable, geminiBrainstormTool, geminiAnalyzeCodeTool } from "
 import { isOpenRouterAvailable } from "./tools/openrouter-tools.js";
 import { getTachiTools } from "./tools/tachi-tool.js";
 import { getPromptTechniqueTools } from "./tools/prompt-technique-tools.js";
+import { withParamAliases } from "./utils/param-aliases.js";
 // import { registerGPT5Tools, isGPT5Available } from "./tools/openai-gpt5-fixed.js"; // DISABLED - using regular openai-tools.ts
 import { initializeOptimizations } from "./optimization/index.js";
 import { FocusModeRegistry } from "./application/services/focus/FocusModeRegistry.js";
@@ -117,6 +118,9 @@ function safeAddTool(tool) {
     if (!isToolEnabled(tool.name)) {
         return; // Skip disabled tools silently (logging handled by isToolEnabled)
     }
+    // Auto-alias common param names (query/problem/prompt/question/topic)
+    // so LLMs can use any synonym and the tool still works
+    tool = withParamAliases(tool);
     if (!registeredTools.has(tool.name)) {
         // Wrap execute with usage tracking
         const originalExecute = tool.execute;

package/dist/src/tools/grok-enhanced.js

@@ -19,23 +19,9 @@ config({ path: path.resolve(__dirname, '../../../.env') });
 const GROK_API_KEY = getGrokApiKey();
 const GROK_API_URL = "https://api.x.ai/v1/chat/completions";
 const GROK_RESPONSES_URL = "https://api.x.ai/v1/responses"; // New Agent Tools API endpoint (Jan 2025)
-// Grok models - Updated 2025-11-22 with correct API model names
-export var GrokModel;
-(function (GrokModel) {
-    // Grok 4.1 models (Nov 2025) - LATEST & BEST (verified working)
-    GrokModel["GROK_4_1_FAST_REASONING"] = "grok-4-1-fast-reasoning";
-    GrokModel["GROK_4_1_FAST"] = "grok-4-1-fast-non-reasoning";
-    // Grok 4 fast models (2025) - Still good
-    GrokModel["CODE_FAST"] = "grok-code-fast-1";
-    GrokModel["GROK_4_FAST_REASONING"] = "grok-4-fast-reasoning";
-    GrokModel["GROK_4_FAST"] = "grok-4-fast-non-reasoning";
-    // Expensive/specialized (use sparingly)
-    GrokModel["GROK_4_HEAVY"] = "grok-4-0709";
-    GrokModel["GROK_3"] = "grok-3";
-    // Beta/experimental (deprecated)
-    GrokModel["GROK_BETA"] = "grok-beta";
-    GrokModel["GROK_VISION_BETA"] = "grok-vision-beta";
-})(GrokModel || (GrokModel = {}));
+// Unified GrokModel enum - single source of truth in grok-tools.ts
+import { GrokModel } from './grok-tools.js';
+export { GrokModel };
 /**
  * Enhanced Grok API call with live search support
  */
@@ -45,7 +31,7 @@ export async function callGrokEnhanced(messages, options = {}) {
             content: `[Grok API key not configured. Add GROK_API_KEY or XAI_API_KEY to .env file]`
         };
     }
-    const { model = GrokModel.GROK_4_1_FAST_REASONING, // Updated 2025-11-22: Use latest Grok 4.1 by default
+    const { model = GrokModel.GROK_4_20_REASONING, // Updated: Use Grok 4.20 by default
     temperature = 0.7, maxTokens = options.useHeavy ? 100000 : 4000, enableLiveSearch = false, searchSources = 100, // Default to 100 sources for cost control
     searchDomains = [], structuredOutput = false } = options;
     try {
@@ -54,7 +40,7 @@ export async function callGrokEnhanced(messages, options = {}) {
             // NEW Agent Tools API (Jan 2025) - uses /v1/responses endpoint
             // with 'input' instead of 'messages' and tools array
             const searchRequestBody = {
-                model: GrokModel.GROK_4_1_FAST, // Tool-calling optimized model for agentic search
+                model: GrokModel.GROK_4_20_NON_REASONING, // 4.20 standard is better for tool-calling search
                 input: messages.map(m => ({ role: m.role, content: m.content })),
                 tools: [
                     { type: "web_search" },
@@ -187,9 +173,9 @@ ${FORMAT_INSTRUCTION}`
                 content: query
             }
         ];
-        log?.info(`Grok Scout: ${variant} research with ${enableLiveSearch ? 'live search' : 'knowledge base'} (using grok-4-1-fast-reasoning with enhanced reasoning)`);
+        log?.info(`Grok Scout: ${variant} research with ${enableLiveSearch ? 'live search' : 'knowledge base'} (using grok-4.20 reasoning)`);
         const result = await callGrokEnhanced(messages, {
-            model: GrokModel.GROK_4_1_FAST_REASONING, // Updated 2025-11-21: Use latest Grok 4.1
+            model: GrokModel.GROK_4_20_REASONING, // 4.20 for low hallucination research
             enableLiveSearch,
             searchSources,
             searchDomains,
@@ -255,7 +241,7 @@ ${FORMAT_INSTRUCTION}`
         const costInfo = useHeavy ? '$3/$15 (expensive!)' : '$0.20/$0.50 (latest!)';
         log?.info(`Using ${modelName} (${approach}) with ${enableLiveSearch ? 'live search' : 'knowledge base'} - Cost: ${costInfo}`);
         const result = await callGrokEnhanced(messages, {
-            model: useHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_1_FAST_REASONING, // Updated 2025-11-21: Use latest Grok 4.1
+            model: useHeavy ? GrokModel.GROK_4_20_MULTI_AGENT : GrokModel.GROK_4_20_REASONING,
             useHeavy,
             enableLiveSearch,
             searchSources: 50,
@@ -307,7 +293,7 @@ export const grokFunctionTool = {
         ];
         // Make request with tools
         const requestBody = {
-            model: args.useHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_1_FAST, // Updated 2025-11-22: Use tool-calling optimized Grok 4.1 Fast Non-Reasoning
+            model: args.useHeavy ? GrokModel.GROK_4_20_MULTI_AGENT : GrokModel.GROK_4_20_NON_REASONING,
             messages,
             tools,
             tool_choice: "auto", // Let Grok decide when to call functions
@@ -373,13 +359,13 @@ ${FORMAT_INSTRUCTION}`
                 content: `Search for: ${query}`
             }
         ];
-        log?.info(`Grok Search: ${max_search_results} sources, recency: ${recency} (using grok-4-1-fast-reasoning with enhanced reasoning)`);
+        log?.info(`Grok Search: ${max_search_results} sources, recency: ${recency} (using grok-4.20 reasoning)`);
         // Extract domains from sources if specified
         const domains = sources
             ?.filter((s) => s.allowed_websites)
             ?.flatMap((s) => s.allowed_websites) || [];
         const result = await callGrokEnhanced(messages, {
-            model: GrokModel.GROK_4_1_FAST_REASONING, // Updated 2025-11-21: Use latest Grok 4.1 with search
+            model: GrokModel.GROK_4_20_REASONING, // Low hallucination is CRITICAL for search accuracy
             enableLiveSearch: true,
             searchSources: max_search_results,
             searchDomains: domains,
@@ -417,11 +403,11 @@ export function isGrokAvailable() {
 export function getGrokStatus() {
     return {
         available: isGrokAvailable(),
-        model: GrokModel.GROK_4_1_FAST_REASONING,
+        model: "grok-4.20-0309-reasoning",
         features: [
-            'Grok 4.1 Fast Reasoning (Nov 2025): Enhanced reasoning, creativity & emotional intelligence ($0.20/$0.50, 2M context)',
-            'Grok 4.1 Fast Non-Reasoning: Tool-calling optimized, agentic workflows ($0.20/$0.50, 2M context)',
-            'Heavy mode available (grok-4-0709: $3/$15, use sparingly)',
+            'Grok 4.20 Reasoning (grok-4.20-0309-reasoning): Flagship, low hallucination, 2M context ($2/$6)',
+            'Grok 4.20 Non-Reasoning (grok-4.20-0309-non-reasoning): Tool-calling optimized, agentic workflows ($2/$6)',
+            'Grok 4.20 Multi-Agent (grok-4.20-multi-agent-0309): 4-16 parallel agents ($2/$6)',
             'Live web search with citations',
             'Function calling',
             'Structured outputs',

package/dist/src/tools/grok-tools.js

@@ -21,10 +21,14 @@ config({ path: path.resolve(__dirname, '../../../.env') });
 // Grok API configuration
 const GROK_API_KEY = getGrokApiKey();
 const GROK_API_URL = "https://api.x.ai/v1/chat/completions";
-// Available Grok models - Updated 2025-11-22 with correct API model names
+// Available Grok models - Updated 2026-04-10 with Grok 4.20 (Mar 2026)
 export var GrokModel;
 (function (GrokModel) {
-    // Grok 4.1 models (Nov 2025) - LATEST & BEST (verified working)
+    // Grok 4.20 models (Mar 10, 2026) - FLAGSHIP
+    GrokModel["GROK_4_20_REASONING"] = "grok-4.20-0309-reasoning";
+    GrokModel["GROK_4_20_NON_REASONING"] = "grok-4.20-0309-non-reasoning";
+    GrokModel["GROK_4_20_MULTI_AGENT"] = "grok-4.20-multi-agent-0309";
+    // Grok 4.1 fast models (Nov 2025) - BEST VALUE (10x cheaper)
     GrokModel["GROK_4_1_FAST_REASONING"] = "grok-4-1-fast-reasoning";
     GrokModel["GROK_4_1_FAST"] = "grok-4-1-fast-non-reasoning";
     // Grok 4 fast models (2025) - Still good
@@ -42,9 +46,8 @@ export var GrokModel;
  *   - 'code-analysis': Relaxed for code analysis tools
  *   - 'llm-orchestration': Medium for LLM-to-LLM calls
  */
-export async function callGrok(messages, model = GrokModel.GROK_4_1_FAST_REASONING, // Updated 2025-11-22: Use latest Grok 4.1 by default
-temperature = 0.7, maxTokens = 16384, // Increased default for comprehensive responses
-forceVisibleOutput = true, validationContext = 'llm-orchestration') {
+export async function callGrok(messages, model = GrokModel.GROK_4_20_REASONING, temperature = 0.7, maxTokens = 16384, // Increased default for comprehensive responses
+forceVisibleOutput = true, validationContext = 'llm-orchestration', reasoningEffort) {
     // Try OpenRouter gateway first if enabled
     if (isGatewayEnabled()) {
         const gatewayResult = await tryOpenRouterGateway(model, messages, {
@@ -68,34 +71,43 @@ forceVisibleOutput = true, validationContext = 'llm-orchestration') {
         }
         return { ...msg, content: validation.sanitized };
     });
+    // Grok 4.x reasoning can take 60-90s; 4.20 and multi-agent can take longer
+    const isReasoning = model.includes('reasoning') || model.includes('multi-agent');
+    const is420 = model.includes('4.20');
+    const timeoutMs = is420 ? 180000 : (isReasoning ? 120000 : 60000);
     try {
-        // For Grok 4 models, we need to handle reasoning tokens specially
-        const isGrok4 = model === GrokModel.GROK_4_1_FAST_REASONING ||
-            model === GrokModel.GROK_4_1_FAST ||
-            model === GrokModel.GROK_4_FAST_REASONING ||
-            model === GrokModel.GROK_4_FAST ||
-            model === GrokModel.GROK_4_HEAVY;
-        // Adjust prompt for Grok 4 to ensure visible output
-        if (isGrok4 && forceVisibleOutput) {
+        // For Grok 4+ models, we need to handle reasoning tokens specially
+        const isGrok4Plus = model.includes('grok-4');
+        // Adjust prompt for Grok 4+ to ensure visible output
+        if (isGrok4Plus && forceVisibleOutput) {
             const lastMessage = validatedMessages[validatedMessages.length - 1];
             if (lastMessage.role === 'user') {
                 lastMessage.content += '\n\nProvide a detailed response with your reasoning and conclusion.';
             }
         }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        const isMultiAgent = model.includes('multi-agent');
+        const requestBody = {
+            model,
+            messages: validatedMessages,
+            temperature,
+            max_tokens: maxTokens,
+            stream: false
+        };
+        if (isMultiAgent && reasoningEffort) {
+            requestBody.reasoning = { effort: reasoningEffort };
+        }
         const response = await fetch(GROK_API_URL, {
             method: "POST",
             headers: {
                 "Authorization": `Bearer ${GROK_API_KEY}`,
                 "Content-Type": "application/json"
             },
-            body: JSON.stringify({
-                model,
-                messages: validatedMessages,
-                temperature,
-                max_tokens: maxTokens,
-                stream: false
-            })
+            body: JSON.stringify(requestBody),
+            signal: controller.signal
         });
+        clearTimeout(timeoutId);
         if (!response.ok) {
             const error = await response.text();
             throw new Error(`Grok API error: ${response.statusText} - ${error}`);
@@ -105,7 +117,7 @@ forceVisibleOutput = true, validationContext = 'llm-orchestration') {
         // Handle Grok 4's reasoning tokens
         if (!content && data.usage?.completion_tokens_details?.reasoning_tokens > 0) {
             // If Grok 4 returns no visible content, retry with Grok 3 for visible output
-            if (isGrok4 && forceVisibleOutput) {
+            if (isGrok4Plus && forceVisibleOutput) {
                 console.error(`Grok 4 used ${data.usage.completion_tokens_details.reasoning_tokens} reasoning tokens with no output. Retrying with Grok 3...`);
                 // Messages already validated - use same context for retry
                 return callGrok(validatedMessages, GrokModel.GROK_3, temperature, maxTokens, false, validationContext);
@@ -115,6 +127,9 @@ forceVisibleOutput = true, validationContext = 'llm-orchestration') {
         return content || "No response from Grok";
     }
     catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            return `[Grok timeout: ${model} exceeded ${isReasoning ? '120' : '60'}s limit]`;
+        }
         return `[Grok error: ${error instanceof Error ? error.message : String(error)}]`;
     }
 }
@@ -158,10 +173,10 @@ ${FORMAT_INSTRUCTION}`
                 content: problem + fileContext
             }
         ];
-        // Use GROK_4_1_FAST_REASONING by default (latest with enhanced reasoning!), GROK_4_HEAVY only if explicitly requested
-        const model = useHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_1_FAST_REASONING;
-        const maxTokens = useHeavy ? 100000 : 16384; // 100k for heavy, 16k for normal reasoning
-        log?.info(`Using Grok model: ${model} for deep reasoning (max tokens: ${maxTokens}, cost: ${useHeavy ? 'expensive $3/$15' : 'cheap $0.20/$0.50'})`);
+        // Use 4.20 flagship by default, multi-agent for heavy tasks
+        const model = useHeavy ? GrokModel.GROK_4_20_MULTI_AGENT : GrokModel.GROK_4_20_REASONING;
+        const maxTokens = useHeavy ? 100000 : 16384;
+        log?.info(`Using Grok model: ${model} for deep reasoning (max tokens: ${maxTokens})`);
         // Use heartbeat to prevent MCP timeout during long reasoning operations
         const reportFn = reportProgress ?? (async () => { });
         const result = await withHeartbeat(() => callGrok(messages, model, 0.7, maxTokens, true, 'llm-orchestration'), reportFn);
@@ -212,7 +227,7 @@ ${FORMAT_INSTRUCTION}`
         log?.info(`Using Grok 4.1 Fast Non-Reasoning (2M context, tool-calling optimized, $0.20/$0.50)`);
         // Use heartbeat to prevent MCP timeout
         const reportFn = reportProgress ?? (async () => { });
-        const result = await withHeartbeat(() => callGrok(messages, GrokModel.GROK_4_1_FAST, 0.2, 4000, true, 'code-analysis'), reportFn);
+        const result = await withHeartbeat(() => callGrok(messages, GrokModel.GROK_4_20_NON_REASONING, 0.2, 4000, true, 'code-analysis'), reportFn);
         return stripFormatting(result);
     }
 };
@@ -264,7 +279,7 @@ ${FORMAT_INSTRUCTION}`
         log?.info(`Using Grok 4.1 Fast Non-Reasoning for debugging (tool-calling optimized, $0.20/$0.50)`);
         // Use heartbeat to prevent MCP timeout
         const reportFn = reportProgress ?? (async () => { });
-        const result = await withHeartbeat(() => callGrok(messages, GrokModel.GROK_4_1_FAST, 0.3, 3000, true, 'code-analysis'), reportFn);
+        const result = await withHeartbeat(() => callGrok(messages, GrokModel.GROK_4_20_NON_REASONING, 0.3, 3000, true, 'code-analysis'), reportFn);
         return stripFormatting(result);
     }
 };
@@ -302,10 +317,10 @@ ${FORMAT_INSTRUCTION}`
                 content: requirements + fileContext
             }
         ];
-        log?.info(`Using Grok 4.1 Fast Reasoning for architecture (latest model, $0.20/$0.50)`);
+        log?.info(`Using Grok 4.20 multi-agent for architecture (16-agent swarm)`);
         // Use heartbeat to prevent MCP timeout
         const reportFn = reportProgress ?? (async () => { });
-        const result = await withHeartbeat(() => callGrok(messages, GrokModel.GROK_4_1_FAST_REASONING, 0.6, 4000, true, 'llm-orchestration'), reportFn);
+        const result = await withHeartbeat(() => callGrok(messages, GrokModel.GROK_4_20_MULTI_AGENT, 0.6, 4000, true, 'llm-orchestration', 'high'), reportFn);
         return stripFormatting(result);
     }
 };
@@ -356,8 +371,8 @@ ${FORMAT_INSTRUCTION}`
                 content: topic + fileContext
             }
         ];
-        const model = forceHeavy ? GrokModel.GROK_4_HEAVY : GrokModel.GROK_4_1_FAST_REASONING;
-        log?.info(`Brainstorming with Grok model: ${model} (Heavy: ${forceHeavy}, cost: ${forceHeavy ? 'expensive $3/$15' : 'cheap $0.20/$0.50 - latest 4.1'})`);
+        const model = forceHeavy ? GrokModel.GROK_4_20_MULTI_AGENT : GrokModel.GROK_4_20_NON_REASONING;
+        log?.info(`Brainstorming with Grok model: ${model} (Heavy: ${forceHeavy})`);
         const reportFn = reportProgress ?? (async () => { });
         const result = await withHeartbeat(() => callGrok(messages, model, 0.95, 4000, true, 'llm-orchestration'), reportFn);
         return stripFormatting(result);

package/dist/src/tools/openai-tools.js

@@ -184,14 +184,20 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
                 };
             }
             console.error(`🔍 TRACE: Using ${isGPT5 ? '/v1/responses' : '/v1/chat/completions'} endpoint for ${currentModel}`);
+            // GPT-5.4 with high reasoning effort can take 2+ minutes
+            const timeoutMs = (reasoningEffort === 'high' || reasoningEffort === 'xhigh') ? 180000 : 90000;
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
             const response = await fetch(endpoint, {
                 method: "POST",
                 headers: {
                     "Authorization": `Bearer ${OPENAI_API_KEY}`,
                     "Content-Type": "application/json"
                 },
-                body: JSON.stringify(requestBody)
+                body: JSON.stringify(requestBody),
+                signal: controller.signal
             });
+            clearTimeout(timeoutId);
             if (!response.ok) {
                 const error = await response.text();
                 lastError = `${currentModel}: ${response.statusText} - ${error}`;
@@ -254,8 +260,15 @@ reasoningEffort = "low", requireConfirmation = false, skipValidation = false) {
             return stripFormatting(result);
         }
         catch (error) {
-            lastError = `${currentModel}: ${error instanceof Error ? error.message : String(error)}`;
-            console.error(`🔍 TRACE: ${currentModel} EXCEPTION - ${lastError}`);
+            // Handle abort/timeout specifically
+            if (error instanceof Error && error.name === 'AbortError') {
+                lastError = `${currentModel}: Timeout (reasoning_effort=${reasoningEffort})`;
+                console.error(`🔍 TRACE: ${currentModel} TIMEOUT - reasoning_effort=${reasoningEffort}`);
+            }
+            else {
+                lastError = `${currentModel}: ${error instanceof Error ? error.message : String(error)}`;
+                console.error(`🔍 TRACE: ${currentModel} EXCEPTION - ${lastError}`);
+            }
             continue; // Try next model
         }
     }

package/dist/src/tools/planner-tools.js

@@ -1136,11 +1136,13 @@ function generateProgressBar(current, total) {
  */
 function parsePlanSteps(plan) {
     const steps = [];
-    // Try numbered steps first (### Step 1: or 1. or Step 1:)
+    // Try structured step/task headers (### Step 1:, ### Task T1:, 1., Step 1:)
     const stepPatterns = [
         /###\s*Step\s*\d+[:\s]+([^\n]+)([\s\S]*?)(?=###\s*Step|\n##[^#]|$)/gi,
+        /###\s*Task\s*[^\n:]+:\s*([^\n]+)([\s\S]*?)(?=###\s*Task|\n##[^#]|$)/gi,
         /^\s*(\d+)\.\s*([^\n]+)([\s\S]*?)(?=^\s*\d+\.|$)/gm,
         /^Step\s*\d+[:\s]+([^\n]+)([\s\S]*?)(?=^Step\s*\d+|$)/gim,
+        /^Task\s*[^\n:]+:\s*([^\n]+)([\s\S]*?)(?=^Task\s*\S+|$)/gim,
     ];
     for (const pattern of stepPatterns) {
         const matches = [...plan.matchAll(pattern)];
@@ -1253,6 +1255,10 @@ Evidence params (unblind the checkpoints):
         // Parse plan into steps
         const steps = parsePlanSteps(plan);
         const totalSteps = steps.length;
+        if (completed.length > totalSteps) {
+            lines.push(`⚠️ Plan parse mismatch: ${completed.length} steps completed but only ${totalSteps} parsed. Plan format may have degraded.`);
+            lines.push("");
+        }
         if (mode === "start") {
             // ═══════════════════════════════════════════════════════════════
             // START: Show parsed plan and devlog hint

package/dist/src/tools/tachi-tool.js

@@ -131,7 +131,7 @@ Focus on recent, accurate information. Provide sources.${FORMAT_INSTRUCTION}`
             { role: "user", content: query }
         ];
         const result = await callGrokEnhanced(messages, {
-            model: GrokModel.GROK_4_1_FAST_REASONING,
+            model: GrokModel.GROK_4_20_REASONING,
             enableLiveSearch: true,
             searchSources: 20,
             temperature: 0.3,
@@ -176,7 +176,7 @@ async function solveHandler(query) {
                 { role: "system", content: `Search for solutions to this coding problem. Find relevant Stack Overflow, docs, or GitHub issues.${FORMAT_INSTRUCTION}` },
                 { role: "user", content: query }
             ], {
-                model: GrokModel.GROK_4_1_FAST_REASONING,
+                model: GrokModel.GROK_4_20_REASONING,
                 enableLiveSearch: true,
                 searchSources: 10,
                 temperature: 0.3,
@@ -269,7 +269,7 @@ async function architectHandler(query) {
             { role: "system", content: `Search for architecture patterns, best practices, and real-world examples for this design decision.${FORMAT_INSTRUCTION}` },
             { role: "user", content: query }
         ], {
-            model: GrokModel.GROK_4_1_FAST_REASONING,
+            model: GrokModel.GROK_4_20_REASONING,
             enableLiveSearch: true,
             searchSources: 15,
             temperature: 0.3,

package/dist/src/utils/ansi-renderer.js

@@ -452,8 +452,8 @@ export function stripMarkdown(md, options) {
     text = text
         // Markdown headers — strip # prefix (or bold if boldHeaders)
         .replace(/^#{1,6}\s+(.+)$/gm, boldHeaders ? '\x1b[1m$1\x1b[0m' : '$1')
-        // Emoji section headers — e.g. "🧠 TYPE SAFETY ───" → rotating pastel bg, dark bold text
-        .replace(/^(.{1,2})\s+([A-Z][A-Z\s&]+?)\s*─+$/gm, (_match, emoji, header) => {
+        // Emoji section headers — e.g. "🧠 TYPE SAFETY ───" or "🧠 Key Activities" → rotating pastel bg
+        .replace(/^(.{1,2})\s+([A-Z][\w\s&,()/-]{2,50}?)\s*─*$/gm, (_match, emoji, header) => {
         if (!boldHeaders)
             return `${emoji} ${header}`;
         const pastels = [146, 182, 152, 187, 116, 180]; // lavender, mauve, powder blue, sand, mint, peach