pumuki 6.3.45 → 6.3.47

package/integrations/git/stageRunners.ts

@@ -18,10 +18,12 @@ import {
   emitAuditSummaryNotificationFromEvidence,
   emitGateBlockedNotification,
 } from '../notifications/emitAuditSummaryNotification';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 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.';
@@ -52,8 +54,18 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
   PRE_PUSH_UPSTREAM_MISSING: 'Ejecuta: git push --set-upstream origin <branch>',
   PRE_PUSH_UPSTREAM_MISALIGNED:
     'Alinea upstream con la rama actual: git branch --unset-upstream && git push --set-upstream origin <branch>',
+  MANIFEST_MUTATION_DETECTED:
+    'Los hooks/gates no deben modificar manifests. Revisa wiring y ejecuta upgrade explícito solo cuando aplique (por ejemplo: pumuki update --latest).',
 };
 
+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 +101,7 @@ type StageRunnerDependencies = {
   writeHookGateSummary: (message: string) => void;
   isQuietMode: () => boolean;
   ensureRuntimeArtifactsIgnored: (repoRoot: string) => void;
+  runPolicyReconcile: typeof runPolicyReconcile;
 };
 
 const defaultDependencies: StageRunnerDependencies = {
@@ -144,6 +157,7 @@ const defaultDependencies: StageRunnerDependencies = {
     } catch {
     }
   },
+  runPolicyReconcile,
 };
 
 const getDependencies = (
@@ -196,6 +210,169 @@ 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 MANIFEST_GUARD_FILES = ['package.json', 'package-lock.json'] as const;
+
+type ManifestGuardEntry = {
+  relativePath: (typeof MANIFEST_GUARD_FILES)[number];
+  absolutePath: string;
+  existed: boolean;
+  contents: string;
+};
+
+const captureManifestGuardSnapshot = (repoRoot: string): Array<ManifestGuardEntry> =>
+  MANIFEST_GUARD_FILES.map((relativePath) => {
+    const absolutePath = join(repoRoot, relativePath);
+    const existed = existsSync(absolutePath);
+    return {
+      relativePath,
+      absolutePath,
+      existed,
+      contents: existed ? readFileSync(absolutePath, 'utf8') : '',
+    };
+  });
+
+const restoreManifestGuardSnapshot = (
+  snapshot: ReadonlyArray<ManifestGuardEntry>
+): Array<string> => {
+  const mutated: Array<string> = [];
+  for (const entry of snapshot) {
+    const existsNow = existsSync(entry.absolutePath);
+    if (entry.existed) {
+      if (!existsNow) {
+        writeFileSync(entry.absolutePath, entry.contents, 'utf8');
+        mutated.push(entry.relativePath);
+        continue;
+      }
+      const current = readFileSync(entry.absolutePath, 'utf8');
+      if (current !== entry.contents) {
+        writeFileSync(entry.absolutePath, entry.contents, 'utf8');
+        mutated.push(entry.relativePath);
+      }
+      continue;
+    }
+    if (existsNow) {
+      unlinkSync(entry.absolutePath);
+      mutated.push(entry.relativePath);
+    }
+  }
+  return Array.from(new Set(mutated));
+};
+
+const enforceManifestGuard = (params: {
+  dependencies: StageRunnerDependencies;
+  repoRoot: string;
+  stage: HookStage;
+  snapshot: ReadonlyArray<ManifestGuardEntry>;
+}): boolean => {
+  const mutated = restoreManifestGuardSnapshot(params.snapshot);
+  if (mutated.length === 0) {
+    return false;
+  }
+  const summary = mutated.join(', ');
+  process.stderr.write(
+    `[pumuki][manifest-guard] unexpected manifest mutation detected and reverted: ${summary}\n`
+  );
+  params.dependencies.notifyGateBlocked({
+    repoRoot: params.repoRoot,
+    stage: params.stage,
+    totalViolations: mutated.length,
+    causeCode: 'MANIFEST_MUTATION_DETECTED',
+    causeMessage:
+      `Unexpected manifest mutation detected during ${params.stage}: ${summary}. ` +
+      'Hooks/gates must not mutate consumer manifests without explicit upgrade command.',
+    remediation: BLOCKED_REMEDIATION_BY_CODE.MANIFEST_MUTATION_DETECTED
+      ?? DEFAULT_BLOCKED_REMEDIATION,
+  });
+  notifyAuditSummaryForStage(params.dependencies, params.stage);
+  return true;
+};
+
+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 = (
@@ -357,6 +534,7 @@ export async function runPreCommitStage(
 ): Promise<number> {
   const activeDependencies = getDependencies(dependencies);
   const repoRoot = activeDependencies.resolveRepoRoot();
+  const manifestSnapshot = captureManifestGuardSnapshot(repoRoot);
   activeDependencies.ensureRuntimeArtifactsIgnored(repoRoot);
   if (
     enforceGitAtomicityGate({
@@ -367,21 +545,31 @@ 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',
     },
   });
+  if (
+    enforceManifestGuard({
+      dependencies: activeDependencies,
+      repoRoot,
+      stage: 'PRE_COMMIT',
+      snapshot: manifestSnapshot,
+    })
+  ) {
+    return 1;
+  }
   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 +579,7 @@ export async function runPreCommitStage(
     });
   }
   notifyAuditSummaryForStage(activeDependencies, 'PRE_COMMIT');
-  return exitCode;
+  return result.exitCode;
 }
 
 export async function runPrePushStage(
@@ -399,6 +587,7 @@ export async function runPrePushStage(
 ): Promise<number> {
   const activeDependencies = getDependencies(dependencies);
   const repoRoot = activeDependencies.resolveRepoRoot();
+  const manifestSnapshot = captureManifestGuardSnapshot(repoRoot);
   activeDependencies.ensureRuntimeArtifactsIgnored(repoRoot);
   const upstreamRef = activeDependencies.resolveUpstreamRef();
   if (!upstreamRef) {
@@ -427,43 +616,63 @@ 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,
           toRef: 'HEAD',
         },
       });
+      if (
+        enforceManifestGuard({
+          dependencies: activeDependencies,
+          repoRoot,
+          stage: 'PRE_PUSH',
+          snapshot: manifestSnapshot,
+        })
+      ) {
+        return 1;
+      }
       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',
         },
       });
+      if (
+        enforceManifestGuard({
+          dependencies: activeDependencies,
+          repoRoot,
+          stage: 'PRE_PUSH',
+          snapshot: manifestSnapshot,
+        })
+      ) {
+        return 1;
+      }
       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,23 +715,33 @@ 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,
       toRef: 'HEAD',
     },
   });
+  if (
+    enforceManifestGuard({
+      dependencies: activeDependencies,
+      repoRoot,
+      stage: 'PRE_PUSH',
+      snapshot: manifestSnapshot,
+    })
+  ) {
+    return 1;
+  }
   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 +751,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.47",
   "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,