pumuki 6.3.273 → 6.3.274

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [6.3.274] - 2026-05-18
+
+- Notifications: gate blocks now propagate every blocking cause as `blockingCauses[]`, emit one `[pumuki][blocked-cause]` line per violation with rule, file, reason and fix, and show rule/file/remediation in the macOS dialog without hiding AST skill violations behind tracking or governance.
+
 ## [6.3.273] - 2026-05-18
 
 - Fix `PUMUKI-INC-142` residual hook communication: when PRE_WRITE cannot issue a lease because real gate findings exist, PRE_COMMIT/PRE_PUSH keep failing closed but prioritize the real blocking finding before the lease symptom.

package/core/facts/detectors/text/ios.ts

@@ -1461,6 +1461,22 @@ export const hasSwiftNavigationViewUsage = (source: string): boolean => {
   });
 };
 
+export const hasSwiftNSLayoutConstraintUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'N') {
+      return false;
+    }
+
+    return (
+      hasIdentifierAt(swiftSource, index, 'NSLayoutConstraint') ||
+      hasIdentifierAt(swiftSource, index, 'NSLayoutAnchor') ||
+      hasIdentifierAt(swiftSource, index, 'NSLayoutXAxisAnchor') ||
+      hasIdentifierAt(swiftSource, index, 'NSLayoutYAxisAnchor') ||
+      hasIdentifierAt(swiftSource, index, 'NSLayoutDimension')
+    );
+  });
+};
+
 export const hasSwiftUntypedNavigationLinkDestinationUsage = (source: string): boolean => {
   const swiftSource = sanitizeSwiftSourceForMultilineRegex(source);
   const destinationParameterPattern = /\bNavigationLink\s*\([^)]*\bdestination\s*:/;

package/docs/operations/RELEASE_NOTES.md

@@ -4,6 +4,10 @@ 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.274)
+
+- Notifications now carry all blocking causes instead of a single collapsed cause. Hooks and audit output emit `[pumuki][blocked-cause]` for each violation with code, rule, file, reason and fix; macOS blocked dialogs show rule/file/solution details and no longer hide AST skill violations behind tracking/governance blockers.
+
 ### 2026-05-18 (v6.3.272)
 
 - `PUMUKI-INC-142`: `sdd validate --stage=PRE_WRITE` refreshes evidence with PRE_WRITE semantics before writing the validated-diff lease, avoiding the PRE_COMMIT/PRE_PUSH bootstrap loop that still produced `ENFORCEMENT_GAP_PRE_WRITE_LEASE_MISSING` in real RuralGo commits.

package/integrations/git/runPlatformGate.ts

@@ -833,15 +833,53 @@ const shouldBlockFromFinding = (finding: Finding | undefined): boolean => {
   return finding.blocking !== false;
 };
 
+const isAstRuleFinding = (finding: Finding): boolean => {
+  const ruleId = finding.ruleId.toLowerCase();
+  const source = finding.source?.toLowerCase() ?? '';
+  const matchedBy = finding.matchedBy?.toLowerCase() ?? '';
+  if (ruleId.startsWith('governance.')) {
+    return false;
+  }
+  return (
+    ruleId.startsWith('skills.') ||
+    ruleId.startsWith('heuristics.') ||
+    source.includes('heuristic') ||
+    matchedBy.includes('heuristic') ||
+    matchedBy.includes('ast')
+  );
+};
+
 const resolvePrimaryBlockingFinding = (
   findings: ReadonlyArray<Finding>
 ): Finding | undefined => (
+  findings.find(
+    (finding) =>
+      shouldBlockFromFinding(finding) &&
+      isAstRuleFinding(finding) &&
+      finding.severity === 'CRITICAL'
+  ) ??
+  findings.find(
+    (finding) =>
+      shouldBlockFromFinding(finding) &&
+      isAstRuleFinding(finding) &&
+      finding.severity === 'ERROR'
+  ) ??
+  findings.find((finding) => shouldBlockFromFinding(finding) && isAstRuleFinding(finding)) ??
   findings.find((finding) => shouldBlockFromFinding(finding) && finding.severity === 'CRITICAL') ??
   findings.find((finding) => shouldBlockFromFinding(finding) && finding.severity === 'ERROR') ??
   findings.find((finding) => shouldBlockFromFinding(finding)) ??
   findings[0]
 );
 
+const resolveBlockingNotificationFindings = (
+  findings: ReadonlyArray<Finding>
+): ReadonlyArray<Finding> => {
+  const blockingFindings = findings.filter((finding) => shouldBlockFromFinding(finding));
+  const astFindings = blockingFindings.filter(isAstRuleFinding);
+  const nonAstFindings = blockingFindings.filter((finding) => !isAstRuleFinding(finding));
+  return [...astFindings, ...nonAstFindings];
+};
+
 const applySkillsFindingEnforcement = (
   finding: Finding | undefined
 ): Finding | undefined => {
@@ -1477,7 +1515,9 @@ export async function runPlatformGate(params: {
   });
 
   if (gateOutcome === 'BLOCK') {
-    const primaryBlockingFinding = resolvePrimaryBlockingFinding(findingsWithWaiver);
+    const notificationFindings = resolveBlockingNotificationFindings(findingsWithWaiver);
+    const primaryBlockingFinding =
+      notificationFindings[0] ?? resolvePrimaryBlockingFinding(findingsWithWaiver);
     if (
       primaryBlockingFinding &&
       (
@@ -1495,11 +1535,27 @@ export async function runPlatformGate(params: {
         remediation:
           primaryBlockingFinding.expected_fix ??
           'Corrige la causa bloqueante y reejecuta el gate.',
+        blockingCauses: notificationFindings.map((finding) => ({
+          code: finding.code ?? finding.ruleId,
+          message: finding.message,
+          ruleId: finding.ruleId,
+          file: finding.filePath,
+          remediation: finding.expected_fix,
+        })),
       });
       process.stderr.write(
         `[pumuki][blocked] code=${primaryBlockingFinding.code ?? primaryBlockingFinding.ruleId} ` +
         `stage=${params.policy.stage} reason=${primaryBlockingFinding.message}\n`
       );
+      for (const finding of notificationFindings) {
+        process.stderr.write(
+          `[pumuki][blocked-cause] code=${finding.code ?? finding.ruleId}` +
+          ` rule=${finding.ruleId}` +
+          ` file=${finding.filePath ?? 'n/a'}` +
+          ` reason=${finding.message}` +
+          ` fix=${finding.expected_fix ?? 'Corrige la causa bloqueante y reejecuta el gate.'}\n`
+        );
+      }
       process.stderr.write(
         `[pumuki][notification] delivered=${notificationResult.delivered ? 'yes' : 'no'} ` +
         `reason=${notificationResult.reason}\n`

package/integrations/git/stageRunners.ts

@@ -124,6 +124,13 @@ type StageRunnerDependencies = {
     causeCode: string;
     causeMessage: string;
     remediation: string;
+    blockingCauses?: ReadonlyArray<{
+      code: string;
+      message: string;
+      ruleId?: string;
+      file?: string;
+      remediation?: string;
+    }>;
   }) => void;
   readEvidenceResult: (repoRoot: string) => EvidenceReadResult;
   readEvidence: typeof readEvidence;
@@ -262,6 +269,22 @@ const notifyAuditSummaryForStage = (
 const resolvePrimaryBlockedStageFinding = (
   findings: ReadonlyArray<SnapshotFinding>
 ): SnapshotFinding | undefined => (
+  findings.find((finding) => {
+    const ruleId = finding.ruleId.toLowerCase();
+    const source = finding.source?.toLowerCase() ?? '';
+    const matchedBy = finding.matchedBy?.toLowerCase() ?? '';
+    return (
+      isSeverityAtLeast(finding.severity, 'ERROR') &&
+      !ruleId.startsWith('governance.') &&
+      (
+        ruleId.startsWith('skills.') ||
+        ruleId.startsWith('heuristics.') ||
+        source.includes('heuristic') ||
+        matchedBy.includes('ast') ||
+        matchedBy.includes('heuristic')
+      )
+    );
+  }) ??
   findings.find((finding) => {
     return isSeverityAtLeast(finding.severity, 'ERROR');
   }) ?? findings[0]
@@ -288,6 +311,13 @@ const notifyGateBlockedForStage = (params: {
     BLOCKED_REMEDIATION_BY_CODE[causeCode]
     ?? params.fallbackRemediation
     ?? DEFAULT_BLOCKED_REMEDIATION;
+  const blockingCauses = stageFindings.map((finding) => ({
+    code: finding.code ?? finding.ruleId,
+    message: finding.message,
+    ruleId: finding.ruleId,
+    file: finding.file,
+    remediation: finding.expected_fix,
+  }));
   params.dependencies.notifyGateBlocked({
     repoRoot,
     stage: params.stage,
@@ -297,6 +327,7 @@ const notifyGateBlockedForStage = (params: {
     causeCode,
     causeMessage,
     remediation,
+    blockingCauses,
   });
 };
 

package/integrations/notifications/emitAuditSummaryNotification.ts

@@ -159,6 +159,13 @@ export const emitGateBlockedNotification = (
     causeCode: string;
     causeMessage: string;
     remediation: string;
+    blockingCauses?: ReadonlyArray<{
+      code: string;
+      message: string;
+      ruleId?: string;
+      file?: string;
+      remediation?: string;
+    }>;
   },
   dependencies: Partial<AuditSummaryNotificationDependencies> = {}
 ): SystemNotificationEmitResult => {
@@ -177,6 +184,7 @@ export const emitGateBlockedNotification = (
         causeMessage: params.causeMessage,
       }),
       remediation: params.remediation,
+      blockingCauses: params.blockingCauses,
     },
     repoRoot: params.repoRoot,
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.273",
+  "version": "6.3.274",
   "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-cause.ts

@@ -77,6 +77,51 @@ const resolvePriorityCauseFromMessage = (message?: string): string | null => {
 const isCauseCodePriorityOverTracking = (causeCode: string): boolean =>
   causeCode === 'CONTEXT_NOT_APPLIED' || causeCode === 'CONTEXT_INVALID';
 
+const isAstBlockedCauseCode = (causeCode: string): boolean => {
+  const normalized = causeCode.toLowerCase();
+  return (
+    normalized.startsWith('skills_') ||
+    normalized.startsWith('skills.') ||
+    normalized.startsWith('heuristics_') ||
+    normalized.startsWith('heuristics.') ||
+    normalized.includes('_ast') ||
+    normalized.includes('solid') ||
+    normalized.includes('no_') ||
+    normalized.includes('avoid_')
+  );
+};
+
+const isAstBlockedCause = (
+  cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number]
+): boolean => {
+  const ruleId = cause.ruleId?.toLowerCase() ?? '';
+  const code = cause.code.toLowerCase();
+  return (
+    ruleId.startsWith('skills.') ||
+    ruleId.startsWith('heuristics.') ||
+    isAstBlockedCauseCode(code)
+  );
+};
+
+const buildBlockedCausesSummary = (
+  event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>
+): string | null => {
+  const causes = event.blockingCauses ?? [];
+  if (causes.length === 0) {
+    return null;
+  }
+  const astCauses = causes.filter(isAstBlockedCause);
+  const selectedCauses = astCauses.length > 0 ? astCauses : causes;
+  const first = selectedCauses[0];
+  if (!first) {
+    return null;
+  }
+  const file = first.file ? ` en ${first.file}` : '';
+  const rule = first.ruleId ?? first.code;
+  const suffix = selectedCauses.length > 1 ? ` (+${selectedCauses.length - 1} más)` : '';
+  return `Violación ${rule}${file}${suffix}.`;
+};
+
 const buildGenericSpanishBlockedCauseSummary = (
   event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>,
   causeCode: string
@@ -120,6 +165,10 @@ export const resolveBlockedCauseSummary = (
   event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>,
   causeCode: string
 ): string => {
+  const blockedCausesSummary = buildBlockedCausesSummary(event);
+  if (blockedCausesSummary) {
+    return truncateNotificationText(blockedCausesSummary, 72);
+  }
   const trackingContext = extractNotificationTrackingContext(event.causeMessage);
   const priorityCode = resolvePriorityCauseFromMessage(event.causeMessage);
   if (priorityCode) {

package/scripts/framework-menu-system-notifications-event-types.ts

@@ -1,5 +1,13 @@
 export type PumukiNotificationStage = 'PRE_COMMIT' | 'PRE_PUSH' | 'CI' | 'PRE_WRITE';
 
+export type PumukiBlockedNotificationCause = {
+  code: string;
+  message: string;
+  ruleId?: string;
+  file?: string;
+  remediation?: string;
+};
+
 export type PumukiCriticalNotificationEvent =
   | {
       kind: 'audit.summary';
@@ -14,6 +22,7 @@ export type PumukiCriticalNotificationEvent =
       causeCode?: string;
       causeMessage?: string;
       remediation?: string;
+      blockingCauses?: ReadonlyArray<PumukiBlockedNotificationCause>;
     }
   | {
       kind: 'evidence.stale';

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

@@ -11,13 +11,31 @@ export type BlockedDialogPayload = {
   remediation: string;
 };
 
+const buildBlockingCausesDetails = (
+  causes: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']
+): string | null => {
+  if (!causes || causes.length === 0) {
+    return null;
+  }
+  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}`;
+    })
+    .join('\n');
+};
+
 export const buildBlockedDialogPayload = (params: {
   event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>;
   repoRoot: string;
   env: NodeJS.ProcessEnv;
 }): BlockedDialogPayload => {
   const causeCode = params.event.causeCode ?? 'GATE_BLOCKED';
-  const cause = resolveBlockedCauseSummary(params.event, causeCode);
+  const cause = buildBlockingCausesDetails(params.event.blockingCauses)
+    ?? resolveBlockedCauseSummary(params.event, causeCode);
   const remediation = resolveBlockedRemediation(params.event, causeCode);
   const projectLabel = resolveProjectLabel({
     repoRoot: params.repoRoot,

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

@@ -102,6 +102,15 @@ export const resolveBlockedRemediation = (
 ): string => {
   const variant = options?.variant ?? 'dialog';
   const maxLength = BLOCKED_REMEDIATION_MAX_LENGTH_BY_VARIANT[variant];
+  const firstCauseWithRemediation = event.blockingCauses?.find(
+    (cause) => cause.remediation && cause.remediation.trim().length > 0
+  );
+  if (firstCauseWithRemediation?.remediation) {
+    return truncateNotificationText(
+      normalizeBlockedRemediation(firstCauseWithRemediation.remediation),
+      maxLength
+    );
+  }
   const fromEvent = event.remediation
     ? normalizeBlockedRemediation(event.remediation)
     : '';