qfai 0.3.1 → 0.3.2

package/dist/cli/index.cjs

@@ -160,7 +160,7 @@ function report(copied, skipped, dryRun, label) {
 }
 
 // src/cli/commands/report.ts
-var import_promises13 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var import_node_path14 = __toESM(require("path"), 1);
 
 // src/core/config.ts
@@ -497,11 +497,11 @@ function isRecord(value) {
 }
 
 // src/core/report.ts
-var import_promises12 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 var import_node_path13 = __toESM(require("path"), 1);
 
 // src/core/discovery.ts
-var import_node_path6 = __toESM(require("path"), 1);
+var import_promises5 = require("fs/promises");
 
 // src/core/fs.ts
 var import_promises3 = require("fs/promises");
@@ -558,25 +558,50 @@ async function exists2(target) {
   }
 }
 
-// src/core/discovery.ts
-var SPEC_PACK_DIR_PATTERN = /^spec-\d{3}$/;
-async function collectSpecPackDirs(specsRoot) {
-  const files = await collectFiles(specsRoot, { extensions: [".md"] });
-  const packs = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    if (isSpecPackFile(file, "spec.md")) {
-      packs.add(import_node_path6.default.dirname(file));
+// src/core/specLayout.ts
+var import_promises4 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
+var SPEC_DIR_RE = /^spec-\d{4}$/;
+async function collectSpecEntries(specsRoot) {
+  const dirs = await listSpecDirs(specsRoot);
+  const entries = dirs.map((dir) => ({
+    dir,
+    specPath: import_node_path6.default.join(dir, "spec.md"),
+    deltaPath: import_node_path6.default.join(dir, "delta.md"),
+    scenarioPath: import_node_path6.default.join(dir, "scenario.md")
+  }));
+  return entries.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+async function listSpecDirs(specsRoot) {
+  try {
+    const items = await (0, import_promises4.readdir)(specsRoot, { withFileTypes: true });
+    return items.filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => SPEC_DIR_RE.test(name.toLowerCase())).map((name) => import_node_path6.default.join(specsRoot, name));
+  } catch (error2) {
+    if (isMissingFileError(error2)) {
+      return [];
     }
+    throw error2;
+  }
+}
+function isMissingFileError(error2) {
+  if (!error2 || typeof error2 !== "object") {
+    return false;
   }
-  return Array.from(packs).sort();
+  return error2.code === "ENOENT";
+}
+
+// src/core/discovery.ts
+async function collectSpecPackDirs(specsRoot) {
+  const entries = await collectSpecEntries(specsRoot);
+  return entries.map((entry) => entry.dir);
 }
 async function collectSpecFiles(specsRoot) {
-  const files = await collectFiles(specsRoot, { extensions: [".md"] });
-  return files.filter((file) => isSpecPackFile(file, "spec.md"));
+  const entries = await collectSpecEntries(specsRoot);
+  return filterExisting(entries.map((entry) => entry.specPath));
 }
 async function collectScenarioFiles(specsRoot) {
-  const files = await collectFiles(specsRoot, { extensions: [".md"] });
-  return files.filter((file) => isSpecPackFile(file, "scenario.md"));
+  const entries = await collectSpecEntries(specsRoot);
+  return filterExisting(entries.map((entry) => entry.scenarioPath));
 }
 async function collectUiContractFiles(uiRoot) {
   return collectFiles(uiRoot, { extensions: [".yaml", ".yml"] });
@@ -595,12 +620,22 @@ async function collectContractFiles(uiRoot, apiRoot, dataRoot) {
   ]);
   return { ui, api, db };
 }
-function isSpecPackFile(filePath, baseName) {
-  if (import_node_path6.default.basename(filePath).toLowerCase() !== baseName) {
+async function filterExisting(files) {
+  const existing = [];
+  for (const file of files) {
+    if (await exists3(file)) {
+      existing.push(file);
+    }
+  }
+  return existing;
+}
+async function exists3(target) {
+  try {
+    await (0, import_promises5.access)(target);
+    return true;
+  } catch {
     return false;
   }
-  const dirName = import_node_path6.default.basename(import_node_path6.default.dirname(filePath)).toLowerCase();
-  return SPEC_PACK_DIR_PATTERN.test(dirName);
 }
 
 // src/core/ids.ts
@@ -660,16 +695,16 @@ function isValidId(value, prefix) {
 var VALIDATION_SCHEMA_VERSION = "0.2";
 
 // src/core/version.ts
-var import_promises4 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 var import_node_path7 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 async function resolveToolVersion() {
-  if ("0.3.1".length > 0) {
-    return "0.3.1";
+  if ("0.3.2".length > 0) {
+    return "0.3.2";
   }
   try {
     const packagePath = resolvePackageJsonPath();
-    const raw = await (0, import_promises4.readFile)(packagePath, "utf-8");
+    const raw = await (0, import_promises6.readFile)(packagePath, "utf-8");
     const parsed = JSON.parse(raw);
     const version = typeof parsed.version === "string" ? parsed.version : "";
     return version.length > 0 ? version : "unknown";
@@ -684,7 +719,7 @@ function resolvePackageJsonPath() {
 }
 
 // src/core/validators/contracts.ts
-var import_promises5 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 var import_node_path9 = __toESM(require("path"), 1);
 
 // src/core/contracts.ts
@@ -762,7 +797,7 @@ async function validateUiContracts(uiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises5.readFile)(file, "utf-8");
+    const text = await (0, import_promises7.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -829,7 +864,7 @@ async function validateApiContracts(apiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises5.readFile)(file, "utf-8");
+    const text = await (0, import_promises7.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -907,7 +942,7 @@ async function validateDataContracts(dataRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises5.readFile)(file, "utf-8");
+    const text = await (0, import_promises7.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -978,7 +1013,7 @@ function issue(code, message, severity, file, rule, refs) {
 }
 
 // src/core/validators/delta.ts
-var import_promises6 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 var import_node_path10 = __toESM(require("path"), 1);
 var SECTION_RE = /^##\s+変更区分/m;
 var COMPAT_LINE_RE = /^\s*-\s*\[[ xX]\]\s*Compatibility\b/m;
@@ -996,9 +1031,9 @@ async function validateDeltas(root, config) {
     const deltaPath = import_node_path10.default.join(pack, "delta.md");
     let text;
     try {
-      text = await (0, import_promises6.readFile)(deltaPath, "utf-8");
+      text = await (0, import_promises8.readFile)(deltaPath, "utf-8");
     } catch (error2) {
-      if (isMissingFileError(error2)) {
+      if (isMissingFileError2(error2)) {
         issues.push(
           issue2(
             "QFAI-DELTA-001",
@@ -1043,7 +1078,7 @@ async function validateDeltas(root, config) {
   }
   return issues;
 }
-function isMissingFileError(error2) {
+function isMissingFileError2(error2) {
   if (!error2 || typeof error2 !== "object") {
     return false;
   }
@@ -1068,11 +1103,11 @@ function issue2(code, message, severity, file, rule, refs) {
 }
 
 // src/core/validators/ids.ts
-var import_promises8 = require("fs/promises");
+var import_promises10 = require("fs/promises");
 var import_node_path12 = __toESM(require("path"), 1);
 
 // src/core/contractIndex.ts
-var import_promises7 = require("fs/promises");
+var import_promises9 = require("fs/promises");
 var import_node_path11 = __toESM(require("path"), 1);
 async function buildContractIndex(root, config) {
   const contractsRoot = resolvePath(root, config, "contractsDir");
@@ -1097,7 +1132,7 @@ async function buildContractIndex(root, config) {
 }
 async function indexUiContracts(files, index) {
   for (const file of files) {
-    const text = await (0, import_promises7.readFile)(file, "utf-8");
+    const text = await (0, import_promises9.readFile)(file, "utf-8");
     try {
       const doc = parseStructuredContract(file, text);
       extractUiContractIds(doc).forEach((id) => record(index, id, file));
@@ -1109,7 +1144,7 @@ async function indexUiContracts(files, index) {
 }
 async function indexApiContracts(files, index) {
   for (const file of files) {
-    const text = await (0, import_promises7.readFile)(file, "utf-8");
+    const text = await (0, import_promises9.readFile)(file, "utf-8");
     try {
       const doc = parseStructuredContract(file, text);
       extractApiContractIds(doc).forEach((id) => record(index, id, file));
@@ -1121,7 +1156,7 @@ async function indexApiContracts(files, index) {
 }
 async function indexDataContracts(files, index) {
   for (const file of files) {
-    const text = await (0, import_promises7.readFile)(file, "utf-8");
+    const text = await (0, import_promises9.readFile)(file, "utf-8");
     extractIds(text, "DATA").forEach((id) => record(index, id, file));
   }
 }
@@ -1132,66 +1167,6 @@ function record(index, id, file) {
   index.idToFiles.set(id, current);
 }
 
-// src/core/parse/gherkin.ts
-var FEATURE_RE = /^\s*Feature:\s+/;
-var SCENARIO_RE = /^\s*Scenario(?: Outline)?:\s*(.+)\s*$/;
-var TAG_LINE_RE = /^\s*@/;
-function parseTags(line) {
-  return line.trim().split(/\s+/).filter((tag) => tag.startsWith("@")).map((tag) => tag.replace(/^@/, ""));
-}
-function parseGherkinFeature(text, file) {
-  const lines = text.split(/\r?\n/);
-  const scenarios = [];
-  let featurePresent = false;
-  let featureTags = [];
-  let pendingTags = [];
-  let current = null;
-  const flush = () => {
-    if (!current) return;
-    scenarios.push({
-      ...current,
-      body: current.body.trim()
-    });
-    current = null;
-  };
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i] ?? "";
-    const trimmed = line.trim();
-    if (TAG_LINE_RE.test(trimmed)) {
-      pendingTags.push(...parseTags(trimmed));
-      continue;
-    }
-    if (FEATURE_RE.test(trimmed)) {
-      featurePresent = true;
-      featureTags = [...pendingTags];
-      pendingTags = [];
-      continue;
-    }
-    const match = trimmed.match(SCENARIO_RE);
-    if (match) {
-      const scenarioName = match[1]?.trim();
-      if (!scenarioName) {
-        continue;
-      }
-      flush();
-      current = {
-        name: scenarioName,
-        line: i + 1,
-        tags: [...featureTags, ...pendingTags],
-        body: ""
-      };
-      pendingTags = [];
-      continue;
-    }
-    if (current) {
-      current.body += `${line}
-`;
-    }
-  }
-  flush();
-  return { file, featurePresent, scenarios };
-}
-
 // src/core/parse/markdown.ts
 var HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
 function parseHeadings(md) {
@@ -1310,8 +1285,162 @@ function parseSpec(md, file) {
   return parsed;
 }
 
-// src/core/validators/ids.ts
+// src/core/gherkin/parse.ts
+var import_gherkin = require("@cucumber/gherkin");
+var import_node_crypto = require("crypto");
+function parseGherkin(source, uri) {
+  const errors = [];
+  const uuidFn = () => (0, import_node_crypto.randomUUID)();
+  const builder = new import_gherkin.AstBuilder(uuidFn);
+  const matcher = new import_gherkin.GherkinClassicTokenMatcher();
+  const parser = new import_gherkin.Parser(builder, matcher);
+  try {
+    const gherkinDocument = parser.parse(source);
+    gherkinDocument.uri = uri;
+    return { gherkinDocument, errors };
+  } catch (error2) {
+    errors.push(formatError3(error2));
+    return { gherkinDocument: null, errors };
+  }
+}
+function formatError3(error2) {
+  if (error2 instanceof Error) {
+    return error2.message;
+  }
+  return String(error2);
+}
+
+// src/core/scenarioModel.ts
+var SPEC_TAG_RE = /^SPEC-\d{4}$/;
 var SC_TAG_RE = /^SC-\d{4}$/;
+var BR_TAG_RE = /^BR-\d{4}$/;
+var UI_TAG_RE = /^UI-\d{4}$/;
+var API_TAG_RE = /^API-\d{4}$/;
+var DATA_TAG_RE = /^DATA-\d{4}$/;
+function parseScenarioDocument(text, uri) {
+  const { gherkinDocument, errors } = parseGherkin(text, uri);
+  if (!gherkinDocument) {
+    return { document: null, errors };
+  }
+  const feature = gherkinDocument.feature;
+  if (!feature) {
+    return {
+      document: { uri, featureTags: [], scenarios: [] },
+      errors
+    };
+  }
+  const featureTags = collectTagNames(feature.tags);
+  const scenarios = collectScenarioNodes(feature, featureTags);
+  return {
+    document: {
+      uri,
+      featureName: feature.name,
+      featureTags,
+      scenarios
+    },
+    errors
+  };
+}
+function buildScenarioAtoms(document) {
+  return document.scenarios.map((scenario) => {
+    const specIds = scenario.tags.filter((tag) => SPEC_TAG_RE.test(tag));
+    const scIds = scenario.tags.filter((tag) => SC_TAG_RE.test(tag));
+    const brIds = unique2(scenario.tags.filter((tag) => BR_TAG_RE.test(tag)));
+    const contractIds = /* @__PURE__ */ new Set();
+    scenario.tags.forEach((tag) => {
+      if (UI_TAG_RE.test(tag) || API_TAG_RE.test(tag) || DATA_TAG_RE.test(tag)) {
+        contractIds.add(tag);
+      }
+    });
+    for (const step of scenario.steps) {
+      for (const text of collectStepTexts(step)) {
+        extractIds(text, "UI").forEach((id) => contractIds.add(id));
+        extractIds(text, "API").forEach((id) => contractIds.add(id));
+        extractIds(text, "DATA").forEach((id) => contractIds.add(id));
+      }
+    }
+    const atom = {
+      uri: document.uri,
+      featureName: document.featureName ?? "",
+      scenarioName: scenario.name,
+      kind: scenario.kind,
+      brIds,
+      contractIds: Array.from(contractIds).sort()
+    };
+    if (scenario.line !== void 0) {
+      atom.line = scenario.line;
+    }
+    if (specIds.length === 1) {
+      const specId = specIds[0];
+      if (specId) {
+        atom.specId = specId;
+      }
+    }
+    if (scIds.length === 1) {
+      const scId = scIds[0];
+      if (scId) {
+        atom.scId = scId;
+      }
+    }
+    return atom;
+  });
+}
+function collectScenarioNodes(feature, featureTags) {
+  const scenarios = [];
+  for (const child of feature.children) {
+    if (child.scenario) {
+      scenarios.push(buildScenarioNode(child.scenario, featureTags, []));
+    }
+    if (child.rule) {
+      const ruleTags = collectTagNames(child.rule.tags);
+      for (const ruleChild of child.rule.children) {
+        if (ruleChild.scenario) {
+          scenarios.push(
+            buildScenarioNode(ruleChild.scenario, featureTags, ruleTags)
+          );
+        }
+      }
+    }
+  }
+  return scenarios;
+}
+function buildScenarioNode(scenario, featureTags, ruleTags) {
+  const tags = [...featureTags, ...ruleTags, ...collectTagNames(scenario.tags)];
+  const kind = scenario.examples.length > 0 ? "ScenarioOutline" : "Scenario";
+  return {
+    name: scenario.name,
+    kind,
+    line: scenario.location?.line,
+    tags,
+    steps: scenario.steps
+  };
+}
+function collectTagNames(tags) {
+  return tags.map((tag) => tag.name.replace(/^@/, ""));
+}
+function collectStepTexts(step) {
+  const texts = [];
+  if (step.text) {
+    texts.push(step.text);
+  }
+  if (step.docString?.content) {
+    texts.push(step.docString.content);
+  }
+  if (step.dataTable?.rows) {
+    for (const row of step.dataTable.rows) {
+      for (const cell of row.cells) {
+        texts.push(cell.value);
+      }
+    }
+  }
+  return texts;
+}
+function unique2(values) {
+  return Array.from(new Set(values));
+}
+
+// src/core/validators/ids.ts
+var SC_TAG_RE2 = /^SC-\d{4}$/;
 async function validateDefinedIds(root, config) {
   const issues = [];
   const specsRoot = resolvePath(root, config, "specsDir");
@@ -1345,7 +1474,7 @@ async function validateDefinedIds(root, config) {
 }
 async function collectSpecDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await (0, import_promises8.readFile)(file, "utf-8");
+    const text = await (0, import_promises10.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
       recordId(out, parsed.specId, file);
@@ -1355,11 +1484,14 @@ async function collectSpecDefinitionIds(files, out) {
 }
 async function collectScenarioDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await (0, import_promises8.readFile)(file, "utf-8");
-    const parsed = parseGherkinFeature(text, file);
-    for (const scenario of parsed.scenarios) {
+    const text = await (0, import_promises10.readFile)(file, "utf-8");
+    const { document, errors } = parseScenarioDocument(text, file);
+    if (!document || errors.length > 0) {
+      continue;
+    }
+    for (const scenario of document.scenarios) {
       for (const tag of scenario.tags) {
-        if (SC_TAG_RE.test(tag)) {
+        if (SC_TAG_RE2.test(tag)) {
           recordId(out, tag, file);
         }
       }
@@ -1396,21 +1528,23 @@ function issue3(code, message, severity, file, rule, refs) {
 }
 
 // src/core/validators/scenario.ts
-var import_promises9 = require("fs/promises");
+var import_promises11 = require("fs/promises");
 var GIVEN_PATTERN = /\bGiven\b/;
 var WHEN_PATTERN = /\bWhen\b/;
 var THEN_PATTERN = /\bThen\b/;
-var SC_TAG_RE2 = /^SC-\d{4}$/;
-var SPEC_TAG_RE = /^SPEC-\d{4}$/;
-var BR_TAG_RE = /^BR-\d{4}$/;
+var SC_TAG_RE3 = /^SC-\d{4}$/;
+var SPEC_TAG_RE2 = /^SPEC-\d{4}$/;
+var BR_TAG_RE2 = /^BR-\d{4}$/;
 async function validateScenarios(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
-  const files = await collectScenarioFiles(specsRoot);
-  if (files.length === 0) {
+  const entries = await collectSpecEntries(specsRoot);
+  if (entries.length === 0) {
+    const expected = "spec-0001/scenario.md";
+    const legacy = "spec-001/scenario.md";
     return [
       issue4(
         "QFAI-SC-000",
-        "Scenario \u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        `Scenario \u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002\u914D\u7F6E\u5834\u6240: ${config.paths.specsDir} / \u671F\u5F85\u30D1\u30BF\u30FC\u30F3: ${expected} (${legacy} \u306F\u975E\u5BFE\u5FDC)`,
         "info",
         specsRoot,
         "scenario.files"
@@ -1418,15 +1552,31 @@ async function validateScenarios(root, config) {
     ];
   }
   const issues = [];
-  for (const file of files) {
-    const text = await (0, import_promises9.readFile)(file, "utf-8");
-    issues.push(...validateScenarioContent(text, file));
+  for (const entry of entries) {
+    let text;
+    try {
+      text = await (0, import_promises11.readFile)(entry.scenarioPath, "utf-8");
+    } catch (error2) {
+      if (isMissingFileError3(error2)) {
+        issues.push(
+          issue4(
+            "QFAI-SC-001",
+            "scenario.md \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+            "error",
+            entry.scenarioPath,
+            "scenario.exists"
+          )
+        );
+        continue;
+      }
+      throw error2;
+    }
+    issues.push(...validateScenarioContent(text, entry.scenarioPath));
   }
   return issues;
 }
 function validateScenarioContent(text, file) {
   const issues = [];
-  const parsed = parseGherkinFeature(text, file);
   const invalidIds = extractInvalidIds(text, [
     "SPEC",
     "BR",
@@ -1448,9 +1598,47 @@ function validateScenarioContent(text, file) {
       )
     );
   }
+  const { document, errors } = parseScenarioDocument(text, file);
+  if (!document || errors.length > 0) {
+    issues.push(
+      issue4(
+        "QFAI-SC-010",
+        `Gherkin \u306E\u89E3\u6790\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${errors.join(", ") || "unknown"}`,
+        "error",
+        file,
+        "scenario.parse"
+      )
+    );
+    return issues;
+  }
+  const featureSpecTags = document.featureTags.filter(
+    (tag) => SPEC_TAG_RE2.test(tag)
+  );
+  if (featureSpecTags.length === 0) {
+    issues.push(
+      issue4(
+        "QFAI-SC-009",
+        "Feature \u30BF\u30B0\u306B SPEC \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "error",
+        file,
+        "scenario.featureSpec"
+      )
+    );
+  } else if (featureSpecTags.length > 1) {
+    issues.push(
+      issue4(
+        "QFAI-SC-009",
+        `Feature \u306E SPEC \u30BF\u30B0\u304C\u8907\u6570\u3042\u308A\u307E\u3059: ${featureSpecTags.join(", ")}`,
+        "error",
+        file,
+        "scenario.featureSpec",
+        featureSpecTags
+      )
+    );
+  }
   const missingStructure = [];
-  if (!parsed.featurePresent) missingStructure.push("Feature");
-  if (parsed.scenarios.length === 0) missingStructure.push("Scenario");
+  if (!document.featureName) missingStructure.push("Feature");
+  if (document.scenarios.length === 0) missingStructure.push("Scenario");
   if (missingStructure.length > 0) {
     issues.push(
       issue4(
@@ -1464,7 +1652,7 @@ function validateScenarioContent(text, file) {
       )
     );
   }
-  for (const scenario of parsed.scenarios) {
+  for (const scenario of document.scenarios) {
     if (scenario.tags.length === 0) {
       issues.push(
         issue4(
@@ -1478,16 +1666,16 @@ function validateScenarioContent(text, file) {
       continue;
     }
     const missingTags = [];
-    const scTags = scenario.tags.filter((tag) => SC_TAG_RE2.test(tag));
+    const scTags = scenario.tags.filter((tag) => SC_TAG_RE3.test(tag));
     if (scTags.length === 0) {
       missingTags.push("SC(0\u4EF6)");
     } else if (scTags.length > 1) {
       missingTags.push(`SC(${scTags.length}\u4EF6/1\u4EF6\u5FC5\u9808)`);
     }
-    if (!scenario.tags.some((tag) => SPEC_TAG_RE.test(tag))) {
+    if (!scenario.tags.some((tag) => SPEC_TAG_RE2.test(tag))) {
       missingTags.push("SPEC");
     }
-    if (!scenario.tags.some((tag) => BR_TAG_RE.test(tag))) {
+    if (!scenario.tags.some((tag) => BR_TAG_RE2.test(tag))) {
       missingTags.push("BR");
     }
     if (missingTags.length > 0) {
@@ -1502,15 +1690,16 @@ function validateScenarioContent(text, file) {
       );
     }
   }
-  for (const scenario of parsed.scenarios) {
+  for (const scenario of document.scenarios) {
     const missingSteps = [];
-    if (!GIVEN_PATTERN.test(scenario.body)) {
+    const keywords = scenario.steps.map((step) => step.keyword.trim());
+    if (!keywords.some((keyword) => GIVEN_PATTERN.test(keyword))) {
       missingSteps.push("Given");
     }
-    if (!WHEN_PATTERN.test(scenario.body)) {
+    if (!keywords.some((keyword) => WHEN_PATTERN.test(keyword))) {
       missingSteps.push("When");
     }
-    if (!THEN_PATTERN.test(scenario.body)) {
+    if (!keywords.some((keyword) => THEN_PATTERN.test(keyword))) {
       missingSteps.push("Then");
     }
     if (missingSteps.length > 0) {
@@ -1544,18 +1733,25 @@ function issue4(code, message, severity, file, rule, refs) {
   }
   return issue7;
 }
+function isMissingFileError3(error2) {
+  if (!error2 || typeof error2 !== "object") {
+    return false;
+  }
+  return error2.code === "ENOENT";
+}
 
 // src/core/validators/spec.ts
-var import_promises10 = require("fs/promises");
+var import_promises12 = require("fs/promises");
 async function validateSpecs(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
-  const files = await collectSpecFiles(specsRoot);
-  if (files.length === 0) {
-    const expected = "spec-001/spec.md";
+  const entries = await collectSpecEntries(specsRoot);
+  if (entries.length === 0) {
+    const expected = "spec-0001/spec.md";
+    const legacy = "spec-001/spec.md";
     return [
       issue5(
         "QFAI-SPEC-000",
-        `Spec \u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002\u914D\u7F6E\u5834\u6240: ${config.paths.specsDir} / \u671F\u5F85\u30D1\u30BF\u30FC\u30F3: ${expected}`,
+        `Spec \u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002\u914D\u7F6E\u5834\u6240: ${config.paths.specsDir} / \u671F\u5F85\u30D1\u30BF\u30FC\u30F3: ${expected} (${legacy} \u306F\u975E\u5BFE\u5FDC)`,
         "info",
         specsRoot,
         "spec.files"
@@ -1563,12 +1759,29 @@ async function validateSpecs(root, config) {
     ];
   }
   const issues = [];
-  for (const file of files) {
-    const text = await (0, import_promises10.readFile)(file, "utf-8");
+  for (const entry of entries) {
+    let text;
+    try {
+      text = await (0, import_promises12.readFile)(entry.specPath, "utf-8");
+    } catch (error2) {
+      if (isMissingFileError4(error2)) {
+        issues.push(
+          issue5(
+            "QFAI-SPEC-005",
+            "spec.md \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+            "error",
+            entry.specPath,
+            "spec.exists"
+          )
+        );
+        continue;
+      }
+      throw error2;
+    }
     issues.push(
       ...validateSpecContent(
         text,
-        file,
+        entry.specPath,
         config.validation.require.specSections
       )
     );
@@ -1690,15 +1903,18 @@ function issue5(code, message, severity, file, rule, refs) {
   }
   return issue7;
 }
+function isMissingFileError4(error2) {
+  if (!error2 || typeof error2 !== "object") {
+    return false;
+  }
+  return error2.code === "ENOENT";
+}
 
 // src/core/validators/traceability.ts
-var import_promises11 = require("fs/promises");
-var SC_TAG_RE3 = /^SC-\d{4}$/;
-var SPEC_TAG_RE2 = /^SPEC-\d{4}$/;
-var BR_TAG_RE2 = /^BR-\d{4}$/;
-var UI_TAG_RE = /^UI-\d{4}$/;
-var API_TAG_RE = /^API-\d{4}$/;
-var DATA_TAG_RE = /^DATA-\d{4}$/;
+var import_promises13 = require("fs/promises");
+var SC_TAG_RE4 = /^SC-\d{4}$/;
+var SPEC_TAG_RE3 = /^SPEC-\d{4}$/;
+var BR_TAG_RE3 = /^BR-\d{4}$/;
 async function validateTraceability(root, config) {
   const issues = [];
   const specsRoot = resolvePath(root, config, "specsDir");
@@ -1717,7 +1933,7 @@ async function validateTraceability(root, config) {
   const contractIndex = await buildContractIndex(root, config);
   const contractIds = contractIndex.ids;
   for (const file of specFiles) {
-    const text = await (0, import_promises11.readFile)(file, "utf-8");
+    const text = await (0, import_promises13.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
@@ -1754,106 +1970,99 @@ async function validateTraceability(root, config) {
     }
   }
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises11.readFile)(file, "utf-8");
+    const text = await (0, import_promises13.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
-    const parsed = parseGherkinFeature(text, file);
-    const specIdsInScenario = /* @__PURE__ */ new Set();
-    const brIds = /* @__PURE__ */ new Set();
-    const scIds = /* @__PURE__ */ new Set();
-    const scenarioIds = /* @__PURE__ */ new Set();
-    for (const scenario of parsed.scenarios) {
-      for (const tag of scenario.tags) {
-        if (SPEC_TAG_RE2.test(tag)) {
-          specIdsInScenario.add(tag);
-        }
-        if (BR_TAG_RE2.test(tag)) {
-          brIds.add(tag);
-        }
-        if (SC_TAG_RE3.test(tag)) {
-          scIds.add(tag);
-        }
-        if (UI_TAG_RE.test(tag) || API_TAG_RE.test(tag) || DATA_TAG_RE.test(tag)) {
-          scenarioIds.add(tag);
-        }
-      }
-    }
-    const specIdsList = Array.from(specIdsInScenario);
-    const brIdsList = Array.from(brIds);
-    const scIdsList = Array.from(scIds);
-    const scenarioIdsList = Array.from(scenarioIds);
-    brIdsList.forEach((id) => brIdsInScenarios.add(id));
-    scIdsList.forEach((id) => scIdsInScenarios.add(id));
-    scenarioIdsList.forEach((id) => scenarioContractIds.add(id));
-    if (scenarioIdsList.length > 0) {
-      scIdsList.forEach((id) => scWithContracts.add(id));
-    }
-    const unknownSpecIds = specIdsList.filter((id) => !specIds.has(id));
-    if (unknownSpecIds.length > 0) {
-      issues.push(
-        issue6(
-          "QFAI-TRACE-005",
-          `Scenario \u304C\u5B58\u5728\u3057\u306A\u3044 SPEC \u3092\u53C2\u7167\u3057\u3066\u3044\u307E\u3059: ${unknownSpecIds.join(", ")}`,
-          "error",
-          file,
-          "traceability.scenarioSpecExists",
-          unknownSpecIds
-        )
-      );
-    }
-    const unknownBrIds = brIdsList.filter((id) => !brIdsInSpecs.has(id));
-    if (unknownBrIds.length > 0) {
-      issues.push(
-        issue6(
-          "QFAI-TRACE-006",
-          `Scenario \u304C\u5B58\u5728\u3057\u306A\u3044 BR \u3092\u53C2\u7167\u3057\u3066\u3044\u307E\u3059: ${unknownBrIds.join(", ")}`,
-          "error",
-          file,
-          "traceability.scenarioBrExists",
-          unknownBrIds
-        )
-      );
-    }
-    const unknownContractIds = scenarioIdsList.filter(
-      (id) => !contractIds.has(id)
-    );
-    if (unknownContractIds.length > 0) {
-      issues.push(
-        issue6(
-          "QFAI-TRACE-008",
-          `Scenario \u304C\u5B58\u5728\u3057\u306A\u3044\u5951\u7D04 ID \u3092\u53C2\u7167\u3057\u3066\u3044\u307E\u3059: ${unknownContractIds.join(
-            ", "
-          )}`,
-          config.validation.traceability.unknownContractIdSeverity,
-          file,
-          "traceability.scenarioContractExists",
-          unknownContractIds
-        )
-      );
+    const { document, errors } = parseScenarioDocument(text, file);
+    if (!document || errors.length > 0) {
+      continue;
     }
-    if (specIdsList.length > 0) {
-      const allowedBrIds = /* @__PURE__ */ new Set();
-      for (const specId of specIdsList) {
-        const brIdsForSpec = specToBrIds.get(specId);
-        if (!brIdsForSpec) {
-          continue;
-        }
-        brIdsForSpec.forEach((id) => allowedBrIds.add(id));
+    const atoms = buildScenarioAtoms(document);
+    for (const [index, scenario] of document.scenarios.entries()) {
+      const atom = atoms[index];
+      if (!atom) {
+        continue;
+      }
+      const specTags = scenario.tags.filter((tag) => SPEC_TAG_RE3.test(tag));
+      const brTags = scenario.tags.filter((tag) => BR_TAG_RE3.test(tag));
+      const scTags = scenario.tags.filter((tag) => SC_TAG_RE4.test(tag));
+      brTags.forEach((id) => brIdsInScenarios.add(id));
+      scTags.forEach((id) => scIdsInScenarios.add(id));
+      atom.contractIds.forEach((id) => scenarioContractIds.add(id));
+      if (atom.contractIds.length > 0) {
+        scTags.forEach((id) => scWithContracts.add(id));
       }
-      const invalidBrIds = brIdsList.filter((id) => !allowedBrIds.has(id));
-      if (invalidBrIds.length > 0) {
+      const unknownSpecIds = specTags.filter((id) => !specIds.has(id));
+      if (unknownSpecIds.length > 0) {
         issues.push(
           issue6(
-            "QFAI-TRACE-007",
-            `Scenario \u306E BR \u304C\u53C2\u7167 SPEC \u306B\u5C5E\u3057\u3066\u3044\u307E\u305B\u3093: ${invalidBrIds.join(
+            "QFAI-TRACE-005",
+            `Scenario \u304C\u5B58\u5728\u3057\u306A\u3044 SPEC \u3092\u53C2\u7167\u3057\u3066\u3044\u307E\u3059: ${unknownSpecIds.join(
               ", "
-            )} (SPEC: ${specIdsList.join(", ")})`,
+            )} (${scenario.name})`,
             "error",
             file,
-            "traceability.scenarioBrUnderSpec",
-            invalidBrIds
+            "traceability.scenarioSpecExists",
+            unknownSpecIds
           )
         );
       }
+      const unknownBrIds = brTags.filter((id) => !brIdsInSpecs.has(id));
+      if (unknownBrIds.length > 0) {
+        issues.push(
+          issue6(
+            "QFAI-TRACE-006",
+            `Scenario \u304C\u5B58\u5728\u3057\u306A\u3044 BR \u3092\u53C2\u7167\u3057\u3066\u3044\u307E\u3059: ${unknownBrIds.join(
+              ", "
+            )} (${scenario.name})`,
+            "error",
+            file,
+            "traceability.scenarioBrExists",
+            unknownBrIds
+          )
+        );
+      }
+      const unknownContractIds = atom.contractIds.filter(
+        (id) => !contractIds.has(id)
+      );
+      if (unknownContractIds.length > 0) {
+        issues.push(
+          issue6(
+            "QFAI-TRACE-008",
+            `Scenario \u304C\u5B58\u5728\u3057\u306A\u3044\u5951\u7D04 ID \u3092\u53C2\u7167\u3057\u3066\u3044\u307E\u3059: ${unknownContractIds.join(
+              ", "
+            )} (${scenario.name})`,
+            config.validation.traceability.unknownContractIdSeverity,
+            file,
+            "traceability.scenarioContractExists",
+            unknownContractIds
+          )
+        );
+      }
+      if (specTags.length > 0 && brTags.length > 0) {
+        const allowedBrIds = /* @__PURE__ */ new Set();
+        for (const specId of specTags) {
+          const brIdsForSpec = specToBrIds.get(specId);
+          if (!brIdsForSpec) {
+            continue;
+          }
+          brIdsForSpec.forEach((id) => allowedBrIds.add(id));
+        }
+        const invalidBrIds = brTags.filter((id) => !allowedBrIds.has(id));
+        if (invalidBrIds.length > 0) {
+          issues.push(
+            issue6(
+              "QFAI-TRACE-007",
+              `Scenario \u306E BR \u304C\u53C2\u7167 SPEC \u306B\u5C5E\u3057\u3066\u3044\u307E\u305B\u3093: ${invalidBrIds.join(
+                ", "
+              )} (SPEC: ${specTags.join(", ")}) (${scenario.name})`,
+              "error",
+              file,
+              "traceability.scenarioBrUnderSpec",
+              invalidBrIds
+            )
+          );
+        }
+      }
     }
   }
   if (upstreamIds.size === 0) {
@@ -1951,7 +2160,7 @@ async function validateCodeReferences(upstreamIds, srcRoot, testsRoot) {
   const pattern = buildIdPattern(Array.from(upstreamIds));
   let found = false;
   for (const file of targetFiles) {
-    const text = await (0, import_promises11.readFile)(file, "utf-8");
+    const text = await (0, import_promises13.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       found = true;
       break;
@@ -2178,7 +2387,7 @@ async function collectIds(files) {
     DATA: /* @__PURE__ */ new Set()
   };
   for (const file of files) {
-    const text = await (0, import_promises12.readFile)(file, "utf-8");
+    const text = await (0, import_promises14.readFile)(file, "utf-8");
     for (const prefix of ID_PREFIXES2) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -2196,7 +2405,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await (0, import_promises12.readFile)(file, "utf-8");
+    const text = await (0, import_promises14.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -2217,7 +2426,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern2(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await (0, import_promises12.readFile)(file, "utf-8");
+    const text = await (0, import_promises14.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -2269,7 +2478,7 @@ async function runReport(options) {
   try {
     validation = await readValidationResult(inputPath);
   } catch (err) {
-    if (isMissingFileError2(err)) {
+    if (isMissingFileError5(err)) {
       error(
         [
           `qfai report: \u5165\u529B\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${inputPath}`,
@@ -2292,8 +2501,8 @@ async function runReport(options) {
   const defaultOut = options.format === "json" ? import_node_path14.default.join(outRoot, "report.json") : import_node_path14.default.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
   const outPath = import_node_path14.default.isAbsolute(out) ? out : import_node_path14.default.resolve(root, out);
-  await (0, import_promises13.mkdir)(import_node_path14.default.dirname(outPath), { recursive: true });
-  await (0, import_promises13.writeFile)(outPath, `${output}
+  await (0, import_promises15.mkdir)(import_node_path14.default.dirname(outPath), { recursive: true });
+  await (0, import_promises15.writeFile)(outPath, `${output}
 `, "utf-8");
   info(
     `report: info=${validation.counts.info} warning=${validation.counts.warning} error=${validation.counts.error}`
@@ -2301,7 +2510,7 @@ async function runReport(options) {
   info(`wrote report: ${outPath}`);
 }
 async function readValidationResult(inputPath) {
-  const raw = await (0, import_promises13.readFile)(inputPath, "utf-8");
+  const raw = await (0, import_promises15.readFile)(inputPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!isValidationResult(parsed)) {
     throw new Error(`validate.json \u306E\u5F62\u5F0F\u304C\u4E0D\u6B63\u3067\u3059: ${inputPath}`);
@@ -2333,7 +2542,7 @@ function isValidationResult(value) {
   }
   return typeof counts.info === "number" && typeof counts.warning === "number" && typeof counts.error === "number";
 }
-function isMissingFileError2(error2) {
+function isMissingFileError5(error2) {
   if (!error2 || typeof error2 !== "object") {
     return false;
   }
@@ -2342,7 +2551,7 @@ function isMissingFileError2(error2) {
 }
 
 // src/cli/commands/validate.ts
-var import_promises14 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var import_node_path15 = __toESM(require("path"), 1);
 
 // src/cli/lib/failOn.ts
@@ -2408,8 +2617,8 @@ function emitGitHub(issue7) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = import_node_path15.default.isAbsolute(jsonPath) ? jsonPath : import_node_path15.default.resolve(root, jsonPath);
-  await (0, import_promises14.mkdir)(import_node_path15.default.dirname(abs), { recursive: true });
-  await (0, import_promises14.writeFile)(abs, `${JSON.stringify(result, null, 2)}
+  await (0, import_promises16.mkdir)(import_node_path15.default.dirname(abs), { recursive: true });
+  await (0, import_promises16.writeFile)(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }