0xray 2.0.0

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

@@ -0,0 +1,600 @@
+/**
+ * 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
+ * @version 1.0.0
+ */
+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");
+    }
+}