qfai 0.5.0 → 0.6.0

package/dist/cli/index.cjs

@@ -23,166 +23,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/cli/commands/init.ts
-var import_node_path3 = __toESM(require("path"), 1);
-
-// src/cli/lib/fs.ts
-var import_promises = require("fs/promises");
-var import_node_path = __toESM(require("path"), 1);
-async function copyTemplateTree(sourceRoot, destRoot, options) {
-  const files = await collectTemplateFiles(sourceRoot);
-  return copyFiles(files, sourceRoot, destRoot, options);
-}
-async function copyFiles(files, sourceRoot, destRoot, options) {
-  const copied = [];
-  const skipped = [];
-  const conflicts = [];
-  if (!options.force) {
-    for (const file of files) {
-      const relative = import_node_path.default.relative(sourceRoot, file);
-      const dest = import_node_path.default.join(destRoot, relative);
-      if (!await shouldWrite(dest, options.force)) {
-        conflicts.push(dest);
-      }
-    }
-    if (conflicts.length > 0) {
-      throw new Error(formatConflictMessage(conflicts));
-    }
-  }
-  for (const file of files) {
-    const relative = import_node_path.default.relative(sourceRoot, file);
-    const dest = import_node_path.default.join(destRoot, relative);
-    if (!await shouldWrite(dest, options.force)) {
-      skipped.push(dest);
-      continue;
-    }
-    if (!options.dryRun) {
-      await (0, import_promises.mkdir)(import_node_path.default.dirname(dest), { recursive: true });
-      await (0, import_promises.copyFile)(file, dest);
-    }
-    copied.push(dest);
-  }
-  return { copied, skipped };
-}
-function formatConflictMessage(conflicts) {
-  return [
-    "\u65E2\u5B58\u30D5\u30A1\u30A4\u30EB\u3068\u885D\u7A81\u3057\u307E\u3057\u305F\u3002\u5B89\u5168\u306E\u305F\u3081\u505C\u6B62\u3057\u307E\u3059\u3002",
-    "",
-    "\u885D\u7A81\u30D5\u30A1\u30A4\u30EB:",
-    ...conflicts.map((conflict) => `- ${conflict}`),
-    "",
-    "\u4E0A\u66F8\u304D\u3057\u3066\u7D9A\u884C\u3059\u308B\u5834\u5408\u306F --force \u3092\u4ED8\u3051\u3066\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
-  ].join("\n");
-}
-async function collectTemplateFiles(root) {
-  const entries = [];
-  if (!await exists(root)) {
-    return entries;
-  }
-  const items = await (0, import_promises.readdir)(root, { withFileTypes: true });
-  for (const item of items) {
-    const fullPath = import_node_path.default.join(root, item.name);
-    if (item.isDirectory()) {
-      const nested = await collectTemplateFiles(fullPath);
-      entries.push(...nested);
-      continue;
-    }
-    if (item.isFile()) {
-      entries.push(fullPath);
-    }
-  }
-  return entries;
-}
-async function shouldWrite(target, force) {
-  if (force) {
-    return true;
-  }
-  return !await exists(target);
-}
-async function exists(target) {
-  try {
-    await (0, import_promises.access)(target);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/cli/lib/assets.ts
-var import_node_fs = require("fs");
-var import_node_path2 = __toESM(require("path"), 1);
-var import_node_url = require("url");
-function getInitAssetsDir() {
-  const base = __filename;
-  const basePath = base.startsWith("file:") ? (0, import_node_url.fileURLToPath)(base) : base;
-  const baseDir = import_node_path2.default.dirname(basePath);
-  const candidates = [
-    import_node_path2.default.resolve(baseDir, "../../../assets/init"),
-    import_node_path2.default.resolve(baseDir, "../../assets/init")
-  ];
-  for (const candidate of candidates) {
-    if ((0, import_node_fs.existsSync)(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(
-    [
-      "init \u7528\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002Template assets not found.",
-      "\u78BA\u8A8D\u3057\u305F\u30D1\u30B9 / Checked paths:",
-      ...candidates.map((candidate) => `- ${candidate}`)
-    ].join("\n")
-  );
-}
-
-// src/cli/lib/logger.ts
-function info(message) {
-  process.stdout.write(`${message}
-`);
-}
-function error(message) {
-  process.stderr.write(`${message}
-`);
-}
-
-// src/cli/commands/init.ts
-async function runInit(options) {
-  const assetsRoot = getInitAssetsDir();
-  const rootAssets = import_node_path3.default.join(assetsRoot, "root");
-  const qfaiAssets = import_node_path3.default.join(assetsRoot, ".qfai");
-  const destRoot = import_node_path3.default.resolve(options.dir);
-  const destQfai = import_node_path3.default.join(destRoot, ".qfai");
-  const rootResult = await copyTemplateTree(rootAssets, destRoot, {
-    force: options.force,
-    dryRun: options.dryRun
-  });
-  const qfaiResult = await copyTemplateTree(qfaiAssets, destQfai, {
-    force: options.force,
-    dryRun: options.dryRun
-  });
-  report(
-    [...rootResult.copied, ...qfaiResult.copied],
-    [...rootResult.skipped, ...qfaiResult.skipped],
-    options.dryRun,
-    "init"
-  );
-}
-function report(copied, skipped, dryRun, label) {
-  info(`qfai ${label}: ${dryRun ? "dry-run" : "done"}`);
-  if (copied.length > 0) {
-    info(`  created: ${copied.length}`);
-  }
-  if (skipped.length > 0) {
-    info(`  skipped: ${skipped.length}`);
-  }
-}
+// src/cli/commands/doctor.ts
+var import_promises8 = require("fs/promises");
+var import_node_path8 = __toESM(require("path"), 1);
 
-// src/cli/commands/report.ts
-var import_promises16 = require("fs/promises");
-var import_node_path15 = __toESM(require("path"), 1);
+// src/core/doctor.ts
+var import_promises7 = require("fs/promises");
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/core/config.ts
-var import_promises2 = require("fs/promises");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
 var import_yaml = require("yaml");
 var defaultConfig = {
   paths: {
@@ -213,7 +64,7 @@ var defaultConfig = {
       testFileGlobs: [],
       testFileExcludeGlobs: [],
       scNoTestSeverity: "error",
-      allowOrphanContracts: false,
+      orphanContractsPolicy: "error",
       unknownContractIdSeverity: "error"
     }
   },
@@ -222,14 +73,34 @@ var defaultConfig = {
   }
 };
 function getConfigPath(root) {
-  return import_node_path4.default.join(root, "qfai.config.yaml");
+  return import_node_path.default.join(root, "qfai.config.yaml");
+}
+async function findConfigRoot(startDir) {
+  const resolvedStart = import_node_path.default.resolve(startDir);
+  let current = resolvedStart;
+  while (true) {
+    const configPath = getConfigPath(current);
+    if (await exists(configPath)) {
+      return { root: current, configPath, found: true };
+    }
+    const parent = import_node_path.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return {
+    root: resolvedStart,
+    configPath: getConfigPath(resolvedStart),
+    found: false
+  };
 }
 async function loadConfig(root) {
   const configPath = getConfigPath(root);
   const issues = [];
   let parsed;
   try {
-    const raw = await (0, import_promises2.readFile)(configPath, "utf-8");
+    const raw = await (0, import_promises.readFile)(configPath, "utf-8");
     parsed = (0, import_yaml.parse)(raw);
   } catch (error2) {
     if (isMissingFile(error2)) {
@@ -242,7 +113,7 @@ async function loadConfig(root) {
   return { config: normalized, issues, configPath };
 }
 function resolvePath(root, config, key) {
-  return import_node_path4.default.resolve(root, config.paths[key]);
+  return import_node_path.default.resolve(root, config.paths[key]);
 }
 function normalizeConfig(raw, configPath, issues) {
   if (!isRecord(raw)) {
@@ -413,10 +284,10 @@ function normalizeValidation(raw, configPath, issues) {
         configPath,
         issues
       ),
-      allowOrphanContracts: readBoolean(
-        traceabilityRaw?.allowOrphanContracts,
-        base.traceability.allowOrphanContracts,
-        "validation.traceability.allowOrphanContracts",
+      orphanContractsPolicy: readOrphanContractsPolicy(
+        traceabilityRaw?.orphanContractsPolicy,
+        base.traceability.orphanContractsPolicy,
+        "validation.traceability.orphanContractsPolicy",
         configPath,
         issues
       ),
@@ -512,6 +383,20 @@ function readTraceabilitySeverity(value, fallback, label, configPath, issues) {
   }
   return fallback;
 }
+function readOrphanContractsPolicy(value, fallback, label, configPath, issues) {
+  if (value === "error" || value === "warning" || value === "allow") {
+    return value;
+  }
+  if (value !== void 0) {
+    issues.push(
+      configIssue(
+        configPath,
+        `${label} \u306F error|warning|allow \u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002`
+      )
+    );
+  }
+  return fallback;
+}
 function configIssue(file, message) {
   return {
     code: "QFAI_CONFIG_INVALID",
@@ -527,6 +412,14 @@ function isMissingFile(error2) {
   }
   return false;
 }
+async function exists(target) {
+  try {
+    await (0, import_promises.access)(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function formatError(error2) {
   if (error2 instanceof Error) {
     return error2.message;
@@ -537,20 +430,12 @@ function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-// src/core/report.ts
-var import_promises15 = require("fs/promises");
-var import_node_path14 = __toESM(require("path"), 1);
-
-// src/core/contractIndex.ts
-var import_promises6 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"), 1);
-
 // src/core/discovery.ts
-var import_promises5 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 
 // src/core/fs.ts
-var import_promises3 = require("fs/promises");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
 var import_fast_glob = __toESM(require("fast-glob"), 1);
 var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -586,9 +471,9 @@ async function collectFilesByGlobs(root, options) {
   });
 }
 async function walk(base, current, ignoreDirs, extensions, out) {
-  const items = await (0, import_promises3.readdir)(current, { withFileTypes: true });
+  const items = await (0, import_promises2.readdir)(current, { withFileTypes: true });
   for (const item of items) {
-    const fullPath = import_node_path5.default.join(current, item.name);
+    const fullPath = import_node_path2.default.join(current, item.name);
     if (item.isDirectory()) {
       if (ignoreDirs.has(item.name)) {
         continue;
@@ -598,7 +483,7 @@ async function walk(base, current, ignoreDirs, extensions, out) {
     }
     if (item.isFile()) {
       if (extensions.length > 0) {
-        const ext = import_node_path5.default.extname(item.name).toLowerCase();
+        const ext = import_node_path2.default.extname(item.name).toLowerCase();
         if (!extensions.includes(ext)) {
           continue;
         }
@@ -609,7 +494,7 @@ async function walk(base, current, ignoreDirs, extensions, out) {
 }
 async function exists2(target) {
   try {
-    await (0, import_promises3.access)(target);
+    await (0, import_promises2.access)(target);
     return true;
   } catch {
     return false;
@@ -617,23 +502,23 @@ async function exists2(target) {
 }
 
 // src/core/specLayout.ts
-var import_promises4 = require("fs/promises");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __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")
+    specPath: import_node_path3.default.join(dir, "spec.md"),
+    deltaPath: import_node_path3.default.join(dir, "delta.md"),
+    scenarioPath: import_node_path3.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));
+    const items = await (0, import_promises3.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_path3.default.join(specsRoot, name));
   } catch (error2) {
     if (isMissingFileError(error2)) {
       return [];
@@ -689,314 +574,65 @@ async function filterExisting(files) {
 }
 async function exists3(target) {
   try {
-    await (0, import_promises5.access)(target);
+    await (0, import_promises4.access)(target);
     return true;
   } catch {
     return false;
   }
 }
 
-// src/core/contractsDecl.ts
-var CONTRACT_DECLARATION_RE = /^\s*(?:#|\/\/|--|\/\*+|\*+)?\s*QFAI-CONTRACT-ID:\s*((?:API|UI|DB)-\d{4})\s*(?:\*\/)?\s*$/gm;
-var CONTRACT_DECLARATION_LINE_RE = /^\s*(?:#|\/\/|--|\/\*+|\*+)?\s*QFAI-CONTRACT-ID:\s*(?:API|UI|DB)-\d{4}\s*(?:\*\/)?\s*$/;
-function extractDeclaredContractIds(text) {
-  const ids = [];
-  for (const match of text.matchAll(CONTRACT_DECLARATION_RE)) {
-    const id = match[1];
-    if (id) {
-      ids.push(id);
-    }
+// src/core/paths.ts
+var import_node_path4 = __toESM(require("path"), 1);
+function toRelativePath(root, target) {
+  if (!target) {
+    return target;
   }
-  return ids;
+  if (!import_node_path4.default.isAbsolute(target)) {
+    return toPosixPath(target);
+  }
+  const relative = import_node_path4.default.relative(root, target);
+  if (!relative) {
+    return ".";
+  }
+  return toPosixPath(relative);
 }
-function stripContractDeclarationLines(text) {
-  return text.split(/\r?\n/).filter((line) => !CONTRACT_DECLARATION_LINE_RE.test(line)).join("\n");
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
 }
 
-// src/core/contractIndex.ts
-async function buildContractIndex(root, config) {
-  const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = import_node_path7.default.join(contractsRoot, "ui");
-  const apiRoot = import_node_path7.default.join(contractsRoot, "api");
-  const dbRoot = import_node_path7.default.join(contractsRoot, "db");
-  const [uiFiles, apiFiles, dbFiles] = await Promise.all([
-    collectUiContractFiles(uiRoot),
-    collectApiContractFiles(apiRoot),
-    collectDbContractFiles(dbRoot)
-  ]);
-  const index = {
-    ids: /* @__PURE__ */ new Set(),
-    idToFiles: /* @__PURE__ */ new Map(),
-    files: { ui: uiFiles, api: apiFiles, db: dbFiles }
-  };
-  await indexContractFiles(uiFiles, index);
-  await indexContractFiles(apiFiles, index);
-  await indexContractFiles(dbFiles, index);
-  return index;
-}
-async function indexContractFiles(files, index) {
-  for (const file of files) {
-    const text = await (0, import_promises6.readFile)(file, "utf-8");
-    extractDeclaredContractIds(text).forEach((id) => record(index, id, file));
+// src/core/traceability.ts
+var import_promises5 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
+
+// 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(formatError2(error2));
+    return { gherkinDocument: null, errors };
   }
 }
-function record(index, id, file) {
-  index.ids.add(id);
-  const current = index.idToFiles.get(id) ?? /* @__PURE__ */ new Set();
-  current.add(file);
-  index.idToFiles.set(id, current);
-}
-
-// src/core/ids.ts
-var ID_PREFIXES = ["SPEC", "BR", "SC", "UI", "API", "DB"];
-var STRICT_ID_PATTERNS = {
-  SPEC: /\bSPEC-\d{4}\b/g,
-  BR: /\bBR-\d{4}\b/g,
-  SC: /\bSC-\d{4}\b/g,
-  UI: /\bUI-\d{4}\b/g,
-  API: /\bAPI-\d{4}\b/g,
-  DB: /\bDB-\d{4}\b/g,
-  ADR: /\bADR-\d{4}\b/g
-};
-var LOOSE_ID_PATTERNS = {
-  SPEC: /\bSPEC-[A-Za-z0-9_-]+\b/gi,
-  BR: /\bBR-[A-Za-z0-9_-]+\b/gi,
-  SC: /\bSC-[A-Za-z0-9_-]+\b/gi,
-  UI: /\bUI-[A-Za-z0-9_-]+\b/gi,
-  API: /\bAPI-[A-Za-z0-9_-]+\b/gi,
-  DB: /\bDB-[A-Za-z0-9_-]+\b/gi,
-  ADR: /\bADR-[A-Za-z0-9_-]+\b/gi
-};
-function extractIds(text, prefix) {
-  const pattern = STRICT_ID_PATTERNS[prefix];
-  const matches = text.match(pattern);
-  return unique(matches ?? []);
-}
-function extractAllIds(text) {
-  const all = [];
-  ID_PREFIXES.forEach((prefix) => {
-    all.push(...extractIds(text, prefix));
-  });
-  return unique(all);
-}
-function extractInvalidIds(text, prefixes) {
-  const invalid = [];
-  for (const prefix of prefixes) {
-    const candidates = text.match(LOOSE_ID_PATTERNS[prefix]) ?? [];
-    for (const candidate of candidates) {
-      if (!isValidId(candidate, prefix)) {
-        invalid.push(candidate);
-      }
-    }
-  }
-  return unique(invalid);
-}
-function unique(values) {
-  return Array.from(new Set(values));
-}
-function isValidId(value, prefix) {
-  const pattern = STRICT_ID_PATTERNS[prefix];
-  const strict = new RegExp(pattern.source);
-  return strict.test(value);
-}
-
-// src/core/parse/markdown.ts
-var HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
-function parseHeadings(md) {
-  const lines = md.split(/\r?\n/);
-  const headings = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i] ?? "";
-    const match = line.match(HEADING_RE);
-    if (!match) continue;
-    const levelToken = match[1];
-    const title = match[2];
-    if (!levelToken || !title) continue;
-    headings.push({
-      level: levelToken.length,
-      title: title.trim(),
-      line: i + 1
-    });
-  }
-  return headings;
-}
-function extractH2Sections(md) {
-  const lines = md.split(/\r?\n/);
-  const headings = parseHeadings(md).filter((heading) => heading.level === 2);
-  const sections = /* @__PURE__ */ new Map();
-  for (let i = 0; i < headings.length; i++) {
-    const current = headings[i];
-    if (!current) continue;
-    const next = headings[i + 1];
-    const startLine = current.line + 1;
-    const endLine = (next?.line ?? lines.length + 1) - 1;
-    const body = startLine <= endLine ? lines.slice(startLine - 1, endLine).join("\n") : "";
-    sections.set(current.title.trim(), {
-      title: current.title.trim(),
-      startLine,
-      endLine,
-      body
-    });
-  }
-  return sections;
-}
-
-// src/core/parse/spec.ts
-var SPEC_ID_RE = /\bSPEC-\d{4}\b/;
-var BR_LINE_RE = /^\s*(?:[-*]\s*)?\[(BR-\d{4})\]\[(P[0-3])\]\s*(.+)$/;
-var BR_LINE_ANY_PRIORITY_RE = /^\s*(?:[-*]\s*)?\[(BR-\d{4})\]\[(P[^\]]+)\]\s*(.+)$/;
-var BR_LINE_NO_PRIORITY_RE = /^\s*(?:[-*]\s*)?\[(BR-\d{4})\](?!\s*\[P)\s*(.*\S.*)$/;
-var CONTRACT_REF_LINE_RE = /^[ \t]*QFAI-CONTRACT-REF:[ \t]*([^\r\n]*)[ \t]*$/gm;
-var CONTRACT_REF_ID_RE = /^(?:API|UI|DB)-\d{4}$/;
-var BR_SECTION_TITLE = "\u696D\u52D9\u30EB\u30FC\u30EB";
-var VALID_PRIORITIES = /* @__PURE__ */ new Set(["P0", "P1", "P2", "P3"]);
-function parseSpec(md, file) {
-  const headings = parseHeadings(md);
-  const h1 = headings.find((heading) => heading.level === 1);
-  const specId = h1?.title.match(SPEC_ID_RE)?.[0];
-  const sections = extractH2Sections(md);
-  const sectionNames = new Set(Array.from(sections.keys()));
-  const brSection = sections.get(BR_SECTION_TITLE);
-  const brLines = brSection ? brSection.body.split(/\r?\n/) : [];
-  const startLine = brSection?.startLine ?? 1;
-  const brs = [];
-  const brsWithoutPriority = [];
-  const brsWithInvalidPriority = [];
-  for (let i = 0; i < brLines.length; i++) {
-    const lineText = brLines[i] ?? "";
-    const lineNumber = startLine + i;
-    const validMatch = lineText.match(BR_LINE_RE);
-    if (validMatch) {
-      const id = validMatch[1];
-      const priority = validMatch[2];
-      const text = validMatch[3];
-      if (!id || !priority || !text) continue;
-      brs.push({
-        id,
-        priority,
-        text: text.trim(),
-        line: lineNumber
-      });
-      continue;
-    }
-    const anyPriorityMatch = lineText.match(BR_LINE_ANY_PRIORITY_RE);
-    if (anyPriorityMatch) {
-      const id = anyPriorityMatch[1];
-      const priority = anyPriorityMatch[2];
-      const text = anyPriorityMatch[3];
-      if (!id || !priority || !text) continue;
-      if (!VALID_PRIORITIES.has(priority)) {
-        brsWithInvalidPriority.push({
-          id,
-          priority,
-          text: text.trim(),
-          line: lineNumber
-        });
-      }
-      continue;
-    }
-    const noPriorityMatch = lineText.match(BR_LINE_NO_PRIORITY_RE);
-    if (noPriorityMatch) {
-      const id = noPriorityMatch[1];
-      const text = noPriorityMatch[2];
-      if (!id || !text) continue;
-      brsWithoutPriority.push({
-        id,
-        text: text.trim(),
-        line: lineNumber
-      });
-    }
-  }
-  const parsed = {
-    file,
-    sections: sectionNames,
-    brs,
-    brsWithoutPriority,
-    brsWithInvalidPriority,
-    contractRefs: parseContractRefs(md)
-  };
-  if (specId) {
-    parsed.specId = specId;
-  }
-  return parsed;
-}
-function parseContractRefs(md) {
-  const lines = [];
-  for (const match of md.matchAll(CONTRACT_REF_LINE_RE)) {
-    lines.push((match[1] ?? "").trim());
-  }
-  const ids = [];
-  const invalidTokens = [];
-  let hasNone = false;
-  for (const line of lines) {
-    if (line.length === 0) {
-      invalidTokens.push("(empty)");
-      continue;
-    }
-    const tokens = line.split(",").map((token) => token.trim());
-    for (const token of tokens) {
-      if (token.length === 0) {
-        invalidTokens.push("(empty)");
-        continue;
-      }
-      if (token === "none") {
-        hasNone = true;
-        continue;
-      }
-      if (CONTRACT_REF_ID_RE.test(token)) {
-        ids.push(token);
-        continue;
-      }
-      invalidTokens.push(token);
-    }
-  }
-  return {
-    lines,
-    ids: unique2(ids),
-    invalidTokens: unique2(invalidTokens),
-    hasNone
-  };
-}
-function unique2(values) {
-  return Array.from(new Set(values));
-}
-
-// src/core/traceability.ts
-var import_promises7 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
-
-// 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(formatError2(error2));
-    return { gherkinDocument: null, errors };
-  }
-}
-function formatError2(error2) {
-  if (error2 instanceof Error) {
-    return error2.message;
-  }
-  return String(error2);
+function formatError2(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 DB_TAG_RE = /^DB-\d{4}$/;
 function parseScenarioDocument(text, uri) {
   const { gherkinDocument, errors } = parseGherkin(text, uri);
   if (!gherkinDocument) {
@@ -1021,31 +657,21 @@ function parseScenarioDocument(text, uri) {
     errors
   };
 }
-function buildScenarioAtoms(document) {
+function buildScenarioAtoms(document, contractIds = []) {
+  const uniqueContractIds = unique(contractIds).sort(
+    (a, b) => a.localeCompare(b)
+  );
   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 = unique3(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) || DB_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, "DB").forEach((id) => contractIds.add(id));
-      }
-    }
+    const brIds = unique(scenario.tags.filter((tag) => BR_TAG_RE.test(tag)));
     const atom = {
       uri: document.uri,
       featureName: document.featureName ?? "",
       scenarioName: scenario.name,
       kind: scenario.kind,
       brIds,
-      contractIds: Array.from(contractIds).sort()
+      contractIds: uniqueContractIds
     };
     if (scenario.line !== void 0) {
       atom.line = scenario.line;
@@ -1098,24 +724,7 @@ function buildScenarioNode(scenario, featureTags, ruleTags) {
 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 unique3(values) {
+function unique(values) {
   return Array.from(new Set(values));
 }
 
@@ -1145,7 +754,7 @@ function extractAnnotatedScIds(text) {
 async function collectScIdsFromScenarioFiles(scenarioFiles) {
   const scIds = /* @__PURE__ */ new Set();
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises7.readFile)(file, "utf-8");
+    const text = await (0, import_promises5.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -1163,7 +772,7 @@ async function collectScIdsFromScenarioFiles(scenarioFiles) {
 async function collectScIdSourcesFromScenarioFiles(scenarioFiles) {
   const sources = /* @__PURE__ */ new Map();
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises7.readFile)(file, "utf-8");
+    const text = await (0, import_promises5.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -1216,10 +825,10 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
     };
   }
   const normalizedFiles = Array.from(
-    new Set(files.map((file) => import_node_path8.default.normalize(file)))
+    new Set(files.map((file) => import_node_path5.default.normalize(file)))
   );
   for (const file of normalizedFiles) {
-    const text = await (0, import_promises7.readFile)(file, "utf-8");
+    const text = await (0, import_promises5.readFile)(file, "utf-8");
     const scIds = extractAnnotatedScIds(text);
     if (scIds.length === 0) {
       continue;
@@ -1229,85 +838,772 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
       current.add(file);
       refs.set(scId, current);
     }
-  }
-  return {
-    refs,
-    scan: {
-      globs: normalizedGlobs,
-      excludeGlobs: mergedExcludeGlobs,
-      matchedFileCount: normalizedFiles.length
+  }
+  return {
+    refs,
+    scan: {
+      globs: normalizedGlobs,
+      excludeGlobs: mergedExcludeGlobs,
+      matchedFileCount: normalizedFiles.length
+    }
+  };
+}
+function buildScCoverage(scIds, refs) {
+  const sortedScIds = toSortedArray(scIds);
+  const refsRecord = {};
+  const missingIds = [];
+  let covered = 0;
+  for (const scId of sortedScIds) {
+    const files = refs.get(scId);
+    const sortedFiles = files ? toSortedArray(files) : [];
+    refsRecord[scId] = sortedFiles;
+    if (sortedFiles.length === 0) {
+      missingIds.push(scId);
+    } else {
+      covered += 1;
+    }
+  }
+  return {
+    total: sortedScIds.length,
+    covered,
+    missing: missingIds.length,
+    missingIds,
+    refs: refsRecord
+  };
+}
+function toSortedArray(values) {
+  return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
+}
+function normalizeGlobs(globs) {
+  return globs.map((glob) => glob.trim()).filter((glob) => glob.length > 0);
+}
+function formatError3(error2) {
+  if (error2 instanceof Error) {
+    return error2.message;
+  }
+  return String(error2);
+}
+
+// src/core/version.ts
+var import_promises6 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+async function resolveToolVersion() {
+  if ("0.6.0".length > 0) {
+    return "0.6.0";
+  }
+  try {
+    const packagePath = resolvePackageJsonPath();
+    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";
+  } catch {
+    return "unknown";
+  }
+}
+function resolvePackageJsonPath() {
+  const base = __filename;
+  const basePath = base.startsWith("file:") ? (0, import_node_url.fileURLToPath)(base) : base;
+  return import_node_path6.default.resolve(import_node_path6.default.dirname(basePath), "../../package.json");
+}
+
+// src/core/doctor.ts
+async function exists4(target) {
+  try {
+    await (0, import_promises7.access)(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function addCheck(checks, check) {
+  checks.push(check);
+}
+function summarize(checks) {
+  const summary = { ok: 0, warning: 0, error: 0 };
+  for (const check of checks) {
+    summary[check.severity] += 1;
+  }
+  return summary;
+}
+function normalizeGlobs2(values) {
+  return values.map((glob) => glob.trim()).filter((glob) => glob.length > 0);
+}
+async function createDoctorData(options) {
+  const startDir = import_node_path7.default.resolve(options.startDir);
+  const checks = [];
+  const configPath = getConfigPath(startDir);
+  const search = options.rootExplicit ? {
+    root: startDir,
+    configPath,
+    found: await exists4(configPath)
+  } : await findConfigRoot(startDir);
+  const root = search.root;
+  const version = await resolveToolVersion();
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  addCheck(checks, {
+    id: "config.search",
+    severity: search.found ? "ok" : "warning",
+    title: "Config search",
+    message: search.found ? "qfai.config.yaml found" : "qfai.config.yaml not found (default config will be used)",
+    details: { configPath: toRelativePath(root, search.configPath) }
+  });
+  const {
+    config,
+    issues,
+    configPath: resolvedConfigPath
+  } = await loadConfig(root);
+  if (issues.length === 0) {
+    addCheck(checks, {
+      id: "config.load",
+      severity: "ok",
+      title: "Config load",
+      message: "Loaded and normalized with 0 issues",
+      details: { configPath: toRelativePath(root, resolvedConfigPath) }
+    });
+  } else {
+    addCheck(checks, {
+      id: "config.load",
+      severity: "warning",
+      title: "Config load",
+      message: `Loaded with ${issues.length} issue(s) (normalized with defaults when needed)`,
+      details: {
+        configPath: toRelativePath(root, resolvedConfigPath),
+        issues
+      }
+    });
+  }
+  const pathKeys = [
+    "specsDir",
+    "contractsDir",
+    "outDir",
+    "srcDir",
+    "testsDir",
+    "rulesDir",
+    "promptsDir"
+  ];
+  for (const key of pathKeys) {
+    const resolved = resolvePath(root, config, key);
+    const ok = await exists4(resolved);
+    addCheck(checks, {
+      id: `paths.${key}`,
+      severity: ok ? "ok" : "warning",
+      title: `Path exists: ${key}`,
+      message: ok ? `${key} exists` : `${key} is missing (did you run 'qfai init'?)`,
+      details: { path: toRelativePath(root, resolved) }
+    });
+  }
+  const specsRoot = resolvePath(root, config, "specsDir");
+  const entries = await collectSpecEntries(specsRoot);
+  let missingFiles = 0;
+  for (const entry of entries) {
+    const requiredFiles = [entry.specPath, entry.deltaPath, entry.scenarioPath];
+    for (const filePath of requiredFiles) {
+      if (!await exists4(filePath)) {
+        missingFiles += 1;
+      }
+    }
+  }
+  addCheck(checks, {
+    id: "spec.layout",
+    severity: missingFiles === 0 ? "ok" : "warning",
+    title: "Spec pack shape",
+    message: missingFiles === 0 ? `All spec packs have required files (count=${entries.length})` : `Missing required files in spec packs (missingFiles=${missingFiles})`,
+    details: { specPacks: entries.length, missingFiles }
+  });
+  const validateJsonAbs = import_node_path7.default.isAbsolute(config.output.validateJsonPath) ? config.output.validateJsonPath : import_node_path7.default.resolve(root, config.output.validateJsonPath);
+  const validateJsonExists = await exists4(validateJsonAbs);
+  addCheck(checks, {
+    id: "output.validateJson",
+    severity: validateJsonExists ? "ok" : "warning",
+    title: "validate.json",
+    message: validateJsonExists ? "validate.json exists (report can run)" : "validate.json is missing (run 'qfai validate' before 'qfai report')",
+    details: { path: toRelativePath(root, validateJsonAbs) }
+  });
+  const scenarioFiles = await collectScenarioFiles(specsRoot);
+  const globs = normalizeGlobs2(config.validation.traceability.testFileGlobs);
+  const exclude = normalizeGlobs2([
+    ...DEFAULT_TEST_FILE_EXCLUDE_GLOBS,
+    ...config.validation.traceability.testFileExcludeGlobs
+  ]);
+  try {
+    const matched = globs.length === 0 ? [] : await collectFilesByGlobs(root, { globs, ignore: exclude });
+    const matchedCount = matched.length;
+    const severity = globs.length === 0 ? "warning" : scenarioFiles.length > 0 && config.validation.traceability.scMustHaveTest && matchedCount === 0 ? "warning" : "ok";
+    addCheck(checks, {
+      id: "traceability.testGlobs",
+      severity,
+      title: "Test file globs",
+      message: globs.length === 0 ? "testFileGlobs is empty (SC\u2192Test cannot be verified)" : `matchedFileCount=${matchedCount}`,
+      details: {
+        globs,
+        excludeGlobs: exclude,
+        scenarioFiles: scenarioFiles.length,
+        scMustHaveTest: config.validation.traceability.scMustHaveTest
+      }
+    });
+  } catch (error2) {
+    addCheck(checks, {
+      id: "traceability.testGlobs",
+      severity: "error",
+      title: "Test file globs",
+      message: "Glob scan failed (invalid pattern or filesystem error)",
+      details: { globs, excludeGlobs: exclude, error: String(error2) }
+    });
+  }
+  const outDirAbs = resolvePath(root, config, "outDir");
+  const rel = import_node_path7.default.relative(outDirAbs, validateJsonAbs);
+  const inside = rel !== "" && !rel.startsWith("..") && !import_node_path7.default.isAbsolute(rel);
+  addCheck(checks, {
+    id: "output.pathAlignment",
+    severity: inside ? "ok" : "warning",
+    title: "Output path alignment",
+    message: inside ? "validateJsonPath is under outDir" : "validateJsonPath is not under outDir (may be intended, but check configuration)",
+    details: {
+      outDir: toRelativePath(root, outDirAbs),
+      validateJsonPath: toRelativePath(root, validateJsonAbs)
+    }
+  });
+  return {
+    tool: "qfai",
+    version,
+    doctorFormatVersion: 1,
+    generatedAt,
+    root: toRelativePath(process.cwd(), root),
+    config: {
+      startDir: toRelativePath(process.cwd(), startDir),
+      found: search.found,
+      configPath: toRelativePath(root, search.configPath) || "qfai.config.yaml"
+    },
+    summary: summarize(checks),
+    checks
+  };
+}
+
+// src/cli/lib/logger.ts
+function info(message) {
+  process.stdout.write(`${message}
+`);
+}
+function warn(message) {
+  process.stdout.write(`${message}
+`);
+}
+function error(message) {
+  process.stderr.write(`${message}
+`);
+}
+
+// src/cli/commands/doctor.ts
+function formatDoctorText(data) {
+  const lines = [];
+  lines.push(
+    `qfai doctor: root=${data.root} config=${data.config.configPath} (${data.config.found ? "found" : "missing"})`
+  );
+  for (const check of data.checks) {
+    lines.push(`[${check.severity}] ${check.id}: ${check.message}`);
+  }
+  lines.push(
+    `summary: ok=${data.summary.ok} warning=${data.summary.warning} error=${data.summary.error}`
+  );
+  return lines.join("\n");
+}
+function formatDoctorJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+async function runDoctor(options) {
+  const data = await createDoctorData({
+    startDir: options.root,
+    rootExplicit: options.rootExplicit
+  });
+  const output = options.format === "json" ? formatDoctorJson(data) : formatDoctorText(data);
+  if (options.outPath) {
+    const outAbs = import_node_path8.default.isAbsolute(options.outPath) ? options.outPath : import_node_path8.default.resolve(process.cwd(), options.outPath);
+    await (0, import_promises8.mkdir)(import_node_path8.default.dirname(outAbs), { recursive: true });
+    await (0, import_promises8.writeFile)(outAbs, `${output}
+`, "utf-8");
+    info(`doctor: wrote ${outAbs}`);
+    return;
+  }
+  info(output);
+}
+
+// src/cli/commands/init.ts
+var import_node_path11 = __toESM(require("path"), 1);
+
+// src/cli/lib/fs.ts
+var import_promises9 = require("fs/promises");
+var import_node_path9 = __toESM(require("path"), 1);
+async function copyTemplateTree(sourceRoot, destRoot, options) {
+  const files = await collectTemplateFiles(sourceRoot);
+  return copyFiles(files, sourceRoot, destRoot, options);
+}
+async function copyFiles(files, sourceRoot, destRoot, options) {
+  const copied = [];
+  const skipped = [];
+  const conflicts = [];
+  if (!options.force) {
+    for (const file of files) {
+      const relative = import_node_path9.default.relative(sourceRoot, file);
+      const dest = import_node_path9.default.join(destRoot, relative);
+      if (!await shouldWrite(dest, options.force)) {
+        conflicts.push(dest);
+      }
+    }
+    if (conflicts.length > 0) {
+      throw new Error(formatConflictMessage(conflicts));
+    }
+  }
+  for (const file of files) {
+    const relative = import_node_path9.default.relative(sourceRoot, file);
+    const dest = import_node_path9.default.join(destRoot, relative);
+    if (!await shouldWrite(dest, options.force)) {
+      skipped.push(dest);
+      continue;
+    }
+    if (!options.dryRun) {
+      await (0, import_promises9.mkdir)(import_node_path9.default.dirname(dest), { recursive: true });
+      await (0, import_promises9.copyFile)(file, dest);
+    }
+    copied.push(dest);
+  }
+  return { copied, skipped };
+}
+function formatConflictMessage(conflicts) {
+  return [
+    "\u65E2\u5B58\u30D5\u30A1\u30A4\u30EB\u3068\u885D\u7A81\u3057\u307E\u3057\u305F\u3002\u5B89\u5168\u306E\u305F\u3081\u505C\u6B62\u3057\u307E\u3059\u3002",
+    "",
+    "\u885D\u7A81\u30D5\u30A1\u30A4\u30EB:",
+    ...conflicts.map((conflict) => `- ${conflict}`),
+    "",
+    "\u4E0A\u66F8\u304D\u3057\u3066\u7D9A\u884C\u3059\u308B\u5834\u5408\u306F --force \u3092\u4ED8\u3051\u3066\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+  ].join("\n");
+}
+async function collectTemplateFiles(root) {
+  const entries = [];
+  if (!await exists5(root)) {
+    return entries;
+  }
+  const items = await (0, import_promises9.readdir)(root, { withFileTypes: true });
+  for (const item of items) {
+    const fullPath = import_node_path9.default.join(root, item.name);
+    if (item.isDirectory()) {
+      const nested = await collectTemplateFiles(fullPath);
+      entries.push(...nested);
+      continue;
+    }
+    if (item.isFile()) {
+      entries.push(fullPath);
+    }
+  }
+  return entries;
+}
+async function shouldWrite(target, force) {
+  if (force) {
+    return true;
+  }
+  return !await exists5(target);
+}
+async function exists5(target) {
+  try {
+    await (0, import_promises9.access)(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/lib/assets.ts
+var import_node_fs = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+function getInitAssetsDir() {
+  const base = __filename;
+  const basePath = base.startsWith("file:") ? (0, import_node_url2.fileURLToPath)(base) : base;
+  const baseDir = import_node_path10.default.dirname(basePath);
+  const candidates = [
+    import_node_path10.default.resolve(baseDir, "../../../assets/init"),
+    import_node_path10.default.resolve(baseDir, "../../assets/init")
+  ];
+  for (const candidate of candidates) {
+    if ((0, import_node_fs.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    [
+      "init \u7528\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002Template assets not found.",
+      "\u78BA\u8A8D\u3057\u305F\u30D1\u30B9 / Checked paths:",
+      ...candidates.map((candidate) => `- ${candidate}`)
+    ].join("\n")
+  );
+}
+
+// src/cli/commands/init.ts
+async function runInit(options) {
+  const assetsRoot = getInitAssetsDir();
+  const rootAssets = import_node_path11.default.join(assetsRoot, "root");
+  const qfaiAssets = import_node_path11.default.join(assetsRoot, ".qfai");
+  const destRoot = import_node_path11.default.resolve(options.dir);
+  const destQfai = import_node_path11.default.join(destRoot, ".qfai");
+  const rootResult = await copyTemplateTree(rootAssets, destRoot, {
+    force: options.force,
+    dryRun: options.dryRun
+  });
+  const qfaiResult = await copyTemplateTree(qfaiAssets, destQfai, {
+    force: options.force,
+    dryRun: options.dryRun
+  });
+  report(
+    [...rootResult.copied, ...qfaiResult.copied],
+    [...rootResult.skipped, ...qfaiResult.skipped],
+    options.dryRun,
+    "init"
+  );
+}
+function report(copied, skipped, dryRun, label) {
+  info(`qfai ${label}: ${dryRun ? "dry-run" : "done"}`);
+  if (copied.length > 0) {
+    info(`  created: ${copied.length}`);
+  }
+  if (skipped.length > 0) {
+    info(`  skipped: ${skipped.length}`);
+  }
+}
+
+// src/cli/commands/report.ts
+var import_promises18 = require("fs/promises");
+var import_node_path18 = __toESM(require("path"), 1);
+
+// src/core/normalize.ts
+function normalizeIssuePaths(root, issues) {
+  return issues.map((issue7) => {
+    if (!issue7.file) {
+      return issue7;
+    }
+    const normalized = toRelativePath(root, issue7.file);
+    if (normalized === issue7.file) {
+      return issue7;
+    }
+    return {
+      ...issue7,
+      file: normalized
+    };
+  });
+}
+function normalizeScCoverage(root, sc) {
+  const refs = {};
+  for (const [scId, files] of Object.entries(sc.refs)) {
+    refs[scId] = files.map((file) => toRelativePath(root, file));
+  }
+  return {
+    ...sc,
+    refs
+  };
+}
+function normalizeValidationResult(root, result) {
+  return {
+    ...result,
+    issues: normalizeIssuePaths(root, result.issues),
+    traceability: {
+      ...result.traceability,
+      sc: normalizeScCoverage(root, result.traceability.sc)
+    }
+  };
+}
+
+// src/core/report.ts
+var import_promises17 = require("fs/promises");
+var import_node_path17 = __toESM(require("path"), 1);
+
+// src/core/contractIndex.ts
+var import_promises10 = require("fs/promises");
+var import_node_path12 = __toESM(require("path"), 1);
+
+// src/core/contractsDecl.ts
+var CONTRACT_DECLARATION_RE = /^\s*(?:#|\/\/|--|\/\*+|\*+)?\s*QFAI-CONTRACT-ID:\s*((?:API|UI|DB)-\d{4})\s*(?:\*\/)?\s*$/gm;
+var CONTRACT_DECLARATION_LINE_RE = /^\s*(?:#|\/\/|--|\/\*+|\*+)?\s*QFAI-CONTRACT-ID:\s*(?:API|UI|DB)-\d{4}\s*(?:\*\/)?\s*$/;
+function extractDeclaredContractIds(text) {
+  const ids = [];
+  for (const match of text.matchAll(CONTRACT_DECLARATION_RE)) {
+    const id = match[1];
+    if (id) {
+      ids.push(id);
+    }
+  }
+  return ids;
+}
+function stripContractDeclarationLines(text) {
+  return text.split(/\r?\n/).filter((line) => !CONTRACT_DECLARATION_LINE_RE.test(line)).join("\n");
+}
+
+// src/core/contractIndex.ts
+async function buildContractIndex(root, config) {
+  const contractsRoot = resolvePath(root, config, "contractsDir");
+  const uiRoot = import_node_path12.default.join(contractsRoot, "ui");
+  const apiRoot = import_node_path12.default.join(contractsRoot, "api");
+  const dbRoot = import_node_path12.default.join(contractsRoot, "db");
+  const [uiFiles, apiFiles, dbFiles] = await Promise.all([
+    collectUiContractFiles(uiRoot),
+    collectApiContractFiles(apiRoot),
+    collectDbContractFiles(dbRoot)
+  ]);
+  const index = {
+    ids: /* @__PURE__ */ new Set(),
+    idToFiles: /* @__PURE__ */ new Map(),
+    files: { ui: uiFiles, api: apiFiles, db: dbFiles }
+  };
+  await indexContractFiles(uiFiles, index);
+  await indexContractFiles(apiFiles, index);
+  await indexContractFiles(dbFiles, index);
+  return index;
+}
+async function indexContractFiles(files, index) {
+  for (const file of files) {
+    const text = await (0, import_promises10.readFile)(file, "utf-8");
+    extractDeclaredContractIds(text).forEach((id) => record(index, id, file));
+  }
+}
+function record(index, id, file) {
+  index.ids.add(id);
+  const current = index.idToFiles.get(id) ?? /* @__PURE__ */ new Set();
+  current.add(file);
+  index.idToFiles.set(id, current);
+}
+
+// src/core/ids.ts
+var ID_PREFIXES = ["SPEC", "BR", "SC", "UI", "API", "DB"];
+var STRICT_ID_PATTERNS = {
+  SPEC: /\bSPEC-\d{4}\b/g,
+  BR: /\bBR-\d{4}\b/g,
+  SC: /\bSC-\d{4}\b/g,
+  UI: /\bUI-\d{4}\b/g,
+  API: /\bAPI-\d{4}\b/g,
+  DB: /\bDB-\d{4}\b/g,
+  ADR: /\bADR-\d{4}\b/g
+};
+var LOOSE_ID_PATTERNS = {
+  SPEC: /\bSPEC-[A-Za-z0-9_-]+\b/gi,
+  BR: /\bBR-[A-Za-z0-9_-]+\b/gi,
+  SC: /\bSC-[A-Za-z0-9_-]+\b/gi,
+  UI: /\bUI-[A-Za-z0-9_-]+\b/gi,
+  API: /\bAPI-[A-Za-z0-9_-]+\b/gi,
+  DB: /\bDB-[A-Za-z0-9_-]+\b/gi,
+  ADR: /\bADR-[A-Za-z0-9_-]+\b/gi
+};
+function extractIds(text, prefix) {
+  const pattern = STRICT_ID_PATTERNS[prefix];
+  const matches = text.match(pattern);
+  return unique2(matches ?? []);
+}
+function extractAllIds(text) {
+  const all = [];
+  ID_PREFIXES.forEach((prefix) => {
+    all.push(...extractIds(text, prefix));
+  });
+  return unique2(all);
+}
+function extractInvalidIds(text, prefixes) {
+  const invalid = [];
+  for (const prefix of prefixes) {
+    const candidates = text.match(LOOSE_ID_PATTERNS[prefix]) ?? [];
+    for (const candidate of candidates) {
+      if (!isValidId(candidate, prefix)) {
+        invalid.push(candidate);
+      }
+    }
+  }
+  return unique2(invalid);
+}
+function unique2(values) {
+  return Array.from(new Set(values));
+}
+function isValidId(value, prefix) {
+  const pattern = STRICT_ID_PATTERNS[prefix];
+  const strict = new RegExp(pattern.source);
+  return strict.test(value);
+}
+
+// src/core/parse/contractRefs.ts
+var CONTRACT_REF_ID_RE = /^(?:API|UI|DB)-\d{4}$/;
+function parseContractRefs(text, options = {}) {
+  const linePattern = buildLinePattern(options);
+  const lines = [];
+  for (const match of text.matchAll(linePattern)) {
+    lines.push((match[1] ?? "").trim());
+  }
+  const ids = [];
+  const invalidTokens = [];
+  let hasNone = false;
+  for (const line of lines) {
+    if (line.length === 0) {
+      invalidTokens.push("(empty)");
+      continue;
+    }
+    const tokens = line.split(",").map((token) => token.trim());
+    for (const token of tokens) {
+      if (token.length === 0) {
+        invalidTokens.push("(empty)");
+        continue;
+      }
+      if (token === "none") {
+        hasNone = true;
+        continue;
+      }
+      if (CONTRACT_REF_ID_RE.test(token)) {
+        ids.push(token);
+        continue;
+      }
+      invalidTokens.push(token);
+    }
+  }
+  return {
+    lines,
+    ids: unique3(ids),
+    invalidTokens: unique3(invalidTokens),
+    hasNone
+  };
+}
+function buildLinePattern(options) {
+  const prefix = options.allowCommentPrefix ? "#" : "";
+  return new RegExp(
+    `^[ \\t]*${prefix}[ \\t]*QFAI-CONTRACT-REF:[ \\t]*([^\\r\\n]*)[ \\t]*$`,
+    "gm"
+  );
+}
+function unique3(values) {
+  return Array.from(new Set(values));
+}
+
+// src/core/parse/markdown.ts
+var HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+function parseHeadings(md) {
+  const lines = md.split(/\r?\n/);
+  const headings = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const match = line.match(HEADING_RE);
+    if (!match) continue;
+    const levelToken = match[1];
+    const title = match[2];
+    if (!levelToken || !title) continue;
+    headings.push({
+      level: levelToken.length,
+      title: title.trim(),
+      line: i + 1
+    });
+  }
+  return headings;
+}
+function extractH2Sections(md) {
+  const lines = md.split(/\r?\n/);
+  const headings = parseHeadings(md).filter((heading) => heading.level === 2);
+  const sections = /* @__PURE__ */ new Map();
+  for (let i = 0; i < headings.length; i++) {
+    const current = headings[i];
+    if (!current) continue;
+    const next = headings[i + 1];
+    const startLine = current.line + 1;
+    const endLine = (next?.line ?? lines.length + 1) - 1;
+    const body = startLine <= endLine ? lines.slice(startLine - 1, endLine).join("\n") : "";
+    sections.set(current.title.trim(), {
+      title: current.title.trim(),
+      startLine,
+      endLine,
+      body
+    });
+  }
+  return sections;
+}
+
+// src/core/parse/spec.ts
+var SPEC_ID_RE = /\bSPEC-\d{4}\b/;
+var BR_LINE_RE = /^\s*(?:[-*]\s*)?\[(BR-\d{4})\]\[(P[0-3])\]\s*(.+)$/;
+var BR_LINE_ANY_PRIORITY_RE = /^\s*(?:[-*]\s*)?\[(BR-\d{4})\]\[(P[^\]]+)\]\s*(.+)$/;
+var BR_LINE_NO_PRIORITY_RE = /^\s*(?:[-*]\s*)?\[(BR-\d{4})\](?!\s*\[P)\s*(.*\S.*)$/;
+var BR_SECTION_TITLE = "\u696D\u52D9\u30EB\u30FC\u30EB";
+var VALID_PRIORITIES = /* @__PURE__ */ new Set(["P0", "P1", "P2", "P3"]);
+function parseSpec(md, file) {
+  const headings = parseHeadings(md);
+  const h1 = headings.find((heading) => heading.level === 1);
+  const specId = h1?.title.match(SPEC_ID_RE)?.[0];
+  const sections = extractH2Sections(md);
+  const sectionNames = new Set(Array.from(sections.keys()));
+  const brSection = sections.get(BR_SECTION_TITLE);
+  const brLines = brSection ? brSection.body.split(/\r?\n/) : [];
+  const startLine = brSection?.startLine ?? 1;
+  const brs = [];
+  const brsWithoutPriority = [];
+  const brsWithInvalidPriority = [];
+  for (let i = 0; i < brLines.length; i++) {
+    const lineText = brLines[i] ?? "";
+    const lineNumber = startLine + i;
+    const validMatch = lineText.match(BR_LINE_RE);
+    if (validMatch) {
+      const id = validMatch[1];
+      const priority = validMatch[2];
+      const text = validMatch[3];
+      if (!id || !priority || !text) continue;
+      brs.push({
+        id,
+        priority,
+        text: text.trim(),
+        line: lineNumber
+      });
+      continue;
+    }
+    const anyPriorityMatch = lineText.match(BR_LINE_ANY_PRIORITY_RE);
+    if (anyPriorityMatch) {
+      const id = anyPriorityMatch[1];
+      const priority = anyPriorityMatch[2];
+      const text = anyPriorityMatch[3];
+      if (!id || !priority || !text) continue;
+      if (!VALID_PRIORITIES.has(priority)) {
+        brsWithInvalidPriority.push({
+          id,
+          priority,
+          text: text.trim(),
+          line: lineNumber
+        });
+      }
+      continue;
     }
-  };
-}
-function buildScCoverage(scIds, refs) {
-  const sortedScIds = toSortedArray(scIds);
-  const refsRecord = {};
-  const missingIds = [];
-  let covered = 0;
-  for (const scId of sortedScIds) {
-    const files = refs.get(scId);
-    const sortedFiles = files ? toSortedArray(files) : [];
-    refsRecord[scId] = sortedFiles;
-    if (sortedFiles.length === 0) {
-      missingIds.push(scId);
-    } else {
-      covered += 1;
+    const noPriorityMatch = lineText.match(BR_LINE_NO_PRIORITY_RE);
+    if (noPriorityMatch) {
+      const id = noPriorityMatch[1];
+      const text = noPriorityMatch[2];
+      if (!id || !text) continue;
+      brsWithoutPriority.push({
+        id,
+        text: text.trim(),
+        line: lineNumber
+      });
     }
   }
-  return {
-    total: sortedScIds.length,
-    covered,
-    missing: missingIds.length,
-    missingIds,
-    refs: refsRecord
+  const parsed = {
+    file,
+    sections: sectionNames,
+    brs,
+    brsWithoutPriority,
+    brsWithInvalidPriority,
+    contractRefs: parseContractRefs(md)
   };
-}
-function toSortedArray(values) {
-  return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
-}
-function normalizeGlobs(globs) {
-  return globs.map((glob) => glob.trim()).filter((glob) => glob.length > 0);
-}
-function formatError3(error2) {
-  if (error2 instanceof Error) {
-    return error2.message;
-  }
-  return String(error2);
-}
-
-// src/core/version.ts
-var import_promises8 = require("fs/promises");
-var import_node_path9 = __toESM(require("path"), 1);
-var import_node_url2 = require("url");
-async function resolveToolVersion() {
-  if ("0.5.0".length > 0) {
-    return "0.5.0";
-  }
-  try {
-    const packagePath = resolvePackageJsonPath();
-    const raw = await (0, import_promises8.readFile)(packagePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    const version = typeof parsed.version === "string" ? parsed.version : "";
-    return version.length > 0 ? version : "unknown";
-  } catch {
-    return "unknown";
+  if (specId) {
+    parsed.specId = specId;
   }
-}
-function resolvePackageJsonPath() {
-  const base = __filename;
-  const basePath = base.startsWith("file:") ? (0, import_node_url2.fileURLToPath)(base) : base;
-  return import_node_path9.default.resolve(import_node_path9.default.dirname(basePath), "../../package.json");
+  return parsed;
 }
 
 // src/core/validators/contracts.ts
-var import_promises9 = require("fs/promises");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_promises11 = require("fs/promises");
+var import_node_path14 = __toESM(require("path"), 1);
 
 // src/core/contracts.ts
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var import_yaml2 = require("yaml");
 function parseStructuredContract(file, text) {
-  const ext = import_node_path10.default.extname(file).toLowerCase();
+  const ext = import_node_path13.default.extname(file).toLowerCase();
   if (ext === ".json") {
     return JSON.parse(text);
   }
@@ -1327,9 +1623,9 @@ var SQL_DANGEROUS_PATTERNS = [
 async function validateContracts(root, config) {
   const issues = [];
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  issues.push(...await validateUiContracts(import_node_path11.default.join(contractsRoot, "ui")));
-  issues.push(...await validateApiContracts(import_node_path11.default.join(contractsRoot, "api")));
-  issues.push(...await validateDbContracts(import_node_path11.default.join(contractsRoot, "db")));
+  issues.push(...await validateUiContracts(import_node_path14.default.join(contractsRoot, "ui")));
+  issues.push(...await validateApiContracts(import_node_path14.default.join(contractsRoot, "api")));
+  issues.push(...await validateDbContracts(import_node_path14.default.join(contractsRoot, "db")));
   const contractIndex = await buildContractIndex(root, config);
   issues.push(...validateDuplicateContractIds(contractIndex));
   return issues;
@@ -1349,7 +1645,7 @@ async function validateUiContracts(uiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises9.readFile)(file, "utf-8");
+    const text = await (0, import_promises11.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1404,7 +1700,7 @@ async function validateApiContracts(apiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises9.readFile)(file, "utf-8");
+    const text = await (0, import_promises11.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1472,7 +1768,7 @@ async function validateDbContracts(dbRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises9.readFile)(file, "utf-8");
+    const text = await (0, import_promises11.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1611,8 +1907,8 @@ function issue(code, message, severity, file, rule, refs) {
 }
 
 // src/core/validators/delta.ts
-var import_promises10 = require("fs/promises");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_promises12 = require("fs/promises");
+var import_node_path15 = __toESM(require("path"), 1);
 var SECTION_RE = /^##\s+変更区分/m;
 var COMPAT_LINE_RE = /^\s*-\s*\[[ xX]\]\s*Compatibility\b/m;
 var CHANGE_LINE_RE = /^\s*-\s*\[[ xX]\]\s*Change\/Improvement\b/m;
@@ -1626,10 +1922,10 @@ async function validateDeltas(root, config) {
   }
   const issues = [];
   for (const pack of packs) {
-    const deltaPath = import_node_path12.default.join(pack, "delta.md");
+    const deltaPath = import_node_path15.default.join(pack, "delta.md");
     let text;
     try {
-      text = await (0, import_promises10.readFile)(deltaPath, "utf-8");
+      text = await (0, import_promises12.readFile)(deltaPath, "utf-8");
     } catch (error2) {
       if (isMissingFileError2(error2)) {
         issues.push(
@@ -1701,8 +1997,8 @@ function issue2(code, message, severity, file, rule, refs) {
 }
 
 // src/core/validators/ids.ts
-var import_promises11 = require("fs/promises");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_promises13 = require("fs/promises");
+var import_node_path16 = __toESM(require("path"), 1);
 var SC_TAG_RE3 = /^SC-\d{4}$/;
 async function validateDefinedIds(root, config) {
   const issues = [];
@@ -1737,7 +2033,7 @@ async function validateDefinedIds(root, config) {
 }
 async function collectSpecDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await (0, import_promises11.readFile)(file, "utf-8");
+    const text = await (0, import_promises13.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
       recordId(out, parsed.specId, file);
@@ -1747,7 +2043,7 @@ async function collectSpecDefinitionIds(files, out) {
 }
 async function collectScenarioDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await (0, import_promises11.readFile)(file, "utf-8");
+    const text = await (0, import_promises13.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -1768,7 +2064,7 @@ function recordId(out, id, file) {
 }
 function formatFileList(files, root) {
   return files.map((file) => {
-    const relative = import_node_path13.default.relative(root, file);
+    const relative = import_node_path16.default.relative(root, file);
     return relative.length > 0 ? relative : file;
   }).join(", ");
 }
@@ -1791,7 +2087,7 @@ function issue3(code, message, severity, file, rule, refs) {
 }
 
 // src/core/validators/scenario.ts
-var import_promises12 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 var GIVEN_PATTERN = /\bGiven\b/;
 var WHEN_PATTERN = /\bWhen\b/;
 var THEN_PATTERN = /\bThen\b/;
@@ -1817,7 +2113,7 @@ async function validateScenarios(root, config) {
   for (const entry of entries) {
     let text;
     try {
-      text = await (0, import_promises12.readFile)(entry.scenarioPath, "utf-8");
+      text = await (0, import_promises14.readFile)(entry.scenarioPath, "utf-8");
     } catch (error2) {
       if (isMissingFileError3(error2)) {
         issues.push(
@@ -1987,7 +2283,7 @@ function isMissingFileError3(error2) {
 }
 
 // src/core/validators/spec.ts
-var import_promises13 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 async function validateSpecs(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
@@ -2008,7 +2304,7 @@ async function validateSpecs(root, config) {
   for (const entry of entries) {
     let text;
     try {
-      text = await (0, import_promises13.readFile)(entry.specPath, "utf-8");
+      text = await (0, import_promises15.readFile)(entry.specPath, "utf-8");
     } catch (error2) {
       if (isMissingFileError4(error2)) {
         issues.push(
@@ -2157,7 +2453,7 @@ function isMissingFileError4(error2) {
 }
 
 // src/core/validators/traceability.ts
-var import_promises14 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var SPEC_TAG_RE3 = /^SPEC-\d{4}$/;
 var BR_TAG_RE2 = /^BR-\d{4}$/;
 async function validateTraceability(root, config) {
@@ -2177,7 +2473,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_promises14.readFile)(file, "utf-8");
+    const text = await (0, import_promises16.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
@@ -2205,7 +2501,7 @@ async function validateTraceability(root, config) {
       if (contractRefs.hasNone && contractRefs.ids.length > 0) {
         issues.push(
           issue6(
-            "QFAI-TRACE-021",
+            "QFAI-TRACE-023",
             "Spec \u306E QFAI-CONTRACT-REF \u306B none \u3068\u5951\u7D04 ID \u304C\u6DF7\u5728\u3057\u3066\u3044\u307E\u3059\u3002",
             "error",
             file,
@@ -2237,7 +2533,7 @@ async function validateTraceability(root, config) {
     if (unknownContractIds.length > 0) {
       issues.push(
         issue6(
-          "QFAI-TRACE-021",
+          "QFAI-TRACE-024",
           `Spec \u304C\u672A\u77E5\u306E\u5951\u7D04 ID \u3092\u53C2\u7167\u3057\u3066\u3044\u307E\u3059: ${unknownContractIds.join(
             ", "
           )}`,
@@ -2250,13 +2546,64 @@ async function validateTraceability(root, config) {
     }
   }
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises14.readFile)(file, "utf-8");
+    const text = await (0, import_promises16.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
+    const scenarioContractRefs = parseContractRefs(text, {
+      allowCommentPrefix: true
+    });
+    if (scenarioContractRefs.lines.length === 0) {
+      issues.push(
+        issue6(
+          "QFAI-TRACE-031",
+          "Scenario \u306B QFAI-CONTRACT-REF \u304C\u3042\u308A\u307E\u305B\u3093\u3002",
+          "error",
+          file,
+          "traceability.scenarioContractRefRequired"
+        )
+      );
+    } else {
+      if (scenarioContractRefs.hasNone && scenarioContractRefs.ids.length > 0) {
+        issues.push(
+          issue6(
+            "QFAI-TRACE-033",
+            "Scenario \u306E QFAI-CONTRACT-REF \u306B none \u3068\u5951\u7D04 ID \u304C\u6DF7\u5728\u3057\u3066\u3044\u307E\u3059\u3002",
+            "error",
+            file,
+            "traceability.scenarioContractRefFormat"
+          )
+        );
+      }
+      if (scenarioContractRefs.invalidTokens.length > 0) {
+        issues.push(
+          issue6(
+            "QFAI-TRACE-032",
+            `Scenario \u306E\u5951\u7D04 ID \u304C\u4E0D\u6B63\u3067\u3059: ${scenarioContractRefs.invalidTokens.join(
+              ", "
+            )}`,
+            "error",
+            file,
+            "traceability.scenarioContractRefFormat",
+            scenarioContractRefs.invalidTokens
+          )
+        );
+      }
+    }
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
     }
-    const atoms = buildScenarioAtoms(document);
+    if (document.scenarios.length !== 1) {
+      issues.push(
+        issue6(
+          "QFAI-TRACE-030",
+          `Scenario \u30D5\u30A1\u30A4\u30EB\u306F 1\u30D5\u30A1\u30A4\u30EB=1\u30B7\u30CA\u30EA\u30AA\u3067\u3059\u3002\u73FE\u5728: ${document.scenarios.length}\u4EF6 (file=${file})`,
+          "error",
+          file,
+          "traceability.scenarioOnePerFile"
+        )
+      );
+    }
+    const atoms = buildScenarioAtoms(document, scenarioContractRefs.ids);
     const scIdsInFile = /* @__PURE__ */ new Set();
     for (const [index, scenario] of document.scenarios.entries()) {
       const atom = atoms[index];
@@ -2401,7 +2748,7 @@ async function validateTraceability(root, config) {
     if (orphanBrIds.length > 0) {
       issues.push(
         issue6(
-          "QFAI_TRACE_BR_ORPHAN",
+          "QFAI-TRACE-009",
           `BR \u304C SC \u306B\u7D10\u3065\u3044\u3066\u3044\u307E\u305B\u3093: ${orphanBrIds.join(", ")}`,
           "error",
           specsRoot,
@@ -2471,17 +2818,19 @@ async function validateTraceability(root, config) {
       );
     }
   }
-  if (!config.validation.traceability.allowOrphanContracts) {
+  const orphanPolicy = config.validation.traceability.orphanContractsPolicy;
+  if (orphanPolicy !== "allow") {
     if (contractIds.size > 0) {
       const orphanContracts = Array.from(contractIds).filter(
         (id) => !specContractIds.has(id)
       );
       if (orphanContracts.length > 0) {
+        const severity = orphanPolicy === "warning" ? "warning" : "error";
         issues.push(
           issue6(
             "QFAI-TRACE-022",
             `\u5951\u7D04\u304C Spec \u304B\u3089\u53C2\u7167\u3055\u308C\u3066\u3044\u307E\u305B\u3093: ${orphanContracts.join(", ")}`,
-            "error",
+            severity,
             specsRoot,
             "traceability.contractCoverage",
             orphanContracts
@@ -2519,7 +2868,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_promises14.readFile)(file, "utf-8");
+    const text = await (0, import_promises16.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       found = true;
       break;
@@ -2606,16 +2955,17 @@ function countIssues(issues) {
 // src/core/report.ts
 var ID_PREFIXES2 = ["SPEC", "BR", "SC", "UI", "API", "DB"];
 async function createReportData(root, validation, configResult) {
-  const resolved = configResult ?? await loadConfig(root);
+  const resolvedRoot = import_node_path17.default.resolve(root);
+  const resolved = configResult ?? await loadConfig(resolvedRoot);
   const config = resolved.config;
   const configPath = resolved.configPath;
-  const specsRoot = resolvePath(root, config, "specsDir");
-  const contractsRoot = resolvePath(root, config, "contractsDir");
-  const apiRoot = import_node_path14.default.join(contractsRoot, "api");
-  const uiRoot = import_node_path14.default.join(contractsRoot, "ui");
-  const dbRoot = import_node_path14.default.join(contractsRoot, "db");
-  const srcRoot = resolvePath(root, config, "srcDir");
-  const testsRoot = resolvePath(root, config, "testsDir");
+  const specsRoot = resolvePath(resolvedRoot, config, "specsDir");
+  const contractsRoot = resolvePath(resolvedRoot, config, "contractsDir");
+  const apiRoot = import_node_path17.default.join(contractsRoot, "api");
+  const uiRoot = import_node_path17.default.join(contractsRoot, "ui");
+  const dbRoot = import_node_path17.default.join(contractsRoot, "db");
+  const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
+  const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specFiles = await collectSpecFiles(specsRoot);
   const scenarioFiles = await collectScenarioFiles(specsRoot);
   const {
@@ -2623,15 +2973,15 @@ async function createReportData(root, validation, configResult) {
     ui: uiFiles,
     db: dbFiles
   } = await collectContractFiles(uiRoot, apiRoot, dbRoot);
-  const contractIndex = await buildContractIndex(root, config);
+  const contractIndex = await buildContractIndex(resolvedRoot, config);
   const contractIdList = Array.from(contractIndex.ids);
   const specContractRefs = await collectSpecContractRefs(
     specFiles,
     contractIdList
   );
   const referencedContracts = /* @__PURE__ */ new Set();
-  for (const ids of specContractRefs.specToContractIds.values()) {
-    ids.forEach((id) => referencedContracts.add(id));
+  for (const entry of specContractRefs.specToContracts.values()) {
+    entry.ids.forEach((id) => referencedContracts.add(id));
   }
   const referencedContractCount = contractIdList.filter(
     (id) => referencedContracts.has(id)
@@ -2640,8 +2990,8 @@ async function createReportData(root, validation, configResult) {
     (id) => !referencedContracts.has(id)
   ).length;
   const contractIdToSpecsRecord = mapToSortedRecord(specContractRefs.idToSpecs);
-  const specToContractIdsRecord = mapToSortedRecord(
-    specContractRefs.specToContractIds
+  const specToContractsRecord = mapToSpecContractRecord(
+    specContractRefs.specToContracts
   );
   const idsByPrefix = await collectIds([
     ...specFiles,
@@ -2659,24 +3009,28 @@ async function createReportData(root, validation, configResult) {
     srcRoot,
     testsRoot
   );
-  const scIds = await collectScIdsFromScenarioFiles(scenarioFiles);
-  const scRefsResult = await collectScTestReferences(
-    root,
-    config.validation.traceability.testFileGlobs,
-    config.validation.traceability.testFileExcludeGlobs
+  const resolvedValidationRaw = validation ?? await validateProject(resolvedRoot, resolved);
+  const normalizedValidation = normalizeValidationResult(
+    resolvedRoot,
+    resolvedValidationRaw
   );
-  const scCoverage = validation?.traceability?.sc ?? buildScCoverage(scIds, scRefsResult.refs);
-  const testFiles = validation?.traceability?.testFiles ?? scRefsResult.scan;
+  const scCoverage = normalizedValidation.traceability.sc;
+  const testFiles = normalizedValidation.traceability.testFiles;
   const scSources = await collectScIdSourcesFromScenarioFiles(scenarioFiles);
-  const scSourceRecord = mapToSortedRecord(scSources);
-  const resolvedValidation = validation ?? await validateProject(root, resolved);
+  const scSourceRecord = mapToSortedRecord(
+    normalizeScSources(resolvedRoot, scSources)
+  );
   const version = await resolveToolVersion();
+  const reportFormatVersion = 1;
+  const displayRoot = toRelativePath(resolvedRoot, resolvedRoot);
+  const displayConfigPath = toRelativePath(resolvedRoot, configPath);
   return {
     tool: "qfai",
     version,
+    reportFormatVersion,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    root,
-    configPath,
+    root: displayRoot,
+    configPath: displayConfigPath,
     summary: {
       specs: specFiles.length,
       scenarios: scenarioFiles.length,
@@ -2685,7 +3039,7 @@ async function createReportData(root, validation, configResult) {
         ui: uiFiles.length,
         db: dbFiles.length
       },
-      counts: resolvedValidation.counts
+      counts: normalizedValidation.counts
     },
     ids: {
       spec: idsByPrefix.SPEC,
@@ -2710,21 +3064,23 @@ async function createReportData(root, validation, configResult) {
       specs: {
         contractRefMissing: specContractRefs.missingRefSpecs.size,
         missingRefSpecs: toSortedArray2(specContractRefs.missingRefSpecs),
-        specToContractIds: specToContractIdsRecord
+        specToContracts: specToContractsRecord
       }
     },
-    issues: resolvedValidation.issues
+    issues: normalizedValidation.issues
   };
 }
 function formatReportMarkdown(data) {
   const lines = [];
   lines.push("# QFAI Report");
+  lines.push("");
   lines.push(`- \u751F\u6210\u65E5\u6642: ${data.generatedAt}`);
   lines.push(`- \u30EB\u30FC\u30C8: ${data.root}`);
   lines.push(`- \u8A2D\u5B9A: ${data.configPath}`);
   lines.push(`- \u7248: ${data.version}`);
   lines.push("");
   lines.push("## \u6982\u8981");
+  lines.push("");
   lines.push(`- specs: ${data.summary.specs}`);
   lines.push(`- scenarios: ${data.summary.scenarios}`);
   lines.push(
@@ -2735,6 +3091,7 @@ function formatReportMarkdown(data) {
   );
   lines.push("");
   lines.push("## ID\u96C6\u8A08");
+  lines.push("");
   lines.push(formatIdLine("SPEC", data.ids.spec));
   lines.push(formatIdLine("BR", data.ids.br));
   lines.push(formatIdLine("SC", data.ids.sc));
@@ -2743,12 +3100,14 @@ function formatReportMarkdown(data) {
   lines.push(formatIdLine("DB", data.ids.db));
   lines.push("");
   lines.push("## \u30C8\u30EC\u30FC\u30B5\u30D3\u30EA\u30C6\u30A3");
+  lines.push("");
   lines.push(`- \u4E0A\u6D41ID\u691C\u51FA\u6570: ${data.traceability.upstreamIdsFound}`);
   lines.push(
     `- \u30B3\u30FC\u30C9/\u30C6\u30B9\u30C8\u53C2\u7167: ${data.traceability.referencedInCodeOrTests ? "\u3042\u308A" : "\u306A\u3057"}`
   );
   lines.push("");
   lines.push("## \u5951\u7D04\u30AB\u30D0\u30EC\u30C3\u30B8");
+  lines.push("");
   lines.push(`- total: ${data.traceability.contracts.total}`);
   lines.push(`- referenced: ${data.traceability.contracts.referenced}`);
   lines.push(`- orphan: ${data.traceability.contracts.orphan}`);
@@ -2757,6 +3116,7 @@ function formatReportMarkdown(data) {
   );
   lines.push("");
   lines.push("## \u5951\u7D04\u2192Spec");
+  lines.push("");
   const contractToSpecs = data.traceability.contracts.idToSpecs;
   const contractIds = Object.keys(contractToSpecs).sort(
     (a, b) => a.localeCompare(b)
@@ -2775,24 +3135,25 @@ function formatReportMarkdown(data) {
   }
   lines.push("");
   lines.push("## Spec\u2192\u5951\u7D04");
-  const specToContracts = data.traceability.specs.specToContractIds;
+  lines.push("");
+  const specToContracts = data.traceability.specs.specToContracts;
   const specIds = Object.keys(specToContracts).sort(
     (a, b) => a.localeCompare(b)
   );
   if (specIds.length === 0) {
     lines.push("- (none)");
   } else {
-    for (const specId of specIds) {
-      const contractIds2 = specToContracts[specId] ?? [];
-      if (contractIds2.length === 0) {
-        lines.push(`- ${specId}: (none)`);
-      } else {
-        lines.push(`- ${specId}: ${contractIds2.join(", ")}`);
-      }
-    }
+    const rows = specIds.map((specId) => {
+      const entry = specToContracts[specId];
+      const contracts = entry?.status === "missing" ? "(missing)" : entry && entry.ids.length > 0 ? entry.ids.join(", ") : "(none)";
+      const status = entry?.status ?? "missing";
+      return [specId, status, contracts];
+    });
+    lines.push(...formatMarkdownTable(["Spec", "Status", "Contracts"], rows));
   }
   lines.push("");
   lines.push("## Spec\u3067 contract-ref \u672A\u5BA3\u8A00");
+  lines.push("");
   const missingRefSpecs = data.traceability.specs.missingRefSpecs;
   if (missingRefSpecs.length === 0) {
     lines.push("- (none)");
@@ -2803,6 +3164,7 @@ function formatReportMarkdown(data) {
   }
   lines.push("");
   lines.push("## SC\u30AB\u30D0\u30EC\u30C3\u30B8");
+  lines.push("");
   lines.push(`- total: ${data.traceability.sc.total}`);
   lines.push(`- covered: ${data.traceability.sc.covered}`);
   lines.push(`- missing: ${data.traceability.sc.missing}`);
@@ -2832,6 +3194,7 @@ function formatReportMarkdown(data) {
   }
   lines.push("");
   lines.push("## SC\u2192\u53C2\u7167\u30C6\u30B9\u30C8");
+  lines.push("");
   const scRefs = data.traceability.sc.refs;
   const scIds = Object.keys(scRefs).sort((a, b) => a.localeCompare(b));
   if (scIds.length === 0) {
@@ -2848,6 +3211,7 @@ function formatReportMarkdown(data) {
   }
   lines.push("");
   lines.push("## Spec:SC=1:1 \u9055\u53CD");
+  lines.push("");
   const specScIssues = data.issues.filter(
     (item) => item.code === "QFAI-TRACE-012"
   );
@@ -2862,6 +3226,7 @@ function formatReportMarkdown(data) {
   }
   lines.push("");
   lines.push("## Hotspots");
+  lines.push("");
   const hotspots = buildHotspots(data.issues);
   if (hotspots.length === 0) {
     lines.push("- (none)");
@@ -2874,6 +3239,7 @@ function formatReportMarkdown(data) {
   }
   lines.push("");
   lines.push("## \u30C8\u30EC\u30FC\u30B5\u30D3\u30EA\u30C6\u30A3\uFF08\u691C\u8A3C\uFF09");
+  lines.push("");
   const traceIssues = data.issues.filter(
     (item) => item.rule?.startsWith("traceability.") || item.code.startsWith("QFAI_TRACE") || item.code.startsWith("QFAI-TRACE-")
   );
@@ -2889,6 +3255,7 @@ function formatReportMarkdown(data) {
   }
   lines.push("");
   lines.push("## \u691C\u8A3C\u7D50\u679C");
+  lines.push("");
   if (data.issues.length === 0) {
     lines.push("- (none)");
   } else {
@@ -2906,33 +3273,40 @@ function formatReportJson(data) {
   return JSON.stringify(data, null, 2);
 }
 async function collectSpecContractRefs(specFiles, contractIdList) {
-  const specToContractIds = /* @__PURE__ */ new Map();
+  const specToContracts = /* @__PURE__ */ new Map();
   const idToSpecs = /* @__PURE__ */ new Map();
   const missingRefSpecs = /* @__PURE__ */ new Set();
   for (const contractId of contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await (0, import_promises15.readFile)(file, "utf-8");
+    const text = await (0, import_promises17.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
-    const specKey = parsed.specId ?? file;
+    const specKey = parsed.specId;
+    if (!specKey) {
+      continue;
+    }
     const refs = parsed.contractRefs;
     if (refs.lines.length === 0) {
       missingRefSpecs.add(specKey);
+      specToContracts.set(specKey, { status: "missing", ids: /* @__PURE__ */ new Set() });
       continue;
     }
-    const currentContracts = specToContractIds.get(specKey) ?? /* @__PURE__ */ new Set();
+    const current = specToContracts.get(specKey) ?? {
+      status: "declared",
+      ids: /* @__PURE__ */ new Set()
+    };
     for (const id of refs.ids) {
-      currentContracts.add(id);
+      current.ids.add(id);
       const specs = idToSpecs.get(id);
       if (specs) {
         specs.add(specKey);
       }
     }
-    specToContractIds.set(specKey, currentContracts);
+    specToContracts.set(specKey, current);
   }
   return {
-    specToContractIds,
+    specToContracts,
     idToSpecs,
     missingRefSpecs
   };
@@ -2947,7 +3321,7 @@ async function collectIds(files) {
     DB: /* @__PURE__ */ new Set()
   };
   for (const file of files) {
-    const text = await (0, import_promises15.readFile)(file, "utf-8");
+    const text = await (0, import_promises17.readFile)(file, "utf-8");
     for (const prefix of ID_PREFIXES2) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -2965,7 +3339,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await (0, import_promises15.readFile)(file, "utf-8");
+    const text = await (0, import_promises17.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -2986,7 +3360,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern2(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await (0, import_promises15.readFile)(file, "utf-8");
+    const text = await (0, import_promises17.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -3009,6 +3383,20 @@ function formatList(values) {
   }
   return values.join(", ");
 }
+function formatMarkdownTable(headers, rows) {
+  const widths = headers.map((header, index) => {
+    const candidates = rows.map((row) => row[index] ?? "");
+    return Math.max(header.length, ...candidates.map((item) => item.length));
+  });
+  const formatRow = (cells) => {
+    const padded = cells.map(
+      (cell, index) => (cell ?? "").padEnd(widths[index] ?? 0)
+    );
+    return `| ${padded.join(" | ")} |`;
+  };
+  const separator = `| ${widths.map((width) => "-".repeat(width)).join(" | ")} |`;
+  return [formatRow(headers), separator, ...rows.map(formatRow)];
+}
 function toSortedArray2(values) {
   return Array.from(values).sort((a, b) => a.localeCompare(b));
 }
@@ -3019,6 +3407,27 @@ function mapToSortedRecord(values) {
   }
   return record2;
 }
+function mapToSpecContractRecord(values) {
+  const record2 = {};
+  for (const [key, entry] of values.entries()) {
+    record2[key] = {
+      status: entry.status,
+      ids: toSortedArray2(entry.ids)
+    };
+  }
+  return record2;
+}
+function normalizeScSources(root, sources) {
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [id, files] of sources.entries()) {
+    const mapped = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      mapped.add(toRelativePath(root, file));
+    }
+    normalized.set(id, mapped);
+  }
+  return normalized;
+}
 function buildHotspots(issues) {
   const map = /* @__PURE__ */ new Map();
   for (const issue7 of issues) {
@@ -3043,39 +3452,54 @@ function buildHotspots(issues) {
 
 // src/cli/commands/report.ts
 async function runReport(options) {
-  const root = import_node_path15.default.resolve(options.root);
+  const root = import_node_path18.default.resolve(options.root);
   const configResult = await loadConfig(root);
-  const input = configResult.config.output.validateJsonPath;
-  const inputPath = import_node_path15.default.isAbsolute(input) ? input : import_node_path15.default.resolve(root, input);
   let validation;
-  try {
-    validation = await readValidationResult(inputPath);
-  } catch (err) {
-    if (isMissingFileError5(err)) {
-      error(
-        [
-          `qfai report: \u5165\u529B\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${inputPath}`,
-          "",
-          "\u307E\u305A qfai validate \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u4F8B:",
-          "  qfai validate",
-          "\uFF08\u30C7\u30D5\u30A9\u30EB\u30C8\u306E\u51FA\u529B\u5148: .qfai/out/validate.json\uFF09",
-          "",
-          "GitHub Actions \u30C6\u30F3\u30D7\u30EC\u3092\u4F7F\u3063\u3066\u3044\u308B\u5834\u5408\u306F\u3001workflow \u306E validate \u30B8\u30E7\u30D6\u3092\u5148\u306B\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
-        ].join("\n")
-      );
-      process.exitCode = 2;
-      return;
+  if (options.runValidate) {
+    if (options.inputPath) {
+      warn("report: --run-validate \u304C\u6307\u5B9A\u3055\u308C\u305F\u305F\u3081 --in \u306F\u7121\u8996\u3057\u307E\u3059\u3002");
+    }
+    const result = await validateProject(root, configResult);
+    const normalized = normalizeValidationResult(root, result);
+    await writeValidationResult(
+      root,
+      configResult.config.output.validateJsonPath,
+      normalized
+    );
+    validation = normalized;
+  } else {
+    const input = options.inputPath ?? configResult.config.output.validateJsonPath;
+    const inputPath = import_node_path18.default.isAbsolute(input) ? input : import_node_path18.default.resolve(root, input);
+    try {
+      validation = await readValidationResult(inputPath);
+    } catch (err) {
+      if (isMissingFileError5(err)) {
+        error(
+          [
+            `qfai report: \u5165\u529B\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${inputPath}`,
+            "",
+            "\u307E\u305A qfai validate \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u4F8B:",
+            "  qfai validate",
+            "\uFF08\u30C7\u30D5\u30A9\u30EB\u30C8\u306E\u51FA\u529B\u5148: .qfai/out/validate.json\uFF09",
+            "",
+            "\u307E\u305F\u306F report \u306B --run-validate \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+            "GitHub Actions \u30C6\u30F3\u30D7\u30EC\u3092\u4F7F\u3063\u3066\u3044\u308B\u5834\u5408\u306F\u3001workflow \u306E validate \u30B8\u30E7\u30D6\u3092\u5148\u306B\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+          ].join("\n")
+        );
+        process.exitCode = 2;
+        return;
+      }
+      throw err;
     }
-    throw err;
   }
   const data = await createReportData(root, validation, configResult);
   const output = options.format === "json" ? formatReportJson(data) : formatReportMarkdown(data);
   const outRoot = resolvePath(root, configResult.config, "outDir");
-  const defaultOut = options.format === "json" ? import_node_path15.default.join(outRoot, "report.json") : import_node_path15.default.join(outRoot, "report.md");
+  const defaultOut = options.format === "json" ? import_node_path18.default.join(outRoot, "report.json") : import_node_path18.default.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
-  const outPath = import_node_path15.default.isAbsolute(out) ? out : import_node_path15.default.resolve(root, out);
-  await (0, import_promises16.mkdir)(import_node_path15.default.dirname(outPath), { recursive: true });
-  await (0, import_promises16.writeFile)(outPath, `${output}
+  const outPath = import_node_path18.default.isAbsolute(out) ? out : import_node_path18.default.resolve(root, out);
+  await (0, import_promises18.mkdir)(import_node_path18.default.dirname(outPath), { recursive: true });
+  await (0, import_promises18.writeFile)(outPath, `${output}
 `, "utf-8");
   info(
     `report: info=${validation.counts.info} warning=${validation.counts.warning} error=${validation.counts.error}`
@@ -3083,7 +3507,7 @@ async function runReport(options) {
   info(`wrote report: ${outPath}`);
 }
 async function readValidationResult(inputPath) {
-  const raw = await (0, import_promises16.readFile)(inputPath, "utf-8");
+  const raw = await (0, import_promises18.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}`);
@@ -3138,10 +3562,16 @@ function isMissingFileError5(error2) {
   const record2 = error2;
   return record2.code === "ENOENT";
 }
+async function writeValidationResult(root, outputPath, result) {
+  const abs = import_node_path18.default.isAbsolute(outputPath) ? outputPath : import_node_path18.default.resolve(root, outputPath);
+  await (0, import_promises18.mkdir)(import_node_path18.default.dirname(abs), { recursive: true });
+  await (0, import_promises18.writeFile)(abs, `${JSON.stringify(result, null, 2)}
+`, "utf-8");
+}
 
 // src/cli/commands/validate.ts
-var import_promises17 = require("fs/promises");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_promises19 = require("fs/promises");
+var import_node_path19 = __toESM(require("path"), 1);
 
 // src/cli/lib/failOn.ts
 function shouldFail(result, failOn) {
@@ -3156,19 +3586,24 @@ function shouldFail(result, failOn) {
 
 // src/cli/commands/validate.ts
 async function runValidate(options) {
-  const root = import_node_path16.default.resolve(options.root);
+  const root = import_node_path19.default.resolve(options.root);
   const configResult = await loadConfig(root);
   const result = await validateProject(root, configResult);
+  const normalized = normalizeValidationResult(root, result);
   const format = options.format ?? "text";
   if (format === "text") {
-    emitText(result);
+    emitText(normalized);
   }
   if (format === "github") {
-    result.issues.forEach(emitGitHub);
+    const jsonPath = resolveJsonPath(
+      root,
+      configResult.config.output.validateJsonPath
+    );
+    emitGitHubOutput(normalized, root, jsonPath);
   }
-  await emitJson(result, root, configResult.config.output.validateJsonPath);
+  await emitJson(normalized, root, configResult.config.output.validateJsonPath);
   const failOn = resolveFailOn(options, configResult.config.validation.failOn);
-  return shouldFail(result, failOn) ? 1 : 0;
+  return shouldFail(normalized, failOn) ? 1 : 0;
 }
 function resolveFailOn(options, fallback) {
   if (options.failOn) {
@@ -3193,6 +3628,22 @@ function emitText(result) {
 `
   );
 }
+function emitGitHubOutput(result, root, jsonPath) {
+  const deduped = dedupeIssues(result.issues);
+  const omitted = Math.max(deduped.length - GITHUB_ANNOTATION_LIMIT, 0);
+  const dropped = Math.max(result.issues.length - deduped.length, 0);
+  emitGitHubSummary(result, {
+    total: deduped.length,
+    omitted,
+    dropped,
+    jsonPath,
+    root
+  });
+  const issues = deduped.slice(0, GITHUB_ANNOTATION_LIMIT);
+  for (const issue7 of issues) {
+    emitGitHub(issue7);
+  }
+}
 function emitGitHub(issue7) {
   const level = issue7.severity === "error" ? "error" : issue7.severity === "warning" ? "warning" : "notice";
   const file = issue7.file ? `file=${issue7.file}` : "";
@@ -3204,22 +3655,75 @@ function emitGitHub(issue7) {
 `
   );
 }
+function emitGitHubSummary(result, options) {
+  const summary = [
+    "qfai validate summary:",
+    `error=${result.counts.error}`,
+    `warning=${result.counts.warning}`,
+    `info=${result.counts.info}`,
+    `annotations=${Math.min(options.total, GITHUB_ANNOTATION_LIMIT)}/${options.total}`
+  ].join(" ");
+  process.stdout.write(`${summary}
+`);
+  if (options.dropped > 0 || options.omitted > 0) {
+    const details = [
+      "qfai validate note:",
+      options.dropped > 0 ? `\u91CD\u8907\u9664\u5916=${options.dropped}` : null,
+      options.omitted > 0 ? `\u4E0A\u9650\u7701\u7565=${options.omitted}` : null
+    ].filter(Boolean).join(" ");
+    process.stdout.write(`${details}
+`);
+  }
+  const relative = toRelativePath(options.root, options.jsonPath);
+  process.stdout.write(
+    `qfai validate note: \u8A73\u7D30\u306F ${relative} \u307E\u305F\u306F --format text \u3092\u53C2\u7167\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+`
+  );
+}
+function dedupeIssues(issues) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const issue7 of issues) {
+    const key = issueKey(issue7);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(issue7);
+  }
+  return deduped;
+}
+function issueKey(issue7) {
+  const file = issue7.file ?? "";
+  const line = issue7.loc?.line ?? "";
+  const column = issue7.loc?.column ?? "";
+  return [issue7.code, issue7.severity, issue7.message, file, line, column].join(
+    "|"
+  );
+}
 async function emitJson(result, root, jsonPath) {
-  const abs = import_node_path16.default.isAbsolute(jsonPath) ? jsonPath : import_node_path16.default.resolve(root, jsonPath);
-  await (0, import_promises17.mkdir)(import_node_path16.default.dirname(abs), { recursive: true });
-  await (0, import_promises17.writeFile)(abs, `${JSON.stringify(result, null, 2)}
+  const abs = resolveJsonPath(root, jsonPath);
+  await (0, import_promises19.mkdir)(import_node_path19.default.dirname(abs), { recursive: true });
+  await (0, import_promises19.writeFile)(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
+function resolveJsonPath(root, jsonPath) {
+  return import_node_path19.default.isAbsolute(jsonPath) ? jsonPath : import_node_path19.default.resolve(root, jsonPath);
+}
+var GITHUB_ANNOTATION_LIMIT = 100;
 
 // src/cli/lib/args.ts
 function parseArgs(argv, cwd) {
   const options = {
     root: cwd,
+    rootExplicit: false,
     dir: cwd,
     force: false,
     yes: false,
     dryRun: false,
     reportFormat: "md",
+    reportRunValidate: false,
+    doctorFormat: "text",
     validateFormat: "text",
     strict: false,
     help: false
@@ -3235,6 +3739,7 @@ function parseArgs(argv, cwd) {
     switch (arg) {
       case "--root":
         options.root = args[i + 1] ?? options.root;
+        options.rootExplicit = true;
         i += 1;
         break;
       case "--dir":
@@ -3271,11 +3776,27 @@ function parseArgs(argv, cwd) {
         {
           const next = args[i + 1];
           if (next) {
-            options.reportOut = next;
+            if (command === "doctor") {
+              options.doctorOut = next;
+            } else {
+              options.reportOut = next;
+            }
+          }
+        }
+        i += 1;
+        break;
+      case "--in":
+        {
+          const next = args[i + 1];
+          if (next) {
+            options.reportIn = next;
           }
         }
         i += 1;
         break;
+      case "--run-validate":
+        options.reportRunValidate = true;
+        break;
       case "--help":
       case "-h":
         options.help = true;
@@ -3302,6 +3823,12 @@ function applyFormatOption(command, value, options) {
     }
     return;
   }
+  if (command === "doctor") {
+    if (value === "text" || value === "json") {
+      options.doctorFormat = value;
+    }
+    return;
+  }
   if (value === "md" || value === "json") {
     options.reportFormat = value;
   }
@@ -3327,18 +3854,34 @@ async function run(argv, cwd) {
       });
       return;
     case "validate":
-      process.exitCode = await runValidate({
-        root: options.root,
-        strict: options.strict,
-        format: options.validateFormat,
-        ...options.failOn !== void 0 ? { failOn: options.failOn } : {}
-      });
+      {
+        const resolvedRoot = await resolveRoot(options);
+        process.exitCode = await runValidate({
+          root: resolvedRoot,
+          strict: options.strict,
+          format: options.validateFormat,
+          ...options.failOn !== void 0 ? { failOn: options.failOn } : {}
+        });
+      }
       return;
     case "report":
-      await runReport({
+      {
+        const resolvedRoot = await resolveRoot(options);
+        await runReport({
+          root: resolvedRoot,
+          format: options.reportFormat,
+          ...options.reportOut !== void 0 ? { outPath: options.reportOut } : {},
+          ...options.reportIn !== void 0 ? { inputPath: options.reportIn } : {},
+          ...options.reportRunValidate ? { runValidate: true } : {}
+        });
+      }
+      return;
+    case "doctor":
+      await runDoctor({
         root: options.root,
-        format: options.reportFormat,
-        ...options.reportOut !== void 0 ? { outPath: options.reportOut } : {}
+        rootExplicit: options.rootExplicit,
+        format: options.doctorFormat,
+        ...options.doctorOut !== void 0 ? { outPath: options.doctorOut } : {}
       });
       return;
     default:
@@ -3354,6 +3897,7 @@ Commands:
   init       \u30C6\u30F3\u30D7\u30EC\u3092\u751F\u6210
   validate   \u4ED5\u69D8/\u5951\u7D04/\u53C2\u7167\u306E\u691C\u67FB
   report     \u691C\u8A3C\u7D50\u679C\u3068\u96C6\u8A08\u3092\u51FA\u529B
+  doctor     \u8A2D\u5B9A/\u30D1\u30B9/\u51FA\u529B\u524D\u63D0\u306E\u8A3A\u65AD
 
 Options:
   --root <path>   \u5BFE\u8C61\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA
@@ -3363,12 +3907,27 @@ Options:
   --dry-run       \u5909\u66F4\u3092\u884C\u308F\u305A\u8868\u793A\u306E\u307F
   --format <text|github>       validate \u306E\u51FA\u529B\u5F62\u5F0F
   --format <md|json>           report \u306E\u51FA\u529B\u5F62\u5F0F
+  --format <text|json>         doctor \u306E\u51FA\u529B\u5F62\u5F0F
   --strict                     validate: warning \u4EE5\u4E0A\u3067 exit 1
   --fail-on <error|warning|never>  validate: \u5931\u6557\u6761\u4EF6
-  --out <path>                  report: \u51FA\u529B\u5148
+  --out <path>                  report/doctor: \u51FA\u529B\u5148
+  --in <path>                   report: validate.json \u306E\u5165\u529B\u5148\uFF08config\u3088\u308A\u512A\u5148\uFF09
+  --run-validate                report: validate \u3092\u5B9F\u884C\u3057\u3066\u304B\u3089 report \u3092\u751F\u6210
   -h, --help      \u30D8\u30EB\u30D7\u8868\u793A
 `;
 }
+async function resolveRoot(options) {
+  if (options.rootExplicit) {
+    return options.root;
+  }
+  const search = await findConfigRoot(options.root);
+  if (!search.found) {
+    warn(
+      `qfai: qfai.config.yaml \u304C\u898B\u3064\u304B\u3089\u306A\u3044\u305F\u3081 defaultConfig \u3092\u4F7F\u7528\u3057\u307E\u3059 (root=${search.root})`
+    );
+  }
+  return search.root;
+}
 
 // src/cli/index.ts
 run(process.argv.slice(2), process.cwd()).catch((err) => {