attocode 0.1.8 → 0.2.0

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, 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
@@ -74,8 +74,11 @@ export class ProductionAgent {
     capabilitiesRegistry = null;
     toolResolver = null;
     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();
@@ -88,6 +91,9 @@ export class ProductionAgent {
     // Graceful wrapup support (for subagent timeout wrapup phase)
     wrapupRequested = false;
     wrapupReason = null;
+    // Cacheable system prompt blocks for prompt caching (Improvement P1)
+    // When set, callLLM() will inject these as structured content with cache_control markers
+    cacheableSystemBlocks = null;
     // Initialization tracking
     initPromises = [];
     initComplete = false;
@@ -141,6 +147,26 @@ export class ProductionAgent {
                 deduplicateFindings: true,
             });
         }
+        // Shared File Cache - eliminates redundant file reads across parent and subagents
+        // Subagents inherit parent's cache; parent agents create their own
+        if (userConfig.fileCache) {
+            this.fileCache = userConfig.fileCache;
+        }
+        else if (this.config.subagent !== false) {
+            this.fileCache = createSharedFileCache({
+                maxCacheBytes: 5 * 1024 * 1024, // 5MB
+                ttlMs: 5 * 60 * 1000, // 5 minutes
+            });
+        }
+        // Shared Budget Pool - pools token budget across parent and subagents
+        // Only parent agents create the pool; subagents don't need their own
+        // The pool is used in spawnAgent() to allocate budgets from the parent's total
+        if (this.config.subagent !== false) {
+            // Use actual configured budget (custom or default), not always STANDARD_BUDGET
+            const baseBudget = this.config.budget ?? STANDARD_BUDGET;
+            const parentBudgetTokens = baseBudget.maxTokens ?? STANDARD_BUDGET.maxTokens ?? 200000;
+            this.budgetPool = createBudgetPool(parentBudgetTokens, 0.25, 100000);
+        }
         // Initialize enabled features
         this.initializeFeatures();
     }
@@ -275,6 +301,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();
@@ -751,8 +797,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 {
@@ -877,6 +929,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.
      */
@@ -1222,8 +1311,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',
@@ -1236,7 +1326,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',
@@ -1353,10 +1474,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) {
@@ -1689,28 +1811,42 @@ export class ProductionAgent {
             }
         }
         // Build system prompt using cache-aware builder if available (Trick P)
-        let systemPrompt;
         // Combine memory, learnings, and codebase context
         const combinedContext = [
             ...(memoryContext.length > 0 ? memoryContext : []),
             ...(learningsContext ? [learningsContext] : []),
             ...(codebaseContextStr ? [`\n## Relevant Code\n${codebaseContextStr}`] : []),
         ].join('\n');
+        const promptOptions = {
+            rules: rulesContent + (skillsPrompt ? '\n\n' + skillsPrompt : ''),
+            tools: toolDescriptions,
+            memory: combinedContext.length > 0 ? combinedContext : undefined,
+            dynamic: {
+                mode: this.modeManager?.getMode() ?? 'default',
+            },
+        };
         if (this.contextEngineering) {
-            // Use cache-optimized prompt builder - orders sections for KV-cache reuse:
-            // static prefix -> rules -> tools -> memory/codebase -> dynamic
-            systemPrompt = this.contextEngineering.buildSystemPrompt({
-                rules: rulesContent + (skillsPrompt ? '\n\n' + skillsPrompt : ''),
-                tools: toolDescriptions,
-                memory: combinedContext.length > 0 ? combinedContext : undefined,
-                dynamic: {
-                    mode: this.modeManager?.getMode() ?? 'default',
-                },
-            });
+            // Build cache-aware system prompt with cache_control markers (Improvement P1).
+            // Store structured blocks for callLLM() to inject as MessageWithContent.
+            // The string version is still used for token estimation and debugging.
+            const cacheableBlocks = this.contextEngineering.buildCacheableSystemPrompt(promptOptions);
+            // Safety check: ensure we have content (empty array = no cache context configured)
+            if (cacheableBlocks.length === 0 || cacheableBlocks.every(b => b.text.trim().length === 0)) {
+                this.cacheableSystemBlocks = null;
+                messages.push({ role: 'system', content: this.config.systemPrompt || 'You are a helpful AI assistant.' });
+            }
+            else {
+                // Store cacheable blocks for provider injection
+                this.cacheableSystemBlocks = cacheableBlocks;
+                // Push a regular string Message for backward compatibility (token estimation, etc.)
+                const flatPrompt = cacheableBlocks.map(b => b.text).join('');
+                messages.push({ role: 'system', content: flatPrompt });
+            }
         }
         else {
-            // Fallback: manual concatenation (original behavior)
-            systemPrompt = this.config.systemPrompt;
+            // Fallback: manual concatenation (original behavior) — no cache markers
+            this.cacheableSystemBlocks = null;
+            let systemPrompt = this.config.systemPrompt;
             if (rulesContent)
                 systemPrompt += '\n\n' + rulesContent;
             if (skillsPrompt)
@@ -1721,13 +1857,13 @@ export class ProductionAgent {
             if (toolDescriptions) {
                 systemPrompt += '\n\nAvailable tools:\n' + toolDescriptions;
             }
+            // Safety check: ensure system prompt is not empty
+            if (!systemPrompt || systemPrompt.trim().length === 0) {
+                console.warn('[buildMessages] Warning: Empty system prompt detected, using fallback');
+                systemPrompt = this.config.systemPrompt || 'You are a helpful AI assistant.';
+            }
+            messages.push({ role: 'system', content: systemPrompt });
         }
-        // Safety check: ensure system prompt is not empty
-        if (!systemPrompt || systemPrompt.trim().length === 0) {
-            console.warn('[buildMessages] Warning: Empty system prompt detected, using fallback');
-            systemPrompt = this.config.systemPrompt || 'You are a helpful AI assistant.';
-        }
-        messages.push({ role: 'system', content: systemPrompt });
         // Add existing conversation
         for (const msg of this.state.messages) {
             if (msg.role !== 'system') {
@@ -1744,6 +1880,22 @@ export class ProductionAgent {
     async callLLM(messages) {
         const spanId = this.observability?.tracer?.startSpan('llm.call');
         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[].
+        let providerMessages = messages;
+        if (this.cacheableSystemBlocks && this.cacheableSystemBlocks.length > 0) {
+            providerMessages = messages.map((m, i) => {
+                if (i === 0 && m.role === 'system') {
+                    // Replace system message with structured cacheable content
+                    return {
+                        role: 'system',
+                        content: this.cacheableSystemBlocks,
+                    };
+                }
+                return m;
+            });
+        }
         // Emit context insight for verbose feedback
         const estimatedTokens = messages.reduce((sum, m) => {
             const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
@@ -1859,7 +2011,7 @@ export class ProductionAgent {
                 });
             }
             else {
-                response = await this.provider.chat(messages, {
+                response = await this.provider.chat(providerMessages, {
                     model: this.config.model,
                     tools: Array.from(this.tools.values()),
                 });
@@ -2132,6 +2284,29 @@ export class ProductionAgent {
                         }
                     }
                 }
+                // 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
+                        }
+                    }
+                }
                 // Execute tool (with sandbox if available)
                 let result;
                 if (this.safety?.sandbox) {
@@ -2170,6 +2345,22 @@ export class ProductionAgent {
                 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);
+                    }
+                }
                 // Emit tool insight with result summary
                 const summary = this.summarizeToolResult(toolCall.name, result);
                 this.emit({
@@ -3331,7 +3522,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();
@@ -3341,30 +3534,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;
+                    }
                 }
             }
         }
@@ -3420,20 +3616,34 @@ export class ProductionAgent {
             }
             // Get subagent config with agent-type-specific timeouts and iteration limits
             // Uses dynamic configuration based on agent type (researcher needs more time than reviewer)
+            // Precedence: per-type config > per-type default > global config > hardcoded fallback
             const subagentConfig = this.config.subagent;
             const hasSubagentConfig = subagentConfig !== false && subagentConfig !== undefined;
-            // Agent-type-specific timeout: researchers get 5min, reviewers get 2min, etc.
+            // Timeout precedence: per-type config override > agent-type default > global config default
             const agentTypeTimeout = getSubagentTimeout(agentName);
-            const configTimeout = hasSubagentConfig
+            const rawPerTypeTimeout = hasSubagentConfig
+                ? subagentConfig.timeouts?.[agentName]
+                : undefined;
+            const rawGlobalTimeout = hasSubagentConfig
                 ? subagentConfig.defaultTimeout
                 : undefined;
-            const subagentTimeout = configTimeout ?? agentTypeTimeout;
-            // Agent-type-specific iteration limit: researchers get 25, documenters get 10, etc.
+            // Validate: reject negative, NaN, or non-finite timeout values
+            const isValidTimeout = (v) => v !== undefined && Number.isFinite(v) && v > 0;
+            const perTypeConfigTimeout = isValidTimeout(rawPerTypeTimeout) ? rawPerTypeTimeout : undefined;
+            const globalConfigTimeout = isValidTimeout(rawGlobalTimeout) ? rawGlobalTimeout : undefined;
+            const subagentTimeout = perTypeConfigTimeout ?? agentTypeTimeout ?? globalConfigTimeout ?? 300000;
+            // Iteration precedence: per-type config override > agent-type default > global config default
             const agentTypeMaxIter = getSubagentMaxIterations(agentName);
-            const configMaxIter = hasSubagentConfig
+            const rawPerTypeMaxIter = hasSubagentConfig
+                ? subagentConfig.maxIterations?.[agentName]
+                : undefined;
+            const rawGlobalMaxIter = hasSubagentConfig
                 ? subagentConfig.defaultMaxIterations
                 : undefined;
-            const defaultMaxIterations = agentDef.maxIterations ?? configMaxIter ?? agentTypeMaxIter;
+            const isValidIter = (v) => v !== undefined && Number.isFinite(v) && v > 0 && Number.isInteger(v);
+            const perTypeConfigMaxIter = isValidIter(rawPerTypeMaxIter) ? rawPerTypeMaxIter : undefined;
+            const globalConfigMaxIter = isValidIter(rawGlobalMaxIter) ? rawGlobalMaxIter : undefined;
+            const defaultMaxIterations = agentDef.maxIterations ?? perTypeConfigMaxIter ?? agentTypeMaxIter ?? globalConfigMaxIter ?? 15;
             // BLACKBOARD CONTEXT INJECTION
             // Gather relevant context from the blackboard for the subagent
             let blackboardContext = '';
@@ -3506,6 +3716,9 @@ export class ProductionAgent {
             const subagentSystemPrompt = parentMode === 'plan'
                 ? `${agentDef.systemPrompt}\n\n${SUBAGENT_PLAN_MODE_ADDITION}${blackboardContext}${constraintContext}`
                 : `${agentDef.systemPrompt}${blackboardContext}${constraintContext}`;
+            // Allocate budget from pool (or use default) — track allocation ID for release later
+            const pooledBudget = this.getSubagentBudget(agentName, constraints);
+            const poolAllocationId = pooledBudget.allocationId;
             // Create a sub-agent with the agent's config
             // Use SUBAGENT_BUDGET to constrain resource usage (prevents runaway token consumption)
             const subAgent = new ProductionAgent({
@@ -3522,10 +3735,29 @@ export class ProductionAgent {
                 memory: false,
                 planning: false,
                 reflection: false,
+                // Enable lightweight compaction for subagents (Improvement P5)
+                // tokenThreshold configures the Compactor's per-pass size limit
+                // maxContextTokens constrains AutoCompactionManager's percentage thresholds
+                // With maxContextTokens=80000 and default 80% threshold, compaction triggers at ~64K
+                compaction: {
+                    enabled: true,
+                    mode: 'auto',
+                    tokenThreshold: 40000, // Compactor summarization size limit per pass
+                    preserveRecentCount: 4, // Preserve fewer messages (splits to 2 user + 2 assistant)
+                    preserveToolResults: false, // More aggressive — subagents can re-read files
+                    summaryMaxTokens: 500,
+                },
+                // Lower context window for subagents so percentage-based compaction triggers earlier
+                maxContextTokens: 80000,
                 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 : {
@@ -3535,11 +3767,11 @@ export class ProductionAgent {
                 },
                 // Share parent's blackboard for coordination between parallel subagents
                 blackboard: this.blackboard || undefined,
-                // CONSTRAINED BUDGET: Subagents get smaller budget to prevent runaway consumption
-                // Uses SUBAGENT_BUDGET (100k tokens, 4 min) vs STANDARD_BUDGET (200k, 5 min)
-                budget: constraints?.maxTokens
-                    ? { ...SUBAGENT_BUDGET, maxTokens: constraints.maxTokens }
-                    : SUBAGENT_BUDGET,
+                // Share parent's file cache to eliminate redundant reads across agents
+                fileCache: this.fileCache || undefined,
+                // CONSTRAINED BUDGET: Use pooled budget when available, falling back to SUBAGENT_BUDGET
+                // Pooled budget ensures total tree cost stays bounded by parent's budget
+                budget: pooledBudget.budget,
             });
             // CRITICAL: Subagent inherits parent's mode
             // This ensures that if parent is in plan mode:
@@ -3549,6 +3781,17 @@ export class ProductionAgent {
             if (parentMode !== 'build') {
                 subAgent.setMode(parentMode);
             }
+            // APPROVAL BATCHING (Improvement P6): Set approval scope for subagents
+            // Read-only tools are auto-approved; write tools get scoped approval
+            // This reduces interruptions from ~8 per session to ~1-2
+            subAgent.setApprovalScope({
+                autoApprove: ['read_file', 'list_files', 'glob', 'grep', 'show_file_history', 'show_session_changes'],
+                scopedApprove: {
+                    write_file: { paths: ['src/', 'tests/', 'tools/'] },
+                    edit_file: { paths: ['src/', 'tests/', 'tools/'] },
+                },
+                requireApproval: ['bash', 'delete_file'],
+            });
             // Pass parent's iteration count to subagent for accurate budget tracking
             // This prevents subagents from consuming excessive iterations when parent already used many
             subAgent.setParentIterations(this.getTotalIterations());
@@ -3899,6 +4142,13 @@ export class ProductionAgent {
                 // Dispose both sources (linked source disposes its internal state, timeout source handles its timer)
                 effectiveSource.dispose();
                 progressAwareTimeout.dispose();
+                // BUDGET POOL: Record actual usage and release the allocation
+                // This must happen in finally to ensure cleanup on both success and error paths
+                if (this.budgetPool && poolAllocationId) {
+                    const subMetrics = subAgent.getMetrics();
+                    this.budgetPool.recordUsage(poolAllocationId, subMetrics.totalTokens, subMetrics.estimatedCost);
+                    this.budgetPool.release(poolAllocationId);
+                }
             }
         }
         catch (err) {
@@ -3926,6 +4176,49 @@ export class ProductionAgent {
      * Spawn multiple agents in parallel to work on independent tasks.
      * Uses the shared blackboard for coordination and conflict prevention.
      *
+     * Get budget for a subagent, using the pooled budget when available.
+     * Falls back to the static SUBAGENT_BUDGET if no pool is configured.
+     * Returns both the budget and the pool allocation ID (if any) for tracking.
+     */
+    getSubagentBudget(agentName, constraints) {
+        // If explicit maxTokens constraint, use that
+        if (constraints?.maxTokens) {
+            return {
+                budget: { ...SUBAGENT_BUDGET, maxTokens: constraints.maxTokens },
+                allocationId: null,
+            };
+        }
+        // Try to allocate from the shared budget pool
+        if (this.budgetPool) {
+            const allocationId = `${agentName}-${Date.now()}`;
+            const allocation = this.budgetPool.reserve(allocationId);
+            if (allocation) {
+                return {
+                    budget: {
+                        ...SUBAGENT_BUDGET,
+                        maxTokens: allocation.tokenBudget,
+                        softTokenLimit: Math.floor(allocation.tokenBudget * 0.7),
+                        maxCost: allocation.costBudget,
+                    },
+                    allocationId,
+                };
+            }
+            // Pool exhausted — give a tiny emergency budget (just enough to report failure)
+            // This does NOT bypass the pool — it's a fixed small cost for error messaging
+            return {
+                budget: {
+                    ...SUBAGENT_BUDGET,
+                    maxTokens: 5000,
+                    softTokenLimit: 3000,
+                    maxCost: 0.01,
+                },
+                allocationId: null,
+            };
+        }
+        // No pool — use default subagent budget
+        return { budget: SUBAGENT_BUDGET, allocationId: null };
+    }
+    /**
      * Uses Promise.allSettled to handle partial failures gracefully - if one
      * agent fails or times out, others can still complete successfully.
      */
@@ -4321,6 +4614,15 @@ If the task is a simple question or doesn't need specialized handling, set bestA
     setParentIterations(count) {
         this.parentIterations = count;
     }
+    /**
+     * Set an approval scope for this agent (used by parent when spawning subagents).
+     * Enables pre-approved operations within a defined scope, reducing approval prompts.
+     */
+    setApprovalScope(scope) {
+        if (this.safety?.humanInLoop) {
+            this.safety.humanInLoop.setApprovalScope(scope);
+        }
+    }
     /**
      * Set an external cancellation token for this agent.
      * Used when spawning subagents to propagate parent timeout/cancellation.