pumuki 6.3.275 → 6.3.277

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [6.3.277] - 2026-05-18
+
+- `PUMUKI-INC-146`: PRE_WRITE now resolves the effective iOS test-quality scope from staged paths first when a staged slice exists, falling back to the worktree only when there is no staged code. This prevents unstaged Swift test files from forcing `skills.ios.critical-test-quality` onto unrelated staged iOS/SwiftUI production commits, while preserving the hard block for staged Swift test slices.
+
+## [6.3.276] - 2026-05-18
+
+- `PUMUKI-INC-146`: PRE_WRITE no longer requires `skills.ios.critical-test-quality` for iOS/SwiftUI production-only slices that do not touch test files. The rule remains hard-blocking when the PRE_WRITE scope includes Swift test paths (`/Tests/`, `/UITests/`, `*Test.swift`, `*Tests.swift`, `*.spec.swift`), preserving XCTest/Swift Testing quality enforcement without blocking unrelated visual/product commits.
+
 ## [6.3.275] - 2026-05-18
 
 - PRE_WRITE skills coverage: `PRE_WRITE` now loads the full runtime skills contract for the detected platform, so Web/Frontend slices evaluate `skills.frontend.*` before commit instead of failing with `EVIDENCE_PLATFORM_SKILLS_SCOPE_INCOMPLETE` while no frontend rule was active.

package/VERSION

@@ -1 +1 @@
-v6.3.272
+v6.3.277

package/docs/operations/RELEASE_NOTES.md

@@ -4,6 +4,14 @@ 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-18 (v6.3.277)
+
+- `PUMUKI-INC-146`: PRE_WRITE uses staged paths as the effective slice for `skills.ios.critical-test-quality` when staged files exist. Unstaged Swift tests no longer contaminate a staged production-only iOS commit, but staged Swift tests still require the critical test-quality rule and remain fail-closed.
+
+### 2026-05-18 (v6.3.276)
+
+- `PUMUKI-INC-146`: PRE_WRITE keeps `skills.ios.critical-test-quality` fail-closed for real Swift test slices, but stops applying that test-quality critical rule to iOS/SwiftUI production-only slices. RuralGo wordmark/splash-style commits should still be blocked by real iOS AST/skills violations, SDD, context or evidence issues, but not by missing XCTest quality coverage when no test file is in scope.
+
 ### 2026-05-18 (v6.3.275)
 
 - `PUMUKI-INC-143`: PRE_WRITE now loads the full runtime skills contract for detected platforms. Frontend slices now materialize `skills.frontend.*` in `active_rule_ids` and `evaluated_rule_ids` instead of failing on missing scope coverage before any frontend rule can run.

package/integrations/evidence/blockingCauses.ts

@@ -0,0 +1,82 @@
+import type { AiEvidenceV2_1, CompatibilityViolation, SnapshotFinding } from './schema';
+
+export type EvidenceBlockingCause = {
+  ruleId: string;
+  code: string;
+  severity: string;
+  message: string;
+  file?: string;
+  lines?: SnapshotFinding['lines'];
+  remediation?: string;
+  source: 'snapshot.findings' | 'ai_gate.violations';
+};
+
+const isBlockingSeverity = (severity: string): boolean =>
+  severity.toUpperCase() === 'CRITICAL' || severity.toUpperCase() === 'ERROR';
+
+const toFindingBlockingCause = (finding: SnapshotFinding): EvidenceBlockingCause => ({
+  ruleId: finding.ruleId,
+  code: finding.code,
+  severity: finding.severity,
+  message: finding.message,
+  file: finding.file,
+  lines: finding.lines,
+  remediation: finding.expected_fix,
+  source: 'snapshot.findings',
+});
+
+const toViolationBlockingCause = (
+  violation: CompatibilityViolation
+): EvidenceBlockingCause => ({
+  ruleId: violation.ruleId,
+  code: violation.code,
+  severity: violation.level,
+  message: violation.message,
+  file: violation.file,
+  lines: violation.lines,
+  remediation: violation.expected_fix,
+  source: 'ai_gate.violations',
+});
+
+const causeKey = (cause: EvidenceBlockingCause): string =>
+  [cause.source, cause.ruleId, cause.code, cause.file ?? '', String(cause.lines ?? '')].join('|');
+
+export const extractEvidenceBlockingCauses = (
+  evidence: AiEvidenceV2_1
+): ReadonlyArray<EvidenceBlockingCause> => {
+  const causes: EvidenceBlockingCause[] = [];
+  const seen = new Set<string>();
+
+  for (const finding of evidence.snapshot.findings) {
+    if (finding.blocking === false || !isBlockingSeverity(finding.severity)) {
+      continue;
+    }
+    const cause = toFindingBlockingCause(finding);
+    const key = causeKey(cause);
+    if (!seen.has(key)) {
+      causes.push(cause);
+      seen.add(key);
+    }
+  }
+
+  for (const violation of evidence.ai_gate.violations) {
+    if (violation.blocking === false || !isBlockingSeverity(violation.level)) {
+      continue;
+    }
+    const cause = toViolationBlockingCause(violation);
+    const key = causeKey(cause);
+    if (!seen.has(key)) {
+      causes.push(cause);
+      seen.add(key);
+    }
+  }
+
+  return causes;
+};
+
+export const formatEvidenceBlockingCause = (cause: EvidenceBlockingCause): string => {
+  const location = cause.file ? ` file=${cause.file}` : '';
+  const lines = cause.lines ? ` lines=${String(cause.lines)}` : '';
+  const remediation = cause.remediation ? ` remediation=${cause.remediation}` : '';
+  return `${cause.ruleId} severity=${cause.severity} code=${cause.code}${location}${lines} message=${cause.message}${remediation}`;
+};

package/integrations/gate/evaluateAiGate.ts

@@ -401,6 +401,69 @@ const collectWorktreeChangedPaths = (repoRoot: string): ReadonlyArray<string> =>
   }
 };
 
+const collectStagedChangedPaths = (repoRoot: string): ReadonlyArray<string> => {
+  try {
+    const output = execFileSync(
+      'git',
+      ['diff', '--cached', '--name-only'],
+      {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }
+    );
+    const files = output
+      .split('\n')
+      .map((line) => normalizeChangedPath(line))
+      .filter((line) => line.length > 0);
+    return [...new Set(files)];
+  } catch {
+    return [];
+  }
+};
+
+const collectPreWriteEffectiveChangedPaths = (repoRoot: string): ReadonlyArray<string> => {
+  const stagedPaths = collectStagedChangedPaths(repoRoot);
+  if (stagedPaths.length > 0) {
+    return stagedPaths;
+  }
+  return collectWorktreeChangedPaths(repoRoot);
+};
+
+const isIosTestQualityPath = (filePath: string): boolean => {
+  const normalized = normalizeChangedPath(filePath).toLowerCase();
+  if (!normalized.endsWith('.swift')) {
+    return false;
+  }
+  return normalized.includes('/tests/')
+    || normalized.includes('/uitests/')
+    || normalized.endsWith('test.swift')
+    || normalized.endsWith('tests.swift')
+    || normalized.endsWith('.spec.swift');
+};
+
+const hasPreWriteIosTestQualityScope = (repoRoot: string): boolean =>
+  collectPreWriteEffectiveChangedPaths(repoRoot).some((filePath) =>
+    isIosTestQualityPath(filePath)
+  );
+
+const resolvePreWriteCriticalSkillsRules = (params: {
+  platform: PreWriteSkillsPlatform;
+  stage: AiGateStage;
+  repoRoot: string;
+}): ReadonlyArray<string> => {
+  const ruleIds = PREWRITE_CRITICAL_SKILLS_RULES[params.platform];
+  if (
+    params.platform === 'ios'
+    && params.stage === 'PRE_WRITE'
+    && ruleIds.includes('skills.ios.critical-test-quality')
+    && !hasPreWriteIosTestQualityScope(params.repoRoot)
+  ) {
+    return ruleIds.filter((ruleId) => ruleId !== 'skills.ios.critical-test-quality');
+  }
+  return ruleIds;
+};
+
 const isPlatformPath = (platform: PreWriteSkillsPlatform, filePath: string): boolean => {
   const normalized = normalizeChangedPath(filePath).toLowerCase();
   if (platform === 'ios') {
@@ -552,6 +615,7 @@ const collectActiveRuleIdsCoverageViolations = (params: {
 };
 
 const collectPreWritePlatformSkillsViolations = (params: {
+  repoRoot: string;
   evidence: Extract<EvidenceReadResult, { kind: 'valid' }>['evidence'];
   coverage: NonNullable<Extract<EvidenceReadResult, { kind: 'valid' }>['evidence']['snapshot']['rules_coverage']>;
   skillsEnforcement: SkillsEnforcementResolution;
@@ -625,7 +689,11 @@ const collectPreWritePlatformSkillsViolations = (params: {
 
   const missingCriticalRulesByPlatform: string[] = [];
   for (const platform of detectedPlatforms) {
-    const requiredCriticalRuleIds = PREWRITE_CRITICAL_SKILLS_RULES[platform];
+    const requiredCriticalRuleIds = resolvePreWriteCriticalSkillsRules({
+      platform,
+      stage: 'PRE_WRITE',
+      repoRoot: params.repoRoot,
+    });
     if (requiredCriticalRuleIds.length === 0) {
       continue;
     }
@@ -716,14 +784,22 @@ const toSkillsContractAssessment = (params: {
         platform,
         required_rule_prefix: PLATFORM_SKILLS_RULE_PREFIXES[platform],
         required_bundles: [...PLATFORM_REQUIRED_SKILLS_BUNDLES[platform]],
-        required_critical_rule_ids: [...PREWRITE_CRITICAL_SKILLS_RULES[platform]],
+        required_critical_rule_ids: resolvePreWriteCriticalSkillsRules({
+          platform,
+          stage: params.stage,
+          repoRoot: params.repoRoot,
+        }),
         required_any_transversal_critical_rule_ids: [
           ...PREWRITE_TRANSVERSAL_CRITICAL_SKILLS_RULES[platform],
         ],
         active_prefix_covered: false,
         evaluated_prefix_covered: false,
         missing_bundles: [...PLATFORM_REQUIRED_SKILLS_BUNDLES[platform]],
-        missing_critical_rule_ids: [...PREWRITE_CRITICAL_SKILLS_RULES[platform]],
+        missing_critical_rule_ids: resolvePreWriteCriticalSkillsRules({
+          platform,
+          stage: params.stage,
+          repoRoot: params.repoRoot,
+        }),
         transversal_critical_covered: false,
         missing_any_transversal_critical_rule_ids: [
           ...PREWRITE_TRANSVERSAL_CRITICAL_SKILLS_RULES[platform],
@@ -798,14 +874,22 @@ const toSkillsContractAssessment = (params: {
       platform,
       required_rule_prefix: PLATFORM_SKILLS_RULE_PREFIXES[platform],
       required_bundles: [...PLATFORM_REQUIRED_SKILLS_BUNDLES[platform]],
-      required_critical_rule_ids: [...PREWRITE_CRITICAL_SKILLS_RULES[platform]],
+      required_critical_rule_ids: resolvePreWriteCriticalSkillsRules({
+        platform,
+        stage: params.stage,
+        repoRoot: params.repoRoot,
+      }),
       required_any_transversal_critical_rule_ids: [
         ...PREWRITE_TRANSVERSAL_CRITICAL_SKILLS_RULES[platform],
       ],
       active_prefix_covered: false,
       evaluated_prefix_covered: false,
       missing_bundles: [...PLATFORM_REQUIRED_SKILLS_BUNDLES[platform]],
-      missing_critical_rule_ids: [...PREWRITE_CRITICAL_SKILLS_RULES[platform]],
+      missing_critical_rule_ids: resolvePreWriteCriticalSkillsRules({
+        platform,
+        stage: params.stage,
+        repoRoot: params.repoRoot,
+      }),
       transversal_critical_covered: false,
       missing_any_transversal_critical_rule_ids: [
         ...PREWRITE_TRANSVERSAL_CRITICAL_SKILLS_RULES[platform],
@@ -859,7 +943,13 @@ const toSkillsContractAssessment = (params: {
   for (const platform of assessmentPlatforms) {
     const requiredRulePrefix = PLATFORM_SKILLS_RULE_PREFIXES[platform];
     const requiredBundles = [...PLATFORM_REQUIRED_SKILLS_BUNDLES[platform]];
-    const requiredCriticalRuleIds = [...PREWRITE_CRITICAL_SKILLS_RULES[platform]];
+    const requiredCriticalRuleIds = [
+      ...resolvePreWriteCriticalSkillsRules({
+        platform,
+        stage: params.stage,
+        repoRoot: params.repoRoot,
+      }),
+    ];
     const requiredAnyTransversalCriticalRuleIds = [
       ...PREWRITE_TRANSVERSAL_CRITICAL_SKILLS_RULES[platform],
     ];
@@ -1057,6 +1147,7 @@ const collectPreWriteCoherenceViolations = (params: {
 
     violations.push(
       ...collectPreWritePlatformSkillsViolations({
+        repoRoot: params.repoRoot,
         evidence: params.evidence,
         coverage,
         skillsEnforcement,

package/integrations/git/runPlatformGate.ts

@@ -32,7 +32,6 @@ import { createEmptyEvaluationMetrics } from '../evidence/evaluationMetrics';
 import { createEmptySnapshotRulesCoverage } from '../evidence/rulesCoverage';
 import { enforceTddBddPolicy } from '../tdd/enforcement';
 import type { TddBddSnapshot } from '../tdd/types';
-import { resolveSkillsEnforcement } from '../policy/skillsEnforcement';
 import { applyTddBddEnforcement } from '../policy/tddBddEnforcement';
 import { collectAiGateRepoPolicyFindings } from './aiGateRepoPolicyFindings';
 import {
@@ -886,25 +885,7 @@ const applySkillsFindingEnforcement = (
   if (!finding) {
     return undefined;
   }
-  const skillsEnforcement = resolveSkillsEnforcement();
-  if (skillsEnforcement.blocking) {
-    return finding;
-  }
-  return {
-    ...finding,
-    severity: 'WARN',
-    blocking: false,
-  };
-};
-
-const toSoftPreCommitSkillsFinding = (params: {
-  finding: Finding | undefined;
-  enabled: boolean;
-  observedCodePaths: ReadonlyArray<string>;
-}): Finding | undefined => {
-  void params.enabled;
-  void params.observedCodePaths;
-  return params.finding;
+  return finding;
 };
 
 export async function runPlatformGate(params: {
@@ -1281,42 +1262,10 @@ export async function runPlatformGate(params: {
   const hasNativeBlockingFinding = findings.some(
     (finding) => shouldBlockFromFinding(finding)
   );
-  const preCommitSoftSkillsEnabled = process.env.PUMUKI_PRE_COMMIT_SOFT_SKILLS === '1';
-  const lowRiskPreCommitWindow = observedCodePaths.length > 0 && observedCodePaths.length <= 3;
-  const shouldSoftEnforceSkillsFindings =
-    params.policy.stage === 'PRE_COMMIT'
-    && preCommitSoftSkillsEnabled
-    && lowRiskPreCommitWindow
-    && !sddBlockingFinding
-    && !degradedModeBlocks
-    && !shouldBlockFromFinding(policyAsCodeBlockingFinding)
-    && !shouldBlockFromFinding(coverageBlockingFinding)
-    && !shouldBlockFromFinding(declarativeRulesClassificationFinding)
-    && !shouldBlockFromFinding(activeRulesEmptyForCodeChangesFinding)
-    && !shouldBlockFromFinding(effectiveIosTestsQualityFinding)
-    && !shouldBlockFromFinding(astIntelligenceDualFinding)
-    && !hasTddBddBlockingFinding
-    && !hasNativeBlockingFinding;
-  const effectiveUnsupportedSkillsMappingFinding = toSoftPreCommitSkillsFinding({
-    finding: effectiveUnsupportedSkillsMappingInput,
-    enabled: shouldSoftEnforceSkillsFindings,
-    observedCodePaths,
-  });
-  const effectivePlatformSkillsCoverageFinding = toSoftPreCommitSkillsFinding({
-    finding: effectivePlatformSkillsCoverageInput,
-    enabled: shouldSoftEnforceSkillsFindings,
-    observedCodePaths,
-  });
-  const effectiveCrossPlatformCriticalFinding = toSoftPreCommitSkillsFinding({
-    finding: effectiveCrossPlatformCriticalInput,
-    enabled: shouldSoftEnforceSkillsFindings,
-    observedCodePaths,
-  });
-  const effectiveSkillsScopeComplianceFinding = toSoftPreCommitSkillsFinding({
-    finding: effectiveSkillsScopeComplianceInput,
-    enabled: shouldSoftEnforceSkillsFindings,
-    observedCodePaths,
-  });
+  const effectiveUnsupportedSkillsMappingFinding = effectiveUnsupportedSkillsMappingInput;
+  const effectivePlatformSkillsCoverageFinding = effectivePlatformSkillsCoverageInput;
+  const effectiveCrossPlatformCriticalFinding = effectiveCrossPlatformCriticalInput;
+  const effectiveSkillsScopeComplianceFinding = effectiveSkillsScopeComplianceInput;
   const effectiveFindings = sddBlockingFinding
     ? [
       ...(contextBlockingFinding ? [contextBlockingFinding] : []),

package/integrations/git/runPlatformGateOutput.ts

@@ -21,6 +21,12 @@ const BLOCK_NEXT_ACTION_BY_CODE: Readonly<Record<string, string>> = {
     '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.',
+  SKILLS_SKILLS_BACKEND_NO_CONSOLE_LOG:
+    'Elimina console.log del backend o sustitúyelo por el logger aprobado para runtime; vuelve a ejecutar el gate.',
+  SKILLS_SKILLS_FRONTEND_NO_CONSOLE_LOG:
+    'Elimina console.log del frontend de producción o muévelo a instrumentación aprobada; vuelve a ejecutar el gate.',
+  HEURISTICS_CONSOLE_LOG_AST:
+    'Elimina console.log del código productivo o usa el logger aprobado del proyecto; vuelve a ejecutar el gate.',
 };
 
 const severityWeight = (severity: string): number => {
@@ -38,6 +44,23 @@ const severityWeight = (severity: string): number => {
   }
 };
 
+const isAstSkillFinding = (finding: Finding): boolean => {
+  const ruleId = finding.ruleId.toLowerCase();
+  const code = finding.code.toLowerCase();
+  return (
+    ruleId.startsWith('skills.') ||
+    ruleId.startsWith('heuristics.') ||
+    code.startsWith('skills_') ||
+    code.startsWith('heuristics_') ||
+    code.includes('_ast')
+  );
+};
+
+const primaryWeight = (finding: Finding): number => {
+  const astSkillWeight = isAstSkillFinding(finding) ? 100 : 0;
+  return astSkillWeight + severityWeight(finding.severity);
+};
+
 const resolvePrimaryFinding = (findings: ReadonlyArray<Finding>): Finding => {
   let primary = findings[0];
   for (const finding of findings.slice(1)) {
@@ -45,7 +68,7 @@ const resolvePrimaryFinding = (findings: ReadonlyArray<Finding>): Finding => {
       primary = finding;
       continue;
     }
-    if (severityWeight(finding.severity) > severityWeight(primary.severity)) {
+    if (primaryWeight(finding) > primaryWeight(primary)) {
       primary = finding;
     }
   }
@@ -54,6 +77,10 @@ const resolvePrimaryFinding = (findings: ReadonlyArray<Finding>): Finding => {
 
 const sortFindingsBySeverity = (findings: ReadonlyArray<Finding>): ReadonlyArray<Finding> =>
   [...findings].sort((left, right) => {
+    const primaryDelta = primaryWeight(right) - primaryWeight(left);
+    if (primaryDelta !== 0) {
+      return primaryDelta;
+    }
     const severityDelta = severityWeight(right.severity) - severityWeight(left.severity);
     if (severityDelta !== 0) {
       return severityDelta;
@@ -126,7 +153,8 @@ export const printGateFindings = (findings: ReadonlyArray<Finding>): void => {
       `[pumuki][warning-summary] secondary=${finding.code} severity=${finding.severity.toUpperCase()} rule=${finding.ruleId}\n`
     );
   }
-  for (const finding of orderedFindings) {
-    process.stdout.write(`${formatFinding(finding)}\n`);
+  process.stdout.write(`[pumuki][findings] total=${orderedFindings.length}\n`);
+  for (const [index, finding] of orderedFindings.entries()) {
+    process.stdout.write(`\n${index + 1}. ${formatFinding(finding)}\n`);
   }
 };

package/integrations/git/stageRunners.ts

@@ -823,6 +823,13 @@ const enforceGitAtomicityGate = (params: {
     causeCode: firstViolation.code,
     causeMessage: firstViolation.message,
     remediation: firstViolation.remediation,
+    blockingCauses: atomicity.violations.map((violation) => ({
+      code: violation.code,
+      message: violation.message,
+      ruleId: 'git.atomicity.blocked',
+      file: '.pumuki/git-atomicity.json',
+      remediation: violation.remediation,
+    })),
   });
   notifyAuditSummaryForStage(params.dependencies, params.stage);
   return true;

package/integrations/lifecycle/cliSdd.ts

@@ -334,6 +334,16 @@ export const runSddCommand = async (parsed: ParsedArgs, activeDependencies: Life
                 causeCode,
                 nextAction,
               }),
+              blockingCauses: aiGate.violations.map((violation) => ({
+                code: violation.code,
+                message: violation.message,
+                ruleId: violation.code,
+                file: resolveAiGateViolationLocation(violation.code),
+                remediation: resolvePreWriteBlockedRemediation({
+                  causeCode: violation.code,
+                  nextAction,
+                }),
+              })),
             });
             return 1;
           }

package/integrations/lifecycle/doctor.ts

@@ -25,12 +25,18 @@ import {
   readLifecycleNotificationStatus,
   type LifecycleNotificationStatus,
 } from './notificationStatus';
+import {
+  extractEvidenceBlockingCauses,
+  formatEvidenceBlockingCause,
+  type EvidenceBlockingCause,
+} from '../evidence/blockingCauses';
 
 export type DoctorIssueSeverity = 'warning' | 'error';
 
 export type DoctorIssue = {
   severity: DoctorIssueSeverity;
   message: string;
+  blockingCauses?: ReadonlyArray<EvidenceBlockingCause>;
 };
 
 export type DoctorDeepCheckId =
@@ -193,12 +199,20 @@ const buildDoctorIssues = (params: {
       evidence.severity_metrics.gate_status === 'BLOCKED';
     if (blocked) {
       const blockedStage = evidence?.snapshot?.stage ?? 'PRE_WRITE';
+      const blockingCauses = extractEvidenceBlockingCauses(evidence);
+      const causeDetails =
+        blockingCauses.length > 0
+          ? ` Blocking causes: ${blockingCauses.length}. ${blockingCauses
+              .map(formatEvidenceBlockingCause)
+              .join(' | ')}`
+          : '';
       issues.push({
         severity: 'error',
         message: appendTrackingActionableContext({
           repoRoot: params.repoRoot,
-          message: `Governance is blocked (${blockedStage}).`,
+          message: `Governance is blocked (${blockedStage}).${causeDetails}`,
         }),
+        blockingCauses,
       });
     } else if (evidence.snapshot.outcome === 'WARN') {
       const warnStage = evidence?.snapshot?.stage ?? 'PRE_WRITE';

package/integrations/lifecycle/status.ts

@@ -22,6 +22,10 @@ import {
   readLifecycleNotificationStatus,
   type LifecycleNotificationStatus,
 } from './notificationStatus';
+import {
+  extractEvidenceBlockingCauses,
+  formatEvidenceBlockingCause,
+} from '../evidence/blockingCauses';
 
 export type LifecycleStatus = {
   repoRoot: string;
@@ -101,12 +105,20 @@ const buildLifecycleIssues = (repoRoot: string): ReadonlyArray<DoctorIssue> => {
     repoRoot,
     message: `Governance is blocked (${blockedStage}).`,
   });
+  const blockingCauses = extractEvidenceBlockingCauses(evidence);
+  const causeDetails =
+    blockingCauses.length > 0
+      ? ` Blocking causes: ${blockingCauses.length}. ${blockingCauses
+          .map(formatEvidenceBlockingCause)
+          .join(' | ')}`
+      : '';
   return [
     ...notificationIssues,
     ...leaseIssues,
     {
       severity: 'error',
-      message,
+      message: `${message}${causeDetails}`,
+      blockingCauses,
     },
   ];
 };

package/integrations/lifecycle/watch.ts

@@ -679,6 +679,13 @@ export const runLifecycleWatch = async (
               causeCode: cause.code,
               causeMessage: cause.message,
               remediation: cause.remediation,
+              blockingCauses: matchedFindings.map((finding) => ({
+                code: finding.code ?? finding.ruleId,
+                message: finding.message,
+                ruleId: finding.ruleId,
+                file: finding.file,
+                remediation: finding.expected_fix,
+              })),
             });
           } else {
             notificationResult = activeDependencies.emitAuditSummaryNotificationFromEvidence({

package/integrations/mcp/evidencePayloadStatus.ts

@@ -21,6 +21,7 @@ import {
 } from './evidenceFacets';
 import { CONTEXT_API_CAPABILITIES } from './evidencePayloadConfig';
 import { toSuppressedSummaryFields } from './evidencePayloadSummarySuppressed';
+import { extractEvidenceBlockingCauses } from '../evidence/blockingCauses';
 
 export const toStatusPayload = (repoRoot: string): unknown => {
   const readResult = readEvidenceResult(repoRoot);
@@ -61,6 +62,7 @@ export const toStatusPayload = (repoRoot: string): unknown => {
   const detectedPlatformsCount = sortedPlatforms.filter((entry) => entry.detected).length;
   const suppressedFindingsCount = evidence.consolidation?.suppressed?.length ?? 0;
   const findingsWithLinesCount = toFindingsWithLinesCount(evidence.snapshot.findings);
+  const blockingCauses = extractEvidenceBlockingCauses(evidence);
   return {
     status: 'ok',
     context_api: CONTEXT_API_CAPABILITIES,
@@ -83,6 +85,8 @@ export const toStatusPayload = (repoRoot: string): unknown => {
       findings_by_platform: toFindingsByPlatform(evidence.snapshot.findings),
       highest_severity: toHighestSeverity(evidence.snapshot.findings),
       blocking_findings_count: toBlockingFindingsCount(evidence.snapshot.findings),
+      blocking_causes_count: blockingCauses.length,
+      blocking_causes: blockingCauses,
       ledger_count: evidence.ledger.length,
       ledger_files_count: toLedgerFilesCount(evidence.ledger),
       ledger_rules_count: toLedgerRulesCount(evidence.ledger),

package/integrations/mcp/evidencePayloadSummary.ts

@@ -19,12 +19,14 @@ import {
   toSeverityCounts,
 } from './evidenceFacets';
 import { toSuppressedSummaryFields } from './evidencePayloadSummarySuppressed';
+import { extractEvidenceBlockingCauses } from '../evidence/blockingCauses';
 
 export const toSummaryPayload = (evidence: AiEvidenceV2_1) => {
   const sortedPlatforms = sortPlatforms(evidence.platforms);
   const detectedPlatforms = sortedPlatforms.filter((entry) => entry.detected);
   const suppressedFindingsCount = evidence.consolidation?.suppressed?.length ?? 0;
   const findingsWithLinesCount = toFindingsWithLinesCount(evidence.snapshot.findings);
+  const blockingCauses = extractEvidenceBlockingCauses(evidence);
   return {
     version: evidence.version,
     timestamp: evidence.timestamp,
@@ -41,6 +43,8 @@ export const toSummaryPayload = (evidence: AiEvidenceV2_1) => {
       findings_by_platform: toFindingsByPlatform(evidence.snapshot.findings),
       highest_severity: toHighestSeverity(evidence.snapshot.findings),
       blocking_findings_count: toBlockingFindingsCount(evidence.snapshot.findings),
+      blocking_causes_count: blockingCauses.length,
+      blocking_causes: blockingCauses,
     },
     ledger_count: evidence.ledger.length,
     ledger_files_count: toLedgerFilesCount(evidence.ledger),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.275",
+  "version": "6.3.277",
   "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-consumer-runtime-actions.ts

@@ -2,6 +2,7 @@ import { createConsumerLegacyMenuActions } from './framework-menu-consumer-actio
 import { formatConsumerPreflight, runConsumerPreflight } from './framework-menu-consumer-preflight-lib';
 import {
   buildConsumerRuntimeBlockedSummary,
+  buildConsumerRuntimeBlockedCauseLines,
   exportConsumerRuntimeMarkdown,
   notifyConsumerRuntimeAuditSummary,
   printConsumerRuntimeEmptyScopeHint,
@@ -83,6 +84,11 @@ const renderSummaryAfterGate = (
     dependencies.setSummaryOverride(
       buildConsumerRuntimeBlockedSummary(gateResult.blocked)
     );
+    dependencies.write(
+      '\n' +
+        buildConsumerRuntimeBlockedCauseLines(gateResult.blocked).join('\n') +
+        '\n'
+    );
   } else {
     dependencies.clearSummaryOverride();
   }
@@ -102,13 +108,57 @@ const renderSummaryAfterGate = (
   return summary;
 };
 
+const buildFullAuditFinalSummaryLines = (
+  summary: import('./framework-menu-evidence-summary-lib').FrameworkMenuEvidenceSummary
+): string[] => {
+  const platformRows = summary.platformAuditRows ?? [];
+  const topFindings = summary.topFindings.slice(0, 10);
+  return [
+    '✅ AST Intelligence completed',
+    '═══════════════════════════════════════════════════════════════',
+    'FINAL SUMMARY - VIOLATIONS BY SEVERITY',
+    `🔴 CRITICAL: ${summary.byEnterpriseSeverity?.CRITICAL ?? summary.bySeverity.CRITICAL}`,
+    `🟠 HIGH:     ${summary.byEnterpriseSeverity?.HIGH ?? summary.bySeverity.ERROR}`,
+    `🟡 MEDIUM:   ${summary.byEnterpriseSeverity?.MEDIUM ?? summary.bySeverity.WARN}`,
+    `🔵 LOW:      ${summary.byEnterpriseSeverity?.LOW ?? summary.bySeverity.INFO}`,
+    `Total violations: ${summary.totalFindings}`,
+    '',
+    'PLATFORM-SPECIFIC ANALYSIS',
+    ...(platformRows.length === 0
+      ? ['  No platform findings.']
+      : platformRows.map((row) => `  Platform: ${row.platform} -> ${row.violations} violations`)),
+    '',
+    'TOP VIOLATIONS & REMEDIATION',
+    ...(topFindings.length === 0
+      ? ['  No violations detected.']
+      : topFindings.map(
+          (finding) =>
+            `  [${finding.severity}] ${finding.ruleId} -> ${finding.file}:${finding.line}`
+        )),
+  ];
+};
+
 export const createConsumerRuntimeActions = (
   dependencies: ConsumerRuntimeActionDependencies
 ): ReadonlyArray<ConsumerAction> =>
   createConsumerLegacyMenuActions({
     runFullAudit: async () => {
+      dependencies.write(
+        '\n' +
+          [
+            'Collecting source files...',
+            'Running pattern checks...',
+            'Running ESLint audits...',
+            '⚙️ AST Intelligence',
+            'Running AST analysis...',
+          ].join('\n') +
+          '\n'
+      );
       await runConsumerRuntimePreflight(dependencies, 'PRE_COMMIT');
-      renderSummaryAfterGate(dependencies, await dependencies.runRepoGate());
+      const summary = renderSummaryAfterGate(dependencies, await dependencies.runRepoGate());
+      dependencies.write(
+        `\n${buildFullAuditFinalSummaryLines(summary).join('\n')}\n`
+      );
     },
     runStrictRepoAndStaged: async () => {
       await runConsumerRuntimePreflight(dependencies, 'PRE_PUSH');

package/scripts/framework-menu-consumer-runtime-audit.ts

@@ -155,46 +155,123 @@ export const printPrePushTrackedEvidenceDiskHint = (params: {
 
 export const buildConsumerRuntimeBlockedSummary = (
   blocked: ConsumerRuntimeBlockedGate
-): FrameworkMenuEvidenceSummary => ({
-  status: 'ok',
-  stage: blocked.stage,
-  outcome: 'BLOCK',
-  totalFindings: blocked.totalViolations,
-  filesScanned: 0,
-  filesAffected: 0,
-  bySeverity: {
-    CRITICAL: 0,
-    ERROR: 1,
-    WARN: 0,
-    INFO: 0,
-  },
-  byEnterpriseSeverity: {
-    CRITICAL: 0,
-    HIGH: 1,
-    MEDIUM: 0,
-    LOW: 0,
-  },
-  topFiles: [
-    {
-      file: 'PROJECT_ROOT',
-      count: 1,
-    },
-  ],
-  topFileLocations: [
-    {
-      file: 'PROJECT_ROOT',
-      line: 1,
+): FrameworkMenuEvidenceSummary => {
+  const normalizedCause = blocked.causeCode.toLowerCase();
+  const inferredPlatform = normalizedCause.includes('backend')
+    ? 'Backend'
+    : normalizedCause.includes('frontend') || normalizedCause.includes('web')
+      ? 'Frontend'
+      : normalizedCause.includes('ios')
+        ? 'iOS'
+        : normalizedCause.includes('android')
+          ? 'Android'
+        : null;
+  const blockingCauses = blocked.blockingCauses ?? [];
+  const topFindings =
+    blockingCauses.length > 0
+      ? blockingCauses.map((cause) => ({
+          severity: 'HIGH' as const,
+          ruleId: cause.ruleId ?? cause.code,
+          file: cause.file ?? 'PROJECT_ROOT',
+          line: 1,
+        }))
+      : [
+          {
+            severity: 'HIGH' as const,
+            ruleId: blocked.causeCode,
+            file: 'PROJECT_ROOT',
+            line: 1,
+          },
+        ];
+  const topFiles = new Map<string, number>();
+  for (const finding of topFindings) {
+    topFiles.set(finding.file, (topFiles.get(finding.file) ?? 0) + 1);
+  }
+  const platformCounts = new Map<string, number>();
+  const inferPlatform = (value: string): string | null => {
+    const normalized = value.toLowerCase();
+    if (normalized.includes('backend')) {
+      return 'Backend';
+    }
+    if (normalized.includes('frontend') || normalized.includes('/web/') || normalized.includes('web')) {
+      return 'Frontend';
+    }
+    if (normalized.includes('ios')) {
+      return 'iOS';
+    }
+    if (normalized.includes('android')) {
+      return 'Android';
+    }
+    return null;
+  };
+  if (blockingCauses.length > 0) {
+    for (const cause of blockingCauses) {
+      const platform = inferPlatform(`${cause.ruleId ?? cause.code} ${cause.file ?? ''}`);
+      if (platform) {
+        platformCounts.set(platform, (platformCounts.get(platform) ?? 0) + 1);
+      }
+    }
+  } else if (inferredPlatform) {
+    platformCounts.set(inferredPlatform, blocked.totalViolations);
+  }
+  return {
+    status: 'ok',
+    stage: blocked.stage,
+    outcome: 'BLOCK',
+    totalFindings: blocked.totalViolations,
+    filesScanned: 0,
+    filesAffected: 0,
+    bySeverity: {
+      CRITICAL: 0,
+      ERROR: 1,
+      WARN: 0,
+      INFO: 0,
     },
-  ],
-  topFindings: [
-    {
-      severity: 'HIGH',
-      ruleId: blocked.causeCode,
-      file: 'PROJECT_ROOT',
-      line: 1,
+    byEnterpriseSeverity: {
+      CRITICAL: 0,
+      HIGH: 1,
+      MEDIUM: 0,
+      LOW: 0,
     },
-  ],
-});
+    topFiles: [
+      ...topFiles.entries(),
+    ].map(([file, count]) => ({
+      file,
+      count,
+    })),
+    topFileLocations: topFindings.map((finding) => ({
+      file: finding.file,
+      line: finding.line,
+    })),
+    topFindings,
+    platformAuditRows: [...platformCounts.entries()].map(([platform, violations]) => ({
+      platform,
+      violations,
+    })),
+  };
+};
+
+export const buildConsumerRuntimeBlockedCauseLines = (
+  blocked: ConsumerRuntimeBlockedGate
+): string[] => {
+  const causes = blocked.blockingCauses ?? [];
+  if (causes.length === 0) {
+    return [
+      `🔴 Gate blocked: ${blocked.causeCode}`,
+      `Cause: ${blocked.causeMessage}`,
+      `Solution: ${blocked.remediation}`,
+    ];
+  }
+  return [
+    `🔴 Gate blocked: ${blocked.causeCode}`,
+    `Blocking causes: ${causes.length}`,
+    ...causes.flatMap((cause, index) => [
+      `${index + 1}. ${cause.ruleId ?? cause.code}${cause.file ? ` @ ${cause.file}` : ''}`,
+      `   Cause: ${cause.message}`,
+      `   Solution: ${cause.remediation ?? blocked.remediation}`,
+    ]),
+  ];
+};
 
 export const printConsumerRuntimeEmptyScopeHint = (
   dependencies: Pick<ConsumerRuntimeSummaryDependencies, 'write'>,

package/scripts/framework-menu-consumer-runtime-menu.ts

@@ -18,6 +18,16 @@ import type {
   ConsumerRuntimeWrite,
 } from './framework-menu-consumer-runtime-types';
 
+const PUMUKI_LEGACY_BANNER = [
+  '██████╗ ██╗   ██╗███╗   ███╗██╗   ██╗██╗  ██╗██╗',
+  '██╔══██╗██║   ██║████╗ ████║██║   ██║██║ ██╔╝██║',
+  '██████╔╝██║   ██║██╔████╔██║██║   ██║█████╔╝ ██║',
+  '██╔═══╝ ██║   ██║██║╚██╔╝██║██║   ██║██╔═██╗ ██║',
+  '██║     ╚██████╔╝██║ ╚═╝ ██║╚██████╔╝██║  ██╗██║',
+  '╚═╝      ╚═════╝ ╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝',
+  '                      🐈 En memoria de Pumuki 💚',
+];
+
 const buildConsumerRuntimeMenuStatus = (
   menuSummary: FrameworkMenuEvidenceSummary
 ): { level: 'info' | 'block' | 'warn' | 'ok'; label: string } =>
@@ -35,17 +45,26 @@ export const renderConsumerRuntimeClassicMenu = (
   actions: ReadonlyArray<ConsumerAction>,
   useColor: () => boolean
 ): string => {
-  const groupedActions = resolveConsumerMenuLayout(actions);
+  const actionById = new Map(actions.map((action) => [action.id, action]));
+  const label = (id: string): string => actionById.get(id)?.label ?? 'Unavailable';
   const lines = [
-    'PUMUKI',
+    ...PUMUKI_LEGACY_BANNER,
+    '',
     'Advanced Project Audit — AST Intelligence & Quality Gate',
-    'A. Switch to advanced menu',
     '',
-    ...groupedActions.flatMap((group) => [
-      group.title,
-      ...group.items.map((item) => `${item.id}) ${item.action.label}`),
-      '',
-    ]),
+    `1) ${label('1')}   6) ${label('6')}`,
+    `2) ${label('2')}  7) ${label('7')}`,
+    `3) ${label('3')}    8) ${label('8')}`,
+    `4) ${label('4')}       9) ${label('9')}`,
+    `5) ${label('5')}                 10) ${label('10')}`,
+    '',
+    'Additional engine flows',
+    `11) ${label('11')}`,
+    `12) ${label('12')}`,
+    `13) ${label('13')}`,
+    `14) ${label('14')}`,
+    '',
+    'A) Switch to advanced menu',
   ];
   return renderLegacyPanel(lines, {
     width: resolveLegacyPanelOuterWidth(),
@@ -68,7 +87,8 @@ export const renderConsumerRuntimeModernMenu = (
   });
   const groupedActions = resolveConsumerMenuLayout(params.actions);
   const lines = [
-    'PUMUKI',
+    ...PUMUKI_LEGACY_BANNER,
+    '',
     'Advanced Project Audit — AST Intelligence & Quality Gate',
     `Status: ${renderBadge(menuStatus.label, menuStatus.level, tokens)}`,
     'A. Switch to advanced menu',

package/scripts/framework-menu-consumer-runtime-types.ts

@@ -1,5 +1,6 @@
 import type { FrameworkMenuEvidenceSummary } from './framework-menu-evidence-summary-lib';
 import type {
+  PumukiBlockedNotificationCause,
   PumukiCriticalNotificationEvent,
   SystemNotificationEmitResult,
 } from './framework-menu-system-notifications-lib';
@@ -16,6 +17,7 @@ export type ConsumerRuntimeBlockedGate = {
   causeCode: string;
   causeMessage: string;
   remediation: string;
+  blockingCauses?: ReadonlyArray<PumukiBlockedNotificationCause>;
 };
 
 export type ConsumerRuntimeGateResult = {

package/scripts/framework-menu-gate-lib.ts

@@ -239,6 +239,7 @@ const runMenuAuditGateWithBlocked = async (
           causeCode: params.causeCode,
           causeMessage: params.causeMessage,
           remediation: params.remediation,
+          blockingCauses: params.blockingCauses,
         };
         return {
           delivered: false,
@@ -273,6 +274,7 @@ const runRepoAndStagedPrePushGateSilentWithDependencies = async (
         causeCode: params.causeCode,
         causeMessage: params.causeMessage,
         remediation: params.remediation,
+        blockingCauses: params.blockingCauses,
       };
     },
     writeHookGateSummary: () => {},

package/scripts/framework-menu-layout-data.ts

@@ -3,7 +3,7 @@ import type { MenuLayoutGroup } from './framework-menu-layout-types';
 export const CONSUMER_MENU_LAYOUT: ReadonlyArray<MenuLayoutGroup> = [
   {
     key: 'read-only-gates',
-    title: 'Legacy Audit Flows',
+    title: 'Classic audit flows',
     itemIds: ['1', '2', '3', '4'],
   },
   {
@@ -13,12 +13,12 @@ export const CONSUMER_MENU_LAYOUT: ReadonlyArray<MenuLayoutGroup> = [
   },
   {
     key: 'export',
-    title: 'Legacy Export',
+    title: 'Classic export',
     itemIds: ['8'],
   },
   {
     key: 'legacy-read-only-diagnostics',
-    title: 'Legacy Diagnostics',
+    title: 'Classic diagnostics',
     itemIds: ['5', '6', '7', '9'],
   },
   {

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

@@ -118,7 +118,8 @@ const buildBlockedCausesSummary = (
   }
   const file = first.file ? ` en ${first.file}` : '';
   const rule = first.ruleId ?? first.code;
-  const suffix = selectedCauses.length > 1 ? ` (+${selectedCauses.length - 1} más)` : '';
+  const remainingCauses = Math.max(0, causes.length - 1);
+  const suffix = remainingCauses > 0 ? ` (+${remainingCauses} más)` : '';
   return `Violación ${rule}${file}${suffix}.`;
 };
 

package/scripts/framework-menu-system-notifications-macos-dialog-payload.ts

@@ -17,14 +17,18 @@ const buildBlockingCausesDetails = (
   if (!causes || causes.length === 0) {
     return null;
   }
+  const total = causes.length;
+  const header = total === 1
+    ? 'Causas bloqueantes: 1'
+    : `Causas bloqueantes: ${total}`;
   return causes
-    .slice(0, 6)
     .map((cause, index) => {
       const rule = cause.ruleId ?? cause.code;
       const file = cause.file ? ` · ${cause.file}` : '';
       const fix = cause.remediation ? ` · Solución: ${cause.remediation}` : '';
       return `${index + 1}. ${rule}${file}. ${cause.message}${fix}`;
     })
+    .reduce((lines, line) => [...lines, line], [header])
     .join('\n');
 };
 

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

@@ -41,6 +41,9 @@ const BLOCKED_REMEDIATION_MAX_LENGTH_BY_VARIANT: Readonly<Record<BlockedRemediat
 const GENERIC_BLOCKED_REMEDIATION =
   'Corrige el bloqueo indicado y vuelve a ejecutar el comando.';
 
+const buildMultipleCausesRemediation = (count: number): string =>
+  `Corrige las ${count} causas bloqueantes listadas arriba, empezando por violaciones AST/skills de codigo cuando existan, y vuelve a ejecutar el gate.`;
+
 const normalizeBlockedRemediation = (value: string): string =>
   normalizeNotificationText(value)
     .replace(/^cómo solucionarlo:\s*/i, '')
@@ -102,6 +105,13 @@ export const resolveBlockedRemediation = (
 ): string => {
   const variant = options?.variant ?? 'dialog';
   const maxLength = BLOCKED_REMEDIATION_MAX_LENGTH_BY_VARIANT[variant];
+  const blockingCausesCount = event.blockingCauses?.length ?? 0;
+  if (blockingCausesCount > 1) {
+    return truncateNotificationText(
+      buildMultipleCausesRemediation(blockingCausesCount),
+      maxLength
+    );
+  }
   const firstCauseWithRemediation = event.blockingCauses?.find(
     (cause) => cause.remediation && cause.remediation.trim().length > 0
   );

package/scripts/framework-menu.ts

@@ -103,7 +103,8 @@ const menu = async (): Promise<void> => {
           }
         }
       }
-      const option = (await rl.question('\nSelect option: ')).trim();
+      const prompt = mode === 'consumer' ? '\nChoose an option: ' : '\nSelect option: ';
+      const option = (await rl.question(prompt)).trim();
       const normalized = option.toUpperCase();
 
       if (mode === 'consumer' && normalized === 'A') {