pumuki 6.3.43 → 6.3.44

package/docs/USAGE.md

@@ -327,6 +327,8 @@ Watch runtime behavior:
 - `--notify-cooldown-ms` enables anti-spam throttling for repeated alerts with equal signature.
 - `--no-notify` keeps watch output without OS notifications.
 - `--once` or `--iterations=<n>` is recommended for CI/scripts to avoid long-running sessions.
+- `--json` now includes per-tick file traceability: `lastTick.changedFiles[]` and `lastTick.evaluatedFiles[]`.
+- Runtime artifacts hygiene is self-healed in `.git/info/exclude` (`.ai_evidence.json`, `.AI_EVIDENCE.json`, `.pumuki/`) to avoid dirty worktree noise.
 
 <a id="backlog-tooling"></a>
 Backlog tooling behavior (`watch` + `reconcile` scripts):

package/docs/seguimiento-activo-pumuki-saas-supermercados.md

@@ -1868,9 +1868,243 @@
       - `openspec_compatible=true`
       - `session_active=true`
 
-- 🚧 PUMUKI-150: Ejecutar siguiente pendiente real en backlog externo (Flux `PUM-005`) y cerrar incidencia de `pumuki sdd evidence` con contrato v1 compatible con gate TDD.
+- ✅ PUMUKI-150: Ejecutar siguiente pendiente real en backlog externo (Flux `PUM-005`) y cerrar incidencia de `pumuki sdd evidence` con contrato v1 compatible con gate TDD.
   - Alcance:
     - reproducir `PUM-005` con evidencia local controlada,
     - aplicar fix mínimo en core (`sdd evidence` -> `version=\"1\"` + `slices[]`),
     - validar RED->GREEN con smoke en `Flux_training`,
     - actualizar leyenda en `docs/BUGS_Y_MEJORAS_PUMUKI.md` (Flux) sin tocar código del consumer.
+  - Resultado (2026-03-05):
+    - fix aplicado en core:
+      - `integrations/sdd/evidenceScaffold.ts`: `artifact.version=\"1\"` + `artifact.slices[]`, manteniendo campos legacy (`scenario_id`, `test_run`, `ai_evidence`).
+      - `integrations/sdd/stateSync.ts`: compatibilidad de lectura `version=1|1.0` para rollout sin ruptura.
+    - validación local:
+      - `npx --yes tsx@4.21.0 --test integrations/sdd/__tests__/evidenceScaffold.test.ts integrations/sdd/__tests__/stateSync.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `47 pass / 0 fail`.
+      - `npm run -s typecheck` -> `PASS`.
+    - release asociado: `pumuki@6.3.43` publicado en npm.
+    - revalidación en Flux con `@latest`:
+      - `pumuki sdd evidence ... --json` => `artifact.version=\"1\"` + `slices[]`,
+      - `pnpm exec pumuki watch --once --stage=PRE_COMMIT --scope=staged --json` en `ALLOW` sin `TDD_BDD_EVIDENCE_INVALID`.
+    - leyenda Flux actualizada: `PUM-005` -> `✅ Cerrado`; `PUM-006` -> `🚧 En construccion`.
+
+- ✅ PUMUKI-151: Ejecutar siguiente pendiente activo de backlog Flux (`PUM-006`) para enriquecer salida JSON de `pumuki watch` con `changedFiles/evaluatedFiles`.
+  - Resultado (2026-03-05):
+    - `integrations/lifecycle/watch.ts`:
+      - contrato extendido de tick con `changedFiles[]` y `evaluatedFiles[]`,
+      - cálculo determinista por `facts` del scope evaluado.
+    - `integrations/lifecycle/__tests__/watch.test.ts`:
+      - cobertura de ambos campos en ticks `BLOCK/ALLOW/WARN`.
+    - `integrations/lifecycle/__tests__/cli.test.ts`:
+      - payload JSON estable de `watch --once --json` validando ambos campos.
+    - `docs/USAGE.md`:
+      - documentación de trazabilidad por tick en salida JSON.
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/lifecycle/__tests__/watch.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `42 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - leyenda Flux actualizada: `PUM-006` -> `✅ Cerrado`; `PUM-007` -> `🚧 En construccion`.
+
+- ✅ PUMUKI-152: Ejecutar siguiente pendiente activo de backlog Flux (`PUM-007`) para evitar artefactos efimeros en raíz del repo tras hooks/watch.
+  - Alcance:
+    - reproducir contaminación de worktree por `.ai_evidence.json` y `.pumuki/**`,
+    - definir cleanup post-ejecución sin perder trazabilidad oficial del repo,
+    - validar con tests + smoke en `Flux_training`,
+    - cerrar leyenda en MD externo Flux al completar fix.
+  - Avance actual (2026-03-05):
+    - `integrations/lifecycle/artifacts.ts`:
+      - nuevo `ensureRuntimeArtifactsIgnored(repoRoot)` con bloque gestionado en `.git/info/exclude`,
+      - soporte para repos normales y `git worktree` (`.git` como `gitdir`).
+    - integración aplicada en:
+      - `integrations/lifecycle/install.ts`
+      - `integrations/lifecycle/watch.ts`
+      - `integrations/git/stageRunners.ts`
+    - cobertura de regresión:
+      - `integrations/lifecycle/__tests__/artifacts.test.ts` (bloque insert/replace/idempotent),
+      - `integrations/git/__tests__/stageRunners.test.ts` (pre-commit asegura ignore runtime),
+      - `integrations/lifecycle/__tests__/install.test.ts` (worktree sin regresión).
+    - evidencia local:
+      - `npx --yes tsx@4.21.0 --test integrations/lifecycle/__tests__/install.test.ts integrations/lifecycle/__tests__/artifacts.test.ts integrations/git/__tests__/stageRunners.test.ts integrations/lifecycle/__tests__/watch.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `86 pass / 0 fail`.
+      - `npm run -s typecheck` -> `PASS`.
+    - smoke en consumer Flux:
+      - `node /Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/bin/pumuki.js watch --once --stage=PRE_COMMIT --scope=staged --json` ejecutado en `Flux_training`,
+      - `.git/info/exclude` con bloque `pumuki-runtime-artifacts`,
+      - `git status --short` sin ruido de `.ai_evidence.json` / `.pumuki/**`.
+    - leyenda Flux actualizada: `PUM-007` -> `✅ Cerrado`; `PUM-008` -> `🚧 En construccion`.
+
+- ✅ PUMUKI-153: Ejecutar siguiente pendiente activo de backlog Flux (`PUM-008`) para hacer accionable el bloqueo `skills.frontend.no-solid-violations` en cambios incrementales.
+  - Resultado (2026-03-05):
+    - `integrations/config/skillsRuleSet.ts`:
+      - mensajes enriquecidos para reglas `*.no-solid-violations` con `ast_nodes`, `observed_paths` y `sample_paths`.
+    - `integrations/git/runPlatformGateOutput.ts`:
+      - `next_action` específico y progresivo para `SKILLS_SKILLS_FRONTEND_NO_SOLID_VIOLATIONS` (extracción incremental por componente/hook).
+    - cobertura:
+      - `integrations/config/__tests__/skillsRuleSet.test.ts`,
+      - `integrations/git/__tests__/runPlatformGateOutput.test.ts`.
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/config/__tests__/skillsRuleSet.test.ts integrations/git/__tests__/runPlatformGateOutput.test.ts` -> `17 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - leyenda Flux actualizada: `PUM-008` -> `✅ Cerrado`.
+
+- ✅ PUMUKI-154: Ejecutar siguiente pendiente crítico del backlog SAAS (`PUMUKI-016`) para convertir bloqueos de `PRE_WRITE` por regla iOS crítica ausente en remediación guiada y determinista de bootstrap/reconcile.
+  - Resultado (2026-03-05):
+    - `integrations/mcp/preFlightCheck.ts`:
+      - hints accionables para `EVIDENCE_PLATFORM_CRITICAL_SKILLS_RULES_MISSING` y `EVIDENCE_CROSS_PLATFORM_CRITICAL_ENFORCEMENT_INCOMPLETE`.
+    - `integrations/mcp/autoExecuteAiStart.ts`:
+      - `next_action` determinista con comando `policy reconcile --strict` + revalidación `PRE_WRITE`.
+      - clasificación de confianza alineada para ambos códigos críticos.
+    - `integrations/lifecycle/cli.ts`:
+      - `PRE_WRITE_HINTS_BY_CODE` enriquecido para esos códigos críticos.
+      - `resolvePreWriteNextAction` ahora prioriza ruta de reconcile estricto en bloqueos de reglas críticas.
+    - cobertura añadida:
+      - `integrations/mcp/__tests__/preFlightCheck.test.ts`
+      - `integrations/mcp/__tests__/autoExecuteAiStart.test.ts`
+      - `integrations/lifecycle/__tests__/cli.test.ts`
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/mcp/__tests__/preFlightCheck.test.ts integrations/mcp/__tests__/autoExecuteAiStart.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `50 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - leyenda SAAS actualizada:
+      - `PUMUKI-016` -> `✅ Cerrado`
+      - `PUMUKI-012` -> `🚧 En construcción` (siguiente foco).
+
+- ✅ PUMUKI-155: Ejecutar siguiente pendiente HIGH del backlog SAAS (`PUMUKI-012`) para cerrar la recurrencia de `active_rule_ids` vacío con cambios de código en `PRE_COMMIT`.
+  - Alcance:
+    - reproducir recurrencia en contexto real (diffs pequeños y grandes),
+    - endurecer contrato de `rules_coverage` en `PRE_COMMIT` para evitar falso verde con cobertura vacía,
+    - validar con tests focales + typecheck,
+    - actualizar leyenda SAAS manteniendo una única `🚧`.
+  - Avance técnico (2026-03-05):
+    - `integrations/git/stageRunners.ts`:
+      - en bloqueos de `PRE_COMMIT/PRE_PUSH/CI` prioriza `snapshot.findings` del stage actual como causa primaria (en lugar de depender solo de `ai_gate.violations`),
+      - remediación específica añadida para `ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES_HIGH`.
+    - `integrations/git/runPlatformGateOutput.ts`:
+      - `next_action` explícito para `ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES_HIGH` con flujo `policy reconcile --strict` + `pumuki-pre-commit`.
+    - cobertura añadida:
+      - `integrations/git/__tests__/stageRunners.test.ts`
+      - `integrations/git/__tests__/runPlatformGateOutput.test.ts`
+    - evidencia local:
+      - `npx --yes tsx@4.21.0 --test integrations/git/__tests__/runPlatformGateOutput.test.ts integrations/git/__tests__/stageRunners.test.ts integrations/mcp/__tests__/preFlightCheck.test.ts integrations/mcp/__tests__/autoExecuteAiStart.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `82 pass / 0 fail`.
+      - `npm run -s typecheck` -> `PASS`.
+  - Avance técnico adicional (2026-03-05, cierre de falso bloqueo cross-platform en PRE_WRITE):
+    - `integrations/gate/evaluateAiGate.ts`:
+      - detección efectiva de plataformas en `PRE_WRITE` basada en `rules_coverage` cuando hay plataformas detectadas, para evitar arrastre de scope legado (ej.: iOS) en diffs backend.
+      - mantiene enforcement hard sin relajar contrato: si no hay señal efectiva de coverage por prefijo, conserva fallback al scope detectado original.
+    - `integrations/gate/__tests__/evaluateAiGate.test.ts`:
+      - nuevo caso de regresión: `platforms` arrastra `ios`, pero la cobertura efectiva real es `backend` y el gate debe quedar en `ALLOWED`.
+    - evidencia local:
+      - `npx --yes tsx@4.21.0 --test integrations/gate/__tests__/evaluateAiGate.test.ts` -> `26 pass / 0 fail`.
+      - `npx --yes tsx@4.21.0 --test integrations/git/__tests__/runPlatformGateOutput.test.ts integrations/git/__tests__/stageRunners.test.ts integrations/mcp/__tests__/preFlightCheck.test.ts integrations/mcp/__tests__/autoExecuteAiStart.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `82 pass / 0 fail`.
+      - `npm run -s typecheck` -> `PASS`.
+  - Avance técnico adicional (2026-03-05, hardening de cobertura vacía en PRE_WRITE):
+    - `integrations/gate/evaluateAiGate.ts`:
+      - `EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES` ahora también bloquea cuando `active_rule_ids=[]` y la cobertura evaluada infiere plataforma (`skills.<scope>.*`) aunque `platforms` venga vacío.
+      - mensaje distingue modo de detección (`detected`/`inferred`) para trazabilidad de root-cause.
+    - `integrations/gate/__tests__/evaluateAiGate.test.ts`:
+      - nuevo caso de regresión: `platforms={}` + `evaluated_rule_ids=['skills.backend.no-empty-catch']` + `active_rule_ids=[]` => `BLOCKED`.
+    - evidencia local:
+      - `npx --yes tsx@4.21.0 --test integrations/gate/__tests__/evaluateAiGate.test.ts` -> `27 pass / 0 fail`.
+      - `npx --yes tsx@4.21.0 --test integrations/git/__tests__/runPlatformGate.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `73 pass / 0 fail`.
+      - `npm run -s typecheck` -> `PASS`.
+  - Cierre operativo final (2026-03-05):
+    - `integrations/mcp/autoExecuteAiStart.ts`, `integrations/mcp/preFlightCheck.ts` y `integrations/lifecycle/cli.ts` alineados con remediación accionable para `EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES`.
+    - pruebas de regresión completas:
+      - `npx --yes tsx@4.21.0 --test integrations/mcp/__tests__/autoExecuteAiStart.test.ts integrations/mcp/__tests__/preFlightCheck.test.ts integrations/lifecycle/__tests__/cli.test.ts integrations/gate/__tests__/evaluateAiGate.test.ts` -> `80 pass / 0 fail`.
+      - `npm run -s typecheck` -> `PASS`.
+    - leyenda SAAS actualizada:
+      - `PUMUKI-012` -> `✅ Cerrado`
+      - `PUMUKI-M008` -> `🚧 En construcción` (siguiente foco único).
+
+- ✅ PUMUKI-156: Ejecutar siguiente pendiente HIGH del backlog SAAS (`PUMUKI-017`) para reducir falsos bloqueos de `skills.backend.no-solid-violations` en `PRE_COMMIT` y mantener enforcement fuerte en `PRE_PUSH`.
+  - Resultado (2026-03-05):
+    - `integrations/config/skillsMarkdownRules.ts`:
+      - reglas conocidas `*.no-solid-violations` ahora usan stage canónico `PRE_PUSH` cuando el markdown no define stage.
+      - si el markdown define stage explícito, se respeta sin override.
+    - `integrations/config/__tests__/skillsMarkdownRules.test.ts`:
+      - cobertura nueva para stage canónico y respeto de stage explícito.
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/config/__tests__/skillsMarkdownRules.test.ts integrations/config/__tests__/skillsRuleSet.test.ts` -> `20 pass / 0 fail`.
+    - `npx --yes tsx@4.21.0 --test integrations/git/__tests__/runPlatformGate.test.ts integrations/git/__tests__/stageRunners.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `101 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+
+- ✅ PUMUKI-157: Ejecutar siguiente pendiente HIGH del backlog SAAS (`PUMUKI-M008`) para entregar asistente de partición atómica accionable en `PRE_WRITE` antes del bloqueo.
+  - Alcance:
+    - generar `suggested-atomic-slices` por contexto (scope/ruta/tipo de archivo),
+    - exponer `next_action` con comandos concretos de staging por lote,
+    - mantener comportamiento anti-spam y sin auto-aplicar cambios.
+  - Resultado (2026-03-05):
+    - helper nuevo `integrations/git/worktreeAtomicSlices.ts` para agrupar cambios por scope y proponer `git add -- ...` por lote.
+    - `pre_flight_check` ahora expone `ATOMIC_SLICES` y `ATOMIC_SLICES[next]` en bloqueos de higiene de worktree.
+    - `auto_execute_ai_start` ahora devuelve `next_action` con primer lote atómico accionable + comando de revalidación `PRE_WRITE`.
+    - `pumuki sdd validate --stage=PRE_WRITE` ahora expone `next_action` con slice atómico cuando el umbral se supera.
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/git/__tests__/worktreeAtomicSlices.test.ts integrations/mcp/__tests__/autoExecuteAiStart.test.ts integrations/mcp/__tests__/preFlightCheck.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `56 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - leyenda SAAS actualizada:
+      - `PUMUKI-M008` -> `✅ Cerrado`
+      - `PUMUKI-M005` -> `🚧 En construcción` (siguiente foco único).
+
+- ✅ PUMUKI-158: Ejecutar siguiente pendiente MEDIUM del backlog SAAS (`PUMUKI-M005`) para cerrar convergencia determinista de `policy reconcile --strict` (diagnóstico + autofix + verificación).
+  - Alcance:
+    - definir salida `next_action` estable de autofix cuando detecte drift crítico,
+    - añadir modo `--apply` seguro e idempotente para convergencia guiada,
+    - dejar evidencia machine-readable de antes/después (`drift -> reconciled`).
+  - Resultado (2026-03-05):
+    - `integrations/lifecycle/policyReconcile.ts` ahora soporta `apply=true` y produce bloque `autofix` (`attempted/status/actions/details`).
+    - `policy reconcile --strict --apply` escribe contrato determinista `.pumuki/policy-as-code.json` (`WRITE_POLICY_AS_CODE_CONTRACT`) y reevalúa convergencia.
+    - `integrations/lifecycle/cli.ts` añade flag `--apply` + salida textual de autofix.
+    - cobertura añadida:
+      - `integrations/lifecycle/__tests__/policyReconcile.test.ts` (convergencia `--strict --apply`),
+      - `integrations/lifecycle/__tests__/cli.test.ts` (parse + ejecución `--strict --apply --json`).
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/lifecycle/__tests__/policyReconcile.test.ts integrations/lifecycle/__tests__/cli.test.ts integrations/git/__tests__/worktreeAtomicSlices.test.ts integrations/mcp/__tests__/preFlightCheck.test.ts integrations/mcp/__tests__/autoExecuteAiStart.test.ts` -> `63 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - leyenda SAAS actualizada:
+      - `PUMUKI-M005` -> `✅ Cerrado`
+      - `PUMUKI-006` -> `🚧 En construcción` (siguiente foco único).
+
+- ✅ PUMUKI-159: Ejecutar siguiente pendiente LOW del backlog SAAS (`PUMUKI-006`) para alinear `package_version` y `lifecycle_version` en `ai_gate_check`/MCP.
+  - Resultado (2026-03-05):
+    - `integrations/gate/evaluateAiGate.ts` incorpora normalización defensiva para evitar payload desalineado cuando `captureRepoState` mezcla fuentes de versión.
+    - se alinea `repo_state.lifecycle.package_version` con `lifecycle_version` en salida de gate/MCP, manteniendo trazabilidad sin drift en contratos JSON.
+    - regresión cubierta en `integrations/gate/__tests__/evaluateAiGate.test.ts` con fixture desalineada.
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/gate/__tests__/evaluateAiGate.test.ts` -> `PASS`.
+    - `npx --yes tsx@4.21.0 --test integrations/mcp/__tests__/preFlightCheck.test.ts integrations/mcp/__tests__/autoExecuteAiStart.test.ts integrations/mcp/__tests__/aiGateCheck.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `PASS`.
+    - `npm run -s typecheck` -> `PASS`.
+    - leyenda SAAS actualizada:
+      - `PUMUKI-006` -> `✅ Cerrado`
+      - backlog SAAS externo queda en `✅ 100% cerrado`.
+
+- ✅ PUMUKI-160: Iniciar siguiente ciclo activo sobre backlog RuralGo/consumidores (solo hallazgos netos nuevos) sin reabrir incidencias ya cerradas.
+  - Resultado (2026-03-05):
+    - validado estado canónico externo:
+      - SAAS: `✅ Cerrados: 25`, `0` en `🚧/⏳/⛔`.
+      - RuralGo: `✅ Cerrados: 98`, `0` en `🚧/⏳/⛔`.
+      - Flux: backlog localizado en `docs/BUGS_Y_MEJORAS_PUMUKI.md` (ruta real), con foco activo en `PUM-010`.
+    - cerrado `PUM-009` en Flux tras verificación directa contra paquete publicado (`pumuki@latest`) con salida válida de `sdd evidence` (`version: "1"` + `slices[]`).
+  - Evidencia:
+    - `npx --yes --package pumuki@latest pumuki sdd evidence --scenario-id=docs/validation/features/p3_t1_web_shell_dashboard --test-command='pnpm test' --test-status=passed --json` -> artefacto válido.
+    - actualización de leyenda en `Flux_training/docs/BUGS_Y_MEJORAS_PUMUKI.md`:
+      - `PUM-009` -> `✅ Cerrado`
+      - `PUM-010` -> `🚧 En construccion`
+      - `PUM-011` -> `⏳ Pendiente`.
+
+- ✅ PUMUKI-161: Ejecutar siguiente pendiente activo de Flux (`PUM-010`) para estabilizar persistencia de bundles/rules de `skills.frontend.*` entre iteraciones sin bootstrap manual repetitivo.
+  - Resultado (2026-03-05):
+    - `integrations/lifecycle/watch.ts` ahora detecta drift de skills coverage en runtime (`SKILLS_PLATFORM_COVERAGE_INCOMPLETE_HIGH`, `SKILLS_SCOPE_COMPLIANCE_INCOMPLETE_HIGH` y equivalentes `EVIDENCE_*`) y ejecuta auto-reconcile determinista (`policy reconcile --strict --apply`) dentro del mismo tick.
+    - si el autofix aplica contrato (`WRITE_POLICY_AS_CODE_CONTRACT`), `watch` reevalúa el gate en la misma iteración para evitar bootstrap manual repetido.
+    - cobertura añadida: test dedicado en `integrations/lifecycle/__tests__/watch.test.ts` (`auto-reconcilia policy en drift de skills y reevalua en la misma iteracion`).
+    - leyenda Flux actualizada:
+      - `PUM-010` -> `✅ Cerrado`
+      - `PUM-011` -> `🚧 En construccion`.
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/lifecycle/__tests__/watch.test.ts integrations/lifecycle/__tests__/cli.test.ts integrations/lifecycle/__tests__/policyReconcile.test.ts` -> `53 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+
+- 🚧 PUMUKI-162: Ejecutar siguiente pendiente activo de Flux (`PUM-011`) para cerrar paridad consumer de `watch --once --json` con `lastTick.changedFiles[]` y `lastTick.evaluatedFiles[]`.
+  - Alcance:
+    - verificar contrato JSON final en paquete publicado vs consumer runtime,
+    - eliminar drift de payload entre core y distribución npm,
+    - cerrar con validación reproducible en consumer (sin tocar código funcional del consumer).
+  - Avance actual (2026-03-05):
+    - verificado en core local (`bin/pumuki.js`): `lastTick.changedFiles[]` y `lastTick.evaluatedFiles[]` sí aparecen.
+    - verificado en paquete publicado (`pumuki@latest`): esos campos aún no aparecen en JSON de `watch`.
+    - conclusión: bug activo de rollout/distribución (no de lógica local), pendiente de corte/release para cerrar `PUM-011`.

package/integrations/config/skillsMarkdownRules.ts

@@ -87,6 +87,25 @@ const inferRuleStage = (raw: string): SkillsStage | undefined => {
   return undefined;
 };
 
+const KNOWN_RULE_DEFAULT_STAGE: Readonly<Record<string, SkillsStage>> = {
+  'skills.backend.no-solid-violations': 'PRE_PUSH',
+  'skills.frontend.no-solid-violations': 'PRE_PUSH',
+  'skills.backend.enforce-clean-architecture': 'PRE_PUSH',
+  'skills.frontend.enforce-clean-architecture': 'PRE_PUSH',
+  'skills.backend.no-god-classes': 'PRE_PUSH',
+  'skills.frontend.no-god-classes': 'PRE_PUSH',
+};
+
+const resolveDefaultStageForKnownRule = (
+  ruleId: string,
+  inferredStage: SkillsStage | undefined
+): SkillsStage | undefined => {
+  if (inferredStage) {
+    return inferredStage;
+  }
+  return KNOWN_RULE_DEFAULT_STAGE[ruleId];
+};
+
 const isRuleCandidateLine = (line: string): boolean => {
   if (CHECK_RULE_PREFIX.test(line)) {
     return true;
@@ -339,6 +358,11 @@ export const extractCompiledRulesFromSkillMarkdown = (params: {
     const evaluationMode: SkillsRuleEvaluationMode =
       knownRuleId || astNodeIds.length > 0 ? 'AUTO' : 'DECLARATIVE';
 
+    const inferredStage = inferRuleStage(rawLine);
+    const resolvedStage = knownRuleId
+      ? resolveDefaultStageForKnownRule(knownRuleId, inferredStage)
+      : inferredStage;
+
     rules.push({
       id: nextId,
       description,
@@ -346,7 +370,7 @@ export const extractCompiledRulesFromSkillMarkdown = (params: {
       platform,
       sourceSkill: params.sourceSkill,
       sourcePath: params.sourcePath,
-      stage: inferRuleStage(rawLine),
+      stage: resolvedStage,
       confidence: inferRuleConfidence(rawLine),
       locked: true,
       evaluationMode,

package/integrations/config/skillsRuleSet.ts

@@ -256,6 +256,34 @@ const toSkillsRuntimeIrSource = (params: {
   );
 };
 
+const buildRuleFindingMessage = (params: {
+  rule: SkillsCompiledRule;
+  mappedHeuristicRuleIds: ReadonlyArray<string>;
+  observedFilePaths?: ReadonlyArray<string>;
+}): string => {
+  if (!params.rule.id.endsWith('.no-solid-violations')) {
+    return params.rule.description;
+  }
+
+  const relevantObservedPaths = (params.observedFilePaths ?? [])
+    .map((path) => normalizeObservedPath(path))
+    .filter((path) =>
+      isObservedPathForPlatform({
+        platform: params.rule.platform,
+        path,
+      })
+    );
+  const samplePaths = [...new Set(relevantObservedPaths)].slice(0, 3);
+  const astNodes = [...params.mappedHeuristicRuleIds].sort();
+  const astNodesToken = astNodes.length > 0 ? astNodes.join(',') : 'none';
+  const sampleToken = samplePaths.length > 0 ? ` sample_paths=[${samplePaths.join(', ')}].` : '';
+
+  return (
+    `${params.rule.description} ` +
+    `Criteria: ast_nodes=[${astNodesToken}], observed_paths=${relevantObservedPaths.length}.${sampleToken}`
+  );
+};
+
 const stageApplies = (
   currentStage: Exclude<GateStage, 'STAGED'>,
   ruleStage?: Exclude<GateStage, 'STAGED'>
@@ -365,6 +393,11 @@ const toRuleDefinition = (params: {
     rule: params.rule,
     mappedHeuristicRuleIds,
   });
+  const findingMessage = buildRuleFindingMessage({
+    rule: params.rule,
+    mappedHeuristicRuleIds,
+    observedFilePaths: params.observedFilePaths,
+  });
 
   if (evaluationMode === 'AUTO') {
     if (mappedHeuristicRuleIds.length === 0) {
@@ -395,7 +428,7 @@ const toRuleDefinition = (params: {
       when,
       then: {
         kind: 'Finding',
-        message: params.rule.description,
+        message: findingMessage,
         code: toCode(params.rule.id),
         source: runtimeIrSource,
       },

package/integrations/gate/evaluateAiGate.ts

@@ -168,6 +168,23 @@ const toWarnViolation = (code: string, message: string): AiGateViolation => ({
   message,
 });
 
+const normalizeRepoStateLifecycleVersions = (repoState: RepoState): RepoState => {
+  const packageVersion = repoState.lifecycle.package_version;
+  const lifecycleVersion = repoState.lifecycle.lifecycle_version;
+  if (packageVersion === lifecycleVersion) {
+    return repoState;
+  }
+  const canonicalVersion = packageVersion ?? lifecycleVersion ?? null;
+  return {
+    ...repoState,
+    lifecycle: {
+      ...repoState.lifecycle,
+      package_version: canonicalVersion,
+      lifecycle_version: canonicalVersion,
+    },
+  };
+};
+
 const toPositiveInteger = (value: unknown, fallback: number): number => {
   if (typeof value !== 'number' || !Number.isFinite(value)) {
     return fallback;
@@ -272,6 +289,45 @@ const toDetectedSkillsPlatforms = (
   return detected;
 };
 
+const toCoverageInferredPlatforms = (
+  coverage: NonNullable<Extract<EvidenceReadResult, { kind: 'valid' }>['evidence']['snapshot']['rules_coverage']> | undefined
+): ReadonlyArray<PreWriteSkillsPlatform> => {
+  if (!coverage) {
+    return [];
+  }
+  const ruleIds = [...coverage.active_rule_ids, ...coverage.evaluated_rule_ids];
+  const inferred = new Set<PreWriteSkillsPlatform>();
+  for (const ruleId of ruleIds) {
+    for (const platform of PREWRITE_SKILLS_PLATFORMS) {
+      const prefix = PLATFORM_SKILLS_RULE_PREFIXES[platform];
+      if (ruleId.startsWith(prefix)) {
+        inferred.add(platform);
+      }
+    }
+  }
+  return PREWRITE_SKILLS_PLATFORMS.filter((platform) => inferred.has(platform));
+};
+
+const toEffectiveSkillsPlatforms = (params: {
+  platforms: Extract<EvidenceReadResult, { kind: 'valid' }>['evidence']['platforms'] | undefined;
+  coverage: NonNullable<Extract<EvidenceReadResult, { kind: 'valid' }>['evidence']['snapshot']['rules_coverage']> | undefined;
+}): ReadonlyArray<PreWriteSkillsPlatform> => {
+  const detectedPlatforms = toDetectedSkillsPlatforms(params.platforms);
+  if (detectedPlatforms.length === 0) {
+    return [];
+  }
+  const inferredFromCoverage = toCoverageInferredPlatforms(params.coverage);
+  if (inferredFromCoverage.length === 0) {
+    return detectedPlatforms;
+  }
+  const inferredSet = new Set(inferredFromCoverage);
+  const intersection = detectedPlatforms.filter((platform) => inferredSet.has(platform));
+  if (intersection.length > 0) {
+    return intersection;
+  }
+  return detectedPlatforms;
+};
+
 const collectActiveRuleIdsCoverageViolations = (params: {
   stage: AiGateStage;
   evidence: Extract<EvidenceReadResult, { kind: 'valid' }>['evidence'];
@@ -280,14 +336,23 @@ const collectActiveRuleIdsCoverageViolations = (params: {
   if (params.coverage.active_rule_ids.length > 0) {
     return [];
   }
-  const detectedPlatforms = toDetectedSkillsPlatforms(params.evidence.platforms);
-  if (detectedPlatforms.length === 0) {
+  const effectivePlatforms = toEffectiveSkillsPlatforms({
+    platforms: params.evidence.platforms,
+    coverage: params.coverage,
+  });
+  const inferredPlatforms =
+    effectivePlatforms.length > 0 ? [] : toCoverageInferredPlatforms(params.coverage);
+  const blockedPlatforms = effectivePlatforms.length > 0
+    ? effectivePlatforms
+    : inferredPlatforms;
+  if (blockedPlatforms.length === 0) {
     return [];
   }
+  const detectionMode = effectivePlatforms.length > 0 ? 'detected' : 'inferred';
   return [
     toErrorViolation(
       'EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES',
-      `Active rules coverage is empty at ${params.stage} with detected code platforms=[${detectedPlatforms.join(', ')}].`
+      `Active rules coverage is empty at ${params.stage} with ${detectionMode} code platforms=[${blockedPlatforms.join(', ')}].`
     ),
   ];
 };
@@ -296,7 +361,10 @@ const collectPreWritePlatformSkillsViolations = (params: {
   evidence: Extract<EvidenceReadResult, { kind: 'valid' }>['evidence'];
   coverage: NonNullable<Extract<EvidenceReadResult, { kind: 'valid' }>['evidence']['snapshot']['rules_coverage']>;
 }): AiGateViolation[] => {
-  const detectedPlatforms = toDetectedSkillsPlatforms(params.evidence.platforms);
+  const detectedPlatforms = toEffectiveSkillsPlatforms({
+    platforms: params.evidence.platforms,
+    coverage: params.coverage,
+  });
   if (detectedPlatforms.length === 0) {
     return [];
   }
@@ -393,7 +461,10 @@ const collectPreWriteCrossPlatformCriticalViolations = (params: {
   evidence: Extract<EvidenceReadResult, { kind: 'valid' }>['evidence'];
   coverage: NonNullable<Extract<EvidenceReadResult, { kind: 'valid' }>['evidence']['snapshot']['rules_coverage']>;
 }): AiGateViolation[] => {
-  const detectedPlatforms = toDetectedSkillsPlatforms(params.evidence.platforms);
+  const detectedPlatforms = toEffectiveSkillsPlatforms({
+    platforms: params.evidence.platforms,
+    coverage: params.coverage,
+  });
   if (detectedPlatforms.length === 0) {
     return [];
   }
@@ -447,7 +518,10 @@ const toSkillsContractAssessment = (params: {
   }
 
   const coverage = params.evidenceResult.evidence.snapshot.rules_coverage;
-  const detectedPlatforms = toDetectedSkillsPlatforms(params.evidenceResult.evidence.platforms);
+  const detectedPlatforms = toEffectiveSkillsPlatforms({
+    platforms: params.evidenceResult.evidence.platforms,
+    coverage,
+  });
   if (detectedPlatforms.length === 0) {
     return {
       stage: params.stage,
@@ -977,7 +1051,9 @@ export const evaluateAiGate = (
   const protectedBranches = new Set(params.protectedBranches ?? Array.from(DEFAULT_PROTECTED_BRANCHES));
   const nowMs = activeDependencies.now();
   const evidenceResult = activeDependencies.readEvidenceResult(params.repoRoot);
-  const repoState = activeDependencies.captureRepoState(params.repoRoot);
+  const repoState = normalizeRepoStateLifecycleVersions(
+    activeDependencies.captureRepoState(params.repoRoot)
+  );
   const policyStage = toPolicyStage(params.stage);
   const resolvedPolicy = activeDependencies.resolvePolicyForStage(
     policyStage,

package/integrations/git/runPlatformGateOutput.ts

@@ -17,6 +17,10 @@ const BLOCK_NEXT_ACTION_BY_CODE: Readonly<Record<string, string>> = {
     'git restore --staged . && separa cambios en commits más pequeños',
   GIT_ATOMICITY_TOO_MANY_SCOPES:
     'git restore --staged . && git add <scope>/ && git commit -m "<tipo>: <scope>"',
+  ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES_HIGH:
+    'Reconcilia policy/skills y reintenta PRE_COMMIT: npx --yes --package pumuki@latest pumuki policy reconcile --strict --json && npx --yes --package pumuki@latest pumuki-pre-commit',
+  SKILLS_SKILLS_FRONTEND_NO_SOLID_VIOLATIONS:
+    'Aplica refactor incremental: extrae 1 componente/hook por commit y vuelve a ejecutar PRE_COMMIT.',
 };
 
 const severityWeight = (severity: string): number => {

package/integrations/git/stageRunners.ts

@@ -21,6 +21,7 @@ import {
 import { readFileSync } from 'node:fs';
 import { readEvidence, readEvidenceResult } from '../evidence/readEvidence';
 import type { EvidenceReadResult } from '../evidence/readEvidence';
+import { ensureRuntimeArtifactsIgnored } from '../lifecycle/artifacts';
 
 const PRE_PUSH_UPSTREAM_REQUIRED_MESSAGE =
   'pumuki pre-push blocked: branch has no upstream tracking reference. Configure upstream first (for example: git push --set-upstream origin <branch>) and retry.';
@@ -43,6 +44,10 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_BRANCH_MISMATCH: 'Regenera evidencia en la rama actual y reintenta.',
   EVIDENCE_RULES_COVERAGE_MISSING: 'Ejecuta auditoría completa para recalcular rules_coverage.',
   EVIDENCE_RULES_COVERAGE_INCOMPLETE: 'Asegura coverage_ratio=1 y unevaluated=0.',
+  ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES_HIGH:
+    'Reconcilia policy/skills y reintenta PRE_COMMIT: npx --yes --package pumuki@latest pumuki policy reconcile --strict --json && npx --yes --package pumuki@latest pumuki-pre-commit',
+  EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES:
+    'Reconcilia policy/skills y revalida PRE_WRITE: npx --yes --package pumuki@latest pumuki policy reconcile --strict --json && npx --yes --package pumuki@latest pumuki sdd validate --stage=PRE_WRITE --json',
   GITFLOW_PROTECTED_BRANCH: 'Trabaja en feature/* y evita ramas protegidas.',
   PRE_PUSH_UPSTREAM_MISSING: 'Ejecuta: git push --set-upstream origin <branch>',
   PRE_PUSH_UPSTREAM_MISALIGNED:
@@ -83,6 +88,7 @@ type StageRunnerDependencies = {
   now: () => number;
   writeHookGateSummary: (message: string) => void;
   isQuietMode: () => boolean;
+  ensureRuntimeArtifactsIgnored: (repoRoot: string) => void;
 };
 
 const defaultDependencies: StageRunnerDependencies = {
@@ -132,6 +138,12 @@ const defaultDependencies: StageRunnerDependencies = {
     process.stdout.write(`${message}\n`);
   },
   isQuietMode: () => process.argv.includes('--quiet'),
+  ensureRuntimeArtifactsIgnored: (repoRoot) => {
+    try {
+      ensureRuntimeArtifactsIgnored(repoRoot);
+    } catch {
+    }
+  },
 };
 
 const getDependencies = (
@@ -160,9 +172,14 @@ const notifyGateBlockedForStage = (params: {
 }): void => {
   const repoRoot = params.dependencies.resolveRepoRoot();
   const evidence = params.dependencies.readEvidence(repoRoot);
+  const stageFindings =
+    evidence?.snapshot.stage === params.stage
+      ? evidence.snapshot.findings
+      : [];
+  const firstStageFinding = stageFindings[0];
   const firstViolation = evidence?.ai_gate.violations[0];
-  const causeCode = firstViolation?.code ?? params.fallbackCauseCode;
-  const causeMessage = firstViolation?.message ?? params.fallbackCauseMessage;
+  const causeCode = firstStageFinding?.code ?? firstViolation?.code ?? params.fallbackCauseCode;
+  const causeMessage = firstStageFinding?.message ?? firstViolation?.message ?? params.fallbackCauseMessage;
   const remediation =
     BLOCKED_REMEDIATION_BY_CODE[causeCode]
     ?? params.fallbackRemediation
@@ -170,7 +187,9 @@ const notifyGateBlockedForStage = (params: {
   params.dependencies.notifyGateBlocked({
     repoRoot,
     stage: params.stage,
-    totalViolations: evidence?.ai_gate.violations.length ?? 0,
+    totalViolations: stageFindings.length > 0
+      ? stageFindings.length
+      : evidence?.ai_gate.violations.length ?? 0,
     causeCode,
     causeMessage,
     remediation,
@@ -338,6 +357,7 @@ export async function runPreCommitStage(
 ): Promise<number> {
   const activeDependencies = getDependencies(dependencies);
   const repoRoot = activeDependencies.resolveRepoRoot();
+  activeDependencies.ensureRuntimeArtifactsIgnored(repoRoot);
   if (
     enforceGitAtomicityGate({
       dependencies: activeDependencies,
@@ -379,6 +399,7 @@ export async function runPrePushStage(
 ): Promise<number> {
   const activeDependencies = getDependencies(dependencies);
   const repoRoot = activeDependencies.resolveRepoRoot();
+  activeDependencies.ensureRuntimeArtifactsIgnored(repoRoot);
   const upstreamRef = activeDependencies.resolveUpstreamRef();
   if (!upstreamRef) {
     const prePushInput = activeDependencies.readPrePushStdin();
@@ -519,6 +540,7 @@ export async function runCiStage(
 ): Promise<number> {
   const activeDependencies = getDependencies(dependencies);
   const repoRoot = activeDependencies.resolveRepoRoot();
+  activeDependencies.ensureRuntimeArtifactsIgnored(repoRoot);
   const ciBaseRef = activeDependencies.resolveCiBaseRef();
   if (
     enforceGitAtomicityGate({