neuro-cli 4.3.0 → 5.0.0

package/dist/agents/base.d.ts

@@ -16,6 +16,12 @@ export interface AgentCallbacks {
     onApprovalNeeded?: (toolName: string, args: Record<string, unknown>, risk: string) => Promise<boolean>;
     onIteration?: (iteration: number, maxIterations: number) => void;
     onComplete?: (result: AgentRunResult) => void;
+    /** Called when the agent starts a new agentic cycle */
+    onCycleStart?: (cycle: number, summary: string) => void;
+    /** Called when the agent detects task completion */
+    onTaskComplete?: (reason: string) => void;
+    /** Signal to abort the agent loop (e.g. user pressed Ctrl+C) */
+    abortSignal?: AbortSignal;
 }
 export declare class BaseAgent {
     protected config: AgentConfig;
@@ -24,6 +30,11 @@ export declare class BaseAgent {
     protected workingDirectory: string;
     protected sessionId: string;
     protected messages: Message[];
+    private lastToolCalls;
+    private repeatedActionCount;
+    private static readonly MAX_REPEATED_ACTIONS;
+    private static readonly MAX_CONSECUTIVE_ERRORS;
+    private static readonly ABSOLUTE_MAX_CYCLES;
     constructor(config: AgentConfig, client: OpenRouterClient, registry: ToolRegistry, workingDirectory: string, sessionId: string);
     get name(): string;
     get description(): string;
@@ -35,7 +46,7 @@ export declare class BaseAgent {
      */
     protected initializeMessages(taskContext?: string): Message[];
     /**
-     * Build the system prompt with context
+     * Build the system prompt with context — Claude Code-style
      */
     protected buildSystemPrompt(taskContext?: string): string;
     /**
@@ -51,7 +62,15 @@ export declare class BaseAgent {
      */
     protected addToolResult(toolCallId: string, content: string, name: string, isError?: boolean): void;
     /**
-     * Run the agent loop
+     * Detect if the model's response indicates the task is complete
+     */
+    private isTaskComplete;
+    /**
+     * Detect doom-loop: same tool+args repeated too many times
+     */
+    private detectDoomLoop;
+    /**
+     * Run the agent loop — Claude Code style: keep going until task is truly done
      */
     run(task: string, callbacks?: AgentCallbacks, maxIterations?: number): Promise<AgentRunResult>;
     /**

package/dist/agents/base.js

@@ -1,8 +1,28 @@
 // ============================================================
-// NeuroCLI - Base Agent
+// NeuroCLI - Base Agent v5.0 (Claude Code-style Agentic Loop)
 // Foundation class for all agents
+// Key changes:
+//   - No arbitrary iteration limits; loops until task is complete
+//   - Self-evaluation after each LLM turn (is the task done?)
+//   - Error recovery with alternative approaches
+//   - Continuous tool chaining until the model says "I'm done"
+//   - Doom-loop detection replaces hard iteration caps
 // ============================================================
 import { MODELS } from '../api/models.js';
+// Patterns that indicate the model considers the task complete
+const TASK_COMPLETE_PATTERNS = [
+    /\b(task|job|work|mission|assignment)\s+(is\s+)?(complete|done|finished|accomplished|fulfilled)\b/i,
+    /\bi('ve| have)\s+(completed|finished|done|accomplished)\b/i,
+    /\b(all|every)\s+(the\s+)?(task|step|item|file|change|modification)s?\s+(are|is|have been)\s+(done|complete|applied|made|created)\b/i,
+    /\bnothing\s+(more|else)\s+(to\s+)?(do|change|modify|update)\b/i,
+    /\beverything\s+(is\s+)?(done|complete|ready|set|in\s+place)\b/i,
+];
+// Patterns that indicate the model is still working
+const STILL_WORKING_PATTERNS = [
+    /\b(next|then|now|i\s+need\s+to|i\s+should|i\s+will|let\s+me)\b/i,
+    /\b(create|write|modify|edit|update|add|remove|delete|fix|implement|refactor|install)\b/i,
+    /\b(read|check|verify|test|run|execute|search|find|look)\b/i,
+];
 export class BaseAgent {
     config;
     client;
@@ -10,6 +30,13 @@ export class BaseAgent {
     workingDirectory;
     sessionId;
     messages = [];
+    // Track repetitive actions for doom-loop detection
+    lastToolCalls = [];
+    repeatedActionCount = 0;
+    static MAX_REPEATED_ACTIONS = 4;
+    static MAX_CONSECUTIVE_ERRORS = 5;
+    // Safety ceiling: prevent truly infinite loops (extremely high, only for runaway agents)
+    static ABSOLUTE_MAX_CYCLES = 500;
     constructor(config, client, registry, workingDirectory, sessionId) {
         this.config = config;
         this.client = client;
@@ -41,7 +68,7 @@ export class BaseAgent {
         return this.messages;
     }
     /**
-     * Build the system prompt with context
+     * Build the system prompt with context — Claude Code-style
      */
     buildSystemPrompt(taskContext) {
         const model = MODELS[this.config.model || ''];
@@ -55,14 +82,20 @@ export class BaseAgent {
         if (taskContext) {
             prompt += `\n\n## Task Context\n${taskContext}`;
         }
-        prompt += `\n\n## Guidelines
-- Be precise and thorough in your responses
-- Use tools to verify your assumptions before making changes
-- When modifying files, make minimal, targeted changes
-- Always read a file before editing it
-- Report what you've done and what still needs to be done
-- If you encounter errors, analyze them before retrying
-- Do NOT repeat the same action if it failed - try a different approach`;
+        // Claude Code-style guidelines: work until the task is TRULY done
+        prompt += `\n\n## Critical Operating Guidelines
+- You MUST continue working until the ENTIRE task is complete — do not stop after partial progress
+- After each tool call, evaluate: "Is the task fully done? If not, what's the next step?"
+- If a tool call fails, try a DIFFERENT approach — never repeat the exact same failed action
+- If you encounter an error, analyze it, understand the root cause, and fix it before moving on
+- When creating or modifying files, verify your changes by reading the file back
+- When implementing features, check that all related files are updated consistently
+- Be thorough: create ALL necessary files, update ALL relevant imports, handle ALL edge cases
+- Do NOT say "I've completed the task" unless you have verified everything works
+- Chain tools naturally: read → understand → plan → implement → verify → continue if needed
+- If you realize the task requires more work than initially thought, KEEP GOING
+- Never use phrases like "the rest is left as an exercise" or "you can continue from here"
+- Your job is to deliver a COMPLETE, WORKING solution — not a partial outline`;
         return prompt;
     }
     /**
@@ -90,14 +123,60 @@ export class BaseAgent {
         });
     }
     /**
-     * Run the agent loop
+     * Detect if the model's response indicates the task is complete
+     */
+    isTaskComplete(response, hasToolCalls) {
+        // If the model is still calling tools, it's not done
+        if (hasToolCalls)
+            return false;
+        // Check for explicit completion signals
+        for (const pattern of TASK_COMPLETE_PATTERNS) {
+            if (pattern.test(response))
+                return true;
+        }
+        // If no tool calls and the response contains "still working" patterns, it might be stuck
+        // But if there are no tool calls and no "still working" patterns, assume done
+        const hasWorkingSignals = STILL_WORKING_PATTERNS.some(p => p.test(response));
+        if (!hasWorkingSignals && !hasToolCalls) {
+            // No tool calls + no "still working" language = probably done
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Detect doom-loop: same tool+args repeated too many times
+     */
+    detectDoomLoop(toolName, args) {
+        const callSig = `${toolName}:${JSON.stringify(args)}`;
+        if (this.lastToolCalls.length >= BaseAgent.MAX_REPEATED_ACTIONS &&
+            this.lastToolCalls.slice(-BaseAgent.MAX_REPEATED_ACTIONS).every(c => c === callSig)) {
+            this.repeatedActionCount++;
+            if (this.repeatedActionCount >= BaseAgent.MAX_REPEATED_ACTIONS) {
+                return true;
+            }
+        }
+        else {
+            this.repeatedActionCount = 0;
+        }
+        this.lastToolCalls.push(callSig);
+        // Keep only recent history
+        if (this.lastToolCalls.length > 20) {
+            this.lastToolCalls = this.lastToolCalls.slice(-20);
+        }
+        return false;
+    }
+    /**
+     * Run the agent loop — Claude Code style: keep going until task is truly done
      */
     async run(task, callbacks, maxIterations) {
-        const maxIter = maxIterations || this.config.maxIterations || 10;
+        // maxIterations is now a SOFT ceiling with override for continued work
+        // If not specified, we use our absolute max (effectively no limit)
+        const softCap = maxIterations || this.config.maxIterations || BaseAgent.ABSOLUTE_MAX_CYCLES;
         const startTime = Date.now();
         let totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
         let toolCallsMade = 0;
         let iteration = 0;
+        let consecutiveErrors = 0;
         const execution = {
             agentName: this.config.name,
             task,
@@ -109,8 +188,18 @@ export class BaseAgent {
         // Initialize messages
         this.initializeMessages();
         this.addUserMessage(task);
-        for (iteration = 1; iteration <= maxIter; iteration++) {
-            callbacks?.onIteration?.(iteration, maxIter);
+        this.lastToolCalls = [];
+        this.repeatedActionCount = 0;
+        // Main agentic loop — Claude Code style: keep going until done
+        for (iteration = 1; iteration <= BaseAgent.ABSOLUTE_MAX_CYCLES; iteration++) {
+            // Check abort signal
+            if (callbacks?.abortSignal?.aborted) {
+                execution.status = 'cancelled';
+                execution.result = 'Task cancelled by user';
+                break;
+            }
+            // Report iteration progress (0 means "no fixed limit")
+            callbacks?.onIteration?.(iteration, 0);
             // Get tool definitions for this agent
             const toolDefs = this.registry.getDefinitions(this.config.tools);
             // Prepare stream callbacks
@@ -134,19 +223,35 @@ export class BaseAgent {
                     tools: toolDefs.length > 0 ? toolDefs : undefined,
                     temperature: this.config.temperature,
                     maxTokens: this.config.maxTokens,
-                    stream: false, // Disable streaming for better compatibility with free models
+                    stream: false,
                 }, streamCallbacks);
                 totalUsage.inputTokens += response.usage.inputTokens;
                 totalUsage.outputTokens += response.usage.outputTokens;
                 totalUsage.cost += response.usage.cost;
-                // If no tool calls, we're done
+                // Reset error counter on successful response
+                consecutiveErrors = 0;
+                // Check if task is complete (no tool calls + completion signals)
                 if (response.toolCalls.length === 0) {
                     this.addAssistantMessage(response.content);
-                    execution.status = 'completed';
-                    execution.result = response.content;
-                    break;
+                    if (this.isTaskComplete(response.content, false)) {
+                        callbacks?.onTaskComplete?.('Task completed successfully');
+                        execution.status = 'completed';
+                        execution.result = response.content;
+                        break;
+                    }
+                    // Model returned text without tool calls but didn't signal completion
+                    // This might be a summary or partial completion — check if we should continue
+                    // If the soft cap is reached and there are no tool calls, we're likely done
+                    if (iteration >= softCap) {
+                        execution.status = 'completed';
+                        execution.result = response.content;
+                        break;
+                    }
+                    // Otherwise, add a nudge to continue working
+                    this.addUserMessage('Continue working on the task. If there is more to do, use your tools. If the task is truly complete, say "Task complete" and summarize what was done.');
+                    continue;
                 }
-                // Process tool calls
+                // Process tool calls — the agent is still working
                 this.addAssistantMessage(response.content, response.toolCalls);
                 for (const toolCall of response.toolCalls) {
                     let args;
@@ -158,11 +263,20 @@ export class BaseAgent {
                     }
                     const toolName = toolCall.function.name;
                     toolCallsMade++;
+                    // Doom-loop detection
+                    if (this.detectDoomLoop(toolName, args)) {
+                        const msg = `Doom loop detected: "${toolName}" called with the same arguments too many times. Breaking the loop.`;
+                        callbacks?.onThinking?.(msg);
+                        this.addToolResult(toolCall.id, msg, toolName, true);
+                        // Add a nudge to try a different approach
+                        this.addUserMessage('You seem to be stuck in a loop, calling the same tool with the same arguments repeatedly. Try a completely different approach to solve this problem.');
+                        break;
+                    }
                     callbacks?.onToolCall?.(toolName, args);
                     // Check if approval is needed
                     const needsApproval = this.registry.getApprovalRequest(toolName, args);
                     if (needsApproval && this.config.autoApprove !== true) {
-                        const approved = await callbacks?.onApprovalNeeded?.(toolName, args, needsApproval.risk) ?? true; // Default to approve if no callback
+                        const approved = await callbacks?.onApprovalNeeded?.(toolName, args, needsApproval.risk) ?? true;
                         if (!approved) {
                             this.addToolResult(toolCall.id, 'User denied this tool call.', toolName);
                             callbacks?.onToolResult?.(toolName, 'Denied by user', false);
@@ -176,23 +290,52 @@ export class BaseAgent {
                         agentName: this.config.name,
                         onProgress: (msg) => callbacks?.onThinking?.(msg),
                     };
-                    const result = await this.registry.execute(toolName, args, toolContext);
-                    // Use the original tool_call_id from the assistant's tool call, not the registry's generated one
-                    this.addToolResult(toolCall.id, result.content, toolName, result.isError);
-                    callbacks?.onToolResult?.(toolName, result.content, result.isError || false);
+                    try {
+                        const result = await this.registry.execute(toolName, args, toolContext);
+                        this.addToolResult(toolCall.id, result.content, toolName, result.isError);
+                        callbacks?.onToolResult?.(toolName, result.content, result.isError || false);
+                        // If tool had an error, note it but continue (error recovery)
+                        if (result.isError) {
+                            consecutiveErrors++;
+                            if (consecutiveErrors >= BaseAgent.MAX_CONSECUTIVE_ERRORS) {
+                                // Add context about repeated failures
+                                this.addUserMessage(`The last ${consecutiveErrors} tool calls have resulted in errors. Please step back, analyze the situation, and try a completely different approach. Read relevant files first to understand the current state before making changes.`);
+                                consecutiveErrors = 0; // Reset after nudge
+                            }
+                        }
+                    }
+                    catch (toolError) {
+                        const errMsg = toolError instanceof Error ? toolError.message : String(toolError);
+                        this.addToolResult(toolCall.id, `Tool execution error: ${errMsg}`, toolName, true);
+                        callbacks?.onToolResult?.(toolName, errMsg, true);
+                        consecutiveErrors++;
+                    }
                 }
+                // After processing all tool calls for this iteration, report cycle progress
+                const cycleSummary = `${toolCallsMade} tools used, iteration ${iteration}`;
+                callbacks?.onCycleStart?.(iteration, cycleSummary);
             }
             catch (error) {
                 const errMsg = error instanceof Error ? error.message : String(error);
-                this.addAssistantMessage(`Error encountered: ${errMsg}`);
-                execution.status = 'failed';
-                execution.result = errMsg;
-                break;
+                consecutiveErrors++;
+                // If we've had too many consecutive API errors, stop
+                if (consecutiveErrors >= BaseAgent.MAX_CONSECUTIVE_ERRORS) {
+                    this.addAssistantMessage(`Error encountered: ${errMsg}. Too many consecutive errors, stopping.`);
+                    execution.status = 'failed';
+                    execution.result = errMsg;
+                    break;
+                }
+                // Otherwise, add error to conversation and let the model try to recover
+                this.addAssistantMessage(`Error encountered: ${errMsg}. Retrying...`);
+                // Brief delay before retry
+                await new Promise(resolve => setTimeout(resolve, 1000 * consecutiveErrors));
+                continue;
             }
         }
-        if (iteration > maxIter && execution.status === 'running') {
+        // If we hit the absolute max, mark as completed (not failed — the work might be sufficient)
+        if (iteration > BaseAgent.ABSOLUTE_MAX_CYCLES && execution.status === 'running') {
             execution.status = 'completed';
-            execution.result = `Max iterations reached (${maxIter}). The task may not be fully completed. Consider using a higher effort level or switching to /orchestrate mode for complex tasks.`;
+            execution.result = `Agent reached maximum processing cycles (${BaseAgent.ABSOLUTE_MAX_CYCLES}). The task has been worked on extensively. Review the results and provide further instructions if needed.`;
         }
         execution.endTime = Date.now();
         execution.iterations = iteration;

package/dist/agents/orchestrator.d.ts

@@ -35,7 +35,9 @@ export declare class Orchestrator extends BaseAgent {
      */
     plan(task: string, callbacks?: AgentCallbacks): Promise<OrchestratedPlan>;
     /**
-     * Execute a planned task with sub-agents
+     * Execute a planned task with sub-agents — Claude Code style
+     * Sub-agents run until their tasks are complete.
+     * After all tasks complete, verify the overall result and re-plan if needed.
      */
     orchestrate(task: string, callbacks?: AgentCallbacks, autoPlan?: boolean): Promise<OrchestratorResult>;
     /**

package/dist/agents/orchestrator.js

@@ -1,6 +1,10 @@
 // ============================================================
-// NeuroCLI - Orchestrator Agent
+// NeuroCLI - Orchestrator Agent v5.0 (Claude Code-style)
 // Central coordinator that manages sub-agents
+// Key changes:
+//   - Sub-agents run until their tasks are complete (no hard limits)
+//   - Re-planning when sub-tasks fail or need follow-up
+//   - Verification loop after all sub-tasks complete
 // ============================================================
 import { BaseAgent } from './base.js';
 export class Orchestrator extends BaseAgent {
@@ -40,6 +44,7 @@ ${task}
 2. Assign each sub-task to the most appropriate agent
 3. Specify dependencies between tasks (which tasks must complete before others can start)
 4. Provide any context each agent needs
+5. IMPORTANT: Be thorough — include ALL steps needed to complete the task end-to-end
 
 Respond with a JSON plan in this exact format:
 \`\`\`json
@@ -56,7 +61,7 @@ Respond with a JSON plan in this exact format:
 }
 \`\`\``;
         const messages = [
-            { role: 'system', content: 'You are an expert task orchestrator. Always respond with valid JSON.', timestamp: Date.now() },
+            { role: 'system', content: 'You are an expert task orchestrator. Always respond with valid JSON. Be thorough — include every step needed.', timestamp: Date.now() },
             { role: 'user', content: planPrompt, timestamp: Date.now() },
         ];
         let response;
@@ -64,21 +69,18 @@ Respond with a JSON plan in this exact format:
             response = await this.client.quickChat(this.config.model || 'anthropic/claude-sonnet-4', messages);
         }
         catch {
-            // API error during planning, fallback to direct approach
             return {
                 reasoning: 'API error during planning, falling back to direct approach',
                 tasks: [{ agent: 'Coder', task, dependsOn: [] }],
             };
         }
         try {
-            // Extract JSON from response
             const jsonMatch = response.content.match(/```json\n([\s\S]*?)\n```/) ||
                 response.content.match(/\{[\s\S]*\}/);
             const jsonStr = jsonMatch ? (jsonMatch[1] || jsonMatch[0]) : response.content;
             return JSON.parse(jsonStr);
         }
         catch {
-            // Fallback: use coder agent directly
             return {
                 reasoning: 'Could not parse plan, defaulting to direct coding approach',
                 tasks: [{ agent: 'Coder', task, dependsOn: [] }],
@@ -86,7 +88,9 @@ Respond with a JSON plan in this exact format:
         }
     }
     /**
-     * Execute a planned task with sub-agents
+     * Execute a planned task with sub-agents — Claude Code style
+     * Sub-agents run until their tasks are complete.
+     * After all tasks complete, verify the overall result and re-plan if needed.
      */
     async orchestrate(task, callbacks, autoPlan = true) {
         const startTime = Date.now();
@@ -103,7 +107,7 @@ Respond with a JSON plan in this exact format:
         // Step 1: Create execution plan
         let plan;
         if (autoPlan) {
-            callbacks?.onThinking?.('🧠 Planning task decomposition...');
+            callbacks?.onThinking?.('Planning task decomposition...');
             plan = await this.plan(task, callbacks);
         }
         else {
@@ -112,11 +116,11 @@ Respond with a JSON plan in this exact format:
                 tasks: [{ agent: 'Coder', task }],
             };
         }
-        callbacks?.onThinking?.(`📋 Plan: ${plan.tasks.length} sub-tasks`);
-        callbacks?.onThinking?.(`💭 ${plan.reasoning}`);
-        // Step 2: Execute tasks respecting dependencies
+        callbacks?.onThinking?.(`Plan: ${plan.tasks.length} sub-tasks — ${plan.reasoning}`);
+        // Step 2: Execute tasks respecting dependencies — each agent runs until done
         const completedTasks = new Set();
         let taskIndex = 0;
+        let maxReplans = 3; // Allow up to 3 re-planning cycles
         while (completedTasks.size < plan.tasks.length) {
             // Find tasks whose dependencies are all completed
             const readyTasks = plan.tasks.filter(t => {
@@ -127,23 +131,28 @@ Respond with a JSON plan in this exact format:
                 return t.dependsOn.every(dep => completedTasks.has(dep));
             });
             if (readyTasks.length === 0) {
-                // Deadlock detection - log unresolved tasks
+                // Deadlock detection
                 const unresolved = plan.tasks.filter(t => !completedTasks.has(t.agent + ':' + t.task));
                 if (unresolved.length > 0) {
-                    callbacks?.onThinking?.(`⚠️ Deadlock detected. Unresolved tasks: ${unresolved.map(t => t.agent + ':' + t.task).join(', ')}`);
+                    callbacks?.onThinking?.(`Deadlock detected. Unresolved tasks: ${unresolved.map(t => t.agent + ':' + t.task).join(', ')}`);
+                    // Clear dependency constraints to break deadlock
+                    for (const t of unresolved) {
+                        t.dependsOn = [];
+                    }
+                    continue;
                 }
                 break;
             }
-            // Execute ready tasks (could be parallelized in future)
+            // Execute ready tasks (sequentially for safety, could parallelize in future)
             for (const subTask of readyTasks) {
                 const agent = this.agents.get(subTask.agent);
                 if (!agent) {
-                    callbacks?.onThinking?.(`⚠️ Agent not found: ${subTask.agent}`);
+                    callbacks?.onThinking?.(`Agent not found: ${subTask.agent}`);
                     completedTasks.add(subTask.agent + ':' + subTask.task);
                     continue;
                 }
                 taskIndex++;
-                callbacks?.onThinking?.(`\n🤖 [${taskIndex}/${plan.tasks.length}] Running ${subTask.agent}: ${subTask.task.slice(0, 80)}...`);
+                callbacks?.onThinking?.(`[${taskIndex}/${plan.tasks.length}] Running ${subTask.agent}: ${subTask.task.slice(0, 80)}...`);
                 // Build context from previous agent results
                 let fullTask = subTask.task;
                 if (subTask.context) {
@@ -160,16 +169,23 @@ Respond with a JSON plan in this exact format:
                         fullTask = `${fullTask}\n\n## Context from previous agents:\n${depResults}`;
                     }
                 }
+                // Run the sub-agent — it will keep going until its task is complete
                 let result;
                 try {
                     result = await agent.run(fullTask, {
                         onToken: (token) => callbacks?.onToken?.(token),
                         onToolCall: (name, args) => callbacks?.onToolCall?.(name, args),
-                        onToolResult: (name, result, isError) => callbacks?.onToolResult?.(name, result, isError),
+                        onToolResult: (name, res, isError) => callbacks?.onToolResult?.(name, res, isError),
                         onApprovalNeeded: async (name, args, risk) => {
                             return callbacks?.onApprovalNeeded?.(name, args, risk) ?? true;
                         },
                         onThinking: (thinking) => callbacks?.onThinking?.(thinking),
+                        onIteration: (i, _max) => {
+                            callbacks?.onThinking?.(`  ${subTask.agent} step ${i}`);
+                        },
+                        onTaskComplete: (reason) => {
+                            callbacks?.onThinking?.(`  ${subTask.agent}: ${reason}`);
+                        },
                     });
                 }
                 catch (error) {

package/dist/config/config.js

@@ -14,82 +14,82 @@ export const DEFAULT_CONFIG = {
         planner: {
             name: 'Planner',
             description: 'Task decomposition and planning specialist',
-            systemPrompt: `You are an expert software architect and planner. Your job is to break down complex tasks into clear, actionable steps. For each step, specify which agent should handle it and what tools they should use. Be thorough but concise.`,
+            systemPrompt: `You are an expert software architect and planner. Your job is to break down complex tasks into clear, actionable steps. For each step, specify which agent should handle it and what tools they should use. Be thorough but concise. Keep working until you have a COMPLETE plan covering every aspect of the task.`,
             model: 'qwen/qwen3-coder:free',
             temperature: 0.7,
             maxTokens: 4096,
             tools: ['read_file', 'search_files', 'list_directory'],
-            maxIterations: 10,
+            maxIterations: 0, // 0 = no limit, run until done
         },
         coder: {
             name: 'Coder',
             description: 'Code generation and modification specialist',
-            systemPrompt: `You are an expert software developer. You write clean, efficient, well-documented code. You understand design patterns, best practices, and can work with any programming language or framework. When modifying existing code, you make minimal, targeted changes. Always consider edge cases and error handling.`,
+            systemPrompt: `You are an expert software developer. You write clean, efficient, well-documented code. You understand design patterns, best practices, and can work with any programming language or framework. When modifying existing code, you make minimal, targeted changes. Always consider edge cases and error handling. IMPORTANT: You MUST keep working until the entire task is COMPLETE — do not stop after creating only some files. Create ALL necessary files, update ALL imports, and verify your work.`,
             model: 'qwen/qwen3-coder:free',
             temperature: 0.4,
             maxTokens: 16384,
             tools: ['read_file', 'write_file', 'edit_file', 'search_files', 'list_directory', 'run_command', 'apply_diff'],
-            maxIterations: 50,
+            maxIterations: 0, // 0 = no limit, run until done
         },
         reviewer: {
             name: 'Reviewer',
             description: 'Code review and quality assurance specialist',
-            systemPrompt: `You are an expert code reviewer. You analyze code for bugs, security vulnerabilities, performance issues, and adherence to best practices. You provide specific, actionable feedback with line references. You categorize issues by severity (critical, warning, suggestion). You also check for test coverage and documentation.`,
+            systemPrompt: `You are an expert code reviewer. You analyze code for bugs, security vulnerabilities, performance issues, and adherence to best practices. You provide specific, actionable feedback with line references. You categorize issues by severity (critical, warning, suggestion). You also check for test coverage and documentation. Keep reviewing until you have checked ALL relevant files.`,
             model: 'nvidia/nemotron-3-super-120b-a12b:free',
             temperature: 0.3,
             maxTokens: 8192,
             tools: ['read_file', 'search_files', 'list_directory'],
-            maxIterations: 15,
+            maxIterations: 0,
         },
         researcher: {
             name: 'Researcher',
             description: 'Information gathering and analysis specialist',
-            systemPrompt: `You are an expert researcher and analyst. You gather information from files, web resources, and codebases. You synthesize findings into clear, structured reports. You can explain complex technical concepts and find relevant examples or documentation.`,
+            systemPrompt: `You are an expert researcher and analyst. You gather information from files, web resources, and codebases. You synthesize findings into clear, structured reports. You can explain complex technical concepts and find relevant examples or documentation. Keep researching until you have a COMPLETE picture.`,
             model: 'google/gemma-4-31b-it:free',
             temperature: 0.5,
             maxTokens: 8192,
             tools: ['read_file', 'search_files', 'list_directory', 'web_search', 'web_fetch'],
-            maxIterations: 20,
+            maxIterations: 0,
         },
         tester: {
             name: 'Tester',
             description: 'Test generation and execution specialist',
-            systemPrompt: `You are an expert QA engineer. You write comprehensive test suites covering unit tests, integration tests, and edge cases. You run tests and analyze failures to identify root causes. You ensure code meets quality standards before it's considered complete.`,
+            systemPrompt: `You are an expert QA engineer. You write comprehensive test suites covering unit tests, integration tests, and edge cases. You run tests and analyze failures to identify root causes. You ensure code meets quality standards before it's considered complete. Keep testing until ALL tests pass.`,
             model: 'qwen/qwen3-coder:free',
             temperature: 0.3,
             maxTokens: 8192,
             tools: ['read_file', 'write_file', 'search_files', 'run_command', 'list_directory'],
-            maxIterations: 25,
+            maxIterations: 0,
         },
         debugger: {
             name: 'Debugger',
             description: 'Bug investigation and fixing specialist',
-            systemPrompt: `You are an expert debugger. You systematically investigate bugs by reading code, running diagnostic commands, analyzing error messages and stack traces. You identify root causes and implement targeted fixes. You verify fixes work before reporting completion.`,
+            systemPrompt: `You are an expert debugger. You systematically investigate bugs by reading code, running diagnostic commands, analyzing error messages and stack traces. You identify root causes and implement targeted fixes. You verify fixes work before reporting completion. Keep debugging until the bug is COMPLETELY fixed and verified.`,
             model: 'qwen/qwen3-coder:free',
             temperature: 0.2,
             maxTokens: 8192,
             tools: ['read_file', 'edit_file', 'search_files', 'run_command', 'list_directory', 'apply_diff'],
-            maxIterations: 20,
+            maxIterations: 0,
         },
         architect: {
             name: 'Architect',
             description: 'System design and architecture specialist',
-            systemPrompt: `You are an expert software architect. You design scalable, maintainable system architectures. You make technology stack decisions, define component boundaries, and establish coding standards. You create detailed technical specifications that other agents can implement.`,
+            systemPrompt: `You are an expert software architect. You design scalable, maintainable system architectures. You make technology stack decisions, define component boundaries, and establish coding standards. You create detailed technical specifications that other agents can implement. Keep designing until the architecture is COMPLETE and all components are specified.`,
             model: 'nvidia/nemotron-3-ultra-550b-a55b:free',
             temperature: 0.7,
             maxTokens: 8192,
             tools: ['read_file', 'search_files', 'list_directory'],
-            maxIterations: 15,
+            maxIterations: 0,
         },
         devops: {
             name: 'DevOps',
             description: 'Deployment and infrastructure specialist',
-            systemPrompt: `You are an expert DevOps engineer. You handle CI/CD pipelines, Docker configurations, cloud deployments, and infrastructure as code. You optimize build processes and ensure reliable deployments.`,
+            systemPrompt: `You are an expert DevOps engineer. You handle CI/CD pipelines, Docker configurations, cloud deployments, and infrastructure as code. You optimize build processes and ensure reliable deployments. Keep working until the deployment is FULLY configured and verified.`,
             model: 'cohere/north-mini-code:free',
             temperature: 0.3,
             maxTokens: 8192,
             tools: ['read_file', 'write_file', 'edit_file', 'run_command', 'search_files', 'list_directory'],
-            maxIterations: 25,
+            maxIterations: 0,
         },
     },
     tools: {
@@ -208,7 +208,7 @@ export const DEFAULT_CONFIG = {
     autoMode: {
         enabled: false,
         safetyLevel: 'conservative',
-        maxIterations: 50,
+        maxIterations: 0, // 0 = no limit, run until done (Claude Code style)
         maxCost: 0,
         maxTimeMs: 0,
         blockedCommands: ['rm -rf /', 'mkfs', 'dd if=/dev/zero'],

package/dist/core/engine.d.ts

@@ -137,7 +137,9 @@ export declare class NeuroEngine {
      */
     private initializeAgents;
     /**
-     * Process a user message
+     * Process a user message — Claude Code style
+     * Every task is sent to the best agent which runs until completion.
+     * No arbitrary early termination — the agent keeps working until done.
      */
     processMessage(message: string, mode?: 'auto' | 'agent' | 'direct', targetAgent?: string): Promise<{
         content: string;
@@ -153,8 +155,9 @@ export declare class NeuroEngine {
      */
     private handleApproval;
     /**
-     * Assess task complexity to decide execution mode
-     * Now delegates to ModelRouter for more sophisticated analysis
+     * Assess task complexity — delegates to ModelRouter
+     * Note: complexity no longer determines execution mode (all tasks run until complete)
+     * but is still used for model selection
      */
     private assessComplexity;
     /**

package/dist/core/engine.js

@@ -1,5 +1,5 @@
 // ============================================================
-// NeuroCLI - NeuroEngine v4.1.3
+// NeuroCLI - NeuroEngine v5.0 (Claude Code-style Agentic Loop)
 // The main engine that ties everything together
 // Now with: Sandbox, Plugin SDK, Enhanced MCP, Enhanced Approval,
 // Model Router, Prompt Cache, Undo/Redo, Output Styles,
@@ -483,7 +483,7 @@ export class NeuroEngine {
         this.gitWorktree = new GitWorktreeManager(process.cwd());
         // Auto-Updater
         this.updater = new AutoUpdater({
-            currentVersion: '4.1.3',
+            currentVersion: '5.0.0',
             autoCheck: true,
             autoUpdate: false,
         });
@@ -523,6 +523,7 @@ Key responsibilities:
 - Manage dependencies between sub-tasks
 - Synthesize results from multiple agents
 - Handle errors and re-plan if needed
+- IMPORTANT: Keep working until the ENTIRE task is COMPLETE
 
 Always consider the strengths of each agent when delegating:
 - Planner: For task decomposition and architecture decisions
@@ -537,7 +538,7 @@ Always consider the strengths of each agent when delegating:
             temperature: 0.7,
             maxTokens: 4096,
             tools: [],
-            maxIterations: 20,
+            maxIterations: 0, // 0 = no limit, run until done
         };
         this.orchestrator = new Orchestrator(orchestratorConfig, this.client, this.registry, process.cwd(), this.sessionManager.getCurrent()?.id || 'default');
         // Register all agents with orchestrator
@@ -634,7 +635,9 @@ Always consider the strengths of each agent when delegating:
         }
     }
     /**
-     * Process a user message
+     * Process a user message — Claude Code style
+     * Every task is sent to the best agent which runs until completion.
+     * No arbitrary early termination — the agent keeps working until done.
      */
     async processMessage(message, mode = 'auto', targetAgent) {
         // Check spending limit via spending monitor
@@ -687,7 +690,7 @@ Always consider the strengths of each agent when delegating:
         const skillAdditions = this.skillSystem.getSystemPromptAdditions();
         const styleAddition = this.styleManager.getSystemPromptAddition();
         const thinkingAddition = this.extendedThinking.getSystemPromptAddition();
-        // Build UI callbacks
+        // Build UI callbacks — Claude Code style
         const callbacks = {
             onThinking: (thinking) => this.ui.thinking(thinking),
             onToken: (token) => this.ui.streamingToken(token),
@@ -702,28 +705,32 @@ Always consider the strengths of each agent when delegating:
                     return;
                 }
                 this.ui.toolCall(name, args);
-                // Record in undo/redo for file modification tools
-                if (['write_file', 'edit_file', 'apply_diff', 'delete_file'].includes(name)) {
-                    // The undo/redo push will happen in the tool execution result handler
-                }
             },
             onToolResult: (name, result, isError) => this.ui.toolResult(name, result, isError),
             onApprovalNeeded: async (name, args, risk) => {
                 return this.handleApproval(name, args, risk);
             },
-            onIteration: (i, max) => {
-                this.ui.info(`Iteration ${i}/${max}`);
+            onIteration: (i, _max) => {
+                // Claude Code style: show iteration count without a ceiling
+                this.ui.agentActivity(this.config.defaultModel, 'working', `step ${i}`);
+            },
+            onCycleStart: (cycle, summary) => {
+                this.ui.agentActivity(this.config.defaultModel, 'working', `cycle ${cycle}: ${summary}`);
+            },
+            onTaskComplete: (reason) => {
+                this.ui.agentActivity(this.config.defaultModel, 'done', reason);
             },
         };
         let result;
         const activeModel = routeDecision?.model || this.config.defaultModel;
+        // === Claude Code-style routing: always send to the best agent and let it run until done ===
         if (mode === 'direct' && targetAgent) {
+            // Direct mode: use specified agent
             const agent = this.agents.get(targetAgent);
             if (!agent) {
                 this.ui.error(`Agent not found: ${targetAgent}`);
                 return { content: '', usage: { inputTokens: 0, outputTokens: 0, cost: 0 } };
             }
-            // Override agent model if defaultModel differs from agent's model
             const originalModel = agent.configModel;
             if (this.config.defaultModel !== originalModel) {
                 agent.configModel = this.config.defaultModel;
@@ -735,10 +742,10 @@ Always consider the strengths of each agent when delegating:
             finally {
                 this.ui.endStreaming();
             }
-            // Restore original model
             agent.configModel = originalModel;
         }
         else if (mode === 'agent') {
+            // Orchestration mode: multi-agent with re-planning
             const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
             result = {
                 content: orchestrateResult.content,
@@ -749,58 +756,52 @@ Always consider the strengths of each agent when delegating:
             };
         }
         else {
-            const complexity = routeDecision?.complexity || this.assessComplexity(message);
+            // Auto mode — Claude Code style: route to best agent, let it run until done
             const category = routeDecision?.category || this.modelRouter.getCategory(message);
-            if (complexity === 'simple') {
-                // Route to the best agent based on task category
-                const targetAgentName = this.selectAgentForCategory(category);
-                const agent = this.agents.get(targetAgentName);
-                if (agent) {
-                    this.ui.info(`Using ${targetAgentName} agent (${category} task)`);
+            const targetAgentName = this.selectAgentForCategory(category);
+            const agent = this.agents.get(targetAgentName);
+            if (agent) {
+                // Override agent model with routed model if different
+                const originalModel = agent.configModel;
+                if (activeModel !== originalModel) {
+                    agent.configModel = activeModel;
+                }
+                this.ui.info(`Using ${targetAgentName} agent (${category} task) — will run until complete`);
+                this.ui.startStreaming();
+                try {
+                    result = await agent.run(message, callbacks);
+                }
+                finally {
+                    this.ui.endStreaming();
+                }
+                // Restore original model
+                agent.configModel = originalModel;
+            }
+            else {
+                // Fallback: try Coder, then orchestrator
+                const coderAgent = this.agents.get('Coder');
+                if (coderAgent) {
+                    this.ui.info(`Using Coder agent — will run until complete`);
                     this.ui.startStreaming();
                     try {
-                        result = await agent.run(message, callbacks);
+                        result = await coderAgent.run(message, callbacks);
                     }
                     finally {
                         this.ui.endStreaming();
                     }
                 }
                 else {
-                    // Fallback to Coder
-                    const coderAgent = this.agents.get('Coder');
-                    if (coderAgent) {
-                        this.ui.startStreaming();
-                        try {
-                            result = await coderAgent.run(message, callbacks);
-                        }
-                        finally {
-                            this.ui.endStreaming();
-                        }
-                    }
-                    else {
-                        this.ui.warning('No agents initialized, using orchestration mode');
-                        const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
-                        result = {
-                            content: orchestrateResult.content,
-                            toolCallsMade: 0,
-                            iterations: orchestrateResult.execution.iterations,
-                            usage: orchestrateResult.totalUsage,
-                            execution: orchestrateResult.execution,
-                        };
-                    }
+                    this.ui.warning('No agents initialized, using orchestration mode');
+                    const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
+                    result = {
+                        content: orchestrateResult.content,
+                        toolCallsMade: 0,
+                        iterations: orchestrateResult.execution.iterations,
+                        usage: orchestrateResult.totalUsage,
+                        execution: orchestrateResult.execution,
+                    };
                 }
             }
-            else {
-                this.ui.thinking('Analyzing task complexity... Using multi-agent orchestration');
-                const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
-                result = {
-                    content: orchestrateResult.content,
-                    toolCallsMade: 0,
-                    iterations: orchestrateResult.execution.iterations,
-                    usage: orchestrateResult.totalUsage,
-                    execution: orchestrateResult.execution,
-                };
-            }
         }
         // Parse extended thinking blocks from response
         const thinkingResult = this.extendedThinking.parseResponse(result.content);
@@ -914,8 +915,9 @@ Always consider the strengths of each agent when delegating:
         return result.approved;
     }
     /**
-     * Assess task complexity to decide execution mode
-     * Now delegates to ModelRouter for more sophisticated analysis
+     * Assess task complexity — delegates to ModelRouter
+     * Note: complexity no longer determines execution mode (all tasks run until complete)
+     * but is still used for model selection
      */
     assessComplexity(message) {
         const decision = this.modelRouter.route(message);

package/dist/core/model-router.js

@@ -72,7 +72,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(hello|hi|thanks|yes|no|ok|sure|done|correct|right|please)\b/i,
         ],
         lengthThreshold: 80,
-        maxSteps: 5,
+        maxSteps: 0, // 0 = no limit (Claude Code style)
     },
     moderate: {
         patterns: [
@@ -83,7 +83,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(refactor|clean|simplify|optimize|restructure)\b/i,
         ],
         lengthThreshold: 300,
-        maxSteps: 15,
+        maxSteps: 0, // 0 = no limit (Claude Code style)
     },
     complex: {
         patterns: [
@@ -97,7 +97,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(security\s+(audit|review|hardening)|performance\s+(optim|tuning|profiling)|scalab(ility|le))\b/i,
         ],
         lengthThreshold: 500,
-        maxSteps: 30,
+        maxSteps: 0, // 0 = no limit (Claude Code style)
     },
 };
 // ---------------------------------------------------------------------------

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // ============================================================
 // NeuroCLI - Advanced AI Terminal Coding Assistant
-// Main Entry Point - v4.1.3 with robust error handling
+// Main Entry Point - v5.0 (Claude Code-style Agentic Loop)
 // ============================================================
 import { Command } from 'commander';
 import { createInterface } from 'readline';
@@ -16,7 +16,7 @@ import { HeadlessMode } from './core/headless.js';
 import { ShellCompletionGenerator } from './core/shell-completion.js';
 import chalk from 'chalk';
 import { AutoUpdater } from './core/updater.js';
-const VERSION = '4.3.0';
+const VERSION = '5.0.0';
 // ---- Global Error Handlers (prevent crashes) ----
 process.on('unhandledRejection', (reason) => {
     console.error(chalk.red('\n⚠️ Unhandled promise rejection:'), reason);

package/dist/ui/renderer.d.ts

@@ -21,7 +21,7 @@ export declare class TerminalUI {
     approvalRequest(toolName: string, args: Record<string, unknown>, risk: 'low' | 'medium' | 'high'): boolean;
     tokenUsage(usage: TokenUsage, modelId: string): void;
     sessionStats(totalInput: number, totalOutput: number, totalCost: number): void;
-    agentActivity(agentName: string, status: 'starting' | 'working' | 'done' | 'error'): void;
+    agentActivity(agentName: string, status: 'starting' | 'working' | 'done' | 'error', detail?: string): void;
     error(message: string): void;
     info(message: string): void;
     success(message: string): void;

package/dist/ui/renderer.js

@@ -165,7 +165,7 @@ export class TerminalUI {
         console.log(`  ${this.theme.muted('Session:')}`, this.theme.dim(`${totalInput.toLocaleString()} in · ${totalOutput.toLocaleString()} out · $${totalCost.toFixed(4)}`));
     }
     // ── Agent Activity (subtle indicator) ───────────────────
-    agentActivity(agentName, status) {
+    agentActivity(agentName, status, detail) {
         const indicators = {
             starting: this.theme.muted('○'),
             working: this.theme.accent('◎'),
@@ -178,7 +178,8 @@ export class TerminalUI {
             done: 'done',
             error: 'failed',
         };
-        console.log(`  ${indicators[status]} ${this.theme.muted(agentName)} ${this.theme.dim(statusText[status])}`);
+        const detailStr = detail ? ` ${this.theme.dim(detail)}` : '';
+        console.log(`  ${indicators[status]} ${this.theme.muted(agentName)} ${this.theme.dim(statusText[status])}${detailStr}`);
     }
     // ── Status Messages (minimal) ───────────────────────────
     error(message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuro-cli",
-  "version": "4.3.0",
+  "version": "5.0.0",
   "description": "Advanced AI-powered terminal coding assistant with multi-agent orchestration, sub-agent spawning, ACP protocol, OS-level sandboxing, spec-driven development, smart monitoring, multi-model routing, MCP Apps, auto-updater, and 23+ free models",
   "main": "dist/index.js",
   "bin": {