pumuki 6.3.128 → 6.3.129

package/core/rules/presets/heuristics/android.test.ts

@@ -3,13 +3,24 @@ import test from 'node:test';
 import { androidRules } from './android';
 
 test('androidRules define reglas heurísticas locked para plataforma android', () => {
-  assert.equal(androidRules.length, 3);
+  assert.equal(androidRules.length, 14);
 
   const ids = androidRules.map((rule) => rule.id);
   assert.deepEqual(ids, [
     'heuristics.android.thread-sleep.ast',
     'heuristics.android.globalscope.ast',
     'heuristics.android.run-blocking.ast',
+    'heuristics.android.force-unwrap.ast',
+    'heuristics.android.java-source.ast',
+    'heuristics.android.asynctask-deprecated.ast',
+    'heuristics.android.findviewbyid.ast',
+    'heuristics.android.rxjava-new-code.ast',
+    'heuristics.android.dispatchers-main-ui-io-network-disk-default-cpu.ast',
+    'heuristics.android.withcontext-change-dispatcher.ast',
+    'heuristics.android.no-console-log.ast',
+    'heuristics.android.hardcoded-strings.ast',
+    'heuristics.android.no-singleton.ast',
+    'heuristics.android.try-catch-manejo-de-errores-en-coroutines.ast',
   ]);
 
   const byId = new Map(androidRules.map((rule) => [rule.id, rule]));
@@ -25,6 +36,50 @@ test('androidRules define reglas heurísticas locked para plataforma android', (
     byId.get('heuristics.android.run-blocking.ast')?.then.code,
     'HEURISTICS_ANDROID_RUN_BLOCKING_AST'
   );
+  assert.equal(
+    byId.get('heuristics.android.force-unwrap.ast')?.then.code,
+    'HEURISTICS_ANDROID_FORCE_UNWRAP_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.java-source.ast')?.then.code,
+    'HEURISTICS_ANDROID_JAVA_SOURCE_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.asynctask-deprecated.ast')?.then.code,
+    'HEURISTICS_ANDROID_ASYNCTASK_DEPRECATED_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.findviewbyid.ast')?.then.code,
+    'HEURISTICS_ANDROID_FINDVIEWBYID_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.rxjava-new-code.ast')?.then.code,
+    'HEURISTICS_ANDROID_RXJAVA_NEW_CODE_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.dispatchers-main-ui-io-network-disk-default-cpu.ast')?.then.code,
+    'HEURISTICS_ANDROID_DISPATCHERS_MAIN_UI_IO_NETWORK_DISK_DEFAULT_CPU_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.withcontext-change-dispatcher.ast')?.then.code,
+    'HEURISTICS_ANDROID_WITHCONTEXT_CHANGE_DISPATCHER_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.no-console-log.ast')?.then.code,
+    'HEURISTICS_ANDROID_NO_CONSOLE_LOG_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.hardcoded-strings.ast')?.then.code,
+    'HEURISTICS_ANDROID_HARDCODED_STRINGS_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.no-singleton.ast')?.then.code,
+    'HEURISTICS_ANDROID_NO_SINGLETON_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.try-catch-manejo-de-errores-en-coroutines.ast')?.then.code,
+    'HEURISTICS_ANDROID_TRY_CATCH_MANEJO_DE_ERRORES_EN_COROUTINES_AST'
+  );
 
   for (const rule of androidRules) {
     assert.equal(rule.platform, 'android');

package/core/rules/presets/heuristics/android.ts

@@ -55,4 +55,204 @@ export const androidRules: RuleSet = [
       code: 'HEURISTICS_ANDROID_RUN_BLOCKING_AST',
     },
   },
+  {
+    id: 'heuristics.android.force-unwrap.ast',
+    description: 'Detects Kotlin force unwrap (!!) usage in Android production files.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.force-unwrap.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected Kotlin force unwrap (!!) usage in production code.',
+      code: 'HEURISTICS_ANDROID_FORCE_UNWRAP_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.java-source.ast',
+    description: 'Detects Java source in Android production code where Kotlin is required.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.java-source.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected Java source in Android production code where Kotlin is required for new code.',
+      code: 'HEURISTICS_ANDROID_JAVA_SOURCE_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.asynctask-deprecated.ast',
+    description: 'Detects AsyncTask usage in Android production code where Coroutines are required.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.asynctask-deprecated.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected AsyncTask usage in Android production code where Coroutines are required.',
+      code: 'HEURISTICS_ANDROID_ASYNCTASK_DEPRECATED_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.findviewbyid.ast',
+    description: 'Detects findViewById usage in Android production code where View Binding or Compose is required.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.findviewbyid.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected findViewById usage in Android production code where View Binding or Compose is required.',
+      code: 'HEURISTICS_ANDROID_FINDVIEWBYID_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.rxjava-new-code.ast',
+    description: 'Detects RxJava usage in Android production code where Flow is required for new code.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.rxjava-new-code.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected RxJava usage in Android production code where Flow is required for new code.',
+      code: 'HEURISTICS_ANDROID_RXJAVA_NEW_CODE_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.dispatchers-main-ui-io-network-disk-default-cpu.ast',
+    description:
+      'Detects explicit Dispatchers.Main/IO/Default usage in Android production code where dispatcher selection must remain intentional.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.dispatchers-main-ui-io-network-disk-default-cpu.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message:
+        'AST heuristic detected explicit Dispatchers.Main/IO/Default usage in Android production code where dispatcher selection must remain intentional.',
+      code: 'HEURISTICS_ANDROID_DISPATCHERS_MAIN_UI_IO_NETWORK_DISK_DEFAULT_CPU_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.withcontext-change-dispatcher.ast',
+    description: 'Detects withContext usage in Android production code where dispatcher switching is intentional.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.withcontext-change-dispatcher.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected withContext usage in Android production code where dispatcher switching is intentional.',
+      code: 'HEURISTICS_ANDROID_WITHCONTEXT_CHANGE_DISPATCHER_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.no-console-log.ast',
+    description: 'Detects Android logging usage in production code without a debug-only guard.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.no-console-log.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected Android logging usage in production code without a debug-only guard.',
+      code: 'HEURISTICS_ANDROID_NO_CONSOLE_LOG_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.hardcoded-strings.ast',
+    description: 'Detects hardcoded string literal usage in Android production code where strings.xml should be used.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.hardcoded-strings.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected hardcoded string literal usage in Android production code where strings.xml should be used.',
+      code: 'HEURISTICS_ANDROID_HARDCODED_STRINGS_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.no-singleton.ast',
+    description: 'Detects Kotlin singleton object or companion singleton holder usage in Android production code where Hilt or Dagger DI should be used.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.no-singleton.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected Kotlin singleton object or companion singleton holder usage in Android production code where Hilt or Dagger DI should be used.',
+      code: 'HEURISTICS_ANDROID_NO_SINGLETON_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.try-catch-manejo-de-errores-en-coroutines.ast',
+    description: 'Detects try/catch usage in Android coroutine code where error handling must remain explicit.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.try-catch-manejo-de-errores-en-coroutines.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected try/catch usage in Android coroutine code where error handling must remain explicit.',
+      code: 'HEURISTICS_ANDROID_TRY_CATCH_MANEJO_DE_ERRORES_EN_COROUTINES_AST',
+    },
+  },
 ];

package/docs/operations/RELEASE_NOTES.md

@@ -4,6 +4,12 @@ This file tracks the active deterministic framework line used in this repository
 Canonical release chronology lives in `CHANGELOG.md`.
 This file keeps only the operational highlights and rollout notes that matter while running the framework.
 
+### 2026-04-29 (v6.3.129)
+
+- **Singletons Android con detector AST real:** `skills.android.no-singleton-usar-inyeccio-n-de-dependencias-hilt-dagger` queda vinculada a un detector que distingue singleton real de `@Module` / `@InstallIn` / `@EntryPoint`.
+- **Regresión cerrada en la suite Android:** el caso de objetos anónimos y companion objects inocuos queda cubierto y la compilación del lock vuelve a producir el binding canónico.
+- **Rollout recomendado:** publicar `pumuki@6.3.129`, repin inmediato en `RuralGo` y revalidar `status` / `doctor` / `audit --stage=PRE_WRITE --json` sobre el consumer.
+
 ## 2026-04 (CLI stability and macOS notifications)
 
 ### 2026-04-25 (v6.3.116)

package/docs/product/CONFIGURATION.md

@@ -66,6 +66,14 @@ Current enforcement scope:
 - curated template compilation (`skills.sources.json` -> `skills.lock.json`)
 - stage-aware policy resolution via `resolvePolicyForStage`
 - additive skills-derived rules merged through the shared gate runner
+- strict skills enforcement by default; `PUMUKI_SKILLS_ENFORCEMENT=advisory`
+  is an explicit opt-in escape hatch, not the product baseline
+- strict heuristics, TDD/BDD evidence, SDD completeness, and Git atomicity by
+  default; their `advisory`/`0` env values are explicit legacy overrides, not
+  the product baseline
+- declarative skill rules that represent auditable norms must be mapped to an
+  intelligent AST detector; missing detector bindings are reported as
+  `unsupported_detector_rule_ids` and block strict gate execution
 - evidence traceability for active skills bundles and policy source/hash in `.ai_evidence.json`
 
 Ownership model:

package/integrations/config/skillsCompilerTemplates.test.ts

@@ -67,3 +67,17 @@ test('skillsCompilerTemplates mantiene bundles iOS enterprise esperados', () =>
     assert.equal(bundle.rules.every((rule) => rule.platform === 'ios'), true);
   }
 });
+
+test('skillsCompilerTemplates mantiene el bundle Android baseline esperado', () => {
+  const bundle = skillsCompilerTemplates['android-guidelines'];
+  assert.ok(bundle, 'Missing Android bundle: android-guidelines');
+  assert.deepEqual(bundle.rules.map((rule) => rule.id), [
+    'skills.android.no-thread-sleep',
+    'skills.android.no-globalscope',
+    'skills.android.no-console-log',
+    'skills.android.hardcoded-strings-usar-strings-xml',
+    'skills.android.no-singleton-usar-inyeccio-n-de-dependencias-hilt-dagger',
+    'skills.android.no-runblocking',
+  ]);
+  assert.equal(bundle.rules.every((rule) => rule.platform === 'android'), true);
+});

package/integrations/config/skillsCompilerTemplates.ts

@@ -565,6 +565,33 @@ export const skillsCompilerTemplates: Record<string, SkillsCompilerTemplate> = {
         stage: 'PRE_PUSH',
         locked: true,
       },
+      {
+        id: 'skills.android.no-console-log',
+        description: 'Disallow logs in Android production code.',
+        severity: 'ERROR',
+        platform: 'android',
+        confidence: 'HIGH',
+        stage: 'PRE_PUSH',
+        locked: true,
+      },
+      {
+        id: 'skills.android.hardcoded-strings-usar-strings-xml',
+        description: 'Disallow hardcoded strings in Android production code.',
+        severity: 'ERROR',
+        platform: 'android',
+        confidence: 'HIGH',
+        stage: 'PRE_PUSH',
+        locked: true,
+      },
+      {
+        id: 'skills.android.no-singleton-usar-inyeccio-n-de-dependencias-hilt-dagger',
+        description: 'Disallow singleton object patterns in Android production code; use Hilt or Dagger DI.',
+        severity: 'ERROR',
+        platform: 'android',
+        confidence: 'HIGH',
+        stage: 'PRE_PUSH',
+        locked: true,
+      },
       {
         id: 'skills.android.no-runblocking',
         description: 'Disallow runBlocking in Android production code.',

package/integrations/config/skillsDetectorRegistry.ts

@@ -210,6 +210,42 @@ const registryByRuleId: Record<string, SkillsDetectorBinding> = {
   'skills.android.no-runblocking': heuristicDetector('android.run-blocking', [
     'heuristics.android.run-blocking.ast',
   ]),
+  'skills.android.no-force-unwrap': heuristicDetector('android.force-unwrap', [
+    'heuristics.android.force-unwrap.ast',
+  ]),
+  'skills.android.no-java-new-code': heuristicDetector('android.java-source', [
+    'heuristics.android.java-source.ast',
+  ]),
+  'skills.android.asynctask-deprecated-usar-coroutines': heuristicDetector('android.asynctask', [
+    'heuristics.android.asynctask-deprecated.ast',
+  ]),
+  'skills.android.findviewbyid-view-binding-o-compose': heuristicDetector('android.findviewbyid', [
+    'heuristics.android.findviewbyid.ast',
+  ]),
+  'skills.android.rxjava-new-code': heuristicDetector('android.rxjava-new-code', [
+    'heuristics.android.rxjava-new-code.ast',
+  ]),
+  'skills.android.dispatchers-main-ui-io-network-disk-default-cpu': heuristicDetector(
+    'android.dispatchers-main-ui-io-network-disk-default-cpu',
+    ['heuristics.android.dispatchers-main-ui-io-network-disk-default-cpu.ast']
+  ),
+  'skills.android.withcontext-change-dispatcher': heuristicDetector('android.withcontext-change-dispatcher', [
+    'heuristics.android.withcontext-change-dispatcher.ast',
+  ]),
+  'skills.android.no-console-log': heuristicDetector('android.no-console-log', [
+    'heuristics.android.no-console-log.ast',
+  ]),
+  'skills.android.hardcoded-strings-usar-strings-xml': heuristicDetector('android.hardcoded-strings', [
+    'heuristics.android.hardcoded-strings.ast',
+  ]),
+  'skills.android.no-singleton-usar-inyeccio-n-de-dependencias-hilt-dagger': heuristicDetector(
+    'android.no-singleton',
+    ['heuristics.android.no-singleton.ast']
+  ),
+  'skills.android.try-catch-manejo-de-errores-en-coroutines': heuristicDetector(
+    'android.try-catch-manejo-de-errores-en-coroutines',
+    ['heuristics.android.try-catch-manejo-de-errores-en-coroutines.ast']
+  ),
 };
 
 export const listSkillsDetectorBindings = (): ReadonlyArray<{

package/integrations/config/skillsMarkdownRules.ts

@@ -192,7 +192,12 @@ const normalizeKnownRuleTarget = (
   const includes = (needle: string): boolean => normalizedDescription.includes(needle);
 
   if (platform === 'ios') {
-    if (includes('force unwrap')) {
+    if (
+      includes('force unwrap') ||
+      includes('force unwrapping') ||
+      includes('no force unwrap') ||
+      includes('no force unwrapping')
+    ) {
       return 'skills.ios.no-force-unwrap';
     }
     if (includes('force try')) {
@@ -354,8 +359,10 @@ const normalizeKnownRuleTarget = (
       includes('prefer import testing') ||
       includes('prefer test functions over test methods') ||
       includes('test functions over test methods') ||
+      includes('new xctest only unit tests') ||
       includes('xctest-only unit tests') ||
       includes('new xctest-only unit tests') ||
+      includes('xctest solo para proyectos legacy') ||
       includes('xctest only for ui') ||
       includes('xctest only for ui performance')
     ) {
@@ -426,12 +433,111 @@ const normalizeKnownRuleTarget = (
   }
 
   if (platform === 'android') {
+    if (
+      includes('asynctask') ||
+      includes('deprecated, usar coroutines') ||
+      includes('usar coroutines')
+    ) {
+      return 'skills.android.asynctask-deprecated-usar-coroutines';
+    }
+    if (
+      includes('java en codigo nuevo') ||
+      includes('java en co digo nuevo') ||
+      includes('no java en codigo nuevo') ||
+      includes('no java en co digo nuevo') ||
+      includes('solo kotlin') ||
+      includes('kotlin para todo')
+    ) {
+      return 'skills.android.no-java-new-code';
+    }
+    if (
+      includes('rxjava') ||
+      includes('usar flow') ||
+      includes('usar flows') ||
+      includes('flow en nuevo codigo') ||
+      includes('flow en nuevo co digo')
+    ) {
+      return 'skills.android.rxjava-new-code';
+    }
+    if (
+      includes('dispatchers') ||
+      includes('dispatcher') ||
+      includes('main ui') ||
+      includes('io network') ||
+      includes('default cpu') ||
+      includes('withcontext')
+    ) {
+      if (includes('withcontext') || includes('cambiar dispatcher')) {
+        return 'skills.android.withcontext-change-dispatcher';
+      }
+      return 'skills.android.dispatchers-main-ui-io-network-disk-default-cpu';
+    }
+    if (
+      includes('try-catch') ||
+      includes('manejo de errores en coroutines') ||
+      includes('errores en coroutines') ||
+      includes('error handling in coroutines')
+    ) {
+      return 'skills.android.try-catch-manejo-de-errores-en-coroutines';
+    }
+    if (
+      includes('findviewbyid') ||
+      includes('view binding') ||
+      includes('viewbinding') ||
+      includes('compose') ||
+      includes('no xml layouts') ||
+      includes('xml layouts')
+    ) {
+      return 'skills.android.findviewbyid-view-binding-o-compose';
+    }
+    if (
+      includes('force unwrap') ||
+      includes('force unwrapping') ||
+      includes('no force unwrap') ||
+      includes('no force unwrapping')
+    ) {
+      return 'skills.android.no-force-unwrap';
+    }
     if (includes('thread sleep') || includes('thread.sleep')) {
       return 'skills.android.no-thread-sleep';
     }
     if (includes('globalscope') || includes('global scope')) {
       return 'skills.android.no-globalscope';
     }
+    if (
+      includes('console log') ||
+      includes('console.log') ||
+      includes('logs ad-hoc') ||
+      includes('no logs en produccion') ||
+      includes('no logs en producción') ||
+      includes('no logs en produccio n') ||
+      includes('timber.d') ||
+      includes('buildconfig.debug') ||
+      includes('android.util.log')
+    ) {
+      return 'skills.android.no-console-log';
+    }
+    if (
+      includes('no singleton') ||
+      includes('singleton') ||
+      includes('singletons everywhere') ||
+      includes('hilt dagger') ||
+      includes('hilt/dagger') ||
+      includes('inyeccion de dependencias') ||
+      includes('inyecion de dependencias') ||
+      includes('usar inyeccion de dependencias') ||
+      includes('usar inyecion de dependencias')
+    ) {
+      return 'skills.android.no-singleton-usar-inyeccio-n-de-dependencias-hilt-dagger';
+    }
+    if (
+      includes('hardcoded strings') ||
+      includes('hardcoded string') ||
+      includes('usar strings.xml') ||
+      includes('usar strings xml')
+    ) {
+      return 'skills.android.hardcoded-strings-usar-strings-xml';
+    }
     if (includes('runblocking') || includes('run blocking')) {
       return 'skills.android.no-runblocking';
     }
@@ -440,22 +546,86 @@ const normalizeKnownRuleTarget = (
 
   if (platform === 'backend' || platform === 'frontend') {
     const prefix = platform === 'backend' ? 'skills.backend' : 'skills.frontend';
-    if (includes('solid') || includes('single responsibility') || includes('srp')) {
+    if (
+      includes('solid') ||
+      includes('single responsibility') ||
+      includes('srp') ||
+      includes('controllers delgados') ||
+      includes('logic in controllers') ||
+      includes('lo gica en controllers') ||
+      includes('lógica en controllers') ||
+      includes('mover a servicios') ||
+      includes('componentes pequeños') ||
+      includes('componentes pequen os') ||
+      includes('custom hooks para logica reutilizable') ||
+      includes('custom hooks para lógica reutilizable') ||
+      includes('prop drilling excesivo') ||
+      includes('anemic domain models') ||
+      includes('entidades solo con getters') ||
+      includes('no logica de negocio en repositorios') ||
+      includes('no lógica de negocio en repositorios')
+    ) {
       return `${prefix}.no-solid-violations`;
     }
-    if (includes('clean architecture')) {
+    if (
+      includes('clean architecture') ||
+      includes('clean code') ||
+      includes('clean por feature') ||
+      includes('domain application infrastructure presentation') ||
+      includes('presentation application domain infrastructure') ||
+      includes('dependencias hacia adentro') ||
+      includes('capas presentacion') ||
+      includes('capas presentación') ||
+      includes('infrastructure domain') ||
+      includes('feature first') ||
+      includes('bounded context') ||
+      includes('shared kernel')
+    ) {
       return `${prefix}.enforce-clean-architecture`;
     }
-    if (includes('god classes') || includes('god class')) {
+    if (
+      includes('god classes') ||
+      includes('god class') ||
+      includes('servicios que mezclan responsabilidades') ||
+      includes('mezclan responsabilidades') ||
+      includes('modulos cohesivos') ||
+      includes('módulos cohesivos') ||
+      includes('mo dulos cohesivos') ||
+      includes('un modulo por feature') ||
+      includes('un módulo por feature') ||
+      includes('un mo dulo por feature')
+    ) {
       return `${prefix}.no-god-classes`;
     }
-    if (includes('empty catch')) {
+    if (
+      includes('empty catch') ||
+      includes('catch vacios') ||
+      includes('catch vacíos') ||
+      includes('try-catch silenciosos') ||
+      includes('silenciar errores') ||
+      includes('siempre loggear o propagar')
+    ) {
       return `${prefix}.no-empty-catch`;
     }
-    if (includes('console log') || includes('console.log')) {
+    if (
+      includes('console log') ||
+      includes('console.log') ||
+      includes('logs ad-hoc') ||
+      includes('no logs en produccion') ||
+      includes('no logs en producción') ||
+      includes('no logs en produccio n')
+    ) {
       return `${prefix}.no-console-log`;
     }
-    if (includes('explicit any') || includes(' no any') || includes('avoid any')) {
+    if (
+      includes('explicit any') ||
+      includes(' no any') ||
+      includes('avoid any') ||
+      includes('usar unknown') ||
+      includes('type guard') ||
+      includes('tipos explicitos') ||
+      includes('tipos explícitos')
+    ) {
       return `${prefix}.avoid-explicit-any`;
     }
     return null;

package/integrations/config/skillsRuleSet.ts

@@ -21,6 +21,7 @@ export type SkillsRuleSetLoadResult = {
   mappedHeuristicRuleIds: ReadonlySet<string>;
   requiresHeuristicFacts: boolean;
   unsupportedAutoRuleIds?: ReadonlyArray<string>;
+  unsupportedDetectorRuleIds?: ReadonlyArray<string>;
   registryCoverage?: {
     contract: 'AUTO_RUNTIME_RULES_FOR_STAGE';
     stage: Exclude<GateStage, 'STAGED'>;
@@ -502,6 +503,7 @@ const emptyResult = (): SkillsRuleSetLoadResult => {
     mappedHeuristicRuleIds: new Set<string>(),
     requiresHeuristicFacts: false,
     unsupportedAutoRuleIds: [],
+    unsupportedDetectorRuleIds: [],
   };
 };
 
@@ -534,6 +536,7 @@ export const loadSkillsRuleSetForStage = (
   const rulesById = new Map<string, RuleDefinition>();
   const mappedHeuristicRuleIds = new Set<string>();
   const unsupportedAutoRuleIds = new Set<string>();
+  const unsupportedDetectorRuleIds = new Set<string>();
   const registryRuleIds = new Set<string>();
   const registryAutoRuleIds = new Set<string>();
   const registryDeclarativeRuleIds = new Set<string>();
@@ -565,11 +568,13 @@ export const loadSkillsRuleSetForStage = (
         continue;
       }
       if (evaluationMode !== 'AUTO') {
+        unsupportedDetectorRuleIds.add(compiledRule.id);
         continue;
       }
       stageApplicableAutoRuleIds.add(compiledRule.id);
       if (evaluationMode === 'AUTO' && mappedRuleIds.length === 0) {
         unsupportedAutoRuleIds.add(compiledRule.id);
+        unsupportedDetectorRuleIds.add(compiledRule.id);
         continue;
       }
 
@@ -602,6 +607,7 @@ export const loadSkillsRuleSetForStage = (
     mappedHeuristicRuleIds,
     requiresHeuristicFacts: mappedHeuristicRuleIds.size > 0,
     unsupportedAutoRuleIds: [...unsupportedAutoRuleIds].sort(),
+    unsupportedDetectorRuleIds: [...unsupportedDetectorRuleIds].sort(),
     registryCoverage: {
       contract: 'AUTO_RUNTIME_RULES_FOR_STAGE',
       stage,