neuro-cli 4.2.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) {