qfai 1.2.2 → 1.2.4

package/dist/cli/index.mjs

@@ -26,6 +26,12 @@ var defaultConfig = {
     require: {
       specSections: []
     },
+    testStrategy: {
+      requireLayerTags: false,
+      requireSizeTags: false,
+      maxE2eScenarioRatio: null,
+      maxE2eScenarioCount: null
+    },
     traceability: {
       brMustHaveSc: true,
       scMustHaveTest: true,
@@ -192,6 +198,20 @@ function normalizeValidation(raw, configPath, issues) {
     );
     traceabilityRaw = void 0;
   }
+  let testStrategyRaw;
+  if (raw.testStrategy === void 0) {
+    testStrategyRaw = void 0;
+  } else if (isRecord(raw.testStrategy)) {
+    testStrategyRaw = raw.testStrategy;
+  } else {
+    issues.push(
+      configIssue(
+        configPath,
+        "validation.testStrategy \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+      )
+    );
+    testStrategyRaw = void 0;
+  }
   return {
     failOn: readFailOn(
       raw.failOn,
@@ -209,6 +229,36 @@ function normalizeValidation(raw, configPath, issues) {
         issues
       )
     },
+    testStrategy: {
+      requireLayerTags: readBoolean(
+        testStrategyRaw?.requireLayerTags,
+        base.testStrategy.requireLayerTags,
+        "validation.testStrategy.requireLayerTags",
+        configPath,
+        issues
+      ),
+      requireSizeTags: readBoolean(
+        testStrategyRaw?.requireSizeTags,
+        base.testStrategy.requireSizeTags,
+        "validation.testStrategy.requireSizeTags",
+        configPath,
+        issues
+      ),
+      maxE2eScenarioRatio: readOptionalRatio(
+        testStrategyRaw?.maxE2eScenarioRatio,
+        base.testStrategy.maxE2eScenarioRatio,
+        "validation.testStrategy.maxE2eScenarioRatio",
+        configPath,
+        issues
+      ),
+      maxE2eScenarioCount: readOptionalNonNegativeInt(
+        testStrategyRaw?.maxE2eScenarioCount,
+        base.testStrategy.maxE2eScenarioCount,
+        "validation.testStrategy.maxE2eScenarioCount",
+        configPath,
+        issues
+      )
+    },
     traceability: {
       brMustHaveSc: readBoolean(
         traceabilityRaw?.brMustHaveSc,
@@ -294,6 +344,36 @@ function readString(value, fallback, label, configPath, issues) {
   }
   return fallback;
 }
+function readOptionalRatio(value, fallback, label, configPath, issues) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1) {
+    return value;
+  }
+  issues.push(
+    configIssue(configPath, `${label} \u306F 0\u301C1 \u306E\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002`)
+  );
+  return fallback;
+}
+function readOptionalNonNegativeInt(value, fallback, label, configPath, issues) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0) {
+    return value;
+  }
+  issues.push(
+    configIssue(configPath, `${label} \u306F 0 \u4EE5\u4E0A\u306E\u6574\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002`)
+  );
+  return fallback;
+}
 function readStringArray(value, fallback, label, configPath, issues) {
   if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
     return value;
@@ -810,6 +890,7 @@ async function collectScIdSourcesFromScenarioFiles(scenarioFiles) {
 }
 async function collectScTestReferences(root, globs, excludeGlobs) {
   const refs = /* @__PURE__ */ new Map();
+  const parseErrors = [];
   const normalizedGlobs = normalizeGlobs(globs);
   const normalizedExcludeGlobs = normalizeGlobs(excludeGlobs);
   const mergedExcludeGlobs = Array.from(
@@ -824,7 +905,8 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
         matchedFileCount: 0,
         truncated: false,
         limit: DEFAULT_GLOB_FILE_LIMIT
-      }
+      },
+      parseErrors
     };
   }
   let scanResult;
@@ -844,6 +926,7 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
         truncated: false,
         limit: DEFAULT_GLOB_FILE_LIMIT
       },
+      parseErrors,
       error: formatError3(error2)
     };
   }
@@ -852,6 +935,33 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
   );
   for (const file of normalizedFiles) {
     const text = await readFile2(file, "utf-8");
+    if (file.toLowerCase().endsWith(".feature")) {
+      const { document, errors } = parseScenarioDocument(text, file);
+      if (!document || errors.length > 0) {
+        parseErrors.push({
+          file,
+          errors: errors.length > 0 ? errors : ["Invalid Gherkin document."]
+        });
+        continue;
+      }
+      const scIds2 = /* @__PURE__ */ new Set();
+      for (const scenario of document.scenarios) {
+        for (const tag of scenario.tags) {
+          if (SC_TAG_RE2.test(tag)) {
+            scIds2.add(tag);
+          }
+        }
+      }
+      if (scIds2.size === 0) {
+        continue;
+      }
+      for (const scId of scIds2) {
+        const current = refs.get(scId) ?? /* @__PURE__ */ new Set();
+        current.add(file);
+        refs.set(scId, current);
+      }
+      continue;
+    }
     const scIds = extractAnnotatedScIds(text);
     if (scIds.length === 0) {
       continue;
@@ -870,7 +980,8 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
       matchedFileCount: scanResult.matchedFileCount,
       truncated: scanResult.truncated,
       limit: scanResult.limit
-    }
+    },
+    parseErrors
   };
 }
 function buildScCoverage(scIds, refs) {
@@ -1054,8 +1165,8 @@ import { readFile as readFile4 } from "fs/promises";
 import path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function resolveToolVersion() {
-  if ("1.2.2".length > 0) {
-    return "1.2.2";
+  if ("1.2.4".length > 0) {
+    return "1.2.4";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -3658,7 +3769,7 @@ async function validateScenarios(root, config) {
       ...collectStrategyCandidates(text, entry.scenarioPath)
     );
   }
-  issues.push(...buildStrategyIssues(strategyCandidates));
+  issues.push(...buildStrategyIssues(strategyCandidates, config));
   return issues;
 }
 function validateScenarioContent(text, file) {
@@ -3861,22 +3972,39 @@ function collectStrategyCandidates(text, file) {
       label: buildScenarioLabel(file, scenario.tags, scenario.name),
       hasAnyTag: strategy.hasAnyTag,
       adopted: strategy.isAdopted,
-      missing: !strategy.isAdopted
+      missing: !strategy.isAdopted,
+      layerBucket: classifyLayer(scenario.tags),
+      sizeBucket: classifySize(scenario.tags)
     };
   });
 }
-function buildStrategyIssues(candidates) {
+function buildStrategyIssues(candidates, config) {
   const totalScenarios = candidates.length;
   if (totalScenarios === 0) {
     return [];
   }
   const adoptedCount = candidates.filter((item) => item.adopted).length;
   const missingItems = candidates.filter((item) => item.missing);
+  const missingLayerItems = candidates.filter(
+    (item) => item.layerBucket === "none"
+  );
+  const missingSizeItems = candidates.filter(
+    (item) => item.sizeBucket === "none"
+  );
   const hasAnyStrategyTag = candidates.some((item) => item.hasAnyTag);
   const missingSamples = missingItems.map((item) => item.label).slice(0, STRATEGY_SAMPLE_LIMIT);
+  const missingLayerSamples = missingLayerItems.map((item) => item.label).slice(0, STRATEGY_SAMPLE_LIMIT);
+  const missingSizeSamples = missingSizeItems.map((item) => item.label).slice(0, STRATEGY_SAMPLE_LIMIT);
   const adoptionRate = totalScenarios === 0 ? "0%" : `${Math.round(adoptedCount / totalScenarios * 100)}%`;
+  const e2eCount = candidates.filter(
+    (item) => item.layerBucket === "e2e"
+  ).length;
+  const e2eRatio = totalScenarios === 0 ? 0 : e2eCount / totalScenarios;
+  const maxE2eRatio = config.validation.testStrategy.maxE2eScenarioRatio;
+  const maxE2eCount = config.validation.testStrategy.maxE2eScenarioCount;
+  const issues = [];
   if (!hasAnyStrategyTag) {
-    return [
+    issues.push(
       issue(
         "QFAI-TS-100",
         "\u5168\u3066\u306E Scenario \u306B layer/size \u30BF\u30B0\u304C\u3042\u308A\u307E\u305B\u3093\u3002\u5C0E\u5165\u306F\u4EFB\u610F\u3067\u3059\uFF08opt-in\uFF09\u3002",
@@ -3884,10 +4012,10 @@ function buildStrategyIssues(candidates) {
         void 0,
         "scenario.testStrategyAllMissing"
       )
-    ];
+    );
   }
-  if (adoptedCount < totalScenarios) {
-    return [
+  if (hasAnyStrategyTag && adoptedCount < totalScenarios) {
+    issues.push(
       issue(
         "QFAI-TS-101",
         `layer/size \u30BF\u30B0\u306E\u90E8\u5206\u5C0E\u5165\u3067\u3059: missing=${missingItems.length}, total=${totalScenarios}, adopted=${adoptedCount}, adoptionRate=${adoptionRate}, samples=${missingSamples.join(
@@ -3898,9 +4026,59 @@ function buildStrategyIssues(candidates) {
         "scenario.testStrategyPartialAdoption",
         missingSamples
       )
-    ];
+    );
+  }
+  if (config.validation.testStrategy.requireLayerTags && missingLayerItems.length > 0) {
+    issues.push(
+      issue(
+        "QFAI-TS-102",
+        `layer \u30BF\u30B0\u304C\u672A\u8A2D\u5B9A\u3067\u3059: missing=${missingLayerItems.length}, total=${totalScenarios}, samples=${missingLayerSamples.join(
+          ", "
+        )}`,
+        "warning",
+        void 0,
+        "scenario.testStrategyRequireLayerTags",
+        missingLayerSamples
+      )
+    );
+  }
+  if (config.validation.testStrategy.requireSizeTags && missingSizeItems.length > 0) {
+    issues.push(
+      issue(
+        "QFAI-TS-103",
+        `size \u30BF\u30B0\u304C\u672A\u8A2D\u5B9A\u3067\u3059: missing=${missingSizeItems.length}, total=${totalScenarios}, samples=${missingSizeSamples.join(
+          ", "
+        )}`,
+        "warning",
+        void 0,
+        "scenario.testStrategyRequireSizeTags",
+        missingSizeSamples
+      )
+    );
+  }
+  if (maxE2eRatio !== null && e2eRatio > maxE2eRatio) {
+    issues.push(
+      issue(
+        "QFAI-TS-110",
+        `layer-e2e \u306E\u6BD4\u7387\u304C\u4E0A\u9650\u3092\u8D85\u904E\u3057\u3066\u3044\u307E\u3059: e2e=${e2eCount}, total=${totalScenarios}, ratio=${Math.round(e2eRatio * 1e3) / 10}% (max=${Math.round(maxE2eRatio * 1e3) / 10}%)`,
+        "warning",
+        void 0,
+        "scenario.testStrategyMaxE2eRatio"
+      )
+    );
   }
-  return [];
+  if (maxE2eCount !== null && e2eCount > maxE2eCount) {
+    issues.push(
+      issue(
+        "QFAI-TS-111",
+        `layer-e2e \u306E\u4EF6\u6570\u304C\u4E0A\u9650\u3092\u8D85\u904E\u3057\u3066\u3044\u307E\u3059: e2e=${e2eCount} (max=${maxE2eCount})`,
+        "warning",
+        void 0,
+        "scenario.testStrategyMaxE2eCount"
+      )
+    );
+  }
+  return issues;
 }
 async function fileExists(target) {
   try {
@@ -4088,6 +4266,7 @@ function validateSpecContent(text, file, requiredSections) {
 import { readFile as readFile13 } from "fs/promises";
 var SPEC_TAG_RE3 = /^SPEC-\d{4}$/;
 var BR_TAG_RE2 = /^BR-\d{4}-\d{4}$/;
+var SAMPLE_LIMIT = 20;
 async function validateTraceability(root, config) {
   const issues = [];
   const specsRoot = resolvePath(root, config, "specsDir");
@@ -4104,6 +4283,8 @@ async function validateTraceability(root, config) {
   const scIdsInScenarios = /* @__PURE__ */ new Set();
   const specContractIds = /* @__PURE__ */ new Set();
   const specToBrIds = /* @__PURE__ */ new Map();
+  const scIdToLayer = /* @__PURE__ */ new Map();
+  const layerToScIds = /* @__PURE__ */ new Map();
   const contractIndex = await buildContractIndex(root, config);
   const contractIds = contractIndex.ids;
   for (const file of specFiles) {
@@ -4236,6 +4417,7 @@ async function validateTraceability(root, config) {
       const specTags = scenario.tags.filter((tag) => SPEC_TAG_RE3.test(tag));
       const brTags = scenario.tags.filter((tag) => BR_TAG_RE2.test(tag));
       const scTags = scenario.tags.filter((tag) => SC_TAG_RE2.test(tag));
+      const layerBucket = classifyLayer(scenario.tags);
       if (specTags.length > 1) {
         issues.push(
           issue(
@@ -4273,6 +4455,10 @@ async function validateTraceability(root, config) {
       brTags.forEach((id) => brIdsInScenarios.add(id));
       scTags.forEach((id) => {
         scIdsInScenarios.add(id);
+        scIdToLayer.set(id, layerBucket);
+        const layerIds = layerToScIds.get(layerBucket) ?? /* @__PURE__ */ new Set();
+        layerIds.add(id);
+        layerToScIds.set(layerBucket, layerIds);
         const current = scIdToScenarioInfo.get(id) ?? {
           count: 0,
           names: /* @__PURE__ */ new Set()
@@ -4381,6 +4567,17 @@ async function validateTraceability(root, config) {
     }
     const specInfo = scenarioToSpec.get(file);
     if (specInfo && specInfo.contractRefs.lines.length > 0) {
+      if (!specInfo.contractRefs.hasNone && specInfo.contractRefs.ids.length > 0 && scenarioContractRefs.hasNone) {
+        issues.push(
+          issue(
+            "QFAI-TRACE-036",
+            `Spec \u304C\u5951\u7D04 ID \u3092\u5217\u6319\u3057\u3066\u3044\u307E\u3059\u304C Scenario \u304C none \u3092\u6307\u5B9A\u3057\u3066\u3044\u307E\u3059 (SPEC: ${specInfo.specId ?? "unknown"})`,
+            "warning",
+            file,
+            "traceability.scenarioContractRefNone"
+          )
+        );
+      }
       if (specInfo.contractRefs.hasNone && scenarioContractRefs.ids.length > 0) {
         issues.push(
           issue(
@@ -4469,9 +4666,24 @@ async function validateTraceability(root, config) {
   );
   const scTestRefs = scRefsResult.refs;
   const testFileScan = scRefsResult.scan;
+  const parseErrors = scRefsResult.parseErrors;
   const hasScenarios = scIdsInScenarios.size > 0;
   const hasGlobConfig = testFileScan.globs.length > 0;
   const hasMatchedTests = testFileScan.matchedFileCount > 0;
+  if (parseErrors.length > 0) {
+    for (const entry of parseErrors) {
+      const detail = entry.errors.join(" / ");
+      issues.push(
+        issue(
+          "QFAI-TRACE-040",
+          `\u30C6\u30B9\u30C8\u8A3C\u8DE1\u306E .feature \u89E3\u6790\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${detail}`,
+          "error",
+          entry.file,
+          "traceability.testFileParse"
+        )
+      );
+    }
+  }
   if (hasScenarios && (!hasGlobConfig || !hasMatchedTests || scRefsResult.error)) {
     const detail = scRefsResult.error ? `\uFF08\u8A73\u7D30: ${scRefsResult.error}\uFF09` : "";
     issues.push(
@@ -4485,21 +4697,55 @@ async function validateTraceability(root, config) {
     );
   } else {
     if (config.validation.traceability.scMustHaveTest && scIdsInScenarios.size) {
-      const scWithoutTests = Array.from(scIdsInScenarios).filter((id) => {
-        const refs = scTestRefs.get(id);
-        return !refs || refs.size === 0;
-      });
-      if (scWithoutTests.length > 0) {
+      const enforcedLayers = /* @__PURE__ */ new Set();
+      for (const [scId, refs] of scTestRefs.entries()) {
+        if (!refs || refs.size === 0) {
+          continue;
+        }
+        const layer = scIdToLayer.get(scId);
+        if (layer) {
+          enforcedLayers.add(layer);
+        }
+      }
+      const deferredLayers = [];
+      for (const [layer, scIds] of layerToScIds.entries()) {
+        const missing = Array.from(scIds).filter((id) => {
+          const refs = scTestRefs.get(id);
+          return !refs || refs.size === 0;
+        });
+        if (missing.length === 0) {
+          continue;
+        }
+        if (enforcedLayers.has(layer)) {
+          const samples = missing.slice(0, SAMPLE_LIMIT);
+          const truncated = samples.length < missing.length;
+          const sampleText = samples.join(", ");
+          const suffix = truncated ? " ..." : "";
+          issues.push(
+            issue(
+              "QFAI-TRACE-010",
+              `SC \u304C\u30C6\u30B9\u30C8\u3067\u53C2\u7167\u3055\u308C\u3066\u3044\u307E\u305B\u3093 (layer=${layer}, missing=${missing.length}, samples=${sampleText}${suffix})\u3002testFileGlobs \u306B\u4E00\u81F4\u3059\u308B\u30C6\u30B9\u30C8\u30D5\u30A1\u30A4\u30EB\u3078 QFAI:SC-XXXX-XXXX \u307E\u305F\u306F .feature \u306E @SC-XXXX-XXXX\uFF08\u5BFE\u8C61\u306E SC ID\uFF09\u3092\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044\u3002`,
+              config.validation.traceability.scNoTestSeverity,
+              testsRoot,
+              "traceability.scMustHaveTest",
+              samples
+            )
+          );
+        } else {
+          deferredLayers.push({ layer, missing });
+        }
+      }
+      if (deferredLayers.length > 0) {
+        const summary = deferredLayers.map(
+          (entry) => `layer=${entry.layer} missing=${entry.missing.length}`
+        ).join(", ");
         issues.push(
           issue(
-            "QFAI-TRACE-010",
-            `SC \u304C\u30C6\u30B9\u30C8\u3067\u53C2\u7167\u3055\u308C\u3066\u3044\u307E\u305B\u3093: ${scWithoutTests.join(
-              ", "
-            )}\u3002testFileGlobs \u306B\u4E00\u81F4\u3059\u308B\u30C6\u30B9\u30C8\u30D5\u30A1\u30A4\u30EB\u3078 QFAI:SC-XXXX-XXXX\uFF08\u5BFE\u8C61\u306E SC ID\uFF09\u3092\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044\u3002`,
-            config.validation.traceability.scNoTestSeverity,
+            "QFAI-TRACE-041",
+            `\u30C6\u30B9\u30C8\u8A3C\u8DE1\u304C\u672A\u691C\u51FA\u306E\u30EC\u30A4\u30E4\u30FC\u306F SC\u2192Test \u5224\u5B9A\u3092\u4FDD\u7559\u3057\u307E\u3057\u305F: ${summary}\u3002\u8A72\u5F53\u30EC\u30A4\u30E4\u30FC\u306B\u30C6\u30B9\u30C8\u8A3C\u8DE1\u304C1\u4EF6\u3067\u3082\u8FFD\u52A0\u3055\u308C\u305F\u6642\u70B9\u3067 100% \u3092\u5F37\u5236\u3057\u307E\u3059\u3002`,
+            "info",
             testsRoot,
-            "traceability.scMustHaveTest",
-            scWithoutTests
+            "traceability.scMustHaveTest"
           )
         );
       }
@@ -4511,9 +4757,7 @@ async function validateTraceability(root, config) {
       issues.push(
         issue(
           "QFAI-TRACE-011",
-          `\u30C6\u30B9\u30C8\u304C\u672A\u77E5\u306E SC \u3092\u30A2\u30CE\u30C6\u30FC\u30B7\u30E7\u30F3\u53C2\u7167\u3057\u3066\u3044\u307E\u3059: ${unknownScIds.join(
-            ", "
-          )}`,
+          `\u30C6\u30B9\u30C8\u304C\u672A\u77E5\u306E SC \u3092\u53C2\u7167\u3057\u3066\u3044\u307E\u3059: ${unknownScIds.join(", ")}`,
           "error",
           testsRoot,
           "traceability.scUnknownInTests",
@@ -4838,6 +5082,7 @@ async function createReportData(root, validation, configResult) {
   const testStrategy = await collectTestStrategy(
     scenarioFiles,
     resolvedRoot,
+    config,
     REPORT_TEST_STRATEGY_SAMPLE_LIMIT
   );
   const {
@@ -5256,6 +5501,27 @@ function formatReportMarkdown(data, options = {}) {
     `- s: ${data.testStrategy.size.s} / m: ${data.testStrategy.size.m} / l: ${data.testStrategy.size.l} / none: ${data.testStrategy.size.none} / unknown: ${data.testStrategy.size.unknown}`
   );
   lines.push("");
+  const e2eHeading = data.testStrategy.e2e.ratioExceeded || data.testStrategy.e2e.countExceeded ? "### E2E guardrails (warning)" : "### E2E guardrails";
+  lines.push(e2eHeading);
+  lines.push("");
+  lines.push(
+    `- e2e: ${data.testStrategy.e2e.count} / ${data.testStrategy.totalScenarios} (ratio=${formatPercent(data.testStrategy.e2e.ratio)})`
+  );
+  lines.push(
+    `- maxRatio: ${formatOptionalPercent(data.testStrategy.e2e.maxRatio)}`
+  );
+  lines.push(
+    `- maxCount: ${formatOptionalNumber(data.testStrategy.e2e.maxCount)}`
+  );
+  if (data.testStrategy.e2e.ratioExceeded || data.testStrategy.e2e.countExceeded) {
+    if (data.testStrategy.e2e.ratioExceeded) {
+      lines.push("- warning: layer-e2e \u306E\u6BD4\u7387\u304C\u4E0A\u9650\u3092\u8D85\u904E\u3057\u3066\u3044\u307E\u3059\u3002");
+    }
+    if (data.testStrategy.e2e.countExceeded) {
+      lines.push("- warning: layer-e2e \u306E\u4EF6\u6570\u304C\u4E0A\u9650\u3092\u8D85\u904E\u3057\u3066\u3044\u307E\u3059\u3002");
+    }
+  }
+  lines.push("");
   lines.push("### Missing layer tags");
   lines.push("");
   lines.push(
@@ -5570,6 +5836,21 @@ function formatList(values) {
   }
   return values.join(", ");
 }
+function formatOptionalPercent(value) {
+  if (value === null) {
+    return "(unset)";
+  }
+  return formatPercent(value);
+}
+function formatOptionalNumber(value) {
+  if (value === null) {
+    return "(unset)";
+  }
+  return String(value);
+}
+function formatPercent(value) {
+  return `${Math.round(value * 1e3) / 10}%`;
+}
 function formatMarkdownTable(headers, rows) {
   const widths = headers.map((header, index) => {
     const candidates = rows.map((row) => row[index] ?? "");
@@ -5662,7 +5943,7 @@ async function countScenarios(scenarioFiles) {
   }
   return total;
 }
-async function collectTestStrategy(scenarioFiles, root, limit) {
+async function collectTestStrategy(scenarioFiles, root, config, limit) {
   const layerCounts = {
     unit: 0,
     component: 0,
@@ -5682,6 +5963,7 @@ async function collectTestStrategy(scenarioFiles, root, limit) {
   const missingLayer = [];
   const missingSize = [];
   let totalScenarios = 0;
+  let e2eCount = 0;
   for (const file of scenarioFiles) {
     const text = await readFile15(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
@@ -5701,6 +5983,9 @@ async function collectTestStrategy(scenarioFiles, root, limit) {
       if (layerBucket === "none") {
         missingLayer.push(label);
       }
+      if (layerBucket === "e2e") {
+        e2eCount += 1;
+      }
       const sizeBucket = classifySize(scenario.tags);
       sizeCounts[sizeBucket] += 1;
       if (sizeBucket === "none") {
@@ -5710,6 +5995,9 @@ async function collectTestStrategy(scenarioFiles, root, limit) {
   }
   const layerSamples = missingLayer.slice(0, limit);
   const sizeSamples = missingSize.slice(0, limit);
+  const ratio = totalScenarios === 0 ? 0 : e2eCount / totalScenarios;
+  const maxRatio = config.validation.testStrategy.maxE2eScenarioRatio;
+  const maxCount = config.validation.testStrategy.maxE2eScenarioCount;
   return {
     totalScenarios,
     limit,
@@ -5726,6 +6014,14 @@ async function collectTestStrategy(scenarioFiles, root, limit) {
         samples: sizeSamples,
         truncated: missingSize.length > sizeSamples.length
       }
+    },
+    e2e: {
+      count: e2eCount,
+      ratio,
+      maxRatio,
+      maxCount,
+      ratioExceeded: maxRatio !== null && ratio > maxRatio,
+      countExceeded: maxCount !== null && e2eCount > maxCount
     }
   };
 }