qfai 1.7.1 → 1.7.2

package/dist/index.mjs

@@ -473,6 +473,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) {
@@ -3504,8 +3567,8 @@ function formatError4(error) {
 }
 
 // src/core/report.ts
-import { readFile as readFile41 } from "fs/promises";
-import path52 from "path";
+import { readFile as readFile42 } from "fs/promises";
+import path54 from "path";
 
 // src/core/contractIndex.ts
 import { readFile as readFile10 } from "fs/promises";
@@ -4263,8 +4326,8 @@ import { readFile as readFile11 } from "fs/promises";
 import path14 from "path";
 import { fileURLToPath } 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();
@@ -11354,7 +11417,7 @@ function collectLayer(layer, layerName, target, errors) {
 }
 function flattenTokens(obj, prefix, target, errors) {
   for (const [key, value] of Object.entries(obj)) {
-    const path53 = `${prefix}.${key}`;
+    const path55 = `${prefix}.${key}`;
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const record2 = value;
       if ("$value" in record2) {
@@ -11370,9 +11433,9 @@ function flattenTokens(obj, prefix, target, errors) {
         if (typeof record2.platform === "string") {
           token.platform = record2.platform;
         }
-        target.set(path53, token);
+        target.set(path55, token);
       } else {
-        flattenTokens(record2, path53, target, errors);
+        flattenTokens(record2, path55, target, errors);
       }
     }
   }
@@ -11382,44 +11445,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 [path53] of allTokens) {
-    resolveTokenRef(path53, allTokens, /* @__PURE__ */ new Set(), 0, result);
+  for (const [path55] of allTokens) {
+    resolveTokenRef(path55, allTokens, /* @__PURE__ */ new Set(), 0, result);
   }
 }
-function resolveTokenRef(path53, allTokens, visited, depth, result) {
-  if (result.resolved.has(path53)) {
-    return result.resolved.get(path53);
+function resolveTokenRef(path55, allTokens, visited, depth, result) {
+  if (result.resolved.has(path55)) {
+    return result.resolved.get(path55);
   }
   if (depth > MAX_RESOLVE_DEPTH) {
     result.errors.push({
-      message: `Max reference depth exceeded at: ${path53}`,
-      path: path53
+      message: `Max reference depth exceeded at: ${path55}`,
+      path: path55
     });
     return void 0;
   }
-  if (visited.has(path53)) {
+  if (visited.has(path55)) {
     result.errors.push({
-      message: `Circular reference detected: ${path53}`,
-      path: path53
+      message: `Circular reference detected: ${path55}`,
+      path: path55
     });
     return void 0;
   }
-  const token = allTokens.get(path53);
+  const token = allTokens.get(path55);
   if (!token) {
     return void 0;
   }
   if (typeof token.$value !== "string") {
     const rawValue2 = stringifyTokenValue(token.$value);
-    result.resolved.set(path53, rawValue2);
+    result.resolved.set(path55, rawValue2);
     return rawValue2;
   }
   const rawValue = stringifyTokenValue(token.$value);
   const refs = [...rawValue.matchAll(REF_PATTERN)];
   if (refs.length === 0) {
-    result.resolved.set(path53, rawValue);
+    result.resolved.set(path55, rawValue);
     return rawValue;
   }
-  visited.add(path53);
+  visited.add(path55);
   let resolved = rawValue;
   for (const ref of refs) {
     const refPath = ref[1];
@@ -11427,8 +11490,8 @@ function resolveTokenRef(path53, allTokens, visited, depth, result) {
     const refToken = allTokens.get(refPath);
     if (!refToken) {
       result.errors.push({
-        message: `Unresolved token reference: {${refPath}} at ${path53}`,
-        path: path53
+        message: `Unresolved token reference: {${refPath}} at ${path55}`,
+        path: path55
       });
       continue;
     }
@@ -11437,7 +11500,7 @@ function resolveTokenRef(path53, allTokens, visited, depth, result) {
       resolved = resolved.split(`{${refPath}}`).join(refValue);
     }
   }
-  result.resolved.set(path53, resolved);
+  result.resolved.set(path55, resolved);
   return resolved;
 }
 function stringifyTokenValue(value) {
@@ -15494,6 +15557,252 @@ async function validateDiscussionDesignHardening(root, config) {
   return issues;
 }
 
+// src/core/validators/designAudit.ts
+import { readdir as readdir9 } from "fs/promises";
+import path52 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 ? path52.resolve(root, configuredDir) : path52.join(root, cfg.paths.contractsDir, "design");
+  let hasTokenFiles = false;
+  try {
+    const entries = await readdir9(tokensDir);
+    hasTokenFiles = entries.some((e) => /\.ya?ml$/i.test(e));
+  } catch {
+    return findings;
+  }
+  if (!hasTokenFiles) return findings;
+  const contractsUiDir = path52.join(root, cfg.paths.contractsDir, "ui");
+  let htmlFiles = [];
+  try {
+    const entries = await readdir9(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(path52.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 = path52.join(root, config.paths.discussionDir);
+  const packRoot = await findLatestDiscussionPackDir(discussionDir);
+  if (!packRoot) return [];
+  const uiBearing = await isUiBearing(packRoot);
+  if (!uiBearing) return [];
+  const storyPath = path52.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 readFile41 } from "fs/promises";
+import path53 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 readFile41(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 = path53.dirname(basePath);
+  const candidates = [
+    path53.join(baseDir, "designSlopPatterns.json"),
+    path53.resolve(baseDir, "../../../assets/validators/designSlopPatterns.json"),
+    path53.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 = path53.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 = path53.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 = {}) {
@@ -15511,7 +15820,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()];
@@ -15598,15 +15909,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 = path52.resolve(root);
+  const resolvedRoot = path54.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 = path52.join(contractsRoot, "api");
-  const uiRoot = path52.join(contractsRoot, "ui");
-  const dbRoot = path52.join(contractsRoot, "db");
+  const apiRoot = path54.join(contractsRoot, "api");
+  const uiRoot = path54.join(contractsRoot, "ui");
+  const dbRoot = path54.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specEntries = await collectSpecEntries(specsRoot);
@@ -15934,6 +16245,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)");
@@ -16082,6 +16395,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");
@@ -16501,7 +16854,7 @@ async function collectChangeTypeSummary(specsRoot) {
   };
   const deltaFiles = await collectDeltaFiles(specsRoot);
   for (const deltaFile of deltaFiles) {
-    const text = await readFile41(deltaFile, "utf-8");
+    const text = await readFile42(deltaFile, "utf-8");
     const parsed = parseDeltaV1(text);
     for (const entry of parsed.entries) {
       if (!entry.meta) {
@@ -16538,7 +16891,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile42(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -16575,7 +16928,7 @@ async function collectIds(files) {
     result[prefix] = /* @__PURE__ */ new Set();
   }
   for (const file of files) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile42(file, "utf-8");
     for (const prefix of ID_PREFIXES) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -16590,7 +16943,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile42(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -16611,7 +16964,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile42(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -16730,7 +17083,7 @@ function normalizeScSources(root, sources) {
 async function countScenarios(scenarioFiles) {
   let total = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile42(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -16761,7 +17114,7 @@ async function collectTestStrategy(scenarioFiles, root, config, limit) {
   let totalScenarios = 0;
   let e2eCount = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile42(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -16849,10 +17202,10 @@ function buildHotspots(issues) {
 async function collectTddCoverage(entries) {
   const specs = [];
   for (const entry of entries) {
-    const testCasesPath = path52.join(entry.dir, "06_Test-Cases.md");
+    const testCasesPath = path54.join(entry.dir, "06_Test-Cases.md");
     let tcContent;
     try {
-      tcContent = await readFile41(testCasesPath, "utf-8");
+      tcContent = await readFile42(testCasesPath, "utf-8");
     } catch {
       continue;
     }
@@ -16884,10 +17237,10 @@ async function collectTddCoverage(entries) {
       });
       continue;
     }
-    const tddListPath = path52.join(entry.dir, "tdd", "test-list.md");
+    const tddListPath = path54.join(entry.dir, "tdd", "test-list.md");
     let tddContent;
     try {
-      tddContent = await readFile41(tddListPath, "utf-8");
+      tddContent = await readFile42(tddListPath, "utf-8");
     } catch {
       specs.push({
         specNumber: entry.specNumber,