qfai 1.7.0 → 1.7.2

package/dist/cli/index.mjs

@@ -12,6 +12,22 @@ import path10 from "path";
 import { access, readFile } from "fs/promises";
 import path from "path";
 import { parse as parseYaml } from "yaml";
+
+// src/core/uiux/renderEvidenceTypes.ts
+var DEFAULT_RENDER_VIEWPORTS = ["desktop", "mobile"];
+function normalizeRenderViewports(viewports) {
+  const normalized = Array.isArray(viewports) ? viewports.map((item) => item.trim()).filter((item) => item.length > 0) : [];
+  if (normalized.length > 0) {
+    return Array.from(new Set(normalized));
+  }
+  return [...DEFAULT_RENDER_VIEWPORTS];
+}
+function looksLikeInlineRenderPayload(value) {
+  const trimmed = value.trim().toLowerCase();
+  return trimmed.startsWith("data:image") || trimmed.includes("<html");
+}
+
+// src/core/config.ts
 var defaultConfig = {
   paths: {
     contractsDir: ".qfai/contracts",
@@ -461,6 +477,133 @@ function normalizeUiux(raw, configPath, issues) {
       );
     }
   }
+  if (raw.renderEvidence !== void 0) {
+    const renderEvidence = normalizeRenderEvidence(raw.renderEvidence, configPath, issues);
+    if (renderEvidence) {
+      result.renderEvidence = renderEvidence;
+    }
+  }
+  if (raw.audit !== void 0) {
+    const audit = normalizeUiuxAudit(raw.audit, configPath, issues);
+    if (audit) {
+      result.audit = audit;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function normalizeUiuxAudit(raw, configPath, issues) {
+  if (!isRecord(raw)) {
+    issues.push(configIssue(configPath, "uiux.audit \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"));
+    return void 0;
+  }
+  const result = {};
+  if (raw.enabled !== void 0) {
+    if (typeof raw.enabled === "boolean") {
+      result.enabled = raw.enabled;
+    } else {
+      issues.push(configIssue(configPath, "uiux.audit.enabled \u306F\u30D6\u30FC\u30EB\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"));
+    }
+  }
+  if (raw.slopDetection !== void 0) {
+    if (typeof raw.slopDetection === "boolean") {
+      result.slopDetection = raw.slopDetection;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.audit.slopDetection \u306F\u30D6\u30FC\u30EB\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
+  if (raw.maxPrimaryCtas !== void 0) {
+    if (typeof raw.maxPrimaryCtas === "number" && Number.isFinite(raw.maxPrimaryCtas) && raw.maxPrimaryCtas >= 0) {
+      result.maxPrimaryCtas = raw.maxPrimaryCtas;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.audit.maxPrimaryCtas \u306F0\u4EE5\u4E0A\u306E\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
+  if (raw.maxRawTokenLiteralWarnings !== void 0) {
+    if (typeof raw.maxRawTokenLiteralWarnings === "number" && Number.isFinite(raw.maxRawTokenLiteralWarnings) && raw.maxRawTokenLiteralWarnings >= 0) {
+      result.maxRawTokenLiteralWarnings = raw.maxRawTokenLiteralWarnings;
+    } else {
+      issues.push(
+        configIssue(
+          configPath,
+          "uiux.audit.maxRawTokenLiteralWarnings \u306F0\u4EE5\u4E0A\u306E\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+        )
+      );
+    }
+  }
+  if (raw.maxDuplicateFindingsPerRule !== void 0) {
+    if (typeof raw.maxDuplicateFindingsPerRule === "number" && Number.isFinite(raw.maxDuplicateFindingsPerRule) && raw.maxDuplicateFindingsPerRule >= 0) {
+      result.maxDuplicateFindingsPerRule = raw.maxDuplicateFindingsPerRule;
+    } else {
+      issues.push(
+        configIssue(
+          configPath,
+          "uiux.audit.maxDuplicateFindingsPerRule \u306F0\u4EE5\u4E0A\u306E\u6570\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+        )
+      );
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function normalizeRenderEvidence(raw, configPath, issues) {
+  if (!isRecord(raw)) {
+    issues.push(
+      configIssue(configPath, "uiux.renderEvidence \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+    );
+    return void 0;
+  }
+  const result = {};
+  if (raw.enabled !== void 0) {
+    if (typeof raw.enabled === "boolean") {
+      result.enabled = raw.enabled;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.renderEvidence.enabled \u306F\u30D6\u30FC\u30EB\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
+  if (raw.viewports !== void 0) {
+    if (Array.isArray(raw.viewports) && raw.viewports.every((item) => typeof item === "string")) {
+      result.viewports = normalizeRenderViewports(raw.viewports);
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.renderEvidence.viewports \u306F\u6587\u5B57\u5217\u914D\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
+  if (raw.out !== void 0) {
+    if (typeof raw.out === "string" && raw.out.trim().length > 0) {
+      result.out = raw.out.trim();
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.renderEvidence.out \u306F\u7A7A\u3067\u306A\u3044\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
+  if (raw.baseUrl !== void 0) {
+    if (typeof raw.baseUrl === "string" && raw.baseUrl.trim().length > 0) {
+      result.baseUrl = raw.baseUrl.trim();
+    } else {
+      issues.push(
+        configIssue(
+          configPath,
+          "uiux.renderEvidence.baseUrl \u306F\u7A7A\u3067\u306A\u3044\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+        )
+      );
+    }
+  }
+  if (raw.failOpen !== void 0) {
+    if (typeof raw.failOpen === "boolean") {
+      result.failOpen = raw.failOpen;
+    } else {
+      issues.push(
+        configIssue(configPath, "uiux.renderEvidence.failOpen \u306F\u30D6\u30FC\u30EB\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+      );
+    }
+  }
   return Object.keys(result).length > 0 ? result : void 0;
 }
 function configIssue(file, message) {
@@ -1541,8 +1684,8 @@ import { readFile as readFile5 } from "fs/promises";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function resolveToolVersion() {
-  if ("1.7.0".length > 0) {
-    return "1.7.0";
+  if ("1.7.2".length > 0) {
+    return "1.7.2";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -3311,6 +3454,7 @@ var ID_PREFIXES = [
   "DB",
   "THEMA"
 ];
+var DIGIT_AHEAD = "(?=[A-Za-z0-9_-]*\\d)";
 var STRICT_ID_PATTERNS = {
   CAP: /\bCAP-\d{4}\b/g,
   SPEC: /\bSPEC-\d{4}\b/g,
@@ -3326,18 +3470,18 @@ var STRICT_ID_PATTERNS = {
   ADR: /\bADR-\d{4}\b/g
 };
 var LOOSE_ID_PATTERNS = {
-  CAP: /\bCAP-[A-Za-z0-9_-]+\b/gi,
-  SPEC: /\bSPEC-[A-Za-z0-9_-]+\b/gi,
-  US: /\bUS-[A-Za-z0-9_-]+\b/gi,
-  BR: /\bBR-[A-Za-z0-9_-]+\b/gi,
-  SC: /\bSC-[A-Za-z0-9_-]+\b/gi,
-  AC: /\bAC-[A-Za-z0-9_-]+\b/gi,
-  CASE: /\bCASE-[A-Za-z0-9_-]+\b/gi,
-  UI: /\bUI-[A-Za-z0-9_-]+\b/gi,
-  API: /\bAPI-[A-Za-z0-9_-]+\b/gi,
-  DB: /\bDB-[A-Za-z0-9_-]+\b/gi,
-  THEMA: /\bTHEMA-[A-Za-z0-9_-]+\b/gi,
-  ADR: /\bADR-[A-Za-z0-9_-]+\b/gi
+  CAP: new RegExp(`\\bCAP-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  SPEC: new RegExp(`\\bSPEC-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  US: new RegExp(`\\bUS-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  BR: new RegExp(`\\bBR-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  SC: new RegExp(`\\bSC-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  AC: new RegExp(`\\bAC-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  CASE: new RegExp(`\\bCASE-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  UI: new RegExp(`\\bUI-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  API: new RegExp(`\\bAPI-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  DB: new RegExp(`\\bDB-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  THEMA: new RegExp(`\\bTHEMA-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi"),
+  ADR: new RegExp(`\\bADR-${DIGIT_AHEAD}[A-Za-z0-9_-]+\\b`, "gi")
 };
 function extractIds(text, prefix) {
   const pattern = STRICT_ID_PATTERNS[prefix];
@@ -3919,6 +4063,8 @@ function formatError4(error2) {
 var ENV_AUTOGEN = "QFAI_PROTOTYPE_FIDELITY_AUTOGEN";
 var DEFAULT_EVIDENCE_PATH = ".qfai/evidence/prototyping.json";
 async function runPrototyping(options) {
+  const { config } = await loadConfig(options.root);
+  const renderOptions = mergeRenderOptions(options, config.uiux?.renderEvidence);
   const autogenEnabled = options.autogenUiFidelity || process.env[ENV_AUTOGEN] === "1";
   if (!autogenEnabled) {
     if (options.autogenOnly) {
@@ -3949,16 +4095,24 @@ async function runPrototyping(options) {
       status: "skipped",
       reason: "autogen not enabled (--autogen-ui-fidelity or env not set)"
     });
-    await writeEvidence(evidencePath2, skippedEvidence);
+    const renderBundle2 = await maybeWriteRenderBundle(
+      toolVersion2,
+      "qfai prototyping --render-evidence",
+      renderOptions,
+      false
+    );
+    await writeEvidence(
+      evidencePath2,
+      applyRenderEvidence(skippedEvidence, renderOptions, false, renderBundle2?.path)
+    );
     return 0;
   }
-  const baseUrl = resolveBaseUrl(options);
+  const baseUrl = resolveBaseUrl(renderOptions);
   if (!baseUrl) {
     error(`prototyping: --base-url \u307E\u305F\u306F QFAI_PROTOTYPE_BASE_URL \u306E\u6307\u5B9A\u304C\u5FC5\u8981\u3067\u3059\u3002`);
     return 1;
   }
   const toolVersion = await resolveToolVersion();
-  const { config } = await loadConfig(options.root);
   const evidencePath = resolveEvidencePath(options.root, options.evidenceOut);
   info(`prototyping: autogen uiFidelity \u3092\u5B9F\u884C\u3057\u307E\u3059 (baseUrl=${baseUrl})`);
   let existingEvidence = {};
@@ -3985,7 +4139,16 @@ async function runPrototyping(options) {
       status: "failed",
       reason
     });
-    await writeEvidence(evidencePath, failedEvidence);
+    const renderBundle2 = await maybeWriteRenderBundle(
+      toolVersion,
+      "qfai prototyping --render-evidence",
+      renderOptions,
+      true
+    );
+    await writeEvidence(
+      evidencePath,
+      applyRenderEvidence(failedEvidence, renderOptions, true, renderBundle2?.path)
+    );
     info(`prototyping: wrote evidence with status=failed to ${evidencePath}`);
     return options.autogenOnly ? 1 : 0;
   }
@@ -4004,7 +4167,16 @@ async function runPrototyping(options) {
       crawled: result.crawled,
       reason
     });
-    await writeEvidence(evidencePath, failedEvidence);
+    const renderBundle2 = await maybeWriteRenderBundle(
+      toolVersion,
+      "qfai prototyping --render-evidence",
+      renderOptions,
+      true
+    );
+    await writeEvidence(
+      evidencePath,
+      applyRenderEvidence(failedEvidence, renderOptions, true, renderBundle2?.path)
+    );
     info(`prototyping: wrote evidence with status=failed to ${evidencePath}`);
     return options.autogenOnly ? 1 : 0;
   }
@@ -4017,7 +4189,16 @@ async function runPrototyping(options) {
     screens: result.screens,
     crawled: result.crawled
   });
-  await writeEvidence(evidencePath, successEvidence);
+  const renderBundle = await maybeWriteRenderBundle(
+    toolVersion,
+    "qfai prototyping --render-evidence",
+    renderOptions,
+    true
+  );
+  await writeEvidence(
+    evidencePath,
+    applyRenderEvidence(successEvidence, renderOptions, true, renderBundle?.path)
+  );
   const routeOkCount = result.crawled.filter((r) => r.status === "ok").length;
   const routeFailCount = result.crawled.filter((r) => r.status === "failed").length;
   const avgCoverage = result.screens.length > 0 ? (result.screens.reduce((sum, s) => sum + s.coverage, 0) / result.screens.length).toFixed(2) : "N/A";
@@ -4047,6 +4228,75 @@ async function writeEvidence(filePath, evidence) {
   await mkdir4(path17.dirname(filePath), { recursive: true });
   await writeFile3(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
 }
+async function writeRenderBundle(filePath, bundle) {
+  await mkdir4(path17.dirname(filePath), { recursive: true });
+  await writeFile3(filePath, JSON.stringify(bundle, null, 2) + "\n", "utf-8");
+}
+async function maybeWriteRenderBundle(toolVersion, command, options, autogenEnabled) {
+  if (!options.renderEvidence) {
+    return void 0;
+  }
+  const renderBundle = buildRenderBundle(toolVersion, command, options, autogenEnabled);
+  await writeRenderBundle(renderBundle.path, renderBundle.bundle);
+  return renderBundle;
+}
+function applyRenderEvidence(evidence, options, autogenEnabled, outputPath) {
+  if (!options.renderEvidence) {
+    return evidence;
+  }
+  const viewports = normalizeRenderViewports(options.renderViewports);
+  return {
+    ...evidence,
+    renderEvidence: {
+      status: autogenEnabled ? "requested" : "skipped",
+      requested: true,
+      autogenEnabled,
+      viewports,
+      outputPath: outputPath ?? resolveRenderOutPath(options.root, options.renderOut),
+      reason: autogenEnabled ? "render evidence capture not implemented in this slice" : "render requested without autogen-ui-fidelity"
+    }
+  };
+}
+function buildRenderBundle(toolVersion, command, options, autogenEnabled) {
+  const path64 = resolveRenderOutPath(options.root, options.renderOut);
+  return {
+    path: path64,
+    bundle: {
+      meta: {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        toolVersion,
+        commands: [command]
+      },
+      renderEvidence: {
+        status: autogenEnabled ? "requested" : "skipped",
+        requested: true,
+        autogenEnabled,
+        viewports: normalizeRenderViewports(options.renderViewports),
+        outputPath: path64,
+        reason: autogenEnabled ? "render evidence capture not implemented in this slice" : "render requested without autogen-ui-fidelity"
+      }
+    }
+  };
+}
+function mergeRenderOptions(options, configRenderEvidence) {
+  const cliViewportsSpecified = Array.isArray(options.renderViewports);
+  const mergedViewports = cliViewportsSpecified ? normalizeRenderViewports(options.renderViewports) : normalizeRenderViewports(configRenderEvidence?.viewports);
+  const renderOut = options.renderOut ?? configRenderEvidence?.out;
+  const baseUrl = options.baseUrl ?? configRenderEvidence?.baseUrl;
+  return {
+    ...options,
+    renderEvidence: options.renderEvidence || configRenderEvidence?.enabled === true,
+    renderViewports: mergedViewports,
+    ...renderOut ? { renderOut } : {},
+    ...baseUrl ? { baseUrl } : {}
+  };
+}
+function resolveRenderOutPath(root, explicit) {
+  if (explicit) {
+    return path17.isAbsolute(explicit) ? explicit : path17.resolve(root, explicit);
+  }
+  return path17.resolve(root, ".qfai/evidence/render.json");
+}
 function extractRouteHintsFromEvidence(evidence) {
   const routes = /* @__PURE__ */ new Set();
   const runtimeGate = evidence.runtimeGate;
@@ -4088,8 +4338,8 @@ function extractRouteHintsFromEvidence(evidence) {
 }
 
 // src/cli/commands/report.ts
-import { mkdir as mkdir8, readFile as readFile43, writeFile as writeFile7 } from "fs/promises";
-import path59 from "path";
+import { mkdir as mkdir8, readFile as readFile45, writeFile as writeFile7 } from "fs/promises";
+import path61 from "path";
 
 // src/core/normalize.ts
 function normalizeIssuePaths(root, issues) {
@@ -4184,8 +4434,8 @@ async function createPhaseGuardResult(phase, blockedIssue) {
 }
 
 // src/core/report.ts
-import { readFile as readFile41 } from "fs/promises";
-import path57 from "path";
+import { readFile as readFile43 } from "fs/promises";
+import path59 from "path";
 
 // src/core/contractIndex.ts
 import { readFile as readFile10 } from "fs/promises";
@@ -8365,11 +8615,11 @@ import path29 from "path";
 // src/core/atddTraceability.ts
 import { readFile as readFile20 } from "fs/promises";
 import path28 from "path";
-var US_TEST_ANNOTATION_RE = /\bQFAI:SPEC-(\d{4}):US-(\d{4})\b/g;
-var TC_TEST_ANNOTATION_RE = /\bQFAI:SPEC-(\d{4}):TC-(\d{4})\b/g;
+var US_TEST_ANNOTATION_RE = /\bQFAI:SPEC-(\d{4}):US-(\d{4}(?:-\d{4})?)\b/g;
+var TC_TEST_ANNOTATION_RE = /\bQFAI:SPEC-(\d{4}):TC-(\d{4}(?:-\d{4})?)\b/g;
 var API_TEST_ANNOTATION_RE = /\bQFAI:CON-API-(\d+)\b/g;
-var SHORT_US_ID_RE = /^US-\d{4}$/;
-var SHORT_TC_ID_RE = /^TC-\d{4}$/;
+var US_ID_RE2 = /^US-\d{4}(?:-\d{4})?$/;
+var TC_ID_RE = /^TC-\d{4}(?:-\d{4})?$/;
 var API_CONTRACT_ID_RE = /^CON-API-\d+$/;
 var TEST_FILE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts,feature,md,markdown}";
 async function evaluateAtddCodeTraceability(root, config) {
@@ -8517,11 +8767,11 @@ async function collectApiContractIds(apiRoot) {
 function collectShortIds(text, prefix) {
   const ids = /* @__PURE__ */ new Set();
   const headingIds = collectMarkdownItems(text, prefix).map((item) => item.id);
-  const pattern = prefix === "US" ? /\bUS-\d{4}\b/g : /\bTC-\d{4}\b/g;
+  const pattern = prefix === "US" ? /\bUS-\d{4}(?:-\d{4})?\b/g : /\bTC-\d{4}(?:-\d{4})?\b/g;
   const looseIds = uniqueMatches(text, pattern);
   for (const id of [...headingIds, ...looseIds]) {
     const normalized = id.toUpperCase();
-    if (prefix === "US" && SHORT_US_ID_RE.test(normalized) || prefix === "TC" && SHORT_TC_ID_RE.test(normalized)) {
+    if (prefix === "US" && US_ID_RE2.test(normalized) || prefix === "TC" && TC_ID_RE.test(normalized)) {
       ids.add(normalized);
     }
   }
@@ -9530,15 +9780,15 @@ import path33 from "path";
 import { mkdir as mkdir6, writeFile as writeFile5 } from "fs/promises";
 import path34 from "path";
 var ID_PATTERNS = {
-  us: /^US-\d{4}$/,
-  ac: /^AC-\d{4}$/,
-  br: /^BR-\d{4}$/,
-  ex: /^EX-\d{4}$/
+  us: /^US-\d{4}(?:-\d{4})?$/,
+  ac: /^AC-\d{4}(?:-\d{4})?$/,
+  br: /^BR-\d{4}(?:-\d{4})?$/,
+  ex: /^EX-\d{4}(?:-\d{4})?$/
 };
 var V1421_REFS = {
-  ac: /\bAC-\d{4}\b/gi,
-  br: /\bBR-\d{4}\b/gi,
-  ex: /\bEX-\d{4}\b/gi
+  ac: /\bAC-\d{4}(?:-\d{4})?\b/gi,
+  br: /\bBR-\d{4}(?:-\d{4})?\b/gi,
+  ex: /\bEX-\d{4}(?:-\d{4})?\b/gi
 };
 async function validateLayerCoverage(root, config) {
   const specsRoot = resolvePath(root, config, "specsDir");
@@ -9811,11 +10061,11 @@ function parseAcceptanceCriteriaIds2(text) {
   const ids = /* @__PURE__ */ new Set();
   const lines = text.replace(/\r\n/g, "\n").split("\n");
   for (const line of lines) {
-    const headingMatch = /^##\s*(AC-\d{4})\b/i.exec(line.trim());
+    const headingMatch = /^##\s*(AC-\d{4}(?:-\d{4})?)\b/i.exec(line.trim());
     if (headingMatch?.[1]) {
       ids.add(headingMatch[1].toUpperCase());
     }
-    const commentMatch = /^\s*#\s*(AC-\d{4})\b/i.exec(line);
+    const commentMatch = /^\s*#\s*(AC-\d{4}(?:-\d{4})?)\b/i.exec(line);
     if (commentMatch?.[1]) {
       ids.add(commentMatch[1].toUpperCase());
     }
@@ -9835,8 +10085,8 @@ function parseAcceptanceCriteriaIds2(text) {
 function parseDefinitionRefs(text, prefix, refPattern, options = {}) {
   const lines = text.replace(/\r\n/g, "\n").split("\n");
   const refsById = /* @__PURE__ */ new Map();
-  const idPattern = new RegExp(`^${prefix}-\\d{4}$`);
-  const headingPattern = new RegExp(`^##\\s*(${prefix}-\\d{4})\\b`, "i");
+  const idPattern = new RegExp(`^${prefix}-\\d{4}(?:-\\d{4})?$`);
+  const headingPattern = new RegExp(`^##\\s*(${prefix}-\\d{4}(?:-\\d{4})?)\\b`, "i");
   const referenceColumns = new Set(
     (options.referenceColumns ?? []).map((column) => normalizeColumnName(column))
   );
@@ -10237,7 +10487,7 @@ var US_DOWNSTREAM_RE = /\b(?:AC|BR|EX|TC)-\d{4}\b/g;
 var AC_DOWNSTREAM_RE = /\b(?:BR|EX|TC)-\d{4}\b/g;
 var BR_DOWNSTREAM_RE = /\b(?:EX|TC)-\d{4}\b/g;
 var CAP_ID_RE = /^CAP-\d{4}$/;
-var US_ID_RE2 = /^US-\d{4}$/;
+var US_ID_RE3 = /^US-\d{4}$/;
 var AC_ID_RE4 = /^AC-\d{4}$/;
 var BR_OR_AC_ID_RE = /^(?:BR|AC)-\d{4}$/;
 var EX_ID_RE2 = /^EX-\d{4}$/;
@@ -10276,7 +10526,7 @@ async function validateLayeredTraceability(root, config) {
         ...await validateMarkdownParentFormat(entry.userStoriesPath, "US", CAP_ID_RE, "CAP")
       );
       issues.push(
-        ...await validateMarkdownParentFormat(entry.acceptanceCriteriaPath, "AC", US_ID_RE2, "US")
+        ...await validateMarkdownParentFormat(entry.acceptanceCriteriaPath, "AC", US_ID_RE3, "US")
       );
       issues.push(
         ...await validateMarkdownParentFormat(entry.businessRulesPath, "BR", AC_ID_RE4, "AC")
@@ -11082,7 +11332,7 @@ function validateExParentExists(filePath, exItems, acIds, brIds) {
 }
 
 // src/core/validators/prototypingEvidence.ts
-import { readFile as readFile26 } from "fs/promises";
+import { access as access12, readFile as readFile26 } from "fs/promises";
 import path39 from "path";
 var EVIDENCE_MARKDOWN_FILE = "prototyping.md";
 var EVIDENCE_JSON_FILE = "prototyping.json";
@@ -11588,6 +11838,100 @@ async function validateUiFidelity(root, config, evidenceJsonPath, evidence) {
       )
     );
   }
+  const renderIssues = await validateRenderEvidenceScreens(
+    root,
+    config,
+    evidenceJsonPath,
+    uiFidelity.screens
+  );
+  issues.push(...renderIssues);
+  return issues;
+}
+async function validateRenderEvidenceScreens(root, config, evidenceJsonPath, screens) {
+  const issues = [];
+  const hasAnyRenderEvidence = screens.some((screen) => screen.renders.length > 0);
+  if (!hasAnyRenderEvidence) {
+    return issues;
+  }
+  const qualityProfile = config.uiux?.qualityProfile ?? "default";
+  for (const screen of screens) {
+    if (screen.renders.length === 0) {
+      continue;
+    }
+    const viewports = new Set(screen.renders.map((render) => render.viewport));
+    const missingDefaultViewports = DEFAULT_RENDER_VIEWPORTS.filter(
+      (viewport) => !viewports.has(viewport)
+    );
+    const allSkipped = screen.renders.every((render) => render.status === "skipped");
+    for (const render of screen.renders) {
+      if (render.status !== "captured") {
+        continue;
+      }
+      const invalidPaths = [
+        { label: "imagePath", value: render.imagePath },
+        { label: "htmlPath", value: render.htmlPath }
+      ].filter((entry) => looksLikeInlineRenderPayload(entry.value));
+      if (invalidPaths.length > 0) {
+        issues.push(
+          issue(
+            "QFAI-PROT-244",
+            `QFAI-PROT-244: render evidence must be path-only. route=${screen.route}, viewport=${render.viewport}, invalid=${invalidPaths.map((entry) => entry.label).join("|")}`,
+            "error",
+            evidenceJsonPath,
+            "prototypingEvidence.renderArtifactPresence",
+            [
+              `route=${screen.route}`,
+              `viewport=${render.viewport}`,
+              ...invalidPaths.map((entry) => `artifact=${entry.label}`)
+            ],
+            "change",
+            "imagePath/htmlPath \u306B\u306F\u30D5\u30A1\u30A4\u30EB\u30D1\u30B9\u306E\u307F\u3092\u4FDD\u5B58\u3057\u3001data URI \u3084 HTML \u672C\u6587\u3092 JSON \u306B\u57CB\u3081\u8FBC\u307E\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002"
+          )
+        );
+        continue;
+      }
+      const missingArtifacts = await collectMissingRenderArtifacts(root, render);
+      if (missingArtifacts.length > 0) {
+        issues.push(
+          issue(
+            "QFAI-PROT-244",
+            `QFAI-PROT-244: captured render artifact is missing. route=${screen.route}, viewport=${render.viewport}, missing=${missingArtifacts.join("|")}`,
+            "error",
+            evidenceJsonPath,
+            "prototypingEvidence.renderArtifactPresence",
+            [
+              `route=${screen.route}`,
+              `viewport=${render.viewport}`,
+              ...missingArtifacts.map((artifact) => `artifact=${artifact}`)
+            ],
+            "change",
+            "render capture \u3092\u518D\u5B9F\u884C\u3057\u3001screenshot \u3068 HTML snapshot \u306E\u4E21\u65B9\u304C\u4FDD\u5B58\u3055\u308C\u308B\u3053\u3068\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+          )
+        );
+      }
+    }
+    if (missingDefaultViewports.length === 0 && !allSkipped) {
+      continue;
+    }
+    const severity = qualityProfile === "default" ? "warning" : "error";
+    const reason = allSkipped ? "all renders are skipped" : `missing default viewports=${missingDefaultViewports.join("|")}`;
+    issues.push(
+      issue(
+        "QFAI-PROT-245",
+        `QFAI-PROT-245: render coverage is incomplete for ${screen.route}. ${reason}. qualityProfile=${qualityProfile}`,
+        severity,
+        evidenceJsonPath,
+        "prototypingEvidence.renderCoverage",
+        [
+          `route=${screen.route}`,
+          ...missingDefaultViewports.map((viewport) => `viewport=${viewport}`),
+          `qualityProfile=${qualityProfile}`
+        ],
+        "change",
+        allSkipped ? "\u5C11\u306A\u304F\u3068\u3082 desktop/mobile \u306E\u3044\u305A\u308C\u304B\u3067 captured \u307E\u305F\u306F failed \u306E\u660E\u793A\u7684\u306A render outcome \u3092\u6B8B\u3057\u3066\u304F\u3060\u3055\u3044\u3002" : "desktop/mobile \u306E default viewport \u3092\u63C3\u3048\u308B\u304B\u3001profile \u8A2D\u5B9A\u3068 scope \u3092\u898B\u76F4\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      )
+    );
+  }
   return issues;
 }
 function formatUiFidelityMismatch(mismatch) {
@@ -11800,6 +12144,10 @@ function normalizeUiFidelityScreen(value) {
   if (!mockPaths.ok) {
     return mockPaths;
   }
+  const renders = normalizeRenderEntries(value.renders);
+  if (!renders.ok) {
+    return renders;
+  }
   return {
     ok: true,
     value: {
@@ -11810,8 +12158,103 @@ function normalizeUiFidelityScreen(value) {
       ...normalizeOptionalMissingBlock(value.missing),
       ...typeof value.coverage === "number" ? { coverage: value.coverage } : {},
       observed: observed.value,
-      mockPaths: mockPaths.value
+      mockPaths: mockPaths.value,
+      renders: renders.value
+    }
+  };
+}
+function normalizeRenderEntries(value) {
+  if (value === void 0) {
+    return { ok: true, value: [] };
+  }
+  if (!Array.isArray(value)) {
+    return { ok: false, reason: "`uiFidelity.screens[].renders` must be an array" };
+  }
+  const renders = [];
+  for (const entry of value) {
+    const normalized = normalizeRenderEntry(entry);
+    if (!normalized.ok) {
+      return normalized;
+    }
+    renders.push(normalized.value);
+  }
+  return { ok: true, value: renders };
+}
+function normalizeRenderEntry(value) {
+  if (!isRecord5(value)) {
+    return { ok: false, reason: "`uiFidelity.screens[].renders[]` must be objects" };
+  }
+  if (typeof value.viewport !== "string" || value.viewport.trim().length === 0) {
+    return { ok: false, reason: "`uiFidelity.screens[].renders[].viewport` is required" };
+  }
+  if (!isNonNegativeInteger(value.width) || !isNonNegativeInteger(value.height) || value.width === 0 || value.height === 0) {
+    return {
+      ok: false,
+      reason: "`uiFidelity.screens[].renders[]` requires positive integers for width/height"
+    };
+  }
+  const viewport = value.viewport.trim();
+  const width = value.width;
+  const height = value.height;
+  const status = typeof value.status === "string" ? value.status.trim().toLowerCase() : "";
+  if (status === "captured") {
+    if (typeof value.imagePath !== "string" || value.imagePath.trim().length === 0 || typeof value.htmlPath !== "string" || value.htmlPath.trim().length === 0) {
+      return {
+        ok: false,
+        reason: "`captured` render entries require imagePath and htmlPath"
+      };
+    }
+    return {
+      ok: true,
+      value: {
+        viewport,
+        status: "captured",
+        width,
+        height,
+        imagePath: value.imagePath.trim(),
+        htmlPath: value.htmlPath.trim()
+      }
+    };
+  }
+  if (status === "skipped") {
+    if (typeof value.skippedReason !== "string" || value.skippedReason.trim().length === 0) {
+      return {
+        ok: false,
+        reason: "`skipped` render entries require skippedReason"
+      };
+    }
+    return {
+      ok: true,
+      value: {
+        viewport,
+        status: "skipped",
+        width,
+        height,
+        skippedReason: value.skippedReason.trim()
+      }
+    };
+  }
+  if (status === "failed") {
+    if (typeof value.error !== "string" || value.error.trim().length === 0) {
+      return {
+        ok: false,
+        reason: "`failed` render entries require error"
+      };
     }
+    return {
+      ok: true,
+      value: {
+        viewport,
+        status: "failed",
+        width,
+        height,
+        error: value.error.trim()
+      }
+    };
+  }
+  return {
+    ok: false,
+    reason: "`uiFidelity.screens[].renders[].status` must be captured|skipped|failed"
   };
 }
 function normalizeUiFidelityExpected(value) {
@@ -12037,6 +12480,22 @@ function normalizeOptionalMissingBlock(value) {
 function isRecord5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+async function collectMissingRenderArtifacts(root, render) {
+  const missing = [];
+  const candidates = [
+    { label: "imagePath", target: render.imagePath },
+    { label: "htmlPath", target: render.htmlPath }
+  ];
+  for (const candidate of candidates) {
+    const resolved = path39.isAbsolute(candidate.target) ? candidate.target : path39.resolve(root, candidate.target);
+    try {
+      await access12(resolved);
+    } catch {
+      missing.push(candidate.label);
+    }
+  }
+  return missing;
+}
 function isInteger(value) {
   return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
 }
@@ -12385,7 +12844,7 @@ function collectLayer(layer, layerName, target, errors) {
 }
 function flattenTokens(obj, prefix, target, errors) {
   for (const [key, value] of Object.entries(obj)) {
-    const path62 = `${prefix}.${key}`;
+    const path64 = `${prefix}.${key}`;
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const record2 = value;
       if ("$value" in record2) {
@@ -12401,9 +12860,9 @@ function flattenTokens(obj, prefix, target, errors) {
         if (typeof record2.platform === "string") {
           token.platform = record2.platform;
         }
-        target.set(path62, token);
+        target.set(path64, token);
       } else {
-        flattenTokens(record2, path62, target, errors);
+        flattenTokens(record2, path64, target, errors);
       }
     }
   }
@@ -12413,44 +12872,44 @@ function resolveAllReferences(result) {
   for (const [key, val] of result.primitives) allTokens.set(key, val);
   for (const [key, val] of result.semantics) allTokens.set(key, val);
   for (const [key, val] of result.components) allTokens.set(key, val);
-  for (const [path62] of allTokens) {
-    resolveTokenRef(path62, allTokens, /* @__PURE__ */ new Set(), 0, result);
+  for (const [path64] of allTokens) {
+    resolveTokenRef(path64, allTokens, /* @__PURE__ */ new Set(), 0, result);
   }
 }
-function resolveTokenRef(path62, allTokens, visited, depth, result) {
-  if (result.resolved.has(path62)) {
-    return result.resolved.get(path62);
+function resolveTokenRef(path64, allTokens, visited, depth, result) {
+  if (result.resolved.has(path64)) {
+    return result.resolved.get(path64);
   }
   if (depth > MAX_RESOLVE_DEPTH) {
     result.errors.push({
-      message: `Max reference depth exceeded at: ${path62}`,
-      path: path62
+      message: `Max reference depth exceeded at: ${path64}`,
+      path: path64
     });
     return void 0;
   }
-  if (visited.has(path62)) {
+  if (visited.has(path64)) {
     result.errors.push({
-      message: `Circular reference detected: ${path62}`,
-      path: path62
+      message: `Circular reference detected: ${path64}`,
+      path: path64
     });
     return void 0;
   }
-  const token = allTokens.get(path62);
+  const token = allTokens.get(path64);
   if (!token) {
     return void 0;
   }
   if (typeof token.$value !== "string") {
     const rawValue2 = stringifyTokenValue(token.$value);
-    result.resolved.set(path62, rawValue2);
+    result.resolved.set(path64, rawValue2);
     return rawValue2;
   }
   const rawValue = stringifyTokenValue(token.$value);
   const refs = [...rawValue.matchAll(REF_PATTERN)];
   if (refs.length === 0) {
-    result.resolved.set(path62, rawValue);
+    result.resolved.set(path64, rawValue);
     return rawValue;
   }
-  visited.add(path62);
+  visited.add(path64);
   let resolved = rawValue;
   for (const ref of refs) {
     const refPath = ref[1];
@@ -12458,8 +12917,8 @@ function resolveTokenRef(path62, allTokens, visited, depth, result) {
     const refToken = allTokens.get(refPath);
     if (!refToken) {
       result.errors.push({
-        message: `Unresolved token reference: {${refPath}} at ${path62}`,
-        path: path62
+        message: `Unresolved token reference: {${refPath}} at ${path64}`,
+        path: path64
       });
       continue;
     }
@@ -12468,7 +12927,7 @@ function resolveTokenRef(path62, allTokens, visited, depth, result) {
       resolved = resolved.split(`{${refPath}}`).join(refValue);
     }
   }
-  result.resolved.set(path62, resolved);
+  result.resolved.set(path64, resolved);
   return resolved;
 }
 function stringifyTokenValue(value) {
@@ -15580,6 +16039,7 @@ async function validateNavigationFlow(root, config) {
 
 // src/core/validators/renderCritique.ts
 import path54 from "path";
+import { readFile as readFile40 } from "fs/promises";
 import fg9 from "fast-glob";
 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;
@@ -15611,6 +16071,7 @@ async function validateRenderCritique(root, config) {
   if (!hasDdp) return issues;
   const skillsDir = path54.join(root, config.paths.skillsDir).replace(/\\/g, "/");
   const evidenceDir = path54.join(root, ".qfai", "evidence").replace(/\\/g, "/");
+  const renderEvidenceViewports = await collectRenderEvidenceViewports(root);
   const skillPromptPattern = path54.posix.join(skillsDir, "qfai-{prototyping,implement}*/SKILL.md");
   const skillFiles = await fg9(skillPromptPattern, { dot: true });
   const evidencePattern = path54.posix.join(evidenceDir, "{prototyping*,critique-*}.md");
@@ -15650,7 +16111,7 @@ async function validateRenderCritique(root, config) {
     }
   }
   const allEvidenceContent = await collectContent(evidenceFiles);
-  if (evidenceFiles.length > 0 && !DESKTOP_RE.test(allEvidenceContent)) {
+  if (evidenceFiles.length > 0 && !DESKTOP_RE.test(allEvidenceContent) && !renderEvidenceViewports.has("desktop")) {
     issues.push(
       issue(
         "QFAI-CRIT-003",
@@ -15664,7 +16125,7 @@ async function validateRenderCritique(root, config) {
       )
     );
   }
-  if (evidenceFiles.length > 0 && !MOBILE_RE.test(allEvidenceContent)) {
+  if (evidenceFiles.length > 0 && !MOBILE_RE.test(allEvidenceContent) && !renderEvidenceViewports.has("mobile")) {
     issues.push(
       issue(
         "QFAI-CRIT-004",
@@ -15825,9 +16286,49 @@ async function collectContent(files) {
   }
   return contents.join("\n---\n");
 }
+async function collectRenderEvidenceViewports(root) {
+  const prototypingJsonPath = path54.join(root, ".qfai", "evidence", "prototyping.json");
+  try {
+    const raw = await readFile40(prototypingJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return /* @__PURE__ */ new Set();
+    }
+    const uiFidelity = parsed.uiFidelity;
+    if (!uiFidelity || typeof uiFidelity !== "object" || Array.isArray(uiFidelity)) {
+      return /* @__PURE__ */ new Set();
+    }
+    const screens = uiFidelity.screens;
+    if (!Array.isArray(screens)) {
+      return /* @__PURE__ */ new Set();
+    }
+    const viewports = /* @__PURE__ */ new Set();
+    for (const screen of screens) {
+      if (!screen || typeof screen !== "object" || Array.isArray(screen)) {
+        continue;
+      }
+      const renders = screen.renders;
+      if (!Array.isArray(renders)) {
+        continue;
+      }
+      for (const render of renders) {
+        if (!render || typeof render !== "object" || Array.isArray(render)) {
+          continue;
+        }
+        const viewport = render.viewport;
+        if (typeof viewport === "string" && viewport.trim().length > 0) {
+          viewports.add(viewport.trim().toLowerCase());
+        }
+      }
+    }
+    return viewports;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
 
 // src/core/validators/designFidelity.ts
-import { readFile as readFile40 } from "fs/promises";
+import { readFile as readFile41 } from "fs/promises";
 import path55 from "path";
 import fg10 from "fast-glob";
 var SCORECARD_HEADING_RE = /^#{1,3}\s+Fidelity\s+Scorecard/im;
@@ -15860,7 +16361,7 @@ async function validateDesignFidelity(root, config) {
   for (const filePath of allFiles) {
     let content;
     try {
-      content = await readFile40(filePath, "utf-8");
+      content = await readFile41(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -16483,6 +16984,252 @@ async function validateDiscussionDesignHardening(root, config) {
   return issues;
 }
 
+// src/core/validators/designAudit.ts
+import { readdir as readdir11 } from "fs/promises";
+import path57 from "path";
+var COSMETIC_CATEGORIES = ["generic-shell", "stock-imagery", "placeholder-copy"];
+function resolveAuditConfig(config) {
+  const audit = config.uiux?.audit;
+  const profile = config.uiux?.qualityProfile ?? "default";
+  return {
+    enabled: audit?.enabled ?? true,
+    slopDetection: audit?.slopDetection ?? true,
+    qualityProfile: profile,
+    maxPrimaryCtas: audit?.maxPrimaryCtas ?? 1,
+    maxRawTokenLiteralWarnings: audit?.maxRawTokenLiteralWarnings ?? 5,
+    maxDuplicateFindingsPerRule: audit?.maxDuplicateFindingsPerRule ?? 5
+  };
+}
+function mapSeverity(tier, profile, category) {
+  if (tier === 1) return "error";
+  if (tier === 2) return profile === "strict" ? "error" : "warning";
+  if (profile === "default") {
+    return category && COSMETIC_CATEGORIES.includes(category) ? "info" : "warning";
+  }
+  return "warning";
+}
+function findingToIssue(finding, profile, rulePrefix = "audit") {
+  const severity = mapSeverity(finding.severityTier, profile, finding.dimension);
+  return issue(
+    finding.ruleId,
+    finding.message,
+    severity,
+    finding.file,
+    `${rulePrefix}.${finding.dimension}`,
+    finding.evidence.length > 0 ? finding.evidence : void 0,
+    "compatibility",
+    finding.guidance
+  );
+}
+function extractSection2(content, heading) {
+  const idx = content.indexOf(heading);
+  if (idx === -1) return null;
+  const start = idx + heading.length;
+  const headingLevel = heading.match(/^#+/)?.[0]?.length ?? 3;
+  const rest = content.slice(start);
+  const headingPattern = new RegExp(`^#{1,${headingLevel}} `, "m");
+  const nextHeadingMatch = headingPattern.exec(rest);
+  const sectionContent = nextHeadingMatch ? rest.slice(0, nextHeadingMatch.index) : rest;
+  return sectionContent.trim() || null;
+}
+function checkCtaHierarchy(content, auditConfig, file) {
+  const findings = [];
+  const ctaSection = extractSection2(content, "### CTA Hierarchy");
+  if (!ctaSection) return findings;
+  const primaryLines = ctaSection.match(/^-\s*Primary:/gm) || [];
+  const primaryCount = primaryLines.length;
+  if (primaryCount === 0) {
+    findings.push({
+      ruleId: "QFAI-AUD-001",
+      dimension: "visualHierarchy",
+      severityTier: 1,
+      message: "No primary CTA defined in CTA Hierarchy",
+      why: "Every UI screen needs a clear primary action to guide users",
+      evidence: [],
+      guidance: "Define at least one primary CTA in the CTA Hierarchy section",
+      file
+    });
+  }
+  if (primaryCount > auditConfig.maxPrimaryCtas) {
+    findings.push({
+      ruleId: "QFAI-AUD-020",
+      dimension: "visualHierarchy",
+      severityTier: 2,
+      message: `Multiple primary CTAs detected (${primaryCount} > ${auditConfig.maxPrimaryCtas})`,
+      why: "Multiple primary CTAs create decision paralysis and weaken visual hierarchy",
+      evidence: primaryLines.map((l) => l.trim()),
+      guidance: "Reduce to a single primary CTA per screen; demote others to secondary",
+      file
+    });
+  }
+  return findings;
+}
+var RAW_COLOR_RE = /#[0-9a-fA-F]{3,8}\b|rgb\([^)]+\)|rgba\([^)]+\)|hsl\([^)]+\)|hsla\([^)]+\)/g;
+async function checkTokenDrift(root, auditConfig, cfg) {
+  const findings = [];
+  const configuredDir = cfg.uiux?.designTokensDir;
+  const tokensDir = configuredDir ? path57.resolve(root, configuredDir) : path57.join(root, cfg.paths.contractsDir, "design");
+  let hasTokenFiles = false;
+  try {
+    const entries = await readdir11(tokensDir);
+    hasTokenFiles = entries.some((e) => /\.ya?ml$/i.test(e));
+  } catch {
+    return findings;
+  }
+  if (!hasTokenFiles) return findings;
+  const contractsUiDir = path57.join(root, cfg.paths.contractsDir, "ui");
+  let htmlFiles = [];
+  try {
+    const entries = await readdir11(contractsUiDir);
+    htmlFiles = entries.filter((e) => /\.html?$/i.test(e));
+  } catch {
+    return findings;
+  }
+  let rawCount = 0;
+  const sampleLiterals = [];
+  for (const htmlFile of htmlFiles) {
+    const content = await readSafe(path57.join(contractsUiDir, htmlFile));
+    if (!content) continue;
+    const matches = content.match(RAW_COLOR_RE);
+    if (matches) {
+      rawCount += matches.length;
+      for (const m of matches) {
+        if (sampleLiterals.length < 10) {
+          sampleLiterals.push(m.toLowerCase());
+        }
+      }
+    }
+  }
+  if (rawCount > auditConfig.maxRawTokenLiteralWarnings) {
+    findings.push({
+      ruleId: "QFAI-AUD-004",
+      dimension: "tokenDiscipline",
+      severityTier: 1,
+      message: `Token drift: ${rawCount} raw color literal occurrences found (threshold: ${auditConfig.maxRawTokenLiteralWarnings})`,
+      why: "Raw color values bypass design tokens, causing visual inconsistency",
+      evidence: sampleLiterals,
+      guidance: "Replace raw color literals with design token references"
+    });
+  }
+  return findings;
+}
+function deduplicateFindings(issues, maxPerRule) {
+  const counts = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const iss of issues) {
+    const count = counts.get(iss.code) ?? 0;
+    if (count < maxPerRule) {
+      result.push(iss);
+    }
+    counts.set(iss.code, count + 1);
+  }
+  for (const [code, count] of counts) {
+    if (count > maxPerRule) {
+      result.push({
+        code,
+        severity: "info",
+        category: "compatibility",
+        message: `${count - maxPerRule} additional "${code}" finding(s) suppressed (max ${maxPerRule} per rule)`,
+        rule: `audit.dedup.${code}`
+      });
+    }
+  }
+  return result;
+}
+async function validateDesignAudit(root, config) {
+  const auditConfig = resolveAuditConfig(config);
+  if (!auditConfig.enabled) return [];
+  const discussionDir = path57.join(root, config.paths.discussionDir);
+  const packRoot = await findLatestDiscussionPackDir(discussionDir);
+  if (!packRoot) return [];
+  const uiBearing = await isUiBearing(packRoot);
+  if (!uiBearing) return [];
+  const storyPath = path57.join(packRoot, "03_Story-Workshop.md");
+  const content = await readSafe(storyPath);
+  if (!content) return [];
+  const findings = [];
+  findings.push(...checkCtaHierarchy(content, auditConfig, "03_Story-Workshop.md"));
+  findings.push(...await checkTokenDrift(root, auditConfig, config));
+  const issues = findings.map((f) => findingToIssue(f, auditConfig.qualityProfile));
+  return deduplicateFindings(issues, auditConfig.maxDuplicateFindingsPerRule);
+}
+
+// src/core/validators/designSlop.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile42 } from "fs/promises";
+import path58 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function isValidSlopPattern(rule) {
+  if (typeof rule !== "object" || rule === null) return false;
+  const r = rule;
+  return typeof r.id === "string" && typeof r.category === "string" && typeof r.tier === "number" && Array.isArray(r.scopes) && typeof r.match === "string" && typeof r.message === "string" && typeof r.guidance === "string";
+}
+async function loadSlopPatterns(jsonPath) {
+  const raw = await readFile42(jsonPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) return [];
+  return parsed.filter((r) => isValidSlopPattern(r));
+}
+function defaultPatternsPath() {
+  const base = import.meta.url;
+  const basePath = base.startsWith("file:") ? fileURLToPath4(base) : base;
+  const baseDir = path58.dirname(basePath);
+  const candidates = [
+    path58.join(baseDir, "designSlopPatterns.json"),
+    path58.resolve(baseDir, "../../../assets/validators/designSlopPatterns.json"),
+    path58.resolve(baseDir, "../../assets/validators/designSlopPatterns.json")
+  ];
+  for (const c of candidates) {
+    if (existsSync2(c)) return c;
+  }
+  return candidates[0];
+}
+async function validateDesignSlop(root, config) {
+  const auditConfig = resolveAuditConfig(config);
+  if (!auditConfig.enabled) return [];
+  if (!auditConfig.slopDetection) return [];
+  const discussionDir = path58.join(root, config.paths.discussionDir);
+  const packRoot = await findLatestDiscussionPackDir(discussionDir);
+  if (!packRoot) return [];
+  const uiBearing = await isUiBearing(packRoot);
+  if (!uiBearing) return [];
+  let patterns;
+  try {
+    patterns = await loadSlopPatterns(defaultPatternsPath());
+  } catch {
+    return [];
+  }
+  const findings = [];
+  const seenRules = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    let regex;
+    try {
+      regex = new RegExp(pattern.match, "gi");
+    } catch {
+      continue;
+    }
+    for (const scope of pattern.scopes) {
+      const filePath = path58.join(packRoot, scope);
+      const content = await readSafe(filePath);
+      if (!content) continue;
+      if (regex.test(content) && !seenRules.has(pattern.id)) {
+        seenRules.add(pattern.id);
+        findings.push({
+          ruleId: pattern.id,
+          dimension: pattern.category,
+          severityTier: pattern.tier,
+          message: pattern.message,
+          why: `Slop pattern "${pattern.id}" matched in ${scope}`,
+          evidence: [],
+          guidance: pattern.guidance,
+          file: scope
+        });
+      }
+    }
+  }
+  return findings.map((f) => findingToIssue(f, auditConfig.qualityProfile, "slop"));
+}
+
 // src/core/validate.ts
 var UIUX_VALIDATION_BUDGET_MS = 2e3;
 async function validateProject(root, configResult, options = {}) {
@@ -16500,7 +17247,9 @@ async function validateProject(root, configResult, options = {}) {
     () => validateBpApDb(root, config),
     () => validateUiDefinitionConsistency(root, config),
     () => validateResearchSummary(root, config),
-    () => validateAgentDefinition(root, config)
+    () => validateAgentDefinition(root, config),
+    () => validateDesignAudit(root, config),
+    () => validateDesignSlop(root, config)
   ];
   const uiuxIssueGroups = await Promise.all(uiuxValidators.map((validator) => validator()));
   const uiuxIssues = [...platformResult.issues, ...uiuxIssueGroups.flat()];
@@ -16587,15 +17336,15 @@ var REPORT_GUARDRAILS_MAX = 20;
 var REPORT_TEST_STRATEGY_SAMPLE_LIMIT = 20;
 var SC_TAG_RE4 = /^SC-\d{4}-\d{4}$/;
 async function createReportData(root, validation, configResult) {
-  const resolvedRoot = path57.resolve(root);
+  const resolvedRoot = path59.resolve(root);
   const resolved = configResult ?? await loadConfig(resolvedRoot);
   const config = resolved.config;
   const configPath = resolved.configPath;
   const specsRoot = resolvePath(resolvedRoot, config, "specsDir");
   const contractsRoot = resolvePath(resolvedRoot, config, "contractsDir");
-  const apiRoot = path57.join(contractsRoot, "api");
-  const uiRoot = path57.join(contractsRoot, "ui");
-  const dbRoot = path57.join(contractsRoot, "db");
+  const apiRoot = path59.join(contractsRoot, "api");
+  const uiRoot = path59.join(contractsRoot, "ui");
+  const dbRoot = path59.join(contractsRoot, "db");
   const srcRoot = resolvePath(resolvedRoot, config, "srcDir");
   const testsRoot = resolvePath(resolvedRoot, config, "testsDir");
   const specEntries = await collectSpecEntries(specsRoot);
@@ -16923,6 +17672,8 @@ function formatReportMarkdown(data, options = {}) {
   lines.push("");
   lines.push("- [Compatibility Issues](#compatibility-issues)");
   lines.push("- [Change Issues](#change-issues)");
+  lines.push("- [Design Audit Findings](#design-audit-findings)");
+  lines.push("- [Slop Guardrails Findings](#slop-guardrails-findings)");
   lines.push("- [Change Type](#change-type)");
   lines.push("- [Waivers](#waivers)");
   lines.push("- [Decision Guardrails](#decision-guardrails)");
@@ -17071,6 +17822,46 @@ function formatReportMarkdown(data, options = {}) {
   lines.push("### Issues");
   lines.push("");
   lines.push(...formatIssueCards(issuesByCategory.change));
+  const auditIssues = data.issues.filter((i) => /^QFAI-AUD-/.test(i.code));
+  if (auditIssues.length > 0) {
+    lines.push("## Design Audit Findings");
+    lines.push("");
+    const byDimension = /* @__PURE__ */ new Map();
+    for (const iss of auditIssues) {
+      const dim = iss.rule?.replace(/^audit\./, "").split(".")[0] ?? "unknown";
+      const group = byDimension.get(dim) ?? [];
+      group.push(iss);
+      byDimension.set(dim, group);
+    }
+    for (const [dim, dimIssues] of byDimension) {
+      lines.push(`### ${dim}`);
+      lines.push("");
+      for (const iss of dimIssues) {
+        lines.push(`- **${iss.severity.toUpperCase()}** [${iss.code}] ${iss.message}`);
+      }
+      lines.push("");
+    }
+  }
+  const slopIssues = data.issues.filter((i) => /^SLP-/.test(i.code));
+  if (slopIssues.length > 0) {
+    lines.push("## Slop Guardrails Findings");
+    lines.push("");
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const iss of slopIssues) {
+      const cat = iss.rule?.replace(/^slop\./, "").split(".")[0] ?? "unknown";
+      const group = byCategory.get(cat) ?? [];
+      group.push(iss);
+      byCategory.set(cat, group);
+    }
+    for (const [cat, catIssues] of byCategory) {
+      lines.push(`### ${cat}`);
+      lines.push("");
+      for (const iss of catIssues) {
+        lines.push(`- **${iss.severity.toUpperCase()}** [${iss.code}] ${iss.message}`);
+      }
+      lines.push("");
+    }
+  }
   lines.push("## Change Type");
   lines.push("");
   lines.push("### Summary");
@@ -17442,6 +18233,20 @@ function formatReportMarkdown(data, options = {}) {
   } else {
     lines.push("- issue \u306F\u691C\u51FA\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u904B\u7528\u30C6\u30F3\u30D7\u30EC\u306B\u6CBF\u3063\u3066\u7D99\u7D9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
   }
+  const renderEvidenceIssues = data.issues.filter(
+    (item) => ["QFAI-PROT-101", "QFAI-PROT-244", "QFAI-PROT-245"].includes(item.code)
+  );
+  if (renderEvidenceIssues.length > 0) {
+    lines.push(
+      "- render evidence \u304C\u4E0D\u8DB3\u307E\u305F\u306F\u4E0D\u5B8C\u5168\u3067\u3059\u3002viewport coverage \u3068 artifact path \u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+    lines.push(
+      "- recover: `qfai prototyping --autogen-ui-fidelity --render-evidence --viewports desktop,mobile` \u3092\u5B9F\u884C\u3057\u3001`.qfai/evidence/prototyping.json` \u3068 render bundle \u3092\u66F4\u65B0\u3057\u307E\u3059\u3002"
+    );
+    lines.push(
+      "- why it matters: render evidence \u306F viewport coverage \u3068 missing artifact \u306E\u5207\u308A\u5206\u3051\u306B\u4F7F\u308F\u308C\u3001strict/high profile \u3067\u306F gate \u306B\u5F71\u97FF\u3057\u307E\u3059\u3002"
+    );
+  }
   lines.push("- \u5909\u66F4\u5185\u5BB9\u30FB\u53D7\u5165\u89B3\u70B9\u306F `.qfai/specs/*/18_delta.md` \u306B\u8A18\u9332\u3057\u307E\u3059\u3002");
   lines.push("- \u53C2\u7167\u30EB\u30FC\u30EB\u306E\u6B63\u672C: `.qfai/assistant/instructions/constitution.md`");
   return lines.join("\n");
@@ -17476,7 +18281,7 @@ async function collectChangeTypeSummary(specsRoot) {
   };
   const deltaFiles = await collectDeltaFiles(specsRoot);
   for (const deltaFile of deltaFiles) {
-    const text = await readFile41(deltaFile, "utf-8");
+    const text = await readFile43(deltaFile, "utf-8");
     const parsed = parseDeltaV1(text);
     for (const entry of parsed.entries) {
       if (!entry.meta) {
@@ -17513,7 +18318,7 @@ async function collectSpecContractRefs(specFiles, contractIdList) {
     idToSpecs.set(contractId, /* @__PURE__ */ new Set());
   }
   for (const file of specFiles) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     const parsed = parseSpec(text, file);
     const specKey = parsed.specId;
     if (!specKey) {
@@ -17550,7 +18355,7 @@ async function collectIds(files) {
     result[prefix] = /* @__PURE__ */ new Set();
   }
   for (const file of files) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     for (const prefix of ID_PREFIXES) {
       const ids = extractIds(text, prefix);
       ids.forEach((id) => result[prefix].add(id));
@@ -17565,7 +18370,7 @@ async function collectIds(files) {
 async function collectUpstreamIds(files) {
   const ids = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     extractAllIds(text).forEach((id) => ids.add(id));
   }
   return ids;
@@ -17586,7 +18391,7 @@ async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
   }
   const pattern = buildIdPattern(Array.from(upstreamIds));
   for (const file of targetFiles) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     if (pattern.test(text)) {
       return true;
     }
@@ -17705,7 +18510,7 @@ function normalizeScSources(root, sources) {
 async function countScenarios(scenarioFiles) {
   let total = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -17736,7 +18541,7 @@ async function collectTestStrategy(scenarioFiles, root, config, limit) {
   let totalScenarios = 0;
   let e2eCount = 0;
   for (const file of scenarioFiles) {
-    const text = await readFile41(file, "utf-8");
+    const text = await readFile43(file, "utf-8");
     const { document, errors } = parseScenarioDocument(text, file);
     if (!document || errors.length > 0) {
       continue;
@@ -17824,10 +18629,10 @@ function buildHotspots(issues) {
 async function collectTddCoverage(entries) {
   const specs = [];
   for (const entry of entries) {
-    const testCasesPath = path57.join(entry.dir, "06_Test-Cases.md");
+    const testCasesPath = path59.join(entry.dir, "06_Test-Cases.md");
     let tcContent;
     try {
-      tcContent = await readFile41(testCasesPath, "utf-8");
+      tcContent = await readFile43(testCasesPath, "utf-8");
     } catch {
       continue;
     }
@@ -17859,10 +18664,10 @@ async function collectTddCoverage(entries) {
       });
       continue;
     }
-    const tddListPath = path57.join(entry.dir, "tdd", "test-list.md");
+    const tddListPath = path59.join(entry.dir, "tdd", "test-list.md");
     let tddContent;
     try {
-      tddContent = await readFile41(tddListPath, "utf-8");
+      tddContent = await readFile43(tddListPath, "utf-8");
     } catch {
       specs.push({
         specNumber: entry.specNumber,
@@ -17945,8 +18750,8 @@ async function collectTddCoverage(entries) {
 }
 
 // src/core/specPackReport.ts
-import { mkdir as mkdir7, readFile as readFile42, writeFile as writeFile6 } from "fs/promises";
-import path58 from "path";
+import { mkdir as mkdir7, readFile as readFile44, writeFile as writeFile6 } from "fs/promises";
+import path60 from "path";
 var REQUIRED_LEDGER_COLUMNS = [
   "trace_id",
   "obj_id",
@@ -17964,8 +18769,8 @@ async function writeSpecPackReports(root, config) {
   const entries = await collectSpecEntries(specsRoot);
   const contractIndex = await buildContractIndex(root, config);
   for (const entry of entries) {
-    const specName = path58.basename(entry.dir);
-    const outputDir = path58.join(outRoot, specName);
+    const specName = path60.basename(entry.dir);
+    const outputDir = path60.join(outRoot, specName);
     await mkdir7(outputDir, { recursive: true });
     const [acText, tcText, exText, ledgerText] = await Promise.all([
       readSafe12(entry.acceptanceCriteriaPath),
@@ -17992,13 +18797,13 @@ async function writeSpecPackReports(root, config) {
     });
     const graph = buildTraceabilityGraph(ledgerRows);
     await writeFile6(
-      path58.join(outputDir, "coverage.md"),
+      path60.join(outputDir, "coverage.md"),
       `${formatCoverageMarkdown(specName, coverage)}
 `,
       "utf-8"
     );
     await writeFile6(
-      path58.join(outputDir, "traceability-graph.json"),
+      path60.join(outputDir, "traceability-graph.json"),
       `${JSON.stringify(graph, null, 2)}
 `,
       "utf-8"
@@ -18173,7 +18978,7 @@ function getCell(row, indexByColumn, column) {
 }
 async function readSafe12(filePath) {
   try {
-    return await readFile42(filePath, "utf-8");
+    return await readFile44(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -18191,7 +18996,7 @@ function warnIfTruncated(scan, context) {
 
 // src/cli/commands/report.ts
 async function runReport(options) {
-  const root = path59.resolve(options.root);
+  const root = path61.resolve(options.root);
   const configResult = await loadConfig(root);
   let validation;
   let blockedByPhaseGuard = false;
@@ -18207,7 +19012,7 @@ async function runReport(options) {
     validation = normalized;
   } else {
     const input = options.inputPath ?? configResult.config.output.validateJsonPath;
-    const inputPath = path59.isAbsolute(input) ? input : path59.resolve(root, input);
+    const inputPath = path61.isAbsolute(input) ? input : path61.resolve(root, input);
     try {
       validation = await readValidationResult(inputPath);
     } catch (err) {
@@ -18234,10 +19039,10 @@ async function runReport(options) {
   warnIfTruncated(data.traceability.testFiles, "report");
   const output = options.format === "json" ? formatReportJson(data) : options.baseUrl ? formatReportMarkdown(data, { baseUrl: options.baseUrl }) : formatReportMarkdown(data);
   const outRoot = resolvePath(root, configResult.config, "outDir");
-  const defaultOut = options.format === "json" ? path59.join(outRoot, "report.json") : path59.join(outRoot, "report.md");
+  const defaultOut = options.format === "json" ? path61.join(outRoot, "report.json") : path61.join(outRoot, "report.md");
   const out = options.outPath ?? defaultOut;
-  const outPath = path59.isAbsolute(out) ? out : path59.resolve(root, out);
-  await mkdir8(path59.dirname(outPath), { recursive: true });
+  const outPath = path61.isAbsolute(out) ? out : path61.resolve(root, out);
+  await mkdir8(path61.dirname(outPath), { recursive: true });
   await writeFile7(outPath, `${output}
 `, "utf-8");
   await writeSpecPackReports(root, configResult.config);
@@ -18253,7 +19058,7 @@ async function runReport(options) {
   info(`wrote report: ${outPath}`);
 }
 async function readValidationResult(inputPath) {
-  const raw = await readFile43(inputPath, "utf-8");
+  const raw = await readFile45(inputPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!isValidationResult(parsed)) {
     throw new Error(`validate.json \u306E\u5F62\u5F0F\u304C\u4E0D\u6B63\u3067\u3059: ${inputPath}`);
@@ -18313,21 +19118,21 @@ function isMissingFileError2(error2) {
   return record2.code === "ENOENT";
 }
 async function writeValidationResult(root, outputPath, result) {
-  const abs = path59.isAbsolute(outputPath) ? outputPath : path59.resolve(root, outputPath);
-  await mkdir8(path59.dirname(abs), { recursive: true });
+  const abs = path61.isAbsolute(outputPath) ? outputPath : path61.resolve(root, outputPath);
+  await mkdir8(path61.dirname(abs), { recursive: true });
   await writeFile7(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 
 // src/cli/commands/validate.ts
 import { mkdir as mkdir10, writeFile as writeFile9 } from "fs/promises";
-import path61 from "path";
+import path63 from "path";
 
 // src/core/runLog.ts
 import { mkdir as mkdir9, writeFile as writeFile8 } from "fs/promises";
-import path60 from "path";
+import path62 from "path";
 async function writeValidateRunLog(input) {
-  const root = path60.resolve(input.root);
+  const root = path62.resolve(input.root);
   const outDir = resolvePath(root, input.config, "outDir");
   await mkdir9(outDir, { recursive: true });
   const { runId, reportDir } = await allocateRunReportDir(outDir, input.startedAt);
@@ -18374,10 +19179,10 @@ async function writeValidateRunLog(input) {
     errors,
     warnings
   });
-  await writeJson(path60.join(reportDir, "run.json"), runJson);
-  await writeJson(path60.join(reportDir, "validator.json"), validatorJson);
-  await writeJson(path60.join(reportDir, "traceability.json"), traceabilityJson);
-  await writeFile8(path60.join(reportDir, "summary.md"), `${summaryMd}
+  await writeJson(path62.join(reportDir, "run.json"), runJson);
+  await writeJson(path62.join(reportDir, "validator.json"), validatorJson);
+  await writeJson(path62.join(reportDir, "traceability.json"), traceabilityJson);
+  await writeFile8(path62.join(reportDir, "summary.md"), `${summaryMd}
 `, "utf-8");
   return {
     runId,
@@ -18501,7 +19306,7 @@ async function allocateRunReportDir(outDir, startedAt) {
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     const candidateDate = new Date(startedAt.getTime() + attempt);
     const runId = `run-${formatTimestamp17(candidateDate)}`;
-    const reportDir = path60.join(outDir, runId);
+    const reportDir = path62.join(outDir, runId);
     try {
       await mkdir9(reportDir);
       return { runId, reportDir };
@@ -18532,7 +19337,7 @@ function shouldFail(result, failOn) {
 // src/cli/commands/validate.ts
 async function runValidate(options) {
   const startedAt = /* @__PURE__ */ new Date();
-  const root = path61.resolve(options.root);
+  const root = path63.resolve(options.root);
   const configResult = await loadConfig(root);
   const blockedIssue = buildCiRefinementIssue(options.phase);
   const blockedByPhaseGuard = blockedIssue !== null;
@@ -18688,12 +19493,12 @@ function issueKey(issue2) {
 }
 async function emitJson(result, root, jsonPath) {
   const abs = resolveJsonPath(root, jsonPath);
-  await mkdir10(path61.dirname(abs), { recursive: true });
+  await mkdir10(path63.dirname(abs), { recursive: true });
   await writeFile9(abs, `${JSON.stringify(result, null, 2)}
 `, "utf-8");
 }
 function resolveJsonPath(root, jsonPath) {
-  return path61.isAbsolute(jsonPath) ? jsonPath : path61.resolve(root, jsonPath);
+  return path63.isAbsolute(jsonPath) ? jsonPath : path63.resolve(root, jsonPath);
 }
 var GITHUB_ANNOTATION_LIMIT = 100;
 var ISSUE_EXPECTED_BY_CODE = {
@@ -18812,6 +19617,8 @@ function parseArgs(argv, cwd) {
     guardrailsPaths: [],
     prototypingAutogen: false,
     prototypingAutogenOnly: false,
+    prototypingRenderEvidence: false,
+    prototypingRenderViewports: [],
     help: false,
     invalidExitCode: 1
   };
@@ -19023,6 +19830,37 @@ function parseArgs(argv, cwd) {
         i += 1;
         break;
       }
+      case "--render-evidence":
+        if (command === "prototyping") {
+          options.prototypingRenderEvidence = true;
+        }
+        break;
+      case "--viewports": {
+        if (command !== "prototyping") {
+          break;
+        }
+        const next = readOptionValue(args, i);
+        if (next === null) {
+          markInvalid();
+          break;
+        }
+        options.prototypingRenderViewports = next.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+        i += 1;
+        break;
+      }
+      case "--render-out": {
+        if (command !== "prototyping") {
+          break;
+        }
+        const next = readOptionValue(args, i);
+        if (next === null) {
+          markInvalid();
+          break;
+        }
+        options.prototypingRenderOut = next;
+        i += 1;
+        break;
+      }
       case "--platform": {
         if (command !== "validate") {
           break;
@@ -19175,7 +20013,10 @@ async function run(argv, cwd) {
           autogenUiFidelity: options.prototypingAutogen,
           autogenOnly: options.prototypingAutogenOnly,
           ...options.prototypingBaseUrl !== void 0 ? { baseUrl: options.prototypingBaseUrl } : {},
-          ...options.prototypingEvidenceOut !== void 0 ? { evidenceOut: options.prototypingEvidenceOut } : {}
+          ...options.prototypingEvidenceOut !== void 0 ? { evidenceOut: options.prototypingEvidenceOut } : {},
+          renderEvidence: options.prototypingRenderEvidence,
+          renderViewports: options.prototypingRenderViewports,
+          ...options.prototypingRenderOut !== void 0 ? { renderOut: options.prototypingRenderOut } : {}
         });
         process.exitCode = exitCode;
       }
@@ -19221,6 +20062,9 @@ Options:
   --autogen-ui-fidelity         prototyping: uiFidelity \u81EA\u52D5\u751F\u6210\u3092\u6709\u52B9\u5316
   --autogen-only                prototyping: \u81EA\u52D5\u751F\u6210\u306E\u307F\u5B9F\u884C\uFF08\u5931\u6557\u6642exit 1\uFF09
   --evidence-out <path>         prototyping: \u51FA\u529B\u5148\uFF08\u30C7\u30D5\u30A9\u30EB\u30C8 .qfai/evidence/prototyping.json\uFF09
+  --render-evidence             prototyping: render evidence \u306E\u53CE\u96C6\u3092\u6709\u52B9\u5316
+  --viewports <list>            prototyping: render \u5BFE\u8C61 viewport \u3092\u30AB\u30F3\u30DE\u533A\u5207\u308A\u3067\u6307\u5B9A
+  --render-out <path>          prototyping: render evidence \u306E\u51FA\u529B\u5148
   -h, --help      \u30D8\u30EB\u30D7\u8868\u793A
 
 Environment: