pumuki 6.3.144 → 6.3.146

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

@@ -532,6 +532,23 @@ let text = "XCTAssertEqual(value, expected)"
   assert.equal(hasSwiftXCTestAssertionUsage(ignored), false);
 });
 
+test('hasSwiftXCTestAssertionUsage excluye XCTest compatible con UI automation', () => {
+  const uiSource = `
+import XCTest
+
+final class BuyerCommerceUISmokeTests: XCTestCase {
+  func test_buyer_flow() {
+    let app = XCUIApplication()
+    app.launch()
+    XCTAssertTrue(app.buttons["Comprar"].exists)
+  }
+}
+`;
+
+  assert.equal(hasSwiftXCTestAssertionUsage(uiSource), false);
+  assert.equal(hasSwiftXCTUnwrapUsage(`${uiSource}\nlet value = try XCTUnwrap(optional)`), false);
+});
+
 test('hasSwiftXCTUnwrapUsage detecta XCTUnwrap real y evita strings', () => {
   const source = `
 let value = try XCTUnwrap(optionalValue)

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

@@ -767,6 +767,10 @@ export const hasSwiftMixedTestingFrameworksUsage = (source: string): boolean =>
 };
 
 export const hasSwiftXCTestAssertionUsage = (source: string): boolean => {
+  if (hasSwiftLegacyXCTestUiOrPerformanceUsage(source)) {
+    return false;
+  }
+
   return (
     collectSwiftRegexLines(source, /\bXCTAssert[A-Za-z0-9_]*\s*\(/).length > 0 ||
     collectSwiftRegexLines(source, /\bXCTFail\s*\(/).length > 0
@@ -774,6 +778,10 @@ export const hasSwiftXCTestAssertionUsage = (source: string): boolean => {
 };
 
 export const hasSwiftXCTUnwrapUsage = (source: string): boolean => {
+  if (hasSwiftLegacyXCTestUiOrPerformanceUsage(source)) {
+    return false;
+  }
+
   return collectSwiftRegexLines(source, /\bXCTUnwrap\s*\(/).length > 0;
 };
 

package/docs/operations/RELEASE_NOTES.md

@@ -4,6 +4,12 @@ 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-05 (v6.3.145)
+
+- **RuralGo PUMUKI-INC-124:** `skills.ios.critical-test-quality` deja de bloquear tests XCTest de UI automation/performance cuando usan `XCUIApplication`, `XCTMetric` o `measure`.
+- **Swift Testing sin regresión:** los unit/integration tests XCTest modernizables siguen bloqueados si incumplen el contrato; solo se respeta la compatibilidad explícita que `swift-testing-expert` permite para UI/performance.
+- **Rollout:** publicar `pumuki@6.3.145`, repinear primero RuralGo y revalidar el smoke UI XCTest que estaba bloqueado.
+
 ### 2026-05-05 (v6.3.144)
 
 - **RuralGo PUMUKI-INC-122:** `pumuki sdd evidence` serializa escrituras concurrentes del artefacto `.pumuki/artifacts/pumuki-evidence-v1.json` con lock local y rename atómico.

package/integrations/gate/blockingCause.ts

@@ -0,0 +1,40 @@
+type BlockingCauseCandidate = {
+  code?: string;
+  message?: string;
+  remediation?: string;
+  severity?: string;
+};
+
+const UMBRELLA_EVIDENCE_CODES = new Set([
+  'EVIDENCE_GATE_BLOCKED',
+  'AI_GATE_BLOCKED',
+  'GATE_BLOCKED',
+]);
+
+export const isTddBddBlockingCause = (candidate?: {
+  code?: string;
+  message?: string;
+}): boolean => {
+  const code = candidate?.code ?? '';
+  const message = candidate?.message ?? '';
+  return code.startsWith('TDD_BDD_') || /\bTDD_BDD_[A-Z0-9_]+\b/u.test(message);
+};
+
+export const resolvePrimaryBlockingCause = <T extends BlockingCauseCandidate>(
+  candidates: ReadonlyArray<T>
+): T | undefined => {
+  const tddBddCause = candidates.find(isTddBddBlockingCause);
+  if (tddBddCause) {
+    return tddBddCause;
+  }
+
+  const specificCause = candidates.find((candidate) => {
+    const code = candidate.code ?? '';
+    return code.length > 0 && !UMBRELLA_EVIDENCE_CODES.has(code);
+  });
+  if (specificCause) {
+    return specificCause;
+  }
+
+  return candidates[0];
+};

package/integrations/gate/remediationCatalog.ts

@@ -12,6 +12,14 @@ export const REMEDIATION_HINT_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_BRANCH_MISMATCH: 'Regenera evidencia en la rama actual y reintenta.',
   TDD_BDD_BASELINE_BLOCKED:
     'Corrige el baseline TDD/BDD roto y regenera la evidencia antes de continuar.',
+  TDD_BDD_EVIDENCE_INVALID:
+    'Regenera la evidencia TDD/BDD válida del escenario afectado y vuelve a ejecutar el gate.',
+  TDD_BDD_SCENARIO_FILE_MISSING:
+    'Crea o corrige el fichero .feature referenciado por la evidencia TDD/BDD y revalida.',
+  TDD_BDD_EVIDENCE_STALE:
+    'Reejecuta los tests baseline del componente tocado, refresca la evidencia TDD/BDD y revalida.',
+  TDD_BDD_EVIDENCE_MISSING:
+    'Genera evidencia TDD/BDD para el cambio actual antes de continuar.',
   EVIDENCE_RULES_COVERAGE_MISSING: 'Ejecuta auditoría completa para recalcular rules_coverage.',
   EVIDENCE_RULES_COVERAGE_INCOMPLETE: 'Asegura coverage_ratio=1 y unevaluated=0.',
   ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES_HIGH:

package/integrations/git/runPlatformGate.ts

@@ -442,6 +442,10 @@ const isXCTestSource = (content: string): boolean => {
   return /\bimport\s+XCTest\b/.test(content) || /\bXCTestCase\b/.test(content);
 };
 
+const isXCTestUiOrPerformanceCompatibilitySource = (content: string): boolean => {
+  return /\bXCUIApplication\b|\bXCTMetric\b|\bmeasure\s*(?:\(|\{)/.test(content);
+};
+
 const hasMakeSUTPattern = (content: string): boolean => /\bmakeSUT\s*\(/.test(content);
 
 const hasTrackForMemoryLeaksPattern = (content: string): boolean =>
@@ -461,6 +465,9 @@ const toIosTestsQualityBlockingFinding = (params: {
     if (!isXCTestSource(testFile.content)) {
       continue;
     }
+    if (isXCTestUiOrPerformanceCompatibilitySource(testFile.content)) {
+      continue;
+    }
     const missingMarkers: string[] = [];
     if (!hasMakeSUTPattern(testFile.content)) {
       missingMarkers.push('makeSUT()');

package/integrations/git/stageRunners.ts

@@ -35,6 +35,7 @@ import {
   DEFAULT_GATE_REMEDIATION as DEFAULT_BLOCKED_REMEDIATION,
   REMEDIATION_HINT_BY_CODE as BLOCKED_REMEDIATION_BY_CODE,
 } from '../gate/remediationCatalog';
+import { resolvePrimaryBlockingCause } from '../gate/blockingCause';
 
 const PRE_PUSH_UPSTREAM_REQUIRED_MESSAGE =
   'pumuki pre-push blocked: branch has no upstream tracking reference. Configure upstream first (for example: git push --set-upstream origin <branch>) and retry.';
@@ -273,10 +274,16 @@ const notifyGateBlockedForStage = (params: {
     evidence?.snapshot.stage === params.stage
       ? evidence.snapshot.findings
       : [];
-  const primaryStageFinding = resolvePrimaryBlockedStageFinding(stageFindings);
-  const firstViolation = evidence?.ai_gate.violations[0];
-  const causeCode = primaryStageFinding?.code ?? firstViolation?.code ?? params.fallbackCauseCode;
-  const causeMessage = primaryStageFinding?.message ?? firstViolation?.message ?? params.fallbackCauseMessage;
+  const blockingStageFindings = stageFindings.filter((finding) =>
+    isSeverityAtLeast(finding.severity, 'ERROR')
+  );
+  const primaryCause = resolvePrimaryBlockingCause([
+    ...blockingStageFindings,
+    ...(evidence?.ai_gate.violations ?? []),
+  ]);
+  const primaryStageFinding = primaryCause ?? resolvePrimaryBlockedStageFinding(stageFindings);
+  const causeCode = primaryStageFinding?.code ?? params.fallbackCauseCode;
+  const causeMessage = primaryStageFinding?.message ?? params.fallbackCauseMessage;
   const remediation =
     BLOCKED_REMEDIATION_BY_CODE[causeCode]
     ?? params.fallbackRemediation

package/integrations/lifecycle/cliSdd.ts

@@ -21,6 +21,7 @@ import {
   type PreWriteEnforcementResolution,
 } from '../policy/preWriteEnforcement';
 import { readLifecycleExperimentalFeaturesSnapshot } from './experimentalFeaturesSnapshot';
+import { resolvePrimaryBlockingCause } from '../gate/blockingCause';
 
 import {
   type ParsedArgs,
@@ -321,9 +322,9 @@ export const runSddCommand = async (parsed: ParsedArgs, activeDependencies: Life
             return 1;
           }
           if (aiGate && !aiGate.allowed && preWriteEnforcement.blocking) {
-            const firstViolation = aiGate.violations[0];
-            const causeCode = firstViolation?.code ?? 'AI_GATE_BLOCKED';
-            const causeMessage = firstViolation?.message ?? 'AI gate blocked PRE_WRITE stage.';
+            const primaryViolation = resolvePrimaryBlockingCause(aiGate.violations);
+            const causeCode = primaryViolation?.code ?? 'AI_GATE_BLOCKED';
+            const causeMessage = primaryViolation?.message ?? 'AI gate blocked PRE_WRITE stage.';
             activeDependencies.emitGateBlockedNotification({
               repoRoot: process.cwd(),
               stage: result.stage,

package/integrations/lifecycle/watch.ts

@@ -36,6 +36,7 @@ import {
   resolveGitAtomicityEnforcement,
   type GitAtomicityEnforcementResolution,
 } from '../policy/gitAtomicityEnforcement';
+import { resolvePrimaryBlockingCause } from '../gate/blockingCause';
 
 export type LifecycleWatchStage = 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
 export type LifecycleWatchScope = 'workingTree' | 'staged' | 'repoAndStaged' | 'repo';
@@ -119,6 +120,11 @@ type LifecycleWatchDependencies = {
 };
 
 const defaultGitService = new GitService();
+const GIT_STATUS_PORCELAIN_ARGS = [
+  'status',
+  '--porcelain=v1',
+  '--untracked-files=all',
+] as const;
 
 class RepoScopedGitService extends GitService implements IGitService {
   constructor(private readonly repoRoot: string) {
@@ -137,7 +143,7 @@ class RepoScopedGitService extends GitService implements IGitService {
 const defaultDependencies: LifecycleWatchDependencies = {
   resolveRepoRoot: () => defaultGitService.resolveRepoRoot(),
   readChangeToken: (repoRoot) =>
-    defaultGitService.runGit(['status', '--porcelain=v1', '--untracked-files=all'], repoRoot),
+    defaultGitService.runGit([...GIT_STATUS_PORCELAIN_ARGS], repoRoot),
   resolvePolicyForStage: (stage) => resolvePolicyForStage(stage),
   resolveUpstreamRef,
   resolvePrePushBootstrapBaseRef,
@@ -155,7 +161,10 @@ const defaultDependencies: LifecycleWatchDependencies = {
   ensureRuntimeArtifactsIgnored: (repoRoot) => {
     try {
       ensureRuntimeArtifactsIgnored(repoRoot);
-    } catch {
+    } catch (error) {
+      process.stderr.write(
+        `[pumuki][watch] unable to ensure runtime artifacts are ignored: ${String(error)}\n`
+      );
     }
   },
   emitAuditSummaryNotificationFromEvidence,
@@ -180,6 +189,16 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
   SDD_SESSION_MISSING: 'Abre sesión SDD y vuelve a intentar.',
   SDD_SESSION_INVALID: 'Refresca la sesión SDD y vuelve a intentar.',
   OPENSPEC_MISSING: 'Instala OpenSpec y reintenta la validación.',
+  TDD_BDD_EVIDENCE_INVALID:
+    'Regenera la evidencia TDD/BDD válida del escenario afectado y vuelve a ejecutar el gate.',
+  TDD_BDD_SCENARIO_FILE_MISSING:
+    'Crea o corrige el fichero .feature referenciado por la evidencia TDD/BDD y revalida.',
+  TDD_BDD_EVIDENCE_STALE:
+    'Reejecuta los tests baseline del componente tocado, refresca la evidencia TDD/BDD y revalida.',
+  TDD_BDD_EVIDENCE_MISSING:
+    'Genera evidencia TDD/BDD para el cambio actual antes de continuar.',
+  TDD_BDD_BASELINE_BLOCKED:
+    'Corrige el baseline TDD/BDD roto y regenera la evidencia antes de continuar.',
   MCP_ENTERPRISE_RECEIPT_MISSING: 'Genera el receipt enterprise de MCP antes de continuar.',
   MANIFEST_MUTATION_DETECTED:
     'Validación no debe mutar package.json/lockfiles. Revisa wiring y realiza upgrades solo con comando explícito.',
@@ -369,12 +388,13 @@ const toFirstCause = (params: {
   evidence: AiEvidenceV2_1 | undefined;
   matchedFindings: ReadonlyArray<SnapshotFinding>;
 }): { code: string; message: string; remediation: string } => {
-  const firstFinding = params.matchedFindings[0];
-  const firstViolation = params.evidence?.ai_gate.violations[0];
-  const code = firstFinding?.code ?? firstViolation?.code ?? 'WATCH_GATE_BLOCKED';
+  const primaryCause = resolvePrimaryBlockingCause([
+    ...params.matchedFindings,
+    ...(params.evidence?.ai_gate.violations ?? []),
+  ]);
+  const code = primaryCause?.code ?? 'WATCH_GATE_BLOCKED';
   const message =
-    firstFinding?.message ??
-    firstViolation?.message ??
+    primaryCause?.message ??
     `Watch gate bloqueado (${code}).`;
   const remediation =
     BLOCKED_REMEDIATION_BY_CODE[code] ??

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.144",
+  "version": "6.3.146",
   "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-preflight-run.ts

@@ -2,6 +2,7 @@ import {
   evaluateAiGate,
   type AiGateCheckResult,
 } from '../integrations/gate/evaluateAiGate';
+import { resolvePrimaryBlockingCause } from '../integrations/gate/blockingCause';
 import { readLifecycleExperimentalFeaturesSnapshot } from '../integrations/lifecycle/experimentalFeaturesSnapshot';
 import { LifecycleGitService } from '../integrations/lifecycle/gitService';
 import { readGovernanceObservationSnapshot } from '../integrations/lifecycle/governanceObservationSnapshot';
@@ -36,6 +37,8 @@ const defaultDependencies: ConsumerPreflightDependencies = {
   readGovernanceNextAction,
 };
 
+const SECONDS_PER_MINUTE = 60;
+
 const buildNotificationEvents = (
   result: AiGateCheckResult
 ): ReadonlyArray<PumukiCriticalNotificationEvent> => {
@@ -45,7 +48,7 @@ const buildNotificationEvents = (
     events.push({
       kind: 'evidence.stale',
       evidencePath: '.ai_evidence.json',
-      ageMinutes: Math.max(1, Math.ceil(ageSeconds / 60)),
+      ageMinutes: Math.max(1, Math.ceil(ageSeconds / SECONDS_PER_MINUTE)),
     });
   }
   if (hasViolationCode(result.violations, 'GITFLOW_PROTECTED_BRANCH')) {
@@ -56,13 +59,13 @@ const buildNotificationEvents = (
     });
   }
   if (result.status === 'BLOCKED') {
-    const firstViolation = result.violations[0];
-    const causeCode = firstViolation?.code ?? 'GATE_BLOCKED';
+    const primaryViolation = resolvePrimaryBlockingCause(result.violations);
+    const causeCode = primaryViolation?.code ?? 'GATE_BLOCKED';
     const causeMessage =
-      firstViolation?.message
+      primaryViolation?.message
       ?? `Detected ${result.violations.length} blocking violations in stage ${result.stage}.`;
     const remediation =
-      (firstViolation ? ACTIONABLE_HINTS_BY_CODE[firstViolation.code] : undefined)
+      (primaryViolation ? ACTIONABLE_HINTS_BY_CODE[primaryViolation.code] : undefined)
       ?? 'Corrige la causa bloqueante y vuelve a ejecutar el gate.';
     events.push({
       kind: 'gate.blocked',

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

@@ -7,9 +7,16 @@ import {
   buildNotificationTrackingCauseSummary,
   extractNotificationTrackingContext,
 } from './framework-menu-system-notifications-tracking';
+import { isTddBddBlockingCause } from '../integrations/gate/blockingCause';
 
 const BLOCKED_CAUSE_SUMMARY_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_GATE_BLOCKED: 'El gate de evidencia/gobernanza está bloqueado.',
+  TDD_BDD_EVIDENCE_INVALID: 'La evidencia TDD/BDD actual es inválida.',
+  TDD_BDD_SCENARIO_FILE_MISSING:
+    'Falta el fichero de escenario TDD/BDD referenciado por la evidencia.',
+  TDD_BDD_EVIDENCE_STALE: 'La evidencia TDD/BDD está caducada.',
+  TDD_BDD_EVIDENCE_MISSING: 'Falta evidencia TDD/BDD para el cambio actual.',
+  TDD_BDD_BASELINE_BLOCKED: 'La baseline TDD/BDD está bloqueada.',
   EVIDENCE_MISSING: 'Falta evidencia para validar este paso.',
   EVIDENCE_INVALID: 'La evidencia actual es inválida.',
   EVIDENCE_CHAIN_INVALID: 'La cadena de evidencia no es válida.',
@@ -32,6 +39,13 @@ const BLOCKED_CAUSE_SUMMARY_BY_CODE: Readonly<Record<string, string>> = {
     'No hay reglas activas para cambios de código.',
 };
 
+const TRACKING_COMPATIBLE_UMBRELLA_CODES = new Set([
+  'EVIDENCE_GATE_BLOCKED',
+  'AI_GATE_BLOCKED',
+  'AI_GATE_BLOCK',
+  'GATE_BLOCKED',
+]);
+
 const ENGLISH_CAUSE_HINTS = [
   'detected',
   'avoid explicit any',
@@ -97,13 +111,22 @@ export const resolveBlockedCauseSummary = (
   causeCode: string
 ): string => {
   const trackingContext = extractNotificationTrackingContext(event.causeMessage);
-  if (trackingContext) {
+  if (isTddBddBlockingCause({ code: causeCode, message: event.causeMessage })) {
+    return (
+      BLOCKED_CAUSE_SUMMARY_BY_CODE[causeCode] ??
+      'La evidencia TDD/BDD bloquea el gate; revisa el escenario y el artefacto de evidencia.'
+    );
+  }
+  if (trackingContext && TRACKING_COMPATIBLE_UMBRELLA_CODES.has(causeCode)) {
     return buildNotificationTrackingCauseSummary(trackingContext);
   }
   const mapped = BLOCKED_CAUSE_SUMMARY_BY_CODE[causeCode];
   if (mapped) {
     return mapped;
   }
+  if (trackingContext) {
+    return buildNotificationTrackingCauseSummary(trackingContext);
+  }
   if (event.causeMessage && event.causeMessage.trim().length > 0) {
     const rawMessage = normalizeNotificationText(event.causeMessage).replace(/^[A-Z0-9_]+:\s*/, '');
     const translated = toKnownSpanishCauseFromMessage(rawMessage);

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

@@ -7,12 +7,23 @@ import {
   extractNotificationTrackingContext,
   TRACKING_BLOCKED_REMEDIATION,
 } from './framework-menu-system-notifications-tracking';
+import { isTddBddBlockingCause } from '../integrations/gate/blockingCause';
 
 type BlockedRemediationVariant = 'banner' | 'dialog';
 
 const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_GATE_BLOCKED:
     'Revisa status/doctor para ver la causa exacta del gate, corrígela y revalida.',
+  TDD_BDD_EVIDENCE_INVALID:
+    'Regenera la evidencia TDD/BDD válida del escenario afectado y vuelve a ejecutar el gate.',
+  TDD_BDD_SCENARIO_FILE_MISSING:
+    'Crea o corrige el fichero .feature referenciado por la evidencia TDD/BDD y revalida.',
+  TDD_BDD_EVIDENCE_STALE:
+    'Reejecuta los tests baseline del componente tocado, refresca la evidencia TDD/BDD y revalida.',
+  TDD_BDD_EVIDENCE_MISSING:
+    'Genera evidencia TDD/BDD para el cambio actual antes de continuar.',
+  TDD_BDD_BASELINE_BLOCKED:
+    'Corrige la baseline TDD/BDD rota, registra evidencia pasada y vuelve a ejecutar el gate.',
   EVIDENCE_MISSING: 'Genera la evidencia del slice actual y vuelve a validar esta fase.',
   EVIDENCE_INVALID: 'Regenera la evidencia de esta iteración y repite la validación.',
   EVIDENCE_CHAIN_INVALID: 'Regenera la evidencia para restaurar la cadena de integridad y vuelve a validar.',
@@ -105,6 +116,9 @@ export const resolveBlockedRemediation = (
   const fromEvent = event.remediation
     ? normalizeBlockedRemediation(event.remediation)
     : '';
+  if (isTddBddBlockingCause({ code: causeCode, message: event.causeMessage })) {
+    return truncateNotificationText(resolveFallbackRemediation(causeCode), maxLength);
+  }
   if (extractNotificationTrackingContext(event.causeMessage)) {
     return truncateNotificationText(TRACKING_BLOCKED_REMEDIATION, maxLength);
   }