pumuki 6.3.145 → 6.3.147

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

@@ -375,11 +375,34 @@ final class SyncTests: XCTestCase {
     }
   }
 }
+`;
+  const brownfieldCompatibleUnitTest = `
+import XCTest
+
+final class LoginModelTests: XCTestCase {
+  func test_submit_validCredentials_storesSession() async throws {
+    let (sut, repository) = makeSUT()
+    try await sut.submit()
+    XCTAssertEqual(repository.receivedRequests.count, 1)
+  }
+
+  private func makeSUT(
+    file: StaticString = #filePath,
+    line: UInt = #line
+  ) -> (LoginModel, AuthRepositorySpy) {
+    let repository = AuthRepositorySpy()
+    let sut = LoginModel(repository: repository)
+    trackForMemoryLeaks(sut, testCase: self, file: file, line: line)
+    trackForMemoryLeaks(repository, testCase: self, file: file, line: line)
+    return (sut, repository)
+  }
+}
 `;
 
   assert.equal(hasSwiftLegacyXCTestImportUsage(unitTest), true);
   assert.equal(hasSwiftLegacyXCTestImportUsage(uiTest), false);
   assert.equal(hasSwiftLegacyXCTestImportUsage(performanceTest), false);
+  assert.equal(hasSwiftLegacyXCTestImportUsage(brownfieldCompatibleUnitTest), false);
 });
 
 test('hasSwiftLegacySwiftUiObservableWrapperUsage detecta @StateObject/@ObservedObject legacy', () => {
@@ -476,11 +499,34 @@ final class LoginUITests: XCTestCase {
     app.launch()
   }
 }
+`;
+  const brownfieldCompatibleSuite = `
+import XCTest
+
+final class LoginModelTests: XCTestCase {
+  func test_submit_validCredentials_storesSession() async throws {
+    let (sut, repository) = makeSUT()
+    try await sut.submit()
+    XCTAssertEqual(repository.receivedRequests.count, 1)
+  }
+
+  private func makeSUT(
+    file: StaticString = #filePath,
+    line: UInt = #line
+  ) -> (LoginModel, AuthRepositorySpy) {
+    let repository = AuthRepositorySpy()
+    let sut = LoginModel(repository: repository)
+    trackForMemoryLeaks(sut, testCase: self, file: file, line: line)
+    trackForMemoryLeaks(repository, testCase: self, file: file, line: line)
+    return (sut, repository)
+  }
+}
 `;
 
   assert.equal(hasSwiftModernizableXCTestSuiteUsage(legacySuite), true);
   assert.equal(hasSwiftModernizableXCTestSuiteUsage(mixedSuite), false);
   assert.equal(hasSwiftModernizableXCTestSuiteUsage(uiSuite), false);
+  assert.equal(hasSwiftModernizableXCTestSuiteUsage(brownfieldCompatibleSuite), false);
 });
 
 test('hasSwiftMixedTestingFrameworksUsage detecta mezcla XCTestCase y Testing/@Test', () => {
@@ -549,6 +595,46 @@ final class BuyerCommerceUISmokeTests: XCTestCase {
   assert.equal(hasSwiftXCTUnwrapUsage(`${uiSource}\nlet value = try XCTUnwrap(optional)`), false);
 });
 
+test('hasSwiftXCTestAssertionUsage excluye XCTest brownfield compatible y bloquea suites sin contrato de calidad', () => {
+  const compatibleSource = `
+import XCTest
+
+final class LoginModelTests: XCTestCase {
+  func test_submit_validCredentials_storesSession() async throws {
+    let (sut, repository) = makeSUT()
+    try await sut.submit()
+    XCTAssertEqual(repository.receivedRequests.count, 1)
+    let session = try XCTUnwrap(repository.savedSession)
+    XCTAssertEqual(session.userId, "buyer-1")
+  }
+
+  private func makeSUT(
+    file: StaticString = #filePath,
+    line: UInt = #line
+  ) -> (LoginModel, AuthRepositorySpy) {
+    let repository = AuthRepositorySpy()
+    let sut = LoginModel(repository: repository)
+    trackForMemoryLeaks(sut, testCase: self, file: file, line: line)
+    trackForMemoryLeaks(repository, testCase: self, file: file, line: line)
+    return (sut, repository)
+  }
+}
+`;
+  const missingQualityContract = `
+import XCTest
+
+final class LoginModelTests: XCTestCase {
+  func test_submit_validCredentials_storesSession() async throws {
+    XCTAssertEqual(repository.receivedRequests.count, 1)
+  }
+}
+`;
+
+  assert.equal(hasSwiftXCTestAssertionUsage(compatibleSource), false);
+  assert.equal(hasSwiftXCTUnwrapUsage(compatibleSource), false);
+  assert.equal(hasSwiftXCTestAssertionUsage(missingQualityContract), true);
+});
+
 test('hasSwiftXCTUnwrapUsage detecta XCTUnwrap real y evita strings', () => {
   const source = `
 let value = try XCTUnwrap(optionalValue)

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

@@ -730,6 +730,30 @@ const hasSwiftLegacyXCTestMethodUsage = (source: string): boolean => {
     .length > 0;
 };
 
+const hasSwiftMakeSutUsage = (source: string): boolean => {
+  return hasSwiftSanitizedRegexMatch(source, /\bmakeSUT\s*\(/);
+};
+
+const hasSwiftMemoryLeakTrackingUsage = (source: string): boolean => {
+  return hasSwiftSanitizedRegexMatch(source, /\btrackForMemoryLeaks\s*\(/);
+};
+
+const hasSwiftBrownfieldCompatibleXCTestUsage = (source: string): boolean => {
+  if (!hasSwiftXCTestImportUsage(source) || !hasSwiftXCTestCaseSubclassUsage(source)) {
+    return false;
+  }
+
+  if (!hasSwiftLegacyXCTestMethodUsage(source)) {
+    return false;
+  }
+
+  if (hasSwiftTestingImportUsage(source) || hasSwiftTestingSuiteAttributeUsage(source)) {
+    return false;
+  }
+
+  return hasSwiftMakeSutUsage(source) && hasSwiftMemoryLeakTrackingUsage(source);
+};
+
 export const hasSwiftLegacyXCTestImportUsage = (source: string): boolean => {
   if (!hasSwiftXCTestImportUsage(source)) {
     return false;
@@ -739,6 +763,10 @@ export const hasSwiftLegacyXCTestImportUsage = (source: string): boolean => {
     return false;
   }
 
+  if (hasSwiftBrownfieldCompatibleXCTestUsage(source)) {
+    return false;
+  }
+
   return true;
 };
 
@@ -771,6 +799,10 @@ export const hasSwiftXCTestAssertionUsage = (source: string): boolean => {
     return false;
   }
 
+  if (hasSwiftBrownfieldCompatibleXCTestUsage(source)) {
+    return false;
+  }
+
   return (
     collectSwiftRegexLines(source, /\bXCTAssert[A-Za-z0-9_]*\s*\(/).length > 0 ||
     collectSwiftRegexLines(source, /\bXCTFail\s*\(/).length > 0
@@ -782,6 +814,10 @@ export const hasSwiftXCTUnwrapUsage = (source: string): boolean => {
     return false;
   }
 
+  if (hasSwiftBrownfieldCompatibleXCTestUsage(source)) {
+    return false;
+  }
+
   return collectSwiftRegexLines(source, /\bXCTUnwrap\s*\(/).length > 0;
 };
 

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/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.145",
+  "version": "6.3.147",
   "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);
   }