pumuki-ast-hooks 5.5.50 → 5.5.53

package/README.md

@@ -866,6 +866,15 @@ Automates the complete Git Flow cycle: commit → push → PR → merge, plus co
 
 For more details, see [MCP_SERVERS.md](./docs/MCP_SERVERS.md).
 
+#### Troubleshooting
+
+If `ai_gate_check` behaves inconsistently (stale branch name, missing rules, or intermittent transport errors), verify you are not running multiple `ast-intelligence-automation` servers across different repositories.
+
+- Prefer enabling a single MCP server for the repository you are working on.
+- Verify the active process points to this repository path:
+  - `.../ast-intelligence-hooks/scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js`
+- If you detect multiple processes, stop the duplicates and restart your IDE/MCP servers.
+
 ---
 
 ## API Reference

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki-ast-hooks",
-  "version": "5.5.50",
+  "version": "5.5.53",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {

package/scripts/hooks-system/.audit_tmp/hook-metrics.jsonl

@@ -110,3 +110,59 @@
 {"timestamp":1767772971939,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
 {"timestamp":1767772971939,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
 {"timestamp":1767772971939,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767775802167,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767775802167,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767775802167,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767775802167,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767775833943,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767775833943,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767775833943,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767775833943,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767776135844,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767776135844,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767776135844,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767776135844,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767776384649,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767776384649,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767776384649,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767776384649,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767777653343,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767777653343,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767777653343,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767777653344,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767778142566,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767778142567,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767778142567,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767778142567,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767778800954,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767778800955,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767778800955,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767778800955,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767779528552,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767779528552,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767779528552,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767779528552,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767779903813,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767779903813,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767779903813,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767779903813,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767780497468,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767780497468,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767780497468,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767780497468,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767780655724,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767780655725,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767780655725,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767780655725,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767782291627,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767782291627,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767782291627,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767782291627,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767784424360,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767784424360,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767784424360,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767784424360,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767784524038,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767784524038,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767784524038,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767784524038,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}

package/scripts/hooks-system/application/services/AutonomousOrchestrator.js

@@ -31,10 +31,47 @@ class AutonomousOrchestrator {
         }
     }
 
+    detectFromBranchKeywords(branchName) {
+        try {
+            const PlatformHeuristics = require('./platform/PlatformHeuristics');
+            const heuristics = new PlatformHeuristics(this.platformDetector);
+            return heuristics.detectFromBranchKeywords(branchName);
+        } catch (error) {
+            const msg = error && error.message ? error.message : String(error);
+            this.logger?.debug?.('ORCHESTRATOR_BRANCH_KEYWORDS_DETECTION_ERROR', { error: msg });
+            return [];
+        }
+    }
+
+    detectFromEvidenceFile() {
+        try {
+            const PlatformHeuristics = require('./platform/PlatformHeuristics');
+            const heuristics = new PlatformHeuristics(this.platformDetector);
+            return heuristics.detectFromEvidenceFile();
+        } catch (error) {
+            const msg = error && error.message ? error.message : String(error);
+            this.logger?.debug?.('ORCHESTRATOR_EVIDENCE_FILE_DETECTION_ERROR', { error: msg });
+            return [];
+        }
+    }
+
     detectFromASTSystemFilesLegacy(files) {
         return this.detectFromASTSystemFiles(files);
     }
 
+    async scoreConfidence(platforms) {
+        try {
+            const PlatformAnalysisService = require('./PlatformAnalysisService');
+            const analysisService = new PlatformAnalysisService(this.platformDetector);
+            const context = await this.contextEngine.detectContext();
+            return analysisService.analyzeConfidence(platforms || [], context || {});
+        } catch (error) {
+            const msg = error && error.message ? error.message : String(error);
+            this.logger?.debug?.('ORCHESTRATOR_SCORE_CONFIDENCE_ERROR', { error: msg });
+            return [];
+        }
+    }
+
     async analyzeContext() {
         const platforms = await this.detectActivePlatforms();
         const scores = await this.scoreConfidence(platforms);

package/scripts/hooks-system/application/services/installation/McpConfigurator.js

@@ -130,33 +130,99 @@ class McpConfigurator {
             }
         };
 
-        const globalConfigPath = this.getGlobalWindsurfConfigPath();
-        const globalConfigDir = path.dirname(globalConfigPath);
-        if (!fs.existsSync(globalConfigDir)) {
-            fs.mkdirSync(globalConfigDir, { recursive: true });
-        }
+        this.configureProjectScoped(mcpConfig, serverId);
+        this.cleanupGlobalConfig(serverId);
+    }
+
+    configureProjectScoped(mcpConfig, serverId) {
+        const windsurfProjectDir = path.join(this.targetRoot, '.windsurf');
+        const windsurfProjectPath = path.join(windsurfProjectDir, 'mcp.json');
 
         try {
-            if (!fs.existsSync(globalConfigPath)) {
-                fs.writeFileSync(globalConfigPath, JSON.stringify(mcpConfig, null, 2));
-                this.logSuccess(`Configured global Windsurf MCP at ${globalConfigPath}`);
-                if (this.logger) this.logger.info('MCP_GLOBAL_CONFIGURED', { path: globalConfigPath });
-            } else {
-                const existing = JSON.parse(fs.readFileSync(globalConfigPath, 'utf8'));
+            if (!fs.existsSync(windsurfProjectDir)) {
+                fs.mkdirSync(windsurfProjectDir, { recursive: true });
+            }
+
+            let finalConfig = mcpConfig;
+            if (fs.existsSync(windsurfProjectPath)) {
+                const existing = JSON.parse(fs.readFileSync(windsurfProjectPath, 'utf8'));
                 if (!existing.mcpServers) existing.mcpServers = {};
+                Object.keys(existing.mcpServers).forEach(id => {
+                    if (id.startsWith('ast-intelligence-automation-') && id !== serverId) {
+                        delete existing.mcpServers[id];
+                    }
+                });
+                existing.mcpServers[serverId] = mcpConfig.mcpServers[serverId];
+                finalConfig = existing;
+            }
+
+            fs.writeFileSync(windsurfProjectPath, JSON.stringify(finalConfig, null, 2));
+            this.logSuccess(`Configured project-scoped Windsurf MCP at ${windsurfProjectPath}`);
+            if (this.logger) this.logger.info('MCP_PROJECT_CONFIGURED', { path: windsurfProjectPath, serverId });
+        } catch (error) {
+            this.logWarning(`Failed to configure project-scoped MCP: ${error.message}`);
+            if (this.logger) this.logger.warn('MCP_PROJECT_CONFIGURE_FAILED', { error: error.message });
+        }
 
-                // Prevent duplicate MCP servers for the same repoRoot by disabling legacy entries.
-                this.disableDuplicateServersForRepo(existing, serverId);
+        const cursorProjectDir = path.join(this.targetRoot, '.cursor');
+        const cursorProjectPath = path.join(cursorProjectDir, 'mcp.json');
 
+        try {
+            if (!fs.existsSync(cursorProjectDir)) {
+                fs.mkdirSync(cursorProjectDir, { recursive: true });
+            }
+
+            let finalConfig = mcpConfig;
+            if (fs.existsSync(cursorProjectPath)) {
+                const existing = JSON.parse(fs.readFileSync(cursorProjectPath, 'utf8'));
+                if (!existing.mcpServers) existing.mcpServers = {};
+                Object.keys(existing.mcpServers).forEach(id => {
+                    if (id.startsWith('ast-intelligence-automation-') && id !== serverId) {
+                        delete existing.mcpServers[id];
+                    }
+                });
                 existing.mcpServers[serverId] = mcpConfig.mcpServers[serverId];
+                finalConfig = existing;
+            }
+
+            fs.writeFileSync(cursorProjectPath, JSON.stringify(finalConfig, null, 2));
+            this.logSuccess(`Configured project-scoped Cursor MCP at ${cursorProjectPath}`);
+            if (this.logger) this.logger.info('MCP_CURSOR_CONFIGURED', { path: cursorProjectPath, serverId });
+        } catch (error) {
+            this.logWarning(`Failed to configure Cursor MCP: ${error.message}`);
+            if (this.logger) this.logger.warn('MCP_CURSOR_CONFIGURE_FAILED', { error: error.message });
+        }
+    }
+
+    cleanupGlobalConfig(currentServerId) {
+        const globalConfigPath = this.getGlobalWindsurfConfigPath();
 
+        try {
+            if (!fs.existsSync(globalConfigPath)) return;
+
+            const existing = JSON.parse(fs.readFileSync(globalConfigPath, 'utf8'));
+            if (!existing.mcpServers) return;
+
+            let modified = false;
+            Object.keys(existing.mcpServers).forEach(id => {
+                const server = existing.mcpServers[id];
+                if (!server || !server.env) return;
+
+                if (server.env.REPO_ROOT === this.targetRoot) {
+                    delete existing.mcpServers[id];
+                    modified = true;
+                    this.logInfo(`Removed ${id} from global config (now project-scoped)`);
+                }
+            });
+
+            if (modified) {
                 fs.writeFileSync(globalConfigPath, JSON.stringify(existing, null, 2));
-                this.logSuccess(`Updated global Windsurf MCP at ${globalConfigPath}`);
-                if (this.logger) this.logger.info('MCP_GLOBAL_UPDATED', { path: globalConfigPath });
+                if (this.logger) this.logger.info('MCP_GLOBAL_CLEANUP', { removedForRepo: this.targetRoot });
+            }
+        } catch (error) {
+            if (process.env.DEBUG) {
+                process.stderr.write(`[MCP] cleanupGlobalConfig failed: ${error.message}\n`);
             }
-        } catch (mergeError) {
-            this.logWarning(`${globalConfigPath} exists but couldn't be merged, skipping`);
-            if (this.logger) this.logger.warn('MCP_GLOBAL_MERGE_FAILED', { error: mergeError.message });
         }
     }
 

package/scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js

@@ -576,9 +576,293 @@ function checkBranchChangesCoherence(branchName, uncommittedChanges) {
     return { isCoherent: true, expectedScope, detectedScope: dominantScope, reason: 'Changes match branch scope' };
 }
 
+/**
+ * Load platform rules from .cursor/rules or .windsurf/rules
+ * Returns the content of the rules file for the detected platform
+ */
+async function loadPlatformRules(platforms) {
+    const DynamicRulesLoader = require('../../application/services/DynamicRulesLoader');
+    const loader = new DynamicRulesLoader();
+    const rules = {};
+    const criticalRules = [];
+
+    for (const platform of platforms) {
+        try {
+            const content = await loader.loadRule(`rules${platform}.mdc`);
+            if (content) {
+                rules[platform] = content;
+                const criticalPatterns = extractCriticalPatterns(content, platform);
+                criticalRules.push(...criticalPatterns);
+            }
+        } catch (error) {
+            if (process.env.DEBUG) {
+                process.stderr.write(`[MCP] Failed to load rules for ${platform}: ${error.message}\n`);
+            }
+        }
+    }
+
+    try {
+        const goldContent = await loader.loadRule('rulesgold.mdc');
+        if (goldContent) {
+            rules.gold = goldContent;
+            const goldPatterns = extractCriticalPatterns(goldContent, 'gold');
+            criticalRules.push(...goldPatterns);
+        }
+    } catch (error) {
+        if (process.env.DEBUG) {
+            process.stderr.write(`[MCP] Failed to load gold rules: ${error.message}\n`);
+        }
+    }
+
+    return { rules, criticalRules };
+}
+
+/**
+ * Extract critical patterns from rules content that AI MUST follow
+ */
+function extractCriticalPatterns(content, platform) {
+    const patterns = [];
+    if (!content) return patterns;
+
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (line.includes('❌') || line.includes('NUNCA') || line.includes('PROHIBIDO') || line.includes('NO ')) {
+            patterns.push({ platform, rule: line.trim(), severity: 'CRITICAL' });
+        }
+        if (line.includes('✅') && (line.includes('OBLIGATORIO') || line.includes('SIEMPRE'))) {
+            patterns.push({ platform, rule: line.trim(), severity: 'MANDATORY' });
+        }
+    }
+
+    if (platform === 'ios') {
+        // PROHIBICIONES CRÍTICAS iOS
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar GCD (DispatchQueue.main.async, DispatchQueue.global) - usar Swift Concurrency (async/await, Task, actor, @MainActor)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar completion handlers/@escaping callbacks - usar async/await', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA dejar catch vacíos - siempre gestionar errores (log/rethrow/wrap)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA mezclar operaciones de escritura (commands) con lecturas (queries) en el mismo flujo/servicio - aplicar CQRS', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar Singleton - usar Inyección de Dependencias (DI por init/protocols)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar force unwrap (!) - usar guard let/if let/?? (excepción: IBOutlets)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar librerías de terceros (Alamofire, Swinject, Quick/Nimble, etc.) - usar APIs nativas (URLSession, DI manual, Swift Testing)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA añadir comentarios en el código - nombres autodescriptivos', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar prints/logs ad-hoc - usar Logger del framework os', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar AnyView - afecta performance, usar @ViewBuilder o generics', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar ObservableObject - usar @Observable (iOS 17+)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar Storyboards/XIBs - usar SwiftUI o Programmatic UI', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar CocoaPods/Carthage - usar Swift Package Manager', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar JSONSerialization - usar Codable', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar OperationQueue para async - usar Task/TaskGroup', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar any (type erasure) - usar generics con protocolos de frontera', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA usar Localizable.strings - usar String Catalogs (.xcstrings)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA ignorar warnings - warnings = errores futuros', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA crear Massive View Controllers (>300 líneas) - separar lógica en ViewModels', severity: 'CRITICAL' });
+        patterns.push({ platform: 'ios', rule: '❌ NUNCA crear retain cycles - usar [weak self] en closures', severity: 'CRITICAL' });
+
+        // OBLIGATORIOS iOS
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar Swift 6.2 con Strict Concurrency Checking en Complete', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar async/await para TODAS las operaciones asíncronas', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar SwiftUI (UIKit solo si estrictamente necesario)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar @Observable (iOS 17+) con @Bindable para bindings', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar NavigationStack + NavigationPath para navegación', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar guard/early returns - evitar pyramid of doom', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO seguir Clean Architecture (Domain → Application → Infrastructure → Presentation)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO aplicar CQRS (Command Query Responsibility Segregation): separar comandos (write) de consultas (read)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO verificar SOLID (SRP, OCP, LSP, ISP, DIP)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO nombres autodescriptivos en inglés', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO comprobar que compila (Xcode build) ANTES de sugerir', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar Sendable conformance para tipos thread-safe', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar actor para estado compartido thread-safe', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar @MainActor para código UI', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar Task {} para lanzar contextos asíncronos desde código síncrono', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar Keychain nativo para datos sensibles (NO UserDefaults)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar SwiftData (iOS 17+) para persistencia (CoreData solo legacy)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar Swift Testing framework para tests (XCTest solo legacy)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar makeSUT pattern en tests', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar trackForMemoryLeaks helper en tests', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar spies en vez de mocks/stubs', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar protocols para testability (inyectar protocols, no tipos concretos)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar struct por defecto, class solo cuando necesites identity/herencia', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO usar let > var (inmutabilidad por defecto)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO cero warnings en el proyecto', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO seguir flujo BDD → TDD (Feature files → Specs → Implementación)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'ios', rule: '✅ OBLIGATORIO en producción todo real contra APIs/persistencia (cero mocks/spies)', severity: 'MANDATORY' });
+    }
+
+    if (platform === 'android') {
+        // PROHIBICIONES CRÍTICAS Android
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar Singleton - usar Hilt para Inyección de Dependencias', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar XML layouts - usar Jetpack Compose', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar Java en código nuevo - usar Kotlin 100%', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar LiveData - usar StateFlow/SharedFlow', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA dejar catch vacíos - siempre gestionar errores', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA mezclar operaciones de escritura (commands) con lecturas (queries) en el mismo caso de uso/repository - aplicar CQRS', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA añadir comentarios en el código', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar force unwrap (!!) - usar ?, ?:, let, requireNotNull', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar AsyncTask (deprecated) - usar Coroutines', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar RxJava en código nuevo - usar Flow', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar findViewById - usar Compose o View Binding', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar Context leaks - no referencias a Activity en objetos long-lived', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar God Activities - Single Activity + Composables', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA hardcodear strings - usar strings.xml', severity: 'CRITICAL' });
+        patterns.push({ platform: 'android', rule: '❌ NUNCA usar callbacks para async - usar suspend functions', severity: 'CRITICAL' });
+
+        // OBLIGATORIOS Android
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Jetpack Compose + Material 3', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Hilt para DI (@HiltAndroidApp, @AndroidEntryPoint, @Inject)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Kotlin Coroutines + Flow para async', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar StateFlow para exponer estado del ViewModel', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar sealed classes para estados (Success, Error, Loading)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO seguir Clean Architecture (Domain → Data → Presentation)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO aplicar CQRS (Command Query Responsibility Segregation): separar comandos (write) de consultas (read)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO verificar SOLID', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar MVVM + Single Activity', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Navigation Compose para navegación', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Room para persistencia local', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Retrofit + Moshi para networking', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Coil para carga de imágenes', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Kotlin DSL (build.gradle.kts)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Version Catalogs (libs.versions.toml)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar JUnit5 + MockK para testing', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar Timber para logging (solo en DEBUG)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO usar EncryptedSharedPreferences para datos sensibles', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO nombres autodescriptivos en inglés', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO comprobar que compila (Gradle build) ANTES de sugerir', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO seguir flujo BDD → TDD', severity: 'MANDATORY' });
+        patterns.push({ platform: 'android', rule: '✅ OBLIGATORIO en producción todo real contra APIs/persistencia', severity: 'MANDATORY' });
+    }
+
+    if (platform === 'backend') {
+        // PROHIBICIONES CRÍTICAS Backend
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA usar Singleton - usar NestJS DI (@Injectable)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA usar console.log/console.error - usar Logger de NestJS', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA usar any/unknown en TypeScript - usar tipos explícitos o generics', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA dejar catch vacíos - siempre loggear o propagar (common.error.empty_catch)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA mezclar Command y Query en el mismo handler/service - aplicar CQRS', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA hardcodear secretos - usar variables de entorno (AWS Secrets Manager, Vault)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA añadir comentarios en el código', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA exponer datos sin validar - usar class-validator + DTOs', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA exponer stack traces en producción', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA usar mocks en producción - solo datos reales', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA loggear datos sensibles (passwords, tokens, PII)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA usar God classes (servicios >500 líneas)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA usar callback hell - usar async/await', severity: 'CRITICAL' });
+        patterns.push({ platform: 'backend', rule: '❌ NUNCA poner lógica en controllers - mover a servicios/use cases', severity: 'CRITICAL' });
+
+        // OBLIGATORIOS Backend
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar Repository Pattern (interfaces en domain, impl en infrastructure)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar DTOs + class-validator para validación de entrada/salida', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar Guards para autenticación/autorización (@UseGuards)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO paginación en TODOS los endpoints de listado', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO seguir Clean Architecture (Domain → Application → Infrastructure → Presentation)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO aplicar CQRS (Command Query Responsibility Segregation): Commands (write) separados de Queries (read)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO verificar SOLID', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO TypeScript strict mode', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar Use Cases explícitos (CreateOrderUseCase, etc.)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar Exception Filters para manejo global de errores', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar Swagger/OpenAPI para documentación (@nestjs/swagger)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar queries parametrizadas (prevenir SQL injection)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar índices en columnas frecuentes en WHERE/JOIN', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar transacciones para operaciones críticas', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar soft deletes (deleted_at) por defecto', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar JWT + refresh tokens para autenticación', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar rate limiting (@nestjs/throttler)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar Helmet para security headers', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar health checks (/health endpoint)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO usar correlation IDs para tracing distribuido', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO nombres autodescriptivos en inglés', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO comprobar que compila (npm run build) ANTES de sugerir', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO seguir flujo BDD → TDD', severity: 'MANDATORY' });
+        patterns.push({ platform: 'backend', rule: '✅ OBLIGATORIO coverage >95% en lógica crítica', severity: 'MANDATORY' });
+    }
+
+    if (platform === 'frontend') {
+        // PROHIBICIONES CRÍTICAS Frontend
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA usar any/unknown en TypeScript - usar tipos explícitos o generics', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA usar class components - usar functional components + hooks', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA hardcodear strings - usar i18n (useTranslation)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA dejar catch vacíos - siempre gestionar errores (common.error.empty_catch)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA mezclar operaciones de escritura (commands/mutations) con lecturas (queries) en el mismo hook/service - aplicar CQRS', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA añadir comentarios en el código', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA usar console.log en producción', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA usar Singleton - usar providers/context para DI', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA usar índice como key en listas si el orden puede cambiar', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA usar prop drilling excesivo - usar Context/Zustand', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA renderizar HTML de usuario sin sanitizar (DOMPurify)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'frontend', rule: '❌ NUNCA poner tokens en URLs - usar Authorization headers', severity: 'CRITICAL' });
+
+        // OBLIGATORIOS Frontend
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar TypeScript strict mode', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar React functional components + hooks', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar TailwindCSS para estilos', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar Next.js 15 App Router (app/ directory)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar Server Components por defecto ("use client" solo cuando necesario)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar React Query para server state', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar Zustand para estado global', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar React Hook Form + Zod para forms', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO API client en capa infrastructure (abstraer axios/fetch)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO tests con React Testing Library + Playwright', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO seguir Clean Architecture', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO aplicar CQRS (Command Query Responsibility Segregation): separar writes (mutations) de reads (queries)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO verificar SOLID', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar Next/Image para imágenes', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar loading.tsx/error.tsx en cada ruta', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar semantic HTML + ARIA labels', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO usar keyboard navigation en todos los interactivos', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO WCAG AA mínimo (contraste 4.5:1)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO nombres autodescriptivos en inglés', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO comprobar que compila y pasa tests ANTES de sugerir', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO seguir flujo BDD → TDD', severity: 'MANDATORY' });
+        patterns.push({ platform: 'frontend', rule: '✅ OBLIGATORIO en producción todo real contra APIs', severity: 'MANDATORY' });
+    }
+
+    if (platform === 'gold') {
+        // PROHIBICIONES CRÍTICAS Gold (comunes a todas las plataformas)
+        patterns.push({ platform: 'gold', rule: '❌ NUNCA usar Singleton - usar Inyección de Dependencias', severity: 'CRITICAL' });
+        patterns.push({ platform: 'gold', rule: '❌ NUNCA dejar catch vacíos - siempre loggear o propagar (AST: common.error.empty_catch)', severity: 'CRITICAL' });
+        patterns.push({ platform: 'gold', rule: '❌ NUNCA añadir comentarios en el código - nombres autodescriptivos', severity: 'CRITICAL' });
+        patterns.push({ platform: 'gold', rule: '❌ NUNCA usar mocks/spies en producción - todo real contra BBDD/servicios', severity: 'CRITICAL' });
+        patterns.push({ platform: 'gold', rule: '❌ NUNCA usar --no-verify o GIT_BYPASS_HOOK sin autorización explícita verbal', severity: 'CRITICAL' });
+        patterns.push({ platform: 'gold', rule: '❌ NUNCA hardcodear secretos en código - usar variables de entorno', severity: 'CRITICAL' });
+        patterns.push({ platform: 'gold', rule: '❌ NUNCA silenciar errores - siempre loggear o propagar', severity: 'CRITICAL' });
+        patterns.push({ platform: 'gold', rule: '❌ NUNCA modificar librerías locales (node_modules/@pumuki/...) - reportar bugs', severity: 'CRITICAL' });
+
+        // OBLIGATORIOS Gold (comunes a todas las plataformas)
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO responder siempre en español', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO actuar como Arquitecto de Soluciones y Software Designer', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO seguir flujo BDD → TDD (Feature files → Specs → Implementación)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO seguir Clean Architecture y Clean Code (capas, dependencias hacia adentro)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO verificar SOLID (SRP, OCP, LSP, ISP, DIP) en cada cambio', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO preferir guard/early returns - evitar pyramid of doom', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO nombres autodescriptivos en inglés (todo el código)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO comprobar que compila ANTES de sugerir cualquier cambio', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO analizar estructura existente antes de implementar', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO usar makeSUT pattern en tests', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO usar trackForMemoryLeaks en tests', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO preferir spies frente a stubs/mocks en tests', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO validar SIEMPRE entradas de usuario', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO sanitizar datos (prevenir XSS, SQL Injection)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO principio de menor privilegio (permisos mínimos)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO paginación en todas las listas', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO tests como documentación viva (AAA/Given-When-Then)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO cobertura mínima 80%, objetivo 95%+ en lógica crítica', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO commits atómicos con Conventional Commits (feat:, fix:, etc.)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO branch naming (feature/, bugfix/, hotfix/, refactor/)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO i18n desde día 1 - no hardcodear strings', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO WCAG 2.1 AA mínimo para accesibilidad', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO "Measure twice, cut once" - planificar bien antes de implementar', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO YAGNI - You Ain\'t Gonna Need It (no sobre-ingeniería)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO KISS - Keep It Simple, Stupid (solución más simple que funcione)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO Fail Fast - validar precondiciones al inicio', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO inmutabilidad por defecto (const, readonly, let > var)', severity: 'MANDATORY' });
+        patterns.push({ platform: 'gold', rule: '✅ OBLIGATORIO composición > herencia', severity: 'MANDATORY' });
+    }
+
+    return patterns;
+}
+
 /**
  * AI Gate Check - MANDATORY at start of every AI response
  * Returns BLOCKED or ALLOWED status with auto-fixes applied
+ * NOW INCLUDES: mandatory_rules that AI MUST read and follow
  */
 async function aiGateCheck() {
     const startedAt = Date.now();
@@ -683,19 +967,71 @@ async function aiGateCheck() {
             }
         }
 
+        let mandatoryRules = null;
+        let detectedPlatforms = [];
+        try {
+            const orchestrator = getCompositionRoot().getOrchestrator();
+            const contextDecision = await orchestrator.analyzeContext();
+            if (contextDecision && contextDecision.platforms) {
+                detectedPlatforms = contextDecision.platforms.map(p => p.platform || p);
+            }
+            const fallbackPlatforms = ['backend', 'frontend', 'ios', 'android'];
+            const platformsForRules = (detectedPlatforms.length > 0 ? detectedPlatforms : fallbackPlatforms)
+                .filter(Boolean);
+            const normalizedPlatforms = Array.from(new Set(platformsForRules));
+            const rulesData = await loadPlatformRules(normalizedPlatforms);
+            const rulesSample = rulesData.criticalRules.slice(0, 5).map(r => r.rule || r);
+            const rulesCount = rulesData.criticalRules.length;
+            mandatoryRules = {
+                platforms: normalizedPlatforms,
+                criticalRules: rulesData.criticalRules,
+                rulesLoaded: Object.keys(rulesData.rules),
+                totalRulesCount: rulesCount,
+                rulesSample: rulesSample,
+                proofOfRead: `✅ VERIFIED: ${rulesCount} critical rules loaded from ${Object.keys(rulesData.rules).join(', ')}`
+            };
+        } catch (error) {
+            if (process.env.DEBUG) {
+                process.stderr.write(`[MCP] Failed to load mandatory rules: ${error.message}\n`);
+            }
+
+            const fallbackPlatforms = ['backend', 'frontend', 'ios', 'android'];
+            const normalizedPlatforms = Array.from(new Set((detectedPlatforms.length > 0 ? detectedPlatforms : fallbackPlatforms).filter(Boolean)));
+            mandatoryRules = {
+                platforms: normalizedPlatforms,
+                criticalRules: [],
+                rulesLoaded: [],
+                status: 'FAILED_TO_LOAD',
+                error: `Failed to load rules content: ${error && error.message ? error.message : String(error)}`
+            };
+        }
+
+        const rulesLoadedSuccessfully = mandatoryRules &&
+            mandatoryRules.criticalRules &&
+            mandatoryRules.criticalRules.length > 0;
+
+        if (!rulesLoadedSuccessfully) {
+            violations.push('❌ RULES_NOT_LOADED: Critical platform rules could not be loaded. AI cannot proceed without reading mandatory rules.');
+        }
+
+        const finalBlocked = isBlocked || !rulesLoadedSuccessfully;
+
         return {
-            status: isBlocked ? 'BLOCKED' : 'ALLOWED',
+            status: finalBlocked ? 'BLOCKED' : 'ALLOWED',
             timestamp: new Date().toISOString(),
             branch: currentBranch,
             violations,
             warnings,
             autoFixes,
-            summary: isBlocked
+            mandatory_rules: rulesLoadedSuccessfully
+                ? { ...mandatoryRules, status: 'LOADED_OK' }
+                : mandatoryRules,
+            summary: finalBlocked
                 ? `🚫 BLOCKED: ${violations.length} violation(s). Fix before proceeding.`
-                : `🚦 ALLOWED: Gate passed.${warnings.length > 0 ? ` ${warnings.length} warning(s).` : ''}`,
-            instructions: isBlocked
+                : `🚦 ALLOWED: Gate passed. ${mandatoryRules.totalRulesCount} critical rules loaded and verified.`,
+            instructions: finalBlocked
                 ? 'DO NOT proceed with user task. Announce violations and fix them first.'
-                : 'You may proceed with user task.'
+                : `✅ ${mandatoryRules.totalRulesCount} RULES LOADED. Sample: ${mandatoryRules.rulesSample.slice(0, 2).join(' | ')}... Review ALL rules in mandatory_rules.criticalRules before ANY code generation.`
         };
     };
 
@@ -712,11 +1048,59 @@ async function aiGateCheck() {
         violations: ['❌ GATE_TIMEOUT: AI gate check timed out. Retry or run ai-start manually.'],
         warnings: [],
         autoFixes: [],
+        mandatory_rules: {
+            platforms: ['backend', 'frontend', 'ios', 'android'],
+            criticalRules: [],
+            rulesLoaded: [],
+            warning: '⚠️ AI MUST read and follow these rules before ANY code generation or modification',
+            error: 'Rules could not be loaded due to timeout'
+        },
         summary: '🚫 BLOCKED: Gate check timed out.',
         instructions: 'DO NOT proceed with user task. Retry the gate check.'
     };
 }
 
+/**
+ * Read platform rules handler - returns critical rules for a specific platform
+ */
+async function readPlatformRulesHandler(params) {
+    const platform = params.platform;
+    if (!platform) {
+        return {
+            success: false,
+            error: 'Platform is required. Use: ios, android, backend, or frontend'
+        };
+    }
+
+    try {
+        const rulesData = await loadPlatformRules([platform]);
+        const DynamicRulesLoader = require('../../application/services/DynamicRulesLoader');
+        const loader = new DynamicRulesLoader();
+        const fullContent = await loader.loadRule(`rules${platform}.mdc`);
+
+        return {
+            success: true,
+            platform,
+            rulesLoaded: true,
+            criticalRules: rulesData.criticalRules,
+            fullRulesContent: fullContent,
+            warning: `⚠️ YOU MUST FOLLOW ALL THESE RULES. Violations will block commits.`,
+            instructions: [
+                `❌ NEVER violate any rule marked with ❌ or NUNCA/PROHIBIDO`,
+                `✅ ALWAYS follow rules marked with ✅ or OBLIGATORIO/SIEMPRE`,
+                `🚨 If you violate these rules, the commit will be BLOCKED`,
+                `📝 Read the fullRulesContent carefully before generating ANY code`
+            ]
+        };
+    } catch (error) {
+        return {
+            success: false,
+            platform,
+            error: `Failed to load rules: ${error.message}`
+        };
+    }
+}
+
 /**
  * Validate and fix common issues
  */
@@ -1010,6 +1394,21 @@ async function handleMcpMessage(message) {
                             name: 'ai_gate_check',
                             description: '🚦 MANDATORY gate check',
                             inputSchema: { type: 'object', properties: {} }
+                        },
+                        {
+                            name: 'read_platform_rules',
+                            description: '📚 MANDATORY: Read platform-specific rules BEFORE any code generation. Returns critical rules that AI MUST follow.',
+                            inputSchema: {
+                                type: 'object',
+                                properties: {
+                                    platform: {
+                                        type: 'string',
+                                        enum: ['ios', 'android', 'backend', 'frontend'],
+                                        description: 'Platform to load rules for'
+                                    }
+                                },
+                                required: ['platform']
+                            }
                         }
                     ]
                 }
@@ -1043,6 +1442,9 @@ async function handleMcpMessage(message) {
                 case 'ai_gate_check':
                     result = await aiGateCheck();
                     break;
+                case 'read_platform_rules':
+                    result = await readPlatformRulesHandler(toolParams);
+                    break;
                 default:
                     return {
                         jsonrpc: '2.0',

package/scripts/hooks-system/infrastructure/shell/gitflow/gitflow-enforcer.sh

@@ -25,7 +25,6 @@ AUTO_MERGE_PR=${GITFLOW_AUTO_MERGE:-false}
 PR_BASE_BRANCH=${GITFLOW_PR_BASE:-develop}
 STRICT_ATOMIC=${GITFLOW_STRICT_ATOMIC:-true}
 REQUIRE_TEST_RELATIONS=${GITFLOW_REQUIRE_TESTS:-true}
-STRICT_CHECK=${GITFLOW_STRICT_CHECK:-false}
 
 print_section() {
   printf "${BLUE}═══════════════════════════════════════════════════════════════${NC}\n"
@@ -168,17 +167,16 @@ verify_atomic_commit() {
     return 0
   fi
 
-  local files=()
+  local -a files=()
   while IFS= read -r file; do
-    [[ -z "$file" ]] && continue
-    files+=("$file")
+    [[ -n "$file" ]] && files+=("$file")
   done < <($GIT_BIN diff --name-only "${commit}^..${commit}")
   if [[ "${#files[@]}" -eq 0 ]]; then
     return 0
   fi
 
-  local roots_list
-  roots_list=()
+  local roots_list=""
+  local root_count=0
   for file in "${files[@]}"; do
     local root="${file%%/*}"
     if [[ "$root" == "$file" ]]; then
@@ -193,36 +191,24 @@ verify_atomic_commit() {
         ;;
     esac
 
-    local seen=0
-    local existing
-    if (( ${#roots_list[@]:-0} > 0 )); then
-      for existing in "${roots_list[@]}"; do
-        if [[ "$existing" == "$root" ]]; then
-          seen=1
-          break
-        fi
-      done
-    fi
-    if [[ "$seen" -eq 0 ]]; then
-      roots_list+=("$root")
+    if [[ " $roots_list " != *" $root "* ]]; then
+      roots_list="${roots_list}${root} "
+      root_count=$((root_count + 1))
     fi
   done
 
-  local root_count=${#roots_list[@]}
   if (( root_count > 1 )); then
     local has_scripts=0
     local has_tests=0
-    for root in "${roots_list[@]}"; do
+    for root in $roots_list; do
       [[ "$root" == "scripts" ]] && has_scripts=1
       [[ "$root" == "tests" ]] && has_tests=1
     done
-    
     if [[ $has_scripts -eq 1 && $has_tests -eq 1 && $root_count -eq 2 ]]; then
       printf "${GREEN}✅ Commit %s toca scripts + tests (permitido para bugfixes/features con tests).${NC}\n" "$commit"
       return 0
     fi
-    
-    printf "${RED}❌ Commit %s toca múltiples raíces (%s). Divide los cambios en commits atómicos.${NC}\n" "$commit" "$(printf "%s " "${roots_list[@]}")"
+    printf "${RED}❌ Commit %s toca múltiples raíces (%s). Divide los cambios en commits atómicos.${NC}\n" "$commit" "$roots_list"
     return 1
   fi
   if (( root_count == 0 )); then
@@ -230,7 +216,7 @@ verify_atomic_commit() {
     return 0
   fi
   local root_name
-  for root_name in "${roots_list[@]}"; do
+  for root_name in $roots_list; do
     printf "${GREEN}✅ Commit %s cumple atomicidad (raíz %s).${NC}\n" "$commit" "$root_name"
   done
   return 0
@@ -250,10 +236,9 @@ verify_pending_commits_atomic() {
     return $?
   fi
 
-  local commits=()
+  local -a commits=()
   while IFS= read -r commit; do
-    [[ -z "$commit" ]] && continue
-    commits+=("$commit")
+    [[ -n "$commit" ]] && commits+=("$commit")
   done < <($GIT_BIN rev-list "${base_ref}..${branch}")
   local failed=0
   for commit in "${commits[@]}"; do
@@ -384,50 +369,22 @@ cmd_check() {
   local branch
   branch=$(current_branch)
   printf "${CYAN}📍 Rama actual: %s${NC}\n" "$branch"
-  local failed=0
-
-  if [[ "${STRICT_CHECK}" == "true" ]]; then
-    ensure_evidence_fresh || failed=1
-    lint_hooks_system || failed=1
-    run_mobile_checks || failed=1
-  else
-    ensure_evidence_fresh || true
-    lint_hooks_system || true
-    run_mobile_checks || true
-  fi
+  ensure_evidence_fresh || true
+  lint_hooks_system || true
+  run_mobile_checks || true
   print_sync_table
   print_cleanup_candidates
-  if [[ "${STRICT_CHECK}" == "true" ]]; then
-    verify_atomic_commit "HEAD" || failed=1
-    if [[ "$REQUIRE_TEST_RELATIONS" == "true" ]]; then
-      verify_related_files_commit "HEAD" || failed=1
-    fi
-    if ! verify_pending_commits_atomic "$branch"; then
-      failed=1
-    fi
-    if [[ "$REQUIRE_TEST_RELATIONS" == "true" ]]; then
-      if ! verify_pending_commits_related "$branch"; then
-        failed=1
-      fi
-    fi
-  else
-    verify_atomic_commit "HEAD" || true
-    if [[ "$REQUIRE_TEST_RELATIONS" == "true" ]]; then
-      verify_related_files_commit "HEAD" || true
-    fi
+  verify_atomic_commit "HEAD" || true
+  if [[ "$REQUIRE_TEST_RELATIONS" == "true" ]]; then
+    verify_related_files_commit "HEAD" || true
   fi
   local pending
   pending=$(unpushed_commits "$branch")
   if [[ "$pending" != "0" ]]; then
     printf "${YELLOW}⚠️  Commits sin subir (${pending}). Ejecuta git push.${NC}\n"
-    if [[ "${STRICT_CHECK}" == "true" ]]; then
-      failed=1
-    fi
   else
     printf "${GREEN}✅ No hay commits pendientes de push.${NC}\n"
   fi
-
-  return $failed
 }
 
 cmd_cycle() {
@@ -580,7 +537,6 @@ main() {
       ;;
   esac
 }
-
 is_test_file() {
   local file="$1"
   case "$file" in
@@ -681,14 +637,12 @@ verify_pending_commits_related() {
   local base_ref="origin/${branch}"
 
   if ! $GIT_BIN show-ref --verify --quiet "refs/remotes/origin/${branch}"; then
-    verify_related_files_commit "HEAD"
-    return $?
+    return verify_related_files_commit "HEAD"
   fi
 
-  local commits=()
+  local -a commits=()
   while IFS= read -r commit; do
-    [[ -z "$commit" ]] && continue
-    commits+=("$commit")
+    [[ -n "$commit" ]] && commits+=("$commit")
   done < <($GIT_BIN rev-list "${base_ref}..${branch}")
   local failed=0
   local commit