qfai 1.6.4 → 1.6.5

package/dist/cli/index.cjs

@@ -442,6 +442,48 @@ function normalizeUiux(raw, configPath, issues) {
       issues.push(configIssue(configPath, "uiux.htmlMockTimeout \u306F\u6B63\u306E\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"));
     }
   }
+  if (raw.qualityProfile !== void 0) {
+    if (typeof raw.qualityProfile === "string" && ["strict", "high", "default"].includes(raw.qualityProfile)) {
+      result.qualityProfile = raw.qualityProfile;
+    } else {
+      issues.push(
+        configIssue(
+          configPath,
+          "uiux.qualityProfile \u306F strict|high|default \u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+        )
+      );
+    }
+  }
+  if (raw.requireResearchSummary !== void 0) {
+    if (typeof raw.requireResearchSummary === "boolean") {
+      result.requireResearchSummary = raw.requireResearchSummary;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.requireResearchSummary \u306F\u30D6\u30FC\u30EB\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
+  if (raw.competitive_refs_min !== void 0) {
+    if (typeof raw.competitive_refs_min === "number" && Number.isFinite(raw.competitive_refs_min) && raw.competitive_refs_min >= 0) {
+      result.competitive_refs_min = raw.competitive_refs_min;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.competitive_refs_min \u306F0\u4EE5\u4E0A\u306E\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
+  if (raw.warning_as_error_override !== void 0) {
+    if (Array.isArray(raw.warning_as_error_override) && raw.warning_as_error_override.every((v) => typeof v === "string")) {
+      result.warning_as_error_override = raw.warning_as_error_override;
+    } else {
+      issues.push(
+        configIssue(
+          configPath,
+          "uiux.warning_as_error_override \u306F\u6587\u5B57\u5217\u914D\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+        )
+      );
+    }
+  }
   return Object.keys(result).length > 0 ? result : void 0;
 }
 function configIssue(file, message) {
@@ -1522,8 +1564,8 @@ var import_promises7 = require("fs/promises");
 var import_node_path8 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 async function resolveToolVersion() {
-  if ("1.6.4".length > 0) {
-    return "1.6.4";
+  if ("1.6.5".length > 0) {
+    return "1.6.5";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -4059,8 +4101,8 @@ function extractRouteHintsFromEvidence(evidence) {
 }
 
 // src/cli/commands/report.ts
-var import_promises52 = require("fs/promises");
-var import_node_path55 = __toESM(require("path"), 1);
+var import_promises55 = require("fs/promises");
+var import_node_path58 = __toESM(require("path"), 1);
 
 // src/core/normalize.ts
 function normalizeIssuePaths(root, issues) {
@@ -4155,8 +4197,8 @@ async function createPhaseGuardResult(phase, blockedIssue) {
 }
 
 // src/core/report.ts
-var import_promises50 = require("fs/promises");
-var import_node_path53 = __toESM(require("path"), 1);
+var import_promises53 = require("fs/promises");
+var import_node_path56 = __toESM(require("path"), 1);
 
 // src/core/contractIndex.ts
 var import_promises15 = require("fs/promises");
@@ -12356,7 +12398,7 @@ function collectLayer(layer, layerName, target, errors) {
 }
 function flattenTokens(obj, prefix, target, errors) {
   for (const [key, value] of Object.entries(obj)) {
-    const path58 = `${prefix}.${key}`;
+    const path61 = `${prefix}.${key}`;
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const record2 = value;
       if ("$value" in record2) {
@@ -12372,9 +12414,9 @@ function flattenTokens(obj, prefix, target, errors) {
         if (typeof record2.platform === "string") {
           token.platform = record2.platform;
         }
-        target.set(path58, token);
+        target.set(path61, token);
       } else {
-        flattenTokens(record2, path58, target, errors);
+        flattenTokens(record2, path61, target, errors);
       }
     }
   }
@@ -12384,44 +12426,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 [path58] of allTokens) {
-    resolveTokenRef(path58, allTokens, /* @__PURE__ */ new Set(), 0, result);
+  for (const [path61] of allTokens) {
+    resolveTokenRef(path61, allTokens, /* @__PURE__ */ new Set(), 0, result);
   }
 }
-function resolveTokenRef(path58, allTokens, visited, depth, result) {
-  if (result.resolved.has(path58)) {
-    return result.resolved.get(path58);
+function resolveTokenRef(path61, allTokens, visited, depth, result) {
+  if (result.resolved.has(path61)) {
+    return result.resolved.get(path61);
   }
   if (depth > MAX_RESOLVE_DEPTH) {
     result.errors.push({
-      message: `Max reference depth exceeded at: ${path58}`,
-      path: path58
+      message: `Max reference depth exceeded at: ${path61}`,
+      path: path61
     });
     return void 0;
   }
-  if (visited.has(path58)) {
+  if (visited.has(path61)) {
     result.errors.push({
-      message: `Circular reference detected: ${path58}`,
-      path: path58
+      message: `Circular reference detected: ${path61}`,
+      path: path61
     });
     return void 0;
   }
-  const token = allTokens.get(path58);
+  const token = allTokens.get(path61);
   if (!token) {
     return void 0;
   }
   if (typeof token.$value !== "string") {
     const rawValue2 = stringifyTokenValue(token.$value);
-    result.resolved.set(path58, rawValue2);
+    result.resolved.set(path61, rawValue2);
     return rawValue2;
   }
   const rawValue = stringifyTokenValue(token.$value);
   const refs = [...rawValue.matchAll(REF_PATTERN)];
   if (refs.length === 0) {
-    result.resolved.set(path58, rawValue);
+    result.resolved.set(path61, rawValue);
     return rawValue;
   }
-  visited.add(path58);
+  visited.add(path61);
   let resolved = rawValue;
   for (const ref of refs) {
     const refPath = ref[1];
@@ -12429,8 +12471,8 @@ function resolveTokenRef(path58, allTokens, visited, depth, result) {
     const refToken = allTokens.get(refPath);
     if (!refToken) {
       result.errors.push({
-        message: `Unresolved token reference: {${refPath}} at ${path58}`,
-        path: path58
+        message: `Unresolved token reference: {${refPath}} at ${path61}`,
+        path: path61
       });
       continue;
     }
@@ -12439,7 +12481,7 @@ function resolveTokenRef(path58, allTokens, visited, depth, result) {
       resolved = resolved.split(`{${refPath}}`).join(refValue);
     }
   }
-  result.resolved.set(path58, resolved);
+  result.resolved.set(path61, resolved);
   return resolved;
 }
 function stringifyTokenValue(value) {
@@ -12677,8 +12719,8 @@ var import_node_path45 = __toESM(require("path"), 1);
 var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 
 // src/core/uiux/contrastRatio.ts
-function computeContrastRatio(fg8, bg) {
-  const fgLum = relativeLuminance(fg8);
+function computeContrastRatio(fg11, bg) {
+  const fgLum = relativeLuminance(fg11);
   const bgLum = relativeLuminance(bg);
   if (fgLum === null || bgLum === null) return null;
   const lighter = Math.max(fgLum, bgLum);
@@ -14618,216 +14660,1729 @@ async function collectTestCaseIds(specDir) {
   return { knownTcIds, unitComponentTcIds };
 }
 
-// src/core/validate.ts
-var UIUX_VALIDATION_BUDGET_MS = 2e3;
-async function validateProject(root, configResult, options = {}) {
-  const resolved = configResult ?? await loadConfig(root);
-  const { config, issues: configIssues } = resolved;
-  const phase = options.phase ?? "full";
-  const atddCodeTraceabilityIssues = phase === "refinement" ? [] : await validateAtddCodeTraceability(root, config);
-  const uiuxStart = performance.now();
-  const platformResult = await detectPlatform(root, config, options.platform);
-  const platform = platformResult.platform;
-  const uiuxValidators = [
-    () => validateDesignToken(root, config),
-    () => validateHtmlMock(root, platform, config),
-    () => validateMermaidScreenFlow(root, config),
-    () => validateBpApDb(root, config),
-    () => validateUiDefinitionConsistency(root, config),
-    () => validateResearchSummary(root, config),
-    () => validateAgentDefinition(root, config)
-  ];
-  const uiuxIssueGroups = await Promise.all(uiuxValidators.map((validator) => validator()));
-  const uiuxIssues = [...platformResult.issues, ...uiuxIssueGroups.flat()];
-  const uiuxElapsed = performance.now() - uiuxStart;
-  if (uiuxElapsed > UIUX_VALIDATION_BUDGET_MS) {
-    uiuxIssues.push({
-      code: "QFAI-UIUX-PERF",
-      severity: "warning",
-      category: "compatibility",
-      message: `UI/UX validation exceeded budget (${UIUX_VALIDATION_BUDGET_MS}ms). All validators were executed.`,
-      rule: "uiux.performanceBudget"
-    });
+// src/core/validators/ddpValidation.ts
+var import_promises50 = require("fs/promises");
+var import_node_path53 = __toESM(require("path"), 1);
+var import_node_url3 = require("url");
+var import_fast_glob8 = __toESM(require("fast-glob"), 1);
+var DDP_HEADING_RE = /^#{1,3}\s+Design\s+Direction\s+Pack/im;
+var DDP_REQUIRED_FIELDS = [
+  "visual_thesis",
+  "content_plan",
+  "interaction_thesis",
+  "anti_goals",
+  "cta_hierarchy"
+];
+var DDP_THEME_FIELDS = ["theme", "mood", "taste", "material", "energy", "visual_anchor"];
+var UI_BEARING_KEYWORDS_RE = /\b(screen|ui|interface|mock|layout|design)\b/i;
+var FIGMA_URL_RE = /https?:\/\/(?:www\.)?figma\.com\/[^\s)]+/i;
+var _bannedPatterns = null;
+async function loadBannedPatterns() {
+  if (_bannedPatterns !== null) return _bannedPatterns;
+  try {
+    const thisDir = import_node_path53.default.dirname((0, import_node_url3.fileURLToPath)(__filename));
+    const filePath = import_node_path53.default.join(thisDir, "ddpBannedPatterns.txt");
+    const content = await (0, import_promises50.readFile)(filePath, "utf-8");
+    _bannedPatterns = content.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
+  } catch {
+    _bannedPatterns = [];
   }
-  const findings = [
-    ...configIssues,
-    ...await validateRepositoryHygiene(root, config),
-    ...await validateSkillsIntegrity(root, config),
-    ...await validateAssistantAssets(root, config),
-    ...await validateDiscussionMermaid(root),
-    ...await validateMermaidEnforcement(root),
-    ...await validateSpecPacks(root, config),
-    ...await validateDiscussionPackReadiness(root, config),
-    ...await validateDiscussionVisuals(root),
-    ...await validateLegacyStatusDir(root),
-    ...await validateStatusInSpecs(root, config),
-    ...await validateDensityHints(root, config),
-    ...await validateReviewArtifacts(root),
-    ...await validatePrototypingEvidence(root, config),
-    ...await validateSpecSplitByCapability(root, config),
-    ...await validateLayeredTraceability(root, config),
-    ...await validateOrphanProhibition(root, config),
-    ...await validateLayerCoverage(root, config),
-    ...atddCodeTraceabilityIssues,
-    ...await validateContractReferences(root, config),
-    ...await validateTraceability(root, config, phase),
-    ...await validateDefinedIds(root, config),
-    ...await validateContracts(root, config),
-    ...await validateTddList(root, config),
-    ...uiuxIssues
-  ];
-  const { issues, waivers } = await applyWaivers(root, findings);
-  const specsRoot = resolvePath(root, config, "specsDir");
-  const scenarioFiles = await collectScenarioFiles(specsRoot);
-  const scIds = await collectScIdsFromScenarioFiles(scenarioFiles);
-  const { refs: scTestRefs, scan: testFiles } = await collectScTestReferences(
-    root,
-    config.validation.traceability.testFileGlobs,
-    config.validation.traceability.testFileExcludeGlobs
-  );
-  const scCoverage = buildScCoverage(scIds, scTestRefs);
-  const toolVersion = await resolveToolVersion();
-  return {
-    toolVersion,
-    phase,
-    issues,
-    counts: countIssues(issues),
-    traceability: {
-      sc: scCoverage,
-      testFiles
-    },
-    waivers
-  };
+  return _bannedPatterns;
 }
-function countIssues(issues) {
-  return issues.reduce(
-    (acc, issue2) => {
-      if (issue2.suppressed) {
-        return acc;
+async function validateDdpFields(root, config) {
+  const issues = [];
+  const pattern = import_node_path53.default.posix.join(root.replace(/\\/g, "/"), config.paths.discussionDir, "**/*.md");
+  const files = await (0, import_fast_glob8.default)(pattern, { absolute: true });
+  let ddpFound = false;
+  let isUiBearing = false;
+  for (const filePath of files) {
+    const basename = import_node_path53.default.basename(filePath);
+    if (basename === "03_Story-Workshop.md") {
+      try {
+        const storyContent = await (0, import_promises50.readFile)(filePath, "utf-8");
+        if (UI_BEARING_KEYWORDS_RE.test(storyContent)) {
+          isUiBearing = true;
+        }
+      } catch {
       }
-      acc[issue2.severity] += 1;
-      return acc;
-    },
-    { info: 0, warning: 0, error: 0 }
-  );
-}
-
-// src/core/report.ts
-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 = import_node_path53.default.resolve(root);
-  const resolved = configResult ?? await loadConfig(resolvedRoot);
-  const config = resolved.config;
-  const configPath = resolved.configPath;
-  const specsRoot = resolvePath(resolvedRoot, config, "specsDir");
-  const contractsRoot = resolvePath(resolvedRoot, config, "contractsDir");
-  const apiRoot = import_node_path53.default.join(contractsRoot, "api");
-  const uiRoot = import_node_path53.default.join(contractsRoot, "ui");
-  const dbRoot = import_node_path53.default.join(contractsRoot, "db");
-  const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
-  const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
-  const specEntries = await collectSpecEntries(specsRoot);
-  const specFiles = await collectSpecFiles(specsRoot);
-  const scenarioFiles = await collectScenarioFiles(specsRoot);
-  const scenarioCount = await countScenarios(scenarioFiles);
-  const testStrategy = await collectTestStrategy(
-    scenarioFiles,
-    resolvedRoot,
-    config,
-    REPORT_TEST_STRATEGY_SAMPLE_LIMIT
-  );
-  const {
-    api: apiFiles,
-    ui: uiFiles,
-    db: dbFiles,
-    thema: themaFiles
-  } = await collectContractFiles(uiRoot, apiRoot, dbRoot);
-  const contractIndex = await buildContractIndex(resolvedRoot, config);
-  const contractIdList = Array.from(contractIndex.ids);
-  const specContractRefs = await collectSpecContractRefs(specFiles, contractIdList);
-  const referencedContracts = /* @__PURE__ */ new Set();
-  for (const entry of specContractRefs.specToContracts.values()) {
-    entry.ids.forEach((id) => referencedContracts.add(id));
-  }
-  const referencedContractCount = contractIdList.filter((id) => referencedContracts.has(id)).length;
-  const orphanContractCount = contractIdList.filter((id) => !referencedContracts.has(id)).length;
-  const contractIdToSpecsRecord = mapToSortedRecord(specContractRefs.idToSpecs);
-  const specToContractsRecord = mapToSpecContractRecord(specContractRefs.specToContracts);
-  const idsByPrefix = await collectIds([
-    ...specFiles,
-    ...scenarioFiles,
-    ...apiFiles,
-    ...uiFiles,
-    ...dbFiles,
-    ...themaFiles
-  ]);
-  const upstreamIds = await collectUpstreamIds([...specFiles, ...scenarioFiles]);
-  const traceability = await evaluateTraceability(upstreamIds, srcRoot, testsRoot);
-  const resolvedValidationRaw = validation ?? await validateProject(resolvedRoot, resolved);
-  const normalizedValidation = normalizeValidationResult(resolvedRoot, resolvedValidationRaw);
-  const scCoverage = normalizedValidation.traceability.sc;
-  const testFiles = normalizedValidation.traceability.testFiles;
-  const scSources = await collectScIdSourcesFromScenarioFiles(scenarioFiles);
-  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 {
-      guardrailsByType.tradeOff += 1;
     }
   }
-  const guardrailsErrors = guardrailsLoad.errors.map((item) => ({
-    path: toRelativePath(resolvedRoot, item.path),
-    message: item.message
-  }));
-  const changeTypeSummary = await collectChangeTypeSummary(specsRoot);
-  const ctypeWarnings = normalizedValidation.issues.filter((item) => item.code === "QFAI-CTYPE-002").map((item) => {
-    const warning = {
-      file: item.file ? toRelativePath(resolvedRoot, item.file) : "(unknown)",
-      suspectedMismatch: item.message,
-      refs: item.refs ?? []
-    };
-    if (item.suggested_action) {
-      warning.suggestion = item.suggested_action;
+  for (const filePath of files) {
+    let content;
+    try {
+      content = await (0, import_promises50.readFile)(filePath, "utf-8");
+    } catch {
+      continue;
     }
-    return warning;
-  });
-  const toReportRuleFinding = (item) => {
-    const finding = {
-      code: item.code,
-      severity: item.severity,
-      message: item.message,
-      refs: item.refs ?? []
-    };
-    if (item.file) {
-      finding.file = toRelativePath(resolvedRoot, item.file);
+    if (!DDP_HEADING_RE.test(content)) continue;
+    ddpFound = true;
+    const rel = import_node_path53.default.relative(root, filePath).replace(/\\/g, "/");
+    const section = extractDdpSection(content);
+    if (!section) continue;
+    for (const field of DDP_REQUIRED_FIELDS) {
+      if (!hasNonEmptyField(section, field)) {
+        issues.push(
+          issue(
+            "QFAI-DDP-001",
+            `DDP required field missing: ${field}`,
+            "error",
+            rel,
+            `ddp.requiredField.${field}`
+          )
+        );
+      }
     }
-    if (item.suggested_action) {
-      finding.suggestion = item.suggested_action;
+    const visualThesisValue = getFieldValue(section, "visual_thesis");
+    if (visualThesisValue) {
+      const trimmed = visualThesisValue.trim();
+      if (/^-\s/.test(trimmed) && !/[.!?]/.test(trimmed)) {
+        issues.push(
+          issue(
+            "QFAI-DDP-002",
+            "Visual thesis should be a single descriptive sentence, not bullet points",
+            "warning",
+            rel,
+            "ddp.visualThesisFormat"
+          )
+        );
+      }
     }
-    return finding;
-  };
-  const compatFindings = normalizedValidation.issues.filter((item) => /^QFAI-COMPAT-\d+$/.test(item.code)).map((item) => toReportRuleFinding(item));
-  const scopeMismatches = normalizedValidation.issues.filter((item) => item.code === "QFAI-SCOPE-001" || item.code === "QFAI-SCOPE-002").map((item) => toReportRuleFinding(item));
-  const verificationFindings = normalizedValidation.issues.filter((item) => /^QFAI-VFY-\d+$/.test(item.code)).map((item) => toReportRuleFinding(item));
-  const missingDeltaUpdateIssues = normalizedValidation.issues.filter(
-    (item) => item.code === "QFAI-CTYPE-003"
-  ).length;
-  const waiverState = normalizedValidation.waivers ?? {
-    active: [],
-    suppressed: {
-      total: 0,
-      byWaiver: {},
+    const themeBlock = extractNestedBlock(section, "theme");
+    if (themeBlock !== null) {
+      for (const tf of DDP_THEME_FIELDS) {
+        if (!hasSubField(themeBlock, tf)) {
+          issues.push(
+            issue(
+              "QFAI-DDP-003",
+              `DDP theme field missing: ${tf}`,
+              "error",
+              rel,
+              `ddp.themeField.${tf}`
+            )
+          );
+        }
+      }
+    }
+    const ctaBlock = extractNestedBlock(section, "cta_hierarchy");
+    if (ctaBlock !== null) {
+      if (!hasSubField(ctaBlock, "primary")) {
+        issues.push(
+          issue(
+            "QFAI-DDP-004",
+            "CTA hierarchy must have at least one primary CTA",
+            "error",
+            rel,
+            "ddp.ctaPrimaryMissing"
+          )
+        );
+      }
+      if (!hasSubField(ctaBlock, "placement")) {
+        issues.push(
+          issue(
+            "QFAI-DDP-005",
+            "CTA placement not specified",
+            "warning",
+            rel,
+            "ddp.ctaPlacementMissing"
+          )
+        );
+      }
+    } else {
+      const ctaInline = getFieldValue(section, "cta_hierarchy");
+      if (ctaInline && !ctaInline.toLowerCase().includes("primary")) {
+        issues.push(
+          issue(
+            "QFAI-DDP-004",
+            "CTA hierarchy must have at least one primary CTA",
+            "error",
+            rel,
+            "ddp.ctaPrimaryMissing"
+          )
+        );
+      }
+    }
+    const contentPlanItems = collectListItems(section, "content_plan");
+    if (contentPlanItems.length > 0 && contentPlanItems.length < 2) {
+      issues.push(
+        issue(
+          "QFAI-DDP-007",
+          "Content plan should have at least 2 sections",
+          "warning",
+          rel,
+          "ddp.contentPlanSections"
+        )
+      );
+    }
+    const interactionItems = collectListItems(section, "interaction_thesis");
+    if (interactionItems.length > 0 && interactionItems.length < 2) {
+      issues.push(
+        issue(
+          "QFAI-DDP-008",
+          "Interaction thesis should contain 2-3 motion principles",
+          "warning",
+          rel,
+          "ddp.interactionThesisPrinciples"
+        )
+      );
+    }
+    const antiGoalItems = collectListItems(section, "anti_goals");
+    const bannedPatterns = await loadBannedPatterns();
+    const hasBannedPattern = antiGoalItems.some(
+      (item) => bannedPatterns.some((bp) => item.toLowerCase().includes(bp.toLowerCase()))
+    );
+    if (hasNonEmptyField(section, "anti_goals") && antiGoalItems.length > 0 && !hasBannedPattern) {
+      issues.push(
+        issue(
+          "QFAI-DDP-009",
+          "DDP anti-goals should contain at least one banned generic pattern",
+          "warning",
+          rel,
+          "ddp.antiGoalsBannedPattern"
+        )
+      );
+    }
+    if (FIGMA_URL_RE.test(section)) {
+      issues.push(
+        issue(
+          "QFAI-DDP-010",
+          "DDP contains hard reference to external tool (Figma URL); DDP should be tool-independent",
+          "error",
+          rel,
+          "ddp.externalToolDependency"
+        )
+      );
+    }
+  }
+  if (isUiBearing && !ddpFound) {
+    issues.push(
+      issue(
+        "QFAI-DDP-006",
+        "UI-bearing artifact detected but no Design Direction Pack found",
+        "error",
+        void 0,
+        "ddp.uiBearingNoDdp"
+      )
+    );
+  }
+  await validateResearchTraceability(root, config, issues);
+  await validateStoryWorkshopTemplates(root, config, issues, files);
+  validateQualityProfile(config, issues);
+  await validateOptionComparison(root, config, issues);
+  await validateCompetitiveRefs(root, config, issues);
+  return issues;
+}
+var LIST_TEMPLATE_REQUIRED_FIELDS = [
+  "screen_type",
+  "items_source",
+  "empty_state",
+  "sort_filter_controls",
+  "pagination_or_infinite_scroll",
+  "primary_cta"
+];
+var FORM_TEMPLATE_REQUIRED_FIELDS = [
+  "screen_type",
+  "fields",
+  "required_fields_count",
+  "submit_cta",
+  "validation_feedback",
+  "cancel_or_back_action"
+];
+var ANTI_PATTERN_CHECKS = [
+  {
+    pattern: /dual\s+primary\s+CTA|two\s+primary\s+CTA|2\s+primary\s+CTA/i,
+    id: "dual-primary-cta",
+    message: "Anti-pattern detected: dual primary CTA",
+    guidance: "A screen should have exactly one primary CTA to avoid user confusion."
+  },
+  {
+    pattern: /required.fields.*(?:[89]|\d{2,})|required_fields_count\s*:\s*(?:[89]|\d{2,})/i,
+    id: "too-many-required-fields",
+    message: "Anti-pattern detected: form has more than 7 required fields",
+    guidance: "Keep required fields to 7 or fewer to reduce form abandonment."
+  },
+  {
+    pattern: /empty.state(?:(?!action|cta|button|link).)*$/im,
+    id: "empty-state-no-action",
+    message: "Anti-pattern detected: empty state without action",
+    guidance: "Empty states should include an actionable CTA to guide users forward."
+  }
+];
+async function validateResearchTraceability(root, config, issues) {
+  const requireResearchSummary = config.uiux?.requireResearchSummary === true;
+  const discussionPattern = import_node_path53.default.posix.join(
+    root.replace(/\\/g, "/"),
+    config.paths.discussionDir,
+    "**/*.md"
+  );
+  const discussionFiles = await (0, import_fast_glob8.default)(discussionPattern, { absolute: true });
+  let hasResearchSummary = false;
+  for (const filePath of discussionFiles) {
+    try {
+      const content = await (0, import_promises50.readFile)(filePath, "utf-8");
+      if (/research_summary\s*:/m.test(content)) {
+        hasResearchSummary = true;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (requireResearchSummary && !hasResearchSummary) {
+    issues.push(
+      issue(
+        "QFAI-DDP-012",
+        "Research summary required by config (requireResearchSummary=true) but not found in discussion pack",
+        "error",
+        void 0,
+        "ddp.researchSummaryRequired"
+      )
+    );
+  }
+  const contractPattern = import_node_path53.default.posix.join(
+    root.replace(/\\/g, "/"),
+    config.paths.contractsDir,
+    "design",
+    "*.yaml"
+  );
+  const contractFiles = await (0, import_fast_glob8.default)(contractPattern, { absolute: true });
+  for (const filePath of contractFiles) {
+    let content;
+    try {
+      content = await (0, import_promises50.readFile)(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const rel = import_node_path53.default.relative(root, filePath).replace(/\\/g, "/");
+    const ruleBlocks = content.split(/(?=^-\s+(?:rule|id)\s*:)/m).filter((b) => b.trim());
+    for (const block of ruleBlocks) {
+      const idMatch = /(?:^|\n)\s*(?:-\s+)?id\s*:\s*(\S+)/m.exec(block);
+      const ruleId = idMatch?.[1] ?? "unknown";
+      if (!/source_research\s*:/m.test(block) && /(?:rule|id)\s*:/m.test(block)) {
+        issues.push(
+          issue(
+            "QFAI-DDP-011",
+            `Design contract rule '${ruleId}' missing source_research traceability field`,
+            "warning",
+            rel,
+            `ddp.researchTraceability.${ruleId}`
+          )
+        );
+      }
+    }
+  }
+}
+async function validateStoryWorkshopTemplates(root, config, issues, discussionFiles) {
+  for (const filePath of discussionFiles) {
+    let content;
+    try {
+      content = await (0, import_promises50.readFile)(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const rel = import_node_path53.default.relative(root, filePath).replace(/\\/g, "/");
+    if (/screen_type\s*:\s*list/im.test(content)) {
+      for (const field of LIST_TEMPLATE_REQUIRED_FIELDS) {
+        if (!hasNonEmptyField(content, field)) {
+          issues.push(
+            issue(
+              "QFAI-DDP-013",
+              `List template missing required field: ${field}`,
+              "error",
+              rel,
+              `ddp.listTemplate.${field}`
+            )
+          );
+        }
+      }
+      if (hasFieldKey(content, "density_rationale") && !hasNonEmptyField(content, "density_rationale")) {
+        issues.push(
+          issue(
+            "QFAI-DDP-013",
+            "List template density_rationale is empty",
+            "error",
+            rel,
+            "ddp.listTemplate.density_rationale"
+          )
+        );
+      }
+    }
+    if (/screen_type\s*:\s*form/im.test(content)) {
+      for (const field of FORM_TEMPLATE_REQUIRED_FIELDS) {
+        if (!hasNonEmptyField(content, field)) {
+          issues.push(
+            issue(
+              "QFAI-DDP-013",
+              `Form template missing required field: ${field}`,
+              "error",
+              rel,
+              `ddp.formTemplate.${field}`
+            )
+          );
+        }
+      }
+      const statesBlock = extractNestedBlock(content, "states");
+      if (statesBlock !== null && !hasSubField(statesBlock, "error")) {
+        issues.push(
+          issue(
+            "QFAI-DDP-013",
+            "Form template states.error is missing",
+            "error",
+            rel,
+            "ddp.formTemplate.states.error"
+          )
+        );
+      }
+    }
+    detectAntiPatterns(content, rel, issues);
+  }
+}
+function detectAntiPatterns(content, rel, issues) {
+  for (const check of ANTI_PATTERN_CHECKS) {
+    if (check.pattern.test(content)) {
+      issues.push(
+        issue(
+          "QFAI-DDP-014",
+          check.message,
+          "error",
+          rel,
+          `ddp.antiPattern.${check.id}`,
+          void 0,
+          "compatibility",
+          check.guidance
+        )
+      );
+    }
+  }
+}
+function validateQualityProfile(config, issues) {
+  const profile = config.uiux?.qualityProfile;
+  if (profile === "strict") {
+    issues.push(
+      issue(
+        "QFAI-DDP-015",
+        "Quality profile is set to 'strict': all DDP warnings are enforced as errors",
+        "info",
+        void 0,
+        "ddp.qualityProfile.strict"
+      )
+    );
+  } else if (profile === "high") {
+    issues.push(
+      issue(
+        "QFAI-DDP-015",
+        "Quality profile is set to 'high': all DDP warnings are shown",
+        "info",
+        void 0,
+        "ddp.qualityProfile.high"
+      )
+    );
+  }
+}
+async function validateOptionComparison(root, config, issues) {
+  const contractPattern = import_node_path53.default.posix.join(
+    root.replace(/\\/g, "/"),
+    config.paths.contractsDir,
+    "design",
+    "*.yaml"
+  );
+  const contractFiles = await (0, import_fast_glob8.default)(contractPattern, { absolute: true });
+  for (const filePath of contractFiles) {
+    let content;
+    try {
+      content = await (0, import_promises50.readFile)(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const rel = import_node_path53.default.relative(root, filePath).replace(/\\/g, "/");
+    const optionMatches = content.match(/(?:^|\n)\s*-\s+option\s*:/gm) ?? [];
+    const numberedOptions = content.match(/(?:^|\n)\s*option_\d+\s*:/gm) ?? [];
+    const totalOptions = optionMatches.length + numberedOptions.length;
+    if (totalOptions === 1) {
+      issues.push(
+        issue(
+          "QFAI-DDP-016",
+          "Design contract has only 1 option; at least 2 options are required for comparison",
+          "error",
+          rel,
+          "ddp.optionComparison.insufficient"
+        )
+      );
+    } else if (totalOptions >= 2) {
+      const lines = content.split(/\r?\n/);
+      for (const line of lines) {
+        const prosMatch = /^\s*pros\s*:\s*(.*)$/m.exec(line);
+        if (prosMatch && prosMatch[1]?.trim() === "") {
+          issues.push(
+            issue(
+              "QFAI-DDP-016",
+              "Design option has empty pros field",
+              "warning",
+              rel,
+              "ddp.optionComparison.emptyPros"
+            )
+          );
+        }
+      }
+    }
+  }
+}
+async function validateCompetitiveRefs(root, config, issues) {
+  const minRefs = config.uiux?.competitive_refs_min ?? 3;
+  const contractPattern = import_node_path53.default.posix.join(
+    root.replace(/\\/g, "/"),
+    config.paths.contractsDir,
+    "design",
+    "*.yaml"
+  );
+  const contractFiles = await (0, import_fast_glob8.default)(contractPattern, { absolute: true });
+  for (const filePath of contractFiles) {
+    let content;
+    try {
+      content = await (0, import_promises50.readFile)(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const rel = import_node_path53.default.relative(root, filePath).replace(/\\/g, "/");
+    const refsBlock = extractNestedBlock(content, "competitive_refs");
+    if (refsBlock !== null) {
+      const refItems = refsBlock.split(/\n/).filter((l) => /^\s*-\s/.test(l));
+      if (refItems.length < minRefs) {
+        issues.push(
+          issue(
+            "QFAI-DDP-017",
+            `Competitive references insufficient: found ${refItems.length}, minimum ${minRefs} required`,
+            "error",
+            rel,
+            "ddp.competitiveRefs.insufficient"
+          )
+        );
+      }
+    } else {
+      const inlineRefs = getFieldValue(content, "competitive_refs");
+      if (inlineRefs !== null) {
+        if (1 < minRefs) {
+          issues.push(
+            issue(
+              "QFAI-DDP-017",
+              `Competitive references insufficient: found 1, minimum ${minRefs} required`,
+              "error",
+              rel,
+              "ddp.competitiveRefs.insufficient"
+            )
+          );
+        }
+      }
+    }
+    if (/competitive_refs/m.test(content) && !/translation_policy\s*:/m.test(content)) {
+      issues.push(
+        issue(
+          "QFAI-DDP-018",
+          "Translation policy missing in design contract with competitive references",
+          "warning",
+          rel,
+          "ddp.translationPolicy.missing"
+        )
+      );
+    }
+  }
+}
+function extractDdpSection(content) {
+  const heading = DDP_HEADING_RE.exec(content);
+  if (!heading) return null;
+  const start = heading.index + heading[0].length;
+  const remainder = content.slice(start);
+  const nextHeadingOffset = remainder.search(/^#{1,3}\s+/m);
+  const section = nextHeadingOffset === -1 ? remainder : remainder.slice(0, nextHeadingOffset);
+  return section.trim();
+}
+function hasFieldKey(section, field) {
+  const re = new RegExp(`^${field}\\s*:`, "m");
+  return re.test(section);
+}
+function hasNonEmptyField(section, field) {
+  const re = new RegExp(`^${field}\\s*:(.*)`, "m");
+  const match = re.exec(section);
+  if (!match) return false;
+  const inlineValue = (match[1] ?? "").trim();
+  if (inlineValue) return true;
+  const matchEnd = match.index + match[0].length;
+  const remainder = section.slice(matchEnd);
+  const lines = remainder.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^\s+/.test(line) && trimmed.length > 0) return true;
+    break;
+  }
+  return false;
+}
+function getFieldValue(section, field) {
+  const re = new RegExp(`^${field}\\s*:(.*)`, "m");
+  const match = re.exec(section);
+  if (!match) return null;
+  const inlineValue = (match[1] ?? "").trim();
+  if (inlineValue) return inlineValue;
+  const matchEnd = match.index + match[0].length;
+  const remainder = section.slice(matchEnd);
+  const lines = remainder.split(/\r?\n/);
+  const blockLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed && blockLines.length === 0) continue;
+    if (/^\s+/.test(line) && trimmed.length > 0) {
+      blockLines.push(trimmed);
+    } else if (blockLines.length > 0 || !trimmed && blockLines.length === 0) {
+      if (!trimmed && blockLines.length === 0) continue;
+      break;
+    } else {
+      break;
+    }
+  }
+  return blockLines.length > 0 ? blockLines.join("\n") : null;
+}
+function extractNestedBlock(section, field) {
+  const re = new RegExp(`^${field}\\s*:(.*)`, "m");
+  const match = re.exec(section);
+  if (!match) return null;
+  const inlineValue = (match[1] ?? "").trim();
+  if (inlineValue) return null;
+  const matchEnd = match.index + match[0].length;
+  const remainder = section.slice(matchEnd);
+  const lines = remainder.split(/\r?\n/);
+  const blockLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed && blockLines.length === 0) continue;
+    if (/^\s+/.test(line) && trimmed.length > 0) {
+      blockLines.push(line);
+    } else if (blockLines.length > 0) {
+      break;
+    } else if (trimmed) {
+      break;
+    }
+  }
+  return blockLines.length > 0 ? blockLines.join("\n") : null;
+}
+function hasSubField(block, subField) {
+  const re = new RegExp(`^\\s*${subField}\\s*:\\s*\\S`, "m");
+  return re.test(block);
+}
+function collectListItems(section, field) {
+  const re = new RegExp(`^${field}\\s*:(.*)`, "m");
+  const match = re.exec(section);
+  if (!match) return [];
+  const matchEnd = match.index + match[0].length;
+  const remainder = section.slice(matchEnd);
+  const lines = remainder.split(/\r?\n/);
+  const items = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed && items.length === 0) continue;
+    if (/^\s+-\s/.test(line)) {
+      items.push(trimmed.replace(/^-\s*/, ""));
+    } else if (/^\s+\S/.test(line) && items.length > 0) {
+      continue;
+    } else if (trimmed && !/^\s/.test(line)) {
+      break;
+    } else if (!trimmed && items.length > 0) {
+      break;
+    }
+  }
+  return items;
+}
+
+// src/core/validators/navigationFlow.ts
+var import_promises51 = require("fs/promises");
+var NODE_DEF_RE = /([A-Za-z_][\w-]*)\s*(?:\[.*?\]|\(.*?\)|\{.*?\})/g;
+var EDGE_RE = /([A-Za-z_][\w-]*)(?:\s*(?:\[[^\]]*\]|\([^)]*\)|\{[^}]*\}))?(?:::\w+)?\s*(?:--+>|==+>|-.->|~~>)\s*(?:\|"?([^"|]*)"?\|)?\s*([A-Za-z_][\w-]*)(?:\s*(?:\[[^\]]*\]|\([^)]*\)|\{[^}]*\}))?(?:::\w+)?/g;
+var SUBGRAPH_RE = /^\s*subgraph\s+([\w-]+)/gm;
+var FLOWCHART_DECL_RE = /^\s*(?:flowchart|graph)\s+(TD|TB|BT|RL|LR)\s*$/m;
+var MODERN_FLOWCHART_RE = /^\s*flowchart\s+(TD|TB|BT|RL|LR)\s*$/m;
+var TERMINAL_TEXT_RE = /\b(?:end|terminal|finish|complete|done|終了|完了)\b/i;
+var ERROR_NODE_CLASS_RE = /:::\s*error\b/;
+var ERROR_PREFIX_RE = /^err-/;
+function parseFlowchart(content) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const subgraphs = [];
+  for (const match of content.matchAll(SUBGRAPH_RE)) {
+    if (match[1]) subgraphs.push(match[1]);
+  }
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("%%") || trimmed.startsWith("subgraph") || trimmed === "end" || FLOWCHART_DECL_RE.test(trimmed)) {
+      continue;
+    }
+    for (const match of line.matchAll(NODE_DEF_RE)) {
+      const id = match[1] ?? "";
+      const fullMatch = match[0];
+      const bracketContent = fullMatch.match(/\[([^\]]*)\]/)?.[1] ?? fullMatch.match(/\(([^)]*)\)/)?.[1] ?? fullMatch.match(/\{([^}]*)\}/)?.[1] ?? id;
+      const displayText = bracketContent.replace(/^["']|["']$/g, "");
+      const isError = ERROR_PREFIX_RE.test(id) || ERROR_NODE_CLASS_RE.test(line);
+      const isTerminal = TERMINAL_TEXT_RE.test(displayText);
+      if (!nodes.has(id)) {
+        nodes.set(id, { id, displayText, isTerminal, isError });
+      }
+    }
+  }
+  for (const match of content.matchAll(EDGE_RE)) {
+    const from = match[1] ?? "";
+    const label = match[2] !== void 0 && match[2] !== "" ? match[2] : null;
+    const to = match[3] ?? "";
+    edges.push({ from, to, label });
+    if (!nodes.has(from)) {
+      nodes.set(from, {
+        id: from,
+        displayText: from,
+        isTerminal: false,
+        isError: ERROR_PREFIX_RE.test(from)
+      });
+    }
+    if (!nodes.has(to)) {
+      nodes.set(to, {
+        id: to,
+        displayText: to,
+        isTerminal: false,
+        isError: ERROR_PREFIX_RE.test(to)
+      });
+    }
+  }
+  return { nodes, edges, subgraphs, raw: content };
+}
+function hasFlowchartDeclaration(content) {
+  return FLOWCHART_DECL_RE.test(content);
+}
+function checkMermaidSyntax(content, file) {
+  const issues = [];
+  if (hasFlowchartDeclaration(content) && !MODERN_FLOWCHART_RE.test(content)) {
+    issues.push(
+      issue(
+        "QFAI-NAV-001",
+        `Mermaid block uses legacy "graph" keyword. Use "flowchart" instead.`,
+        "error",
+        file,
+        "navigationFlow.mermaid.syntax"
+      )
+    );
+    return issues;
+  }
+  if (!hasFlowchartDeclaration(content)) {
+    issues.push(
+      issue(
+        "QFAI-NAV-001",
+        `Mermaid block does not contain a valid flowchart declaration.`,
+        "error",
+        file,
+        "navigationFlow.mermaid.syntax"
+      )
+    );
+    return issues;
+  }
+  const subgraphOpens = (content.match(/^\s*subgraph\b/gm) ?? []).length;
+  const subgraphCloses = (content.match(/^\s*end\b/gm) ?? []).length;
+  if (subgraphOpens !== subgraphCloses) {
+    issues.push(
+      issue(
+        "QFAI-NAV-001",
+        `Mermaid flowchart has mismatched subgraph/end blocks (${subgraphOpens} subgraph vs ${subgraphCloses} end).`,
+        "error",
+        file,
+        "navigationFlow.mermaid.syntax"
+      )
+    );
+  }
+  return issues;
+}
+function checkUnlabeledEdges(parsed, file) {
+  const issues = [];
+  for (const edge of parsed.edges) {
+    if (edge.label === null) {
+      issues.push(
+        issue(
+          "QFAI-NAV-002",
+          `Edge ${edge.from} \u2192 ${edge.to} has no label. All edges must be labeled.`,
+          "warning",
+          file,
+          "navigationFlow.edge.label"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function checkDeadEndNodes(parsed, file) {
+  const issues = [];
+  const outgoingCount = /* @__PURE__ */ new Map();
+  for (const [id] of parsed.nodes) {
+    outgoingCount.set(id, 0);
+  }
+  for (const edge of parsed.edges) {
+    outgoingCount.set(edge.from, (outgoingCount.get(edge.from) ?? 0) + 1);
+  }
+  for (const [id, count] of outgoingCount) {
+    if (count === 0) {
+      const node = parsed.nodes.get(id);
+      if (node && !node.isTerminal) {
+        issues.push(
+          issue(
+            "QFAI-NAV-003",
+            `Node "${id}" has no outgoing edges and is not marked as terminal.`,
+            "warning",
+            file,
+            "navigationFlow.node.deadEnd"
+          )
+        );
+      }
+    }
+  }
+  return issues;
+}
+function checkReachability(parsed, file) {
+  const issues = [];
+  if (parsed.nodes.size === 0) return issues;
+  const firstEdge = parsed.edges[0];
+  const entryId = firstEdge?.from ?? parsed.nodes.keys().next().value;
+  if (!entryId) return issues;
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [entryId];
+  visited.add(entryId);
+  while (queue.length > 0) {
+    const current = queue.shift() ?? "";
+    for (const edge of parsed.edges) {
+      if (edge.from === current && !visited.has(edge.to)) {
+        visited.add(edge.to);
+        queue.push(edge.to);
+      }
+    }
+  }
+  for (const [id] of parsed.nodes) {
+    if (!visited.has(id)) {
+      issues.push(
+        issue(
+          "QFAI-NAV-004",
+          `Node "${id}" is unreachable from entry point "${entryId}".`,
+          "error",
+          file,
+          "navigationFlow.node.unreachable"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function checkErrorRecovery(parsed, file) {
+  const issues = [];
+  for (const [id, node] of parsed.nodes) {
+    if (!node.isError) continue;
+    const hasOutgoing = parsed.edges.some((e) => e.from === id);
+    if (!hasOutgoing) {
+      issues.push(
+        issue(
+          "QFAI-NAV-005",
+          `Error node "${id}" has no outgoing edge to recover to normal flow.`,
+          "error",
+          file,
+          "navigationFlow.errorNode.recovery"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function checkViewportDiffs(content, parsed, file) {
+  const issues = [];
+  const hasViewportSubgraph = parsed.subgraphs.some(
+    (s) => /desktop|mobile|tablet|responsive/i.test(s)
+  );
+  const hasViewportAnnotation = /%%\s*(?:desktop|mobile|tablet|viewport|responsive)/i.test(content) || /\bdesktop\b.*\bmobile\b/i.test(content) || /\bmobile\b.*\bdesktop\b/i.test(content);
+  const hasSharedDeclaration = /\b(?:shared|common)\b/i.test(content);
+  if (!hasViewportSubgraph && !hasViewportAnnotation && !hasSharedDeclaration) {
+    issues.push(
+      issue(
+        "QFAI-NAV-006",
+        `Flowchart does not document viewport differences. Use subgraphs for desktop/mobile or annotate as "shared".`,
+        "warning",
+        file,
+        "navigationFlow.viewport.diff"
+      )
+    );
+  }
+  return issues;
+}
+function checkImplementationAlignment(specContent, parsed, file) {
+  const issues = [];
+  const screenListMatch = specContent.match(/## Screen List\s*\n((?:.*\n)*?)(?=## |$)/);
+  if (!screenListMatch) {
+    return issues;
+  }
+  const screenListBlock = screenListMatch[1] ?? "";
+  const screenNames = [];
+  for (const line of screenListBlock.split("\n")) {
+    const match = line.match(/^\s*[-*]\s+(.+)/);
+    if (match?.[1]) {
+      screenNames.push(match[1].trim());
+    }
+  }
+  if (screenNames.length === 0) return issues;
+  const flowNodeTexts = /* @__PURE__ */ new Set();
+  for (const [, node] of parsed.nodes) {
+    flowNodeTexts.add(node.displayText.toLowerCase());
+  }
+  for (const screen of screenNames) {
+    const screenLower = screen.toLowerCase();
+    const found = [...flowNodeTexts].some(
+      (t) => t.includes(screenLower) || screenLower.includes(t)
+    );
+    if (!found) {
+      issues.push(
+        issue(
+          "QFAI-NAV-007",
+          `Screen "${screen}" in Screen List is not found in flowchart nodes.`,
+          "warning",
+          file,
+          "navigationFlow.alignment.mismatch"
+        )
+      );
+    }
+  }
+  const screenNamesLower = screenNames.map((s) => s.toLowerCase());
+  for (const [, node] of parsed.nodes) {
+    if (node.isTerminal || node.isError) continue;
+    const textLower = node.displayText.toLowerCase();
+    const found = screenNamesLower.some((s) => s.includes(textLower) || textLower.includes(s));
+    if (!found) {
+      issues.push(
+        issue(
+          "QFAI-NAV-007",
+          `Flowchart node "${node.displayText}" has no matching entry in Screen List.`,
+          "warning",
+          file,
+          "navigationFlow.alignment.mismatch"
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function validateNavigationFlow(root, config) {
+  const specsDir = resolvePath(root, config, "specsDir");
+  const allFiles = await collectFiles(specsDir, { extensions: [".md"] });
+  const specFiles = allFiles.filter((f) => /[\\/]spec-\d{4}[\\/]/.test(f));
+  const issues = [];
+  for (const file of specFiles) {
+    const content = await (0, import_promises51.readFile)(file, "utf-8");
+    const blocks = extractFencedCodeBlocks(content);
+    const mermaidBlocks = blocks.filter((b) => b.language === "mermaid");
+    const _flowchartBlocks = mermaidBlocks.filter((b) => hasFlowchartDeclaration(b.content));
+    for (const block of mermaidBlocks) {
+      if (!hasFlowchartDeclaration(block.content)) {
+        continue;
+      }
+      issues.push(...checkMermaidSyntax(block.content, file));
+      const parsed = parseFlowchart(block.content);
+      issues.push(...checkUnlabeledEdges(parsed, file));
+      issues.push(...checkDeadEndNodes(parsed, file));
+      issues.push(...checkReachability(parsed, file));
+      issues.push(...checkErrorRecovery(parsed, file));
+      issues.push(...checkViewportDiffs(block.content, parsed, file));
+      issues.push(...checkImplementationAlignment(content, parsed, file));
+    }
+  }
+  return issues;
+}
+
+// src/core/validators/renderCritique.ts
+var import_node_path54 = __toESM(require("path"), 1);
+var import_fast_glob9 = __toESM(require("fast-glob"), 1);
+var RENDERED_KEYWORDS_RE = /\b(rendered|screenshot|html\b|preview|visual\s*review)/i;
+var DDP_REFERENCE_RE = /\b(ddp|design\s*direction\s*pack)\b/i;
+var READ_ORDER_RE = /DDP[\s\S]{0,40}Design\s*Token[\s\S]{0,40}UI\s*Contract[\s\S]{0,40}HTML\s*Mock[\s\S]{0,40}Flow/i;
+var DESKTOP_RE = /\b(desktop|1024\s*px|1280\s*px|1440\s*px|viewport\s*[≥>=]+\s*1024)\b/i;
+var MOBILE_RE = /\b(mobile|480\s*px|375\s*px|390\s*px|viewport\s*[≤<=]+\s*480)\b/i;
+var EVIDENCE_DATE_RE = /\bdate\s*:/i;
+var EVIDENCE_VIEWPORT_RE = /\bviewport\s*:/i;
+var EVIDENCE_VERDICT_RE = /\bverdict\s*:\s*(PASS|REVISE)\b/i;
+var EVIDENCE_FINDINGS_RE = /\bfindings\s*:/i;
+var RUBRIC_RE = /\b(rubric|evaluation\s*criteria|scoring\s*guide)\b/i;
+var TASK_FIDELITY_SECTION_RE = /\btaskFidelity\b/i;
+var STEP_COUNT_RE = /\bstep_count\s*:\s*(\d+)/i;
+var CTA_VISIBILITY_RE = /\bcta_visibility\s*:/i;
+var FOUR_STATE_CHECK_RE = /\bfour_state_check\s*:/i;
+var MAX_PRIMARY_STEPS_RE = /\bmax_primary_steps\s*:\s*(\d+)/i;
+async function validateRenderCritique(root, config) {
+  const issues = [];
+  const discussionDir = import_node_path54.default.join(root, config.paths.discussionDir).replace(/\\/g, "/");
+  const discussionFiles = await (0, import_fast_glob9.default)(import_node_path54.default.posix.join(discussionDir, "**/*.md"), { absolute: true });
+  let hasDdp = false;
+  for (const df of discussionFiles) {
+    const content = await readSafe(df);
+    if (/^#{1,3}\s+Design\s+Direction\s+Pack/im.test(content)) {
+      hasDdp = true;
+      break;
+    }
+  }
+  if (!hasDdp) return issues;
+  const skillsDir = import_node_path54.default.join(root, config.paths.skillsDir).replace(/\\/g, "/");
+  const evidenceDir = import_node_path54.default.join(root, ".qfai", "evidence").replace(/\\/g, "/");
+  const skillPromptPattern = import_node_path54.default.posix.join(skillsDir, "qfai-{prototyping,implement}*/SKILL.md");
+  const skillFiles = await (0, import_fast_glob9.default)(skillPromptPattern, { dot: true });
+  const evidencePattern = import_node_path54.default.posix.join(evidenceDir, "{prototyping*,critique-*}.md");
+  const evidenceFiles = await (0, import_fast_glob9.default)(evidencePattern, { dot: true });
+  for (const sf of skillFiles) {
+    const content = await readSafe(sf);
+    if (content.length > 0 && !RENDERED_KEYWORDS_RE.test(content)) {
+      issues.push(
+        issue(
+          "QFAI-CRIT-001",
+          `Skill prompt does not mention rendered/screenshot/HTML review: ${import_node_path54.default.relative(root, sf)}`,
+          "error",
+          sf,
+          "renderCritique.codeOnly",
+          void 0,
+          "change",
+          "Add rendered output review requirement (e.g. 'screenshot', 'rendered', 'HTML') to the skill prompt."
+        )
+      );
+    }
+  }
+  for (const sf of skillFiles) {
+    const content = await readSafe(sf);
+    if (content.length > 0 && !DDP_REFERENCE_RE.test(content)) {
+      issues.push(
+        issue(
+          "QFAI-CRIT-002",
+          `Downstream skill prompt missing DDP reference: ${import_node_path54.default.relative(root, sf)}`,
+          "error",
+          sf,
+          "renderCritique.ddpMissing",
+          void 0,
+          "change",
+          "Add DDP (Design Direction Pack) reference to the downstream skill prompt."
+        )
+      );
+    }
+  }
+  const allEvidenceContent = await collectContent(evidenceFiles);
+  if (evidenceFiles.length > 0 && !DESKTOP_RE.test(allEvidenceContent)) {
+    issues.push(
+      issue(
+        "QFAI-CRIT-003",
+        "No desktop viewport critique found in evidence files (viewport >= 1024px required).",
+        "error",
+        evidenceDir,
+        "renderCritique.desktopMissing",
+        void 0,
+        "change",
+        "Add desktop viewport critique (>= 1024px) to evidence files."
+      )
+    );
+  }
+  if (evidenceFiles.length > 0 && !MOBILE_RE.test(allEvidenceContent)) {
+    issues.push(
+      issue(
+        "QFAI-CRIT-004",
+        "No mobile viewport critique found in evidence files (viewport <= 480px required).",
+        "error",
+        evidenceDir,
+        "renderCritique.mobileMissing",
+        void 0,
+        "change",
+        "Add mobile viewport critique (<= 480px) to evidence files."
+      )
+    );
+  }
+  for (const sf of skillFiles) {
+    const content = await readSafe(sf);
+    if (content.length > 0 && !READ_ORDER_RE.test(content)) {
+      issues.push(
+        issue(
+          "QFAI-CRIT-005",
+          `Read order not specified (DDP \u2192 Design Token \u2192 UI Contract \u2192 HTML Mock \u2192 Flow): ${import_node_path54.default.relative(root, sf)}`,
+          "error",
+          sf,
+          "renderCritique.readOrder",
+          void 0,
+          "change",
+          "Specify the read order: DDP \u2192 Design Token \u2192 UI Contract \u2192 HTML Mock \u2192 Flow."
+        )
+      );
+    }
+  }
+  for (const ef of evidenceFiles) {
+    const content = await readSafe(ef);
+    if (content.length === 0) continue;
+    const hasDate = EVIDENCE_DATE_RE.test(content);
+    const hasViewport = EVIDENCE_VIEWPORT_RE.test(content);
+    const hasVerdict = EVIDENCE_VERDICT_RE.test(content);
+    const hasFindings = EVIDENCE_FINDINGS_RE.test(content);
+    if (!hasDate || !hasViewport || !hasVerdict || !hasFindings) {
+      const missing = [];
+      if (!hasDate) missing.push("date");
+      if (!hasViewport) missing.push("viewport");
+      if (!hasVerdict) missing.push("verdict");
+      if (!hasFindings) missing.push("findings");
+      issues.push(
+        issue(
+          "QFAI-CRIT-006",
+          `Critique evidence incomplete (missing: ${missing.join(", ")}): ${import_node_path54.default.relative(root, ef)}`,
+          "error",
+          ef,
+          "renderCritique.incompleteEvidence",
+          void 0,
+          "change",
+          "Ensure evidence includes date, viewport, verdict (PASS/REVISE), and findings."
+        )
+      );
+    }
+  }
+  if (evidenceFiles.length > 0 && !RUBRIC_RE.test(allEvidenceContent)) {
+    issues.push(
+      issue(
+        "QFAI-CRIT-007",
+        "Rubric / evaluation criteria not documented in evidence files.",
+        "warning",
+        evidenceDir,
+        "renderCritique.rubricMissing",
+        void 0,
+        "change",
+        "Document the rubric or evaluation criteria in evidence files for reproducibility."
+      )
+    );
+  }
+  if (evidenceFiles.length > 0) {
+    const desktopPass = hasViewportPass(allEvidenceContent, "desktop");
+    const mobilePass = hasViewportPass(allEvidenceContent, "mobile");
+    if (!desktopPass || !mobilePass) {
+      issues.push(
+        issue(
+          "QFAI-CRIT-008",
+          `Iterative loop not completed: ${!desktopPass ? "desktop" : ""}${!desktopPass && !mobilePass ? " and " : ""}${!mobilePass ? "mobile" : ""} viewport not PASS.`,
+          "error",
+          evidenceDir,
+          "renderCritique.loopNotCompleted",
+          void 0,
+          "change",
+          "Both desktop and mobile viewports must have verdict: PASS for the loop to complete."
+        )
+      );
+    }
+  }
+  if (evidenceFiles.length > 0 && !TASK_FIDELITY_SECTION_RE.test(allEvidenceContent)) {
+    issues.push(
+      issue(
+        "QFAI-CRIT-009",
+        "taskFidelity evaluation not recorded in evidence files.",
+        "error",
+        evidenceDir,
+        "renderCritique.taskFidelityMissing",
+        void 0,
+        "change",
+        "Add taskFidelity section with step_count, cta_visibility, and four_state_check."
+      )
+    );
+  }
+  if (evidenceFiles.length > 0 && TASK_FIDELITY_SECTION_RE.test(allEvidenceContent)) {
+    const stepCountMatch = STEP_COUNT_RE.exec(allEvidenceContent);
+    const maxStepsMatch = MAX_PRIMARY_STEPS_RE.exec(allEvidenceContent);
+    const hasCta = CTA_VISIBILITY_RE.test(allEvidenceContent);
+    const hasFourState = FOUR_STATE_CHECK_RE.test(allEvidenceContent);
+    if (!hasCta || !hasFourState) {
+      issues.push(
+        issue(
+          "QFAI-CRIT-009",
+          `taskFidelity section incomplete (missing: ${[!hasCta ? "cta_visibility" : "", !hasFourState ? "four_state_check" : ""].filter(Boolean).join(", ")}).`,
+          "error",
+          evidenceDir,
+          "renderCritique.taskFidelityMissing",
+          void 0,
+          "change",
+          "Add missing taskFidelity fields: step_count, cta_visibility, four_state_check."
+        )
+      );
+    }
+    if (stepCountMatch && maxStepsMatch) {
+      const stepCount = parseInt(stepCountMatch[1] ?? "0", 10);
+      const maxSteps = parseInt(maxStepsMatch[1] ?? "0", 10);
+      if (stepCount > maxSteps) {
+        issues.push(
+          issue(
+            "QFAI-CRIT-010",
+            `taskFidelity FAIL: step_count (${stepCount}) exceeds max_primary_steps (${maxSteps}).`,
+            "error",
+            evidenceDir,
+            "renderCritique.taskFidelityFail",
+            void 0,
+            "change",
+            "Reduce step_count to be within max_primary_steps, or revise the flow."
+          )
+        );
+      }
+    }
+  }
+  return issues;
+}
+function hasViewportPass(content, viewport) {
+  const vpRe = viewport === "desktop" ? DESKTOP_RE : MOBILE_RE;
+  const sections = content.split(/(?=^#{1,3}\s)/m);
+  for (const section of sections) {
+    if (vpRe.test(section) && /verdict\s*:\s*PASS/i.test(section)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function collectContent(files) {
+  const contents = [];
+  for (const f of files) {
+    contents.push(await readSafe(f));
+  }
+  return contents.join("\n---\n");
+}
+
+// src/core/validators/designFidelity.ts
+var import_promises52 = require("fs/promises");
+var import_node_path55 = __toESM(require("path"), 1);
+var import_fast_glob10 = __toESM(require("fast-glob"), 1);
+var SCORECARD_HEADING_RE = /^#{1,3}\s+Fidelity\s+Scorecard/im;
+var BASE_DIMENSIONS = ["hierarchy", "clarity", "accessibility", "responsive"];
+var TASK_FIDELITY_REQUIRED_FIELDS = [
+  "step_count",
+  "cta_visibility",
+  "empty_state",
+  "error_state",
+  "primary_flow_clicks"
+];
+var PASS_THRESHOLD = 70;
+var ESCALATED_CODES = [
+  "dual_primary_cta",
+  "empty_state_without_action",
+  "error_without_recovery",
+  "placeholder_or_lorem",
+  "cta_visibility_fail",
+  "scorecard_dimension_missing"
+];
+async function validateDesignFidelity(root, config) {
+  const issues = [];
+  const evidenceDirs = [".qfai/evidence", ".qfai/review"];
+  const allFiles = [];
+  for (const dir of evidenceDirs) {
+    const pattern = import_node_path55.default.posix.join(root.replace(/\\/g, "/"), dir, "**/*.md");
+    const files = await (0, import_fast_glob10.default)(pattern, { absolute: true });
+    allFiles.push(...files);
+  }
+  for (const filePath of allFiles) {
+    let content;
+    try {
+      content = await (0, import_promises52.readFile)(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (!SCORECARD_HEADING_RE.test(content)) continue;
+    const rel = import_node_path55.default.relative(root, filePath).replace(/\\/g, "/");
+    const section = extractScorecardSection(content);
+    if (!section) continue;
+    const dimensions = parseDimensions(section);
+    const _verdict = parseVerdict(section);
+    for (const dim of BASE_DIMENSIONS) {
+      if (!dimensions.has(dim)) {
+        issues.push(
+          issue(
+            "QFAI-FID-001",
+            `Fidelity scorecard missing dimension: ${dim}`,
+            "error",
+            rel,
+            `fidelity.dimension.${dim}`
+          )
+        );
+      } else {
+        const d = dimensions.get(dim);
+        if (d && (d.score === null || d.comment === null)) {
+          issues.push(
+            issue(
+              "QFAI-FID-002",
+              `Fidelity dimension '${dim}' missing ${d.score === null ? "score" : "prose comment"}`,
+              "error",
+              rel,
+              `fidelity.scoreOrProse.${dim}`
+            )
+          );
+        }
+      }
+    }
+    const scores = [];
+    for (const dim of BASE_DIMENSIONS) {
+      const d = dimensions.get(dim);
+      if (d?.score !== null && d?.score !== void 0) {
+        scores.push(d.score);
+        if (d.score < PASS_THRESHOLD) {
+          issues.push(
+            issue(
+              "QFAI-FID-003",
+              `Dimension '${dim}' score ${d.score} is below threshold ${PASS_THRESHOLD}`,
+              "error",
+              rel,
+              `fidelity.threshold.${dim}`
+            )
+          );
+        }
+      }
+    }
+    const taskFid = dimensions.get("taskFidelity");
+    if (taskFid?.score !== null && taskFid?.score !== void 0) {
+      scores.push(taskFid.score);
+      if (taskFid.score < PASS_THRESHOLD) {
+        issues.push(
+          issue(
+            "QFAI-FID-003",
+            `Dimension 'taskFidelity' score ${taskFid.score} is below threshold ${PASS_THRESHOLD}`,
+            "error",
+            rel,
+            "fidelity.threshold.taskFidelity"
+          )
+        );
+      }
+    }
+    if (scores.length > 0) {
+      const avg = scores.reduce((a, b) => a + b, 0) / scores.length;
+      if (avg < PASS_THRESHOLD) {
+        issues.push(
+          issue(
+            "QFAI-FID-003",
+            `Overall average score ${avg.toFixed(1)} is below threshold ${PASS_THRESHOLD}`,
+            "error",
+            rel,
+            "fidelity.threshold.average"
+          )
+        );
+      }
+    }
+    for (const dim of BASE_DIMENSIONS) {
+      const d = dimensions.get(dim);
+      if (d?.score !== null && d?.score !== void 0 && d.score < PASS_THRESHOLD) {
+        if (!d.improvement || !d.alternative) {
+          issues.push(
+            issue(
+              "QFAI-FID-004",
+              `FAIL dimension '${dim}' missing ${!d.improvement ? "improvement instructions" : "alternative suggestion"}`,
+              "error",
+              rel,
+              `fidelity.improvement.${dim}`
+            )
+          );
+        }
+      }
+    }
+    const responsive = dimensions.get("responsive");
+    if (responsive) {
+      if (!responsive.desktop || !responsive.mobile) {
+        issues.push(
+          issue(
+            "QFAI-FID-005",
+            `Responsive dimension missing ${!responsive.desktop ? "desktop" : "mobile"} viewport results`,
+            "error",
+            rel,
+            "fidelity.viewport.responsive"
+          )
+        );
+      }
+    }
+    const delta = parseDelta(section);
+    if (delta.hasBreaking) {
+      if (!delta.content || !delta.impact || !delta.migration) {
+        const missing = [];
+        if (!delta.content) missing.push("content");
+        if (!delta.impact) missing.push("impact");
+        if (!delta.migration) missing.push("migration steps");
+        issues.push(
+          issue(
+            "QFAI-FID-006",
+            `Breaking delta missing: ${missing.join(", ")}`,
+            "error",
+            rel,
+            "fidelity.breakingDelta"
+          )
+        );
+      }
+    }
+    if (!hasRubric(section)) {
+      issues.push(
+        issue(
+          "QFAI-FID-007",
+          "Scorecard rubric not documented; results are not reproducible",
+          "error",
+          rel,
+          "fidelity.rubricMissing"
+        )
+      );
+    }
+    const requiresTaskFidelity = hasTaskFidelityRequirement(content);
+    if (requiresTaskFidelity) {
+      if (!dimensions.has("taskFidelity")) {
+        issues.push(
+          issue(
+            "QFAI-FID-008",
+            "Spec requires taskFidelity dimension but it is not present in scorecard",
+            "error",
+            rel,
+            "fidelity.taskFidelity.missing"
+          )
+        );
+      } else {
+        const tf = dimensions.get("taskFidelity");
+        for (const field of TASK_FIDELITY_REQUIRED_FIELDS) {
+          if (tf && !tf.fields.has(field)) {
+            issues.push(
+              issue(
+                "QFAI-FID-009",
+                `taskFidelity missing required field: ${field}`,
+                "error",
+                rel,
+                `fidelity.taskFidelity.field.${field}`
+              )
+            );
+          }
+        }
+      }
+    }
+    const overrides = config.uiux?.warning_as_error_override ?? [];
+    for (const code of ESCALATED_CODES) {
+      if (hasAntiPatternMention(section, code)) {
+        const isOverridden = overrides.includes(code);
+        const severity = isOverridden ? "warning" : "error";
+        const issueCode = isOverridden ? "QFAI-FID-011" : "QFAI-FID-010";
+        const suffix = isOverridden ? " (overridden to warning by config)" : "";
+        issues.push(
+          issue(
+            issueCode,
+            `Escalated validation: ${code}${suffix}`,
+            severity,
+            rel,
+            `fidelity.escalation.${code}`
+          )
+        );
+      }
+    }
+  }
+  return issues;
+}
+function extractScorecardSection(content) {
+  const heading = SCORECARD_HEADING_RE.exec(content);
+  if (!heading) return null;
+  const start = heading.index + heading[0].length;
+  const remainder = content.slice(start);
+  const nextHeadingOffset = remainder.search(/^#{1,3}\s+/m);
+  const section = nextHeadingOffset === -1 ? remainder : remainder.slice(0, nextHeadingOffset);
+  return section.trim();
+}
+function parseDimensions(section) {
+  const dims = /* @__PURE__ */ new Map();
+  const lines = section.split(/\r?\n/);
+  let currentDim = null;
+  let currentInfo = null;
+  for (const line of lines) {
+    const dimMatch = /^(\w+)\s*:(.*)$/.exec(line);
+    if (dimMatch && !line.startsWith(" ") && !line.startsWith("	")) {
+      if (currentDim && currentInfo) {
+        dims.set(currentDim, currentInfo);
+      }
+      const name = dimMatch[1] ?? "";
+      const inlineValue = (dimMatch[2] ?? "").trim();
+      if (["verdict", "rubric", "delta", "breaking_delta"].includes(name)) {
+        currentDim = null;
+        currentInfo = null;
+        continue;
+      }
+      currentDim = name;
+      currentInfo = {
+        score: null,
+        comment: null,
+        improvement: null,
+        alternative: null,
+        desktop: null,
+        mobile: null,
+        fields: /* @__PURE__ */ new Map()
+      };
+      if (inlineValue && /^\d+$/.test(inlineValue)) {
+        currentInfo.score = parseInt(inlineValue, 10);
+      }
+      continue;
+    }
+    if (currentDim && currentInfo && /^\s+/.test(line)) {
+      const subMatch = /^\s+(\w+)\s*:\s*(.*)$/.exec(line);
+      if (subMatch) {
+        const key = subMatch[1] ?? "";
+        const value = (subMatch[2] ?? "").trim();
+        switch (key) {
+          case "score":
+            currentInfo.score = value ? parseInt(value, 10) : null;
+            break;
+          case "comment":
+            currentInfo.comment = value || null;
+            break;
+          case "improvement":
+            currentInfo.improvement = value || null;
+            break;
+          case "alternative":
+            currentInfo.alternative = value || null;
+            break;
+          case "desktop":
+            currentInfo.desktop = value || null;
+            break;
+          case "mobile":
+            currentInfo.mobile = value || null;
+            break;
+          default:
+            currentInfo.fields.set(key, value);
+            break;
+        }
+      }
+    }
+  }
+  if (currentDim && currentInfo) {
+    dims.set(currentDim, currentInfo);
+  }
+  return dims;
+}
+function parseVerdict(section) {
+  const match = /^verdict\s*:\s*(\S+)/m.exec(section);
+  return match?.[1] ?? null;
+}
+function parseDelta(section) {
+  const hasBreaking = /breaking_delta\s*:/m.test(section) || /delta\s*:/m.test(section) && /breaking/im.test(section);
+  if (!hasBreaking) {
+    return { hasBreaking: false, content: false, impact: false, migration: false };
+  }
+  return {
+    hasBreaking: true,
+    content: /content\s*:/m.test(section),
+    impact: /impact\s*:/m.test(section),
+    migration: /migration\s*:/m.test(section)
+  };
+}
+function hasRubric(section) {
+  return /rubric\s*:/m.test(section);
+}
+function hasTaskFidelityRequirement(content) {
+  return /taskFidelity\s*:\s*required/im.test(content) || /require.*taskFidelity/im.test(content);
+}
+function hasAntiPatternMention(section, code) {
+  return new RegExp(`\\b${code.replace(/_/g, "[_ ]")}\\b`, "i").test(section);
+}
+
+// src/core/validate.ts
+var UIUX_VALIDATION_BUDGET_MS = 2e3;
+async function validateProject(root, configResult, options = {}) {
+  const resolved = configResult ?? await loadConfig(root);
+  const { config, issues: configIssues } = resolved;
+  const phase = options.phase ?? "full";
+  const atddCodeTraceabilityIssues = phase === "refinement" ? [] : await validateAtddCodeTraceability(root, config);
+  const uiuxStart = performance.now();
+  const platformResult = await detectPlatform(root, config, options.platform);
+  const platform = platformResult.platform;
+  const uiuxValidators = [
+    () => validateDesignToken(root, config),
+    () => validateHtmlMock(root, platform, config),
+    () => validateMermaidScreenFlow(root, config),
+    () => validateBpApDb(root, config),
+    () => validateUiDefinitionConsistency(root, config),
+    () => validateResearchSummary(root, config),
+    () => validateAgentDefinition(root, config)
+  ];
+  const uiuxIssueGroups = await Promise.all(uiuxValidators.map((validator) => validator()));
+  const uiuxIssues = [...platformResult.issues, ...uiuxIssueGroups.flat()];
+  const uiuxElapsed = performance.now() - uiuxStart;
+  if (uiuxElapsed > UIUX_VALIDATION_BUDGET_MS) {
+    uiuxIssues.push({
+      code: "QFAI-UIUX-PERF",
+      severity: "warning",
+      category: "compatibility",
+      message: `UI/UX validation exceeded budget (${UIUX_VALIDATION_BUDGET_MS}ms). All validators were executed.`,
+      rule: "uiux.performanceBudget"
+    });
+  }
+  const findings = [
+    ...configIssues,
+    ...await validateRepositoryHygiene(root, config),
+    ...await validateSkillsIntegrity(root, config),
+    ...await validateAssistantAssets(root, config),
+    ...await validateDiscussionMermaid(root),
+    ...await validateMermaidEnforcement(root),
+    ...await validateSpecPacks(root, config),
+    ...await validateDiscussionPackReadiness(root, config),
+    ...await validateDiscussionVisuals(root),
+    ...await validateLegacyStatusDir(root),
+    ...await validateStatusInSpecs(root, config),
+    ...await validateDensityHints(root, config),
+    ...await validateReviewArtifacts(root),
+    ...await validatePrototypingEvidence(root, config),
+    ...await validateSpecSplitByCapability(root, config),
+    ...await validateLayeredTraceability(root, config),
+    ...await validateOrphanProhibition(root, config),
+    ...await validateLayerCoverage(root, config),
+    ...atddCodeTraceabilityIssues,
+    ...await validateContractReferences(root, config),
+    ...await validateTraceability(root, config, phase),
+    ...await validateDefinedIds(root, config),
+    ...await validateContracts(root, config),
+    ...await validateTddList(root, config),
+    ...await validateDdpFields(root, config),
+    ...await validateNavigationFlow(root, config),
+    ...await validateRenderCritique(root, config),
+    ...await validateDesignFidelity(root, config),
+    ...uiuxIssues
+  ];
+  const { issues, waivers } = await applyWaivers(root, findings);
+  const specsRoot = resolvePath(root, config, "specsDir");
+  const scenarioFiles = await collectScenarioFiles(specsRoot);
+  const scIds = await collectScIdsFromScenarioFiles(scenarioFiles);
+  const { refs: scTestRefs, scan: testFiles } = await collectScTestReferences(
+    root,
+    config.validation.traceability.testFileGlobs,
+    config.validation.traceability.testFileExcludeGlobs
+  );
+  const scCoverage = buildScCoverage(scIds, scTestRefs);
+  const toolVersion = await resolveToolVersion();
+  return {
+    toolVersion,
+    phase,
+    issues,
+    counts: countIssues(issues),
+    traceability: {
+      sc: scCoverage,
+      testFiles
+    },
+    waivers
+  };
+}
+function countIssues(issues) {
+  return issues.reduce(
+    (acc, issue2) => {
+      if (issue2.suppressed) {
+        return acc;
+      }
+      acc[issue2.severity] += 1;
+      return acc;
+    },
+    { info: 0, warning: 0, error: 0 }
+  );
+}
+
+// src/core/report.ts
+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 = import_node_path56.default.resolve(root);
+  const resolved = configResult ?? await loadConfig(resolvedRoot);
+  const config = resolved.config;
+  const configPath = resolved.configPath;
+  const specsRoot = resolvePath(resolvedRoot, config, "specsDir");
+  const contractsRoot = resolvePath(resolvedRoot, config, "contractsDir");
+  const apiRoot = import_node_path56.default.join(contractsRoot, "api");
+  const uiRoot = import_node_path56.default.join(contractsRoot, "ui");
+  const dbRoot = import_node_path56.default.join(contractsRoot, "db");
+  const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
+  const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
+  const specEntries = await collectSpecEntries(specsRoot);
+  const specFiles = await collectSpecFiles(specsRoot);
+  const scenarioFiles = await collectScenarioFiles(specsRoot);
+  const scenarioCount = await countScenarios(scenarioFiles);
+  const testStrategy = await collectTestStrategy(
+    scenarioFiles,
+    resolvedRoot,
+    config,
+    REPORT_TEST_STRATEGY_SAMPLE_LIMIT
+  );
+  const {
+    api: apiFiles,
+    ui: uiFiles,
+    db: dbFiles,
+    thema: themaFiles
+  } = await collectContractFiles(uiRoot, apiRoot, dbRoot);
+  const contractIndex = await buildContractIndex(resolvedRoot, config);
+  const contractIdList = Array.from(contractIndex.ids);
+  const specContractRefs = await collectSpecContractRefs(specFiles, contractIdList);
+  const referencedContracts = /* @__PURE__ */ new Set();
+  for (const entry of specContractRefs.specToContracts.values()) {
+    entry.ids.forEach((id) => referencedContracts.add(id));
+  }
+  const referencedContractCount = contractIdList.filter((id) => referencedContracts.has(id)).length;
+  const orphanContractCount = contractIdList.filter((id) => !referencedContracts.has(id)).length;
+  const contractIdToSpecsRecord = mapToSortedRecord(specContractRefs.idToSpecs);
+  const specToContractsRecord = mapToSpecContractRecord(specContractRefs.specToContracts);
+  const idsByPrefix = await collectIds([
+    ...specFiles,
+    ...scenarioFiles,
+    ...apiFiles,
+    ...uiFiles,
+    ...dbFiles,
+    ...themaFiles
+  ]);
+  const upstreamIds = await collectUpstreamIds([...specFiles, ...scenarioFiles]);
+  const traceability = await evaluateTraceability(upstreamIds, srcRoot, testsRoot);
+  const resolvedValidationRaw = validation ?? await validateProject(resolvedRoot, resolved);
+  const normalizedValidation = normalizeValidationResult(resolvedRoot, resolvedValidationRaw);
+  const scCoverage = normalizedValidation.traceability.sc;
+  const testFiles = normalizedValidation.traceability.testFiles;
+  const scSources = await collectScIdSourcesFromScenarioFiles(scenarioFiles);
+  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 {
+      guardrailsByType.tradeOff += 1;
+    }
+  }
+  const guardrailsErrors = guardrailsLoad.errors.map((item) => ({
+    path: toRelativePath(resolvedRoot, item.path),
+    message: item.message
+  }));
+  const changeTypeSummary = await collectChangeTypeSummary(specsRoot);
+  const ctypeWarnings = normalizedValidation.issues.filter((item) => item.code === "QFAI-CTYPE-002").map((item) => {
+    const warning = {
+      file: item.file ? toRelativePath(resolvedRoot, item.file) : "(unknown)",
+      suspectedMismatch: item.message,
+      refs: item.refs ?? []
+    };
+    if (item.suggested_action) {
+      warning.suggestion = item.suggested_action;
+    }
+    return warning;
+  });
+  const toReportRuleFinding = (item) => {
+    const finding = {
+      code: item.code,
+      severity: item.severity,
+      message: item.message,
+      refs: item.refs ?? []
+    };
+    if (item.file) {
+      finding.file = toRelativePath(resolvedRoot, item.file);
+    }
+    if (item.suggested_action) {
+      finding.suggestion = item.suggested_action;
+    }
+    return finding;
+  };
+  const compatFindings = normalizedValidation.issues.filter((item) => /^QFAI-COMPAT-\d+$/.test(item.code)).map((item) => toReportRuleFinding(item));
+  const scopeMismatches = normalizedValidation.issues.filter((item) => item.code === "QFAI-SCOPE-001" || item.code === "QFAI-SCOPE-002").map((item) => toReportRuleFinding(item));
+  const verificationFindings = normalizedValidation.issues.filter((item) => /^QFAI-VFY-\d+$/.test(item.code)).map((item) => toReportRuleFinding(item));
+  const missingDeltaUpdateIssues = normalizedValidation.issues.filter(
+    (item) => item.code === "QFAI-CTYPE-003"
+  ).length;
+  const waiverState = normalizedValidation.waivers ?? {
+    active: [],
+    suppressed: {
+      total: 0,
+      byWaiver: {},
       byRule: {}
     }
   };
@@ -15606,7 +17161,7 @@ async function collectChangeTypeSummary(specsRoot) {
   };
   const deltaFiles = await collectDeltaFiles(specsRoot);
   for (const deltaFile of deltaFiles) {
-    const text = await (0, import_promises50.readFile)(deltaFile, "utf-8");
+    const text = await (0, import_promises53.readFile)(deltaFile, "utf-8");
     const parsed = parseDeltaV1(text);
     for (const entry of parsed.entries) {
       if (!entry.meta) {
@@ -15643,7 +17198,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await (0, import_promises50.readFile)(file, "utf-8");
+    const text = await (0, import_promises53.readFile)(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -15680,7 +17235,7 @@ async function collectIds(files) {
     result[prefix] = /* @__PURE__ */ new Set();
   }
   for (const file of files) {
-    const text = await (0, import_promises50.readFile)(file, "utf-8");
+    const text = await (0, import_promises53.readFile)(file, "utf-8");
     for (const prefix of ID_PREFIXES) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -15695,7 +17250,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await (0, import_promises50.readFile)(file, "utf-8");
+    const text = await (0, import_promises53.readFile)(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -15716,7 +17271,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await (0, import_promises50.readFile)(file, "utf-8");
+    const text = await (0, import_promises53.readFile)(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -15835,7 +17390,7 @@ function normalizeScSources(root, sources) {
 async function countScenarios(scenarioFiles) {
   let total = 0;
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises50.readFile)(file, "utf-8");
+    const text = await (0, import_promises53.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -15866,7 +17421,7 @@ async function collectTestStrategy(scenarioFiles, root, config, limit) {
   let totalScenarios = 0;
   let e2eCount = 0;
   for (const file of scenarioFiles) {
-    const text = await (0, import_promises50.readFile)(file, "utf-8");
+    const text = await (0, import_promises53.readFile)(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -15954,10 +17509,10 @@ function buildHotspots(issues) {
 async function collectTddCoverage(entries) {
   const specs = [];
   for (const entry of entries) {
-    const testCasesPath = import_node_path53.default.join(entry.dir, "06_Test-Cases.md");
+    const testCasesPath = import_node_path56.default.join(entry.dir, "06_Test-Cases.md");
     let tcContent;
     try {
-      tcContent = await (0, import_promises50.readFile)(testCasesPath, "utf-8");
+      tcContent = await (0, import_promises53.readFile)(testCasesPath, "utf-8");
     } catch {
       continue;
     }
@@ -15989,10 +17544,10 @@ async function collectTddCoverage(entries) {
       });
       continue;
     }
-    const tddListPath = import_node_path53.default.join(entry.dir, "tdd", "test-list.md");
+    const tddListPath = import_node_path56.default.join(entry.dir, "tdd", "test-list.md");
     let tddContent;
     try {
-      tddContent = await (0, import_promises50.readFile)(tddListPath, "utf-8");
+      tddContent = await (0, import_promises53.readFile)(tddListPath, "utf-8");
     } catch {
       specs.push({
         specNumber: entry.specNumber,
@@ -16075,8 +17630,8 @@ async function collectTddCoverage(entries) {
 }
 
 // src/core/specPackReport.ts
-var import_promises51 = require("fs/promises");
-var import_node_path54 = __toESM(require("path"), 1);
+var import_promises54 = require("fs/promises");
+var import_node_path57 = __toESM(require("path"), 1);
 var REQUIRED_LEDGER_COLUMNS = [
   "trace_id",
   "obj_id",
@@ -16094,9 +17649,9 @@ async function writeSpecPackReports(root, config) {
   const entries = await collectSpecEntries(specsRoot);
   const contractIndex = await buildContractIndex(root, config);
   for (const entry of entries) {
-    const specName = import_node_path54.default.basename(entry.dir);
-    const outputDir = import_node_path54.default.join(outRoot, specName);
-    await (0, import_promises51.mkdir)(outputDir, { recursive: true });
+    const specName = import_node_path57.default.basename(entry.dir);
+    const outputDir = import_node_path57.default.join(outRoot, specName);
+    await (0, import_promises54.mkdir)(outputDir, { recursive: true });
     const [acText, tcText, exText, ledgerText] = await Promise.all([
       readSafe12(entry.acceptanceCriteriaPath),
       readSafe12(entry.testCasesPath),
@@ -16121,14 +17676,14 @@ async function writeSpecPackReports(root, config) {
       contractIds: contractIndex.ids
     });
     const graph = buildTraceabilityGraph(ledgerRows);
-    await (0, import_promises51.writeFile)(
-      import_node_path54.default.join(outputDir, "coverage.md"),
+    await (0, import_promises54.writeFile)(
+      import_node_path57.default.join(outputDir, "coverage.md"),
       `${formatCoverageMarkdown(specName, coverage)}
 `,
       "utf-8"
     );
-    await (0, import_promises51.writeFile)(
-      import_node_path54.default.join(outputDir, "traceability-graph.json"),
+    await (0, import_promises54.writeFile)(
+      import_node_path57.default.join(outputDir, "traceability-graph.json"),
       `${JSON.stringify(graph, null, 2)}
 `,
       "utf-8"
@@ -16303,7 +17858,7 @@ function getCell(row, indexByColumn, column) {
 }
 async function readSafe12(filePath) {
   try {
-    return await (0, import_promises51.readFile)(filePath, "utf-8");
+    return await (0, import_promises54.readFile)(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -16321,7 +17876,7 @@ function warnIfTruncated(scan, context) {
 
 // src/cli/commands/report.ts
 async function runReport(options) {
-  const root = import_node_path55.default.resolve(options.root);
+  const root = import_node_path58.default.resolve(options.root);
   const configResult = await loadConfig(root);
   let validation;
   let blockedByPhaseGuard = false;
@@ -16337,7 +17892,7 @@ async function runReport(options) {
     validation = normalized;
   } else {
     const input = options.inputPath ?? configResult.config.output.validateJsonPath;
-    const inputPath = import_node_path55.default.isAbsolute(input) ? input : import_node_path55.default.resolve(root, input);
+    const inputPath = import_node_path58.default.isAbsolute(input) ? input : import_node_path58.default.resolve(root, input);
     try {
       validation = await readValidationResult(inputPath);
     } catch (err) {
@@ -16364,11 +17919,11 @@ 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" ? import_node_path55.default.join(outRoot, "report.json") : import_node_path55.default.join(outRoot, "report.md");
+  const defaultOut = options.format === "json" ? import_node_path58.default.join(outRoot, "report.json") : import_node_path58.default.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
-  const outPath = import_node_path55.default.isAbsolute(out) ? out : import_node_path55.default.resolve(root, out);
-  await (0, import_promises52.mkdir)(import_node_path55.default.dirname(outPath), { recursive: true });
-  await (0, import_promises52.writeFile)(outPath, `${output}
+  const outPath = import_node_path58.default.isAbsolute(out) ? out : import_node_path58.default.resolve(root, out);
+  await (0, import_promises55.mkdir)(import_node_path58.default.dirname(outPath), { recursive: true });
+  await (0, import_promises55.writeFile)(outPath, `${output}
 `, "utf-8");
   await writeSpecPackReports(root, configResult.config);
   if (blockedByPhaseGuard) {
@@ -16383,7 +17938,7 @@ async function runReport(options) {
   info(`wrote report: ${outPath}`);
 }
 async function readValidationResult(inputPath) {
-  const raw = await (0, import_promises52.readFile)(inputPath, "utf-8");
+  const raw = await (0, import_promises55.readFile)(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}`);
@@ -16443,23 +17998,23 @@ function isMissingFileError2(error2) {
   return record2.code === "ENOENT";
 }
 async function writeValidationResult(root, outputPath, result) {
-  const abs = import_node_path55.default.isAbsolute(outputPath) ? outputPath : import_node_path55.default.resolve(root, outputPath);
-  await (0, import_promises52.mkdir)(import_node_path55.default.dirname(abs), { recursive: true });
-  await (0, import_promises52.writeFile)(abs, `${JSON.stringify(result, null, 2)}
+  const abs = import_node_path58.default.isAbsolute(outputPath) ? outputPath : import_node_path58.default.resolve(root, outputPath);
+  await (0, import_promises55.mkdir)(import_node_path58.default.dirname(abs), { recursive: true });
+  await (0, import_promises55.writeFile)(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 
 // src/cli/commands/validate.ts
-var import_promises54 = require("fs/promises");
-var import_node_path57 = __toESM(require("path"), 1);
+var import_promises57 = require("fs/promises");
+var import_node_path60 = __toESM(require("path"), 1);
 
 // src/core/runLog.ts
-var import_promises53 = require("fs/promises");
-var import_node_path56 = __toESM(require("path"), 1);
+var import_promises56 = require("fs/promises");
+var import_node_path59 = __toESM(require("path"), 1);
 async function writeValidateRunLog(input) {
-  const root = import_node_path56.default.resolve(input.root);
+  const root = import_node_path59.default.resolve(input.root);
   const outDir = resolvePath(root, input.config, "outDir");
-  await (0, import_promises53.mkdir)(outDir, { recursive: true });
+  await (0, import_promises56.mkdir)(outDir, { recursive: true });
   const { runId, reportDir } = await allocateRunReportDir(outDir, input.startedAt);
   const relativeSpecsRoot = toRelativePath(root, resolvePath(root, input.config, "specsDir"));
   const latestDiscussion = await findLatestPack(
@@ -16504,10 +18059,10 @@ async function writeValidateRunLog(input) {
     errors,
     warnings
   });
-  await writeJson(import_node_path56.default.join(reportDir, "run.json"), runJson);
-  await writeJson(import_node_path56.default.join(reportDir, "validator.json"), validatorJson);
-  await writeJson(import_node_path56.default.join(reportDir, "traceability.json"), traceabilityJson);
-  await (0, import_promises53.writeFile)(import_node_path56.default.join(reportDir, "summary.md"), `${summaryMd}
+  await writeJson(import_node_path59.default.join(reportDir, "run.json"), runJson);
+  await writeJson(import_node_path59.default.join(reportDir, "validator.json"), validatorJson);
+  await writeJson(import_node_path59.default.join(reportDir, "traceability.json"), traceabilityJson);
+  await (0, import_promises56.writeFile)(import_node_path59.default.join(reportDir, "summary.md"), `${summaryMd}
 `, "utf-8");
   return {
     runId,
@@ -16515,7 +18070,7 @@ async function writeValidateRunLog(input) {
   };
 }
 async function writeJson(filePath, value) {
-  await (0, import_promises53.writeFile)(filePath, `${JSON.stringify(value, null, 2)}
+  await (0, import_promises56.writeFile)(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
 }
 function resolveStatus(result, override) {
@@ -16631,9 +18186,9 @@ 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 = import_node_path56.default.join(outDir, runId);
+    const reportDir = import_node_path59.default.join(outDir, runId);
     try {
-      await (0, import_promises53.mkdir)(reportDir);
+      await (0, import_promises56.mkdir)(reportDir);
       return { runId, reportDir };
     } catch (error2) {
       if (isAlreadyExistsError(error2)) {
@@ -16662,7 +18217,7 @@ function shouldFail(result, failOn) {
 // src/cli/commands/validate.ts
 async function runValidate(options) {
   const startedAt = /* @__PURE__ */ new Date();
-  const root = import_node_path57.default.resolve(options.root);
+  const root = import_node_path60.default.resolve(options.root);
   const configResult = await loadConfig(root);
   const blockedIssue = buildCiRefinementIssue(options.phase);
   const blockedByPhaseGuard = blockedIssue !== null;
@@ -16818,12 +18373,12 @@ function issueKey(issue2) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await (0, import_promises54.mkdir)(import_node_path57.default.dirname(abs), { recursive: true });
-  await (0, import_promises54.writeFile)(abs, `${JSON.stringify(result, null, 2)}
+  await (0, import_promises57.mkdir)(import_node_path60.default.dirname(abs), { recursive: true });
+  await (0, import_promises57.writeFile)(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return import_node_path57.default.isAbsolute(jsonPath) ? jsonPath : import_node_path57.default.resolve(root, jsonPath);
+  return import_node_path60.default.isAbsolute(jsonPath) ? jsonPath : import_node_path60.default.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 var ISSUE_EXPECTED_BY_CODE = {