attocode 0.1.6 → 0.1.7

package/dist/src/agent.js

@@ -18,10 +18,10 @@
  * - Execution Policies (Lesson 23)
  * - Thread Management (Lesson 24)
  */
-import { buildConfig, isFeatureEnabled, getEnabledFeatures, } from './defaults.js';
-import { createModeManager, formatModeList, parseMode, } from './modes.js';
+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, } from './integrations/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';
 // Lesson 26: Tracing & Evaluation integration
 import { createTraceCollector } from './tracing/trace-collector.js';
 // Model registry for context window limits
@@ -29,6 +29,8 @@ import { modelRegistry } from './costs/index.js';
 import { getModelContextLength } from './integrations/openrouter-pricing.js';
 // Spawn agent tools for LLM-driven subagent delegation
 import { createBoundSpawnAgentTool, createBoundSpawnAgentsParallelTool, } from './tools/agent.js';
+// Task tools for Claude Code-style task management
+import { createTaskTools, } from './tools/tasks.js';
 // =============================================================================
 // PRODUCTION AGENT
 // =============================================================================
@@ -72,12 +74,16 @@ export class ProductionAgent {
     capabilitiesRegistry = null;
     toolResolver = null;
     blackboard = null;
+    taskManager = null;
     // Duplicate spawn prevention - tracks recently spawned tasks to prevent doom loops
     // Map<taskKey, { timestamp: number; result: string; queuedChanges: number }>
     spawnedTasks = new Map();
     static SPAWN_DEDUP_WINDOW_MS = 60000; // 60 seconds
     // Parent iteration tracking for total budget calculation
     parentIterations = 0;
+    // External cancellation token (for subagent timeout propagation)
+    // When set, the agent will check this token in addition to its own cancellation manager
+    externalCancellationToken = null;
     // Initialization tracking
     initPromises = [];
     initComplete = false;
@@ -234,11 +240,25 @@ export class ProductionAgent {
             console.warn('[ProductionAgent] Failed to load user agents:', err);
         }));
         // Register spawn_agent tool so LLM can delegate to subagents
-        const boundSpawnTool = createBoundSpawnAgentTool((name, task) => this.spawnAgent(name, task));
+        const boundSpawnTool = createBoundSpawnAgentTool((name, task, constraints) => this.spawnAgent(name, task, constraints));
         this.tools.set(boundSpawnTool.name, boundSpawnTool);
         // Register spawn_agents_parallel tool for parallel subagent execution
         const boundParallelSpawnTool = createBoundSpawnAgentsParallelTool((tasks) => this.spawnAgentsParallel(tasks));
         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) => {
+            this.emit({ type: 'task.created', task: data.task });
+        });
+        this.taskManager.on('task.updated', (data) => {
+            this.emit({ type: 'task.updated', task: data.task });
+        });
+        // Register task tools
+        const taskTools = createTaskTools(this.taskManager);
+        for (const tool of taskTools) {
+            this.tools.set(tool.name, tool);
+        }
         // Cancellation Support
         if (isFeatureEnabled(this.config.cancellation)) {
             this.cancellation = createCancellationManager();
@@ -863,10 +883,16 @@ export class ProductionAgent {
                 });
                 // =======================================================================
                 // CANCELLATION CHECK
+                // Checks both internal cancellation (ESC key) and external cancellation
+                // (parent timeout when this agent is a subagent)
                 // =======================================================================
                 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
                 // =======================================================================
@@ -1900,17 +1926,21 @@ export class ProductionAgent {
                 // Execute tool (with sandbox if available)
                 let result;
                 if (this.safety?.sandbox) {
-                    // CRITICAL: spawn_agent needs a MUCH longer timeout than regular tools
+                    // CRITICAL: spawn_agent and spawn_agents_parallel need MUCH longer timeouts
                     // The default 60s sandbox timeout would kill subagents prematurely
                     // Subagents may run for minutes (per their own timeout config)
                     const isSpawnAgent = toolCall.name === 'spawn_agent';
+                    const isSpawnParallel = toolCall.name === 'spawn_agents_parallel';
+                    const isSubagentTool = isSpawnAgent || isSpawnParallel;
                     const subagentConfig = this.config.subagent;
                     const hasSubagentConfig = subagentConfig !== false && subagentConfig !== undefined;
                     const subagentTimeout = hasSubagentConfig
                         ? subagentConfig.defaultTimeout ?? 600000 // 10 min default
                         : 600000;
-                    // Use subagent timeout + buffer for spawn_agent, default for others
-                    const toolTimeout = isSpawnAgent ? subagentTimeout + 30000 : undefined;
+                    // Use subagent timeout + buffer for spawn tools, default for others
+                    // For spawn_agents_parallel, multiply by number of agents (they run in parallel,
+                    // but the total wall-clock time should still allow the slowest agent to complete)
+                    const toolTimeout = isSubagentTool ? subagentTimeout + 30000 : undefined;
                     result = await this.safety.sandbox.executeWithLimits(() => tool.execute(toolCall.arguments), toolTimeout);
                 }
                 else {
@@ -2294,6 +2324,13 @@ export class ProductionAgent {
     getTraceCollector() {
         return this.traceCollector;
     }
+    /**
+     * Set a trace collector for this agent.
+     * Used for subagents to share the parent's trace collector (with subagent context).
+     */
+    setTraceCollector(collector) {
+        this.traceCollector = collector;
+    }
     /**
      * Get the learning store for cross-session learning.
      * Returns null if learning store is not enabled.
@@ -2813,6 +2850,11 @@ export class ProductionAgent {
         if (!this.threadManager) {
             throw new Error('Thread management not enabled. Enable it in config to use createCheckpoint()');
         }
+        // CRITICAL: Sync current state.messages to threadManager before checkpoint
+        // The run() method adds messages directly to this.state.messages but doesn't sync
+        // to threadManager, so thread.messages would be empty without this sync
+        const thread = this.threadManager.getActiveThread();
+        thread.messages = [...this.state.messages];
         const checkpoint = this.threadManager.createCheckpoint({
             label,
             agentState: this.state,
@@ -2987,8 +3029,12 @@ export class ProductionAgent {
     /**
      * Spawn an agent to execute a task.
      * Returns the result when the agent completes.
+     *
+     * @param agentName - Name of the agent to spawn (researcher, coder, etc.)
+     * @param task - The task description for the agent
+     * @param constraints - Optional constraints to keep the subagent focused
      */
-    async spawnAgent(agentName, task) {
+    async spawnAgent(agentName, task, constraints) {
         if (!this.agentRegistry) {
             return {
                 success: false,
@@ -3004,10 +3050,10 @@ export class ProductionAgent {
                 metrics: { tokens: 0, duration: 0, toolCalls: 0 },
             };
         }
-        // DUPLICATE SPAWN PREVENTION
-        // Create a key from agent name and normalized task (first 150 chars to catch same intent)
+        // DUPLICATE SPAWN PREVENTION with SEMANTIC SIMILARITY
+        // First try exact string match, then check semantic similarity for similar tasks
+        const SEMANTIC_SIMILARITY_THRESHOLD = 0.75; // 75% similarity = duplicate
         const taskKey = `${agentName}:${task.slice(0, 150).toLowerCase().replace(/\s+/g, ' ').trim()}`;
-        const existing = this.spawnedTasks.get(taskKey);
         const now = Date.now();
         // Clean up old entries (older than dedup window)
         for (const [key, entry] of this.spawnedTasks.entries()) {
@@ -3015,21 +3061,48 @@ export class ProductionAgent {
                 this.spawnedTasks.delete(key);
             }
         }
-        if (existing && now - existing.timestamp < ProductionAgent.SPAWN_DEDUP_WINDOW_MS) {
-            // Same task spawned within the dedup window - return cached result
-            // Log this as a warning for observability (no special event type needed)
+        // Check for exact match first
+        let existingMatch = this.spawnedTasks.get(taskKey);
+        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 (existingMatch && now - existingMatch.timestamp < ProductionAgent.SPAWN_DEDUP_WINDOW_MS) {
+            // Same or semantically similar task spawned within the dedup window
             this.observability?.logger?.warn('Duplicate spawn prevented', {
                 agent: agentName,
                 task: task.slice(0, 100),
-                originalTimestamp: existing.timestamp,
-                elapsedMs: now - existing.timestamp,
+                matchType,
+                originalTimestamp: existingMatch.timestamp,
+                elapsedMs: now - existingMatch.timestamp,
             });
-            const duplicateMessage = `[DUPLICATE SPAWN PREVENTED]\n` +
-                `This task was already spawned ${Math.round((now - existing.timestamp) / 1000)}s ago.\n` +
-                `${existing.queuedChanges > 0
-                    ? `The previous spawn queued ${existing.queuedChanges} change(s) to the pending plan.\n` +
+            const duplicateMessage = `[DUPLICATE SPAWN PREVENTED${matchType === 'semantic' ? ' - SEMANTIC MATCH' : ''}]\n` +
+                `This task was already spawned ${Math.round((now - existingMatch.timestamp) / 1000)}s ago.\n` +
+                `${existingMatch.queuedChanges > 0
+                    ? `The previous spawn queued ${existingMatch.queuedChanges} change(s) to the pending plan.\n` +
                         `These changes are already in your plan - do NOT spawn again.\n`
-                    : ''}Previous result summary:\n${existing.result.slice(0, 500)}`;
+                    : ''}Previous result summary:\n${existingMatch.result.slice(0, 500)}`;
             return {
                 success: true, // Mark as success since original task completed
                 output: duplicateMessage,
@@ -3049,16 +3122,88 @@ export class ProductionAgent {
             const resolvedModel = (agentDef.model && agentDef.model.includes('/'))
                 ? agentDef.model
                 : this.config.model;
-            // Get subagent config with defaults
-            // Note: subagent config is SubagentConfig | false from buildConfig
+            // Get subagent config with agent-type-specific timeouts and iteration limits
+            // Uses dynamic configuration based on agent type (researcher needs more time than reviewer)
             const subagentConfig = this.config.subagent;
             const hasSubagentConfig = subagentConfig !== false && subagentConfig !== undefined;
-            const defaultMaxIterations = hasSubagentConfig
-                ? subagentConfig.defaultMaxIterations ?? 25
-                : 25; // Increased from 10 to allow more thorough exploration
-            const subagentTimeout = hasSubagentConfig
-                ? subagentConfig.defaultTimeout ?? 600000
-                : 600000; // Increased from 120s to 600s (10 minutes) for deeper analysis
+            // Agent-type-specific timeout: researchers get 5min, reviewers get 2min, etc.
+            const agentTypeTimeout = getSubagentTimeout(agentName);
+            const configTimeout = hasSubagentConfig
+                ? subagentConfig.defaultTimeout
+                : undefined;
+            const subagentTimeout = configTimeout ?? agentTypeTimeout;
+            // Agent-type-specific iteration limit: researchers get 25, documenters get 10, etc.
+            const agentTypeMaxIter = getSubagentMaxIterations(agentName);
+            const configMaxIter = hasSubagentConfig
+                ? subagentConfig.defaultMaxIterations
+                : undefined;
+            const defaultMaxIterations = agentDef.maxIterations ?? configMaxIter ?? agentTypeMaxIter;
+            // BLACKBOARD CONTEXT INJECTION
+            // Gather relevant context from the blackboard for the subagent
+            let blackboardContext = '';
+            const parentAgentId = `parent-${Date.now()}`;
+            if (this.blackboard) {
+                // Post parent's exploration context before spawning
+                this.blackboard.post(parentAgentId, {
+                    topic: 'spawn.parent_context',
+                    content: `Parent spawning ${agentName} for task: ${task.slice(0, 200)}`,
+                    type: 'progress',
+                    confidence: 1,
+                    metadata: { agentName, taskPreview: task.slice(0, 100) },
+                });
+                // Gather recent findings that might help the subagent
+                const recentFindings = this.blackboard.query({
+                    limit: 5,
+                    types: ['discovery', 'analysis', 'progress'],
+                    minConfidence: 0.7,
+                });
+                if (recentFindings.length > 0) {
+                    const findingsSummary = recentFindings
+                        .map(f => `- [${f.agentId}] ${f.topic}: ${f.content.slice(0, 150)}${f.content.length > 150 ? '...' : ''}`)
+                        .join('\n');
+                    blackboardContext = `\n\n**BLACKBOARD CONTEXT (from parent/sibling agents):**\n${findingsSummary}\n`;
+                }
+            }
+            // Check for files already being modified in parent's pending plan
+            const currentPlan = this.pendingPlanManager.getPendingPlan();
+            if (currentPlan && currentPlan.proposedChanges.length > 0) {
+                const pendingFiles = currentPlan.proposedChanges
+                    .filter((c) => c.tool === 'write_file' || c.tool === 'edit_file')
+                    .map((c) => c.args.path || c.args.file_path)
+                    .filter(Boolean);
+                if (pendingFiles.length > 0) {
+                    blackboardContext += `\n**FILES ALREADY IN PENDING PLAN (do not duplicate):**\n${pendingFiles.slice(0, 10).join('\n')}\n`;
+                }
+            }
+            // CONSTRAINT INJECTION
+            // Add constraints to the subagent's context if provided
+            let constraintContext = '';
+            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')}`);
+                }
+                if (constraints.excludeAreas && constraints.excludeAreas.length > 0) {
+                    constraintParts.push(`**EXCLUDED AREAS (do NOT explore these):**\n${constraints.excludeAreas.map(a => `  - ${a}`).join('\n')}`);
+                }
+                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`;
+                }
+            }
+            // 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}`;
             // Create a sub-agent with the agent's config
             const subAgent = new ProductionAgent({
                 provider: this.provider,
@@ -3067,7 +3212,7 @@ export class ProductionAgent {
                 toolResolver: this.toolResolver || undefined,
                 // Pass MCP tool summaries so subagent knows what tools are available
                 mcpToolSummaries: this.config.mcpToolSummaries,
-                systemPrompt: agentDef.systemPrompt,
+                systemPrompt: subagentSystemPrompt,
                 model: resolvedModel,
                 maxIterations: agentDef.maxIterations || defaultMaxIterations,
                 // Inherit some features but keep subagent simpler
@@ -3093,13 +3238,23 @@ export class ProductionAgent {
             // - Subagent's read operations execute immediately (visible exploration)
             // - Subagent's write operations get queued in the subagent's pending plan
             // - User maintains control over what actually gets written
-            const parentMode = this.getMode();
             if (parentMode !== 'build') {
                 subAgent.setMode(parentMode);
             }
             // 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());
+            // UNIFIED TRACING: Share parent's trace collector with subagent context
+            // This ensures all subagent events are written to the same trace file as the parent,
+            // tagged with subagent context for proper aggregation in /trace output
+            if (this.traceCollector) {
+                const subagentTraceView = this.traceCollector.createSubagentView({
+                    parentSessionId: this.traceCollector.getSessionId() || 'unknown',
+                    agentType: agentName,
+                    spawnedAtIteration: this.state.iteration,
+                });
+                subAgent.setTraceCollector(subagentTraceView);
+            }
             // Forward events from subagent with context
             subAgent.subscribe(event => {
                 // Tag event with subagent source so TUI can display it properly
@@ -3113,6 +3268,10 @@ export class ProductionAgent {
             const effectiveSource = parentSource
                 ? createLinkedToken(parentSource, timeoutSource)
                 : timeoutSource;
+            // 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);
             try {
                 // Run the task with cancellation propagation from parent
                 const result = await race(subAgent.run(task), effectiveSource.token);
@@ -3225,6 +3384,20 @@ export class ProductionAgent {
                         ? 'User cancelled'
                         : `Timed out after ${subagentTimeout}ms`;
                     this.emit({ type: 'agent.error', agentId: agentName, error: reason });
+                    // =======================================================================
+                    // PRESERVE PARTIAL RESULTS
+                    // Instead of discarding all work, capture whatever the subagent produced
+                    // before timeout. This prevents the "zombie agent" problem where tokens
+                    // are consumed but results are lost.
+                    // =======================================================================
+                    const subagentState = subAgent.getState();
+                    const subagentMetrics = subAgent.getMetrics();
+                    // Extract partial response from the last assistant message
+                    const assistantMessages = subagentState.messages.filter(m => m.role === 'assistant');
+                    const lastAssistantMsg = assistantMessages[assistantMessages.length - 1];
+                    const partialResponse = typeof lastAssistantMsg?.content === 'string'
+                        ? lastAssistantMsg.content
+                        : '';
                     // Extract pending plan before cleanup (even on cancellation, preserve any queued work)
                     let cancelledQueuedSummary = '';
                     if (subAgent.hasPendingPlan()) {
@@ -3267,13 +3440,50 @@ export class ProductionAgent {
                     catch {
                         // Ignore cleanup errors on cancellation
                     }
+                    // Build output message with partial results
                     const baseOutput = isUserCancellation
                         ? `Subagent '${agentName}' was cancelled by user.`
-                        : `Subagent '${agentName}' timed out after ${Math.round(subagentTimeout / 1000)}s. The task may be too complex or the model may be slow.`;
+                        : `Subagent '${agentName}' timed out after ${Math.round(subagentTimeout / 1000)}s.`;
+                    // Include partial response if we have one
+                    const partialResultSection = partialResponse
+                        ? `\n\n[PARTIAL RESULTS BEFORE TIMEOUT]\n${partialResponse.slice(0, 2000)}${partialResponse.length > 2000 ? '...(truncated)' : ''}`
+                        : '';
+                    // Enhanced tracing: Record subagent timeout with partial results
+                    this.traceCollector?.record({
+                        type: 'subagent.link',
+                        data: {
+                            parentSessionId: this.traceCollector.getSessionId() || 'unknown',
+                            childSessionId,
+                            childTraceId,
+                            childConfig: {
+                                agentType: agentName,
+                                model: resolvedModel || 'default',
+                                task,
+                                tools: agentTools.map(t => t.name),
+                            },
+                            spawnContext: {
+                                reason: `Delegated task: ${task.slice(0, 100)}`,
+                                expectedOutcome: agentDef.description,
+                                parentIteration: this.state.iteration,
+                            },
+                            result: {
+                                success: false,
+                                summary: `[TIMEOUT] ${baseOutput}\n${partialResponse.slice(0, 200)}`,
+                                tokensUsed: subagentMetrics.totalTokens,
+                                durationMs: duration,
+                            },
+                        },
+                    });
                     return {
                         success: false,
-                        output: baseOutput + cancelledQueuedSummary,
-                        metrics: { tokens: 0, duration, toolCalls: 0 },
+                        output: baseOutput + partialResultSection + cancelledQueuedSummary,
+                        // IMPORTANT: Use actual metrics instead of zeros
+                        // This ensures accurate token tracking in /trace output
+                        metrics: {
+                            tokens: subagentMetrics.totalTokens,
+                            duration,
+                            toolCalls: subagentMetrics.toolCalls,
+                        },
                     };
                 }
                 throw err; // Re-throw non-cancellation errors
@@ -3663,6 +3873,22 @@ If the task is a simple question or doesn't need specialized handling, set bestA
     setParentIterations(count) {
         this.parentIterations = count;
     }
+    /**
+     * Set an external cancellation token for this agent.
+     * Used when spawning subagents to propagate parent timeout/cancellation.
+     * The agent will check this token in its main loop and stop gracefully
+     * when cancellation is requested, preserving partial results.
+     */
+    setExternalCancellation(token) {
+        this.externalCancellationToken = token;
+    }
+    /**
+     * Check if external cancellation has been requested.
+     * Returns true if the external token signals cancellation.
+     */
+    isExternallyCancelled() {
+        return this.externalCancellationToken?.isCancellationRequested ?? false;
+    }
     /**
      * Get total iterations (this agent + parent).
      * Used for accurate budget tracking across subagent hierarchies.
@@ -3844,6 +4070,12 @@ If the task is a simple question or doesn't need specialized handling, set bestA
     getAgentRegistry() {
         return this.agentRegistry;
     }
+    /**
+     * Get the task manager instance for task tracking.
+     */
+    getTaskManager() {
+        return this.taskManager;
+    }
     /**
      * Get all loaded skills.
      */