qfai 1.0.7 → 1.1.1

package/dist/index.mjs

@@ -14,15 +14,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,
@@ -390,80 +382,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
-import { readFile as readFile12 } from "fs/promises";
-import path16 from "path";
-
-// src/core/contractIndex.ts
-import { readFile as readFile2 } from "fs/promises";
-import path5 from "path";
-
-// src/core/discovery.ts
-import { access as access3 } from "fs/promises";
-import path4 from "path";
+// src/core/decisionGuardrails.ts
+import { readFile as readFile2, stat } from "fs/promises";
+import path3 from "path";
 
 // src/core/fs.ts
 import { access as access2, readdir } from "fs/promises";
@@ -566,24 +487,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 readFile2(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 ? path3.isAbsolute(specsRoot) ? specsRoot : path3.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 = path3.isAbsolute(rawPath) ? rawPath : path3.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 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
+import { readFile as readFile13 } from "fs/promises";
+import path17 from "path";
+
+// src/core/contractIndex.ts
+import { readFile as readFile3 } from "fs/promises";
+import path6 from "path";
+
+// src/core/discovery.ts
+import { access as access3 } from "fs/promises";
+import path5 from "path";
+
 // src/core/specLayout.ts
 import { readdir as readdir2 } from "fs/promises";
-import path3 from "path";
+import path4 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: path3.join(dir, "spec.md"),
-    deltaPath: path3.join(dir, "delta.md"),
-    scenarioPath: path3.join(dir, "scenario.feature")
+    specPath: path4.join(dir, "spec.md"),
+    deltaPath: path4.join(dir, "delta.md"),
+    scenarioPath: path4.join(dir, "scenario.feature")
   }));
   return entries.sort((a, b) => a.dir.localeCompare(b.dir));
 }
 async function listSpecDirs(specsRoot) {
   try {
     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));
+    return items.filter((item) => item.isDirectory()).map((item) => item.name).filter((name) => SPEC_DIR_RE.test(name.toLowerCase())).map((name) => path4.join(specsRoot, name));
   } catch (error) {
     if (isMissingFileError(error)) {
       return [];
@@ -654,7 +1100,7 @@ async function exists3(target) {
 function filterByBasenamePrefix(files, prefix) {
   const lowerPrefix = prefix.toLowerCase();
   return files.filter(
-    (file) => path4.basename(file).toLowerCase().startsWith(lowerPrefix)
+    (file) => path5.basename(file).toLowerCase().startsWith(lowerPrefix)
   );
 }
 
@@ -678,9 +1124,9 @@ function stripContractDeclarationLines(text) {
 // src/core/contractIndex.ts
 async function buildContractIndex(root, config) {
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = path5.join(contractsRoot, "ui");
-  const apiRoot = path5.join(contractsRoot, "api");
-  const dbRoot = path5.join(contractsRoot, "db");
+  const uiRoot = path6.join(contractsRoot, "ui");
+  const apiRoot = path6.join(contractsRoot, "api");
+  const dbRoot = path6.join(contractsRoot, "db");
   const [uiFiles, themaFiles, apiFiles, dbFiles] = await Promise.all([
     collectUiContractFiles(uiRoot),
     collectThemaContractFiles(uiRoot),
@@ -700,7 +1146,7 @@ async function buildContractIndex(root, config) {
 }
 async function indexContractFiles(files, index) {
   for (const file of files) {
-    const text = await readFile2(file, "utf-8");
+    const text = await readFile3(file, "utf-8");
     extractDeclaredContractIds(text).forEach((id) => record(index, id, file));
   }
 }
@@ -712,15 +1158,15 @@ function record(index, id, file) {
 }
 
 // src/core/paths.ts
-import path6 from "path";
+import path7 from "path";
 function toRelativePath(root, target) {
   if (!target) {
     return target;
   }
-  if (!path6.isAbsolute(target)) {
+  if (!path7.isAbsolute(target)) {
     return toPosixPath(target);
   }
-  const relative = path6.relative(root, target);
+  const relative = path7.relative(root, target);
   if (!relative) {
     return ".";
   }
@@ -818,53 +1264,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);
@@ -872,15 +1276,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];
@@ -938,8 +1340,8 @@ function parseSpec(md, file) {
 }
 
 // src/core/traceability.ts
-import { readFile as readFile3 } from "fs/promises";
-import path7 from "path";
+import { readFile as readFile4 } from "fs/promises";
+import path8 from "path";
 
 // src/core/gherkin/parse.ts
 import {
@@ -1095,7 +1497,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 readFile4(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -1113,7 +1515,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 readFile4(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -1171,10 +1573,10 @@ async function collectScTestReferences(root, globs, excludeGlobs) {
     };
   }
   const normalizedFiles = Array.from(
-    new Set(scanResult.files.map((file) => path7.normalize(file)))
+    new Set(scanResult.files.map((file) => path8.normalize(file)))
   );
   for (const file of normalizedFiles) {
-    const text = await readFile3(file, "utf-8");
+    const text = await readFile4(file, "utf-8");
     const scIds = extractAnnotatedScIds(text);
     if (scIds.length === 0) {
       continue;
@@ -1233,16 +1635,16 @@ function formatError3(error) {
 }
 
 // src/core/version.ts
-import { readFile as readFile4 } from "fs/promises";
-import path8 from "path";
+import { readFile as readFile5 } from "fs/promises";
+import path9 from "path";
 import { fileURLToPath } from "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 readFile4(packagePath, "utf-8");
+    const raw = await readFile5(packagePath, "utf-8");
     const parsed = JSON.parse(raw);
     const version = typeof parsed.version === "string" ? parsed.version : "";
     return version.length > 0 ? version : "unknown";
@@ -1253,18 +1655,18 @@ async function resolveToolVersion() {
 function resolvePackageJsonPath() {
   const base = import.meta.url;
   const basePath = base.startsWith("file:") ? fileURLToPath(base) : base;
-  return path8.resolve(path8.dirname(basePath), "../../package.json");
+  return path9.resolve(path9.dirname(basePath), "../../package.json");
 }
 
 // src/core/validators/contracts.ts
-import { access as access4, readFile as readFile5 } from "fs/promises";
-import path10 from "path";
+import { access as access4, readFile as readFile6 } from "fs/promises";
+import path11 from "path";
 
 // src/core/contracts.ts
-import path9 from "path";
+import path10 from "path";
 import { parse as parseYaml2 } from "yaml";
 function parseStructuredContract(file, text) {
-  const ext = path9.extname(file).toLowerCase();
+  const ext = path10.extname(file).toLowerCase();
   if (ext === ".json") {
     return JSON.parse(text);
   }
@@ -1286,14 +1688,14 @@ async function validateContracts(root, config) {
   const issues = [];
   const contractIndex = await buildContractIndex(root, config);
   const contractsRoot = resolvePath(root, config, "contractsDir");
-  const uiRoot = path10.join(contractsRoot, "ui");
+  const uiRoot = path11.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(path10.join(contractsRoot, "api")));
-  issues.push(...await validateDbContracts(path10.join(contractsRoot, "db")));
+  issues.push(...await validateApiContracts(path11.join(contractsRoot, "api")));
+  issues.push(...await validateDbContracts(path11.join(contractsRoot, "db")));
   issues.push(...validateDuplicateContractIds(contractIndex));
   return issues;
 }
@@ -1312,7 +1714,7 @@ async function validateUiContracts(uiRoot, themaIds) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await readFile5(file, "utf-8");
+    const text = await readFile6(file, "utf-8");
     const declaredIds = extractDeclaredContractIds(text);
     issues.push(...validateDeclaredContractIds(declaredIds, file, "UI"));
     let doc = null;
@@ -1366,7 +1768,7 @@ async function validateThemaContracts(uiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await readFile5(file, "utf-8");
+    const text = await readFile6(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1500,7 +1902,7 @@ async function validateApiContracts(apiRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await readFile5(file, "utf-8");
+    const text = await readFile6(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1569,7 +1971,7 @@ async function validateDbContracts(dbRoot) {
   }
   const issues = [];
   for (const file of files) {
-    const text = await readFile5(file, "utf-8");
+    const text = await readFile6(file, "utf-8");
     const invalidIds = extractInvalidIds(text, [
       "SPEC",
       "BR",
@@ -1766,9 +2168,9 @@ async function validateUiAssets(assets, file, uiRoot) {
     );
     return issues;
   }
-  const packDir = path10.resolve(uiRoot, packValue);
-  const packRelative = path10.relative(uiRoot, packDir);
-  if (packRelative.startsWith("..") || path10.isAbsolute(packRelative)) {
+  const packDir = path11.resolve(uiRoot, packValue);
+  const packRelative = path11.relative(uiRoot, packDir);
+  if (packRelative.startsWith("..") || path11.isAbsolute(packRelative)) {
     issues.push(
       issue(
         "QFAI-ASSET-001",
@@ -1794,7 +2196,7 @@ async function validateUiAssets(assets, file, uiRoot) {
     );
     return issues;
   }
-  const assetsYamlPath = path10.join(packDir, "assets.yaml");
+  const assetsYamlPath = path11.join(packDir, "assets.yaml");
   if (!await exists4(assetsYamlPath)) {
     issues.push(
       issue(
@@ -1809,7 +2211,7 @@ async function validateUiAssets(assets, file, uiRoot) {
   }
   let manifest;
   try {
-    const manifestText = await readFile5(assetsYamlPath, "utf-8");
+    const manifestText = await readFile6(assetsYamlPath, "utf-8");
     manifest = parseStructuredContract(assetsYamlPath, manifestText);
   } catch (error) {
     issues.push(
@@ -1882,9 +2284,9 @@ async function validateUiAssets(assets, file, uiRoot) {
       );
       continue;
     }
-    const assetPath = path10.resolve(packDir, entry.path);
-    const assetRelative = path10.relative(packDir, assetPath);
-    if (assetRelative.startsWith("..") || path10.isAbsolute(assetRelative)) {
+    const assetPath = path11.resolve(packDir, entry.path);
+    const assetRelative = path11.relative(packDir, assetPath);
+    if (assetRelative.startsWith("..") || path11.isAbsolute(assetRelative)) {
       issues.push(
         issue(
           "QFAI-ASSET-004",
@@ -1925,7 +2327,7 @@ function shouldIgnoreInvalidId(value, doc) {
     return false;
   }
   const normalized = packValue.replace(/\\/g, "/");
-  const basename = path10.posix.basename(normalized);
+  const basename = path11.posix.basename(normalized);
   if (!basename) {
     return false;
   }
@@ -1935,7 +2337,7 @@ function isSafeRelativePath(value) {
   if (!value) {
     return false;
   }
-  if (path10.isAbsolute(value)) {
+  if (path11.isAbsolute(value)) {
     return false;
   }
   const normalized = value.replace(/\\/g, "/");
@@ -1985,8 +2387,8 @@ function issue(code, message, severity, file, rule, refs, category = "compatibil
 }
 
 // src/core/validators/delta.ts
-import { readFile as readFile6 } from "fs/promises";
-import path11 from "path";
+import { readFile as readFile7 } from "fs/promises";
+import path12 from "path";
 async function validateDeltas(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const packs = await collectSpecPackDirs(specsRoot);
@@ -1995,9 +2397,9 @@ async function validateDeltas(root, config) {
   }
   const issues = [];
   for (const pack of packs) {
-    const deltaPath = path11.join(pack, "delta.md");
+    const deltaPath = path12.join(pack, "delta.md");
     try {
-      await readFile6(deltaPath, "utf-8");
+      await readFile7(deltaPath, "utf-8");
     } catch (error) {
       if (isMissingFileError2(error)) {
         issues.push(
@@ -2048,8 +2450,8 @@ function issue2(code, message, severity, file, rule, refs, category = "change",
 }
 
 // src/core/validators/ids.ts
-import { readFile as readFile7 } from "fs/promises";
-import path12 from "path";
+import { readFile as readFile8 } from "fs/promises";
+import path13 from "path";
 var SC_TAG_RE3 = /^SC-\d{4}$/;
 async function validateDefinedIds(root, config) {
   const issues = [];
@@ -2084,7 +2486,7 @@ async function validateDefinedIds(root, config) {
 }
 async function collectSpecDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await readFile7(file, "utf-8");
+    const text = await readFile8(file, "utf-8");
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
       recordId(out, parsed.specId, file);
@@ -2094,7 +2496,7 @@ async function collectSpecDefinitionIds(files, out) {
 }
 async function collectScenarioDefinitionIds(files, out) {
   for (const file of files) {
-    const text = await readFile7(file, "utf-8");
+    const text = await readFile8(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -2115,7 +2517,7 @@ function recordId(out, id, file) {
 }
 function formatFileList(files, root) {
   return files.map((file) => {
-    const relative = path12.relative(root, file);
+    const relative = path13.relative(root, file);
     return relative.length > 0 ? relative : file;
   }).join(", ");
 }
@@ -2142,20 +2544,20 @@ function issue3(code, message, severity, file, rule, refs, category = "compatibi
 }
 
 // src/core/promptsIntegrity.ts
-import { readFile as readFile8 } from "fs/promises";
-import path14 from "path";
+import { readFile as readFile9 } from "fs/promises";
+import path15 from "path";
 
 // src/shared/assets.ts
 import { existsSync } from "fs";
-import path13 from "path";
+import path14 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 = path13.dirname(basePath);
+  const baseDir = path14.dirname(basePath);
   const candidates = [
-    path13.resolve(baseDir, "../../../assets/init"),
-    path13.resolve(baseDir, "../../assets/init")
+    path14.resolve(baseDir, "../../../assets/init"),
+    path14.resolve(baseDir, "../../assets/init")
   ];
   for (const candidate of candidates) {
     if (existsSync(candidate)) {
@@ -2175,10 +2577,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 = path14.isAbsolute(promptsDirConfig) ? promptsDirConfig : path14.resolve(root, promptsDirConfig);
+  const promptsDir = path15.isAbsolute(promptsDirConfig) ? promptsDirConfig : path15.resolve(root, promptsDirConfig);
   let templateDir;
   try {
-    const rel = path14.isAbsolute(promptsDirConfig) ? path14.relative(root, promptsDirConfig) : promptsDirConfig;
+    const rel = path15.isAbsolute(promptsDirConfig) ? path15.relative(root, promptsDirConfig) : promptsDirConfig;
     const normalized = rel.replace(/^[\\/]+/, "");
     if (normalized.length === 0 || normalized.startsWith("..")) {
       return {
@@ -2190,7 +2592,7 @@ async function diffProjectPromptsAgainstInitAssets(root, config) {
         changed: []
       };
     }
-    templateDir = path14.join(getInitAssetsDir(), normalized);
+    templateDir = path15.join(getInitAssetsDir(), normalized);
   } catch {
     return {
       status: "skipped_missing_assets",
@@ -2244,8 +2646,8 @@ async function diffProjectPromptsAgainstInitAssets(root, config) {
     }
     try {
       const [a, b] = await Promise.all([
-        readFile8(templateAbs, "utf-8"),
-        readFile8(projectAbs, "utf-8")
+        readFile9(templateAbs, "utf-8"),
+        readFile9(projectAbs, "utf-8")
       ]);
       if (normalizeNewlines(a) !== normalizeNewlines(b)) {
         changed.push(rel);
@@ -2268,7 +2670,7 @@ function normalizeNewlines(text) {
   return text.replace(/\r\n/g, "\n");
 }
 function toRel(base, abs) {
-  const rel = path14.relative(base, abs);
+  const rel = path15.relative(base, abs);
   return rel.replace(/[\\/]+/g, "/");
 }
 function intersectKeys(a, b) {
@@ -2313,8 +2715,8 @@ async function validatePromptsIntegrity(root, config) {
 }
 
 // src/core/validators/scenario.ts
-import { access as access5, readFile as readFile9 } from "fs/promises";
-import path15 from "path";
+import { access as access5, readFile as readFile10 } from "fs/promises";
+import path16 from "path";
 var GIVEN_PATTERN = /\bGiven\b/;
 var WHEN_PATTERN = /\bWhen\b/;
 var THEN_PATTERN = /\bThen\b/;
@@ -2337,7 +2739,7 @@ async function validateScenarios(root, config) {
   }
   const issues = [];
   for (const entry of entries) {
-    const legacyScenarioPath = path15.join(entry.dir, "scenario.md");
+    const legacyScenarioPath = path16.join(entry.dir, "scenario.md");
     if (await fileExists(legacyScenarioPath)) {
       issues.push(
         issue4(
@@ -2351,7 +2753,7 @@ async function validateScenarios(root, config) {
     }
     let text;
     try {
-      text = await readFile9(entry.scenarioPath, "utf-8");
+      text = await readFile10(entry.scenarioPath, "utf-8");
     } catch (error) {
       if (isMissingFileError3(error)) {
         issues.push(
@@ -2534,7 +2936,7 @@ async function fileExists(target) {
 }
 
 // src/core/validators/spec.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 async function validateSpecs(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
   const entries = await collectSpecEntries(specsRoot);
@@ -2555,7 +2957,7 @@ async function validateSpecs(root, config) {
   for (const entry of entries) {
     let text;
     try {
-      text = await readFile10(entry.specPath, "utf-8");
+      text = await readFile11(entry.specPath, "utf-8");
     } catch (error) {
       if (isMissingFileError4(error)) {
         issues.push(
@@ -2709,7 +3111,7 @@ function isMissingFileError4(error) {
 }
 
 // src/core/validators/traceability.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 var SPEC_TAG_RE3 = /^SPEC-\d{4}$/;
 var BR_TAG_RE2 = /^BR-\d{4}$/;
 async function validateTraceability(root, config) {
@@ -2729,7 +3131,7 @@ async function validateTraceability(root, config) {
   const contractIndex = await buildContractIndex(root, config);
   const contractIds = contractIndex.ids;
   for (const file of specFiles) {
-    const text = await readFile11(file, "utf-8");
+    const text = await readFile12(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const parsed = parseSpec(text, file);
     if (parsed.specId) {
@@ -2802,7 +3204,7 @@ async function validateTraceability(root, config) {
     }
   }
   for (const file of scenarioFiles) {
-    const text = await readFile11(file, "utf-8");
+    const text = await readFile12(file, "utf-8");
     extractAllIds(text).forEach((id) => upstreamIds.add(id));
     const scenarioContractRefs = parseContractRefs(text, {
       allowCommentPrefix: true
@@ -3124,7 +3526,7 @@ async function validateCodeReferences(upstreamIds, srcRoot, testsRoot) {
   const pattern = buildIdPattern(Array.from(upstreamIds));
   let found = false;
   for (const file of targetFiles) {
-    const text = await readFile11(file, "utf-8");
+    const text = await readFile12(file, "utf-8");
     if (pattern.test(text)) {
       found = true;
       break;
@@ -3223,16 +3625,17 @@ var ID_PREFIXES2 = [
   "DB",
   "THEMA"
 ];
+var REPORT_GUARDRAILS_MAX = 20;
 async function createReportData(root, validation, configResult) {
-  const resolvedRoot = path16.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 = path16.join(contractsRoot, "api");
-  const uiRoot = path16.join(contractsRoot, "ui");
-  const dbRoot = path16.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);
@@ -3291,6 +3694,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);
@@ -3338,6 +3762,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
   };
 }
@@ -3433,6 +3885,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("");
@@ -3524,6 +3977,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));
@@ -3714,7 +4210,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await readFile12(file, "utf-8");
+    const text = await readFile13(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -3756,7 +4252,7 @@ async function collectIds(files) {
     THEMA: /* @__PURE__ */ new Set()
   };
   for (const file of files) {
-    const text = await readFile12(file, "utf-8");
+    const text = await readFile13(file, "utf-8");
     for (const prefix of ID_PREFIXES2) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -3775,7 +4271,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await readFile12(file, "utf-8");
+    const text = await readFile13(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -3796,7 +4292,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern2(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await readFile12(file, "utf-8");
+    const text = await readFile13(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -3921,19 +4417,26 @@ function buildHotspots(issues) {
   );
 }
 export {
+  checkDecisionGuardrails,
   createReportData,
   defaultConfig,
   extractAllIds,
+  extractDecisionGuardrailsFromMarkdown,
   extractIds,
   extractInvalidIds,
+  filterDecisionGuardrailsByKeyword,
   findConfigRoot,
+  formatGuardrailsForLlm,
   formatReportJson,
   formatReportMarkdown,
   getConfigPath,
   lintSql,
   loadConfig,
+  loadDecisionGuardrails,
+  normalizeDecisionGuardrails,
   resolvePath,
   resolveToolVersion,
+  sortDecisionGuardrails,
   validateContracts,
   validateDefinedIds,
   validateDeltas,