qfai 1.7.1 → 1.7.2

package/dist/cli/index.mjs

@@ -483,6 +483,69 @@ function normalizeUiux(raw, configPath, issues) {
       result.renderEvidence = renderEvidence;
     }
   }
+  if (raw.audit !== void 0) {
+    const audit = normalizeUiuxAudit(raw.audit, configPath, issues);
+    if (audit) {
+      result.audit = audit;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function normalizeUiuxAudit(raw, configPath, issues) {
+  if (!isRecord(raw)) {
+    issues.push(configIssue(configPath, "uiux.audit \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"));
+    return void 0;
+  }
+  const result = {};
+  if (raw.enabled !== void 0) {
+    if (typeof raw.enabled === "boolean") {
+      result.enabled = raw.enabled;
+    } else {
+      issues.push(configIssue(configPath, "uiux.audit.enabled \u306F\u30D6\u30FC\u30EB\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"));
+    }
+  }
+  if (raw.slopDetection !== void 0) {
+    if (typeof raw.slopDetection === "boolean") {
+      result.slopDetection = raw.slopDetection;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.audit.slopDetection \u306F\u30D6\u30FC\u30EB\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
+  if (raw.maxPrimaryCtas !== void 0) {
+    if (typeof raw.maxPrimaryCtas === "number" && Number.isFinite(raw.maxPrimaryCtas) && raw.maxPrimaryCtas >= 0) {
+      result.maxPrimaryCtas = raw.maxPrimaryCtas;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.audit.maxPrimaryCtas \u306F0\u4EE5\u4E0A\u306E\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
+  if (raw.maxRawTokenLiteralWarnings !== void 0) {
+    if (typeof raw.maxRawTokenLiteralWarnings === "number" && Number.isFinite(raw.maxRawTokenLiteralWarnings) && raw.maxRawTokenLiteralWarnings >= 0) {
+      result.maxRawTokenLiteralWarnings = raw.maxRawTokenLiteralWarnings;
+    } else {
+      issues.push(
+        configIssue(
+          configPath,
+          "uiux.audit.maxRawTokenLiteralWarnings \u306F0\u4EE5\u4E0A\u306E\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+        )
+      );
+    }
+  }
+  if (raw.maxDuplicateFindingsPerRule !== void 0) {
+    if (typeof raw.maxDuplicateFindingsPerRule === "number" && Number.isFinite(raw.maxDuplicateFindingsPerRule) && raw.maxDuplicateFindingsPerRule >= 0) {
+      result.maxDuplicateFindingsPerRule = raw.maxDuplicateFindingsPerRule;
+    } else {
+      issues.push(
+        configIssue(
+          configPath,
+          "uiux.audit.maxDuplicateFindingsPerRule \u306F0\u4EE5\u4E0A\u306E\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+        )
+      );
+    }
+  }
   return Object.keys(result).length > 0 ? result : void 0;
 }
 function normalizeRenderEvidence(raw, configPath, issues) {
@@ -1621,8 +1684,8 @@ import { readFile as readFile5 } from "fs/promises";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function resolveToolVersion() {
-  if ("1.7.1".length > 0) {
-    return "1.7.1";
+  if ("1.7.2".length > 0) {
+    return "1.7.2";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -4195,9 +4258,9 @@ function applyRenderEvidence(evidence, options, autogenEnabled, outputPath) {
   };
 }
 function buildRenderBundle(toolVersion, command, options, autogenEnabled) {
-  const path62 = resolveRenderOutPath(options.root, options.renderOut);
+  const path64 = resolveRenderOutPath(options.root, options.renderOut);
   return {
-    path: path62,
+    path: path64,
     bundle: {
       meta: {
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4209,7 +4272,7 @@ function buildRenderBundle(toolVersion, command, options, autogenEnabled) {
         requested: true,
         autogenEnabled,
         viewports: normalizeRenderViewports(options.renderViewports),
-        outputPath: path62,
+        outputPath: path64,
         reason: autogenEnabled ? "render evidence capture not implemented in this slice" : "render requested without autogen-ui-fidelity"
       }
     }
@@ -4275,8 +4338,8 @@ function extractRouteHintsFromEvidence(evidence) {
 }
 
 // src/cli/commands/report.ts
-import { mkdir as mkdir8, readFile as readFile44, writeFile as writeFile7 } from "fs/promises";
-import path59 from "path";
+import { mkdir as mkdir8, readFile as readFile45, writeFile as writeFile7 } from "fs/promises";
+import path61 from "path";
 
 // src/core/normalize.ts
 function normalizeIssuePaths(root, issues) {
@@ -4371,8 +4434,8 @@ async function createPhaseGuardResult(phase, blockedIssue) {
 }
 
 // src/core/report.ts
-import { readFile as readFile42 } from "fs/promises";
-import path57 from "path";
+import { readFile as readFile43 } from "fs/promises";
+import path59 from "path";
 
 // src/core/contractIndex.ts
 import { readFile as readFile10 } from "fs/promises";
@@ -12781,7 +12844,7 @@ function collectLayer(layer, layerName, target, errors) {
 }
 function flattenTokens(obj, prefix, target, errors) {
   for (const [key, value] of Object.entries(obj)) {
-    const path62 = `${prefix}.${key}`;
+    const path64 = `${prefix}.${key}`;
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const record2 = value;
       if ("$value" in record2) {
@@ -12797,9 +12860,9 @@ function flattenTokens(obj, prefix, target, errors) {
         if (typeof record2.platform === "string") {
           token.platform = record2.platform;
         }
-        target.set(path62, token);
+        target.set(path64, token);
       } else {
-        flattenTokens(record2, path62, target, errors);
+        flattenTokens(record2, path64, target, errors);
       }
     }
   }
@@ -12809,44 +12872,44 @@ function resolveAllReferences(result) {
   for (const [key, val] of result.primitives) allTokens.set(key, val);
   for (const [key, val] of result.semantics) allTokens.set(key, val);
   for (const [key, val] of result.components) allTokens.set(key, val);
-  for (const [path62] of allTokens) {
-    resolveTokenRef(path62, allTokens, /* @__PURE__ */ new Set(), 0, result);
+  for (const [path64] of allTokens) {
+    resolveTokenRef(path64, allTokens, /* @__PURE__ */ new Set(), 0, result);
   }
 }
-function resolveTokenRef(path62, allTokens, visited, depth, result) {
-  if (result.resolved.has(path62)) {
-    return result.resolved.get(path62);
+function resolveTokenRef(path64, allTokens, visited, depth, result) {
+  if (result.resolved.has(path64)) {
+    return result.resolved.get(path64);
   }
   if (depth > MAX_RESOLVE_DEPTH) {
     result.errors.push({
-      message: `Max reference depth exceeded at: ${path62}`,
-      path: path62
+      message: `Max reference depth exceeded at: ${path64}`,
+      path: path64
     });
     return void 0;
   }
-  if (visited.has(path62)) {
+  if (visited.has(path64)) {
     result.errors.push({
-      message: `Circular reference detected: ${path62}`,
-      path: path62
+      message: `Circular reference detected: ${path64}`,
+      path: path64
     });
     return void 0;
   }
-  const token = allTokens.get(path62);
+  const token = allTokens.get(path64);
   if (!token) {
     return void 0;
   }
   if (typeof token.$value !== "string") {
     const rawValue2 = stringifyTokenValue(token.$value);
-    result.resolved.set(path62, rawValue2);
+    result.resolved.set(path64, rawValue2);
     return rawValue2;
   }
   const rawValue = stringifyTokenValue(token.$value);
   const refs = [...rawValue.matchAll(REF_PATTERN)];
   if (refs.length === 0) {
-    result.resolved.set(path62, rawValue);
+    result.resolved.set(path64, rawValue);
     return rawValue;
   }
-  visited.add(path62);
+  visited.add(path64);
   let resolved = rawValue;
   for (const ref of refs) {
     const refPath = ref[1];
@@ -12854,8 +12917,8 @@ function resolveTokenRef(path62, allTokens, visited, depth, result) {
     const refToken = allTokens.get(refPath);
     if (!refToken) {
       result.errors.push({
-        message: `Unresolved token reference: {${refPath}} at ${path62}`,
-        path: path62
+        message: `Unresolved token reference: {${refPath}} at ${path64}`,
+        path: path64
       });
       continue;
     }
@@ -12864,7 +12927,7 @@ function resolveTokenRef(path62, allTokens, visited, depth, result) {
       resolved = resolved.split(`{${refPath}}`).join(refValue);
     }
   }
-  result.resolved.set(path62, resolved);
+  result.resolved.set(path64, resolved);
   return resolved;
 }
 function stringifyTokenValue(value) {
@@ -16921,6 +16984,252 @@ async function validateDiscussionDesignHardening(root, config) {
   return issues;
 }
 
+// src/core/validators/designAudit.ts
+import { readdir as readdir11 } from "fs/promises";
+import path57 from "path";
+var COSMETIC_CATEGORIES = ["generic-shell", "stock-imagery", "placeholder-copy"];
+function resolveAuditConfig(config) {
+  const audit = config.uiux?.audit;
+  const profile = config.uiux?.qualityProfile ?? "default";
+  return {
+    enabled: audit?.enabled ?? true,
+    slopDetection: audit?.slopDetection ?? true,
+    qualityProfile: profile,
+    maxPrimaryCtas: audit?.maxPrimaryCtas ?? 1,
+    maxRawTokenLiteralWarnings: audit?.maxRawTokenLiteralWarnings ?? 5,
+    maxDuplicateFindingsPerRule: audit?.maxDuplicateFindingsPerRule ?? 5
+  };
+}
+function mapSeverity(tier, profile, category) {
+  if (tier === 1) return "error";
+  if (tier === 2) return profile === "strict" ? "error" : "warning";
+  if (profile === "default") {
+    return category && COSMETIC_CATEGORIES.includes(category) ? "info" : "warning";
+  }
+  return "warning";
+}
+function findingToIssue(finding, profile, rulePrefix = "audit") {
+  const severity = mapSeverity(finding.severityTier, profile, finding.dimension);
+  return issue(
+    finding.ruleId,
+    finding.message,
+    severity,
+    finding.file,
+    `${rulePrefix}.${finding.dimension}`,
+    finding.evidence.length > 0 ? finding.evidence : void 0,
+    "compatibility",
+    finding.guidance
+  );
+}
+function extractSection2(content, heading) {
+  const idx = content.indexOf(heading);
+  if (idx === -1) return null;
+  const start = idx + heading.length;
+  const headingLevel = heading.match(/^#+/)?.[0]?.length ?? 3;
+  const rest = content.slice(start);
+  const headingPattern = new RegExp(`^#{1,${headingLevel}} `, "m");
+  const nextHeadingMatch = headingPattern.exec(rest);
+  const sectionContent = nextHeadingMatch ? rest.slice(0, nextHeadingMatch.index) : rest;
+  return sectionContent.trim() || null;
+}
+function checkCtaHierarchy(content, auditConfig, file) {
+  const findings = [];
+  const ctaSection = extractSection2(content, "### CTA Hierarchy");
+  if (!ctaSection) return findings;
+  const primaryLines = ctaSection.match(/^-\s*Primary:/gm) || [];
+  const primaryCount = primaryLines.length;
+  if (primaryCount === 0) {
+    findings.push({
+      ruleId: "QFAI-AUD-001",
+      dimension: "visualHierarchy",
+      severityTier: 1,
+      message: "No primary CTA defined in CTA Hierarchy",
+      why: "Every UI screen needs a clear primary action to guide users",
+      evidence: [],
+      guidance: "Define at least one primary CTA in the CTA Hierarchy section",
+      file
+    });
+  }
+  if (primaryCount > auditConfig.maxPrimaryCtas) {
+    findings.push({
+      ruleId: "QFAI-AUD-020",
+      dimension: "visualHierarchy",
+      severityTier: 2,
+      message: `Multiple primary CTAs detected (${primaryCount} > ${auditConfig.maxPrimaryCtas})`,
+      why: "Multiple primary CTAs create decision paralysis and weaken visual hierarchy",
+      evidence: primaryLines.map((l) => l.trim()),
+      guidance: "Reduce to a single primary CTA per screen; demote others to secondary",
+      file
+    });
+  }
+  return findings;
+}
+var RAW_COLOR_RE = /#[0-9a-fA-F]{3,8}\b|rgb\([^)]+\)|rgba\([^)]+\)|hsl\([^)]+\)|hsla\([^)]+\)/g;
+async function checkTokenDrift(root, auditConfig, cfg) {
+  const findings = [];
+  const configuredDir = cfg.uiux?.designTokensDir;
+  const tokensDir = configuredDir ? path57.resolve(root, configuredDir) : path57.join(root, cfg.paths.contractsDir, "design");
+  let hasTokenFiles = false;
+  try {
+    const entries = await readdir11(tokensDir);
+    hasTokenFiles = entries.some((e) => /\.ya?ml$/i.test(e));
+  } catch {
+    return findings;
+  }
+  if (!hasTokenFiles) return findings;
+  const contractsUiDir = path57.join(root, cfg.paths.contractsDir, "ui");
+  let htmlFiles = [];
+  try {
+    const entries = await readdir11(contractsUiDir);
+    htmlFiles = entries.filter((e) => /\.html?$/i.test(e));
+  } catch {
+    return findings;
+  }
+  let rawCount = 0;
+  const sampleLiterals = [];
+  for (const htmlFile of htmlFiles) {
+    const content = await readSafe(path57.join(contractsUiDir, htmlFile));
+    if (!content) continue;
+    const matches = content.match(RAW_COLOR_RE);
+    if (matches) {
+      rawCount += matches.length;
+      for (const m of matches) {
+        if (sampleLiterals.length < 10) {
+          sampleLiterals.push(m.toLowerCase());
+        }
+      }
+    }
+  }
+  if (rawCount > auditConfig.maxRawTokenLiteralWarnings) {
+    findings.push({
+      ruleId: "QFAI-AUD-004",
+      dimension: "tokenDiscipline",
+      severityTier: 1,
+      message: `Token drift: ${rawCount} raw color literal occurrences found (threshold: ${auditConfig.maxRawTokenLiteralWarnings})`,
+      why: "Raw color values bypass design tokens, causing visual inconsistency",
+      evidence: sampleLiterals,
+      guidance: "Replace raw color literals with design token references"
+    });
+  }
+  return findings;
+}
+function deduplicateFindings(issues, maxPerRule) {
+  const counts = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const iss of issues) {
+    const count = counts.get(iss.code) ?? 0;
+    if (count < maxPerRule) {
+      result.push(iss);
+    }
+    counts.set(iss.code, count + 1);
+  }
+  for (const [code, count] of counts) {
+    if (count > maxPerRule) {
+      result.push({
+        code,
+        severity: "info",
+        category: "compatibility",
+        message: `${count - maxPerRule} additional "${code}" finding(s) suppressed (max ${maxPerRule} per rule)`,
+        rule: `audit.dedup.${code}`
+      });
+    }
+  }
+  return result;
+}
+async function validateDesignAudit(root, config) {
+  const auditConfig = resolveAuditConfig(config);
+  if (!auditConfig.enabled) return [];
+  const discussionDir = path57.join(root, config.paths.discussionDir);
+  const packRoot = await findLatestDiscussionPackDir(discussionDir);
+  if (!packRoot) return [];
+  const uiBearing = await isUiBearing(packRoot);
+  if (!uiBearing) return [];
+  const storyPath = path57.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe(storyPath);
+  if (!content) return [];
+  const findings = [];
+  findings.push(...checkCtaHierarchy(content, auditConfig, "03_Story-Workshop.md"));
+  findings.push(...await checkTokenDrift(root, auditConfig, config));
+  const issues = findings.map((f) => findingToIssue(f, auditConfig.qualityProfile));
+  return deduplicateFindings(issues, auditConfig.maxDuplicateFindingsPerRule);
+}
+
+// src/core/validators/designSlop.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile42 } from "fs/promises";
+import path58 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function isValidSlopPattern(rule) {
+  if (typeof rule !== "object" || rule === null) return false;
+  const r = rule;
+  return typeof r.id === "string" && typeof r.category === "string" && typeof r.tier === "number" && Array.isArray(r.scopes) && typeof r.match === "string" && typeof r.message === "string" && typeof r.guidance === "string";
+}
+async function loadSlopPatterns(jsonPath) {
+  const raw = await readFile42(jsonPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) return [];
+  return parsed.filter((r) => isValidSlopPattern(r));
+}
+function defaultPatternsPath() {
+  const base = import.meta.url;
+  const basePath = base.startsWith("file:") ? fileURLToPath4(base) : base;
+  const baseDir = path58.dirname(basePath);
+  const candidates = [
+    path58.join(baseDir, "designSlopPatterns.json"),
+    path58.resolve(baseDir, "../../../assets/validators/designSlopPatterns.json"),
+    path58.resolve(baseDir, "../../assets/validators/designSlopPatterns.json")
+  ];
+  for (const c of candidates) {
+    if (existsSync2(c)) return c;
+  }
+  return candidates[0];
+}
+async function validateDesignSlop(root, config) {
+  const auditConfig = resolveAuditConfig(config);
+  if (!auditConfig.enabled) return [];
+  if (!auditConfig.slopDetection) return [];
+  const discussionDir = path58.join(root, config.paths.discussionDir);
+  const packRoot = await findLatestDiscussionPackDir(discussionDir);
+  if (!packRoot) return [];
+  const uiBearing = await isUiBearing(packRoot);
+  if (!uiBearing) return [];
+  let patterns;
+  try {
+    patterns = await loadSlopPatterns(defaultPatternsPath());
+  } catch {
+    return [];
+  }
+  const findings = [];
+  const seenRules = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    let regex;
+    try {
+      regex = new RegExp(pattern.match, "gi");
+    } catch {
+      continue;
+    }
+    for (const scope of pattern.scopes) {
+      const filePath = path58.join(packRoot, scope);
+      const content = await readSafe(filePath);
+      if (!content) continue;
+      if (regex.test(content) && !seenRules.has(pattern.id)) {
+        seenRules.add(pattern.id);
+        findings.push({
+          ruleId: pattern.id,
+          dimension: pattern.category,
+          severityTier: pattern.tier,
+          message: pattern.message,
+          why: `Slop pattern "${pattern.id}" matched in ${scope}`,
+          evidence: [],
+          guidance: pattern.guidance,
+          file: scope
+        });
+      }
+    }
+  }
+  return findings.map((f) => findingToIssue(f, auditConfig.qualityProfile, "slop"));
+}
+
 // src/core/validate.ts
 var UIUX_VALIDATION_BUDGET_MS = 2e3;
 async function validateProject(root, configResult, options = {}) {
@@ -16938,7 +17247,9 @@ async function validateProject(root, configResult, options = {}) {
     () => validateBpApDb(root, config),
     () => validateUiDefinitionConsistency(root, config),
     () => validateResearchSummary(root, config),
-    () => validateAgentDefinition(root, config)
+    () => validateAgentDefinition(root, config),
+    () => validateDesignAudit(root, config),
+    () => validateDesignSlop(root, config)
   ];
   const uiuxIssueGroups = await Promise.all(uiuxValidators.map((validator) => validator()));
   const uiuxIssues = [...platformResult.issues, ...uiuxIssueGroups.flat()];
@@ -17025,15 +17336,15 @@ var REPORT_GUARDRAILS_MAX = 20;
 var REPORT_TEST_STRATEGY_SAMPLE_LIMIT = 20;
 var SC_TAG_RE4 = /^SC-\d{4}-\d{4}$/;
 async function createReportData(root, validation, configResult) {
-  const resolvedRoot = path57.resolve(root);
+  const resolvedRoot = path59.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 = path57.join(contractsRoot, "api");
-  const uiRoot = path57.join(contractsRoot, "ui");
-  const dbRoot = path57.join(contractsRoot, "db");
+  const apiRoot = path59.join(contractsRoot, "api");
+  const uiRoot = path59.join(contractsRoot, "ui");
+  const dbRoot = path59.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specEntries = await collectSpecEntries(specsRoot);
@@ -17361,6 +17672,8 @@ function formatReportMarkdown(data, options = {}) {
   lines.push("");
   lines.push("- [Compatibility Issues](#compatibility-issues)");
   lines.push("- [Change Issues](#change-issues)");
+  lines.push("- [Design Audit Findings](#design-audit-findings)");
+  lines.push("- [Slop Guardrails Findings](#slop-guardrails-findings)");
   lines.push("- [Change Type](#change-type)");
   lines.push("- [Waivers](#waivers)");
   lines.push("- [Decision Guardrails](#decision-guardrails)");
@@ -17509,6 +17822,46 @@ function formatReportMarkdown(data, options = {}) {
   lines.push("### Issues");
   lines.push("");
   lines.push(...formatIssueCards(issuesByCategory.change));
+  const auditIssues = data.issues.filter((i) => /^QFAI-AUD-/.test(i.code));
+  if (auditIssues.length > 0) {
+    lines.push("## Design Audit Findings");
+    lines.push("");
+    const byDimension = /* @__PURE__ */ new Map();
+    for (const iss of auditIssues) {
+      const dim = iss.rule?.replace(/^audit\./, "").split(".")[0] ?? "unknown";
+      const group = byDimension.get(dim) ?? [];
+      group.push(iss);
+      byDimension.set(dim, group);
+    }
+    for (const [dim, dimIssues] of byDimension) {
+      lines.push(`### ${dim}`);
+      lines.push("");
+      for (const iss of dimIssues) {
+        lines.push(`- **${iss.severity.toUpperCase()}** [${iss.code}] ${iss.message}`);
+      }
+      lines.push("");
+    }
+  }
+  const slopIssues = data.issues.filter((i) => /^SLP-/.test(i.code));
+  if (slopIssues.length > 0) {
+    lines.push("## Slop Guardrails Findings");
+    lines.push("");
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const iss of slopIssues) {
+      const cat = iss.rule?.replace(/^slop\./, "").split(".")[0] ?? "unknown";
+      const group = byCategory.get(cat) ?? [];
+      group.push(iss);
+      byCategory.set(cat, group);
+    }
+    for (const [cat, catIssues] of byCategory) {
+      lines.push(`### ${cat}`);
+      lines.push("");
+      for (const iss of catIssues) {
+        lines.push(`- **${iss.severity.toUpperCase()}** [${iss.code}] ${iss.message}`);
+      }
+      lines.push("");
+    }
+  }
   lines.push("## Change Type");
   lines.push("");
   lines.push("### Summary");
@@ -17928,7 +18281,7 @@ async function collectChangeTypeSummary(specsRoot) {
   };
   const deltaFiles = await collectDeltaFiles(specsRoot);
   for (const deltaFile of deltaFiles) {
-    const text = await readFile42(deltaFile, "utf-8");
+    const text = await readFile43(deltaFile, "utf-8");
     const parsed = parseDeltaV1(text);
     for (const entry of parsed.entries) {
       if (!entry.meta) {
@@ -17965,7 +18318,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await readFile42(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -18002,7 +18355,7 @@ async function collectIds(files) {
     result[prefix] = /* @__PURE__ */ new Set();
   }
   for (const file of files) {
-    const text = await readFile42(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     for (const prefix of ID_PREFIXES) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -18017,7 +18370,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await readFile42(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -18038,7 +18391,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await readFile42(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -18157,7 +18510,7 @@ function normalizeScSources(root, sources) {
 async function countScenarios(scenarioFiles) {
   let total = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile42(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -18188,7 +18541,7 @@ async function collectTestStrategy(scenarioFiles, root, config, limit) {
   let totalScenarios = 0;
   let e2eCount = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile42(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -18276,10 +18629,10 @@ function buildHotspots(issues) {
 async function collectTddCoverage(entries) {
   const specs = [];
   for (const entry of entries) {
-    const testCasesPath = path57.join(entry.dir, "06_Test-Cases.md");
+    const testCasesPath = path59.join(entry.dir, "06_Test-Cases.md");
     let tcContent;
     try {
-      tcContent = await readFile42(testCasesPath, "utf-8");
+      tcContent = await readFile43(testCasesPath, "utf-8");
     } catch {
       continue;
     }
@@ -18311,10 +18664,10 @@ async function collectTddCoverage(entries) {
       });
       continue;
     }
-    const tddListPath = path57.join(entry.dir, "tdd", "test-list.md");
+    const tddListPath = path59.join(entry.dir, "tdd", "test-list.md");
     let tddContent;
     try {
-      tddContent = await readFile42(tddListPath, "utf-8");
+      tddContent = await readFile43(tddListPath, "utf-8");
     } catch {
       specs.push({
         specNumber: entry.specNumber,
@@ -18397,8 +18750,8 @@ async function collectTddCoverage(entries) {
 }
 
 // src/core/specPackReport.ts
-import { mkdir as mkdir7, readFile as readFile43, writeFile as writeFile6 } from "fs/promises";
-import path58 from "path";
+import { mkdir as mkdir7, readFile as readFile44, writeFile as writeFile6 } from "fs/promises";
+import path60 from "path";
 var REQUIRED_LEDGER_COLUMNS = [
   "trace_id",
   "obj_id",
@@ -18416,8 +18769,8 @@ async function writeSpecPackReports(root, config) {
   const entries = await collectSpecEntries(specsRoot);
   const contractIndex = await buildContractIndex(root, config);
   for (const entry of entries) {
-    const specName = path58.basename(entry.dir);
-    const outputDir = path58.join(outRoot, specName);
+    const specName = path60.basename(entry.dir);
+    const outputDir = path60.join(outRoot, specName);
     await mkdir7(outputDir, { recursive: true });
     const [acText, tcText, exText, ledgerText] = await Promise.all([
       readSafe12(entry.acceptanceCriteriaPath),
@@ -18444,13 +18797,13 @@ async function writeSpecPackReports(root, config) {
     });
     const graph = buildTraceabilityGraph(ledgerRows);
     await writeFile6(
-      path58.join(outputDir, "coverage.md"),
+      path60.join(outputDir, "coverage.md"),
       `${formatCoverageMarkdown(specName, coverage)}
 `,
       "utf-8"
     );
     await writeFile6(
-      path58.join(outputDir, "traceability-graph.json"),
+      path60.join(outputDir, "traceability-graph.json"),
       `${JSON.stringify(graph, null, 2)}
 `,
       "utf-8"
@@ -18625,7 +18978,7 @@ function getCell(row, indexByColumn, column) {
 }
 async function readSafe12(filePath) {
   try {
-    return await readFile43(filePath, "utf-8");
+    return await readFile44(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -18643,7 +18996,7 @@ function warnIfTruncated(scan, context) {
 
 // src/cli/commands/report.ts
 async function runReport(options) {
-  const root = path59.resolve(options.root);
+  const root = path61.resolve(options.root);
   const configResult = await loadConfig(root);
   let validation;
   let blockedByPhaseGuard = false;
@@ -18659,7 +19012,7 @@ async function runReport(options) {
     validation = normalized;
   } else {
     const input = options.inputPath ?? configResult.config.output.validateJsonPath;
-    const inputPath = path59.isAbsolute(input) ? input : path59.resolve(root, input);
+    const inputPath = path61.isAbsolute(input) ? input : path61.resolve(root, input);
     try {
       validation = await readValidationResult(inputPath);
     } catch (err) {
@@ -18686,10 +19039,10 @@ async function runReport(options) {
   warnIfTruncated(data.traceability.testFiles, "report");
   const output = options.format === "json" ? formatReportJson(data) : options.baseUrl ? formatReportMarkdown(data, { baseUrl: options.baseUrl }) : formatReportMarkdown(data);
   const outRoot = resolvePath(root, configResult.config, "outDir");
-  const defaultOut = options.format === "json" ? path59.join(outRoot, "report.json") : path59.join(outRoot, "report.md");
+  const defaultOut = options.format === "json" ? path61.join(outRoot, "report.json") : path61.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
-  const outPath = path59.isAbsolute(out) ? out : path59.resolve(root, out);
-  await mkdir8(path59.dirname(outPath), { recursive: true });
+  const outPath = path61.isAbsolute(out) ? out : path61.resolve(root, out);
+  await mkdir8(path61.dirname(outPath), { recursive: true });
   await writeFile7(outPath, `${output}
 `, "utf-8");
   await writeSpecPackReports(root, configResult.config);
@@ -18705,7 +19058,7 @@ async function runReport(options) {
   info(`wrote report: ${outPath}`);
 }
 async function readValidationResult(inputPath) {
-  const raw = await readFile44(inputPath, "utf-8");
+  const raw = await readFile45(inputPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!isValidationResult(parsed)) {
     throw new Error(`validate.json \u306E\u5F62\u5F0F\u304C\u4E0D\u6B63\u3067\u3059: ${inputPath}`);
@@ -18765,21 +19118,21 @@ function isMissingFileError2(error2) {
   return record2.code === "ENOENT";
 }
 async function writeValidationResult(root, outputPath, result) {
-  const abs = path59.isAbsolute(outputPath) ? outputPath : path59.resolve(root, outputPath);
-  await mkdir8(path59.dirname(abs), { recursive: true });
+  const abs = path61.isAbsolute(outputPath) ? outputPath : path61.resolve(root, outputPath);
+  await mkdir8(path61.dirname(abs), { recursive: true });
   await writeFile7(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 
 // src/cli/commands/validate.ts
 import { mkdir as mkdir10, writeFile as writeFile9 } from "fs/promises";
-import path61 from "path";
+import path63 from "path";
 
 // src/core/runLog.ts
 import { mkdir as mkdir9, writeFile as writeFile8 } from "fs/promises";
-import path60 from "path";
+import path62 from "path";
 async function writeValidateRunLog(input) {
-  const root = path60.resolve(input.root);
+  const root = path62.resolve(input.root);
   const outDir = resolvePath(root, input.config, "outDir");
   await mkdir9(outDir, { recursive: true });
   const { runId, reportDir } = await allocateRunReportDir(outDir, input.startedAt);
@@ -18826,10 +19179,10 @@ async function writeValidateRunLog(input) {
     errors,
     warnings
   });
-  await writeJson(path60.join(reportDir, "run.json"), runJson);
-  await writeJson(path60.join(reportDir, "validator.json"), validatorJson);
-  await writeJson(path60.join(reportDir, "traceability.json"), traceabilityJson);
-  await writeFile8(path60.join(reportDir, "summary.md"), `${summaryMd}
+  await writeJson(path62.join(reportDir, "run.json"), runJson);
+  await writeJson(path62.join(reportDir, "validator.json"), validatorJson);
+  await writeJson(path62.join(reportDir, "traceability.json"), traceabilityJson);
+  await writeFile8(path62.join(reportDir, "summary.md"), `${summaryMd}
 `, "utf-8");
   return {
     runId,
@@ -18953,7 +19306,7 @@ async function allocateRunReportDir(outDir, startedAt) {
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     const candidateDate = new Date(startedAt.getTime() + attempt);
     const runId = `run-${formatTimestamp17(candidateDate)}`;
-    const reportDir = path60.join(outDir, runId);
+    const reportDir = path62.join(outDir, runId);
     try {
       await mkdir9(reportDir);
       return { runId, reportDir };
@@ -18984,7 +19337,7 @@ function shouldFail(result, failOn) {
 // src/cli/commands/validate.ts
 async function runValidate(options) {
   const startedAt = /* @__PURE__ */ new Date();
-  const root = path61.resolve(options.root);
+  const root = path63.resolve(options.root);
   const configResult = await loadConfig(root);
   const blockedIssue = buildCiRefinementIssue(options.phase);
   const blockedByPhaseGuard = blockedIssue !== null;
@@ -19140,12 +19493,12 @@ function issueKey(issue2) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await mkdir10(path61.dirname(abs), { recursive: true });
+  await mkdir10(path63.dirname(abs), { recursive: true });
   await writeFile9(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return path61.isAbsolute(jsonPath) ? jsonPath : path61.resolve(root, jsonPath);
+  return path63.isAbsolute(jsonPath) ? jsonPath : path63.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 var ISSUE_EXPECTED_BY_CODE = {