0xray 4.0.11 → 4.0.13

package/dist/enforcement/validators/architecture-validators.js

@@ -1,599 +0,0 @@
-/**
- * Architecture Validators
- *
- * Validators for architecture category rules extracted from rule-enforcer.ts.
- * Each validator encapsulates the validation logic for a specific architectural rule.
- *
- * @module validators/architecture-validators
- */
-import { BaseValidator } from "./base-validator.js";
-/**
- * Validates dependency management (Codex Term #46).
- * Ensures dependencies are properly declared and used.
- */
-export class DependencyManagementValidator extends BaseValidator {
-    id = "dependency-management-validator";
-    ruleId = "dependency-management";
-    category = "architecture";
-    severity = "error";
-    async validate(context) {
-        const { newCode, dependencies } = context;
-        if (!newCode) {
-            return this.createSuccessResult("No code to validate for dependencies");
-        }
-        // Allow dynamic imports for edge cases
-        const dynamicImports = newCode.includes("import(") || newCode.includes("await import");
-        if (dynamicImports) {
-            return this.createSuccessResult("Dynamic imports are allowed");
-        }
-        // Check for used imports
-        const imports = newCode.match(/import\s+.*?from\s+['"]([^'"]+)['"]/g);
-        if (!imports) {
-            // Check for unused dependencies when there are no imports
-            if (dependencies && dependencies.length > 0) {
-                return this.createFailureResult(`Unused dependencies declared: ${dependencies.join(", ")}`, ["Remove unused dependencies", "Check import statements"]);
-            }
-            return this.createSuccessResult("No imports to validate");
-        }
-        const usedImports = imports
-            .map((imp) => {
-            const match = imp.match(/from\s+['"]([^'"]+)['"]/);
-            return match ? match[1] : "";
-        })
-            .filter(Boolean);
-        // Check if declared dependencies are actually used
-        if (dependencies) {
-            const unusedDeps = dependencies.filter((dep) => !usedImports.some((imp) => imp && imp.includes(dep)));
-            if (unusedDeps.length > 0) {
-                return this.createFailureResult(`Unused dependencies declared: ${unusedDeps.join(", ")}`, ["Remove unused dependencies", "Check import statements"]);
-            }
-        }
-        // Allow properly declared dependencies even if not used (common in libraries)
-        if (dependencies && dependencies.length > 0) {
-            // Check that declared dependencies don't have undeclared usage
-            const undeclaredDeps = usedImports.filter((imp) => imp &&
-                !dependencies?.some((dep) => imp.includes(dep)) &&
-                !imp.startsWith("./") &&
-                !imp.startsWith("../"));
-            if (undeclaredDeps.length > 0) {
-                return this.createFailureResult(`Undeclared dependencies used: ${undeclaredDeps.join(", ")}`, ["Add missing dependencies to package.json", "Check import paths"]);
-            }
-            // If we have proper declarations and no undeclared usage, pass
-            return this.createSuccessResult("Dependencies properly declared and managed");
-        }
-        // Check for undeclared dependencies
-        const undeclaredDeps = usedImports.filter((imp) => imp &&
-            !dependencies?.some((dep) => imp.includes(dep)) &&
-            !imp.startsWith("./") &&
-            !imp.startsWith("../"));
-        if (undeclaredDeps.length > 0) {
-            return this.createFailureResult(`Undeclared dependencies used: ${undeclaredDeps.join(", ")}`, ["Add missing dependencies to package.json", "Check import paths"]);
-        }
-        return this.createSuccessResult("Dependencies properly managed");
-    }
-}
-/**
- * Validates src-dist integrity.
- * Prevents direct file copying between src/ and dist/.
- * All changes must be made in src/ and compiled via npm run build.
- */
-export class SrcDistIntegrityValidator extends BaseValidator {
-    id = "src-dist-integrity-validator";
-    ruleId = "src-dist-integrity";
-    category = "architecture";
-    severity = "error";
-    async validate(context) {
-        const { files, operation } = context;
-        if (!files || files.length === 0) {
-            return this.createSuccessResult("No files to check for src-dist integrity");
-        }
-        // Check if any files are being copied directly between src and dist
-        const violations = [];
-        for (const file of files) {
-            const normalizedFile = file.replace(/^\.\//, ""); // Remove leading ./
-            // Check for direct edits to dist/ that should come from src/
-            if ((normalizedFile.startsWith("dist/") ||
-                normalizedFile.includes("/dist/")) &&
-                !normalizedFile.includes("/node_modules/")) {
-                violations.push("Direct edit to dist/: " +
-                    file +
-                    ". Make changes in src/ and run 'npm run build'");
-            }
-            // Check for direct edits to .opencode/ that should be generated
-            if ((normalizedFile.startsWith(".opencode/") ||
-                normalizedFile.includes("/.opencode/")) &&
-                (normalizedFile.includes("/plugin/"))) {
-                violations.push("Direct edit to .opencode/plugin/: " +
-                    file +
-                    ". This should be generated via build/postinstall");
-            }
-        }
-        if (violations.length > 0) {
-            return this.createFailureResult(`SRC-DIST INTEGRITY VIOLATION: ${violations.length} issue(s) found`, [
-                "Make all code changes in src/ directory",
-                "Run 'npm run build' to compile to dist/",
-                "Use postinstall scripts for consumer path transformations",
-                "Never copy files directly between src and dist",
-            ]);
-        }
-        return this.createSuccessResult("Src-dist integrity maintained");
-    }
-}
-/**
- * Validates import consistency (Codex Term #46).
- * Ensures consistent import patterns throughout the codebase.
- */
-export class ImportConsistencyValidator extends BaseValidator {
-    id = "import-consistency-validator";
-    ruleId = "import-consistency";
-    category = "architecture";
-    severity = "error";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code to validate for import consistency");
-        }
-        if (newCode.includes("import type")) {
-            return this.createSuccessResult("Type-only imports are allowed");
-        }
-        // Simple check - flag obvious import issues but allow type-only imports
-        if (newCode.includes("from '../src/") || newCode.includes("from './src/")) {
-            return this.createFailureResult("Import from src/ directory detected", [
-                "Use relative imports or dist/ for runtime compatibility",
-            ]);
-        }
-        if (newCode.includes("from './dist/") ||
-            newCode.includes("from '../dist/")) {
-            return this.createFailureResult("Import from dist/ directory in source file detected", ["Use relative imports in source files"]);
-        }
-        // Allow type-only imports
-        if (newCode.includes("import type")) {
-            return this.createSuccessResult("Type-only imports are allowed");
-        }
-        return this.createSuccessResult("Import patterns are consistent");
-    }
-}
-/**
- * Validates module system consistency (Codex Term #47).
- * Enforces ES module consistency and prevents CommonJS/ES module mixing.
- */
-export class ModuleSystemConsistencyValidator extends BaseValidator {
-    id = "module-system-consistency-validator";
-    ruleId = "module-system-consistency";
-    category = "architecture";
-    severity = "error";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code to validate for module system consistency");
-        }
-        const violations = [];
-        const suggestions = [];
-        // CRITICAL: CommonJS patterns in ES module environment
-        if (newCode.includes("require.main")) {
-            violations.push("CommonJS require.main pattern detected in ES module");
-            suggestions.push("Replace require.main === module with import.meta.url === `file://${process.argv[1]}`");
-        }
-        if (newCode.includes("require(") &&
-            !newCode.includes("// Allow require for") &&
-            !newCode.includes("dynamic import")) {
-            violations.push("CommonJS require() calls detected in ES module");
-            suggestions.push("Use ES module import statements instead of require()");
-        }
-        if (newCode.includes("__dirname") || newCode.includes("__filename")) {
-            violations.push("CommonJS __dirname/__filename usage detected in ES module");
-            suggestions.push("Use import.meta.url with fileURLToPath() and dirname()");
-        }
-        if (newCode.includes("module.exports") || newCode.includes("exports.")) {
-            violations.push("CommonJS module.exports pattern detected in ES module");
-            suggestions.push("Use ES module export statements");
-        }
-        if (newCode.includes("global.") &&
-            !newCode.includes("// Allow global for")) {
-            violations.push("Global namespace usage detected");
-            suggestions.push("Avoid global variables; use proper module scoping");
-        }
-        // Check for mixed module patterns
-        const hasImport = newCode.includes("import ");
-        const hasRequire = newCode.includes("require(");
-        const hasExport = newCode.includes("export ");
-        const hasModuleExports = newCode.includes("module.exports");
-        if ((hasImport || hasExport) && (hasRequire || hasModuleExports)) {
-            violations.push("Mixed ES module and CommonJS patterns detected");
-            suggestions.push("Choose one module system: use either ES modules OR CommonJS, not both");
-        }
-        // Package.json consistency check (if this is package.json related)
-        if (newCode.includes('"type": "module"') &&
-            (hasRequire || hasModuleExports)) {
-            violations.push("ES module package using CommonJS patterns");
-            suggestions.push('Remove CommonJS patterns or change "type" to "commonjs"');
-        }
-        if (violations.length > 0) {
-            return this.createFailureResult(`Module system consistency violations: ${violations.join(", ")}`, [
-                "This codebase uses ES modules exclusively",
-                "CommonJS patterns will cause runtime failures",
-                ...suggestions,
-                "Run: npm run lint:fix to auto-correct module patterns",
-            ]);
-        }
-        return this.createSuccessResult("Module system consistency validated - ES modules only");
-    }
-}
-/**
- * Validates error resolution (Codex Term #7).
- * Ensures proper error handling and prevents console.log debugging.
- */
-export class ErrorResolutionValidator extends BaseValidator {
-    id = "error-resolution-validator";
-    ruleId = "error-resolution";
-    category = "architecture";
-    severity = "error";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code to validate for error resolution");
-        }
-        const violations = [];
-        const suggestions = [];
-        // Remove comments before checking for console.log
-        const codeWithoutComments = newCode
-            .replace(/\/\/.*$/gm, '') // Remove single-line comments
-            .replace(/\/\*[\s\S]*?\*\//g, ''); // Remove multi-line comments
-        // Check for console.log debugging (improper error handling)
-        const consoleLogMatches = codeWithoutComments.match(/console\.(log|debug|info)\s*\(/g);
-        if (consoleLogMatches && consoleLogMatches.length > 0) {
-            violations.push(`Found ${consoleLogMatches.length} console.log/debug/info statements - use proper logging`);
-            suggestions.push("Replace console.log/debug/info with frameworkLogger");
-        }
-        // Check for unhandled promise rejections
-        const asyncOps = (codeWithoutComments.match(/await\s+\w+/g) || []).length;
-        const tryCatchBlocks = (codeWithoutComments.match(/try\s*{[\s\S]*?}\s*catch/g) || [])
-            .length;
-        // For edge cases, require error handling for any async operations
-        if (asyncOps > 0 && tryCatchBlocks === 0) {
-            violations.push("Async operations without error handling detected");
-            suggestions.push("Wrap async operations in try-catch blocks");
-        }
-        // Check for empty catch blocks (use code without comments)
-        const emptyCatchMatches = codeWithoutComments.match(/catch\s*\(\s*\w+\s*\)\s*{[\s\S]*?}/g);
-        if (emptyCatchMatches) {
-            for (const match of emptyCatchMatches) {
-                // Extract content between braces
-                const content = match.match(/catch\s*\([^)]*\)\s*{([^}]*)}/)?.[1] || "";
-                // Check if catch block has meaningful error handling
-                const hasMeaningfulContent = content.trim().length > 5 &&
-                    (content.includes("throw") || content.includes("log") || content.includes("error") ||
-                        content.includes("return") || content.includes("retry") || content.includes("handle") ||
-                        content.includes("retry") || content.includes("reject"));
-                if (!hasMeaningfulContent) {
-                    violations.push("Empty or minimal catch block detected");
-                    suggestions.push("Implement proper error handling in catch blocks");
-                    break;
-                }
-            }
-        }
-        if (violations.length > 0) {
-            return this.createFailureResult(`Error resolution violations: ${violations.join(", ")}`, suggestions);
-        }
-        return this.createSuccessResult("Error resolution patterns are properly implemented");
-    }
-}
-/**
- * Validates loop safety (Codex Term #8).
- * Prevents infinite loops by checking for proper termination conditions.
- */
-export class LoopSafetyValidator extends BaseValidator {
-    id = "loop-safety-validator";
-    ruleId = "loop-safety";
-    category = "architecture";
-    severity = "error";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code to validate for loop safety");
-        }
-        const violations = [];
-        const suggestions = [];
-        // Check for for loops without clear termination
-        const forLoops = newCode.match(/for\s*\([^;]*;[^;]*;[^)]*\)/g);
-        if (forLoops) {
-            for (const loop of forLoops) {
-                // Check for potentially infinite loops (empty condition or no increment)
-                // Match patterns like: for (;;) or for (let i = 0; ; i++) or for (let i = 0; i < 10; )
-                const hasEmptyCondition = loop.match(/;\s*;/); // Two consecutive semicolons
-                const hasEmptyMiddle = loop.match(/;\s*;/) && !loop.match(/;\s*[^;\s]+\s*;/);
-                if (hasEmptyCondition || loop.includes("for (;;)")) {
-                    violations.push("Potentially infinite for loop detected");
-                    suggestions.push("Ensure for loops have clear termination conditions");
-                }
-            }
-        }
-        // Check for while loops
-        const whileLoops = newCode.match(/while\s*\([^)]+\)/g);
-        if (whileLoops) {
-            for (const loop of whileLoops) {
-                // Flag while(true) or similar
-                if (loop.includes("while (true)") || loop.includes("while(1)")) {
-                    violations.push("Potentially infinite while loop detected");
-                    suggestions.push("Replace infinite while loops with proper termination conditions");
-                }
-            }
-        }
-        // Check for recursion without base case detection (basic)
-        const functionMatches = newCode.match(/function\s+\w+\s*\([^)]*\)/g);
-        if (functionMatches) {
-            const functionNames = functionMatches
-                .map((match) => {
-                const nameMatch = match.match(/function\s+(\w+)/);
-                return nameMatch ? nameMatch[1] : null;
-            })
-                .filter(Boolean);
-            for (const funcName of functionNames) {
-                // Check if function calls itself (basic recursion detection)
-                const selfCalls = (newCode.match(new RegExp(`${funcName}\\s*\\(`, "g")) || []).length;
-                if (selfCalls > 1) {
-                    // More than just the function definition
-                    // Allow recursive functions with proper base cases (edge case)
-                    const hasBaseCase = newCode.includes(`if`) &&
-                        newCode.includes(`return`) &&
-                        (newCode.includes(`<= 1`) ||
-                            newCode.includes(`<= 0`) ||
-                            newCode.includes(`=== 0`));
-                    if (hasBaseCase) {
-                        return this.createSuccessResult("Recursive function with proper base case allowed");
-                    }
-                    violations.push(`Potential unsafe recursion detected in ${funcName} - ensure base case exists`);
-                    suggestions.push("Ensure recursive functions have proper base cases and termination conditions");
-                }
-            }
-        }
-        if (violations.length > 0) {
-            return this.createFailureResult(`Loop safety violations: ${violations.join(", ")}`, suggestions);
-        }
-        return this.createSuccessResult("All loops have proper termination conditions");
-    }
-}
-/**
- * Validates state management patterns (Codex Term #41).
- * Ensures proper state management throughout the application.
- */
-export class StateManagementPatternsValidator extends BaseValidator {
-    id = "state-management-patterns-validator";
-    ruleId = "state-management-patterns";
-    category = "architecture";
-    severity = "error";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code to validate for state management patterns");
-        }
-        const violations = [];
-        const suggestions = [];
-        // Check for global state abuse
-        const globalVarMatches = newCode.match(/(?:window\.|global\.|globalThis\.)\w+\s*=/g);
-        if (globalVarMatches && globalVarMatches.length > 0) {
-            violations.push(`${globalVarMatches.length} global variable assignments detected`);
-            suggestions.push("Avoid global state - use proper state management patterns");
-        }
-        // Check for prop drilling (basic detection)
-        const propsPassing = newCode.match(/props\.\w+\s*=\s*{\s*[\s\S]*?}/g);
-        if (propsPassing &&
-            propsPassing.some((match) => match.split("\n").length > 3)) {
-            violations.push("Potential prop drilling detected - deep props passing");
-            suggestions.push("Consider using Context API, Redux, or Zustand for state management");
-        }
-        // Check for direct DOM manipulation (anti-pattern for state management)
-        const domManipulation = newCode.match(/document\.(?:getElementById|querySelector)\s*\(/g);
-        if (domManipulation && domManipulation.length > 0) {
-            violations.push(`${domManipulation.length} direct DOM manipulations detected`);
-            suggestions.push("Use proper state management instead of direct DOM manipulation");
-        }
-        // Allow legacy class components for acceptable contexts first
-        if (newCode.includes("Legacy") ||
-            newCode.includes("migration")) {
-            return this.createSuccessResult("Legacy patterns allowed in acceptable contexts");
-        }
-        // Check for stateful class components (React anti-pattern)
-        const classComponents = newCode.match(/class\s+\w+\s+extends\s+(?:Component|React\.Component)/g);
-        if (classComponents && classComponents.length > 0) {
-            const hasState = newCode.includes("this.state") || newCode.includes("setState");
-            if (hasState) {
-                violations.push("Stateful class components detected - prefer functional components with hooks");
-                suggestions.push("Migrate to functional components with useState/useReducer hooks");
-            }
-        }
-        // Flag obvious state abuse
-        if (newCode.includes("GlobalStateManager") &&
-            newCode.includes("static global")) {
-            violations.push("Global state abuse detected");
-            suggestions.push("Avoid global state - use proper state management patterns");
-        }
-        // Check for state updates without proper immutability
-        const directMutations = newCode.match(/state\.\w+\s*=\s*[^=]/g);
-        if (directMutations && directMutations.length > 0) {
-            violations.push(`${directMutations.length} direct state mutations detected`);
-            suggestions.push("Use immutable state updates (spread operator, immer, etc.)");
-        }
-        if (violations.length > 0) {
-            return this.createFailureResult(`State management violations: ${violations.join(", ")}`, suggestions);
-        }
-        return this.createSuccessResult("State management patterns are properly implemented");
-    }
-}
-/**
- * Validates single responsibility principle (Codex Term #24).
- * Ensures classes and functions don't do too many things.
- */
-export class SingleResponsibilityValidator extends BaseValidator {
-    id = "single-responsibility-validator";
-    ruleId = "single-responsibility";
-    category = "architecture";
-    severity = "warning";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code to validate for single responsibility");
-        }
-        // Check for classes/functions that do too many things
-        const classes = newCode.match(/class\s+\w+/g) || [];
-        const functions = newCode.match(/(?:function|const\s+\w+\s*=).*?\(/g) || [];
-        if (classes.length > 0) {
-            // Check if class has too many methods (more than 10 might indicate multiple responsibilities)
-            const methods = newCode.match(/(?:async\s+)?(?:public\s+|private\s+|protected\s+)?(?:\w+\s+)?\w+\s*\(/g) || [];
-            if (methods.length > 15) {
-                return this.createFailureResult(`Class has ${methods.length} methods - may violate single responsibility principle`, [
-                    "Split class into smaller, focused classes",
-                    "Extract methods into separate modules",
-                ]);
-            }
-        }
-        return this.createSuccessResult("Single responsibility principle maintained");
-    }
-}
-/**
- * Validates deployment safety (Codex Term #43).
- * Ensures deployments have proper safety checks.
- */
-export class DeploymentSafetyValidator extends BaseValidator {
-    id = "deployment-safety-validator";
-    ruleId = "deployment-safety";
-    category = "architecture";
-    severity = "blocking";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code change to validate");
-        }
-        const hasDeployCode = newCode.includes("deploy") ||
-            newCode.includes("docker") ||
-            newCode.includes("kubernetes") ||
-            newCode.includes("ci/cd") ||
-            newCode.includes("pipeline");
-        if (hasDeployCode) {
-            const hasSafetyChecks = newCode.includes("rollback") ||
-                newCode.includes("health") ||
-                newCode.includes("verify") ||
-                newCode.includes("canary") ||
-                newCode.includes("graceful");
-            if (!hasSafetyChecks) {
-                return this.createFailureResult("Deployment code lacks safety checks", ["Add rollback capability", "Add health verification", "Consider canary deployments"]);
-            }
-        }
-        return this.createSuccessResult("Deployment safety requirements met");
-    }
-}
-/**
- * Validates multi-agent ensemble patterns.
- * Ensures multi-agent configurations follow best practices.
- */
-export class MultiAgentEnsembleValidator extends BaseValidator {
-    id = "multi-agent-ensemble-validator";
-    ruleId = "multi-agent-ensemble";
-    category = "architecture";
-    severity = "warning";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code change to validate");
-        }
-        const hasMultiAgentCode = newCode.includes("subagent") ||
-            newCode.includes("delegate") ||
-            newCode.includes("spawn") ||
-            newCode.includes("orchestrat");
-        if (hasMultiAgentCode) {
-            const hasCoordination = newCode.includes("timeout") ||
-                newCode.includes("retry") ||
-                newCode.includes("fallback") ||
-                newCode.includes("error");
-            if (!hasCoordination) {
-                return this.createFailureResult("Multi-agent code lacks coordination patterns", ["Add timeout handling", "Add retry/fallback logic"]);
-            }
-        }
-        return this.createSuccessResult("Multi-agent ensemble requirements met");
-    }
-}
-/**
- * Validates substrate externalization patterns.
- * Ensures proper abstraction boundaries.
- */
-export class SubstrateExternalizationValidator extends BaseValidator {
-    id = "substrate-externalization-validator";
-    ruleId = "substrate-externalization";
-    category = "architecture";
-    severity = "info";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code change to validate");
-        }
-        const hasExternalAPICode = newCode.includes("export") &&
-            (newCode.includes("interface") ||
-                newCode.includes("type") ||
-                newCode.includes("class"));
-        if (hasExternalAPICode) {
-            const hasAbstraction = newCode.includes("abstract") ||
-                newCode.includes("interface") ||
-                newCode.includes("implements");
-            if (!hasAbstraction) {
-                return this.createFailureResult("External API lacks proper abstraction", ["Use interfaces for external APIs", "Consider abstract classes for implementations"]);
-            }
-        }
-        return this.createSuccessResult("Substrate externalization requirements met");
-    }
-}
-/**
- * Validates framework self-validation capability.
- * Ensures framework can validate itself.
- */
-export class FrameworkSelfValidationValidator extends BaseValidator {
-    id = "framework-self-validation-validator";
-    ruleId = "framework-self-validation";
-    category = "architecture";
-    severity = "info";
-    async validate(context) {
-        const { files, operation } = context;
-        if (operation !== "write") {
-            return this.createSuccessResult("No code change to validate");
-        }
-        const isFrameworkCode = files?.some((f) => f.includes("src/core") || f.includes("src/enforcement"));
-        if (isFrameworkCode) {
-            const hasSelfTests = context.newCode?.includes("self") ||
-                context.newCode?.includes("validate") ||
-                context.newCode?.includes("test");
-            if (!hasSelfTests) {
-                return this.createFailureResult("Framework code lacks self-validation", ["Add self-validation tests", "Include framework health checks"]);
-            }
-        }
-        return this.createSuccessResult("Framework self-validation requirements met");
-    }
-}
-/**
- * Validates emergent improvement patterns.
- * Ensures continuous improvement mechanisms exist.
- */
-export class EmergentImprovementValidator extends BaseValidator {
-    id = "emergent-improvement-validator";
-    ruleId = "emergent-improvement";
-    category = "architecture";
-    severity = "info";
-    async validate(context) {
-        const { newCode, operation } = context;
-        if (!newCode || operation !== "write") {
-            return this.createSuccessResult("No code change to validate");
-        }
-        const hasImprovementCode = newCode.includes("improve") ||
-            newCode.includes("optimize") ||
-            newCode.includes("refactor") ||
-            newCode.includes("enhance");
-        if (hasImprovementCode) {
-            const hasFeedbackLoop = newCode.includes("metrics") ||
-                newCode.includes("telemetry") ||
-                newCode.includes("analytics") ||
-                newCode.includes("log");
-            if (!hasFeedbackLoop) {
-                return this.createFailureResult("Improvement code lacks feedback mechanism", ["Add metrics/telemetry for improvement tracking", "Include analytics for continuous improvement"]);
-            }
-        }
-        return this.createSuccessResult("Emergent improvement requirements met");
-    }
-}