qfai 1.0.7 → 1.1.1

package/dist/index.cjs

@@ -30,19 +30,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  checkDecisionGuardrails: () => checkDecisionGuardrails,
   createReportData: () => createReportData,
   defaultConfig: () => defaultConfig,
   extractAllIds: () => extractAllIds,
+  extractDecisionGuardrailsFromMarkdown: () => extractDecisionGuardrailsFromMarkdown,
   extractIds: () => extractIds,
   extractInvalidIds: () => extractInvalidIds,
+  filterDecisionGuardrailsByKeyword: () => filterDecisionGuardrailsByKeyword,
   findConfigRoot: () => findConfigRoot,
+  formatGuardrailsForLlm: () => formatGuardrailsForLlm,
   formatReportJson: () => formatReportJson,
   formatReportMarkdown: () => formatReportMarkdown,
   getConfigPath: () => getConfigPath,
   lintSql: () => lintSql,
   loadConfig: () => loadConfig,
+  loadDecisionGuardrails: () => loadDecisionGuardrails,
+  normalizeDecisionGuardrails: () => normalizeDecisionGuardrails,
   resolvePath: () => resolvePath,
   resolveToolVersion: () => resolveToolVersion,
+  sortDecisionGuardrails: () => sortDecisionGuardrails,
   validateContracts: () => validateContracts,
   validateDefinedIds: () => validateDefinedIds,
   validateDeltas: () => validateDeltas,
@@ -71,15 +78,7 @@ var defaultConfig = {
   validation: {
     failOn: "error",
     require: {
-      specSections: [
-        "\u80CC\u666F",
-        "\u30B9\u30B3\u30FC\u30D7",
-        "\u975E\u30B4\u30FC\u30EB",
-        "\u7528\u8A9E",
-        "\u524D\u63D0",
-        "\u6C7A\u5B9A\u4E8B\u9805",
-        "\u696D\u52D9\u30EB\u30FC\u30EB"
-      ]
+      specSections: []
     },
     traceability: {
       brMustHaveSc: true,
@@ -447,80 +446,9 @@ function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-// src/core/ids.ts
-var ID_PREFIXES = [
-  "SPEC",
-  "BR",
-  "SC",
-  "UI",
-  "API",
-  "DB",
-  "THEMA"
-];
-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,
-  THEMA: /\bTHEMA-\d{3}\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,
-  THEMA: /\bTHEMA-[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/report.ts
-var import_promises15 = require("fs/promises");
-var import_node_path16 = __toESM(require("path"), 1);
-
-// src/core/contractIndex.ts
-var import_promises5 = require("fs/promises");
-var import_node_path5 = __toESM(require("path"), 1);
-
-// src/core/discovery.ts
-var import_promises4 = require("fs/promises");
-var import_node_path4 = __toESM(require("path"), 1);
+// src/core/decisionGuardrails.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
 
 // src/core/fs.ts
 var import_promises2 = require("fs/promises");
@@ -623,24 +551,549 @@ function destroyStream(stream) {
   }
 }
 
+// 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/decisionGuardrails.ts
+var DEFAULT_DECISION_GUARDRAILS_GLOBS = [".qfai/specs/**/delta.md"];
+var DEFAULT_GUARDRAILS_IGNORE_GLOBS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.pnpm/**",
+  "**/tmp/**",
+  "**/.mcp-tools/**"
+];
+var SECTION_TITLE = "decision guardrails";
+var ENTRY_START_RE = /^\s*[-*]\s+ID:\s*(.+?)\s*$/i;
+var FIELD_RE = /^\s{2,}([A-Za-z][A-Za-z0-9 _-]*):\s*(.*)$/;
+var CONTINUATION_RE = /^\s{4,}(.+)$/;
+var ID_FORMAT_RE = /^DG-\d{4}$/;
+var TYPE_ORDER = {
+  "non-goal": 0,
+  "not-now": 1,
+  "trade-off": 2
+};
+async function loadDecisionGuardrails(root, options = {}) {
+  const errors = [];
+  const files = await scanDecisionGuardrailFiles(
+    root,
+    options.paths,
+    errors,
+    options.specsRoot
+  );
+  const entries = [];
+  for (const filePath of files) {
+    try {
+      const content = await (0, import_promises3.readFile)(filePath, "utf-8");
+      const parsed = extractDecisionGuardrailsFromMarkdown(content, filePath);
+      entries.push(...parsed);
+    } catch (error) {
+      errors.push({ path: filePath, message: String(error) });
+    }
+  }
+  return { entries, errors, files };
+}
+function extractDecisionGuardrailsFromMarkdown(markdown, filePath) {
+  const sections = extractH2Sections(markdown);
+  const section = findDecisionGuardrailsSection(sections);
+  if (!section) {
+    return [];
+  }
+  const lines = section.body.split(/\r?\n/);
+  const entries = [];
+  let current = null;
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    const entry = {
+      keywords: current.keywords,
+      source: { file: filePath, line: current.startLine },
+      ...current.fields.id ? { id: current.fields.id } : {},
+      ...current.fields.type ? { type: current.fields.type } : {},
+      ...current.fields.guardrail ? { guardrail: current.fields.guardrail } : {},
+      ...current.fields.rationale ? { rationale: current.fields.rationale } : {},
+      ...current.fields.reconsider ? { reconsider: current.fields.reconsider } : {},
+      ...current.fields.related ? { related: current.fields.related } : {},
+      ...current.fields.title ? { title: current.fields.title } : {}
+    };
+    entries.push(entry);
+    current = null;
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    const rawLine = lines[i] ?? "";
+    const lineNumber = section.startLine + i;
+    const entryMatch = rawLine.match(ENTRY_START_RE);
+    if (entryMatch) {
+      flush();
+      const id = entryMatch[1]?.trim() ?? "";
+      current = {
+        startLine: lineNumber,
+        fields: { id },
+        keywords: []
+      };
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    const fieldMatch = rawLine.match(FIELD_RE);
+    if (fieldMatch) {
+      const rawKey = fieldMatch[1] ?? "";
+      const value = fieldMatch[2] ?? "";
+      const key = normalizeFieldKey(rawKey);
+      if (key) {
+        if (key === "keywords") {
+          current.keywords.push(
+            ...value.split(",").map((item) => item.trim()).filter((item) => item.length > 0)
+          );
+        } else {
+          const trimmed = value.trim();
+          if (trimmed.length > 0) {
+            const existing = current.fields[key];
+            current.fields[key] = existing ? `${existing}
+${trimmed}` : trimmed;
+          }
+        }
+        current.lastKey = key;
+      } else {
+        delete current.lastKey;
+      }
+      continue;
+    }
+    const continuationMatch = rawLine.match(CONTINUATION_RE);
+    if (continuationMatch && current.lastKey) {
+      const value = continuationMatch[1]?.trim() ?? "";
+      if (value.length > 0) {
+        const existing = current.fields[current.lastKey];
+        current.fields[current.lastKey] = existing ? `${existing}
+${value}` : value;
+      }
+    }
+  }
+  flush();
+  return entries;
+}
+function normalizeDecisionGuardrails(entries) {
+  const items = [];
+  for (const entry of entries) {
+    const id = entry.id?.trim();
+    const type = normalizeGuardrailType(entry.type);
+    const guardrail = entry.guardrail?.trim();
+    if (!id || !type || !guardrail) {
+      continue;
+    }
+    const item = {
+      id,
+      type,
+      guardrail,
+      keywords: entry.keywords?.filter((word) => word.length > 0) ?? [],
+      source: entry.source
+    };
+    const rationale = entry.rationale?.trim();
+    if (rationale) {
+      item.rationale = rationale;
+    }
+    const reconsider = entry.reconsider?.trim();
+    if (reconsider) {
+      item.reconsider = reconsider;
+    }
+    const related = entry.related?.trim();
+    if (related) {
+      item.related = related;
+    }
+    const title = entry.title?.trim();
+    if (title) {
+      item.title = title;
+    }
+    items.push(item);
+  }
+  return items;
+}
+function sortDecisionGuardrails(items) {
+  return [...items].sort((a, b) => {
+    const typeOrder = (TYPE_ORDER[a.type] ?? 999) - (TYPE_ORDER[b.type] ?? 999);
+    if (typeOrder !== 0) {
+      return typeOrder;
+    }
+    return a.id.localeCompare(b.id);
+  });
+}
+function filterDecisionGuardrailsByKeyword(items, keyword) {
+  const needle = keyword?.trim().toLowerCase();
+  if (!needle) {
+    return items;
+  }
+  return items.filter((item) => {
+    const haystack = [
+      item.title,
+      item.guardrail,
+      item.rationale,
+      item.related,
+      item.keywords.join(" ")
+    ].filter((value) => Boolean(value)).map((value) => value.toLowerCase());
+    return haystack.some((value) => value.includes(needle));
+  });
+}
+function formatGuardrailsForLlm(items, max) {
+  const limit = Math.max(0, Math.floor(max));
+  const lines = ["# Decision Guardrails (extract)", ""];
+  const slice = limit > 0 ? items.slice(0, limit) : [];
+  if (slice.length === 0) {
+    lines.push("- (none)");
+    return lines.join("\n");
+  }
+  for (const item of slice) {
+    lines.push(`- [${item.id}][${item.type}] ${item.guardrail}`);
+    if (item.rationale) {
+      lines.push(`  Rationale: ${item.rationale}`);
+    }
+    if (item.reconsider) {
+      lines.push(`  Reconsider: ${item.reconsider}`);
+    }
+    if (item.related) {
+      lines.push(`  Related: ${item.related}`);
+    }
+  }
+  return lines.join("\n");
+}
+function checkDecisionGuardrails(entries) {
+  const errors = [];
+  const warnings = [];
+  const idMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const file = entry.source.file;
+    const line = entry.source.line;
+    const id = entry.id?.trim();
+    const typeRaw = entry.type?.trim();
+    const guardrail = entry.guardrail?.trim();
+    const rationale = entry.rationale?.trim();
+    const reconsider = entry.reconsider?.trim();
+    if (!id) {
+      errors.push({
+        severity: "error",
+        code: "QFAI-GR-001",
+        message: "ID is missing",
+        file,
+        line
+      });
+    } else {
+      const list = idMap.get(id) ?? [];
+      list.push(entry);
+      idMap.set(id, list);
+      if (!ID_FORMAT_RE.test(id)) {
+        warnings.push({
+          severity: "warning",
+          code: "QFAI-GR-002",
+          message: `ID format is not standard: ${id}`,
+          file,
+          line,
+          id
+        });
+      }
+    }
+    if (!typeRaw) {
+      errors.push({
+        severity: "error",
+        code: "QFAI-GR-003",
+        message: "Type is missing",
+        file,
+        line,
+        ...id ? { id } : {}
+      });
+    } else if (!normalizeGuardrailType(typeRaw)) {
+      errors.push({
+        severity: "error",
+        code: "QFAI-GR-004",
+        message: `Type is invalid: ${typeRaw}`,
+        file,
+        line,
+        ...id ? { id } : {}
+      });
+    }
+    if (!guardrail) {
+      errors.push({
+        severity: "error",
+        code: "QFAI-GR-005",
+        message: "Guardrail is missing",
+        file,
+        line,
+        ...id ? { id } : {}
+      });
+    }
+    if (!rationale) {
+      warnings.push({
+        severity: "warning",
+        code: "QFAI-GR-006",
+        message: "Rationale is missing",
+        file,
+        line,
+        ...id ? { id } : {}
+      });
+    }
+    if (!reconsider) {
+      warnings.push({
+        severity: "warning",
+        code: "QFAI-GR-007",
+        message: "Reconsider is missing",
+        file,
+        line,
+        ...id ? { id } : {}
+      });
+    }
+  }
+  for (const [id, list] of idMap.entries()) {
+    if (list.length > 1) {
+      const locations = list.map((entry) => `${entry.source.file}:${entry.source.line}`).join(", ");
+      const first = list[0];
+      const file = first?.source.file ?? "";
+      const line = first?.source.line;
+      errors.push({
+        severity: "error",
+        code: "QFAI-GR-008",
+        message: `ID is duplicated: ${id} (${locations})`,
+        file,
+        ...line !== void 0 ? { line } : {},
+        id
+      });
+    }
+  }
+  return { errors, warnings };
+}
+function normalizeGuardrailType(raw) {
+  if (!raw) {
+    return null;
+  }
+  const normalized = raw.trim().toLowerCase().replace(/[_\s]+/g, "-");
+  if (normalized === "non-goal") {
+    return "non-goal";
+  }
+  if (normalized === "not-now") {
+    return "not-now";
+  }
+  if (normalized === "trade-off") {
+    return "trade-off";
+  }
+  return null;
+}
+function normalizeFieldKey(raw) {
+  const normalized = raw.trim().toLowerCase().replace(/[_\s-]+/g, "");
+  switch (normalized) {
+    case "id":
+      return "id";
+    case "type":
+      return "type";
+    case "guardrail":
+      return "guardrail";
+    case "rationale":
+    case "reason":
+      return "rationale";
+    case "reconsider":
+      return "reconsider";
+    case "related":
+      return "related";
+    case "keywords":
+    case "keyword":
+      return "keywords";
+    case "title":
+    case "heading":
+      return "title";
+    default:
+      return null;
+  }
+}
+async function scanDecisionGuardrailFiles(root, rawPaths, errors, specsRoot) {
+  if (!rawPaths || rawPaths.length === 0) {
+    const scanRoot = specsRoot ? import_node_path3.default.isAbsolute(specsRoot) ? specsRoot : import_node_path3.default.resolve(root, specsRoot) : root;
+    const globs = specsRoot ? ["**/delta.md"] : DEFAULT_DECISION_GUARDRAILS_GLOBS;
+    try {
+      const result = await collectFilesByGlobs(scanRoot, {
+        globs,
+        ignore: DEFAULT_GUARDRAILS_IGNORE_GLOBS
+      });
+      return result.files.sort((a, b) => a.localeCompare(b));
+    } catch (error) {
+      errors.push({ path: scanRoot, message: String(error) });
+      return [];
+    }
+  }
+  const files = /* @__PURE__ */ new Set();
+  for (const rawPath of rawPaths) {
+    const resolved = import_node_path3.default.isAbsolute(rawPath) ? rawPath : import_node_path3.default.resolve(root, rawPath);
+    const stats = await safeStat(resolved);
+    if (!stats) {
+      errors.push({ path: resolved, message: "Path does not exist" });
+      continue;
+    }
+    if (stats.isFile()) {
+      files.add(resolved);
+      continue;
+    }
+    if (stats.isDirectory()) {
+      try {
+        const result = await collectFilesByGlobs(resolved, {
+          globs: ["**/delta.md"],
+          ignore: DEFAULT_GUARDRAILS_IGNORE_GLOBS
+        });
+        result.files.forEach((file) => files.add(file));
+      } catch (error) {
+        errors.push({ path: resolved, message: String(error) });
+      }
+      continue;
+    }
+    errors.push({ path: resolved, message: "Unsupported path type" });
+  }
+  return Array.from(files).sort((a, b) => a.localeCompare(b));
+}
+async function safeStat(target) {
+  try {
+    return await (0, import_promises3.stat)(target);
+  } catch {
+    return null;
+  }
+}
+function findDecisionGuardrailsSection(sections) {
+  for (const [title, section] of sections.entries()) {
+    if (title.trim().toLowerCase() === SECTION_TITLE) {
+      return section;
+    }
+  }
+  return null;
+}
+
+// src/core/ids.ts
+var ID_PREFIXES = [
+  "SPEC",
+  "BR",
+  "SC",
+  "UI",
+  "API",
+  "DB",
+  "THEMA"
+];
+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,
+  THEMA: /\bTHEMA-\d{3}\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,
+  THEMA: /\bTHEMA-[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/report.ts
+var import_promises16 = require("fs/promises");
+var import_node_path17 = __toESM(require("path"), 1);
+
+// src/core/contractIndex.ts
+var import_promises6 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
+
+// src/core/discovery.ts
+var import_promises5 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
+
 // src/core/specLayout.ts
-var import_promises3 = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_promises4 = require("fs/promises");
+var import_node_path4 = __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_path3.default.join(dir, "spec.md"),
-    deltaPath: import_node_path3.default.join(dir, "delta.md"),
-    scenarioPath: import_node_path3.default.join(dir, "scenario.feature")
+    specPath: import_node_path4.default.join(dir, "spec.md"),
+    deltaPath: import_node_path4.default.join(dir, "delta.md"),
+    scenarioPath: import_node_path4.default.join(dir, "scenario.feature")
   }));
   return entries.sort((a, b) => a.dir.localeCompare(b.dir));
 }
 async function listSpecDirs(specsRoot) {
   try {
-    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));
+    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_path4.default.join(specsRoot, name));
   } catch (error) {
     if (isMissingFileError(error)) {
       return [];
@@ -702,7 +1155,7 @@ async function filterExisting(files) {
 }
 async function exists3(target) {
   try {
-    await (0, import_promises4.access)(target);
+    await (0, import_promises5.access)(target);
     return true;
   } catch {
     return false;
@@ -711,7 +1164,7 @@ async function exists3(target) {
 function filterByBasenamePrefix(files, prefix) {
   const lowerPrefix = prefix.toLowerCase();
   return files.filter(
-    (file) => import_node_path4.default.basename(file).toLowerCase().startsWith(lowerPrefix)
+    (file) => import_node_path5.default.basename(file).toLowerCase().startsWith(lowerPrefix)
   );
 }
 
@@ -735,9 +1188,9 @@ function stripContractDeclarationLines(text) {
 // src/core/contractIndex.ts
 async function buildContractIndex(root, config) {
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = import_node_path5.default.join(contractsRoot, "ui");
-  const apiRoot = import_node_path5.default.join(contractsRoot, "api");
-  const dbRoot = import_node_path5.default.join(contractsRoot, "db");
+  const uiRoot = import_node_path6.default.join(contractsRoot, "ui");
+  const apiRoot = import_node_path6.default.join(contractsRoot, "api");
+  const dbRoot = import_node_path6.default.join(contractsRoot, "db");
   const [uiFiles, themaFiles, apiFiles, dbFiles] = await Promise.all([
     collectUiContractFiles(uiRoot),
     collectThemaContractFiles(uiRoot),
@@ -757,7 +1210,7 @@ async function buildContractIndex(root, config) {
 }
 async function indexContractFiles(files, index) {
   for (const file of files) {
-    const text = await (0, import_promises5.readFile)(file, "utf-8");
+    const text = await (0, import_promises6.readFile)(file, "utf-8");
     extractDeclaredContractIds(text).forEach((id) => record(index, id, file));
   }
 }
@@ -769,15 +1222,15 @@ function record(index, id, file) {
 }
 
 // src/core/paths.ts
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 function toRelativePath(root, target) {
   if (!target) {
     return target;
   }
-  if (!import_node_path6.default.isAbsolute(target)) {
+  if (!import_node_path7.default.isAbsolute(target)) {
     return toPosixPath(target);
   }
-  const relative = import_node_path6.default.relative(root, target);
+  const relative = import_node_path7.default.relative(root, target);
   if (!relative) {
     return ".";
   }
@@ -875,53 +1328,11 @@ 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);
@@ -929,15 +1340,13 @@ function parseSpec(md, file) {
   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 lines = md.split(/\r?\n/);
   const brs = [];
   const brsWithoutPriority = [];
   const brsWithInvalidPriority = [];
-  for (let i = 0; i < brLines.length; i++) {
-    const lineText = brLines[i] ?? "";
-    const lineNumber = startLine + i;
+  for (let i = 0; i < lines.length; i++) {
+    const lineText = lines[i] ?? "";
+    const lineNumber = i + 1;
     const validMatch = lineText.match(BR_LINE_RE);
     if (validMatch) {
       const id = validMatch[1];
@@ -995,8 +1404,8 @@ function parseSpec(md, file) {
 }
 
 // src/core/traceability.ts
-var import_promises6 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"), 1);
+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");
@@ -1148,7 +1557,7 @@ function extractAnnotatedScIds(text) {
 async function collectScIdsFromScenarioFiles(scenarioFiles) {
   const scIds = /* @__PURE__ */ new Set();
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises6.readFile)(file, "utf-8");
+    const text = await (0, import_promises7.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -1166,7 +1575,7 @@ async function collectScIdsFromScenarioFiles(scenarioFiles) {
 async function collectScIdSourcesFromScenarioFiles(scenarioFiles) {
   const sources = /* @__PURE__ */ new Map();
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises6.readFile)(file, "utf-8");
+    const text = await (0, import_promises7.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -1224,10 +1633,10 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
     };
   }
   const normalizedFiles = Array.from(
-    new Set(scanResult.files.map((file) => import_node_path7.default.normalize(file)))
+    new Set(scanResult.files.map((file) => import_node_path8.default.normalize(file)))
   );
   for (const file of normalizedFiles) {
-    const text = await (0, import_promises6.readFile)(file, "utf-8");
+    const text = await (0, import_promises7.readFile)(file, "utf-8");
     const scIds = extractAnnotatedScIds(text);
     if (scIds.length === 0) {
       continue;
@@ -1286,16 +1695,16 @@ function formatError3(error) {
 }
 
 // src/core/version.ts
-var import_promises7 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_promises8 = require("fs/promises");
+var import_node_path9 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 async function resolveToolVersion() {
-  if ("1.0.7".length > 0) {
-    return "1.0.7";
+  if ("1.1.1".length > 0) {
+    return "1.1.1";
   }
   try {
     const packagePath = resolvePackageJsonPath();
-    const raw = await (0, import_promises7.readFile)(packagePath, "utf-8");
+    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";
@@ -1306,18 +1715,18 @@ async function resolveToolVersion() {
 function resolvePackageJsonPath() {
   const base = __filename;
   const basePath = base.startsWith("file:") ? (0, import_node_url.fileURLToPath)(base) : base;
-  return import_node_path8.default.resolve(import_node_path8.default.dirname(basePath), "../../package.json");
+  return import_node_path9.default.resolve(import_node_path9.default.dirname(basePath), "../../package.json");
 }
 
 // src/core/validators/contracts.ts
-var import_promises8 = require("fs/promises");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_promises9 = require("fs/promises");
+var import_node_path11 = __toESM(require("path"), 1);
 
 // src/core/contracts.ts
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_yaml2 = require("yaml");
 function parseStructuredContract(file, text) {
-  const ext = import_node_path9.default.extname(file).toLowerCase();
+  const ext = import_node_path10.default.extname(file).toLowerCase();
   if (ext === ".json") {
     return JSON.parse(text);
   }
@@ -1339,14 +1748,14 @@ async function validateContracts(root, config) {
   const issues = [];
   const contractIndex = await buildContractIndex(root, config);
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = import_node_path10.default.join(contractsRoot, "ui");
+  const uiRoot = import_node_path11.default.join(contractsRoot, "ui");
   const themaIds = new Set(
     Array.from(contractIndex.ids).filter((id) => id.startsWith("THEMA-"))
   );
   issues.push(...await validateUiContracts(uiRoot, themaIds));
   issues.push(...await validateThemaContracts(uiRoot));
-  issues.push(...await validateApiContracts(import_node_path10.default.join(contractsRoot, "api")));
-  issues.push(...await validateDbContracts(import_node_path10.default.join(contractsRoot, "db")));
+  issues.push(...await validateApiContracts(import_node_path11.default.join(contractsRoot, "api")));
+  issues.push(...await validateDbContracts(import_node_path11.default.join(contractsRoot, "db")));
   issues.push(...validateDuplicateContractIds(contractIndex));
   return issues;
 }
@@ -1365,7 +1774,7 @@ async function validateUiContracts(uiRoot, themaIds) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises8.readFile)(file, "utf-8");
+    const text = await (0, import_promises9.readFile)(file, "utf-8");
     const declaredIds = extractDeclaredContractIds(text);
     issues.push(...validateDeclaredContractIds(declaredIds, file, "UI"));
     let doc = null;
@@ -1419,7 +1828,7 @@ async function validateThemaContracts(uiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises8.readFile)(file, "utf-8");
+    const text = await (0, import_promises9.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1553,7 +1962,7 @@ async function validateApiContracts(apiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises8.readFile)(file, "utf-8");
+    const text = await (0, import_promises9.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1622,7 +2031,7 @@ async function validateDbContracts(dbRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await (0, import_promises8.readFile)(file, "utf-8");
+    const text = await (0, import_promises9.readFile)(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1819,9 +2228,9 @@ async function validateUiAssets(assets, file, uiRoot) {
     );
     return issues;
   }
-  const packDir = import_node_path10.default.resolve(uiRoot, packValue);
-  const packRelative = import_node_path10.default.relative(uiRoot, packDir);
-  if (packRelative.startsWith("..") || import_node_path10.default.isAbsolute(packRelative)) {
+  const packDir = import_node_path11.default.resolve(uiRoot, packValue);
+  const packRelative = import_node_path11.default.relative(uiRoot, packDir);
+  if (packRelative.startsWith("..") || import_node_path11.default.isAbsolute(packRelative)) {
     issues.push(
       issue(
         "QFAI-ASSET-001",
@@ -1847,7 +2256,7 @@ async function validateUiAssets(assets, file, uiRoot) {
     );
     return issues;
   }
-  const assetsYamlPath = import_node_path10.default.join(packDir, "assets.yaml");
+  const assetsYamlPath = import_node_path11.default.join(packDir, "assets.yaml");
   if (!await exists4(assetsYamlPath)) {
     issues.push(
       issue(
@@ -1862,7 +2271,7 @@ async function validateUiAssets(assets, file, uiRoot) {
   }
   let manifest;
   try {
-    const manifestText = await (0, import_promises8.readFile)(assetsYamlPath, "utf-8");
+    const manifestText = await (0, import_promises9.readFile)(assetsYamlPath, "utf-8");
     manifest = parseStructuredContract(assetsYamlPath, manifestText);
   } catch (error) {
     issues.push(
@@ -1935,9 +2344,9 @@ async function validateUiAssets(assets, file, uiRoot) {
       );
       continue;
     }
-    const assetPath = import_node_path10.default.resolve(packDir, entry.path);
-    const assetRelative = import_node_path10.default.relative(packDir, assetPath);
-    if (assetRelative.startsWith("..") || import_node_path10.default.isAbsolute(assetRelative)) {
+    const assetPath = import_node_path11.default.resolve(packDir, entry.path);
+    const assetRelative = import_node_path11.default.relative(packDir, assetPath);
+    if (assetRelative.startsWith("..") || import_node_path11.default.isAbsolute(assetRelative)) {
       issues.push(
         issue(
           "QFAI-ASSET-004",
@@ -1978,7 +2387,7 @@ function shouldIgnoreInvalidId(value, doc) {
     return false;
   }
   const normalized = packValue.replace(/\\/g, "/");
-  const basename = import_node_path10.default.posix.basename(normalized);
+  const basename = import_node_path11.default.posix.basename(normalized);
   if (!basename) {
     return false;
   }
@@ -1988,7 +2397,7 @@ function isSafeRelativePath(value) {
   if (!value) {
     return false;
   }
-  if (import_node_path10.default.isAbsolute(value)) {
+  if (import_node_path11.default.isAbsolute(value)) {
     return false;
   }
   const normalized = value.replace(/\\/g, "/");
@@ -2003,7 +2412,7 @@ function isSafeRelativePath(value) {
 }
 async function exists4(target) {
   try {
-    await (0, import_promises8.access)(target);
+    await (0, import_promises9.access)(target);
     return true;
   } catch {
     return false;
@@ -2038,8 +2447,8 @@ function issue(code, message, severity, file, rule, refs, category = "compatibil
 }
 
 // src/core/validators/delta.ts
-var import_promises9 = require("fs/promises");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_promises10 = require("fs/promises");
+var import_node_path12 = __toESM(require("path"), 1);
 async function validateDeltas(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const packs = await collectSpecPackDirs(specsRoot);
@@ -2048,9 +2457,9 @@ async function validateDeltas(root, config) {
   }
   const issues = [];
   for (const pack of packs) {
-    const deltaPath = import_node_path11.default.join(pack, "delta.md");
+    const deltaPath = import_node_path12.default.join(pack, "delta.md");
     try {
-      await (0, import_promises9.readFile)(deltaPath, "utf-8");
+      await (0, import_promises10.readFile)(deltaPath, "utf-8");
     } catch (error) {
       if (isMissingFileError2(error)) {
         issues.push(
@@ -2101,8 +2510,8 @@ function issue2(code, message, severity, file, rule, refs, category = "change",
 }
 
 // src/core/validators/ids.ts
-var import_promises10 = require("fs/promises");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_promises11 = require("fs/promises");
+var import_node_path13 = __toESM(require("path"), 1);
 var SC_TAG_RE3 = /^SC-\d{4}$/;
 async function validateDefinedIds(root, config) {
   const issues = [];
@@ -2137,7 +2546,7 @@ async function validateDefinedIds(root, config) {
 }
 async function collectSpecDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await (0, import_promises10.readFile)(file, "utf-8");
+    const text = await (0, import_promises11.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
       recordId(out, parsed.specId, file);
@@ -2147,7 +2556,7 @@ async function collectSpecDefinitionIds(files, out) {
 }
 async function collectScenarioDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await (0, import_promises10.readFile)(file, "utf-8");
+    const text = await (0, import_promises11.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -2168,7 +2577,7 @@ function recordId(out, id, file) {
 }
 function formatFileList(files, root) {
   return files.map((file) => {
-    const relative = import_node_path12.default.relative(root, file);
+    const relative = import_node_path13.default.relative(root, file);
     return relative.length > 0 ? relative : file;
   }).join(", ");
 }
@@ -2195,20 +2604,20 @@ function issue3(code, message, severity, file, rule, refs, category = "compatibi
 }
 
 // src/core/promptsIntegrity.ts
-var import_promises11 = require("fs/promises");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_promises12 = require("fs/promises");
+var import_node_path15 = __toESM(require("path"), 1);
 
 // src/shared/assets.ts
 var import_node_fs = require("fs");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path14 = __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_path13.default.dirname(basePath);
+  const baseDir = import_node_path14.default.dirname(basePath);
   const candidates = [
-    import_node_path13.default.resolve(baseDir, "../../../assets/init"),
-    import_node_path13.default.resolve(baseDir, "../../assets/init")
+    import_node_path14.default.resolve(baseDir, "../../../assets/init"),
+    import_node_path14.default.resolve(baseDir, "../../assets/init")
   ];
   for (const candidate of candidates) {
     if ((0, import_node_fs.existsSync)(candidate)) {
@@ -2228,10 +2637,10 @@ function getInitAssetsDir() {
 var LEGACY_OK_EXTRA = /* @__PURE__ */ new Set(["qfai-classify-change.md"]);
 async function diffProjectPromptsAgainstInitAssets(root, config) {
   const promptsDirConfig = config.paths.promptsDir;
-  const promptsDir = import_node_path14.default.isAbsolute(promptsDirConfig) ? promptsDirConfig : import_node_path14.default.resolve(root, promptsDirConfig);
+  const promptsDir = import_node_path15.default.isAbsolute(promptsDirConfig) ? promptsDirConfig : import_node_path15.default.resolve(root, promptsDirConfig);
   let templateDir;
   try {
-    const rel = import_node_path14.default.isAbsolute(promptsDirConfig) ? import_node_path14.default.relative(root, promptsDirConfig) : promptsDirConfig;
+    const rel = import_node_path15.default.isAbsolute(promptsDirConfig) ? import_node_path15.default.relative(root, promptsDirConfig) : promptsDirConfig;
     const normalized = rel.replace(/^[\\/]+/, "");
     if (normalized.length === 0 || normalized.startsWith("..")) {
       return {
@@ -2243,7 +2652,7 @@ async function diffProjectPromptsAgainstInitAssets(root, config) {
         changed: []
       };
     }
-    templateDir = import_node_path14.default.join(getInitAssetsDir(), normalized);
+    templateDir = import_node_path15.default.join(getInitAssetsDir(), normalized);
   } catch {
     return {
       status: "skipped_missing_assets",
@@ -2297,8 +2706,8 @@ async function diffProjectPromptsAgainstInitAssets(root, config) {
     }
     try {
       const [a, b] = await Promise.all([
-        (0, import_promises11.readFile)(templateAbs, "utf-8"),
-        (0, import_promises11.readFile)(projectAbs, "utf-8")
+        (0, import_promises12.readFile)(templateAbs, "utf-8"),
+        (0, import_promises12.readFile)(projectAbs, "utf-8")
       ]);
       if (normalizeNewlines(a) !== normalizeNewlines(b)) {
         changed.push(rel);
@@ -2321,7 +2730,7 @@ function normalizeNewlines(text) {
   return text.replace(/\r\n/g, "\n");
 }
 function toRel(base, abs) {
-  const rel = import_node_path14.default.relative(base, abs);
+  const rel = import_node_path15.default.relative(base, abs);
   return rel.replace(/[\\/]+/g, "/");
 }
 function intersectKeys(a, b) {
@@ -2366,8 +2775,8 @@ async function validatePromptsIntegrity(root, config) {
 }
 
 // src/core/validators/scenario.ts
-var import_promises12 = require("fs/promises");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_promises13 = require("fs/promises");
+var import_node_path16 = __toESM(require("path"), 1);
 var GIVEN_PATTERN = /\bGiven\b/;
 var WHEN_PATTERN = /\bWhen\b/;
 var THEN_PATTERN = /\bThen\b/;
@@ -2390,7 +2799,7 @@ async function validateScenarios(root, config) {
   }
   const issues = [];
   for (const entry of entries) {
-    const legacyScenarioPath = import_node_path15.default.join(entry.dir, "scenario.md");
+    const legacyScenarioPath = import_node_path16.default.join(entry.dir, "scenario.md");
     if (await fileExists(legacyScenarioPath)) {
       issues.push(
         issue4(
@@ -2404,7 +2813,7 @@ async function validateScenarios(root, config) {
     }
     let text;
     try {
-      text = await (0, import_promises12.readFile)(entry.scenarioPath, "utf-8");
+      text = await (0, import_promises13.readFile)(entry.scenarioPath, "utf-8");
     } catch (error) {
       if (isMissingFileError3(error)) {
         issues.push(
@@ -2579,7 +2988,7 @@ function isMissingFileError3(error) {
 }
 async function fileExists(target) {
   try {
-    await (0, import_promises12.access)(target);
+    await (0, import_promises13.access)(target);
     return true;
   } catch {
     return false;
@@ -2587,7 +2996,7 @@ async function fileExists(target) {
 }
 
 // src/core/validators/spec.ts
-var import_promises13 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 async function validateSpecs(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
@@ -2608,7 +3017,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_promises14.readFile)(entry.specPath, "utf-8");
     } catch (error) {
       if (isMissingFileError4(error)) {
         issues.push(
@@ -2762,7 +3171,7 @@ function isMissingFileError4(error) {
 }
 
 // src/core/validators/traceability.ts
-var import_promises14 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var SPEC_TAG_RE3 = /^SPEC-\d{4}$/;
 var BR_TAG_RE2 = /^BR-\d{4}$/;
 async function validateTraceability(root, config) {
@@ -2782,7 +3191,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_promises15.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
@@ -2855,7 +3264,7 @@ 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_promises15.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const scenarioContractRefs = parseContractRefs(text, {
       allowCommentPrefix: true
@@ -3177,7 +3586,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_promises15.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       found = true;
       break;
@@ -3276,16 +3685,17 @@ var ID_PREFIXES2 = [
   "DB",
   "THEMA"
 ];
+var REPORT_GUARDRAILS_MAX = 20;
 async function createReportData(root, validation, configResult) {
-  const resolvedRoot = import_node_path16.default.resolve(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(resolvedRoot, config, "specsDir");
   const contractsRoot = resolvePath(resolvedRoot, config, "contractsDir");
-  const apiRoot = import_node_path16.default.join(contractsRoot, "api");
-  const uiRoot = import_node_path16.default.join(contractsRoot, "ui");
-  const dbRoot = import_node_path16.default.join(contractsRoot, "db");
+  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);
@@ -3344,6 +3754,27 @@ async function createReportData(root, validation, configResult) {
   const scSourceRecord = mapToSortedRecord(
     normalizeScSources(resolvedRoot, scSources)
   );
+  const guardrailsLoad = await loadDecisionGuardrails(resolvedRoot, {
+    specsRoot
+  });
+  const guardrailsAll = sortDecisionGuardrails(
+    normalizeDecisionGuardrails(guardrailsLoad.entries)
+  );
+  const guardrailsDisplay = guardrailsAll.slice(0, REPORT_GUARDRAILS_MAX);
+  const guardrailsByType = { nonGoal: 0, notNow: 0, tradeOff: 0 };
+  for (const item of guardrailsAll) {
+    if (item.type === "non-goal") {
+      guardrailsByType.nonGoal += 1;
+    } else if (item.type === "not-now") {
+      guardrailsByType.notNow += 1;
+    } else if (item.type === "trade-off") {
+      guardrailsByType.tradeOff += 1;
+    }
+  }
+  const guardrailsErrors = guardrailsLoad.errors.map((item) => ({
+    path: toRelativePath(resolvedRoot, item.path),
+    message: item.message
+  }));
   const version = await resolveToolVersion();
   const displayRoot = toRelativePath(resolvedRoot, resolvedRoot);
   const displayConfigPath = toRelativePath(resolvedRoot, configPath);
@@ -3391,6 +3822,34 @@ async function createReportData(root, validation, configResult) {
         specToContracts: specToContractsRecord
       }
     },
+    guardrails: {
+      total: guardrailsAll.length,
+      max: REPORT_GUARDRAILS_MAX,
+      truncated: guardrailsAll.length > guardrailsDisplay.length,
+      byType: guardrailsByType,
+      items: guardrailsDisplay.map((item) => {
+        const entry = {
+          id: item.id,
+          type: item.type,
+          guardrail: item.guardrail,
+          source: {
+            file: toRelativePath(resolvedRoot, item.source.file),
+            line: item.source.line
+          }
+        };
+        if (item.rationale) {
+          entry.rationale = item.rationale;
+        }
+        if (item.reconsider) {
+          entry.reconsider = item.reconsider;
+        }
+        if (item.related) {
+          entry.related = item.related;
+        }
+        return entry;
+      }),
+      scanErrors: guardrailsErrors
+    },
     issues: normalizedValidation.issues
   };
 }
@@ -3486,6 +3945,7 @@ function formatReportMarkdown(data, options = {}) {
   lines.push("");
   lines.push("- [Compatibility Issues](#compatibility-issues)");
   lines.push("- [Change Issues](#change-issues)");
+  lines.push("- [Decision Guardrails](#decision-guardrails)");
   lines.push("- [IDs](#ids)");
   lines.push("- [Traceability](#traceability)");
   lines.push("");
@@ -3577,6 +4037,49 @@ function formatReportMarkdown(data, options = {}) {
   lines.push("### Issues");
   lines.push("");
   lines.push(...formatIssueCards(issuesByCategory.change));
+  lines.push("## Decision Guardrails");
+  lines.push("");
+  lines.push(`- total: ${data.guardrails.total}`);
+  lines.push(
+    `- types: non-goal ${data.guardrails.byType.nonGoal} / not-now ${data.guardrails.byType.notNow} / trade-off ${data.guardrails.byType.tradeOff}`
+  );
+  if (data.guardrails.truncated) {
+    lines.push(`- truncated: true (max=${data.guardrails.max})`);
+  }
+  if (data.guardrails.scanErrors.length > 0) {
+    lines.push(`- scanErrors: ${data.guardrails.scanErrors.length}`);
+  }
+  lines.push("");
+  if (data.guardrails.items.length === 0) {
+    lines.push("- (none)");
+  } else {
+    for (const item of data.guardrails.items) {
+      lines.push(`- [${item.id}][${item.type}] ${item.guardrail}`);
+      lines.push(
+        `  - source: ${formatPathWithLine(item.source.file, { line: item.source.line }, baseUrl)}`
+      );
+      if (item.rationale) {
+        lines.push(`  - Rationale: ${item.rationale}`);
+      }
+      if (item.reconsider) {
+        lines.push(`  - Reconsider: ${item.reconsider}`);
+      }
+      if (item.related) {
+        lines.push(`  - Related: ${item.related}`);
+      }
+    }
+  }
+  if (data.guardrails.scanErrors.length > 0) {
+    lines.push("");
+    lines.push("### Scan errors");
+    lines.push("");
+    for (const errorItem of data.guardrails.scanErrors) {
+      lines.push(
+        `- ${formatPathLink(errorItem.path, baseUrl)}: ${errorItem.message}`
+      );
+    }
+  }
+  lines.push("");
   lines.push("## IDs");
   lines.push("");
   lines.push(formatIdLine("SPEC", data.ids.spec));
@@ -3767,7 +4270,7 @@ async function collectSpecContractRefs(specFiles, 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_promises16.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -3809,7 +4312,7 @@ async function collectIds(files) {
     THEMA: /* @__PURE__ */ new Set()
   };
   for (const file of files) {
-    const text = await (0, import_promises15.readFile)(file, "utf-8");
+    const text = await (0, import_promises16.readFile)(file, "utf-8");
     for (const prefix of ID_PREFIXES2) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -3828,7 +4331,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_promises16.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -3849,7 +4352,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_promises16.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -3975,19 +4478,26 @@ function buildHotspots(issues) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  checkDecisionGuardrails,
   createReportData,
   defaultConfig,
   extractAllIds,
+  extractDecisionGuardrailsFromMarkdown,
   extractIds,
   extractInvalidIds,
+  filterDecisionGuardrailsByKeyword,
   findConfigRoot,
+  formatGuardrailsForLlm,
   formatReportJson,
   formatReportMarkdown,
   getConfigPath,
   lintSql,
   loadConfig,
+  loadDecisionGuardrails,
+  normalizeDecisionGuardrails,
   resolvePath,
   resolveToolVersion,
+  sortDecisionGuardrails,
   validateContracts,
   validateDefinedIds,
   validateDeltas,