erosolar-cli 2.1.270 → 2.1.272

package/dist/core/orchestration.js

@@ -1,2009 +0,0 @@
-/**
- * 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