erosolar-cli 2.1.247 → 2.1.249

package/dist/capabilities/orchestrationCapability.js

@@ -5,14 +5,596 @@
  * - Government procedures (law enforcement, compliance)
  * - Infrastructure deployment (US, Ukraine, EU, Asia)
  * - Security deliverables (pentest reports, incident response)
- * - APT chain execution (kill-chain phases)
- * - Dual-RL refinement (self-improving execution)
+ * - Validation & error analysis (TypeScript, build, test, lint)
+ * - Hypothesis testing & failure recovery
+ * - Result verification (prevents hallucinated success)
  */
+// ============================================================================
+// TYPES - Error Analysis & Validation (from aiErrorFixer.ts, validationRunner.ts)
+// ============================================================================
+export var ErrorType;
+(function (ErrorType) {
+    ErrorType["BUILD_ERROR"] = "build_error";
+    ErrorType["TEST_FAILURE"] = "test_failure";
+    ErrorType["TYPE_ERROR"] = "type_error";
+    ErrorType["LINT_ERROR"] = "lint_error";
+    ErrorType["IMPORT_ERROR"] = "import_error";
+    ErrorType["SYNTAX_ERROR"] = "syntax_error";
+    ErrorType["FILE_NOT_FOUND"] = "file_not_found";
+    ErrorType["PERMISSION_ERROR"] = "permission_error";
+    ErrorType["EDIT_CONFLICT"] = "edit_conflict";
+    ErrorType["NEWLINE_IN_STRING"] = "newline_in_string";
+    ErrorType["UNKNOWN"] = "unknown";
+})(ErrorType || (ErrorType = {}));
+// ============================================================================
+// ERROR PATTERNS
+// ============================================================================
+const TS_ERROR_PATTERN = /([^\s:]+\.tsx?):(\d+):(\d+)\s*-\s*error\s+TS(\d+):\s*(.+)/gm;
+const NPM_DEP_PATTERN = /(?:Cannot find|Module not found).*['"]([^'"]+)['"]/gm;
+const TEST_FAIL_PATTERN = /FAIL\s+([^\n]+)/gm;
+const FAILURE_INDICATORS = {
+    build: [/error\s+TS\d+/i, /SyntaxError/i, /Cannot find module/i, /error:\s+/i, /failed with exit code/i, /npm ERR!/i],
+    test: [/FAIL\s+/, /AssertionError/i, /Expected.*but got/i, /\d+ failing/i, /Error: expect/i],
+    runtime: [/TypeError:/i, /ReferenceError:/i, /RangeError:/i, /Uncaught/i, /ENOENT/i, /EACCES/i, /ETIMEDOUT/i],
+    userFeedback: [/doesn't work/i, /didn't work/i, /not working/i, /still broken/i, /wrong/i, /incorrect/i, /try again/i, /failed/i],
+};
+const OUTPUT_PATTERNS = {
+    git: {
+        success: [/\[.+\s+\w+\]/, /pushed/i, /merged/i, /On branch/i, /nothing to commit/i, /Already up to date/i],
+        failure: [/fatal:/i, /error:/i, /conflict/i, /rejected/i, /CONFLICT/, /Aborting/i],
+    },
+    npm: {
+        success: [/npm notice/i, /\+ .+@\d+\.\d+\.\d+/, /published/i],
+        failure: [/npm ERR!/i, /ERESOLVE/i, /E404/i, /EINTEGRITY/i],
+    },
+    command: {
+        success: [/^(success|completed|done|finished)/im, /successfully/i],
+        failure: [/^error/im, /^fatal/im, /failed/i, /command not found/i, /permission denied/i, /ENOENT/i, /EACCES/i],
+    },
+};
+// ============================================================================
+// ERROR ANALYSIS CLASS (from aiErrorFixer.ts)
+// ============================================================================
+class ErrorAnalyzer {
+    analyzeOutput(output, command) {
+        const errors = [];
+        const outputType = this.detectOutputType(output, command);
+        if (outputType === 'typescript')
+            errors.push(...this.parseTypeScriptErrors(output));
+        else if (outputType === 'npm')
+            errors.push(...this.parseNpmErrors(output));
+        else if (outputType === 'test')
+            errors.push(...this.parseTestErrors(output));
+        else
+            errors.push(...this.parseGenericErrors(output));
+        for (const error of errors) {
+            error.suggestedFixes = this.generateFixes(error);
+        }
+        return errors;
+    }
+    formatForAI(errors) {
+        if (errors.length === 0)
+            return '';
+        const lines = ['', '═══ AI ERROR ANALYSIS ═══', ''];
+        for (let i = 0; i < Math.min(errors.length, 5); i++) {
+            const error = errors[i];
+            if (!error)
+                continue;
+            lines.push(`• ${error.errorType.toUpperCase()}: ${error.message.slice(0, 150)}`);
+            const loc = error.locations[0];
+            if (loc)
+                lines.push(`  at ${loc.filePath}:${loc.lineNumber ?? '?'}`);
+            const bestFix = error.suggestedFixes[0];
+            if (bestFix)
+                lines.push(`  FIX: ${bestFix.description}`);
+            lines.push('');
+        }
+        if (errors.length > 5)
+            lines.push(`... and ${errors.length - 5} more errors`);
+        return lines.join('\n');
+    }
+    detectOutputType(output, command) {
+        const outputLower = output.toLowerCase();
+        const commandLower = (command ?? '').toLowerCase();
+        if (commandLower.includes('tsc') || commandLower.includes('typescript'))
+            return 'typescript';
+        if (commandLower.includes('test') || commandLower.includes('jest'))
+            return 'test';
+        if (commandLower.includes('npm') || commandLower.includes('yarn'))
+            return 'npm';
+        if (outputLower.includes('error ts') || output.includes('.ts:'))
+            return 'typescript';
+        if (outputLower.includes('npm err!'))
+            return 'npm';
+        return 'generic';
+    }
+    parseTypeScriptErrors(output) {
+        const errors = [];
+        const regex = new RegExp(TS_ERROR_PATTERN.source, 'gm');
+        let match;
+        while ((match = regex.exec(output)) !== null) {
+            const [, file, line, col, code, msg] = match;
+            if (!file || !code || !msg)
+                continue;
+            errors.push({
+                errorType: ErrorType.TYPE_ERROR,
+                message: `TS${code}: ${msg}`,
+                rawOutput: match[0],
+                locations: [{ filePath: file, lineNumber: line ? parseInt(line, 10) : undefined, column: col ? parseInt(col, 10) : undefined }],
+                suggestedFixes: [],
+                relatedErrors: [],
+                metadata: { tsCode: code },
+            });
+        }
+        return errors;
+    }
+    parseNpmErrors(output) {
+        const errors = [];
+        const regex = new RegExp(NPM_DEP_PATTERN.source, 'gm');
+        let match;
+        while ((match = regex.exec(output)) !== null) {
+            const [, dep] = match;
+            if (!dep)
+                continue;
+            errors.push({
+                errorType: ErrorType.IMPORT_ERROR,
+                message: `Missing dependency: ${dep}`,
+                rawOutput: match[0],
+                locations: [],
+                suggestedFixes: [],
+                relatedErrors: [],
+                metadata: { missingDep: dep },
+            });
+        }
+        return errors;
+    }
+    parseTestErrors(output) {
+        const errors = [];
+        const regex = new RegExp(TEST_FAIL_PATTERN.source, 'gm');
+        let match;
+        while ((match = regex.exec(output)) !== null) {
+            const [, file] = match;
+            if (!file)
+                continue;
+            errors.push({
+                errorType: ErrorType.TEST_FAILURE,
+                message: `Test failed: ${file}`,
+                rawOutput: match[0],
+                locations: [{ filePath: file.trim() }],
+                suggestedFixes: [],
+                relatedErrors: [],
+                metadata: {},
+            });
+        }
+        return errors;
+    }
+    parseGenericErrors(output) {
+        const errors = [];
+        const errorLines = [];
+        for (const line of output.split('\n')) {
+            const lineLower = line.toLowerCase();
+            if (lineLower.includes('error:') || lineLower.includes('failed:') || lineLower.includes('exception:') || lineLower.includes('fatal:')) {
+                errorLines.push(line.trim());
+            }
+        }
+        if (errorLines.length > 0 && errorLines[0]) {
+            errors.push({
+                errorType: ErrorType.UNKNOWN,
+                message: errorLines[0].slice(0, 200),
+                rawOutput: errorLines.slice(0, 5).join('\n'),
+                locations: [],
+                suggestedFixes: [],
+                relatedErrors: errorLines.slice(1, 5),
+                metadata: {},
+            });
+        }
+        return errors;
+    }
+    generateFixes(error) {
+        const fixes = [];
+        const loc = error.locations[0];
+        if (error.errorType === ErrorType.TYPE_ERROR && loc) {
+            const tsCode = String(error.metadata['tsCode'] ?? '');
+            if (tsCode === '2304') {
+                const nameMatch = error.message.match(/Cannot find name '([^']+)'/);
+                if (nameMatch?.[1]) {
+                    fixes.push({
+                        description: `Add import for '${nameMatch[1]}'`,
+                        filePath: loc.filePath,
+                        oldContent: '',
+                        newContent: `import { ${nameMatch[1]} } from './${nameMatch[1]}';`,
+                        confidence: 0.6,
+                        autoApplicable: false,
+                        requiresConfirmation: true,
+                    });
+                }
+            }
+            if (tsCode === '6133') {
+                const varMatch = error.message.match(/'([^']+)' is declared but/);
+                if (varMatch?.[1]) {
+                    fixes.push({
+                        description: `Prefix '${varMatch[1]}' with underscore`,
+                        filePath: loc.filePath,
+                        oldContent: varMatch[1],
+                        newContent: `_${varMatch[1]}`,
+                        confidence: 0.8,
+                        autoApplicable: true,
+                        requiresConfirmation: false,
+                    });
+                }
+            }
+        }
+        if (error.errorType === ErrorType.IMPORT_ERROR) {
+            const missingDep = String(error.metadata['missingDep'] ?? '');
+            if (missingDep) {
+                fixes.push({
+                    description: `Install: npm install ${missingDep}`,
+                    filePath: 'package.json',
+                    oldContent: '',
+                    newContent: '',
+                    confidence: 0.9,
+                    autoApplicable: false,
+                    requiresConfirmation: true,
+                });
+            }
+        }
+        return fixes;
+    }
+}
+// ============================================================================
+// HYPOTHESIS ENGINE (from hypothesisEngine.ts)
+// ============================================================================
+class HypothesisEngine {
+    hypotheses = new Map();
+    maxHypotheses;
+    constructor(maxHypotheses = 5) {
+        this.maxHypotheses = maxHypotheses;
+    }
+    generateHypothesis(description, initialEvidence = []) {
+        const id = `hyp_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        const hypothesis = {
+            id,
+            description,
+            confidence: this.calculateConfidence(initialEvidence),
+            evidence: initialEvidence,
+            status: 'pending',
+        };
+        this.hypotheses.set(id, hypothesis);
+        this.pruneHypotheses();
+        return hypothesis;
+    }
+    addEvidence(hypothesisId, evidence) {
+        const hypothesis = this.hypotheses.get(hypothesisId);
+        if (!hypothesis)
+            throw new Error(`Hypothesis ${hypothesisId} not found`);
+        hypothesis.evidence.push(evidence);
+        hypothesis.confidence = this.calculateConfidence(hypothesis.evidence);
+    }
+    getBestHypothesis() {
+        let best = null;
+        let highestConfidence = -Infinity;
+        for (const hypothesis of this.hypotheses.values()) {
+            if (hypothesis.status !== 'rejected' && hypothesis.confidence > highestConfidence) {
+                highestConfidence = hypothesis.confidence;
+                best = hypothesis;
+            }
+        }
+        return best;
+    }
+    getAllHypotheses() {
+        return Array.from(this.hypotheses.values()).sort((a, b) => b.confidence - a.confidence);
+    }
+    clear() {
+        this.hypotheses.clear();
+    }
+    calculateConfidence(evidence) {
+        if (evidence.length === 0)
+            return 0.5;
+        const totalWeight = evidence.reduce((sum, e) => sum + Math.abs(e.weight), 0);
+        if (totalWeight === 0)
+            return 0.5;
+        const weightedSum = evidence.reduce((sum, e) => sum + e.weight, 0);
+        return Math.max(0, Math.min(1, 0.5 + (weightedSum / totalWeight) * 0.5));
+    }
+    pruneHypotheses() {
+        if (this.hypotheses.size <= this.maxHypotheses)
+            return;
+        const sorted = Array.from(this.hypotheses.entries()).sort(([, a], [, b]) => a.confidence - b.confidence);
+        const lowest = sorted[0];
+        if (lowest)
+            this.hypotheses.delete(lowest[0]);
+    }
+}
+// ============================================================================
+// FAILURE DETECTION (from failureRecovery.ts)
+// ============================================================================
+function detectFailure(output, context) {
+    for (const pattern of FAILURE_INDICATORS.build) {
+        if (pattern.test(output)) {
+            return { type: 'build', severity: 'critical', message: extractErrorMessage(output, pattern), timestamp: new Date().toISOString() };
+        }
+    }
+    for (const pattern of FAILURE_INDICATORS.test) {
+        if (pattern.test(output)) {
+            return { type: 'test', severity: 'major', message: extractErrorMessage(output, pattern), timestamp: new Date().toISOString() };
+        }
+    }
+    for (const pattern of FAILURE_INDICATORS.runtime) {
+        if (pattern.test(output)) {
+            return { type: 'tool', severity: 'major', message: extractErrorMessage(output, pattern), timestamp: new Date().toISOString() };
+        }
+    }
+    if (context.userMessage) {
+        for (const pattern of FAILURE_INDICATORS.userFeedback) {
+            if (pattern.test(context.userMessage)) {
+                return { type: 'user-feedback', severity: 'major', message: context.userMessage.slice(0, 200), timestamp: new Date().toISOString() };
+            }
+        }
+    }
+    return null;
+}
+function extractErrorMessage(output, pattern) {
+    const match = output.match(pattern);
+    if (!match)
+        return 'Unknown error';
+    const lines = output.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        if (pattern.test(lines[i])) {
+            return lines.slice(i, Math.min(lines.length, i + 3)).join('\n').slice(0, 300);
+        }
+    }
+    return match[0].slice(0, 200);
+}
+// ============================================================================
+// RESULT VERIFICATION (from resultVerification.ts)
+// ============================================================================
+function formatVerifiedResult(result) {
+    if (result.status === 'VERIFIED_SUCCESS')
+        return result.details || result.summary;
+    const lines = [];
+    switch (result.status) {
+        case 'VERIFIED_FAILURE':
+            lines.push('═══ FAILED ═══');
+            break;
+        case 'UNVERIFIED':
+            lines.push('═══ UNVERIFIED ═══');
+            break;
+        case 'PARTIAL_SUCCESS':
+            lines.push('═══ PARTIAL SUCCESS ═══');
+            break;
+        case 'REQUIRES_USER_ACTION':
+            lines.push('═══ ACTION REQUIRED ═══');
+            break;
+    }
+    lines.push('', result.summary, '');
+    if (result.verificationChecks) {
+        const failedChecks = result.verificationChecks.filter(c => !c.passed);
+        if (failedChecks.length > 0) {
+            lines.push('Failed checks:');
+            for (const check of failedChecks) {
+                lines.push(`  ✗ ${check.check}${check.details ? `: ${check.details}` : ''}`);
+            }
+            lines.push('');
+        }
+    }
+    if (result.details)
+        lines.push(result.details, '');
+    if (result.suggestedActions?.length) {
+        lines.push('Suggested actions:');
+        for (const action of result.suggestedActions)
+            lines.push(`  → ${action}`);
+    }
+    return lines.join('\n');
+}
+function analyzeOutput(output, patterns, exitCode) {
+    const normalizedOutput = output.normalize('NFC');
+    for (const pattern of patterns.failure) {
+        if (pattern.test(normalizedOutput))
+            return { isSuccess: false, isFailure: true, confidence: 'high' };
+    }
+    for (const pattern of patterns.success) {
+        if (pattern.test(normalizedOutput))
+            return { isSuccess: true, isFailure: false, confidence: 'high' };
+    }
+    if (exitCode !== undefined) {
+        if (exitCode !== 0)
+            return { isSuccess: false, isFailure: true, confidence: 'high' };
+        return { isSuccess: false, isFailure: false, confidence: 'low' };
+    }
+    return { isSuccess: false, isFailure: false, confidence: 'low' };
+}
+// ============================================================================
+// TOOL CREATION
+// ============================================================================
 function createOrchestrationTools(options = {}) {
     const enableAll = !options.enableGovernment && !options.enableInfrastructure &&
-        !options.enableSecurity && !options.enableAPT;
+        !options.enableSecurity && !options.enableAPT &&
+        !options.enableValidation && !options.enableHypothesis && !options.enableRecovery;
     const tools = [];
-    // Government procedures tool
+    // ====== VALIDATION & ERROR ANALYSIS TOOL ======
+    if (enableAll || options.enableValidation) {
+        const errorAnalyzer = new ErrorAnalyzer();
+        tools.push({
+            name: 'analyze_errors',
+            description: `Analyze command output for errors and generate fix suggestions.
+
+Capabilities:
+- Parse TypeScript, npm, test, and generic errors
+- Extract error locations (file, line, column)
+- Generate confidence-scored fix suggestions
+- Format errors for AI consumption`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    output: { type: 'string', description: 'Command output to analyze' },
+                    command: { type: 'string', description: 'Command that produced the output (for context)' },
+                    format: { type: 'string', enum: ['detailed', 'ai', 'summary'], description: 'Output format' },
+                },
+                required: ['output'],
+            },
+            async handler(params) {
+                const output = params['output'];
+                const command = params['command'];
+                const format = params['format'] || 'detailed';
+                const errors = errorAnalyzer.analyzeOutput(output, command);
+                if (format === 'ai') {
+                    return errorAnalyzer.formatForAI(errors);
+                }
+                else if (format === 'summary') {
+                    return `Found ${errors.length} error(s):\n` +
+                        errors.slice(0, 5).map(e => `• ${e.errorType}: ${e.message.slice(0, 80)}`).join('\n');
+                }
+                return JSON.stringify(errors, null, 2);
+            },
+        });
+        tools.push({
+            name: 'verify_result',
+            description: `Verify operation results to prevent hallucinated success.
+
+Checks:
+- Pattern matching against known success/failure indicators
+- Exit code analysis
+- Unicode normalization to prevent spoofing
+- Negative context detection`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    output: { type: 'string', description: 'Operation output to verify' },
+                    operation: { type: 'string', enum: ['git', 'npm', 'command'], description: 'Type of operation' },
+                    exitCode: { type: 'number', description: 'Exit code if available' },
+                },
+                required: ['output', 'operation'],
+            },
+            async handler(params) {
+                const output = params['output'];
+                const operation = params['operation'];
+                const exitCode = params['exitCode'];
+                const patterns = OUTPUT_PATTERNS[operation] || OUTPUT_PATTERNS.command;
+                const analysis = analyzeOutput(output, patterns, exitCode);
+                const result = {
+                    status: analysis.isSuccess ? 'VERIFIED_SUCCESS' :
+                        analysis.isFailure ? 'VERIFIED_FAILURE' : 'UNVERIFIED',
+                    summary: analysis.isSuccess ? 'Operation succeeded' :
+                        analysis.isFailure ? 'Operation failed' : 'Cannot verify outcome',
+                    details: output.slice(0, 500),
+                    verifiedAt: new Date().toISOString(),
+                };
+                return formatVerifiedResult(result);
+            },
+        });
+    }
+    // ====== HYPOTHESIS TESTING TOOL ======
+    if (enableAll || options.enableHypothesis) {
+        const hypothesisEngine = new HypothesisEngine(10);
+        tools.push({
+            name: 'hypothesis',
+            description: `Multi-hypothesis reasoning for bug analysis and problem solving.
+
+Operations:
+- generate: Create a new hypothesis with initial evidence
+- add_evidence: Add supporting/contradicting evidence
+- get_best: Get highest-confidence hypothesis
+- list_all: List all hypotheses sorted by confidence
+- clear: Reset all hypotheses`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: { type: 'string', enum: ['generate', 'add_evidence', 'get_best', 'list_all', 'clear'] },
+                    description: { type: 'string', description: 'Hypothesis description (for generate)' },
+                    hypothesisId: { type: 'string', description: 'Hypothesis ID (for add_evidence)' },
+                    evidence: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', enum: ['observation', 'data', 'test_result', 'user_feedback'] },
+                            content: { type: 'string' },
+                            weight: { type: 'number', description: '-1 to 1, positive supports, negative contradicts' },
+                        },
+                    },
+                },
+                required: ['action'],
+            },
+            async handler(params) {
+                const action = params['action'];
+                switch (action) {
+                    case 'generate': {
+                        const description = params['description'];
+                        if (!description)
+                            return 'Error: description required';
+                        const hypothesis = hypothesisEngine.generateHypothesis(description);
+                        return JSON.stringify(hypothesis, null, 2);
+                    }
+                    case 'add_evidence': {
+                        const id = params['hypothesisId'];
+                        const evidenceData = params['evidence'];
+                        if (!id || !evidenceData)
+                            return 'Error: hypothesisId and evidence required';
+                        const evidence = {
+                            type: evidenceData.type,
+                            content: evidenceData.content,
+                            weight: evidenceData.weight,
+                            timestamp: new Date(),
+                        };
+                        hypothesisEngine.addEvidence(id, evidence);
+                        return `Evidence added to hypothesis ${id}`;
+                    }
+                    case 'get_best': {
+                        const best = hypothesisEngine.getBestHypothesis();
+                        return best ? JSON.stringify(best, null, 2) : 'No hypotheses available';
+                    }
+                    case 'list_all': {
+                        const all = hypothesisEngine.getAllHypotheses();
+                        return JSON.stringify(all, null, 2);
+                    }
+                    case 'clear': {
+                        hypothesisEngine.clear();
+                        return 'All hypotheses cleared';
+                    }
+                    default:
+                        return `Unknown action: ${action}`;
+                }
+            },
+        });
+    }
+    // ====== FAILURE DETECTION & RECOVERY TOOL ======
+    if (enableAll || options.enableRecovery) {
+        tools.push({
+            name: 'detect_failure',
+            description: `Detect failures in output and suggest recovery strategies.
+
+Detects:
+- Build failures (TypeScript, syntax, module errors)
+- Test failures (Jest, assertion errors)
+- Runtime errors (TypeError, ReferenceError, etc.)
+- User feedback indicating failure`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    output: { type: 'string', description: 'Output to analyze for failures' },
+                    userMessage: { type: 'string', description: 'User message (for feedback detection)' },
+                },
+                required: ['output'],
+            },
+            async handler(params) {
+                const output = params['output'];
+                const userMessage = params['userMessage'];
+                const failure = detectFailure(output, { userMessage });
+                if (!failure) {
+                    return JSON.stringify({ detected: false, message: 'No failure detected' });
+                }
+                return JSON.stringify({
+                    detected: true,
+                    failure,
+                    suggestedRecovery: [
+                        `Identify root cause of ${failure.type} failure`,
+                        'Review the error message for specific guidance',
+                        'Check for similar patterns in codebase',
+                        'Consider alternative approaches if current fails repeatedly',
+                    ],
+                }, null, 2);
+            },
+        });
+    }
+    // ====== GOVERNMENT PROCEDURES TOOL ======
     if (enableAll || options.enableGovernment) {
         tools.push({
             name: 'gov_procedures',
@@ -29,29 +611,14 @@ Provides:
                 properties: {
                     action: {
                         type: 'string',
-                        enum: [
-                            'get_contacts', 'get_legal_frameworks', 'get_reporting_requirements',
-                            'generate_incident_report', 'generate_evidence_form',
-                        ],
-                        description: 'Action to perform',
+                        enum: ['get_contacts', 'get_legal_frameworks', 'get_reporting_requirements', 'generate_incident_report', 'generate_evidence_form'],
                     },
                     agencyType: {
                         type: 'string',
-                        enum: [
-                            'federal-le', 'state-le', 'local-le', 'intelligence',
-                            'military', 'regulatory', 'international', 'cisa', 'nist', 'contractor',
-                        ],
-                        description: 'Type of agency',
-                    },
-                    incidentType: {
-                        type: 'string',
-                        description: 'Type of incident for reporting',
-                    },
-                    classification: {
-                        type: 'string',
-                        enum: ['unclassified', 'cui', 'confidential', 'secret', 'top-secret', 'ts-sci'],
-                        description: 'Classification level',
+                        enum: ['federal-le', 'state-le', 'local-le', 'intelligence', 'military', 'regulatory', 'international', 'cisa', 'nist', 'contractor'],
                     },
+                    incidentType: { type: 'string' },
+                    classification: { type: 'string', enum: ['unclassified', 'cui', 'confidential', 'secret', 'top-secret', 'ts-sci'] },
                 },
                 required: ['action'],
             },
@@ -88,7 +655,7 @@ Provides:
             },
         });
     }
-    // Infrastructure deployment tool
+    // ====== INFRASTRUCTURE DEPLOYMENT TOOL ======
     if (enableAll || options.enableInfrastructure) {
         tools.push({
             name: 'infrastructure',
@@ -104,27 +671,10 @@ Includes:
             parameters: {
                 type: 'object',
                 properties: {
-                    action: {
-                        type: 'string',
-                        enum: [
-                            'get_stack', 'list_templates', 'generate_deployment',
-                            'generate_teardown', 'generate_opsec_checklist',
-                        ],
-                        description: 'Action to perform',
-                    },
-                    region: {
-                        type: 'string',
-                        enum: ['us', 'ukraine', 'eu', 'asia', 'global'],
-                        description: 'Operational region',
-                    },
-                    stackId: {
-                        type: 'string',
-                        description: 'Infrastructure stack ID',
-                    },
-                    templateId: {
-                        type: 'string',
-                        description: 'Auto-execution template ID',
-                    },
+                    action: { type: 'string', enum: ['get_stack', 'list_templates', 'generate_deployment', 'generate_teardown', 'generate_opsec_checklist'] },
+                    region: { type: 'string', enum: ['us', 'ukraine', 'eu', 'asia', 'global'] },
+                    stackId: { type: 'string' },
+                    templateId: { type: 'string' },
                 },
                 required: ['action'],
             },
@@ -165,7 +715,7 @@ Includes:
             },
         });
     }
-    // Security deliverables tool
+    // ====== SECURITY DELIVERABLES TOOL ======
     if (enableAll || options.enableSecurity) {
         tools.push({
             name: 'security_deliverable',
@@ -185,32 +735,12 @@ Types:
                 properties: {
                     type: {
                         type: 'string',
-                        enum: [
-                            'pentest-report', 'incident-response', 'security-controls',
-                            'training-module', 'compliance-audit', 'threat-assessment',
-                            'apt-analysis', 'vulnerability-report', 'infrastructure-assessment',
-                            'persistence-procedures', 'red-team-playbook',
-                        ],
-                        description: 'Type of deliverable',
-                    },
-                    title: {
-                        type: 'string',
-                        description: 'Title for the deliverable',
-                    },
-                    scope: {
-                        type: 'string',
-                        description: 'Scope description',
-                    },
-                    findings: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'List of findings to include',
-                    },
-                    format: {
-                        type: 'string',
-                        enum: ['markdown', 'json', 'html'],
-                        description: 'Output format',
+                        enum: ['pentest-report', 'incident-response', 'security-controls', 'training-module', 'compliance-audit', 'threat-assessment', 'apt-analysis', 'vulnerability-report', 'infrastructure-assessment', 'persistence-procedures', 'red-team-playbook'],
                     },
+                    title: { type: 'string' },
+                    scope: { type: 'string' },
+                    findings: { type: 'array', items: { type: 'string' } },
+                    format: { type: 'string', enum: ['markdown', 'json', 'html'] },
                 },
                 required: ['type'],
             },
@@ -221,7 +751,6 @@ Types:
                 const title = params['title'];
                 const scope = params['scope'];
                 const format = params['format'];
-                // Generate deliverable with minimal context
                 const deliverable = await generator.generate(deliverableType, {
                     exitReason: 'complete',
                     finalResponse: title || 'Generated Deliverable',
@@ -253,31 +782,27 @@ Types:
                     },
                     limitations: [],
                     recommendations: [],
-                }, [], {
-                    customTitle: title,
-                    constraints: scope ? [scope] : undefined,
-                });
-                // Export in requested format
+                }, [], { customTitle: title, constraints: scope ? [scope] : undefined });
                 switch (format || 'markdown') {
-                    case 'json':
-                        return sec.exportToJSON(deliverable);
-                    case 'html':
-                        return sec.exportToHTML(deliverable);
-                    default:
-                        return sec.exportToMarkdown(deliverable);
+                    case 'json': return sec.exportToJSON(deliverable);
+                    case 'html': return sec.exportToHTML(deliverable);
+                    default: return sec.exportToMarkdown(deliverable);
                 }
             },
         });
     }
     return {
         id: 'orchestration-tools',
-        description: 'Unified orchestration for government, infrastructure, security, and APT operations',
+        description: 'Unified orchestration: gov, infra, security, validation, hypothesis, recovery',
         tools,
     };
 }
+// ============================================================================
+// CAPABILITY MODULE
+// ============================================================================
 export class OrchestrationCapabilityModule {
     id = 'capability.orchestration';
-    description = 'Unified orchestration for government, infrastructure, security, and APT operations';
+    description = 'Unified orchestration for gov, infra, security, validation, hypothesis testing, and failure recovery';
     options;
     constructor(options = {}) {
         this.options = options;
@@ -295,4 +820,8 @@ export class OrchestrationCapabilityModule {
         };
     }
 }
+// ============================================================================
+// EXPORTS - For direct usage
+// ============================================================================
+export { ErrorAnalyzer, HypothesisEngine, detectFailure, formatVerifiedResult, analyzeOutput };
 //# sourceMappingURL=orchestrationCapability.js.map