pumuki 6.3.315 → 6.3.317

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.315",
+  "version": "6.3.317",
   "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

@@ -227,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.';
@@ -239,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.';
 };
@@ -299,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-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.';
 };
@@ -143,7 +145,7 @@ const formatCauseProblem = (cause: BlockedCause): string => {
 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.'
+    'Corrige la violación indicada con regla, fichero y línea, y vuelve a intentar el commit.'
   );
 
 export const resolvePrioritizedBlockingCauses = (
@@ -204,7 +206,7 @@ const buildBlockingCausesRemediation = (
     return [
       `Regla: ${formatVisibleRule(first)}.`,
       `Fichero: ${formatCauseLocation(first)}.`,
-      `Viola: ${formatCauseProblem(first)}.`,
+      `Falla: ${formatCauseProblem(first)}.`,
       `Solución: ${formatCauseFix(first)}.`,
       prioritized.length > 1 ? `Quedan ${prioritized.length - 1} causa(s) más en el reporte completo.` : '',
     ]

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

@@ -21,9 +21,9 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_REPO_ROOT_MISMATCH: 'Regenera la evidencia desde este repositorio y vuelve a validar.',
   PRE_PUSH_UPSTREAM_MISSING: 'Configura upstream con `git push --set-upstream origin <branch>` y repite PRE_PUSH.',
   SDD_SESSION_MISSING:
-    'Abre una sesión SDD válida para el change activo (`pumuki sdd session --open --change=<id>`) y reejecuta PRE_WRITE. Agente IA: STOP hasta que exista esa sesión.',
+    'Abre la sesión SDD del cambio activo: `pumuki sdd session --open --change=<id>`. Sustituye <id> por la carpeta en openspec/changes. Después vuelve a intentar el commit; Pumuki ejecutará PRE_WRITE automáticamente.',
   SDD_SESSION_INVALID:
-    'Refresca la sesión SDD activa (`pumuki sdd session --refresh --ttl-minutes=90`) y reejecuta PRE_WRITE. Agente IA: STOP hasta que sea válida.',
+    'Refresca la sesión SDD activa: `pumuki sdd session --refresh --ttl-minutes=90`. Después vuelve a intentar el commit; Pumuki ejecutará PRE_WRITE automáticamente.',
   OPENSPEC_MISSING: 'Instala OpenSpec en este repositorio y vuelve a validar el gate.',
   MCP_ENTERPRISE_RECEIPT_MISSING: 'Genera el receipt enterprise de MCP y vuelve a validar.',
   BACKEND_AVOID_EXPLICIT_ANY: 'Sustituye `any` por tipos concretos en backend y relanza el gate.',
@@ -34,7 +34,7 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
   ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES_HIGH:
     'Ejecuta `pumuki policy reconcile --strict --json` y revalida antes de continuar.',
   EVIDENCE_PREWRITE_WORKTREE_WARN:
-    'Reduce el worktree pendiente a un slice atómico antes del commit: stagea solo la tarea activa o guarda el resto en stash nombrado, y reejecuta PRE_WRITE.',
+    'Reduce el worktree pendiente a un slice atómico antes del commit: stagea solo la tarea activa o guarda el resto en stash nombrado, y vuelve a intentar el commit.',
   EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT:
     'El worktree supera el límite permitido: divide cambios por scope en commits atómicos o stashes nombrados antes de continuar.',
 };