pumuki 6.3.147 → 6.3.149

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

@@ -6,6 +6,7 @@ import {
   findSwiftOpenClosedSwitchMatch,
   findSwiftConcreteDependencyDipMatch,
   findSwiftPresentationSrpMatch,
+  findSwiftXCTestSrpMatch,
   hasSwiftAnyViewUsage,
   hasSwiftCallbackStyleSignature,
   hasSwiftCornerRadiusUsage,
@@ -888,6 +889,69 @@ final class PumukiOcpIosCanaryUseCase {
   assert.match(match.expected_fix, /estrategia|protocolo|registry/i);
 });
 
+test('findSwiftOpenClosedSwitchMatch detecta switch sobre outcome en Coordinator iOS', () => {
+  const source = `public final class LaunchFlowCoordinator {
+  public func bootstrap() async {
+    let outcome = await appConfigurationUseCase.execute()
+    switch outcome {
+    case .mandatoryUpdate:
+      route = .updateRequired
+    case .maintenance:
+      route = .maintenance
+    case .proceed:
+      route = .home
+    }
+  }
+}
+`;
+
+  const match = findSwiftOpenClosedSwitchMatch(source);
+
+  assert.ok(match);
+  assert.equal(match.primary_node.name, 'LaunchFlowCoordinator');
+  assert.deepEqual(match.related_nodes, [
+    { kind: 'member', name: 'discriminator switch: outcome', lines: [4] },
+    { kind: 'member', name: 'case .mandatoryUpdate', lines: [5] },
+    { kind: 'member', name: 'case .maintenance', lines: [7] },
+    { kind: 'member', name: 'case .proceed', lines: [9] },
+  ]);
+  assert.match(match.why, /OCP/);
+});
+
+test('findSwiftXCTestSrpMatch detecta XCTestCase con responsabilidades mezcladas', () => {
+  const source = `import XCTest
+
+final class LaunchFlowCoordinatorConfigTests: XCTestCase {
+  func test_bootstrap_whenMandatoryUpdate_routesToUpdateRequired() async {}
+  func test_bootstrap_whenSessionIsValid_routesHome() async {}
+  func test_completeOnboarding_marksProgressAndRoutesToLogin() async {}
+}
+`;
+
+  const match = findSwiftXCTestSrpMatch(source);
+
+  assert.ok(match);
+  assert.equal(match.primary_node.name, 'LaunchFlowCoordinatorConfigTests');
+  assert.deepEqual(match.related_nodes, [
+    { kind: 'member', name: 'session routing tests', lines: [5] },
+    { kind: 'member', name: 'onboarding progress tests', lines: [6] },
+  ]);
+  assert.match(match.why, /XCTestCase|SRP/);
+});
+
+test('findSwiftXCTestSrpMatch permite XCTestCase enfocado en una responsabilidad', () => {
+  const source = `import XCTest
+
+final class LaunchFlowCoordinatorNonBlockingConfigTests: XCTestCase {
+  func test_bootstrap_whenConfigFetchFailsWithCache_usesCachedConfigAndContinues() async {}
+  func test_bootstrap_whenOptionalUpdate_allowsAccessAndContinues() async {}
+  func test_bootstrap_whenProceed_continuesToSessionValidation() async {}
+}
+`;
+
+  assert.equal(findSwiftXCTestSrpMatch(source), undefined);
+});
+
 test('findSwiftInterfaceSegregationMatch devuelve payload semantico para ISP-iOS en application', () => {
   const source = `
 protocol PumukiIspIosCanarySessionManaging {

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

@@ -32,6 +32,8 @@ export type SwiftPresentationSrpMatch = {
   lines: readonly number[];
 };
 
+export type SwiftXCTestSrpMatch = SwiftPresentationSrpMatch;
+
 export type SwiftConcreteDependencyDipMatch = {
   primary_node: SwiftSemanticNodeMatch;
   related_nodes: readonly SwiftSemanticNodeMatch[];
@@ -1185,6 +1187,100 @@ export const findSwiftPresentationSrpMatch = (
   };
 };
 
+export const findSwiftXCTestSrpMatch = (source: string): SwiftXCTestSrpMatch | undefined => {
+  if (!hasSwiftXCTestCaseSubclassUsage(source)) {
+    return undefined;
+  }
+
+  const classPattern = /\b(?:final\s+)?class\s+([A-Za-z0-9_]*Tests?)\s*:\s*XCTestCase\b/;
+  const classLines = collectSwiftRegexLines(source, classPattern);
+  if (classLines.length === 0) {
+    return undefined;
+  }
+
+  const classLine = source.split(/\r?\n/)[classLines[0] - 1] ?? '';
+  const className = classLine.match(classPattern)?.[1];
+  if (!className) {
+    return undefined;
+  }
+
+  const sourceLines = source.split(/\r?\n/);
+  const familyPatterns: ReadonlyArray<{
+    key: string;
+    name: string;
+    tokens: readonly string[];
+  }> = [
+    { key: 'configuration', name: 'configuration outcome tests', tokens: ['config', 'configuration', 'update', 'cache'] },
+    { key: 'session', name: 'session routing tests', tokens: ['session', 'login', 'auth', 'valid', 'invalid'] },
+    { key: 'onboarding', name: 'onboarding progress tests', tokens: ['onboarding', 'progress', 'completeonboarding'] },
+    { key: 'permissions', name: 'permissions routing tests', tokens: ['permission', 'camera', 'location', 'notification'] },
+    { key: 'tutorial', name: 'tutorial or feature discovery tests', tokens: ['tutorial', 'featurediscovery'] },
+    { key: 'splash', name: 'splash delay tests', tokens: ['splash', 'delay', 'start'] },
+  ];
+  const matchesFamily = (value: string, tokens: readonly string[]): boolean => {
+    const normalizedValue = value.toLowerCase();
+    return tokens.some((token) => normalizedValue.includes(token));
+  };
+
+  const classFamilyKeys = new Set(
+    familyPatterns
+      .filter((entry) => matchesFamily(className, entry.tokens))
+      .map((entry) => entry.key)
+  );
+  const matchedFamilies = new Map<string, SwiftSemanticNodeMatch>();
+
+  sourceLines.forEach((line, index) => {
+    const sanitizedLine = stripSwiftLineForSemanticScan(line);
+    const methodMatch = sanitizedLine.match(/\bfunc\s+(test[A-Za-z0-9_]+)\s*\(/);
+    const methodName = methodMatch?.[1];
+    if (!methodName) {
+      return;
+    }
+
+    for (const family of familyPatterns) {
+      if (!matchesFamily(methodName, family.tokens)) {
+        continue;
+      }
+      if (classFamilyKeys.has(family.key)) {
+        continue;
+      }
+      if (!matchedFamilies.has(family.key)) {
+        matchedFamilies.set(family.key, {
+          kind: 'member',
+          name: family.name,
+          lines: [index + 1],
+        });
+      }
+    }
+  });
+
+  const relatedNodes = [...matchedFamilies.values()];
+  if (relatedNodes.length < 2) {
+    return undefined;
+  }
+
+  const relatedNodeNames = relatedNodes.map((node) => node.name).join(', ');
+  const allLines = sortedUniqueLines([
+    ...classLines,
+    ...relatedNodes.flatMap((node) => [...node.lines]),
+  ]);
+
+  return {
+    primary_node: {
+      kind: 'class',
+      name: className,
+      lines: classLines,
+    },
+    related_nodes: relatedNodes,
+    why: `${className} mezcla ${relatedNodeNames} dentro del mismo XCTestCase, rompiendo SRP en la suite de tests.`,
+    impact:
+      'La suite acumula múltiples razones de cambio, oculta regresiones por responsabilidad y hace más difícil aislar el baseline afectado antes de PRE_WRITE.',
+    expected_fix:
+      'Divide la suite por responsabilidad observable: configuración, sesión, onboarding, permisos, tutorial o splash deben vivir en XCTestCase separados.',
+    lines: allLines,
+  };
+};
+
 export const findSwiftConcreteDependencyDipMatch = (
   source: string
 ): SwiftConcreteDependencyDipMatch | undefined => {
@@ -1275,7 +1371,7 @@ export const findSwiftOpenClosedSwitchMatch = (
   }
 
   const lines = source.split(/\r?\n/);
-  const discriminatorPattern = /\b(?:kind|type|mode|channel|variant|provider|route|flow|source|experience)\b/i;
+  const discriminatorPattern = /\b(?:kind|type|mode|channel|variant|provider|route|flow|source|experience|outcome|state|status|configuration|config)\b/i;
   const switchPattern = /\bswitch\s+([A-Za-z_][A-Za-z0-9_\.]*)\s*\{/;
 
   for (let index = 0; index < lines.length; index += 1) {

package/core/facts/extractHeuristicFacts.ts

@@ -901,11 +901,30 @@ export const extractHeuristicFacts = (
       }
     }
 
-    if (
-      params.detectedPlatforms.ios?.detected &&
-      isIOSSwiftPath(fileFact.path) &&
-      !isSwiftTestPath(fileFact.path)
-    ) {
+    if (params.detectedPlatforms.ios?.detected && isIOSSwiftPath(fileFact.path)) {
+      if (isSwiftTestPath(fileFact.path)) {
+        const semanticTestSrpMatch = TextIOS.findSwiftXCTestSrpMatch(fileFact.content);
+        if (semanticTestSrpMatch) {
+          heuristicFacts.push(
+            createHeuristicFact({
+              ruleId: 'heuristics.ios.solid.srp.presentation-mixed-responsibilities.ast',
+              code: 'HEURISTICS_IOS_SOLID_SRP_XCTEST_MIXED_RESPONSIBILITIES_AST',
+              message:
+                'Semantic iOS SRP heuristic detected an XCTestCase suite mixing multiple responsibilities.',
+              filePath: fileFact.path,
+              lines: semanticTestSrpMatch.lines,
+              severity: 'CRITICAL',
+              primary_node: semanticTestSrpMatch.primary_node,
+              related_nodes: semanticTestSrpMatch.related_nodes,
+              why: semanticTestSrpMatch.why,
+              impact: semanticTestSrpMatch.impact,
+              expected_fix: semanticTestSrpMatch.expected_fix,
+            })
+          );
+        }
+      }
+
+      if (!isSwiftTestPath(fileFact.path)) {
       if (isIOSApplicationOrPresentationPath(fileFact.path)) {
         const semanticOcpMatch = TextIOS.findSwiftOpenClosedSwitchMatch(fileFact.content);
         if (semanticOcpMatch) {
@@ -1027,6 +1046,7 @@ export const extractHeuristicFacts = (
           })
         );
       }
+      }
     }
 
     if (

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.147",
+  "version": "6.3.149",
   "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": {