pumuki 6.3.127 → 6.3.129

package/CHANGELOG.md

@@ -6,6 +6,14 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [6.3.129] - 2026-04-29
+
+### Fixed
+
+- **Nueva slice Android de singletons cerrada:** `skills.android.no-singleton-usar-inyeccio-n-de-dependencias-hilt-dagger` pasa a detector AST real y deja de depender de normalización genérica.
+- **Exclusión correcta de módulos DI:** `@Module`, `@InstallIn` y `@EntryPoint` ya no disparan el detector de singleton cuando el `object` es un módulo de inyección legítimo.
+- **Cobertura de regresión y lock recompilado:** la suite Android dirigida vuelve a verde y `skills.lock.json` se regenera con el binding canónico de la nueva skill.
+
 ## [6.3.127] - 2026-04-28
 
 ### Fixed

package/VERSION

@@ -1 +1 @@
-v6.3.127
+v6.3.128

package/core/facts/detectors/text/android.test.ts

@@ -6,6 +6,17 @@ import {
   findKotlinLiskovSubstitutionMatch,
   findKotlinOpenClosedWhenMatch,
   findKotlinPresentationSrpMatch,
+  hasAndroidAsyncTaskUsage,
+  hasAndroidFindViewByIdUsage,
+  hasAndroidJavaSourceCode,
+  hasAndroidDispatcherUsage,
+  hasAndroidCoroutineTryCatchUsage,
+  hasAndroidHardcodedStringUsage,
+  hasAndroidNoConsoleLogUsage,
+  hasAndroidRxJavaUsage,
+  hasAndroidSingletonUsage,
+  hasAndroidWithContextUsage,
+  hasKotlinForceUnwrapUsage,
   hasKotlinGlobalScopeUsage,
   hasKotlinRunBlockingUsage,
   hasKotlinThreadSleepCall,
@@ -91,6 +102,263 @@ fun main() {
   assert.equal(hasKotlinRunBlockingUsage(partialSource), false);
 });
 
+test('hasKotlinForceUnwrapUsage detecta operador !! en codigo Kotlin real', () => {
+  const source = `
+fun renderName(user: User?) {
+  val name = user!!.name
+  println(name)
+}
+`;
+  assert.equal(hasKotlinForceUnwrapUsage(source), true);
+});
+
+test('hasKotlinForceUnwrapUsage ignora comentarios, strings y operador !=', () => {
+  const source = `
+// val name = user!!.name
+val debug = "user!!.name"
+fun isDifferent(left: String?, right: String?) = left != right
+`;
+  assert.equal(hasKotlinForceUnwrapUsage(source), false);
+});
+
+test('hasAndroidJavaSourceCode detecta codigo Java real', () => {
+  const source = `
+package com.acme.orders;
+
+public class OrdersActivity {
+}
+`;
+  assert.equal(hasAndroidJavaSourceCode(source), true);
+});
+
+test('hasAndroidJavaSourceCode ignora menciones Java en comentarios y strings', () => {
+  const source = `
+// public class OrdersActivity {}
+val sample = "class OrdersActivity"
+`;
+  assert.equal(hasAndroidJavaSourceCode(source), false);
+});
+
+test('hasAndroidAsyncTaskUsage detecta AsyncTask real en codigo Android', () => {
+  const source = `
+import android.os.AsyncTask
+
+class LoadDataTask : AsyncTask<Unit, Unit, String>() {
+  override fun doInBackground(vararg params: Unit): String = "ok"
+}
+`;
+  assert.equal(hasAndroidAsyncTaskUsage(source), true);
+});
+
+test('hasAndroidAsyncTaskUsage ignora comentarios, strings y nombres parciales', () => {
+  const source = `
+// AsyncTask should be removed
+val sample = "AsyncTask"
+class AsyncTaskRunner
+`;
+  assert.equal(hasAndroidAsyncTaskUsage(source), false);
+});
+
+test('hasAndroidFindViewByIdUsage detecta findViewById real en codigo Android', () => {
+  const source = `
+class HomeActivity : AppCompatActivity() {
+  fun render() {
+    val title = findViewById<TextView>(R.id.title)
+  }
+}
+`;
+  assert.equal(hasAndroidFindViewByIdUsage(source), true);
+});
+
+test('hasAndroidFindViewByIdUsage ignora comentarios, strings y nombres parciales', () => {
+  const source = `
+// findViewById<TextView>(R.id.title)
+val sample = "findViewById"
+class FindViewByIdHelper
+`;
+  assert.equal(hasAndroidFindViewByIdUsage(source), false);
+});
+
+test('hasAndroidRxJavaUsage detecta RxJava real en codigo Android', () => {
+  const source = `
+import io.reactivex.rxjava3.core.Observable
+
+class HomeRepository {
+  fun load() = Observable.just("ok")
+}
+`;
+  assert.equal(hasAndroidRxJavaUsage(source), true);
+});
+
+test('hasAndroidRxJavaUsage ignora comentarios, strings y nombres parciales', () => {
+  const source = `
+// Observable.just("ok")
+val sample = "RxJava"
+class ObservableHelper
+`;
+  assert.equal(hasAndroidRxJavaUsage(source), false);
+});
+
+test('hasAndroidDispatcherUsage detecta Dispatchers reales en codigo Android', () => {
+  const source = `
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+suspend fun load() = withContext(Dispatchers.IO) {
+  "ok"
+}
+`;
+  assert.equal(hasAndroidDispatcherUsage(source), true);
+});
+
+test('hasAndroidDispatcherUsage ignora comentarios, strings y nombres parciales', () => {
+  const source = `
+// withContext(Dispatchers.IO)
+val sample = "Dispatchers.Main"
+class DispatchersHelper
+`;
+  assert.equal(hasAndroidDispatcherUsage(source), false);
+});
+
+test('hasAndroidWithContextUsage detecta withContext real en codigo Android', () => {
+  const source = `
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+suspend fun load() = withContext(Dispatchers.IO) {
+  "ok"
+}
+`;
+  assert.equal(hasAndroidWithContextUsage(source), true);
+});
+
+test('hasAndroidWithContextUsage ignora comentarios, strings y nombres parciales', () => {
+  const source = `
+// withContext(Dispatchers.IO)
+val sample = "withContext"
+class WithContextHelper
+`;
+  assert.equal(hasAndroidWithContextUsage(source), false);
+});
+
+test('hasAndroidCoroutineTryCatchUsage detecta try-catch real en codigo coroutine Android', () => {
+  const source = `
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+suspend fun load() {
+  try {
+    withContext(Dispatchers.IO) { }
+  } catch (e: Exception) {
+    throw e
+  }
+}
+`;
+  assert.equal(hasAndroidCoroutineTryCatchUsage(source), true);
+});
+
+test('hasAndroidCoroutineTryCatchUsage ignora comentarios, strings y codigo no coroutine', () => {
+  const source = `
+// try { withContext(Dispatchers.IO) } catch (e: Exception) {}
+val sample = "try catch"
+fun notCoroutine() {
+  try {
+    println("ok")
+  } catch (e: Exception) {
+    println(e)
+  }
+}
+`;
+  assert.equal(hasAndroidCoroutineTryCatchUsage(source), false);
+});
+
+test('hasAndroidNoConsoleLogUsage detecta logs reales en codigo Android y permite debug guards', () => {
+  const source = `
+import timber.log.Timber
+
+fun render() {
+  Timber.d("visible in production")
+  if (BuildConfig.DEBUG) Timber.d("visible in debug only")
+  if (BuildConfig.DEBUG) {
+    Log.d("Tag", "debug only")
+  }
+}
+`;
+  assert.equal(hasAndroidNoConsoleLogUsage(source), true);
+});
+
+test('hasAndroidNoConsoleLogUsage ignora comentarios, strings y logs protegidos por BuildConfig.DEBUG', () => {
+  const source = `
+// Timber.d("debug")
+val sample = "Log.e(\\"Tag\\", \\"debug\\")"
+fun render() {
+  if (BuildConfig.DEBUG) Timber.d("debug only")
+  if (BuildConfig.DEBUG) {
+    Log.e("Tag", "debug only")
+  }
+}
+`;
+  assert.equal(hasAndroidNoConsoleLogUsage(source), false);
+});
+
+test('hasAndroidHardcodedStringUsage detecta strings hardcodeadas en codigo Android', () => {
+  const source = `
+fun render() {
+  val title = "Hola mundo"
+}
+`;
+  assert.equal(hasAndroidHardcodedStringUsage(source), true);
+});
+
+test('hasAndroidHardcodedStringUsage ignora comentarios y referencias a resources', () => {
+  const source = `
+// "Hola mundo"
+fun render() {
+  val title = R.string.app_name
+}
+`;
+  assert.equal(hasAndroidHardcodedStringUsage(source), false);
+});
+
+test('hasAndroidSingletonUsage detecta object declarations y companion singleton holders', () => {
+  const source = `
+object SessionManager {
+  fun refresh() {}
+}
+
+class HomeRepository private constructor() {
+  companion object {
+    @Volatile private var INSTANCE: HomeRepository? = null
+
+    fun getInstance(): HomeRepository {
+      return INSTANCE ?: HomeRepository()
+    }
+  }
+}
+`;
+  assert.equal(hasAndroidSingletonUsage(source), true);
+});
+
+test('hasAndroidSingletonUsage ignora anonymous objects y companion objects inocuos', () => {
+  const source = `
+val listener = object : Runnable {
+  override fun run() {}
+}
+
+@Module
+object NetworkModule {
+  fun provideClient(): String = "ok"
+}
+
+class Themes {
+  companion object {
+    const val DEFAULT = "dark"
+  }
+}
+`;
+  assert.equal(hasAndroidSingletonUsage(source), false);
+});
+
 test('findKotlinPresentationSrpMatch devuelve payload semantico para SRP-Android en presentation', () => {
   const source = `
 import android.content.SharedPreferences

package/core/facts/detectors/text/android.ts

@@ -292,6 +292,346 @@ export const hasKotlinRunBlockingUsage = (source: string): boolean => {
   });
 };
 
+export const hasKotlinForceUnwrapUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: kotlinSource, index, current }) => {
+    if (current !== '!' || kotlinSource[index + 1] !== '!') {
+      return false;
+    }
+
+    return kotlinSource[index + 2] !== '=';
+  });
+};
+
+export const hasAndroidJavaSourceCode = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: javaSource, index, current }) => {
+    if (!/[a-zA-Z_]/.test(current)) {
+      return false;
+    }
+
+    const tail = javaSource.slice(index, index + 32);
+    return /^(package|import|class|interface|enum|record)\b/.test(tail);
+  });
+};
+
+export const hasAndroidAsyncTaskUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: androidSource, index, current }) => {
+    if (current !== 'A') {
+      return false;
+    }
+
+    return hasIdentifierAt(androidSource, index, 'AsyncTask');
+  });
+};
+
+export const hasAndroidFindViewByIdUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: androidSource, index, current }) => {
+    if (current !== 'f') {
+      return false;
+    }
+
+    return hasIdentifierAt(androidSource, index, 'findViewById');
+  });
+};
+
+export const hasAndroidRxJavaUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: androidSource, index, current }) => {
+    if (current === 'i' && androidSource.startsWith('io.reactivex', index)) {
+      return true;
+    }
+
+    if (current === 'r' && androidSource.startsWith('rx.', index)) {
+      return true;
+    }
+
+    const rxJavaIdentifiers = [
+      'Observable',
+      'Flowable',
+      'Single',
+      'Maybe',
+      'Completable',
+      'Disposable',
+      'CompositeDisposable',
+      'Subject',
+      'PublishSubject',
+      'BehaviorSubject',
+      'ReplaySubject',
+      'ConnectableObservable',
+    ];
+
+    return rxJavaIdentifiers.some((identifier) => {
+      return current === identifier[0] && hasIdentifierAt(androidSource, index, identifier);
+    });
+  });
+};
+
+export const hasAndroidDispatcherUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: androidSource, index, current }) => {
+    if (current !== 'D' || !hasIdentifierAt(androidSource, index, 'Dispatchers')) {
+      return false;
+    }
+
+    const start = index + 'Dispatchers'.length;
+    const tail = androidSource.slice(start, start + 32);
+    return /^\s*\.(Main|IO|Default)\b/.test(tail);
+  });
+};
+
+export const hasAndroidWithContextUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: androidSource, index, current }) => {
+    if (current !== 'w' || !hasIdentifierAt(androidSource, index, 'withContext')) {
+      return false;
+    }
+
+    const start = index + 'withContext'.length;
+    const tail = androidSource.slice(start, start + 48);
+    return /^\s*(<[^>\n]+>\s*)?\(/.test(tail);
+  });
+};
+
+export const hasAndroidCoroutineTryCatchUsage = (source: string): boolean => {
+  const hasCoroutineContextHint = scanCodeLikeSource(source, ({ source: androidSource, index, current }) => {
+    if (current === 'w' && hasIdentifierAt(androidSource, index, 'withContext')) {
+      return true;
+    }
+
+    if (current === 'D' && hasIdentifierAt(androidSource, index, 'Dispatchers')) {
+      return true;
+    }
+
+    if (current === 'v' && hasIdentifierAt(androidSource, index, 'viewModelScope')) {
+      return true;
+    }
+
+    if (current === 'l' && hasIdentifierAt(androidSource, index, 'lifecycleScope')) {
+      return true;
+    }
+
+    if (current === 'c' && hasIdentifierAt(androidSource, index, 'coroutineScope')) {
+      return true;
+    }
+
+    if (current === 's' && hasIdentifierAt(androidSource, index, 'supervisorScope')) {
+      return true;
+    }
+
+    if (current === 'l' && hasIdentifierAt(androidSource, index, 'launch')) {
+      return true;
+    }
+
+    if (current === 'a' && hasIdentifierAt(androidSource, index, 'async')) {
+      return true;
+    }
+
+    if (current === 's' && hasIdentifierAt(androidSource, index, 'suspend')) {
+      const tail = androidSource.slice(index + 'suspend'.length, index + 'suspend'.length + 16);
+      return /^\s+fun\b/.test(tail);
+    }
+
+    return false;
+  });
+
+  if (!hasCoroutineContextHint) {
+    return false;
+  }
+
+  return scanCodeLikeSource(source, ({ source: androidSource, index, current }) => {
+    if (current !== 't' || !hasIdentifierAt(androidSource, index, 'try')) {
+      return false;
+    }
+
+    const tail = androidSource.slice(index + 'try'.length, index + 'try'.length + 192);
+    return /\bcatch\b/.test(tail);
+  });
+};
+
+const isAndroidDebugLogGuardWindow = (lines: readonly string[], lineIndex: number): boolean => {
+  const guardPattern = /\bif\s*\(\s*BuildConfig\.DEBUG\s*\)/;
+  const windowStart = Math.max(0, lineIndex - 2);
+  const window = lines
+    .slice(windowStart, lineIndex + 1)
+    .map((line) => stripKotlinLineForSemanticScan(line ?? ''))
+    .join(' ');
+  return guardPattern.test(window);
+};
+
+const hasAndroidLogCallInLine = (line: string): boolean => {
+  return /\b(?:Timber|Log)\s*\.\s*(?:v|d|i|w|e)\s*\(/.test(line);
+};
+
+export const hasAndroidNoConsoleLogUsage = (source: string): boolean => {
+  const lines = source.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const sanitizedLine = stripKotlinLineForSemanticScan(lines[index] ?? '');
+    if (sanitizedLine.trimStart().startsWith('import ')) {
+      continue;
+    }
+    if (!hasAndroidLogCallInLine(sanitizedLine)) {
+      continue;
+    }
+    if (isAndroidDebugLogGuardWindow(lines, index)) {
+      continue;
+    }
+    return true;
+  }
+
+  return false;
+};
+
+export const hasAndroidHardcodedStringUsage = (source: string): boolean => {
+  let inLineComment = false;
+  let inBlockComment = 0;
+  let inString = false;
+  let inMultilineString = false;
+  let stringStartIndex = -1;
+  let lastNonWhitespace = '';
+
+  for (let index = 0; index < source.length; index += 1) {
+    const current = source[index];
+    const next = source[index + 1];
+    const nextTwo = source[index + 2];
+
+    if (inLineComment) {
+      if (current === '\n') {
+        inLineComment = false;
+      }
+      continue;
+    }
+
+    if (inBlockComment > 0) {
+      if (current === '/' && next === '*') {
+        inBlockComment += 1;
+        index += 1;
+        continue;
+      }
+      if (current === '*' && next === '/') {
+        inBlockComment -= 1;
+        index += 1;
+        continue;
+      }
+      continue;
+    }
+
+    if (inMultilineString) {
+      if (current === '"' && next === '"' && nextTwo === '"') {
+        return true;
+      }
+      continue;
+    }
+
+    if (inString) {
+      if (current === '\\') {
+        index += 1;
+        continue;
+      }
+      if (current === '"') {
+        const previousChar = lastNonWhitespace;
+        const isInterpolationOrResource = previousChar === '.' || previousChar === ')';
+        if (!isInterpolationOrResource) {
+          return true;
+        }
+        inString = false;
+        stringStartIndex = -1;
+      }
+      continue;
+    }
+
+    if (current === '/' && next === '/') {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+
+    if (current === '/' && next === '*') {
+      inBlockComment = 1;
+      index += 1;
+      continue;
+    }
+
+    if (current === '"' && next === '"' && nextTwo === '"') {
+      inMultilineString = true;
+      stringStartIndex = index;
+      return true;
+    }
+
+    if (current === '"') {
+      const tail = source.slice(Math.max(0, index - 24), index + 1);
+      if (/\bR\.(?:string|plurals|array)\s*\.\s*[A-Za-z_]/.test(tail)) {
+        inString = false;
+        stringStartIndex = -1;
+        continue;
+      }
+      inString = true;
+      stringStartIndex = index;
+    }
+
+    if (!/\s/.test(current)) {
+      lastNonWhitespace = current;
+    }
+  }
+
+  return false;
+};
+
+const hasAndroidSingletonModuleAnnotation = (window: string): boolean => {
+  return /@(Module|InstallIn|EntryPoint)\b/.test(window);
+};
+
+const hasAndroidSingletonCompanionPattern = (block: string): boolean => {
+  return (
+    /\b(?:getInstance|INSTANCE|instance)\b/.test(block) ||
+    /@Volatile\b/.test(block) ||
+    /\bprivate\s+(?:val|var)\s+(?:INSTANCE|instance)\b/.test(block)
+  );
+};
+
+export const hasAndroidSingletonUsage = (source: string): boolean => {
+  const lines = source.split(/\r?\n/);
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const sanitizedLine = stripKotlinLineForSemanticScan(lines[index] ?? '');
+    if (sanitizedLine.trimStart().startsWith('import ')) {
+      continue;
+    }
+
+    const namedObjectMatch = sanitizedLine.match(
+      /^\s*(?:internal\s+|private\s+|public\s+)?(?:data\s+)?object\s+([A-Za-z_][A-Za-z0-9_]*)\b/
+    );
+    if (namedObjectMatch?.[1]) {
+      const annotationWindow = lines
+        .slice(Math.max(0, index - 3), index + 1)
+        .map((line) => stripKotlinLineForSemanticScan(line ?? ''))
+        .join(' ');
+      if (!hasAndroidSingletonModuleAnnotation(annotationWindow)) {
+        return true;
+      }
+    }
+
+    if (!/\bcompanion\s+object\b/.test(sanitizedLine)) {
+      continue;
+    }
+
+    let braceDepth =
+      countTokenOccurrences(sanitizedLine, '{') - countTokenOccurrences(sanitizedLine, '}');
+    const blockLines = [sanitizedLine];
+
+    for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+      const candidateLine = stripKotlinLineForSemanticScan(lines[cursor] ?? '');
+      blockLines.push(candidateLine);
+      braceDepth += countTokenOccurrences(candidateLine, '{');
+      braceDepth -= countTokenOccurrences(candidateLine, '}');
+      if (braceDepth <= 0) {
+        break;
+      }
+    }
+
+    if (hasAndroidSingletonCompanionPattern(blockLines.join(' '))) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
 export const findKotlinPresentationSrpMatch = (
   source: string
 ): KotlinPresentationSrpMatch | undefined => {

package/core/facts/extractHeuristicFacts.ts

@@ -91,6 +91,14 @@ const isAndroidKotlinPath = (path: string): boolean => {
   return (path.endsWith('.kt') || path.endsWith('.kts')) && path.startsWith('apps/android/');
 };
 
+const isAndroidJavaPath = (path: string): boolean => {
+  return path.endsWith('.java') && path.startsWith('apps/android/');
+};
+
+const isAndroidSourcePath = (path: string): boolean => {
+  return isAndroidKotlinPath(path) || isAndroidJavaPath(path);
+};
+
 const isAndroidPresentationPath = (path: string): boolean => {
   return isAndroidKotlinPath(path) && path.includes('/presentation/');
 };
@@ -146,6 +154,16 @@ const isKotlinTestPath = (path: string): boolean => {
   );
 };
 
+const isJavaTestPath = (path: string): boolean => {
+  const normalized = path.toLowerCase();
+  return (
+    normalized.includes('/test/') ||
+    normalized.includes('/androidtest/') ||
+    normalized.endsWith('test.java') ||
+    normalized.endsWith('tests.java')
+  );
+};
+
 const isExcludedProjectScanPath = (path: string): boolean => {
   const normalized = path.replace(/\\/g, '/').toLowerCase();
   return (
@@ -636,6 +654,17 @@ const textDetectorRegistry: ReadonlyArray<TextDetectorRegistryEntry> = [
   { platform: 'android', pathCheck: isAndroidKotlinPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasKotlinThreadSleepCall, ruleId: 'heuristics.android.thread-sleep.ast', code: 'HEURISTICS_ANDROID_THREAD_SLEEP_AST', message: 'AST heuristic detected Thread.sleep usage in production Kotlin code.' },
   { platform: 'android', pathCheck: isAndroidKotlinPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasKotlinGlobalScopeUsage, ruleId: 'heuristics.android.globalscope.ast', code: 'HEURISTICS_ANDROID_GLOBAL_SCOPE_AST', message: 'AST heuristic detected GlobalScope coroutine usage in production Kotlin code.' },
   { platform: 'android', pathCheck: isAndroidKotlinPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasKotlinRunBlockingUsage, ruleId: 'heuristics.android.run-blocking.ast', code: 'HEURISTICS_ANDROID_RUN_BLOCKING_AST', message: 'AST heuristic detected runBlocking usage in production Kotlin code.' },
+  { platform: 'android', pathCheck: isAndroidKotlinPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasKotlinForceUnwrapUsage, ruleId: 'heuristics.android.force-unwrap.ast', code: 'HEURISTICS_ANDROID_FORCE_UNWRAP_AST', message: 'AST heuristic detected Kotlin force unwrap (!!) usage in production code.' },
+  { platform: 'android', pathCheck: isAndroidJavaPath, excludePaths: [isJavaTestPath], detect: TextAndroid.hasAndroidJavaSourceCode, ruleId: 'heuristics.android.java-source.ast', code: 'HEURISTICS_ANDROID_JAVA_SOURCE_AST', message: 'AST heuristic detected Java source in Android production code where Kotlin is required for new code.' },
+  { platform: 'android', pathCheck: isAndroidSourcePath, excludePaths: [isKotlinTestPath, isJavaTestPath], detect: TextAndroid.hasAndroidAsyncTaskUsage, ruleId: 'heuristics.android.asynctask-deprecated.ast', code: 'HEURISTICS_ANDROID_ASYNCTASK_DEPRECATED_AST', message: 'AST heuristic detected AsyncTask usage in Android production code where Coroutines are required.' },
+  { platform: 'android', pathCheck: isAndroidSourcePath, excludePaths: [isKotlinTestPath, isJavaTestPath], detect: TextAndroid.hasAndroidFindViewByIdUsage, ruleId: 'heuristics.android.findviewbyid.ast', code: 'HEURISTICS_ANDROID_FINDVIEWBYID_AST', message: 'AST heuristic detected findViewById usage in Android production code where View Binding or Compose is required.' },
+  { platform: 'android', pathCheck: isAndroidSourcePath, excludePaths: [isKotlinTestPath, isJavaTestPath], detect: TextAndroid.hasAndroidRxJavaUsage, ruleId: 'heuristics.android.rxjava-new-code.ast', code: 'HEURISTICS_ANDROID_RXJAVA_NEW_CODE_AST', message: 'AST heuristic detected RxJava usage in Android production code where Flow is required for new code.' },
+  { platform: 'android', pathCheck: isAndroidKotlinPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasAndroidDispatcherUsage, ruleId: 'heuristics.android.dispatchers-main-ui-io-network-disk-default-cpu.ast', code: 'HEURISTICS_ANDROID_DISPATCHERS_MAIN_UI_IO_NETWORK_DISK_DEFAULT_CPU_AST', message: 'AST heuristic detected explicit Dispatchers.Main/IO/Default usage in Android production code where dispatcher selection must remain intentional.' },
+  { platform: 'android', pathCheck: isAndroidKotlinPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasAndroidWithContextUsage, ruleId: 'heuristics.android.withcontext-change-dispatcher.ast', code: 'HEURISTICS_ANDROID_WITHCONTEXT_CHANGE_DISPATCHER_AST', message: 'AST heuristic detected withContext usage in Android production code where dispatcher switching is intentional.' },
+  { platform: 'android', pathCheck: isAndroidSourcePath, excludePaths: [isKotlinTestPath, isJavaTestPath], detect: TextAndroid.hasAndroidNoConsoleLogUsage, ruleId: 'heuristics.android.no-console-log.ast', code: 'HEURISTICS_ANDROID_NO_CONSOLE_LOG_AST', message: 'AST heuristic detected Android logging usage in production code without a debug-only guard.' },
+  { platform: 'android', pathCheck: isAndroidSourcePath, excludePaths: [isKotlinTestPath, isJavaTestPath], detect: TextAndroid.hasAndroidHardcodedStringUsage, ruleId: 'heuristics.android.hardcoded-strings.ast', code: 'HEURISTICS_ANDROID_HARDCODED_STRINGS_AST', message: 'AST heuristic detected hardcoded string literal usage in Android production code where strings.xml should be used.' },
+  { platform: 'android', pathCheck: isAndroidKotlinPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasAndroidSingletonUsage, ruleId: 'heuristics.android.no-singleton.ast', code: 'HEURISTICS_ANDROID_NO_SINGLETON_AST', message: 'AST heuristic detected Kotlin singleton object or companion singleton holder usage in Android production code where Hilt or Dagger DI should be used.' },
+  { platform: 'android', pathCheck: isAndroidKotlinPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasAndroidCoroutineTryCatchUsage, ruleId: 'heuristics.android.try-catch-manejo-de-errores-en-coroutines.ast', code: 'HEURISTICS_ANDROID_TRY_CATCH_MANEJO_DE_ERRORES_EN_COROUTINES_AST', message: 'AST heuristic detected try/catch usage in Android coroutine code where error handling must remain explicit.' },
 ];
 
 const extractWorkflowHeuristicFacts = (