pumuki 6.3.45 → 6.3.46

package/docs/RELEASE_NOTES.md

@@ -5,6 +5,19 @@ Detailed commit history remains available through Git history (`git log` / `git
 
 ## 2026-03 (enterprise hardening updates)
 
+### 2026-03-05 (v6.3.46)
+
+- Paridad hook/watch en auto-remediación de skills coverage:
+  - `pre-commit` y `pre-push` ahora ejecutan `policy reconcile --strict --apply` y reintentan una única vez cuando el bloqueo es de coverage de skills.
+  - elimina recurrencia de bootstrap/reconcile manual entre iteraciones de consumer.
+- Contrato `watch --json` enriquecido para drift de versión:
+  - nuevo bloque `version` con `effective/runtime/consumerInstalled/source`,
+  - incluye `driftFromRuntime` y `driftWarning` cuando el binario del consumer no está alineado con runtime/latest.
+- Evidencia de validación:
+  - `npx --yes tsx@4.21.0 --test integrations/git/__tests__/stageRunners.test.ts` (`30 pass / 0 fail`)
+  - `npx --yes tsx@4.21.0 --test integrations/lifecycle/__tests__/watch.test.ts integrations/lifecycle/__tests__/cli.test.ts` (`48 pass / 0 fail`)
+  - `npm run -s typecheck` (`PASS`)
+
 ### 2026-03-05 (v6.3.45)
 
 - SDD sync canónico ampliado por defecto en consumer:

package/docs/USAGE.md

@@ -334,6 +334,8 @@ Watch runtime behavior:
 Backlog tooling behavior (`watch` + `reconcile` scripts):
 - mapping precedence is deterministic: inline `#issue` -> `--id-issue-map-from` -> `--id-issue-map` -> `--resolve-missing-via-gh`.
 - `watch-consumer-backlog` is non-destructive and reports action-required drift.
+- `watch-consumer-backlog-fleet` agrega varios backlogs en una sola ejecución y devuelve resumen consolidado por target.
+- `watch-consumer-backlog-fleet-tick` ejecuta un ciclo canónico SAAS+RuralGo+Flux con overrides opcionales (`--saas/--ruralgo/--flux`).
 - `watch-consumer-backlog` reports heading drift (`heading_drift`) when section headers `### ✅/🚧/⏳/⛔ <ID>` diverge from effective table status.
 - `watch-consumer-backlog --json` exposes `heading_drift_count` for low-friction alerting parsers.
 - `watch-consumer-backlog --json` exposes `classification_counts` (`needs_issue`, `drift_closed_issue`, `active_issue`, `heading_drift`).
@@ -405,6 +407,9 @@ Backlog tooling quick reference:
 |---|---|
 | `npm run -s test:backlog-tooling` | Ejecutar suite focal de regresión del tooling de backlog. |
 | `scripts/watch-consumer-backlog.ts --json` | Detectar drift accionable sin mutar archivos. |
+| `scripts/watch-consumer-backlog-fleet.ts --json` | Vigilar varios backlogs consumidores y consolidar estado global en una sola salida. |
+| `npm run -s validation:backlog-watch:tick` | Ejecutar tick canónico único (SAAS+RuralGo+Flux) para decisión rápida `fix now` vs `no-action`. |
+| `npm run -s validation:backlog-watch:gate` | Gate previo a release: falla con exit code `1` si hay señal neta accionable en cualquier consumer. |
 | `scripts/reconcile-consumer-backlog-issues.ts --json` | Simular reconciliación (dry-run) y revisar cambios planeados. |
 | `scripts/reconcile-consumer-backlog-issues.ts --apply` | Aplicar reconciliación sobre el backlog consumidor. |
 
@@ -429,6 +434,20 @@ npx --yes tsx@4.21.0 scripts/watch-consumer-backlog.ts \
   --resolve-missing-via-gh \
   --json
 
+# watch fleet: varios consumers en una sola pasada (sin mutar, sin fallar pipeline)
+npx --yes tsx@4.21.0 scripts/watch-consumer-backlog-fleet.ts \
+  --target=/abs/path/consumer1/PUMUKI_BUGS_MEJORAS.md::SwiftEnProfundidad/ast-intelligence-hooks \
+  --target=/abs/path/consumer2/pumuki-integration-feedback.md::SwiftEnProfundidad/ast-intelligence-hooks \
+  --target=/abs/path/consumer3/BUGS_Y_MEJORAS_PUMUKI.md \
+  --json \
+  --no-fail
+
+# watch tick canónico (usa rutas por defecto y devuelve JSON consolidado)
+npm run -s validation:backlog-watch:tick
+
+# gate de release (misma señal, pero bloquea con exit code 1 si hay acción requerida)
+npm run -s validation:backlog-watch:gate
+
 # reconcile dry-run: same source chain
 npx --yes tsx@4.21.0 scripts/reconcile-consumer-backlog-issues.ts \
   --file=/abs/path/consumer/PUMUKI_BUGS_MEJORAS.md \

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

@@ -2185,8 +2185,208 @@
     - `npx --yes tsx@4.21.0 --test integrations/mcp/__tests__/aiGateCheck.test.ts integrations/mcp/__tests__/preFlightCheck.test.ts integrations/mcp/__tests__/autoExecuteAiStart.test.ts integrations/sdd/__tests__/syncDocs.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `78 pass / 0 fail`.
     - `npm run -s typecheck` -> `PASS`.
 
-- 🚧 PUMUKI-167: Preparar release + rollout consumidor tras cierre de backlog SDD/Flux/RuralGo.
-  - Alcance:
-    - consolidar changelog de fixes/mejoras cerradas en este bloque,
-    - publicar nueva versión npm con evidencia de tests en verde,
-    - ejecutar upgrade/update en repos consumidores (`SAAS`, `R_GO`) y validar smoke mínimo post-upgrade.
+- ✅ PUMUKI-167: Preparar release + rollout consumidor tras cierre de backlog SDD/Flux/RuralGo.
+  - Resultado (2026-03-05):
+    - versión publicada: `pumuki@6.3.45`.
+    - changelog/release notes actualizados para bloque SDD:
+      - `sync-docs` default 3 docs canónicos,
+      - `auto-sync` default `tasks/design/retrospective`,
+      - `learning_context` automático en tools MCP.
+    - rollout consumidor completado:
+      - `R_GO`: `install + status --json + doctor --json` en verde (`lifecycleState.version=6.3.45`, `issues=[]`).
+      - `SAAS:APP_SUPERMERCADOS`: `install + status --json + doctor --json` en verde (`lifecycleState.version=6.3.45`, `issues=[]`).
+      - `Flux_training`: `install + status --json + doctor --json` en verde (`lifecycleState.version=6.3.45`, `issues=[]`).
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/mcp/__tests__/aiGateCheck.test.ts integrations/mcp/__tests__/preFlightCheck.test.ts integrations/mcp/__tests__/autoExecuteAiStart.test.ts integrations/sdd/__tests__/syncDocs.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `78 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - `npm publish --access public` -> `+ pumuki@6.3.45`.
+    - `npm view pumuki@6.3.45 version` -> `6.3.45`.
+
+- ✅ PUMUKI-168: Monitorización post-release 6.3.45 en consumidores reales y captura de hallazgos netos nuevos (sin reabrir cerrados).
+  - Resultado (2026-03-05):
+    - pasada completa de `backlog-watch` en consumidores:
+      - `SAAS`: `entriesScanned=25`, `nonClosedEntries=0`, `hasActionRequired=false`.
+      - `RuralGo`: `entriesScanned=100`, `nonClosedEntries=0`, `hasActionRequired=false`.
+      - `Flux`: se detectó gap de parser (`entriesScanned=0`) con IDs `PUM-*`.
+    - fix inmediato aplicado en core backlog tooling para compatibilidad con IDs Flux:
+      - regex de IDs ampliado a `PUM-*` en:
+        - `scripts/watch-consumer-backlog-lib.ts`
+        - `scripts/reconcile-consumer-backlog-issues-lib.ts`
+        - `scripts/backlog-id-issue-map-lib.ts`
+      - tests de regresión añadidos:
+        - `scripts/__tests__/watch-consumer-backlog.test.ts`
+        - `scripts/__tests__/reconcile-consumer-backlog-issues.test.ts`
+        - `scripts/__tests__/backlog-id-issue-map-lib.test.ts`
+    - revalidación post-fix:
+      - `Flux` pasa a `entriesScanned=12`, `nonClosedEntries=0`, `hasActionRequired=false`.
+  - Evidencia:
+    - `npm run -s test:backlog-tooling` -> `51 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - `npm run -s validation:backlog-watch -- --file=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/SAAS:APP_SUPERMERCADOS/docs/pumuki/PUMUKI_BUGS_MEJORAS.md\" --repo=SwiftEnProfundidad/ast-intelligence-hooks --json --no-fail` -> `hasActionRequired=false`.
+    - `npm run -s validation:backlog-watch -- --file=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/R_GO/docs/technical/08-validation/refactor/pumuki-integration-feedback.md\" --repo=SwiftEnProfundidad/ast-intelligence-hooks --json --no-fail` -> `hasActionRequired=false`.
+    - `npm run -s validation:backlog-watch -- --file=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/Flux_training/docs/BUGS_Y_MEJORAS_PUMUKI.md\" --repo=SwiftEnProfundidad/ast-intelligence-hooks --json --no-fail` -> `entriesScanned=12`, `hasActionRequired=false`.
+
+- ✅ PUMUKI-169: Vigilancia continua post-6.3.45 + preparación de siguiente corte solo ante incidencia neta reproducible.
+  - Resultado (2026-03-05):
+    - monitorización ejecutada en los 3 consumers con `backlog-watch`:
+      - `SAAS`: `entriesScanned=25`, `nonClosedEntries=0`, `hasActionRequired=false`.
+      - `RuralGo`: `entriesScanned=100`, `nonClosedEntries=0`, `hasActionRequired=false`.
+      - `Flux`: se detectó bug de parser interno (IDs `PUM-*` no contabilizados, `entriesScanned=0`).
+    - fix aplicado en core backlog-tooling:
+      - soporte de IDs `PUM-*` añadido en:
+        - `scripts/watch-consumer-backlog-lib.ts`
+        - `scripts/reconcile-consumer-backlog-issues-lib.ts`
+        - `scripts/backlog-id-issue-map-lib.ts`
+      - regresión cubierta en tests:
+        - `scripts/__tests__/watch-consumer-backlog.test.ts`
+        - `scripts/__tests__/reconcile-consumer-backlog-issues.test.ts`
+        - `scripts/__tests__/backlog-id-issue-map-lib.test.ts`
+    - revalidación post-fix:
+      - `Flux` pasa a `entriesScanned=12`, `nonClosedEntries=0`, `hasActionRequired=false`.
+  - Evidencia:
+    - `npm run -s test:backlog-tooling` -> `51 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - `npm run -s validation:backlog-watch -- --file=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/Flux_training/docs/BUGS_Y_MEJORAS_PUMUKI.md\" --repo=SwiftEnProfundidad/ast-intelligence-hooks --json --no-fail` -> `entriesScanned=12`, `hasActionRequired=false`.
+
+- ✅ PUMUKI-170: Consolidar vigilancia multi-consumer en un solo comando fleet para reducir fricción operativa y mantener la señal neta en una ejecución única.
+  - Resultado (2026-03-05):
+    - nuevo comando fleet:
+      - `scripts/watch-consumer-backlog-fleet.ts`
+      - permite múltiples `--target=<path>[::repo]`, resumen agregado y salida JSON consolidada.
+    - cobertura añadida:
+      - `scripts/__tests__/watch-consumer-backlog-fleet.test.ts` (help, agregación JSON multi-target, exit code determinista con/ sin `--no-fail`).
+    - wiring operativo:
+      - `package.json`: nuevo script `validation:backlog-watch:fleet`.
+      - `docs/USAGE.md`: comportamiento, referencia rápida y ejemplo de uso multi-consumer.
+  - Evidencia:
+    - `npm run -s test:backlog-tooling` -> `54 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - `npm run -s validation:backlog-watch:fleet -- --target=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/SAAS:APP_SUPERMERCADOS/docs/pumuki/PUMUKI_BUGS_MEJORAS.md::SwiftEnProfundidad/ast-intelligence-hooks\" --target=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/R_GO/docs/technical/08-validation/refactor/pumuki-integration-feedback.md::SwiftEnProfundidad/ast-intelligence-hooks\" --target=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/Flux_training/docs/BUGS_Y_MEJORAS_PUMUKI.md\" --json --no-fail` -> `targets=3`, `has_action_required=false`.
+
+- ✅ PUMUKI-171: Mantener vigilancia continua con el nuevo comando fleet y abrir fix incremental solo ante incidencia neta reproducible.
+  - Resultado (2026-03-05):
+    - ciclo de vigilancia ejecutado con `validation:backlog-watch:fleet` en `SAAS`, `RuralGo`, `Flux`.
+    - salida consolidada limpia:
+      - `targets=3`
+      - `entries_scanned_total=137`
+      - `non_closed_total=0`
+      - `action_required_targets=0`
+      - `has_action_required=false`
+    - no se abrió frente técnico nuevo porque no hubo señal neta reproducible.
+  - Evidencia:
+    - `npm run -s validation:backlog-watch:fleet -- --target=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/SAAS:APP_SUPERMERCADOS/docs/pumuki/PUMUKI_BUGS_MEJORAS.md::SwiftEnProfundidad/ast-intelligence-hooks\" --target=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/R_GO/docs/technical/08-validation/refactor/pumuki-integration-feedback.md::SwiftEnProfundidad/ast-intelligence-hooks\" --target=\"/Users/juancarlosmerlosalbarracin/Developer/Projects/Flux_training/docs/BUGS_Y_MEJORAS_PUMUKI.md\" --json --no-fail` -> `has_action_required=false`.
+
+- ✅ PUMUKI-172: Automatizar vigilancia cíclica sin fricción (tick único) y dejar evidencia compacta para decisión de release/fix.
+  - Resultado (2026-03-05):
+    - nuevo comando operativo de tick:
+      - `scripts/watch-consumer-backlog-fleet-tick.ts`
+      - defaults canónicos para `SAAS`, `RuralGo` y `Flux` con overrides por flag (`--saas/--ruralgo/--flux`) y repo configurable (`--repo`).
+    - wiring operativo:
+      - `package.json`: nuevo script `validation:backlog-watch:tick`.
+      - `docs/USAGE.md`: comportamiento + referencia rápida + ejemplo de uso.
+    - cobertura añadida:
+      - `scripts/__tests__/watch-consumer-backlog-fleet-tick.test.ts` (`--help`, JSON limpio, exit code 1 con findings sin `--no-fail`).
+    - ejecución real del tick canónico completada en verde (`has_action_required=false`).
+  - Evidencia:
+    - `npm run -s test:backlog-tooling` -> `57 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - `npm run -s validation:backlog-watch:tick` -> `targets=3`, `entries_scanned_total=137`, `has_action_required=false`.
+
+- ✅ PUMUKI-173: Cerrar ciclo de release incremental con criterio “no-action” documentado y checklist de publicación solo cuando haya señal neta.
+  - Resultado (2026-03-05):
+    - criterio operativo formalizado en comandos:
+      - `validation:backlog-watch:tick` (observabilidad, no bloquea pipeline).
+      - `validation:backlog-watch:gate` (gate de release, bloquea con exit code `1` cuando hay señal neta).
+    - documentación actualizada en `docs/USAGE.md` con quick reference y ejemplo explícito para ambos comandos.
+    - verificación real:
+      - `tick` y `gate` devuelven `has_action_required=false` en el estado actual de `SAAS`, `RuralGo`, `Flux`.
+  - Evidencia:
+    - `npm run -s validation:backlog-watch:tick` -> `targets=3`, `has_action_required=false`.
+    - `npm run -s validation:backlog-watch:gate` -> `targets=3`, `has_action_required=false`.
+    - `npm run -s typecheck` -> `PASS`.
+
+- ✅ PUMUKI-174: Ejecutar ciclo de vigilancia continua y preparar fix inmediato solo al primer `has_action_required=true` en consumers.
+  - Resultado (2026-03-05):
+    - ciclo de vigilancia ejecutado con ambos modos:
+      - `validation:backlog-watch:tick` (observabilidad),
+      - `validation:backlog-watch:gate` (bloqueante para release).
+    - salida consolidada del ciclo:
+      - `targets=3`
+      - `entries_scanned_total=137`
+      - `non_closed_total=0`
+      - `has_action_required=false`
+    - no se abrió issue/fix nuevo porque no hubo señal neta reproducible.
+  - Evidencia:
+    - `npm run -s validation:backlog-watch:tick` -> `has_action_required=false`.
+    - `npm run -s validation:backlog-watch:gate` -> `has_action_required=false`.
+
+- ✅ PUMUKI-175: Mantener operación continua de vigilancia y disparar fix/release incremental únicamente con señal neta (`has_action_required=true`).
+  - Resultado (2026-03-05):
+    - ciclo de vigilancia periódico ejecutado en modo observabilidad (`tick`) y modo gate (`gate`).
+    - señal consolidada estable:
+      - `targets=3`
+      - `entries_scanned_total=137`
+      - `non_closed_total=0`
+      - `action_required_targets=0`
+      - `has_action_required=false`
+    - no se abrió issue/fix nuevo al no existir incidencia neta reproducible.
+  - Evidencia:
+    - `npm run -s validation:backlog-watch:tick` -> `has_action_required=false`.
+    - `npm run -s validation:backlog-watch:gate` -> `has_action_required=false`.
+
+- ✅ PUMUKI-176: Continuar vigilancia operativa y abrir ejecución técnica inmediata al primer hallazgo neto en SAAS/RuralGo/Flux.
+  - Resultado (2026-03-05):
+    - ciclo ejecutado con `tick` y `gate` en los tres consumers.
+    - resumen consolidado:
+      - `targets=3`
+      - `entries_scanned_total=137`
+      - `non_closed_total=0`
+      - `action_required_targets=0`
+      - `has_action_required=false`
+    - sin señal neta reproducible, por lo que no se abrió fix nuevo.
+  - Evidencia:
+    - `npm run -s validation:backlog-watch:tick` -> `has_action_required=false`.
+    - `npm run -s validation:backlog-watch:gate` -> `has_action_required=false`.
+
+- ✅ PUMUKI-177: Mantener vigilancia continua y disparar fix inmediato al primer `has_action_required=true` con actualización simultánea de leyendas externas e internas.
+  - Resultado (2026-03-05):
+    - se detectó señal neta en `Flux` (`has_action_required=true`) por `needs_issue` en `PUM-009/010/011`.
+    - normalización ejecutada sin tocar código funcional del consumer:
+      - `PUM-009` validado como corregido con `pumuki@latest` (`artifact.version="1"` + `artifact.slices[]`) y marcado `✅ Cerrado`.
+      - `PUM-011` validado como corregido con `pumuki@latest` (`lastTick.changedFiles[]` + `lastTick.evaluatedFiles[]`) y marcado `✅ Cerrado`.
+      - `PUM-010` mantenido activo y enlazado a issue upstream `#719` para trazabilidad (`🚧 En construccion`).
+    - tras normalización de leyenda/refs en MD externo, el ciclo vuelve a estado saludable (`has_action_required=false`).
+  - Evidencia:
+    - `gh issue create ...` -> `https://github.com/SwiftEnProfundidad/ast-intelligence-hooks/issues/719`.
+    - `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` (en Flux) -> contrato válido.
+    - `npx --yes --package pumuki@latest pumuki watch --once --stage=PRE_COMMIT --scope=staged --json` (en Flux) -> `lastTick.changedFiles[]` y `lastTick.evaluatedFiles[]` presentes.
+    - `npm run -s validation:backlog-watch:tick` + `npm run -s validation:backlog-watch:gate` -> `has_action_required=false`.
+
+- ✅ PUMUKI-178: Ejecutar implementación técnica del issue `#719` para persistencia estable de skills coverage entre iteraciones en consumer.
+  - Resultado (2026-03-05):
+    - `stageRunners` ahora replica el patrón de auto-reconcile de `watch` para bloqueos de skills coverage en hooks (`PRE_COMMIT`/`PRE_PUSH`):
+      - detecta códigos de bloqueo de cobertura de skills,
+      - ejecuta `policy reconcile --strict --apply`,
+      - reintenta una única vez el gate de hook con política re-resuelta.
+    - cobertura de regresión añadida:
+      - retry exitoso con reconcile automático en `PRE_COMMIT`,
+      - no-retry cuando `PUMUKI_HOOK_POLICY_AUTO_RECONCILE=0`.
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/git/__tests__/stageRunners.test.ts` -> `30 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+
+- ✅ PUMUKI-179: Ejecutar siguiente foco activo de Flux (`PUM-012`) para eliminar drift entre binario local del consumer y `pumuki@latest` en contrato `watch --json` (`changedFiles/evaluatedFiles` + versión efectiva).
+  - Resultado (2026-03-05):
+    - `watch --json` ahora expone bloque `version` con:
+      - `effective`, `runtime`, `consumerInstalled`, `source`,
+      - `driftFromRuntime`,
+      - `driftWarning` humano/accionable cuando existe desalineación.
+    - cobertura técnica añadida:
+      - `integrations/lifecycle/__tests__/watch.test.ts` (metadata + warning de drift),
+      - ajuste de contrato en `integrations/lifecycle/__tests__/cli.test.ts`.
+  - Evidencia:
+    - `npx --yes tsx@4.21.0 --test integrations/lifecycle/__tests__/watch.test.ts integrations/lifecycle/__tests__/cli.test.ts` -> `48 pass / 0 fail`.
+    - `npm run -s typecheck` -> `PASS`.
+    - smoke consumer Flux (binario local core): `watch --once --json` -> `version.driftFromRuntime=true` + `driftWarning` presente.
+
+- 🚧 PUMUKI-180: Cerrar rollout consumidor de `PUM-012` (release + update en Flux) y mover leyenda externa de `🚧` a `✅` con evidencia en `pnpm exec pumuki watch --json`.

package/integrations/git/stageRunners.ts

@@ -22,6 +22,7 @@ import { readFileSync } from 'node:fs';
 import { readEvidence, readEvidenceResult } from '../evidence/readEvidence';
 import type { EvidenceReadResult } from '../evidence/readEvidence';
 import { ensureRuntimeArtifactsIgnored } from '../lifecycle/artifacts';
+import { runPolicyReconcile } from '../lifecycle/policyReconcile';
 
 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.';
@@ -54,6 +55,14 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
     'Alinea upstream con la rama actual: git branch --unset-upstream && git push --set-upstream origin <branch>',
 };
 
+const HOOK_POLICY_RECONCILE_CODES = new Set<string>([
+  'SKILLS_PLATFORM_COVERAGE_INCOMPLETE_HIGH',
+  'SKILLS_SCOPE_COMPLIANCE_INCOMPLETE_HIGH',
+  'EVIDENCE_PLATFORM_SKILLS_SCOPE_INCOMPLETE',
+  'EVIDENCE_PLATFORM_SKILLS_BUNDLES_MISSING',
+  'EVIDENCE_CROSS_PLATFORM_CRITICAL_ENFORCEMENT_INCOMPLETE',
+]);
+
 type StageRunnerDependencies = {
   resolvePolicyForStage: typeof resolvePolicyForStage;
   resolveUpstreamRef: typeof resolveUpstreamRef;
@@ -89,6 +98,7 @@ type StageRunnerDependencies = {
   writeHookGateSummary: (message: string) => void;
   isQuietMode: () => boolean;
   ensureRuntimeArtifactsIgnored: (repoRoot: string) => void;
+  runPolicyReconcile: typeof runPolicyReconcile;
 };
 
 const defaultDependencies: StageRunnerDependencies = {
@@ -144,6 +154,7 @@ const defaultDependencies: StageRunnerDependencies = {
     } catch {
     }
   },
+  runPolicyReconcile,
 };
 
 const getDependencies = (
@@ -196,6 +207,93 @@ const notifyGateBlockedForStage = (params: {
   });
 };
 
+const isHookPolicyAutoReconcileEnabled = (): boolean =>
+  process.env.PUMUKI_HOOK_POLICY_AUTO_RECONCILE !== '0';
+
+const shouldRetryAfterPolicyReconcile = (params: {
+  dependencies: StageRunnerDependencies;
+  repoRoot: string;
+  stage: 'PRE_COMMIT' | 'PRE_PUSH';
+}): boolean => {
+  const evidence = params.dependencies.readEvidence(params.repoRoot);
+  if (!evidence) {
+    return false;
+  }
+  const stageCodes = new Set<string>();
+  if (evidence.snapshot.stage === params.stage) {
+    for (const finding of evidence.snapshot.findings) {
+      stageCodes.add(finding.code);
+    }
+  }
+  for (const violation of evidence.ai_gate.violations) {
+    stageCodes.add(violation.code);
+  }
+  for (const code of stageCodes) {
+    if (HOOK_POLICY_RECONCILE_CODES.has(code)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+type HookStage = 'PRE_COMMIT' | 'PRE_PUSH';
+type HookPolicyTrace = NonNullable<ReturnType<typeof resolvePolicyForStage>['trace']>;
+
+const runHookGateAttempt = async (params: {
+  dependencies: StageRunnerDependencies;
+  stage: HookStage;
+  scope: Parameters<typeof runPlatformGate>[0]['scope'];
+}): Promise<{ exitCode: number; policyTrace: HookPolicyTrace }> => {
+  const resolved = params.dependencies.resolvePolicyForStage(params.stage);
+  const exitCode = await params.dependencies.runPlatformGate({
+    policy: resolved.policy,
+    policyTrace: resolved.trace,
+    scope: params.scope,
+  });
+  return {
+    exitCode,
+    policyTrace: resolved.trace,
+  };
+};
+
+const runHookGateWithPolicyRetry = async (params: {
+  dependencies: StageRunnerDependencies;
+  repoRoot: string;
+  stage: HookStage;
+  scope: Parameters<typeof runPlatformGate>[0]['scope'];
+}): Promise<{ exitCode: number; policyTrace: HookPolicyTrace }> => {
+  const firstAttempt = await runHookGateAttempt({
+    dependencies: params.dependencies,
+    stage: params.stage,
+    scope: params.scope,
+  });
+  if (firstAttempt.exitCode === 0) {
+    return firstAttempt;
+  }
+  if (!isHookPolicyAutoReconcileEnabled()) {
+    return firstAttempt;
+  }
+  if (
+    !shouldRetryAfterPolicyReconcile({
+      dependencies: params.dependencies,
+      repoRoot: params.repoRoot,
+      stage: params.stage,
+    })
+  ) {
+    return firstAttempt;
+  }
+  params.dependencies.runPolicyReconcile({
+    repoRoot: params.repoRoot,
+    strict: true,
+    apply: true,
+  });
+  return runHookGateAttempt({
+    dependencies: params.dependencies,
+    stage: params.stage,
+    scope: params.scope,
+  });
+};
+
 const ZERO_HASH = /^0+$/;
 
 const toEvidenceAgeSeconds = (
@@ -367,10 +465,10 @@ export async function runPreCommitStage(
   ) {
     return 1;
   }
-  const resolved = activeDependencies.resolvePolicyForStage('PRE_COMMIT');
-  const exitCode = await activeDependencies.runPlatformGate({
-    policy: resolved.policy,
-    policyTrace: resolved.trace,
+  const result = await runHookGateWithPolicyRetry({
+    dependencies: activeDependencies,
+    repoRoot,
+    stage: 'PRE_COMMIT',
     scope: {
       kind: 'staged',
     },
@@ -378,10 +476,10 @@ export async function runPreCommitStage(
   emitSuccessfulHookGateSummary({
     dependencies: activeDependencies,
     stage: 'PRE_COMMIT',
-    policyTrace: resolved.trace,
-    exitCode,
+    policyTrace: result.policyTrace,
+    exitCode: result.exitCode,
   });
-  if (exitCode !== 0) {
+  if (result.exitCode !== 0) {
     notifyGateBlockedForStage({
       dependencies: activeDependencies,
       stage: 'PRE_COMMIT',
@@ -391,7 +489,7 @@ export async function runPreCommitStage(
     });
   }
   notifyAuditSummaryForStage(activeDependencies, 'PRE_COMMIT');
-  return exitCode;
+  return result.exitCode;
 }
 
 export async function runPrePushStage(
@@ -427,10 +525,10 @@ export async function runPrePushStage(
       ) {
         return 1;
       }
-      const resolved = activeDependencies.resolvePolicyForStage('PRE_PUSH');
-      const exitCode = await activeDependencies.runPlatformGate({
-        policy: resolved.policy,
-        policyTrace: resolved.trace,
+      const result = await runHookGateWithPolicyRetry({
+        dependencies: activeDependencies,
+        repoRoot,
+        stage: 'PRE_PUSH',
         scope: {
           kind: 'range',
           fromRef: bootstrapBaseRef,
@@ -440,18 +538,18 @@ export async function runPrePushStage(
       emitSuccessfulHookGateSummary({
         dependencies: activeDependencies,
         stage: 'PRE_PUSH',
-        policyTrace: resolved.trace,
-        exitCode,
+        policyTrace: result.policyTrace,
+        exitCode: result.exitCode,
       });
       notifyAuditSummaryForStage(activeDependencies, 'PRE_PUSH');
-      return exitCode;
+      return result.exitCode;
     }
     if (manualInvocationFallback) {
       process.stderr.write(`${PRE_PUSH_MANUAL_FALLBACK_MESSAGE}\n`);
-      const resolved = activeDependencies.resolvePolicyForStage('PRE_PUSH');
-      const exitCode = await activeDependencies.runPlatformGate({
-        policy: resolved.policy,
-        policyTrace: resolved.trace,
+      const result = await runHookGateWithPolicyRetry({
+        dependencies: activeDependencies,
+        repoRoot,
+        stage: 'PRE_PUSH',
         scope: {
           kind: 'workingTree',
         },
@@ -459,11 +557,11 @@ export async function runPrePushStage(
       emitSuccessfulHookGateSummary({
         dependencies: activeDependencies,
         stage: 'PRE_PUSH',
-        policyTrace: resolved.trace,
-        exitCode,
+        policyTrace: result.policyTrace,
+        exitCode: result.exitCode,
       });
       notifyAuditSummaryForStage(activeDependencies, 'PRE_PUSH');
-      return exitCode;
+      return result.exitCode;
     }
     process.stderr.write(`${PRE_PUSH_UPSTREAM_REQUIRED_MESSAGE}\n`);
     notifyGateBlockedForStage({
@@ -506,10 +604,10 @@ export async function runPrePushStage(
     return 1;
   }
 
-  const resolved = activeDependencies.resolvePolicyForStage('PRE_PUSH');
-  const exitCode = await activeDependencies.runPlatformGate({
-    policy: resolved.policy,
-    policyTrace: resolved.trace,
+  const result = await runHookGateWithPolicyRetry({
+    dependencies: activeDependencies,
+    repoRoot,
+    stage: 'PRE_PUSH',
     scope: {
       kind: 'range',
       fromRef: upstreamRef,
@@ -519,10 +617,10 @@ export async function runPrePushStage(
   emitSuccessfulHookGateSummary({
     dependencies: activeDependencies,
     stage: 'PRE_PUSH',
-    policyTrace: resolved.trace,
-    exitCode,
+    policyTrace: result.policyTrace,
+    exitCode: result.exitCode,
   });
-  if (exitCode !== 0) {
+  if (result.exitCode !== 0) {
     notifyGateBlockedForStage({
       dependencies: activeDependencies,
       stage: 'PRE_PUSH',
@@ -532,7 +630,7 @@ export async function runPrePushStage(
     });
   }
   notifyAuditSummaryForStage(activeDependencies, 'PRE_PUSH');
-  return exitCode;
+  return result.exitCode;
 }
 
 export async function runCiStage(

package/integrations/lifecycle/watch.ts

@@ -15,6 +15,7 @@ import {
   emitGateBlockedNotification,
 } from '../notifications/emitAuditSummaryNotification';
 import { runPolicyReconcile } from './policyReconcile';
+import { resolvePumukiVersionMetadata, type PumukiVersionMetadata } from './packageInfo';
 
 export type LifecycleWatchStage = 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
 export type LifecycleWatchScope = 'workingTree' | 'staged' | 'repoAndStaged' | 'repo';
@@ -49,6 +50,14 @@ export type LifecycleWatchTickResult = {
 export type LifecycleWatchResult = {
   command: 'pumuki watch';
   repoRoot: string;
+  version: {
+    effective: string;
+    runtime: string;
+    consumerInstalled: string | null;
+    source: PumukiVersionMetadata['source'];
+    driftFromRuntime: boolean;
+    driftWarning: string | null;
+  };
   stage: LifecycleWatchStage;
   scope: LifecycleWatchScope;
   intervalMs: number;
@@ -73,6 +82,7 @@ type LifecycleWatchDependencies = {
   emitAuditSummaryNotificationFromEvidence: typeof emitAuditSummaryNotificationFromEvidence;
   emitGateBlockedNotification: typeof emitGateBlockedNotification;
   runPolicyReconcile: typeof runPolicyReconcile;
+  resolvePumukiVersionMetadata: (params?: { repoRoot?: string }) => PumukiVersionMetadata;
   nowMs: () => number;
   sleep: (ms: number) => Promise<void>;
 };
@@ -96,6 +106,7 @@ const defaultDependencies: LifecycleWatchDependencies = {
   emitAuditSummaryNotificationFromEvidence,
   emitGateBlockedNotification,
   runPolicyReconcile,
+  resolvePumukiVersionMetadata,
   nowMs: () => Date.now(),
   sleep: async (ms) => {
     await sleepTimer(ms);
@@ -231,6 +242,12 @@ export const runLifecycleWatch = async (
     ...dependencies,
   };
   const repoRoot = params?.repoRoot ?? activeDependencies.resolveRepoRoot();
+  const versionMetadata = activeDependencies.resolvePumukiVersionMetadata({ repoRoot });
+  const driftFromRuntime = versionMetadata.resolvedVersion !== versionMetadata.runtimeVersion;
+  const driftWarning = driftFromRuntime
+    ? `Version drift detectado: effective=${versionMetadata.resolvedVersion} runtime=${versionMetadata.runtimeVersion}. ` +
+      'Actualiza el consumer para alinear el binario local con @latest y evitar diagnósticos inconsistentes.'
+    : null;
   const stage = params?.stage ?? 'PRE_COMMIT';
   const scope = params?.scope ?? 'workingTree';
   const intervalMs = Math.max(250, Math.trunc(params?.intervalMs ?? 3000));
@@ -450,6 +467,14 @@ export const runLifecycleWatch = async (
       return {
         command: 'pumuki watch',
         repoRoot,
+        version: {
+          effective: versionMetadata.resolvedVersion,
+          runtime: versionMetadata.runtimeVersion,
+          consumerInstalled: versionMetadata.consumerInstalledVersion,
+          source: versionMetadata.source,
+          driftFromRuntime,
+          driftWarning,
+        },
         stage,
         scope,
         intervalMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.45",
+  "version": "6.3.46",
   "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": {
@@ -49,7 +49,7 @@
     "test:heuristics": "npx --yes tsx@4.21.0 --test core/facts/__tests__/extractHeuristicFacts.test.ts",
     "test:evidence": "npx --yes tsx@4.21.0 --test integrations/evidence/__tests__/buildEvidence.test.ts integrations/evidence/__tests__/humanIntent.test.ts",
     "test:mcp": "npx --yes tsx@4.21.0 --test integrations/mcp/__tests__/*.test.ts",
-    "test:backlog-tooling": "npx --yes tsx@4.21.0 --test scripts/__tests__/backlog-action-reasons-lib.test.ts scripts/__tests__/backlog-json-contract-lib.test.ts scripts/__tests__/backlog-cli-help-exit-code.test.ts scripts/__tests__/backlog-id-issue-map-lib.test.ts scripts/__tests__/reconcile-consumer-backlog-issues.test.ts scripts/__tests__/watch-consumer-backlog.test.ts",
+    "test:backlog-tooling": "npx --yes tsx@4.21.0 --test scripts/__tests__/backlog-action-reasons-lib.test.ts scripts/__tests__/backlog-json-contract-lib.test.ts scripts/__tests__/backlog-cli-help-exit-code.test.ts scripts/__tests__/backlog-id-issue-map-lib.test.ts scripts/__tests__/reconcile-consumer-backlog-issues.test.ts scripts/__tests__/watch-consumer-backlog.test.ts scripts/__tests__/watch-consumer-backlog-fleet.test.ts scripts/__tests__/watch-consumer-backlog-fleet-tick.test.ts",
     "test:saas-ingestion": "npx --yes tsx@4.21.0 --test integrations/lifecycle/__tests__/saasIngestionContract.test.ts integrations/lifecycle/__tests__/saasIngestionBuilder.test.ts integrations/lifecycle/__tests__/saasIngestionTransport.test.ts integrations/lifecycle/__tests__/saasIngestionIdempotency.test.ts integrations/lifecycle/__tests__/saasIngestionAuth.test.ts integrations/lifecycle/__tests__/saasIngestionAudit.test.ts integrations/lifecycle/__tests__/saasIngestionMetrics.test.ts integrations/lifecycle/__tests__/saasIngestionGovernance.test.ts integrations/lifecycle/__tests__/saasFederation.test.ts integrations/lifecycle/__tests__/saasEnterpriseAnalytics.test.ts integrations/lifecycle/__tests__/cli.test.ts",
     "test:operational-memory": "npx --yes tsx@4.21.0 --test integrations/lifecycle/__tests__/operationalMemoryContract.test.ts integrations/lifecycle/__tests__/operationalMemorySignals.test.ts integrations/lifecycle/__tests__/operationalMemorySnapshot.test.ts integrations/git/__tests__/runPlatformGate.test.ts integrations/git/__tests__/runPlatformGateEvidence.test.ts integrations/evidence/__tests__/buildEvidence.test.ts integrations/evidence/writeEvidence.test.ts integrations/evidence/generateEvidence.test.ts",
     "test:stage-gates": "npx --yes tsx@4.21.0 --test integrations/config/__tests__/*.test.ts integrations/gate/__tests__/*.test.ts integrations/git/__tests__/*.test.ts integrations/lifecycle/__tests__/*.test.ts integrations/sdd/__tests__/*.test.ts scripts/__tests__/*.test.ts",
@@ -101,6 +101,9 @@
     "validation:tracking-single-active": "bash scripts/check-tracking-single-active.sh",
     "validation:backlog-reconcile": "node --import tsx scripts/reconcile-consumer-backlog-issues.ts",
     "validation:backlog-watch": "node --import tsx scripts/watch-consumer-backlog.ts",
+    "validation:backlog-watch:fleet": "node --import tsx scripts/watch-consumer-backlog-fleet.ts",
+    "validation:backlog-watch:tick": "node --import tsx scripts/watch-consumer-backlog-fleet-tick.ts --json --no-fail",
+    "validation:backlog-watch:gate": "node --import tsx scripts/watch-consumer-backlog-fleet-tick.ts --json",
     "validation:phase5-escalation:ready-to-submit": "bash scripts/check-phase5-escalation-ready-to-submit.sh",
     "validation:phase5-escalation:prepare": "bash scripts/prepare-phase5-escalation-submission.sh",
     "validation:phase5-escalation:close-submission": "bash scripts/close-phase5-escalation-submission.sh",

package/scripts/backlog-id-issue-map-lib.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
-export const BACKLOG_ID_PATTERN = /^(PUMUKI-(?:M)?\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)$/;
+export const BACKLOG_ID_PATTERN = /^(PUMUKI-(?:M)?\d+|PUM-\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)$/;
 
 export type BacklogIdIssueMapRecord = Readonly<Record<string, number>>;
 

package/scripts/reconcile-consumer-backlog-issues-lib.ts

@@ -75,10 +75,10 @@ export type BacklogReconcileResult = {
 
 const STATUS_EMOJI_PATTERN = /(✅|🚧|⏳|⛔)/;
 const ISSUE_REF_PATTERN = /#(\d+)/;
-const BACKLOG_ID_PATTERN = /^(PUMUKI-(?:M)?\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)$/;
+const BACKLOG_ID_PATTERN = /^(PUMUKI-(?:M)?\d+|PUM-\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)$/;
 const PENDING_REFERENCE_PATTERN = /\|\s*Pendiente(?:\s*\(rel\.\s*#\d+\))?\s*\|/;
 const BACKLOG_SECTION_HEADING_PATTERN =
-  /^(\s*###\s*)(✅|🚧|⏳|⛔)(\s+)(PUMUKI-(?:M)?\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)\b/;
+  /^(\s*###\s*)(✅|🚧|⏳|⛔)(\s+)(PUMUKI-(?:M)?\d+|PUM-\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)\b/;
 
 export type BacklogIssueNumberResolver = (
   backlogId: string,

package/scripts/watch-consumer-backlog-fleet-tick.ts

@@ -0,0 +1,225 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import {
+  buildWatchActionRequiredReasons,
+  formatActionReasonsForHuman,
+} from './backlog-action-reasons-lib';
+import {
+  BACKLOG_JSON_COMPAT_CONTRACT_ID,
+  BACKLOG_JSON_COMPAT_MIN_READER_VERSION,
+  BACKLOG_JSON_SCHEMA_VERSION,
+} from './backlog-json-contract-lib';
+import { runBacklogWatch } from './watch-consumer-backlog-lib';
+
+type FleetTarget = {
+  key: 'saas' | 'ruralgo' | 'flux';
+  filePath: string;
+  repo?: string;
+};
+
+type ParsedArgs = {
+  json: boolean;
+  failOnFindings: boolean;
+  targets: ReadonlyArray<FleetTarget>;
+};
+
+const JSON_TOOL_NAME = 'backlog-watch-fleet-tick';
+const DEFAULT_REPO = 'SwiftEnProfundidad/ast-intelligence-hooks';
+const DEFAULT_TARGETS = {
+  saas: resolve(
+    homedir(),
+    'Developer/Projects/SAAS:APP_SUPERMERCADOS/docs/pumuki/PUMUKI_BUGS_MEJORAS.md'
+  ),
+  ruralgo: resolve(
+    homedir(),
+    'Developer/Projects/R_GO/docs/technical/08-validation/refactor/pumuki-integration-feedback.md'
+  ),
+  flux: resolve(homedir(), 'Developer/Projects/Flux_training/docs/BUGS_Y_MEJORAS_PUMUKI.md'),
+} as const;
+
+const HELP_TEXT = `Usage:
+  npx --yes tsx@4.21.0 scripts/watch-consumer-backlog-fleet-tick.ts [--json] [--no-fail]
+    [--saas=<path>] [--ruralgo=<path>] [--flux=<path>] [--repo=<owner/name>]
+
+Defaults:
+  --saas=${DEFAULT_TARGETS.saas}
+  --ruralgo=${DEFAULT_TARGETS.ruralgo}
+  --flux=${DEFAULT_TARGETS.flux}
+  --repo=${DEFAULT_REPO}
+
+Options:
+  --json        Imprime salida consolidada JSON.
+  --no-fail     No devuelve exit code 1 aunque existan findings accionables.
+  --saas=PATH   Override ruta backlog SAAS.
+  --ruralgo=PATH Override ruta backlog RuralGo.
+  --flux=PATH   Override ruta backlog Flux.
+  --repo=NAME   Override repo para targets que consultan upstream.
+`;
+
+class HelpRequestedError extends Error {
+  constructor() {
+    super(HELP_TEXT);
+    this.name = 'HelpRequestedError';
+  }
+}
+
+const parseArgs = (argv: ReadonlyArray<string>): ParsedArgs => {
+  let json = false;
+  let failOnFindings = true;
+  let saasPath = DEFAULT_TARGETS.saas;
+  let ruralgoPath = DEFAULT_TARGETS.ruralgo;
+  let fluxPath = DEFAULT_TARGETS.flux;
+  let repo = DEFAULT_REPO;
+
+  for (const arg of argv) {
+    if (arg === '--help' || arg === '-h') {
+      throw new HelpRequestedError();
+    }
+    if (arg === '--json') {
+      json = true;
+      continue;
+    }
+    if (arg === '--no-fail') {
+      failOnFindings = false;
+      continue;
+    }
+    if (arg.startsWith('--saas=')) {
+      saasPath = resolve(arg.slice('--saas='.length).trim());
+      continue;
+    }
+    if (arg.startsWith('--ruralgo=')) {
+      ruralgoPath = resolve(arg.slice('--ruralgo='.length).trim());
+      continue;
+    }
+    if (arg.startsWith('--flux=')) {
+      fluxPath = resolve(arg.slice('--flux='.length).trim());
+      continue;
+    }
+    if (arg.startsWith('--repo=')) {
+      const value = arg.slice('--repo='.length).trim();
+      repo = value.length > 0 ? value : DEFAULT_REPO;
+      continue;
+    }
+    throw new Error(`Unknown argument "${arg}"\n\n${HELP_TEXT}`);
+  }
+
+  const targets: FleetTarget[] = [
+    { key: 'saas', filePath: saasPath, repo },
+    { key: 'ruralgo', filePath: ruralgoPath, repo },
+    { key: 'flux', filePath: fluxPath },
+  ];
+
+  for (const target of targets) {
+    if (!existsSync(target.filePath)) {
+      throw new Error(
+        `Target backlog not found for ${target.key}: ${target.filePath}\n` +
+          `Use --${target.key}=<path> to override.\n\n${HELP_TEXT}`
+      );
+    }
+  }
+
+  return {
+    json,
+    failOnFindings,
+    targets,
+  };
+};
+
+const formatHumanOutput = (
+  targets: ReadonlyArray<
+    Awaited<ReturnType<typeof runBacklogWatch>> & {
+      key: FleetTarget['key'];
+      actionRequiredReasons: ReadonlyArray<string>;
+    }
+  >
+): string => {
+  const lines: string[] = [];
+  const actionRequiredTargets = targets.filter((item) => item.hasActionRequired).length;
+  const entriesTotal = targets.reduce((acc, item) => acc + item.entriesScanned, 0);
+  const nonClosedTotal = targets.reduce((acc, item) => acc + item.nonClosedEntries, 0);
+  lines.push(
+    `[pumuki][backlog-watch-fleet-tick] targets=${targets.length} entries_total=${entriesTotal} non_closed_total=${nonClosedTotal} action_required_targets=${actionRequiredTargets}`
+  );
+  for (const target of targets) {
+    lines.push(
+      `[pumuki][backlog-watch-fleet-tick] key=${target.key} target=${target.filePath} entries=${target.entriesScanned} non_closed=${target.nonClosedEntries} action_required=${target.hasActionRequired ? 'yes' : 'no'} reasons=${formatActionReasonsForHuman(target.actionRequiredReasons)}`
+    );
+  }
+  return `${lines.join('\n')}\n`;
+};
+
+const main = async (): Promise<void> => {
+  const parsed = parseArgs(process.argv.slice(2));
+  const results = await Promise.all(
+    parsed.targets.map(async (target) => {
+      const watchResult = await runBacklogWatch({
+        filePath: target.filePath,
+        repo: target.repo,
+      });
+      const actionRequiredReasons = buildWatchActionRequiredReasons({
+        needsIssueCount: watchResult.classification.needsIssue.length,
+        driftClosedIssueCount: watchResult.classification.driftClosedIssue.length,
+        headingDriftCount: watchResult.headingDrift.length,
+      });
+      return {
+        ...watchResult,
+        key: target.key,
+        actionRequiredReasons,
+      };
+    })
+  );
+
+  const hasActionRequired = results.some((item) => item.hasActionRequired);
+  const actionRequiredTargets = results.filter((item) => item.hasActionRequired).length;
+  const entriesScannedTotal = results.reduce((acc, item) => acc + item.entriesScanned, 0);
+  const nonClosedTotal = results.reduce((acc, item) => acc + item.nonClosedEntries, 0);
+
+  if (parsed.json) {
+    writeFileSync(
+      process.stdout.fd,
+      `${JSON.stringify(
+        {
+          tool: JSON_TOOL_NAME,
+          schema_version: BACKLOG_JSON_SCHEMA_VERSION,
+          generated_at: new Date().toISOString(),
+          run_id: randomUUID(),
+          compat: {
+            contract_id: BACKLOG_JSON_COMPAT_CONTRACT_ID,
+            min_reader_version: BACKLOG_JSON_COMPAT_MIN_READER_VERSION,
+            is_backward_compatible: true,
+            breaking_changes: [],
+          },
+          summary: {
+            targets: parsed.targets.length,
+            entries_scanned_total: entriesScannedTotal,
+            non_closed_total: nonClosedTotal,
+            action_required_targets: actionRequiredTargets,
+            has_action_required: hasActionRequired,
+          },
+          results,
+        },
+        null,
+        2
+      )}\n`
+    );
+  } else {
+    writeFileSync(process.stdout.fd, formatHumanOutput(results));
+  }
+
+  if (parsed.failOnFindings && hasActionRequired) {
+    process.exitCode = 1;
+  }
+};
+
+main().catch((error: unknown) => {
+  if (error instanceof HelpRequestedError) {
+    writeFileSync(process.stdout.fd, `${HELP_TEXT}\n`);
+    process.exitCode = 0;
+    return;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  writeFileSync(process.stderr.fd, `${message}\n`);
+  process.exitCode = 1;
+});

package/scripts/watch-consumer-backlog-fleet.ts

@@ -0,0 +1,200 @@
+import { randomUUID } from 'node:crypto';
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import {
+  buildWatchActionRequiredReasons,
+  formatActionReasonsForHuman,
+} from './backlog-action-reasons-lib';
+import {
+  BACKLOG_JSON_COMPAT_CONTRACT_ID,
+  BACKLOG_JSON_COMPAT_MIN_READER_VERSION,
+  BACKLOG_JSON_SCHEMA_VERSION,
+} from './backlog-json-contract-lib';
+import { runBacklogWatch } from './watch-consumer-backlog-lib';
+
+type FleetTarget = {
+  filePath: string;
+  repo?: string;
+};
+
+type ParsedArgs = {
+  targets: ReadonlyArray<FleetTarget>;
+  json: boolean;
+  failOnFindings: boolean;
+};
+
+const JSON_TOOL_NAME = 'backlog-watch-fleet';
+
+const HELP_TEXT = `Usage:
+  npx --yes tsx@4.21.0 scripts/watch-consumer-backlog-fleet.ts --target=<markdown-path>[::owner/name] [--target=<markdown-path>[::owner/name] ...] [--json] [--no-fail]
+
+Options:
+  --target=<path>[::repo]  Backlog markdown consumidor a vigilar. Puedes repetir el flag.
+                           Ejemplo: --target=/repo/docs/backlog.md::owner/name
+  --json                   Imprime resultado consolidado en JSON.
+  --no-fail                No devuelve exit code 1 aunque existan findings accionables.
+`;
+
+class HelpRequestedError extends Error {
+  constructor() {
+    super(HELP_TEXT);
+    this.name = 'HelpRequestedError';
+  }
+}
+
+const parseTarget = (rawTarget: string): FleetTarget => {
+  const trimmed = rawTarget.trim();
+  const separatorIndex = trimmed.indexOf('::');
+  if (separatorIndex === -1) {
+    return {
+      filePath: resolve(trimmed),
+    };
+  }
+  const filePath = trimmed.slice(0, separatorIndex).trim();
+  const repo = trimmed.slice(separatorIndex + 2).trim();
+  return {
+    filePath: resolve(filePath),
+    repo: repo.length > 0 ? repo : undefined,
+  };
+};
+
+const parseArgs = (argv: ReadonlyArray<string>): ParsedArgs => {
+  const targets: FleetTarget[] = [];
+  let json = false;
+  let failOnFindings = true;
+
+  for (const arg of argv) {
+    if (arg === '--help' || arg === '-h') {
+      throw new HelpRequestedError();
+    }
+    if (arg === '--json') {
+      json = true;
+      continue;
+    }
+    if (arg === '--no-fail') {
+      failOnFindings = false;
+      continue;
+    }
+    if (arg.startsWith('--target=')) {
+      const rawTarget = arg.slice('--target='.length);
+      if (rawTarget.trim().length === 0) {
+        throw new Error(`Invalid --target (empty value)\n\n${HELP_TEXT}`);
+      }
+      targets.push(parseTarget(rawTarget));
+      continue;
+    }
+    throw new Error(`Unknown argument "${arg}"\n\n${HELP_TEXT}`);
+  }
+
+  if (targets.length === 0) {
+    throw new Error(`Missing --target\n\n${HELP_TEXT}`);
+  }
+
+  return {
+    targets,
+    json,
+    failOnFindings,
+  };
+};
+
+const formatHumanOutput = (
+  targets: ReadonlyArray<
+    Awaited<ReturnType<typeof runBacklogWatch>> & {
+      actionRequiredReasons: ReadonlyArray<string>;
+    }
+  >
+): string => {
+  const lines: string[] = [];
+  const actionRequiredTargets = targets.filter((item) => item.hasActionRequired).length;
+  const entriesTotal = targets.reduce((acc, item) => acc + item.entriesScanned, 0);
+  const nonClosedTotal = targets.reduce((acc, item) => acc + item.nonClosedEntries, 0);
+
+  lines.push(
+    `[pumuki][backlog-watch-fleet] targets=${targets.length} entries_total=${entriesTotal} non_closed_total=${nonClosedTotal} action_required_targets=${actionRequiredTargets}`
+  );
+  for (const target of targets) {
+    lines.push(
+      `[pumuki][backlog-watch-fleet] target=${target.filePath} repo=${target.repo ?? '-'} entries=${target.entriesScanned} non_closed=${target.nonClosedEntries} action_required=${target.hasActionRequired ? 'yes' : 'no'} reasons=${formatActionReasonsForHuman(target.actionRequiredReasons)}`
+    );
+  }
+  return `${lines.join('\n')}\n`;
+};
+
+const main = async (): Promise<void> => {
+  const parsed = parseArgs(process.argv.slice(2));
+  const results = await Promise.all(
+    parsed.targets.map(async (target) => {
+      const watchResult = await runBacklogWatch({
+        filePath: target.filePath,
+        repo: target.repo,
+      });
+      const actionRequiredReasons = buildWatchActionRequiredReasons({
+        needsIssueCount: watchResult.classification.needsIssue.length,
+        driftClosedIssueCount: watchResult.classification.driftClosedIssue.length,
+        headingDriftCount: watchResult.headingDrift.length,
+      });
+      return {
+        ...watchResult,
+        actionRequiredReasons,
+      };
+    })
+  );
+
+  const hasActionRequired = results.some((item) => item.hasActionRequired);
+  const actionRequiredTargets = results.filter((item) => item.hasActionRequired).length;
+  const entriesScannedTotal = results.reduce((acc, item) => acc + item.entriesScanned, 0);
+  const nonClosedTotal = results.reduce((acc, item) => acc + item.nonClosedEntries, 0);
+
+  if (parsed.json) {
+    const generatedAt = new Date().toISOString();
+    const runId = randomUUID();
+    writeFileSync(
+      process.stdout.fd,
+      `${JSON.stringify(
+        {
+          tool: JSON_TOOL_NAME,
+          schema_version: BACKLOG_JSON_SCHEMA_VERSION,
+          generated_at: generatedAt,
+          run_id: runId,
+          invocation: {
+            mode: 'json',
+            targets_count: parsed.targets.length,
+          },
+          compat: {
+            contract_id: BACKLOG_JSON_COMPAT_CONTRACT_ID,
+            min_reader_version: BACKLOG_JSON_COMPAT_MIN_READER_VERSION,
+            is_backward_compatible: true,
+            breaking_changes: [],
+          },
+          summary: {
+            targets: parsed.targets.length,
+            entries_scanned_total: entriesScannedTotal,
+            non_closed_total: nonClosedTotal,
+            action_required_targets: actionRequiredTargets,
+            has_action_required: hasActionRequired,
+          },
+          results,
+        },
+        null,
+        2
+      )}\n`
+    );
+  } else {
+    writeFileSync(process.stdout.fd, formatHumanOutput(results));
+  }
+
+  if (parsed.failOnFindings && hasActionRequired) {
+    process.exitCode = 1;
+  }
+};
+
+main().catch((error: unknown) => {
+  if (error instanceof HelpRequestedError) {
+    writeFileSync(process.stdout.fd, `${HELP_TEXT}\n`);
+    process.exitCode = 0;
+    return;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  writeFileSync(process.stderr.fd, `${message}\n`);
+  process.exitCode = 1;
+});

package/scripts/watch-consumer-backlog-lib.ts

@@ -53,10 +53,10 @@ export type BacklogIssueNumberResolver = (
 
 const STATUS_EMOJI_PATTERN = /(✅|🚧|⏳|⛔)/;
 const ISSUE_REF_PATTERN = /#(\d+)/;
-const BACKLOG_ID_PATTERN = /^(PUMUKI-(?:M)?\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)$/;
+const BACKLOG_ID_PATTERN = /^(PUMUKI-(?:M)?\d+|PUM-\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)$/;
 const STATUS_TEXT_PATTERN = /^(OPEN|PENDING|REPORTED|IN_PROGRESS|BLOCKED|FIXED|CLOSED)\b/i;
 const BACKLOG_SECTION_HEADING_PATTERN =
-  /^(\s*###\s*)(✅|🚧|⏳|⛔)(\s+)(PUMUKI-(?:M)?\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)\b/;
+  /^(\s*###\s*)(✅|🚧|⏳|⛔)(\s+)(PUMUKI-(?:M)?\d+|PUM-\d+|PUMUKI-INC-\d+|FP-\d+|AST-GAP-\d+)\b/;
 const STATUS_TEXT_TO_EMOJI: Record<string, BacklogStatusEmoji> = {
   OPEN: '⏳',
   PENDING: '⏳',