erosolar-cli 2.1.270 → 2.1.272

package/dist/core/agentOrchestrator.js

@@ -1,2133 +0,0 @@
-import { TASK_FULLY_COMPLETE } from './constants.js';
-import { TaskCompletionDetector, WRITE_TOOLS } from './taskCompletionDetector.js';
-import { planAttackChain, selectNextTechnique, executeTechniqueInChain, techniqueRegistry, parseNaturalLanguageIntent, validateAuthorizationContext, getRLState, listActiveChains, } from '../tools/tao/index.js';
-import { getInfrastructureStack, generateDeploymentScript, generateTeardownScript, generateOpsecChecklist, } from './infrastructureTemplates.js';
-import { getAgencyContacts, getApplicableLegalFrameworks, } from './governmentProcedures.js';
-import { createTaoTools } from '../tools/taoTools.js';
-// Kill-chain phase definitions for full attack chain execution
-export const KILL_CHAIN_PHASES = [
-    'reconnaissance',
-    'initial_access',
-    'persistence',
-    'privilege_escalation',
-    'defense_evasion',
-    'credential_access',
-    'discovery',
-    'lateral_movement',
-    'collection',
-    'command_control',
-    'exfiltration',
-    'impact',
-];
-/**
- * Single-pass orchestration: drive the agent to finish as much as possible
- * in one go, with strong bias toward real actions over planning.
- */
-export class AgentOrchestrator {
-    agent;
-    constructor(agent) {
-        this.agent = agent;
-    }
-    async runToCompletion(request, options) {
-        // Early safety check for potentially harmful requests
-        const harmfulCheck = this.checkForHarmfulRequest(request);
-        if (harmfulCheck.isHarmful) {
-            return {
-                finalResponse: harmfulCheck.response,
-                toolsUsed: [],
-                planOnly: false,
-                tookAction: false,
-                completion: {
-                    isComplete: true,
-                    confidence: 1.0,
-                    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.0,
-                    },
-                    reason: 'Request declined for safety reasons',
-                    shouldVerify: false,
-                },
-                exitReason: 'refusal',
-                statusSummary: null,
-                limitations: [],
-                recommendations: [],
-            };
-        }
-        const streaming = options?.streaming ?? true;
-        const enforceActions = options?.enforceActions ?? true;
-        const verificationMode = options?.verificationMode ?? 'auto';
-        const singlePassFocus = options?.singlePassFocus ?? true;
-        const maxAttempts = Math.max(1, options?.maxAttempts ?? 6);
-        const completionDetector = new TaskCompletionDetector();
-        const contextualGuidance = this.buildContextualGuidance(request);
-        const attempts = [];
-        const runAttempt = async (prompt, enforceActionsForAttempt) => {
-            const response = (await this.agent.send(prompt, streaming)).trim();
-            const toolExecutions = this.agent.drainToolExecutions();
-            toolExecutions.forEach(exec => completionDetector.recordToolCall(exec.name, exec.success, exec.hasOutput));
-            const toolsUsed = toolExecutions.filter(exec => exec.success).map(exec => exec.name);
-            const completion = completionDetector.analyzeCompletion(response, toolsUsed);
-            const analysis = this.analyzeResponse(response, toolsUsed, enforceActionsForAttempt);
-            const exitReason = this.resolveExitReason(analysis, completion, enforceActionsForAttempt, verificationMode);
-            return {
-                response,
-                toolsUsed,
-                toolExecutions,
-                completion,
-                analysis,
-                exitReason,
-            };
-        };
-        const primaryPrompt = singlePassFocus
-            ? this.buildSinglePassPrompt(request, enforceActions, contextualGuidance)
-            : request.trim();
-        let nextPrompt = primaryPrompt;
-        let finalAttempt = null;
-        let exitReason = 'incomplete';
-        let maxAttemptsHit = false;
-        let consecutiveNoProgress = 0;
-        let consecutiveReadOnlyOnly = 0;
-        while (attempts.length < maxAttempts) {
-            const attempt = await runAttempt(nextPrompt, enforceActions);
-            attempts.push(attempt);
-            finalAttempt = attempt;
-            exitReason = attempt.exitReason;
-            // CRITICAL: Stop immediately on refusals - these are terminal states
-            if (attempt.exitReason === 'refusal') {
-                break;
-            }
-            // Track consecutive no-progress attempts
-            // Key insight: tool usage alone doesn't mean progress if the model is stuck
-            // or refusing. We need to detect actual forward momentum.
-            const terminalNoProgress = attempt.exitReason === 'empty-response' ||
-                attempt.exitReason === 'no-action' ||
-                attempt.exitReason === 'blocked';
-            // Detect response repetition - if we keep getting similar responses, we're stuck
-            // This catches cases where model calls tools but produces same reasoning/refusal
-            const responseFingerprint = this.computeResponseFingerprint(attempt.response);
-            const previousAttempt = attempts.length >= 2 ? attempts[attempts.length - 2] : undefined;
-            const isRepeatedResponse = previousAttempt !== undefined &&
-                this.computeResponseFingerprint(previousAttempt.response) === responseFingerprint &&
-                responseFingerprint !== '';
-            // Progress is considered made when:
-            // 1. Task is complete or needs verification
-            // 2. OR tools were used with a DIFFERENT response (model is working through the problem)
-            const isCompleting = attempt.exitReason === 'complete' ||
-                attempt.exitReason === 'verification-needed';
-            // Check if only read-only tools were used (no write/action tools)
-            const usedWriteTool = attempt.toolsUsed.some(t => WRITE_TOOLS.has(t));
-            const onlyReadOnlyTools = attempt.toolsUsed.length > 0 && !usedWriteTool;
-            // Track consecutive read-only-only iterations
-            // This catches silent refusals where model calls list_files repeatedly
-            if (onlyReadOnlyTools && !isCompleting) {
-                consecutiveReadOnlyOnly++;
-            }
-            else {
-                consecutiveReadOnlyOnly = 0;
-            }
-            const isProgressingWithTools = attempt.toolsUsed.length > 0 && !isRepeatedResponse;
-            const hasRealProgress = isCompleting || isProgressingWithTools;
-            // No progress if: terminal state, no completion AND no tool progress, OR repeated response
-            if (terminalNoProgress || (!hasRealProgress && !isCompleting) || (isRepeatedResponse && !isCompleting)) {
-                consecutiveNoProgress++;
-            }
-            else {
-                consecutiveNoProgress = 0;
-            }
-            // CRITICAL: Stop immediately after 2 consecutive attempts with no progress
-            // This prevents infinite loops when model refuses silently or returns empty responses
-            if (consecutiveNoProgress >= 2) {
-                break;
-            }
-            // CRITICAL: Stop if model keeps using only read-only tools without making task progress
-            // This catches DeepSeek/others silently refusing by calling list_files repeatedly
-            if (consecutiveReadOnlyOnly >= 3) {
-                break;
-            }
-            // Single exit check - combines completion and limit detection
-            maxAttemptsHit = attempts.length >= maxAttempts;
-            const continueRun = this.shouldContinue(attempts, maxAttempts);
-            if (!continueRun || maxAttemptsHit) {
-                break;
-            }
-            nextPrompt = this.buildContinuationPrompt(request, attempt, attempts.length + 1, enforceActions, contextualGuidance);
-        }
-        if (!finalAttempt) {
-            throw new Error('Orchestrator did not record any attempts.');
-        }
-        const toolsUsed = Array.from(new Set(attempts.flatMap((attempt) => attempt.toolExecutions.filter(exec => exec.success).map(exec => exec.name))));
-        const tookAction = attempts.some(attempt => attempt.analysis.tookAction);
-        const planOnly = attempts.every(attempt => attempt.analysis.planOnly);
-        const { summary, limitations, recommendations } = await this.buildStatusSummary(request, finalAttempt.response, finalAttempt.analysis, finalAttempt.completion, toolsUsed, exitReason, attempts.length, maxAttemptsHit, attempts);
-        return {
-            finalResponse: finalAttempt.response,
-            toolsUsed,
-            planOnly,
-            tookAction,
-            completion: finalAttempt.completion,
-            exitReason,
-            statusSummary: summary,
-            limitations,
-            recommendations,
-        };
-    }
-    resolveExitReason(analysis, completion, enforceActions, verificationMode) {
-        if (analysis.empty) {
-            return 'empty-response';
-        }
-        // AI safety refusal - terminal state, do not retry
-        if (analysis.refusal) {
-            return 'refusal';
-        }
-        if (analysis.blocked) {
-            return 'blocked';
-        }
-        if (enforceActions && !analysis.tookAction) {
-            return 'no-action';
-        }
-        const readyToStop = analysis.readyToStop || completion.isComplete;
-        if (verificationMode === 'auto' && completion.shouldVerify && readyToStop) {
-            return 'verification-needed';
-        }
-        if (readyToStop) {
-            return 'complete';
-        }
-        return 'incomplete';
-    }
-    async buildStatusSummary(request, response, _analysis, completion, toolsUsed, exitReason, attemptsCount, maxAttemptsHit, attempts) {
-        // Generate intelligent insight - the only thing users care about
-        const summary = await this.generateInsightSummary(request, response, toolsUsed, exitReason, attemptsCount, maxAttemptsHit, completion, attempts);
-        // Minimal limitations/recommendations - only surface critical issues
-        const limitations = [];
-        const recommendations = [];
-        if (toolsUsed.length === 0) {
-            limitations.push('No tools ran.');
-        }
-        if (maxAttemptsHit && exitReason !== 'complete') {
-            limitations.push('Hit attempt limit.');
-        }
-        if (completion.shouldVerify) {
-            recommendations.push('Verify the output.');
-        }
-        if (toolsUsed.length > 0) {
-            recommendations.push('Run `npm run verify-core` (lint, type-check, focused tests) before shipping.');
-        }
-        return { summary, limitations, recommendations };
-    }
-    /**
-     * Generate comprehensive insight summary for user transparency.
-     * Shows what was done, what might be incomplete, and potential concerns.
-     */
-    async generateInsightSummary(_request, _response, toolsUsed, exitReason, attemptsCount, maxAttemptsHit, completion, attempts) {
-        const history = this.agent.getHistory();
-        const ctx = this.extractContextAndLimitations(history, toolsUsed, attempts);
-        // Build comprehensive summary sections
-        const sections = [];
-        // 1. What was done - key findings and actions
-        if (ctx.keyFindings.length > 0) {
-            const findings = ctx.keyFindings.slice(0, 3).join('; ');
-            sections.push(`Done: ${findings}`);
-        }
-        // 2. Tool execution summary
-        const allTools = attempts.flatMap(a => a.toolExecutions);
-        const successfulTools = allTools.filter(t => t.success);
-        const failedTools = allTools.filter(t => !t.success);
-        if (allTools.length > 0) {
-            const toolSummary = [];
-            if (successfulTools.length > 0) {
-                const uniqueTools = [...new Set(successfulTools.map(t => t.name))];
-                toolSummary.push(`${successfulTools.length} tool calls (${uniqueTools.slice(0, 4).join(', ')}${uniqueTools.length > 4 ? '...' : ''})`);
-            }
-            if (failedTools.length > 0) {
-                toolSummary.push(`${failedTools.length} failed`);
-            }
-            if (toolSummary.length > 0) {
-                sections.push(`Tools: ${toolSummary.join(', ')}`);
-            }
-        }
-        else if (toolsUsed.length === 0) {
-            sections.push('Tools: none used (response may be ungrounded)');
-        }
-        // Validation/telemetry
-        sections.push('Validation: non-blocking bash/tool telemetry enabled; prefer `npm run verify-core` for final checks.');
-        // 3. Verification status
-        const verifyParts = [];
-        if (ctx.ranTests)
-            verifyParts.push('tests ran');
-        if (ctx.hasVerification && !ctx.ranTests)
-            verifyParts.push('build checked');
-        if (ctx.madeEdits && !ctx.ranTests)
-            verifyParts.push('edits NOT tested');
-        if (ctx.hasErrors)
-            verifyParts.push('ERRORS detected');
-        if (ctx.hasWarnings)
-            verifyParts.push('warnings present');
-        if (verifyParts.length > 0) {
-            sections.push(`Status: ${verifyParts.join(', ')}`);
-        }
-        // 4. Completion status and concerns
-        const concerns = [];
-        if (maxAttemptsHit && exitReason !== 'complete') {
-            concerns.push(`stopped after ${attemptsCount} attempts (may be incomplete)`);
-        }
-        if (exitReason === 'incomplete') {
-            concerns.push('task may not be fully complete');
-        }
-        if (completion.shouldVerify) {
-            concerns.push('manual verification recommended');
-        }
-        // 5. Honest limitations - what AI cannot guarantee
-        if (ctx.limitations.length > 0) {
-            const limitationsStr = ctx.limitations.slice(0, 3).join(', ');
-            concerns.push(limitationsStr);
-        }
-        // Add concerns section if any
-        if (concerns.length > 0) {
-            sections.push(`Note: ${concerns.join('; ')}`);
-        }
-        // 6. Potential hallucination warning for ungrounded responses
-        if (toolsUsed.length === 0 && !ctx.hasVerification) {
-            sections.push('⚠️ No tool verification - response based on model knowledge only');
-        }
-        // Return null only for clean, verified completions
-        if (sections.length === 0 ||
-            (exitReason === 'complete' && !completion.shouldVerify &&
-                ctx.hasVerification && !ctx.hasErrors && ctx.limitations.length === 0)) {
-            return null;
-        }
-        return sections.join(' | ');
-    }
-    /**
-     * Extract context AND limitations from the run.
-     * Be honest about what we know vs don't know.
-     */
-    extractContextAndLimitations(history, toolsUsed, attempts) {
-        const keyFindings = [];
-        let hasErrors = false;
-        let hasWarnings = false;
-        let hasVerification = false;
-        let ranTests = false;
-        let madeEdits = false;
-        const limitations = [];
-        // Analyze tool usage
-        const allTools = attempts.flatMap(a => a.toolExecutions);
-        madeEdits = allTools.some(t => t.success && this.isEditTool(t.name));
-        const validationTools = allTools.filter(t => t.success && this.isValidationTool(t.name));
-        ranTests = validationTools.length > 0 || this.hasValidationEvidence(history);
-        hasVerification = ranTests || validationTools.length > 0;
-        // Scan conversation for substance
-        const relevant = history.filter(m => m.role !== 'system').slice(-8);
-        for (const msg of relevant) {
-            const content = String(msg.content || '');
-            if (msg.role === 'tool') {
-                // Detect errors
-                if (/\b(error|failed|failure|exception|ENOENT|EACCES|denied)\b/i.test(content)) {
-                    hasErrors = true;
-                    const errorLine = content.split('\n').find(l => /error|fail|exception/i.test(l));
-                    if (errorLine)
-                        keyFindings.push(errorLine.slice(0, 80));
-                }
-                // Detect warnings
-                if (/\bwarn(ing)?\b/i.test(content)) {
-                    hasWarnings = true;
-                }
-                // Detect test results
-                if (/(\d+)\s*(tests?\s*)?(passed|passing)/i.test(content)) {
-                    const match = content.match(/(\d+)\s*(tests?\s*)?(passed|passing)/i);
-                    if (match)
-                        keyFindings.push(`${match[1]} tests passed`);
-                }
-                if (/(\d+)\s*(tests?\s*)?(failed|failing)/i.test(content)) {
-                    const match = content.match(/(\d+)\s*(tests?\s*)?(failed|failing)/i);
-                    if (match)
-                        keyFindings.push(`${match[1]} tests failed`);
-                    hasErrors = true;
-                }
-            }
-            if (msg.role === 'assistant') {
-                // Extract conclusions
-                const conclusionMatch = content.match(/(?:found|fixed|created|updated|added|removed|the issue was|the problem was|completed)[^.\n]{5,60}/i);
-                if (conclusionMatch) {
-                    keyFindings.push(conclusionMatch[0].trim());
-                }
-            }
-        }
-        // Intelligent limitation analysis - context-aware reasoning about what could go wrong
-        const toolNames = allTools.map(t => t.name);
-        const assistantMessages = relevant.filter(m => m.role === 'assistant').map(m => String(m.content || ''));
-        const lastAssistant = assistantMessages[assistantMessages.length - 1] || '';
-        // 1. Verification gaps
-        if (!ranTests) {
-            if (madeEdits) {
-                limitations.push('code edits made but no tests executed - behavior unverified');
-            }
-            else {
-                limitations.push('no automated tests ran');
-            }
-        }
-        if (madeEdits && !hasVerification) {
-            limitations.push('no build or lint check performed after edits');
-        }
-        // 2. Tool execution concerns
-        if (toolsUsed.length === 0) {
-            limitations.push('response not grounded in tool execution - may contain assumptions');
-        }
-        const failedToolNames = allTools.filter(t => !t.success).map(t => t.name);
-        if (failedToolNames.length > 0) {
-            const unique = [...new Set(failedToolNames)];
-            limitations.push(`${unique.length} tool(s) failed: ${unique.slice(0, 3).join(', ')}${unique.length > 3 ? '...' : ''}`);
-        }
-        // 3. Potential hallucination indicators
-        if (lastAssistant) {
-            // Check for speculative language suggesting uncertainty
-            if (/\b(might|may|could|possibly|probably|likely|assume|guess|think)\b/i.test(lastAssistant)) {
-                if (!/\b(definitely|confirmed|verified|tested|checked)\b/i.test(lastAssistant)) {
-                    limitations.push('response contains speculative language - verify claims');
-                }
-            }
-            // Check for claims without tool evidence
-            if (/\b(fixed|resolved|completed|works now)\b/i.test(lastAssistant) && !ranTests && !hasVerification) {
-                limitations.push('completion claimed without verification - manually confirm');
-            }
-        }
-        // 4. Edge case and scope concerns
-        if (madeEdits) {
-            // Analyze edit scope
-            const editCount = allTools.filter(t => ['edit', 'edit_file', 'write', 'write_file'].includes(t.name) && t.success).length;
-            if (editCount > 3) {
-                limitations.push(`${editCount} files edited - review each for correctness`);
-            }
-            if (!ranTests) {
-                limitations.push('edge cases and error handling paths untested');
-            }
-        }
-        // 5. Security and production concerns
-        if (toolNames.includes('bash')) {
-            const bashOutputs = relevant.filter(m => m.role === 'tool').map(m => String(m.content || ''));
-            const hasSensitiveOps = bashOutputs.some(o => /\b(rm -rf|chmod 777|sudo|password|secret|token|key=)\b/i.test(o));
-            if (hasSensitiveOps) {
-                limitations.push('sensitive operations detected - review security implications');
-            }
-        }
-        // 6. Incomplete task indicators
-        if (hasErrors && !keyFindings.some(f => /fixed|resolved/i.test(f))) {
-            limitations.push('errors detected but not explicitly resolved');
-        }
-        return { keyFindings, hasErrors, hasWarnings, hasVerification, ranTests, madeEdits, limitations };
-    }
-    buildSinglePassPrompt(originalRequest, enforceActions, contextualGuidance) {
-        const actionLine = enforceActions
-            ? '- Use tools to complete the task. Act immediately instead of re-planning.'
-            : '- Provide your best response.';
-        const guidanceBlock = this.formatContextualGuidance(contextualGuidance);
-        const playbook = this.buildExecutionPlaybook(enforceActions);
-        return `${originalRequest.trim()}
-
-${actionLine}
-- Finish as much as possible now.
-- Favor direct execution over additional planning.
-- Run quick verification (tests/build) when claiming completion.
-- Show outputs as evidence.
-- End with TASK_FULLY_COMPLETE when done.${guidanceBlock}${playbook}`;
-    }
-    shouldContinue(attempts, maxAttempts) {
-        if (!attempts.length) {
-            return false;
-        }
-        const latest = attempts[attempts.length - 1];
-        const exitReason = latest.exitReason;
-        if (attempts.length >= maxAttempts) {
-            return false;
-        }
-        // Terminal states - never retry
-        if (exitReason === 'refusal' || exitReason === 'complete') {
-            return false;
-        }
-        // Detect stuck loops early - if we have 2+ consecutive attempts without completion, stop
-        // This catches cases where the model refuses silently, calls tools without progress,
-        // or returns empty/no-action repeatedly
-        if (attempts.length >= 2) {
-            const recentAttempts = attempts.slice(-2);
-            const allNoCompletion = recentAttempts.every(a => a.exitReason !== 'complete' && a.exitReason !== 'verification-needed');
-            if (allNoCompletion) {
-                // Check if responses are similar (stuck in a loop)
-                const fingerprints = recentAttempts.map(a => this.computeResponseFingerprint(a.response));
-                if (fingerprints[0] === fingerprints[1] && fingerprints[0] !== '') {
-                    return false; // Stuck producing same response
-                }
-            }
-        }
-        // Allow recovery attempts for common failure modes before giving up
-        if (exitReason === 'no-action') {
-            const noActionAttempts = attempts.filter((a) => a.exitReason === 'no-action').length;
-            return noActionAttempts < 2;
-        }
-        if (exitReason === 'verification-needed') {
-            const verificationAttempts = attempts.filter((a) => a.exitReason === 'verification-needed').length;
-            return verificationAttempts < 2;
-        }
-        if (exitReason === 'empty-response') {
-            const emptyResponses = attempts.filter((a) => a.exitReason === 'empty-response').length;
-            return emptyResponses < 2;
-        }
-        if (exitReason === 'blocked') {
-            const blockedResponses = attempts.filter((a) => a.exitReason === 'blocked').length;
-            return blockedResponses < 2;
-        }
-        // Detect tool loops - if last 2 attempts used tools, are incomplete, AND produced similar responses
-        if (exitReason === 'incomplete' && attempts.length >= 2) {
-            const recentAttempts = attempts.slice(-2);
-            const allIncomplete = recentAttempts.every(a => a.exitReason === 'incomplete' && a.toolsUsed.length > 0);
-            if (allIncomplete) {
-                // Only stop if responses are also similar (model is stuck in a pattern)
-                const fingerprints = recentAttempts.map(a => this.computeResponseFingerprint(a.response));
-                if (fingerprints[0] === fingerprints[1] && fingerprints[0] !== '') {
-                    return false; // Same response pattern with tools - stuck in a loop
-                }
-            }
-        }
-        return exitReason === 'incomplete';
-    }
-    buildContinuationPrompt(originalRequest, attempt, nextAttemptNumber, enforceActions, contextualGuidance) {
-        const actionLine = enforceActions
-            ? '- Continue with tools.'
-            : '- Provide your best response.';
-        const reason = this.describeContinuationReason(attempt);
-        const toolContext = attempt.toolsUsed.length
-            ? `Tools used: ${attempt.toolsUsed.join(', ')}.`
-            : '';
-        const guidanceBlock = this.formatContextualGuidance(contextualGuidance);
-        const recoveryGuidance = this.buildRecoveryGuidance(attempt);
-        const recoveryBlock = recoveryGuidance.length
-            ? `\nRecovery focus:\n${recoveryGuidance.map((line) => `- ${line}`).join('\n')}`
-            : '';
-        const playbook = this.buildExecutionPlaybook(enforceActions);
-        return `${originalRequest.trim()}
-
-Pass ${nextAttemptNumber}: ${reason}
-${toolContext}
-${actionLine}
-- End with TASK_FULLY_COMPLETE when done.${guidanceBlock}${recoveryBlock}${playbook}`;
-    }
-    buildRecoveryGuidance(attempt) {
-        const guidance = [];
-        const madeEdits = attempt.toolExecutions.some((tool) => tool.success && this.isEditTool(tool.name));
-        const ranValidation = attempt.toolExecutions.some((tool) => tool.success && this.isValidationTool(tool.name));
-        if (attempt.exitReason === 'no-action' || attempt.analysis.planOnly || !attempt.analysis.tookAction) {
-            guidance.push('Skip more planning; call tools now (read/search -> edit/run checks).');
-        }
-        if (attempt.exitReason === 'verification-needed') {
-            guidance.push('Run verification now (tests/build) and include the output before stopping.');
-        }
-        if (madeEdits && !ranValidation) {
-            guidance.push('You edited code; run fast validation (tests/lint/build) and show the output before stopping.');
-        }
-        if (attempt.exitReason === 'empty-response') {
-            guidance.push('Provide a substantive update with tool calls and outputs; previous reply was empty.');
-        }
-        if (attempt.exitReason === 'blocked') {
-            guidance.push('Proceed with available context without asking for more input; use tools to unblock.');
-        }
-        const failedTools = attempt.toolExecutions.filter((tool) => !tool.success).map((tool) => tool.name);
-        if (failedTools.length > 0) {
-            const uniqueFailed = Array.from(new Set(failedTools));
-            guidance.push(`Retry failed tools with fixes or alternatives (${uniqueFailed.join(', ')}).`);
-        }
-        return guidance;
-    }
-    buildContextualGuidance(request) {
-        const normalized = request.toLowerCase();
-        const guidance = [];
-        guidance.push('Ground responses in actual code; read files before suggesting changes.');
-        guidance.push('Default loop: analyze → choose tools → execute → verify → summarize with evidence.');
-        guidance.push('Prefer running targeted commands/tests over narratives; include tool outputs as proof.');
-        const isLargePaste = normalized.length > 4000 || normalized.split('\n').length > 120;
-        if (isLargePaste) {
-            guidance.push('Work directly with the provided long input; avoid asking for more detail and act on it.');
-        }
-        const bugSweep = /\bbugs?\b|\bdefects?\b|\bissues?\b|\bbug\s+report\b/.test(normalized);
-        if (bugSweep) {
-            guidance.push('Search broadly for related issues.');
-        }
-        const asksForTests = /\b(tests?|validation|verify|reproduce|repro)\b/.test(normalized);
-        if (asksForTests || bugSweep) {
-            guidance.push('Capture a failing reproduction or test output first, then re-run after fixes to prove resolution.');
-        }
-        const needsUnderstanding = /\bexplain\b|\bunders(?:tand|tanding)\b|\boverview\b|\bsummar(y|ize)\b|\bwalk\s+through\b/.test(normalized);
-        if (needsUnderstanding) {
-            guidance.push('Skim project structure before detailed analysis.');
-        }
-        const securityWork = /\b(pentest|red\s*team|offensive|exploit|attack|apt|threat|recon|scan|payload|shell|persistence|tao|security testing)\b/.test(normalized);
-        if (securityWork) {
-            guidance.push('For security/offensive tasks use the TAO suite (TaoOps for NL planning; KineticOps/Recon/Fuzz/Payload/Persist/Hash/NetCraft for execution) and show evidence.');
-        }
-        const mentionsTests = /\b(test|verify|lint|type[-\s]?check)\b/.test(normalized);
-        if (mentionsTests || /build|compile/.test(normalized)) {
-            guidance.push('Run quick validation (lint + type-check + focused tests) when changing code; use `npm run verify-core` when unsure.');
-        }
-        return guidance;
-    }
-    formatContextualGuidance(guidance) {
-        if (!guidance.length)
-            return '';
-        const lines = guidance.map((line) => `- ${line}`).join('\n');
-        return `\nContextual guidance:\n${lines}`;
-    }
-    buildExecutionPlaybook(enforceActions) {
-        const bullets = [
-            enforceActions
-                ? 'Start with a 2-3 bullet action plan that names the tools you will use; skip restating the prompt.'
-                : 'If you plan, keep it to 2-3 bullets that name the tools you will use; skip restating the prompt.',
-            'Read before writing: inspect the most relevant files/logs first (ls/rg/cat) to ground changes.',
-            'Use the smallest effective tool and keep edits scoped; prefer targeted commands over broad rewrites.',
-            'After any edits or fixes, run a quick validation (targeted tests/lint/build) and include the command output.',
-            'Keep narration tight; surface evidence and next steps; end with TASK_FULLY_COMPLETE only when truly done.',
-        ];
-        return `\nExecution playbook:\n${bullets.map((line) => `- ${line}`).join('\n')}`;
-    }
-    isEditTool(name) {
-        const normalized = name.toLowerCase();
-        return ['edit', 'write', 'apply', 'patch', 'codemod', 'refactor', 'format'].some(keyword => normalized.includes(keyword));
-    }
-    isValidationTool(name) {
-        const normalized = name.toLowerCase();
-        return ['test', 'lint', 'build', 'check', 'verify', 'coverage', 'ci', 'type-check'].some(keyword => normalized.includes(keyword));
-    }
-    hasValidationEvidence(history) {
-        const recentTools = history.filter(m => m.role === 'tool').slice(-10);
-        return recentTools.some((message) => {
-            const content = String(message.content || '').toLowerCase();
-            return (/\b(jest|mocha|vitest|pytest|go test|npm test|pnpm test|yarn test|pytest|unittest|integration test|end-to-end)\b/.test(content) ||
-                /\b(lint|eslint|tsc|type[- ]?check|typecheck)\b/.test(content) ||
-                /\b(build|webpack|vite build|next build|pnpm build|npm run build)\b/.test(content) ||
-                (/\btests?\b/.test(content) && (/\bpass(ed)?\b/.test(content) || /\bfail(ed)?\b/.test(content))));
-        });
-    }
-    describeContinuationReason(attempt) {
-        switch (attempt.exitReason) {
-            case 'no-action':
-                return 'previous response lacked concrete actions or tool calls.';
-            case 'verification-needed':
-                return attempt.completion.reason
-                    ? `verification was requested (${attempt.completion.reason}).`
-                    : 'verification was requested.';
-            case 'empty-response':
-                return 'previous response was empty or non-substantive.';
-            case 'blocked':
-                return 'model reported being blocked; continue with available context and tools.';
-            case 'refusal':
-                return 'request was declined.';
-            case 'incomplete':
-            default:
-                return attempt.completion.reason
-                    ? `previous response did not reach a completion signal (${attempt.completion.reason}).`
-                    : 'no completion signal detected in the previous response.';
-        }
-    }
-    analyzeResponse(response, toolsUsed, enforceActions) {
-        const trimmed = response.trim();
-        const wordCount = this.wordCount(trimmed);
-        const empty = trimmed.length === 0;
-        const planOnly = this.isPlanOnly(trimmed);
-        const tookAction = toolsUsed.length > 0 || this.hasActionLanguage(trimmed);
-        const hasCompletionMarker = this.hasExplicitCompletion(trimmed);
-        const completionContradiction = this.hasCompletionContradiction(trimmed);
-        const continuing = this.hasContinuingSignal(trimmed);
-        const blocked = this.isBlockedResponse(trimmed);
-        const refusal = this.isRefusalResponse(trimmed);
-        const tooLight = wordCount < 80;
-        const substantiveAnswer = this.hasSubstantiveAnswer(trimmed, {
-            planOnly,
-            tookAction,
-            continuing,
-            blocked,
-            completionContradiction,
-            wordCount,
-        });
-        const readyToStop = (hasCompletionMarker &&
-            !completionContradiction &&
-            !continuing &&
-            (!enforceActions || tookAction || !tooLight)) ||
-            substantiveAnswer;
-        return {
-            empty,
-            planOnly,
-            tookAction,
-            readyToStop,
-            blocked,
-            refusal,
-        };
-    }
-    isPlanOnly(response) {
-        if (!response.trim())
-            return false;
-        const planIndicators = [
-            /\bplan\b/i,
-            /\bapproach\b/i,
-            /\bsteps?:\b/i,
-            /\bstep\s+1\b/i,
-            /\bstart by\b/i,
-            /\bfirst[, ]/i,
-            /\bthen\s+(?:we|i|run|do|take|handle|address|implement|fix)\b/i,
-            /\bnext\s+(?:we|i|up)\b/i,
-            /\bwe\s+will\b/i,
-            /\bi['\u2019]?ll\b/i,
-            /\bi\s+will\b/i,
-            /\bhere(?:'|\u2019)s\s+the\s+plan\b/i,
-            /\bplan:\b/i,
-            /\bapproach:\b/i,
-            /\bexecution\s+plan\b/i,
-        ];
-        return planIndicators.some((pattern) => pattern.test(response));
-    }
-    hasExplicitCompletion(response) {
-        if (!response.trim())
-            return false;
-        if (response.includes(TASK_FULLY_COMPLETE))
-            return true;
-        const completionPatterns = [
-            /\btask(s)? (is|are)?\s*complete\b/i,
-            /\ball done\b/i,
-            /\bcleanup complete\b/i,
-            /\bnothing (else\s*)?to do\b/i,
-            /\bno junk (found|remaining)\b/i,
-        ];
-        return completionPatterns.some((pattern) => pattern.test(response));
-    }
-    hasCompletionContradiction(response) {
-        // Skip contradiction check if TASK_FULLY_COMPLETE is present - explicit marker takes precedence
-        if (response.includes(TASK_FULLY_COMPLETE)) {
-            return false;
-        }
-        const contradictions = [
-            /not\s+yet\s+(done|complete|finished|integrated|implemented)/i,
-            /\bstill\s+(need|needs|pending|left)\s+to\b/i, // more specific: "still need to"
-            /\bpending\s+(work|tasks?|items?|changes?|fixes?)\b/i, // only actual pending work
-            /\bremaining\s+(work|tasks?|items?|to\s+do)\b/i, // only actual remaining work
-            /\bnot\s+(working|functional)\b/i,
-            /\btests?\s+(are\s+)?failing\b/i,
-            /\bto\s+be\s+(done|completed|fixed|implemented)\b/i,
-            /\btodo\b/i,
-            /\bfixme\b/i,
-        ];
-        return contradictions.some((pattern) => pattern.test(response));
-    }
-    hasActionLanguage(response) {
-        const actionPatterns = [
-            /\bremoved\b/i,
-            /\bdeleted\b/i,
-            /\bcreated\b/i,
-            /\badded\b/i,
-            /\bupdated\b/i,
-            /\brefactored\b/i,
-            /\bcommitted\b/i,
-            /\bran\b.+\btests?\b/i,
-            /\bcleaned\b/i,
-            /\bexecuted\b/i,
-            /\bapplied\b/i,
-            /\bpatched\b/i,
-            /\bimplemented\b/i,
-            /\bfixed\b/i,
-            /\bverified\b/i,
-            /\bvalidated\b/i,
-            /\bdeployed\b/i,
-            /\bmerged\b/i,
-        ];
-        return actionPatterns.some((pattern) => pattern.test(response));
-    }
-    hasContinuingSignal(response) {
-        if (!response.trim())
-            return false;
-        const patterns = [
-            /\b(i'?m|i am)\s+(continuing|working|starting|beginning)\b/i,
-            /\bwill\s+(now|next)\s+(run|do|start|take|handle|work on)\b/i,
-            /\babout\s+to\s+(run|execute|start|begin)\b/i,
-            /\bnext\s+up\b/i,
-            /\bplan\s+to\s+start\b/i,
-        ];
-        return patterns.some((pattern) => pattern.test(response));
-    }
-    isBlockedResponse(response) {
-        if (!response.trim())
-            return false;
-        const patterns = [
-            /\bneed(s)?\s+(more\s+)?(info|information|details|clarification)\b/i,
-            /\bmissing\s+(api\s*key|credentials?|access|permission|token)\b/i,
-            /\b(no|not)\s+authorized\b/i,
-            /\b(i['\u2019]?m|i am|currently|still)\s+blocked\b/i,
-            /\bblocked\s+(on|by|due to|because of)\b/i,
-            /\bblocked\b.{0,40}\b(access|permission|token|credential|quota|limit)\b/i,
-            /\bcannot\s+(proceed|continue|start|run|access)\b/i,
-        ];
-        return patterns.some((pattern) => pattern.test(response));
-    }
-    /**
-     * Detects AI safety refusals - when the model declines to help with a request.
-     * These are terminal states that should not be retried.
-     */
-    isRefusalResponse(response) {
-        if (!response.trim())
-            return false;
-        const patterns = [
-            // Direct refusals
-            /\b(i\s+)?(can'?t|cannot|won'?t|will\s+not)\s+(help|assist|do\s+that|provide|comply|support)\b/i,
-            /\bi'?m\s+(not\s+able|unable)\s+to\s+(help|assist|do\s+that|provide)\b/i,
-            /\bi\s+(refuse|decline)\s+to\b/i,
-            /\bsorry[,.]?\s+(but\s+)?(i\s+)?(can'?t|cannot|won'?t|am\s+not\s+able)\b/i,
-            // Harmful/dangerous content refusals
-            /\b(harmful|dangerous|illegal|unethical|malicious|destructive)\s+(content|request|activity)\b/i,
-            /\bagainst\s+(my|the)\s+(guidelines|policies|principles|ethics)\b/i,
-            /\bviolates?\s+(my|the)?\s*(guidelines|policies|terms|safety)\b/i,
-            /\bnot\s+(designed|intended|programmed|able)\s+to\s+(help|assist)\s+with\b/i,
-            // Safety/ethics language
-            /\b(ethical|safety|responsible)\s+(concerns?|guidelines?|reasons?)\b/i,
-            /\bcould\s+(cause|lead\s+to)\s+(harm|damage|injury)\b/i,
-            // DeepSeek specific patterns
-            /\bI'm an AI assistant.{0,50}(cannot|won't|can't)\b/i,
-        ];
-        return patterns.some((pattern) => pattern.test(response));
-    }
-    wordCount(text) {
-        if (!text.trim())
-            return 0;
-        return text.trim().split(/\s+/).length;
-    }
-    /**
-     * Compute a simple fingerprint of a response for repetition detection.
-     * Normalizes whitespace and takes first N significant words to detect
-     * when the model is producing the same response repeatedly.
-     */
-    computeResponseFingerprint(response) {
-        if (!response?.trim())
-            return '';
-        // Normalize: lowercase, collapse whitespace, take first 200 chars
-        const normalized = response.toLowerCase().replace(/\s+/g, ' ').trim();
-        // Extract key content - skip common filler words
-        const words = normalized.split(' ')
-            .filter(w => w.length > 3)
-            .slice(0, 30);
-        return words.join(' ');
-    }
-    /**
-     * Detects when a response is sufficiently detailed to stand on its own,
-     * avoiding false "incomplete" flags for thorough answers without explicit
-     * completion markers.
-     */
-    hasSubstantiveAnswer(response, options) {
-        if (!response.trim())
-            return false;
-        if (options.planOnly || options.continuing || options.blocked || options.completionContradiction) {
-            return false;
-        }
-        const threshold = options.tookAction ? 80 : 120;
-        return options.wordCount >= threshold;
-    }
-    /**
-     * Early safety check for potentially harmful requests.
-     * Returns immediately with a helpful response instead of looping.
-     *
-     * This catches obvious cases before the model even processes them,
-     * preventing wasted compute and infinite "thinking" loops.
-     */
-    checkForHarmfulRequest(request) {
-        const lower = request.toLowerCase();
-        // Known major companies/services that should NEVER be attacked without explicit authorization
-        const protectedTargets = [
-            'google', 'microsoft', 'apple', 'amazon', 'meta', 'facebook',
-            'twitter', 'x.com', 'linkedin', 'github', 'gitlab', 'netflix',
-            'spotify', 'openai', 'anthropic', 'cloudflare', 'aws', 'azure',
-            'gcp', 'oracle', 'ibm', 'cisco', 'adobe', 'salesforce', 'slack',
-            'zoom', 'dropbox', 'paypal', 'stripe', 'visa', 'mastercard',
-        ];
-        // Action words that indicate malicious intent
-        const maliciousActions = [
-            'attack', 'hack', 'pwn', 'exploit', 'compromise', 'breach',
-            'ddos', 'dos', 'flood', 'crash', 'destroy', 'deface',
-            'steal', 'exfiltrate', 'dump', 'leak',
-        ];
-        // Check for combined patterns: malicious action + protected target
-        const hasMaliciousAction = maliciousActions.some(action => lower.includes(action));
-        const hasProtectedTarget = protectedTargets.some(target => lower.includes(target));
-        // Only trigger for clear cases of unauthorized attacks
-        if (hasMaliciousAction && hasProtectedTarget) {
-            // Check for legitimate contexts that override this
-            const legitimateContexts = [
-                'ctf', 'capture the flag', 'hackthebox', 'tryhackme',
-                'lab', 'sandbox', 'authorized', 'pentest', 'penetration test',
-                'bug bounty', 'scope', 'engagement', 'test environment',
-            ];
-            const hasLegitimateContext = legitimateContexts.some(ctx => lower.includes(ctx));
-            if (!hasLegitimateContext) {
-                return {
-                    isHarmful: true,
-                    response: `I can't help with unauthorized attacks against production systems or services.
-
-For legitimate security work, I can help with:
-• **CTF challenges** - Specify the CTF platform or challenge name
-• **Authorized pentests** - Share the scope document or confirm you have written authorization
-• **Bug bounty** - Confirm the target is in scope for a bug bounty program
-• **Lab environments** - Specify it's a personal lab, HackTheBox, TryHackMe, etc.
-• **Security research** - Describe the defensive or educational purpose
-
-What authorized security work can I help you with?`,
-                };
-            }
-        }
-        // Also catch generic "attack everything" requests without any target
-        if (hasMaliciousAction && !lower.includes('ctf') && !lower.includes('lab')) {
-            const veryGenericPatterns = [
-                /attack\s+(any|random|all)/i,
-                /hack\s+(into|the|any)/i,
-                /ddos\s+(the|any|all)/i,
-            ];
-            if (veryGenericPatterns.some(p => p.test(request))) {
-                return {
-                    isHarmful: true,
-                    response: `I need more context about what you're trying to accomplish.
-
-If this is for:
-• **CTF/Competition** - What platform or challenge?
-• **Learning** - What concept are you trying to understand?
-• **Authorized testing** - What's the scope and authorization?
-
-Please provide context so I can help appropriately.`,
-                };
-            }
-        }
-        return { isHarmful: false, response: '' };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // ATTACK CHAIN EXECUTION
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /**
-     * Detect if a request should trigger attack chain execution.
-     * Uses natural language parsing to identify security operation intents.
-     */
-    shouldExecuteAttackChain(request, mode = 'auto') {
-        if (mode === 'disabled') {
-            return { shouldExecute: false, intent: null };
-        }
-        if (mode === 'forced') {
-            const intent = parseNaturalLanguageIntent(request);
-            return { shouldExecute: true, intent };
-        }
-        // Auto mode: parse intent and check for security operations
-        const intent = parseNaturalLanguageIntent(request);
-        const securityActions = ['recon', 'scan', 'enumerate', 'exploit', 'extract', 'test', 'monitor'];
-        const isSecurityOp = securityActions.includes(intent.action);
-        const hasTargets = intent.targets.length > 0;
-        return {
-            shouldExecute: isSecurityOp && hasTargets,
-            intent: isSecurityOp ? intent : null,
-        };
-    }
-    /**
-     * Validate authorization context for attack chain execution.
-     * Ensures proper authorization before executing security techniques.
-     */
-    validateAttackAuthorization(intent, authContext) {
-        // Use the TAO authorization validator
-        const validation = validateAuthorizationContext(intent);
-        // Additional checks for protected targets
-        const protectedTargets = [
-            'google.com', 'microsoft.com', 'apple.com', 'amazon.com',
-            'facebook.com', 'twitter.com', 'github.com',
-        ];
-        const targetingProtected = intent.targets.some(t => protectedTargets.some(pt => t.toLowerCase().includes(pt)));
-        if (targetingProtected && !validation.valid) {
-            return {
-                authorized: false,
-                reason: 'Targeting protected production systems without explicit authorization',
-                warnings: [
-                    'Protected targets detected. Provide CTF/lab context or authorization scope.',
-                    ...validation.warnings,
-                ],
-            };
-        }
-        // Check for explicit authorization context
-        if (authContext) {
-            const authorizedContexts = ['ctf', 'lab', 'pentest', 'bug-bounty', 'authorized'];
-            const hasExplicitAuth = authorizedContexts.some(ctx => authContext.toLowerCase().includes(ctx));
-            if (hasExplicitAuth) {
-                return {
-                    authorized: true,
-                    reason: `Explicit authorization: ${authContext}`,
-                    warnings: validation.warnings,
-                };
-            }
-        }
-        return {
-            authorized: validation.valid,
-            reason: validation.type,
-            warnings: validation.warnings,
-        };
-    }
-    /**
-     * Execute an attack chain with TAO techniques.
-     * Returns results including all executed techniques and artifacts.
-     */
-    async executeAttackChain(request, options = {}) {
-        const intent = parseNaturalLanguageIntent(request);
-        const targets = options.targets ?? intent.targets;
-        // Normalize depth - map 'comprehensive' to 'deep'
-        const rawDepth = options.depth ?? intent.depth;
-        const depth = rawDepth === 'comprehensive' ? 'deep' : rawDepth;
-        const stealth = options.stealth ?? intent.constraints.includes('stealth');
-        // Validate authorization
-        const auth = this.validateAttackAuthorization(intent, options.authContext);
-        if (!auth.authorized) {
-            throw new Error(`Attack chain execution not authorized: ${auth.reason}`);
-        }
-        const executedTechniques = [];
-        const phasesCompleted = new Set();
-        const startTime = Date.now();
-        // Execute chain for each target
-        for (const target of targets) {
-            const chain = planAttackChain(intent, `Attack chain: ${target}`);
-            while (chain.state === 'planning' || chain.state === 'executing') {
-                const action = selectNextTechnique(chain);
-                if (!action)
-                    break;
-                const technique = techniqueRegistry.get(action.id);
-                if (!technique)
-                    continue;
-                const params = {
-                    target,
-                    depth,
-                    stealth,
-                    timeout: depth === 'deep' ? 60000 : depth === 'standard' ? 30000 : 10000,
-                    context: {
-                        chainId: chain.id,
-                        phase: technique.phase,
-                        previousArtifacts: executedTechniques
-                            .filter(t => t.success)
-                            .flatMap(t => t.artifacts),
-                    },
-                };
-                try {
-                    const { result } = await executeTechniqueInChain(chain, action, params);
-                    executedTechniques.push({
-                        id: technique.id,
-                        name: technique.name,
-                        phase: technique.phase,
-                        success: result.success,
-                        duration: result.duration,
-                        artifacts: result.artifacts,
-                    });
-                    if (result.success) {
-                        phasesCompleted.add(technique.phase);
-                    }
-                    options.onProgress?.(chain, technique.id, result);
-                }
-                catch (err) {
-                    // Log but continue chain execution
-                    executedTechniques.push({
-                        id: technique.id,
-                        name: technique.name,
-                        phase: technique.phase,
-                        success: false,
-                        duration: 0,
-                        artifacts: [{ type: 'error', data: String(err) }],
-                    });
-                }
-            }
-        }
-        const successCount = executedTechniques.filter(t => t.success).length;
-        return {
-            chain: planAttackChain(intent, request), // Return final chain state
-            techniques: executedTechniques,
-            totalDuration: Date.now() - startTime,
-            successRate: executedTechniques.length > 0
-                ? successCount / executedTechniques.length
-                : 0,
-            phasesCompleted: Array.from(phasesCompleted),
-        };
-    }
-    /**
-     * Run orchestration with optional attack chain integration.
-     * When attack chain mode is enabled, security operations are executed
-     * directly through TAO techniques rather than relying on LLM tool calls.
-     */
-    async runWithAttackChain(request, options = {}) {
-        const attackChainMode = options.attackChainMode ?? 'auto';
-        // Check if we should execute attack chain
-        const { shouldExecute, intent } = this.shouldExecuteAttackChain(request, attackChainMode);
-        if (!shouldExecute || !intent) {
-            // Fall back to normal orchestration
-            return this.runToCompletion(request, options);
-        }
-        // Validate authorization
-        const auth = this.validateAttackAuthorization(intent, options.authorizationContext);
-        if (!auth.authorized) {
-            return {
-                finalResponse: `Cannot execute security operation: ${auth.reason}\n\n${auth.warnings.join('\n')}`,
-                toolsUsed: [],
-                planOnly: false,
-                tookAction: false,
-                completion: {
-                    isComplete: true,
-                    confidence: 1.0,
-                    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.0,
-                    },
-                    reason: 'Authorization required',
-                    shouldVerify: false,
-                },
-                exitReason: 'attack-chain-aborted',
-                statusSummary: `Authorization required: ${auth.reason}`,
-                limitations: auth.warnings,
-                recommendations: [
-                    'Provide explicit authorization context (CTF, lab, pentest scope)',
-                    'Use --auth-context flag to specify authorization',
-                ],
-            };
-        }
-        // Execute attack chain
-        try {
-            // Normalize depth for attack chain
-            const attackRawDepth = options.attackDepth ?? intent.depth;
-            const attackDepth = attackRawDepth === 'comprehensive' ? 'deep' : attackRawDepth;
-            const chainResult = await this.executeAttackChain(request, {
-                targets: options.attackTargets ?? intent.targets,
-                depth: attackDepth,
-                stealth: options.stealthMode ?? intent.constraints.includes('stealth'),
-                authContext: options.authorizationContext,
-                onProgress: options.onAttackChainProgress,
-            });
-            // Build response summary
-            const summary = this.buildAttackChainSummary(chainResult);
-            return {
-                finalResponse: summary,
-                toolsUsed: chainResult.techniques.map(t => t.id),
-                planOnly: false,
-                tookAction: true,
-                completion: {
-                    isComplete: true,
-                    confidence: chainResult.successRate,
-                    signals: {
-                        hasExplicitCompletionStatement: true,
-                        hasIncompleteWorkIndicators: false,
-                        hasPendingActionIndicators: false,
-                        hasErrorIndicators: chainResult.successRate < 0.5,
-                        hasFollowUpQuestions: false,
-                        toolsUsedInLastResponse: chainResult.techniques.length,
-                        lastToolWasReadOnly: false,
-                        consecutiveResponsesWithoutTools: 0,
-                        hasRecentFileWrites: false,
-                        hasRecentCommits: false,
-                        todoItemsPending: 0,
-                        todoItemsCompleted: chainResult.techniques.length,
-                        mentionsFutureWork: false,
-                        completionConfidence: chainResult.successRate,
-                    },
-                    reason: 'Attack chain completed',
-                    shouldVerify: chainResult.successRate < 1.0,
-                },
-                exitReason: 'attack-chain-complete',
-                statusSummary: `Attack chain: ${chainResult.techniques.length} techniques, ${Math.round(chainResult.successRate * 100)}% success`,
-                limitations: [],
-                recommendations: chainResult.successRate < 1.0
-                    ? ['Review failed techniques and adjust approach']
-                    : [],
-                attackChainResult: chainResult,
-            };
-        }
-        catch (err) {
-            return {
-                finalResponse: `Attack chain execution failed: ${String(err)}`,
-                toolsUsed: [],
-                planOnly: false,
-                tookAction: false,
-                completion: {
-                    isComplete: true,
-                    confidence: 0,
-                    signals: {
-                        hasExplicitCompletionStatement: true,
-                        hasIncompleteWorkIndicators: false,
-                        hasPendingActionIndicators: false,
-                        hasErrorIndicators: true,
-                        hasFollowUpQuestions: false,
-                        toolsUsedInLastResponse: 0,
-                        lastToolWasReadOnly: false,
-                        consecutiveResponsesWithoutTools: 0,
-                        hasRecentFileWrites: false,
-                        hasRecentCommits: false,
-                        todoItemsPending: 0,
-                        todoItemsCompleted: 0,
-                        mentionsFutureWork: false,
-                        completionConfidence: 0,
-                    },
-                    reason: `Error: ${String(err)}`,
-                    shouldVerify: false,
-                },
-                exitReason: 'attack-chain-aborted',
-                statusSummary: `Attack chain failed: ${String(err)}`,
-                limitations: [String(err)],
-                recommendations: ['Check target connectivity', 'Verify authorization context'],
-            };
-        }
-    }
-    /**
-     * Build a human-readable summary of attack chain execution.
-     */
-    buildAttackChainSummary(result) {
-        const lines = [];
-        lines.push('## Attack Chain Execution Summary\n');
-        // Overall stats
-        lines.push(`**Duration:** ${Math.round(result.totalDuration / 1000)}s`);
-        lines.push(`**Success Rate:** ${Math.round(result.successRate * 100)}%`);
-        lines.push(`**Phases Completed:** ${result.phasesCompleted.join(', ')}\n`);
-        // Technique breakdown
-        lines.push('### Techniques Executed\n');
-        const byPhase = new Map();
-        for (const tech of result.techniques) {
-            const list = byPhase.get(tech.phase) || [];
-            list.push(tech);
-            byPhase.set(tech.phase, list);
-        }
-        for (const [phase, techniques] of byPhase) {
-            lines.push(`#### ${phase}`);
-            for (const tech of techniques) {
-                const status = tech.success ? '✓' : '✗';
-                lines.push(`- ${status} **${tech.name}** (${Math.round(tech.duration / 1000)}s)`);
-                if (tech.artifacts.length > 0) {
-                    lines.push(`  - Artifacts: ${tech.artifacts.length} collected`);
-                }
-            }
-            lines.push('');
-        }
-        // Artifacts summary
-        const allArtifacts = result.techniques.flatMap(t => t.artifacts);
-        if (allArtifacts.length > 0) {
-            lines.push('### Collected Artifacts\n');
-            const artifactsByType = new Map();
-            for (const artifact of allArtifacts) {
-                artifactsByType.set(artifact.type, (artifactsByType.get(artifact.type) || 0) + 1);
-            }
-            for (const [type, count] of artifactsByType) {
-                lines.push(`- **${type}:** ${count}`);
-            }
-        }
-        return lines.join('\n');
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // UNIFIED ORCHESTRATION - FULL STACK INTEGRATION
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /** Goal-to-technique mapping for goal-oriented execution */
-    goalTechniques = {
-        reconnaissance: [
-            'dns_enum', 'whois_recon', 'asn_lookup', 'subdomain_enum', 'dns_zone_transfer',
-            'ssl_analysis', 'ct_search', 'web_fingerprint', 'tech_fingerprint',
-            'cloud_detect', 's3_enum', 'gcs_enum', 'azure_enum', 'email_security',
-            'port_scan', 'service_enum', '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: [
-            'file_discovery', 'data_discovery', 'process_enum', 'cloud_enum',
-            'credential_harvest', 'git_analysis', 'api_surface_map',
-        ],
-        exfiltration: [
-            'data_staging', 'exfil', 'c2_beacon',
-        ],
-        impact: [
-            'service_disruption', 'resource_exhaustion', 'cleanup',
-        ],
-        stealth: [
-            'cleanup', 'process_enum', 'network_discovery',
-        ],
-        all: [], // Dynamically populated
-    };
-    /**
-     * Unified orchestration entry point.
-     * Routes to appropriate execution strategy based on mode and options.
-     *
-     * This is the primary method for full-stack unified orchestration that
-     * combines LLM-driven orchestration with direct TAO technique execution,
-     * infrastructure deployment, and goal-oriented APT simulation.
-     */
-    async runUnified(request, options = {}) {
-        const mode = options.unifiedMode || this.detectMode(request, options);
-        switch (mode) {
-            case 'attack-chain':
-                return this.runWithAttackChain(request, options);
-            case 'apt-simulation':
-                return this.runAPTSimulation(request, options);
-            case 'infrastructure':
-                return this.runInfrastructureMode(request, options);
-            case 'red-team':
-                return this.runRedTeamMode(request, options);
-            case 'intel-collection':
-                return this.runIntelCollectionMode(request, options);
-            case 'compliance':
-                return this.runComplianceMode(request, options);
-            case 'standard':
-            default:
-                // Check for full kill-chain mode
-                if (options.fullKillChain) {
-                    return this.runFullOffensiveChain(request, options);
-                }
-                // Check for goal-oriented execution
-                if (options.goal || options.goals) {
-                    return this.runGoalOriented(request, options);
-                }
-                return this.runToCompletion(request, options);
-        }
-    }
-    /**
-     * Auto-detect the appropriate orchestration mode from request content.
-     */
-    detectMode(request, options) {
-        const lower = request.toLowerCase();
-        // Check for explicit goals first
-        if (options.goal || options.goals) {
-            return 'attack-chain';
-        }
-        // Infrastructure keywords
-        if (lower.includes('infrastructure') || lower.includes('deploy') ||
-            lower.includes('c2 server') || lower.includes('redirector')) {
-            return 'infrastructure';
-        }
-        // Compliance keywords
-        if (lower.includes('compliance') || lower.includes('audit') ||
-            lower.includes('legal') || lower.includes('framework')) {
-            return 'compliance';
-        }
-        // Intel collection keywords
-        if (lower.includes('intelligence') || lower.includes('osint') ||
-            lower.includes('gather') || lower.includes('collect')) {
-            return 'intel-collection';
-        }
-        // Red team keywords
-        if (lower.includes('red team') || lower.includes('adversary') ||
-            lower.includes('full simulation')) {
-            return 'red-team';
-        }
-        // APT simulation keywords
-        if (lower.includes('apt') || lower.includes('kill chain') ||
-            lower.includes('kill-chain') || lower.includes('attack chain')) {
-            return 'apt-simulation';
-        }
-        // Security operation keywords (attack chain)
-        const securityKeywords = ['scan', 'recon', 'enumerate', 'exploit', 'pentest', 'hack'];
-        if (securityKeywords.some(kw => lower.includes(kw))) {
-            return 'attack-chain';
-        }
-        return 'standard';
-    }
-    /**
-     * Run full APT simulation with all kill-chain phases.
-     */
-    async runAPTSimulation(request, options) {
-        const startTime = Date.now();
-        const intent = parseNaturalLanguageIntent(request);
-        const targets = options.attackTargets ?? intent.targets;
-        const depth = this.normalizeDepth(options.attackDepth ?? intent.depth);
-        const stealth = options.stealthMode ?? intent.constraints.includes('stealth');
-        // Validate authorization
-        const auth = this.validateAttackAuthorization(intent, options.authorizationContext);
-        if (!auth.authorized) {
-            return this.buildAuthorizationError(auth);
-        }
-        const realExecutions = [];
-        const completedPhases = new Set();
-        const allArtifacts = [];
-        // APT Kill Chain Phases
-        const killChainPhases = [
-            'reconnaissance',
-            'weaponization',
-            'delivery',
-            'exploitation',
-            'installation',
-            'command-control',
-            'actions-on-objectives',
-        ];
-        // Execute techniques for each target
-        for (const target of targets) {
-            const chain = planAttackChain(intent, `APT Simulation: ${target}`);
-            for (const phase of killChainPhases) {
-                const phaseTechniques = techniqueRegistry.getByPhase(phase);
-                const techniqueLimit = depth === 'quick' ? 2 : depth === 'standard' ? 4 : phaseTechniques.length;
-                for (const technique of phaseTechniques.slice(0, techniqueLimit)) {
-                    if (stealth && technique.stealthRating < 0.3)
-                        continue;
-                    options.onTechniqueStart?.(technique.id, target);
-                    try {
-                        const result = await technique.execute({
-                            target,
-                            depth,
-                            stealth,
-                            timeout: depth === 'deep' ? 60000 : 30000,
-                            context: { chainId: chain.id, phase },
-                        });
-                        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);
-                        allArtifacts.push(...result.artifacts);
-                        options.onTechniqueComplete?.(execResult);
-                        if (result.success) {
-                            completedPhases.add(phase);
-                        }
-                        // Stealth abort if detection risk too high
-                        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: [],
-                        });
-                    }
-                }
-            }
-        }
-        const metrics = this.computeMetrics(realExecutions, startTime);
-        return {
-            finalResponse: this.buildExecutionSummary(realExecutions, metrics, 'APT Simulation'),
-            toolsUsed: realExecutions.map(r => `tao:${r.techniqueId}`),
-            planOnly: false,
-            tookAction: true,
-            completion: this.buildCompletionAnalysis(metrics),
-            exitReason: metrics.successfulTechniques > 0 ? 'attack-chain-complete' : 'attack-chain-aborted',
-            statusSummary: `APT: ${metrics.successfulTechniques}/${metrics.totalTechniquesExecuted} techniques`,
-            limitations: [],
-            recommendations: this.buildRecommendations(realExecutions),
-            realExecutions,
-            realMetrics: metrics,
-            attackChains: listActiveChains(),
-            attackChainPhases: Array.from(completedPhases),
-            collectedArtifacts: allArtifacts,
-        };
-    }
-    /**
-     * Run infrastructure deployment mode.
-     */
-    async runInfrastructureMode(request, options) {
-        const region = options.region || 'us';
-        const stack = getInfrastructureStack(region);
-        if (!stack) {
-            return {
-                finalResponse: `No infrastructure stack available for region: ${region}`,
-                toolsUsed: [],
-                planOnly: false,
-                tookAction: false,
-                completion: this.buildCompletionAnalysis({ totalTechniquesExecuted: 0, successfulTechniques: 0, failedTechniques: 0, totalDuration: 0, averageDetectionRisk: 0, phasesCompleted: [], artifactsCollected: 0, rlRewardAverage: 0 }),
-                exitReason: 'incomplete',
-                statusSummary: 'No infrastructure stack',
-                limitations: [`Region '${region}' not supported`],
-                recommendations: ['Use us or ukraine region'],
-            };
-        }
-        const deployScript = generateDeploymentScript(stack);
-        const teardownScript = generateTeardownScript(stack);
-        const opsecList = generateOpsecChecklist(stack);
-        options.onInfrastructure?.(stack);
-        return {
-            finalResponse: `## Infrastructure Stack: ${stack.name}\n\n` +
-                `**Region:** ${stack.region}\n` +
-                `**Components:** ${stack.components.length}\n` +
-                `**Persistence Mechanisms:** ${stack.persistence.length}\n` +
-                `**Monthly Cost:** $${stack.costEstimate.monthly}\n\n` +
-                `### Components\n${stack.components.map(c => `- ${c.name} (${c.type})`).join('\n')}\n\n` +
-                `### Deployment Script Generated\n### Teardown Script Generated\n### OPSEC Checklist Generated`,
-            toolsUsed: ['infrastructure-deploy', 'script-generator'],
-            planOnly: false,
-            tookAction: true,
-            completion: this.buildCompletionAnalysis({ totalTechniquesExecuted: 1, successfulTechniques: 1, failedTechniques: 0, totalDuration: 0, averageDetectionRisk: 0, phasesCompleted: [], artifactsCollected: 0, rlRewardAverage: 0 }),
-            exitReason: 'complete',
-            statusSummary: `Infrastructure: ${stack.components.length} components`,
-            limitations: [],
-            recommendations: ['Review OPSEC checklist before deployment'],
-            infrastructureStack: stack,
-            deploymentScript: deployScript,
-            teardownScript: teardownScript,
-            opsecChecklist: opsecList,
-        };
-    }
-    /**
-     * Run combined red team mode.
-     */
-    async runRedTeamMode(request, options) {
-        // Red team combines infrastructure + APT simulation
-        const infraResult = await this.runInfrastructureMode(request, options);
-        const aptResult = await this.runAPTSimulation(request, {
-            ...options,
-            attackDepth: 'deep',
-            stealthMode: true,
-        });
-        return {
-            ...aptResult,
-            finalResponse: `## Red Team Operation\n\n${infraResult.finalResponse}\n\n---\n\n${aptResult.finalResponse}`,
-            toolsUsed: [...infraResult.toolsUsed, ...aptResult.toolsUsed],
-            infrastructureStack: infraResult.infrastructureStack,
-            deploymentScript: infraResult.deploymentScript,
-            teardownScript: infraResult.teardownScript,
-            opsecChecklist: infraResult.opsecChecklist,
-            statusSummary: `Red Team: ${aptResult.realMetrics?.successfulTechniques || 0} techniques + ${infraResult.infrastructureStack?.components.length || 0} infra components`,
-        };
-    }
-    /**
-     * Run intelligence collection mode.
-     */
-    async runIntelCollectionMode(request, options) {
-        return this.runGoalOriented(request, {
-            ...options,
-            goals: ['reconnaissance', 'collection'],
-            collectIntel: true,
-            minimizeFootprint: true,
-        });
-    }
-    /**
-     * Run compliance mode with legal frameworks.
-     */
-    async runComplianceMode(request, options) {
-        const agencyTypes = options.agencyTypes || ['federal-le', 'regulatory'];
-        const contacts = agencyTypes.flatMap(at => getAgencyContacts(at));
-        const frameworks = getApplicableLegalFrameworks(agencyTypes);
-        const response = `## Compliance Analysis\n\n` +
-            `### Applicable Legal Frameworks\n` +
-            frameworks.map(f => `- **${f.name}** (${f.jurisdiction})\n  Requirements: ${f.requirements.length}`).join('\n') +
-            `\n\n### Agency Contacts\n` +
-            contacts.map(c => `- **${c.agency}** - ${c.division}\n  Contact: ${c.contact.email}`).join('\n');
-        return {
-            finalResponse: response,
-            toolsUsed: ['compliance-check'],
-            planOnly: false,
-            tookAction: true,
-            completion: this.buildCompletionAnalysis({ totalTechniquesExecuted: 1, successfulTechniques: 1, failedTechniques: 0, totalDuration: 0, averageDetectionRisk: 0, phasesCompleted: [], artifactsCollected: 0, rlRewardAverage: 0 }),
-            exitReason: 'complete',
-            statusSummary: `Compliance: ${frameworks.length} frameworks`,
-            limitations: [],
-            recommendations: frameworks.flatMap(f => f.requirements.map(r => r.requirement)),
-        };
-    }
-    /**
-     * Run goal-oriented APT execution.
-     */
-    async runGoalOriented(request, options) {
-        const startTime = Date.now();
-        const goals = options.goals || (options.goal ? [options.goal] : ['reconnaissance']);
-        const targets = options.attackTargets || [];
-        const depth = this.normalizeDepth(options.attackDepth ?? 'standard');
-        const stealth = options.stealthMode ?? options.minimizeFootprint ?? false;
-        // Build technique list from goals
-        let techniques = [];
-        for (const goal of goals) {
-            if (goal === 'all') {
-                techniques = techniqueRegistry.list().map(t => t.id);
-                break;
-            }
-            techniques.push(...(this.goalTechniques[goal] || []));
-        }
-        techniques = [...new Set(techniques)];
-        const realExecutions = [];
-        const achievedGoals = [];
-        const allArtifacts = [];
-        // Execute techniques
-        for (const target of targets) {
-            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 goal achievement
-                    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 persistence 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 metrics = this.computeMetrics(realExecutions, startTime);
-        return {
-            finalResponse: this.buildExecutionSummary(realExecutions, metrics, `Goal-Oriented: ${goals.join(', ')}`),
-            toolsUsed: realExecutions.map(r => r.techniqueId),
-            planOnly: false,
-            tookAction: true,
-            completion: this.buildCompletionAnalysis(metrics),
-            exitReason: metrics.successfulTechniques > 0 ? 'attack-chain-complete' : 'attack-chain-aborted',
-            statusSummary: `Goals: ${achievedGoals.length}/${goals.length} achieved`,
-            limitations: [],
-            recommendations: this.buildRecommendations(realExecutions),
-            realExecutions,
-            realMetrics: metrics,
-            attackChains: listActiveChains(),
-            achievedGoals,
-            collectedArtifacts: allArtifacts,
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // HELPER METHODS
-    // ═══════════════════════════════════════════════════════════════════════════════
-    normalizeDepth(depth) {
-        if (depth === 'quick' || depth === 'standard' || depth === 'deep') {
-            return depth;
-        }
-        return 'standard';
-    }
-    computeMetrics(executions, startTime) {
-        const successful = executions.filter(e => e.success).length;
-        const rlState = getRLState();
-        return {
-            totalTechniquesExecuted: executions.length,
-            successfulTechniques: successful,
-            failedTechniques: executions.length - successful,
-            totalDuration: Date.now() - startTime,
-            averageDetectionRisk: executions.length > 0
-                ? executions.reduce((s, e) => s + e.detectionRisk, 0) / executions.length
-                : 0,
-            phasesCompleted: [...new Set(executions.filter(e => e.success).map(e => e.phase))],
-            artifactsCollected: executions.reduce((s, e) => s + e.artifacts.length, 0),
-            rlRewardAverage: rlState.avgReward,
-        };
-    }
-    buildCompletionAnalysis(metrics) {
-        const confidence = metrics.totalTechniquesExecuted > 0
-            ? metrics.successfulTechniques / metrics.totalTechniquesExecuted
-            : 0;
-        return {
-            isComplete: true,
-            confidence,
-            signals: {
-                hasExplicitCompletionStatement: true,
-                hasIncompleteWorkIndicators: false,
-                hasPendingActionIndicators: false,
-                hasErrorIndicators: metrics.failedTechniques > metrics.successfulTechniques,
-                hasFollowUpQuestions: false,
-                toolsUsedInLastResponse: metrics.totalTechniquesExecuted,
-                lastToolWasReadOnly: false,
-                consecutiveResponsesWithoutTools: 0,
-                hasRecentFileWrites: false,
-                hasRecentCommits: false,
-                todoItemsPending: 0,
-                todoItemsCompleted: metrics.successfulTechniques,
-                mentionsFutureWork: false,
-                completionConfidence: confidence,
-            },
-            reason: 'Unified execution complete',
-            shouldVerify: confidence < 0.8,
-        };
-    }
-    buildAuthorizationError(auth) {
-        return {
-            finalResponse: `## Authorization Required\n\n${auth.reason}\n\n### Warnings\n${auth.warnings.map(w => `- ${w}`).join('\n')}`,
-            toolsUsed: [],
-            planOnly: false,
-            tookAction: false,
-            completion: {
-                isComplete: true,
-                confidence: 1.0,
-                signals: {
-                    hasExplicitCompletionStatement: true,
-                    hasIncompleteWorkIndicators: false,
-                    hasPendingActionIndicators: false,
-                    hasErrorIndicators: false,
-                    hasFollowUpQuestions: true,
-                    toolsUsedInLastResponse: 0,
-                    lastToolWasReadOnly: false,
-                    consecutiveResponsesWithoutTools: 0,
-                    hasRecentFileWrites: false,
-                    hasRecentCommits: false,
-                    todoItemsPending: 0,
-                    todoItemsCompleted: 0,
-                    mentionsFutureWork: false,
-                    completionConfidence: 1.0,
-                },
-                reason: 'Authorization required',
-                shouldVerify: false,
-            },
-            exitReason: 'attack-chain-aborted',
-            statusSummary: `Authorization required: ${auth.reason}`,
-            limitations: auth.warnings,
-            recommendations: [
-                'Provide CTF/lab context',
-                'Specify pentest authorization',
-                'Use --auth-context flag',
-            ],
-        };
-    }
-    buildExecutionSummary(executions, metrics, title) {
-        const lines = [];
-        lines.push(`## ${title} Execution Summary\n`);
-        lines.push(`**Total Techniques:** ${metrics.totalTechniquesExecuted}`);
-        lines.push(`**Successful:** ${metrics.successfulTechniques}`);
-        lines.push(`**Failed:** ${metrics.failedTechniques}`);
-        lines.push(`**Duration:** ${(metrics.totalDuration / 1000).toFixed(1)}s`);
-        lines.push(`**Detection Risk:** ${(metrics.averageDetectionRisk * 100).toFixed(1)}%`);
-        lines.push(`**Artifacts:** ${metrics.artifactsCollected}`);
-        lines.push(`**Phases:** ${metrics.phasesCompleted.join(', ') || 'none'}`);
-        lines.push('');
-        lines.push(`### Technique Results\n`);
-        for (const exec of executions) {
-            const status = exec.success ? '✓' : '✗';
-            lines.push(`**${status} ${exec.techniqueName}** (${exec.phase})`);
-            lines.push(`- Duration: ${exec.duration}ms`);
-            lines.push(`- Risk: ${(exec.detectionRisk * 100).toFixed(0)}%`);
-            if (exec.artifacts.length > 0) {
-                lines.push(`- Artifacts: ${exec.artifacts.length}`);
-            }
-            lines.push('');
-        }
-        return lines.join('\n');
-    }
-    buildRecommendations(executions) {
-        const recommendations = [];
-        const failed = executions.filter(e => !e.success);
-        if (failed.length > 0) {
-            recommendations.push(`Review ${failed.length} failed technique(s)`);
-        }
-        const highRisk = executions.filter(e => e.detectionRisk > 0.7);
-        if (highRisk.length > 0) {
-            recommendations.push(`${highRisk.length} technique(s) have high detection risk`);
-        }
-        const nextTechniques = [...new Set(executions.flatMap(e => e.nextTechniques))];
-        if (nextTechniques.length > 0) {
-            recommendations.push(`Consider: ${nextTechniques.slice(0, 5).join(', ')}`);
-        }
-        return recommendations;
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // FULL OFFENSIVE ATTACK CHAIN EXECUTION
-    // Direct integration with UnifiedAttackChain tool
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /** TAO tool suite instance for direct tool invocation */
-    taoTools = null;
-    /**
-     * Get or create the TAO tools instance.
-     */
-    getTaoTools() {
-        if (!this.taoTools) {
-            this.taoTools = createTaoTools(process.cwd());
-        }
-        return this.taoTools;
-    }
-    /**
-     * Execute full offensive attack chain using the UnifiedAttackChain tool.
-     * This integrates all 12 kill-chain phases with configurable stealth and objectives.
-     */
-    async executeFullAttackChain(targets, options = {}) {
-        const startTime = Date.now();
-        const chainId = `chain_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        // Validate authorization
-        const intent = parseNaturalLanguageIntent(`attack ${targets.join(' ')}`);
-        const auth = this.validateAttackAuthorization(intent, options.authorizationContext);
-        if (!auth.authorized) {
-            return this.buildAuthorizationError(auth);
-        }
-        const taoTools = this.getTaoTools();
-        const unifiedAttackChainTool = taoTools.tools.find(t => t.name === 'UnifiedAttackChain');
-        if (!unifiedAttackChainTool) {
-            return {
-                finalResponse: 'UnifiedAttackChain tool not available',
-                toolsUsed: [],
-                planOnly: false,
-                tookAction: false,
-                completion: this.buildCompletionAnalysis({
-                    totalTechniquesExecuted: 0,
-                    successfulTechniques: 0,
-                    failedTechniques: 0,
-                    totalDuration: 0,
-                    averageDetectionRisk: 0,
-                    phasesCompleted: [],
-                    artifactsCollected: 0,
-                    rlRewardAverage: 0,
-                }),
-                exitReason: 'attack-chain-aborted',
-                statusSummary: 'Tool unavailable',
-                limitations: ['UnifiedAttackChain tool not loaded'],
-                recommendations: ['Check TAO tools configuration'],
-            };
-        }
-        const result = {
-            chainId,
-            targets,
-            startTime,
-            endTime: 0,
-            duration: 0,
-            phases: [],
-            artifacts: [],
-            credentials: [],
-            persistence: [],
-            c2Channels: [],
-            exfilData: [],
-            detectionEvents: [],
-            overallSuccess: false,
-            successRate: 0,
-            stealthScore: 1.0,
-        };
-        const phasesToExecute = options.killChainPhases ?? KILL_CHAIN_PHASES;
-        const stealthLevel = options.stealthLevel ?? 'moderate';
-        const continueOnFailure = options.continueOnFailure ?? true;
-        let successfulPhases = 0;
-        let totalTechniques = 0;
-        let successfulTechniques = 0;
-        for (const phase of phasesToExecute) {
-            // Check time limit
-            if (options.chainTimeLimit) {
-                const elapsed = (Date.now() - startTime) / 1000;
-                if (elapsed >= options.chainTimeLimit) {
-                    result.detectionEvents.push({
-                        time: Date.now(),
-                        type: 'timeout',
-                        severity: 'info',
-                    });
-                    break;
-                }
-            }
-            try {
-                // Execute phase using UnifiedAttackChain tool
-                const phaseResult = await unifiedAttackChainTool.handler({
-                    operation: 'execute_phase',
-                    targets,
-                    phase,
-                    chain_id: chainId,
-                    depth: options.attackDepth ?? 'standard',
-                    stealth_level: stealthLevel,
-                    objectives: options.chainObjectives ?? [],
-                    constraints: options.operationalConstraints ?? [],
-                    c2_config: options.c2Config,
-                    exfil_config: options.exfilConfig,
-                });
-                const parsed = JSON.parse(phaseResult);
-                const phaseData = {
-                    phase,
-                    status: parsed.success ? 'success' : parsed.partial ? 'partial' : 'failed',
-                    techniques: parsed.techniques?.map((t) => ({
-                        id: t['id'],
-                        name: t['name'],
-                        success: t['success'],
-                        duration: t['duration'],
-                        risk: t['risk'],
-                        outputs: t['outputs'] ?? [],
-                    })) ?? [],
-                    outputs: parsed.outputs ?? [],
-                };
-                result.phases.push(phaseData);
-                // Collect artifacts
-                if (parsed.artifacts) {
-                    for (const artifact of parsed.artifacts) {
-                        result.artifacts.push({ ...artifact, phase });
-                    }
-                }
-                // Collect credentials
-                if (parsed.credentials) {
-                    result.credentials.push(...parsed.credentials);
-                }
-                // Collect persistence mechanisms
-                if (parsed.persistence) {
-                    result.persistence.push(...parsed.persistence);
-                }
-                // Collect C2 channels
-                if (parsed.c2_channels) {
-                    result.c2Channels.push(...parsed.c2_channels);
-                }
-                // Collect exfil data
-                if (parsed.exfil_data) {
-                    result.exfilData.push(...parsed.exfil_data);
-                }
-                // Update metrics
-                totalTechniques += phaseData.techniques.length;
-                successfulTechniques += phaseData.techniques.filter(t => t.success).length;
-                if (phaseData.status === 'success') {
-                    successfulPhases++;
-                }
-                // Update stealth score
-                const phaseRisk = phaseData.techniques.reduce((sum, t) => sum + t.risk, 0) /
-                    Math.max(1, phaseData.techniques.length);
-                result.stealthScore = Math.min(result.stealthScore, 1 - phaseRisk);
-                // Callback
-                options.onPhaseComplete?.(phase, phaseData.outputs);
-                // Check if we should continue
-                if (phaseData.status === 'failed' && !continueOnFailure) {
-                    result.detectionEvents.push({
-                        time: Date.now(),
-                        type: 'phase_failure',
-                        severity: 'high',
-                    });
-                    break;
-                }
-            }
-            catch (error) {
-                result.phases.push({
-                    phase,
-                    status: 'failed',
-                    techniques: [],
-                    outputs: [],
-                });
-                result.detectionEvents.push({
-                    time: Date.now(),
-                    type: 'execution_error',
-                    severity: 'critical',
-                });
-                if (!continueOnFailure)
-                    break;
-            }
-        }
-        // Finalize result
-        result.endTime = Date.now();
-        result.duration = result.endTime - result.startTime;
-        result.successRate = totalTechniques > 0 ? successfulTechniques / totalTechniques : 0;
-        result.overallSuccess = result.successRate >= 0.5 && successfulPhases >= phasesToExecute.length / 2;
-        // Callback
-        options.onChainComplete?.(result);
-        // Build response
-        const summary = this.buildFullAttackChainSummary(result);
-        return {
-            finalResponse: summary,
-            toolsUsed: result.phases.flatMap(p => p.techniques.map(t => `tao:${t.id}`)),
-            planOnly: false,
-            tookAction: true,
-            completion: this.buildCompletionAnalysis({
-                totalTechniquesExecuted: totalTechniques,
-                successfulTechniques,
-                failedTechniques: totalTechniques - successfulTechniques,
-                totalDuration: result.duration,
-                averageDetectionRisk: 1 - result.stealthScore,
-                phasesCompleted: result.phases.filter(p => p.status === 'success').map(p => p.phase),
-                artifactsCollected: result.artifacts.length,
-                rlRewardAverage: getRLState().avgReward,
-            }),
-            exitReason: result.overallSuccess ? 'attack-chain-complete' : 'attack-chain-aborted',
-            statusSummary: `Full Kill-Chain: ${successfulPhases}/${phasesToExecute.length} phases, ${Math.round(result.successRate * 100)}% success`,
-            limitations: result.phases.filter(p => p.status === 'failed').map(p => `Phase '${p.phase}' failed`),
-            recommendations: this.buildFullChainRecommendations(result),
-            fullAttackChainResult: result,
-            attackChains: listActiveChains(),
-        };
-    }
-    /**
-     * Build summary for full attack chain execution.
-     */
-    buildFullAttackChainSummary(result) {
-        const lines = [];
-        lines.push('## Full Kill-Chain Attack Summary\n');
-        lines.push(`**Chain ID:** ${result.chainId}`);
-        lines.push(`**Targets:** ${result.targets.join(', ')}`);
-        lines.push(`**Duration:** ${(result.duration / 1000).toFixed(1)}s`);
-        lines.push(`**Success Rate:** ${Math.round(result.successRate * 100)}%`);
-        lines.push(`**Stealth Score:** ${Math.round(result.stealthScore * 100)}%`);
-        lines.push('');
-        lines.push('### Phase Results\n');
-        for (const phase of result.phases) {
-            const statusIcon = phase.status === 'success' ? '✓' :
-                phase.status === 'partial' ? '◐' : '✗';
-            lines.push(`**${statusIcon} ${phase.phase.toUpperCase()}**`);
-            lines.push(`- Status: ${phase.status}`);
-            lines.push(`- Techniques: ${phase.techniques.filter(t => t.success).length}/${phase.techniques.length}`);
-            if (phase.outputs.length > 0) {
-                lines.push(`- Outputs: ${phase.outputs.join(', ')}`);
-            }
-            lines.push('');
-        }
-        if (result.credentials.length > 0) {
-            lines.push('### Credentials Harvested\n');
-            lines.push(`- **Total:** ${result.credentials.length}`);
-            const byType = new Map();
-            for (const cred of result.credentials) {
-                byType.set(cred.type, (byType.get(cred.type) || 0) + 1);
-            }
-            for (const [type, count] of byType) {
-                lines.push(`- ${type}: ${count}`);
-            }
-            lines.push('');
-        }
-        if (result.persistence.length > 0) {
-            lines.push('### Persistence Mechanisms\n');
-            for (const p of result.persistence) {
-                lines.push(`- **${p.mechanism}:** ${p.status}`);
-            }
-            lines.push('');
-        }
-        if (result.c2Channels.length > 0) {
-            lines.push('### C2 Channels\n');
-            for (const c2 of result.c2Channels) {
-                lines.push(`- **${c2.type}:** ${c2.status}`);
-            }
-            lines.push('');
-        }
-        if (result.exfilData.length > 0) {
-            lines.push('### Exfiltrated Data\n');
-            const totalSize = result.exfilData.reduce((sum, e) => sum + e.size, 0);
-            lines.push(`- **Total:** ${result.exfilData.length} items, ${(totalSize / 1024).toFixed(1)} KB`);
-            lines.push('');
-        }
-        if (result.artifacts.length > 0) {
-            lines.push('### Artifacts Collected\n');
-            const byPhase = new Map();
-            for (const a of result.artifacts) {
-                byPhase.set(a.phase, (byPhase.get(a.phase) || 0) + 1);
-            }
-            for (const [phase, count] of byPhase) {
-                lines.push(`- ${phase}: ${count}`);
-            }
-            lines.push('');
-        }
-        if (result.detectionEvents.length > 0) {
-            lines.push('### Detection Events\n');
-            for (const event of result.detectionEvents) {
-                lines.push(`- **${event.severity.toUpperCase()}:** ${event.type}`);
-            }
-            lines.push('');
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Build recommendations for full chain execution.
-     */
-    buildFullChainRecommendations(result) {
-        const recommendations = [];
-        const failedPhases = result.phases.filter(p => p.status === 'failed');
-        if (failedPhases.length > 0) {
-            recommendations.push(`Review failed phases: ${failedPhases.map(p => p.phase).join(', ')}`);
-        }
-        if (result.stealthScore < 0.5) {
-            recommendations.push('High detection risk detected - consider more stealthy techniques');
-        }
-        if (result.credentials.length === 0 && result.phases.some(p => p.phase === 'credential_access')) {
-            recommendations.push('No credentials harvested - try alternative credential techniques');
-        }
-        if (result.persistence.length === 0 && result.phases.some(p => p.phase === 'persistence')) {
-            recommendations.push('No persistence established - critical for long-term access');
-        }
-        if (result.c2Channels.length === 0 && result.phases.some(p => p.phase === 'command_control')) {
-            recommendations.push('No C2 channels established - consider fallback C2 options');
-        }
-        return recommendations;
-    }
-    /**
-     * Run full offensive attack chain mode.
-     * This is the main entry point for full kill-chain operations.
-     */
-    async runFullOffensiveChain(request, options = {}) {
-        // Parse targets from request
-        const intent = parseNaturalLanguageIntent(request);
-        const targets = options.attackTargets ?? intent.targets;
-        if (targets.length === 0) {
-            return {
-                finalResponse: 'No targets specified for attack chain',
-                toolsUsed: [],
-                planOnly: false,
-                tookAction: false,
-                completion: this.buildCompletionAnalysis({
-                    totalTechniquesExecuted: 0,
-                    successfulTechniques: 0,
-                    failedTechniques: 0,
-                    totalDuration: 0,
-                    averageDetectionRisk: 0,
-                    phasesCompleted: [],
-                    artifactsCollected: 0,
-                    rlRewardAverage: 0,
-                }),
-                exitReason: 'incomplete',
-                statusSummary: 'No targets',
-                limitations: ['No targets provided'],
-                recommendations: ['Specify targets using --targets or in the request'],
-            };
-        }
-        return this.executeFullAttackChain(targets, options);
-    }
-}
-//# sourceMappingURL=agentOrchestrator.js.map