pumuki 6.3.149 → 6.3.151

package/docs/operations/RELEASE_NOTES.md

@@ -4,6 +4,12 @@ This file tracks the active deterministic framework line used in this repository
 Canonical release chronology lives in `CHANGELOG.md`.
 This file keeps only the operational highlights and rollout notes that matter while running the framework.
 
+### 2026-05-05 (v6.3.150)
+
+- **RuralGo PUMUKI-INC-061:** las notificaciones de bloqueo ya recomiendan `policy reconcile --strict --apply --json` cuando la remediación real requiere converger policy-as-code.
+- **UX sin loop falso:** `EVIDENCE_GATE_BLOCKED` y gaps de skills/policy dejan de mostrar un comando dry-run que no puede desbloquear el repo por sí solo.
+- **Rollout:** publicar `pumuki@6.3.150`, repinear primero RuralGo y revalidar un bloqueo de governance verificando el comando visible.
+
 ### 2026-05-05 (v6.3.145)
 
 - **RuralGo PUMUKI-INC-124:** `skills.ios.critical-test-quality` deja de bloquear tests XCTest de UI automation/performance cuando usan `XCUIApplication`, `XCTMetric` o `measure`.

package/integrations/git/runPlatformGate.ts

@@ -447,6 +447,88 @@ const collectStagedPaths = (git: IGitService, repoRoot: string): ReadonlyArray<s
   }
 };
 
+const toBlockingFindingsForPaths = (
+  findings: ReadonlyArray<Finding>,
+  paths: ReadonlySet<string>
+): ReadonlyArray<Finding> => {
+  return findings.filter((finding) => {
+    if (finding.severity !== 'ERROR' && finding.severity !== 'CRITICAL') {
+      return false;
+    }
+    const path = finding.filePath ? toNormalizedPath(finding.filePath) : '';
+    return path.length > 0 && paths.has(path);
+  });
+};
+
+const buildHeadFactsForPaths = (params: {
+  git: IGitService;
+  repoRoot: string;
+  paths: ReadonlyArray<string>;
+}): ReadonlyArray<Fact> => {
+  const facts: Fact[] = [];
+  for (const path of params.paths) {
+    try {
+      const content = params.git.runGit(['show', `HEAD:${path}`], params.repoRoot);
+      facts.push({
+        kind: 'FileChange',
+        path,
+        changeType: 'modified',
+        source: 'git:staged:HEAD',
+      });
+      facts.push({
+        kind: 'FileContent',
+        path,
+        content,
+        source: 'git:staged:HEAD',
+      });
+    } catch {
+      continue;
+    }
+  }
+  return facts;
+};
+
+const toRemediationProgressAllowedFinding = (params: {
+  stage: Exclude<GateStage, 'STAGED'>;
+  currentBlockingCount: number;
+  previousBlockingCount: number;
+  paths: ReadonlyArray<string>;
+  ruleIds: ReadonlyArray<string>;
+}): Finding => {
+  const samplePaths = params.paths.slice(0, MAX_SCOPE_SAMPLE_PATHS).join(LIST_SEPARATOR);
+  const sampleRuleIds = params.ruleIds.slice(0, MAX_SCOPE_SAMPLE_PATHS).join(LIST_SEPARATOR);
+  return {
+    ruleId: 'governance.remediation.progress.allowed',
+    severity: 'INFO',
+    code: 'REMEDIATION_PROGRESS_ALLOWED',
+    message:
+      `Remediation progress allowed at ${params.stage}: ` +
+      `previous_blocking_findings=${params.previousBlockingCount} ` +
+      `current_blocking_findings=${params.currentBlockingCount} ` +
+      `paths=[${samplePaths}] remediated_rule_ids=[${sampleRuleIds}]. ` +
+      'Feature work remains blocked until global skills enforcement is complete.',
+    filePath: '.ai_evidence.json',
+    matchedBy: 'RemediationProgressGuard',
+    source: 'remediation-progress',
+    blocking: false,
+  };
+};
+
+const toRemediationProgressAdvisoryFinding = (finding: Finding): Finding => ({
+  ...finding,
+  severity: 'INFO',
+  code:
+    finding.code === 'SKILLS_GLOBAL_ENFORCEMENT_INCOMPLETE_CRITICAL'
+      ? 'SKILLS_GLOBAL_ENFORCEMENT_INCOMPLETE_REMEDIATION_ADVISORY'
+      : finding.code === 'TDD_BDD_EVIDENCE_STALE'
+        ? 'TDD_BDD_EVIDENCE_STALE_REMEDIATION_ADVISORY'
+        : finding.code,
+  message:
+    `${finding.message} Remediation progress mode converted this blocker to advisory ` +
+    'because the staged diff reduces existing supported-detector findings and introduces none.',
+  blocking: false,
+});
+
 const shouldAugmentStagedSkillsContractFactsWithRepoFacts = (params: {
   scope: GateScope;
   facts: ReadonlyArray<Fact>;
@@ -1305,16 +1387,91 @@ export async function runPlatformGate(params: {
   const hasNativeBlockingFinding = findings.some(
     (finding) => finding.severity === 'ERROR' || finding.severity === 'CRITICAL'
   );
+  const stagedCodePaths = stagedPaths.filter((path) => isObservedCodePath(path));
+  const stagedCodePathSet = new Set(stagedCodePaths);
+  const currentBlockingFindingsForStagedPaths = toBlockingFindingsForPaths(
+    findings,
+    stagedCodePathSet
+  );
+  const previousFactsForStagedPaths =
+    isStrictEnforcementStage(params.policy.stage) &&
+    params.scope.kind === 'staged' &&
+    stagedCodePaths.length > 0 &&
+    currentBlockingFindingsForStagedPaths.length === 0
+      ? buildHeadFactsForPaths({
+          git,
+          repoRoot,
+          paths: stagedCodePaths,
+        })
+      : [];
+  const previousEvaluationForStagedPaths =
+    previousFactsForStagedPaths.length > 0
+      ? dependencies.evaluatePlatformGateFindings({
+          facts: previousFactsForStagedPaths,
+          stage: params.policy.stage,
+          repoRoot,
+        })
+      : undefined;
+  const previousBlockingFindingsForStagedPaths = previousEvaluationForStagedPaths
+    ? toBlockingFindingsForPaths(
+        previousEvaluationForStagedPaths.findings,
+        stagedCodePathSet
+      )
+    : [];
+  const remediationProgressFinding =
+    previousBlockingFindingsForStagedPaths.length > currentBlockingFindingsForStagedPaths.length &&
+    currentBlockingFindingsForStagedPaths.length === 0
+      ? toRemediationProgressAllowedFinding({
+          stage: params.policy.stage as Exclude<GateStage, 'STAGED'>,
+          currentBlockingCount: currentBlockingFindingsForStagedPaths.length,
+          previousBlockingCount: previousBlockingFindingsForStagedPaths.length,
+          paths: stagedCodePaths,
+          ruleIds: [
+            ...new Set(
+              previousBlockingFindingsForStagedPaths.map((finding) => finding.ruleId)
+            ),
+          ].sort(),
+        })
+      : undefined;
+  const remediationProgressAllowsGlobalGap = remediationProgressFinding !== undefined;
+  const effectiveTddBddFindings = remediationProgressAllowsGlobalGap
+    ? tddBddEvaluation.findings.map((finding) =>
+        finding.code === 'TDD_BDD_EVIDENCE_STALE'
+          ? toRemediationProgressAdvisoryFinding(finding)
+          : finding
+      )
+    : tddBddEvaluation.findings;
+  const effectiveTddBddSnapshot =
+    remediationProgressAllowsGlobalGap &&
+    tddBddSnapshot?.status === 'blocked' &&
+    tddBddEvaluation.findings.length > 0 &&
+    tddBddEvaluation.findings.every((finding) => finding.code === 'TDD_BDD_EVIDENCE_STALE')
+      ? {
+          ...tddBddSnapshot,
+          status: 'advisory' as const,
+          evidence: {
+            ...tddBddSnapshot.evidence,
+            errors: ['TDD_BDD_EVIDENCE_STALE_REMEDIATION_ADVISORY'],
+          },
+        }
+      : tddBddSnapshot;
+  const effectiveHasTddBddBlockingFinding = effectiveTddBddFindings.some(
+    (finding) => finding.severity === 'ERROR' || finding.severity === 'CRITICAL'
+  );
   const effectivePlatformSkillsCoverageFinding = effectivePlatformSkillsCoverageInput;
   const effectiveCrossPlatformCriticalFinding = effectiveCrossPlatformCriticalInput;
   const effectiveSkillsScopeComplianceFinding = effectiveSkillsScopeComplianceInput;
+  const effectiveUnsupportedDetectorSkillsFindingForOutcome =
+    remediationProgressAllowsGlobalGap && effectiveUnsupportedDetectorSkillsFinding
+      ? toRemediationProgressAdvisoryFinding(effectiveUnsupportedDetectorSkillsFinding)
+      : effectiveUnsupportedDetectorSkillsFinding;
   const effectiveFindings = sddBlockingFinding
     ? [
       sddBlockingFinding,
       ...(degradedModeFinding ? [degradedModeFinding] : []),
       ...(policyAsCodeBlockingFinding ? [policyAsCodeBlockingFinding] : []),
       ...(effectiveUnsupportedSkillsMappingFinding ? [effectiveUnsupportedSkillsMappingFinding] : []),
-      ...(effectiveUnsupportedDetectorSkillsFinding ? [effectiveUnsupportedDetectorSkillsFinding] : []),
+      ...(effectiveUnsupportedDetectorSkillsFindingForOutcome ? [effectiveUnsupportedDetectorSkillsFindingForOutcome] : []),
       ...(effectivePlatformSkillsCoverageFinding ? [effectivePlatformSkillsCoverageFinding] : []),
       ...(effectiveCrossPlatformCriticalFinding ? [effectiveCrossPlatformCriticalFinding] : []),
       ...(effectiveSkillsScopeComplianceFinding ? [effectiveSkillsScopeComplianceFinding] : []),
@@ -1323,11 +1480,12 @@ export async function runPlatformGate(params: {
       ...(astIntelligenceDualFinding ? [astIntelligenceDualFinding] : []),
       ...(coverageBlockingFinding ? [coverageBlockingFinding] : []),
       ...brownfieldHotspotFindings,
-      ...tddBddEvaluation.findings,
+      ...effectiveTddBddFindings,
+      ...(remediationProgressFinding ? [remediationProgressFinding] : []),
       ...findings,
     ]
     : effectiveUnsupportedSkillsMappingFinding
-      || effectiveUnsupportedDetectorSkillsFinding
+      || effectiveUnsupportedDetectorSkillsFindingForOutcome
       || effectivePlatformSkillsCoverageFinding
       || effectiveCrossPlatformCriticalFinding
       || effectiveSkillsScopeComplianceFinding
@@ -1338,12 +1496,13 @@ export async function runPlatformGate(params: {
       || brownfieldHotspotFindings.length > 0
       || policyAsCodeBlockingFinding
       || degradedModeFinding
-      || tddBddEvaluation.findings.length > 0
+      || effectiveTddBddFindings.length > 0
+      || remediationProgressFinding
       ? [
         ...(degradedModeFinding ? [degradedModeFinding] : []),
         ...(policyAsCodeBlockingFinding ? [policyAsCodeBlockingFinding] : []),
         ...(effectiveUnsupportedSkillsMappingFinding ? [effectiveUnsupportedSkillsMappingFinding] : []),
-        ...(effectiveUnsupportedDetectorSkillsFinding ? [effectiveUnsupportedDetectorSkillsFinding] : []),
+        ...(effectiveUnsupportedDetectorSkillsFindingForOutcome ? [effectiveUnsupportedDetectorSkillsFindingForOutcome] : []),
         ...(effectivePlatformSkillsCoverageFinding ? [effectivePlatformSkillsCoverageFinding] : []),
         ...(effectiveCrossPlatformCriticalFinding ? [effectiveCrossPlatformCriticalFinding] : []),
         ...(effectiveSkillsScopeComplianceFinding ? [effectiveSkillsScopeComplianceFinding] : []),
@@ -1352,20 +1511,22 @@ export async function runPlatformGate(params: {
         ...(astIntelligenceDualFinding ? [astIntelligenceDualFinding] : []),
         ...(coverageBlockingFinding ? [coverageBlockingFinding] : []),
         ...brownfieldHotspotFindings,
-        ...tddBddEvaluation.findings,
+        ...effectiveTddBddFindings,
+        ...(remediationProgressFinding ? [remediationProgressFinding] : []),
         ...findings,
       ]
       : brownfieldHotspotFindings.length > 0
         ? [...brownfieldHotspotFindings, ...findings]
         : findings;
   const hasAstIntelligenceBlockingFinding = shouldBlockFromFinding(astIntelligenceDualFinding);
-  const decision = dependencies.evaluateGate([...effectiveFindings], params.policy);
+  const gateDecisionFindings = effectiveFindings.filter((finding) => finding.blocking !== false);
+  const decision = dependencies.evaluateGate([...gateDecisionFindings], params.policy);
   const baseGateOutcome =
     sddBlockingFinding ||
     degradedModeBlocks ||
     shouldBlockFromFinding(policyAsCodeBlockingFinding) ||
     shouldBlockFromFinding(effectiveUnsupportedSkillsMappingFinding) ||
-    shouldBlockFromFinding(effectiveUnsupportedDetectorSkillsFinding) ||
+    shouldBlockFromFinding(effectiveUnsupportedDetectorSkillsFindingForOutcome) ||
     shouldBlockFromFinding(effectivePlatformSkillsCoverageFinding) ||
     shouldBlockFromFinding(effectiveCrossPlatformCriticalFinding) ||
     shouldBlockFromFinding(effectiveSkillsScopeComplianceFinding) ||
@@ -1374,9 +1535,9 @@ export async function runPlatformGate(params: {
     hasAstIntelligenceBlockingFinding ||
     shouldBlockFromFinding(coverageBlockingFinding) ||
     brownfieldHotspotFindings.some((finding) => shouldBlockFromFinding(finding)) ||
-    hasTddBddBlockingFinding
+    effectiveHasTddBddBlockingFinding
       ? 'BLOCK'
-      : (decision.outcome === 'PASS' && tddBddSnapshot?.status === 'advisory'
+      : (decision.outcome === 'PASS' && effectiveTddBddSnapshot?.status === 'advisory'
           ? 'WARN'
           : decision.outcome);
   const gateWaiverStage =
@@ -1426,7 +1587,7 @@ export async function runPlatformGate(params: {
     try {
       memoryShadowRecommendation = dependencies.buildMemoryShadowRecommendation({
         findings: findingsWithWaiver,
-        ...(tddBddSnapshot ? { tddBddSnapshot } : {}),
+        ...(effectiveTddBddSnapshot ? { tddBddSnapshot: effectiveTddBddSnapshot } : {}),
       });
     } catch (error) {
       const rawReason = error instanceof Error ? error.message : String(error);
@@ -1477,7 +1638,7 @@ export async function runPlatformGate(params: {
     filesScanned,
     evaluationMetrics,
     rulesCoverage,
-    ...(tddBddSnapshot ? { tddBdd: tddBddSnapshot } : {}),
+    ...(effectiveTddBddSnapshot ? { tddBdd: effectiveTddBddSnapshot } : {}),
     ...(memoryShadow ? { memoryShadow } : {}),
     repoRoot,
     detectedPlatforms,

package/package.json

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

package/scripts/framework-menu-system-notifications-payloads-blocked.ts

@@ -64,7 +64,7 @@ export const resolveBlockedCommand = (params: {
     case 'EVIDENCE_CROSS_PLATFORM_CRITICAL_ENFORCEMENT_INCOMPLETE':
       return `${buildPinnedPumukiCommand({
         repoRoot: params.repoRoot,
-        executableAndArgs: 'pumuki policy reconcile --strict --json',
+        executableAndArgs: 'pumuki policy reconcile --strict --apply --json',
       })} && ${buildPinnedPumukiCommand({
         repoRoot: params.repoRoot,
         executableAndArgs: `pumuki sdd validate --stage=${params.event.stage} --json`,
@@ -79,7 +79,7 @@ export const resolveBlockedCommand = (params: {
     case 'EVIDENCE_GATE_BLOCKED':
       return `${buildPinnedPumukiCommand({
         repoRoot: params.repoRoot,
-        executableAndArgs: 'pumuki policy reconcile --strict --json',
+        executableAndArgs: 'pumuki policy reconcile --strict --apply --json',
       })} && ${buildPinnedPumukiCommand({
         repoRoot: params.repoRoot,
         executableAndArgs: `pumuki sdd validate --stage=${params.event.stage} --json`,

package/scripts/framework-menu-system-notifications-remediation.ts

@@ -41,7 +41,7 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
   TRACKING_CANONICAL_IN_PROGRESS_INVALID: TRACKING_BLOCKED_REMEDIATION,
   TRACKING_CANONICAL_SOURCE_CONFLICT: TRACKING_BLOCKED_REMEDIATION,
   ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES_HIGH:
-    'Ejecuta `pumuki policy reconcile --strict --json` y revalida antes de continuar.',
+    'Ejecuta `pumuki policy reconcile --strict --apply --json` y revalida antes de continuar.',
 };
 
 const BLOCKED_REMEDIATION_MAX_LENGTH_BY_VARIANT: Readonly<Record<BlockedRemediationVariant, number>> = {