qfai 0.5.2 → 0.6.2

package/dist/cli/index.mjs

@@ -1,169 +1,16 @@
 #!/usr/bin/env node
 
-// src/cli/commands/init.ts
-import path3 from "path";
-
-// src/cli/lib/fs.ts
-import { access, copyFile, mkdir, readdir } from "fs/promises";
-import path from "path";
-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 = path.relative(sourceRoot, file);
-      const dest = path.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 = path.relative(sourceRoot, file);
-    const dest = path.join(destRoot, relative);
-    if (!await shouldWrite(dest, options.force)) {
-      skipped.push(dest);
-      continue;
-    }
-    if (!options.dryRun) {
-      await mkdir(path.dirname(dest), { recursive: true });
-      await 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 readdir(root, { withFileTypes: true });
-  for (const item of items) {
-    const fullPath = path.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 access(target);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/cli/lib/assets.ts
-import { existsSync } from "fs";
-import path2 from "path";
-import { fileURLToPath } from "url";
-function getInitAssetsDir() {
-  const base = import.meta.url;
-  const basePath = base.startsWith("file:") ? fileURLToPath(base) : base;
-  const baseDir = path2.dirname(basePath);
-  const candidates = [
-    path2.resolve(baseDir, "../../../assets/init"),
-    path2.resolve(baseDir, "../../assets/init")
-  ];
-  for (const candidate of candidates) {
-    if (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 warn(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 = path3.join(assetsRoot, "root");
-  const qfaiAssets = path3.join(assetsRoot, ".qfai");
-  const destRoot = path3.resolve(options.dir);
-  const destQfai = path3.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
+import { mkdir, writeFile } from "fs/promises";
+import path8 from "path";
 
-// src/cli/commands/report.ts
-import { mkdir as mkdir2, readFile as readFile12, writeFile } from "fs/promises";
-import path16 from "path";
+// src/core/doctor.ts
+import { access as access4 } from "fs/promises";
+import path7 from "path";
 
 // src/core/config.ts
-import { access as access2, readFile } from "fs/promises";
-import path4 from "path";
+import { access, readFile } from "fs/promises";
+import path from "path";
 import { parse as parseYaml } from "yaml";
 var defaultConfig = {
   paths: {
@@ -203,17 +50,17 @@ var defaultConfig = {
   }
 };
 function getConfigPath(root) {
-  return path4.join(root, "qfai.config.yaml");
+  return path.join(root, "qfai.config.yaml");
 }
 async function findConfigRoot(startDir) {
-  const resolvedStart = path4.resolve(startDir);
+  const resolvedStart = path.resolve(startDir);
   let current = resolvedStart;
   while (true) {
     const configPath = getConfigPath(current);
-    if (await exists2(configPath)) {
+    if (await exists(configPath)) {
       return { root: current, configPath, found: true };
     }
-    const parent = path4.dirname(current);
+    const parent = path.dirname(current);
     if (parent === current) {
       break;
     }
@@ -243,7 +90,7 @@ async function loadConfig(root) {
   return { config: normalized, issues, configPath };
 }
 function resolvePath(root, config, key) {
-  return path4.resolve(root, config.paths[key]);
+  return path.resolve(root, config.paths[key]);
 }
 function normalizeConfig(raw, configPath, issues) {
   if (!isRecord(raw)) {
@@ -542,9 +389,9 @@ function isMissingFile(error2) {
   }
   return false;
 }
-async function exists2(target) {
+async function exists(target) {
   try {
-    await access2(target);
+    await access(target);
     return true;
   } catch {
     return false;
@@ -560,76 +407,12 @@ function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-// src/core/paths.ts
-import path5 from "path";
-function toRelativePath(root, target) {
-  if (!target) {
-    return target;
-  }
-  if (!path5.isAbsolute(target)) {
-    return toPosixPath(target);
-  }
-  const relative = path5.relative(root, target);
-  if (!relative) {
-    return ".";
-  }
-  return toPosixPath(relative);
-}
-function toPosixPath(value) {
-  return value.replace(/\\/g, "/");
-}
-
-// 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
-import { readFile as readFile11 } from "fs/promises";
-import path15 from "path";
-
-// src/core/contractIndex.ts
-import { readFile as readFile2 } from "fs/promises";
-import path8 from "path";
-
 // src/core/discovery.ts
-import { access as access4 } from "fs/promises";
+import { access as access3 } from "fs/promises";
 
 // src/core/fs.ts
-import { access as access3, readdir as readdir2 } from "fs/promises";
-import path6 from "path";
+import { access as access2, readdir } from "fs/promises";
+import path2 from "path";
 import fg from "fast-glob";
 var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -641,7 +424,7 @@ var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
 ]);
 async function collectFiles(root, options = {}) {
   const entries = [];
-  if (!await exists3(root)) {
+  if (!await exists2(root)) {
     return entries;
   }
   const ignoreDirs = /* @__PURE__ */ new Set([
@@ -665,9 +448,9 @@ async function collectFilesByGlobs(root, options) {
   });
 }
 async function walk(base, current, ignoreDirs, extensions, out) {
-  const items = await readdir2(current, { withFileTypes: true });
+  const items = await readdir(current, { withFileTypes: true });
   for (const item of items) {
-    const fullPath = path6.join(current, item.name);
+    const fullPath = path2.join(current, item.name);
     if (item.isDirectory()) {
       if (ignoreDirs.has(item.name)) {
         continue;
@@ -677,7 +460,7 @@ async function walk(base, current, ignoreDirs, extensions, out) {
     }
     if (item.isFile()) {
       if (extensions.length > 0) {
-        const ext = path6.extname(item.name).toLowerCase();
+        const ext = path2.extname(item.name).toLowerCase();
         if (!extensions.includes(ext)) {
           continue;
         }
@@ -686,9 +469,9 @@ async function walk(base, current, ignoreDirs, extensions, out) {
     }
   }
 }
-async function exists3(target) {
+async function exists2(target) {
   try {
-    await access3(target);
+    await access2(target);
     return true;
   } catch {
     return false;
@@ -696,23 +479,23 @@ async function exists3(target) {
 }
 
 // src/core/specLayout.ts
-import { readdir as readdir3 } from "fs/promises";
-import path7 from "path";
+import { readdir as readdir2 } from "fs/promises";
+import path3 from "path";
 var SPEC_DIR_RE = /^spec-\d{4}$/;
 async function collectSpecEntries(specsRoot) {
   const dirs = await listSpecDirs(specsRoot);
   const entries = dirs.map((dir) => ({
     dir,
-    specPath: path7.join(dir, "spec.md"),
-    deltaPath: path7.join(dir, "delta.md"),
-    scenarioPath: path7.join(dir, "scenario.md")
+    specPath: path3.join(dir, "spec.md"),
+    deltaPath: path3.join(dir, "delta.md"),
+    scenarioPath: path3.join(dir, "scenario.md")
   }));
   return entries.sort((a, b) => a.dir.localeCompare(b.dir));
 }
 async function listSpecDirs(specsRoot) {
   try {
-    const items = await readdir3(specsRoot, { withFileTypes: true });
-    return items.filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => SPEC_DIR_RE.test(name.toLowerCase())).map((name) => path7.join(specsRoot, name));
+    const items = await readdir2(specsRoot, { withFileTypes: true });
+    return items.filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => SPEC_DIR_RE.test(name.toLowerCase())).map((name) => path3.join(specsRoot, name));
   } catch (error2) {
     if (isMissingFileError(error2)) {
       return [];
@@ -760,298 +543,43 @@ async function collectContractFiles(uiRoot, apiRoot, dbRoot) {
 async function filterExisting(files) {
   const existing = [];
   for (const file of files) {
-    if (await exists4(file)) {
+    if (await exists3(file)) {
       existing.push(file);
     }
   }
   return existing;
 }
-async function exists4(target) {
+async function exists3(target) {
   try {
-    await access4(target);
+    await access3(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
+import path4 from "path";
+function toRelativePath(root, target) {
+  if (!target) {
+    return target;
   }
-  return ids;
+  if (!path4.isAbsolute(target)) {
+    return toPosixPath(target);
+  }
+  const relative = path4.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");
-}
-
-// src/core/contractIndex.ts
-async function buildContractIndex(root, config) {
-  const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = path8.join(contractsRoot, "ui");
-  const apiRoot = path8.join(contractsRoot, "api");
-  const dbRoot = path8.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 readFile2(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 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/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: unique2(ids),
-    invalidTokens: unique2(invalidTokens),
-    hasNone
-  };
-}
-function buildLinePattern(options) {
-  const prefix = options.allowCommentPrefix ? "#" : "";
-  return new RegExp(
-    `^[ \\t]*${prefix}[ \\t]*QFAI-CONTRACT-REF:[ \\t]*([^\\r\\n]*)[ \\t]*$`,
-    "gm"
-  );
-}
-function unique2(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;
-    }
-    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 toPosixPath(value) {
+  return value.replace(/\\/g, "/");
 }
 
 // src/core/traceability.ts
-import { readFile as readFile3 } from "fs/promises";
-import path9 from "path";
+import { readFile as readFile2 } from "fs/promises";
+import path5 from "path";
 
 // src/core/gherkin/parse.ts
 import {
@@ -1111,13 +639,13 @@ function parseScenarioDocument(text, uri) {
   };
 }
 function buildScenarioAtoms(document, contractIds = []) {
-  const uniqueContractIds = unique3(contractIds).sort(
+  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 brIds = unique(scenario.tags.filter((tag) => BR_TAG_RE.test(tag)));
     const atom = {
       uri: document.uri,
       featureName: document.featureName ?? "",
@@ -1177,7 +705,7 @@ function buildScenarioNode(scenario, featureTags, ruleTags) {
 function collectTagNames(tags) {
   return tags.map((tag) => tag.name.replace(/^@/, ""));
 }
-function unique3(values) {
+function unique(values) {
   return Array.from(new Set(values));
 }
 
@@ -1207,7 +735,7 @@ function extractAnnotatedScIds(text) {
 async function collectScIdsFromScenarioFiles(scenarioFiles) {
   const scIds = /* @__PURE__ */ new Set();
   for (const file of scenarioFiles) {
-    const text = await readFile3(file, "utf-8");
+    const text = await readFile2(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -1225,7 +753,7 @@ async function collectScIdsFromScenarioFiles(scenarioFiles) {
 async function collectScIdSourcesFromScenarioFiles(scenarioFiles) {
   const sources = /* @__PURE__ */ new Map();
   for (const file of scenarioFiles) {
-    const text = await readFile3(file, "utf-8");
+    const text = await readFile2(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -1260,116 +788,900 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
       }
     };
   }
-  let files = [];
-  try {
-    files = await collectFilesByGlobs(root, {
-      globs: normalizedGlobs,
-      ignore: mergedExcludeGlobs
-    });
-  } catch (error2) {
-    return {
-      refs,
-      scan: {
-        globs: normalizedGlobs,
-        excludeGlobs: mergedExcludeGlobs,
-        matchedFileCount: 0
-      },
-      error: formatError3(error2)
-    };
+  let files = [];
+  try {
+    files = await collectFilesByGlobs(root, {
+      globs: normalizedGlobs,
+      ignore: mergedExcludeGlobs
+    });
+  } catch (error2) {
+    return {
+      refs,
+      scan: {
+        globs: normalizedGlobs,
+        excludeGlobs: mergedExcludeGlobs,
+        matchedFileCount: 0
+      },
+      error: formatError3(error2)
+    };
+  }
+  const normalizedFiles = Array.from(
+    new Set(files.map((file) => path5.normalize(file)))
+  );
+  for (const file of normalizedFiles) {
+    const text = await readFile2(file, "utf-8");
+    const scIds = extractAnnotatedScIds(text);
+    if (scIds.length === 0) {
+      continue;
+    }
+    for (const scId of scIds) {
+      const current = refs.get(scId) ?? /* @__PURE__ */ new Set();
+      current.add(file);
+      refs.set(scId, current);
+    }
+  }
+  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
+import { readFile as readFile3 } from "fs/promises";
+import path6 from "path";
+import { fileURLToPath } from "url";
+async function resolveToolVersion() {
+  if ("0.6.2".length > 0) {
+    return "0.6.2";
+  }
+  try {
+    const packagePath = resolvePackageJsonPath();
+    const raw = await readFile3(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 = import.meta.url;
+  const basePath = base.startsWith("file:") ? fileURLToPath(base) : base;
+  return path6.resolve(path6.dirname(basePath), "../../package.json");
+}
+
+// src/core/doctor.ts
+async function exists4(target) {
+  try {
+    await access4(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 = path7.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 = path7.isAbsolute(config.output.validateJsonPath) ? config.output.validateJsonPath : path7.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 outDirAbs = resolvePath(root, config, "outDir");
+  const rel = path7.relative(outDirAbs, validateJsonAbs);
+  const inside = rel !== "" && !rel.startsWith("..") && !path7.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)
+    }
+  });
+  if (options.rootExplicit) {
+    addCheck(checks, await buildOutDirCollisionCheck(root));
+  }
+  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) }
+    });
+  }
+  return {
+    tool: "qfai",
+    version,
+    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
+  };
+}
+var DEFAULT_CONFIG_SEARCH_IGNORE_GLOBS = [
+  ...DEFAULT_TEST_FILE_EXCLUDE_GLOBS,
+  "**/.pnpm/**",
+  "**/tmp/**",
+  "**/.mcp-tools/**"
+];
+async function buildOutDirCollisionCheck(root) {
+  try {
+    const result = await detectOutDirCollisions(root);
+    const relativeRoot = toRelativePath(process.cwd(), result.monorepoRoot);
+    const configRoots = result.configRoots.map((configRoot) => toRelativePath(result.monorepoRoot, configRoot)).sort((a, b) => a.localeCompare(b));
+    const collisions = result.collisions.map((item) => ({
+      outDir: toRelativePath(result.monorepoRoot, item.outDir),
+      roots: item.roots.map(
+        (collisionRoot) => toRelativePath(result.monorepoRoot, collisionRoot)
+      ).sort((a, b) => a.localeCompare(b))
+    })).sort((a, b) => a.outDir.localeCompare(b.outDir));
+    const severity = collisions.length > 0 ? "warning" : "ok";
+    const message = collisions.length > 0 ? `outDir collision detected (count=${collisions.length})` : `outDir collision not detected (configs=${configRoots.length})`;
+    return {
+      id: "output.outDirCollision",
+      severity,
+      title: "OutDir collision",
+      message,
+      details: {
+        monorepoRoot: relativeRoot,
+        configRoots,
+        collisions
+      }
+    };
+  } catch (error2) {
+    return {
+      id: "output.outDirCollision",
+      severity: "error",
+      title: "OutDir collision",
+      message: "OutDir collision scan failed",
+      details: { error: String(error2) }
+    };
+  }
+}
+async function detectOutDirCollisions(root) {
+  const monorepoRoot = await findMonorepoRoot(root);
+  const configPaths = await collectFilesByGlobs(monorepoRoot, {
+    globs: ["**/qfai.config.yaml"],
+    ignore: DEFAULT_CONFIG_SEARCH_IGNORE_GLOBS
+  });
+  const configRoots = Array.from(
+    new Set(configPaths.map((configPath) => path7.dirname(configPath)))
+  ).sort((a, b) => a.localeCompare(b));
+  const outDirToRoots = /* @__PURE__ */ new Map();
+  for (const configRoot of configRoots) {
+    const { config } = await loadConfig(configRoot);
+    const outDir = path7.normalize(resolvePath(configRoot, config, "outDir"));
+    const roots = outDirToRoots.get(outDir) ?? /* @__PURE__ */ new Set();
+    roots.add(configRoot);
+    outDirToRoots.set(outDir, roots);
+  }
+  const collisions = [];
+  for (const [outDir, roots] of outDirToRoots.entries()) {
+    if (roots.size > 1) {
+      collisions.push({
+        outDir,
+        roots: Array.from(roots).sort((a, b) => a.localeCompare(b))
+      });
+    }
+  }
+  return { monorepoRoot, configRoots, collisions };
+}
+async function findMonorepoRoot(startDir) {
+  let current = path7.resolve(startDir);
+  while (true) {
+    const gitPath = path7.join(current, ".git");
+    const workspacePath = path7.join(current, "pnpm-workspace.yaml");
+    if (await exists4(gitPath) || await exists4(workspacePath)) {
+      return current;
+    }
+    const parent = path7.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return path7.resolve(startDir);
+}
+
+// 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);
+  const exitCode = shouldFailDoctor(data.summary, options.failOn) ? 1 : 0;
+  if (options.outPath) {
+    const outAbs = path8.isAbsolute(options.outPath) ? options.outPath : path8.resolve(process.cwd(), options.outPath);
+    await mkdir(path8.dirname(outAbs), { recursive: true });
+    await writeFile(outAbs, `${output}
+`, "utf-8");
+    info(`doctor: wrote ${outAbs}`);
+    return exitCode;
+  }
+  info(output);
+  return exitCode;
+}
+function shouldFailDoctor(summary, failOn) {
+  if (!failOn) {
+    return false;
+  }
+  if (failOn === "error") {
+    return summary.error > 0;
+  }
+  return summary.warning + summary.error > 0;
+}
+
+// src/cli/commands/init.ts
+import path11 from "path";
+
+// src/cli/lib/fs.ts
+import { access as access5, copyFile, mkdir as mkdir2, readdir as readdir3 } from "fs/promises";
+import path9 from "path";
+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 = path9.relative(sourceRoot, file);
+      const dest = path9.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 = path9.relative(sourceRoot, file);
+    const dest = path9.join(destRoot, relative);
+    if (!await shouldWrite(dest, options.force)) {
+      skipped.push(dest);
+      continue;
+    }
+    if (!options.dryRun) {
+      await mkdir2(path9.dirname(dest), { recursive: true });
+      await 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 readdir3(root, { withFileTypes: true });
+  for (const item of items) {
+    const fullPath = path9.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 access5(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/lib/assets.ts
+import { existsSync } from "fs";
+import path10 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getInitAssetsDir() {
+  const base = import.meta.url;
+  const basePath = base.startsWith("file:") ? fileURLToPath2(base) : base;
+  const baseDir = path10.dirname(basePath);
+  const candidates = [
+    path10.resolve(baseDir, "../../../assets/init"),
+    path10.resolve(baseDir, "../../assets/init")
+  ];
+  for (const candidate of candidates) {
+    if (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 = path11.join(assetsRoot, "root");
+  const qfaiAssets = path11.join(assetsRoot, ".qfai");
+  const destRoot = path11.resolve(options.dir);
+  const destQfai = path11.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
+import { mkdir as mkdir3, readFile as readFile12, writeFile as writeFile2 } from "fs/promises";
+import path18 from "path";
+
+// 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
+import { readFile as readFile11 } from "fs/promises";
+import path17 from "path";
+
+// src/core/contractIndex.ts
+import { readFile as readFile4 } from "fs/promises";
+import path12 from "path";
+
+// 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 = path12.join(contractsRoot, "ui");
+  const apiRoot = path12.join(contractsRoot, "api");
+  const dbRoot = path12.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 readFile4(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 normalizedFiles = Array.from(
-    new Set(files.map((file) => path9.normalize(file)))
-  );
-  for (const file of normalizedFiles) {
-    const text = await readFile3(file, "utf-8");
-    const scIds = extractAnnotatedScIds(text);
-    if (scIds.length === 0) {
+  const ids = [];
+  const invalidTokens = [];
+  let hasNone = false;
+  for (const line of lines) {
+    if (line.length === 0) {
+      invalidTokens.push("(empty)");
       continue;
     }
-    for (const scId of scIds) {
-      const current = refs.get(scId) ?? /* @__PURE__ */ new Set();
-      current.add(file);
-      refs.set(scId, current);
+    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 {
-    refs,
-    scan: {
-      globs: normalizedGlobs,
-      excludeGlobs: mergedExcludeGlobs,
-      matchedFileCount: normalizedFiles.length
-    }
+    lines,
+    ids: unique3(ids),
+    invalidTokens: unique3(invalidTokens),
+    hasNone
   };
 }
-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 buildLinePattern(options) {
+  const prefix = options.allowCommentPrefix ? "#" : "";
+  return new RegExp(
+    `^[ \\t]*${prefix}[ \\t]*QFAI-CONTRACT-REF:[ \\t]*([^\\r\\n]*)[ \\t]*$`,
+    "gm"
+  );
 }
-function toSortedArray(values) {
-  return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
+function unique3(values) {
+  return Array.from(new Set(values));
 }
-function normalizeGlobs(globs) {
-  return globs.map((glob) => glob.trim()).filter((glob) => glob.length > 0);
+
+// 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 formatError3(error2) {
-  if (error2 instanceof Error) {
-    return error2.message;
+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 String(error2);
+  return sections;
 }
 
-// src/core/version.ts
-import { readFile as readFile4 } from "fs/promises";
-import path10 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-async function resolveToolVersion() {
-  if ("0.5.2".length > 0) {
-    return "0.5.2";
+// 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;
+    }
+    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
+      });
+    }
   }
-  try {
-    const packagePath = resolvePackageJsonPath();
-    const raw = await readFile4(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";
+  const parsed = {
+    file,
+    sections: sectionNames,
+    brs,
+    brsWithoutPriority,
+    brsWithInvalidPriority,
+    contractRefs: parseContractRefs(md)
+  };
+  if (specId) {
+    parsed.specId = specId;
   }
-}
-function resolvePackageJsonPath() {
-  const base = import.meta.url;
-  const basePath = base.startsWith("file:") ? fileURLToPath2(base) : base;
-  return path10.resolve(path10.dirname(basePath), "../../package.json");
+  return parsed;
 }
 
 // src/core/validators/contracts.ts
 import { readFile as readFile5 } from "fs/promises";
-import path12 from "path";
+import path14 from "path";
 
 // src/core/contracts.ts
-import path11 from "path";
+import path13 from "path";
 import { parse as parseYaml2 } from "yaml";
 function parseStructuredContract(file, text) {
-  const ext = path11.extname(file).toLowerCase();
+  const ext = path13.extname(file).toLowerCase();
   if (ext === ".json") {
     return JSON.parse(text);
   }
@@ -1389,9 +1701,9 @@ var SQL_DANGEROUS_PATTERNS = [
 async function validateContracts(root, config) {
   const issues = [];
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  issues.push(...await validateUiContracts(path12.join(contractsRoot, "ui")));
-  issues.push(...await validateApiContracts(path12.join(contractsRoot, "api")));
-  issues.push(...await validateDbContracts(path12.join(contractsRoot, "db")));
+  issues.push(...await validateUiContracts(path14.join(contractsRoot, "ui")));
+  issues.push(...await validateApiContracts(path14.join(contractsRoot, "api")));
+  issues.push(...await validateDbContracts(path14.join(contractsRoot, "db")));
   const contractIndex = await buildContractIndex(root, config);
   issues.push(...validateDuplicateContractIds(contractIndex));
   return issues;
@@ -1674,7 +1986,7 @@ function issue(code, message, severity, file, rule, refs) {
 
 // src/core/validators/delta.ts
 import { readFile as readFile6 } from "fs/promises";
-import path13 from "path";
+import path15 from "path";
 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;
@@ -1688,7 +2000,7 @@ async function validateDeltas(root, config) {
   }
   const issues = [];
   for (const pack of packs) {
-    const deltaPath = path13.join(pack, "delta.md");
+    const deltaPath = path15.join(pack, "delta.md");
     let text;
     try {
       text = await readFile6(deltaPath, "utf-8");
@@ -1764,7 +2076,7 @@ function issue2(code, message, severity, file, rule, refs) {
 
 // src/core/validators/ids.ts
 import { readFile as readFile7 } from "fs/promises";
-import path14 from "path";
+import path16 from "path";
 var SC_TAG_RE3 = /^SC-\d{4}$/;
 async function validateDefinedIds(root, config) {
   const issues = [];
@@ -1830,7 +2142,7 @@ function recordId(out, id, file) {
 }
 function formatFileList(files, root) {
   return files.map((file) => {
-    const relative = path14.relative(root, file);
+    const relative = path16.relative(root, file);
     return relative.length > 0 ? relative : file;
   }).join(", ");
 }
@@ -2721,15 +3033,15 @@ function countIssues(issues) {
 // src/core/report.ts
 var ID_PREFIXES2 = ["SPEC", "BR", "SC", "UI", "API", "DB"];
 async function createReportData(root, validation, configResult) {
-  const resolvedRoot = path15.resolve(root);
+  const resolvedRoot = path17.resolve(root);
   const resolved = configResult ?? await loadConfig(resolvedRoot);
   const config = resolved.config;
   const configPath = resolved.configPath;
   const specsRoot = resolvePath(resolvedRoot, config, "specsDir");
   const contractsRoot = resolvePath(resolvedRoot, config, "contractsDir");
-  const apiRoot = path15.join(contractsRoot, "api");
-  const uiRoot = path15.join(contractsRoot, "ui");
-  const dbRoot = path15.join(contractsRoot, "db");
+  const apiRoot = path17.join(contractsRoot, "api");
+  const uiRoot = path17.join(contractsRoot, "ui");
+  const dbRoot = path17.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specFiles = await collectSpecFiles(specsRoot);
@@ -3216,7 +3528,7 @@ function buildHotspots(issues) {
 
 // src/cli/commands/report.ts
 async function runReport(options) {
-  const root = path16.resolve(options.root);
+  const root = path18.resolve(options.root);
   const configResult = await loadConfig(root);
   let validation;
   if (options.runValidate) {
@@ -3233,7 +3545,7 @@ async function runReport(options) {
     validation = normalized;
   } else {
     const input = options.inputPath ?? configResult.config.output.validateJsonPath;
-    const inputPath = path16.isAbsolute(input) ? input : path16.resolve(root, input);
+    const inputPath = path18.isAbsolute(input) ? input : path18.resolve(root, input);
     try {
       validation = await readValidationResult(inputPath);
     } catch (err) {
@@ -3259,11 +3571,11 @@ async function runReport(options) {
   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" ? path16.join(outRoot, "report.json") : path16.join(outRoot, "report.md");
+  const defaultOut = options.format === "json" ? path18.join(outRoot, "report.json") : path18.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
-  const outPath = path16.isAbsolute(out) ? out : path16.resolve(root, out);
-  await mkdir2(path16.dirname(outPath), { recursive: true });
-  await writeFile(outPath, `${output}
+  const outPath = path18.isAbsolute(out) ? out : path18.resolve(root, out);
+  await mkdir3(path18.dirname(outPath), { recursive: true });
+  await writeFile2(outPath, `${output}
 `, "utf-8");
   info(
     `report: info=${validation.counts.info} warning=${validation.counts.warning} error=${validation.counts.error}`
@@ -3327,15 +3639,15 @@ function isMissingFileError5(error2) {
   return record2.code === "ENOENT";
 }
 async function writeValidationResult(root, outputPath, result) {
-  const abs = path16.isAbsolute(outputPath) ? outputPath : path16.resolve(root, outputPath);
-  await mkdir2(path16.dirname(abs), { recursive: true });
-  await writeFile(abs, `${JSON.stringify(result, null, 2)}
+  const abs = path18.isAbsolute(outputPath) ? outputPath : path18.resolve(root, outputPath);
+  await mkdir3(path18.dirname(abs), { recursive: true });
+  await writeFile2(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 
 // src/cli/commands/validate.ts
-import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
-import path17 from "path";
+import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+import path19 from "path";
 
 // src/cli/lib/failOn.ts
 function shouldFail(result, failOn) {
@@ -3350,7 +3662,7 @@ function shouldFail(result, failOn) {
 
 // src/cli/commands/validate.ts
 async function runValidate(options) {
-  const root = path17.resolve(options.root);
+  const root = path19.resolve(options.root);
   const configResult = await loadConfig(root);
   const result = await validateProject(root, configResult);
   const normalized = normalizeValidationResult(root, result);
@@ -3467,12 +3779,12 @@ function issueKey(issue7) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await mkdir3(path17.dirname(abs), { recursive: true });
-  await writeFile2(abs, `${JSON.stringify(result, null, 2)}
+  await mkdir4(path19.dirname(abs), { recursive: true });
+  await writeFile3(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return path17.isAbsolute(jsonPath) ? jsonPath : path17.resolve(root, jsonPath);
+  return path19.isAbsolute(jsonPath) ? jsonPath : path19.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 
@@ -3487,6 +3799,7 @@ function parseArgs(argv, cwd) {
     dryRun: false,
     reportFormat: "md",
     reportRunValidate: false,
+    doctorFormat: "text",
     validateFormat: "text",
     strict: false,
     help: false
@@ -3539,7 +3852,11 @@ 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;
@@ -3582,6 +3899,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;
   }
@@ -3629,6 +3952,18 @@ async function run(argv, cwd) {
         });
       }
       return;
+    case "doctor":
+      {
+        const exitCode = await runDoctor({
+          root: options.root,
+          rootExplicit: options.rootExplicit,
+          format: options.doctorFormat,
+          ...options.doctorOut !== void 0 ? { outPath: options.doctorOut } : {},
+          ...options.failOn && options.failOn !== "never" ? { failOn: options.failOn } : {}
+        });
+        process.exitCode = exitCode;
+      }
+      return;
     default:
       error(`Unknown command: ${command}`);
       info(usage());
@@ -3642,6 +3977,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
@@ -3651,9 +3987,11 @@ 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
+  --fail-on <error|warning>        doctor: \u5931\u6557\u6761\u4EF6
+  --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