pumuki 6.3.311 → 6.3.312

package/AGENTS.md

@@ -159,6 +159,10 @@ Antes de realizar cualquier accion:
   - crear commits atomicos separados o stashes con nombre explicito antes de continuar,
   - no usar un commit masivo para "limpiar" el estado.
 - Antes de cada commit:
+  - confirmar RED registrado o justificar que es cambio documental puro;
+  - confirmar GREEN con test focal ejecutado;
+  - confirmar REFACTOR acotado y gobernado por las skills aplicables;
+  - confirmar VERIFY con typecheck/compilacion/build aplicable;
   - revisar `git diff --cached --name-status`,
   - confirmar que todos los archivos staged pertenecen a la misma intencion,
   - dejar fuera del stage cualquier archivo no relacionado,
@@ -174,9 +178,28 @@ Antes de realizar cualquier accion:
   - preservar cambios en commit o stash con nombre explicito,
   - y reportar la evidencia.
 
+## Golden Flow TDD / Red-Green-Refactor (flujo principal no negociable)
+- Pumuki es primero un orquestador de flujo seguro de ingenieria: las skills son reglas de calidad dentro de este flujo, no sustituyen el flujo.
+- Todo cambio funcional, bugfix de gate/lifecycle, detector AST/nodal, notificacion, hook, policy o codigo de producto debe seguir obligatoriamente:
+  1. `RED`: crear o actualizar primero un test/regresion que falle por el bug o comportamiento esperado.
+  2. `GREEN`: tocar el minimo codigo de produccion necesario para hacer pasar ese test.
+  3. `REFACTOR`: limpiar solo dentro del alcance de la slice, sin cambiar comportamiento.
+  4. `VERIFY`: ejecutar test focal y compilacion/typecheck/build aplicable.
+  5. `COMMIT ATOMICO`: cerrar una unica intencion funcional o tecnica.
+- La fase `REFACTOR` debe aplicar las skills de plataforma correspondientes:
+  - iOS/Swift/SwiftUI: `ios-enterprise-rules`, `swift-concurrency`, `swiftui-expert-skill`; y `swift-testing-expert`, `core-data-expert` o skills Apple adicionales cuando aplique.
+  - Android: `android-enterprise-rules`.
+  - Frontend: `frontend-enterprise-rules`.
+  - Backend: `backend-enterprise-rules`.
+- Esta prohibido commitear codigo funcional sin test focal ejecutado y verde.
+- Esta prohibido publicar release o repinear consumers si el test focal, typecheck o build aplicable fallan.
+- Si no es tecnicamente posible escribir RED antes de tocar produccion, declarar `STATUS: BLOCKED` o documentar una excepcion explicita y trazable antes de continuar.
+- Cambios documentales puros pueden omitir RED, pero deben mantener diff acotado, trazabilidad y commit atomico.
+
 ## Gate operativo obligatorio (antes de editar codigo)
 - Declarar internamente las skills aplicables y tratarlas como activas durante TODO el turno.
 - Verificar cumplimiento minimo previo:
+  - Golden Flow TDD `RED -> GREEN -> REFACTOR -> VERIFY -> COMMIT ATOMICO` requerido para todo cambio funcional.
   - BDD/TDD requerido por la skill correspondiente.
   - Concurrencia y aislamiento segun `swift-concurrency` cuando haya codigo Swift.
   - Estado/arquitectura/UI segun `swiftui-expert-skill` e `ios-enterprise-rules` cuando aplique iOS/SwiftUI.

package/integrations/sdd/evidenceScaffold.ts

@@ -39,6 +39,10 @@ export type SddEvidenceScaffoldResult = {
         status: SddEvidenceScaffoldTestStatus;
         timestamp: string;
       };
+      verify: {
+        status: SddEvidenceScaffoldTestStatus;
+        timestamp: string;
+      };
     }>;
     metadata: {
       source: 'pumuki-sdd-evidence';
@@ -226,6 +230,10 @@ export const runSddEvidenceScaffold = (params?: {
           status: testStatus,
           timestamp: generatedAt,
         },
+        verify: {
+          status: testStatus,
+          timestamp: generatedAt,
+        },
       },
     ],
     metadata: {

package/integrations/tdd/contract.ts

@@ -17,6 +17,7 @@ const tddSliceSchema = z.object({
   red: tddEventSchema,
   green: tddEventSchema,
   refactor: tddEventSchema,
+  verify: tddEventSchema.optional(),
 });
 
 const tddIntegritySchema = z.object({

package/integrations/tdd/enforcement.ts

@@ -96,15 +96,21 @@ export const enforceTddBddPolicy = (params: {
         public_interface_files: scope.metrics.publicInterfaceFiles,
       },
     },
-    evidence: {
-      path: '',
-      state: 'not_required',
-      slices_total: 0,
-      slices_valid: 0,
-      slices_invalid: 0,
-      integrity_ok: true,
-      errors: [],
-    },
+      evidence: {
+        path: '',
+        state: 'not_required',
+        slices_total: 0,
+        slices_valid: 0,
+        slices_invalid: 0,
+        integrity_ok: true,
+        errors: [],
+        phases: {
+          red: 'missing',
+          green: 'missing',
+          refactor: 'missing',
+          verify: 'missing',
+        },
+      },
     waiver: {
       applied: false,
     },
@@ -163,7 +169,7 @@ export const enforceTddBddPolicy = (params: {
       ruleId: 'generic_evidence_integrity_required',
       code: 'TDD_BDD_EVIDENCE_MISSING',
       message:
-        'TDD/BDD evidence contract is required for new/complex changes and was not found.',
+        'Golden Flow evidence is required for functional code changes and was not found. Required phases: RED failed, GREEN passed, REFACTOR passed, VERIFY passed.',
       filePath: evidenceRead.path,
     });
     return {
@@ -207,6 +213,12 @@ export const enforceTddBddPolicy = (params: {
   const sliceFindings: Finding[] = [];
   const seenSliceIds = new Set<string>();
   let validSlices = 0;
+  const phaseState: NonNullable<TddBddSnapshot['evidence']['phases']> = {
+    red: 'missing',
+    green: 'missing',
+    refactor: 'missing',
+    verify: 'missing',
+  };
 
   if (evidenceRead.evidence.slices.length === 0) {
     sliceFindings.push(
@@ -258,6 +270,7 @@ export const enforceTddBddPolicy = (params: {
     }
 
     if (slice.red.status !== 'failed') {
+      phaseState.red = slice.red.status;
       sliceFindings.push(
         buildFinding({
           ruleId: 'generic_tdd_vertical_required',
@@ -266,8 +279,12 @@ export const enforceTddBddPolicy = (params: {
           filePath: evidenceRead.path,
         })
       );
+    } else {
+      phaseState.red = 'failed';
     }
 
+    phaseState.green = slice.green.status;
+    phaseState.refactor = slice.refactor.status;
     if (slice.green.status !== 'passed' || slice.refactor.status !== 'passed') {
       sliceFindings.push(
         buildFinding({
@@ -279,18 +296,42 @@ export const enforceTddBddPolicy = (params: {
       );
     }
 
+    if (!slice.verify) {
+      sliceFindings.push(
+        buildFinding({
+          ruleId: 'generic_golden_flow_verify_required',
+          code: 'GOLDEN_FLOW_VERIFY_EVIDENCE_MISSING',
+          message: `Slice ${slice.id} must include VERIFY passing evidence after REFACTOR.`,
+          filePath: evidenceRead.path,
+        })
+      );
+    } else {
+      phaseState.verify = slice.verify.status;
+      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,
+          })
+        );
+      }
+    }
+
     if (
       !isTimelineOrdered([
         slice.red.timestamp,
         slice.green.timestamp,
         slice.refactor.timestamp,
+        slice.verify?.timestamp,
       ])
     ) {
       sliceFindings.push(
         buildFinding({
           ruleId: 'generic_red_green_refactor_enforced',
           code: 'TDD_PHASE_TIMELINE_INVALID',
-          message: `Slice ${slice.id} has invalid RED->GREEN->REFACTOR timestamp ordering.`,
+          message: `Slice ${slice.id} has invalid RED->GREEN->REFACTOR->VERIFY timestamp ordering.`,
           filePath: evidenceRead.path,
         })
       );
@@ -320,6 +361,7 @@ export const enforceTddBddPolicy = (params: {
         slices_invalid: invalidSlices,
         integrity_ok: evidenceRead.integrity.valid,
         errors: sliceFindings.map((finding) => finding.code),
+        phases: phaseState,
       },
       waiver: {
         applied: false,

package/integrations/tdd/scope.ts

@@ -154,6 +154,9 @@ export const classifyTddBddScope = (
   }
 
   const reasons: string[] = [];
+  if (changedImplementationPaths.size > 0) {
+    reasons.push('functional.implementation_changed');
+  }
   if (changedImplementationPaths.size > thresholds.maxChangedFiles) {
     reasons.push('complex.changed_files_threshold');
   }
@@ -168,9 +171,9 @@ export const classifyTddBddScope = (
   }
 
   const isNewFeature = addedImplementationPaths.size > 0;
-  const isComplexChange = reasons.length > 0;
+  const isComplexChange = reasons.some((reason) => reason.startsWith('complex.'));
   return {
-    inScope: isNewFeature || isComplexChange,
+    inScope: changedImplementationPaths.size > 0,
     isNewFeature,
     isComplexChange,
     reasons,

package/integrations/tdd/types.ts

@@ -21,6 +21,12 @@ export type TddBddSnapshot = {
     slices_invalid: number;
     integrity_ok: boolean;
     errors: string[];
+    phases?: {
+      red: 'missing' | 'passed' | 'failed';
+      green: 'missing' | 'passed' | 'failed';
+      refactor: 'missing' | 'passed' | 'failed';
+      verify: 'missing' | 'passed' | 'failed';
+    };
   };
   waiver: {
     applied: boolean;

package/package.json

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

@@ -27,7 +27,10 @@ const buildBlockingCausesDetails = (
     ? 'Causas bloqueantes: 1'
     : `Causas bloqueantes: ${total}`;
   return resolvePrioritizedBlockingCauses(causes)
-    .flatMap((cause, index) => formatBlockingCauseForDialog(cause, index))
+    .flatMap((cause, index) => {
+      const formatted = formatBlockingCauseForDialog(cause, index);
+      return index === 0 ? formatted : ['', ...formatted];
+    })
     .reduce((lines, line) => [...lines, line], [header])
     .join('\n');
 };
@@ -53,6 +56,40 @@ const stripTechnicalFieldsFromMessage = (message: string): string => {
     .trim();
 };
 
+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'));
+  const value = match?.[1]?.trim();
+  return value && value.length > 0 ? normalizeNotificationText(value) : null;
+};
+
+const extractSnippetFromCauseMessage = (message: string): string | null =>
+  extractFieldFromCauseMessage(message, 'snippet') ??
+  extractFieldFromCauseMessage(message, 'node') ??
+  extractFieldFromCauseMessage(message, 'primary_node');
+
+const extractMissingContractFromCauseMessage = (message: string): string | null => {
+  const missing = extractFieldFromCauseMessage(message, 'missing')?.replace(/\]\]$/u, ']');
+  if (!missing) {
+    return null;
+  }
+  return `Falta: ${missing}`;
+};
+
+const buildEvidenceLine = (
+  cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number]
+): string | null => {
+  const snippet = extractSnippetFromCauseMessage(cause.message);
+  if (snippet) {
+    return `   Evidencia: ${truncateNotificationText(snippet, 160)}`;
+  }
+  const missing = extractMissingContractFromCauseMessage(cause.message);
+  if (missing) {
+    return `   Evidencia: ${truncateNotificationText(missing, 160)}`;
+  }
+  return null;
+};
+
 const formatLocation = (cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number]): string => {
   if (!cause.file) {
     return 'sin fichero';
@@ -95,8 +132,9 @@ const formatBlockingCauseForDialog = (
     `${index + 1}. Regla: ${truncateNotificationText(rule, 96)}`,
     `   Fichero: ${truncateNotificationText(formatLocation(cause), 120)}`,
     `   Viola: ${truncateNotificationText(problem, 160)}`,
+    buildEvidenceLine(cause),
     `   Solución: ${truncateNotificationText(remediation, 180)}`,
-  ];
+  ].filter((line): line is string => typeof line === 'string');
 };
 
 const hasOnlyWorktreeHygieneCauses = (

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

@@ -4,7 +4,10 @@ import type {
 } from './framework-menu-system-notifications-types';
 import { resolveBlockedCauseSummary } from './framework-menu-system-notifications-cause';
 import { resolveBlockedRemediation } from './framework-menu-system-notifications-remediation';
-import { truncateNotificationText } from './framework-menu-system-notifications-text';
+import {
+  normalizeNotificationText,
+  truncateNotificationText,
+} from './framework-menu-system-notifications-text';
 
 export {
   resolveBlockedCauseSummary,
@@ -37,6 +40,39 @@ const formatCauseLocation = (cause: BlockedCause): string => {
 
 const formatCauseRule = (cause: BlockedCause): string => cause.ruleId ?? cause.code;
 
+const extractMessageField = (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'));
+  const value = match?.[1]?.trim();
+  return value && value.length > 0 ? normalizeNotificationText(value) : null;
+};
+
+const stripTechnicalFieldsFromMessage = (message: string): string =>
+  normalizeNotificationText(message)
+    .replace(/\bseverity=[A-Z]+\b/gi, '')
+    .replace(/\bcode=[A-Z0-9_]+\b/gi, '')
+    .replace(/\brule=[^\s]+/gi, '')
+    .replace(/\bfile=[^\s]+/gi, '')
+    .replace(/\blines?=[0-9][0-9,\-\s]*/gi, '')
+    .replace(/\bmessage=/gi, '')
+    .replace(/\bremediation=/gi, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+const formatCauseProblem = (cause: BlockedCause): string => {
+  const messageField = extractMessageField(cause.message, 'message');
+  if (messageField) {
+    return messageField;
+  }
+  return stripTechnicalFieldsFromMessage(cause.message) || cause.code;
+};
+
+const formatCauseFix = (cause: BlockedCause): string =>
+  normalizeNotificationText(
+    cause.remediation ??
+    'Corrige la violación indicada con regla, fichero y línea, y vuelve a ejecutar el gate.'
+  );
+
 export const resolvePrioritizedBlockingCauses = (
   causes: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']
 ): ReadonlyArray<BlockedCause> => {
@@ -66,6 +102,9 @@ const buildBlockingCausesSummary = (
   }
   const prefix = isSkillCause(first) ? 'Skill violada' : 'Causa bloqueante';
   const overflow = prioritized.length > 1 ? ` (+${prioritized.length - 1} más)` : '';
+  if (isSkillCause(first)) {
+    return `${prefix}: ${formatCauseLocation(first)} · ${formatCauseRule(first)}${overflow}`;
+  }
   return `${prefix}: ${formatCauseRule(first)} · ${formatCauseLocation(first)}${overflow}`;
 };
 
@@ -80,10 +119,18 @@ const buildBlockingCausesRemediation = (
   if (!first) {
     return null;
   }
-  const remediation =
-    first.remediation ??
-    'Corrige la violación indicada con regla, fichero y línea, y vuelve a ejecutar el gate.';
-  return `${remediation} Revisa el reporte completo para el resto de causas bloqueantes.`;
+  if (isSkillCause(first)) {
+    return [
+      `Regla: ${formatCauseRule(first)}.`,
+      `Fichero: ${formatCauseLocation(first)}.`,
+      `Viola: ${formatCauseProblem(first)}.`,
+      `Solución: ${formatCauseFix(first)}.`,
+      prioritized.length > 1 ? `Quedan ${prioritized.length - 1} causa(s) más en el reporte completo.` : '',
+    ]
+      .filter((line) => line.length > 0)
+      .join(' ');
+  }
+  return `${formatCauseFix(first)} Revisa el reporte completo para el resto de causas bloqueantes.`;
 };
 
 export const buildGateBlockedPayload = (