attocode 0.1.9 → 0.2.1

package/dist/src/agent.js

@@ -21,7 +21,7 @@
 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, } 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, createPendingPlanManager, createInteractivePlanner, createRecursiveContext, createLearningStore, createCompactor, createAutoCompactionManager, createFileChangeTracker, createCapabilitiesRegistry, createSharedBlackboard, createTaskManager, createSwarmOrchestrator, createThrottledProvider, FREE_TIER_THROTTLE, PAID_TIER_THROTTLE, } from './integrations/index.js';
 // Lesson 26: Tracing & Evaluation integration
 import { createTraceCollector } from './tracing/trace-collector.js';
 // Model registry for context window limits
@@ -34,6 +34,43 @@ 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',
+]);
+/**
+ * Groups consecutive tool calls into batches for parallel/sequential execution.
+ * Consecutive parallelizable tools form a single parallel batch.
+ * Non-parallelizable tools break the sequence, starting a new batch.
+ */
+export function groupToolCallsIntoBatches(toolCalls, isParallelizable = (tc) => PARALLELIZABLE_TOOLS.has(tc.name)) {
+    const batches = [];
+    let currentBatch = [];
+    let currentIsParallel = false;
+    for (const toolCall of toolCalls) {
+        const isParallel = isParallelizable(toolCall);
+        if (batches.length === 0 && currentBatch.length === 0) {
+            currentBatch.push(toolCall);
+            currentIsParallel = isParallel;
+        }
+        else if (isParallel && currentIsParallel) {
+            currentBatch.push(toolCall);
+        }
+        else {
+            batches.push(currentBatch);
+            currentBatch = [toolCall];
+            currentIsParallel = isParallel;
+        }
+    }
+    if (currentBatch.length > 0) {
+        batches.push(currentBatch);
+    }
+    return batches;
+}
 /**
  * Production-ready agent that composes all features.
  */
@@ -73,11 +110,13 @@ export class ProductionAgent {
     fileChangeTracker = null;
     capabilitiesRegistry = null;
     toolResolver = null;
+    agentId;
     blackboard = null;
     fileCache = null;
     budgetPool = null;
     taskManager = null;
     store = null;
+    swarmOrchestrator = null;
     // Duplicate spawn prevention - tracks recently spawned tasks to prevent doom loops
     // Map<taskKey, { timestamp: number; result: string; queuedChanges: number }>
     spawnedTasks = new Map();
@@ -123,6 +162,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) {
@@ -300,6 +341,26 @@ export class ProductionAgent {
         for (const tool of taskTools) {
             this.tools.set(tool.name, tool);
         }
+        // Swarm Mode (experimental)
+        if (this.config.swarm) {
+            const swarmConfig = this.config.swarm;
+            // Wrap provider with request throttle to prevent 429 rate limiting.
+            // All subagents share this.provider by reference (line 4398),
+            // so wrapping here throttles ALL downstream LLM calls.
+            if (swarmConfig.throttle !== false) {
+                const throttleConfig = swarmConfig.throttle === 'paid'
+                    ? PAID_TIER_THROTTLE
+                    : swarmConfig.throttle === 'free' || swarmConfig.throttle === undefined
+                        ? FREE_TIER_THROTTLE
+                        : swarmConfig.throttle;
+                this.provider = createThrottledProvider(this.provider, throttleConfig);
+            }
+            this.swarmOrchestrator = createSwarmOrchestrator(swarmConfig, this.provider, this.agentRegistry, (name, task) => this.spawnAgent(name, task), this.blackboard ?? undefined);
+            // Override parent budget pool with swarm's much larger pool so spawnAgent()
+            // allocates from the swarm budget (e.g. 10M tokens) instead of the parent's
+            // generic pool (200K tokens). Without this, workers get 5K emergency budget.
+            this.budgetPool = this.swarmOrchestrator.getBudgetPool().pool;
+        }
         // Cancellation Support
         if (isFeatureEnabled(this.config.cancellation)) {
             this.cancellation = createCancellationManager();
@@ -776,8 +837,14 @@ export class ProductionAgent {
         try {
             // Check for cancellation before starting
             cancellationToken?.throwIfCancellationRequested();
-            // Check if planning is needed
-            if (this.planning?.shouldPlan(task)) {
+            // Check if swarm mode should handle this task
+            if (this.swarmOrchestrator) {
+                const swarmResult = await this.runSwarm(task);
+                // Store swarm summary as an assistant message for the response
+                this.state.messages.push({ role: 'assistant', content: swarmResult.summary });
+            }
+            else if (this.planning?.shouldPlan(task)) {
+                // Check if planning is needed
                 await this.createAndExecutePlan(task);
             }
             else {
@@ -902,6 +969,43 @@ export class ProductionAgent {
             }
         }
     }
+    /**
+     * Run a task in swarm mode using the SwarmOrchestrator.
+     */
+    async runSwarm(task) {
+        if (!this.swarmOrchestrator) {
+            throw new Error('Swarm orchestrator not initialized');
+        }
+        this.observability?.logger?.info('Starting swarm execution', { task: task.slice(0, 100) });
+        this.observability?.logger?.info('Starting swarm mode — decomposing task into subtasks...');
+        // Forward swarm events to the main agent event system
+        const unsubSwarm = this.swarmOrchestrator.subscribe(event => {
+            // Forward as a generic agent event for TUI display
+            this.emit(event);
+        });
+        // Bridge events to filesystem for live dashboard
+        const { SwarmEventBridge } = await import('./integrations/swarm/swarm-event-bridge.js');
+        const bridge = new SwarmEventBridge({ outputDir: '.agent/swarm-live' });
+        const unsubBridge = bridge.attach(this.swarmOrchestrator);
+        try {
+            const result = await this.swarmOrchestrator.execute(task);
+            // Populate task DAG for dashboard after execution
+            bridge.setTasks(result.tasks);
+            this.observability?.logger?.info('Swarm execution complete', {
+                success: result.success,
+                tasks: result.stats.totalTasks,
+                completed: result.stats.completedTasks,
+                tokens: result.stats.totalTokens,
+                cost: result.stats.totalCost,
+            });
+            return result;
+        }
+        finally {
+            unsubBridge();
+            bridge.close();
+            unsubSwarm();
+        }
+    }
     /**
      * Execute a task directly without planning.
      */
@@ -1247,8 +1351,9 @@ export class ProductionAgent {
                 while (resilienceEnabled && emptyRetries < MAX_EMPTY_RETRIES) {
                     const hasContent = response.content && response.content.length >= MIN_CONTENT_LENGTH;
                     const hasToolCalls = response.toolCalls && response.toolCalls.length > 0;
+                    const hasThinking = response.thinking && response.thinking.length > 0;
                     if (hasContent || hasToolCalls) {
-                        // Valid response received
+                        // Valid visible response
                         if (emptyRetries > 0) {
                             this.emit({
                                 type: 'resilience.recovered',
@@ -1261,7 +1366,38 @@ export class ProductionAgent {
                         }
                         break;
                     }
-                    // Empty response - retry with nudge
+                    if (hasThinking && !hasContent && !hasToolCalls) {
+                        // Model produced reasoning but no visible output (e.g., DeepSeek-R1, GLM-4, QwQ).
+                        // Give ONE targeted nudge, then accept thinking as content.
+                        if (emptyRetries === 0) {
+                            emptyRetries++;
+                            this.emit({
+                                type: 'resilience.retry',
+                                reason: 'thinking_only_response',
+                                attempt: emptyRetries,
+                                maxAttempts: MAX_EMPTY_RETRIES,
+                            });
+                            this.state.metrics.retryCount = (this.state.metrics.retryCount ?? 0) + 1;
+                            this.observability?.logger?.warn('Thinking-only response (no visible content), nudging', {
+                                thinkingLength: response.thinking.length,
+                            });
+                            const thinkingNudge = {
+                                role: 'user',
+                                content: '[System: You produced reasoning but no visible response. Please provide your answer based on your analysis.]',
+                            };
+                            messages.push(thinkingNudge);
+                            this.state.messages.push(thinkingNudge);
+                            response = await this.callLLM(messages);
+                            continue;
+                        }
+                        // Second attempt also thinking-only → accept thinking as content
+                        this.observability?.logger?.info('Accepting thinking as content after nudge failed', {
+                            thinkingLength: response.thinking.length,
+                        });
+                        response = { ...response, content: response.thinking };
+                        break;
+                    }
+                    // Truly empty (no content, no tools, no thinking) — existing retry logic
                     emptyRetries++;
                     this.emit({
                         type: 'resilience.retry',
@@ -1378,10 +1514,11 @@ export class ProductionAgent {
                     role: 'assistant',
                     content: response.content,
                     toolCalls: response.toolCalls,
+                    ...(response.thinking ? { metadata: { thinking: response.thinking } } : {}),
                 };
                 messages.push(assistantMessage);
                 this.state.messages.push(assistantMessage);
-                lastResponse = response.content;
+                lastResponse = response.content || (response.thinking ? response.thinking : '');
                 // In plan mode: capture exploration findings as we go (not just at the end)
                 // This ensures we collect context from exploration iterations before writes are queued
                 if (this.modeManager.getMode() === 'plan' && response.content && response.content.length > 50) {
@@ -1785,9 +1922,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
@@ -1870,7 +2010,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
@@ -1920,6 +2060,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',
@@ -2003,324 +2151,352 @@ 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,
-                    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 });
+            // 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);
+                }
             }
+            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,
+                    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}`,
+            });
+            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.
@@ -3425,7 +3601,9 @@ export class ProductionAgent {
             };
         }
         // DUPLICATE SPAWN PREVENTION with SEMANTIC SIMILARITY
-        // First try exact string match, then check semantic similarity for similar tasks
+        // Skip for swarm workers — the orchestrator handles retry logic and deduplication
+        // at the task level. Without this bypass, retried swarm tasks return stale results.
+        const isSwarmWorker = agentName.startsWith('swarm-');
         const SEMANTIC_SIMILARITY_THRESHOLD = 0.75; // 75% similarity = duplicate
         const taskKey = `${agentName}:${task.slice(0, 150).toLowerCase().replace(/\s+/g, ' ').trim()}`;
         const now = Date.now();
@@ -3435,30 +3613,33 @@ export class ProductionAgent {
                 this.spawnedTasks.delete(key);
             }
         }
-        // Check for exact match first
-        let existingMatch = this.spawnedTasks.get(taskKey);
+        let existingMatch;
         let matchType = 'exact';
-        // If no exact match, check for semantic similarity among same agent's tasks
-        if (!existingMatch) {
-            for (const [key, entry] of this.spawnedTasks.entries()) {
-                // Only compare tasks from the same agent type
-                if (!key.startsWith(`${agentName}:`))
-                    continue;
-                if (now - entry.timestamp >= ProductionAgent.SPAWN_DEDUP_WINDOW_MS)
-                    continue;
-                // Extract the task portion from the key
-                const existingTask = key.slice(agentName.length + 1);
-                const similarity = calculateTaskSimilarity(task, existingTask);
-                if (similarity >= SEMANTIC_SIMILARITY_THRESHOLD) {
-                    existingMatch = entry;
-                    matchType = 'semantic';
-                    this.observability?.logger?.debug('Semantic duplicate detected', {
-                        agent: agentName,
-                        newTask: task.slice(0, 80),
-                        existingTask: existingTask.slice(0, 80),
-                        similarity: (similarity * 100).toFixed(1) + '%',
-                    });
-                    break;
+        if (!isSwarmWorker) {
+            // Check for exact match first
+            existingMatch = this.spawnedTasks.get(taskKey);
+            // If no exact match, check for semantic similarity among same agent's tasks
+            if (!existingMatch) {
+                for (const [key, entry] of this.spawnedTasks.entries()) {
+                    // Only compare tasks from the same agent type
+                    if (!key.startsWith(`${agentName}:`))
+                        continue;
+                    if (now - entry.timestamp >= ProductionAgent.SPAWN_DEDUP_WINDOW_MS)
+                        continue;
+                    // Extract the task portion from the key
+                    const existingTask = key.slice(agentName.length + 1);
+                    const similarity = calculateTaskSimilarity(task, existingTask);
+                    if (similarity >= SEMANTIC_SIMILARITY_THRESHOLD) {
+                        existingMatch = entry;
+                        matchType = 'semantic';
+                        this.observability?.logger?.debug('Semantic duplicate detected', {
+                            agent: agentName,
+                            newTask: task.slice(0, 80),
+                            existingTask: existingTask.slice(0, 80),
+                            similarity: (similarity * 100).toFixed(1) + '%',
+                        });
+                        break;
+                    }
                 }
             }
         }
@@ -3650,7 +3831,12 @@ export class ProductionAgent {
                 observability: this.config.observability,
                 sandbox: this.config.sandbox,
                 humanInLoop: this.config.humanInLoop,
-                executionPolicy: this.config.executionPolicy,
+                // Subagents get 'allow' as default policy since they're already
+                // constrained to their registered tool set. The parent's 'prompt'
+                // policy can't work without humanInLoop.
+                executionPolicy: this.config.executionPolicy
+                    ? { ...this.config.executionPolicy, defaultPolicy: 'allow' }
+                    : this.config.executionPolicy,
                 threads: false,
                 // Disable hooks console output in subagents - parent handles event display
                 hooks: this.config.hooks === false ? false : {
@@ -3658,6 +3844,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
@@ -4122,9 +4310,30 @@ 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);
+        // Pre-divide budget pool equally to prevent first-come starvation.
+        // Temporarily lower maxPerChild so each spawnAgent's normal reserve() call
+        // gets an equal share instead of racing for the full maxPerChild allocation.
+        let settled;
+        if (this.budgetPool && tasks.length > 1) {
+            const poolStats = this.budgetPool.getStats();
+            // equalShare is always ≤ remaining ≤ totalTokens ≤ originalMaxPerChild
+            // (guaranteed by createBudgetPool capping maxPerChild to poolTokens)
+            // so we don't need Math.min(equalShare, originalMaxPerChild) here.
+            const equalShare = Math.floor(poolStats.tokensRemaining / tasks.length);
+            this.budgetPool.setMaxPerChild(equalShare);
+            try {
+                const promises = tasks.map(({ agent, task }) => this.spawnAgent(agent, task));
+                settled = await Promise.allSettled(promises);
+            }
+            finally {
+                this.budgetPool.resetMaxPerChild();
+            }
+        }
+        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') {