pumuki 6.3.146 → 6.3.148

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/evidence/rulesCoverage.ts

@@ -30,6 +30,17 @@ const createCoverageRatio = (active: number, evaluated: number): number => {
   return normalizeCoverageRatio(evaluated / active);
 };
 
+const createSemanticEnforcementRatio = (params: {
+  registryTotal: number;
+  unsupportedDetector: number;
+}): number => {
+  if (params.registryTotal === 0) {
+    return 1;
+  }
+  const supported = Math.max(0, params.registryTotal - params.unsupportedDetector);
+  return normalizeCoverageRatio(supported / params.registryTotal);
+};
+
 export const createEmptySnapshotRulesCoverage = (
   stage: GateStage
 ): SnapshotRulesCoverage => ({
@@ -48,6 +59,15 @@ export const createEmptySnapshotRulesCoverage = (
     unevaluated: 0,
   },
   coverage_ratio: 1,
+  auto_runtime_coverage_ratio: 1,
+  semantic_enforcement_ratio: 1,
+  global_skills_enforcement: {
+    status: 'enforced',
+    registry_total: 0,
+    detector_supported: 0,
+    declarative_only: 0,
+    unsupported_detector: 0,
+  },
 });
 
 export const normalizeSnapshotRulesCoverage = (
@@ -118,6 +138,43 @@ export const normalizeSnapshotRulesCoverage = (
   const coverageRatio = normalizeCoverageRatio(
     Number.isFinite(value.coverage_ratio) ? value.coverage_ratio : ratioFromCounts
   );
+  const registryTotal = normalizeCount(
+    value.global_skills_enforcement?.registry_total
+      ?? value.registry_totals?.total
+      ?? counts.registry_total
+      ?? 0
+  );
+  const declarativeOnly = normalizeCount(
+    value.global_skills_enforcement?.declarative_only
+      ?? value.registry_totals?.declarative
+      ?? counts.registry_declarative
+      ?? 0
+  );
+  const unsupportedDetector = normalizeCount(
+    value.global_skills_enforcement?.unsupported_detector
+      ?? counts.unsupported_detector
+      ?? unsupportedDetectorCount
+  );
+  const detectorSupported = normalizeCount(
+    value.global_skills_enforcement?.detector_supported
+      ?? Math.max(0, registryTotal - unsupportedDetector)
+  );
+  const semanticEnforcementRatio = normalizeCoverageRatio(
+    Number.isFinite(value.semantic_enforcement_ratio)
+      ? value.semantic_enforcement_ratio ?? 1
+      : createSemanticEnforcementRatio({
+        registryTotal,
+        unsupportedDetector,
+      })
+  );
+  const globalSkillsStatus: NonNullable<
+    SnapshotRulesCoverage['global_skills_enforcement']
+  >['status'] =
+    registryTotal === 0 || unsupportedDetector === 0
+      ? 'enforced'
+      : detectorSupported > 0
+        ? 'partially_enforced'
+        : 'unsupported';
 
   const normalized: SnapshotRulesCoverage = {
     stage,
@@ -131,6 +188,19 @@ export const normalizeSnapshotRulesCoverage = (
     unevaluated_rule_ids: unevaluatedRuleIds,
     counts,
     coverage_ratio: coverageRatio,
+    auto_runtime_coverage_ratio: normalizeCoverageRatio(
+      Number.isFinite(value.auto_runtime_coverage_ratio)
+        ? value.auto_runtime_coverage_ratio ?? coverageRatio
+        : coverageRatio
+    ),
+    semantic_enforcement_ratio: semanticEnforcementRatio,
+    global_skills_enforcement: {
+      status: value.global_skills_enforcement?.status ?? globalSkillsStatus,
+      registry_total: registryTotal,
+      detector_supported: detectorSupported,
+      declarative_only: declarativeOnly,
+      unsupported_detector: unsupportedDetector,
+    },
   };
 
   if (registryTotals) {

package/integrations/evidence/schema.ts

@@ -76,6 +76,15 @@ export type SnapshotRulesCoverage = {
     unsupported_detector?: number;
   };
   coverage_ratio: number;
+  auto_runtime_coverage_ratio?: number;
+  semantic_enforcement_ratio?: number;
+  global_skills_enforcement?: {
+    status: 'enforced' | 'partially_enforced' | 'unsupported';
+    registry_total: number;
+    detector_supported: number;
+    declarative_only: number;
+    unsupported_detector: number;
+  };
 };
 
 export type Snapshot = {

package/integrations/gate/evaluateAiGate.ts

@@ -1300,6 +1300,15 @@ const toHighestTriggeredSeverity = (
   return null;
 };
 
+const hasAppliedGateWaiver = (evidenceResult: EvidenceReadResult): boolean => {
+  if (evidenceResult.kind !== 'valid') {
+    return false;
+  }
+  return evidenceResult.evidence.snapshot.findings.some(
+    (finding) => finding.code === 'GATE_WAIVER_APPLIED'
+  );
+};
+
 const collectEvidencePolicyThresholdViolations = (params: {
   evidenceResult: EvidenceReadResult;
   policy: ReturnType<typeof resolvePolicyForStage>['policy'];
@@ -1307,6 +1316,12 @@ const collectEvidencePolicyThresholdViolations = (params: {
   if (params.evidenceResult.kind !== 'valid') {
     return [];
   }
+  if (
+    params.evidenceResult.evidence.ai_gate.status === 'ALLOWED' &&
+    hasAppliedGateWaiver(params.evidenceResult)
+  ) {
+    return [];
+  }
 
   const severityCounts = params.evidenceResult.evidence.severity_metrics.by_severity;
   const blockSeverity = toHighestTriggeredSeverity(

package/integrations/git/astIntelligenceDualValidation.ts

@@ -162,7 +162,7 @@ export const resolveAstIntelligenceDualValidationMode = (
 
 const toDualValidationFinding = (params: {
   mode: Exclude<AstIntelligenceDualValidationMode, 'off'>;
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: 'PRE_WRITE' | 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
   summary: AstIntelligenceDualValidationSummary;
 }): Finding | undefined => {
   if (params.summary.divergences === 0) {
@@ -202,7 +202,7 @@ const toDualValidationFinding = (params: {
 };
 
 export const evaluateAstIntelligenceDualValidation = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: 'PRE_WRITE' | 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
   skillsRules: RuleSet;
   facts: ReadonlyArray<Fact>;
   legacyFindings: ReadonlyArray<Finding>;

package/integrations/git/runPlatformGate.ts

@@ -3,6 +3,7 @@ import type { Fact } from '../../core/facts/Fact';
 import type { Finding } from '../../core/gate/Finding';
 import type { GateOutcome } from '../../core/gate/GateOutcome';
 import type { GatePolicy } from '../../core/gate/GatePolicy';
+import type { GateStage } from '../../core/gate/GateStage';
 import type { RuleSet } from '../../core/rules/RuleSet';
 import type { SkillsRuleSetLoadResult } from '../config/skillsRuleSet';
 import type { ResolvedStagePolicy } from '../gate/stagePolicies';
@@ -27,7 +28,7 @@ import { evaluateBrownfieldHotspotFindings } from './brownfieldHotspots';
 import { emitPlatformGateEvidence } from './runPlatformGateEvidence';
 import { printGateFindings } from './runPlatformGateOutput';
 import { evaluateSddPolicy, type SddDecision } from '../sdd';
-import type { SnapshotEvaluationMetrics } from '../evidence/schema';
+import type { SnapshotEvaluationMetrics, SnapshotRulesCoverage } from '../evidence/schema';
 import { createEmptyEvaluationMetrics } from '../evidence/evaluationMetrics';
 import { createEmptySnapshotRulesCoverage } from '../evidence/rulesCoverage';
 import { enforceTddBddPolicy } from '../tdd/enforcement';
@@ -212,8 +213,24 @@ const toSddBlockingFinding = (decision: Pick<SddDecision, 'code' | 'message'>):
   source: 'sdd-policy',
 });
 
+const STRICT_ENFORCEMENT_STAGES = new Set<GateStage>([
+  'PRE_WRITE',
+  'PRE_COMMIT',
+  'PRE_PUSH',
+  'CI',
+]);
+
+const isStrictEnforcementStage = (
+  stage: GateStage
+): stage is Exclude<GateStage, 'STAGED'> => STRICT_ENFORCEMENT_STAGES.has(stage);
+
+const isLifecycleGateStage = (
+  stage: GateStage
+): stage is 'PRE_COMMIT' | 'PRE_PUSH' | 'CI' =>
+  stage === 'PRE_COMMIT' || stage === 'PRE_PUSH' || stage === 'CI';
+
 const toRulesCoverageBlockingFinding = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: Exclude<GateStage, 'STAGED'>;
   activeRuleIds: ReadonlyArray<string>;
   evaluatedRuleIds: ReadonlyArray<string>;
   unevaluatedRuleIds: ReadonlyArray<string>;
@@ -243,7 +260,7 @@ const toRulesCoverageBlockingFinding = (params: {
 };
 
 const toSkillsUnsupportedAutoRulesBlockingFinding = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: Exclude<GateStage, 'STAGED'>;
   filesScanned: number;
   unsupportedAutoRuleIds: ReadonlyArray<string>;
   unsupportedDetectorRuleIds?: ReadonlyArray<string>;
@@ -273,6 +290,44 @@ const toSkillsUnsupportedAutoRulesBlockingFinding = (params: {
   };
 };
 
+const toSkillsUnsupportedDetectorRulesBlockingFinding = (params: {
+  stage: Exclude<GateStage, 'STAGED'>;
+  filesScanned: number;
+  unsupportedDetectorRuleIds: ReadonlyArray<string>;
+  registryTotal?: number;
+  registryDeclarative?: number;
+}): Finding | undefined => {
+  if (params.filesScanned === 0) {
+    return undefined;
+  }
+
+  const unsupportedRuleIds = [...new Set(params.unsupportedDetectorRuleIds)].sort();
+  if (unsupportedRuleIds.length === 0) {
+    return undefined;
+  }
+
+  const unsupportedRuleIdsSample = unsupportedRuleIds
+    .slice(0, MAX_SCOPE_SAMPLE_PATHS)
+    .join(LIST_SEPARATOR);
+  const remainingRuleIds = Math.max(0, unsupportedRuleIds.length - MAX_SCOPE_SAMPLE_PATHS);
+  return {
+    ruleId: 'governance.skills.global-enforcement.incomplete',
+    severity: 'ERROR',
+    code: 'SKILLS_GLOBAL_ENFORCEMENT_INCOMPLETE_CRITICAL',
+    message:
+      `Global skills enforcement incomplete at ${params.stage}: ` +
+      `registry_total=${params.registryTotal ?? 'n/a'} ` +
+      `registry_declarative=${params.registryDeclarative ?? 'n/a'} ` +
+      `unsupported_detector=${unsupportedRuleIds.length} ` +
+      `unsupported_detector_rule_ids_sample=[${unsupportedRuleIdsSample}] ` +
+      `unsupported_detector_rule_ids_remaining=${remainingRuleIds}. ` +
+      'Every hard skill rule must be enforced by AST detector or fail closed before this stage can proceed.',
+    filePath: '.ai_evidence.json',
+    matchedBy: 'SkillsGlobalEnforcementGuard',
+    source: 'skills-global-enforcement',
+  };
+};
+
 const PLATFORM_SKILLS_RULE_PREFIXES: Record<
   'ios' | 'android' | 'backend' | 'frontend',
   string
@@ -452,7 +507,7 @@ const hasTrackForMemoryLeaksPattern = (content: string): boolean =>
   /\btrackForMemoryLeaks\s*\(/.test(content);
 
 const toIosTestsQualityBlockingFinding = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: Exclude<GateStage, 'STAGED'>;
   facts: ReadonlyArray<Fact>;
 }): Finding | undefined => {
   const testFiles = collectIosTestFileContents(params.facts);
@@ -502,7 +557,7 @@ const toIosTestsQualityBlockingFinding = (params: {
 };
 
 const toActiveRulesEmptyForCodeChangesBlockingFinding = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: Exclude<GateStage, 'STAGED'>;
   facts: ReadonlyArray<Fact>;
   activeRuleIds: ReadonlyArray<string>;
 }): Finding | undefined => {
@@ -570,7 +625,7 @@ const detectRequiredSkillsScopesFromPaths = (
 };
 
 const toSkillsScopeComplianceBlockingFinding = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: Exclude<GateStage, 'STAGED'>;
   facts: ReadonlyArray<Fact>;
   activeRuleIds: ReadonlyArray<string>;
   evaluatedRuleIds: ReadonlyArray<string>;
@@ -619,7 +674,7 @@ const toSkillsScopeComplianceBlockingFinding = (params: {
 };
 
 const toPolicyAsCodeBlockingFinding = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: Exclude<GateStage, 'STAGED'>;
   policyTrace?: ResolvedStagePolicy['trace'];
 }): Finding | undefined => {
   const validation = params.policyTrace?.validation;
@@ -642,7 +697,7 @@ const toPolicyAsCodeBlockingFinding = (params: {
 };
 
 const toDegradedModeFinding = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: Exclude<GateStage, 'STAGED'>;
   policyTrace?: ResolvedStagePolicy['trace'];
 }): Finding | undefined => {
   const degraded = params.policyTrace?.degraded;
@@ -721,7 +776,7 @@ const toGateWaiverInvalidFinding = (params: {
 });
 
 const toPlatformSkillsCoverageBlockingFinding = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: Exclude<GateStage, 'STAGED'>;
   detectedPlatforms: DetectedPlatforms;
   activeBundles: ReadonlyArray<SkillsRuleSetLoadResult['activeBundles'][number]>;
   activeRuleIds: ReadonlyArray<string>;
@@ -780,7 +835,7 @@ const toPlatformSkillsCoverageBlockingFinding = (params: {
 };
 
 const toCrossPlatformCriticalEnforcementBlockingFinding = (params: {
-  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  stage: Exclude<GateStage, 'STAGED'>;
   detectedPlatforms: DetectedPlatforms;
   skillsRules: SkillsRuleSetLoadResult['rules'];
   evaluatedRuleIds: ReadonlyArray<string>;
@@ -990,9 +1045,7 @@ export async function runPlatformGate(params: {
     }
     : createEmptyEvaluationMetrics();
   const coverageBlockingFinding =
-    params.policy.stage === 'PRE_COMMIT' ||
-    params.policy.stage === 'PRE_PUSH' ||
-    params.policy.stage === 'CI'
+    isStrictEnforcementStage(params.policy.stage)
       ? toRulesCoverageBlockingFinding({
         stage: params.policy.stage,
         activeRuleIds: coverage?.activeRuleIds ?? [],
@@ -1001,9 +1054,7 @@ export async function runPlatformGate(params: {
       })
       : undefined;
   const unsupportedSkillsMappingFinding =
-    params.policy.stage === 'PRE_COMMIT' ||
-    params.policy.stage === 'PRE_PUSH' ||
-    params.policy.stage === 'CI'
+    isStrictEnforcementStage(params.policy.stage)
       ? toSkillsUnsupportedAutoRulesBlockingFinding({
         stage: params.policy.stage,
         filesScanned,
@@ -1014,10 +1065,21 @@ export async function runPlatformGate(params: {
   const effectiveUnsupportedSkillsMappingFinding = applySkillsFindingEnforcement(
     unsupportedSkillsMappingFinding
   );
+  const unsupportedDetectorSkillsFinding =
+    isStrictEnforcementStage(params.policy.stage)
+      ? toSkillsUnsupportedDetectorRulesBlockingFinding({
+          stage: params.policy.stage,
+          filesScanned,
+          unsupportedDetectorRuleIds: skillsRuleSet.unsupportedDetectorRuleIds ?? [],
+          registryTotal: skillsRuleSet.registryCoverage?.registryTotals.total,
+          registryDeclarative: skillsRuleSet.registryCoverage?.registryTotals.declarative,
+        })
+      : undefined;
+  const effectiveUnsupportedDetectorSkillsFinding = applySkillsFindingEnforcement(
+    unsupportedDetectorSkillsFinding
+  );
   const platformSkillsCoverageFinding =
-    params.policy.stage === 'PRE_COMMIT' ||
-    params.policy.stage === 'PRE_PUSH' ||
-    params.policy.stage === 'CI'
+    isStrictEnforcementStage(params.policy.stage)
       ? toPlatformSkillsCoverageBlockingFinding({
           stage: params.policy.stage,
           detectedPlatforms,
@@ -1030,9 +1092,7 @@ export async function runPlatformGate(params: {
     platformSkillsCoverageFinding
   );
   const crossPlatformCriticalFinding =
-    params.policy.stage === 'PRE_COMMIT' ||
-    params.policy.stage === 'PRE_PUSH' ||
-    params.policy.stage === 'CI'
+    isStrictEnforcementStage(params.policy.stage)
       ? toCrossPlatformCriticalEnforcementBlockingFinding({
           stage: params.policy.stage,
           detectedPlatforms,
@@ -1044,9 +1104,7 @@ export async function runPlatformGate(params: {
     crossPlatformCriticalFinding
   );
   const skillsScopeComplianceFinding =
-    params.policy.stage === 'PRE_COMMIT' ||
-    params.policy.stage === 'PRE_PUSH' ||
-    params.policy.stage === 'CI'
+    isStrictEnforcementStage(params.policy.stage)
       ? toSkillsScopeComplianceBlockingFinding({
           stage: params.policy.stage,
           facts,
@@ -1058,9 +1116,7 @@ export async function runPlatformGate(params: {
     skillsScopeComplianceFinding
   );
   const activeRulesEmptyForCodeChangesFinding =
-    params.policy.stage === 'PRE_COMMIT' ||
-    params.policy.stage === 'PRE_PUSH' ||
-    params.policy.stage === 'CI'
+    isStrictEnforcementStage(params.policy.stage)
       ? toActiveRulesEmptyForCodeChangesBlockingFinding({
         stage: params.policy.stage,
         facts,
@@ -1068,9 +1124,7 @@ export async function runPlatformGate(params: {
       })
       : undefined;
   const iosTestsQualityFinding =
-    params.policy.stage === 'PRE_COMMIT' ||
-    params.policy.stage === 'PRE_PUSH' ||
-    params.policy.stage === 'CI'
+    isStrictEnforcementStage(params.policy.stage)
       ? toIosTestsQualityBlockingFinding({
           stage: params.policy.stage,
           facts,
@@ -1080,15 +1134,14 @@ export async function runPlatformGate(params: {
     iosTestsQualityFinding
   );
   const policyAsCodeBlockingFinding =
-    params.policy.stage === 'PRE_COMMIT' ||
-    params.policy.stage === 'PRE_PUSH' ||
-    params.policy.stage === 'CI'
+    isStrictEnforcementStage(params.policy.stage)
       ? toPolicyAsCodeBlockingFinding({
           stage: params.policy.stage,
           policyTrace: params.policyTrace,
         })
       : undefined;
-  const degradedModeFinding = LIFECYCLE_GATE_STAGES.includes(params.policy.stage)
+  const degradedModeFinding = isLifecycleGateStage(params.policy.stage)
+    && LIFECYCLE_GATE_STAGES.includes(params.policy.stage)
     ? toDegradedModeFinding({
         stage: params.policy.stage,
         policyTrace: params.policyTrace,
@@ -1097,9 +1150,7 @@ export async function runPlatformGate(params: {
   const astIntelligenceDualValidation:
     | AstIntelligenceDualValidationResult
     | undefined =
-    params.policy.stage === 'PRE_COMMIT'
-      || params.policy.stage === 'PRE_PUSH'
-      || params.policy.stage === 'CI'
+    isStrictEnforcementStage(params.policy.stage)
       ? dependencies.evaluateAstIntelligenceDualValidation({
           stage: params.policy.stage,
           skillsRules: skillsRuleSet.rules,
@@ -1125,7 +1176,7 @@ export async function runPlatformGate(params: {
   }
   const degradedModeBlocks =
     params.policyTrace?.degraded?.action === DEGRADED_MODE_ACTION_BLOCK;
-  const rulesCoverage = coverage
+  const rulesCoverage: SnapshotRulesCoverage = coverage
     ? {
       stage: params.policy.stage,
       contract: skillsRuleSet.registryCoverage?.contract ?? 'AUTO_RUNTIME_RULES_FOR_STAGE',
@@ -1193,6 +1244,43 @@ export async function runPlatformGate(params: {
                 coverage.evaluatedRuleIds.length / coverage.activeRuleIds.length
               ).toFixed(DEFAULT_RULES_COVERAGE_RATIO_DECIMALS)
             ),
+      auto_runtime_coverage_ratio:
+        coverage.activeRuleIds.length === 0
+          ? 1
+          : Number(
+              (
+                coverage.evaluatedRuleIds.length / coverage.activeRuleIds.length
+              ).toFixed(DEFAULT_RULES_COVERAGE_RATIO_DECIMALS)
+            ),
+      semantic_enforcement_ratio: skillsRuleSet.registryCoverage
+        ? Number(
+            (
+              Math.max(
+                0,
+                skillsRuleSet.registryCoverage.registryTotals.total -
+                  (skillsRuleSet.unsupportedDetectorRuleIds ?? []).length
+              ) / Math.max(1, skillsRuleSet.registryCoverage.registryTotals.total)
+            ).toFixed(DEFAULT_RULES_COVERAGE_RATIO_DECIMALS)
+          )
+        : 1,
+      global_skills_enforcement: {
+        status:
+          (skillsRuleSet.unsupportedDetectorRuleIds?.length ?? 0) === 0
+            ? 'enforced'
+            : coverage.activeRuleIds.length > 0
+              ? 'partially_enforced'
+              : 'unsupported',
+        registry_total: skillsRuleSet.registryCoverage?.registryTotals.total ?? 0,
+        detector_supported: Math.max(
+          0,
+          (skillsRuleSet.registryCoverage?.registryTotals.total ?? 0) -
+            (skillsRuleSet.unsupportedDetectorRuleIds ?? []).length
+        ),
+        declarative_only:
+          skillsRuleSet.registryCoverage?.registryTotals.declarative ?? 0,
+        unsupported_detector:
+          (skillsRuleSet.unsupportedDetectorRuleIds ?? []).length,
+      },
     }
     : createEmptySnapshotRulesCoverage(params.policy.stage);
   const brownfieldHotspotFindings = dependencies.evaluateBrownfieldHotspotFindings({
@@ -1226,6 +1314,7 @@ export async function runPlatformGate(params: {
       ...(degradedModeFinding ? [degradedModeFinding] : []),
       ...(policyAsCodeBlockingFinding ? [policyAsCodeBlockingFinding] : []),
       ...(effectiveUnsupportedSkillsMappingFinding ? [effectiveUnsupportedSkillsMappingFinding] : []),
+      ...(effectiveUnsupportedDetectorSkillsFinding ? [effectiveUnsupportedDetectorSkillsFinding] : []),
       ...(effectivePlatformSkillsCoverageFinding ? [effectivePlatformSkillsCoverageFinding] : []),
       ...(effectiveCrossPlatformCriticalFinding ? [effectiveCrossPlatformCriticalFinding] : []),
       ...(effectiveSkillsScopeComplianceFinding ? [effectiveSkillsScopeComplianceFinding] : []),
@@ -1238,6 +1327,7 @@ export async function runPlatformGate(params: {
       ...findings,
     ]
     : effectiveUnsupportedSkillsMappingFinding
+      || effectiveUnsupportedDetectorSkillsFinding
       || effectivePlatformSkillsCoverageFinding
       || effectiveCrossPlatformCriticalFinding
       || effectiveSkillsScopeComplianceFinding
@@ -1253,6 +1343,7 @@ export async function runPlatformGate(params: {
         ...(degradedModeFinding ? [degradedModeFinding] : []),
         ...(policyAsCodeBlockingFinding ? [policyAsCodeBlockingFinding] : []),
         ...(effectiveUnsupportedSkillsMappingFinding ? [effectiveUnsupportedSkillsMappingFinding] : []),
+        ...(effectiveUnsupportedDetectorSkillsFinding ? [effectiveUnsupportedDetectorSkillsFinding] : []),
         ...(effectivePlatformSkillsCoverageFinding ? [effectivePlatformSkillsCoverageFinding] : []),
         ...(effectiveCrossPlatformCriticalFinding ? [effectiveCrossPlatformCriticalFinding] : []),
         ...(effectiveSkillsScopeComplianceFinding ? [effectiveSkillsScopeComplianceFinding] : []),
@@ -1274,6 +1365,7 @@ export async function runPlatformGate(params: {
     degradedModeBlocks ||
     shouldBlockFromFinding(policyAsCodeBlockingFinding) ||
     shouldBlockFromFinding(effectiveUnsupportedSkillsMappingFinding) ||
+    shouldBlockFromFinding(effectiveUnsupportedDetectorSkillsFinding) ||
     shouldBlockFromFinding(effectivePlatformSkillsCoverageFinding) ||
     shouldBlockFromFinding(effectiveCrossPlatformCriticalFinding) ||
     shouldBlockFromFinding(effectiveSkillsScopeComplianceFinding) ||

package/package.json

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