attocode 0.2.0 → 0.2.2

package/dist/src/agent.js

@@ -21,7 +21,11 @@
 import { buildConfig, isFeatureEnabled, getEnabledFeatures, getSubagentTimeout, getSubagentMaxIterations, } from './defaults.js';
 import { createModeManager, formatModeList, parseMode, calculateTaskSimilarity, SUBAGENT_PLAN_MODE_ADDITION, } from './modes.js';
 import { createLSPFileTools, } from './agent-tools/index.js';
-import { HookManager, MemoryManager, PlanningManager, ObservabilityManager, SafetyManager, RoutingManager, MultiAgentManager, ReActManager, ExecutionPolicyManager, ThreadManager, RulesManager, DEFAULT_RULE_SOURCES, ExecutionEconomicsManager, STANDARD_BUDGET, SUBAGENT_BUDGET, TIMEOUT_WRAPUP_PROMPT, AgentRegistry, filterToolsForAgent, formatAgentList, createCancellationManager, isCancellationError, createLinkedToken, createGracefulTimeout, race, createResourceManager, createLSPManager, createSemanticCacheManager, createSkillManager, formatSkillList, createContextEngineering, stableStringify, createCodebaseContext, buildContextFromChunks, createSharedFileCache, createBudgetPool, createPendingPlanManager, createInteractivePlanner, createRecursiveContext, createLearningStore, createCompactor, createAutoCompactionManager, createFileChangeTracker, createCapabilitiesRegistry, createSharedBlackboard, createTaskManager, createSwarmOrchestrator, createThrottledProvider, FREE_TIER_THROTTLE, PAID_TIER_THROTTLE, } from './integrations/index.js';
+import { HookManager, MemoryManager, PlanningManager, ObservabilityManager, SafetyManager, RoutingManager, MultiAgentManager, ReActManager, ExecutionPolicyManager, ThreadManager, RulesManager, DEFAULT_RULE_SOURCES, ExecutionEconomicsManager, STANDARD_BUDGET, SUBAGENT_BUDGET, TIMEOUT_WRAPUP_PROMPT, AgentRegistry, filterToolsForAgent, formatAgentList, createCancellationManager, isCancellationError, createLinkedToken, createGracefulTimeout, race, createResourceManager, createLSPManager, createSemanticCacheManager, createSkillManager, formatSkillList, createContextEngineering, stableStringify, createCodebaseContext, buildContextFromChunks, createSharedFileCache, createBudgetPool, createDynamicBudgetPool, createPendingPlanManager, createInteractivePlanner, createRecursiveContext, createLearningStore, createCompactor, createAutoCompactionManager, createFileChangeTracker, createCapabilitiesRegistry, createSharedBlackboard, createTaskManager, createSwarmOrchestrator, createThrottledProvider, FREE_TIER_THROTTLE, PAID_TIER_THROTTLE, createWorkLog, createVerificationGate, 
+// Phase 2: Orchestration
+classifyComplexity, getScalingGuidance, buildDelegationPrompt, createMinimalDelegationSpec, getSubagentQualityPrompt, ToolRecommendationEngine, createToolRecommendationEngine, createInjectionBudgetManager, 
+// Phase 3: Advanced
+getThinkingSystemPrompt, createSelfImprovementProtocol, createSubagentOutputStore, createSerperSearchTool, getEnvironmentFacts, formatFactsBlock, createAutoCheckpointManager, createSubagentSupervisor, createSubagentHandle, } from './integrations/index.js';
 // Lesson 26: Tracing & Evaluation integration
 import { createTraceCollector } from './tracing/trace-collector.js';
 // Model registry for context window limits
@@ -34,6 +38,119 @@ import { createTaskTools, } from './tools/tasks.js';
 // =============================================================================
 // PRODUCTION AGENT
 // =============================================================================
+/**
+ * Tools that are safe to execute in parallel (read-only, no side effects).
+ * These tools don't modify state, so running them concurrently is safe.
+ */
+export const PARALLELIZABLE_TOOLS = new Set([
+    'read_file', 'glob', 'grep', 'list_files', 'search_files',
+    'search_code', 'get_file_info',
+]);
+/**
+ * Tools that can run in parallel IF they target different files.
+ * write_file and edit_file on different paths are safe to parallelize.
+ */
+export const CONDITIONALLY_PARALLEL_TOOLS = new Set([
+    'write_file', 'edit_file',
+]);
+/**
+ * Extract the target file path from a tool call's arguments.
+ * Returns null if no file path can be determined.
+ */
+export function extractToolFilePath(toolCall) {
+    // Check common argument patterns
+    const args = toolCall;
+    for (const key of ['path', 'file_path', 'filename', 'file']) {
+        if (typeof args[key] === 'string')
+            return args[key];
+    }
+    // Check nested args object
+    if (args.args && typeof args.args === 'object') {
+        const nested = args.args;
+        for (const key of ['path', 'file_path', 'filename', 'file']) {
+            if (typeof nested[key] === 'string')
+                return nested[key];
+        }
+    }
+    // Check input object (common in structured tool calls)
+    if (args.input && typeof args.input === 'object') {
+        const input = args.input;
+        for (const key of ['path', 'file_path', 'filename', 'file']) {
+            if (typeof input[key] === 'string')
+                return input[key];
+        }
+    }
+    return null;
+}
+/**
+ * Check if a conditionally-parallel tool call conflicts with any tool
+ * in the current accumulator (same file path).
+ */
+function hasFileConflict(toolCall, accumulator) {
+    const path = extractToolFilePath(toolCall);
+    if (!path)
+        return true; // Can't determine path → assume conflict
+    for (const existing of accumulator) {
+        const existingPath = extractToolFilePath(existing);
+        if (existingPath === path)
+            return true; // Same file → conflict
+    }
+    return false;
+}
+/**
+ * Groups tool calls into batches for parallel/sequential execution.
+ * Uses accumulate-and-flush: parallelizable tools accumulate until a
+ * non-parallelizable tool flushes them as a batch. This produces optimal
+ * batching even for non-consecutive parallelizable tools.
+ *
+ * Enhanced with conditional parallelism: write_file/edit_file on
+ * DIFFERENT files can be batched together for parallel execution.
+ *
+ * Example: [read1, read2, write, read3, grep] → [[read1, read2], [write], [read3, grep]]
+ * (Previous algorithm produced 4 batches; this produces 3)
+ *
+ * Enhanced: [write_a, write_b, write_a] → [[write_a, write_b], [write_a]]
+ * (Different files parallelized, same file sequential)
+ */
+export function groupToolCallsIntoBatches(toolCalls, isParallelizable = (tc) => PARALLELIZABLE_TOOLS.has(tc.name), isConditionallyParallel = (tc) => CONDITIONALLY_PARALLEL_TOOLS.has(tc.name)) {
+    if (toolCalls.length === 0)
+        return [];
+    const batches = [];
+    let parallelAccum = [];
+    for (const toolCall of toolCalls) {
+        if (isParallelizable(toolCall)) {
+            parallelAccum.push(toolCall);
+        }
+        else if (isConditionallyParallel(toolCall)) {
+            // Can parallelize if no file conflict with existing accumulator
+            if (!hasFileConflict(toolCall, parallelAccum)) {
+                parallelAccum.push(toolCall);
+            }
+            else {
+                // Conflict: flush current batch, start new one with this tool
+                if (parallelAccum.length > 0) {
+                    batches.push(parallelAccum);
+                    parallelAccum = [];
+                }
+                parallelAccum.push(toolCall);
+            }
+        }
+        else {
+            // Flush any accumulated parallel tools as a single batch
+            if (parallelAccum.length > 0) {
+                batches.push(parallelAccum);
+                parallelAccum = [];
+            }
+            // Non-parallelizable tool gets its own batch
+            batches.push([toolCall]);
+        }
+    }
+    // Flush remaining parallel tools
+    if (parallelAccum.length > 0) {
+        batches.push(parallelAccum);
+    }
+    return batches;
+}
 /**
  * Production-ready agent that composes all features.
  */
@@ -73,12 +190,22 @@ export class ProductionAgent {
     fileChangeTracker = null;
     capabilitiesRegistry = null;
     toolResolver = null;
+    agentId;
     blackboard = null;
     fileCache = null;
     budgetPool = null;
     taskManager = null;
     store = null;
     swarmOrchestrator = null;
+    workLog = null;
+    verificationGate = null;
+    // Phase 2-4 integration modules
+    injectionBudget = null;
+    selfImprovement = null;
+    subagentOutputStore = null;
+    autoCheckpointManager = null;
+    toolRecommendation = null;
+    lastComplexityAssessment = null;
     // Duplicate spawn prevention - tracks recently spawned tasks to prevent doom loops
     // Map<taskKey, { timestamp: number; result: string; queuedChanges: number }>
     spawnedTasks = new Map();
@@ -124,6 +251,8 @@ export class ProductionAgent {
         // Build complete config with defaults
         this.config = buildConfig(userConfig);
         this.provider = userConfig.provider;
+        // Set unique agent ID (passed from spawnAgent for subagents, auto-generated for parents)
+        this.agentId = userConfig.agentId || `agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         // Initialize tool registry
         this.tools = new Map();
         for (const tool of this.config.tools) {
@@ -271,6 +400,19 @@ export class ProductionAgent {
             maxIterations: this.config.maxIterations,
             targetIterations: Math.min(baseBudget.targetIterations ?? 20, this.config.maxIterations),
         });
+        // Work Log - compaction-resilient summary of agent work
+        // Always enabled - minimal overhead and critical for long-running tasks
+        this.workLog = createWorkLog();
+        // Verification Gate - opt-in completion verification
+        if (this.config.verificationCriteria) {
+            this.verificationGate = createVerificationGate(this.config.verificationCriteria);
+        }
+        // Phase 2-4: Orchestration & Advanced modules (always enabled, lightweight)
+        this.injectionBudget = createInjectionBudgetManager();
+        this.selfImprovement = createSelfImprovementProtocol(undefined, this.learningStore ?? undefined);
+        this.subagentOutputStore = createSubagentOutputStore({ persistToFile: false });
+        this.autoCheckpointManager = createAutoCheckpointManager({ enabled: true });
+        this.toolRecommendation = createToolRecommendationEngine();
         // Agent Registry - always enabled for subagent support
         this.agentRegistry = new AgentRegistry();
         // Load user agents asynchronously - tracked for ensureReady()
@@ -301,6 +443,15 @@ export class ProductionAgent {
         for (const tool of taskTools) {
             this.tools.set(tool.name, tool);
         }
+        // Built-in web search (Serper API) — gracefully handles missing API key
+        const serperCustomTool = createSerperSearchTool();
+        this.tools.set('web_search', {
+            name: serperCustomTool.name,
+            description: serperCustomTool.description,
+            parameters: serperCustomTool.inputSchema,
+            execute: serperCustomTool.execute,
+            dangerLevel: 'safe',
+        });
         // Swarm Mode (experimental)
         if (this.config.swarm) {
             const swarmConfig = this.config.swarm;
@@ -797,6 +948,10 @@ export class ProductionAgent {
         try {
             // Check for cancellation before starting
             cancellationToken?.throwIfCancellationRequested();
+            // Classify task complexity for scaling guidance
+            this.lastComplexityAssessment = classifyComplexity(task, {
+                hasActivePlan: !!this.state.plan,
+            });
             // Check if swarm mode should handle this task
             if (this.swarmOrchestrator) {
                 const swarmResult = await this.runSwarm(task);
@@ -1079,6 +1234,14 @@ export class ProductionAgent {
                                     content: `[CONTEXT REDUCED: Earlier messages were removed to stay within budget. Conversation continues from recent context.]`,
                                 });
                                 messages.push(...recentMessages);
+                                // Inject work log after emergency truncation to prevent amnesia
+                                if (this.workLog?.hasContent()) {
+                                    const workLogMessage = {
+                                        role: 'user',
+                                        content: this.workLog.toCompactString(),
+                                    };
+                                    messages.push(workLogMessage);
+                                }
                                 // Update state messages too
                                 this.state.messages.length = 0;
                                 this.state.messages.push(...messages);
@@ -1259,6 +1422,35 @@ export class ProductionAgent {
                     }
                 }
                 // =====================================================================
+                // INJECTION BUDGET ANALYSIS (Phase 2 - monitoring mode)
+                // Collects stats on context injections without gating; logs when
+                // budget would have dropped items. Validates system before enabling gating.
+                // =====================================================================
+                if (this.injectionBudget) {
+                    const proposals = [];
+                    if (budgetInjectedPrompt) {
+                        proposals.push({ name: 'budget_warning', priority: 0, maxTokens: 500, content: budgetInjectedPrompt });
+                    }
+                    // Approximate recitation content (actual injection handled above)
+                    if (this.contextEngineering) {
+                        const failureCtx = this.contextEngineering.getFailureContext(5);
+                        if (failureCtx) {
+                            proposals.push({ name: 'failure_context', priority: 2, maxTokens: 300, content: failureCtx });
+                        }
+                    }
+                    if (proposals.length > 0) {
+                        const accepted = this.injectionBudget.allocate(proposals);
+                        const stats = this.injectionBudget.getLastStats();
+                        if (stats && stats.droppedNames.length > 0 && process.env.DEBUG) {
+                            console.log(`[injection-budget] Would drop: ${stats.droppedNames.join(', ')} (${stats.proposedTokens} proposed, ${stats.acceptedTokens} accepted)`);
+                        }
+                        // Log total injection overhead for observability
+                        if (stats && process.env.DEBUG_LLM) {
+                            console.log(`[injection-budget] Iteration ${this.state.iteration}: ${accepted.length}/${proposals.length} injections, ~${stats.acceptedTokens} tokens`);
+                        }
+                    }
+                }
+                // =====================================================================
                 // RESILIENT LLM CALL: Empty response retries + max_tokens continuation
                 // =====================================================================
                 // Get resilience config
@@ -1554,6 +1746,24 @@ export class ProductionAgent {
                         });
                         incompleteActionRetries = 0;
                     }
+                    // Verification gate: if criteria not met, nudge agent to verify before completing
+                    if (this.verificationGate && !forceTextOnly) {
+                        const vResult = this.verificationGate.check();
+                        if (!vResult.satisfied && !vResult.forceAllow && vResult.nudge) {
+                            // Inject nudge and continue the loop
+                            const nudgeMessage = {
+                                role: 'user',
+                                content: vResult.nudge,
+                            };
+                            messages.push(nudgeMessage);
+                            this.state.messages.push(nudgeMessage);
+                            this.observability?.logger?.info('Verification gate nudge', {
+                                missing: vResult.missing,
+                                nudgeCount: this.verificationGate.getState().nudgeCount,
+                            });
+                            continue;
+                        }
+                    }
                     // No tool calls (or forced to ignore), agent is done - compact tool outputs to save context
                     // The model has "consumed" the tool outputs and produced a response,
                     // so we can replace verbose outputs with compact summaries
@@ -1590,12 +1800,33 @@ export class ProductionAgent {
                 // Execute tool calls (we know toolCalls is defined here due to the check above)
                 const toolCalls = response.toolCalls;
                 const toolResults = await this.executeToolCalls(toolCalls);
-                // Record tool calls for economics/progress tracking
+                // Record tool calls for economics/progress tracking + work log
                 for (let i = 0; i < toolCalls.length; i++) {
                     const toolCall = toolCalls[i];
                     const result = toolResults[i];
                     executedToolNames.add(toolCall.name);
                     this.economics?.recordToolCall(toolCall.name, toolCall.arguments, result?.result);
+                    // Record in work log for compaction resilience
+                    const toolOutput = result?.result && typeof result.result === 'object' && 'output' in result.result
+                        ? String(result.result.output)
+                        : typeof result?.result === 'string' ? result.result : undefined;
+                    this.workLog?.recordToolExecution(toolCall.name, toolCall.arguments, toolOutput);
+                    // Record in verification gate
+                    if (this.verificationGate) {
+                        if (toolCall.name === 'bash') {
+                            const toolRes = result?.result;
+                            const output = toolRes && typeof toolRes === 'object' && 'output' in toolRes
+                                ? String(toolRes.output)
+                                : typeof toolRes === 'string' ? toolRes : '';
+                            const exitCode = toolRes && typeof toolRes === 'object' && toolRes.metadata
+                                ? toolRes.metadata.exitCode ?? null
+                                : null;
+                            this.verificationGate.recordBashExecution(String(toolCall.arguments.command || ''), output, exitCode);
+                        }
+                        if (['write_file', 'edit_file'].includes(toolCall.name)) {
+                            this.verificationGate.recordFileChange();
+                        }
+                    }
                 }
                 // Add tool results to messages (with truncation and proactive budget management)
                 const MAX_TOOL_OUTPUT_CHARS = 8000; // ~2000 tokens max per tool output
@@ -1617,6 +1848,15 @@ export class ProductionAgent {
                         messages.push(...compactionResult.compactedMessages);
                         this.state.messages.length = 0;
                         this.state.messages.push(...compactionResult.compactedMessages);
+                        // Inject work log after compaction to prevent amnesia
+                        if (this.workLog?.hasContent()) {
+                            const workLogMessage = {
+                                role: 'user',
+                                content: this.workLog.toCompactString(),
+                            };
+                            messages.push(workLogMessage);
+                            this.state.messages.push(workLogMessage);
+                        }
                     }
                     else if (compactionResult.status === 'hard_limit') {
                         // Hard limit reached - this is serious, emit error
@@ -1811,12 +2051,25 @@ export class ProductionAgent {
             }
         }
         // Build system prompt using cache-aware builder if available (Trick P)
-        // Combine memory, learnings, and codebase context
-        const combinedContext = [
+        // Combine memory, learnings, codebase context, and environment facts
+        const combinedContextParts = [
+            // Environment facts — temporal/platform grounding (prevents stale date hallucinations)
+            formatFactsBlock(getEnvironmentFacts()),
             ...(memoryContext.length > 0 ? memoryContext : []),
             ...(learningsContext ? [learningsContext] : []),
             ...(codebaseContextStr ? [`\n## Relevant Code\n${codebaseContextStr}`] : []),
-        ].join('\n');
+        ];
+        // Inject thinking directives and scaling guidance for non-simple tasks
+        if (this.lastComplexityAssessment) {
+            const thinkingPrompt = getThinkingSystemPrompt(this.lastComplexityAssessment.tier);
+            if (thinkingPrompt) {
+                combinedContextParts.push(thinkingPrompt);
+            }
+            if (this.lastComplexityAssessment.tier !== 'simple') {
+                combinedContextParts.push(getScalingGuidance(this.lastComplexityAssessment));
+            }
+        }
+        const combinedContext = combinedContextParts.join('\n');
         const promptOptions = {
             rules: rulesContent + (skillsPrompt ? '\n\n' + skillsPrompt : ''),
             tools: toolDescriptions,
@@ -1882,9 +2135,12 @@ export class ProductionAgent {
         this.emit({ type: 'llm.start', model: this.config.model || 'default' });
         // Prompt caching (Improvement P1): Replace the system message with structured content
         // that includes cache_control markers, enabling 60-70% cache hit rates.
-        // The original Message[] is kept for token estimation; the provider gets MessageWithContent[].
+        // Only use structured cache_control markers for Anthropic models — other providers
+        // (DeepSeek, Grok, etc.) use automatic prefix-based caching and don't understand these markers.
+        const configModel = this.config.model || 'default';
+        const isAnthropicModel = configModel.startsWith('anthropic/') || configModel.startsWith('claude-');
         let providerMessages = messages;
-        if (this.cacheableSystemBlocks && this.cacheableSystemBlocks.length > 0) {
+        if (isAnthropicModel && this.cacheableSystemBlocks && this.cacheableSystemBlocks.length > 0) {
             providerMessages = messages.map((m, i) => {
                 if (i === 0 && m.role === 'system') {
                     // Replace system message with structured cacheable content
@@ -1953,6 +2209,8 @@ export class ProductionAgent {
                 },
             },
         });
+        // Pause duration budget during LLM call - network time shouldn't count against agent
+        this.economics?.pauseDuration();
         try {
             let response;
             let actualModel = model;
@@ -1967,7 +2225,7 @@ export class ProductionAgent {
                     taskType: 'general',
                     estimatedTokens: messages.reduce((sum, m) => sum + m.content.length / 4, 0),
                 };
-                const result = await this.routing.executeWithFallback(messages, context);
+                const result = await this.routing.executeWithFallback(providerMessages, context);
                 response = result.response;
                 actualModel = result.model;
                 // Emit routing insight
@@ -2017,6 +2275,14 @@ export class ProductionAgent {
                 });
             }
             const duration = Date.now() - startTime;
+            // Debug cache stats when DEBUG_CACHE is set
+            if (process.env.DEBUG_CACHE) {
+                const cr = response.usage?.cacheReadTokens ?? 0;
+                const cw = response.usage?.cacheWriteTokens ?? 0;
+                const inp = response.usage?.inputTokens ?? 0;
+                const hitRate = inp > 0 ? ((cr / inp) * 100).toFixed(1) : '0.0';
+                console.log(`[Cache] model=${actualModel} read=${cr} write=${cw} input=${inp} hit=${hitRate}%`);
+            }
             // Lesson 26: Record LLM response for tracing
             this.traceCollector?.record({
                 type: 'llm.response',
@@ -2084,6 +2350,10 @@ export class ProductionAgent {
             this.observability?.tracer?.endSpan(spanId);
             throw error;
         }
+        finally {
+            // Resume duration budget after LLM call completes (success or failure)
+            this.economics?.resumeDuration();
+        }
     }
     /**
      * Execute an async callback while excluding wall-clock wait time from duration budgeting.
@@ -2100,324 +2370,360 @@ export class ProductionAgent {
     }
     /**
      * Execute tool calls with safety checks and execution policy enforcement.
+     * Parallelizable read-only tools are batched and executed concurrently.
      */
     async executeToolCalls(toolCalls) {
         const results = [];
-        for (const toolCall of toolCalls) {
-            const spanId = this.observability?.tracer?.startSpan(`tool.${toolCall.name}`);
-            const executionId = `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            this.emit({ type: 'tool.start', tool: toolCall.name, args: toolCall.arguments });
-            const startTime = Date.now();
-            // Lesson 26: Record tool start for tracing
+        // Group consecutive parallelizable tool calls into batches
+        const batches = groupToolCallsIntoBatches(toolCalls);
+        // Execute batches: parallel batches use Promise.allSettled, sequential execute one-by-one
+        for (const batch of batches) {
+            if (batch.length > 1 && PARALLELIZABLE_TOOLS.has(batch[0].name)) {
+                // Execute parallelizable batch concurrently
+                const batchResults = await Promise.allSettled(batch.map(tc => this.executeSingleToolCall(tc)));
+                for (const result of batchResults) {
+                    if (result.status === 'fulfilled') {
+                        results.push(result.value);
+                    }
+                    else {
+                        // Should not happen since executeSingleToolCall catches errors internally
+                        const error = result.reason instanceof Error ? result.reason.message : String(result.reason);
+                        results.push({ callId: 'unknown', result: `Error: ${error}`, error });
+                    }
+                }
+            }
+            else {
+                // Execute sequentially
+                for (const tc of batch) {
+                    results.push(await this.executeSingleToolCall(tc));
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Execute a single tool call with all safety checks, tracing, and error handling.
+     */
+    async executeSingleToolCall(toolCall) {
+        const spanId = this.observability?.tracer?.startSpan(`tool.${toolCall.name}`);
+        const executionId = `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.emit({ type: 'tool.start', tool: toolCall.name, args: toolCall.arguments });
+        const startTime = Date.now();
+        // Short-circuit if tool call arguments failed to parse
+        if (toolCall.parseError) {
+            const errorMsg = `Tool arguments could not be parsed: ${toolCall.parseError}. Please retry with complete, valid JSON.`;
+            this.emit({ type: 'tool.blocked', tool: toolCall.name, reason: errorMsg });
             this.traceCollector?.record({
-                type: 'tool.start',
-                data: {
-                    executionId,
-                    toolName: toolCall.name,
-                    arguments: toolCall.arguments,
-                },
+                type: 'tool.end',
+                data: { executionId, status: 'error', error: new Error(errorMsg), durationMs: Date.now() - startTime },
             });
-            try {
-                // =====================================================================
-                // PLAN MODE WRITE INTERCEPTION
-                // =====================================================================
-                // In plan mode, intercept write operations and queue them as proposed changes
-                if (this.modeManager.shouldInterceptTool(toolCall.name, toolCall.arguments)) {
-                    // Extract contextual reasoning instead of simple truncation
-                    const reason = this.extractChangeReasoning(toolCall, this.state.messages);
-                    // Start a new plan if needed
-                    if (!this.pendingPlanManager.hasPendingPlan()) {
-                        const lastUserMsg = [...this.state.messages].reverse().find(m => m.role === 'user');
-                        const task = typeof lastUserMsg?.content === 'string' ? lastUserMsg.content : 'Plan';
-                        this.pendingPlanManager.startPlan(task);
-                    }
-                    // Queue the write operation
-                    const change = this.pendingPlanManager.addProposedChange(toolCall.name, toolCall.arguments, reason, toolCall.id);
-                    // Emit event for UI
-                    this.emit({
-                        type: 'plan.change.queued',
-                        tool: toolCall.name,
-                        changeId: change?.id,
-                        summary: this.formatToolArgsForPlan(toolCall.name, toolCall.arguments),
-                    });
-                    // Return a message indicating the change was queued
-                    const queueMessage = `[PLAN MODE] Change queued for approval:\n` +
-                        `Tool: ${toolCall.name}\n` +
-                        `${this.formatToolArgsForPlan(toolCall.name, toolCall.arguments)}\n` +
-                        `Use /show-plan to see all pending changes, /approve to execute, /reject to discard.`;
-                    results.push({
-                        callId: toolCall.id,
-                        result: queueMessage,
-                    });
-                    this.observability?.tracer?.endSpan(spanId);
-                    continue; // Skip actual execution
+            this.observability?.tracer?.endSpan(spanId);
+            return { callId: toolCall.id, result: `Error: ${errorMsg}`, error: errorMsg };
+        }
+        // Lesson 26: Record tool start for tracing
+        this.traceCollector?.record({
+            type: 'tool.start',
+            data: {
+                executionId,
+                toolName: toolCall.name,
+                arguments: toolCall.arguments,
+            },
+        });
+        try {
+            // =====================================================================
+            // PLAN MODE WRITE INTERCEPTION
+            // =====================================================================
+            // In plan mode, intercept write operations and queue them as proposed changes
+            if (this.modeManager.shouldInterceptTool(toolCall.name, toolCall.arguments)) {
+                // Extract contextual reasoning instead of simple truncation
+                const reason = this.extractChangeReasoning(toolCall, this.state.messages);
+                // Start a new plan if needed
+                if (!this.pendingPlanManager.hasPendingPlan()) {
+                    const lastUserMsg = [...this.state.messages].reverse().find(m => m.role === 'user');
+                    const task = typeof lastUserMsg?.content === 'string' ? lastUserMsg.content : 'Plan';
+                    this.pendingPlanManager.startPlan(task);
                 }
-                // =====================================================================
-                // EXECUTION POLICY ENFORCEMENT (Lesson 23)
-                // =====================================================================
-                let policyApprovedByUser = false;
-                if (this.executionPolicy) {
-                    const policyContext = {
-                        messages: this.state.messages,
-                        currentMessage: this.state.messages.find(m => m.role === 'user')?.content,
-                        previousToolCalls: toolCalls.slice(0, toolCalls.indexOf(toolCall)),
-                    };
-                    const evaluation = this.executionPolicy.evaluate(toolCall, policyContext);
-                    // Emit policy event
-                    this.emit({
-                        type: 'policy.evaluated',
-                        tool: toolCall.name,
-                        policy: evaluation.policy,
-                        reason: evaluation.reason,
-                    });
-                    // Emit decision transparency event
-                    this.emit({
-                        type: 'decision.tool',
-                        tool: toolCall.name,
-                        decision: evaluation.policy === 'forbidden' ? 'blocked'
-                            : evaluation.policy === 'prompt' ? 'prompted'
+                // Queue the write operation
+                const change = this.pendingPlanManager.addProposedChange(toolCall.name, toolCall.arguments, reason, toolCall.id);
+                // Emit event for UI
+                this.emit({
+                    type: 'plan.change.queued',
+                    tool: toolCall.name,
+                    changeId: change?.id,
+                    summary: this.formatToolArgsForPlan(toolCall.name, toolCall.arguments),
+                });
+                // Return a message indicating the change was queued
+                const queueMessage = `[PLAN MODE] Change queued for approval:\n` +
+                    `Tool: ${toolCall.name}\n` +
+                    `${this.formatToolArgsForPlan(toolCall.name, toolCall.arguments)}\n` +
+                    `Use /show-plan to see all pending changes, /approve to execute, /reject to discard.`;
+                this.observability?.tracer?.endSpan(spanId);
+                return { callId: toolCall.id, result: queueMessage };
+            }
+            // =====================================================================
+            // EXECUTION POLICY ENFORCEMENT (Lesson 23)
+            // =====================================================================
+            let policyApprovedByUser = false;
+            if (this.executionPolicy) {
+                const policyContext = {
+                    messages: this.state.messages,
+                    currentMessage: this.state.messages.find(m => m.role === 'user')?.content,
+                    previousToolCalls: [],
+                };
+                const evaluation = this.executionPolicy.evaluate(toolCall, policyContext);
+                // Emit policy event
+                this.emit({
+                    type: 'policy.evaluated',
+                    tool: toolCall.name,
+                    policy: evaluation.policy,
+                    reason: evaluation.reason,
+                });
+                // Emit decision transparency event
+                this.emit({
+                    type: 'decision.tool',
+                    tool: toolCall.name,
+                    decision: evaluation.policy === 'forbidden' ? 'blocked'
+                        : evaluation.policy === 'prompt' ? 'prompted'
+                            : 'allowed',
+                    policyMatch: evaluation.reason,
+                });
+                // Enhanced tracing: Record policy decision
+                this.traceCollector?.record({
+                    type: 'decision',
+                    data: {
+                        type: 'policy',
+                        decision: `Tool ${toolCall.name}: ${evaluation.policy}`,
+                        outcome: evaluation.policy === 'forbidden' ? 'blocked'
+                            : evaluation.policy === 'prompt' ? 'deferred'
                                 : 'allowed',
-                        policyMatch: evaluation.reason,
-                    });
-                    // Enhanced tracing: Record policy decision
-                    this.traceCollector?.record({
-                        type: 'decision',
-                        data: {
-                            type: 'policy',
-                            decision: `Tool ${toolCall.name}: ${evaluation.policy}`,
-                            outcome: evaluation.policy === 'forbidden' ? 'blocked'
-                                : evaluation.policy === 'prompt' ? 'deferred'
-                                    : 'allowed',
-                            reasoning: evaluation.reason,
-                            factors: [
-                                { name: 'policy', value: evaluation.policy },
-                                { name: 'requiresApproval', value: evaluation.requiresApproval ?? false },
-                            ],
-                            confidence: evaluation.intent?.confidence ?? 0.8,
-                        },
-                    });
-                    // Handle forbidden policy - always block
-                    if (evaluation.policy === 'forbidden') {
-                        throw new Error(`Forbidden by policy: ${evaluation.reason}`);
-                    }
-                    // Handle prompt policy - requires approval
-                    if (evaluation.policy === 'prompt' && evaluation.requiresApproval) {
-                        // Try to get approval through safety manager's human-in-loop
-                        const humanInLoop = this.safety?.humanInLoop;
-                        if (humanInLoop) {
-                            const approval = await this.withPausedDuration(() => humanInLoop.requestApproval(toolCall, `Policy requires approval: ${evaluation.reason}`));
-                            if (!approval.approved) {
-                                throw new Error(`Denied by user: ${approval.reason || 'No reason provided'}`);
-                            }
-                            policyApprovedByUser = true;
-                            // Create a grant for future similar calls if approved
-                            this.executionPolicy.createGrant({
-                                toolName: toolCall.name,
-                                grantedBy: 'user',
-                                reason: 'Approved during execution',
-                                maxUsages: 5, // Allow 5 more similar calls
-                            });
-                        }
-                        else {
-                            // No approval handler - block by default for safety
-                            throw new Error(`Policy requires approval but no approval handler available: ${evaluation.reason}`);
+                        reasoning: evaluation.reason,
+                        factors: [
+                            { name: 'policy', value: evaluation.policy },
+                            { name: 'requiresApproval', value: evaluation.requiresApproval ?? false },
+                        ],
+                        confidence: evaluation.intent?.confidence ?? 0.8,
+                    },
+                });
+                // Handle forbidden policy - always block
+                if (evaluation.policy === 'forbidden') {
+                    throw new Error(`Forbidden by policy: ${evaluation.reason}`);
+                }
+                // Handle prompt policy - requires approval
+                if (evaluation.policy === 'prompt' && evaluation.requiresApproval) {
+                    // Try to get approval through safety manager's human-in-loop
+                    const humanInLoop = this.safety?.humanInLoop;
+                    if (humanInLoop) {
+                        const approval = await this.withPausedDuration(() => humanInLoop.requestApproval(toolCall, `Policy requires approval: ${evaluation.reason}`));
+                        if (!approval.approved) {
+                            throw new Error(`Denied by user: ${approval.reason || 'No reason provided'}`);
                         }
-                    }
-                    // Log intent classification if available
-                    if (evaluation.intent) {
-                        this.emit({
-                            type: 'intent.classified',
-                            tool: toolCall.name,
-                            intent: evaluation.intent.type,
-                            confidence: evaluation.intent.confidence,
+                        policyApprovedByUser = true;
+                        // Create a grant for future similar calls if approved
+                        this.executionPolicy.createGrant({
+                            toolName: toolCall.name,
+                            grantedBy: 'user',
+                            reason: 'Approved during execution',
+                            maxUsages: 5, // Allow 5 more similar calls
                         });
                     }
-                }
-                // =====================================================================
-                // SAFETY VALIDATION (Lesson 20-21)
-                // =====================================================================
-                if (this.safety) {
-                    const safety = this.safety;
-                    const validation = await this.withPausedDuration(() => safety.validateAndApprove(toolCall, `Executing tool: ${toolCall.name}`, { skipHumanApproval: policyApprovedByUser }));
-                    if (!validation.allowed) {
-                        throw new Error(`Tool call blocked: ${validation.reason}`);
-                    }
-                }
-                // Get tool definition (with lazy-loading support for MCP tools)
-                let tool = this.tools.get(toolCall.name);
-                const wasPreloaded = !!tool;
-                if (!tool && this.toolResolver) {
-                    // Try to resolve and load the tool on-demand
-                    const resolved = this.toolResolver(toolCall.name);
-                    if (resolved) {
-                        this.addTool(resolved);
-                        tool = resolved;
-                        if (process.env.DEBUG)
-                            console.log(`  🔄 Auto-loaded MCP tool: ${toolCall.name}`);
-                        this.observability?.logger?.info('Tool auto-loaded', { tool: toolCall.name });
+                    else {
+                        // No approval handler - block by default for safety
+                        throw new Error(`Policy requires approval but no approval handler available: ${evaluation.reason}`);
                     }
                 }
-                if (!tool) {
-                    throw new Error(`Unknown tool: ${toolCall.name}`);
+                // Log intent classification if available
+                if (evaluation.intent) {
+                    this.emit({
+                        type: 'intent.classified',
+                        tool: toolCall.name,
+                        intent: evaluation.intent.type,
+                        confidence: evaluation.intent.confidence,
+                    });
                 }
-                // Log whether tool was pre-loaded or auto-loaded (for MCP tools)
-                if (process.env.DEBUG && toolCall.name.startsWith('mcp_') && wasPreloaded) {
-                    console.log(`  ✓ Using pre-loaded MCP tool: ${toolCall.name}`);
+            }
+            // =====================================================================
+            // SAFETY VALIDATION (Lesson 20-21)
+            // =====================================================================
+            if (this.safety) {
+                const safety = this.safety;
+                const validation = await this.withPausedDuration(() => safety.validateAndApprove(toolCall, `Executing tool: ${toolCall.name}`, { skipHumanApproval: policyApprovedByUser }));
+                if (!validation.allowed) {
+                    throw new Error(`Tool call blocked: ${validation.reason}`);
                 }
-                // =====================================================================
-                // BLACKBOARD FILE COORDINATION (Parallel Subagent Support)
-                // =====================================================================
-                // Claim file resources before write operations to prevent conflicts
-                if (this.blackboard && (toolCall.name === 'write_file' || toolCall.name === 'edit_file')) {
-                    const args = toolCall.arguments;
-                    const filePath = String(args.path || args.file_path || '');
-                    if (filePath) {
-                        const agentId = this.config.systemPrompt?.slice(0, 50) || 'agent';
-                        const claimed = this.blackboard.claim(filePath, agentId, 'write', {
-                            ttl: 60000, // 1 minute claim
-                            intent: `${toolCall.name}: ${filePath}`,
-                        });
-                        if (!claimed) {
-                            const existingClaim = this.blackboard.getClaim(filePath);
-                            throw new Error(`File "${filePath}" is being edited by another agent (${existingClaim?.agentId || 'unknown'}). ` +
-                                `Wait for the other agent to complete or choose a different file.`);
-                        }
-                    }
+            }
+            // Get tool definition (with lazy-loading support for MCP tools)
+            let tool = this.tools.get(toolCall.name);
+            const wasPreloaded = !!tool;
+            if (!tool && this.toolResolver) {
+                // Try to resolve and load the tool on-demand
+                const resolved = this.toolResolver(toolCall.name);
+                if (resolved) {
+                    this.addTool(resolved);
+                    tool = resolved;
+                    if (process.env.DEBUG)
+                        console.log(`  🔄 Auto-loaded MCP tool: ${toolCall.name}`);
+                    this.observability?.logger?.info('Tool auto-loaded', { tool: toolCall.name });
                 }
-                // FILE CACHE: Check cache for read_file operations before executing
-                if (this.fileCache && toolCall.name === 'read_file') {
-                    const args = toolCall.arguments;
-                    const readPath = String(args.path || '');
-                    if (readPath) {
-                        const cached = this.fileCache.get(readPath);
-                        if (cached !== undefined) {
-                            const lines = cached.split('\n').length;
-                            const cacheResult = { success: true, output: cached, metadata: { lines, bytes: cached.length, cached: true } };
-                            const duration = Date.now() - startTime;
-                            this.traceCollector?.record({ type: 'tool.end', data: { executionId, status: 'success', result: cacheResult, durationMs: duration } });
-                            this.observability?.metrics?.recordToolCall(toolCall.name, duration, true);
-                            this.state.metrics.toolCalls++;
-                            this.emit({ type: 'tool.complete', tool: toolCall.name, result: cacheResult });
-                            results.push({
-                                callId: toolCall.id,
-                                result: typeof cacheResult === 'string' ? cacheResult : JSON.stringify(cacheResult),
-                            });
-                            this.observability?.tracer?.endSpan(spanId);
-                            continue; // Skip actual file I/O
-                        }
+            }
+            if (!tool) {
+                throw new Error(`Unknown tool: ${toolCall.name}`);
+            }
+            // Log whether tool was pre-loaded or auto-loaded (for MCP tools)
+            if (process.env.DEBUG && toolCall.name.startsWith('mcp_') && wasPreloaded) {
+                console.log(`  ✓ Using pre-loaded MCP tool: ${toolCall.name}`);
+            }
+            // =====================================================================
+            // BLACKBOARD FILE COORDINATION (Parallel Subagent Support)
+            // =====================================================================
+            // Claim file resources before write operations to prevent conflicts
+            if (this.blackboard && (toolCall.name === 'write_file' || toolCall.name === 'edit_file')) {
+                const args = toolCall.arguments;
+                const filePath = String(args.path || args.file_path || '');
+                if (filePath) {
+                    const agentId = this.agentId;
+                    const claimed = this.blackboard.claim(filePath, agentId, 'write', {
+                        ttl: 60000, // 1 minute claim
+                        intent: `${toolCall.name}: ${filePath}`,
+                    });
+                    if (!claimed) {
+                        const existingClaim = this.blackboard.getClaim(filePath);
+                        throw new Error(`File "${filePath}" is being edited by another agent (${existingClaim?.agentId || 'unknown'}). ` +
+                            `Wait for the other agent to complete or choose a different file.`);
                     }
                 }
-                // Execute tool (with sandbox if available)
-                let result;
-                if (this.safety?.sandbox) {
-                    // CRITICAL: spawn_agent and spawn_agents_parallel need MUCH longer timeouts
-                    // The default 60s sandbox timeout would kill subagents prematurely
-                    // Subagents may run for minutes (per their own timeout config)
-                    const isSpawnAgent = toolCall.name === 'spawn_agent';
-                    const isSpawnParallel = toolCall.name === 'spawn_agents_parallel';
-                    const isSubagentTool = isSpawnAgent || isSpawnParallel;
-                    const subagentConfig = this.config.subagent;
-                    const hasSubagentConfig = subagentConfig !== false && subagentConfig !== undefined;
-                    const subagentTimeout = hasSubagentConfig
-                        ? subagentConfig.defaultTimeout ?? 600000 // 10 min default
-                        : 600000;
-                    // Use subagent timeout + buffer for spawn tools, default for others
-                    // For spawn_agents_parallel, multiply by number of agents (they run in parallel,
-                    // but the total wall-clock time should still allow the slowest agent to complete)
-                    const toolTimeout = isSubagentTool ? subagentTimeout + 30000 : undefined;
-                    result = await this.safety.sandbox.executeWithLimits(() => tool.execute(toolCall.arguments), toolTimeout);
-                }
-                else {
-                    result = await tool.execute(toolCall.arguments);
-                }
-                const duration = Date.now() - startTime;
-                // Lesson 26: Record tool completion for tracing
-                this.traceCollector?.record({
-                    type: 'tool.end',
-                    data: {
-                        executionId,
-                        status: 'success',
-                        result,
-                        durationMs: duration,
-                    },
-                });
-                // Record metrics
-                this.observability?.metrics?.recordToolCall(toolCall.name, duration, true);
-                this.state.metrics.toolCalls++;
-                this.emit({ type: 'tool.complete', tool: toolCall.name, result });
-                // FILE CACHE: Store read results and invalidate on writes
-                if (this.fileCache) {
-                    const args = toolCall.arguments;
-                    const filePath = String(args.path || args.file_path || '');
-                    if (toolCall.name === 'read_file' && filePath) {
-                        // Cache successful read results
-                        const resultObj = result;
-                        if (resultObj?.success && typeof resultObj.output === 'string') {
-                            this.fileCache.set(filePath, resultObj.output);
-                        }
-                    }
-                    else if ((toolCall.name === 'write_file' || toolCall.name === 'edit_file' || toolCall.name === 'undo_file_change') && filePath) {
-                        // Invalidate cache when files are modified (including undo operations)
-                        this.fileCache.invalidate(filePath);
+            }
+            // FILE CACHE: Check cache for read_file operations before executing
+            if (this.fileCache && toolCall.name === 'read_file') {
+                const args = toolCall.arguments;
+                const readPath = String(args.path || '');
+                if (readPath) {
+                    const cached = this.fileCache.get(readPath);
+                    if (cached !== undefined) {
+                        const lines = cached.split('\n').length;
+                        const cacheResult = { success: true, output: cached, metadata: { lines, bytes: cached.length, cached: true } };
+                        const duration = Date.now() - startTime;
+                        this.traceCollector?.record({ type: 'tool.end', data: { executionId, status: 'success', result: cacheResult, durationMs: duration } });
+                        this.observability?.metrics?.recordToolCall(toolCall.name, duration, true);
+                        this.state.metrics.toolCalls++;
+                        this.emit({ type: 'tool.complete', tool: toolCall.name, result: cacheResult });
+                        this.observability?.tracer?.endSpan(spanId);
+                        return {
+                            callId: toolCall.id,
+                            result: typeof cacheResult === 'string' ? cacheResult : JSON.stringify(cacheResult),
+                        };
                     }
                 }
-                // Emit tool insight with result summary
-                const summary = this.summarizeToolResult(toolCall.name, result);
-                this.emit({
-                    type: 'insight.tool',
-                    tool: toolCall.name,
-                    summary,
-                    durationMs: duration,
-                    success: true,
-                });
-                results.push({
-                    callId: toolCall.id,
+            }
+            // Execute tool (with sandbox if available)
+            let result;
+            if (this.safety?.sandbox) {
+                // CRITICAL: spawn_agent and spawn_agents_parallel need MUCH longer timeouts
+                // The default 60s sandbox timeout would kill subagents prematurely
+                // Subagents may run for minutes (per their own timeout config)
+                const isSpawnAgent = toolCall.name === 'spawn_agent';
+                const isSpawnParallel = toolCall.name === 'spawn_agents_parallel';
+                const isSubagentTool = isSpawnAgent || isSpawnParallel;
+                const subagentConfig = this.config.subagent;
+                const hasSubagentConfig = subagentConfig !== false && subagentConfig !== undefined;
+                const subagentTimeout = hasSubagentConfig
+                    ? subagentConfig.defaultTimeout ?? 600000 // 10 min default
+                    : 600000;
+                // Use subagent timeout + buffer for spawn tools, default for others
+                // For spawn_agents_parallel, multiply by number of agents (they run in parallel,
+                // but the total wall-clock time should still allow the slowest agent to complete)
+                const toolTimeout = isSubagentTool ? subagentTimeout + 30000 : undefined;
+                result = await this.safety.sandbox.executeWithLimits(() => tool.execute(toolCall.arguments), toolTimeout);
+            }
+            else {
+                result = await tool.execute(toolCall.arguments);
+            }
+            const duration = Date.now() - startTime;
+            // Lesson 26: Record tool completion for tracing
+            this.traceCollector?.record({
+                type: 'tool.end',
+                data: {
+                    executionId,
+                    status: 'success',
                     result,
-                });
-                // Release blackboard claim after successful file write
-                if (this.blackboard && (toolCall.name === 'write_file' || toolCall.name === 'edit_file')) {
-                    const args = toolCall.arguments;
-                    const filePath = String(args.path || args.file_path || '');
-                    if (filePath) {
-                        const agentId = this.config.systemPrompt?.slice(0, 50) || 'agent';
-                        this.blackboard.release(filePath, agentId);
+                    durationMs: duration,
+                },
+            });
+            // Record metrics
+            this.observability?.metrics?.recordToolCall(toolCall.name, duration, true);
+            this.state.metrics.toolCalls++;
+            this.emit({ type: 'tool.complete', tool: toolCall.name, result });
+            // FILE CACHE: Store read results and invalidate on writes
+            if (this.fileCache) {
+                const args = toolCall.arguments;
+                const filePath = String(args.path || args.file_path || '');
+                if (toolCall.name === 'read_file' && filePath) {
+                    // Cache successful read results
+                    const resultObj = result;
+                    if (resultObj?.success && typeof resultObj.output === 'string') {
+                        this.fileCache.set(filePath, resultObj.output);
                     }
                 }
-                this.observability?.tracer?.endSpan(spanId);
+                else if ((toolCall.name === 'write_file' || toolCall.name === 'edit_file' || toolCall.name === 'undo_file_change') && filePath) {
+                    // Invalidate cache when files are modified (including undo operations)
+                    this.fileCache.invalidate(filePath);
+                }
             }
-            catch (err) {
-                const error = err instanceof Error ? err : new Error(String(err));
-                const duration = Date.now() - startTime;
-                // Lesson 26: Record tool error for tracing
-                this.traceCollector?.record({
-                    type: 'tool.end',
-                    data: {
-                        executionId,
-                        status: error.message.includes('Blocked') || error.message.includes('Policy') ? 'blocked' : 'error',
-                        error,
-                        durationMs: duration,
-                    },
-                });
-                this.observability?.metrics?.recordToolCall(toolCall.name, duration, false);
-                this.observability?.tracer?.recordError(error);
-                this.observability?.tracer?.endSpan(spanId);
-                // FAILURE EVIDENCE RECORDING (Trick S)
-                // Track failed tool calls to prevent loops and provide context
-                this.contextEngineering?.recordFailure({
-                    action: toolCall.name,
-                    args: toolCall.arguments,
+            // Emit tool insight with result summary
+            const summary = this.summarizeToolResult(toolCall.name, result);
+            this.emit({
+                type: 'insight.tool',
+                tool: toolCall.name,
+                summary,
+                durationMs: duration,
+                success: true,
+            });
+            // Release blackboard claim after successful file write
+            if (this.blackboard && (toolCall.name === 'write_file' || toolCall.name === 'edit_file')) {
+                const args = toolCall.arguments;
+                const filePath = String(args.path || args.file_path || '');
+                if (filePath) {
+                    const agentId = this.agentId;
+                    this.blackboard.release(filePath, agentId);
+                }
+            }
+            // Self-improvement: record success pattern
+            this.selfImprovement?.recordSuccess(toolCall.name, toolCall.arguments, typeof result === 'string' ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200));
+            this.observability?.tracer?.endSpan(spanId);
+            return { callId: toolCall.id, result };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            const duration = Date.now() - startTime;
+            // Lesson 26: Record tool error for tracing
+            this.traceCollector?.record({
+                type: 'tool.end',
+                data: {
+                    executionId,
+                    status: error.message.includes('Blocked') || error.message.includes('Policy') ? 'blocked' : 'error',
                     error,
-                    intent: `Execute tool ${toolCall.name}`,
-                });
-                results.push({
-                    callId: toolCall.id,
-                    result: `Error: ${error.message}`,
-                    error: error.message,
-                });
-                this.emit({ type: 'tool.blocked', tool: toolCall.name, reason: error.message });
+                    durationMs: duration,
+                },
+            });
+            this.observability?.metrics?.recordToolCall(toolCall.name, duration, false);
+            this.observability?.tracer?.recordError(error);
+            this.observability?.tracer?.endSpan(spanId);
+            // FAILURE EVIDENCE RECORDING (Trick S)
+            // Track failed tool calls to prevent loops and provide context
+            this.contextEngineering?.recordFailure({
+                action: toolCall.name,
+                args: toolCall.arguments,
+                error,
+                intent: `Execute tool ${toolCall.name}`,
+            });
+            // Self-improvement: enhance error message with diagnosis for better LLM recovery
+            if (this.selfImprovement) {
+                const enhanced = this.selfImprovement.enhanceErrorMessage(toolCall.name, error.message, toolCall.arguments);
+                this.emit({ type: 'tool.blocked', tool: toolCall.name, reason: enhanced });
+                return { callId: toolCall.id, result: `Error: ${enhanced}`, error: enhanced };
             }
+            this.emit({ type: 'tool.blocked', tool: toolCall.name, reason: error.message });
+            return { callId: toolCall.id, result: `Error: ${error.message}`, error: error.message };
         }
-        return results;
     }
     /**
      * Get recently modified file paths from the file change tracker.
@@ -3443,6 +3749,19 @@ export class ProductionAgent {
         }
         // Create the checkpoint
         const label = `auto-iter-${this.state.iteration}`;
+        // Supplementary: also save to AutoCheckpointManager (file-based)
+        if (this.autoCheckpointManager) {
+            try {
+                this.autoCheckpointManager.save({
+                    label,
+                    sessionId: this.agentId,
+                    iteration: this.state.iteration,
+                });
+            }
+            catch {
+                // Non-critical — don't fail the main checkpoint path
+            }
+        }
         return this.createCheckpoint(label);
     }
     // =========================================================================
@@ -3596,7 +3915,18 @@ export class ProductionAgent {
         let workerResultId;
         try {
             // Filter tools for this agent
-            const agentTools = filterToolsForAgent(agentDef, Array.from(this.tools.values()));
+            let agentTools = filterToolsForAgent(agentDef, Array.from(this.tools.values()));
+            // Apply tool recommendations to improve subagent focus (only for large tool sets)
+            if (this.toolRecommendation && agentTools.length > 15) {
+                const taskType = ToolRecommendationEngine.inferTaskType(agentName);
+                const recommendations = this.toolRecommendation.recommendTools(task, taskType, agentTools.map(t => t.name));
+                if (recommendations.length > 0) {
+                    const recommendedNames = new Set(recommendations.map(r => r.toolName));
+                    // Always keep spawn tools even if not recommended
+                    const alwaysKeep = new Set(['spawn_agent', 'spawn_agents_parallel']);
+                    agentTools = agentTools.filter(t => recommendedNames.has(t.name) || alwaysKeep.has(t.name));
+                }
+            }
             // Resolve model - abstract tiers (fast/balanced/quality) should use parent's model
             // Only use agentDef.model if it's an actual model ID (contains '/')
             const resolvedModel = (agentDef.model && agentDef.model.includes('/'))
@@ -3688,14 +4018,30 @@ export class ProductionAgent {
             // BUDGET AWARENESS: Always inject so subagent understands its limits
             const subagentBudgetTokens = constraints?.maxTokens ?? SUBAGENT_BUDGET.maxTokens ?? 100000;
             const subagentBudgetMinutes = Math.round((SUBAGENT_BUDGET.maxDuration ?? 240000) / 60000);
-            constraintParts.push(`**RESOURCE AWARENESS (CRITICAL):**\n` +
-                `- Token budget: ~${(subagentBudgetTokens / 1000).toFixed(0)}k tokens\n` +
-                `- Time limit: ~${subagentBudgetMinutes} minutes\n` +
-                `- You will receive warnings at 70% usage. When warned, WRAP UP immediately.\n` +
-                `- Do not explore indefinitely - be focused and efficient.\n` +
-                `- If approaching limits, summarize findings and return.\n` +
-                `- **STRUCTURED WRAPUP:** When told to wrap up, respond with ONLY this JSON (no tool calls):\n` +
-                `  {"findings":[...], "actionsTaken":[...], "failures":[...], "remainingWork":[...], "suggestedNextSteps":[...]}`);
+            if (isSwarmWorker) {
+                // V6: Calmer resource awareness for swarm workers — prevents weaker models
+                // from confabulating budget warnings and wrapping up without doing work
+                constraintParts.push(`**Resource Info:**\n` +
+                    `- Token budget: ~${(subagentBudgetTokens / 1000).toFixed(0)}k tokens (you have plenty)\n` +
+                    `- Time limit: ~${subagentBudgetMinutes} minutes\n` +
+                    `- Focus on completing your task. Do NOT wrap up prematurely.\n` +
+                    `- You will receive a system warning IF you approach budget limits. Until then, work normally.\n` +
+                    `- **IMPORTANT:** Budget warnings come from the SYSTEM, not from your own assessment. ` +
+                    `Do not preemptively claim budget issues.\n` +
+                    `- **STRUCTURED WRAPUP:** When told to wrap up, respond with ONLY this JSON (no tool calls):\n` +
+                    `  {"findings":[...], "actionsTaken":[...], "failures":[...], "remainingWork":[...], "suggestedNextSteps":[...]}`);
+            }
+            else {
+                // Original RESOURCE AWARENESS text for regular subagents
+                constraintParts.push(`**RESOURCE AWARENESS (CRITICAL):**\n` +
+                    `- Token budget: ~${(subagentBudgetTokens / 1000).toFixed(0)}k tokens\n` +
+                    `- Time limit: ~${subagentBudgetMinutes} minutes\n` +
+                    `- You will receive warnings at 70% usage. When warned, WRAP UP immediately.\n` +
+                    `- Do not explore indefinitely - be focused and efficient.\n` +
+                    `- If approaching limits, summarize findings and return.\n` +
+                    `- **STRUCTURED WRAPUP:** When told to wrap up, respond with ONLY this JSON (no tool calls):\n` +
+                    `  {"findings":[...], "actionsTaken":[...], "failures":[...], "remainingWork":[...], "suggestedNextSteps":[...]}`);
+            }
             if (constraints) {
                 if (constraints.focusAreas && constraints.focusAreas.length > 0) {
                     constraintParts.push(`**FOCUS AREAS (limit exploration to these paths):**\n${constraints.focusAreas.map(a => `  - ${a}`).join('\n')}`);
@@ -3711,11 +4057,19 @@ export class ProductionAgent {
                 }
             }
             const constraintContext = `\n\n**EXECUTION CONSTRAINTS:**\n${constraintParts.join('\n\n')}\n`;
+            // Build delegation-enhanced system prompt
+            let delegationContext = '';
+            if (this.lastComplexityAssessment && this.lastComplexityAssessment.tier !== 'simple') {
+                const spec = createMinimalDelegationSpec(task, agentName);
+                delegationContext = '\n\n' + buildDelegationPrompt(spec);
+            }
+            // Quality self-assessment prompt for subagent
+            const qualityPrompt = '\n\n' + getSubagentQualityPrompt();
             // Build subagent system prompt with subagent-specific plan mode addition
             const parentMode = this.getMode();
             const subagentSystemPrompt = parentMode === 'plan'
-                ? `${agentDef.systemPrompt}\n\n${SUBAGENT_PLAN_MODE_ADDITION}${blackboardContext}${constraintContext}`
-                : `${agentDef.systemPrompt}${blackboardContext}${constraintContext}`;
+                ? `${agentDef.systemPrompt}\n\n${SUBAGENT_PLAN_MODE_ADDITION}${blackboardContext}${constraintContext}${delegationContext}${qualityPrompt}`
+                : `${agentDef.systemPrompt}${blackboardContext}${constraintContext}${delegationContext}${qualityPrompt}`;
             // Allocate budget from pool (or use default) — track allocation ID for release later
             const pooledBudget = this.getSubagentBudget(agentName, constraints);
             const poolAllocationId = pooledBudget.allocationId;
@@ -3765,6 +4119,8 @@ export class ProductionAgent {
                     builtIn: { logging: false, timing: false, metrics: false },
                     custom: [],
                 },
+                // Pass unique agentId for blackboard coordination and tracing
+                agentId,
                 // Share parent's blackboard for coordination between parallel subagents
                 blackboard: this.blackboard || undefined,
                 // Share parent's file cache to eliminate redundant reads across agents
@@ -3925,6 +4281,25 @@ export class ProductionAgent {
                     },
                     structured,
                 };
+                // Save full output to subagent output store (avoids telephone problem)
+                if (this.subagentOutputStore) {
+                    const outputEntry = {
+                        id: agentId,
+                        agentId,
+                        agentName,
+                        task,
+                        fullOutput: finalOutput,
+                        structured,
+                        filesModified: [],
+                        filesCreated: [],
+                        timestamp: new Date(),
+                        tokensUsed: result.metrics.totalTokens,
+                        durationMs: duration,
+                    };
+                    const storeId = this.subagentOutputStore.save(outputEntry);
+                    // Attach reference so downstream consumers can retrieve full output
+                    spawnResultFinal.outputStoreId = storeId;
+                }
                 if (workerResultId && this.store?.hasWorkerResultsFeature()) {
                     try {
                         this.store.completeWorkerResult(workerResultId, {
@@ -4229,9 +4604,41 @@ export class ProductionAgent {
             count: tasks.length,
             agents: tasks.map(t => t.agent),
         });
-        // Execute all tasks in parallel using allSettled to handle partial failures
-        const promises = tasks.map(({ agent, task }) => this.spawnAgent(agent, task));
-        const settled = await Promise.allSettled(promises);
+        // Use DynamicBudgetPool for parallel spawns (prevents child starvation,
+        // enables priority-based allocation). Falls back to regular pool for single tasks.
+        let settled;
+        const originalPool = this.budgetPool;
+        // SubagentSupervisor for unified monitoring of concurrent subagents
+        const supervisor = tasks.length > 1 ? createSubagentSupervisor() : null;
+        if (this.budgetPool && tasks.length > 1) {
+            // Swap to DynamicBudgetPool for this parallel batch
+            const poolStats = this.budgetPool.getStats();
+            const dynamicPool = createDynamicBudgetPool(poolStats.tokensRemaining, 0.1);
+            dynamicPool.setExpectedChildren(tasks.length);
+            // Temporarily replace the budget pool so spawnAgent's reserve() uses the dynamic one
+            this.budgetPool = dynamicPool;
+            try {
+                const promises = tasks.map(({ agent, task }) => {
+                    const spawnPromise = this.spawnAgent(agent, task);
+                    // Register with supervisor for monitoring
+                    if (supervisor) {
+                        const handle = createSubagentHandle(`parallel-${agent}-${Date.now()}`, agent, task, spawnPromise, {});
+                        supervisor.add(handle);
+                    }
+                    return spawnPromise;
+                });
+                settled = await Promise.allSettled(promises);
+            }
+            finally {
+                this.budgetPool = originalPool;
+                supervisor?.stop();
+            }
+        }
+        else {
+            // Single task or no pool - use standard sequential allocation
+            const promises = tasks.map(({ agent, task }) => this.spawnAgent(agent, task));
+            settled = await Promise.allSettled(promises);
+        }
         // Convert settled results to SpawnResult array
         const results = settled.map((result, i) => {
             if (result.status === 'fulfilled') {
@@ -4939,8 +5346,19 @@ If the task is a simple question or doesn't need specialized handling, set bestA
         this.unsubscribers = [];
         // Flush trace collector before cleanup
         await this.traceCollector?.flush();
-        // Clear blackboard (releases file claim locks)
-        this.blackboard?.clear();
+        // Per-agent blackboard cleanup: release only this agent's claims and subscriptions
+        // so parallel siblings don't lose their data. Only root agent clears everything.
+        if (this.blackboard) {
+            if (this.parentIterations > 0 && this.agentId) {
+                // Subagent: release only our claims and subscriptions
+                this.blackboard.releaseAll(this.agentId);
+                this.blackboard.unsubscribeAgent(this.agentId);
+            }
+            else {
+                // Root agent: full clear
+                this.blackboard.clear();
+            }
+        }
         // Wait for any pending init before cleanup
         if (this.initPromises.length > 0) {
             try {