pumuki 6.3.178 → 6.3.180

package/VERSION

@@ -1 +1 @@
-v6.3.178
+v6.3.180

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

@@ -7,6 +7,8 @@ import {
   findKotlinOpenClosedWhenMatch,
   findKotlinPresentationSrpMatch,
   hasKotlinGlobalScopeUsage,
+  hasKotlinLiveDataStateExposureUsage,
+  hasKotlinManualCoroutineScopeInViewModelUsage,
   hasKotlinRunBlockingUsage,
   hasKotlinThreadSleepCall,
 } from './android';
@@ -91,6 +93,54 @@ fun main() {
   assert.equal(hasKotlinRunBlockingUsage(partialSource), false);
 });
 
+test('hasKotlinLiveDataStateExposureUsage detecta LiveData y MutableLiveData como estado observable legacy', () => {
+  const source = `
+class OrdersViewModel : ViewModel() {
+  private val mutableState = MutableLiveData<OrdersUiState>()
+  val state: LiveData<OrdersUiState> = mutableState
+}
+`;
+  assert.equal(hasKotlinLiveDataStateExposureUsage(source), true);
+});
+
+test('hasKotlinLiveDataStateExposureUsage ignora imports, comentarios y strings', () => {
+  const source = `
+import androidx.lifecycle.LiveData
+// val state = MutableLiveData<OrdersUiState>()
+val sample = "LiveData<OrdersUiState>"
+class OrdersViewModel : ViewModel() {
+  val state: StateFlow<OrdersUiState> = MutableStateFlow(OrdersUiState())
+}
+`;
+  assert.equal(hasKotlinLiveDataStateExposureUsage(source), false);
+});
+
+test('hasKotlinManualCoroutineScopeInViewModelUsage detecta CoroutineScope manual dentro de ViewModel', () => {
+  const source = `
+class OrdersViewModel : ViewModel() {
+  private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+}
+`;
+  assert.equal(hasKotlinManualCoroutineScopeInViewModelUsage(source), true);
+});
+
+test('hasKotlinManualCoroutineScopeInViewModelUsage ignora imports, comentarios y uso fuera de ViewModel', () => {
+  const source = `
+import kotlinx.coroutines.CoroutineScope
+// private val scope = CoroutineScope(SupervisorJob())
+val sample = "CoroutineScope(SupervisorJob())"
+class OrdersWorker {
+  private val scope = CoroutineScope(SupervisorJob())
+}
+class OrdersViewModel : ViewModel() {
+  fun load() {
+    viewModelScope.launch { }
+  }
+}
+`;
+  assert.equal(hasKotlinManualCoroutineScopeInViewModelUsage(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,45 @@ export const hasKotlinRunBlockingUsage = (source: string): boolean => {
   });
 };
 
+export const hasKotlinLiveDataStateExposureUsage = (source: string): boolean => {
+  return collectKotlinRegexLines(
+    source,
+    /\b(?:MutableLiveData|LiveData)\s*(?:<|\(|\.)/
+  ).length > 0;
+};
+
+export const hasKotlinManualCoroutineScopeInViewModelUsage = (source: string): boolean => {
+  const lines = source.split(/\r?\n/);
+  let insideViewModel = false;
+  let braceDepth = 0;
+
+  for (const rawLine of lines) {
+    const sanitized = stripKotlinLineForSemanticScan(rawLine);
+    if (sanitized.trimStart().startsWith('import ')) {
+      continue;
+    }
+
+    if (!insideViewModel && /\bclass\s+\w*ViewModel\b/.test(sanitized)) {
+      insideViewModel = true;
+      braceDepth =
+        countTokenOccurrences(sanitized, '{') - countTokenOccurrences(sanitized, '}');
+    } else if (insideViewModel) {
+      braceDepth += countTokenOccurrences(sanitized, '{');
+      braceDepth -= countTokenOccurrences(sanitized, '}');
+    }
+
+    if (insideViewModel && /\bCoroutineScope\s*\(/.test(sanitized)) {
+      return true;
+    }
+
+    if (insideViewModel && braceDepth <= 0 && sanitized.includes('}')) {
+      insideViewModel = false;
+    }
+  }
+
+  return false;
+};
+
 export const findKotlinPresentationSrpMatch = (
   source: string
 ): KotlinPresentationSrpMatch | undefined => {

package/core/facts/extractHeuristicFacts.ts

@@ -637,6 +637,8 @@ 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: isAndroidPresentationPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasKotlinLiveDataStateExposureUsage, ruleId: 'heuristics.android.flow.livedata-state-exposure.ast', code: 'HEURISTICS_ANDROID_FLOW_LIVEDATA_STATE_EXPOSURE_AST', message: 'AST heuristic detected LiveData state exposure in Android presentation code where StateFlow or SharedFlow should be preferred.' },
+  { platform: 'android', pathCheck: isAndroidPresentationPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasKotlinManualCoroutineScopeInViewModelUsage, ruleId: 'heuristics.android.coroutines.manual-scope-in-viewmodel.ast', code: 'HEURISTICS_ANDROID_COROUTINES_MANUAL_SCOPE_IN_VIEWMODEL_AST', message: 'AST heuristic detected manual CoroutineScope inside an Android ViewModel where viewModelScope should be preferred.' },
 ];
 
 const extractWorkflowHeuristicFacts = (

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

@@ -3,13 +3,15 @@ import test from 'node:test';
 import { androidRules } from './android';
 
 test('androidRules define reglas heurísticas locked para plataforma android', () => {
-  assert.equal(androidRules.length, 8);
+  assert.equal(androidRules.length, 10);
 
   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.flow.livedata-state-exposure.ast',
+    'heuristics.android.coroutines.manual-scope-in-viewmodel.ast',
     'heuristics.android.solid.srp.presentation-mixed-responsibilities.ast',
     'heuristics.android.solid.ocp.discriminator-branching.ast',
     'heuristics.android.solid.dip.concrete-framework-dependency.ast',
@@ -40,6 +42,14 @@ 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.flow.livedata-state-exposure.ast')?.then.code,
+    'HEURISTICS_ANDROID_FLOW_LIVEDATA_STATE_EXPOSURE_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.android.coroutines.manual-scope-in-viewmodel.ast')?.then.code,
+    'HEURISTICS_ANDROID_COROUTINES_MANUAL_SCOPE_IN_VIEWMODEL_AST'
+  );
   assert.equal(
     byId.get('heuristics.android.solid.srp.presentation-mixed-responsibilities.ast')?.then.code,
     'HEURISTICS_ANDROID_SOLID_SRP_PRESENTATION_MIXED_RESPONSIBILITIES_AST'

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

@@ -55,6 +55,46 @@ export const androidRules: RuleSet = [
       code: 'HEURISTICS_ANDROID_RUN_BLOCKING_AST',
     },
   },
+  {
+    id: 'heuristics.android.flow.livedata-state-exposure.ast',
+    description:
+      'Detects LiveData state exposure in Android presentation code where StateFlow or SharedFlow should be preferred.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.flow.livedata-state-exposure.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message:
+        'AST heuristic detected LiveData state exposure in Android presentation code.',
+      code: 'HEURISTICS_ANDROID_FLOW_LIVEDATA_STATE_EXPOSURE_AST',
+    },
+  },
+  {
+    id: 'heuristics.android.coroutines.manual-scope-in-viewmodel.ast',
+    description:
+      'Detects manual CoroutineScope construction inside Android ViewModel classes where viewModelScope should be preferred.',
+    severity: 'WARN',
+    platform: 'android',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.android.coroutines.manual-scope-in-viewmodel.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message:
+        'AST heuristic detected manual CoroutineScope inside an Android ViewModel.',
+      code: 'HEURISTICS_ANDROID_COROUTINES_MANUAL_SCOPE_IN_VIEWMODEL_AST',
+    },
+  },
   {
     id: 'heuristics.android.solid.srp.presentation-mixed-responsibilities.ast',
     description:

package/docs/codex-skills/android-enterprise-rules.md

@@ -124,9 +124,15 @@ app/
 
 ### Enforcement AST inicial de coroutines Android
 ✅ `skills.android.guideline.android.coroutines-async-await-no-callbacks` debe mapear a señales ejecutables existentes de uso inseguro de coroutines, empezando por `GlobalScope` y `runBlocking`.
-✅ El baseline inicial de coroutines es parcial: cubre APIs bloqueantes o scopes no estructurados, pero no declara todavía cobertura completa de `Flow`, `viewModelScope`, `supervisorScope`, dispatchers ni cancelación cooperativa.
+✅ `skills.android.guideline.android.viewmodelscope-scope-de-viewmodel-cancelado-automa-ticamente` debe mapear a señales ejecutables de scopes manuales dentro de `ViewModel`, empezando por `CoroutineScope(...)` construido en presentation.
+✅ El baseline inicial de coroutines es parcial: cubre APIs bloqueantes, scopes no estructurados y scopes manuales en `ViewModel`, pero no declara todavía cobertura completa de `Flow`, `supervisorScope`, dispatchers ni cancelación cooperativa.
 ✅ Si se amplía esta cobertura, cada nueva regla debe aterrizar como detector AST/textual semántico con test dirigido antes de declararse cubierta en el registry.
 
+### Enforcement AST inicial de Flow/StateFlow Android
+✅ Las reglas de `StateFlow` / `StateFlow-SharedFlow` deben mapear a señales ejecutables de estado observable legacy, empezando por exposición de `LiveData` / `MutableLiveData` en presentation.
+✅ Este baseline no obliga a que todo ViewModel use Flow; solo detecta una alternativa legacy concreta cuando aparece en código de presentación Android.
+✅ `Flow`, `collectAsState`, `stateIn`, Room observable queries y SharedFlow events quedan fuera hasta que tengan detectores propios y regresiones dirigidas.
+
 ### Dependency Injection (Hilt):
 ✅ **Hilt** - DI framework (NO manual factories)
 ✅ **@HiltAndroidApp** - Application class

package/integrations/config/skillsDetectorRegistry.ts

@@ -220,6 +220,22 @@ const registryByRuleId: Record<string, SkillsDetectorBinding> = {
       'heuristics.android.run-blocking.ast',
     ]
   ),
+  'skills.android.guideline.android.viewmodelscope-scope-de-viewmodel-cancelado-automa-ticamente': heuristicDetector(
+    'android.coroutines.viewmodel-scope',
+    ['heuristics.android.coroutines.manual-scope-in-viewmodel.ast']
+  ),
+  'skills.android.guideline.android.stateflow-estado-mutable-observable': heuristicDetector(
+    'android.flow.state-exposure',
+    ['heuristics.android.flow.livedata-state-exposure.ast']
+  ),
+  'skills.android.guideline.android.stateflow-hot-stream-siempre-tiene-valor-para-estado': heuristicDetector(
+    'android.flow.state-exposure',
+    ['heuristics.android.flow.livedata-state-exposure.ast']
+  ),
+  'skills.android.guideline.android.stateflow-sharedflow-para-exponer-estado-del-viewmodel': heuristicDetector(
+    'android.flow.state-exposure',
+    ['heuristics.android.flow.livedata-state-exposure.ast']
+  ),
   'skills.android.no-solid-violations': heuristicDetector('android.solid', [
     'heuristics.android.solid.srp.presentation-mixed-responsibilities.ast',
     'heuristics.android.solid.ocp.discriminator-branching.ast',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.178",
+  "version": "6.3.180",
   "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": {