pumuki 6.3.314 → 6.3.316

package/integrations/lifecycle/preWriteAutomation.ts

@@ -98,11 +98,23 @@ const PRE_WRITE_FUNCTIONAL_EXTENSIONS = [
   '.kts',
 ] as const;
 
+const PRE_WRITE_RUNTIME_ARTIFACT_PATHS = new Set<string>([
+  '.ai_evidence.json',
+  '.AI_EVIDENCE.json',
+  '.pumuki/artifacts/mcp-ai-gate-receipt.json',
+  '.pumuki/prewrite-lease.json',
+]);
+
 const isFunctionalPath = (filePath: string): boolean => {
   const normalized = filePath.trim().toLowerCase();
   return PRE_WRITE_FUNCTIONAL_EXTENSIONS.some((extension) => normalized.endsWith(extension));
 };
 
+const isRuntimeArtifactPath = (filePath: string): boolean => {
+  const normalized = filePath.trim().replace(/\\/g, '/');
+  return PRE_WRITE_RUNTIME_ARTIFACT_PATHS.has(normalized);
+};
+
 const collectStagedPaths = (repoRoot: string): ReadonlyArray<string> | null => {
   try {
     return execFileSync('git', ['diff', '--cached', '--name-only'], {
@@ -127,7 +139,13 @@ const resolvePreWriteRefreshScope = (aiGate: ReturnType<typeof evaluateAiGate>):
   if (stagedPaths === null || stagedPaths.some(isFunctionalPath)) {
     return { kind: 'staged' };
   }
-  return { kind: 'workingTree' };
+  if (stagedPaths.length === 0) {
+    return { kind: 'workingTree' };
+  }
+  if (stagedPaths.length > 0 && stagedPaths.every(isRuntimeArtifactPath)) {
+    return { kind: 'workingTree' };
+  }
+  return { kind: 'staged' };
 };
 
 export const buildPreWriteAutomationTrace = async (params: {

package/integrations/tdd/enforcement.test.ts

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import type { Fact } from '../../core/facts/Fact';
+import { enforceTddBddPolicy } from './enforcement';
+
+test('enforceTddBddPolicy explica cómo registrar XCTest verde cuando falta VERIFY', () => {
+  const repoRoot = mkdtempSync(join(tmpdir(), 'pumuki-tdd-verify-xctest-'));
+  try {
+    mkdirSync(join(repoRoot, 'features'), { recursive: true });
+    mkdirSync(join(repoRoot, '.pumuki', 'artifacts'), { recursive: true });
+    writeFileSync(join(repoRoot, 'features', 'rgo-1900.feature'), 'Feature: social auth\n', 'utf8');
+    writeFileSync(
+      join(repoRoot, '.pumuki', 'artifacts', 'pumuki-evidence-v1.json'),
+      JSON.stringify({
+        version: '1',
+        generated_at: '2026-05-20T08:00:00.000Z',
+        slices: [
+          {
+            id: 'rgo-1900',
+            scenario_ref: 'features/rgo-1900.feature',
+            red: {
+              status: 'failed',
+              timestamp: '2026-05-20T08:00:00.000Z',
+              test_ref: 'RuralGoMacTests/BuyerAppViewModelAuthTests',
+            },
+            green: {
+              status: 'passed',
+              timestamp: '2026-05-20T08:10:00.000Z',
+              test_ref: 'RuralGoMacTests/BuyerAppViewModelAuthTests',
+            },
+            refactor: {
+              status: 'passed',
+              timestamp: '2026-05-20T08:20:00.000Z',
+              test_ref: 'RuralGoMacTests/BuyerCommerceScreensSnapshotTests/test_checkoutSnapshot_matchesReference',
+            },
+          },
+        ],
+      }),
+      'utf8'
+    );
+    const facts: ReadonlyArray<Fact> = [
+      {
+        kind: 'FileChange',
+        path: 'apps/ios/Presentation/Features/BuyerCommerce/BuyerAuthScreen.swift',
+        changeType: 'modified',
+        source: 'git:staged',
+      },
+      {
+        kind: 'FileContent',
+        path: 'apps/ios/Presentation/Features/BuyerCommerce/BuyerAuthScreen.swift',
+        content: 'public struct BuyerAuthScreen {}',
+        source: 'git:staged',
+      },
+    ];
+
+    const result = enforceTddBddPolicy({
+      facts,
+      repoRoot,
+      branch: 'feature/rgo-1900-02-checkout-pixel-perfect',
+    });
+
+    const finding = result.findings.find(
+      (item) => item.code === 'GOLDEN_FLOW_VERIFY_EVIDENCE_MISSING'
+    );
+    assert.ok(finding);
+    assert.match(finding.message, /missing=\[verify\.status=passed\]/);
+    assert.match(finding.message, /BuyerCommerceScreensSnapshotTests/);
+    assert.match(finding.expected_fix ?? '', /pumuki sdd evidence/);
+    assert.match(finding.expected_fix ?? '', /--test-status=passed/);
+    assert.match(finding.expected_fix ?? '', /commit atómico/);
+  } finally {
+    rmSync(repoRoot, { recursive: true, force: true });
+  }
+});

package/integrations/tdd/enforcement.ts

@@ -19,6 +19,7 @@ const buildFinding = (params: {
   severity?: Finding['severity'];
   filePath?: string;
   source?: string;
+  expected_fix?: string;
 }): Finding => {
   return {
     ruleId: params.ruleId,
@@ -28,6 +29,7 @@ const buildFinding = (params: {
     filePath: params.filePath,
     matchedBy: 'TddBddEnforcer',
     source: params.source ?? 'tdd-bdd-contract',
+    expected_fix: params.expected_fix,
   };
 };
 
@@ -301,8 +303,14 @@ export const enforceTddBddPolicy = (params: {
         buildFinding({
           ruleId: 'generic_golden_flow_verify_required',
           code: 'GOLDEN_FLOW_VERIFY_EVIDENCE_MISSING',
-          message: `Slice ${slice.id} must include VERIFY passing evidence after REFACTOR.`,
+          message:
+            `Slice ${slice.id} is missing final test verification after REFACTOR. ` +
+            `missing=[verify.status=passed] test_ref=${slice.refactor.test_ref ?? slice.green.test_ref ?? 'unregistered'}`,
           filePath: evidenceRead.path,
+          expected_fix:
+            `Si el test/build ya pasó, informa a Pumuki del resultado real con: ` +
+            `npx pumuki sdd evidence --scenario-id=${slice.id} --test-command="<comando XCTest/build ejecutado>" --test-status=passed. ` +
+            `Después haz un commit atómico del slice.`,
         })
       );
     } else {
@@ -310,13 +318,18 @@ export const enforceTddBddPolicy = (params: {
       if (slice.verify.status !== 'passed') {
         sliceFindings.push(
           buildFinding({
-            ruleId: 'generic_golden_flow_verify_required',
-            code: 'GOLDEN_FLOW_VERIFY_MUST_PASS',
-            message: `Slice ${slice.id} must finish with VERIFY passing evidence.`,
-            filePath: evidenceRead.path,
-          })
-        );
-      }
+          ruleId: 'generic_golden_flow_verify_required',
+          code: 'GOLDEN_FLOW_VERIFY_MUST_PASS',
+          message:
+            `Slice ${slice.id} has final test verification but it is not green. ` +
+            `missing=[verify.status=passed] test_ref=${slice.verify.test_ref ?? 'unregistered'}`,
+          filePath: evidenceRead.path,
+          expected_fix:
+            `Corrige el fallo del test/build final y vuelve a informar a Pumuki con ` +
+            `npx pumuki sdd evidence --scenario-id=${slice.id} --test-command="<comando XCTest/build ejecutado>" --test-status=passed.`,
+        })
+      );
+    }
     }
 
     if (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.314",
+  "version": "6.3.316",
   "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-macos-dialog-payload.ts

@@ -60,6 +60,32 @@ const stripTechnicalFieldsFromMessage = (message: string): string => {
     .trim();
 };
 
+const localizeDeveloperText = (value: string): string => {
+  const normalized = normalizeNotificationText(value);
+  const knownTexts: ReadonlyArray<[RegExp, string]> = [
+    [/Disallow empty catch blocks in backend runtime code\./iu, 'Catch vacío en código backend runtime.'],
+    [/Action handlers should reference methods, not contain inline logic/iu, 'El handler contiene lógica inline; debe llamar a un método o comando del view model.'],
+    [/Ensure constant number of views per ForEach element/iu, 'Cada elemento de ForEach debe devolver una estructura de vistas estable.'],
+    [/Ensure ForEach uses stable identity/iu, 'ForEach debe usar una identidad estable.'],
+    [/Prefer modifiers over conditional views for state changes/iu, 'Para cambios de estado, usa modificadores en vez de cambiar la identidad de la vista.'],
+    [/Prefer static member lookup \(\.blue vs Color\.blue\)/iu, 'Usa colores semánticos o static member lookup en SwiftUI.'],
+    [/LazyVStack\/LazyHStack - Para listas grandes/iu, 'Las listas grandes deben renderizarse con LazyVStack o LazyHStack.'],
+    [/navigationDestination \(for:\) - Destinos tipados/iu, 'La navegación debe usar navigationDestination(for:) con destinos tipados.'],
+    [/Extract the action body to a named method or view model command and reference that method from Button\./iu, 'Extrae la acción a un método con nombre o comando del view model y referencia ese método desde Button.'],
+    [/Move branching into a dedicated row view or prefer conditional modifiers\/values that keep a stable view structure per element\./iu, 'Mueve la ramificación a una fila dedicada o usa modificadores condicionales que mantengan estable la estructura de vistas por elemento.'],
+    [/Use Identifiable models or an explicit stable domain identifier such as id: \\.id\./iu, 'Usa modelos Identifiable o un identificador estable del dominio, por ejemplo id: \\.id.'],
+    [/Keep one view instance and move the condition into modifiers, parameters or extracted stable row state\./iu, 'Mantén una única instancia de vista y mueve la condición a modificadores, parámetros o estado estable extraído.'],
+    [/Replace Color\.blue\/Color\.primary\/etc\. with \.blue\/\.primary in SwiftUI style contexts, or use named asset colors such as Color\("BrandPrimary"\) when design tokens are required\./iu, 'Sustituye Color.blue/Color.primary por .blue/.primary en contextos SwiftUI, o usa colores semánticos del design system cuando aplique.'],
+    [/Replace VStack\/HStack under ScrollView with LazyVStack\/LazyHStack when rendering collection rows\./iu, 'Sustituye VStack/HStack dentro de ScrollView por LazyVStack/LazyHStack al renderizar colecciones.'],
+  ];
+  for (const [pattern, replacement] of knownTexts) {
+    if (pattern.test(normalized)) {
+      return replacement;
+    }
+  }
+  return normalized;
+};
+
 const extractFieldFromCauseMessage = (message: string, field: string): string | null => {
   const escapedField = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const match = message.match(new RegExp(`\\b${escapedField}=([^\\n]+?)(?=\\s(?:severity|code|rule|file|lines?|message|remediation|snippet|node|primary_node|missing)=|$)`, 'i'));
@@ -104,15 +130,22 @@ const formatLocation = (cause: NonNullable<Extract<PumukiCriticalNotificationEve
 
 const humanizeRuleId = (ruleId: string): string => {
   const knownRules: Record<string, string> = {
+    'no-empty-catch': 'catch vacío',
     'prefer-swift-testing': 'Swift Testing',
     'no-xctassert': 'XCTest assertions',
     'no-wait-for-expectations': 'waitForExpectations en XCTest',
     'ios-test-quality': 'calidad de tests iOS',
+    'action-handlers-should-reference-methods-not-contain-inline-logic': 'handlers SwiftUI sin lógica inline',
+    'ensure-constant-number-of-views-per-foreach-element': 'estructura estable en ForEach',
+    'ensure-foreach-uses-stable-identity-see-references-list-patterns-md': 'identidad estable en ForEach',
+    'prefer-modifiers-over-conditional-views-for-state-changes': 'modificadores para cambios de estado',
     'dynamic-type-font-scaling-automatico': 'Dynamic Type',
     'dynamic-type-fuentes-escalables-y-layouts-adaptativos': 'fuentes escalables y layouts adaptativos',
     'use-relative-layout-over-hard-coded-constants': 'layout relativo en vez de constantes fijas',
     'magic-numbers-usar-constantes-con-nombres': 'números mágicos sin constantes con nombre',
     'prefer-static-member-lookup-blue-vs-color-blue': 'colores semánticos en SwiftUI',
+    'use-lazyvstack-lazyhstack-for-large-lists': 'LazyVStack/LazyHStack para listas grandes',
+    'use-navigationdestination-for-type-safe-navigation': 'navigationDestination type-safe',
   };
   const normalized = ruleId
     .replace(/^skills\./u, '')
@@ -194,7 +227,7 @@ const formatGoldenFlowMissing = (message: string): string => {
   return missing.toLowerCase();
 };
 
-const formatGoldenFlowRemediation = (message: string): string => {
+const formatGoldenFlowRemediation = (message: string, remediation?: string): string => {
   const missing = normalizeGoldenFlowMissingToken(message);
   if (missing.includes('RED')) {
     return 'Implementa la fase RED antes de continuar. Las fases del ciclo TDD (RED, GREEN, REFACTOR) deben completarse para desbloquear.';
@@ -206,7 +239,7 @@ const formatGoldenFlowRemediation = (message: string): string => {
     return 'Implementa la fase REFACTOR antes de continuar. Limpia la solución manteniendo los tests en verde.';
   }
   if (missing.includes('VERIFY')) {
-    return GOLDEN_FLOW_REMEDIATION;
+    return remediation ? localizeDeveloperText(remediation) : GOLDEN_FLOW_REMEDIATION;
   }
   return 'Completa el ciclo TDD en orden: RED, GREEN, REFACTOR y tests finales en verde antes del commit.';
 };
@@ -218,13 +251,13 @@ const formatBlockingCauseForDialog = (
 ): readonly string[] => {
   const rule = cause.ruleId ?? cause.code;
   const visibleRule = formatVisibleRule(cause);
-  const problem = stripTechnicalFieldsFromMessage(cause.message) || cause.code;
+  const problem = localizeDeveloperText(stripTechnicalFieldsFromMessage(cause.message) || cause.code);
   const remediation = isGoldenFlowCause(cause)
     ? GOLDEN_FLOW_REMEDIATION
     : isWorktreeHygieneCause(cause)
     ? WORKTREE_HYGIENE_REMEDIATION
     : cause.remediation
-    ? normalizeNotificationText(cause.remediation)
+    ? localizeDeveloperText(cause.remediation)
     : 'Corrige la violación indicada y vuelve a intentar el commit.';
   if (isWorktreeHygieneCause(cause)) {
     return [
@@ -246,7 +279,7 @@ const formatBlockingCauseForDialog = (
   return [
     `${index + 1}. ${causeLabel}: ${truncateNotificationText(visibleRule, 96)}`,
     `   Fichero: ${truncateNotificationText(formatLocation(cause), 120)}`,
-    `   Viola: ${truncateNotificationText(problem, 160)}`,
+    `   Falla: ${truncateNotificationText(problem, 160)}`,
     buildEvidenceLine(cause),
     `   Solución: ${truncateNotificationText(remediation, 180)}`,
   ].filter((line): line is string => typeof line === 'string');
@@ -266,7 +299,7 @@ const resolveGoldenFlowDialogRemediation = (
   causes: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']
 ): string => {
   const first = causes?.find(isGoldenFlowCause);
-  return first ? formatGoldenFlowRemediation(first.message) : GOLDEN_FLOW_REMEDIATION;
+  return first ? formatGoldenFlowRemediation(first.message, first.remediation) : GOLDEN_FLOW_REMEDIATION;
 };
 
 export const buildBlockedDialogPayload = (params: {

package/scripts/framework-menu-system-notifications-macos-swift-source.ts

@@ -41,8 +41,30 @@ final class DialogAppDelegate: NSObject, NSApplicationDelegate {
 
     let alert = NSAlert()
     alert.messageText = config.title
-    alert.informativeText = "Causa: \(config.cause)\n\nSolución: \(config.remediation)"
+    alert.informativeText = "Revisa el detalle del bloqueo. Puedes seleccionar y copiar el texto."
     alert.alertStyle = .critical
+
+    let details = "Causa:\n\(config.cause)\n\nSolución:\n\(config.remediation)"
+    let scrollView = NSScrollView(frame: NSRect(x: 0, y: 0, width: 560, height: 420))
+    scrollView.hasVerticalScroller = true
+    scrollView.hasHorizontalScroller = false
+    scrollView.borderType = .bezelBorder
+
+    let textView = NSTextView(frame: scrollView.contentView.bounds)
+    textView.string = details
+    textView.isEditable = false
+    textView.isSelectable = true
+    textView.drawsBackground = false
+    textView.font = NSFont.monospacedSystemFont(ofSize: 12, weight: .regular)
+    textView.textContainerInset = NSSize(width: 8, height: 8)
+    textView.textContainer?.widthTracksTextView = true
+    textView.textContainer?.containerSize = NSSize(width: scrollView.contentSize.width, height: CGFloat.greatestFiniteMagnitude)
+    textView.isVerticallyResizable = true
+    textView.isHorizontallyResizable = false
+    textView.autoresizingMask = [.width]
+    scrollView.documentView = textView
+    alert.accessoryView = scrollView
+
     alert.addButton(withTitle: config.keepButton)
     alert.addButton(withTitle: config.muteButton)
     alert.addButton(withTitle: config.disableButton)

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

@@ -55,7 +55,9 @@ const formatGoldenFlowBannerRemediation = (cause: BlockedCause): string => {
     return 'Implementa la fase REFACTOR antes de continuar. Limpia la solución manteniendo los tests en verde.';
   }
   if (missing.includes('VERIFY')) {
-    return 'Ejecuta los tests de la implementación. Si están en verde, haz un commit atómico de los cambios.';
+    return cause.remediation
+      ? normalizeNotificationText(cause.remediation)
+      : 'Ejecuta los tests de la implementación. Si están en verde, haz un commit atómico de los cambios.';
   }
   return 'Completa el ciclo TDD en orden: RED, GREEN, REFACTOR y tests finales en verde antes del commit.';
 };