erosolar-cli 2.1.237 → 2.1.239

package/dist/core/orchestration.js

@@ -0,0 +1,2009 @@
+/**
+ * Unified Orchestration Module
+ *
+ * Single entry point for ALL orchestration modes:
+ * - Single-pass: Standard task completion
+ * - Dual-RL: Self-improving with refinement agent
+ * - Auto-execution: Full objective completion with deliverables
+ * - Security: Specialized for security assessments
+ * - APT-Chain: Full adversary simulation with kill-chain phases
+ * - Infrastructure: Full stack deployment and management
+ * - Government: Law enforcement and compliance procedures
+ *
+ * Features:
+ * - REAL execution: DNS queries, port scans, HTTP probes - not simulations
+ * - Concrete execution producing actual documents and procedures
+ * - Actionable results: training modules, incident response, security controls
+ * - Full offensive stack: recon, exploitation, persistence, exfiltration
+ * - Auto-execution to completion for all modes
+ * - RL-guided technique selection with real feedback loops
+ *
+ * Usage:
+ * ```typescript
+ * import { createOrchestrator, OrchestrationMode } from './orchestration.js';
+ *
+ * const orchestrator = createOrchestrator(agent, 'apt-chain');
+ * const result = await orchestrator.run(objective, options);
+ * ```
+ */
+import { AgentOrchestrator, } from './agentOrchestrator.js';
+import { DualAgentOrchestrator, } from './dualAgentOrchestrator.js';
+import { AutoExecutionOrchestrator, } from './autoExecutionOrchestrator.js';
+import { SecurityDeliverableGenerator, exportToMarkdown, exportToJSON, exportToHTML, } from './securityDeliverableGenerator.js';
+// Direct TAO imports for real execution
+import { techniqueRegistry, planAttackChain, selectNextTechnique, executeTechniqueInChain, listActiveChains, getChainStats, getRLState, } from '../tools/tao/index.js';
+import { parseNaturalLanguageIntent } from '../tools/tao/intentParser.js';
+import { getApplicableLegalFrameworks, } from './governmentProcedures.js';
+import { getInfrastructureStack, generateDeploymentScript, generateTeardownScript, generateOpsecChecklist, } from './infrastructureTemplates.js';
+// ═══════════════════════════════════════════════════════════════════════════════
+// UNIFIED ORCHESTRATOR
+// ═══════════════════════════════════════════════════════════════════════════════
+export class UnifiedOrchestrator {
+    agent;
+    workingDir;
+    singleOrchestrator;
+    dualOrchestrator;
+    autoOrchestrator;
+    deliverableGenerator;
+    constructor(agent, workingDir = process.cwd()) {
+        this.agent = agent;
+        this.workingDir = workingDir;
+        this.singleOrchestrator = new AgentOrchestrator(agent);
+        this.dualOrchestrator = new DualAgentOrchestrator(agent);
+        this.autoOrchestrator = new AutoExecutionOrchestrator(agent, workingDir);
+        this.deliverableGenerator = new SecurityDeliverableGenerator();
+    }
+    /**
+     * Run orchestration with unified interface
+     */
+    async run(request, options = {}) {
+        const mode = options.mode || 'single';
+        const startTime = Date.now();
+        switch (mode) {
+            case 'single':
+                return this.runSingle(request, options, startTime);
+            case 'dual-rl':
+                return this.runDualRL(request, options, startTime);
+            case 'auto':
+                return this.runAuto(request, options, startTime);
+            case 'auto-security':
+                return this.runAutoSecurity(request, options, startTime);
+            case 'security-only':
+                return this.runSecurityOnly(request, options, startTime);
+            case 'apt-chain':
+                return this.runAPTChain(request, options, startTime);
+            case 'infrastructure':
+                return this.runInfrastructure(request, options, startTime);
+            case 'incident-response':
+                return this.runIncidentResponse(request, options, startTime);
+            case 'training':
+                return this.runTraining(request, options, startTime);
+            case 'compliance':
+                return this.runCompliance(request, options, startTime);
+            case 'red-team':
+                return this.runRedTeam(request, options, startTime);
+            case 'a2ad':
+                return this.runA2AD(request, options, startTime);
+            case 'direct-apt':
+                return this.runDirectAPT(request, options, startTime);
+            case 'persistent-access':
+                return this.runPersistentAccess(request, options, startTime);
+            case 'intel-collection':
+                return this.runIntelCollection(request, options, startTime);
+            case 'impact':
+                return this.runImpact(request, options, startTime);
+            default:
+                // Check if goal-oriented execution is requested
+                if (options.goal || options.goals) {
+                    return this.runGoalOriented(request, options, startTime);
+                }
+                return this.runSingle(request, options, startTime);
+        }
+    }
+    /**
+     * Run single-pass orchestration
+     */
+    async runSingle(request, options, startTime) {
+        const orchestratorOptions = {
+            streaming: options.streaming ?? true,
+            enforceActions: options.enforceActions ?? true,
+            maxAttempts: options.maxAttempts ?? 6,
+        };
+        const result = await this.singleOrchestrator.runToCompletion(request, orchestratorOptions);
+        let deliverable;
+        let deliverablePaths;
+        if (options.generateDeliverable) {
+            deliverable = await this.deliverableGenerator.generate(options.deliverableType || 'pentest-report', result, this.agent.getHistory(), {});
+            if (options.outputDir && options.exportFormats) {
+                deliverablePaths = await this.exportDeliverable(deliverable, options.outputDir, options.exportFormats);
+            }
+            if (options.onDeliverable) {
+                options.onDeliverable(deliverable);
+            }
+        }
+        return {
+            mode: 'single',
+            success: result.exitReason === 'complete',
+            finalResponse: result.finalResponse,
+            toolsUsed: result.toolsUsed,
+            orchestratorResult: result,
+            deliverable,
+            deliverablePaths,
+            summary: result.statusSummary || 'Task completed',
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run dual-RL orchestration with refinement
+     */
+    async runDualRL(request, options, startTime) {
+        const dualOptions = {
+            mode: 'dual-rl',
+            streaming: options.streaming ?? true,
+            enforceActions: options.enforceActions ?? true,
+            maxAttempts: options.maxAttempts ?? 6,
+        };
+        const result = await this.dualOrchestrator.runToCompletion(request, dualOptions);
+        let deliverable;
+        let deliverablePaths;
+        if (options.generateDeliverable) {
+            deliverable = await this.deliverableGenerator.generate(options.deliverableType || 'pentest-report', result, this.agent.getHistory(), {});
+            if (options.outputDir && options.exportFormats) {
+                deliverablePaths = await this.exportDeliverable(deliverable, options.outputDir, options.exportFormats);
+            }
+            if (options.onDeliverable) {
+                options.onDeliverable(deliverable);
+            }
+        }
+        return {
+            mode: 'dual-rl',
+            success: result.exitReason === 'complete',
+            finalResponse: result.finalResponse,
+            toolsUsed: result.toolsUsed,
+            dualResult: result,
+            deliverable,
+            deliverablePaths,
+            summary: result.statusSummary || `Dual-RL: ${result.chosenAction || 'primary'} chosen`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run auto-execution to completion
+     */
+    async runAuto(request, options, startTime) {
+        const autoConfig = {
+            maxExecutionTime: options.maxExecutionTime,
+            maxCycles: options.maxCycles,
+            depth: options.depth,
+            stealthMode: options.stealthMode,
+            generateDeliverable: options.generateDeliverable ?? false,
+            deliverableType: options.deliverableType,
+            outputDir: options.outputDir,
+            exportFormats: options.exportFormats,
+            onProgress: options.onProgress,
+            onDeliverable: options.onDeliverable,
+        };
+        const result = await this.autoOrchestrator.execute(request, autoConfig);
+        return {
+            mode: 'auto',
+            success: result.success,
+            finalResponse: result.summary,
+            toolsUsed: result.metrics.toolsUsed,
+            autoResult: result,
+            deliverable: result.deliverable,
+            deliverablePaths: result.deliverablePaths,
+            summary: result.summary,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run auto-execution with security deliverables
+     */
+    async runAutoSecurity(request, options, startTime) {
+        const autoConfig = {
+            maxExecutionTime: options.maxExecutionTime ?? 30 * 60 * 1000,
+            maxCycles: options.maxCycles ?? 10,
+            depth: options.depth ?? 'standard',
+            stealthMode: options.stealthMode ?? false,
+            generateDeliverable: true,
+            deliverableType: options.deliverableType ?? 'pentest-report',
+            outputDir: options.outputDir ?? `${this.workingDir}/deliverables`,
+            exportFormats: options.exportFormats ?? ['markdown', 'json', 'html'],
+            onProgress: options.onProgress,
+            onDeliverable: options.onDeliverable,
+        };
+        const result = await this.autoOrchestrator.execute(request, autoConfig);
+        return {
+            mode: 'auto-security',
+            success: result.success,
+            finalResponse: result.summary,
+            toolsUsed: result.metrics.toolsUsed,
+            autoResult: result,
+            deliverable: result.deliverable,
+            deliverablePaths: result.deliverablePaths,
+            summary: result.summary,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Generate security deliverable from current conversation
+     */
+    async runSecurityOnly(request, options, startTime) {
+        // Create a minimal orchestrator result from current state
+        const minimalResult = {
+            finalResponse: request,
+            toolsUsed: [],
+            planOnly: false,
+            tookAction: false,
+            completion: {
+                isComplete: true,
+                confidence: 1,
+                signals: {
+                    hasExplicitCompletionStatement: true,
+                    hasIncompleteWorkIndicators: false,
+                    hasPendingActionIndicators: false,
+                    hasErrorIndicators: false,
+                    hasFollowUpQuestions: false,
+                    toolsUsedInLastResponse: 0,
+                    lastToolWasReadOnly: false,
+                    consecutiveResponsesWithoutTools: 0,
+                    hasRecentFileWrites: false,
+                    hasRecentCommits: false,
+                    todoItemsPending: 0,
+                    todoItemsCompleted: 0,
+                    mentionsFutureWork: false,
+                    completionConfidence: 1,
+                },
+                reason: 'Security deliverable generation',
+                shouldVerify: false,
+            },
+            exitReason: 'complete',
+            statusSummary: 'Deliverable generated',
+            limitations: [],
+            recommendations: [],
+        };
+        const generatorOptions = {
+            customTitle: request,
+        };
+        const deliverable = await this.deliverableGenerator.generate(options.deliverableType || 'pentest-report', minimalResult, this.agent.getHistory(), generatorOptions);
+        let deliverablePaths;
+        if (options.outputDir && options.exportFormats) {
+            deliverablePaths = await this.exportDeliverable(deliverable, options.outputDir, options.exportFormats);
+        }
+        if (options.onDeliverable) {
+            options.onDeliverable(deliverable);
+        }
+        return {
+            mode: 'security-only',
+            success: true,
+            finalResponse: `Generated ${deliverable.type} deliverable: ${deliverable.id}`,
+            toolsUsed: [],
+            deliverable,
+            deliverablePaths,
+            summary: `Deliverable generated with ${deliverable.findings.length} findings`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run full APT kill-chain simulation with REAL execution
+     * Executes complete adversary simulation with all kill-chain phases
+     * using actual network operations (DNS, TCP, HTTP)
+     */
+    async runAPTChain(request, options, startTime) {
+        const region = options.region || 'us';
+        const stack = getInfrastructureStack(region);
+        // Parse intent for real execution parameters
+        const intent = parseNaturalLanguageIntent(request);
+        const targets = options.targets ?? intent.targets;
+        const stealth = options.stealthMode ?? intent.constraints.includes('stealth');
+        const depth = this.normalizeDepth(options.depth ?? intent.depth);
+        // Track all real executions
+        const realExecutions = [];
+        const completedPhases = [];
+        // Execute REAL techniques for each target
+        for (const target of targets) {
+            // Create attack chain with RL planning
+            const chain = planAttackChain(intent, `APT simulation against ${target}`);
+            options.onChainProgress?.(chain, 0);
+            // Execute each phase with real network operations
+            while (chain.state === 'planning' || chain.state === 'executing') {
+                const action = selectNextTechnique(chain);
+                if (!action)
+                    break;
+                const technique = techniqueRegistry.get(action.id);
+                if (!technique)
+                    continue;
+                // Notify start
+                options.onTechniqueStart?.(action.id, target);
+                // Build technique params
+                const params = {
+                    target,
+                    depth,
+                    stealth,
+                    timeout: depth === 'quick' ? 5000 : depth === 'deep' ? 30000 : 15000,
+                    context: {},
+                };
+                // EXECUTE REAL TECHNIQUE
+                const { result, reward } = await executeTechniqueInChain(chain, action, params);
+                // Record execution
+                const execResult = {
+                    techniqueId: action.id,
+                    techniqueName: technique.name,
+                    phase: technique.phase,
+                    success: result.success,
+                    duration: result.duration,
+                    artifacts: result.artifacts,
+                    detectionRisk: result.detectionRisk,
+                    nextTechniques: result.nextTechniques,
+                };
+                realExecutions.push(execResult);
+                // Notify completion
+                options.onTechniqueComplete?.(execResult);
+                // Track phase completion
+                if (result.success && !completedPhases.includes(technique.phase)) {
+                    completedPhases.push(technique.phase);
+                }
+                // Update chain progress
+                options.onChainProgress?.(chain, chain.currentPhase);
+                // Short delay between techniques for stealth
+                if (stealth) {
+                    await new Promise(r => setTimeout(r, 500 + Math.random() * 1000));
+                }
+            }
+        }
+        // Compute real execution metrics
+        const rlState = getRLState();
+        const realMetrics = {
+            totalTechniquesExecuted: realExecutions.length,
+            successfulTechniques: realExecutions.filter(e => e.success).length,
+            failedTechniques: realExecutions.filter(e => !e.success).length,
+            totalDuration: realExecutions.reduce((sum, e) => sum + e.duration, 0),
+            averageDetectionRisk: realExecutions.length > 0
+                ? realExecutions.reduce((sum, e) => sum + e.detectionRisk, 0) / realExecutions.length
+                : 0,
+            phasesCompleted: completedPhases,
+            artifactsCollected: realExecutions.reduce((sum, e) => sum + e.artifacts.length, 0),
+            rlRewardAverage: rlState.avgReward,
+        };
+        // Now run the auto-orchestrator for comprehensive analysis and deliverable
+        const autoConfig = {
+            maxExecutionTime: options.maxExecutionTime ?? 60 * 60 * 1000,
+            maxCycles: options.maxCycles ?? 20,
+            depth,
+            stealthMode: stealth,
+            generateDeliverable: true,
+            deliverableType: 'apt-analysis',
+            outputDir: options.outputDir ?? `${this.workingDir}/deliverables`,
+            exportFormats: ['markdown', 'json', 'html'],
+            onProgress: options.onProgress,
+            onDeliverable: options.onDeliverable,
+        };
+        // Build summary from real executions for the AI orchestrator
+        const realExecutionSummary = this.buildRealExecutionSummary(realExecutions, realMetrics);
+        const result = await this.autoOrchestrator.execute(`APT SIMULATION ANALYSIS: ${request}\n\n` +
+            `REAL EXECUTION RESULTS:\n${realExecutionSummary}\n\n` +
+            `Analyze the real execution results and provide:\n` +
+            `1. Tactical analysis of what was discovered\n` +
+            `2. Risk assessment based on actual findings\n` +
+            `3. Recommendations for defensive improvements\n` +
+            `4. Evidence preservation notes\n\n` +
+            `Targets: ${targets.join(', ')}\n` +
+            `Constraints: ${options.constraints?.join(', ') || intent.constraints.join(', ') || 'standard ROE'}`, autoConfig);
+        // Get all active chains for reporting
+        const activeChains = listActiveChains();
+        const chainStats = getChainStats();
+        return {
+            mode: 'apt-chain',
+            success: result.success && realMetrics.successfulTechniques > 0,
+            finalResponse: result.summary,
+            toolsUsed: [...result.metrics.toolsUsed, ...realExecutions.map(e => `tao:${e.techniqueId}`)],
+            autoResult: result,
+            deliverable: result.deliverable,
+            deliverablePaths: result.deliverablePaths,
+            infrastructureStack: stack,
+            attackChainPhases: completedPhases.map(p => p),
+            persistenceMechanisms: stack?.persistence,
+            // Real execution data
+            realExecutions,
+            realMetrics,
+            attackChains: activeChains,
+            summary: `APT simulation: ${realMetrics.successfulTechniques}/${realMetrics.totalTechniquesExecuted} techniques, ${realMetrics.artifactsCollected} artifacts`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Build human-readable summary of real technique executions
+     */
+    buildRealExecutionSummary(executions, metrics) {
+        const lines = [];
+        lines.push(`## Execution Metrics`);
+        lines.push(`- Total techniques: ${metrics.totalTechniquesExecuted}`);
+        lines.push(`- Successful: ${metrics.successfulTechniques}`);
+        lines.push(`- Failed: ${metrics.failedTechniques}`);
+        lines.push(`- Total duration: ${(metrics.totalDuration / 1000).toFixed(1)}s`);
+        lines.push(`- Average detection risk: ${(metrics.averageDetectionRisk * 100).toFixed(1)}%`);
+        lines.push(`- Artifacts collected: ${metrics.artifactsCollected}`);
+        lines.push(`- Phases completed: ${metrics.phasesCompleted.join(', ') || 'none'}`);
+        lines.push('');
+        lines.push(`## Technique Execution Details`);
+        for (const exec of executions) {
+            const status = exec.success ? '✓' : '✗';
+            lines.push(`### ${status} ${exec.techniqueName} (${exec.techniqueId})`);
+            lines.push(`- Phase: ${exec.phase}`);
+            lines.push(`- Duration: ${exec.duration}ms`);
+            lines.push(`- Detection risk: ${(exec.detectionRisk * 100).toFixed(1)}%`);
+            if (exec.artifacts.length > 0) {
+                lines.push(`- Artifacts:`);
+                for (const artifact of exec.artifacts.slice(0, 10)) {
+                    lines.push(`  - [${artifact.type}] ${artifact.data.slice(0, 100)}${artifact.data.length > 100 ? '...' : ''}`);
+                }
+            }
+            if (exec.nextTechniques.length > 0) {
+                lines.push(`- Suggested next: ${exec.nextTechniques.join(', ')}`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Run infrastructure deployment mode
+     * Deploys full stack infrastructure for operations
+     */
+    async runInfrastructure(request, options, startTime) {
+        const region = options.region || 'us';
+        const stack = getInfrastructureStack(region);
+        if (!stack) {
+            return {
+                mode: 'infrastructure',
+                success: false,
+                finalResponse: `No infrastructure stack available for region: ${region}`,
+                toolsUsed: [],
+                summary: 'Infrastructure deployment failed - no stack',
+                duration: Date.now() - startTime,
+            };
+        }
+        const deployScript = generateDeploymentScript(stack);
+        const teardownScript = generateTeardownScript(stack);
+        const opsecList = generateOpsecChecklist(stack);
+        // Notify callback if provided
+        if (options.onInfrastructure) {
+            options.onInfrastructure(stack);
+        }
+        // Generate infrastructure assessment deliverable
+        const deliverable = await this.deliverableGenerator.generate('infrastructure-assessment', {
+            finalResponse: `Infrastructure stack deployed: ${stack.name}`,
+            toolsUsed: ['infrastructure-deploy'],
+            planOnly: false,
+            tookAction: true,
+            completion: {
+                isComplete: true,
+                confidence: 1,
+                signals: {
+                    hasExplicitCompletionStatement: true,
+                    hasIncompleteWorkIndicators: false,
+                    hasPendingActionIndicators: false,
+                    hasErrorIndicators: false,
+                    hasFollowUpQuestions: false,
+                    toolsUsedInLastResponse: 1,
+                    lastToolWasReadOnly: false,
+                    consecutiveResponsesWithoutTools: 0,
+                    hasRecentFileWrites: false,
+                    hasRecentCommits: false,
+                    todoItemsPending: 0,
+                    todoItemsCompleted: 1,
+                    mentionsFutureWork: false,
+                    completionConfidence: 1,
+                },
+                reason: 'Infrastructure deployment',
+                shouldVerify: false,
+            },
+            exitReason: 'complete',
+            statusSummary: 'Infrastructure deployed',
+            limitations: [],
+            recommendations: ['Review OPSEC checklist', 'Test all components'],
+        }, this.agent.getHistory(), { customTitle: `Infrastructure: ${stack.name}` });
+        let deliverablePaths;
+        if (options.outputDir && options.exportFormats) {
+            deliverablePaths = await this.exportDeliverable(deliverable, options.outputDir, options.exportFormats);
+        }
+        return {
+            mode: 'infrastructure',
+            success: true,
+            finalResponse: `Infrastructure stack ready: ${stack.name}\n\nComponents: ${stack.components.length}\nPersistence mechanisms: ${stack.persistence.length}\nCost estimate: $${stack.costEstimate.monthly}/month`,
+            toolsUsed: ['infrastructure-deploy', 'script-generator'],
+            infrastructureStack: stack,
+            deploymentScript: deployScript,
+            teardownScript: teardownScript,
+            opsecChecklist: opsecList,
+            deliverable,
+            deliverablePaths,
+            persistenceMechanisms: stack.persistence,
+            summary: `${region.toUpperCase()} infrastructure: ${stack.components.length} components, ${stack.persistence.length} persistence mechanisms`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run incident response procedure generation
+     */
+    async runIncidentResponse(request, options, startTime) {
+        const deliverable = await this.deliverableGenerator.generate('incident-response', {
+            finalResponse: request,
+            toolsUsed: [],
+            planOnly: false,
+            tookAction: false,
+            completion: {
+                isComplete: true,
+                confidence: 1,
+                signals: {
+                    hasExplicitCompletionStatement: true,
+                    hasIncompleteWorkIndicators: false,
+                    hasPendingActionIndicators: false,
+                    hasErrorIndicators: false,
+                    hasFollowUpQuestions: false,
+                    toolsUsedInLastResponse: 0,
+                    lastToolWasReadOnly: false,
+                    consecutiveResponsesWithoutTools: 0,
+                    hasRecentFileWrites: false,
+                    hasRecentCommits: false,
+                    todoItemsPending: 0,
+                    todoItemsCompleted: 0,
+                    mentionsFutureWork: false,
+                    completionConfidence: 1,
+                },
+                reason: 'Incident response generation',
+                shouldVerify: false,
+            },
+            exitReason: 'complete',
+            statusSummary: 'Incident response procedures generated',
+            limitations: [],
+            recommendations: [],
+        }, this.agent.getHistory(), { customTitle: `Incident Response: ${request}` });
+        let deliverablePaths;
+        if (options.outputDir && options.exportFormats) {
+            deliverablePaths = await this.exportDeliverable(deliverable, options.outputDir, options.exportFormats);
+        }
+        return {
+            mode: 'incident-response',
+            success: true,
+            finalResponse: `Generated incident response procedures with ${deliverable.procedures?.length || 0} procedures`,
+            toolsUsed: [],
+            deliverable,
+            deliverablePaths,
+            summary: `IR procedures: ${deliverable.procedures?.length || 0} procedures generated`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run security training module generation
+     */
+    async runTraining(request, options, startTime) {
+        const deliverable = await this.deliverableGenerator.generate('training-module', {
+            finalResponse: request,
+            toolsUsed: [],
+            planOnly: false,
+            tookAction: false,
+            completion: {
+                isComplete: true,
+                confidence: 1,
+                signals: {
+                    hasExplicitCompletionStatement: true,
+                    hasIncompleteWorkIndicators: false,
+                    hasPendingActionIndicators: false,
+                    hasErrorIndicators: false,
+                    hasFollowUpQuestions: false,
+                    toolsUsedInLastResponse: 0,
+                    lastToolWasReadOnly: false,
+                    consecutiveResponsesWithoutTools: 0,
+                    hasRecentFileWrites: false,
+                    hasRecentCommits: false,
+                    todoItemsPending: 0,
+                    todoItemsCompleted: 0,
+                    mentionsFutureWork: false,
+                    completionConfidence: 1,
+                },
+                reason: 'Training module generation',
+                shouldVerify: false,
+            },
+            exitReason: 'complete',
+            statusSummary: 'Training modules generated',
+            limitations: [],
+            recommendations: [],
+        }, this.agent.getHistory(), { customTitle: `Security Training: ${request}` });
+        let deliverablePaths;
+        if (options.outputDir && options.exportFormats) {
+            deliverablePaths = await this.exportDeliverable(deliverable, options.outputDir, options.exportFormats);
+        }
+        return {
+            mode: 'training',
+            success: true,
+            finalResponse: `Generated ${deliverable.training?.length || 0} training modules`,
+            toolsUsed: [],
+            deliverable,
+            deliverablePaths,
+            summary: `Training: ${deliverable.training?.length || 0} modules generated`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run compliance audit mode
+     */
+    async runCompliance(request, options, startTime) {
+        const agencyTypes = options.agencyTypes || ['federal-le', 'regulatory'];
+        const frameworks = getApplicableLegalFrameworks(agencyTypes);
+        const deliverable = await this.deliverableGenerator.generate('compliance-audit', {
+            finalResponse: `Compliance audit: ${frameworks.map(f => f.name).join(', ')}`,
+            toolsUsed: [],
+            planOnly: false,
+            tookAction: false,
+            completion: {
+                isComplete: true,
+                confidence: 1,
+                signals: {
+                    hasExplicitCompletionStatement: true,
+                    hasIncompleteWorkIndicators: false,
+                    hasPendingActionIndicators: false,
+                    hasErrorIndicators: false,
+                    hasFollowUpQuestions: false,
+                    toolsUsedInLastResponse: 0,
+                    lastToolWasReadOnly: false,
+                    consecutiveResponsesWithoutTools: 0,
+                    hasRecentFileWrites: false,
+                    hasRecentCommits: false,
+                    todoItemsPending: 0,
+                    todoItemsCompleted: 0,
+                    mentionsFutureWork: false,
+                    completionConfidence: 1,
+                },
+                reason: 'Compliance audit',
+                shouldVerify: false,
+            },
+            exitReason: 'complete',
+            statusSummary: 'Compliance audit completed',
+            limitations: [],
+            recommendations: frameworks.flatMap(f => f.requirements.map(r => r.requirement)),
+        }, this.agent.getHistory(), { customTitle: `Compliance Audit: ${request}` });
+        let deliverablePaths;
+        if (options.outputDir && options.exportFormats) {
+            deliverablePaths = await this.exportDeliverable(deliverable, options.outputDir, options.exportFormats);
+        }
+        return {
+            mode: 'compliance',
+            success: true,
+            finalResponse: `Compliance audit completed against ${frameworks.length} frameworks`,
+            toolsUsed: [],
+            deliverable,
+            deliverablePaths,
+            summary: `Compliance: ${frameworks.length} frameworks, ${deliverable.controls?.length || 0} controls assessed`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run full red team playbook mode
+     * Combines APT chain with infrastructure and deliverables
+     */
+    async runRedTeam(request, options, startTime) {
+        const region = options.region || 'us';
+        const stack = getInfrastructureStack(region);
+        // Execute red team operations
+        const autoConfig = {
+            maxExecutionTime: options.maxExecutionTime ?? 90 * 60 * 1000, // 90 minutes
+            maxCycles: options.maxCycles ?? 25,
+            depth: options.depth ?? 'deep',
+            stealthMode: options.stealthMode ?? true,
+            generateDeliverable: true,
+            deliverableType: 'red-team-playbook',
+            outputDir: options.outputDir ?? `${this.workingDir}/deliverables`,
+            exportFormats: ['markdown', 'json', 'html'],
+            onProgress: options.onProgress,
+            onDeliverable: options.onDeliverable,
+        };
+        const result = await this.autoOrchestrator.execute(`RED TEAM OPERATION: ${request}\n\n` +
+            `Infrastructure: ${stack?.name || 'standard'}\n` +
+            `Execute full red team playbook:\n` +
+            `1. Infrastructure deployment and verification\n` +
+            `2. Reconnaissance (OSINT, active scanning)\n` +
+            `3. Initial access (phishing, exploitation)\n` +
+            `4. Privilege escalation\n` +
+            `5. Persistence establishment\n` +
+            `6. Lateral movement\n` +
+            `7. Data discovery and exfiltration\n` +
+            `8. Cleanup and reporting\n\n` +
+            `Targets: ${options.targets?.join(', ') || 'as specified'}\n` +
+            `Stealth priority: ${options.stealthMode ? 'HIGH' : 'STANDARD'}`, autoConfig);
+        return {
+            mode: 'red-team',
+            success: result.success,
+            finalResponse: result.summary,
+            toolsUsed: result.metrics.toolsUsed,
+            autoResult: result,
+            deliverable: result.deliverable,
+            deliverablePaths: result.deliverablePaths,
+            infrastructureStack: stack,
+            deploymentScript: stack ? generateDeploymentScript(stack) : undefined,
+            teardownScript: stack ? generateTeardownScript(stack) : undefined,
+            opsecChecklist: stack ? generateOpsecChecklist(stack) : undefined,
+            attackChainPhases: ['recon', 'initial-access', 'privesc', 'persistence', 'lateral', 'exfil', 'cleanup'],
+            persistenceMechanisms: stack?.persistence,
+            summary: `Red team: ${result.metrics.techniquesSucceeded}/${result.metrics.techniquesExecuted} techniques, ${result.metrics.chainsCompleted} chains`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run A2AD (Anti-Access/Area Denial) mode - REAL EXECUTION
+     * Full offensive APT against defense systems, contractors, any stack
+     * Uses direct TAO technique execution - actual DNS, ports, HTTP, commands
+     */
+    async runA2AD(request, options, startTime) {
+        const targets = options.targets || [];
+        const depth = this.normalizeDepth(options.depth ?? 'deep');
+        const stealth = options.stealthMode ?? true;
+        const realExecutions = [];
+        const attackChains = [];
+        // A2AD phases - full kill-chain with cloud/SaaS techniques for maximum coverage
+        const a2adPhases = [
+            {
+                phase: 'reconnaissance',
+                techniques: [
+                    // DNS & Network
+                    'dns_enum', 'whois_recon', 'asn_lookup', 'dns_zone_transfer', 'subdomain_enum',
+                    // SSL/TLS & Certificates
+                    'ssl_analysis', 'ct_search',
+                    // Web & Technology
+                    'web_fingerprint', 'tech_fingerprint', 'email_security',
+                    // Cloud Provider Detection
+                    'cloud_detect', 's3_enum', 'gcs_enum', 'azure_enum',
+                ],
+            },
+            {
+                phase: 'weaponization',
+                techniques: [
+                    // Port & Service Scanning
+                    'port_scan', 'full_port_scan', 'service_enum',
+                    // Protocol Enumeration
+                    'ssh_enum', 'smb_enum',
+                    // Web Enumeration
+                    'dir_enum', 'api_discovery', 'vuln_scan',
+                ],
+            },
+            {
+                phase: 'delivery',
+                techniques: ['credential_spray'],
+            },
+            {
+                phase: 'exploitation',
+                techniques: ['exploit_attempt', 'cloud_metadata'],
+            },
+            {
+                phase: 'installation',
+                techniques: ['privesc', 'process_enum', 'persistence', 'sched_persist', 'ssh_persist'],
+            },
+            {
+                phase: 'command-control',
+                techniques: ['c2_beacon', 'network_discovery', 'lateral_move'],
+            },
+            {
+                phase: 'actions-on-objectives',
+                techniques: ['file_discovery', 'credential_harvest', 'memory_dump', 'exfil', 'cleanup'],
+            },
+        ];
+        // REAL EXECUTION - Direct technique calls
+        for (const target of targets) {
+            const intent = parseNaturalLanguageIntent(`A2AD against ${target}: ${request}`);
+            const chain = planAttackChain(intent, `A2AD_${target}`);
+            attackChains.push(chain);
+            for (const { phase, techniques } of a2adPhases) {
+                const limit = depth === 'quick' ? 2 : depth === 'standard' ? 4 : techniques.length;
+                for (const techniqueId of techniques.slice(0, limit)) {
+                    const technique = techniqueRegistry.get(techniqueId);
+                    if (!technique)
+                        continue;
+                    if (stealth && technique.stealthRating < 0.3)
+                        continue;
+                    options.onTechniqueStart?.(techniqueId, target);
+                    try {
+                        // REAL execution - actual network ops, DNS, TCP, HTTP, commands
+                        const result = await technique.execute({
+                            target,
+                            depth,
+                            stealth,
+                            timeout: 60000,
+                            context: {},
+                        });
+                        const execResult = {
+                            techniqueId: technique.id,
+                            techniqueName: technique.name,
+                            phase,
+                            success: result.success,
+                            duration: result.duration,
+                            artifacts: result.artifacts,
+                            detectionRisk: result.detectionRisk,
+                            nextTechniques: result.nextTechniques,
+                        };
+                        realExecutions.push(execResult);
+                        options.onTechniqueComplete?.(execResult);
+                        if (stealth && result.detectionRisk > 0.7)
+                            break;
+                    }
+                    catch {
+                        realExecutions.push({
+                            techniqueId: technique.id,
+                            techniqueName: technique.name,
+                            phase,
+                            success: false,
+                            duration: 0,
+                            artifacts: [],
+                            detectionRisk: 0.5,
+                            nextTechniques: [],
+                        });
+                    }
+                }
+            }
+        }
+        // Metrics
+        const successCount = realExecutions.filter(r => r.success).length;
+        const realMetrics = {
+            totalTechniquesExecuted: realExecutions.length,
+            successfulTechniques: successCount,
+            failedTechniques: realExecutions.length - successCount,
+            totalDuration: Date.now() - startTime,
+            averageDetectionRisk: realExecutions.length > 0
+                ? realExecutions.reduce((s, r) => s + r.detectionRisk, 0) / realExecutions.length : 0,
+            phasesCompleted: [...new Set(realExecutions.filter(r => r.success).map(r => r.phase))],
+            artifactsCollected: realExecutions.reduce((s, r) => s + r.artifacts.length, 0),
+            rlRewardAverage: getRLState().avgReward,
+        };
+        // Generate deliverable
+        let deliverable;
+        let deliverablePaths;
+        if (options.generateDeliverable !== false) {
+            deliverable = await this.deliverableGenerator.generate('apt-analysis', {
+                finalResponse: `A2/AD: ${successCount}/${realExecutions.length} techniques`,
+                toolsUsed: realExecutions.map(r => r.techniqueId),
+                planOnly: false,
+                tookAction: true,
+                completion: {
+                    isComplete: true,
+                    confidence: successCount / Math.max(realExecutions.length, 1),
+                    signals: {
+                        hasExplicitCompletionStatement: true,
+                        hasIncompleteWorkIndicators: false,
+                        hasPendingActionIndicators: false,
+                        hasErrorIndicators: false,
+                        hasFollowUpQuestions: false,
+                        toolsUsedInLastResponse: realExecutions.length,
+                        lastToolWasReadOnly: false,
+                        consecutiveResponsesWithoutTools: 0,
+                        hasRecentFileWrites: false,
+                        hasRecentCommits: false,
+                        todoItemsPending: 0,
+                        todoItemsCompleted: realExecutions.length,
+                        mentionsFutureWork: false,
+                        completionConfidence: successCount / Math.max(realExecutions.length, 1),
+                    },
+                    reason: 'A2/AD complete',
+                    shouldVerify: false,
+                },
+                exitReason: 'complete',
+                statusSummary: 'A2/AD operation completed',
+                limitations: [],
+                recommendations: realExecutions.flatMap(r => r.nextTechniques),
+            }, this.agent.getHistory(), { customTitle: `A2/AD: ${request}`, targets });
+            if (options.outputDir && options.exportFormats) {
+                deliverablePaths = await this.exportDeliverable(deliverable, options.outputDir, options.exportFormats);
+            }
+        }
+        const region = options.region || 'us';
+        const stack = getInfrastructureStack(region);
+        return {
+            mode: 'a2ad',
+            success: successCount > 0,
+            finalResponse: `A2/AD REAL EXECUTION: ${successCount}/${realExecutions.length} techniques against ${targets.length} targets`,
+            toolsUsed: realExecutions.map(r => r.techniqueId),
+            infrastructureStack: stack,
+            deploymentScript: stack ? generateDeploymentScript(stack) : undefined,
+            teardownScript: stack ? generateTeardownScript(stack) : undefined,
+            opsecChecklist: stack ? generateOpsecChecklist(stack) : undefined,
+            attackChainPhases: a2adPhases.map(p => p.phase),
+            persistenceMechanisms: stack?.persistence,
+            realExecutions,
+            realMetrics,
+            attackChains,
+            deliverable,
+            deliverablePaths,
+            summary: `A2/AD: ${successCount}/${realExecutions.length} real techniques, ${realMetrics.artifactsCollected} artifacts`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run Direct APT mode - real execution without AI orchestration overhead
+     * Pure TAO technique execution with RL guidance
+     */
+    async runDirectAPT(request, options, startTime) {
+        const intent = parseNaturalLanguageIntent(request);
+        const targets = options.targets ?? intent.targets;
+        const stealth = options.stealthMode ?? intent.constraints.includes('stealth');
+        const depth = this.normalizeDepth(options.depth ?? intent.depth);
+        const realExecutions = [];
+        const completedPhases = [];
+        // Execute REAL techniques directly without AI orchestration
+        for (const target of targets) {
+            const chain = planAttackChain(intent, `Direct APT: ${target}`);
+            options.onChainProgress?.(chain, 0);
+            while (chain.state === 'planning' || chain.state === 'executing') {
+                const action = selectNextTechnique(chain);
+                if (!action)
+                    break;
+                const technique = techniqueRegistry.get(action.id);
+                if (!technique)
+                    continue;
+                options.onTechniqueStart?.(action.id, target);
+                const params = {
+                    target,
+                    depth,
+                    stealth,
+                    timeout: depth === 'quick' ? 5000 : depth === 'deep' ? 30000 : 15000,
+                    context: {},
+                };
+                const { result } = await executeTechniqueInChain(chain, action, params);
+                const execResult = {
+                    techniqueId: action.id,
+                    techniqueName: technique.name,
+                    phase: technique.phase,
+                    success: result.success,
+                    duration: result.duration,
+                    artifacts: result.artifacts,
+                    detectionRisk: result.detectionRisk,
+                    nextTechniques: result.nextTechniques,
+                };
+                realExecutions.push(execResult);
+                options.onTechniqueComplete?.(execResult);
+                if (result.success && !completedPhases.includes(technique.phase)) {
+                    completedPhases.push(technique.phase);
+                }
+                options.onChainProgress?.(chain, chain.currentPhase);
+                if (stealth) {
+                    await new Promise(r => setTimeout(r, 300 + Math.random() * 700));
+                }
+            }
+        }
+        const rlState = getRLState();
+        const realMetrics = {
+            totalTechniquesExecuted: realExecutions.length,
+            successfulTechniques: realExecutions.filter(e => e.success).length,
+            failedTechniques: realExecutions.filter(e => !e.success).length,
+            totalDuration: realExecutions.reduce((sum, e) => sum + e.duration, 0),
+            averageDetectionRisk: realExecutions.length > 0
+                ? realExecutions.reduce((sum, e) => sum + e.detectionRisk, 0) / realExecutions.length
+                : 0,
+            phasesCompleted: completedPhases,
+            artifactsCollected: realExecutions.reduce((sum, e) => sum + e.artifacts.length, 0),
+            rlRewardAverage: rlState.avgReward,
+        };
+        const activeChains = listActiveChains();
+        return {
+            mode: 'direct-apt',
+            success: realMetrics.successfulTechniques > 0,
+            finalResponse: this.buildRealExecutionSummary(realExecutions, realMetrics),
+            toolsUsed: realExecutions.map(e => `tao:${e.techniqueId}`),
+            realExecutions,
+            realMetrics,
+            attackChains: activeChains,
+            attackChainPhases: completedPhases.map(p => p),
+            summary: `Direct APT: ${realMetrics.successfulTechniques}/${realMetrics.totalTechniquesExecuted} techniques, ${realMetrics.artifactsCollected} artifacts`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Normalize depth value to valid type
+     */
+    normalizeDepth(depth) {
+        if (depth === 'quick' || depth === 'standard' || depth === 'deep') {
+            return depth;
+        }
+        return 'standard';
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // GOAL-ORIENTED APT EXECUTION
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /** Technique mappings for each APT goal */
+    goalTechniques = {
+        reconnaissance: [
+            // DNS & Network Intelligence
+            'dns_enum', 'whois_recon', 'asn_lookup', 'subdomain_enum', 'dns_zone_transfer',
+            'domain_intel', 'network_mapping', 'port_scan', 'service_enum',
+            // Cryptographic Mapping & SSL/TLS Analysis
+            'crypto_map', 'ssl_analysis', 'ct_search',
+            // Stack & Technology Fingerprinting
+            'stack_fingerprint', 'tech_fingerprint', 'web_fingerprint',
+            // Cloud Provider Enumeration
+            'cloud_detect', 's3_enum', 'gcs_enum', 'azure_enum', 'cloud_metadata',
+            // Corporate Infrastructure Discovery
+            'corp_enum', 'business_sw_enum', 'saas_enum', 'email_security',
+            // Product & API Surface Mapping
+            'product_enum', 'api_surface_map', 'api_discovery', 'git_analysis',
+        ],
+        access: [
+            'credential_spray', 'exploit_attempt', 'cloud_metadata', 'container_escape',
+        ],
+        persistence: [
+            'persistence', 'sched_persist', 'ssh_persist', 'c2_beacon',
+        ],
+        privilege: [
+            'privesc', 'credential_harvest', 'memory_dump', 'cloud_creds',
+        ],
+        lateral: [
+            'lateral_move', 'network_discovery', 'smb_enum', 'ssh_enum',
+        ],
+        collection: [
+            // Discovery & Enumeration
+            'file_discovery', 'data_discovery', 'process_enum', 'cloud_enum',
+            // Credential & Code Collection
+            'credential_harvest', 'git_analysis', 'supply_chain_enum',
+            // Enterprise Stack Collection
+            'stack_fingerprint', 'product_enum', 'business_sw_enum', 'saas_enum',
+            'corp_enum', 'domain_intel', 'api_surface_map',
+        ],
+        exfiltration: [
+            'data_staging', 'exfil', 'c2_beacon',
+        ],
+        impact: [
+            'service_disruption', 'resource_exhaustion', 'cleanup',
+        ],
+        stealth: [
+            'cleanup', 'process_enum', 'network_discovery',
+        ],
+        all: [], // Populated dynamically with all techniques
+    };
+    /**
+     * Run goal-oriented APT execution
+     * Selects techniques based on specified goals for maximum effectiveness
+     */
+    async runGoalOriented(request, options, startTime) {
+        const targets = options.targets || [];
+        const goals = options.goals || (options.goal ? [options.goal] : ['all']);
+        const depth = this.normalizeDepth(options.depth ?? 'deep');
+        const stealth = options.stealthMode ?? options.minimizeFootprint ?? false;
+        const realExecutions = [];
+        const achievedGoals = [];
+        const allArtifacts = [];
+        // Build technique list based on goals
+        let techniques = [];
+        for (const goal of goals) {
+            if (goal === 'all') {
+                // Get all registered techniques
+                techniques = techniqueRegistry.list().map(t => t.id);
+                break;
+            }
+            techniques.push(...(this.goalTechniques[goal] || []));
+        }
+        techniques = [...new Set(techniques)]; // Deduplicate
+        // Execute techniques for each target
+        for (const target of targets) {
+            const intent = parseNaturalLanguageIntent(`Goal-oriented APT: ${goals.join(', ')} against ${target}`);
+            const chain = planAttackChain(intent, `Goal_${goals.join('_')}_${target}`);
+            for (const techniqueId of techniques) {
+                const technique = techniqueRegistry.get(techniqueId);
+                if (!technique)
+                    continue;
+                if (stealth && technique.stealthRating < 0.3)
+                    continue;
+                options.onTechniqueStart?.(techniqueId, target);
+                try {
+                    const result = await technique.execute({
+                        target,
+                        depth,
+                        stealth,
+                        timeout: 60000,
+                        context: {},
+                    });
+                    const execResult = {
+                        techniqueId: technique.id,
+                        techniqueName: technique.name,
+                        phase: technique.phase,
+                        success: result.success,
+                        duration: result.duration,
+                        artifacts: result.artifacts,
+                        detectionRisk: result.detectionRisk,
+                        nextTechniques: result.nextTechniques,
+                    };
+                    realExecutions.push(execResult);
+                    allArtifacts.push(...result.artifacts);
+                    options.onTechniqueComplete?.(execResult);
+                    // Check if any goals were achieved
+                    for (const goal of goals) {
+                        if (!achievedGoals.includes(goal)) {
+                            const goalTechs = this.goalTechniques[goal] || [];
+                            if (goalTechs.includes(techniqueId) && result.success) {
+                                achievedGoals.push(goal);
+                                options.onGoalAchieved?.(goal, result.artifacts);
+                            }
+                        }
+                    }
+                    if (stealth && result.detectionRisk > 0.7)
+                        break;
+                }
+                catch {
+                    realExecutions.push({
+                        techniqueId: technique.id,
+                        techniqueName: technique.name,
+                        phase: technique.phase,
+                        success: false,
+                        duration: 0,
+                        artifacts: [],
+                        detectionRisk: 0.5,
+                        nextTechniques: [],
+                    });
+                }
+            }
+            // Maintain access if requested
+            if (options.maintainAccess) {
+                for (const persistTech of ['persistence', 'sched_persist', 'ssh_persist']) {
+                    const technique = techniqueRegistry.get(persistTech);
+                    if (technique) {
+                        try {
+                            await technique.execute({ target, depth, stealth, timeout: 30000, context: {} });
+                        }
+                        catch { /* ignore */ }
+                    }
+                }
+            }
+        }
+        const successCount = realExecutions.filter(r => r.success).length;
+        const realMetrics = {
+            totalTechniquesExecuted: realExecutions.length,
+            successfulTechniques: successCount,
+            failedTechniques: realExecutions.length - successCount,
+            totalDuration: Date.now() - startTime,
+            averageDetectionRisk: realExecutions.length > 0
+                ? realExecutions.reduce((s, r) => s + r.detectionRisk, 0) / realExecutions.length : 0,
+            phasesCompleted: [...new Set(realExecutions.filter(r => r.success).map(r => r.phase))],
+            artifactsCollected: allArtifacts.length,
+            rlRewardAverage: getRLState().avgReward,
+        };
+        return {
+            mode: options.mode || 'direct-apt',
+            success: successCount > 0,
+            finalResponse: `Goal-oriented APT: ${achievedGoals.length}/${goals.length} goals achieved, ${successCount}/${realExecutions.length} techniques`,
+            toolsUsed: realExecutions.map(r => r.techniqueId),
+            realExecutions,
+            realMetrics,
+            attackChains: listActiveChains(),
+            attackChainPhases: [...new Set(realExecutions.map(r => r.phase))],
+            summary: `Goals: ${achievedGoals.join(', ')} | ${allArtifacts.length} artifacts collected`,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run persistent access mode - establish and maintain long-term presence
+     */
+    async runPersistentAccess(request, options, startTime) {
+        return this.runGoalOriented(request, {
+            ...options,
+            goals: ['access', 'persistence', 'stealth'],
+            maintainAccess: true,
+            minimizeFootprint: true,
+        }, startTime);
+    }
+    /**
+     * Run intelligence collection mode - gather all available data
+     */
+    async runIntelCollection(request, options, startTime) {
+        return this.runGoalOriented(request, {
+            ...options,
+            goals: ['reconnaissance', 'collection', 'exfiltration'],
+            collectIntel: true,
+        }, startTime);
+    }
+    /**
+     * Run impact mode - disrupt/destroy/manipulate target infrastructure
+     */
+    async runImpact(request, options, startTime) {
+        return this.runGoalOriented(request, {
+            ...options,
+            goals: ['access', 'privilege', 'impact'],
+            stealthMode: false, // Impact operations are inherently noisy
+        }, startTime);
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // REAL TECHNIQUE EXECUTION - Direct access to TAO execution
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Execute a specific technique against a target with real network operations
+     * Can be called directly for granular control
+     */
+    async executeRealTechnique(techniqueId, target, options = {}) {
+        const technique = techniqueRegistry.get(techniqueId);
+        if (!technique) {
+            throw new Error(`Unknown technique: ${techniqueId}`);
+        }
+        // Notify start
+        options.onStart?.(techniqueId, target);
+        const params = {
+            target,
+            depth: options.depth ?? 'standard',
+            stealth: options.stealth ?? false,
+            timeout: options.timeout ?? 15000,
+            context: options.context ?? {},
+        };
+        // Create a simple chain for single technique execution
+        const intent = parseNaturalLanguageIntent(`execute ${techniqueId} against ${target}`);
+        const chain = planAttackChain(intent, `Direct ${techniqueId} execution`);
+        const action = { id: techniqueId, params: {}, confidence: 1.0 };
+        const { result } = await executeTechniqueInChain(chain, action, params);
+        const execResult = {
+            techniqueId,
+            techniqueName: technique.name,
+            phase: technique.phase,
+            success: result.success,
+            duration: result.duration,
+            artifacts: result.artifacts,
+            detectionRisk: result.detectionRisk,
+            nextTechniques: result.nextTechniques,
+        };
+        // Notify completion
+        options.onComplete?.(execResult);
+        return execResult;
+    }
+    /**
+     * Execute reconnaissance techniques against a target
+     * Returns structured intel from real DNS/TCP/HTTP operations
+     */
+    async executeRecon(target, options = {}) {
+        const depth = options.depth ?? 'standard';
+        const reconTechniques = options.techniques ?? [
+            'dns_enum',
+            'subdomain_enum',
+            'port_scan',
+            'service_enum',
+            'web_fingerprint',
+        ];
+        // Filter to quick techniques if depth is quick
+        const techniques = depth === 'quick'
+            ? reconTechniques.slice(0, 3)
+            : reconTechniques;
+        const results = [];
+        const completedPhases = [];
+        for (let i = 0; i < techniques.length; i++) {
+            const techId = techniques[i];
+            if (!techId)
+                continue;
+            options.onProgress?.(techId, i, techniques.length);
+            try {
+                const result = await this.executeRealTechnique(techId, target, {
+                    depth,
+                    stealth: false,
+                    timeout: depth === 'deep' ? 30000 : 15000,
+                });
+                results.push(result);
+                if (result.success && !completedPhases.includes(result.phase)) {
+                    completedPhases.push(result.phase);
+                }
+            }
+            catch {
+                // Continue with other techniques on failure
+            }
+        }
+        const rlState = getRLState();
+        const metrics = {
+            totalTechniquesExecuted: results.length,
+            successfulTechniques: results.filter(r => r.success).length,
+            failedTechniques: results.filter(r => !r.success).length,
+            totalDuration: results.reduce((sum, r) => sum + r.duration, 0),
+            averageDetectionRisk: results.length > 0
+                ? results.reduce((sum, r) => sum + r.detectionRisk, 0) / results.length
+                : 0,
+            phasesCompleted: completedPhases,
+            artifactsCollected: results.reduce((sum, r) => sum + r.artifacts.length, 0),
+            rlRewardAverage: rlState.avgReward,
+        };
+        options.onProgress?.('complete', techniques.length, techniques.length);
+        return {
+            target,
+            results,
+            metrics,
+            summary: this.buildRealExecutionSummary(results, metrics),
+        };
+    }
+    /**
+     * Get available techniques for a category or phase
+     */
+    getAvailableTechniques(filter) {
+        let techniques = techniqueRegistry.list();
+        if (filter?.phase) {
+            techniques = techniqueRegistry.getByPhase(filter.phase);
+        }
+        return techniques.map(t => ({
+            id: t.id,
+            name: t.name,
+            category: t.category,
+            phase: t.phase,
+            stealthRating: t.stealthRating,
+        }));
+    }
+    /**
+     * Get current RL state and statistics
+     */
+    getRLStats() {
+        const rlState = getRLState();
+        const chainStats = getChainStats();
+        const techniques = techniqueRegistry.list().map(t => ({
+            id: t.id,
+            successRate: techniqueRegistry.getSuccessRate(t.id),
+        }));
+        return {
+            episode: rlState.episode,
+            steps: rlState.steps,
+            avgReward: rlState.avgReward,
+            chainStats,
+            techniques,
+        };
+    }
+    /**
+     * Export deliverable to files
+     */
+    async exportDeliverable(deliverable, outputDir, formats) {
+        const fs = await import('node:fs/promises');
+        const path = await import('node:path');
+        await fs.mkdir(outputDir, { recursive: true });
+        const baseName = `${deliverable.type}-${new Date().toISOString().slice(0, 10)}`;
+        const paths = {};
+        for (const format of formats) {
+            let content;
+            let extension;
+            switch (format) {
+                case 'markdown':
+                    content = exportToMarkdown(deliverable);
+                    extension = 'md';
+                    break;
+                case 'json':
+                    content = exportToJSON(deliverable);
+                    extension = 'json';
+                    break;
+                case 'html':
+                    content = exportToHTML(deliverable);
+                    extension = 'html';
+                    break;
+                default:
+                    continue;
+            }
+            const filePath = path.join(outputDir, `${baseName}.${extension}`);
+            await fs.writeFile(filePath, content, 'utf-8');
+            paths[format] = filePath;
+        }
+        return paths;
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// FACTORY FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Create an orchestrator for the specified mode
+ */
+export function createOrchestrator(agent, mode = 'single', workingDir = process.cwd()) {
+    return new UnifiedOrchestrator(agent, workingDir);
+}
+/**
+ * Quick function to run a task with the appropriate orchestrator
+ */
+export async function runTask(agent, request, options = {}) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(request, options);
+}
+/**
+ * Run security assessment with deliverables
+ */
+export async function runSecurityAssessment(agent, objective, options = {}) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(objective, {
+        mode: 'auto-security',
+        deliverableType: options.deliverableType || 'pentest-report',
+        depth: options.depth || 'standard',
+        stealthMode: options.stealth || false,
+        outputDir: options.outputDir || './deliverables',
+        exportFormats: ['markdown', 'json', 'html'],
+        generateDeliverable: true,
+    });
+}
+/**
+ * Generate deliverable from current conversation
+ */
+export async function generateDeliverable(agent, type, options = {}) {
+    const generator = new SecurityDeliverableGenerator();
+    const minimalResult = {
+        finalResponse: '',
+        toolsUsed: [],
+        planOnly: false,
+        tookAction: false,
+        completion: {
+            isComplete: true,
+            confidence: 1,
+            signals: {
+                hasExplicitCompletionStatement: true,
+                hasIncompleteWorkIndicators: false,
+                hasPendingActionIndicators: false,
+                hasErrorIndicators: false,
+                hasFollowUpQuestions: false,
+                toolsUsedInLastResponse: 0,
+                lastToolWasReadOnly: false,
+                consecutiveResponsesWithoutTools: 0,
+                hasRecentFileWrites: false,
+                hasRecentCommits: false,
+                todoItemsPending: 0,
+                todoItemsCompleted: 0,
+                mentionsFutureWork: false,
+                completionConfidence: 1,
+            },
+            reason: 'Deliverable generation',
+            shouldVerify: false,
+        },
+        exitReason: 'complete',
+        statusSummary: null,
+        limitations: [],
+        recommendations: [],
+    };
+    return generator.generate(type, minimalResult, agent.getHistory(), options);
+}
+/**
+ * Run APT simulation with full kill-chain
+ */
+export async function runAPTSimulation(agent, objective, options = {}) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(objective, {
+        mode: 'apt-chain',
+        targets: options.targets,
+        constraints: options.constraints,
+        region: options.region || 'us',
+        depth: options.depth || 'deep',
+        stealthMode: options.stealth ?? true,
+        outputDir: options.outputDir || './deliverables',
+        exportFormats: ['markdown', 'json', 'html'],
+        generateDeliverable: true,
+    });
+}
+/**
+ * Run red team operation with full playbook
+ */
+export async function runRedTeamOperation(agent, objective, options = {}) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(objective, {
+        mode: 'red-team',
+        targets: options.targets,
+        region: options.region || 'us',
+        stealthMode: options.stealth ?? true,
+        outputDir: options.outputDir || './deliverables',
+        exportFormats: ['markdown', 'json', 'html'],
+        generateDeliverable: true,
+    });
+}
+/**
+ * Deploy operational infrastructure
+ */
+export async function deployInfrastructure(agent, region, options = {}) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(`Deploy ${region} infrastructure`, {
+        mode: 'infrastructure',
+        region,
+        outputDir: options.outputDir || './deliverables',
+        exportFormats: ['markdown', 'json'],
+        generateDeliverable: true,
+    });
+}
+/**
+ * Generate incident response procedures
+ */
+export async function generateIncidentResponse(agent, scenario, options = {}) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(scenario, {
+        mode: 'incident-response',
+        outputDir: options.outputDir || './deliverables',
+        exportFormats: ['markdown', 'json', 'html'],
+        generateDeliverable: true,
+    });
+}
+/**
+ * Generate security training module
+ */
+export async function generateTrainingModule(agent, topic, options = {}) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(topic, {
+        mode: 'training',
+        outputDir: options.outputDir || './deliverables',
+        exportFormats: ['markdown', 'json', 'html'],
+        generateDeliverable: true,
+    });
+}
+/**
+ * Run compliance audit
+ */
+export async function runComplianceAudit(agent, scope, options = {}) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(scope, {
+        mode: 'compliance',
+        agencyTypes: options.agencyTypes || ['federal-le', 'regulatory'],
+        outputDir: options.outputDir || './deliverables',
+        exportFormats: ['markdown', 'json', 'html'],
+        generateDeliverable: true,
+    });
+}
+/**
+ * Run A2/AD operation with REAL technique execution
+ * Full offensive APT against defense systems, contractors, any stack (Google, AWS, etc)
+ */
+export async function runA2AD(agent, objective, options) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(objective, {
+        mode: 'a2ad',
+        targets: options.targets,
+        region: options.region || 'us',
+        depth: options.depth || 'deep',
+        stealthMode: options.stealth ?? true,
+        outputDir: options.outputDir || './deliverables',
+        exportFormats: ['markdown', 'json', 'html'],
+        generateDeliverable: true,
+        onTechniqueStart: options.onTechniqueStart,
+        onTechniqueComplete: options.onTechniqueComplete,
+    });
+}
+/**
+ * Run Direct APT with NO agent overhead - pure real technique execution
+ * Maximum speed, direct TAO chains, actual network operations
+ */
+export async function runDirectAPT(agent, objective, options) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(objective, {
+        mode: 'direct-apt',
+        targets: options.targets,
+        depth: options.depth || 'deep',
+        stealthMode: options.stealth ?? false,
+        onTechniqueStart: options.onTechniqueStart,
+        onTechniqueComplete: options.onTechniqueComplete,
+    });
+}
+/**
+ * Run goal-oriented APT - specify what you want to achieve
+ * Automatically selects appropriate techniques
+ */
+export async function runGoalAPT(agent, objective, options) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(objective, {
+        targets: options.targets,
+        goal: options.goal,
+        goals: options.goals,
+        depth: options.depth || 'deep',
+        stealthMode: options.stealth ?? false,
+        maintainAccess: options.maintainAccess ?? false,
+        onTechniqueComplete: options.onTechniqueComplete,
+        onGoalAchieved: options.onGoalAchieved,
+    });
+}
+/**
+ * Run persistent access mode - establish long-term presence
+ */
+export async function runPersistentAccess(agent, objective, options) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(objective, {
+        mode: 'persistent-access',
+        targets: options.targets,
+        stealthMode: options.stealth ?? true,
+        maintainAccess: true,
+        minimizeFootprint: true,
+        onTechniqueComplete: options.onTechniqueComplete,
+    });
+}
+/**
+ * Run intelligence collection - gather all available data
+ */
+export async function runIntelCollection(agent, objective, options) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(objective, {
+        mode: 'intel-collection',
+        targets: options.targets,
+        depth: options.depth || 'deep',
+        collectIntel: true,
+        onTechniqueComplete: options.onTechniqueComplete,
+    });
+}
+/**
+ * Run impact operations - disrupt/destroy/manipulate
+ */
+export async function runImpactOps(agent, objective, options) {
+    const orchestrator = new UnifiedOrchestrator(agent);
+    return orchestrator.run(objective, {
+        mode: 'impact',
+        targets: options.targets,
+        stealthMode: false,
+        onTechniqueComplete: options.onTechniqueComplete,
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// REAL EXECUTION HELPERS - Direct TAO technique execution
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Execute real reconnaissance against a target without agent context
+ * Uses actual network operations (DNS, TCP, HTTP)
+ */
+export async function executeRealRecon(target, options = {}) {
+    const depth = options.depth ?? 'standard';
+    const reconTechniques = options.techniques ?? [
+        'dns_enum',
+        'subdomain_enum',
+        'port_scan',
+        'service_enum',
+        'web_fingerprint',
+    ];
+    const techniques = depth === 'quick'
+        ? reconTechniques.slice(0, 3)
+        : reconTechniques;
+    const results = [];
+    const completedPhases = [];
+    const intent = parseNaturalLanguageIntent(`recon ${target}`);
+    for (let i = 0; i < techniques.length; i++) {
+        const techId = techniques[i];
+        if (!techId)
+            continue;
+        const technique = techniqueRegistry.get(techId);
+        if (!technique)
+            continue;
+        options.onProgress?.(techId, i, techniques.length);
+        const chain = planAttackChain(intent, `Recon against ${target}`);
+        const action = { id: techId, params: {}, confidence: 1.0 };
+        const params = {
+            target,
+            depth,
+            stealth: false,
+            timeout: depth === 'deep' ? 30000 : 15000,
+            context: {},
+        };
+        try {
+            const { result } = await executeTechniqueInChain(chain, action, params);
+            const execResult = {
+                techniqueId: techId,
+                techniqueName: technique.name,
+                phase: technique.phase,
+                success: result.success,
+                duration: result.duration,
+                artifacts: result.artifacts,
+                detectionRisk: result.detectionRisk,
+                nextTechniques: result.nextTechniques,
+            };
+            results.push(execResult);
+            // Notify artifacts
+            for (const artifact of result.artifacts) {
+                options.onArtifact?.(artifact);
+            }
+            if (result.success && !completedPhases.includes(technique.phase)) {
+                completedPhases.push(technique.phase);
+            }
+        }
+        catch {
+            // Continue with other techniques
+        }
+    }
+    const rlState = getRLState();
+    const metrics = {
+        totalTechniquesExecuted: results.length,
+        successfulTechniques: results.filter(r => r.success).length,
+        failedTechniques: results.filter(r => !r.success).length,
+        totalDuration: results.reduce((sum, r) => sum + r.duration, 0),
+        averageDetectionRisk: results.length > 0
+            ? results.reduce((sum, r) => sum + r.detectionRisk, 0) / results.length
+            : 0,
+        phasesCompleted: completedPhases,
+        artifactsCollected: results.reduce((sum, r) => sum + r.artifacts.length, 0),
+        rlRewardAverage: rlState.avgReward,
+    };
+    options.onProgress?.('complete', techniques.length, techniques.length);
+    // Build summary
+    const lines = [];
+    lines.push(`## Reconnaissance Results for ${target}`);
+    lines.push(`- Techniques: ${metrics.successfulTechniques}/${metrics.totalTechniquesExecuted} successful`);
+    lines.push(`- Duration: ${(metrics.totalDuration / 1000).toFixed(1)}s`);
+    lines.push(`- Artifacts: ${metrics.artifactsCollected}`);
+    lines.push('');
+    for (const exec of results) {
+        if (exec.success && exec.artifacts.length > 0) {
+            lines.push(`### ${exec.techniqueName}`);
+            for (const artifact of exec.artifacts.slice(0, 5)) {
+                lines.push(`- [${artifact.type}] ${artifact.data}`);
+            }
+        }
+    }
+    return {
+        target,
+        results,
+        metrics,
+        summary: lines.join('\n'),
+    };
+}
+/**
+ * Execute a single technique directly without orchestration context
+ */
+export async function executeRealTechniqueDirect(techniqueId, target, options = {}) {
+    const technique = techniqueRegistry.get(techniqueId);
+    if (!technique) {
+        throw new Error(`Unknown technique: ${techniqueId}`);
+    }
+    const intent = parseNaturalLanguageIntent(`execute ${techniqueId} against ${target}`);
+    const chain = planAttackChain(intent, `Direct ${techniqueId} execution`);
+    const action = { id: techniqueId, params: {}, confidence: 1.0 };
+    const params = {
+        target,
+        depth: options.depth ?? 'standard',
+        stealth: options.stealth ?? false,
+        timeout: options.timeout ?? 15000,
+        context: options.context ?? {},
+    };
+    const { result } = await executeTechniqueInChain(chain, action, params);
+    return {
+        techniqueId,
+        techniqueName: technique.name,
+        phase: technique.phase,
+        success: result.success,
+        duration: result.duration,
+        artifacts: result.artifacts,
+        detectionRisk: result.detectionRisk,
+        nextTechniques: result.nextTechniques,
+    };
+}
+/**
+ * Get list of available real execution techniques
+ */
+export function listRealTechniques() {
+    return techniqueRegistry.list().map(t => ({
+        id: t.id,
+        name: t.name,
+        category: t.category,
+        phase: t.phase,
+        stealthRating: t.stealthRating,
+        description: `${t.category} technique for ${t.phase} phase`,
+    }));
+}
+/**
+ * Get current RL statistics from the unified system
+ */
+export function getRealExecutionStats() {
+    const rlState = getRLState();
+    return {
+        episode: rlState.episode,
+        steps: rlState.steps,
+        avgReward: rlState.avgReward,
+        chainStats: getChainStats(),
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// PERSISTENT APT EXECUTION - Cross-session objective management
+// ═══════════════════════════════════════════════════════════════════════════════
+import { getObjectiveStore, createAPTObjective, resumeObjective, getAPTStatus, } from './persistentObjectiveStore.js';
+/**
+ * Create and start a persistent APT objective
+ * Saves state across sessions and can be resumed
+ */
+export async function startPersistentAPT(agent, params) {
+    const store = getObjectiveStore();
+    // Create persistent objective
+    const objective = createAPTObjective({
+        name: params.name,
+        targets: params.targets,
+        goals: params.goals,
+        priority: params.priority,
+        depth: params.depth,
+        stealth: params.stealth,
+    });
+    // Set as active
+    store.setActiveObjective(objective.id);
+    const orchestrator = new UnifiedOrchestrator(agent);
+    // Execute with persistence tracking
+    const result = await orchestrator.run(`Persistent APT: ${params.name}`, {
+        mode: 'direct-apt',
+        targets: params.targets,
+        goals: params.goals,
+        depth: params.depth || 'standard',
+        stealthMode: params.stealth ?? true,
+        onTechniqueComplete: (execResult) => {
+            // Record to persistent store
+            store.recordTechniqueExecution(objective.id, execResult);
+            // Notify callback
+            const updated = store.getObjective(objective.id);
+            if (updated && params.onProgress) {
+                params.onProgress({
+                    objective: updated,
+                    techniqueId: execResult.techniqueId,
+                    result: execResult,
+                });
+            }
+        },
+        onGoalAchieved: (goal, artifacts) => {
+            store.completeGoal(objective.id, goal);
+            // Create checkpoint on goal completion
+            const checkpoint = createCheckpointFromExecution(store, objective.id, goal, artifacts);
+            if (params.onCheckpoint) {
+                params.onCheckpoint(checkpoint);
+            }
+        },
+    });
+    // Update final state
+    const finalObjective = store.updateObjective(objective.id, {
+        state: result.success ? 'completed' : 'checkpointed',
+        completedAt: result.success ? new Date().toISOString() : undefined,
+    });
+    return {
+        objective: finalObjective || objective,
+        result,
+    };
+}
+/**
+ * Resume a persistent APT objective from where it left off
+ */
+export async function resumePersistentAPT(agent, objectiveId, options) {
+    const resumeData = resumeObjective(objectiveId);
+    if (!resumeData)
+        return null;
+    const { objective, checkpoint, artifacts } = resumeData;
+    const store = getObjectiveStore();
+    // Determine remaining goals
+    const remainingGoals = objective.goals.filter(g => !objective.goalsCompleted.includes(g));
+    if (remainingGoals.length === 0) {
+        // Already complete
+        return {
+            objective,
+            result: {
+                mode: 'direct-apt',
+                success: true,
+                finalResponse: 'Objective already completed',
+                toolsUsed: [],
+                summary: `All ${objective.goals.length} goals previously achieved`,
+                duration: 0,
+            },
+            resumedFrom: checkpoint,
+        };
+    }
+    const orchestrator = new UnifiedOrchestrator(agent);
+    // Build context from checkpoint if available
+    const contextInfo = checkpoint
+        ? `\nResuming from checkpoint: ${checkpoint.id}\n` +
+            `Previous progress: ${checkpoint.state.phasesCompleted.join(', ')}\n` +
+            `Artifacts collected: ${checkpoint.artifacts.length}\n`
+        : '';
+    const result = await orchestrator.run(`Resume APT: ${objective.name}${contextInfo}\nRemaining goals: ${remainingGoals.join(', ')}`, {
+        mode: 'direct-apt',
+        targets: objective.targets,
+        goals: remainingGoals,
+        depth: objective.config.depth,
+        stealthMode: objective.config.stealth,
+        onTechniqueComplete: (execResult) => {
+            store.recordTechniqueExecution(objective.id, execResult);
+            const updated = store.getObjective(objective.id);
+            if (updated && options?.onProgress) {
+                options.onProgress({
+                    objective: updated,
+                    techniqueId: execResult.techniqueId,
+                    result: execResult,
+                });
+            }
+        },
+        onGoalAchieved: (goal, goalArtifacts) => {
+            store.completeGoal(objective.id, goal);
+            const newCheckpoint = createCheckpointFromExecution(store, objective.id, goal, goalArtifacts);
+            if (options?.onCheckpoint) {
+                options.onCheckpoint(newCheckpoint);
+            }
+        },
+    });
+    const finalObjective = store.updateObjective(objective.id, {
+        state: result.success ? 'completed' : 'checkpointed',
+        completedAt: result.success ? new Date().toISOString() : undefined,
+    });
+    return {
+        objective: finalObjective || objective,
+        result,
+        resumedFrom: checkpoint,
+    };
+}
+/**
+ * Pause a running persistent APT objective
+ */
+export function pausePersistentAPT(objectiveId) {
+    const store = getObjectiveStore();
+    return store.updateObjective(objectiveId, { state: 'paused' });
+}
+/**
+ * Get status of all persistent APT objectives
+ */
+export function getPersistentAPTStatus() {
+    const store = getObjectiveStore();
+    const status = getAPTStatus();
+    return {
+        active: store.getActiveObjective(),
+        pending: status.pending.map(s => store.getObjective(s.id)).filter(Boolean),
+        completed: status.completed.map(s => store.getObjective(s.id)).filter(Boolean),
+        paused: store.listObjectives({ state: 'paused' }).map(s => store.getObjective(s.id)).filter(Boolean),
+    };
+}
+/**
+ * Get artifacts collected during persistent APT execution
+ */
+export function getPersistentAPTArtifacts(objectiveId, filter) {
+    const store = getObjectiveStore();
+    return store.listArtifacts(objectiveId, filter);
+}
+/**
+ * Search all artifacts across objectives
+ */
+export function searchAPTArtifacts(query) {
+    const store = getObjectiveStore();
+    return store.searchArtifacts(query);
+}
+/**
+ * Helper to create checkpoint from execution state
+ */
+function createCheckpointFromExecution(store, objectiveId, completedGoal, artifacts) {
+    const objective = store.getObjective(objectiveId);
+    const rlState = getRLState();
+    const chainStats = getChainStats();
+    return store.createCheckpoint(objectiveId, {
+        state: {
+            currentGoal: objective?.currentGoal || null,
+            currentPhase: null,
+            phasesCompleted: objective?.progress.phasesCompleted || [],
+            executionCycle: 0,
+            totalCycles: 0,
+        },
+        attackChains: listActiveChains().map(chain => ({
+            id: chain.id,
+            name: chain.name,
+            objective: chain.objective,
+            state: chain.state,
+            currentPhase: chain.currentPhase,
+            phases: chain.phases.map((p, idx) => ({
+                phase: ['reconnaissance', 'weaponization', 'delivery', 'exploitation', 'installation', 'command-control', 'actions-on-objectives'][idx % 7] || 'reconnaissance',
+                completed: p.completed,
+                rlScore: p.rlScore,
+            })),
+            outcomes: chain.outcomes.map(o => ({
+                techniqueId: o.operation, // OperationOutcome uses 'operation' field
+                success: o.success,
+                artifacts: o.artifacts,
+            })),
+        })),
+        techniqueHistory: [],
+        pendingTechniques: [],
+        artifacts: artifacts.map((a, i) => ({
+            id: `inline-${i}`,
+            objectiveId,
+            techniqueId: 'goal-completion',
+            type: a.type,
+            timestamp: new Date().toISOString(),
+            target: '',
+            phase: 'actions-on-objectives',
+            dataPath: '',
+            summary: a.data.slice(0, 100),
+            tags: [completedGoal],
+        })),
+        agentContext: {
+            messageCount: 0,
+            lastToolCalls: [],
+        },
+        metrics: {
+            totalDuration: objective?.progress.totalExecutionTime || 0,
+            techniquesExecuted: objective?.progress.techniquesExecuted || 0,
+            techniquesSucceeded: objective?.progress.techniquesSucceeded || 0,
+            avgReward: rlState.avgReward,
+        },
+    });
+}
+// Re-export persistence types and functions
+export { getObjectiveStore, createAPTObjective, resumeObjective, getAPTStatus, } from './persistentObjectiveStore.js';
+// ═══════════════════════════════════════════════════════════════════════════════
+// RE-EXPORTS FOR CONVENIENCE
+// ═══════════════════════════════════════════════════════════════════════════════
+// Core orchestrators
+export { AgentOrchestrator } from './agentOrchestrator.js';
+export { DualAgentOrchestrator } from './dualAgentOrchestrator.js';
+export { AutoExecutionOrchestrator } from './autoExecutionOrchestrator.js';
+// Deliverable generation
+export { SecurityDeliverableGenerator, exportToMarkdown, exportToJSON, exportToHTML } from './securityDeliverableGenerator.js';
+// Government procedures
+export { US_FEDERAL_CONTACTS, LEGAL_FRAMEWORKS, EVIDENCE_HANDLING_PROCEDURES, REPORTING_PROCEDURES, COORDINATION_PROTOCOLS, getAgencyContacts, getApplicableLegalFrameworks, getReportingRequirements, generateIncidentReportTemplate, generateEvidenceForm, } from './governmentProcedures.js';
+// Infrastructure templates
+export { US_INFRASTRUCTURE_STACK, UKRAINE_INFRASTRUCTURE_STACK, AUTO_EXECUTION_TEMPLATES, getInfrastructureStack, getAutoExecutionTemplate, listTemplatesForRegion, generateDeploymentScript, generateTeardownScript, generateOpsecChecklist, } from './infrastructureTemplates.js';
+//# sourceMappingURL=orchestration.js.map