attocode 0.1.7 → 0.1.9

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, AgentRegistry, filterToolsForAgent, formatAgentList, createCancellationManager, isCancellationError, createTimeoutToken, createLinkedToken, 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, } from './integrations/index.js';
 // Lesson 26: Tracing & Evaluation integration
 import { createTraceCollector } from './tracing/trace-collector.js';
 // Model registry for context window limits
@@ -74,7 +74,10 @@ export class ProductionAgent {
     capabilitiesRegistry = null;
     toolResolver = null;
     blackboard = null;
+    fileCache = null;
+    budgetPool = null;
     taskManager = null;
+    store = null;
     // Duplicate spawn prevention - tracks recently spawned tasks to prevent doom loops
     // Map<taskKey, { timestamp: number; result: string; queuedChanges: number }>
     spawnedTasks = new Map();
@@ -84,9 +87,17 @@ export class ProductionAgent {
     // External cancellation token (for subagent timeout propagation)
     // When set, the agent will check this token in addition to its own cancellation manager
     externalCancellationToken = null;
+    // 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;
+    // Event listener cleanup tracking (prevents memory leaks in long sessions)
+    unsubscribers = [];
     // State
     state = {
         status: 'idle',
@@ -101,6 +112,10 @@ export class ProductionAgent {
             llmCalls: 0,
             toolCalls: 0,
             duration: 0,
+            successCount: 0,
+            failureCount: 0,
+            cancelCount: 0,
+            retryCount: 0,
         },
         iteration: 0,
     };
@@ -131,6 +146,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();
     }
@@ -227,11 +262,13 @@ export class ProductionAgent {
             }));
         }
         // Economics System (Token Budget) - always enabled
+        // Use custom budget if provided (subagents use SUBAGENT_BUDGET), otherwise STANDARD_BUDGET
+        const baseBudget = this.config.budget ?? STANDARD_BUDGET;
         this.economics = new ExecutionEconomicsManager({
-            ...STANDARD_BUDGET,
+            ...baseBudget,
             // Use maxIterations from config as absolute safety cap
             maxIterations: this.config.maxIterations,
-            targetIterations: Math.min(20, this.config.maxIterations),
+            targetIterations: Math.min(baseBudget.targetIterations ?? 20, this.config.maxIterations),
         });
         // Agent Registry - always enabled for subagent support
         this.agentRegistry = new AgentRegistry();
@@ -247,13 +284,17 @@ export class ProductionAgent {
         this.tools.set(boundParallelSpawnTool.name, boundParallelSpawnTool);
         // Task Manager - Claude Code-style task system for coordination
         this.taskManager = createTaskManager();
-        // Forward task events
-        this.taskManager.on('task.created', (data) => {
+        // Forward task events (with cleanup tracking for EventEmitter-based managers)
+        const taskCreatedHandler = (data) => {
             this.emit({ type: 'task.created', task: data.task });
-        });
-        this.taskManager.on('task.updated', (data) => {
+        };
+        this.taskManager.on('task.created', taskCreatedHandler);
+        this.unsubscribers.push(() => this.taskManager?.off('task.created', taskCreatedHandler));
+        const taskUpdatedHandler = (data) => {
             this.emit({ type: 'task.updated', task: data.task });
-        });
+        };
+        this.taskManager.on('task.updated', taskUpdatedHandler);
+        this.unsubscribers.push(() => this.taskManager?.off('task.updated', taskUpdatedHandler));
         // Register task tools
         const taskTools = createTaskTools(this.taskManager);
         for (const tool of taskTools) {
@@ -262,12 +303,13 @@ export class ProductionAgent {
         // Cancellation Support
         if (isFeatureEnabled(this.config.cancellation)) {
             this.cancellation = createCancellationManager();
-            // Forward cancellation events
-            this.cancellation.subscribe(event => {
+            // Forward cancellation events (with cleanup tracking)
+            const unsubCancellation = this.cancellation.subscribe(event => {
                 if (event.type === 'cancellation.requested') {
                     this.emit({ type: 'cancellation.requested', reason: event.reason });
                 }
             });
+            this.unsubscribers.push(unsubCancellation);
         }
         // Resource Monitoring
         if (isFeatureEnabled(this.config.resources)) {
@@ -298,8 +340,8 @@ export class ProductionAgent {
                 maxSize: this.config.semanticCache.maxSize,
                 ttl: this.config.semanticCache.ttl,
             });
-            // Forward cache events
-            this.semanticCache.subscribe(event => {
+            // Forward cache events (with cleanup tracking)
+            const unsubSemanticCache = this.semanticCache.subscribe(event => {
                 if (event.type === 'cache.hit') {
                     this.emit({ type: 'cache.hit', query: event.query, similarity: event.similarity });
                 }
@@ -310,6 +352,7 @@ export class ProductionAgent {
                     this.emit({ type: 'cache.set', query: event.query });
                 }
             });
+            this.unsubscribers.push(unsubSemanticCache);
         }
         // Skills Support
         if (isFeatureEnabled(this.config.skills)) {
@@ -361,8 +404,8 @@ export class ProductionAgent {
                 this.codebaseContext.setLSPManager(this.lspManager);
             }
         }
-        // Forward context engineering events
-        this.contextEngineering.on(event => {
+        // Forward context engineering events (with cleanup tracking)
+        const unsubContextEngineering = this.contextEngineering.on(event => {
             switch (event.type) {
                 case 'failure.recorded':
                     this.observability?.logger?.warn('Failure recorded', {
@@ -384,6 +427,7 @@ export class ProductionAgent {
                     break;
             }
         });
+        this.unsubscribers.push(unsubContextEngineering);
         // Interactive Planning (conversational + editable planning)
         if (isFeatureEnabled(this.config.interactivePlanning)) {
             const interactiveConfig = typeof this.config.interactivePlanning === 'object'
@@ -395,8 +439,8 @@ export class ProductionAgent {
                 maxCheckpoints: 20,
                 autoPauseAtDecisions: true,
             });
-            // Forward planner events to observability
-            this.interactivePlanner.on(event => {
+            // Forward planner events to observability (with cleanup tracking)
+            const unsubInteractivePlanner = this.interactivePlanner.on(event => {
                 switch (event.type) {
                     case 'plan.created':
                         this.observability?.logger?.info('Interactive plan created', {
@@ -420,6 +464,7 @@ export class ProductionAgent {
                         break;
                 }
             });
+            this.unsubscribers.push(unsubInteractivePlanner);
         }
         // Recursive Context (RLM - Recursive Language Models)
         // Enables on-demand context exploration for large codebases
@@ -436,8 +481,8 @@ export class ProductionAgent {
             });
             // Note: File system source should be registered when needed with proper glob/readFile functions
             // This is deferred to allow flexible configuration
-            // Forward RLM events
-            this.recursiveContext.on(event => {
+            // Forward RLM events (with cleanup tracking)
+            const unsubRecursiveContext = this.recursiveContext.on(event => {
                 switch (event.type) {
                     case 'process.started':
                         this.observability?.logger?.debug('RLM process started', {
@@ -464,6 +509,7 @@ export class ProductionAgent {
                         break;
                 }
             });
+            this.unsubscribers.push(unsubRecursiveContext);
         }
         // Learning Store (cross-session learning from failures)
         // Connects to the failure tracker in contextEngineering for automatic learning extraction
@@ -484,8 +530,8 @@ export class ProductionAgent {
                     this.learningStore.connectFailureTracker(failureTracker);
                 }
             }
-            // Forward learning events to observability
-            this.learningStore.on(event => {
+            // Forward learning events to observability (with cleanup tracking)
+            const unsubLearningStore = this.learningStore.on(event => {
                 switch (event.type) {
                     case 'learning.proposed':
                         this.observability?.logger?.info('Learning proposed', {
@@ -523,6 +569,7 @@ export class ProductionAgent {
                         break;
                 }
             });
+            this.unsubscribers.push(unsubLearningStore);
         }
         // Auto-Compaction Manager (sophisticated context compaction)
         // Uses the Compactor for LLM-based summarization with threshold monitoring
@@ -585,8 +632,8 @@ export class ProductionAgent {
                 maxContextTokens, // Dynamic from model registry or config
                 compactHandler, // Use reversible compaction when contextEngineering is available
             });
-            // Forward compactor events to observability
-            this.compactor.on(event => {
+            // Forward compactor events to observability (with cleanup tracking)
+            const unsubCompactor = this.compactor.on(event => {
                 switch (event.type) {
                     case 'compaction.start':
                         this.observability?.logger?.info('Compaction started', {
@@ -607,8 +654,9 @@ export class ProductionAgent {
                         break;
                 }
             });
-            // Forward auto-compaction events
-            this.autoCompactionManager.on((event) => {
+            this.unsubscribers.push(unsubCompactor);
+            // Forward auto-compaction events (with cleanup tracking)
+            const unsubAutoCompaction = this.autoCompactionManager.on((event) => {
                 switch (event.type) {
                     case 'autocompaction.warning':
                         this.observability?.logger?.warn('Context approaching limit', {
@@ -655,6 +703,7 @@ export class ProductionAgent {
                         break;
                 }
             });
+            this.unsubscribers.push(unsubAutoCompaction);
         }
         // Note: FileChangeTracker requires a database instance which is not
         // available at this point. Use initFileChangeTracker() to enable it
@@ -743,6 +792,7 @@ export class ProductionAgent {
             // Finalize
             const duration = Date.now() - startTime;
             this.state.metrics.duration = duration;
+            this.state.metrics.successCount = (this.state.metrics.successCount ?? 0) + 1;
             await this.observability?.tracer?.endTrace();
             const result = {
                 success: true,
@@ -773,6 +823,7 @@ export class ProductionAgent {
                 const cleanupDuration = Date.now() - cleanupStart;
                 this.emit({ type: 'cancellation.completed', cleanupDuration });
                 this.observability?.logger?.info('Agent cancelled', { reason: error.message, cleanupDuration });
+                this.state.metrics.cancelCount = (this.state.metrics.cancelCount ?? 0) + 1;
                 // Lesson 26: End trace capture on cancellation
                 if (this.traceCollector?.isTaskActive()) {
                     await this.traceCollector.endTask({ success: false, failureReason: `Cancelled: ${error.message}` });
@@ -791,6 +842,7 @@ export class ProductionAgent {
             }
             this.observability?.tracer?.recordError(error);
             await this.observability?.tracer?.endTrace();
+            this.state.metrics.failureCount = (this.state.metrics.failureCount ?? 0) + 1;
             this.emit({ type: 'error', error: error.message });
             this.observability?.logger?.error('Agent failed', { error: error.message });
             // Lesson 26: End trace capture on error
@@ -870,6 +922,9 @@ export class ProductionAgent {
             : 0.8;
         let reflectionAttempt = 0;
         let lastResponse = '';
+        let incompleteActionRetries = 0;
+        const requestedArtifact = this.extractRequestedArtifact(task);
+        const executedToolNames = new Set();
         // Outer loop for reflection (if enabled)
         while (reflectionAttempt < maxReflectionAttempts) {
             reflectionAttempt++;
@@ -883,16 +938,13 @@ export class ProductionAgent {
                 });
                 // =======================================================================
                 // CANCELLATION CHECK
-                // Checks both internal cancellation (ESC key) and external cancellation
-                // (parent timeout when this agent is a subagent)
+                // Checks internal cancellation (ESC key) — always immediate.
+                // External cancellation (parent timeout) is checked after economics
+                // to allow graceful wrapup when wrapup has been requested.
                 // =======================================================================
                 if (this.cancellation?.isCancelled) {
                     this.cancellation.token.throwIfCancellationRequested();
                 }
-                // Also check external cancellation token (from parent when spawned as subagent)
-                if (this.externalCancellationToken?.isCancellationRequested) {
-                    this.externalCancellationToken.throwIfCancellationRequested();
-                }
                 // =======================================================================
                 // RESOURCE CHECK - system resource limits
                 // =======================================================================
@@ -942,6 +994,7 @@ export class ProductionAgent {
                                 attempt: 1,
                                 maxAttempts: 1,
                             });
+                            this.state.metrics.retryCount = (this.state.metrics.retryCount ?? 0) + 1;
                             // Mark that we've attempted recovery to prevent infinite loops
                             this.state._recoveryAttempted = true;
                             const tokensBefore = this.estimateContextTokens(messages);
@@ -1035,6 +1088,26 @@ export class ProductionAgent {
                     }
                 }
                 // =======================================================================
+                // GRACEFUL WRAPUP CHECK
+                // If a wrapup has been requested (e.g., timeout approaching), convert
+                // to forceTextOnly + inject wrapup prompt for structured summary.
+                // Must come after economics check (which may also set forceTextOnly).
+                // =======================================================================
+                if (this.wrapupRequested && !forceTextOnly) {
+                    forceTextOnly = true;
+                    budgetInjectedPrompt = TIMEOUT_WRAPUP_PROMPT;
+                    this.wrapupRequested = false;
+                }
+                // =======================================================================
+                // EXTERNAL CANCELLATION CHECK (deferred from above)
+                // Checked after wrapup so that graceful wrapup can intercept the timeout.
+                // If wrapup was already requested and converted to forceTextOnly above,
+                // we skip throwing here to allow one more text-only turn for the summary.
+                // =======================================================================
+                if (this.externalCancellationToken?.isCancellationRequested && !forceTextOnly) {
+                    this.externalCancellationToken.throwIfCancellationRequested();
+                }
+                // =======================================================================
                 // INTELLIGENT LOOP DETECTION & NUDGE INJECTION
                 // Uses economics system for doom loops, exploration saturation, etc.
                 // =======================================================================
@@ -1133,6 +1206,40 @@ export class ProductionAgent {
                 const MAX_CONTINUATIONS = resilienceConfig.maxContinuations ?? 3;
                 const AUTO_CONTINUE = resilienceConfig.autoContinue ?? true;
                 const MIN_CONTENT_LENGTH = resilienceConfig.minContentLength ?? 1;
+                const INCOMPLETE_ACTION_RECOVERY = resilienceConfig.incompleteActionRecovery ?? true;
+                const MAX_INCOMPLETE_ACTION_RETRIES = resilienceConfig.maxIncompleteActionRetries ?? 2;
+                const ENFORCE_REQUESTED_ARTIFACTS = resilienceConfig.enforceRequestedArtifacts ?? true;
+                // =================================================================
+                // PRE-FLIGHT BUDGET CHECK: Estimate if LLM call would exceed budget
+                // Catches cases where we're at e.g. 120k and next call adds ~35k
+                // =================================================================
+                if (this.economics && !forceTextOnly) {
+                    const estimatedInputTokens = this.estimateContextTokens(messages);
+                    const estimatedOutputTokens = 4096; // Conservative output estimate
+                    const currentUsage = this.economics.getUsage();
+                    const budget = this.economics.getBudget();
+                    const projectedTotal = currentUsage.tokens + estimatedInputTokens + estimatedOutputTokens;
+                    if (projectedTotal > budget.maxTokens) {
+                        this.observability?.logger?.warn('Pre-flight budget check: projected overshoot', {
+                            currentTokens: currentUsage.tokens,
+                            estimatedInput: estimatedInputTokens,
+                            projectedTotal,
+                            maxTokens: budget.maxTokens,
+                        });
+                        // Inject wrap-up prompt if not already injected
+                        if (!budgetInjectedPrompt) {
+                            messages.push({
+                                role: 'user',
+                                content: '[System] BUDGET CRITICAL: This is your LAST response. Summarize findings concisely and stop. Do NOT call tools.',
+                            });
+                            this.state.messages.push({
+                                role: 'user',
+                                content: '[System] BUDGET CRITICAL: This is your LAST response. Summarize findings concisely and stop. Do NOT call tools.',
+                            });
+                        }
+                        forceTextOnly = true;
+                    }
+                }
                 let response = await this.callLLM(messages);
                 let emptyRetries = 0;
                 let continuations = 0;
@@ -1162,6 +1269,7 @@ export class ProductionAgent {
                         attempt: emptyRetries,
                         maxAttempts: MAX_EMPTY_RETRIES,
                     });
+                    this.state.metrics.retryCount = (this.state.metrics.retryCount ?? 0) + 1;
                     this.observability?.logger?.warn('Empty LLM response, retrying', {
                         attempt: emptyRetries,
                         maxAttempts: MAX_EMPTY_RETRIES,
@@ -1219,10 +1327,51 @@ export class ProductionAgent {
                         });
                     }
                 }
+                // Phase 2b: Handle truncated tool calls (stopReason=max_tokens with tool calls present)
+                // When a model hits max_tokens mid-tool-call, the JSON arguments are truncated and unparseable.
+                // Instead of executing broken tool calls, strip them and ask the LLM to retry smaller.
+                if (resilienceEnabled && response.stopReason === 'max_tokens' && response.toolCalls?.length) {
+                    this.emit({
+                        type: 'resilience.truncated_tool_call',
+                        toolNames: response.toolCalls.map(tc => tc.name),
+                    });
+                    this.observability?.logger?.warn('Tool call truncated at max_tokens', {
+                        toolNames: response.toolCalls.map(tc => tc.name),
+                        outputTokens: response.usage?.outputTokens,
+                    });
+                    // Strip truncated tool calls, inject recovery message
+                    const truncatedResponse = response;
+                    response = { ...response, toolCalls: undefined };
+                    const recoveryMessage = {
+                        role: 'user',
+                        content: '[System: Your previous tool call was truncated because the output exceeded the token limit. ' +
+                            'The tool call arguments were cut off and could not be parsed. ' +
+                            'Please retry with a smaller approach: for write_file, break the content into smaller chunks ' +
+                            'or use edit_file for targeted changes instead of rewriting entire files.]',
+                    };
+                    messages.push({ role: 'assistant', content: truncatedResponse.content || '' });
+                    messages.push(recoveryMessage);
+                    this.state.messages.push({ role: 'assistant', content: truncatedResponse.content || '' });
+                    this.state.messages.push(recoveryMessage);
+                    response = await this.callLLM(messages);
+                }
                 // Record LLM usage for economics
                 if (this.economics && response.usage) {
                     this.economics.recordLLMUsage(response.usage.inputTokens, response.usage.outputTokens, this.config.model, response.usage.cost // Use actual cost from provider when available
                     );
+                    // =================================================================
+                    // POST-LLM BUDGET CHECK: Prevent tool execution if over budget
+                    // A single LLM call can push us over - catch it before running tools
+                    // =================================================================
+                    if (!forceTextOnly) {
+                        const postCheck = this.economics.checkBudget();
+                        if (!postCheck.canContinue) {
+                            this.observability?.logger?.warn('Budget exceeded after LLM call, skipping tool execution', {
+                                reason: postCheck.reason,
+                            });
+                            forceTextOnly = true;
+                        }
+                    }
                 }
                 // Add assistant message
                 const assistantMessage = {
@@ -1253,6 +1402,61 @@ export class ProductionAgent {
                             iteration: this.state.iteration,
                         });
                     }
+                    const incompleteAction = this.detectIncompleteActionResponse(response.content || '');
+                    const missingRequiredArtifact = ENFORCE_REQUESTED_ARTIFACTS
+                        ? this.isRequestedArtifactMissing(requestedArtifact, executedToolNames)
+                        : false;
+                    const shouldRecoverIncompleteAction = resilienceEnabled
+                        && INCOMPLETE_ACTION_RECOVERY
+                        && !forceTextOnly
+                        && (incompleteAction || missingRequiredArtifact);
+                    if (shouldRecoverIncompleteAction) {
+                        if (incompleteActionRetries < MAX_INCOMPLETE_ACTION_RETRIES) {
+                            incompleteActionRetries++;
+                            const reason = missingRequiredArtifact && requestedArtifact
+                                ? `missing_requested_artifact:${requestedArtifact}`
+                                : 'future_intent_without_action';
+                            this.emit({
+                                type: 'resilience.incomplete_action_detected',
+                                reason,
+                                attempt: incompleteActionRetries,
+                                maxAttempts: MAX_INCOMPLETE_ACTION_RETRIES,
+                                requiresArtifact: missingRequiredArtifact,
+                            });
+                            this.observability?.logger?.warn('Incomplete action detected, retrying with nudge', {
+                                reason,
+                                attempt: incompleteActionRetries,
+                                maxAttempts: MAX_INCOMPLETE_ACTION_RETRIES,
+                            });
+                            const nudgeMessage = {
+                                role: 'user',
+                                content: missingRequiredArtifact && requestedArtifact
+                                    ? `[System: You said you would complete the next action, but no tool call was made. The task requires creating or updating "${requestedArtifact}". Execute the required tool now, or explicitly explain why it cannot be produced.]`
+                                    : '[System: You described a next action but did not execute it. If work remains, call the required tool now. If the task is complete, provide a final answer with no pending action language.]',
+                            };
+                            messages.push(nudgeMessage);
+                            this.state.messages.push(nudgeMessage);
+                            continue;
+                        }
+                        const failureReason = missingRequiredArtifact && requestedArtifact
+                            ? `incomplete_action_missing_artifact:${requestedArtifact}`
+                            : 'incomplete_action_unresolved';
+                        this.emit({
+                            type: 'resilience.incomplete_action_failed',
+                            reason: failureReason,
+                            attempts: incompleteActionRetries,
+                            maxAttempts: MAX_INCOMPLETE_ACTION_RETRIES,
+                        });
+                        throw new Error(`LLM failed to complete requested action after ${incompleteActionRetries} retries (${failureReason})`);
+                    }
+                    if (incompleteActionRetries > 0) {
+                        this.emit({
+                            type: 'resilience.incomplete_action_recovered',
+                            reason: 'incomplete_action',
+                            attempts: incompleteActionRetries,
+                        });
+                        incompleteActionRetries = 0;
+                    }
                     // No tool calls (or forced to ignore), agent is done - compact tool outputs to save context
                     // The model has "consumed" the tool outputs and produced a response,
                     // so we can replace verbose outputs with compact summaries
@@ -1293,6 +1497,7 @@ export class ProductionAgent {
                 for (let i = 0; i < toolCalls.length; i++) {
                     const toolCall = toolCalls[i];
                     const result = toolResults[i];
+                    executedToolNames.add(toolCall.name);
                     this.economics?.recordToolCall(toolCall.name, toolCall.arguments, result?.result);
                 }
                 // Add tool results to messages (with truncation and proactive budget management)
@@ -1340,8 +1545,11 @@ export class ProductionAgent {
                         this.compactToolOutputs();
                     }
                 }
+                const toolCallNameById = new Map(toolCalls.map(tc => [tc.id, tc.name]));
                 for (const result of toolResults) {
                     let content = typeof result.result === 'string' ? result.result : stableStringify(result.result);
+                    const sourceToolName = toolCallNameById.get(result.callId);
+                    const isExpensiveResult = sourceToolName === 'spawn_agent' || sourceToolName === 'spawn_agents_parallel';
                     // Truncate long outputs to save context
                     if (content.length > MAX_TOOL_OUTPUT_CHARS) {
                         content = content.slice(0, MAX_TOOL_OUTPUT_CHARS) + `\n\n... [truncated ${content.length - MAX_TOOL_OUTPUT_CHARS} chars]`;
@@ -1376,6 +1584,15 @@ export class ProductionAgent {
                         role: 'tool',
                         content,
                         toolCallId: result.callId,
+                        ...(isExpensiveResult
+                            ? {
+                                metadata: {
+                                    preserveFromCompaction: true,
+                                    costToRegenerate: 'high',
+                                    source: sourceToolName,
+                                },
+                            }
+                            : {}),
                     };
                     messages.push(toolMessage);
                     this.state.messages.push(toolMessage);
@@ -1497,28 +1714,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)
@@ -1529,13 +1760,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') {
@@ -1552,6 +1783,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);
@@ -1667,7 +1914,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()),
                 });
@@ -1741,6 +1988,19 @@ export class ProductionAgent {
             throw error;
         }
     }
+    /**
+     * Execute an async callback while excluding wall-clock wait time from duration budgeting.
+     * Used for external waits such as approval dialogs and delegation confirmation.
+     */
+    async withPausedDuration(fn) {
+        this.economics?.pauseDuration();
+        try {
+            return await fn();
+        }
+        finally {
+            this.economics?.resumeDuration();
+        }
+    }
     /**
      * Execute tool calls with safety checks and execution policy enforcement.
      */
@@ -1798,6 +2058,7 @@ export class ProductionAgent {
                 // =====================================================================
                 // EXECUTION POLICY ENFORCEMENT (Lesson 23)
                 // =====================================================================
+                let policyApprovedByUser = false;
                 if (this.executionPolicy) {
                     const policyContext = {
                         messages: this.state.messages,
@@ -1845,11 +2106,13 @@ export class ProductionAgent {
                     // Handle prompt policy - requires approval
                     if (evaluation.policy === 'prompt' && evaluation.requiresApproval) {
                         // Try to get approval through safety manager's human-in-loop
-                        if (this.safety?.humanInLoop) {
-                            const approval = await this.safety.humanInLoop.requestApproval(toolCall, `Policy requires approval: ${evaluation.reason}`);
+                        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,
@@ -1877,7 +2140,8 @@ export class ProductionAgent {
                 // SAFETY VALIDATION (Lesson 20-21)
                 // =====================================================================
                 if (this.safety) {
-                    const validation = await this.safety.validateAndApprove(toolCall, `Executing tool: ${toolCall.name}`);
+                    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}`);
                     }
@@ -1923,6 +2187,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) {
@@ -1961,6 +2248,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({
@@ -2286,7 +2589,14 @@ export class ProductionAgent {
      */
     getMetrics() {
         if (this.observability?.metrics) {
-            return this.observability.metrics.getMetrics();
+            const observed = this.observability.metrics.getMetrics();
+            return {
+                ...observed,
+                successCount: this.state.metrics.successCount ?? 0,
+                failureCount: this.state.metrics.failureCount ?? 0,
+                cancelCount: this.state.metrics.cancelCount ?? 0,
+                retryCount: this.state.metrics.retryCount ?? 0,
+            };
         }
         return this.state.metrics;
     }
@@ -2418,6 +2728,10 @@ export class ProductionAgent {
                 llmCalls: 0,
                 toolCalls: 0,
                 duration: 0,
+                successCount: 0,
+                failureCount: 0,
+                cancelCount: 0,
+                retryCount: 0,
             },
             iteration: 0,
         };
@@ -2563,6 +2877,10 @@ export class ProductionAgent {
                 toolCalls: sanitized.metrics.toolCalls ?? 0,
                 duration: sanitized.metrics.duration ?? 0,
                 reflectionAttempts: sanitized.metrics.reflectionAttempts,
+                successCount: sanitized.metrics.successCount ?? 0,
+                failureCount: sanitized.metrics.failureCount ?? 0,
+                cancelCount: sanitized.metrics.cancelCount ?? 0,
+                retryCount: sanitized.metrics.retryCount ?? 0,
             };
         }
         // Restore plan if present
@@ -2610,10 +2928,20 @@ export class ProductionAgent {
      */
     compactToolOutputs() {
         const COMPACT_PREVIEW_LENGTH = 200; // Keep first 200 chars as preview
+        const MAX_PRESERVED_EXPENSIVE_RESULTS = 6;
         let compactedCount = 0;
         let savedChars = 0;
-        for (const msg of this.state.messages) {
+        const preservedExpensiveIndexes = this.state.messages
+            .map((msg, index) => ({ msg, index }))
+            .filter(({ msg }) => msg.role === 'tool' && msg.metadata?.preserveFromCompaction === true)
+            .map(({ index }) => index);
+        const preserveSet = new Set(preservedExpensiveIndexes.slice(-MAX_PRESERVED_EXPENSIVE_RESULTS));
+        for (let i = 0; i < this.state.messages.length; i++) {
+            const msg = this.state.messages[i];
             if (msg.role === 'tool' && msg.content && msg.content.length > COMPACT_PREVIEW_LENGTH * 2) {
+                if (msg.metadata?.preserveFromCompaction === true && preserveSet.has(i)) {
+                    continue;
+                }
                 const originalLength = msg.content.length;
                 const preview = msg.content.slice(0, COMPACT_PREVIEW_LENGTH).replace(/\n/g, ' ');
                 msg.content = `[${preview}...] (${originalLength} chars, compacted)`;
@@ -2645,6 +2973,42 @@ export class ProductionAgent {
         }
         return Math.ceil(totalChars / 4); // ~4 chars per token
     }
+    /**
+     * Extract a requested markdown artifact filename from a task prompt.
+     * Returns null when no explicit artifact requirement is detected.
+     */
+    extractRequestedArtifact(task) {
+        const markdownArtifactMatch = task.match(/(?:write|save|create)[^.\n]{0,120}\b([A-Za-z0-9._/-]+\.md)\b/i);
+        return markdownArtifactMatch?.[1] ?? null;
+    }
+    /**
+     * Check whether a requested artifact appears to be missing based on executed tools.
+     */
+    isRequestedArtifactMissing(requestedArtifact, executedToolNames) {
+        if (!requestedArtifact) {
+            return false;
+        }
+        const artifactWriteTools = ['write_file', 'edit_file', 'apply_patch', 'append_file'];
+        return !artifactWriteTools.some(toolName => executedToolNames.has(toolName));
+    }
+    /**
+     * Detect "future-intent" responses that imply the model has not completed work.
+     */
+    detectIncompleteActionResponse(content) {
+        const trimmed = content.trim();
+        if (!trimmed) {
+            return false;
+        }
+        const lower = trimmed.toLowerCase();
+        const futureIntentPatterns = [
+            /^(now|next|then)\s+(i\s+will|i'll|let me)\b/,
+            /^i\s+(will|am going to|can)\b/,
+            /^(let me|i'll|i will)\s+(create|write|save|do|make|generate|start)\b/,
+            /^(now|next|then)\s+i(?:'ll| will)\b/,
+        ];
+        const completionSignals = /\b(done|completed|finished|here is|created|saved|wrote)\b/;
+        return futureIntentPatterns.some(pattern => pattern.test(lower)) && !completionSignals.test(lower);
+    }
     /**
      * Get audit log (if human-in-loop is enabled).
      */
@@ -2667,8 +3031,8 @@ export class ProductionAgent {
         for (const role of roles) {
             this.multiAgent.registerRole(role);
         }
-        // Set up event forwarding
-        this.multiAgent.on(event => {
+        // Set up event forwarding (unsubscribe after operation to prevent memory leaks)
+        const unsubMultiAgent = this.multiAgent.on(event => {
             switch (event.type) {
                 case 'agent.spawn':
                     this.emit({ type: 'multiagent.spawn', agentId: event.agentId, role: event.role });
@@ -2684,14 +3048,19 @@ export class ProductionAgent {
                     break;
             }
         });
-        const result = await this.multiAgent.runWithTeam(task, {
-            roles,
-            consensusStrategy: this.config.multiAgent && isFeatureEnabled(this.config.multiAgent)
-                ? this.config.multiAgent.consensusStrategy || 'voting'
-                : 'voting',
-            communicationMode: 'broadcast',
-        });
-        return result;
+        try {
+            const result = await this.multiAgent.runWithTeam(task, {
+                roles,
+                consensusStrategy: this.config.multiAgent && isFeatureEnabled(this.config.multiAgent)
+                    ? this.config.multiAgent.consensusStrategy || 'voting'
+                    : 'voting',
+                communicationMode: 'broadcast',
+            });
+            return result;
+        }
+        finally {
+            unsubMultiAgent();
+        }
     }
     /**
      * Add a role to the multi-agent manager.
@@ -2714,8 +3083,8 @@ export class ProductionAgent {
             throw new Error('ReAct not enabled. Enable it in config to use runWithReAct()');
         }
         this.observability?.logger?.info('Running with ReAct', { task });
-        // Set up event forwarding
-        this.react.on(event => {
+        // Set up event forwarding (unsubscribe after operation to prevent memory leaks)
+        const unsubReact = this.react.on(event => {
             switch (event.type) {
                 case 'react.thought':
                     this.emit({ type: 'react.thought', step: event.step, thought: event.thought });
@@ -2731,15 +3100,20 @@ export class ProductionAgent {
                     break;
             }
         });
-        const trace = await this.react.run(task);
-        // Store trace in memory if available
-        if (this.memory && trace.finalAnswer) {
-            this.memory.storeConversation([
-                { role: 'user', content: task },
-                { role: 'assistant', content: trace.finalAnswer },
-            ]);
+        try {
+            const trace = await this.react.run(task);
+            // Store trace in memory if available
+            if (this.memory && trace.finalAnswer) {
+                this.memory.storeConversation([
+                    { role: 'user', content: task },
+                    { role: 'assistant', content: trace.finalAnswer },
+                ]);
+            }
+            return trace;
+        }
+        finally {
+            unsubReact();
         }
-        return trace;
     }
     /**
      * Get the ReAct trace formatted as a string.
@@ -3109,11 +3483,15 @@ export class ProductionAgent {
                 metrics: { tokens: 0, duration: 0, toolCalls: 0 },
             };
         }
-        this.emit({ type: 'agent.spawn', agentId: `spawn-${Date.now()}`, name: agentName, task });
+        // Generate a unique ID for this agent instance that will be used consistently
+        // throughout the agent's lifecycle (spawn event, token events, completion events)
+        const agentId = `spawn-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.emit({ type: 'agent.spawn', agentId, name: agentName, task });
         this.observability?.logger?.info('Spawning agent', { name: agentName, task });
         const startTime = Date.now();
         const childSessionId = `subagent-${agentName}-${Date.now()}`;
         const childTraceId = `trace-${childSessionId}`;
+        let workerResultId;
         try {
             // Filter tools for this agent
             const agentTools = filterToolsForAgent(agentDef, Array.from(this.tools.values()));
@@ -3122,22 +3500,48 @@ export class ProductionAgent {
             const resolvedModel = (agentDef.model && agentDef.model.includes('/'))
                 ? agentDef.model
                 : this.config.model;
+            // Persist subagent task lifecycle in durable storage when available
+            if (this.store?.hasWorkerResultsFeature()) {
+                try {
+                    workerResultId = this.store.createWorkerResult(agentId, task.slice(0, 500), resolvedModel || 'default');
+                }
+                catch (storeErr) {
+                    this.observability?.logger?.warn('Failed to create worker result record', {
+                        agentId,
+                        error: storeErr.message,
+                    });
+                }
+            }
             // 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 = '';
@@ -3177,9 +3581,20 @@ export class ProductionAgent {
             }
             // CONSTRAINT INJECTION
             // Add constraints to the subagent's context if provided
-            let constraintContext = '';
+            // Also always include budget awareness so subagents know their limits
+            const constraintParts = [];
+            // BUDGET AWARENESS: Always inject so subagent understands its limits
+            const subagentBudgetTokens = constraints?.maxTokens ?? SUBAGENT_BUDGET.maxTokens ?? 100000;
+            const subagentBudgetMinutes = Math.round((SUBAGENT_BUDGET.maxDuration ?? 240000) / 60000);
+            constraintParts.push(`**RESOURCE AWARENESS (CRITICAL):**\n` +
+                `- Token budget: ~${(subagentBudgetTokens / 1000).toFixed(0)}k tokens\n` +
+                `- Time limit: ~${subagentBudgetMinutes} minutes\n` +
+                `- You will receive warnings at 70% usage. When warned, WRAP UP immediately.\n` +
+                `- Do not explore indefinitely - be focused and efficient.\n` +
+                `- If approaching limits, summarize findings and return.\n` +
+                `- **STRUCTURED WRAPUP:** When told to wrap up, respond with ONLY this JSON (no tool calls):\n` +
+                `  {"findings":[...], "actionsTaken":[...], "failures":[...], "remainingWork":[...], "suggestedNextSteps":[...]}`);
             if (constraints) {
-                const constraintParts = [];
                 if (constraints.focusAreas && constraints.focusAreas.length > 0) {
                     constraintParts.push(`**FOCUS AREAS (limit exploration to these paths):**\n${constraints.focusAreas.map(a => `  - ${a}`).join('\n')}`);
                 }
@@ -3189,22 +3604,21 @@ export class ProductionAgent {
                 if (constraints.requiredDeliverables && constraints.requiredDeliverables.length > 0) {
                     constraintParts.push(`**REQUIRED DELIVERABLES (you must produce these):**\n${constraints.requiredDeliverables.map(d => `  - ${d}`).join('\n')}`);
                 }
-                if (constraints.maxTokens) {
-                    constraintParts.push(`**TOKEN BUDGET:** ${constraints.maxTokens} tokens maximum`);
-                }
                 if (constraints.timeboxMinutes) {
                     constraintParts.push(`**TIME LIMIT:** ${constraints.timeboxMinutes} minutes (soft limit - wrap up if approaching)`);
                 }
-                if (constraintParts.length > 0) {
-                    constraintContext = `\n\n**EXECUTION CONSTRAINTS:**\n${constraintParts.join('\n\n')}\n`;
-                }
             }
+            const constraintContext = `\n\n**EXECUTION CONSTRAINTS:**\n${constraintParts.join('\n\n')}\n`;
             // Build subagent system prompt with subagent-specific plan mode addition
             const parentMode = this.getMode();
             const subagentSystemPrompt = parentMode === 'plan'
                 ? `${agentDef.systemPrompt}\n\n${SUBAGENT_PLAN_MODE_ADDITION}${blackboardContext}${constraintContext}`
                 : `${agentDef.systemPrompt}${blackboardContext}${constraintContext}`;
+            // 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({
                 provider: this.provider,
                 tools: agentTools,
@@ -3219,6 +3633,20 @@ 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,
@@ -3232,6 +3660,11 @@ export class ProductionAgent {
                 },
                 // Share parent's blackboard for coordination between parallel subagents
                 blackboard: this.blackboard || undefined,
+                // 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:
@@ -3241,6 +3674,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());
@@ -3255,23 +3699,61 @@ export class ProductionAgent {
                 });
                 subAgent.setTraceCollector(subagentTraceView);
             }
-            // Forward events from subagent with context
-            subAgent.subscribe(event => {
-                // Tag event with subagent source so TUI can display it properly
-                const taggedEvent = { ...event, subagent: agentName };
+            // GRACEFUL TIMEOUT with WRAPUP PHASE
+            // Instead of instant death on timeout, the subagent gets a wrapup window
+            // to produce a structured summary before being killed:
+            // 1. Normal operation: progress extends idle timer
+            // 2. Wrapup phase: 30s before hard kill, wrapup callback fires → forceTextOnly
+            // 3. Hard kill: race() throws CancellationError after wrapup window
+            const IDLE_TIMEOUT = 120000; // 2 minutes without progress = timeout
+            let WRAPUP_WINDOW = 30000;
+            let IDLE_CHECK_INTERVAL = 5000;
+            if (this.config.subagent) {
+                WRAPUP_WINDOW = this.config.subagent.wrapupWindowMs ?? WRAPUP_WINDOW;
+                IDLE_CHECK_INTERVAL = this.config.subagent.idleCheckIntervalMs ?? IDLE_CHECK_INTERVAL;
+            }
+            const progressAwareTimeout = createGracefulTimeout(subagentTimeout, // Max total time (hard limit from agent type config)
+            IDLE_TIMEOUT, // Idle timeout (soft limit - no progress triggers this)
+            WRAPUP_WINDOW, // Wrapup window before hard kill
+            IDLE_CHECK_INTERVAL);
+            // Register wrapup callback — fires 30s before hard kill
+            // This triggers the subagent's forceTextOnly path for a structured summary
+            progressAwareTimeout.onWrapupWarning(() => {
+                this.emit({
+                    type: 'subagent.wrapup.started',
+                    agentId,
+                    agentType: agentName,
+                    reason: 'Timeout approaching - graceful wrapup window opened',
+                    elapsedMs: Date.now() - startTime,
+                });
+                subAgent.requestWrapup('Timeout approaching — produce structured summary');
+            });
+            // Forward events from subagent with context (track for cleanup)
+            // Also report progress to the timeout tracker
+            const unsubSubAgent = subAgent.subscribe(event => {
+                // Tag event with subagent source AND unique ID so TUI can properly attribute
+                // events to the specific agent instance (critical for multiple same-type agents)
+                const taggedEvent = { ...event, subagent: agentName, subagentId: agentId };
                 this.emit(taggedEvent);
+                // Report progress for timeout extension
+                // Progress events: tool calls, LLM responses, token updates
+                const progressEvents = ['tool.start', 'tool.complete', 'llm.start', 'llm.complete'];
+                if (progressEvents.includes(event.type)) {
+                    progressAwareTimeout.reportProgress();
+                }
             });
-            // Create timeout token for subagent execution
-            const timeoutSource = createTimeoutToken(subagentTimeout);
-            // Link parent's cancellation with subagent timeout so ESC propagates to subagents
+            // Link parent's cancellation with progress-aware timeout so ESC propagates to subagents
             const parentSource = this.cancellation?.getSource();
             const effectiveSource = parentSource
-                ? createLinkedToken(parentSource, timeoutSource)
-                : timeoutSource;
+                ? createLinkedToken(parentSource, progressAwareTimeout)
+                : progressAwareTimeout;
             // CRITICAL: Pass the cancellation token to the subagent so it can check and stop
             // gracefully when timeout fires. Without this, the subagent continues running as
             // a "zombie" even after race() returns with a timeout error.
             subAgent.setExternalCancellation(effectiveSource.token);
+            // Pause parent's duration timer while subagent runs to prevent
+            // the parent from timing out on wall-clock while waiting for subagent
+            this.economics?.pauseDuration();
             try {
                 // Run the task with cancellation propagation from parent
                 const result = await race(subAgent.run(task), effectiveSource.token);
@@ -3324,6 +3806,8 @@ export class ProductionAgent {
                 const finalOutput = queuedChangeSummary
                     ? (result.response || '') + queuedChangeSummary
                     : (result.response || result.error || '');
+                // Parse structured closure report from agent's response (if it produced one)
+                const structured = parseStructuredClosureReport(result.response || '', 'completed');
                 const spawnResultFinal = {
                     success: result.success,
                     output: finalOutput,
@@ -3332,13 +3816,43 @@ export class ProductionAgent {
                         duration,
                         toolCalls: result.metrics.toolCalls,
                     },
+                    structured,
                 };
+                if (workerResultId && this.store?.hasWorkerResultsFeature()) {
+                    try {
+                        this.store.completeWorkerResult(workerResultId, {
+                            fullOutput: finalOutput,
+                            summary: finalOutput.slice(0, 500),
+                            artifacts: structured ? [{ type: 'structured_report', data: structured }] : undefined,
+                            metrics: {
+                                tokens: result.metrics.totalTokens,
+                                duration,
+                                toolCalls: result.metrics.toolCalls,
+                            },
+                        });
+                    }
+                    catch (storeErr) {
+                        this.observability?.logger?.warn('Failed to persist worker result', {
+                            agentId,
+                            error: storeErr.message,
+                        });
+                    }
+                }
                 this.emit({
                     type: 'agent.complete',
-                    agentId: agentName,
+                    agentId, // Use unique spawn ID for precise tracking
+                    agentType: agentName, // Keep type for display purposes
                     success: result.success,
                     output: finalOutput.slice(0, 500), // Include output preview
                 });
+                if (progressAwareTimeout.isInWrapupPhase()) {
+                    this.emit({
+                        type: 'subagent.wrapup.completed',
+                        agentId,
+                        agentType: agentName,
+                        elapsedMs: Date.now() - startTime,
+                    });
+                }
                 // Enhanced tracing: Record subagent completion
                 this.traceCollector?.record({
                     type: 'subagent.link',
@@ -3365,6 +3879,8 @@ export class ProductionAgent {
                         },
                     },
                 });
+                // Unsubscribe from subagent events before cleanup
+                unsubSubAgent();
                 await subAgent.cleanup();
                 // Cache result for duplicate spawn prevention
                 // Use the same taskKey from the dedup check above
@@ -3382,8 +3898,17 @@ export class ProductionAgent {
                     const isUserCancellation = parentSource?.isCancellationRequested;
                     const reason = isUserCancellation
                         ? 'User cancelled'
-                        : `Timed out after ${subagentTimeout}ms`;
-                    this.emit({ type: 'agent.error', agentId: agentName, error: reason });
+                        : err.reason || `Timed out after ${subagentTimeout}ms`;
+                    this.emit({ type: 'agent.error', agentId, agentType: agentName, error: reason });
+                    if (!isUserCancellation) {
+                        this.emit({
+                            type: 'subagent.timeout.hard_kill',
+                            agentId,
+                            agentType: agentName,
+                            reason,
+                            elapsedMs: Date.now() - startTime,
+                        });
+                    }
                     // =======================================================================
                     // PRESERVE PARTIAL RESULTS
                     // Instead of discarding all work, capture whatever the subagent produced
@@ -3433,7 +3958,8 @@ export class ProductionAgent {
                             this.pendingPlanManager.appendExplorationFinding(`[${agentName}] ${subPlan.explorationSummary}`);
                         }
                     }
-                    // Try to cleanup the subagent gracefully
+                    // Unsubscribe from subagent events and cleanup gracefully
+                    unsubSubAgent();
                     try {
                         await subAgent.cleanup();
                     }
@@ -3474,6 +4000,20 @@ export class ProductionAgent {
                             },
                         },
                     });
+                    // Parse structured closure report from partial response
+                    const exitReason = isUserCancellation ? 'cancelled' : 'timeout_graceful';
+                    const structured = parseStructuredClosureReport(partialResponse, exitReason, task);
+                    if (workerResultId && this.store?.hasWorkerResultsFeature()) {
+                        try {
+                            this.store.failWorkerResult(workerResultId, reason);
+                        }
+                        catch (storeErr) {
+                            this.observability?.logger?.warn('Failed to mark cancelled worker result as failed', {
+                                agentId,
+                                error: storeErr.message,
+                            });
+                        }
+                    }
                     return {
                         success: false,
                         output: baseOutput + partialResultSection + cancelledQueuedSummary,
@@ -3484,19 +4024,40 @@ export class ProductionAgent {
                             duration,
                             toolCalls: subagentMetrics.toolCalls,
                         },
+                        structured,
                     };
                 }
                 throw err; // Re-throw non-cancellation errors
             }
             finally {
+                // Resume parent's duration timer now that subagent is done
+                this.economics?.resumeDuration();
                 // Dispose both sources (linked source disposes its internal state, timeout source handles its timer)
                 effectiveSource.dispose();
-                timeoutSource.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) {
             const error = err instanceof Error ? err.message : String(err);
-            this.emit({ type: 'agent.error', agentId: agentName, error });
+            this.emit({ type: 'agent.error', agentId, agentType: agentName, error });
+            if (workerResultId && this.store?.hasWorkerResultsFeature()) {
+                try {
+                    this.store.failWorkerResult(workerResultId, error);
+                }
+                catch (storeErr) {
+                    this.observability?.logger?.warn('Failed to mark worker result as failed', {
+                        agentId,
+                        error: storeErr.message,
+                    });
+                }
+            }
             return {
                 success: false,
                 output: `Agent error: ${error}`,
@@ -3507,6 +4068,52 @@ 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.
      */
     async spawnAgentsParallel(tasks) {
         // Emit start event for TUI visibility
@@ -3515,9 +4122,28 @@ export class ProductionAgent {
             count: tasks.length,
             agents: tasks.map(t => t.agent),
         });
-        // Execute all tasks in parallel
+        // Execute all tasks in parallel using allSettled to handle partial failures
         const promises = tasks.map(({ agent, task }) => this.spawnAgent(agent, task));
-        const results = await Promise.all(promises);
+        const settled = await Promise.allSettled(promises);
+        // Convert settled results to SpawnResult array
+        const results = settled.map((result, i) => {
+            if (result.status === 'fulfilled') {
+                return result.value;
+            }
+            // Handle rejected promises (shouldn't happen since spawnAgent catches errors internally,
+            // but this is a safety net for unexpected failures)
+            const error = result.reason instanceof Error ? result.reason.message : String(result.reason);
+            this.emit({
+                type: 'agent.error',
+                agentId: tasks[i].agent,
+                error: `Unexpected parallel spawn error: ${error}`,
+            });
+            return {
+                success: false,
+                output: `Parallel spawn error: ${error}`,
+                metrics: { tokens: 0, duration: 0, toolCalls: 0 },
+            };
+        });
         // Emit completion event
         this.emit({
             type: 'parallel.spawn.complete',
@@ -3666,7 +4292,7 @@ If the task is a simple question or doesn't need specialized handling, set bestA
             const topSuggestion = suggestions[0];
             // If confirmation callback provided, ask user
             if (confirmDelegate && topSuggestion) {
-                const confirmed = await confirmDelegate(topSuggestion.agent, topSuggestion.reason);
+                const confirmed = await this.withPausedDuration(() => confirmDelegate(topSuggestion.agent, topSuggestion.reason));
                 if (!confirmed) {
                     // User declined, run with main agent
                     return this.run(task);
@@ -3723,6 +4349,14 @@ If the task is a simple question or doesn't need specialized handling, set bestA
     getResourceStatus() {
         return this.resourceManager?.getStatusString() || null;
     }
+    /**
+     * Reset CPU time counter for the resource manager.
+     * Call this when starting a new prompt to allow per-prompt time limits
+     * instead of session-wide limits.
+     */
+    resetResourceTimer() {
+        this.resourceManager?.resetCpuTime();
+    }
     // =========================================================================
     // LSP (LANGUAGE SERVER) METHODS
     // =========================================================================
@@ -3873,6 +4507,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.
@@ -3882,6 +4525,12 @@ If the task is a simple question or doesn't need specialized handling, set bestA
     setExternalCancellation(token) {
         this.externalCancellationToken = token;
     }
+    /**
+     * Set a SQLite store instance for durable persistence features.
+     */
+    setStore(store) {
+        this.store = store;
+    }
     /**
      * Check if external cancellation has been requested.
      * Returns true if the external token signals cancellation.
@@ -3889,6 +4538,15 @@ If the task is a simple question or doesn't need specialized handling, set bestA
     isExternallyCancelled() {
         return this.externalCancellationToken?.isCancellationRequested ?? false;
     }
+    /**
+     * Request a graceful wrapup of the agent's current work.
+     * On the next main loop iteration, the agent will produce a structured summary
+     * instead of making more tool calls.
+     */
+    requestWrapup(reason) {
+        this.wrapupRequested = true;
+        this.wrapupReason = reason || 'Timeout approaching';
+    }
     /**
      * Get total iterations (this agent + parent).
      * Used for accurate budget tracking across subagent hierarchies.
@@ -4162,6 +4820,29 @@ If the task is a simple question or doesn't need specialized handling, set bestA
      * Cleanup resources.
      */
     async cleanup() {
+        // Unsubscribe all event listeners (prevents memory leaks in long sessions)
+        for (const unsub of this.unsubscribers) {
+            try {
+                unsub();
+            }
+            catch {
+                // Ignore unsubscribe errors during cleanup
+            }
+        }
+        this.unsubscribers = [];
+        // Flush trace collector before cleanup
+        await this.traceCollector?.flush();
+        // Clear blackboard (releases file claim locks)
+        this.blackboard?.clear();
+        // Wait for any pending init before cleanup
+        if (this.initPromises.length > 0) {
+            try {
+                await Promise.all(this.initPromises);
+            }
+            catch {
+                // Ignore init errors during cleanup
+            }
+        }
         this.cancellation?.cleanup();
         this.resourceManager?.cleanup();
         await this.lspManager?.cleanup();
@@ -4369,4 +5050,64 @@ export class ProductionAgentBuilder {
 export function buildAgent() {
     return new ProductionAgentBuilder();
 }
+// =============================================================================
+// STRUCTURED CLOSURE REPORT PARSER
+// =============================================================================
+/**
+ * Parse a structured closure report from a subagent's text response.
+ * The subagent may have produced JSON in response to a TIMEOUT_WRAPUP_PROMPT.
+ *
+ * @param text - The subagent's last response text
+ * @param defaultExitReason - Exit reason to use (completed, timeout_graceful, cancelled, etc.)
+ * @param fallbackTask - Original task description for fallback remainingWork
+ * @returns Parsed StructuredClosureReport, or undefined if no JSON found and no fallback needed
+ */
+export function parseStructuredClosureReport(text, defaultExitReason, fallbackTask) {
+    if (!text) {
+        // No text at all — create a hard timeout fallback if we have a task
+        if (fallbackTask) {
+            return {
+                findings: [],
+                actionsTaken: [],
+                failures: ['Timeout before producing structured summary'],
+                remainingWork: [fallbackTask],
+                exitReason: 'timeout_hard',
+            };
+        }
+        return undefined;
+    }
+    try {
+        // Try to extract JSON from the response
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            // Validate that it looks like a closure report (has at least one expected field)
+            if (parsed.findings || parsed.actionsTaken || parsed.failures || parsed.remainingWork) {
+                return {
+                    findings: Array.isArray(parsed.findings) ? parsed.findings : [],
+                    actionsTaken: Array.isArray(parsed.actionsTaken) ? parsed.actionsTaken : [],
+                    failures: Array.isArray(parsed.failures) ? parsed.failures : [],
+                    remainingWork: Array.isArray(parsed.remainingWork) ? parsed.remainingWork : [],
+                    exitReason: defaultExitReason,
+                    suggestedNextSteps: Array.isArray(parsed.suggestedNextSteps) ? parsed.suggestedNextSteps : undefined,
+                };
+            }
+        }
+    }
+    catch {
+        // JSON parse failed — fall through to fallback
+    }
+    // Fallback: LLM didn't produce valid JSON but we have text
+    if (defaultExitReason !== 'completed') {
+        return {
+            findings: [text.slice(0, 500)],
+            actionsTaken: [],
+            failures: ['Did not produce structured JSON summary'],
+            remainingWork: fallbackTask ? [fallbackTask] : [],
+            exitReason: defaultExitReason === 'timeout_graceful' ? 'timeout_hard' : defaultExitReason,
+        };
+    }
+    // For completed agents, don't force a structured report if they didn't produce one
+    return undefined;
+}
 //# sourceMappingURL=agent.js.map